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 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 }