xtag: comment out xtag_snprint wich is never used.
[vlc.git] / modules / misc / xml / xtag.c
1 /*****************************************************************************
2  * xtag.c : a trivial parser for XML-like tags
3  *****************************************************************************
4  * Copyright (C) 2003-2004 Commonwealth Scientific and Industrial Research
5  *                         Organisation (CSIRO) Australia
6  * Copyright (C) 2000-2004 the VideoLAN team
7  *
8  * $Id$
9  *
10  * Authors: Conrad Parker <Conrad.Parker@csiro.au>
11  *          Andre Pang <Andre.Pang@csiro.au>
12  *          Gildas Bazin <gbazin@videolan.org>
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
27  *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35
36 #include "vlc_xml.h"
37 #include "vlc_block.h"
38 #include "vlc_stream.h"
39
40 #include <ctype.h>
41 #include <stdarg.h>
42
43 #include <assert.h>
44
45 #undef XTAG_DEBUG
46
47 typedef struct _XList
48 {
49     struct _XList *prev;
50     struct _XList *next;
51     void *data;
52 } XList;
53
54 /*
55  * struct XTag is kind of a union ... it normally represents a whole
56  * tag (and its children), but it could alternatively represent some
57  * PCDATA. Basically, if tag->pcdata is non-NULL, interpret only it and
58  * ignore the name, attributes and inner_tags.
59  */
60 typedef struct _XTag
61 {
62     char *name;
63     char *pcdata;
64     struct _XTag *parent;
65     XList *attributes;
66     XList *children;
67     XList *current_child;
68 } XTag;
69
70 typedef struct _XAttribute
71 {
72     char *name;
73     char *value;
74 } XAttribute;
75
76 typedef struct _XTagParser
77 {
78     int valid; /* boolean */
79     XTag *current_tag;
80     char *start;
81     char *end;
82 } XTagParser;
83
84 /*****************************************************************************
85  * Module descriptor
86  *****************************************************************************/
87 static int  Open ( vlc_object_t * );
88 static void Close( vlc_object_t * );
89
90 vlc_module_begin ()
91     set_description( N_("Simple XML Parser") )
92     set_capability( "xml", 5 )
93     set_callbacks( Open, Close )
94 vlc_module_end ()
95
96 struct xml_reader_sys_t
97 {
98     XTag *p_root; /* Root tag */
99     XTag *p_curtag; /* Current tag */
100     XList *p_curattr; /* Current attribute */
101     bool b_endtag;
102 };
103
104 static xml_reader_t *ReaderCreate( xml_t *, stream_t * );
105 static void ReaderDelete( xml_reader_t * );
106 static int ReaderRead( xml_reader_t * );
107 static int ReaderNodeType( xml_reader_t * );
108 static char *ReaderName( xml_reader_t * );
109 static char *ReaderValue( xml_reader_t * );
110 static int ReaderNextAttr( xml_reader_t * );
111
112 static int ReaderUseDTD ( xml_reader_t *, bool );
113
114 static void CatalogLoad( xml_t *, const char * );
115 static void CatalogAdd( xml_t *, const char *, const char *, const char * );
116
117 static XTag *xtag_new_parse( const char *, int );
118 static char *xtag_get_name( XTag * );
119 #if 0
120 static char *xtag_get_pcdata( XTag * );
121 static char *xtag_get_attribute( XTag *, char * );
122 #endif
123 static XTag *xtag_first_child( XTag *, char * );
124 static XTag *xtag_next_child( XTag *, char * );
125 static void  xtag_free( XTag * );
126 #if 0
127 static int xtag_snprint( char *, int, XTag * );
128 #endif
129
130 /*****************************************************************************
131  * Module initialization
132  *****************************************************************************/
133 static int Open( vlc_object_t *p_this )
134 {
135     xml_t *p_xml = (xml_t *)p_this;
136
137     p_xml->pf_reader_create = ReaderCreate;
138     p_xml->pf_reader_delete = ReaderDelete;
139
140     p_xml->pf_catalog_load = CatalogLoad;
141     p_xml->pf_catalog_add  = CatalogAdd;
142
143     return VLC_SUCCESS;
144 }
145
146 /*****************************************************************************
147  * Module deinitialization
148  *****************************************************************************/
149 static void Close( vlc_object_t *p_this )
150 {
151     VLC_UNUSED(p_this);
152     return;
153 }
154
155 /*****************************************************************************
156  * Catalogue functions
157  *****************************************************************************/
158 static void CatalogLoad( xml_t *p_xml, const char *psz_filename )
159 {
160     VLC_UNUSED(psz_filename);
161     msg_Dbg( p_xml, "catalog support not implemented" );
162 }
163
164 static void CatalogAdd( xml_t *p_xml, const char *psz_arg1,
165                           const char *psz_arg2, const char *psz_filename )
166 {
167     VLC_UNUSED(p_xml); VLC_UNUSED(psz_arg1); VLC_UNUSED(psz_arg2);
168     VLC_UNUSED(psz_filename);
169 }
170
171 /*****************************************************************************
172  * Reader functions
173  *****************************************************************************/
174 static xml_reader_t *ReaderCreate( xml_t *p_xml, stream_t *s )
175 {
176     xml_reader_t *p_reader;
177     char *p_buffer, *p_new;
178     int i_size, i_pos = 0, i_buffer = 2048;
179     XTag *p_root;
180
181     /* Open and read file */
182     p_buffer = malloc( i_buffer );
183     if( p_buffer == NULL )
184         return NULL;
185
186     while( ( i_size = stream_Read( s, &p_buffer[i_pos], 2048 ) ) == 2048 )
187     {
188         i_pos += i_size;
189         i_buffer += i_size;
190         p_new = realloc( p_buffer, i_buffer );
191         if( !p_new )
192         {
193             free( p_buffer );
194             return NULL;
195         }
196         p_buffer = p_new;
197     }
198     if( i_pos + i_size == 0 )
199     {
200         msg_Dbg( p_xml, "empty XML" );
201         free( p_buffer );
202         return NULL;
203     }
204     p_buffer[ i_pos + i_size ] = '\0'; /* 0 terminated string */
205
206     p_root = xtag_new_parse( p_buffer, i_buffer );
207     if( !p_root )
208     {
209         msg_Warn( p_xml, "couldn't parse XML" );
210         free( p_buffer );
211         return NULL;
212     }
213
214     free( p_buffer );
215     p_reader = malloc( sizeof(xml_reader_t) );
216     if( !p_reader )
217         return NULL;
218     p_reader->p_sys = malloc( sizeof(xml_reader_sys_t) );
219     if( !p_reader->p_sys )
220     {
221         free( p_reader );
222         return NULL;
223     }
224     p_reader->p_sys->p_root = p_root;
225     p_reader->p_sys->p_curtag = NULL;
226     p_reader->p_sys->p_curattr = NULL;
227     p_reader->p_sys->b_endtag = false;
228     p_reader->p_xml = p_xml;
229
230     p_reader->pf_read = ReaderRead;
231     p_reader->pf_node_type = ReaderNodeType;
232     p_reader->pf_name = ReaderName;
233     p_reader->pf_value = ReaderValue;
234     p_reader->pf_next_attr = ReaderNextAttr;
235     p_reader->pf_use_dtd = ReaderUseDTD;
236
237     return p_reader;
238 }
239
240 static void ReaderDelete( xml_reader_t *p_reader )
241 {
242     xtag_free( p_reader->p_sys->p_root );
243     free( p_reader->p_sys );
244     free( p_reader );
245 }
246
247 static int ReaderUseDTD ( xml_reader_t *p_reader, bool b_use )
248 {
249     VLC_UNUSED(p_reader); VLC_UNUSED(b_use);
250     return VLC_EGENERIC;
251 }
252
253 static int ReaderRead( xml_reader_t *p_reader )
254 {
255     XTag *p_child;
256
257     if( !p_reader->p_sys->p_curtag )
258     {
259         p_reader->p_sys->p_curtag = p_reader->p_sys->p_root;
260         return 1;
261     }
262
263     while( true )
264     {
265         if( (p_child = xtag_next_child( p_reader->p_sys->p_curtag, 0 )) )
266         {
267             p_reader->p_sys->p_curtag = p_child;
268             p_reader->p_sys->p_curattr = NULL;
269             p_reader->p_sys->b_endtag = false;
270             return 1;
271         }
272
273         if( p_reader->p_sys->p_curtag->name && /* no end tag for pcdata */
274             !p_reader->p_sys->b_endtag )
275         {
276             p_reader->p_sys->b_endtag = true;
277             return 1;
278         }
279
280         p_reader->p_sys->b_endtag = false;
281         if( !p_reader->p_sys->p_curtag->parent ) return 0;
282         p_reader->p_sys->p_curtag = p_reader->p_sys->p_curtag->parent;
283     }
284
285     return 0;
286 }
287
288 static int ReaderNodeType( xml_reader_t *p_reader )
289 {
290     if( p_reader->p_sys->p_curtag->name && p_reader->p_sys->b_endtag )
291         return XML_READER_ENDELEM;
292     if( p_reader->p_sys->p_curtag->name )
293         return XML_READER_STARTELEM;
294     if( p_reader->p_sys->p_curtag->pcdata )
295         return XML_READER_TEXT;
296     return XML_READER_NONE;
297 }
298
299 static char *ReaderName( xml_reader_t *p_reader )
300 {
301     const char *psz_name;
302
303     if( !p_reader->p_sys->p_curattr )
304     {
305         psz_name = xtag_get_name( p_reader->p_sys->p_curtag );
306 #ifdef XTAG_DEBUG
307         fprintf( stderr, "TAG: %s\n", psz_name );
308 #endif
309     }
310     else
311         psz_name = ((XAttribute *)p_reader->p_sys->p_curattr->data)->name;
312
313     return psz_name ? strdup( psz_name ) : NULL;
314 }
315
316 static char *ReaderValue( xml_reader_t *p_reader )
317 {
318     const char *psz_name;
319     if( p_reader->p_sys->p_curtag->pcdata )
320     {
321 #ifdef XTAG_DEBUG
322         fprintf( stderr, "%s\n", p_reader->p_sys->p_curtag->pcdata );
323 #endif
324         return strdup( p_reader->p_sys->p_curtag->pcdata );
325     }
326
327     if( !p_reader->p_sys->p_curattr ) return NULL;
328
329 #ifdef XTAG_DEBUG
330     fprintf( stderr, "%s=%s\n", ((XAttribute *)p_reader->p_sys->p_curattr->data)->name,
331             ((XAttribute *)p_reader->p_sys->p_curattr->data)->value );
332 #endif
333
334     psz_name = ((XAttribute *)p_reader->p_sys->p_curattr->data)->value;
335
336     return psz_name ? strdup( psz_name ) : NULL;
337 }
338
339 static int ReaderNextAttr( xml_reader_t *p_reader )
340 {
341     if( !p_reader->p_sys->p_curattr )
342         p_reader->p_sys->p_curattr = p_reader->p_sys->p_curtag->attributes;
343     else if( p_reader->p_sys->p_curattr )
344         p_reader->p_sys->p_curattr = p_reader->p_sys->p_curattr->next;
345
346     return p_reader->p_sys->p_curattr ? VLC_SUCCESS : VLC_EGENERIC;
347 }
348
349 /*****************************************************************************
350  * XTAG parser functions
351  *****************************************************************************/
352
353 static XList *xlist_append( XList *list, void *data )
354 {
355     XList *l, *last;
356
357     l = (XList *)malloc( sizeof(XList) );
358     l->prev = l->next = NULL;
359     l->data = data;
360
361     if( !list )
362         return l;
363
364     for( last = list; last; last = last->next )
365     {
366         if( !last->next )
367             break;
368     }
369
370     if( last ) last->next = l;
371     l->prev = last;
372     return list;
373 }
374
375 static void xlist_free( XList *list )
376 {
377     XList *l, *ln;
378
379     for( l = list; l; l = ln )
380     {
381         ln = l->next;
382         free( l );
383     }
384 }
385
386 /* Character classes */
387 #define X_NONE           0
388 #define X_WHITESPACE  1<<0
389 #define X_OPENTAG     1<<1
390 #define X_CLOSETAG    1<<2
391 #define X_DQUOTE      1<<3
392 #define X_SQUOTE      1<<4
393 #define X_EQUAL       1<<5
394 #define X_SLASH       1<<6
395 #define X_QMARK       1<<7
396 #define X_DASH        1<<8
397 #define X_EMARK       1<<9
398
399 static int xtag_cin( char c, int char_class )
400 {
401     if( char_class & X_WHITESPACE ) if( isspace(c) ) return true;
402     if( char_class & X_OPENTAG )    if( c == '<' ) return true;
403     if( char_class & X_CLOSETAG )   if( c == '>' ) return true;
404     if( char_class & X_DQUOTE )     if( c == '"' ) return true;
405     if( char_class & X_SQUOTE )     if( c == '\'' ) return true;
406     if( char_class & X_EQUAL )      if( c == '=' ) return true;
407     if( char_class & X_SLASH )      if( c == '/' ) return true;
408     if( char_class & X_QMARK )      if( c == '?' ) return true;
409     if( char_class & X_DASH  )      if( c == '-' ) return true;
410     if( char_class & X_EMARK )      if( c == '!' ) return true;
411
412     return false;
413 }
414
415 static int xtag_index( XTagParser *parser, int char_class )
416 {
417     char *s = parser->start;
418     int i;
419
420     for( i = 0; s[i] && s != parser->end; i++ )
421     {
422         if( xtag_cin( s[i], char_class ) ) return i;
423     }
424
425     return -1;
426 }
427
428 static void xtag_skip_over( XTagParser *parser, int char_class )
429 {
430     char *s = parser->start;
431     int i;
432
433     if( !parser->valid ) return;
434
435     for( i = 0; s[i] && s != parser->end; i++ )
436     {
437         if( !xtag_cin( s[i], char_class ) )
438         {
439             parser->start = &s[i];
440             return;
441         }
442     }
443
444     return;
445 }
446
447 static void xtag_skip_whitespace( XTagParser * parser )
448 {
449     xtag_skip_over( parser, X_WHITESPACE );
450 }
451
452 static char *xtag_slurp_to( XTagParser *parser, int good_end, int bad_end )
453 {
454     char *ret, *s = parser->start;
455     int xi;
456
457     if( !parser->valid ) return NULL;
458
459     xi = xtag_index( parser, good_end | bad_end );
460
461     if( xi > 0 && xtag_cin (s[xi], good_end) )
462     {
463         ret = malloc( xi+1 );
464         strncpy( ret, s, xi );
465         ret[xi] = '\0';
466         parser->start = &s[xi];
467         return ret;
468     }
469
470     return NULL;
471 }
472
473 static int xtag_assert_and_pass( XTagParser *parser, int char_class )
474 {
475     char *s = parser->start;
476
477     if( !parser->valid ) return false;
478
479     if( !xtag_cin( s[0], char_class ) )
480     {
481         parser->valid = false;
482         return false;
483     }
484
485     parser->start = &s[1];
486
487     return true;
488 }
489
490 static char *xtag_slurp_quoted( XTagParser *parser )
491 {
492     char * ret, *s;
493     int quote = X_DQUOTE; /* quote char to match on */
494     int xi;
495
496     if( !parser->valid ) return NULL;
497
498     xtag_skip_whitespace( parser );
499
500     s = parser->start;
501
502     if( xtag_cin( s[0], X_SQUOTE ) ) quote = X_SQUOTE;
503
504     if( !xtag_assert_and_pass( parser, quote ) ) return NULL;
505
506     s = parser->start;
507
508     for( xi = 0; s[xi]; xi++ )
509     {
510         if( xtag_cin( s[xi], quote ) )
511         {
512             if( !(xi > 1 && s[xi-1] == '\\') ) break;
513         }
514     }
515
516     ret = malloc( xi+1 );
517     strncpy( ret, s, xi );
518     ret[xi] = '\0';
519     parser->start = &s[xi];
520
521     if( !xtag_assert_and_pass( parser, quote ) )
522     {
523         free( ret );
524         return NULL;
525     }
526
527     return ret;
528 }
529
530 static XAttribute *xtag_parse_attribute( XTagParser *parser )
531 {
532     XAttribute *attr;
533     char *name, *value;
534     char *s;
535
536     if( !parser->valid )
537         return NULL;
538
539     xtag_skip_whitespace( parser );
540  
541     name = xtag_slurp_to( parser, X_WHITESPACE|X_EQUAL, X_SLASH|X_CLOSETAG );
542     if( !name )
543         return NULL;
544
545     xtag_skip_whitespace( parser );
546     s = parser->start;
547
548     if( !xtag_assert_and_pass( parser, X_EQUAL ) )
549     {
550 #ifdef XTAG_DEBUG
551         fprintf( stderr, "xtag: attr failed EQUAL on <%s>\n", name );
552 #endif
553         goto err_free_name;
554     }
555
556     xtag_skip_whitespace( parser );
557
558     value = xtag_slurp_quoted( parser );
559
560     if( value == NULL )
561     {
562 #ifdef XTAG_DEBUG
563         fprintf (stderr, "Got NULL quoted attribute value\n");
564 #endif
565         goto err_free_name;
566     }
567
568     attr = malloc( sizeof (*attr) );
569     attr->name = name;
570     attr->value = value;
571     return attr;
572
573  err_free_name:
574     free (name);
575     parser->valid = false;
576     return NULL;
577 }
578
579 static XTag *xtag_parse_tag( XTagParser *parser )
580 {
581     XTag *tag, *inner;
582     XAttribute *attr;
583     char *name;
584     char *pcdata;
585     char *s;
586      int xi;
587
588     if( !parser->valid ) return NULL;
589
590     s = parser->start;
591
592     /* if this starts a comment tag, skip until end */
593     if( (parser->end - parser->start) > 7 &&
594           xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_EMARK ) &&
595         xtag_cin( s[2], X_DASH ) && xtag_cin( s[3], X_DASH ) )
596     {
597         parser->start = s = &s[4];
598         while( (xi = xtag_index( parser, X_DASH )) >= 0 )
599         {
600             parser->start = s = &s[xi+1];
601             if( xtag_cin( s[0], X_DASH ) && xtag_cin( s[1], X_CLOSETAG ) )
602             {
603                 parser->start = &s[2];
604                 xtag_skip_whitespace( parser );
605                 return xtag_parse_tag( parser );
606             }
607         }
608         return NULL;
609     }
610
611     /* ignore processing instructions '<?' ... '?>' */
612     if( (parser->end - parser->start) > 4 &&
613           xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_QMARK ) )
614     {
615         parser->start = s = &s[2];
616         while ((xi = xtag_index( parser, X_QMARK )) >= 0) {
617             if (xtag_cin( s[xi+1], X_CLOSETAG )) {
618                 parser->start = &s[xi+2];
619                 xtag_skip_whitespace( parser );
620                 return xtag_parse_tag( parser );
621             }
622         }
623         return NULL;
624     }
625
626     /* ignore doctype  '<!DOCTYPE' ... '>' */
627     if ( (parser->end - parser->start) > 8 &&
628             !strncmp( s, "<!DOCTYPE", 9 ) ) {
629         xi = xtag_index( parser, X_CLOSETAG );
630         if ( xi > 0 ) {
631             parser->start = s = &s[xi+1];
632             xtag_skip_whitespace( parser );
633             return xtag_parse_tag( parser );
634         }
635         else {
636             return NULL;
637         }
638     }
639
640     if( (pcdata = xtag_slurp_to( parser, X_OPENTAG, X_NONE )) != NULL )
641     {
642         tag = malloc( sizeof(*tag) );
643         tag->name = NULL;
644         tag->pcdata = pcdata;
645         tag->parent = parser->current_tag;
646         tag->attributes = NULL;
647         tag->children = NULL;
648         tag->current_child = NULL;
649
650         return tag;
651     }
652
653     /* if this starts a close tag, return NULL and let the parent take it */
654     if( xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_SLASH ) )
655         return NULL;
656
657     /* parse CDATA content */
658     if ( (parser->end - parser->start) > 8 &&
659             !strncmp( s, "<![CDATA[", 9 ) ) {
660         parser->start = s = &s[9];
661         while (parser->end - s > 2) {
662             if (strncmp( s, "]]>", 3 ) == 0) {
663                 if ( !(tag = malloc( sizeof(*tag))) ) return NULL;
664                 if ( !(pcdata = malloc( s - parser->start + 1)) )
665                 {
666                     free( tag );
667                     return NULL;
668                 }
669                 strncpy( pcdata, parser->start, s - parser->start );
670                 pcdata[s - parser->start]='\0';
671                 parser->start = s = &s[3];
672                 tag->name = NULL;
673                 tag->pcdata = pcdata;
674                 tag->parent = parser->current_tag;
675                 tag->attributes = NULL;
676                 tag->children = NULL;
677                 tag->current_child = NULL;
678                 return tag;
679             }
680             else {
681                 s++;
682             }
683         }
684         return NULL;
685     }
686
687     if( !xtag_assert_and_pass( parser, X_OPENTAG ) ) return NULL;
688
689     name = xtag_slurp_to( parser, X_WHITESPACE|X_SLASH|X_CLOSETAG, X_NONE );
690     if( name == NULL ) return NULL;
691
692 #ifdef XTAG_DEBUG
693     fprintf (stderr, "<%s ...\n", name);
694 #endif
695
696     tag = malloc( sizeof(*tag) );
697     tag->name = name;
698     tag->pcdata = NULL;
699     tag->parent = parser->current_tag;
700     tag->attributes = NULL;
701     tag->children = NULL;
702     tag->current_child = NULL;
703
704     s = parser->start;
705
706     if( xtag_cin( s[0], X_WHITESPACE ) )
707     {
708         while( (attr = xtag_parse_attribute( parser )) != NULL )
709         {
710             tag->attributes = xlist_append( tag->attributes, attr );
711         }
712     }
713
714     xtag_skip_whitespace( parser );
715
716     s = parser->start;
717
718     if( xtag_cin( s[0], X_CLOSETAG ) )
719     {
720         parser->current_tag = tag;
721
722         xtag_assert_and_pass( parser, X_CLOSETAG );
723
724         while( (inner = xtag_parse_tag( parser ) ) != NULL )
725         {
726             tag->children = xlist_append( tag->children, inner );
727         }
728
729         parser->current_tag = tag->parent;
730         xtag_skip_whitespace( parser );
731
732         xtag_assert_and_pass( parser, X_OPENTAG );
733         xtag_assert_and_pass( parser, X_SLASH );
734         name = xtag_slurp_to( parser, X_WHITESPACE | X_CLOSETAG, X_NONE );
735         if( name )
736         {
737             if( strcmp( name, tag->name ) )
738             {
739 #ifdef XTAG_DEBUG
740                 fprintf (stderr, "got %s expected %s\n", name, tag->name);
741 #endif
742                 parser->valid = false;
743             }
744             free( name );
745         }
746
747         xtag_skip_whitespace( parser );
748         xtag_assert_and_pass( parser, X_CLOSETAG );
749         xtag_skip_whitespace( parser );
750     }
751     else
752     {
753         xtag_assert_and_pass( parser, X_SLASH );
754         xtag_assert_and_pass( parser, X_CLOSETAG );
755         xtag_skip_whitespace( parser );
756     }
757
758     return tag;
759 }
760
761 static void xtag_free( XTag *xtag )
762 {
763     XList *l;
764     XAttribute *attr;
765     XTag *child;
766
767     if( !xtag )
768         return;
769
770     free( xtag->name );
771     free( xtag->pcdata );
772
773     for( l = xtag->attributes; l; l = l->next )
774     {
775         if( (attr = (XAttribute *)l->data) != NULL )
776         {
777             free( attr->name );
778             free( attr->value );
779             free( attr );
780         }
781     }
782     xlist_free( xtag->attributes );
783
784     for( l = xtag->children; l; l = l->next )
785     {
786         child = (XTag *)l->data;
787         xtag_free( child );
788     }
789     xlist_free( xtag->children );
790
791     free( xtag );
792 }
793
794 static XTag *xtag_new_parse( const char *s, int n )
795 {
796     XTagParser parser;
797     XTag *tag, *ttag, *wrapper;
798
799     parser.valid = true;
800     parser.current_tag = NULL;
801     parser.start = (char *)s;
802
803     if( n == -1 ) parser.end = NULL;
804     else if( n == 0 )
805     {
806 #ifdef XTAG_DEBUG
807         fprintf (stderr, "empty buffer\n");
808 #endif
809         return NULL;
810     }
811     else parser.end = (char *)&s[n];
812
813     /* can't have whitespace pcdata outside rootnode */
814     xtag_skip_whitespace( &parser );
815
816     tag = xtag_parse_tag( &parser );
817
818     if( !parser.valid )
819     {
820 #ifdef XTAG_DEBUG
821         fprintf (stderr, "invalid file\n");
822 #endif
823         xtag_free( tag );
824         return NULL;
825     }
826
827     if( (ttag = xtag_parse_tag( &parser )) != NULL )
828     {
829         if( !parser.valid )
830         {
831             xtag_free( ttag );
832             return tag;
833         }
834
835         wrapper = malloc( sizeof(XTag) );
836         wrapper->name = NULL;
837         wrapper->pcdata = NULL;
838         wrapper->parent = NULL;
839         wrapper->attributes = NULL;
840         wrapper->children = NULL;
841         wrapper->current_child = NULL;
842
843         wrapper->children = xlist_append( wrapper->children, tag );
844         wrapper->children = xlist_append( wrapper->children, ttag );
845
846         while( (ttag = xtag_parse_tag( &parser )) != NULL )
847         {
848             if( !parser.valid )
849             {
850                 xtag_free( ttag );
851                 return wrapper;
852             }
853
854             wrapper->children = xlist_append( wrapper->children, ttag );
855         }
856         return wrapper;
857     }
858
859     return tag;
860 }
861
862 static char *xtag_get_name( XTag *xtag )
863 {
864     return xtag ? xtag->name : NULL;
865 }
866
867 #if 0
868 static char *xtag_get_pcdata( XTag *xtag )
869 {
870     XList *l;
871     XTag *child;
872
873     if( xtag == NULL ) return NULL;
874
875     for( l = xtag->children; l; l = l->next )
876     {
877         child = (XTag *)l->data;
878         if( child->pcdata != NULL )
879         {
880             return child->pcdata;
881         }
882     }
883
884     return NULL;
885 }
886
887 static char *xtag_get_attribute( XTag *xtag, char *attribute )
888 {
889     XList *l;
890     XAttribute *attr;
891
892     if( xtag == NULL ) return NULL;
893
894     for( l = xtag->attributes; l; l = l->next )
895     {
896         if( (attr = (XAttribute *)l->data) != NULL )
897         {
898             if( !strcmp( attr->name, attribute ) ) return attr->value;
899         }
900     }
901
902     return NULL;
903 }
904 #endif
905
906 static XTag *xtag_first_child( XTag *xtag, char *name )
907 {
908     XList *l;
909     XTag *child;
910
911     if( xtag == NULL ) return NULL;
912     if( (l = xtag->children) == NULL ) return NULL;
913
914     if( name == NULL )
915     {
916         xtag->current_child = l;
917         return (XTag *)l->data;
918     }
919
920     for( ; l; l = l->next )
921     {
922         child = (XTag *)l->data;
923
924         if( !strcmp( child->name, name ) )
925         {
926             xtag->current_child = l;
927             return child;
928         }
929     }
930
931     xtag->current_child = NULL;
932
933     return NULL;
934 }
935
936 static XTag *xtag_next_child( XTag *xtag, char *name )
937 {
938     XList *l;
939     XTag *child;
940
941     if( xtag == NULL ) return NULL;
942
943     if( (l = xtag->current_child) == NULL )
944         return xtag_first_child( xtag, name );
945
946     if( (l = l->next) == NULL ) return NULL;
947
948     if( name == NULL )
949     {
950         xtag->current_child = l;
951         return (XTag *)l->data;
952     }
953
954     for( ; l; l = l->next )
955     {
956         child = (XTag *)l->data;
957
958         if( !strcmp( child->name, name ) )
959         {
960             xtag->current_child = l;
961             return child;
962         }
963     }
964
965     xtag->current_child = NULL;
966
967     return NULL;
968 }
969
970 #if 0
971 /*
972  * This snprints function takes a variable list of char *, the last of
973  * which must be NULL, and prints each in turn to buf.
974  * Returns C99-style total length that would have been written, even if
975  * this is larger than n.
976  */
977 static int xtag_snprints( char *buf, int n, ... )
978 {
979     va_list ap;
980     char *s;
981     int len, to_copy, total = 0;
982
983     va_start( ap, n );
984  
985     for( s = va_arg( ap, char * ); s; s = va_arg( ap, char *) )
986     {
987         len = strlen (s);
988
989         if( (to_copy = __MIN(n, len) ) > 0 )
990         {
991             memcpy( buf, s, to_copy );
992             buf += to_copy;
993             n -= to_copy;
994         }
995
996         total += len;
997     }
998
999     va_end( ap );
1000
1001     return total;
1002 }
1003
1004 static int xtag_snprint( char *buf, int n, XTag *xtag )
1005 {
1006     int nn, written = 0;
1007     XList *l;
1008     XAttribute *attr;
1009     XTag *child;
1010
1011 #define FORWARD(N) \
1012     buf += __MIN(n, N); \
1013     n = __MAX(n-N, 0);  \
1014     written += N;
1015
1016     if( xtag == NULL )
1017     {
1018         if( n > 0 ) buf[0] = '\0';
1019         return 0;
1020     }
1021
1022     if( xtag->pcdata )
1023     {
1024         nn = xtag_snprints( buf, n, xtag->pcdata, NULL );
1025         FORWARD( nn );
1026
1027         return written;
1028     }
1029
1030     if( xtag->name )
1031     {
1032         nn = xtag_snprints( buf, n, "<", xtag->name, NULL );
1033         FORWARD( nn );
1034
1035         for( l = xtag->attributes; l; l = l->next )
1036         {
1037             attr = (XAttribute *)l->data;
1038  
1039             nn = xtag_snprints( buf, n, " ", attr->name, "=\"", attr->value,
1040                                 "\"", NULL);
1041             FORWARD( nn );
1042         }
1043
1044         if( xtag->children == NULL )
1045         {
1046             nn = xtag_snprints ( buf, n, "/>", NULL );
1047             FORWARD( nn );
1048
1049             return written;
1050         }
1051
1052         nn = xtag_snprints( buf, n, ">", NULL );
1053         FORWARD( nn );
1054     }
1055
1056     for( l = xtag->children; l; l = l->next )
1057     {
1058         child = (XTag *)l->data;
1059
1060         nn = xtag_snprint( buf, n, child );
1061         FORWARD( nn );
1062     }
1063
1064     if( xtag->name )
1065     {
1066         nn = xtag_snprints( buf, n, "</", xtag->name, ">", NULL );
1067         FORWARD( nn );
1068     }
1069
1070     return written;
1071 }
1072 #endif
1073