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