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