trunk/src/qnd_xml.c

/*
 * Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
 *
 * This file is part of OSM2Go.
 *
 * OSM2Go is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * OSM2Go is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with OSM2Go.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * qnd_xml - quick'n dirty xml is a very small and very fast implementation
 *           of a xml parser. The idea is to replace the usage of libxml2
 *           by this whenever performance is an issue. This is the case
 *           with reading the *.osm files on mobile devices. A powerful
 *           desktop will likely still use the libxml as it's just "better"
 */

#include "appdata.h"

#include <ctype.h>
int isblank(int c);

#define QND_XML_BUFFER_SIZE 1024
typedef struct {
  gpointer userdata;

  FILE *file;
  int total, bytes_read;

  char buffer[QND_XML_BUFFER_SIZE], *cur;
  int fill;

  qnd_xml_stack_t *stack, *sp;
  int mod;   // modifier (?, !, /) in element
  gboolean done;

  qnd_xml_attribute_t *attributes;

} qnd_xml_context_t;


void stack_dump(qnd_xml_context_t *context) {
  qnd_xml_stack_t *stack = context->stack;

  printf("Stack:\n");
  while(stack) {
    if(stack == context->sp) printf(" *");
    else                     printf("  ");

    printf("%s\n", stack->entry->name);
    stack = stack->next;
  }
}

void stack_push(qnd_xml_context_t *context, qnd_xml_entry_t *entry) {
  //  printf("push %s\n", entry->name);

  context->sp->next = g_new0(qnd_xml_stack_t, 1);
  context->sp->next->prev = context->sp;
  context->sp = context->sp->next;
  context->sp->entry = entry;

  //  stack_dump(context);
}

qnd_xml_entry_t *stack_pop(qnd_xml_context_t *context) {
  qnd_xml_entry_t *cur = context->sp->entry;

  context->sp = context->sp->prev;
  g_free(context->sp->next);
  context->sp->next = NULL;

  /* did we just empty the stack? if yes, we're done parsing */
  if(context->sp == context->stack) {
    printf("done parsing\n");
    context->done = TRUE;
  }

  //  printf("popped %s\n", cur->name);
  //  stack_dump(context);
  return cur;
}

gboolean update_buffer(qnd_xml_context_t *context) {

  /* if buffer is empty just fill it */
  if(!context->fill) {
    context->cur = context->buffer;
    context->fill = fread(context->buffer, 1l, 
          QND_XML_BUFFER_SIZE, context->file);

    if(context->fill < 0) {
      printf("read error\n");
      context->fill = 0;
      return FALSE;
    }    
    context->bytes_read += context->fill;
    return TRUE;
  }

  /* shift remaining data down */
  int offset = context->cur - context->buffer;
  g_memmove(context->buffer, context->cur, QND_XML_BUFFER_SIZE - offset);
  context->fill -= offset;
  int bytes_read = fread(context->buffer + QND_XML_BUFFER_SIZE - 
                         offset, 1l, offset, context->file);

  context->cur = context->buffer;
  if(bytes_read < 0) {
    printf("read error\n");
    return FALSE;
  }

  context->bytes_read += bytes_read;
  context->fill += bytes_read;
  return TRUE;
}

/* 
   utf8:
   0xxxxxxx
   110xxxxx 10xxxxxx
   1110xxxx 10xxxxxx 10xxxxxx
   11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

   Do we really need to handle this? Internally we are only 
   handling ascii characters (e.g. '<', '>', '/', '?' etc.)
   thus it's only important to be able to skip utf8 characters
   correctly. Since a subbyte of utf8 never equals a ascii character
   it should be possible to parse the file correctly when ignoring utf8
*/

/* TODO: this needs to be updated to cope with utf8 */
inline char current_char(qnd_xml_context_t *context) {
  return *context->cur;
}

/* TODO: this needs to be updated to cope with utf8 */
inline gboolean skip_char(qnd_xml_context_t *context) {
  context->cur++;
  /* TODO: check buffer range */
  return TRUE;
}

gboolean skip_to_char(qnd_xml_context_t *context, char *chrs) {
  do {
    while(context->cur < context->buffer + context->fill) {
      if(strchr(chrs, current_char(context))) {
        return skip_char(context);
      }
      if(!skip_char(context)) return FALSE;
    }

    /* try to get more data */
    if(!update_buffer(context))
      return FALSE;

  } while(context->fill);

  /* if we get here the system was unable to fill the buffer */
  return FALSE;
}

gboolean buffer_overflow(qnd_xml_context_t *context) {
  return(!(context->cur < context->buffer + context->fill));
}

gboolean get_element_name(qnd_xml_context_t *context) {

  /* drop everything before element from buffer */
  if(!update_buffer(context)) return FALSE;

  char *start = context->cur;

  if(buffer_overflow(context) || !isalpha(current_char(context))) {
    printf("invalid element name #1 (%c)\n", current_char(context));
    return FALSE;
  }

  while(!buffer_overflow(context) && !isblank(current_char(context)) &&
        (current_char(context) != '>')) {
    if(!isalnum(current_char(context))) {
      printf("invalid element name #2 (%c)\n", current_char(context));
      return FALSE;
    }
    if(!skip_char(context)) return FALSE;
  }

#if 0
  char *format = g_strdup_printf("Element name = %%.%ds\n", 
                                 context->cur-start);
  printf(format, start);
  g_free(format);
#endif  

  /* handle special elements locally */
  if(context->mod) {

  } else {
    qnd_xml_entry_t *entry = context->sp->entry, *hit = NULL;

    int i=0;
    for(i=0;!hit && i<entry->num_children;i++) 
      if(strncmp(entry->children[i]->name, start, 
                 strlen(entry->children[i]->name)) == 0) 
        hit = entry->children[i];

    if(hit) 
      stack_push(context, hit);
    else {
      printf("element search failed\n");
      return FALSE;
    }
  }

  return TRUE;
}

gboolean get_attribute_name(qnd_xml_context_t *context) {

  char *start = context->cur;

  if(buffer_overflow(context) || !isalpha(current_char(context))) {
    printf("invalid attribute name\n");
    return FALSE;
  }

  while(!buffer_overflow(context) && !isblank(current_char(context)) && 
        !(current_char(context) == '=')) {
    if(!isalnum(current_char(context))) {
      printf("invalid attribute name\n");
      return FALSE;
    }
    if(!skip_char(context)) return FALSE;
  }

  /* attach a new attribute to chain */
  qnd_xml_attribute_t **attr = &context->attributes;
  while(*attr) attr = &(*attr)->next;
  
  /* terminate name at closing '=' */
  *context->cur = '\0';

  *attr = g_new0(qnd_xml_attribute_t, 1);
  (*attr)->name = start;

  return TRUE;
}

gboolean get_attribute_value(qnd_xml_context_t *context) {

  char *start = context->cur;

  while(!buffer_overflow(context) && !(current_char(context) == '\"')) 
    if(!skip_char(context)) return FALSE;

  /* attach a new attribute to chain */
  qnd_xml_attribute_t **attr = &context->attributes;
  while((*attr) && (*attr)->next) attr = &(*attr)->next;
  
  if(!(*attr) || (*attr)->value) {
    printf("error storing attribute value\n");
    return FALSE;
  }

  /* terminate value at closing '\"' */
  *context->cur = '\0';
  (*attr)->value = start;

  return TRUE;
}

gboolean skip_white(qnd_xml_context_t *context) {
  /* skip all white space */
  while(!buffer_overflow(context) && isblank(current_char(context))) 
    if(!skip_char(context)) return FALSE;

  if(isblank(current_char(context))) {
    printf("error skipping white space\n");
    return FALSE;
  }

  return TRUE;
}

gboolean get_attributes(qnd_xml_context_t *context) {
  /* drop everything before element from buffer */

  if(!update_buffer(context)) return FALSE;
  if(!skip_white(context)) return FALSE;

  while(isalpha(current_char(context))) {

    /* get attribute name */
    if(!get_attribute_name(context)) return FALSE;

    if(!skip_to_char(context, "=")) return FALSE;
    if(!skip_to_char(context, "\"")) return FALSE;

    if(!get_attribute_value(context)) return FALSE;
    if(!skip_to_char(context, "\"")) return FALSE;

    if(!skip_white(context)) return FALSE;
  }
  return TRUE;
}

void attributes_free(qnd_xml_context_t *context) {
  qnd_xml_attribute_t *attr = context->attributes;

  while(attr) {
    qnd_xml_attribute_t *next = attr->next;
    g_free(attr);
    attr = next;
  }

  context->attributes = NULL;
}

void qnd_xml_cleanup(qnd_xml_context_t *context) {
  /* todo: clean stack */

  if(context->file) fclose(context->file);
  g_free(context);
}

gboolean get_element(qnd_xml_context_t *context) {

  /* skip all text */
  if(!skip_to_char(context, "<")) return FALSE;

  /* handle optional modifier */
  if(current_char(context) == '?' || current_char(context) == '!') {
    context->mod = current_char(context);
    if(!skip_char(context)) return FALSE;
  } else
    context->mod = 0;

  /* check for closing element */
  if(current_char(context) == '/') {
    context->mod = '/';
    if(!skip_char(context)) return FALSE;
  }

  if(!get_element_name(context)) return FALSE;
  if(!get_attributes(context)) return FALSE;

  if(context->mod && context->mod != '/') {
    if(current_char(context) != context->mod) {
      printf("modifier mismatch\n");
      return FALSE;
    }
    
    /* skip the modifier */
    if(!skip_char(context)) return FALSE;  
  } 

  if(!skip_white(context)) return FALSE;

  /* call callback now since the entry may be taken from stack */
  if(!context->mod && context->sp->entry->cb) 
    if(!context->sp->entry->cb(context->sp, 
                               context->attributes, context->userdata))
      return FALSE;

  if(context->mod == '/') 
    stack_pop(context);
  else {
    /* if this element closes here it's cleaned up immediately */
    if(current_char(context) == '/') {
      if(!skip_char(context)) return FALSE;
      stack_pop(context);
    }
  }

  if(current_char(context) != '>') {
    printf("element closing error\n");
    return FALSE;
  }

  if(!skip_char(context)) return FALSE;

  attributes_free(context);

  return TRUE;
}

gpointer qnd_xml_parse(char *name, qnd_xml_entry_t *root, gpointer userdata) {
  qnd_xml_context_t *context = g_new0(qnd_xml_context_t, 1);
  context->cur = context->buffer;
  context->userdata = userdata;

  /* init stack by adding root entry */
  context->sp = context->stack = g_new0(qnd_xml_stack_t, 1);
  context->sp->entry = root;

  /* check if file exists and is a regular file */
  if(!g_file_test(name, G_FILE_TEST_IS_REGULAR)) {
    printf("file doesn't exist or is not a regular file\n");
    qnd_xml_cleanup(context);
    return FALSE;
  }

  /* open file */
  context->file = g_fopen(name, "r");
  if(!context->file) { 
    printf("unable to open file\n");
    qnd_xml_cleanup(context);
    return FALSE;
  }

  printf("file is open\n");

  /* get file length */
  fseek(context->file, 0l, SEEK_END);
  context->total = ftell(context->file);
  fseek(context->file, 0l, SEEK_SET);
  
  printf("file length is %d bytes\n", context->total);

  gboolean error = FALSE;
  do
    error = !get_element(context);
  while(!error && !context->done);

  if(error) printf("parser ended with error\n");
  else      printf("parser ended successfully\n");

  printf("current bytes read: %d of %d\n", 
         context->bytes_read, context->total);
  printf("current buffer offset: %d\n", context->cur - context->buffer);

  /* user pointer[0] of root element is retval */
  gpointer retval = error?NULL:context->stack->userdata[0];

  /* close file and cleanup */
  qnd_xml_cleanup(context);

  return retval;
}

char *qnd_xml_get_prop(qnd_xml_attribute_t *attr, char *name) {
  while(attr) {
    if(strcasecmp(name, attr->name) == 0) 
      return attr->value;
    
    attr = attr->next;
  }
  return NULL;
}

char *qnd_xml_get_prop_str(qnd_xml_attribute_t *attr, char *name) {
  char *value = qnd_xml_get_prop(attr, name);
  if(value) return g_strdup(value);
  return NULL;
}

gboolean qnd_xml_get_prop_double(qnd_xml_attribute_t *attr, char *name,
                                 double *dest) {
  char *value = qnd_xml_get_prop(attr, name);
  if(!value) return FALSE;

  *dest = g_ascii_strtod(value, NULL);
  return TRUE;
}

gboolean qnd_xml_get_prop_gulong(qnd_xml_attribute_t *attr, char *name,
                              gulong *dest) {
  char *value = qnd_xml_get_prop(attr, name);
  if(!value) return FALSE;

  *dest = strtoul(value, NULL, 10);
  return TRUE;
}

gboolean qnd_xml_get_prop_is(qnd_xml_attribute_t *attr, char *name,
                             char *ref) {
  char *value = qnd_xml_get_prop(attr, name);
  if(!value) return FALSE;

  return g_strcasecmp(ref, value);
}
1	harbaum	39	/*
2			* Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
3			*
4			* This file is part of OSM2Go.
5			*
6			* OSM2Go is free software: you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* OSM2Go is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with OSM2Go. If not, see <http://www.gnu.org/licenses/>.
18			*/
19
20			/*
21			* qnd_xml - quick'n dirty xml is a very small and very fast implementation
22			* of a xml parser. The idea is to replace the usage of libxml2
23			* by this whenever performance is an issue. This is the case
24			* with reading the *.osm files on mobile devices. A powerful
25			* desktop will likely still use the libxml as it's just "better"
26			*/
27
28			#include "appdata.h"
29
30			#include <ctype.h>
31			int isblank(int c);
32
33			#define QND_XML_BUFFER_SIZE 1024
34			typedef struct {
35			gpointer userdata;
36
37			FILE *file;
38			int total, bytes_read;
39
40			char buffer[QND_XML_BUFFER_SIZE], *cur;
41			int fill;
42
43			qnd_xml_stack_t stack, sp;
44			int mod; // modifier (?, !, /) in element
45			gboolean done;
46
47			qnd_xml_attribute_t *attributes;
48
49			} qnd_xml_context_t;
50
51
52			void stack_dump(qnd_xml_context_t *context) {
53			qnd_xml_stack_t *stack = context->stack;
54
55			printf("Stack:\n");
56			while(stack) {
57			if(stack == context->sp) printf(" *");
58			else printf(" ");
59
60			printf("%s\n", stack->entry->name);
61			stack = stack->next;
62			}
63			}
64
65			void stack_push(qnd_xml_context_t context, qnd_xml_entry_t entry) {
66			// printf("push %s\n", entry->name);
67
68			context->sp->next = g_new0(qnd_xml_stack_t, 1);
69			context->sp->next->prev = context->sp;
70			context->sp = context->sp->next;
71			context->sp->entry = entry;
72
73			// stack_dump(context);
74			}
75
76			qnd_xml_entry_t stack_pop(qnd_xml_context_t context) {
77			qnd_xml_entry_t *cur = context->sp->entry;
78
79			context->sp = context->sp->prev;
80			g_free(context->sp->next);
81			context->sp->next = NULL;
82
83			/* did we just empty the stack? if yes, we're done parsing */
84			if(context->sp == context->stack) {
85			printf("done parsing\n");
86			context->done = TRUE;
87			}
88
89			// printf("popped %s\n", cur->name);
90			// stack_dump(context);
91			return cur;
92			}
93
94			gboolean update_buffer(qnd_xml_context_t *context) {
95
96			/* if buffer is empty just fill it */
97			if(!context->fill) {
98			context->cur = context->buffer;
99			context->fill = fread(context->buffer, 1l,
100			QND_XML_BUFFER_SIZE, context->file);
101
102			if(context->fill < 0) {
103			printf("read error\n");
104			context->fill = 0;
105			return FALSE;
106			}
107			context->bytes_read += context->fill;
108			return TRUE;
109			}
110
111			/* shift remaining data down */
112			int offset = context->cur - context->buffer;
113			g_memmove(context->buffer, context->cur, QND_XML_BUFFER_SIZE - offset);
114			context->fill -= offset;
115			int bytes_read = fread(context->buffer + QND_XML_BUFFER_SIZE -
116			offset, 1l, offset, context->file);
117
118			context->cur = context->buffer;
119			if(bytes_read < 0) {
120			printf("read error\n");
121			return FALSE;
122			}
123
124			context->bytes_read += bytes_read;
125			context->fill += bytes_read;
126			return TRUE;
127			}
128
129			/*
130			utf8:
131			0xxxxxxx
132			110xxxxx 10xxxxxx
133			1110xxxx 10xxxxxx 10xxxxxx
134			11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
135
136			Do we really need to handle this? Internally we are only
137			handling ascii characters (e.g. '<', '>', '/', '?' etc.)
138			thus it's only important to be able to skip utf8 characters
139			correctly. Since a subbyte of utf8 never equals a ascii character
140			it should be possible to parse the file correctly when ignoring utf8
141			*/
142
143			/* TODO: this needs to be updated to cope with utf8 */
144			inline char current_char(qnd_xml_context_t *context) {
145			return *context->cur;
146			}
147
148			/* TODO: this needs to be updated to cope with utf8 */
149			inline gboolean skip_char(qnd_xml_context_t *context) {
150			context->cur++;
151			/* TODO: check buffer range */
152			return TRUE;
153			}
154
155			gboolean skip_to_char(qnd_xml_context_t context, char chrs) {
156			do {
157			while(context->cur < context->buffer + context->fill) {
158			if(strchr(chrs, current_char(context))) {
159			return skip_char(context);
160			}
161			if(!skip_char(context)) return FALSE;
162			}
163
164			/* try to get more data */
165			if(!update_buffer(context))
166			return FALSE;
167
168			} while(context->fill);
169
170			/* if we get here the system was unable to fill the buffer */
171			return FALSE;
172			}
173
174			gboolean buffer_overflow(qnd_xml_context_t *context) {
175			return(!(context->cur < context->buffer + context->fill));
176			}
177
178			gboolean get_element_name(qnd_xml_context_t *context) {
179
180			/* drop everything before element from buffer */
181			if(!update_buffer(context)) return FALSE;
182
183			char *start = context->cur;
184
185			if(buffer_overflow(context) \|\| !isalpha(current_char(context))) {
186			printf("invalid element name #1 (%c)\n", current_char(context));
187			return FALSE;
188			}
189
190			while(!buffer_overflow(context) && !isblank(current_char(context)) &&
191			(current_char(context) != '>')) {
192			if(!isalnum(current_char(context))) {
193			printf("invalid element name #2 (%c)\n", current_char(context));
194			return FALSE;
195			}
196			if(!skip_char(context)) return FALSE;
197			}
198
199			#if 0
200			char *format = g_strdup_printf("Element name = %%.%ds\n",
201			context->cur-start);
202			printf(format, start);
203			g_free(format);
204			#endif
205
206			/* handle special elements locally */
207			if(context->mod) {
208
209			} else {
210			qnd_xml_entry_t entry = context->sp->entry, hit = NULL;
211
212			int i=0;
213			for(i=0;!hit && i<entry->num_children;i++)
214			if(strncmp(entry->children[i]->name, start,
215			strlen(entry->children[i]->name)) == 0)
216			hit = entry->children[i];
217
218			if(hit)
219			stack_push(context, hit);
220			else {
221			printf("element search failed\n");
222			return FALSE;
223			}
224			}
225
226			return TRUE;
227			}
228
229			gboolean get_attribute_name(qnd_xml_context_t *context) {
230
231			char *start = context->cur;
232
233			if(buffer_overflow(context) \|\| !isalpha(current_char(context))) {
234			printf("invalid attribute name\n");
235			return FALSE;
236			}
237
238			while(!buffer_overflow(context) && !isblank(current_char(context)) &&
239			!(current_char(context) == '=')) {
240			if(!isalnum(current_char(context))) {
241			printf("invalid attribute name\n");
242			return FALSE;
243			}
244			if(!skip_char(context)) return FALSE;
245			}
246
247			/* attach a new attribute to chain */
248			qnd_xml_attribute_t **attr = &context->attributes;
249			while(attr) attr = &(attr)->next;
250
251			/* terminate name at closing '=' */
252			*context->cur = '\0';
253
254			*attr = g_new0(qnd_xml_attribute_t, 1);
255			(*attr)->name = start;
256
257			return TRUE;
258			}
259
260			gboolean get_attribute_value(qnd_xml_context_t *context) {
261
262			char *start = context->cur;
263
264			while(!buffer_overflow(context) && !(current_char(context) == '\"'))
265			if(!skip_char(context)) return FALSE;
266
267			/* attach a new attribute to chain */
268			qnd_xml_attribute_t **attr = &context->attributes;
269			while((attr) && (attr)->next) attr = &(*attr)->next;
270
271			if(!(attr) \|\| (attr)->value) {
272			printf("error storing attribute value\n");
273			return FALSE;
274			}
275
276			/* terminate value at closing '\"' */
277			*context->cur = '\0';
278			(*attr)->value = start;
279
280			return TRUE;
281			}
282
283			gboolean skip_white(qnd_xml_context_t *context) {
284			/* skip all white space */
285			while(!buffer_overflow(context) && isblank(current_char(context)))
286			if(!skip_char(context)) return FALSE;
287
288			if(isblank(current_char(context))) {
289			printf("error skipping white space\n");
290			return FALSE;
291			}
292
293			return TRUE;
294			}
295
296			gboolean get_attributes(qnd_xml_context_t *context) {
297			/* drop everything before element from buffer */
298
299			if(!update_buffer(context)) return FALSE;
300			if(!skip_white(context)) return FALSE;
301
302			while(isalpha(current_char(context))) {
303
304			/* get attribute name */
305			if(!get_attribute_name(context)) return FALSE;
306
307			if(!skip_to_char(context, "=")) return FALSE;
308			if(!skip_to_char(context, "\"")) return FALSE;
309
310			if(!get_attribute_value(context)) return FALSE;
311			if(!skip_to_char(context, "\"")) return FALSE;
312
313			if(!skip_white(context)) return FALSE;
314			}
315			return TRUE;
316			}
317
318			void attributes_free(qnd_xml_context_t *context) {
319			qnd_xml_attribute_t *attr = context->attributes;
320
321			while(attr) {
322			qnd_xml_attribute_t *next = attr->next;
323			g_free(attr);
324			attr = next;
325			}
326
327			context->attributes = NULL;
328			}
329
330			void qnd_xml_cleanup(qnd_xml_context_t *context) {
331			/* todo: clean stack */
332
333			if(context->file) fclose(context->file);
334			g_free(context);
335			}
336
337			gboolean get_element(qnd_xml_context_t *context) {
338
339			/* skip all text */
340			if(!skip_to_char(context, "<")) return FALSE;
341
342			/* handle optional modifier */
343			if(current_char(context) == '?' \|\| current_char(context) == '!') {
344			context->mod = current_char(context);
345			if(!skip_char(context)) return FALSE;
346			} else
347			context->mod = 0;
348
349			/* check for closing element */
350			if(current_char(context) == '/') {
351			context->mod = '/';
352			if(!skip_char(context)) return FALSE;
353			}
354
355			if(!get_element_name(context)) return FALSE;
356			if(!get_attributes(context)) return FALSE;
357
358			if(context->mod && context->mod != '/') {
359			if(current_char(context) != context->mod) {
360			printf("modifier mismatch\n");
361			return FALSE;
362			}
363
364			/* skip the modifier */
365			if(!skip_char(context)) return FALSE;
366			}
367
368			if(!skip_white(context)) return FALSE;
369
370			/* call callback now since the entry may be taken from stack */
371			if(!context->mod && context->sp->entry->cb)
372			if(!context->sp->entry->cb(context->sp,
373			context->attributes, context->userdata))
374			return FALSE;
375
376			if(context->mod == '/')
377			stack_pop(context);
378			else {
379			/* if this element closes here it's cleaned up immediately */
380			if(current_char(context) == '/') {
381			if(!skip_char(context)) return FALSE;
382			stack_pop(context);
383			}
384			}
385
386			if(current_char(context) != '>') {
387			printf("element closing error\n");
388			return FALSE;
389			}
390
391			if(!skip_char(context)) return FALSE;
392
393			attributes_free(context);
394
395			return TRUE;
396			}
397
398			gpointer qnd_xml_parse(char name, qnd_xml_entry_t root, gpointer userdata) {
399			qnd_xml_context_t *context = g_new0(qnd_xml_context_t, 1);
400			context->cur = context->buffer;
401			context->userdata = userdata;
402
403			/* init stack by adding root entry */
404			context->sp = context->stack = g_new0(qnd_xml_stack_t, 1);
405			context->sp->entry = root;
406
407			/* check if file exists and is a regular file */
408			if(!g_file_test(name, G_FILE_TEST_IS_REGULAR)) {
409			printf("file doesn't exist or is not a regular file\n");
410			qnd_xml_cleanup(context);
411			return FALSE;
412			}
413
414			/* open file */
415			context->file = g_fopen(name, "r");
416			if(!context->file) {
417			printf("unable to open file\n");
418			qnd_xml_cleanup(context);
419			return FALSE;
420			}
421
422			printf("file is open\n");
423
424			/* get file length */
425			fseek(context->file, 0l, SEEK_END);
426			context->total = ftell(context->file);
427			fseek(context->file, 0l, SEEK_SET);
428
429			printf("file length is %d bytes\n", context->total);
430
431			gboolean error = FALSE;
432			do
433			error = !get_element(context);
434			while(!error && !context->done);
435
436			if(error) printf("parser ended with error\n");
437			else printf("parser ended successfully\n");
438
439			printf("current bytes read: %d of %d\n",
440			context->bytes_read, context->total);
441			printf("current buffer offset: %d\n", context->cur - context->buffer);
442
443			/* user pointer[0] of root element is retval */
444			gpointer retval = error?NULL:context->stack->userdata[0];
445
446			/* close file and cleanup */
447			qnd_xml_cleanup(context);
448
449			return retval;
450			}
451
452			char qnd_xml_get_prop(qnd_xml_attribute_t attr, char *name) {
453			while(attr) {
454			if(strcasecmp(name, attr->name) == 0)
455			return attr->value;
456
457			attr = attr->next;
458			}
459			return NULL;
460			}
461
462			char qnd_xml_get_prop_str(qnd_xml_attribute_t attr, char *name) {
463			char *value = qnd_xml_get_prop(attr, name);
464			if(value) return g_strdup(value);
465			return NULL;
466			}
467
468			gboolean qnd_xml_get_prop_double(qnd_xml_attribute_t attr, char name,
469			double *dest) {
470			char *value = qnd_xml_get_prop(attr, name);
471			if(!value) return FALSE;
472
473			*dest = g_ascii_strtod(value, NULL);
474			return TRUE;
475			}
476
477			gboolean qnd_xml_get_prop_gulong(qnd_xml_attribute_t attr, char name,
478			gulong *dest) {
479			char *value = qnd_xml_get_prop(attr, name);
480			if(!value) return FALSE;
481
482			*dest = strtoul(value, NULL, 10);
483			return TRUE;
484			}
485
486			gboolean qnd_xml_get_prop_is(qnd_xml_attribute_t attr, char name,
487			char *ref) {
488			char *value = qnd_xml_get_prop(attr, name);
489			if(!value) return FALSE;
490
491			return g_strcasecmp(ref, value);
492			}