]> mj.ucw.cz Git - leo.git/blob - xml.c
Log statistics when a data source is loaded
[leo.git] / xml.c
1 /*
2  *      Hic Est Leo -- OSM XML Parser
3  *
4  *      (c) 2014 Martin Mares <mj@ucw.cz>
5  */
6
7 #include <ucw/lib.h>
8 #include <ucw/fastbuf.h>
9 #include <ucw-xml/xml.h>
10
11 #include <fcntl.h>
12 #include <stdio.h>
13 #include <stdlib.h>
14
15 #include "leo.h"
16 #include "osm.h"
17
18 static void parse_tag(struct xml_context *ctx, struct osm_object *o, struct xml_node *t)
19 {
20   char *tag_k = xml_attr_value(ctx, t, "k");
21   char *tag_v = xml_attr_value(ctx, t, "v");
22   if (!tag_k || !tag_v)
23     die("Object %ju has malformed tag", (uintmax_t) o->id);
24   osm_obj_add_tag(o, tag_k, tag_v);
25 }
26
27 static void parse_node(struct xml_context *ctx, struct xml_node *e)
28 {
29   char *attr_id = xml_attr_value(ctx, e, "id");
30   if (!attr_id)
31     die("Node with no id");
32
33   char *attr_vis = xml_attr_value(ctx, e, "visible");
34   if (attr_vis && strcmp(attr_vis, "true"))
35     {
36       msg(L_DEBUG, "Node %s invisible", attr_id);
37       return;
38     }
39
40   char *attr_lat = xml_attr_value(ctx, e, "lat");
41   char *attr_lon = xml_attr_value(ctx, e, "lon");
42   if (!attr_lat || !attr_lon)
43     die("Node %s has mandatory attributes missing", attr_id);
44
45   struct osm_node *n = osm_node_new(osm_parse_id(attr_id));
46   n->x = atof(attr_lon);
47   n->y = atof(attr_lat);
48
49   XML_NODE_FOR_EACH(t, e)
50     if (t->type == XML_NODE_ELEM && !strcmp(t->name, "tag"))
51       parse_tag(ctx, &n->o, t);
52 }
53
54 static void parse_way(struct xml_context *ctx, struct xml_node *e)
55 {
56   char *attr_id = xml_attr_value(ctx, e, "id");
57   if (!attr_id)
58     die("Way with no id");
59
60   char *attr_vis = xml_attr_value(ctx, e, "visible");
61   if (attr_vis && strcmp(attr_vis, "true"))
62     {
63       msg(L_DEBUG, "Way %s invisible", attr_id);
64       return;
65     }
66
67   struct osm_way *w = osm_way_new(osm_parse_id(attr_id));
68
69   XML_NODE_FOR_EACH(t, e)
70     if (t->type == XML_NODE_ELEM)
71       {
72         if (!strcmp(t->name, "tag"))
73           parse_tag(ctx, &w->o, t);
74         else if (!strcmp(t->name, "nd"))
75           {
76             char *nd_ref = xml_attr_value(ctx, t, "ref");
77             if (!nd_ref)
78               die("Way %s has malformed ref", attr_id);
79             struct osm_object *o = osm_obj_find_by_id(OSM_TYPE_NODE, osm_parse_id(nd_ref));
80             if (!o)
81               die("Way %ju refers to unknown node %s", (uintmax_t) w->o.id, nd_ref);
82             osm_way_add_node(w, (struct osm_node *) o);
83           }
84       }
85 }
86
87 static void parse_relation(struct xml_context *ctx, struct xml_node *e)
88 {
89   char *attr_id = xml_attr_value(ctx, e, "id");
90   if (!attr_id)
91     die("Relation with no id");
92
93   char *attr_vis = xml_attr_value(ctx, e, "visible");
94   if (attr_vis && strcmp(attr_vis, "true"))
95     {
96       msg(L_DEBUG, "Relation %s invisible", attr_id);
97       return;
98     }
99
100   struct osm_relation *r = osm_relation_new(osm_parse_id(attr_id));
101
102   XML_NODE_FOR_EACH(t, e)
103     if (t->type == XML_NODE_ELEM)
104       {
105         if (!strcmp(t->name, "tag"))
106           parse_tag(ctx, &r->o, t);
107         else if (!strcmp(t->name, "member"))
108           {
109             char *m_role = xml_attr_value(ctx, t, "role");
110             char *m_ref = xml_attr_value(ctx, t, "ref");
111             char *m_type = xml_attr_value(ctx, t, "type");
112             if (!m_role || !m_ref || !m_type)
113               die("Relation %ju has malformed member", (uintmax_t) r->o.id);
114             osm_id_t ref = osm_parse_id(m_ref);
115
116             enum osm_object_type type;
117             if (!strcmp(m_type, "node"))
118               type = OSM_TYPE_NODE;
119             else if (!strcmp(m_type, "way"))
120               type = OSM_TYPE_WAY;
121             else if (!strcmp(m_type, "relation"))
122               {
123                 type = OSM_TYPE_RELATION;
124                 // Since the order of objects is topological, we need not worry about cycles
125                 // msg(L_DEBUG, "Relation inside relation (%ju inside %ju)", (uintmax_t) o->id, (uintmax_t) r->o.id);
126               }
127             else
128               {
129                 msg(L_WARN, "Relation %ju refers to member %ju of unknown type %s", (uintmax_t) r->o.id, (uintmax_t) ref, m_type);
130                 continue;
131               }
132
133             struct osm_object *o = osm_obj_find_by_id(type, ref);
134             if (!o)
135               {
136                 // This is a standard situation, so warn only when debugging
137                 // msg(L_WARN, "Relation %ju refers to unknown member node %s", (uintmax_t) ref, m_ref);
138                 continue;
139               }
140             osm_relation_add_member(r, o, m_role);
141           }
142       }
143 }
144
145 static void h_error(struct xml_context *ctx)
146 {
147   fprintf(stderr, "%s at %u: %s\n", (ctx->err_code < XML_ERR_ERROR) ? "warn" : "error", xml_row(ctx), ctx->err_msg);
148 }
149
150 static void parse_element(struct xml_context *ctx, struct xml_node *e)
151 {
152   if (!strcmp(e->name, "node"))
153     parse_node(ctx, e);
154   else if (!strcmp(e->name, "way"))
155     parse_way(ctx, e);
156   else if (!strcmp(e->name, "relation"))
157     parse_relation(ctx, e);
158 }
159
160 void osm_xml_parse(const char *name)
161 {
162   struct xml_context ctx;
163   xml_init(&ctx);
164   ctx.h_warn = ctx.h_error = ctx.h_fatal = h_error;
165   xml_push_fastbuf(&ctx, bopen_file(name, O_RDONLY, NULL));
166
167   uint state;
168   while (state = xml_next_state(&ctx, XML_PULL_STAG))
169     switch (state)
170       {
171       case XML_STATE_STAG:
172         // printf("STAG %s\n", ctx.node->name);
173         if (strcmp(ctx.node->name, "osm"))
174           {
175             ctx.flags |= XML_ALLOC_CHARS | XML_ALLOC_TAGS;
176             if (xml_skip_element(&ctx) == XML_STATE_ETAG)
177               {
178                 // printf("ETAG %s\n", ctx.node->name);
179                 parse_element(&ctx, ctx.node);
180               }
181           }
182       }
183
184   if (ctx.err_code)
185     die("Fatal error in XML parser");
186
187   xml_cleanup(&ctx);
188 }