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

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