git.sesse.net Git - vlc/blob - 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 }