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