diff options
Diffstat (limited to 'libxsd/xsd/cxx/xml')
27 files changed, 3725 insertions, 0 deletions
diff --git a/libxsd/xsd/cxx/xml/bits/literals.hxx b/libxsd/xsd/cxx/xml/bits/literals.hxx new file mode 100644 index 0000000..93df006 --- /dev/null +++ b/libxsd/xsd/cxx/xml/bits/literals.hxx @@ -0,0 +1,83 @@ +// file : xsd/cxx/xml/bits/literals.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_BITS_LITERALS_HXX +#define XSD_CXX_XML_BITS_LITERALS_HXX + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace bits + { + template <typename C> + const C* + xml_prefix (); + + template <typename C> + const C* + xml_namespace (); + + template <typename C> + const C* + xmlns_prefix (); + + template <typename C> + const C* + xmlns_namespace (); + + template <typename C> + const C* + xsi_prefix (); + + template <typename C> + const C* + xsi_namespace (); + + template <typename C> + const C* + type (); + + template <typename C> + const C* + nil (); + + template <typename C> + const C* + schema_location (); + + template <typename C> + const C* + no_namespace_schema_location (); + + template <typename C> + const C* + first_prefix (); + + template <typename C> + const C* + second_prefix (); + + template <typename C> + const C* + third_prefix (); + + template <typename C> + const C* + fourth_prefix (); + + template <typename C> + const C* + fifth_prefix (); + } + } + } +} + +#endif // XSD_CXX_XML_BITS_LITERALS_HXX + +#include <xsd/cxx/xml/bits/literals.ixx> diff --git a/libxsd/xsd/cxx/xml/bits/literals.ixx b/libxsd/xsd/cxx/xml/bits/literals.ixx new file mode 100644 index 0000000..827d922 --- /dev/null +++ b/libxsd/xsd/cxx/xml/bits/literals.ixx @@ -0,0 +1,261 @@ +// file : xsd/cxx/xml/bits/literals.ixx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_BITS_LITERALS_IXX +#define XSD_CXX_XML_BITS_LITERALS_IXX + +#endif // XSD_CXX_XML_BITS_LITERALS_IXX + + +#if defined(XSD_USE_CHAR) || !defined(XSD_USE_WCHAR) + +#ifndef XSD_CXX_XML_BITS_LITERALS_IXX_CHAR +#define XSD_CXX_XML_BITS_LITERALS_IXX_CHAR + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace bits + { + template <> + inline const char* + xml_prefix<char> () + { + return "xml"; + } + + template <> + inline const char* + xml_namespace<char> () + { + return "http://www.w3.org/XML/1998/namespace"; + } + + template <> + inline const char* + xmlns_prefix<char> () + { + return "xmlns"; + } + + template <> + inline const char* + xmlns_namespace<char> () + { + return "http://www.w3.org/2000/xmlns/"; + } + + template <> + inline const char* + xsi_prefix<char> () + { + return "xsi"; + } + + template <> + inline const char* + xsi_namespace<char> () + { + return "http://www.w3.org/2001/XMLSchema-instance"; + } + + template <> + inline const char* + type<char> () + { + return "type"; + } + + template <> + inline const char* + nil<char> () + { + return "nil"; + } + + template <> + inline const char* + schema_location<char> () + { + return "schemaLocation"; + } + + template <> + inline const char* + no_namespace_schema_location<char> () + { + return "noNamespaceSchemaLocation"; + } + + template <> + inline const char* + first_prefix<char> () + { + return "p1"; + } + + template <> + inline const char* + second_prefix<char> () + { + return "p2"; + } + + template <> + inline const char* + third_prefix<char> () + { + return "p3"; + } + + template <> + inline const char* + fourth_prefix<char> () + { + return "p4"; + } + + template <> + inline const char* + fifth_prefix<char> () + { + return "p5"; + } + } + } + } +} + +#endif // XSD_CXX_XML_BITS_LITERALS_IXX_CHAR +#endif // XSD_USE_CHAR + + +#if defined(XSD_USE_WCHAR) || !defined(XSD_USE_CHAR) + +#ifndef XSD_CXX_XML_BITS_LITERALS_IXX_WCHAR +#define XSD_CXX_XML_BITS_LITERALS_IXX_WCHAR + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace bits + { + template <> + inline const wchar_t* + xml_prefix<wchar_t> () + { + return L"xml"; + } + + template <> + inline const wchar_t* + xml_namespace<wchar_t> () + { + return L"http://www.w3.org/XML/1998/namespace"; + } + + template <> + inline const wchar_t* + xmlns_prefix<wchar_t> () + { + return L"xmlns"; + } + + template <> + inline const wchar_t* + xmlns_namespace<wchar_t> () + { + return L"http://www.w3.org/2000/xmlns/"; + } + + template <> + inline const wchar_t* + xsi_prefix<wchar_t> () + { + return L"xsi"; + } + + template <> + inline const wchar_t* + xsi_namespace<wchar_t> () + { + return L"http://www.w3.org/2001/XMLSchema-instance"; + } + + template <> + inline const wchar_t* + type<wchar_t> () + { + return L"type"; + } + + template <> + inline const wchar_t* + nil<wchar_t> () + { + return L"nil"; + } + + template <> + inline const wchar_t* + schema_location<wchar_t> () + { + return L"schemaLocation"; + } + + template <> + inline const wchar_t* + no_namespace_schema_location<wchar_t> () + { + return L"noNamespaceSchemaLocation"; + } + + template <> + inline const wchar_t* + first_prefix<wchar_t> () + { + return L"p1"; + } + + template <> + inline const wchar_t* + second_prefix<wchar_t> () + { + return L"p2"; + } + + template <> + inline const wchar_t* + third_prefix<wchar_t> () + { + return L"p3"; + } + + template <> + inline const wchar_t* + fourth_prefix<wchar_t> () + { + return L"p4"; + } + + template <> + inline const wchar_t* + fifth_prefix<wchar_t> () + { + return L"p5"; + } + } + } + } +} + +#endif // XSD_CXX_XML_BITS_LITERALS_IXX_WCHAR +#endif // XSD_USE_WCHAR diff --git a/libxsd/xsd/cxx/xml/dom/auto-ptr.hxx b/libxsd/xsd/cxx/xml/dom/auto-ptr.hxx new file mode 100644 index 0000000..624c0e8 --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/auto-ptr.hxx @@ -0,0 +1,158 @@ +// file : xsd/cxx/xml/dom/auto-ptr.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_DOM_AUTO_PTR_HXX +#define XSD_CXX_XML_DOM_AUTO_PTR_HXX + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + // Simple auto_ptr version that calls release() instead of delete. + // + + template <typename T> + struct remove_c + { + typedef T r; + }; + + template <typename T> + struct remove_c<const T> + { + typedef T r; + }; + + template <typename T> + struct auto_ptr_ref + { + T* x_; + + explicit + auto_ptr_ref (T* x) + : x_ (x) + { + } + }; + + template <typename T> + struct auto_ptr + { + ~auto_ptr () + { + reset (); + } + + explicit + auto_ptr (T* x = 0) + : x_ (x) + { + } + + auto_ptr (auto_ptr& y) + : x_ (y.release ()) + { + } + + template <typename T2> + auto_ptr (auto_ptr<T2>& y) + : x_ (y.release ()) + { + } + + auto_ptr (auto_ptr_ref<T> r) + : x_ (r.x_) + { + } + + auto_ptr& + operator= (auto_ptr& y) + { + if (x_ != y.x_) + reset (y.release ()); + + return *this; + } + + template <typename T2> + auto_ptr& + operator= (auto_ptr<T2>& y) + { + if (x_ != y.x_) + reset (y.release ()); + + return *this; + } + + auto_ptr& + operator= (auto_ptr_ref<T> r) + { + if (r.x_ != x_) + reset (r.x_); + + return *this; + } + + template <typename T2> + operator auto_ptr_ref<T2> () + { + return auto_ptr_ref<T2> (release ()); + } + + template <typename T2> + operator auto_ptr<T2> () + { + return auto_ptr<T2> (release ()); + } + + public: + T& + operator* () const + { + return *x_; + } + + T* + operator-> () const + { + return x_; + } + + T* + get () const + { + return x_; + } + + T* + release () + { + T* x (x_); + x_ = 0; + return x; + } + + void + reset (T* x = 0) + { + if (x_) + const_cast<typename remove_c<T>::r*> (x_)->release (); + + x_ = x; + } + + private: + T* x_; + }; + } + } + } +} + +#endif // XSD_CXX_XML_DOM_AUTO_PTR_HXX diff --git a/libxsd/xsd/cxx/xml/dom/bits/error-handler-proxy.hxx b/libxsd/xsd/cxx/xml/dom/bits/error-handler-proxy.hxx new file mode 100644 index 0000000..e0d9f1d --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/bits/error-handler-proxy.hxx @@ -0,0 +1,61 @@ +// file : xsd/cxx/xml/dom/bits/error-handler-proxy.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_DOM_BITS_ERROR_HANDLER_PROXY_HXX +#define XSD_CXX_XML_DOM_BITS_ERROR_HANDLER_PROXY_HXX + +#include <xercesc/dom/DOMError.hpp> +#include <xercesc/dom/DOMLocator.hpp> +#include <xercesc/dom/DOMErrorHandler.hpp> + +#include <xsd/cxx/xml/error-handler.hxx> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + namespace bits + { + template <typename C> + class error_handler_proxy: public xercesc::DOMErrorHandler + { + public: + error_handler_proxy (error_handler<C>& eh) + : failed_ (false), eh_ (&eh), native_eh_ (0) + { + } + + error_handler_proxy (xercesc::DOMErrorHandler& eh) + : failed_ (false), eh_ (0), native_eh_ (&eh) + { + } + + virtual bool + handleError (const xercesc::DOMError& e); + + bool + failed () const + { + return failed_; + } + + private: + bool failed_; + error_handler<C>* eh_; + xercesc::DOMErrorHandler* native_eh_; + }; + } + } + } + } +} + +#include <xsd/cxx/xml/dom/bits/error-handler-proxy.txx> + +#endif // XSD_CXX_XML_DOM_BITS_ERROR_HANDLER_PROXY_HXX diff --git a/libxsd/xsd/cxx/xml/dom/bits/error-handler-proxy.txx b/libxsd/xsd/cxx/xml/dom/bits/error-handler-proxy.txx new file mode 100644 index 0000000..65a2cf3 --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/bits/error-handler-proxy.txx @@ -0,0 +1,80 @@ +// file : xsd/cxx/xml/dom/bits/error-handler-proxy.txx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include <xsd/cxx/xml/string.hxx> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + namespace bits + { + template <typename C> + bool error_handler_proxy<C>:: + handleError (const xercesc::DOMError& e) + { + using xercesc::DOMError; + + if (e.getSeverity() != DOMError::DOM_SEVERITY_WARNING) + failed_ = true; + + if (native_eh_) + return native_eh_->handleError (e); + else + { + typedef typename error_handler<C>::severity severity; + + severity s (severity::error); + + switch (e.getSeverity()) + { + case DOMError::DOM_SEVERITY_WARNING: + { + s = severity::warning; + break; + } + case DOMError::DOM_SEVERITY_ERROR: + { + s = severity::error; + break; + } + case DOMError::DOM_SEVERITY_FATAL_ERROR: + { + s = severity::fatal; + break; + } + } + + xercesc::DOMLocator* loc (e.getLocation ()); + +#if _XERCES_VERSION >= 30000 + return eh_->handle ( + transcode<C> (loc->getURI ()), + static_cast<unsigned long> (loc->getLineNumber ()), + static_cast<unsigned long> (loc->getColumnNumber ()), + s, + transcode<C> (e.getMessage ())); +#else + XMLSSize_t l (loc->getLineNumber ()); + XMLSSize_t c (loc->getColumnNumber ()); + + return eh_->handle ( + transcode<C> (loc->getURI ()), + (l == -1 ? 0 : static_cast<unsigned long> (l)), + (c == -1 ? 0 : static_cast<unsigned long> (c)), + s, + transcode<C> (e.getMessage ())); +#endif + } + } + } + } + } + } +} diff --git a/libxsd/xsd/cxx/xml/dom/elements.hxx b/libxsd/xsd/cxx/xml/dom/elements.hxx new file mode 100644 index 0000000..9c4623b --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/elements.hxx @@ -0,0 +1,36 @@ +// file : xsd/cxx/xml/dom/elements.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_DOM_ELEMENTS_HXX +#define XSD_CXX_XML_DOM_ELEMENTS_HXX + +#include <xercesc/dom/DOMAttr.hpp> +#include <xercesc/dom/DOMElement.hpp> + +#include <xsd/cxx/xml/qualified-name.hxx> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + template <typename C> + qualified_name<C> + name (const xercesc::DOMAttr&); + + template <typename C> + qualified_name<C> + name (const xercesc::DOMElement&); + } + } + } +} + +#include <xsd/cxx/xml/dom/elements.txx> + +#endif // XSD_CXX_XML_DOM_ELEMENTS_HXX diff --git a/libxsd/xsd/cxx/xml/dom/elements.txx b/libxsd/xsd/cxx/xml/dom/elements.txx new file mode 100644 index 0000000..0286237 --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/elements.txx @@ -0,0 +1,57 @@ +// file : xsd/cxx/xml/dom/elements.txx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include <xsd/cxx/xml/string.hxx> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + template <typename C> + qualified_name<C> + name (const xercesc::DOMAttr& a) + { + const XMLCh* n (a.getLocalName ()); + + // If this DOM doesn't support namespaces then use getName. + // + if (n != 0) + { + if (const XMLCh* ns = a.getNamespaceURI ()) + return qualified_name<C> (transcode<C> (n), transcode<C> (ns)); + else + return qualified_name<C> (transcode<C> (n)); + } + else + return qualified_name<C> (transcode<C> (a.getName ())); + } + + + template <typename C> + qualified_name<C> + name (const xercesc::DOMElement& e) + { + const XMLCh* n (e.getLocalName ()); + + // If this DOM doesn't support namespaces then use getTagName. + // + if (n != 0) + { + if (const XMLCh* ns = e.getNamespaceURI ()) + return qualified_name<C> (transcode<C> (n), transcode<C> (ns)); + else + return qualified_name<C> (transcode<C> (n)); + } + else + return qualified_name<C> (transcode<C> (e.getTagName ())); + } + } + } + } +} diff --git a/libxsd/xsd/cxx/xml/dom/parsing-header.hxx b/libxsd/xsd/cxx/xml/dom/parsing-header.hxx new file mode 100644 index 0000000..6e82c7e --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/parsing-header.hxx @@ -0,0 +1,24 @@ +// file : xsd/cxx/xml/dom/parsing-header.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_DOM_PARSING_HEADER_HXX +#define XSD_CXX_XML_DOM_PARSING_HEADER_HXX + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + template <typename C> + class parser; + } + } + } +} + +#endif // XSD_CXX_XML_DOM_PARSING_HEADER_HXX diff --git a/libxsd/xsd/cxx/xml/dom/parsing-source.hxx b/libxsd/xsd/cxx/xml/dom/parsing-source.hxx new file mode 100644 index 0000000..b6abd58 --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/parsing-source.hxx @@ -0,0 +1,138 @@ +// file : xsd/cxx/xml/dom/parsing-source.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_DOM_PARSING_SOURCE_HXX +#define XSD_CXX_XML_DOM_PARSING_SOURCE_HXX + +#include <string> + +#include <xercesc/dom/DOMNode.hpp> +#include <xercesc/dom/DOMAttr.hpp> +#include <xercesc/dom/DOMElement.hpp> +#include <xercesc/dom/DOMDocument.hpp> +#include <xercesc/dom/DOMNamedNodeMap.hpp> +#include <xercesc/dom/DOMErrorHandler.hpp> + +#include <xercesc/sax/InputSource.hpp> + +#include <xsd/cxx/xml/elements.hxx> // properies +#include <xsd/cxx/xml/error-handler.hxx> + +#include <xsd/cxx/xml/dom/auto-ptr.hxx> +#include <xsd/cxx/xml/dom/elements.hxx> // name +#include <xsd/cxx/xml/dom/parsing-header.hxx> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + // Parser state object. Can be used for parsing element, attributes, + // or both. + // + template <typename C> + class parser + { + public: + parser (const xercesc::DOMElement& e, bool ep, bool ap); + + bool + more_elements () + { + return next_element_ != 0; + } + + const xercesc::DOMElement& + cur_element () + { + return *static_cast<const xercesc::DOMElement*> (next_element_); + } + + void + next_element (); + + bool + more_attributes () + { + return as_ > ai_; + } + + const xercesc::DOMAttr& + next_attribute () + { + return *static_cast<const xercesc::DOMAttr*> (a_->item (ai_++)); + } + + void + reset_attributes () + { + ai_ = 0; + } + + const xercesc::DOMElement& + element () const + { + return element_; + } + + private: + parser (const parser&); + + parser& + operator= (const parser&); + + private: + const xercesc::DOMElement& element_; + const xercesc::DOMNode* next_element_; + + const xercesc::DOMNamedNodeMap* a_; + XMLSize_t ai_; // Index of the next DOMAttr. + XMLSize_t as_; // Cached size of a_. + }; + + + // Parsing flags. + // + const unsigned long dont_validate = 0x00000400UL; + const unsigned long no_muliple_imports = 0x00000800UL; + + template <typename C> + xml::dom::auto_ptr<xercesc::DOMDocument> + parse (xercesc::InputSource&, + error_handler<C>&, + const properties<C>&, + unsigned long flags); + + template <typename C> + xml::dom::auto_ptr<xercesc::DOMDocument> + parse (xercesc::InputSource&, + xercesc::DOMErrorHandler&, + const properties<C>&, + unsigned long flags); + + template <typename C> + xml::dom::auto_ptr<xercesc::DOMDocument> + parse (const std::basic_string<C>& uri, + error_handler<C>&, + const properties<C>&, + unsigned long flags); + + template <typename C> + xml::dom::auto_ptr<xercesc::DOMDocument> + parse (const std::basic_string<C>& uri, + xercesc::DOMErrorHandler&, + const properties<C>&, + unsigned long flags); + } + } + } +} + +#include <xsd/cxx/xml/dom/parsing-source.txx> + +#endif // XSD_CXX_XML_DOM_PARSING_SOURCE_HXX diff --git a/libxsd/xsd/cxx/xml/dom/parsing-source.txx b/libxsd/xsd/cxx/xml/dom/parsing-source.txx new file mode 100644 index 0000000..ae7ceea --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/parsing-source.txx @@ -0,0 +1,458 @@ +// file : xsd/cxx/xml/dom/parsing-source.txx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#if _XERCES_VERSION >= 30000 +# include <xercesc/dom/DOMLSParser.hpp> +#else +# include <xercesc/dom/DOMBuilder.hpp> +#endif +#include <xercesc/dom/DOMNamedNodeMap.hpp> +#include <xercesc/dom/DOMImplementation.hpp> +#include <xercesc/dom/DOMImplementationRegistry.hpp> + +#include <xercesc/util/XMLUni.hpp> // xercesc::fg* +#include <xercesc/util/XMLUniDefs.hpp> // chLatin_L, etc + +#include <xercesc/framework/Wrapper4InputSource.hpp> + +#include <xsd/cxx/xml/string.hxx> +#include <xsd/cxx/xml/dom/bits/error-handler-proxy.hxx> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + // parser + // + template <typename C> + parser<C>:: + parser (const xercesc::DOMElement& e, bool ep, bool ap) + : element_ (e), + next_element_ (0), + a_ (0), + ai_ (0) + { + using xercesc::DOMNode; + + if (ep) + { + for (next_element_ = e.getFirstChild (); + next_element_ != 0 && + next_element_->getNodeType () != DOMNode::ELEMENT_NODE; + next_element_ = next_element_->getNextSibling ()) /*noop*/; + } + + if (ap) + { + a_ = e.getAttributes (); + as_ = a_->getLength (); + } + } + + template <typename C> + void parser<C>:: + next_element () + { + using xercesc::DOMNode; + + for (next_element_ = next_element_->getNextSibling (); + next_element_ != 0 && + next_element_->getNodeType () != DOMNode::ELEMENT_NODE; + next_element_ = next_element_->getNextSibling ())/*noop*/; + } + + // parse() + // + template <typename C> + xml::dom::auto_ptr<xercesc::DOMDocument> + parse (xercesc::InputSource& is, + error_handler<C>& eh, + const properties<C>& prop, + unsigned long flags) + { + bits::error_handler_proxy<C> ehp (eh); + return xml::dom::parse (is, ehp, prop, flags); + } + + template <typename C> + auto_ptr<xercesc::DOMDocument> + parse (xercesc::InputSource& is, + xercesc::DOMErrorHandler& eh, + const properties<C>& prop, + unsigned long flags) + { + // HP aCC cannot handle using namespace xercesc; + // + using xercesc::DOMImplementationRegistry; + using xercesc::DOMImplementationLS; + using xercesc::DOMImplementation; + using xercesc::DOMDocument; +#if _XERCES_VERSION >= 30000 + using xercesc::DOMLSParser; + using xercesc::DOMConfiguration; +#else + using xercesc::DOMBuilder; +#endif + + using xercesc::Wrapper4InputSource; + using xercesc::XMLUni; + + + // Instantiate the DOM parser. + // + const XMLCh ls_id[] = {xercesc::chLatin_L, + xercesc::chLatin_S, + xercesc::chNull}; + + // Get an implementation of the Load-Store (LS) interface. + // + DOMImplementation* impl ( + DOMImplementationRegistry::getDOMImplementation (ls_id)); + +#if _XERCES_VERSION >= 30000 + auto_ptr<DOMLSParser> parser ( + impl->createLSParser (DOMImplementationLS::MODE_SYNCHRONOUS, 0)); + + DOMConfiguration* conf (parser->getDomConfig ()); + + // Discard comment nodes in the document. + // + conf->setParameter (XMLUni::fgDOMComments, false); + + // Enable datatype normalization. + // + conf->setParameter (XMLUni::fgDOMDatatypeNormalization, true); + + // Do not create EntityReference nodes in the DOM tree. No + // EntityReference nodes will be created, only the nodes + // corresponding to their fully expanded substitution text + // will be created. + // + conf->setParameter (XMLUni::fgDOMEntities, false); + + // Perform namespace processing. + // + conf->setParameter (XMLUni::fgDOMNamespaces, true); + + // Do not include ignorable whitespace in the DOM tree. + // + conf->setParameter (XMLUni::fgDOMElementContentWhitespace, false); + + if (flags & dont_validate) + { + conf->setParameter (XMLUni::fgDOMValidate, false); + conf->setParameter (XMLUni::fgXercesSchema, false); + conf->setParameter (XMLUni::fgXercesSchemaFullChecking, false); + } + else + { + conf->setParameter (XMLUni::fgDOMValidate, true); + conf->setParameter (XMLUni::fgXercesSchema, true); + + if (!(flags & no_muliple_imports)) + conf->setParameter (XMLUni::fgXercesHandleMultipleImports, true); + + // This feature checks the schema grammar for additional + // errors. We most likely do not need it when validating + // instances (assuming the schema is valid). + // + conf->setParameter (XMLUni::fgXercesSchemaFullChecking, false); + } + + // We will release DOM ourselves. + // + conf->setParameter (XMLUni::fgXercesUserAdoptsDOMDocument, true); + + + // Transfer properies if any. + // + + if (!prop.schema_location ().empty ()) + { + xml::string sl (prop.schema_location ()); + const void* v (sl.c_str ()); + + conf->setParameter ( + XMLUni::fgXercesSchemaExternalSchemaLocation, + const_cast<void*> (v)); + } + + if (!prop.no_namespace_schema_location ().empty ()) + { + xml::string sl (prop.no_namespace_schema_location ()); + const void* v (sl.c_str ()); + + conf->setParameter ( + XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation, + const_cast<void*> (v)); + } + + // Set error handler. + // + bits::error_handler_proxy<C> ehp (eh); + conf->setParameter (XMLUni::fgDOMErrorHandler, &ehp); + +#else // _XERCES_VERSION >= 30000 + + // Same as above but for Xerces-C++ 2 series. + // + auto_ptr<DOMBuilder> parser ( + impl->createDOMBuilder (DOMImplementationLS::MODE_SYNCHRONOUS, 0)); + + parser->setFeature (XMLUni::fgDOMComments, false); + parser->setFeature (XMLUni::fgDOMDatatypeNormalization, true); + parser->setFeature (XMLUni::fgDOMEntities, false); + parser->setFeature (XMLUni::fgDOMNamespaces, true); + parser->setFeature (XMLUni::fgDOMWhitespaceInElementContent, false); + + if (flags & dont_validate) + { + parser->setFeature (XMLUni::fgDOMValidation, false); + parser->setFeature (XMLUni::fgXercesSchema, false); + parser->setFeature (XMLUni::fgXercesSchemaFullChecking, false); + } + else + { + parser->setFeature (XMLUni::fgDOMValidation, true); + parser->setFeature (XMLUni::fgXercesSchema, true); + parser->setFeature (XMLUni::fgXercesSchemaFullChecking, false); + } + + parser->setFeature (XMLUni::fgXercesUserAdoptsDOMDocument, true); + + if (!prop.schema_location ().empty ()) + { + xml::string sl (prop.schema_location ()); + const void* v (sl.c_str ()); + + parser->setProperty ( + XMLUni::fgXercesSchemaExternalSchemaLocation, + const_cast<void*> (v)); + } + + if (!prop.no_namespace_schema_location ().empty ()) + { + xml::string sl (prop.no_namespace_schema_location ()); + const void* v (sl.c_str ()); + + parser->setProperty ( + XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation, + const_cast<void*> (v)); + } + + bits::error_handler_proxy<C> ehp (eh); + parser->setErrorHandler (&ehp); + +#endif // _XERCES_VERSION >= 30000 + + xercesc::Wrapper4InputSource wrap (&is, false); + +#if _XERCES_VERSION >= 30000 + auto_ptr<DOMDocument> doc (parser->parse (&wrap)); +#else + auto_ptr<DOMDocument> doc (parser->parse (wrap)); +#endif + if (ehp.failed ()) + doc.reset (); + + return doc; + } + + template <typename C> + xml::dom::auto_ptr<xercesc::DOMDocument> + parse (const std::basic_string<C>& uri, + error_handler<C>& eh, + const properties<C>& prop, + unsigned long flags) + { + bits::error_handler_proxy<C> ehp (eh); + return xml::dom::parse (uri, ehp, prop, flags); + } + + template <typename C> + auto_ptr<xercesc::DOMDocument> + parse (const std::basic_string<C>& uri, + xercesc::DOMErrorHandler& eh, + const properties<C>& prop, + unsigned long flags) + { + // HP aCC cannot handle using namespace xercesc; + // + using xercesc::DOMImplementationRegistry; + using xercesc::DOMImplementationLS; + using xercesc::DOMImplementation; + using xercesc::DOMDocument; +#if _XERCES_VERSION >= 30000 + using xercesc::DOMLSParser; + using xercesc::DOMConfiguration; +#else + using xercesc::DOMBuilder; +#endif + using xercesc::XMLUni; + + + // Instantiate the DOM parser. + // + const XMLCh ls_id[] = {xercesc::chLatin_L, + xercesc::chLatin_S, + xercesc::chNull}; + + // Get an implementation of the Load-Store (LS) interface. + // + DOMImplementation* impl ( + DOMImplementationRegistry::getDOMImplementation (ls_id)); + +#if _XERCES_VERSION >= 30000 + auto_ptr<DOMLSParser> parser ( + impl->createLSParser(DOMImplementationLS::MODE_SYNCHRONOUS, 0)); + + DOMConfiguration* conf (parser->getDomConfig ()); + + // Discard comment nodes in the document. + // + conf->setParameter (XMLUni::fgDOMComments, false); + + // Enable datatype normalization. + // + conf->setParameter (XMLUni::fgDOMDatatypeNormalization, true); + + // Do not create EntityReference nodes in the DOM tree. No + // EntityReference nodes will be created, only the nodes + // corresponding to their fully expanded substitution text + // will be created. + // + conf->setParameter (XMLUni::fgDOMEntities, false); + + // Perform namespace processing. + // + conf->setParameter (XMLUni::fgDOMNamespaces, true); + + // Do not include ignorable whitespace in the DOM tree. + // + conf->setParameter (XMLUni::fgDOMElementContentWhitespace, false); + + if (flags & dont_validate) + { + conf->setParameter (XMLUni::fgDOMValidate, false); + conf->setParameter (XMLUni::fgXercesSchema, false); + conf->setParameter (XMLUni::fgXercesSchemaFullChecking, false); + } + else + { + conf->setParameter (XMLUni::fgDOMValidate, true); + conf->setParameter (XMLUni::fgXercesSchema, true); + + if (!(flags & no_muliple_imports)) + conf->setParameter (XMLUni::fgXercesHandleMultipleImports, true); + + // This feature checks the schema grammar for additional + // errors. We most likely do not need it when validating + // instances (assuming the schema is valid). + // + conf->setParameter (XMLUni::fgXercesSchemaFullChecking, false); + } + + // We will release DOM ourselves. + // + conf->setParameter (XMLUni::fgXercesUserAdoptsDOMDocument, true); + + + // Transfer properies if any. + // + + if (!prop.schema_location ().empty ()) + { + xml::string sl (prop.schema_location ()); + const void* v (sl.c_str ()); + + conf->setParameter ( + XMLUni::fgXercesSchemaExternalSchemaLocation, + const_cast<void*> (v)); + } + + if (!prop.no_namespace_schema_location ().empty ()) + { + xml::string sl (prop.no_namespace_schema_location ()); + const void* v (sl.c_str ()); + + conf->setParameter ( + XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation, + const_cast<void*> (v)); + } + + // Set error handler. + // + bits::error_handler_proxy<C> ehp (eh); + conf->setParameter (XMLUni::fgDOMErrorHandler, &ehp); + +#else // _XERCES_VERSION >= 30000 + + // Same as above but for Xerces-C++ 2 series. + // + auto_ptr<DOMBuilder> parser ( + impl->createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS, 0)); + + parser->setFeature (XMLUni::fgDOMComments, false); + parser->setFeature (XMLUni::fgDOMDatatypeNormalization, true); + parser->setFeature (XMLUni::fgDOMEntities, false); + parser->setFeature (XMLUni::fgDOMNamespaces, true); + parser->setFeature (XMLUni::fgDOMWhitespaceInElementContent, false); + + if (flags & dont_validate) + { + parser->setFeature (XMLUni::fgDOMValidation, false); + parser->setFeature (XMLUni::fgXercesSchema, false); + parser->setFeature (XMLUni::fgXercesSchemaFullChecking, false); + } + else + { + parser->setFeature (XMLUni::fgDOMValidation, true); + parser->setFeature (XMLUni::fgXercesSchema, true); + parser->setFeature (XMLUni::fgXercesSchemaFullChecking, false); + } + + parser->setFeature (XMLUni::fgXercesUserAdoptsDOMDocument, true); + + if (!prop.schema_location ().empty ()) + { + xml::string sl (prop.schema_location ()); + const void* v (sl.c_str ()); + + parser->setProperty ( + XMLUni::fgXercesSchemaExternalSchemaLocation, + const_cast<void*> (v)); + } + + if (!prop.no_namespace_schema_location ().empty ()) + { + xml::string sl (prop.no_namespace_schema_location ()); + const void* v (sl.c_str ()); + + parser->setProperty ( + XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation, + const_cast<void*> (v)); + } + + bits::error_handler_proxy<C> ehp (eh); + parser->setErrorHandler (&ehp); + +#endif // _XERCES_VERSION >= 30000 + + auto_ptr<DOMDocument> doc ( + parser->parseURI (string (uri).c_str ())); + + if (ehp.failed ()) + doc.reset (); + + return doc; + } + } + } + } +} diff --git a/libxsd/xsd/cxx/xml/dom/serialization-header.hxx b/libxsd/xsd/cxx/xml/dom/serialization-header.hxx new file mode 100644 index 0000000..c8d836c --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/serialization-header.hxx @@ -0,0 +1,81 @@ +// file : xsd/cxx/xml/dom/serialization-header.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_DOM_SERIALIZATION_HEADER_HXX +#define XSD_CXX_XML_DOM_SERIALIZATION_HEADER_HXX + +#include <map> +#include <string> + +#include <xercesc/dom/DOMElement.hpp> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + // Find an existing prefix or establish a new one. Try to use + // hint if provided and available. + // + template <typename C> + std::basic_string<C> + prefix (const C* ns, xercesc::DOMElement&, const C* hint = 0); + + template <typename C> + inline std::basic_string<C> + prefix (const std::basic_string<C>& ns, + xercesc::DOMElement& e, + const C* hint = 0) + { + return prefix (ns.c_str (), e, hint); + } + + // + // + template <typename C> + void + clear (xercesc::DOMElement&); + + // + // + template <typename C> + class namespace_info + { + public: + typedef std::basic_string<C> string; + + namespace_info () + { + } + + namespace_info (const string& name_, const string& schema_) + : name (name_), + schema (schema_) + { + } + + std::basic_string<C> name; + std::basic_string<C> schema; + }; + + + // Map of namespace prefix to namespace_info. + // + template <typename C> + class namespace_infomap: + public std::map<std::basic_string<C>, namespace_info<C> > + { + }; + } + } + } +} + +#include <xsd/cxx/xml/dom/serialization-header.txx> + +#endif // XSD_CXX_XML_DOM_SERIALIZATION_HEADER_HXX diff --git a/libxsd/xsd/cxx/xml/dom/serialization-header.txx b/libxsd/xsd/cxx/xml/dom/serialization-header.txx new file mode 100644 index 0000000..76d3d43 --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/serialization-header.txx @@ -0,0 +1,192 @@ +// file : xsd/cxx/xml/dom/serialization-header.txx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include <vector> +#include <sstream> +#include <cstddef> // std::size_t + +#include <xercesc/dom/DOMNode.hpp> +#include <xercesc/dom/DOMAttr.hpp> +#include <xercesc/dom/DOMNamedNodeMap.hpp> + +#include <xercesc/util/XMLUni.hpp> // xercesc::fg* +#include <xercesc/util/XMLString.hpp> +#include <xercesc/validators/schema/SchemaSymbols.hpp> + +#include <xsd/cxx/xml/string.hxx> +#include <xsd/cxx/xml/bits/literals.hxx> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + // + // + template <typename C> + std::basic_string<C> + prefix (const C* ns, xercesc::DOMElement& e, const C* hint) + { + string xns (ns); + +#if _XERCES_VERSION >= 30000 + const XMLCh* p (e.lookupPrefix (xns.c_str ())); +#else + const XMLCh* p (e.lookupNamespacePrefix (xns.c_str (), false)); +#endif + if (p != 0) + return transcode<C> (p); + + if (e.isDefaultNamespace (xns.c_str ())) + return std::basic_string<C> (); + + // 'xml' prefix requires special handling and Xerces folks + // refuse to handle this in DOM so I have to do it myself. + // + if (std::basic_string<C> (ns) == xml::bits::xml_namespace<C> ()) + return xml::bits::xml_prefix<C> (); + + // No prefix for this namespace. Will need to establish one. + // + std::basic_string<C> prefix; + + if (hint != 0 && + e.lookupNamespaceURI (xml::string (hint).c_str ()) == 0) + { + prefix = hint; + } + else + { + for (unsigned long n (1);; ++n) + { + // Make finding the first few prefixes fast. + // + switch (n) + { + case 1: + { + prefix = xml::bits::first_prefix<C> (); + break; + } + case 2: + { + prefix = xml::bits::second_prefix<C> (); + break; + } + case 3: + { + prefix = xml::bits::third_prefix<C> (); + break; + } + case 4: + { + prefix = xml::bits::fourth_prefix<C> (); + break; + } + case 5: + { + prefix = xml::bits::fifth_prefix<C> (); + break; + } + default: + { + std::basic_ostringstream<C> ostr; + ostr << C ('p') << n; + prefix = ostr.str (); + break; + } + } + + if (e.lookupNamespaceURI (xml::string (prefix).c_str ()) == 0) + break; + } + } + + std::basic_string<C> name (xml::bits::xmlns_prefix<C> ()); + name += C(':'); + name += prefix; + + e.setAttributeNS ( + xercesc::XMLUni::fgXMLNSURIName, + xml::string (name).c_str (), + xns.c_str ()); + + return prefix; + } + + // + // + template <typename C> + void + clear (xercesc::DOMElement& e) + { + // HP aCC cannot handle using namespace xercesc; + // + using xercesc::DOMNode; + using xercesc::DOMAttr; + using xercesc::DOMNamedNodeMap; + using xercesc::XMLString; + using xercesc::SchemaSymbols; + + // Remove child nodes. + // + while (xercesc::DOMNode* n = e.getFirstChild ()) + { + e.removeChild (n); + n->release (); + } + + // Remove attributes. + // + DOMNamedNodeMap* att_map (e.getAttributes ()); + XMLSize_t n (att_map->getLength ()); + + if (n != 0) + { + std::vector<DOMAttr*> atts; + + // Collect all attributes to be removed while filtering + // out special cases (xmlns & xsi). + // + for (XMLSize_t i (0); i != n; ++i) + { + DOMAttr* a (static_cast<DOMAttr*> (att_map->item (i))); + const XMLCh* ns (a->getNamespaceURI ()); + + if (ns != 0) + { + if (XMLString::equals (ns, xercesc::XMLUni::fgXMLNSURIName)) + continue; + + if (XMLString::equals (ns, SchemaSymbols::fgURI_XSI)) + { + const XMLCh* name (a->getLocalName ()); + + if (XMLString::equals ( + name, SchemaSymbols::fgXSI_SCHEMALOCACTION) || + XMLString::equals ( + name, SchemaSymbols::fgXSI_NONAMESPACESCHEMALOCACTION)) + continue; + } + } + + atts.push_back (a); + } + + for (std::vector<DOMAttr*>::iterator i (atts.begin ()), + end (atts.end ()); i != end; ++i) + { + e.removeAttributeNode (*i); + (*i)->release (); + } + } + } + } + } + } +} diff --git a/libxsd/xsd/cxx/xml/dom/serialization-source.hxx b/libxsd/xsd/cxx/xml/dom/serialization-source.hxx new file mode 100644 index 0000000..4593f9c --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/serialization-source.hxx @@ -0,0 +1,152 @@ +// file : xsd/cxx/xml/dom/serialization-source.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_DOM_SERIALIZATION_SOURCE_HXX +#define XSD_CXX_XML_DOM_SERIALIZATION_SOURCE_HXX + +#include <string> +#include <ostream> + +#include <xercesc/dom/DOMAttr.hpp> +#include <xercesc/dom/DOMElement.hpp> +#include <xercesc/dom/DOMDocument.hpp> +#include <xercesc/dom/DOMErrorHandler.hpp> +#include <xercesc/framework/XMLFormatter.hpp> // XMLFormatTarget, XMLFormatter + +#include <xsd/cxx/xml/error-handler.hxx> +#include <xsd/cxx/xml/dom/auto-ptr.hxx> +#include <xsd/cxx/xml/dom/elements.hxx> // name +#include <xsd/cxx/xml/dom/serialization-header.hxx> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + // + // + template <typename C> + xercesc::DOMAttr& + create_attribute (const C* name, xercesc::DOMElement&); + + template <typename C> + xercesc::DOMAttr& + create_attribute (const C* name, const C* ns, xercesc::DOMElement&); + + template <typename C> + xercesc::DOMElement& + create_element (const C* name, xercesc::DOMElement&); + + template <typename C> + xercesc::DOMElement& + create_element (const C* name, const C* ns, xercesc::DOMElement&); + + // Serialization flags. + // + const unsigned long no_xml_declaration = 0x00010000UL; + const unsigned long dont_pretty_print = 0x00020000UL; + + template <typename C> + xml::dom::auto_ptr<xercesc::DOMDocument> + serialize (const std::basic_string<C>& root_element, + const std::basic_string<C>& root_element_namespace, + const namespace_infomap<C>& map, + unsigned long flags); + + // This one helps Sun C++ to overcome its fears. + // + template <typename C> + inline xml::dom::auto_ptr<xercesc::DOMDocument> + serialize (const C* root_element, + const C* root_element_namespace, + const namespace_infomap<C>& map, + unsigned long flags) + { + return serialize (std::basic_string<C> (root_element), + std::basic_string<C> (root_element_namespace), + map, + flags); + } + + // + // + template <typename C> + bool + serialize (xercesc::XMLFormatTarget& target, + const xercesc::DOMDocument& doc, + const std::basic_string<C>& enconding, + error_handler<C>& eh, + unsigned long flags); + + template <typename C> + bool + serialize (xercesc::XMLFormatTarget& target, + const xercesc::DOMDocument& doc, + const std::basic_string<C>& enconding, + xercesc::DOMErrorHandler& eh, + unsigned long flags); + + // + // + class ostream_format_target: public xercesc::XMLFormatTarget + { + public: + ostream_format_target (std::ostream& os) + : os_ (os) + { + } + + + public: + // I know, some of those consts are stupid. But that's what + // Xerces folks put into their interfaces and VC-7.1 thinks + // there are different signatures if one strips this fluff off. + // + virtual void + writeChars (const XMLByte* const buf, +#if _XERCES_VERSION >= 30000 + const XMLSize_t size, +#else + const unsigned int size, +#endif + xercesc::XMLFormatter* const) + { + // Ignore the data if there was a stream failure and + // the stream is not using exceptions. + // + if (!(os_.bad () || os_.fail ())) + { + os_.write (reinterpret_cast<const char*> (buf), + static_cast<std::streamsize> (size)); + } + } + + + virtual void + flush () + { + // Ignore the flush request if there was a stream failure + // and the stream is not using exceptions. + // + if (!(os_.bad () || os_.fail ())) + { + os_.flush (); + } + } + + private: + std::ostream& os_; + }; + } + } + } +} + +#include <xsd/cxx/xml/dom/serialization-source.txx> + +#endif // XSD_CXX_XML_DOM_SERIALIZATION_SOURCE_HXX diff --git a/libxsd/xsd/cxx/xml/dom/serialization-source.txx b/libxsd/xsd/cxx/xml/dom/serialization-source.txx new file mode 100644 index 0000000..5aaaaed --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/serialization-source.txx @@ -0,0 +1,394 @@ +// file : xsd/cxx/xml/dom/serialization-source.txx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include <xercesc/util/XMLUni.hpp> // xercesc::fg* +#include <xercesc/util/XMLUniDefs.hpp> // chLatin_L, etc +#include <xercesc/validators/schema/SchemaSymbols.hpp> + +#if _XERCES_VERSION >= 30000 +# include <xercesc/dom/DOMLSOutput.hpp> +# include <xercesc/dom/DOMLSSerializer.hpp> +#else +# include <xercesc/dom/DOMWriter.hpp> +#endif +#include <xercesc/dom/DOMElement.hpp> +#include <xercesc/dom/DOMImplementation.hpp> +#include <xercesc/dom/DOMImplementationRegistry.hpp> + +#include <xsd/cxx/xml/string.hxx> +#include <xsd/cxx/xml/bits/literals.hxx> +#include <xsd/cxx/xml/dom/bits/error-handler-proxy.hxx> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + // + // + template <typename C> + xercesc::DOMAttr& + create_attribute (const C* name, xercesc::DOMElement& parent) + { + xercesc::DOMDocument* doc (parent.getOwnerDocument ()); + xercesc::DOMAttr* a (doc->createAttribute (string (name).c_str ())); + parent.setAttributeNode (a); + return *a; + } + + template <typename C> + xercesc::DOMAttr& + create_attribute (const C* name, + const C* ns, + xercesc::DOMElement& parent) + { + if (ns[0] == C ('\0')) + return create_attribute (name, parent); + + xercesc::DOMDocument* doc (parent.getOwnerDocument ()); + + xercesc::DOMAttr* a; + std::basic_string<C> p (prefix<C> (ns, parent)); + + if (!p.empty ()) + { + p += ':'; + p += name; + a = doc->createAttributeNS (string (ns).c_str (), + string (p).c_str ()); + } + else + a = doc->createAttributeNS (string (ns).c_str (), + string (name).c_str ()); + + parent.setAttributeNodeNS (a); + return *a; + } + + template <typename C> + xercesc::DOMElement& + create_element (const C* name, xercesc::DOMElement& parent) + { + xercesc::DOMDocument* doc (parent.getOwnerDocument ()); + xercesc::DOMElement* e (doc->createElement (string (name).c_str ())); + parent.appendChild (e); + return *e; + } + + template <typename C> + xercesc::DOMElement& + create_element (const C* name, + const C* ns, + xercesc::DOMElement& parent) + { + if (ns[0] == C ('\0')) + return create_element (name, parent); + + xercesc::DOMDocument* doc (parent.getOwnerDocument ()); + + xercesc::DOMElement* e; + std::basic_string<C> p (prefix<C> (ns, parent)); + + if (!p.empty ()) + { + p += ':'; + p += name; + e = doc->createElementNS (string (ns).c_str (), + string (p).c_str ()); + } + else + e = doc->createElementNS (string (ns).c_str (), + string (name).c_str ()); + + parent.appendChild (e); + return *e; + } + + + // + // + template <typename C> + auto_ptr<xercesc::DOMDocument> + serialize (const std::basic_string<C>& el, + const std::basic_string<C>& ns, + const namespace_infomap<C>& map, + unsigned long) + { + // HP aCC cannot handle using namespace xercesc; + // + using xercesc::DOMImplementationRegistry; + using xercesc::DOMImplementation; + using xercesc::DOMDocument; + using xercesc::DOMElement; + + // + // + typedef std::basic_string<C> string; + typedef namespace_infomap<C> infomap; + typedef typename infomap::const_iterator infomap_iterator; + + C colon (':'), space (' '); + + string prefix; + + if (!ns.empty ()) + { + infomap_iterator i (map.begin ()), e (map.end ()); + + for ( ;i != e; ++i) + { + if (i->second.name == ns) + { + prefix = i->first; + break; + } + } + + // Since this is the first namespace in document we don't + // need to worry about conflicts. + // + if (i == e) + prefix = xml::bits::first_prefix<C> (); + } + + const XMLCh ls[] = {xercesc::chLatin_L, + xercesc::chLatin_S, + xercesc::chNull}; + + DOMImplementation* impl ( + DOMImplementationRegistry::getDOMImplementation (ls)); + + auto_ptr<DOMDocument> doc ( + impl->createDocument ( + (ns.empty () ? 0 : xml::string (ns).c_str ()), + xml::string ((prefix.empty () + ? el + : prefix + colon + el)).c_str (), + 0)); + + DOMElement* root (doc->getDocumentElement ()); + + // Check if we need to provide xsi mapping. + // + bool xsi (false); + string xsi_prefix; + string xmlns_prefix (xml::bits::xmlns_prefix<C> ()); + + for (infomap_iterator i (map.begin ()), e (map.end ()); i != e; ++i) + { + if (!i->second.schema.empty ()) + { + xsi = true; + break; + } + } + + // Check if we were told to provide xsi mapping. + // + if (xsi) + { + for (infomap_iterator i (map.begin ()), e (map.end ()); + i != e; + ++i) + { + if (i->second.name == xml::bits::xsi_namespace<C> ()) + { + xsi_prefix = i->first; + xsi = false; + break; + } + } + } + + // Create user-defined mappings. + // + for (infomap_iterator i (map.begin ()), e (map.end ()); i != e; ++i) + { + if (i->first.empty ()) + { + // Empty prefix. + // + if (!i->second.name.empty ()) + root->setAttributeNS ( + xercesc::XMLUni::fgXMLNSURIName, + xml::string (xmlns_prefix).c_str (), + xml::string (i->second.name).c_str ()); + } + else + { + root->setAttributeNS ( + xercesc::XMLUni::fgXMLNSURIName, + xml::string (xmlns_prefix + colon + i->first).c_str (), + xml::string (i->second.name).c_str ()); + } + } + + // If we were not told to provide xsi mapping but we need it + // then we will have to add it ourselves. + // + if (xsi) + xsi_prefix = dom::prefix (xml::bits::xsi_namespace<C> (), + *root, + xml::bits::xsi_prefix<C> ()); + + // Create xsi:schemaLocation and xsi:noNamespaceSchemaLocation + // attributes. + // + string schema_location; + string no_namespace_schema_location; + + for (infomap_iterator i (map.begin ()), e (map.end ()); i != e; ++i) + { + if (!i->second.schema.empty ()) + { + if (i->second.name.empty ()) + { + if (!no_namespace_schema_location.empty ()) + no_namespace_schema_location += space; + + no_namespace_schema_location += i->second.schema; + } + else + { + if (!schema_location.empty ()) + schema_location += space; + + schema_location += i->second.name + space + i->second.schema; + } + } + } + + if (!schema_location.empty ()) + { + root->setAttributeNS ( + xercesc::SchemaSymbols::fgURI_XSI, + xml::string (xsi_prefix + colon + + xml::bits::schema_location<C> ()).c_str (), + xml::string (schema_location).c_str ()); + } + + if (!no_namespace_schema_location.empty ()) + { + root->setAttributeNS ( + xercesc::SchemaSymbols::fgURI_XSI, + xml::string ( + xsi_prefix + colon + + xml::bits::no_namespace_schema_location<C> ()).c_str (), + xml::string (no_namespace_schema_location).c_str ()); + } + + return doc; + } + + + template <typename C> + bool + serialize (xercesc::XMLFormatTarget& target, + const xercesc::DOMDocument& doc, + const std::basic_string<C>& encoding, + xercesc::DOMErrorHandler& eh, + unsigned long flags) + { + // HP aCC cannot handle using namespace xercesc; + // + using xercesc::DOMImplementationRegistry; + using xercesc::DOMImplementation; +#if _XERCES_VERSION >= 30000 + using xercesc::DOMLSSerializer; + using xercesc::DOMConfiguration; + using xercesc::DOMLSOutput; +#else + using xercesc::DOMWriter; +#endif + using xercesc::XMLUni; + + const XMLCh ls[] = {xercesc::chLatin_L, + xercesc::chLatin_S, + xercesc::chNull}; + + DOMImplementation* impl ( + DOMImplementationRegistry::getDOMImplementation (ls)); + + bits::error_handler_proxy<C> ehp (eh); + +#if _XERCES_VERSION >= 30000 + xml::dom::auto_ptr<DOMLSSerializer> writer ( + impl->createLSSerializer ()); + + DOMConfiguration* conf (writer->getDomConfig ()); + + conf->setParameter (XMLUni::fgDOMErrorHandler, &ehp); + + // Set some nice features if the serializer supports them. + // + if (conf->canSetParameter ( + XMLUni::fgDOMWRTDiscardDefaultContent, true)) + conf->setParameter (XMLUni::fgDOMWRTDiscardDefaultContent, true); + + if (!(flags & dont_pretty_print) && + conf->canSetParameter (XMLUni::fgDOMWRTFormatPrettyPrint, true)) + conf->setParameter (XMLUni::fgDOMWRTFormatPrettyPrint, true); + + // See if we need to write XML declaration. + // + if ((flags & no_xml_declaration) && + conf->canSetParameter (XMLUni::fgDOMXMLDeclaration, false)) + conf->setParameter (XMLUni::fgDOMXMLDeclaration, false); + + xml::dom::auto_ptr<DOMLSOutput> out (impl->createLSOutput ()); + + out->setEncoding (xml::string (encoding).c_str ()); + out->setByteStream (&target); + + bool r (writer->write (&doc, out.get ())); +#else + xml::dom::auto_ptr<DOMWriter> writer (impl->createDOMWriter ()); + + writer->setErrorHandler (&ehp); + writer->setEncoding (xml::string (encoding).c_str ()); + + // Set some nice features if the serializer supports them. + // + if (writer->canSetFeature ( + XMLUni::fgDOMWRTDiscardDefaultContent, true)) + writer->setFeature (XMLUni::fgDOMWRTDiscardDefaultContent, true); + + if (!(flags & dont_pretty_print) && + writer->canSetFeature (XMLUni::fgDOMWRTFormatPrettyPrint, true)) + writer->setFeature (XMLUni::fgDOMWRTFormatPrettyPrint, true); + + // See if we need to write XML declaration. + // + if ((flags & no_xml_declaration) && + writer->canSetFeature (XMLUni::fgDOMXMLDeclaration, false)) + writer->setFeature (XMLUni::fgDOMXMLDeclaration, false); + + bool r (writer->writeNode (&target, doc)); +#endif + + if (!r || ehp.failed ()) + return false; + + return true; + } + + template <typename C> + bool + serialize (xercesc::XMLFormatTarget& target, + const xercesc::DOMDocument& doc, + const std::basic_string<C>& enconding, + error_handler<C>& eh, + unsigned long flags) + { + bits::error_handler_proxy<C> ehp (eh); + return serialize (target, doc, enconding, ehp, flags); + } + } + } + } +} diff --git a/libxsd/xsd/cxx/xml/dom/wildcard-source.hxx b/libxsd/xsd/cxx/xml/dom/wildcard-source.hxx new file mode 100644 index 0000000..b001f56 --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/wildcard-source.hxx @@ -0,0 +1,31 @@ +// file : xsd/cxx/xml/dom/wildcard-source.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_DOM_WILDCARD_SOURCE_HXX +#define XSD_CXX_XML_DOM_WILDCARD_SOURCE_HXX + +#include <xercesc/dom/DOMDocument.hpp> + +#include <xsd/cxx/xml/dom/auto-ptr.hxx> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + template <typename C> + xml::dom::auto_ptr<xercesc::DOMDocument> + create_document (); + } + } + } +} + +#include <xsd/cxx/xml/dom/wildcard-source.txx> + +#endif // XSD_CXX_XML_DOM_WILDCARD_SOURCE_HXX diff --git a/libxsd/xsd/cxx/xml/dom/wildcard-source.txx b/libxsd/xsd/cxx/xml/dom/wildcard-source.txx new file mode 100644 index 0000000..dcd54d2 --- /dev/null +++ b/libxsd/xsd/cxx/xml/dom/wildcard-source.txx @@ -0,0 +1,39 @@ +// file : xsd/cxx/xml/dom/wildcard-source.txx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include <xercesc/util/XMLUniDefs.hpp> // chLatin_L, etc + +#include <xercesc/dom/DOMImplementation.hpp> +#include <xercesc/dom/DOMImplementationRegistry.hpp> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace dom + { + template <typename C> + xml::dom::auto_ptr<xercesc::DOMDocument> + create_document () + { + const XMLCh ls[] = {xercesc::chLatin_L, + xercesc::chLatin_S, + xercesc::chNull}; + + // Get an implementation of the Load-Store (LS) interface. + // + xercesc::DOMImplementation* impl ( + xercesc::DOMImplementationRegistry::getDOMImplementation (ls)); + + return xml::dom::auto_ptr<xercesc::DOMDocument> ( + impl->createDocument ()); + } + } + } + } +} + diff --git a/libxsd/xsd/cxx/xml/elements.hxx b/libxsd/xsd/cxx/xml/elements.hxx new file mode 100644 index 0000000..c64afda --- /dev/null +++ b/libxsd/xsd/cxx/xml/elements.hxx @@ -0,0 +1,113 @@ +// file : xsd/cxx/xml/elements.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_ELEMENTS_HXX +#define XSD_CXX_XML_ELEMENTS_HXX + +#include <string> + +#include <xercesc/util/PlatformUtils.hpp> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + template <typename C> + class properties + { + public: + struct argument {}; + + + // Schema location properties. Note that all locations are + // relative to an instance document unless they are full + // URIs. For example if you want to use a local schema then + // you will need to use 'file:///absolute/path/to/your/schema'. + // + + // Add a location for a schema with a target namespace. + // + void + schema_location (const std::basic_string<C>& namespace_, + const std::basic_string<C>& location); + + // Add a location for a schema without a target namespace. + // + void + no_namespace_schema_location (const std::basic_string<C>& location); + + public: + const std::basic_string<C>& + schema_location () const + { + return schema_location_; + } + + const std::basic_string<C>& + no_namespace_schema_location () const + { + return no_namespace_schema_location_; + } + + private: + std::basic_string<C> schema_location_; + std::basic_string<C> no_namespace_schema_location_; + }; + + + // + // + + template <typename C> + std::basic_string<C> + prefix (const std::basic_string<C>& n); + + template <typename C> + std::basic_string<C> + uq_name (const std::basic_string<C>& n); + + + // + // + + inline void + initialize () + { + xercesc::XMLPlatformUtils::Initialize (); + } + + inline void + terminate () + { + xercesc::XMLPlatformUtils::Terminate (); + } + + struct auto_initializer + { + auto_initializer (bool initialize = true, bool terminate = true) + : terminate_ (initialize && terminate) + { + if (initialize) + xml::initialize (); + } + + ~auto_initializer () + { + if (terminate_) + terminate (); + } + + private: + bool terminate_; + }; + } + } +} + +#include <xsd/cxx/xml/elements.txx> + +#endif // XSD_CXX_XML_ELEMENTS_HXX diff --git a/libxsd/xsd/cxx/xml/elements.txx b/libxsd/xsd/cxx/xml/elements.txx new file mode 100644 index 0000000..dca6cb2 --- /dev/null +++ b/libxsd/xsd/cxx/xml/elements.txx @@ -0,0 +1,73 @@ +// file : xsd/cxx/xml/elements.txx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +namespace xsd +{ + namespace cxx + { + namespace xml + { + // properties + // + + template <typename C> + void properties<C>:: + schema_location (const std::basic_string<C>& ns, + const std::basic_string<C>& loc) + { + if (ns.empty () || loc.empty ()) + throw argument (); + + if (!schema_location_.empty ()) + schema_location_ += C (' '); + + schema_location_ += ns + C (' ') + loc; + } + + template <typename C> + void properties<C>:: + no_namespace_schema_location (const std::basic_string<C>& loc) + { + if (loc.empty ()) + throw argument (); + + if (!no_namespace_schema_location_.empty ()) + no_namespace_schema_location_ += C (' '); + + no_namespace_schema_location_ += loc; + } + + + // + // + + template <typename C> + std::basic_string<C> + prefix (const std::basic_string<C>& n) + { + std::size_t i (0); + + while (i < n.length () && n[i] != ':') + ++i; + + return std::basic_string<C> (n, i == n.length () ? i : 0, i); + } + + template <typename C> + std::basic_string<C> + uq_name (const std::basic_string<C>& n) + { + std::size_t i (0); + + while (i < n.length () && n[i] != ':') + ++i; + + return std::basic_string<C> ( + n.c_str () + (i == n.length () ? 0 : i + 1)); + } + } + } +} + diff --git a/libxsd/xsd/cxx/xml/error-handler.hxx b/libxsd/xsd/cxx/xml/error-handler.hxx new file mode 100644 index 0000000..76482b7 --- /dev/null +++ b/libxsd/xsd/cxx/xml/error-handler.hxx @@ -0,0 +1,60 @@ +// file : xsd/cxx/xml/error-handler.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_ERROR_HANDLER_HXX +#define XSD_CXX_XML_ERROR_HANDLER_HXX + +#include <string> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + template <typename C> + class error_handler + { + public: + virtual + ~error_handler () + { + } + + public: + + // The fatal severity level results in termination + // of the parsing process no matter what is returned + // from handle. + // + struct severity + { + enum value + { + warning, + error, + fatal + }; + + severity (value v) : v_ (v) {} + operator value () const { return v_; } + + private: + value v_; + }; + + virtual bool + handle (const std::basic_string<C>& id, + unsigned long line, + unsigned long column, + severity, + const std::basic_string<C>& message) = 0; + }; + } + } +} + +#endif // XSD_CXX_XML_ERROR_HANDLER_HXX + diff --git a/libxsd/xsd/cxx/xml/qualified-name.hxx b/libxsd/xsd/cxx/xml/qualified-name.hxx new file mode 100644 index 0000000..4c4dcd4 --- /dev/null +++ b/libxsd/xsd/cxx/xml/qualified-name.hxx @@ -0,0 +1,84 @@ +// file : xsd/cxx/xml/qualified-name.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_QUALIFIED_NAME_HXX +#define XSD_CXX_XML_QUALIFIED_NAME_HXX + +#include <string> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + template <typename C> + struct qualified_name + { + qualified_name (const C* name, + const C* namespace_) + : name_ (name), namespace__ (namespace_) + { + } + + qualified_name (const std::basic_string<C>& name, + const std::basic_string<C>& namespace_) + : name_ (name), namespace__ (namespace_) + { + } + + qualified_name (const C* name) + : name_ (name) + { + } + + qualified_name (const std::basic_string<C>& name) + : name_ (name) + { + } + + const std::basic_string<C>& + name () const + { + return name_; + } + + const std::basic_string<C>& + namespace_ () const + { + return namespace__; + } + + private: + std::basic_string<C> name_; + std::basic_string<C> namespace__; + }; + + template <typename C> + inline bool + operator== (const qualified_name<C>& x, const qualified_name<C>& y) + { + return x.name () == y.name () && x.namespace_ () == y.namespace_ (); + } + + template <typename C> + inline bool + operator!= (const qualified_name<C>& x, const qualified_name<C>& y) + { + return !(x == y); + } + + template <typename C> + inline bool + operator< (const qualified_name<C>& x, const qualified_name<C>& y) + { + int r (x.name ().compare (y.name ())); + return (r < 0) || (r == 0 && x.namespace_ () < y.namespace_ ()); + } + } + } +} + +#endif // XSD_CXX_XML_QUALIFIED_NAME_HXX diff --git a/libxsd/xsd/cxx/xml/sax/bits/error-handler-proxy.hxx b/libxsd/xsd/cxx/xml/sax/bits/error-handler-proxy.hxx new file mode 100644 index 0000000..7eca35b --- /dev/null +++ b/libxsd/xsd/cxx/xml/sax/bits/error-handler-proxy.hxx @@ -0,0 +1,81 @@ +// file : xsd/cxx/xml/sax/bits/error-handler-proxy.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_SAX_ERROR_HANDLER_PROXY_HXX +#define XSD_CXX_XML_SAX_ERROR_HANDLER_PROXY_HXX + +#include <xercesc/sax/ErrorHandler.hpp> +#include <xercesc/sax/SAXParseException.hpp> + +#include <xsd/cxx/xml/error-handler.hxx> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace sax + { + namespace bits + { + template <typename C> + class error_handler_proxy: public xercesc::ErrorHandler + { + public: + error_handler_proxy (error_handler<C>& eh) + : failed_ (false), eh_ (&eh), native_eh_ (0) + { + } + + error_handler_proxy (xercesc::ErrorHandler& eh) + : failed_ (false), eh_ (0), native_eh_ (&eh) + { + } + + public: + virtual void + warning (const xercesc::SAXParseException& e); + + virtual void + error (const xercesc::SAXParseException& e); + + virtual void + fatalError (const xercesc::SAXParseException& e); + + public: + bool + failed () const + { + return failed_; + } + + virtual void + resetErrors() + { + failed_ = false; + } + + private: + typedef typename error_handler<C>::severity severity; + + void + handle (const xercesc::SAXParseException&, severity); + + private: + bool failed_; + error_handler<C>* eh_; + xercesc::ErrorHandler* native_eh_; + }; + } + } + } + } +} + +#include <xsd/cxx/xml/sax/bits/error-handler-proxy.txx> + +#endif // XSD_CXX_XML_SAX_ERROR_HANDLER_PROXY_HXX + diff --git a/libxsd/xsd/cxx/xml/sax/bits/error-handler-proxy.txx b/libxsd/xsd/cxx/xml/sax/bits/error-handler-proxy.txx new file mode 100644 index 0000000..dcf2091 --- /dev/null +++ b/libxsd/xsd/cxx/xml/sax/bits/error-handler-proxy.txx @@ -0,0 +1,89 @@ +// file : xsd/cxx/xml/sax/bits/error-handler-proxy.txx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#include <xsd/cxx/xml/string.hxx> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace sax + { + namespace bits + { + template <typename C> + void error_handler_proxy<C>:: + warning (const xercesc::SAXParseException& e) + { + if (native_eh_) + native_eh_->warning (e); + else + handle (e, severity::warning); + } + + + template <typename C> + void error_handler_proxy<C>:: + error (const xercesc::SAXParseException& e) + { + failed_ = true; + + if (native_eh_) + native_eh_->error (e); + else + handle (e, severity::error); + } + + + template <typename C> + void error_handler_proxy<C>:: + fatalError (const xercesc::SAXParseException& e) + { + failed_ = true; + + if (native_eh_) + native_eh_->fatalError (e); + else + handle (e, severity::fatal); + } + + + template <typename C> + void error_handler_proxy<C>:: + handle (const xercesc::SAXParseException& e, severity s) + { + //@@ I do not honor return values from the handler. This + // is not too bad at the moment because I set + // all-errors-are-fatal flag on the parser. + // + const XMLCh* id (e.getPublicId ()); + + if (id == 0) + id = e.getSystemId (); + +#if _XERCES_VERSION >= 30000 + eh_->handle (transcode<C> (id), + static_cast<unsigned long> (e.getLineNumber ()), + static_cast<unsigned long> (e.getColumnNumber ()), + s, + transcode<C> (e.getMessage ())); +#else + XMLSSize_t l (e.getLineNumber ()); + XMLSSize_t c (e.getColumnNumber ()); + + eh_->handle (transcode<C> (id), + (l == -1 ? 0 : static_cast<unsigned long> (l)), + (c == -1 ? 0 : static_cast<unsigned long> (c)), + s, + transcode<C> (e.getMessage ())); +#endif + } + } + } + } + } +} diff --git a/libxsd/xsd/cxx/xml/sax/std-input-source.hxx b/libxsd/xsd/cxx/xml/sax/std-input-source.hxx new file mode 100644 index 0000000..f97d2c7 --- /dev/null +++ b/libxsd/xsd/cxx/xml/sax/std-input-source.hxx @@ -0,0 +1,174 @@ +// file : xsd/cxx/xml/std-sax-input-source.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_SAX_STD_INPUT_SOURCE_HXX +#define XSD_CXX_XML_SAX_STD_INPUT_SOURCE_HXX + +#include <istream> + +#include <xsd/cxx/xml/string.hxx> + +#include <xercesc/sax/InputSource.hpp> +#include <xercesc/util/BinInputStream.hpp> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace sax + { + class std_input_stream: public xercesc::BinInputStream + { + public : + std_input_stream (std::istream& is) + : is_ (is) + { + } + +#if _XERCES_VERSION >= 30000 + virtual XMLFilePos + curPos () const + { + return static_cast<XMLFilePos> (is_.tellg ()); + } +#else + virtual unsigned int + curPos () const + { + return static_cast<unsigned int> (is_.tellg ()); + } +#endif + +#if _XERCES_VERSION >= 30000 + virtual XMLSize_t + readBytes (XMLByte* const buf, const XMLSize_t size) +#else + virtual unsigned int + readBytes (XMLByte* const buf, const unsigned int size) +#endif + { + // Some implementations don't clear gcount if you + // call read() on a stream that is in the eof state. + // + if (is_.eof ()) + return 0; + + // Unset the exception failbit while we are working + // with the stream. + // + std::ios_base::iostate old (is_.exceptions ()); + is_.exceptions (old & ~std::ios_base::failbit); + + is_.read (reinterpret_cast<char*> (buf), + static_cast<std::streamsize> (size)); + + // Clear the fail bit if it was caused by eof and restore + // the original exception state. If there are any pending + // errors then the exception will be thrown now. + // + if (is_.fail () && is_.eof ()) + is_.clear (is_.rdstate () & ~std::ios_base::failbit); + + is_.exceptions (old); + + // Make sure that if we failed, readBytes won't be called + // again. + // + if (!(is_.bad () || is_.fail ())) + { +#if _XERCES_VERSION >= 30000 + return static_cast<XMLSize_t> (is_.gcount ()); +#else + return static_cast<unsigned int> (is_.gcount ()); +#endif + } + else + return 0; + } + +#if _XERCES_VERSION >= 30000 + virtual const XMLCh* + getContentType () const + { + return 0; + } +#endif + private : + std::istream& is_; + }; + + + class std_input_source: public xercesc::InputSource + { + public : + std_input_source (std::istream& is) + : is_ (&is) + { + } + + template <typename C> + std_input_source (std::istream& is, const C* system_id) + : xercesc::InputSource (xml::string (system_id).c_str ()), + is_ (&is) + { + } + + template <typename C> + std_input_source (std::istream& is, + const std::basic_string<C>& system_id) + : xercesc::InputSource (xml::string (system_id).c_str ()), + is_ (&is) + { + } + + template <typename C> + std_input_source (std::istream& is, + const C* system_id, + const C* public_id) + : xercesc::InputSource (xml::string (system_id).c_str (), + xml::string (public_id).c_str ()), + is_ (&is) + { + } + + template <typename C> + std_input_source (std::istream& is, + const std::basic_string<C>& system_id, + const std::basic_string<C>& public_id) + : xercesc::InputSource (xml::string (system_id).c_str (), + xml::string (public_id).c_str ()), + is_ (&is) + { + } + + struct copy {}; + + // Throws the copy exception if this function is called more + // than once. + // + virtual xercesc::BinInputStream* + makeStream () const + { + if (is_ == 0) + throw copy (); + + std::istream& is (*is_); + + is_ = 0; + + return new std_input_stream (is); + } + + private : + mutable std::istream* is_; + }; + } + } + } +} + +#endif // XSD_CXX_XML_SAX_STD_INPUT_SOURCE_HXX diff --git a/libxsd/xsd/cxx/xml/std-memory-manager.hxx b/libxsd/xsd/cxx/xml/std-memory-manager.hxx new file mode 100644 index 0000000..5324732 --- /dev/null +++ b/libxsd/xsd/cxx/xml/std-memory-manager.hxx @@ -0,0 +1,50 @@ +// file : xsd/cxx/xml/std-memory-manager.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_STD_MEMORY_MANAGER_HXX +#define XSD_CXX_XML_STD_MEMORY_MANAGER_HXX + +#include <new> // operator new, delete +#include <xercesc/framework/MemoryManager.hpp> + +namespace xsd +{ + namespace cxx + { + namespace xml + { + class std_memory_manager: public xercesc::MemoryManager + { + public: + virtual void* +#if _XERCES_VERSION >= 30000 + allocate(XMLSize_t size) +#else + allocate(size_t size) +#endif + { + return operator new (size); + } + + virtual void + deallocate(void* p) + { + if (p) + operator delete (p); + } + +#if _XERCES_VERSION >= 30000 + virtual xercesc::MemoryManager* + getExceptionMemoryManager() + { + return xercesc::XMLPlatformUtils::fgMemoryManager; + } +#endif + }; + } + } +} + +#endif // XSD_CXX_XML_STD_MEMORY_MANAGER_HXX diff --git a/libxsd/xsd/cxx/xml/string.hxx b/libxsd/xsd/cxx/xml/string.hxx new file mode 100644 index 0000000..2d08134 --- /dev/null +++ b/libxsd/xsd/cxx/xml/string.hxx @@ -0,0 +1,90 @@ +// file : xsd/cxx/xml/string.hxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_STRING_HXX +#define XSD_CXX_XML_STRING_HXX + +#include <string> + +#include <xsd/cxx/auto-array.hxx> +#include <xercesc/util/XercesDefs.hpp> // XMLCh + +namespace xsd +{ + namespace cxx + { + namespace xml + { + // + // + struct invalid_utf8_string {}; + struct invalid_utf16_string {}; + + + // Transcode a null-terminated string. + // + template <typename C> + std::basic_string<C> + transcode (const XMLCh* s); + + // Transcode a potentially non-null-terminated string. + // + template <typename C> + std::basic_string<C> + transcode (const XMLCh* s, std::size_t length); + + + // For VC7.1 wchar_t and XMLCh are the same type so we cannot + // overload the transcode name. You should not use these functions + // anyway and instead use the xml::string class below. + // + template <typename C> + XMLCh* + transcode_to_xmlch (const C*); + + template <typename C> + XMLCh* + transcode_to_xmlch (const std::basic_string<C>& s); + + // + // + class string + { + public : + template <typename C> + string (const std::basic_string<C>& s) + : s_ (transcode_to_xmlch<C> (s)) + { + } + + template <typename C> + string (const C* s) + : s_ (transcode_to_xmlch<C> (s)) + { + } + + const XMLCh* + c_str () const + { + return s_.get (); + } + + private: + string (const string&); + + string& + operator= (const string&); + + private: + auto_array<XMLCh> s_; + }; + } + } +} + +#endif // XSD_CXX_XML_STRING_HXX + +#include <xsd/cxx/xml/string.ixx> +#include <xsd/cxx/xml/string.txx> diff --git a/libxsd/xsd/cxx/xml/string.ixx b/libxsd/xsd/cxx/xml/string.ixx new file mode 100644 index 0000000..bde86d8 --- /dev/null +++ b/libxsd/xsd/cxx/xml/string.ixx @@ -0,0 +1,225 @@ +// file : xsd/cxx/xml/string.ixx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_STRING_IXX +#define XSD_CXX_XML_STRING_IXX + +#include <cassert> +#include <cstring> // std::memcpy + +#include <xercesc/util/XMLString.hpp> +#include <xsd/cxx/xml/std-memory-manager.hxx> + +// We sometimes need this functionality even if we are building for +// wchar_t. +// +namespace xsd +{ + namespace cxx + { + namespace xml + { +#ifndef XSD_USE_LCP + namespace bits + { + // UTF-16 to/from UTF-8 transcoder. + // + template <typename C> + struct char_transcoder + { + static std::basic_string<C> + to (const XMLCh* s, std::size_t length); + + static XMLCh* + from (const C* s, std::size_t length); + + private: + static const unsigned char first_byte_mask_[5]; + }; + } +#endif + + template <> + inline std::basic_string<char> + transcode<char> (const XMLCh* s) + { + if (s == 0) + return std::basic_string<char> (); + +#ifndef XSD_USE_LCP + return bits::char_transcoder<char>::to ( + s, xercesc::XMLString::stringLen (s)); +#else + // Use Xerces-C++ local code page transcoding. + // + std_memory_manager mm; + auto_array<char, std_memory_manager> r ( + xercesc::XMLString::transcode (s, &mm), mm); + return std::basic_string<char> (r.get ()); +#endif + } + + template <> + inline std::basic_string<char> + transcode<char> (const XMLCh* s, std::size_t len) + { + if (s == 0 || len == 0) + return std::basic_string<char> (); + +#ifndef XSD_USE_LCP + // Convert UTF-16 to UTF-8 + // + return bits::char_transcoder<char>::to (s, len); +#else + // Use Xerces-C++ local code page transcoding. + // + auto_array<XMLCh> tmp (new XMLCh[len + 1]); + std::memcpy (tmp.get (), s, len * sizeof (XMLCh)); + tmp[len] = XMLCh (0); + + std_memory_manager mm; + auto_array<char, std_memory_manager> r ( + xercesc::XMLString::transcode (tmp.get (), &mm), mm); + + tmp.reset (); + + return std::basic_string<char> (r.get ()); +#endif + } + + template <> + inline XMLCh* + transcode_to_xmlch (const char* s) + { +#ifndef XSD_USE_LCP + // Convert UTF-8 to UTF-16 + // + return bits::char_transcoder<char>::from ( + s, std::char_traits<char>::length (s)); +#else + // Use Xerces-C++ local code page transcoding. + // + std_memory_manager mm; + return xercesc::XMLString::transcode (s, &mm); +#endif + } + + template <> + inline XMLCh* + transcode_to_xmlch (const std::basic_string<char>& s) + { +#ifndef XSD_USE_LCP + // Convert UTF-8 to UTF-16 + // + return bits::char_transcoder<char>::from ( + s.c_str (), s.length ()); +#else + // Use Xerces-C++ local code page transcoding. + // + std_memory_manager mm; + return xercesc::XMLString::transcode (s.c_str (), &mm); +#endif + } + } + } +} + +#endif // XSD_CXX_XML_STRING_IXX + + +#if defined(XSD_USE_CHAR) || !defined(XSD_USE_WCHAR) + +#ifndef XSD_CXX_XML_STRING_IXX_CHAR +#define XSD_CXX_XML_STRING_IXX_CHAR + +#endif // XSD_CXX_XML_STRING_IXX_CHAR +#endif // XSD_USE_CHAR + + +#if defined(XSD_USE_WCHAR) || !defined(XSD_USE_CHAR) + +#ifndef XSD_CXX_XML_STRING_IXX_WCHAR +#define XSD_CXX_XML_STRING_IXX_WCHAR + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace bits + { + template <typename W, std::size_t S> + struct wchar_transcoder; + + // Specialization for 2-byte wchar_t (resulting encoding is UTF-16). + // + template <typename W> + struct wchar_transcoder<W, 2> + { + static std::basic_string<W> + to (const XMLCh* s, std::size_t length); + + static XMLCh* + from (const W* s, std::size_t length); + }; + + + // Specialization for 4-byte wchar_t (resulting encoding is UCS-4). + // + template <typename W> + struct wchar_transcoder<W, 4> + { + static std::basic_string<W> + to (const XMLCh* s, std::size_t length); + + static XMLCh* + from (const W* s, std::size_t length); + }; + } + + template <> + inline std::basic_string<wchar_t> + transcode<wchar_t> (const XMLCh* s) + { + if (s == 0) + return std::basic_string<wchar_t> (); + + return bits::wchar_transcoder<wchar_t, sizeof (wchar_t)>::to ( + s, xercesc::XMLString::stringLen (s)); + } + + template <> + inline std::basic_string<wchar_t> + transcode<wchar_t> (const XMLCh* s, std::size_t len) + { + if (s == 0 || len == 0) + return std::basic_string<wchar_t> (); + + return bits::wchar_transcoder<wchar_t, sizeof (wchar_t)>::to ( + s, len); + } + + template <> + inline XMLCh* + transcode_to_xmlch (const wchar_t* s) + { + return bits::wchar_transcoder<wchar_t, sizeof (wchar_t)>::from ( + s, std::char_traits<wchar_t>::length (s)); + } + + template <> + inline XMLCh* + transcode_to_xmlch (const std::basic_string<wchar_t>& s) + { + return bits::wchar_transcoder<wchar_t, sizeof (wchar_t)>::from ( + s.c_str (), s.length ()); + } + } + } +} + +#endif // XSD_CXX_XML_STRING_IXX_WCHAR +#endif // XSD_USE_WCHAR diff --git a/libxsd/xsd/cxx/xml/string.txx b/libxsd/xsd/cxx/xml/string.txx new file mode 100644 index 0000000..cdef87e --- /dev/null +++ b/libxsd/xsd/cxx/xml/string.txx @@ -0,0 +1,441 @@ +// file : xsd/cxx/xml/string.txx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2005-2009 Code Synthesis Tools CC +// license : GNU GPL v2 + exceptions; see accompanying LICENSE file + +#ifndef XSD_CXX_XML_STRING_TXX +#define XSD_CXX_XML_STRING_TXX + +#ifndef XSD_USE_LCP +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace bits + { + template <typename C> + const unsigned char char_transcoder<C>::first_byte_mask_[5] = + { + 0x00, 0x00, 0xC0, 0xE0, 0xF0 + }; + + template <typename C> + std::basic_string<C> char_transcoder<C>:: + to (const XMLCh* s, std::size_t len) + { + const XMLCh* end (s + len); + + // Find what the resulting buffer size will be. + // + std::size_t rl (0); + unsigned int u (0); // Four byte UCS-4 char. + + bool valid (true); + const XMLCh* p (s); + + for (; p < end; ++p) + { + XMLCh x (*p); + + if (x < 0xD800 || x > 0xDBFF) + u = x; + else + { + // Make sure we have one more char and it has a valid + // value for the second char in a surrogate pair. + // + if (++p == end || !((*p >= 0xDC00) && (*p <= 0xDFFF))) + { + valid = false; + break; + } + + u = ((x - 0xD800) << 10) + (*p - 0xDC00) + 0x10000; + } + + if (u < 0x80) + rl++; + else if (u < 0x800) + rl += 2; + else if (u < 0x10000) + rl += 3; + else if (u < 0x110000) + rl += 4; + else + { + valid = false; + break; + } + } + + if (!valid) + throw invalid_utf16_string (); + + std::basic_string<C> r; + r.reserve (rl + 1); + r.resize (rl); + C* rs (const_cast<C*> (r.c_str ())); + + std::size_t i (0); + unsigned int count (0); + + p = s; + + // Tight first loop for the common case. + // + for (; p < end && *p < 0x80; ++p) + rs[i++] = C (*p); + + for (; p < end; ++p) + { + XMLCh x (*p); + + if ((x >= 0xD800) && (x <= 0xDBFF)) + { + u = ((x - 0xD800) << 10) + (*++p - 0xDC00) + 0x10000; + } + else + u = x; + + if (u < 0x80) + count = 1; + else if (u < 0x800) + count = 2; + else if (u < 0x10000) + count = 3; + else if (u < 0x110000) + count = 4; + + switch(count) + { + case 4: + { + rs[i + 3] = C ((u | 0x80UL) & 0xBFUL); + u >>= 6; + } + case 3: + { + rs[i + 2] = C ((u | 0x80UL) & 0xBFUL); + u >>= 6; + } + case 2: + { + rs[i + 1] = C ((u | 0x80UL) & 0xBFUL); + u >>= 6; + } + case 1: + { + rs[i] = C (u | first_byte_mask_[count]); + } + } + + i += count; + } + + return r; + } + + template <typename C> + XMLCh* char_transcoder<C>:: + from (const C* s, std::size_t len) + { + bool valid (true); + const C* end (s + len); + + // Find what the resulting buffer size will be. + // + std::size_t rl (0); + unsigned int count (0); + + for (const C* p (s); p < end; ++p) + { + unsigned char c (*p); + + if (c < 0x80) + { + // Fast path. + // + rl += 1; + continue; + } + else if ((c >> 5) == 0x06) + count = 2; + else if ((c >> 4) == 0x0E) + count = 3; + else if ((c >> 3) == 0x1E) + count = 4; + else + { + valid = false; + break; + } + + p += count - 1; // One will be added in the for loop + + if (p + 1 > end) + { + valid = false; + break; + } + + // BMP is represented by up to 3 code points in UTF-8. + // + rl += count > 3 ? 2 : 1; + } + + if (!valid) + throw invalid_utf8_string (); + + auto_array<XMLCh> r (new XMLCh[rl + 1]); + XMLCh* ir (r.get ()); + + unsigned int u (0); // Four byte UCS-4 char. + + for (const C* p (s); p < end; ++p) + { + unsigned char c (*p); + + if (c < 0x80) + { + // Fast path. + // + *ir++ = static_cast<XMLCh> (c); + continue; + } + else if ((c >> 5) == 0x06) + { + // UTF-8: 110yyyyy 10zzzzzz + // Unicode: 00000yyy yyzzzzzz + // + u = (c & 0x1F) << 6; + + c = *++p; + if ((c >> 6) != 2) + { + valid = false; + break; + } + u |= c & 0x3F; + } + else if ((c >> 4) == 0x0E) + { + // UTF-8: 1110xxxx 10yyyyyy 10zzzzzz + // Unicode: xxxxyyyy yyzzzzzz + // + u = (c & 0x0F) << 6; + + c = *++p; + if ((c >> 6) != 2) + { + valid = false; + break; + } + u = (u | (c & 0x3F)) << 6; + + c = *++p; + if ((c >> 6) != 2) + { + valid = false; + break; + } + u |= c & 0x3F; + } + else if ((c >> 3) == 0x1E) + { + // UTF-8: 000wwwxx xxxxyyyy yyzzzzzz + // Unicode: 11110www 10xxxxxx 10yyyyyy 10zzzzzz + // + u = (c & 0x07) << 6; + + c = *++p; + if ((c >> 6) != 2) + { + valid = false; + break; + } + u = (u | (c & 0x3F)) << 6; + + c = *++p; + if ((c >> 6) != 2) + { + valid = false; + break; + } + u = (u | (c & 0x3F)) << 6; + + c = *++p; + if ((c >> 6) != 2) + { + valid = false; + break; + } + u |= c & 0x3F; + } + + if (u & 0xFFFF0000) + { + // Surrogate pair. + // + *ir++ = static_cast<XMLCh> (((u - 0x10000) >> 10) + 0xD800); + *ir++ = static_cast<XMLCh> ((u & 0x3FF) + 0xDC00); + } + else + *ir++ = static_cast<XMLCh> (u); + } + + if (!valid) + throw invalid_utf8_string (); + + *ir = XMLCh (0); + + return r.release (); + } + } + } + } +} + +#endif // XSD_USE_LCP +#endif // XSD_CXX_XML_STRING_TXX + + +#if defined(XSD_USE_WCHAR) || !defined(XSD_USE_CHAR) + +#ifndef XSD_CXX_XML_STRING_TXX_WCHAR +#define XSD_CXX_XML_STRING_TXX_WCHAR + +namespace xsd +{ + namespace cxx + { + namespace xml + { + namespace bits + { + // wchar_transcoder (specialization for 2-byte wchar_t) + // + template <typename W> + std::basic_string<W> wchar_transcoder<W, 2>:: + to (const XMLCh* s, std::size_t length) + { + std::basic_string<W> r; + r.reserve (length + 1); + r.resize (length); + W* rs (const_cast<W*> (r.c_str ())); + + for (std::size_t i (0); i < length; ++s, ++i) + { + rs[i] = *s; + } + + return r; + } + + template <typename W> + XMLCh* wchar_transcoder<W, 2>:: + from (const W* s, std::size_t length) + { + auto_array<XMLCh> r (new XMLCh[length + 1]); + XMLCh* ir (r.get ()); + + for (std::size_t i (0); i < length; ++ir, ++i) + { + *ir = static_cast<XMLCh> (s[i]); + } + + *ir = XMLCh (0); + + return r.release (); + } + + + // wchar_transcoder (specialization for 4-byte wchar_t) + // + template <typename W> + std::basic_string<W> wchar_transcoder<W, 4>:: + to (const XMLCh* s, std::size_t length) + { + const XMLCh* end (s + length); + + // Find what the resulting buffer size will be. + // + std::size_t rl (0); + + for (const XMLCh* p (s); p < end; ++p) + { + rl++; + + if ((*p >= 0xD800) && (*p <= 0xDBFF)) + { + // Make sure we have one more char and it has a valid + // value for the second char in a surrogate pair. + // + if (++p == end || !((*p >= 0xDC00) && (*p <= 0xDFFF))) + throw invalid_utf16_string (); + } + } + + std::basic_string<W> r; + r.reserve (rl + 1); + r.resize (rl); + W* rs (const_cast<W*> (r.c_str ())); + + std::size_t i (0); + + for (const XMLCh* p (s); p < end; ++p) + { + XMLCh x (*p); + + if (x < 0xD800 || x > 0xDBFF) + rs[i++] = W (x); + else + rs[i++] = ((x - 0xD800) << 10) + (*++p - 0xDC00) + 0x10000; + } + + return r; + } + + template <typename W> + XMLCh* wchar_transcoder<W, 4>:: + from (const W* s, std::size_t length) + { + // Find what the resulting buffer size will be. + // + std::size_t rl (0); + + for (const W* p (s); p < s + length; ++p) + { + rl += (*p & 0xFFFF0000) ? 2 : 1; + } + + auto_array<XMLCh> r (new XMLCh[rl + 1]); + XMLCh* ir (r.get ()); + + for (const W* p (s); p < s + length; ++p) + { + W w (*p); + + if (w & 0xFFFF0000) + { + // Surrogate pair. + // + *ir++ = static_cast<XMLCh> (((w - 0x10000) >> 10) + 0xD800); + *ir++ = static_cast<XMLCh> ((w & 0x3FF) + 0xDC00); + } + else + *ir++ = static_cast<XMLCh> (w); + } + + *ir = XMLCh (0); + + return r.release (); + } + } + } + } +} + +#endif // XSD_CXX_XML_STRING_TXX_WCHAR +#endif // XSD_USE_WCHAR |