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