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