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