开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
xtag.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：26k
源码类别：

midi

开发平台：

Unix_Linux

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: 681be12be1eb3b24b22a475aaf6732469c68ca3d $
  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.  *****************************************************************************/
  29. #ifdef HAVE_CONFIG_H
  30. # include "config.h"
  31. #endif
  33. #include <vlc_common.h>
  34. #include <vlc_plugin.h>
  36. #include "vlc_xml.h"
  37. #include "vlc_block.h"
  38. #include "vlc_stream.h"
  40. #include <ctype.h>
  41. #include <stdarg.h>
  43. #include <assert.h>
  45. #undef XTAG_DEBUG
  47. typedef struct _XList
  48. {
  49.     struct _XList *prev;
  50.     struct _XList *next;
  51.     void *data;
  52. } XList;
  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;
  70. typedef struct _XAttribute
  71. {
  72.     char *name;
  73.     char *value;
  74. } XAttribute;
  76. typedef struct _XTagParser
  77. {
  78.     int valid; /* boolean */
  79.     XTag *current_tag;
  80.     char *start;
  81.     char *end;
  82. } XTagParser;
  84. /*****************************************************************************
  85.  * Module descriptor
  86.  *****************************************************************************/
  87. static int  Open ( vlc_object_t * );
  88. static void Close( vlc_object_t * );
  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 ()
  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. };
  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 * );
  112. static int ReaderUseDTD ( xml_reader_t *, bool );
  114. static void CatalogLoad( xml_t *, const char * );
  115. static void CatalogAdd( xml_t *, const char *, const char *, const char * );
  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. #if 0
  127. static int xtag_snprint( char *, int, XTag * );
  128. #endif
  130. /*****************************************************************************
  131.  * Module initialization
  132.  *****************************************************************************/
  133. static int Open( vlc_object_t *p_this )
  134. {
  135.     xml_t *p_xml = (xml_t *)p_this;
  137.     p_xml->pf_reader_create = ReaderCreate;
  138.     p_xml->pf_reader_delete = ReaderDelete;
  140.     p_xml->pf_catalog_load = CatalogLoad;
  141.     p_xml->pf_catalog_add  = CatalogAdd;
  143.     return VLC_SUCCESS;
  144. }
  146. /*****************************************************************************
  147.  * Module deinitialization
  148.  *****************************************************************************/
  149. static void Close( vlc_object_t *p_this )
  150. {
  151.     VLC_UNUSED(p_this);
  152.     return;
  153. }
  155. /*****************************************************************************
  156.  * Catalogue functions
  157.  *****************************************************************************/
  158. static void CatalogLoad( xml_t *p_xml, const char *psz_filename )
  159. {
  160.     VLC_UNUSED(psz_filename);
  161.     msg_Dbg( p_xml, "catalog support not implemented" );
  162. }
  164. static void CatalogAdd( xml_t *p_xml, const char *psz_arg1,
  165.                           const char *psz_arg2, const char *psz_filename )
  166. {
  167.     VLC_UNUSED(p_xml); VLC_UNUSED(psz_arg1); VLC_UNUSED(psz_arg2);
  168.     VLC_UNUSED(psz_filename);
  169. }
  171. /*****************************************************************************
  172.  * Reader functions
  173.  *****************************************************************************/
  174. static xml_reader_t *ReaderCreate( xml_t *p_xml, stream_t *s )
  175. {
  176.     xml_reader_t *p_reader;
  177.     char *p_buffer, *p_new;
  178.     int i_size, i_pos = 0, i_buffer = 2048;
  179.     XTag *p_root;
  181.     /* Open and read file */
  182.     p_buffer = malloc( i_buffer );
  183.     if( p_buffer == NULL )
  184.         return NULL;
  186.     while( ( i_size = stream_Read( s, &p_buffer[i_pos], 2048 ) ) == 2048 )
  187.     {
  188.         i_pos += i_size;
  189.         i_buffer += i_size;
  190.         p_new = realloc( p_buffer, i_buffer );
  191.         if( !p_new )
  192.         {
  193.             free( p_buffer );
  194.             return NULL;
  195.         }
  196.         p_buffer = p_new;
  197.     }
  198.     if( i_pos + i_size == 0 )
  199.     {
  200.         msg_Dbg( p_xml, "empty XML" );
  201.         free( p_buffer );
  202.         return NULL;
  203.     }
  204.     p_buffer[ i_pos + i_size ] = ''; /* 0 terminated string */
  206.     p_root = xtag_new_parse( p_buffer, i_buffer );
  207.     if( !p_root )
  208.     {
  209.         msg_Warn( p_xml, "couldn't parse XML" );
  210.         free( p_buffer );
  211.         return NULL;
  212.     }
  214.     free( p_buffer );
  215.     p_reader = malloc( sizeof(xml_reader_t) );
  216.     if( !p_reader )
  217.         return NULL;
  218.     p_reader->p_sys = malloc( sizeof(xml_reader_sys_t) );
  219.     if( !p_reader->p_sys )
  220.     {
  221.         free( p_reader );
  222.         return NULL;
  223.     }
  224.     p_reader->p_sys->p_root = p_root;
  225.     p_reader->p_sys->p_curtag = NULL;
  226.     p_reader->p_sys->p_curattr = NULL;
  227.     p_reader->p_sys->b_endtag = false;
  228.     p_reader->p_xml = p_xml;
  230.     p_reader->pf_read = ReaderRead;
  231.     p_reader->pf_node_type = ReaderNodeType;
  232.     p_reader->pf_name = ReaderName;
  233.     p_reader->pf_value = ReaderValue;
  234.     p_reader->pf_next_attr = ReaderNextAttr;
  235.     p_reader->pf_use_dtd = ReaderUseDTD;
  237.     return p_reader;
  238. }
  240. static void ReaderDelete( xml_reader_t *p_reader )
  241. {
  242.     xtag_free( p_reader->p_sys->p_root );
  243.     free( p_reader->p_sys );
  244.     free( p_reader );
  245. }
  247. static int ReaderUseDTD ( xml_reader_t *p_reader, bool b_use )
  248. {
  249.     VLC_UNUSED(p_reader); VLC_UNUSED(b_use);
  250.     return VLC_EGENERIC;
  251. }
  253. static int ReaderRead( xml_reader_t *p_reader )
  254. {
  255.     XTag *p_child;
  257.     if( !p_reader->p_sys->p_curtag )
  258.     {
  259.         p_reader->p_sys->p_curtag = p_reader->p_sys->p_root;
  260.         return 1;
  261.     }
  263.     while( true )
  264.     {
  265.         if( (p_child = xtag_next_child( p_reader->p_sys->p_curtag, 0 )) )
  266.         {
  267.             p_reader->p_sys->p_curtag = p_child;
  268.             p_reader->p_sys->p_curattr = NULL;
  269.             p_reader->p_sys->b_endtag = false;
  270.             return 1;
  271.         }
  273.         if( p_reader->p_sys->p_curtag->name && /* no end tag for pcdata */
  274.             !p_reader->p_sys->b_endtag )
  275.         {
  276.             p_reader->p_sys->b_endtag = true;
  277.             return 1;
  278.         }
  280.         p_reader->p_sys->b_endtag = false;
  281.         if( !p_reader->p_sys->p_curtag->parent ) return 0;
  282.         p_reader->p_sys->p_curtag = p_reader->p_sys->p_curtag->parent;
  283.     }
  285.     return 0;
  286. }
  288. static int ReaderNodeType( xml_reader_t *p_reader )
  289. {
  290.     if( p_reader->p_sys->p_curtag->name && p_reader->p_sys->b_endtag )
  291.         return XML_READER_ENDELEM;
  292.     if( p_reader->p_sys->p_curtag->name )
  293.         return XML_READER_STARTELEM;
  294.     if( p_reader->p_sys->p_curtag->pcdata )
  295.         return XML_READER_TEXT;
  296.     return XML_READER_NONE;
  297. }
  299. static char *ReaderName( xml_reader_t *p_reader )
  300. {
  301.     const char *psz_name;
  303.     if( !p_reader->p_sys->p_curattr )
  304.     {
  305.         psz_name = xtag_get_name( p_reader->p_sys->p_curtag );
  306. #ifdef XTAG_DEBUG
  307.         fprintf( stderr, "TAG: %sn", psz_name );
  308. #endif
  309.     }
  310.     else
  311.         psz_name = ((XAttribute *)p_reader->p_sys->p_curattr->data)->name;
  313.     return psz_name ? strdup( psz_name ) : NULL;
  314. }
  316. static char *ReaderValue( xml_reader_t *p_reader )
  317. {
  318.     const char *psz_name;
  319.     if( p_reader->p_sys->p_curtag->pcdata )
  320.     {
  321. #ifdef XTAG_DEBUG
  322.         fprintf( stderr, "%sn", p_reader->p_sys->p_curtag->pcdata );
  323. #endif
  324.         return strdup( p_reader->p_sys->p_curtag->pcdata );
  325.     }
  327.     if( !p_reader->p_sys->p_curattr ) return NULL;
  329. #ifdef XTAG_DEBUG
  330.     fprintf( stderr, "%s=%sn", ((XAttribute *)p_reader->p_sys->p_curattr->data)->name,
  331.             ((XAttribute *)p_reader->p_sys->p_curattr->data)->value );
  332. #endif
  334.     psz_name = ((XAttribute *)p_reader->p_sys->p_curattr->data)->value;
  336.     return psz_name ? strdup( psz_name ) : NULL;
  337. }
  339. static int ReaderNextAttr( xml_reader_t *p_reader )
  340. {
  341.     if( !p_reader->p_sys->p_curattr )
  342.         p_reader->p_sys->p_curattr = p_reader->p_sys->p_curtag->attributes;
  343.     else if( p_reader->p_sys->p_curattr )
  344.         p_reader->p_sys->p_curattr = p_reader->p_sys->p_curattr->next;
  346.     return p_reader->p_sys->p_curattr ? VLC_SUCCESS : VLC_EGENERIC;
  347. }
  349. /*****************************************************************************
  350.  * XTAG parser functions
  351.  *****************************************************************************/
  353. static XList *xlist_append( XList *list, void *data )
  354. {
  355.     XList *l, *last;
  357.     l = (XList *)malloc( sizeof(XList) );
  358.     l->prev = l->next = NULL;
  359.     l->data = data;
  361.     if( !list )
  362.         return l;
  364.     for( last = list; last; last = last->next )
  365.     {
  366.         if( !last->next )
  367.             break;
  368.     }
  370.     if( last ) last->next = l;
  371.     l->prev = last;
  372.     return list;
  373. }
  375. static void xlist_free( XList *list )
  376. {
  377.     XList *l, *ln;
  379.     for( l = list; l; l = ln )
  380.     {
  381.         ln = l->next;
  382.         free( l );
  383.     }
  384. }
  386. /* Character classes */
  387. #define X_NONE           0
  388. #define X_WHITESPACE  1<<0
  389. #define X_OPENTAG     1<<1
  390. #define X_CLOSETAG    1<<2
  391. #define X_DQUOTE      1<<3
  392. #define X_SQUOTE      1<<4
  393. #define X_EQUAL       1<<5
  394. #define X_SLASH       1<<6
  395. #define X_QMARK       1<<7
  396. #define X_DASH        1<<8
  397. #define X_EMARK       1<<9
  399. static int xtag_cin( char c, int char_class )
  400. {
  401.     if( char_class & X_WHITESPACE ) if( isspace(c) ) return true;
  402.     if( char_class & X_OPENTAG )    if( c == '<' ) return true;
  403.     if( char_class & X_CLOSETAG )   if( c == '>' ) return true;
  404.     if( char_class & X_DQUOTE )     if( c == '"' ) return true;
  405.     if( char_class & X_SQUOTE )     if( c == ''' ) return true;
  406.     if( char_class & X_EQUAL )      if( c == '=' ) return true;
  407.     if( char_class & X_SLASH )      if( c == '/' ) return true;
  408.     if( char_class & X_QMARK )      if( c == '?' ) return true;
  409.     if( char_class & X_DASH  )      if( c == '-' ) return true;
  410.     if( char_class & X_EMARK )      if( c == '!' ) return true;
  412.     return false;
  413. }
  415. static int xtag_index( XTagParser *parser, int char_class )
  416. {
  417.     char *s = parser->start;
  418.     int i;
  420.     for( i = 0; s[i] && s != parser->end; i++ )
  421.     {
  422.         if( xtag_cin( s[i], char_class ) ) return i;
  423.     }
  425.     return -1;
  426. }
  428. static void xtag_skip_over( XTagParser *parser, int char_class )
  429. {
  430.     char *s = parser->start;
  431.     int i;
  433.     if( !parser->valid ) return;
  435.     for( i = 0; s[i] && s != parser->end; i++ )
  436.     {
  437.         if( !xtag_cin( s[i], char_class ) )
  438.         {
  439.             parser->start = &s[i];
  440.             return;
  441.         }
  442.     }
  444.     return;
  445. }
  447. static void xtag_skip_whitespace( XTagParser * parser )
  448. {
  449.     xtag_skip_over( parser, X_WHITESPACE );
  450. }
  452. static char *xtag_slurp_to( XTagParser *parser, int good_end, int bad_end )
  453. {
  454.     char *ret, *s = parser->start;
  455.     int xi;
  457.     if( !parser->valid ) return NULL;
  459.     xi = xtag_index( parser, good_end | bad_end );
  461.     if( xi > 0 && xtag_cin (s[xi], good_end) )
  462.     {
  463.         ret = malloc( xi+1 );
  464.         strncpy( ret, s, xi );
  465.         ret[xi] = '';
  466.         parser->start = &s[xi];
  467.         return ret;
  468.     }
  470.     return NULL;
  471. }
  473. static int xtag_assert_and_pass( XTagParser *parser, int char_class )
  474. {
  475.     char *s = parser->start;
  477.     if( !parser->valid ) return false;
  479.     if( !xtag_cin( s[0], char_class ) )
  480.     {
  481.         parser->valid = false;
  482.         return false;
  483.     }
  485.     parser->start = &s[1];
  487.     return true;
  488. }
  490. static char *xtag_slurp_quoted( XTagParser *parser )
  491. {
  492.     char * ret, *s;
  493.     int quote = X_DQUOTE; /* quote char to match on */
  494.     int xi;
  496.     if( !parser->valid ) return NULL;
  498.     xtag_skip_whitespace( parser );
  500.     s = parser->start;
  502.     if( xtag_cin( s[0], X_SQUOTE ) ) quote = X_SQUOTE;
  504.     if( !xtag_assert_and_pass( parser, quote ) ) return NULL;
  506.     s = parser->start;
  508.     for( xi = 0; s[xi]; xi++ )
  509.     {
  510.         if( xtag_cin( s[xi], quote ) )
  511.         {
  512.             if( !(xi > 1 && s[xi-1] == '\') ) break;
  513.         }
  514.     }
  516.     ret = malloc( xi+1 );
  517.     strncpy( ret, s, xi );
  518.     ret[xi] = '';
  519.     parser->start = &s[xi];
  521.     if( !xtag_assert_and_pass( parser, quote ) )
  522.     {
  523.         free( ret );
  524.         return NULL;
  525.     }
  527.     return ret;
  528. }
  530. static XAttribute *xtag_parse_attribute( XTagParser *parser )
  531. {
  532.     XAttribute *attr;
  533.     char *name, *value;
  534.     char *s;
  536.     if( !parser->valid )
  537.         return NULL;
  539.     xtag_skip_whitespace( parser );
  540.  
  541.     name = xtag_slurp_to( parser, X_WHITESPACE|X_EQUAL, X_SLASH|X_CLOSETAG );
  542.     if( !name )
  543.         return NULL;
  545.     xtag_skip_whitespace( parser );
  546.     s = parser->start;
  548.     if( !xtag_assert_and_pass( parser, X_EQUAL ) )
  549.     {
  550. #ifdef XTAG_DEBUG
  551.         fprintf( stderr, "xtag: attr failed EQUAL on <%s>n", name );
  552. #endif
  553.         goto err_free_name;
  554.     }
  556.     xtag_skip_whitespace( parser );
  558.     value = xtag_slurp_quoted( parser );
  560.     if( value == NULL )
  561.     {
  562. #ifdef XTAG_DEBUG
  563.         fprintf (stderr, "Got NULL quoted attribute valuen");
  564. #endif
  565.         goto err_free_name;
  566.     }
  568.     attr = malloc( sizeof (*attr) );
  569.     attr->name = name;
  570.     attr->value = value;
  571.     return attr;
  573.  err_free_name:
  574.     free (name);
  575.     parser->valid = false;
  576.     return NULL;
  577. }
  579. static XTag *xtag_parse_tag( XTagParser *parser )
  580. {
  581.     XTag *tag, *inner;
  582.     XAttribute *attr;
  583.     char *name;
  584.     char *pcdata;
  585.     char *s;
  586.      int xi;
  588.     if( !parser->valid ) return NULL;
  590.     s = parser->start;
  592.     /* if this starts a comment tag, skip until end */
  593.     if( (parser->end - parser->start) > 7 &&
  594.           xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_EMARK ) &&
  595.         xtag_cin( s[2], X_DASH ) && xtag_cin( s[3], X_DASH ) )
  596.     {
  597.         parser->start = s = &s[4];
  598.         while( (xi = xtag_index( parser, X_DASH )) >= 0 )
  599.         {
  600.             parser->start = s = &s[xi+1];
  601.             if( xtag_cin( s[0], X_DASH ) && xtag_cin( s[1], X_CLOSETAG ) )
  602.             {
  603.                 parser->start = &s[2];
  604.                 xtag_skip_whitespace( parser );
  605.                 return xtag_parse_tag( parser );
  606.             }
  607.         }
  608.         return NULL;
  609.     }
  611.     /* ignore processing instructions '<?' ... '?>' */
  612.     if( (parser->end - parser->start) > 4 &&
  613.           xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_QMARK ) )
  614.     {
  615.         parser->start = s = &s[2];
  616.         while ((xi = xtag_index( parser, X_QMARK )) >= 0) {
  617.             if (xtag_cin( s[xi+1], X_CLOSETAG )) {
  618.                 parser->start = &s[xi+2];
  619.                 xtag_skip_whitespace( parser );
  620.                 return xtag_parse_tag( parser );
  621.             }
  622.         }
  623.         return NULL;
  624.     }
  626.     /* ignore doctype  '<!DOCTYPE' ... '>' */
  627.     if ( (parser->end - parser->start) > 8 &&
  628.             !strncmp( s, "<!DOCTYPE", 9 ) ) {
  629.         xi = xtag_index( parser, X_CLOSETAG );
  630.         if ( xi > 0 ) {
  631.             parser->start = s = &s[xi+1];
  632.             xtag_skip_whitespace( parser );
  633.             return xtag_parse_tag( parser );
  634.         }
  635.         else {
  636.             return NULL;
  637.         }
  638.     }
  640.     if( (pcdata = xtag_slurp_to( parser, X_OPENTAG, X_NONE )) != NULL )
  641.     {
  642.         tag = malloc( sizeof(*tag) );
  643.         tag->name = NULL;
  644.         tag->pcdata = pcdata;
  645.         tag->parent = parser->current_tag;
  646.         tag->attributes = NULL;
  647.         tag->children = NULL;
  648.         tag->current_child = NULL;
  650.         return tag;
  651.     }
  653.     /* if this starts a close tag, return NULL and let the parent take it */
  654.     if( xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_SLASH ) )
  655.         return NULL;
  657.     /* parse CDATA content */
  658.     if ( (parser->end - parser->start) > 8 &&
  659.             !strncmp( s, "<![CDATA[", 9 ) ) {
  660.         parser->start = s = &s[9];
  661.         while (parser->end - s > 2) {
  662.             if (strncmp( s, "]]>", 3 ) == 0) {
  663.                 if ( !(tag = malloc( sizeof(*tag))) ) return NULL;
  664.                 if ( !(pcdata = malloc( s - parser->start + 1)) )
  665.                 {
  666.                     free( tag );
  667.                     return NULL;
  668.                 }
  669.                 strncpy( pcdata, parser->start, s - parser->start );
  670.                 pcdata[s - parser->start]='';
  671.                 parser->start = s = &s[3];
  672.                 tag->name = NULL;
  673.                 tag->pcdata = pcdata;
  674.                 tag->parent = parser->current_tag;
  675.                 tag->attributes = NULL;
  676.                 tag->children = NULL;
  677.                 tag->current_child = NULL;
  678.                 return tag;
  679.             }
  680.             else {
  681.                 s++;
  682.             }
  683.         }
  684.         return NULL;
  685.     }
  687.     if( !xtag_assert_and_pass( parser, X_OPENTAG ) ) return NULL;
  689.     name = xtag_slurp_to( parser, X_WHITESPACE|X_SLASH|X_CLOSETAG, X_NONE );
  690.     if( name == NULL ) return NULL;
  692. #ifdef XTAG_DEBUG
  693.     fprintf (stderr, "<%s ...n", name);
  694. #endif
  696.     tag = malloc( sizeof(*tag) );
  697.     tag->name = name;
  698.     tag->pcdata = NULL;
  699.     tag->parent = parser->current_tag;
  700.     tag->attributes = NULL;
  701.     tag->children = NULL;
  702.     tag->current_child = NULL;
  704.     s = parser->start;
  706.     if( xtag_cin( s[0], X_WHITESPACE ) )
  707.     {
  708.         while( (attr = xtag_parse_attribute( parser )) != NULL )
  709.         {
  710.             tag->attributes = xlist_append( tag->attributes, attr );
  711.         }
  712.     }
  714.     xtag_skip_whitespace( parser );
  716.     s = parser->start;
  718.     if( xtag_cin( s[0], X_CLOSETAG ) )
  719.     {
  720.         parser->current_tag = tag;
  722.         xtag_assert_and_pass( parser, X_CLOSETAG );
  724.         while( (inner = xtag_parse_tag( parser ) ) != NULL )
  725.         {
  726.             tag->children = xlist_append( tag->children, inner );
  727.         }
  729.         parser->current_tag = tag->parent;
  730.         xtag_skip_whitespace( parser );
  732.         xtag_assert_and_pass( parser, X_OPENTAG );
  733.         xtag_assert_and_pass( parser, X_SLASH );
  734.         name = xtag_slurp_to( parser, X_WHITESPACE | X_CLOSETAG, X_NONE );
  735.         if( name )
  736.         {
  737.             if( strcmp( name, tag->name ) )
  738.             {
  739. #ifdef XTAG_DEBUG
  740.                 fprintf (stderr, "got %s expected %sn", name, tag->name);
  741. #endif
  742.                 parser->valid = false;
  743.             }
  744.             free( name );
  745.         }
  747.         xtag_skip_whitespace( parser );
  748.         xtag_assert_and_pass( parser, X_CLOSETAG );
  749.         xtag_skip_whitespace( parser );
  750.     }
  751.     else
  752.     {
  753.         xtag_assert_and_pass( parser, X_SLASH );
  754.         xtag_assert_and_pass( parser, X_CLOSETAG );
  755.         xtag_skip_whitespace( parser );
  756.     }
  758.     return tag;
  759. }
  761. static void xtag_free( XTag *xtag )
  762. {
  763.     XList *l;
  764.     XAttribute *attr;
  765.     XTag *child;
  767.     if( !xtag )
  768.         return;
  770.     free( xtag->name );
  771.     free( xtag->pcdata );
  773.     for( l = xtag->attributes; l; l = l->next )
  774.     {
  775.         if( (attr = (XAttribute *)l->data) != NULL )
  776.         {
  777.             free( attr->name );
  778.             free( attr->value );
  779.             free( attr );
  780.         }
  781.     }
  782.     xlist_free( xtag->attributes );
  784.     for( l = xtag->children; l; l = l->next )
  785.     {
  786.         child = (XTag *)l->data;
  787.         xtag_free( child );
  788.     }
  789.     xlist_free( xtag->children );
  791.     free( xtag );
  792. }
  794. static XTag *xtag_new_parse( const char *s, int n )
  795. {
  796.     XTagParser parser;
  797.     XTag *tag, *ttag, *wrapper;
  799.     parser.valid = true;
  800.     parser.current_tag = NULL;
  801.     parser.start = (char *)s;
  803.     if( n == -1 ) parser.end = NULL;
  804.     else if( n == 0 )
  805.     {
  806. #ifdef XTAG_DEBUG
  807.         fprintf (stderr, "empty buffern");
  808. #endif
  809.         return NULL;
  810.     }
  811.     else parser.end = (char *)&s[n];
  813.     /* can't have whitespace pcdata outside rootnode */
  814.     xtag_skip_whitespace( &parser );
  816.     tag = xtag_parse_tag( &parser );
  818.     if( !parser.valid )
  819.     {
  820. #ifdef XTAG_DEBUG
  821.         fprintf (stderr, "invalid filen");
  822. #endif
  823.         xtag_free( tag );
  824.         return NULL;
  825.     }
  827.     if( (ttag = xtag_parse_tag( &parser )) != NULL )
  828.     {
  829.         if( !parser.valid )
  830.         {
  831.             xtag_free( ttag );
  832.             return tag;
  833.         }
  835.         wrapper = malloc( sizeof(XTag) );
  836.         wrapper->name = NULL;
  837.         wrapper->pcdata = NULL;
  838.         wrapper->parent = NULL;
  839.         wrapper->attributes = NULL;
  840.         wrapper->children = NULL;
  841.         wrapper->current_child = NULL;
  843.         wrapper->children = xlist_append( wrapper->children, tag );
  844.         wrapper->children = xlist_append( wrapper->children, ttag );
  846.         while( (ttag = xtag_parse_tag( &parser )) != NULL )
  847.         {
  848.             if( !parser.valid )
  849.             {
  850.                 xtag_free( ttag );
  851.                 return wrapper;
  852.             }
  854.             wrapper->children = xlist_append( wrapper->children, ttag );
  855.         }
  856.         return wrapper;
  857.     }
  859.     return tag;
  860. }
  862. static char *xtag_get_name( XTag *xtag )
  863. {
  864.     return xtag ? xtag->name : NULL;
  865. }
  867. #if 0
  868. static char *xtag_get_pcdata( XTag *xtag )
  869. {
  870.     XList *l;
  871.     XTag *child;
  873.     if( xtag == NULL ) return NULL;
  875.     for( l = xtag->children; l; l = l->next )
  876.     {
  877.         child = (XTag *)l->data;
  878.         if( child->pcdata != NULL )
  879.         {
  880.             return child->pcdata;
  881.         }
  882.     }
  884.     return NULL;
  885. }
  887. static char *xtag_get_attribute( XTag *xtag, char *attribute )
  888. {
  889.     XList *l;
  890.     XAttribute *attr;
  892.     if( xtag == NULL ) return NULL;
  894.     for( l = xtag->attributes; l; l = l->next )
  895.     {
  896.         if( (attr = (XAttribute *)l->data) != NULL )
  897.         {
  898.             if( !strcmp( attr->name, attribute ) ) return attr->value;
  899.         }
  900.     }
  902.     return NULL;
  903. }
  904. #endif
  906. static XTag *xtag_first_child( XTag *xtag, char *name )
  907. {
  908.     XList *l;
  909.     XTag *child;
  911.     if( xtag == NULL ) return NULL;
  912.     if( (l = xtag->children) == NULL ) return NULL;
  914.     if( name == NULL )
  915.     {
  916.         xtag->current_child = l;
  917.         return (XTag *)l->data;
  918.     }
  920.     for( ; l; l = l->next )
  921.     {
  922.         child = (XTag *)l->data;
  924.         if( !strcmp( child->name, name ) )
  925.         {
  926.             xtag->current_child = l;
  927.             return child;
  928.         }
  929.     }
  931.     xtag->current_child = NULL;
  933.     return NULL;
  934. }
  936. static XTag *xtag_next_child( XTag *xtag, char *name )
  937. {
  938.     XList *l;
  939.     XTag *child;
  941.     if( xtag == NULL ) return NULL;
  943.     if( (l = xtag->current_child) == NULL )
  944.         return xtag_first_child( xtag, name );
  946.     if( (l = l->next) == NULL ) return NULL;
  948.     if( name == NULL )
  949.     {
  950.         xtag->current_child = l;
  951.         return (XTag *)l->data;
  952.     }
  954.     for( ; l; l = l->next )
  955.     {
  956.         child = (XTag *)l->data;
  958.         if( !strcmp( child->name, name ) )
  959.         {
  960.             xtag->current_child = l;
  961.             return child;
  962.         }
  963.     }
  965.     xtag->current_child = NULL;
  967.     return NULL;
  968. }
  970. #if 0
  971. /*
  972.  * This snprints function takes a variable list of char *, the last of
  973.  * which must be NULL, and prints each in turn to buf.
  974.  * Returns C99-style total length that would have been written, even if
  975.  * this is larger than n.
  976.  */
  977. static int xtag_snprints( char *buf, int n, ... )
  978. {
  979.     va_list ap;
  980.     char *s;
  981.     int len, to_copy, total = 0;
  983.     va_start( ap, n );
  984.  
  985.     for( s = va_arg( ap, char * ); s; s = va_arg( ap, char *) )
  986.     {
  987.         len = strlen (s);
  989.         if( (to_copy = __MIN(n, len) ) > 0 )
  990.         {
  991.             memcpy( buf, s, to_copy );
  992.             buf += to_copy;
  993.             n -= to_copy;
  994.         }
  996.         total += len;
  997.     }
  999.     va_end( ap );
  1001.     return total;
  1002. }
  1004. static int xtag_snprint( char *buf, int n, XTag *xtag )
  1005. {
  1006.     int nn, written = 0;
  1007.     XList *l;
  1008.     XAttribute *attr;
  1009.     XTag *child;
  1011. #define FORWARD(N) 
  1012.     buf += __MIN(n, N); 
  1013.     n = __MAX(n-N, 0);  
  1014.     written += N;
  1016.     if( xtag == NULL )
  1017.     {
  1018.         if( n > 0 ) buf[0] = '';
  1019.         return 0;
  1020.     }
  1022.     if( xtag->pcdata )
  1023.     {
  1024.         nn = xtag_snprints( buf, n, xtag->pcdata, NULL );
  1025.         FORWARD( nn );
  1027.         return written;
  1028.     }
  1030.     if( xtag->name )
  1031.     {
  1032.         nn = xtag_snprints( buf, n, "<", xtag->name, NULL );
  1033.         FORWARD( nn );
  1035.         for( l = xtag->attributes; l; l = l->next )
  1036.         {
  1037.             attr = (XAttribute *)l->data;
  1038.  
  1039.             nn = xtag_snprints( buf, n, " ", attr->name, "="", attr->value,
  1040.                                 """, NULL);
  1041.             FORWARD( nn );
  1042.         }
  1044.         if( xtag->children == NULL )
  1045.         {
  1046.             nn = xtag_snprints ( buf, n, "/>", NULL );
  1047.             FORWARD( nn );
  1049.             return written;
  1050.         }
  1052.         nn = xtag_snprints( buf, n, ">", NULL );
  1053.         FORWARD( nn );
  1054.     }
  1056.     for( l = xtag->children; l; l = l->next )
  1057.     {
  1058.         child = (XTag *)l->data;
  1060.         nn = xtag_snprint( buf, n, child );
  1061.         FORWARD( nn );
  1062.     }
  1064.     if( xtag->name )
  1065.     {
  1066.         nn = xtag_snprints( buf, n, "</", xtag->name, ">", NULL );
  1067.         FORWARD( nn );
  1068.     }
  1070.     return written;
  1071. }
  1072. #endif