git.sesse.net Git - vlc/blob - modules/misc/xml/xtag.c

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