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