X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fmisc%2Fxml%2Fxtag.c;h=487ce513292183f2994b55f475e6937b5566ebeb;hb=c328515343633f4f85e40cd88d7ffd977c951c1b;hp=6c4ae02bd2e36be2bdbebabf0ce6e2cee7b9227d;hpb=af40daabd8b447f367c5ce63e1bec3dde3031c2c;p=vlc

diff --git a/modules/misc/xml/xtag.c b/modules/misc/xml/xtag.c
index 6c4ae02bd2..487ce51329 100644
--- a/modules/misc/xml/xtag.c
+++ b/modules/misc/xml/xtag.c
@@ -3,7 +3,7 @@
  *****************************************************************************
  * Copyright (C) 2003-2004 Commonwealth Scientific and Industrial Research
  *                         Organisation (CSIRO) Australia
- * Copyright (C) 2000-2004 VideoLAN
+ * Copyright (C) 2000-2004 the VideoLAN team
  *
  * $Id$
  *
@@ -23,21 +23,23 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
 
-#include <stdlib.h>
-#include <vlc/vlc.h>
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc_common.h>
+#include <vlc_plugin.h>
 
-#include "vlc_xml.h"
-#include "vlc_block.h"
-#include "vlc_stream.h"
+#include <vlc_xml.h>
+#include <vlc_block.h>
+#include <vlc_stream.h>
+#include <vlc_memory.h>
 
 #include <ctype.h>
-#include <string.h>
 #include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
 
 #undef XTAG_DEBUG
 
@@ -81,129 +83,94 @@ typedef struct _XTagParser
 /*****************************************************************************
  * Module descriptor
  *****************************************************************************/
-static int  Open ( vlc_object_t * );
-static void Close( vlc_object_t * );
+static int ReaderOpen( vlc_object_t * );
+static void ReaderClose( vlc_object_t * );
 
-vlc_module_begin();
-    set_category( CAT_ADVANCED );
-    set_subcategory( SUBCAT_ADVANCED_XML );
-    set_description( _("Simple XML Parser") );
-    set_capability( "xml", 5 );
-    set_callbacks( Open, Close );
-vlc_module_end();
+vlc_module_begin ()
+    set_description( N_("Simple XML Parser") )
+    set_capability( "xml reader", 5 )
+    set_callbacks( ReaderOpen, ReaderClose )
+vlc_module_end ()
 
 struct xml_reader_sys_t
 {
     XTag *p_root; /* Root tag */
     XTag *p_curtag; /* Current tag */
     XList *p_curattr; /* Current attribute */
-    vlc_bool_t b_endtag;
+    bool b_endtag;
 };
 
-static xml_reader_t *ReaderCreate( xml_t *, stream_t * );
-static void ReaderDelete( xml_reader_t * );
 static int ReaderRead( xml_reader_t * );
 static int ReaderNodeType( xml_reader_t * );
 static char *ReaderName( xml_reader_t * );
 static char *ReaderValue( xml_reader_t * );
 static int ReaderNextAttr( xml_reader_t * );
 
-static int ReaderUseDTD ( xml_reader_t *, vlc_bool_t );
-
-static void CatalogLoad( xml_t *, const char * );
-static void CatalogAdd( xml_t *, const char *, const char *, const char * );
+static int ReaderUseDTD ( xml_reader_t *, bool );
 
 static XTag *xtag_new_parse( const char *, int );
 static char *xtag_get_name( XTag * );
+#if 0
 static char *xtag_get_pcdata( XTag * );
 static char *xtag_get_attribute( XTag *, char * );
+#endif
 static XTag *xtag_first_child( XTag *, char * );
 static XTag *xtag_next_child( XTag *, char * );
-static XTag *xtag_free( XTag * );
+static void  xtag_free( XTag * );
+#if 0
 static int xtag_snprint( char *, int, XTag * );
-
-/*****************************************************************************
- * Module initialization
- *****************************************************************************/
-static int Open( vlc_object_t *p_this )
-{
-    xml_t *p_xml = (xml_t *)p_this;
-
-    p_xml->pf_reader_create = ReaderCreate;
-    p_xml->pf_reader_delete = ReaderDelete;
-
-    p_xml->pf_catalog_load = CatalogLoad;
-    p_xml->pf_catalog_add  = CatalogAdd;
-
-    return VLC_SUCCESS;
-}
-
-/*****************************************************************************
- * Module deinitialization
- *****************************************************************************/
-static void Close( vlc_object_t *p_this )
-{
-    return;
-}
-
-/*****************************************************************************
- * Catalogue functions
- *****************************************************************************/
-static void CatalogLoad( xml_t *p_xml, const char *psz_filename )
-{
-    msg_Dbg( p_xml, "catalog support not implemented" );
-}
-
-static void CatalogAdd( xml_t *p_xml, const char *psz_arg1,
-                          const char *psz_arg2, const char *psz_filename )
-{
-}
+#endif
 
 /*****************************************************************************
  * Reader functions
  *****************************************************************************/
-static xml_reader_t *ReaderCreate( xml_t *p_xml, stream_t *s )
+static int ReaderOpen( vlc_object_t *p_this )
 {
-    xml_reader_t *p_reader;
-    xml_reader_sys_t *p_sys;
+    xml_reader_t *p_reader = (xml_reader_t *)p_this;
+    stream_t *s = p_reader->p_stream;
     char *p_buffer;
-    int i_size,i_buffer;
+    int i_size, i_pos = 0, i_buffer = 2048;
     XTag *p_root;
 
     /* Open and read file */
+    p_buffer = malloc( i_buffer );
+    if( p_buffer == NULL )
+        return VLC_ENOMEM;
 
-    i_size = stream_Size( s ) - stream_Tell( s );
-    p_buffer = malloc( i_size + 1 );
-    i_buffer = 0;
-    while( i_buffer < i_size )
+    while( ( i_size = stream_Read( s, &p_buffer[i_pos], 2048 ) ) == 2048 )
     {
-        msg_Dbg( p_xml, "got %d, want %d", i_buffer, i_size );
-        i_buffer += stream_Read( s, &p_buffer[i_buffer], i_size - i_buffer );
+        i_pos += i_size;
+        i_buffer += i_size;
+        p_buffer = realloc_or_free( p_buffer, i_buffer );
+        if( !p_buffer )
+            return VLC_ENOMEM;
     }
-    p_buffer[ i_buffer ] = 0;
-
-    if( !i_buffer )
+    if( i_pos + i_size == 0 )
     {
-        msg_Dbg( p_xml, "empty xml" );
+        msg_Dbg( p_this, "empty XML" );
         free( p_buffer );
-        return 0;
+        return VLC_ENOMEM;
     }
+    p_buffer[ i_pos + i_size ] = '\0'; /* 0 terminated string */
 
     p_root = xtag_new_parse( p_buffer, i_buffer );
+    free( p_buffer );
     if( !p_root )
     {
-        msg_Warn( p_xml, "couldn't parse xml" );
-        free( p_buffer );
-        return 0;
+        msg_Warn( p_this, "couldn't parse XML" );
+        return VLC_ENOMEM;
     }
 
-    p_reader = malloc( sizeof(xml_reader_t) );
-    p_reader->p_sys = p_sys = malloc( sizeof(xml_reader_sys_t) );
+    p_reader->p_sys = malloc( sizeof(xml_reader_sys_t) );
+    if( !p_reader->p_sys )
+    {
+        xtag_free( p_root );
+        return VLC_ENOMEM;
+    }
     p_reader->p_sys->p_root = p_root;
     p_reader->p_sys->p_curtag = NULL;
     p_reader->p_sys->p_curattr = NULL;
-    p_reader->p_sys->b_endtag = VLC_FALSE;
-    p_reader->p_xml = p_xml;
+    p_reader->p_sys->b_endtag = false;
 
     p_reader->pf_read = ReaderRead;
     p_reader->pf_node_type = ReaderNodeType;
@@ -212,18 +179,20 @@ static xml_reader_t *ReaderCreate( xml_t *p_xml, stream_t *s )
     p_reader->pf_next_attr = ReaderNextAttr;
     p_reader->pf_use_dtd = ReaderUseDTD;
 
-    return p_reader;
+    return VLC_SUCCESS;
 }
 
-static void ReaderDelete( xml_reader_t *p_reader )
+static void ReaderClose( vlc_object_t *p_this )
 {
+    xml_reader_t *p_reader = (xml_reader_t *)p_this;
+
     xtag_free( p_reader->p_sys->p_root );
     free( p_reader->p_sys );
-    free( p_reader );
 }
 
-static int ReaderUseDTD ( xml_reader_t *p_reader, vlc_bool_t b_use )
+static int ReaderUseDTD ( xml_reader_t *p_reader, bool b_use )
 {
+    VLC_UNUSED(p_reader); VLC_UNUSED(b_use);
     return VLC_EGENERIC;
 }
 
@@ -237,24 +206,24 @@ static int ReaderRead( xml_reader_t *p_reader )
         return 1;
     }
 
-    while( 1 )
+    while( true )
     {
         if( (p_child = xtag_next_child( p_reader->p_sys->p_curtag, 0 )) )
         {
             p_reader->p_sys->p_curtag = p_child;
-            p_reader->p_sys->p_curattr = 0;
-            p_reader->p_sys->b_endtag = VLC_FALSE;
+            p_reader->p_sys->p_curattr = NULL;
+            p_reader->p_sys->b_endtag = false;
             return 1;
         }
 
         if( p_reader->p_sys->p_curtag->name && /* no end tag for pcdata */
             !p_reader->p_sys->b_endtag )
         {
-            p_reader->p_sys->b_endtag = VLC_TRUE;
+            p_reader->p_sys->b_endtag = true;
             return 1;
         }
 
-        p_reader->p_sys->b_endtag = VLC_FALSE;
+        p_reader->p_sys->b_endtag = false;
         if( !p_reader->p_sys->p_curtag->parent ) return 0;
         p_reader->p_sys->p_curtag = p_reader->p_sys->p_curtag->parent;
     }
@@ -264,10 +233,12 @@ static int ReaderRead( xml_reader_t *p_reader )
 
 static int ReaderNodeType( xml_reader_t *p_reader )
 {
-    if( p_reader->p_sys->p_curtag->name &&
-        p_reader->p_sys->b_endtag ) return XML_READER_ENDELEM;
-    if( p_reader->p_sys->p_curtag->name ) return XML_READER_STARTELEM;
-    if( p_reader->p_sys->p_curtag->pcdata ) return XML_READER_TEXT;
+    if( p_reader->p_sys->p_curtag->name && p_reader->p_sys->b_endtag )
+        return XML_READER_ENDELEM;
+    if( p_reader->p_sys->p_curtag->name )
+        return XML_READER_STARTELEM;
+    if( p_reader->p_sys->p_curtag->pcdata )
+        return XML_READER_TEXT;
     return XML_READER_NONE;
 }
 
@@ -279,14 +250,13 @@ static char *ReaderName( xml_reader_t *p_reader )
     {
         psz_name = xtag_get_name( p_reader->p_sys->p_curtag );
 #ifdef XTAG_DEBUG
-        printf( "TAG: %s\n", psz_name );
+        fprintf( stderr, "TAG: %s\n", psz_name );
 #endif
     }
     else
         psz_name = ((XAttribute *)p_reader->p_sys->p_curattr->data)->name;
 
-    if( psz_name ) return strdup( psz_name );
-    else return 0;
+    return psz_name ? strdup( psz_name ) : NULL;
 }
 
 static char *ReaderValue( xml_reader_t *p_reader )
@@ -295,22 +265,21 @@ static char *ReaderValue( xml_reader_t *p_reader )
     if( p_reader->p_sys->p_curtag->pcdata )
     {
 #ifdef XTAG_DEBUG
-        printf( "%s\n", p_reader->p_sys->p_curtag->pcdata );
+        fprintf( stderr, "%s\n", p_reader->p_sys->p_curtag->pcdata );
 #endif
         return strdup( p_reader->p_sys->p_curtag->pcdata );
     }
 
-    if( !p_reader->p_sys->p_curattr ) return 0;
+    if( !p_reader->p_sys->p_curattr ) return NULL;
 
 #ifdef XTAG_DEBUG
-    printf( "%s=%s\n", ((XAttribute *)p_reader->p_sys->p_curattr->data)->name,
+    fprintf( stderr, "%s=%s\n", ((XAttribute *)p_reader->p_sys->p_curattr->data)->name,
             ((XAttribute *)p_reader->p_sys->p_curattr->data)->value );
 #endif
 
     psz_name = ((XAttribute *)p_reader->p_sys->p_curattr->data)->value;
 
-    if( psz_name ) return strdup( psz_name );
-    else return 0;
+    return psz_name ? strdup( psz_name ) : NULL;
 }
 
 static int ReaderNextAttr( xml_reader_t *p_reader )
@@ -319,9 +288,8 @@ static int ReaderNextAttr( xml_reader_t *p_reader )
         p_reader->p_sys->p_curattr = p_reader->p_sys->p_curtag->attributes;
     else if( p_reader->p_sys->p_curattr )
         p_reader->p_sys->p_curattr = p_reader->p_sys->p_curattr->next;
- 
-    if( p_reader->p_sys->p_curattr ) return VLC_SUCCESS;
-    else return VLC_EGENERIC;
+
+    return p_reader->p_sys->p_curattr ? VLC_SUCCESS : VLC_EGENERIC;
 }
 
 /*****************************************************************************
@@ -332,17 +300,20 @@ static XList *xlist_append( XList *list, void *data )
 {
     XList *l, *last;
 
-    l = (XList *)malloc( sizeof(XList) );
+    l = (XList *)xmalloc( sizeof(XList) );
     l->prev = l->next = NULL;
     l->data = data;
 
-    if( list == NULL ) return l;
+    if( !list )
+        return l;
 
-    for( last = list; last; last = last->next )
-        if( last->next == NULL ) break;
+    /* Find the last element */
+    last = list;
+    while( last->next )
+        last = last->next;
 
-    if( last ) last->next = l;
-    l->prev = last; 
+    last->next = l;
+    l->prev = last;
     return list;
 }
 
@@ -368,20 +339,22 @@ static void xlist_free( XList *list )
 #define X_SLASH       1<<6
 #define X_QMARK       1<<7
 #define X_DASH        1<<8
+#define X_EMARK       1<<9
 
 static int xtag_cin( char c, int char_class )
 {
-    if( char_class & X_WHITESPACE ) if( isspace(c) ) return VLC_TRUE;
-    if( char_class & X_OPENTAG )    if( c == '<' ) return VLC_TRUE;
-    if( char_class & X_CLOSETAG )   if( c == '>' ) return VLC_TRUE;
-    if( char_class & X_DQUOTE )     if( c == '"' ) return VLC_TRUE;
-    if( char_class & X_SQUOTE )     if( c == '\'' ) return VLC_TRUE;
-    if( char_class & X_EQUAL )      if( c == '=' ) return VLC_TRUE;
-    if( char_class & X_SLASH )      if( c == '/' ) return VLC_TRUE;
-    if( char_class & X_QMARK )      if( c == '!' ) return VLC_TRUE;
-    if( char_class & X_DASH  )      if( c == '-' ) return VLC_TRUE;
-
-    return VLC_FALSE;
+    if( char_class & X_WHITESPACE ) if( isspace(c) ) return true;
+    if( char_class & X_OPENTAG )    if( c == '<' ) return true;
+    if( char_class & X_CLOSETAG )   if( c == '>' ) return true;
+    if( char_class & X_DQUOTE )     if( c == '"' ) return true;
+    if( char_class & X_SQUOTE )     if( c == '\'' ) return true;
+    if( char_class & X_EQUAL )      if( c == '=' ) return true;
+    if( char_class & X_SLASH )      if( c == '/' ) return true;
+    if( char_class & X_QMARK )      if( c == '?' ) return true;
+    if( char_class & X_DASH  )      if( c == '-' ) return true;
+    if( char_class & X_EMARK )      if( c == '!' ) return true;
+
+    return false;
 }
 
 static int xtag_index( XTagParser *parser, int char_class )
@@ -432,7 +405,7 @@ static char *xtag_slurp_to( XTagParser *parser, int good_end, int bad_end )
 
     if( xi > 0 && xtag_cin (s[xi], good_end) )
     {
-        ret = malloc( (xi+1) * sizeof(char) );
+        ret = xmalloc( xi+1 );
         strncpy( ret, s, xi );
         ret[xi] = '\0';
         parser->start = &s[xi];
@@ -446,17 +419,17 @@ static int xtag_assert_and_pass( XTagParser *parser, int char_class )
 {
     char *s = parser->start;
 
-    if( !parser->valid ) return VLC_FALSE;
+    if( !parser->valid ) return false;
 
     if( !xtag_cin( s[0], char_class ) )
     {
-        parser->valid = VLC_FALSE;
-        return VLC_FALSE;
+        parser->valid = false;
+        return false;
     }
 
     parser->start = &s[1];
 
-    return VLC_TRUE;
+    return true;
 }
 
 static char *xtag_slurp_quoted( XTagParser *parser )
@@ -485,12 +458,16 @@ static char *xtag_slurp_quoted( XTagParser *parser )
         }
     }
 
-    ret = malloc( (xi+1) * sizeof(char) );
+    ret = xmalloc( xi+1 );
     strncpy( ret, s, xi );
     ret[xi] = '\0';
     parser->start = &s[xi];
 
-    if( !xtag_assert_and_pass( parser, quote ) ) return NULL;
+    if( !xtag_assert_and_pass( parser, quote ) )
+    {
+        free( ret );
+        return NULL;
+    }
 
     return ret;
 }
@@ -501,12 +478,14 @@ static XAttribute *xtag_parse_attribute( XTagParser *parser )
     char *name, *value;
     char *s;
 
-    if( !parser->valid ) return NULL;
+    if( !parser->valid )
+        return NULL;
 
     xtag_skip_whitespace( parser );
  
     name = xtag_slurp_to( parser, X_WHITESPACE|X_EQUAL, X_SLASH|X_CLOSETAG );
-    if( name == NULL ) return NULL;
+    if( !name )
+        return NULL;
 
     xtag_skip_whitespace( parser );
     s = parser->start;
@@ -514,7 +493,7 @@ static XAttribute *xtag_parse_attribute( XTagParser *parser )
     if( !xtag_assert_and_pass( parser, X_EQUAL ) )
     {
 #ifdef XTAG_DEBUG
-        printf( "xtag: attr failed EQUAL on <%s>\n", name );
+        fprintf( stderr, "xtag: attr failed EQUAL on <%s>\n", name );
 #endif
         goto err_free_name;
     }
@@ -526,19 +505,19 @@ static XAttribute *xtag_parse_attribute( XTagParser *parser )
     if( value == NULL )
     {
 #ifdef XTAG_DEBUG
-        printf ("Got NULL quoted attribute value\n");
+        fprintf (stderr, "Got NULL quoted attribute value\n");
 #endif
         goto err_free_name;
     }
 
-    attr = malloc( sizeof (*attr) );
+    attr = xmalloc( sizeof (*attr) );
     attr->name = name;
     attr->value = value;
     return attr;
 
  err_free_name:
     free (name);
-    parser->valid = VLC_FALSE;
+    parser->valid = false;
     return NULL;
 }
 
@@ -549,44 +528,21 @@ static XTag *xtag_parse_tag( XTagParser *parser )
     char *name;
     char *pcdata;
     char *s;
+     int xi;
 
     if( !parser->valid ) return NULL;
 
-#if 0 /* Do we really want all the whitespace pcdata ? */
-    xtag_skip_whitespace( parser );
-#endif
-
-    if( (pcdata = xtag_slurp_to( parser, X_OPENTAG, X_NONE )) != NULL )
-    {
-        tag = malloc( sizeof(*tag) );
-        tag->name = NULL;
-        tag->pcdata = pcdata;
-        tag->parent = parser->current_tag;
-        tag->attributes = NULL;
-        tag->children = NULL;
-        tag->current_child = NULL;
-
-        return tag;
-    }
-
     s = parser->start;
 
-    /* if this starts a close tag, return NULL and let the parent take it */
-    if( xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_SLASH ) )
-        return NULL;
-
     /* if this starts a comment tag, skip until end */
-    if( xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_QMARK ) &&
+    if( (parser->end - parser->start) > 7 &&
+          xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_EMARK ) &&
         xtag_cin( s[2], X_DASH ) && xtag_cin( s[3], X_DASH ) )
     {
-        int xi;
-
         parser->start = s = &s[4];
-
         while( (xi = xtag_index( parser, X_DASH )) >= 0 )
         {
             parser->start = s = &s[xi+1];
-
             if( xtag_cin( s[0], X_DASH ) && xtag_cin( s[1], X_CLOSETAG ) )
             {
                 parser->start = &s[2];
@@ -594,19 +550,83 @@ static XTag *xtag_parse_tag( XTagParser *parser )
                 return xtag_parse_tag( parser );
             }
         }
+        return NULL;
+    }
 
+    /* ignore processing instructions '<?' ... '?>' */
+    if( (parser->end - parser->start) > 4 &&
+          xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_QMARK ) )
+    {
+        parser->start = s = &s[2];
+        while ((xi = xtag_index( parser, X_QMARK )) >= 0) {
+            if (xtag_cin( s[xi+1], X_CLOSETAG )) {
+                parser->start = &s[xi+2];
+                xtag_skip_whitespace( parser );
+                return xtag_parse_tag( parser );
+            }
+        }
         return NULL;
     }
 
-    /* FIXME: if this starts a DOCTYPE tag, skip until end */
-    if( xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_QMARK ) )
+    /* ignore doctype  '<!DOCTYPE' ... '>' */
+    if ( (parser->end - parser->start) > 8 &&
+            !strncmp( s, "<!DOCTYPE", 9 ) ) {
+        xi = xtag_index( parser, X_CLOSETAG );
+        if ( xi > 0 ) {
+            parser->start = &s[xi+1];
+            xtag_skip_whitespace( parser );
+            return xtag_parse_tag( parser );
+        }
+        else {
+            return NULL;
+        }
+    }
+
+    if( (pcdata = xtag_slurp_to( parser, X_OPENTAG, X_NONE )) != NULL )
     {
-        int xi = xtag_index( parser, X_CLOSETAG );
-        if( xi <= 0 ) return NULL;
+        tag = xmalloc( sizeof(*tag) );
+        tag->name = NULL;
+        tag->pcdata = pcdata;
+        tag->parent = parser->current_tag;
+        tag->attributes = NULL;
+        tag->children = NULL;
+        tag->current_child = NULL;
 
-        parser->start = &s[xi+1];
-        xtag_skip_whitespace( parser );
-        return xtag_parse_tag( parser );
+        return tag;
+    }
+
+    /* if this starts a close tag, return NULL and let the parent take it */
+    if( xtag_cin( s[0], X_OPENTAG ) && xtag_cin( s[1], X_SLASH ) )
+        return NULL;
+
+    /* parse CDATA content */
+    if ( (parser->end - parser->start) > 8 &&
+            !strncmp( s, "<![CDATA[", 9 ) ) {
+        parser->start = s = &s[9];
+        while (parser->end - s > 2) {
+            if (strncmp( s, "]]>", 3 ) == 0) {
+                if ( !(tag = malloc( sizeof(*tag))) ) return NULL;
+                if ( !(pcdata = malloc( s - parser->start + 1)) )
+                {
+                    free( tag );
+                    return NULL;
+                }
+                strncpy( pcdata, parser->start, s - parser->start );
+                pcdata[s - parser->start]='\0';
+                parser->start = &s[3];
+                tag->name = NULL;
+                tag->pcdata = pcdata;
+                tag->parent = parser->current_tag;
+                tag->attributes = NULL;
+                tag->children = NULL;
+                tag->current_child = NULL;
+                return tag;
+            }
+            else {
+                s++;
+            }
+        }
+        return NULL;
     }
 
     if( !xtag_assert_and_pass( parser, X_OPENTAG ) ) return NULL;
@@ -615,10 +635,10 @@ static XTag *xtag_parse_tag( XTagParser *parser )
     if( name == NULL ) return NULL;
 
 #ifdef XTAG_DEBUG
-    printf ("<%s ...\n", name);
+    fprintf (stderr, "<%s ...\n", name);
 #endif
 
-    tag = malloc( sizeof(*tag) );
+    tag = xmalloc( sizeof(*tag) );
     tag->name = name;
     tag->pcdata = NULL;
     tag->parent = parser->current_tag;
@@ -662,43 +682,45 @@ static XTag *xtag_parse_tag( XTagParser *parser )
             if( strcmp( name, tag->name ) )
             {
 #ifdef XTAG_DEBUG
-                printf ("got %s expected %s\n", name, tag->name);
+                fprintf (stderr, "got %s expected %s\n", name, tag->name);
 #endif
-                parser->valid = VLC_FALSE;
+                parser->valid = false;
             }
             free( name );
         }
 
         xtag_skip_whitespace( parser );
         xtag_assert_and_pass( parser, X_CLOSETAG );
-
+        xtag_skip_whitespace( parser );
     }
     else
     {
         xtag_assert_and_pass( parser, X_SLASH );
         xtag_assert_and_pass( parser, X_CLOSETAG );
+        xtag_skip_whitespace( parser );
     }
 
     return tag;
 }
 
-static XTag *xtag_free( XTag *xtag )
+static void xtag_free( XTag *xtag )
 {
     XList *l;
     XAttribute *attr;
     XTag *child;
 
-    if( xtag == NULL ) return NULL;
+    if( !xtag )
+        return;
 
-    if( xtag->name ) free( xtag->name );
-    if( xtag->pcdata ) free( xtag->pcdata );
+    free( xtag->name );
+    free( xtag->pcdata );
 
     for( l = xtag->attributes; l; l = l->next )
     {
         if( (attr = (XAttribute *)l->data) != NULL )
         {
-            if( attr->name ) free( attr->name );
-            if( attr->value ) free( attr->value );
+            free( attr->name );
+            free( attr->value );
             free( attr );
         }
     }
@@ -712,8 +734,6 @@ static XTag *xtag_free( XTag *xtag )
     xlist_free( xtag->children );
 
     free( xtag );
-
-    return NULL;
 }
 
 static XTag *xtag_new_parse( const char *s, int n )
@@ -721,7 +741,7 @@ static XTag *xtag_new_parse( const char *s, int n )
     XTagParser parser;
     XTag *tag, *ttag, *wrapper;
 
-    parser.valid = VLC_TRUE;
+    parser.valid = true;
     parser.current_tag = NULL;
     parser.start = (char *)s;
 
@@ -729,8 +749,8 @@ static XTag *xtag_new_parse( const char *s, int n )
     else if( n == 0 )
     {
 #ifdef XTAG_DEBUG
-        printf ("empty buffer");
-#endif        
+        fprintf (stderr, "empty buffer\n");
+#endif
         return NULL;
     }
     else parser.end = (char *)&s[n];
@@ -743,7 +763,7 @@ static XTag *xtag_new_parse( const char *s, int n )
     if( !parser.valid )
     {
 #ifdef XTAG_DEBUG
-        printf ("invalid file");
+        fprintf (stderr, "invalid file\n");
 #endif
         xtag_free( tag );
         return NULL;
@@ -757,7 +777,7 @@ static XTag *xtag_new_parse( const char *s, int n )
             return tag;
         }
 
-        wrapper = malloc( sizeof(XTag) );
+        wrapper = xmalloc( sizeof(XTag) );
         wrapper->name = NULL;
         wrapper->pcdata = NULL;
         wrapper->parent = NULL;
@@ -789,6 +809,7 @@ static char *xtag_get_name( XTag *xtag )
     return xtag ? xtag->name : NULL;
 }
 
+#if 0
 static char *xtag_get_pcdata( XTag *xtag )
 {
     XList *l;
@@ -825,6 +846,7 @@ static char *xtag_get_attribute( XTag *xtag, char *attribute )
 
     return NULL;
 }
+#endif
 
 static XTag *xtag_first_child( XTag *xtag, char *name )
 {
@@ -890,6 +912,7 @@ static XTag *xtag_next_child( XTag *xtag, char *name )
     return NULL;
 }
 
+#if 0
 /*
  * This snprints function takes a variable list of char *, the last of
  * which must be NULL, and prints each in turn to buf.
@@ -903,7 +926,7 @@ static int xtag_snprints( char *buf, int n, ... )
     int len, to_copy, total = 0;
 
     va_start( ap, n );
-  
+ 
     for( s = va_arg( ap, char * ); s; s = va_arg( ap, char *) )
     {
         len = strlen (s);
@@ -957,7 +980,7 @@ static int xtag_snprint( char *buf, int n, XTag *xtag )
         for( l = xtag->attributes; l; l = l->next )
         {
             attr = (XAttribute *)l->data;
-      
+ 
             nn = xtag_snprints( buf, n, " ", attr->name, "=\"", attr->value,
                                 "\"", NULL);
             FORWARD( nn );
@@ -991,3 +1014,5 @@ static int xtag_snprint( char *buf, int n, XTag *xtag )
 
     return written;
 }
+#endif
+