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