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