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