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