Author: martinf Date: Tue Aug 1 03:23:19 2006 New Revision: 23398
URL: http://svn.reactos.org/svn/reactos?rev=23398&view=rev Log: IBrowser: update XMLStorage library and remove Expat dependency
Added: trunk/reactos/base/applications/ibrowser/utility/xs-native.cpp (with props) Removed: trunk/reactos/base/applications/ibrowser/expat-license.txt Modified: trunk/reactos/base/applications/ibrowser/Makefile-MinGW trunk/reactos/base/applications/ibrowser/Makefile-precomp trunk/reactos/base/applications/ibrowser/favorites.cpp trunk/reactos/base/applications/ibrowser/ibrowser.dsp trunk/reactos/base/applications/ibrowser/ibrowser.rbuild trunk/reactos/base/applications/ibrowser/make_ibrowser.dsp trunk/reactos/base/applications/ibrowser/utility/xmlstorage.cpp trunk/reactos/base/applications/ibrowser/utility/xmlstorage.h
Modified: trunk/reactos/base/applications/ibrowser/Makefile-MinGW URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/ibrowser/... ============================================================================== --- trunk/reactos/base/applications/ibrowser/Makefile-MinGW (original) +++ trunk/reactos/base/applications/ibrowser/Makefile-MinGW Tue Aug 1 03:23:19 2006 @@ -50,13 +50,14 @@ webchild.o \ mainframe.o \ favorites.o \ + xs-native.o \ xmlstorage.o
LIBS = gdi32 comctl32 shell32 ole32 uuid oleaut32
all: $(TARGET)
-$(TARGET): $(OBJECTS) $(PROGRAM)$(RES_SUFFIX) libexpat.dll +$(TARGET): $(OBJECTS) $(PROGRAM)$(RES_SUFFIX) $(LINK) $(LFLAGS) -o $@ $^ $(addprefix -l,$(LIBS)) $(addprefix -l,$(DELAYIMPORTS))
ibrowser$(RES_SUFFIX): $(PROGRAM)_intres.rc res/*.bmp res/*.ico
Modified: trunk/reactos/base/applications/ibrowser/Makefile-precomp URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/ibrowser/... ============================================================================== --- trunk/reactos/base/applications/ibrowser/Makefile-precomp (original) +++ trunk/reactos/base/applications/ibrowser/Makefile-precomp Tue Aug 1 03:23:19 2006 @@ -52,6 +52,7 @@ webchild.o \ mainframe.o \ favorites.o \ + xs-native.o \ xmlstorage.o
LIBS = gdi32 comctl32 shell32 ole32 oleaut32 uuid @@ -61,7 +62,7 @@ precomp.h.gch: *.h utility/*.h $(CXX) $(CFLAGS) precomp.h
-$(TARGET): $(OBJECTS) $(PROGRAM)$(RES_SUFFIX) libexpat.dll +$(TARGET): $(OBJECTS) $(PROGRAM)$(RES_SUFFIX) $(LINK) $(LFLAGS) -o $@ $^ $(addprefix -l,$(LIBS)) $(addprefix -l,$(DELAYIMPORTS))
ibrowser$(RES_SUFFIX): $(PROGRAM)_intres.rc res/*.bmp res/*.ico
Removed: trunk/reactos/base/applications/ibrowser/expat-license.txt URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/ibrowser/... ============================================================================== --- trunk/reactos/base/applications/ibrowser/expat-license.txt (original) +++ trunk/reactos/base/applications/ibrowser/expat-license.txt (removed) @@ -1,22 +1,0 @@ -Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd - and Clark Cooper -Copyright (c) 2001, 2002, 2003 Expat maintainers. - -Permission is hereby granted, free of charge, to any person obtaining -a copy of this software and associated documentation files (the -"Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sublicense, and/or sell copies of the Software, and to -permit persons to whom the Software is furnished to do so, subject to -the following conditions: - -The above copyright notice and this permission notice shall be included -in all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Modified: trunk/reactos/base/applications/ibrowser/favorites.cpp URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/ibrowser/... ============================================================================== --- trunk/reactos/base/applications/ibrowser/favorites.cpp (original) +++ trunk/reactos/base/applications/ibrowser/favorites.cpp Tue Aug 1 03:23:19 2006 @@ -429,10 +429,10 @@ XMLDoc xbel;
if (!xbel.read(path)) - if (xbel._last_error == XML_ERROR_NO_ELEMENTS) +/*@@ if (xbel._last_error == XML_ERROR_NO_ELEMENTS) return false; - else - MessageBox(0/*@@g_Globals._hwndDesktop*/, String(xbel._last_error_msg.c_str()), + else */ + MessageBox(0/*@@g_Globals._hwndDesktop*/, xbel._errors.str(), TEXT("ROS Explorer - reading bookmark file"), MB_OK);
const_XMLPos pos(&xbel); @@ -457,9 +457,9 @@ super::write(pos); pos.back();
- xbel._header._doctype = "<!DOCTYPE xbel" - " PUBLIC \"+//IDN python.org//DTD XML Bookmark Exchange Language 1.0//EN//XML\"\n" - " \"http://www.python.org/topics/xml/dtds/xbel-1.0.dtd\">"; + xbel._format._doctype._name = "xbel"; + xbel._format._doctype._public = "//IDN python.org//DTD XML Bookmark Exchange Language 1.0//EN//XML"; + xbel._format._doctype._system = "http://www.python.org/topics/xml/dtds/xbel-1.0.dtd";
xbel.write(path); }
Modified: trunk/reactos/base/applications/ibrowser/ibrowser.dsp URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/ibrowser/... ============================================================================== --- trunk/reactos/base/applications/ibrowser/ibrowser.dsp (original) +++ trunk/reactos/base/applications/ibrowser/ibrowser.dsp Tue Aug 1 03:23:19 2006 @@ -28,7 +28,7 @@ # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" -CPP=cl.exe +CPP=cl.cmd RSC=rc.exe
!IF "$(CFG)" == "ibrowser - Win32 Release" @@ -199,6 +199,10 @@
SOURCE=.\utility\xmlstorage.h # End Source File +# Begin Source File + +SOURCE=".\utility\xs-native.cpp" +# End Source File # End Group # Begin Group "resources"
Modified: trunk/reactos/base/applications/ibrowser/ibrowser.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/ibrowser/... ============================================================================== --- trunk/reactos/base/applications/ibrowser/ibrowser.rbuild (original) +++ trunk/reactos/base/applications/ibrowser/ibrowser.rbuild Tue Aug 1 03:23:19 2006 @@ -3,7 +3,6 @@ <module name="ibrowser" type="win32gui" installbase="system32" installname="ibrowser.exe" allowwarnings ="true"> <linkerflag>-fexceptions</linkerflag> <include base="ibrowser">.</include> - <include base="ReactOS">include/expat</include> <define name="__USE_W32API" /> <define name="UNICODE" /> <define name="WIN32" /> @@ -18,12 +17,12 @@ <library>ole32</library> <library>oleaut32</library> <library>shell32</library> - <library>expat</library> <pch>precomp.h</pch> <directory name="utility"> <file>utility.cpp</file> <file>window.cpp</file> <file>xmlstorage.cpp</file> + <file>xs-native.cpp</file> </directory> <file>ibrowser.cpp</file> <file>favorites.cpp</file>
Modified: trunk/reactos/base/applications/ibrowser/make_ibrowser.dsp URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/ibrowser/... ============================================================================== --- trunk/reactos/base/applications/ibrowser/make_ibrowser.dsp (original) +++ trunk/reactos/base/applications/ibrowser/make_ibrowser.dsp Tue Aug 1 03:23:19 2006 @@ -4,7 +4,7 @@
# TARGTYPE "Win32 (x86) External Target" 0x0106
-CFG=make_ibrowser - Win32 bjam +CFG=make_ibrowser - Win32 Release !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE @@ -13,7 +13,7 @@ !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE -!MESSAGE NMAKE /f "make_ibrowser.mak" CFG="make_ibrowser - Win32 bjam" +!MESSAGE NMAKE /f "make_ibrowser.mak" CFG="make_ibrowser - Win32 Release" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE @@ -43,7 +43,7 @@ # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" -# PROP Cmd_Line "msdevfilt -gcc -pipe "perl d:\tools\gSTLFilt.pl" make -f Makefile-precomp UNICODE=0" +# PROP Cmd_Line "msdevfilt -gcc -pipe "perl d:\tools\gSTLFilt.pl" mingw32-make -f Makefile-precomp UNICODE=0" # PROP Rebuild_Opt "clean all" # PROP Target_File "ibrowser.exe" # PROP Bsc_Name "" @@ -64,7 +64,7 @@ # PROP Use_Debug_Libraries 1 # PROP Output_Dir "Debug" # PROP Intermediate_Dir "Debug" -# PROP Cmd_Line "msdevfilt -gcc -pipe "perl d:\tools\gSTLFilt.pl" make -f Makefile-precomp UNICODE=0 DEBUG=1" +# PROP Cmd_Line "msdevfilt -gcc -pipe "perl d:\tools\gSTLFilt.pl" mingw32-make -f Makefile-precomp UNICODE=0 DEBUG=1" # PROP Rebuild_Opt "clean all" # PROP Target_File "ibrowser.exe" # PROP Bsc_Name "msdevfilt -gcc -pipe "perl d:\tools\gSTLFilt.pl" make -f Makefile.MinGW UNICODE=0 DEBUG=1" @@ -85,7 +85,7 @@ # PROP Use_Debug_Libraries 1 # PROP Output_Dir "UDebug" # PROP Intermediate_Dir "UDebug" -# PROP Cmd_Line "msdevfilt -gcc -pipe "perl d:\tools\gSTLFilt.pl" make -f Makefile.MinGW UNICODE=1 DEBUG=1" +# PROP Cmd_Line "msdevfilt -gcc -pipe "perl d:\tools\gSTLFilt.pl" mingw32-make -f Makefile.MinGW UNICODE=1 DEBUG=1" # PROP Rebuild_Opt "clean all" # PROP Target_File "ibrowser.exe" # PROP Bsc_Name "" @@ -106,7 +106,7 @@ # PROP Use_Debug_Libraries 0 # PROP Output_Dir "URelease" # PROP Intermediate_Dir "URelease" -# PROP Cmd_Line "msdevfilt -gcc make -f Makefile-precomp UNICODE=1" +# PROP Cmd_Line "msdevfilt -gcc mingw32-make -f Makefile-precomp UNICODE=1" # PROP Rebuild_Opt "clean all" # PROP Target_File "ibrowser.exe" # PROP Bsc_Name ""
Modified: trunk/reactos/base/applications/ibrowser/utility/xmlstorage.cpp URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/ibrowser/... ============================================================================== --- trunk/reactos/base/applications/ibrowser/utility/xmlstorage.cpp (original) +++ trunk/reactos/base/applications/ibrowser/utility/xmlstorage.cpp Tue Aug 1 03:23:19 2006 @@ -4,7 +4,7 @@ // // xmlstorage.cpp // - // Copyright (c) 2004, 2005 Martin Fuchs martin-fuchs@gmx.net + // Copyright (c) 2004, 2005, 2006 Martin Fuchs martin-fuchs@gmx.net //
@@ -36,22 +36,29 @@
*/
+#ifndef XS_NO_COMMENT +#define XS_NO_COMMENT // no #pragma comment(lib, ...) statements in .lib files +#endif + //#include "xmlstorage.h" #include <precomp.h>
// work around GCC's wide string constant bug #ifdef __GNUC__ -const LPCXSSTR XMLStorage::XS_TRUE = XS_TEXT("true"); -const LPCXSSTR XMLStorage::XS_FALSE = XS_TEXT("false"); -const LPCXSSTR XMLStorage::XS_NUMBERFMT = XS_TEXT("%d"); +const LPCXSSTR XMLStorage::XS_EMPTY = XS_EMPTY_STR; +const LPCXSSTR XMLStorage::XS_TRUE = XS_TRUE_STR; +const LPCXSSTR XMLStorage::XS_FALSE = XS_FALSE_STR; +const LPCXSSTR XMLStorage::XS_INTFMT = XS_INTFMT_STR; +const LPCXSSTR XMLStorage::XS_FLOATFMT = XS_FLOATFMT_STR; #endif
namespace XMLStorage {
-static std::string unescape(const char* s, char b='"', char e='"') + /// remove escape characters from zero terminated string +static std::string unescape(const char* s, char b, char e) { const char* end = s + strlen(s);
@@ -68,7 +75,13 @@ return std::string(s, end-s); }
-static std::string unescape(const char* s, int l, char b='"', char e='"') +inline std::string unescape(const char* s) +{ + return unescape(s, '"', '"'); +} + + /// remove escape characters from string with specified length +static std::string unescape(const char* s, size_t l, char b, char e) { const char* end = s + l;
@@ -85,6 +98,11 @@ return std::string(s, end-s); }
+inline std::string unescape(const char* s, size_t l) +{ + return unescape(s, l, '"', '"'); +} +
/// move XPath like to position in XML tree bool XMLPos::go(const char* path) @@ -137,7 +155,7 @@ if (slash == path) return NULL;
- int l = slash? slash-path: strlen(path); + size_t l = slash? slash-path: strlen(path); std::string comp(path, l); path += l;
@@ -198,7 +216,7 @@ if (slash == path) return NULL;
- int l = slash? slash-path: strlen(path); + size_t l = slash? slash-path: strlen(path); std::string comp(path, l); path += l;
@@ -259,239 +277,113 @@ }
- /// read XML stream into XML tree below _pos -XML_Status XMLReaderBase::read() -{ - XML_Status status = XML_STATUS_OK; - - while(status == XML_STATUS_OK) { - char* buffer = (char*) XML_GetBuffer(_parser, BUFFER_LEN); - - int l = read_buffer(buffer, BUFFER_LEN); - if (l < 0) - break; - - status = XML_ParseBuffer(_parser, l, false); + /// encode XML string literals +std::string EncodeXMLString(const XS_String& str) +{ + LPCXSSTR s = str.c_str(); + size_t l = XS_len(s); + + if (l <= BUFFER_LEN) { + LPXSSTR buffer = (LPXSSTR)alloca(6*sizeof(XS_CHAR)*XS_len(s)); // worst case """ / "'" + LPXSSTR o = buffer; + + for(LPCXSSTR p=s; *p; ++p) + switch(*p) { + case '&': + *o++ = '&'; *o++ = 'a'; *o++ = 'm'; *o++ = 'p'; *o++ = ';'; + break; + + case '<': + *o++ = '&'; *o++ = 'l'; *o++ = 't'; *o++ = ';'; + break; + + case '>': + *o++ = '&'; *o++ = 'g'; *o++ = 't'; *o++ = ';'; + break; + + case '"': + *o++ = '&'; *o++ = 'q'; *o++ = 'u'; *o++ = 'o'; *o++ = 't'; *o++ = ';'; + break; + + case ''': + *o++ = '&'; *o++ = 'a'; *o++ = 'p'; *o++ = 'o'; *o++ = 's'; *o++ = ';'; + break; + + default: + if ((unsigned)*p<20 && *p!='\t' && *p!='\r' && *p!='\n') { + char b[16]; + sprintf(b, "&%d;", (unsigned)*p); + for(const char*q=b; *q; ) + *o++ = *q++; + } else + *o++ = *p; + } + +#ifdef XS_STRING_UTF8 + return XS_String(buffer, o-buffer); +#else + return get_utf8(buffer, o-buffer); +#endif + } else { // l > BUFFER_LEN + // encode the whole string in a CDATA section + std::string ret = "<![CDATA["; + +#ifdef XS_STRING_UTF8 + ret += str; +#else + ret += get_utf8(str); +#endif + + ret += "]]>"; + + return ret; + +/* alternative code using ostringstream (beware: quite slow) +#include <sstream> + + std::ostringstream out; + + LPCXSSTR s = str.c_str(); + + for(LPCXSSTR p=s; *p; ++p) + switch(*p) { + case '&': + out << "&"; + break; + + case '<': + out << "<"; + break; + + case '>': + out << ">"; + break; + + case '"': + out << """; + break; + + case ''': + out << "'"; + break; + + default: + if ((unsigned)*p<20 && *p!='\t' *p!='\r' && *p!='\n') + out << "&" << (unsigned)*p << ";"; + else + out << *p; + } + +#ifdef XS_STRING_UTF8 + return XS_String(out.str()); +#else + return get_utf8(out.str()); +#endif + */ } - - if (status != XML_STATUS_ERROR) - status = XML_ParseBuffer(_parser, 0, true); - - if (_pos->_children.empty()) - _pos->_trailing.append(_content); - else - _pos->_children.back()->_trailing.append(_content); - - _content.erase(); - - return status; -} - - - /// store XML version and encoding into XML reader -void XMLCALL XMLReaderBase::XML_XmlDeclHandler(void* userData, const XML_Char* version, const XML_Char* encoding, int standalone) -{ - XMLReaderBase* pReader = (XMLReaderBase*) userData; - - if (version) - pReader->_xml_version = version; - - if (encoding) - pReader->_encoding = encoding; -} - - /// notifications about XML start tag -void XMLCALL XMLReaderBase::XML_StartElementHandler(void* userData, const XML_Char* name, const XML_Char** atts) -{ - XMLReaderBase* pReader = (XMLReaderBase*) userData; - XMLPos& pos = pReader->_pos; - - // search for end of first line - const char* s = pReader->_content.c_str(); - const char* p = s; - const char* e = p + pReader->_content.length(); - - for(; p<e; ++p) - if (*p == '\n') { - ++p; - break; - } - - if (p != s) - if (pos->_children.empty()) { // no children in last node? - if (pReader->_last_tag == TAG_START) - pos->_content.append(s, p-s); - else if (pReader->_last_tag == TAG_END) - pos->_trailing.append(s, p-s); - // else TAG_NONE -> don't store white space in root node - } else - pos->_children.back()->_trailing.append(s, p-s); - - std::string leading; - - if (p != e) - leading.assign(p, e-p); - - XMLNode* node = new XMLNode(String_from_XML_Char(name), leading); - - pos.add_down(node); - - while(*atts) { - const XML_Char* attr_name = *atts++; - const XML_Char* attr_value = *atts++; - - (*node)[String_from_XML_Char(attr_name)] = String_from_XML_Char(attr_value); - } - - pReader->_last_tag = TAG_START; - pReader->_content.erase(); -} - - /// notifications about XML end tag -void XMLCALL XMLReaderBase::XML_EndElementHandler(void* userData, const XML_Char* name) -{ - XMLReaderBase* pReader = (XMLReaderBase*) userData; - XMLPos& pos = pReader->_pos; - - // search for end of first line - const char* s = pReader->_content.c_str(); - const char* p = s; - const char* e = p + pReader->_content.length(); - - for(; p<e; ++p) - if (*p == '\n') { - ++p; - break; - } - - if (p != s) - if (pos->_children.empty()) // no children in current node? - pos->_content.append(s, p-s); - else - if (pReader->_last_tag == TAG_START) - pos->_content.append(s, p-s); - else - pos->_children.back()->_trailing.append(s, p-s); - - if (p != e) - pos->_end_leading.assign(p, e-p); - - pos.back(); - - pReader->_last_tag = TAG_END; - pReader->_content.erase(); -} - - /// store content, white space and comments -void XMLCALL XMLReaderBase::XML_DefaultHandler(void* userData, const XML_Char* s, int len) -{ - XMLReaderBase* pReader = (XMLReaderBase*) userData; - - pReader->_content.append(s, len); -} - - -std::string XMLReaderBase::get_error_string() const -{ - XML_Error error = XML_GetErrorCode(_parser); - - switch(error) { - case XML_ERROR_NONE: return "XML_ERROR_NONE"; - case XML_ERROR_NO_MEMORY: return "XML_ERROR_NO_MEMORY"; - case XML_ERROR_SYNTAX: return "XML_ERROR_SYNTAX"; - case XML_ERROR_NO_ELEMENTS: return "XML_ERROR_NO_ELEMENTS"; - case XML_ERROR_INVALID_TOKEN: return "XML_ERROR_INVALID_TOKEN"; - case XML_ERROR_UNCLOSED_TOKEN: return "XML_ERROR_UNCLOSED_TOKEN"; - case XML_ERROR_PARTIAL_CHAR: return "XML_ERROR_PARTIAL_CHAR"; - case XML_ERROR_TAG_MISMATCH: return "XML_ERROR_TAG_MISMATCH"; - case XML_ERROR_DUPLICATE_ATTRIBUTE: return "XML_ERROR_DUPLICATE_ATTRIBUTE"; - case XML_ERROR_JUNK_AFTER_DOC_ELEMENT: return "XML_ERROR_JUNK_AFTER_DOC_ELEMENT"; - case XML_ERROR_PARAM_ENTITY_REF: return "XML_ERROR_PARAM_ENTITY_REF"; - case XML_ERROR_UNDEFINED_ENTITY: return "XML_ERROR_UNDEFINED_ENTITY"; - case XML_ERROR_RECURSIVE_ENTITY_REF: return "XML_ERROR_RECURSIVE_ENTITY_REF"; - case XML_ERROR_ASYNC_ENTITY: return "XML_ERROR_ASYNC_ENTITY"; - case XML_ERROR_BAD_CHAR_REF: return "XML_ERROR_BAD_CHAR_REF"; - case XML_ERROR_BINARY_ENTITY_REF: return "XML_ERROR_BINARY_ENTITY_REF"; - case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF: return "XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF"; - case XML_ERROR_MISPLACED_XML_PI: return "XML_ERROR_MISPLACED_XML_PI"; - case XML_ERROR_UNKNOWN_ENCODING: return "XML_ERROR_UNKNOWN_ENCODING"; - case XML_ERROR_INCORRECT_ENCODING: return "XML_ERROR_INCORRECT_ENCODING"; - case XML_ERROR_UNCLOSED_CDATA_SECTION: return "XML_ERROR_UNCLOSED_CDATA_SECTION"; - case XML_ERROR_EXTERNAL_ENTITY_HANDLING: return "XML_ERROR_EXTERNAL_ENTITY_HANDLING"; - case XML_ERROR_NOT_STANDALONE: return "XML_ERROR_NOT_STANDALONE"; - case XML_ERROR_UNEXPECTED_STATE: return "XML_ERROR_UNEXPECTED_STATE"; - case XML_ERROR_ENTITY_DECLARED_IN_PE: return "XML_ERROR_ENTITY_DECLARED_IN_PE"; - case XML_ERROR_FEATURE_REQUIRES_XML_DTD: return "XML_ERROR_FEATURE_REQUIRES_XML_DTD"; - case XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING: return "XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING"; - case XML_ERROR_UNBOUND_PREFIX: return "XML_ERROR_UNBOUND_PREFIX"; - // EXPAT version >= 1.95.8 -#if XML_MAJOR_VERSION>1 || (XML_MAJOR_VERSION==1 && XML_MINOR_VERSION>95) || (XML_MAJOR_VERSION==1 && XML_MINOR_VERSION==95 && XML_MICRO_VERSION>7) - case XML_ERROR_UNDECLARING_PREFIX: return "XML_ERROR_UNDECLARING_PREFIX"; - case XML_ERROR_INCOMPLETE_PE: return "XML_ERROR_INCOMPLETE_PE"; - case XML_ERROR_XML_DECL: return "XML_ERROR_XML_DECL"; - case XML_ERROR_TEXT_DECL: return "XML_ERROR_TEXT_DECL"; - case XML_ERROR_PUBLICID: return "XML_ERROR_PUBLICID"; - case XML_ERROR_SUSPENDED: return "XML_ERROR_SUSPENDED"; - case XML_ERROR_NOT_SUSPENDED: return "XML_ERROR_NOT_SUSPENDED"; - case XML_ERROR_ABORTED: return "XML_ERROR_ABORTED"; - case XML_ERROR_FINISHED: return "XML_ERROR_FINISHED"; - case XML_ERROR_SUSPEND_PE: return "XML_ERROR_SUSPEND_PE"; -//#endif -//#if XML_MAJOR_VERSION>=2 - /* Added in 2.0. */ - case XML_ERROR_RESERVED_PREFIX_XML: return "XML_ERROR_RESERVED_PREFIX_XML"; - case XML_ERROR_RESERVED_PREFIX_XMLNS: return "XML_ERROR_RESERVED_PREFIX_XMLNS"; - case XML_ERROR_RESERVED_NAMESPACE_URI: return "XML_ERROR_RESERVED_NAMESPACE_URI"; -#endif - } - - std::ostringstream out; - - out << "XML parser error #" << error; - - return out.str(); -} - - -std::string EncodeXMLString(const XS_String& str) -{ - LPCXSSTR s = str.c_str(); - LPXSSTR buffer = (LPXSSTR)alloca(5*sizeof(XS_CHAR)*XS_len(s)); // worst case. "&" - LPXSSTR o = buffer; - - for(LPCXSSTR p=s; *p; ++p) - switch(*p) { - case '&': - *o++ = '&'; *o++ = 'a'; *o++ = 'm'; *o++ = 'p'; *o++ = ';'; - break; - - case '<': - *o++ = '&'; *o++ = 'l'; *o++ = 't'; *o++ = ';'; - break; - - case '>': - *o++ = '&'; *o++ = 'g'; *o++ = 't'; *o++ = ';'; - break; - - case '"': - *o++ = '&'; *o++ = 'q'; *o++ = 'u'; *o++ = 'o'; *o++ = 't'; *o++ = ';'; - break; - - case ''': - *o++ = '&'; *o++ = 'a'; *o++ = 'p'; *o++ = 'o'; *o++ = 's'; *o++ = ';'; - break; - - default: - *o++ = *p; - } - -#ifdef XS_STRING_UTF8 - return XS_String(buffer, o-buffer); -#else - return get_utf8(buffer, o-buffer); -#endif -} - +} + + /// decode XML string literals XS_String DecodeXMLString(const XS_String& str) { LPCXSSTR s = str.c_str(); @@ -517,6 +409,16 @@ p += 5; } else *o++ = *p; + } else if (*p=='<' && !XS_nicmp(p+1,XS_TEXT("!CDATA["),7)) { + p += 9; + LPCXSSTR e = XS_strstr(p, XS_TEXT("]]>")); + if (e) { + size_t l = e - p; + memcpy(o, p, l); + o += l; + p += 3; + } else + *o++ = *p; } else *o++ = *p;
@@ -546,8 +448,28 @@ }
+ /// print node without any white space +void XMLNode::plain_write_worker(std::ostream& out) const +{ + out << '<' << EncodeXMLString(*this); + + for(AttributeMap::const_iterator it=_attributes.begin(); it!=_attributes.end(); ++it) + out << ' ' << EncodeXMLString(it->first) << "="" << EncodeXMLString(it->second) << """; + + if (!_children.empty()/*@@ || !_content.empty()*/) { + out << ">"; + + for(Children::const_iterator it=_children.begin(); it!=_children.end(); ++it) + (*it)->plain_write_worker(out); + + out << "</" << EncodeXMLString(*this) << ">"; + } else + out << "/>"; +} + + /// pretty print node with children tree to output stream -void XMLNode::pretty_write_worker(std::ostream& out, int indent) const +void XMLNode::pretty_write_worker(std::ostream& out, const XMLFormat& format, int indent) const { for(int i=indent; i--; ) out << XML_INDENT_SPACE; @@ -557,23 +479,23 @@ for(AttributeMap::const_iterator it=_attributes.begin(); it!=_attributes.end(); ++it) out << ' ' << EncodeXMLString(it->first) << "="" << EncodeXMLString(it->second) << """;
- if (!_children.empty() || !_content.empty()) { - out << ">\n"; + if (!_children.empty()/*@@ || !_content.empty()*/) { + out << '>' << format._endl;
for(Children::const_iterator it=_children.begin(); it!=_children.end(); ++it) - (*it)->pretty_write_worker(out, indent+1); + (*it)->pretty_write_worker(out, format, indent+1);
for(int i=indent; i--; ) out << XML_INDENT_SPACE;
- out << "</" << EncodeXMLString(*this) << ">\n"; + out << "</" << EncodeXMLString(*this) << '>' << format._endl; } else - out << "/>\n"; + out << "/>" << format._endl; }
/// write node with children tree to output stream using smart formating -void XMLNode::smart_write_worker(std::ostream& out, int indent) const +void XMLNode::smart_write_worker(std::ostream& out, const XMLFormat& format, int indent) const { if (_leading.empty()) for(int i=indent; i--; ) @@ -592,7 +514,7 @@ out << '>';
if (_content.empty()) - out << '\n'; + out << format._endl; else out << _content;
@@ -600,7 +522,7 @@
if (it != _children.end()) { for(; it!=_children.end(); ++it) - (*it)->smart_write_worker(out, indent+1); + (*it)->smart_write_worker(out, format, indent+1);
if (_end_leading.empty()) for(int i=indent; i--; ) @@ -614,10 +536,269 @@ }
if (_trailing.empty()) - out << '\n'; + out << format._endl; else out << _trailing; }
+std::ostream& operator<<(std::ostream& out, const XMLError& err) +{ + out << err._systemId << "(" << err._line << ") [column " << err._column << "] : " + << err._message; + + return out; +} + + +void DocType::parse(const char* p) +{ + while(isspace((unsigned char)*p)) ++p; + + const char* start = p; + while(isxmlsym(*p)) ++p; + _name.assign(start, p-start); + + while(isspace((unsigned char)*p)) ++p; + + start = p; + while(isxmlsym(*p)) ++p; + std::string keyword(p, p-start); // "PUBLIC" or "SYSTEM" + + while(isspace((unsigned char)*p)) ++p; + + if (*p=='"' || *p==''') { + char delim = *p; + + start = ++p; + while(*p && *p!=delim) ++p; + + if (*p == delim) + _public.assign(start, p++-start); + } else + _public.erase(); + + while(isspace((unsigned char)*p)) ++p; + + if (*p=='"' || *p==''') { + char delim = *p; + + start = ++p; + while(*p && *p!=delim) ++p; + + if (*p == delim) + _system.assign(start, p++-start); + } else + _system.erase(); +} + + + +void XMLFormat::print_header(std::ostream& out, bool lf) const +{ + out << "<?xml version=\"" << _version << "\" encoding=\"" << _encoding << "\""; + + if (_standalone != -1) + out << " standalone=\"yes\""; + + out << "?>"; + + if (lf) + out << _endl; + + if (!_doctype.empty()) { + out << "<!DOCTYPE " << _doctype._name; + + if (!_doctype._public.empty()) { + out << " PUBLIC " << _doctype._public; + + if (lf) + out << _endl; + + out << " " << _doctype._system; + } else if (!_doctype._system.empty()) + out << " SYSTEM " << _doctype._system; + + out << "?>"; + + if (lf) + out << _endl; + } + + for(StyleSheetList::const_iterator it=_stylesheets.begin(); it!=_stylesheets.end(); ++it) { + it->print(out); + + if (lf) + out << _endl; + } + +/* if (!_additional.empty()) { + out << _additional; + + if (lf) + out << _endl; + } */ +} + +void StyleSheet::print(std::ostream& out) const +{ + out << "<?xml-stylesheet" + " href=\"" << _href << "\"" + " type=\"" << _type << "\""; + + if (!_title.empty()) + out << " title=\"" << _title << "\""; + + if (!_media.empty()) + out << " media=\"" << _media << "\""; + + if (!_charset.empty()) + out << " charset=\"" << _charset << "\""; + + if (_alternate) + out << " alternate=\"yes\""; + + out << "?>"; +} + + + /// return formated error message +std::string XMLError::str() const +{ + std::ostringstream out; + + out << *this; + + return out.str(); +} + + + /// return merged error strings +XS_String XMLErrorList::str() const +{ + std::ostringstream out; + + for(const_iterator it=begin(); it!=end(); ++it) + out << *it << std::endl; + + return out.str(); +} + + +void XMLReaderBase::finish_read() +{ + if (_pos->_children.empty()) + _pos->_trailing.append(_content); + else + _pos->_children.back()->_trailing.append(_content); + + _content.erase(); +} + + + /// store XML version and encoding into XML reader +void XMLReaderBase::XmlDeclHandler(const char* version, const char* encoding, int standalone) +{ + if (version) + _format._version = version; + + if (encoding) + _format._encoding = encoding; + + _format._standalone = standalone; +} + + + /// notifications about XML start tag +void XMLReaderBase::StartElementHandler(const XS_String& name, const XMLNode::AttributeMap& attributes) +{ + // search for end of first line + const char* s = _content.c_str(); + const char* p = s; + const char* e = p + _content.length(); + + for(; p<e; ++p) + if (*p == '\n') { + ++p; + break; + } + + if (p != s) + if (_pos->_children.empty()) { // no children in last node? + if (_last_tag == TAG_START) + _pos->_content.append(s, p-s); + else if (_last_tag == TAG_END) + _pos->_trailing.append(s, p-s); + else // TAG_NONE at root node + p = s; + } else + _pos->_children.back()->_trailing.append(s, p-s); + + std::string leading; + + if (p != e) + leading.assign(p, e-p); + + XMLNode* node = new XMLNode(name, leading); + + _pos.add_down(node); + +#ifdef XMLNODE_LOCATION + node->_location = get_location(); +#endif + + node->_attributes = attributes; + + _last_tag = TAG_START; + _content.erase(); +} + + /// notifications about XML end tag +void XMLReaderBase::EndElementHandler() +{ + // search for end of first line + const char* s = _content.c_str(); + const char* p = s; + const char* e = p + _content.length(); + + for(; p<e; ++p) + if (*p == '\n') { + ++p; + break; + } + + if (p != s) + if (_pos->_children.empty()) // no children in current node? + _pos->_content.append(s, p-s); + else + if (_last_tag == TAG_START) + _pos->_content.append(s, p-s); + else + _pos->_children.back()->_trailing.append(s, p-s); + + if (p != e) + _pos->_end_leading.assign(p, e-p); + + _pos.back(); + + _last_tag = TAG_END; + _content.erase(); +} + +#if defined(XS_USE_XERCES) || defined(XS_USE_EXPAT) + /// store content, white space and comments +void XMLReaderBase::DefaultHandler(const XML_Char* s, int len) +{ +#if defined(XML_UNICODE) || defined(XS_USE_XERCES) + _content.append(String_from_XML_Char(s, len)); +#else + _content.append(s, len); +#endif +} +#endif + + +XS_String XMLWriter::s_empty_attr; + + } // namespace XMLStorage
Modified: trunk/reactos/base/applications/ibrowser/utility/xmlstorage.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/ibrowser/... ============================================================================== --- trunk/reactos/base/applications/ibrowser/utility/xmlstorage.h (original) +++ trunk/reactos/base/applications/ibrowser/utility/xmlstorage.h Tue Aug 1 03:23:19 2006 @@ -4,7 +4,7 @@ // // xmlstorage.h // - // Copyright (c) 2004, 2005 Martin Fuchs martin-fuchs@gmx.net + // Copyright (c) 2004, 2005, 2006 Martin Fuchs martin-fuchs@gmx.net //
@@ -38,19 +38,107 @@
#ifndef _XMLSTORAGE_H
+ +#if _MSC_VER>=1400 +#ifndef _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES +#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1 +#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT 1 +#define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES 1 +#endif +#endif + + +#ifdef XS_USE_XERCES + +#ifndef UNICODE +#ifndef XS_STRING_UTF8 +#define XS_STRING_UTF8 +#endif +#endif + +#include <xercesc/parsers/SAXParser.hpp> +#include <xercesc/sax/HandlerBase.hpp> + +using XERCES_CPP_NAMESPACE_QUALIFIER Locator; +using XERCES_CPP_NAMESPACE_QUALIFIER SAXParser; +using XERCES_CPP_NAMESPACE_QUALIFIER HandlerBase; +using XERCES_CPP_NAMESPACE_QUALIFIER InputSource; +using XERCES_CPP_NAMESPACE_QUALIFIER AttributeList; +using XERCES_CPP_NAMESPACE_QUALIFIER SAXParseException; + +typedef XMLCh XML_Char; + +#elif defined(XS_USE_EXPAT) + #include <expat/expat.h>
+#endif + + #ifdef _MSC_VER -#pragma comment(lib, "libexpat.lib") #pragma warning(disable: 4786) -#endif - + +#ifndef XS_NO_COMMENT + +#ifdef XS_USE_XERCES +#ifdef _DEBUG +#pragma comment(lib, "xerces-c_2D") +#else +#pragma comment(lib, "xerces-c_2") +#endif +#elif defined(XS_USE_EXPAT) +#ifdef XML_STATIC +#ifndef _DEBUG +#pragma comment(lib, "libexpatMT") +#endif +#else +#pragma comment(lib, "libexpat") +#endif +#endif + +#ifndef _STRING_DEFINED // _STRING_DEFINED only allowed if using xmlstorage.cpp embedded in the project +#if defined(_DEBUG) && defined(_DLL) // DEBUG version only supported with MSVCRTD +#if _MSC_VER==1400 +#pragma comment(lib, "xmlstorage-vc8d") +#else +#pragma comment(lib, "xmlstorage-vc6d") +#endif +#else +#ifdef _DLL +#if _MSC_VER==1400 +#pragma comment(lib, "xmlstorage-vc8") +#else +#pragma comment(lib, "xmlstorage-vc6") +#endif +#elif defined(_MT) +#if _MSC_VER==1400 +#pragma comment(lib, "xmlstorage-vc8t") +#else +#pragma comment(lib, "xmlstorage-vc6t") +#endif +#else + // -ML is no more supported by VS2005. +#pragma comment(lib, "xmlstorage-vc6l") +#endif +#endif +#endif // _STRING_DEFINED + +#endif // XS_NO_COMMENT + +#endif // _MSC_VER + + +#ifdef UNICODE +#ifndef _UNICODE +#define _UNICODE +#endif +#else +#ifdef _UNICODE +#define UNICODE +#endif +#endif
#include <windows.h> // for LPCTSTR - -#ifdef UNICODE -#define _UNICODE -#endif
#include <tchar.h> #include <malloc.h> @@ -78,24 +166,47 @@ #define XS_TEXT(x) x #define LPXSSTR LPSTR #define LPCXSSTR LPCSTR +#define XS_cmp strcmp #define XS_icmp stricmp +#define XS_ncmp strncmp #define XS_nicmp strnicmp #define XS_toi atoi +#define XS_tod strtod #define XS_len strlen -#define XS_sprintf sprintf -#define XS_vsprintf vsprintf +#define XS_snprintf _snprintf +#define XS_vsnprintf _vsnprintf +#define XS_strstr strstr #else #define XS_CHAR TCHAR #define XS_TEXT(x) TEXT(x) #define LPXSSTR LPTSTR #define LPCXSSTR LPCTSTR +#define XS_cmp _tcscmp #define XS_icmp _tcsicmp +#define XS_ncmp _tcsncmp #define XS_nicmp _tcsnicmp #define XS_toi _ttoi +#define XS_tod _tcstod #define XS_len _tcslen -#define XS_sprintf _stprintf -#define XS_vsprintf _vstprintf -#endif +#define XS_snprintf _sntprintf +#define XS_vsnprintf _vsntprintf +#define XS_strstr _tcsstr +#endif + +#ifndef COUNTOF +#if _MSC_VER>=1400 +#define COUNTOF _countof +#else +#define COUNTOF(b) (sizeof(b)/sizeof(b[0])) +#endif +#endif + + +int inline isxmlsym(unsigned char c) +{ + return isalnum(c) || c=='_' || c=='-'; +} +
#if defined(_STRING_DEFINED) && !defined(XS_STRING_UTF8)
@@ -121,46 +232,46 @@ XS_String() {}
XS_String(LPCXSSTR s) {if (s) super::assign(s);} - XS_String(LPCXSSTR s, int l) : super(s, l) {} + XS_String(LPCXSSTR s, size_t l) : super(s, l) {}
XS_String(const super& other) : super(other) {} XS_String(const XS_String& other) : super(other) {}
#if defined(UNICODE) && !defined(XS_STRING_UTF8) XS_String(LPCSTR s) {assign(s);} - XS_String(LPCSTR s, int l) {assign(s, l);} + XS_String(LPCSTR s, size_t l) {assign(s, l);} XS_String(const std::string& other) {assign(other.c_str());} XS_String& operator=(LPCSTR s) {assign(s); return *this;} - void assign(LPCSTR s) {if (s) {int bl=strlen(s); LPWSTR b=(LPWSTR)alloca(sizeof(WCHAR)*bl); super::assign(b, MultiByteToWideChar(CP_ACP, 0, s, bl, b, bl));} else erase();} - void assign(LPCSTR s, int l) {if (s) {int bl=l; LPWSTR b=(LPWSTR)alloca(sizeof(WCHAR)*bl); super::assign(b, MultiByteToWideChar(CP_ACP, 0, s, l, b, bl));} else erase();} + void assign(LPCSTR s) {if (s) {size_t bl=strlen(s); LPWSTR b=(LPWSTR)alloca(sizeof(WCHAR)*bl); super::assign(b, MultiByteToWideChar(CP_ACP, 0, s, bl, b, bl));} else erase();} + void assign(LPCSTR s, size_t l) {if (s) {size_t bl=l; LPWSTR b=(LPWSTR)alloca(sizeof(WCHAR)*bl); super::assign(b, MultiByteToWideChar(CP_ACP, 0, s, l, b, bl));} else erase();} #else XS_String(LPCWSTR s) {assign(s);} - XS_String(LPCWSTR s, int l) {assign(s, l);} + XS_String(LPCWSTR s, size_t l) {assign(s, l);} XS_String(const std::wstring& other) {assign(other.c_str());} XS_String& operator=(LPCWSTR s) {assign(s); return *this;} #ifdef XS_STRING_UTF8 void assign(const XS_String& s) {assign(s.c_str());} - void assign(LPCWSTR s) {if (s) {int bl=wcslen(s); LPSTR b=(LPSTR)alloca(bl); super::assign(b, WideCharToMultiByte(CP_UTF8, 0, s, bl, b, bl, 0, 0));} else erase();} - void assign(LPCWSTR s, int l) {int bl=l; if (s) {LPSTR b=(LPSTR)alloca(bl); super::assign(b, WideCharToMultiByte(CP_UTF8, 0, s, l, b, bl, 0, 0));} else erase();} + void assign(LPCWSTR s) {if (s) {size_t bl=wcslen(s); LPSTR b=(LPSTR)alloca(bl); super::assign(b, WideCharToMultiByte(CP_UTF8, 0, s, (int)bl, b, (int)bl, 0, 0));} else erase();} + void assign(LPCWSTR s, size_t l) {size_t bl=l; if (s) {LPSTR b=(LPSTR)alloca(bl); super::assign(b, WideCharToMultiByte(CP_UTF8, 0, s, (int)l, b, (int)bl, 0, 0));} else erase();} #else // if !UNICODE && !XS_STRING_UTF8 - void assign(LPCWSTR s) {if (s) {int bl=wcslen(s); LPSTR b=(LPSTR)alloca(bl); super::assign(b, WideCharToMultiByte(CP_ACP, 0, s, bl, b, bl, 0, 0));} else erase();} - void assign(LPCWSTR s, int l) {int bl=l; if (s) {LPSTR b=(LPSTR)alloca(bl); super::assign(b, WideCharToMultiByte(CP_ACP, 0, s, l, b, bl, 0, 0));} else erase();} + void assign(LPCWSTR s) {if (s) {size_t bl=wcslen(s); LPSTR b=(LPSTR)alloca(bl); super::assign(b, WideCharToMultiByte(CP_ACP, 0, s, (int)bl, b, (int)bl, 0, 0));} else erase();} + void assign(LPCWSTR s, size_t l) {size_t bl=l; if (s) {LPSTR b=(LPSTR)alloca(bl); super::assign(b, WideCharToMultiByte(CP_ACP, 0, s, (int)l, b, (int)bl, 0, 0));} else erase();} #endif #endif
XS_String& operator=(LPCXSSTR s) {if (s) super::assign(s); else erase(); return *this;} XS_String& operator=(const super& s) {super::assign(s); return *this;} void assign(LPCXSSTR s) {super::assign(s);} - void assign(LPCXSSTR s, int l) {super::assign(s, l);} + void assign(LPCXSSTR s, size_t l) {super::assign(s, l);}
operator LPCXSSTR() const {return c_str();}
#ifdef XS_STRING_UTF8 - operator std::wstring() const {int bl=length(); LPWSTR b=(LPWSTR)alloca(sizeof(WCHAR)*bl); return std::wstring(b, MultiByteToWideChar(CP_UTF8, 0, c_str(), bl, b, bl));} + operator std::wstring() const {size_t bl=length(); LPWSTR b=(LPWSTR)alloca(sizeof(WCHAR)*bl); return std::wstring(b, MultiByteToWideChar(CP_UTF8, 0, c_str(), bl, b, bl));} #elif defined(UNICODE) - operator std::string() const {int bl=length(); LPSTR b=(LPSTR)alloca(bl); return std::string(b, WideCharToMultiByte(CP_ACP, 0, c_str(), bl, b, bl, 0, 0));} -#else - operator std::wstring() const {int bl=length(); LPWSTR b=(LPWSTR)alloca(sizeof(WCHAR)*bl); return std::wstring(b, MultiByteToWideChar(CP_ACP, 0, c_str(), bl, b, bl));} + operator std::string() const {size_t bl=length(); LPSTR b=(LPSTR)alloca(bl); return std::string(b, WideCharToMultiByte(CP_ACP, 0, c_str(), bl, b, bl, 0, 0));} +#else + operator std::wstring() const {size_t bl=length(); LPWSTR b=(LPWSTR)alloca(sizeof(WCHAR)*bl); return std::wstring(b, MultiByteToWideChar(CP_ACP, 0, c_str(), (int)bl, b, (int)bl));} #endif
XS_String& printf(LPCXSSTR fmt, ...) @@ -169,7 +280,7 @@ XS_CHAR b[BUFFER_LEN];
va_start(l, fmt); - super::assign(b, XS_vsprintf(b, fmt, l)); + super::assign(b, XS_vsnprintf(b, COUNTOF(b), fmt, l)); va_end(l);
return *this; @@ -179,7 +290,7 @@ { XS_CHAR b[BUFFER_LEN];
- super::assign(b, XS_vsprintf(b, fmt, l)); + super::assign(b, XS_vsnprintf(b, COUNTOF(b), fmt, l));
return *this; } @@ -190,7 +301,7 @@ XS_CHAR b[BUFFER_LEN];
va_start(l, fmt); - super::append(b, XS_vsprintf(b, fmt, l)); + super::append(b, XS_vsnprintf(b, COUNTOF(b), fmt, l)); va_end(l);
return *this; @@ -200,7 +311,7 @@ { XS_CHAR b[BUFFER_LEN];
- super::append(b, XS_vsprintf(b, fmt, l)); + super::append(b, XS_vsnprintf(b, COUNTOF(b), fmt, l));
return *this; } @@ -211,12 +322,33 @@ #endif // XS_String
+#define XS_EMPTY_STR XS_TEXT("") +#define XS_TRUE_STR XS_TEXT("true") +#define XS_FALSE_STR XS_TEXT("false") +#define XS_INTFMT_STR XS_TEXT("%d") +#define XS_FLOATFMT_STR XS_TEXT("%f") + + // work around GCC's wide string constant bug +#ifdef __GNUC__ +extern const LPCXSSTR XS_EMPTY; +extern const LPCXSSTR XS_TRUE; +extern const LPCXSSTR XS_FALSE; +extern const LPCXSSTR XS_INTFMT; +extern const LPCXSSTR XS_FLOATFMT; +#else +#define XS_EMPTY XS_EMPTY_STR +#define XS_TRUE XS_TRUE_STR +#define XS_FALSE XS_FALSE_STR +#define XS_INTFMT XS_INTFMT_STR +#define XS_FLOATFMT XS_FLOATFMT_STR +#endif + + #ifndef XS_STRING_UTF8
-inline void assign_utf8(XS_String& s, const char* str) -{ - int lutf8 = strlen(str); - + // from UTF-8 to XS internal string encoding +inline void assign_utf8(XS_String& s, const char* str, int lutf8) +{ #ifdef UNICODE LPTSTR buffer = (LPTSTR)alloca(sizeof(TCHAR)*lutf8); int l = MultiByteToWideChar(CP_UTF8, 0, str, lutf8, buffer, lutf8); @@ -231,22 +363,44 @@ s.assign(buffer, l); }
-inline std::string get_utf8(LPCTSTR s, int l) + // from UTF-8 to XS internal string encoding +inline void assign_utf8(XS_String& s, const char* str) +{ + assign_utf8(s, str, strlen(str)); +} + + // from XS internal string encoding to UTF-8 +inline std::string get_utf8(LPCTSTR s, size_t l) { #ifdef UNICODE - int bl=2*l; LPSTR buffer = (LPSTR)alloca(bl); - l = WideCharToMultiByte(CP_UTF8, 0, s, l, buffer, bl, 0, 0); + size_t bl=2*l; LPSTR buffer = (LPSTR)alloca(bl); + l = WideCharToMultiByte(CP_UTF8, 0, s, (int)l, buffer, (int)bl, 0, 0); #else LPWSTR wbuffer = (LPWSTR)alloca(sizeof(WCHAR)*l); - l = MultiByteToWideChar(CP_ACP, 0, s, l, wbuffer, l); - - int bl=2*l; LPSTR buffer = (LPSTR)alloca(bl); - l = WideCharToMultiByte(CP_UTF8, 0, wbuffer, l, buffer, bl, 0, 0); + l = MultiByteToWideChar(CP_ACP, 0, s, (int)l, wbuffer, (int)l); + + size_t bl=2*l; LPSTR buffer = (LPSTR)alloca(bl); + l = WideCharToMultiByte(CP_UTF8, 0, wbuffer, (int)l, buffer, (int)bl, 0, 0); #endif
return std::string(buffer, l); }
+#ifdef UNICODE + // from XS internal string encoding to UTF-8 +inline std::string get_utf8(const char* s, size_t l) +{ + LPWSTR wbuffer = (LPWSTR)alloca(sizeof(WCHAR)*l); + l = MultiByteToWideChar(CP_ACP, 0, s, (int)l, wbuffer, (int)l); + + size_t bl=2*l; LPSTR buffer = (LPSTR)alloca(bl); + l = WideCharToMultiByte(CP_UTF8, 0, wbuffer, (int)l, buffer, (int)bl, 0, 0); + + return std::string(buffer, l); +} +#endif + + // from XS internal string encoding to UTF-8 inline std::string get_utf8(const XS_String& s) { return get_utf8(s.c_str(), s.length()); @@ -265,43 +419,58 @@ typedef std::filebuf STDIO_FILEBUF; #endif
+struct FileHolder +{ + FileHolder(LPCTSTR path, LPCTSTR mode) + { +#ifdef __STDC_WANT_SECURE_LIB__ // secure CRT functions using VS 2005 + if (_tfopen_s(&_pfile, path, mode) != 0) + _pfile = NULL; +#else + _pfile = _tfopen(path, mode); +#endif + } + + ~FileHolder() + { + if (_pfile) + fclose(_pfile); + } + +protected: + FILE* _pfile; +}; + /// input file stream with ANSI/UNICODE file names -struct tifstream : public std::istream +struct tifstream : public std::istream, FileHolder { typedef std::istream super;
tifstream(LPCTSTR path) : super(&_buf), - _pfile(_tfopen(path, TEXT("r"))), + FileHolder(path, TEXT("rb")), // binary mode is important for XMLReader::read_buffer() with MinGW libraries #ifdef __GNUC__ - _buf(_pfile, ios::in) + _buf(_pfile, std::ios::in) #else _buf(_pfile) #endif { }
- ~tifstream() - { - if (_pfile) - fclose(_pfile); - } - protected: - FILE* _pfile; STDIO_FILEBUF _buf; };
/// output file stream with ANSI/UNICODE file names -struct tofstream : public std::ostream +struct tofstream : public std::ostream, FileHolder { typedef std::ostream super;
tofstream(LPCTSTR path) : super(&_buf), - _pfile(_tfopen(path, TEXT("w"))), + FileHolder(path, TEXT("wb")), #ifdef __GNUC__ - _buf(_pfile, ios::out) + _buf(_pfile, std::ios::out) #else _buf(_pfile) #endif @@ -311,13 +480,9 @@ ~tofstream() { flush(); - - if (_pfile) - fclose(_pfile); }
protected: - FILE* _pfile; STDIO_FILEBUF _buf; };
@@ -326,16 +491,17 @@ #define XML_INDENT_SPACE " "
-#ifdef XML_UNICODE // Are XML_Char strings UTF-16 encoded? - +#if defined(XS_USE_XERCES) || defined(XS_USE_EXPAT) + +#if defined(XML_UNICODE)/*Expat*/ || defined(XS_USE_XERCES)/*Xerces*/ // Are Expat/Xerces XML strings UTF-16 encoded? typedef XS_String String_from_XML_Char;
#elif defined(XS_STRING_UTF8) - typedef XS_String String_from_XML_Char;
#else
+ /// converter from Expat/Xerces strings to XMLStorage internal strings struct String_from_XML_Char : public XS_String { String_from_XML_Char(const XML_Char* str) @@ -345,6 +511,8 @@ };
#endif + +#endif // defined(XS_USE_XERCES) || defined(XS_USE_EXPAT)
#if defined(UNICODE) && !defined(XS_STRING_UTF8) @@ -363,6 +531,152 @@ };
#endif + + + /// XML Error with message and location +struct XMLError +{ + XMLError() + : _line(0), + _column(0), + _error_code(0) + { + } + + std::string str() const; + friend std::ostream& operator<<(std::ostream&, const XMLError& err); + + XS_String _message; + XS_String _systemId; + int _line; + int _column; + int _error_code; +}; + +struct XMLErrorList : public std::list<XMLError> +{ + XS_String str() const; +}; + + +#ifdef XMLNODE_LOCATION + /// location of XML Node including XML file name +struct XMLLocation +{ + XMLLocation() + : _pdisplay_path(NULL), + _line(0), + _column(0) + { + } + + XMLLocation(const char* display_path, int line, int column) + : _pdisplay_path(display_path), + _line(line), + _column(column) + { + } + + std::string str() const; + +protected: + const char* _pdisplay_path; // character pointer for fast reference + int _line; + int _column; +}; +#endif + + +enum PRETTY_FLAGS { + PRETTY_PLAIN = 0, + PRETTY_LINEFEED = 1, + PRETTY_INDENT = 2 +}; + + +struct StyleSheet +{ + std::string _href; // CDATA #REQUIRED + std::string _type; // CDATA #REQUIRED + std::string _title; // CDATA #IMPLIED + std::string _media; // CDATA #IMPLIED + std::string _charset; // CDATA #IMPLIED + bool _alternate; // (yes|no) "no" + + StyleSheet() : _alternate(false) {} + + StyleSheet(const std::string& href, const std::string& type="text/xsl", bool alternate=false) + : _href(href), + _type(type), + _alternate(alternate) + { + } + + bool empty() const {return _href.empty();} + void print(std::ostream& out) const; +}; + +struct StyleSheetList : public std::list<StyleSheet> +{ + void set(const StyleSheet& stylesheet) + { + clear(); + push_back(stylesheet); + } +}; + + +struct DocType +{ + std::string _name; + + // External Document Types are noted, but not parsed. + std::string _public; + std::string _system; + + // Internal DTDs are not supported. + + void parse(const char* str); + bool empty() const {return _name.empty();} +}; + + /// Management of XML file headers and formating +struct XMLFormat +{ + XMLFormat(PRETTY_FLAGS pretty=PRETTY_INDENT, const std::string& xml_version="1.0", const std::string& encoding="utf-8", const DocType& doctype=DocType()) + : _pretty(pretty), + _endl("\n"), + _version(xml_version), + _encoding(encoding), + _doctype(doctype), + _standalone(-1) + { + } + + void print_header(std::ostream& out, bool lf=true) const; + + PRETTY_FLAGS _pretty; + const char* _endl; // line ending string: "\n" or "\r\n" + + std::string _version; + std::string _encoding; + + DocType _doctype; + + StyleSheetList _stylesheets; + +// std::string _additional; + + int _standalone; +}; + + +enum WRITE_MODE { + FORMAT_PLAIN, /// write XML without any white space + FORMAT_SMART, /// preserve original white space and comments if present; pretty print otherwise + FORMAT_ORIGINAL, /// write XML stream preserving original white space and comments + FORMAT_PRETTY /// pretty print node to stream without preserving original white space +};
/// in memory representation of an XML node @@ -392,11 +706,33 @@ { return super::find(x); } + + XS_String get(const char* x, LPXSSTR def=XS_EMPTY_STR) const + { + const_iterator found = find(x); + + if (found != end()) + return found->second; + else + return def; + } }; #else - typedef std::map<XS_String, XS_String> AttributeMap; -#endif - + struct AttributeMap : public std::map<XS_String, XS_String> + { + XS_String get(const char* x, LPXSSTR def=XS_EMPTY_STR) const + { + const_iterator found = find(x); + + if (found != end()) + return found->second; + else + return def; + } + }; +#endif + + /// internal children node list struct Children : public std::list<XMLNode*> { void assign(const Children& other) @@ -436,17 +772,21 @@ }
XMLNode(const XMLNode& other) - : _attributes(other._attributes), + : XS_String(other), + _attributes(other._attributes), _leading(other._leading), _content(other._content), _end_leading(other._end_leading), _trailing(other._trailing) +#ifdef XMLNODE_LOCATION + , _location(other._location) +#endif { for(Children::const_iterator it=other._children.begin(); it!=other._children.end(); ++it) _children.push_back(new XMLNode(**it)); }
- ~XMLNode() + virtual ~XMLNode() { while(!_children.empty()) { delete _children.back(); @@ -500,14 +840,14 @@ }
/// read only access to an attribute - template<typename T> XS_String get(const T& attr_name) const + template<typename T> XS_String get(const T& attr_name, LPXSSTR def=XS_EMPTY_STR) const { AttributeMap::const_iterator found = _attributes.find(attr_name);
if (found != _attributes.end()) return found->second; else - return XS_String(); + return def; }
/// convenient value access in children node @@ -570,13 +910,23 @@ return _children; }
+ const AttributeMap& get_attributes() const + { + return _attributes; + } + + AttributeMap& get_attributes() + { + return _attributes; + } + XS_String get_content() const { #ifdef XS_STRING_UTF8 const XS_String& ret = _content; #else XS_String ret; - assign_utf8(ret, _content.c_str()); + assign_utf8(ret, _content.c_str(), _content.length()); #endif
return DecodeXMLString(ret.c_str()); @@ -587,18 +937,20 @@ _content.assign(EncodeXMLString(s.c_str())); }
- enum WRITE_MODE { - FORMAT_SMART = 0, /// preserve original white space and comments if present; pretty print otherwise - FORMAT_ORIGINAL = 1, /// write XML stream preserving original white space and comments - FORMAT_PRETTY = 2 /// pretty print node to stream without preserving original white space - }; +#ifdef XMLNODE_LOCATION + const XMLLocation& get_location() const {return _location;} +#endif
/// write node with children tree to output stream - std::ostream& write(std::ostream& out, WRITE_MODE mode=FORMAT_SMART, int indent=0) const + std::ostream& write(std::ostream& out, const XMLFormat& format, WRITE_MODE mode=FORMAT_SMART, int indent=0) const { switch(mode) { + case FORMAT_PLAIN: + plain_write_worker(out); + break; + case FORMAT_PRETTY: - pretty_write_worker(out, indent); + pretty_write_worker(out, format, indent); break;
case FORMAT_ORIGINAL: @@ -606,7 +958,7 @@ break;
default: // FORMAT_SMART - smart_write_worker(out, indent); + smart_write_worker(out, format, indent); }
return out; @@ -616,10 +968,14 @@ Children _children; AttributeMap _attributes;
- std::string _leading; - std::string _content; - std::string _end_leading; - std::string _trailing; + std::string _leading; // UTF-8 encoded + std::string _content; // UTF-8 and entity encoded, may contain CDATA sections; decode with DecodeXMLString() + std::string _end_leading; // UTF-8 encoded + std::string _trailing; // UTF-8 encoded + +#ifdef XMLNODE_LOCATION + XMLLocation _location; +#endif
XMLNode* get_first_child() const { @@ -678,18 +1034,20 @@ } #endif
- /// XPath find functions + /// XPath find function (const) const XMLNode* find_relative(const char* path) const;
+ /// XPath find function XMLNode* find_relative(const char* path) {return const_cast<XMLNode*>(const_cast<const XMLNode*>(this)->find_relative(path));}
/// relative XPath create function XMLNode* create_relative(const char* path);
- void write_worker(std::ostream& out, int indent) const; - void pretty_write_worker(std::ostream& out, int indent) const; - void smart_write_worker(std::ostream& out, int indent) const; + void write_worker(std::ostream& out, int indent) const; + void plain_write_worker(std::ostream& out) const; + void pretty_write_worker(std::ostream& out, const XMLFormat& format, int indent) const; + void smart_write_worker(std::ostream& out, const XMLFormat& format, int indent) const; };
@@ -708,6 +1066,7 @@ { }
+ /// internal iterator class struct iterator { typedef XMLNode::Children::iterator BaseIterator; @@ -806,6 +1165,7 @@ { }
+ /// internal iterator class struct const_iterator { typedef XMLNode::Children::const_iterator BaseIterator; @@ -954,6 +1314,7 @@ return _cur->get(attr_name); }
+ /// attribute setting void put(const XS_String& attr_name, const XS_String& value) { _cur->put(attr_name, value); @@ -1218,18 +1579,7 @@ };
- // work around GCC's wide string constant bug -#ifdef __GNUC__ -extern const LPCXSSTR XS_TRUE; -extern const LPCXSSTR XS_FALSE; -extern const LPCXSSTR XS_NUMBERFMT; -#else -#define XS_TRUE XS_TEXT("true") -#define XS_FALSE XS_TEXT("false") -#define XS_NUMBERFMT XS_TEXT("%d") -#endif - - + /// type converter for boolean data struct XMLBool { XMLBool(bool value=false) @@ -1277,6 +1627,7 @@ void operator=(const XMLBool&); // disallow assignment operations };
+ /// type converter for boolean data with write access struct XMLBoolRef { XMLBoolRef(XMLNode* node, const XS_String& attr_name, bool def=false) @@ -1318,6 +1669,7 @@ };
+ /// type converter for integer data struct XMLInt { XMLInt(int value) @@ -1351,7 +1703,7 @@ operator XS_String() const { XS_CHAR buffer[32]; - XS_sprintf(buffer, XS_NUMBERFMT, _value); + XS_snprintf(buffer, COUNTOF(buffer), XS_INTFMT, _value); return buffer; }
@@ -1362,6 +1714,7 @@ void operator=(const XMLInt&); // disallow assignment operations };
+ /// type converter for integer data with write access struct XMLIntRef { XMLIntRef(XMLNode* node, const XS_String& attr_name, int def=0) @@ -1386,7 +1739,7 @@ void assign(int value) { XS_CHAR buffer[32]; - XS_sprintf(buffer, XS_NUMBERFMT, value); + XS_snprintf(buffer, COUNTOF(buffer), XS_INTFMT, value); _ref.assign(buffer); }
@@ -1395,6 +1748,90 @@ };
+ /// type converter for numeric data +struct XMLDouble +{ + XMLDouble(double value) + : _value(value) + { + } + + XMLDouble(LPCXSSTR value, double def=0.) + { + LPTSTR end; + + if (value && *value) + _value = XS_tod(value, &end); + else + _value = def; + } + + XMLDouble(const XMLNode* node, const XS_String& attr_name, double def=0.) + { + LPTSTR end; + const XS_String& value = node->get(attr_name); + + if (!value.empty()) + _value = XS_tod(value.c_str(), &end); + else + _value = def; + } + + operator double() const + { + return _value; + } + + operator XS_String() const + { + XS_CHAR buffer[32]; + XS_snprintf(buffer, COUNTOF(buffer), XS_FLOATFMT, _value); + return buffer; + } + +protected: + double _value; + +private: + void operator=(const XMLDouble&); // disallow assignment operations +}; + + /// type converter for numeric data with write access +struct XMLDoubleRef +{ + XMLDoubleRef(XMLNode* node, const XS_String& attr_name, double def=0.) + : _ref((*node)[attr_name]) + { + if (_ref.empty()) + assign(def); + } + + XMLDoubleRef& operator=(double value) + { + assign(value); + + return *this; + } + + operator double() const + { + LPTSTR end; + return XS_tod(_ref.c_str(), &end); + } + + void assign(double value) + { + XS_CHAR buffer[32]; + XS_snprintf(buffer, COUNTOF(buffer), XS_FLOATFMT, value); + _ref.assign(buffer); + } + +protected: + XS_String& _ref; +}; + + + /// type converter for string data struct XMLString { XMLString(const XS_String& value) @@ -1402,7 +1839,7 @@ { }
- XMLString(LPCXSSTR value, LPCXSSTR def=XS_TEXT("")) + XMLString(LPCXSSTR value, LPCXSSTR def=XS_EMPTY) { if (value && *value) _value = value; @@ -1410,7 +1847,7 @@ _value = def; }
- XMLString(const XMLNode* node, const XS_String& attr_name, LPCXSSTR def=XS_TEXT("")) + XMLString(const XMLNode* node, const XS_String& attr_name, LPCXSSTR def=XS_EMPTY) { const XS_String& value = node->get(attr_name);
@@ -1437,16 +1874,17 @@ void operator=(const XMLString&); // disallow assignment operations };
+ /// type converter for string data with write access struct XMStringRef { - XMStringRef(XMLNode* node, const XS_String& attr_name, LPCXSSTR def=XS_TEXT("")) + XMStringRef(XMLNode* node, const XS_String& attr_name, LPCXSSTR def=XS_EMPTY) : _ref((*node)[attr_name]) { if (_ref.empty()) assign(def); }
- XMStringRef(XMLNode* node, const XS_String& node_name, const XS_String& attr_name, LPCXSSTR def=XS_TEXT("")) + XMStringRef(XMLNode* node, const XS_String& node_name, const XS_String& attr_name, LPCXSSTR def=XS_EMPTY) : _ref(node->subvalue(node_name, attr_name)) { if (_ref.empty()) @@ -1500,62 +1938,175 @@
/// XML reader base class struct XMLReaderBase -{ - XMLReaderBase(XMLNode* node) - : _pos(node), - _parser(XML_ParserCreate(NULL)) - { - XML_SetUserData(_parser, this); - XML_SetXmlDeclHandler(_parser, XML_XmlDeclHandler); - XML_SetElementHandler(_parser, XML_StartElementHandler, XML_EndElementHandler); - XML_SetDefaultHandler(_parser, XML_DefaultHandler); - - _last_tag = TAG_NONE; - } - - virtual ~XMLReaderBase() - { - XML_ParserFree(_parser); - } - - XML_Status read(); - - virtual int read_buffer(char* buffer, int len) = 0; - - std::string get_position() const - { - int line = XML_GetCurrentLineNumber(_parser); - int column = XML_GetCurrentColumnNumber(_parser); - - std::ostringstream out; - out << "(" << line << ") : [column " << column << "]"; - - return out.str(); - } - - std::string get_instructions() const {return _instructions;} - - XML_Error get_error_code() {return XML_GetErrorCode(_parser);} - std::string get_error_string() const; +#ifdef XS_USE_XERCES + : public HandlerBase +#endif +{ +#ifdef XS_USE_XERCES + + XMLReaderBase(XMLNode* node, InputSource* source, bool adoptSource=false); + virtual ~XMLReaderBase(); + + void read();
protected: - XMLPos _pos; + SAXParser* _parser; + InputSource* _source; + bool _deleteSource; + + virtual void XMLDecl(const XMLCh* const versionStr, const XMLCh* const encodingStr, + const XMLCh* const standaloneStr, const XMLCh* const actualEncodingStr); + + // Handlers for the SAX DocumentHandler interface + virtual void setDocumentLocator(const Locator* const locator); + virtual void startElement(const XMLCh* const name, AttributeList& attributes); + virtual void endElement(const XMLCh* const name); + virtual void characters(const XMLCh* const chars, const unsigned int length); + virtual void ignorableWhitespace(const XMLCh* const chars, const unsigned int length); + + // Handlers for the SAX ErrorHandler interface + virtual void error(const SAXParseException& e); + virtual void fatalError(const SAXParseException& e); + virtual void warning(const SAXParseException& e); + virtual void resetErrors(); + +#elif defined(XS_USE_EXPAT) // !XS_USE_XERCES + + XMLReaderBase(XMLNode* node); + virtual ~XMLReaderBase(); + +protected: XML_Parser _parser; - std::string _xml_version; - std::string _encoding; - std::string _instructions; - - std::string _content; - enum {TAG_NONE, TAG_START, TAG_END} _last_tag; - - static void XMLCALL XML_XmlDeclHandler(void* userData, const XML_Char* version, const XML_Char* encoding, int standalone); + + static void XMLCALL XML_XmlDeclHandler(void* userData, const XML_Char* version, const XML_Char* encoding, int standalone=-1); static void XMLCALL XML_StartElementHandler(void* userData, const XML_Char* name, const XML_Char** atts); static void XMLCALL XML_EndElementHandler(void* userData, const XML_Char* name); static void XMLCALL XML_DefaultHandler(void* userData, const XML_Char* s, int len); + + static std::string get_expat_error_string(XML_Error error_code); + +#else // XS_USE_EXPAT + + XMLReaderBase(XMLNode* node) + : _pos(node), + _endl_defined(false), + _utf8(false) + { + _last_tag = TAG_NONE; + } + + virtual ~XMLReaderBase(); + + bool parse(); + +#endif + +public: +#ifndef XS_USE_XERCES + void read(); + + std::string get_position() const; +#endif + const XMLFormat& get_format() const {return _format;} + const char* get_endl() const {return _endl_defined? _format._endl: "\n";} + + const XMLErrorList& get_errors() const {return _errors;} + const XMLErrorList& get_warnings() const {return _warnings;} + + void clear_errors() {_errors.clear(); _warnings.clear();} + +#ifdef XMLNODE_LOCATION + const char* _display_path; // character pointer for fast reference in XMLLocation + +#ifdef XS_USE_XERCES + const Locator* _locator; +#endif + + XMLLocation get_location() const; +#endif + +protected: + XMLPos _pos; + + std::string _content; // UTF-8 encoded + enum {TAG_NONE, TAG_START, TAG_END} _last_tag; + + XMLErrorList _errors; + XMLErrorList _warnings; + + XMLFormat _format; + bool _endl_defined; + +#ifdef XS_USE_XERCES + //@@ +#elif defined(XS_USE_EXPAT) + virtual int read_buffer(char* buffer, int len) = 0; +#else + virtual int get() = 0; + int eat_endl(); + + bool _utf8; +#endif + + void finish_read(); + + virtual void XmlDeclHandler(const char* version, const char* encoding, int standalone); + virtual void StartElementHandler(const XS_String& name, const XMLNode::AttributeMap& attributes); + virtual void EndElementHandler(); +#if defined(XS_USE_XERCES) || defined(XS_USE_EXPAT) + virtual void DefaultHandler(const XML_Char* s, int len); +#else + virtual void DefaultHandler(const std::string& s); +#endif };
/// XML file reader + +#ifdef XS_USE_XERCES + +struct XercesXMLReader : public XMLReaderBase +{ + XercesXMLReader(XMLNode* node, InputSource* source, bool adoptSource=false) + : XMLReaderBase(node, source, adoptSource) + { + } + + XercesXMLReader(XMLNode* node, LPCTSTR path); + XercesXMLReader(XMLNode* node, const XMLByte* buffer, size_t bytes, const std::string& system_id=std::string()); +}; + +#define XMLReader XercesXMLReader + +#elif defined(XS_USE_EXPAT) + +struct ExpatXMLReader : public XMLReaderBase +{ + ExpatXMLReader(XMLNode* node, std::istream& in) + : XMLReaderBase(node), + _in(in) + { + } + + /// read XML stream into XML tree below _pos + int read_buffer(char* buffer, int len) + { + if (!_in.good()) + return -1; + + _in.read(buffer, len); + + return _in.gcount(); + } + +protected: + std::istream& _in; +}; + +#define XMLReader ExpatXMLReader + +#else // XS_USE_XERCES, XS_USE_EXPAT + struct XMLReader : public XMLReaderBase { XMLReader(XMLNode* node, std::istream& in) @@ -1564,127 +2115,110 @@ { }
- /// read XML stream into XML tree below _pos - int read_buffer(char* buffer, int len) - { - if (!_in.good()) - return -1; - - _in.read(buffer, len); - - return _in.gcount(); + /// read one character from XML stream + int get() + { + return _in.get(); }
protected: std::istream& _in; };
- -struct XMLHeader -{ - XMLHeader(const std::string& xml_version="1.0", const std::string& encoding="UTF-8", const std::string& doctype="") - : _version(xml_version), - _encoding(encoding), - _doctype(doctype) - { - } - - void print(std::ostream& out) const - { - out << "<?xml version=\"" << _version << "\" encoding=\"" << _encoding << "\"?>\n"; - - if (!_doctype.empty()) - out << _doctype << '\n'; - if (!_additional.empty()) - out << _additional << '\n'; - } - - std::string _version; - std::string _encoding; - std::string _doctype; - std::string _additional; -}; - - +#endif // XS_USE_XERCES + + + /// XML document holder struct XMLDoc : public XMLNode { XMLDoc() - : XMLNode(""), - _last_error(XML_ERROR_NONE) + : XMLNode("") { }
XMLDoc(LPCTSTR path) - : XMLNode(""), - _last_error(XML_ERROR_NONE) + : XMLNode("") { read(path); }
- std::istream& read(std::istream& in) - { - XMLReader reader(this, in); - - read(reader); - - return in; - } +#ifdef XS_USE_XERCES + bool read(LPCTSTR path) + { + XMLReader reader(this, path); + +#if defined(_STRING_DEFINED) && !defined(XS_STRING_UTF8) + return read(reader, std::string(ANS(path))); +#else + return read(reader, XS_String(path)); +#endif + } + + bool read(const char* buffer, size_t len, const std::string& system_id=std::string()) + { + XMLReader reader(this, (const XMLByte*)buffer, len, system_id); + + return read(reader, system_id); + } + +#else // XS_USE_XERCES
bool read(LPCTSTR path) { tifstream in(path); XMLReader reader(this, in);
-//#if defined(_STRING_DEFINED) && !defined(XS_STRING_UTF8) -// return read(reader, std::string(ANS(path))); -//#else +#if defined(_STRING_DEFINED) && !defined(XS_STRING_UTF8) + return read(reader, std::string(ANS(path))); +#else return read(reader, XS_String(path)); -//#endif - } - - bool read(XMLReaderBase& reader) - { - XML_Status status = reader.read(); - - _header._additional = reader.get_instructions(); - - if (status == XML_STATUS_ERROR) { - std::ostringstream out; - - out << "input stream" << reader.get_position() << " " << reader.get_error_string(); - - _last_error = reader.get_error_code(); - _last_error_msg = out.str(); - } - - return status != XML_STATUS_ERROR; - } +#endif + } + + bool read(const char* buffer, size_t len, const std::string& system_id=std::string()) + { + std::istringstream in(std::string(buffer, len)); + + return read(in, system_id); + } + + bool read(std::istream& in, const std::string& system_id=std::string()) + { + XMLReader reader(this, in); + + return read(reader, system_id); + } +#endif // XS_USE_XERCES
bool read(XMLReaderBase& reader, const std::string& display_path) { - XML_Status status = reader.read(); - - _header._additional = reader.get_instructions(); - - if (status == XML_STATUS_ERROR) { - std::ostringstream out; - - out << display_path << reader.get_position() << " " << reader.get_error_string(); - - _last_error = reader.get_error_code(); - _last_error_msg = out.str(); - } - - return status != XML_STATUS_ERROR; +#ifdef XMLNODE_LOCATION + // make a string copy to handle temporary string objects + _display_path = display_path; + reader._display_path = _display_path.c_str(); +#endif + + reader.clear_errors(); + reader.read(); + + _format = reader.get_format(); + _format._endl = reader.get_endl(); + + if (!reader.get_errors().empty()) { + _errors = reader.get_errors(); + return false; + } + + return true; }
/// write XML stream preserving previous white space and comments std::ostream& write(std::ostream& out, WRITE_MODE mode=FORMAT_SMART) const { - _header.print(out); + _format.print_header(out, mode!=FORMAT_PLAIN);
if (!_children.empty()) - _children.front()->write(out); + _children.front()->write(out, _format, mode);
return out; } @@ -1695,26 +2229,30 @@ return write(out, FORMAT_PRETTY); }
- void write(LPCTSTR path, WRITE_MODE mode=FORMAT_SMART) const + bool write(LPCTSTR path, WRITE_MODE mode=FORMAT_SMART) const { tofstream out(path);
- write(out, mode); - } - - void write_formating(LPCTSTR path) const + return write(out, mode).good(); + } + + bool write_formating(LPCTSTR path) const { tofstream out(path);
- write_formating(out); - } - - XMLHeader _header; - XML_Error _last_error; - std::string _last_error_msg; -}; - - + return write_formating(out).good(); + } + + XMLFormat _format; + XMLErrorList _errors; + +#ifdef XMLNODE_LOCATION + std::string _display_path; +#endif +}; + + + /// XML message wrapper struct XMLMessage : public XMLDoc { XMLMessage(const char* name) @@ -1723,7 +2261,212 @@ _pos.create(name); }
+ std::string toString() const + { + std::ostringstream out; + + write(out); + + return out.str(); + } + XMLPos _pos; + +protected: + XMLMessage() + : _pos(this) + { + } +}; + + +struct XMLMessageFromString : public XMLMessage +{ + XMLMessageFromString(const std::string& xml_str, const std::string& system_id=std::string()) + { + read(xml_str.c_str(), xml_str.length(), system_id); + } +}; + + + /// Reader for XML Messages +struct XMLMessageReader : public XMLPos +{ + XMLMessageReader(const std::string& xml_str, const std::string& system_id=std::string()) + : XMLPos(&_msg) + { + _msg.read(xml_str.c_str(), xml_str.length(), system_id); + } + + const XMLDoc& get_document() + { + return _msg; + } + +protected: + XMLDoc _msg; +}; + + +struct XMLWriter +{ + XMLWriter(std::ostream& out, const XMLFormat& format=XMLFormat()) + : _pofstream(NULL), + _out(out), + _format(format) + { + format.print_header(_out, false); // _format._endl is printed in write_pre() + } + + XMLWriter(LPCTSTR path, const XMLFormat& format=XMLFormat()) + : _pofstream(new tofstream(path)), + _out(*_pofstream), + _format(format) + { + format.print_header(_out, false); // _format._endl is printed in write_pre() + } + + ~XMLWriter() + { + _out << _format._endl; + delete _pofstream; + } + + /// create node and move to it + void create(const XS_String& name) + { + if (!_stack.empty()) { + StackEntry& last = _stack.top(); + + if (last._state < PRE_CLOSED) { + write_attributes(last); + close_pre(last); + } + + ++last._children; + } + + StackEntry entry; + entry._node_name = name; + _stack.push(entry); + + write_pre(entry); + } + + /// go back to previous position + bool back() + { + if (!_stack.empty()) { + write_post(_stack.top()); + + _stack.pop(); + return true; + } else + return false; + } + + /// attribute setting + void put(const XS_String& attr_name, const XS_String& value) + { + if (!_stack.empty()) + _stack.top()._attributes[attr_name] = value; + } + + /// C++ write access to an attribute + XS_String& operator[](const XS_String& attr_name) + { + if (_stack.empty()) + return s_empty_attr; + + return _stack.top()._attributes[attr_name]; + } + + void set_content(const XS_String& s) + { + if (!_stack.empty()) + _stack.top()._content = EncodeXMLString(s.c_str()); + } + + // public for access in StackEntry + enum WRITESTATE { + NOTHING, /*PRE,*/ ATTRIBUTES, PRE_CLOSED, /*CONTENT,*/ POST + }; + +protected: + tofstream* _pofstream; + std::ostream& _out; + const XMLFormat&_format; + + typedef XMLNode::AttributeMap AttrMap; + + struct StackEntry { + XS_String _node_name; + AttrMap _attributes; + std::string _content; + WRITESTATE _state; + bool _children; + + StackEntry() : _state(NOTHING), _children(false) {} + }; + + std::stack<StackEntry> _stack; + + static XS_String s_empty_attr; + + void close_pre(StackEntry& entry) + { + _out << '>'; + + entry._state = PRE_CLOSED; + } + + void write_pre(StackEntry& entry) + { + if (_format._pretty >= PRETTY_LINEFEED) + _out << _format._endl; + + if (_format._pretty == PRETTY_INDENT) + for(size_t i=_stack.size(); --i>0; ) + _out << XML_INDENT_SPACE; + + _out << '<' << EncodeXMLString(entry._node_name); + //entry._state = PRE; + } + + void write_attributes(StackEntry& entry) + { + for(AttrMap::const_iterator it=entry._attributes.begin(); it!=entry._attributes.end(); ++it) + _out << ' ' << EncodeXMLString(it->first) << "="" << EncodeXMLString(it->second) << """; + + entry._state = ATTRIBUTES; + } + + void write_post(StackEntry& entry) + { + if (entry._state < ATTRIBUTES) + write_attributes(entry); + + if (entry._children || !entry._content.empty()) { + if (entry._state < PRE_CLOSED) + close_pre(entry); + + _out << entry._content; + //entry._state = CONTENT; + + if (_format._pretty>=PRETTY_LINEFEED && entry._content.empty()) + _out << _format._endl; + + if (_format._pretty==PRETTY_INDENT && entry._content.empty()) + for(size_t i=_stack.size(); --i>0; ) + _out << XML_INDENT_SPACE; + + _out << "</" << EncodeXMLString(entry._node_name) << ">"; + } else { + _out << "/>"; + } + + entry._state = POST; + } };
Added: trunk/reactos/base/applications/ibrowser/utility/xs-native.cpp URL: http://svn.reactos.org/svn/reactos/trunk/reactos/base/applications/ibrowser/... ============================================================================== --- trunk/reactos/base/applications/ibrowser/utility/xs-native.cpp (added) +++ trunk/reactos/base/applications/ibrowser/utility/xs-native.cpp Tue Aug 1 03:23:19 2006 @@ -1,0 +1,438 @@ + + // + // XML storage classes + // + // xs-native.cpp + // + // Copyright (c) 2006 Martin Fuchs martin-fuchs@gmx.net + // + + +/* + + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + +*/ + +#ifndef XS_NO_COMMENT +#define XS_NO_COMMENT // no #pragma comment(lib, ...) statements in .lib files to enable static linking +#endif + +//#include "xmlstorage.h" +#include <precomp.h> + + +#if !defined(XS_USE_EXPAT) && !defined(XS_USE_XERCES) + +namespace XMLStorage { + + +XMLReaderBase::~XMLReaderBase() +{ +} + + /// read XML stream into XML tree below _pos +void XMLReaderBase::read() +{ + if (!parse()) { + XMLError error; + + error._message = "XML parsing error"; + //error._line = ; + //error._column = ; + + _errors.push_back(error); + } + + finish_read(); +} + + +struct Buffer +{ + Buffer() + { + _buffer = (char*) malloc(BUFFER_LEN); + _len = BUFFER_LEN; + + reset(); + } + + ~Buffer() + { + free(_buffer); + } + + void reset() + { + _wptr = _buffer; + _buffer_str.erase(); + } + + void append(char c) + { + size_t wpos = _wptr-_buffer; + + if (wpos >= _len) { + _len <<= 1; + _buffer = (char*) realloc(_buffer, _len); + _wptr = _buffer + wpos; + } + + *_wptr++ = c; + } + + const std::string& str(bool utf8) // returns UTF-8 encoded buffer content + { + if (utf8) + _buffer_str.assign(_buffer, _wptr-_buffer); + else + _buffer_str = get_utf8(_buffer, _wptr-_buffer); + + return _buffer_str; + } + + size_t len() const + { + return _wptr - _buffer; + } + + bool has_CDEnd() const + { + //if (_wptr-_buffer < 3) + // return false; + + return !strncmp(_wptr-3, "]]>", 3); + } + + XS_String get_tag() const + { + const char* p = _buffer_str.c_str(); + + if (*p == '<') + ++p; + + if (*p == '/') + ++p; + + const char* q = p; + + if (*q == '?') + ++q; + + while(isxmlsym(*q)) + ++q; + +#ifdef XS_STRING_UTF8 + return XS_String(p, q-p); +#else + XS_String tag; + assign_utf8(tag, p, q-p); + return tag; +#endif + } + + /// read attributes and values + void get_attributes(XMLNode::AttributeMap& attributes) const + { + const char* p = _buffer_str.c_str(); + + // find end of tag name + if (*p == '<') + ++p; + + if (*p == '/') + ++p; + else if (*p == '?') + ++p; + + while(isxmlsym(*p)) + ++p; + + // read attributes from buffer + while(*p && *p!='>' && *p!='/') { + while(isspace((unsigned char)*p)) + ++p; + + const char* attr_name = p; + + while(isxmlsym(*p)) + ++p; + + if (*p != '=') + break; //@TODO error handling + + size_t attr_len = p - attr_name; + + if (*++p!='"' && *p!=''') + break; //@TODO error handling + + char delim = *p; + const char* value = ++p; + + while(*p && *p!=delim) + ++p; + + size_t value_len = p - value; + + if (*p) + ++p; // '"' + +#ifdef XS_STRING_UTF8 + XS_String name_str(attr_name, attr_len); + XS_String value_str(value, value_len); +#else + XS_String name_str, value_str; + assign_utf8(name_str, attr_name, attr_len); + assign_utf8(value_str, value, value_len); +#endif + + attributes[name_str] = DecodeXMLString(value_str); + } + } + +protected: + char* _buffer; + char* _wptr; + size_t _len; + std::string _buffer_str; // UF-8 encoded +}; + +bool XMLReaderBase::parse() +{ + Buffer buffer; + int c = get(); + bool in_comment = false; + + while(c != EOF) { + if (in_comment || c=='<') { + buffer.append(c); + + // read start or end tag + for(;;) { + c = get(); + + if (c == EOF) + break; + + buffer.append(c); + + if (c == '>') + break; + } + + const std::string& b = buffer.str(_utf8); + const char* str = b.c_str(); + + if (in_comment || !strncmp(str+1, "!--", 3)) { + // XML comment + DefaultHandler(b); + + if (strcmp(str+b.length()-3, "-->")) + in_comment = true; + else + in_comment = false; + + c = get(); + } else if (str[1] == '/') { + // end tag + + /*@TODO error handling + const XS_String& tag = buffer.get_tag(); + + if (tag != last_opened_tag) { + ERROR + } + */ + + EndElementHandler(); + + c = get(); + } else if (str[1] == '?') { + // XML declaration + const XS_String& tag = buffer.get_tag(); + + if (tag == "?xml") { + XMLNode::AttributeMap attributes; + buffer.get_attributes(attributes); + + const std::string& version = attributes.get("version"); + const std::string& encoding = attributes.get("encoding"); + + int standalone; + XMLNode::AttributeMap::const_iterator found = // const_cast for ISO C++ compatibility error of GCC + const_cast<const XMLNode::AttributeMap&>(attributes).find("standalone"); + if (found != attributes.end()) + standalone = !XS_icmp(found->second.c_str(), XS_TEXT("yes")); + else + standalone = -1; + + XmlDeclHandler(version.empty()?NULL:version.c_str(), encoding.empty()?NULL:encoding.c_str(), standalone); + + if (!encoding.empty() && !_stricmp(encoding.c_str(), "utf-8")) + _utf8 = true; + + c = eat_endl(); + } else if (tag == "?xml-stylesheet") { + XMLNode::AttributeMap attributes; + buffer.get_attributes(attributes); + + StyleSheet stylesheet(attributes.get("href"), attributes.get("type"), !XS_icmp(attributes.get("alternate"), XS_TEXT("yes"))); + stylesheet._title = attributes.get("title"); + stylesheet._media = attributes.get("media"); + stylesheet._charset = attributes.get("charset"); + + _format._stylesheets.push_back(stylesheet); + + c = eat_endl(); + } else { + DefaultHandler(b); + c = get(); + } + } else if (str[1] == '!') { + if (!strncmp(str+2, "DOCTYPE ", 8)) { + _format._doctype.parse(str+10); + + c = eat_endl(); + } else if (!strncmp(str+2, "[CDATA[", 7)) { + // parse <![CDATA[ ... ]]> strings + while(!buffer.has_CDEnd()) { + c = get(); + + if (c == EOF) + break; + + buffer.append(c); + } + + DefaultHandler(buffer.str(_utf8)); + + c = get(); + } + } else { + // start tag + const XS_String& tag = buffer.get_tag(); + + if (!tag.empty()) { + XMLNode::AttributeMap attributes; + buffer.get_attributes(attributes); + + StartElementHandler(tag, attributes); + + if (str[b.length()-2] == '/') + EndElementHandler(); + } + + c = get(); + } + } else { + buffer.append(c); + + // read white space + for(;;) { + // check for the encoding of the first line end + if (!_endl_defined) + if (c == '\n') { + _format._endl = "\n"; + _endl_defined = true; + } else if (c == '\r') { + _format._endl = "\r\n"; + _endl_defined = true; + } + + c = get(); + + if (c == EOF) + break; + + if (c == '<') + break; + + buffer.append(c); + } + + DefaultHandler(buffer.str(_utf8)); + } + + buffer.reset(); + } + + return true; +} + +int XMLReaderBase::eat_endl() +{ + int c = get(); + + if (c == '\r') + c = get(); + + if (c == '\n') + c = get(); + + return c; +} + + /// return current parser position as string +std::string XMLReaderBase::get_position() const +{ +/*@TODO display parser position in case of errors + int line = XML_GetCurrentLineNumber(_parser); + int column = XML_GetCurrentColumnNumber(_parser); + + std::ostringstream out; + out << "(" << line << ") : [column " << column << "]"; + + return out.str(); +*/ + return ""; +} + + +#ifdef XMLNODE_LOCATION + +XMLLocation XMLReaderBase::get_location() const +{ + return XMLLocation(); //@TODO XMLLocation for XS-native +} + +std::string XMLLocation::str() const +{ + return ""; //TODO +} + +#endif + + + /// store content, white space and comments +void XMLReaderBase::DefaultHandler(const std::string& s) +{ + _content.append(s); +} + + +} // namespace XMLStorage + +#endif // !defined(XS_USE_EXPAT) && !defined(XS_USE_XERCES)
Propchange: trunk/reactos/base/applications/ibrowser/utility/xs-native.cpp ------------------------------------------------------------------------------ svn:eol-style = native
Propchange: trunk/reactos/base/applications/ibrowser/utility/xs-native.cpp ------------------------------------------------------------------------------ svn:keywords = Author Date Id Revision
-
martinf＠svn.reactos.org