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