libs/xml/xmlparser.h

   1 /*
   2    Copyright (C) 2001-2006, William Joseph.
   3    All Rights Reserved.
   4
   5    This file is part of GtkRadiant.
   6
   7    GtkRadiant is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    GtkRadiant is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GtkRadiant; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 #if !defined( INCLUDED_XML_XMLPARSER_H )
  23 #define INCLUDED_XML_XMLPARSER_H
  24
  25 #include <cstdio>
  26 #include <string.h>
  27 #include "ixml.h"
  28 #include "libxml/parser.h"
  29 #include "convert.h"
  30
  31 class TextInputStream;
  32
  33 class SAXElement : public XMLElement
  34 {
  35 public:
  36 SAXElement( const char* name, const char** atts )
  37         : m_name( name ), m_atts( atts ){
  38 }
  39 const char* name() const {
  40         return m_name;
  41 }
  42 const char* attribute( const char* name ) const {
  43         if ( m_atts != 0 ) {
  44                 for ( const char** att = m_atts; *att != 0; att += 2 )
  45                 {
  46                         if ( strcmp( *att, name ) == 0 ) {
  47                                 return *( ++att );
  48                         }
  49                 }
  50         }
  51         return "";
  52 }
  53 void forEachAttribute( XMLAttrVisitor& visitor ) const {
  54         if ( m_atts != 0 ) {
  55                 for ( const char** att = m_atts; *att != 0; att += 2 )
  56                 {
  57                         visitor.visit( *att, *( att + 1 ) );
  58                 }
  59         }
  60 }
  61 private:
  62 const char* m_name;
  63 const char** m_atts;
  64 };
  65
  66 #include <stdarg.h>
  67
  68 class FormattedVA
  69 {
  70 public:
  71 const char* m_format;
  72 va_list& m_arguments;
  73 FormattedVA( const char* format, va_list& m_arguments )
  74         : m_format( format ), m_arguments( m_arguments ){
  75 }
  76 };
  77
  78 class Formatted
  79 {
  80 public:
  81 const char* m_format;
  82 mutable va_list m_arguments;
  83 Formatted( const char* format, ... )
  84         : m_format( format ){
  85         va_start( m_arguments, format );
  86 }
  87 ~Formatted(){
  88         va_end( m_arguments );
  89 }
  90 };
  91
  92 #ifdef _MSC_VER
  93 #if _MSC_VER < 1400
  94 #define vsnprintf std::vsnprintf
  95 #endif
  96 #endif
  97
  98 template<typename TextOutputStreamType>
  99 inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const FormattedVA& formatted ){
 100         char buffer[1024];
 101         ostream.write( buffer, vsnprintf( buffer, 1023, formatted.m_format, formatted.m_arguments ) );
 102         return ostream;
 103 }
 104
 105 template<typename TextOutputStreamType>
 106 inline TextOutputStreamType& ostream_write( TextOutputStreamType& ostream, const Formatted& formatted ){
 107         char buffer[1024];
 108         ostream.write( buffer, vsnprintf( buffer, 1023, formatted.m_format, formatted.m_arguments ) );
 109         return ostream;
 110 }
 111
 112 class XMLSAXImporter
 113 {
 114 XMLImporter& m_importer;
 115 xmlSAXHandler m_sax;
 116
 117 static void startElement( void *user_data, const xmlChar *name, const xmlChar **atts ){
 118         SAXElement element( reinterpret_cast<const char*>( name ), reinterpret_cast<const char**>( atts ) );
 119         reinterpret_cast<XMLSAXImporter*>( user_data )->m_importer.pushElement( element );
 120 }
 121 static void endElement( void *user_data, const xmlChar *name ){
 122         reinterpret_cast<XMLSAXImporter*>( user_data )->m_importer.popElement( reinterpret_cast<const char*>( name ) );
 123 }
 124 static void characters( void *user_data, const xmlChar *ch, int len ){
 125         reinterpret_cast<XMLSAXImporter*>( user_data )->m_importer
 126         << StringRange( reinterpret_cast<const char*>( ch ), reinterpret_cast<const char*>( ch + len ) );
 127 }
 128
 129 static void warning( void *user_data, const char *msg, ... ){
 130         va_list args;
 131         va_start( args, msg );
 132         globalErrorStream() << "XML WARNING: " << FormattedVA( msg, args );
 133         va_end( args );
 134 }
 135 static void error( void *user_data, const char *msg, ... ){
 136         va_list args;
 137         va_start( args, msg );
 138         globalErrorStream() << "XML ERROR: " << FormattedVA( msg, args );
 139         va_end( args );
 140 }
 141
 142 public:
 143 XMLSAXImporter( XMLImporter& importer ) : m_importer( importer ){
 144         m_sax.internalSubset = 0;
 145         m_sax.isStandalone = 0;
 146         m_sax.hasInternalSubset = 0;
 147         m_sax.hasExternalSubset = 0;
 148         m_sax.resolveEntity = 0;
 149         m_sax.getEntity = 0;
 150         m_sax.entityDecl = 0;
 151         m_sax.notationDecl = 0;
 152         m_sax.attributeDecl = 0;
 153         m_sax.elementDecl = 0;
 154         m_sax.unparsedEntityDecl = 0;
 155         m_sax.setDocumentLocator = 0;
 156         m_sax.startDocument = 0;
 157         m_sax.endDocument = 0;
 158         m_sax.startElement = startElement;
 159         m_sax.endElement = endElement;
 160         m_sax.reference = 0;
 161         m_sax.characters = characters;
 162         m_sax.ignorableWhitespace = 0;
 163         m_sax.processingInstruction = 0;
 164         m_sax.comment = 0;
 165         m_sax.warning = warning;
 166         m_sax.error = error;
 167         m_sax.fatalError = 0;
 168         m_sax.getParameterEntity = 0;
 169         m_sax.cdataBlock = 0;
 170         m_sax.externalSubset = 0;
 171         m_sax.initialized = 1;
 172 }
 173
 174 xmlSAXHandler* callbacks(){
 175         return &m_sax;
 176 }
 177 void* context(){
 178         return this;
 179 }
 180 };
 181
 182 class XMLStreamParser : public XMLExporter
 183 {
 184 enum unnamed0 { BUFSIZE = 1024 };
 185 public:
 186 XMLStreamParser( TextInputStream& istream )
 187         : m_istream( istream ){
 188 }
 189 virtual void exportXML( XMLImporter& importer ){
 190         bool wellFormed = false;
 191
 192         char chars[BUFSIZE];
 193         std::size_t res = m_istream.read( chars, 4 );
 194         if ( res > 0 ) {
 195                 XMLSAXImporter sax( importer );
 196
 197                 xmlParserCtxtPtr ctxt = xmlCreatePushParserCtxt( sax.callbacks(), sax.context(), chars, static_cast<int>( res ), 0 );
 198                 ctxt->replaceEntities = 1;
 199
 200                 while ( ( res = m_istream.read( chars, BUFSIZE ) ) > 0 )
 201                 {
 202                         xmlParseChunk( ctxt, chars, static_cast<int>( res ), 0 );
 203                 }
 204                 xmlParseChunk( ctxt, chars, 0, 1 );
 205
 206                 wellFormed = ( ctxt->wellFormed == 1 );
 207
 208                 xmlFreeParserCtxt( ctxt );
 209         }
 210
 211         (void) wellFormed;
 212         //return wellFormed;
 213 }
 214 private:
 215 TextInputStream& m_istream;
 216 };
 217
 218
 219
 220 #endif