modules/misc/xml/xtag.c

   1 /*****************************************************************************
   2  * xtag.c : a trivial parser for XML-like tags
   3  *****************************************************************************
   4  * Copyright (C) 2003-2004 Commonwealth Scientific and Industrial Research
   5  *                         Organisation (CSIRO) Australia
   6  * Copyright (C) 2000-2004 the VideoLAN team
   7  *
   8  * $Id$
   9  *
  10  * Authors: Conrad Parker <Conrad.Parker@csiro.au>
  11  *          Andre Pang <Andre.Pang@csiro.au>
  12  *          Gildas Bazin <gbazin@videolan.org>
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  27  *****************************************************************************/
  28
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #include <vlc_common.h>
  34 #include <vlc_plugin.h>
  35
  36 #include <vlc_xml.h>
  37 #include <vlc_block.h>
  38 #include <vlc_stream.h>
  39 #include <vlc_memory.h>
  40
  41 #include <ctype.h>
  42 #include <stdarg.h>
  43
  44 #undef XTAG_DEBUG
  45
  46 typedef struct _XList
  47 {
  48     struct _XList *prev;
  49     struct _XList *next;
  50     void *data;
  51 } XList;
  52
  53 /*
  54  * struct XTag is kind of a union ... it normally represents a whole
  55  * tag (and its children), but it could alternatively represent some
  56  * PCDATA. Basically, if tag->pcdata is non-NULL, interpret only it and
  57  * ignore the name, attributes and inner_tags.
  58  */
  59 typedef struct _XTag
  60 {
  61     char *name;
  62     char *pcdata;
  63     struct _XTag *parent;
  64     XList *attributes;
  65     XList *children;
  66     XList *current_child;
  67 } XTag;
  68
  69 typedef struct _XAttribute
  70 {
  71     char *name;
  72     char *value;
  73 } XAttribute;
  74
  75 typedef struct _XTagParser
  76 {
  77     int valid; /* boolean */
  78     XTag *current_tag;
  79     char *start;
  80     char *end;
  81 } XTagParser;
  82
  83 /*****************************************************************************
  84  * Module descriptor
  85  *****************************************************************************/
  86 static int  Open ( vlc_object_t * );
  87 static void Close( vlc_object_t * );
  88
  89 vlc_module_begin ()
  90     set_description( N_("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     bool 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 *, bool );
 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 #if 0
 119 static char *xtag_get_pcdata( XTag * );
 120 static char *xtag_get_attribute( XTag *, char * );
 121 #endif
 122 static XTag *xtag_first_child( XTag *, char * );
 123 static XTag *xtag_next_child( XTag *, char * );
 124 static void  xtag_free( XTag * );
 125 #if 0
 126 static int xtag_snprint( char *, int, XTag * );
 127 #endif
 128
 129 /*****************************************************************************
 130  * Module initialization
 131  *****************************************************************************/
 132 static int Open( vlc_object_t *p_this )
 133 {
 134     xml_t *p_xml = (xml_t *)p_this;
 135
 136     p_xml->pf_reader_create = ReaderCreate;
 137     p_xml->pf_reader_delete = ReaderDelete;
 138
 139     p_xml->pf_catalog_load = CatalogLoad;
 140     p_xml->pf_catalog_add  = CatalogAdd;
 141
 142     return VLC_SUCCESS;
 143 }
 144
 145 /*****************************************************************************
 146  * Module deinitialization
 147  *****************************************************************************/
 148 static void Close( vlc_object_t *p_this )
 149 {
 150     VLC_UNUSED(p_this);
 151     return;
 152 }
 153
 154 /*****************************************************************************
 155  * Catalogue functions
 156  *****************************************************************************/
 157 static void CatalogLoad( xml_t *p_xml, const char *psz_filename )
 158 {
 159     VLC_UNUSED(psz_filename);
 160     msg_Dbg( p_xml, "catalog support not implemented" );
 161 }
 162
 163 static void CatalogAdd( xml_t *p_xml, const char *psz_arg1,
 164                           const char *psz_arg2, const char *psz_filename )
 165 {
 166     VLC_UNUSED(p_xml); VLC_UNUSED(psz_arg1); VLC_UNUSED(psz_arg2);
 167     VLC_UNUSED(psz_filename);
 168 }
 169
 170 /*****************************************************************************
 171  * Reader functions
 172  *****************************************************************************/
 173 static xml_reader_t *ReaderCreate( xml_t *p_xml, stream_t *s )
 174 {
 175     xml_reader_t *p_reader;
 176     char *p_buffer;
 177     int i_size, i_pos = 0, i_buffer = 2048;
 178     XTag *p_root;
 179
 180     /* Open and read file */
 181     p_buffer = malloc( i_buffer );
 182     if( p_buffer == NULL )
 183         return NULL;
 184
 185     while( ( i_size = stream_Read( s, &p_buffer[i_pos], 2048 ) ) == 2048 )
 186     {
 187         i_pos += i_size;
 188         i_buffer += i_size;
 189         p_buffer = realloc_or_free( p_buffer, i_buffer );
 190         if( !p_buffer )
 191             return NULL;
 192     }
 193     if( i_pos + i_size == 0 )
 194     {
 195         msg_Dbg( p_xml, "empty XML" );
 196         free( p_buffer );
 197         return NULL;
 198     }
 199     p_buffer[ i_pos + i_size ] = '\0'; /* 0 terminated string */
 200
 201     p_root = xtag_new_parse( p_buffer, i_buffer );
 202     if( !p_root )
 203     {
 204         msg_Warn( p_xml, "couldn't parse XML" );
 205         free( p_buffer );
 206         return NULL;
 207     }
 208
 209     free( p_buffer );
 210     p_reader = malloc( sizeof(xml_reader_t) );
 211     if( !p_reader )
 212         return NULL;
 213     p_reader->p_sys = malloc( sizeof(xml_reader_sys_t) );
 214     if( !p_reader->p_sys )
 215     {
 216         free( p_reader );
 217         return NULL;
 218     }
 219     p_reader->p_sys->p_root = p_root;
 220     p_reader->p_sys->p_curtag = NULL;
 221     p_reader->p_sys->p_curattr = NULL;
 222     p_reader->p_sys->b_endtag = false;
 223     p_reader->p_xml = p_xml;
 224
 225     p_reader->pf_read = ReaderRead;
 226     p_reader->pf_node_type = ReaderNodeType;
 227     p_reader->pf_name = ReaderName;
 228     p_reader->pf_value = ReaderValue;
 229     p_reader->pf_next_attr = ReaderNextAttr;
 230     p_reader->pf_use_dtd = ReaderUseDTD;
 231
 232     return p_reader;
 233 }
 234
 235 static void ReaderDelete( xml_reader_t *p_reader )
 236 {
 237     xtag_free( p_reader->p_sys->p_root );
 238     free( p_reader->p_sys );
 239     free( p_reader );
 240 }
 241
 242 static int ReaderUseDTD ( xml_reader_t *p_reader, bool b_use )
 243 {
 244     VLC_UNUSED(p_reader); VLC_UNUSED(b_use);
 245     return VLC_EGENERIC;
 246 }
 247
 248 static int ReaderRead( xml_reader_t *p_reader )
 249 {
 250     XTag *p_child;
 251
 252     if( !p_reader->p_sys->p_curtag )
 253     {
 254         p_reader->p_sys->p_curtag = p_reader->p_sys->p_root;
 255         return 1;
 256     }
 257
 258     while( true )
 259     {
 260         if( (p_child = xtag_next_child( p_reader->p_sys->p_curtag, 0 )) )
 261         {
 262             p_reader->p_sys->p_curtag = p_child;
 263             p_reader->p_sys->p_curattr = NULL;
 264             p_reader->p_sys->b_endtag = false;
 265             return 1;
 266         }
 267
 268         if( p_reader->p_sys->p_curtag->name && /* no end tag for pcdata */
 269             !p_reader->p_sys->b_endtag )
 270         {
 271             p_reader->p_sys->b_endtag = true;
 272             return 1;
 273         }
 274
 275         p_reader->p_sys->b_endtag = false;
 276         if( !p_reader->p_sys->p_curtag->parent ) return 0;
 277         p_reader->p_sys->p_curtag = p_reader->p_sys->p_curtag->parent;
 278     }
 279
 280     return 0;
 281 }
 282
 283 static int ReaderNodeType( xml_reader_t *p_reader )
 284 {
 285     if( p_reader->p_sys->p_curtag->name && p_reader->p_sys->b_endtag )
 286         return XML_READER_ENDELEM;
 287     if( p_reader->p_sys->p_curtag->name )
 288         return XML_READER_STARTELEM;
 289     if( p_reader->p_sys->p_curtag->pcdata )
 290         return XML_READER_TEXT;
 291     return XML_READER_NONE;
 292 }
 293
 294 static char *ReaderName( xml_reader_t *p_reader )
 295 {
 296     const char *psz_name;
 297
 298     if( !p_reader->p_sys->p_curattr )
 299     {
 300         psz_name = xtag_get_name( p_reader->p_sys->p_curtag );
 301 #ifdef XTAG_DEBUG
 302         fprintf( stderr, "TAG: %s\n", psz_name );
 303 #endif
 304     }
 305     else
 306         psz_name = ((XAttribute *)p_reader->p_sys->p_curattr->data)->name;
 307
 308     return psz_name ? strdup( psz_name ) : NULL;
 309 }
 310
 311 static char *ReaderValue( xml_reader_t *p_reader )
 312 {
 313     const char *psz_name;
 314     if( p_reader->p_sys->p_curtag->pcdata )
 315     {
 316 #ifdef XTAG_DEBUG
 317         fprintf( stderr, "%s\n", p_reader->p_sys->p_curtag->pcdata );
 318 #endif
 319         return strdup( p_reader->p_sys->p_curtag->pcdata );
 320     }
 321
 322     if( !p_reader->p_sys->p_curattr ) return NULL;
 323
 324 #ifdef XTAG_DEBUG
 325     fprintf( stderr, "%s=%s\n", ((XAttribute *)p_reader->p_sys->p_curattr->data)->name,
 326             ((XAttribute *)p_reader->p_sys->p_curattr->data)->value );
 327 #endif
 328
 329     psz_name = ((XAttribute *)p_reader->p_sys->p_curattr->data)->value;
 330
 331     return psz_name ? strdup( psz_name ) : NULL;
 332 }
 333
 334 static int ReaderNextAttr( xml_reader_t *p_reader )
 335 {
 336     if( !p_reader->p_sys->p_curattr )
 337         p_reader->p_sys->p_curattr = p_reader->p_sys->p_curtag->attributes;
 338     else if( p_reader->p_sys->p_curattr )
 339         p_reader->p_sys->p_curattr = p_reader->p_sys->p_curattr->next;
 340
 341     return p_reader->p_sys->p_curattr ? VLC_SUCCESS : VLC_EGENERIC;
 342 }
 343
 344 /*****************************************************************************
 345  * XTAG parser functions
 346  *****************************************************************************/
 347
 348 static XList *xlist_append( XList *list, void *data )
 349 {
 350     XList *l, *last;
 351
 352     l = (XList *)xmalloc( sizeof(XList) );
 353     l->prev = l->next = NULL;
 354     l->data = data;
 355
 356     if( !list )
 357         return l;
 358
 359     /* Find the last element */
 360     last = list;
 361     while( last->next )
 362         last = last->next;
 363
 364     last->next = l;
 365     l->prev = last;
 366     return list;
 367 }
 368
 369 static void xlist_free( XList *list )
 370 {
 371     XList *l, *ln;
 372
 373     for( l = list; l; l = ln )
 374     {
 375         ln = l->next;
 376         free( l );
 377     }
 378 }
 379
 380 /* Character classes */
 381 #define X_NONE           0
 382 #define X_WHITESPACE  1<<0
 383 #define X_OPENTAG     1<<1
 384 #define X_CLOSETAG    1<<2
 385 #define X_DQUOTE      1<<3
 386 #define X_SQUOTE      1<<4
 387 #define X_EQUAL       1<<5
 388 #define X_SLASH       1<<6
 389 #define X_QMARK       1<<7
 390 #define X_DASH        1<<8
 391 #define X_EMARK       1<<9
 392
 393 static int xtag_cin( char c, int char_class )
 394 {
 395     if( char_class & X_WHITESPACE ) if( isspace(c) ) return true;
 396     if( char_class & X_OPENTAG )    if( c == '<' ) return true;
 397     if( char_class & X_CLOSETAG )   if( c == '>' ) return true;
 398     if( char_class & X_DQUOTE )     if( c == '"' ) return true;
 399     if( char_class & X_SQUOTE )     if( c == '\'' ) return true;
 400     if( char_class & X_EQUAL )      if( c == '=' ) return true;
 401     if( char_class & X_SLASH )      if( c == '/' ) return true;
 402     if( char_class & X_QMARK )      if( c == '?' ) return true;
 403     if( char_class & X_DASH  )      if( c == '-' ) return true;
 404     if( char_class & X_EMARK )      if( c == '!' ) return true;
 405
 406     return false;
 407 }
 408
 409 static int xtag_index( XTagParser *parser, int char_class )
 410 {
 411     char *s = parser->start;
 412     int i;
 413
 414     for( i = 0; s[i] && s != parser->end; i++ )
 415     {
 416         if( xtag_cin( s[i], char_class ) ) return i;
 417     }
 418
 419     return -1;
 420 }
 421
 422 static void xtag_skip_over( XTagParser *parser, int char_class )
 423 {
 424     char *s = parser->start;
 425     int i;
 426
 427     if( !parser->valid ) return;
 428
 429     for( i = 0; s[i] && s != parser->end; i++ )
 430     {
 431         if( !xtag_cin( s[i], char_class ) )
 432         {
 433             parser->start = &s[i];
 434             return;
 435         }
 436     }
 437
 438     return;
 439 }
 440
 441 static void xtag_skip_whitespace( XTagParser * parser )
 442 {
 443     xtag_skip_over( parser, X_WHITESPACE );
 444 }
 445
 446 static char *xtag_slurp_to( XTagParser *parser, int good_end, int bad_end )
 447 {
 448     char *ret, *s = parser->start;
 449     int xi;
 450
 451     if( !parser->valid ) return NULL;
 452
 453     xi = xtag_index( parser, good_end | bad_end );
 454
 455     if( xi > 0 && xtag_cin (s[xi], good_end) )
 456     {
 457         ret = xmalloc( xi+1 );
 458         strncpy( ret, s, xi );
 459         ret[xi] = '\0';
 460         parser->start = &s[xi];
 461         return ret;
 462     }
 463
 464     return NULL;
 465 }
 466
 467 static int xtag_assert_and_pass( XTagParser *parser, int char_class )
 468 {
 469     char *s = parser->start;
 470
 471     if( !parser->valid ) return false;
 472
 473     if( !xtag_cin( s[0], char_class ) )
 474     {
 475         parser->valid = false;
 476         return false;
 477     }
 478
 479     parser->start = &s[1];
 480
 481     return true;
 482 }
 483
 484 static char *xtag_slurp_quoted( XTagParser *parser )
 485 {
 486     char * ret, *s;
 487     int quote = X_DQUOTE; /* quote char to match on */
 488     int xi;
 489
 490     if( !parser->valid ) return NULL;
 491
 492     xtag_skip_whitespace( parser );
 493
 494     s = parser->start;
 495
 496     if( xtag_cin( s[0], X_SQUOTE ) ) quote = X_SQUOTE;
 497
 498     if( !xtag_assert_and_pass( parser, quote ) ) return NULL;
 499
 500     s = parser->start;
 501
 502     for( xi = 0; s[xi]; xi++ )
 503     {
 504         if( xtag_cin( s[xi], quote ) )
 505         {
 506             if( !(xi > 1 && s[xi-1] == '\\') ) break;
 507         }
 508     }
 509
 510     ret = xmalloc( xi+1 );
 511     strncpy( ret, s, xi );
 512     ret[xi] = '\0';
 513     parser->start = &s[xi];
 514
 515     if( !xtag_assert_and_pass( parser, quote ) )
 516     {
 517         free( ret );
 518         return NULL;
 519     }
 520
 521     return ret;
 522 }
 523
 524 static XAttribute *xtag_parse_attribute( XTagParser *parser )
 525 {
 526     XAttribute *attr;
 527     char *name, *value;
 528     char *s;
 529
 530     if( !parser->valid )
 531         return NULL;
 532
 533     xtag_skip_whitespace( parser );
 534
 535     name = xtag_slurp_to( parser, X_WHITESPACE|X_EQUAL, X_SLASH|X_CLOSETAG );
 536     if( !name )
 537         return NULL;
 538
 539     xtag_skip_whitespace( parser );
 540     s = parser->start;
 541
 542     if( !xtag_assert_and_pass( parser, X_EQUAL ) )
 543     {
 544 #ifdef XTAG_DEBUG
 545         fprintf( stderr, "xtag: attr failed EQUAL on <%s>\n", name );
 546 #endif
 547         goto err_free_name;
 548     }
 549
 550     xtag_skip_whitespace( parser );
 551
 552     value = xtag_slurp_quoted( parser );
 553
 554     if( value == NULL )
 555     {
 556 #ifdef XTAG_DEBUG
 557         fprintf (stderr, "Got NULL quoted attribute value\n");
 558 #endif
 559         goto err_free_name;
 560     }
 561
 562     attr = xmalloc( sizeof (*attr) );
 563     attr->name = name;
 564     attr->value = value;
 565     return attr;
 566
 567  err_free_name:
 568     free (name);
 569     parser->valid = false;
 570     return NULL;
 571 }
 572
 573 static XTag *xtag_parse_tag( XTagParser *parser )
 574 {
 575     XTag *tag, *inner;
 576     XAttribute *attr;
 577     char *name;
 578     char *pcdata;
 579     char *s;
 580      int xi;
 581
 582     if( !parser->valid ) return NULL;
 583
 584     s = parser->start;
 585
 586     /* if this starts a comment tag, skip until end */
 587     if( (parser->end - parser->start) > 7 &&
 588           xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_EMARK ) &&
 589         xtag_cin( s[2], X_DASH ) && xtag_cin( s[3], X_DASH ) )
 590     {
 591         parser->start = s = &s[4];
 592         while( (xi = xtag_index( parser, X_DASH )) >= 0 )
 593         {
 594             parser->start = s = &s[xi+1];
 595             if( xtag_cin( s[0], X_DASH ) && xtag_cin( s[1], X_CLOSETAG ) )
 596             {
 597                 parser->start = &s[2];
 598                 xtag_skip_whitespace( parser );
 599                 return xtag_parse_tag( parser );
 600             }
 601         }
 602         return NULL;
 603     }
 604
 605     /* ignore processing instructions '<?' ... '?>' */
 606     if( (parser->end - parser->start) > 4 &&
 607           xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_QMARK ) )
 608     {
 609         parser->start = s = &s[2];
 610         while ((xi = xtag_index( parser, X_QMARK )) >= 0) {
 611             if (xtag_cin( s[xi+1], X_CLOSETAG )) {
 612                 parser->start = &s[xi+2];
 613                 xtag_skip_whitespace( parser );
 614                 return xtag_parse_tag( parser );
 615             }
 616         }
 617         return NULL;
 618     }
 619
 620     /* ignore doctype  '<!DOCTYPE' ... '>' */
 621     if ( (parser->end - parser->start) > 8 &&
 622             !strncmp( s, "<!DOCTYPE", 9 ) ) {
 623         xi = xtag_index( parser, X_CLOSETAG );
 624         if ( xi > 0 ) {
 625             parser->start = &s[xi+1];
 626             xtag_skip_whitespace( parser );
 627             return xtag_parse_tag( parser );
 628         }
 629         else {
 630             return NULL;
 631         }
 632     }
 633
 634     if( (pcdata = xtag_slurp_to( parser, X_OPENTAG, X_NONE )) != NULL )
 635     {
 636         tag = xmalloc( sizeof(*tag) );
 637         tag->name = NULL;
 638         tag->pcdata = pcdata;
 639         tag->parent = parser->current_tag;
 640         tag->attributes = NULL;
 641         tag->children = NULL;
 642         tag->current_child = NULL;
 643
 644         return tag;
 645     }
 646
 647     /* if this starts a close tag, return NULL and let the parent take it */
 648     if( xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_SLASH ) )
 649         return NULL;
 650
 651     /* parse CDATA content */
 652     if ( (parser->end - parser->start) > 8 &&
 653             !strncmp( s, "<![CDATA[", 9 ) ) {
 654         parser->start = s = &s[9];
 655         while (parser->end - s > 2) {
 656             if (strncmp( s, "]]>", 3 ) == 0) {
 657                 if ( !(tag = malloc( sizeof(*tag))) ) return NULL;
 658                 if ( !(pcdata = malloc( s - parser->start + 1)) )
 659                 {
 660                     free( tag );
 661                     return NULL;
 662                 }
 663                 strncpy( pcdata, parser->start, s - parser->start );
 664                 pcdata[s - parser->start]='\0';
 665                 parser->start = &s[3];
 666                 tag->name = NULL;
 667                 tag->pcdata = pcdata;
 668                 tag->parent = parser->current_tag;
 669                 tag->attributes = NULL;
 670                 tag->children = NULL;
 671                 tag->current_child = NULL;
 672                 return tag;
 673             }
 674             else {
 675                 s++;
 676             }
 677         }
 678         return NULL;
 679     }
 680
 681     if( !xtag_assert_and_pass( parser, X_OPENTAG ) ) return NULL;
 682
 683     name = xtag_slurp_to( parser, X_WHITESPACE|X_SLASH|X_CLOSETAG, X_NONE );
 684     if( name == NULL ) return NULL;
 685
 686 #ifdef XTAG_DEBUG
 687     fprintf (stderr, "<%s ...\n", name);
 688 #endif
 689
 690     tag = xmalloc( sizeof(*tag) );
 691     tag->name = name;
 692     tag->pcdata = NULL;
 693     tag->parent = parser->current_tag;
 694     tag->attributes = NULL;
 695     tag->children = NULL;
 696     tag->current_child = NULL;
 697
 698     s = parser->start;
 699
 700     if( xtag_cin( s[0], X_WHITESPACE ) )
 701     {
 702         while( (attr = xtag_parse_attribute( parser )) != NULL )
 703         {
 704             tag->attributes = xlist_append( tag->attributes, attr );
 705         }
 706     }
 707
 708     xtag_skip_whitespace( parser );
 709
 710     s = parser->start;
 711
 712     if( xtag_cin( s[0], X_CLOSETAG ) )
 713     {
 714         parser->current_tag = tag;
 715
 716         xtag_assert_and_pass( parser, X_CLOSETAG );
 717
 718         while( (inner = xtag_parse_tag( parser ) ) != NULL )
 719         {
 720             tag->children = xlist_append( tag->children, inner );
 721         }
 722
 723         parser->current_tag = tag->parent;
 724         xtag_skip_whitespace( parser );
 725
 726         xtag_assert_and_pass( parser, X_OPENTAG );
 727         xtag_assert_and_pass( parser, X_SLASH );
 728         name = xtag_slurp_to( parser, X_WHITESPACE | X_CLOSETAG, X_NONE );
 729         if( name )
 730         {
 731             if( strcmp( name, tag->name ) )
 732             {
 733 #ifdef XTAG_DEBUG
 734                 fprintf (stderr, "got %s expected %s\n", name, tag->name);
 735 #endif
 736                 parser->valid = false;
 737             }
 738             free( name );
 739         }
 740
 741         xtag_skip_whitespace( parser );
 742         xtag_assert_and_pass( parser, X_CLOSETAG );
 743         xtag_skip_whitespace( parser );
 744     }
 745     else
 746     {
 747         xtag_assert_and_pass( parser, X_SLASH );
 748         xtag_assert_and_pass( parser, X_CLOSETAG );
 749         xtag_skip_whitespace( parser );
 750     }
 751
 752     return tag;
 753 }
 754
 755 static void xtag_free( XTag *xtag )
 756 {
 757     XList *l;
 758     XAttribute *attr;
 759     XTag *child;
 760
 761     if( !xtag )
 762         return;
 763
 764     free( xtag->name );
 765     free( xtag->pcdata );
 766
 767     for( l = xtag->attributes; l; l = l->next )
 768     {
 769         if( (attr = (XAttribute *)l->data) != NULL )
 770         {
 771             free( attr->name );
 772             free( attr->value );
 773             free( attr );
 774         }
 775     }
 776     xlist_free( xtag->attributes );
 777
 778     for( l = xtag->children; l; l = l->next )
 779     {
 780         child = (XTag *)l->data;
 781         xtag_free( child );
 782     }
 783     xlist_free( xtag->children );
 784
 785     free( xtag );
 786 }
 787
 788 static XTag *xtag_new_parse( const char *s, int n )
 789 {
 790     XTagParser parser;
 791     XTag *tag, *ttag, *wrapper;
 792
 793     parser.valid = true;
 794     parser.current_tag = NULL;
 795     parser.start = (char *)s;
 796
 797     if( n == -1 ) parser.end = NULL;
 798     else if( n == 0 )
 799     {
 800 #ifdef XTAG_DEBUG
 801         fprintf (stderr, "empty buffer\n");
 802 #endif
 803         return NULL;
 804     }
 805     else parser.end = (char *)&s[n];
 806
 807     /* can't have whitespace pcdata outside rootnode */
 808     xtag_skip_whitespace( &parser );
 809
 810     tag = xtag_parse_tag( &parser );
 811
 812     if( !parser.valid )
 813     {
 814 #ifdef XTAG_DEBUG
 815         fprintf (stderr, "invalid file\n");
 816 #endif
 817         xtag_free( tag );
 818         return NULL;
 819     }
 820
 821     if( (ttag = xtag_parse_tag( &parser )) != NULL )
 822     {
 823         if( !parser.valid )
 824         {
 825             xtag_free( ttag );
 826             return tag;
 827         }
 828
 829         wrapper = xmalloc( sizeof(XTag) );
 830         wrapper->name = NULL;
 831         wrapper->pcdata = NULL;
 832         wrapper->parent = NULL;
 833         wrapper->attributes = NULL;
 834         wrapper->children = NULL;
 835         wrapper->current_child = NULL;
 836
 837         wrapper->children = xlist_append( wrapper->children, tag );
 838         wrapper->children = xlist_append( wrapper->children, ttag );
 839
 840         while( (ttag = xtag_parse_tag( &parser )) != NULL )
 841         {
 842             if( !parser.valid )
 843             {
 844                 xtag_free( ttag );
 845                 return wrapper;
 846             }
 847
 848             wrapper->children = xlist_append( wrapper->children, ttag );
 849         }
 850         return wrapper;
 851     }
 852
 853     return tag;
 854 }
 855
 856 static char *xtag_get_name( XTag *xtag )
 857 {
 858     return xtag ? xtag->name : NULL;
 859 }
 860
 861 #if 0
 862 static char *xtag_get_pcdata( XTag *xtag )
 863 {
 864     XList *l;
 865     XTag *child;
 866
 867     if( xtag == NULL ) return NULL;
 868
 869     for( l = xtag->children; l; l = l->next )
 870     {
 871         child = (XTag *)l->data;
 872         if( child->pcdata != NULL )
 873         {
 874             return child->pcdata;
 875         }
 876     }
 877
 878     return NULL;
 879 }
 880
 881 static char *xtag_get_attribute( XTag *xtag, char *attribute )
 882 {
 883     XList *l;
 884     XAttribute *attr;
 885
 886     if( xtag == NULL ) return NULL;
 887
 888     for( l = xtag->attributes; l; l = l->next )
 889     {
 890         if( (attr = (XAttribute *)l->data) != NULL )
 891         {
 892             if( !strcmp( attr->name, attribute ) ) return attr->value;
 893         }
 894     }
 895
 896     return NULL;
 897 }
 898 #endif
 899
 900 static XTag *xtag_first_child( XTag *xtag, char *name )
 901 {
 902     XList *l;
 903     XTag *child;
 904
 905     if( xtag == NULL ) return NULL;
 906     if( (l = xtag->children) == NULL ) return NULL;
 907
 908     if( name == NULL )
 909     {
 910         xtag->current_child = l;
 911         return (XTag *)l->data;
 912     }
 913
 914     for( ; l; l = l->next )
 915     {
 916         child = (XTag *)l->data;
 917
 918         if( !strcmp( child->name, name ) )
 919         {
 920             xtag->current_child = l;
 921             return child;
 922         }
 923     }
 924
 925     xtag->current_child = NULL;
 926
 927     return NULL;
 928 }
 929
 930 static XTag *xtag_next_child( XTag *xtag, char *name )
 931 {
 932     XList *l;
 933     XTag *child;
 934
 935     if( xtag == NULL ) return NULL;
 936
 937     if( (l = xtag->current_child) == NULL )
 938         return xtag_first_child( xtag, name );
 939
 940     if( (l = l->next) == NULL ) return NULL;
 941
 942     if( name == NULL )
 943     {
 944         xtag->current_child = l;
 945         return (XTag *)l->data;
 946     }
 947
 948     for( ; l; l = l->next )
 949     {
 950         child = (XTag *)l->data;
 951
 952         if( !strcmp( child->name, name ) )
 953         {
 954             xtag->current_child = l;
 955             return child;
 956         }
 957     }
 958
 959     xtag->current_child = NULL;
 960
 961     return NULL;
 962 }
 963
 964 #if 0
 965 /*
 966  * This snprints function takes a variable list of char *, the last of
 967  * which must be NULL, and prints each in turn to buf.
 968  * Returns C99-style total length that would have been written, even if
 969  * this is larger than n.
 970  */
 971 static int xtag_snprints( char *buf, int n, ... )
 972 {
 973     va_list ap;
 974     char *s;
 975     int len, to_copy, total = 0;
 976
 977     va_start( ap, n );
 978
 979     for( s = va_arg( ap, char * ); s; s = va_arg( ap, char *) )
 980     {
 981         len = strlen (s);
 982
 983         if( (to_copy = __MIN(n, len) ) > 0 )
 984         {
 985             memcpy( buf, s, to_copy );
 986             buf += to_copy;
 987             n -= to_copy;
 988         }
 989
 990         total += len;
 991     }
 992
 993     va_end( ap );
 994
 995     return total;
 996 }
 997
 998 static int xtag_snprint( char *buf, int n, XTag *xtag )
 999 {
1000     int nn, written = 0;
1001     XList *l;
1002     XAttribute *attr;
1003     XTag *child;
1004
1005 #define FORWARD(N) \
1006     buf += __MIN(n, N); \
1007     n = __MAX(n-N, 0);  \
1008     written += N;
1009
1010     if( xtag == NULL )
1011     {
1012         if( n > 0 ) buf[0] = '\0';
1013         return 0;
1014     }
1015
1016     if( xtag->pcdata )
1017     {
1018         nn = xtag_snprints( buf, n, xtag->pcdata, NULL );
1019         FORWARD( nn );
1020
1021         return written;
1022     }
1023
1024     if( xtag->name )
1025     {
1026         nn = xtag_snprints( buf, n, "<", xtag->name, NULL );
1027         FORWARD( nn );
1028
1029         for( l = xtag->attributes; l; l = l->next )
1030         {
1031             attr = (XAttribute *)l->data;
1032
1033             nn = xtag_snprints( buf, n, " ", attr->name, "=\"", attr->value,
1034                                 "\"", NULL);
1035             FORWARD( nn );
1036         }
1037
1038         if( xtag->children == NULL )
1039         {
1040             nn = xtag_snprints ( buf, n, "/>", NULL );
1041             FORWARD( nn );
1042
1043             return written;
1044         }
1045
1046         nn = xtag_snprints( buf, n, ">", NULL );
1047         FORWARD( nn );
1048     }
1049
1050     for( l = xtag->children; l; l = l->next )
1051     {
1052         child = (XTag *)l->data;
1053
1054         nn = xtag_snprint( buf, n, child );
1055         FORWARD( nn );
1056     }
1057
1058     if( xtag->name )
1059     {
1060         nn = xtag_snprints( buf, n, "</", xtag->name, ">", NULL );
1061         FORWARD( nn );
1062     }
1063
1064     return written;
1065 }
1066 #endif
1067