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