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