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