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