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