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