diff options
Diffstat (limited to 'libxsd/xsd/cxx/parser/expat')
| -rw-r--r-- | libxsd/xsd/cxx/parser/expat/elements.hxx | 344 | ||||
| -rw-r--r-- | libxsd/xsd/cxx/parser/expat/elements.txx | 822 |
2 files changed, 1166 insertions, 0 deletions
diff --git a/libxsd/xsd/cxx/parser/expat/elements.hxx b/libxsd/xsd/cxx/parser/expat/elements.hxx new file mode 100644 index 0000000..a0de3e3 --- /dev/null +++ b/libxsd/xsd/cxx/parser/expat/elements.hxx @@ -0,0 +1,344 @@ +// file : xsd/cxx/parser/expat/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_PARSER_EXPAT_ELEMENTS_HXX +#define XSD_CXX_PARSER_EXPAT_ELEMENTS_HXX + +#include <string> +#include <iosfwd> +#include <cstddef> // std::size_t +#include <vector> + +#include <expat.h> + +// We only support UTF-8 expat for now. +// +#ifdef XML_UNICODE +#error UTF-16 expat (XML_UNICODE defined) is not supported +#endif + +#include <xsd/cxx/xml/error-handler.hxx> + +#include <xsd/cxx/parser/exceptions.hxx> +#include <xsd/cxx/parser/elements.hxx> +#include <xsd/cxx/parser/document.hxx> +#include <xsd/cxx/parser/error-handler.hxx> +#include <xsd/cxx/parser/schema-exceptions.hxx> + +namespace xsd +{ + namespace cxx + { + namespace parser + { + namespace expat + { + // Simple auto pointer for Expat's XML_Parser object. + // + struct parser_auto_ptr + { + ~parser_auto_ptr () + { + if (parser_ != 0) + XML_ParserFree (parser_); + } + + explicit + parser_auto_ptr (XML_Parser parser = 0) + : parser_ (parser) + { + } + + parser_auto_ptr& + operator= (XML_Parser parser) + { + if (parser_ != 0) + XML_ParserFree (parser_); + + parser_ = parser; + return *this; + } + + public: + operator XML_Parser () + { + return parser_; + } + + private: + parser_auto_ptr (const parser_auto_ptr&); + + parser_auto_ptr& + operator= (const parser_auto_ptr&); + + private: + XML_Parser parser_; + }; + + + // + // + template <typename C> + struct document: cxx::parser::document<C> // VC 7.1 likes it qualified + { + public: + document (parser_base<C>&, + const C* root_element_name, + bool polymorphic = false); + + document (parser_base<C>&, + const std::basic_string<C>& root_element_name, + bool polymorphic = false); + + document (parser_base<C>&, + const C* root_element_namespace, + const C* root_element_name, + bool polymorphic = false); + + document (parser_base<C>&, + const std::basic_string<C>& root_element_namespace, + const std::basic_string<C>& root_element_name, + bool polymorphic = false); + + protected: + document (bool polymorphic = false); + + public: + // Parse a local file. The file is accessed with std::ifstream + // in binary mode. The std::ios_base::failure exception is used + // to report io errors (badbit and failbit). + void + parse (const std::basic_string<C>& file); + + // Parse a local file with a user-provided error_handler + // object. The file is accessed with std::ifstream in binary + // mode. The std::ios_base::failure exception is used to report + // io errors (badbit and failbit). + // + void + parse (const std::basic_string<C>& file, xml::error_handler<C>&); + + public: + // System id is a "system" identifier of the resources (e.g., + // URI or a full file path). Public id is a "public" identifier + // of the resource (e.g., application-specific name or relative + // file path). System id is used to resolve relative paths. + // In diagnostics messages system id is used if public id is + // not available. Otherwise public id is used. + // + + // Parse std::istream. + // + void + parse (std::istream&); + + // Parse std::istream with a user-provided error_handler object. + // + void + parse (std::istream&, xml::error_handler<C>&); + + // Parse std::istream with a system id. + // + void + parse (std::istream&, const std::basic_string<C>& system_id); + + // Parse std::istream with a system id and a user-provided + // error_handler object. + // + void + parse (std::istream&, + const std::basic_string<C>& system_id, + xml::error_handler<C>&); + + // Parse std::istream with system and public ids. + // + void + parse (std::istream&, + const std::basic_string<C>& system_id, + const std::basic_string<C>& public_id); + + // Parse std::istream with system and public ids and a user-provided + // error_handler object. + // + void + parse (std::istream&, + const std::basic_string<C>& system_id, + const std::basic_string<C>& public_id, + xml::error_handler<C>&); + + public: + // Parse a chunk of input. You can call these functions multiple + // times with the last call having the last argument true. + // + void + parse (const void* data, std::size_t size, bool last); + + void + parse (const void* data, std::size_t size, bool last, + xml::error_handler<C>&); + + void + parse (const void* data, std::size_t size, bool last, + const std::basic_string<C>& system_id); + + void + parse (const void* data, std::size_t size, bool last, + const std::basic_string<C>& system_id, + xml::error_handler<C>&); + + void + parse (const void* data, std::size_t size, bool last, + const std::basic_string<C>& system_id, + const std::basic_string<C>& public_id); + + void + parse (const void* data, std::size_t size, bool last, + const std::basic_string<C>& system_id, + const std::basic_string<C>& public_id, + xml::error_handler<C>&); + + public: + // Low-level Expat-specific parsing API. A typical use case + // would look like this (pseudo-code): + // + // xxx_pimpl root; + // document doc (root, "root"); + // + // root.pre (); + // doc.parse_begin (xml_parser, "file.xml"); + // + // while (more_stuff_to_parse &&) + // { + // // Call XML_Parse or XML_ParseBuffer. + // + // if (status == XML_STATUS_ERROR) + // break; + // } + // + // // Call parse_end even in case of an error to translate + // // XML and Schema errors to exceptions or error_handler + // // calls. + // // + // doc.parse_end (); + // result_type result (root.post_xxx ()); + // + // Notes: + // + // 1. If your XML instances use XML namespaces, the + // XML_ParserCreateNS functions should be used to create the + // XML parser. Space (XML_Char (' ')) should be used as a + // separator (the second argument to XML_ParserCreateNS). + // + void + parse_begin (XML_Parser); + + void + parse_begin (XML_Parser, const std::basic_string<C>& public_id); + + void + parse_begin (XML_Parser, xml::error_handler<C>&); + + void + parse_begin (XML_Parser, + const std::basic_string<C>& public_id, + xml::error_handler<C>&); + void + parse_end (); + + // Event routing. + // + public: + static void XMLCALL + start_element_thunk_ (void*, const XML_Char*, const XML_Char**); + + static void XMLCALL + end_element_thunk_ (void*, const XML_Char*); + + static void XMLCALL + characters_thunk_ (void*, const XML_Char*, int); + + static void XMLCALL + start_namespace_decl_thunk_ ( + void*, const XML_Char*, const XML_Char*); + + static void XMLCALL + end_namespace_decl_thunk_ (void*, const XML_Char*); + + protected: + void + start_element_ (const XML_Char* ns_name, const XML_Char** atts); + + void + end_element_ (const XML_Char* ns_name); + + void + characters_ (const XML_Char* s, std::size_t n); + + void + start_namespace_decl_ (const XML_Char* prefix, const XML_Char* ns); + + void + end_namespace_decl_ (const XML_Char* prefix); + + protected: + void + set (); + + void + clear (); + + bool + parse (std::istream&, + const std::basic_string<C>* system_id, + const std::basic_string<C>* public_id, + xml::error_handler<C>&); + + bool + parse (const void* data, std::size_t size, bool last, + const std::basic_string<C>* system_id, + const std::basic_string<C>* public_id, + xml::error_handler<C>&); + + + void + translate_schema_exception (const schema_exception<C>& e); + + protected: + XML_Parser xml_parser_; + parser_auto_ptr auto_xml_parser_; + + xml::error_handler<C>* eh_; + error_handler<C> default_eh_; + std::basic_string<C> public_id_; + + bool polymorphic_; + + // Namespace-prefix mapping. Only maintained in the polymorphic + // case. + // + struct ns_decl + { + ns_decl (const std::basic_string<C>& p, + const std::basic_string<C>& n) + : prefix (p), ns (n) + { + } + + std::basic_string<C> prefix; + std::basic_string<C> ns; + }; + + typedef std::vector<ns_decl> ns_decls; + + ns_decls ns_decls_; + }; + } + } + } +} + +#include <xsd/cxx/parser/expat/elements.txx> + +#endif // XSD_CXX_PARSER_EXPAT_ELEMENTS_HXX diff --git a/libxsd/xsd/cxx/parser/expat/elements.txx b/libxsd/xsd/cxx/parser/expat/elements.txx new file mode 100644 index 0000000..5a60eb5 --- /dev/null +++ b/libxsd/xsd/cxx/parser/expat/elements.txx @@ -0,0 +1,822 @@ +// file : xsd/cxx/parser/expat/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 <new> // std::bad_alloc +#include <istream> +#include <fstream> +#include <cstring> // std::strchr +#include <cassert> + +#include <xsd/cxx/xml/bits/literals.hxx> // xml::bits::{xml_prefix, etc} + +namespace xsd +{ + namespace cxx + { + namespace parser + { + namespace expat + { + + // document + // + + template <typename C> + document<C>:: + document (parser_base<C>& p, + const std::basic_string<C>& name, + bool polymorphic) + : cxx::parser::document<C> (p, std::basic_string<C> (), name), + xml_parser_ (0), + eh_ (0), + polymorphic_ (polymorphic) + { + } + + template <typename C> + document<C>:: + document (parser_base<C>& p, + const C* name, + bool polymorphic) + : cxx::parser::document<C> (p, std::basic_string<C> (), name), + xml_parser_ (0), + eh_ (0), + polymorphic_ (polymorphic) + { + } + + template <typename C> + document<C>:: + document (parser_base<C>& p, + const C* ns, + const C* name, + bool polymorphic) + : cxx::parser::document<C> (p, ns, name), + xml_parser_ (0), + eh_ (0), + polymorphic_ (polymorphic) + { + } + + template <typename C> + document<C>:: + document (parser_base<C>& p, + const std::basic_string<C>& ns, + const std::basic_string<C>& name, + bool polymorphic) + : cxx::parser::document<C> (p, ns, name), + xml_parser_ (0), + eh_ (0), + polymorphic_ (polymorphic) + { + } + + template <typename C> + document<C>:: + document (bool polymorphic) + : xml_parser_ (0), + eh_ (0), + polymorphic_ (polymorphic) + { + } + + // file + // + + template <typename C> + void document<C>:: + parse (const std::basic_string<C>& file) + { + std::ifstream ifs; + ifs.exceptions (std::ios_base::badbit | std::ios_base::failbit); + ifs.open (file.c_str (), std::ios_base::in | std::ios_base::binary); + + parse (ifs, file); + } + + template <typename C> + void document<C>:: + parse (const std::basic_string<C>& file, xml::error_handler<C>& eh) + { + std::ifstream ifs; + ifs.exceptions (std::ios_base::badbit | std::ios_base::failbit); + ifs.open (file.c_str (), std::ios_base::in | std::ios_base::binary); + + parse (ifs, file, eh); + } + + + // istream + // + + template <typename C> + void document<C>:: + parse (std::istream& is) + { + parse (is, 0, 0, default_eh_); + } + + template <typename C> + void document<C>:: + parse (std::istream& is, xml::error_handler<C>& eh) + { + if (!parse (is, 0, 0, eh)) + throw parsing<C> (); + } + + template <typename C> + void document<C>:: + parse (std::istream& is, const std::basic_string<C>& system_id) + { + default_eh_.reset (); + parse (is, &system_id, 0, default_eh_); + } + + template <typename C> + void document<C>:: + parse (std::istream& is, + const std::basic_string<C>& system_id, + xml::error_handler<C>& eh) + { + if (!parse (is, &system_id, 0, eh)) + throw parsing<C> (); + } + + template <typename C> + void document<C>:: + parse (std::istream& is, + const std::basic_string<C>& system_id, + const std::basic_string<C>& public_id) + { + default_eh_.reset (); + parse (is, &system_id, &public_id, default_eh_); + } + + template <typename C> + void document<C>:: + parse (std::istream& is, + const std::basic_string<C>& system_id, + const std::basic_string<C>& public_id, + xml::error_handler<C>& eh) + { + if (!parse (is, &system_id, &public_id, eh)) + throw parsing<C> (); + } + + // data + // + + template <typename C> + void document<C>:: + parse (const void* data, std::size_t size, bool last) + { + default_eh_.reset (); + parse (data, size, last, 0, 0, default_eh_); + } + + template <typename C> + void document<C>:: + parse (const void* data, std::size_t size, bool last, + xml::error_handler<C>& eh) + { + if (!parse (data, size, last, 0, 0, eh)) + throw parsing<C> (); + } + + template <typename C> + void document<C>:: + parse (const void* data, std::size_t size, bool last, + const std::basic_string<C>& system_id) + { + default_eh_.reset (); + parse (data, size, last, &system_id, 0, default_eh_); + } + + template <typename C> + void document<C>:: + parse (const void* data, std::size_t size, bool last, + const std::basic_string<C>& system_id, + xml::error_handler<C>& eh) + { + if (!parse (data, size, last, &system_id, 0, eh)) + throw parsing<C> (); + } + + template <typename C> + void document<C>:: + parse (const void* data, std::size_t size, bool last, + const std::basic_string<C>& system_id, + const std::basic_string<C>& public_id) + { + default_eh_.reset (); + parse (data, size, last, &system_id, &public_id, default_eh_); + } + + template <typename C> + void document<C>:: + parse (const void* data, std::size_t size, bool last, + const std::basic_string<C>& system_id, + const std::basic_string<C>& public_id, + xml::error_handler<C>& eh) + { + if (!parse (data, size, last, &system_id, &public_id, eh)) + throw parsing<C> (); + } + + // Implementation details. + // + + namespace bits + { + struct stream_exception_controller + { + ~stream_exception_controller () + { + std::ios_base::iostate s = is_.rdstate (); + s &= ~std::ios_base::failbit; + + // If our error state (sans failbit) intersects with the + // exception state then that means we have an active + // exception and changing error/exception state will + // cause another to be thrown. + // + if (!(old_state_ & s)) + { + // Clear failbit if it was caused by eof. + // + if (is_.fail () && is_.eof ()) + is_.clear (s); + + is_.exceptions (old_state_); + } + } + + stream_exception_controller (std::istream& is) + : is_ (is), old_state_ (is_.exceptions ()) + { + is_.exceptions (old_state_ & ~std::ios_base::failbit); + } + + private: + stream_exception_controller (const stream_exception_controller&); + + stream_exception_controller& + operator= (const stream_exception_controller&); + + private: + std::istream& is_; + std::ios_base::iostate old_state_; + }; + }; + + template <typename C> + bool document<C>:: + parse (std::istream& is, + const std::basic_string<C>* system_id, + const std::basic_string<C>* public_id, + xml::error_handler<C>& eh) + { + parser_auto_ptr parser (XML_ParserCreateNS (0, XML_Char (' '))); + + if (parser == 0) + throw std::bad_alloc (); + + if (system_id || public_id) + parse_begin (parser, system_id ? *system_id : *public_id, eh); + else + parse_begin (parser, eh); + + // Temporarily unset the exception failbit. Also clear the + // fail bit when we reset the old state if it was caused + // by eof. + // + bits::stream_exception_controller sec (is); + + char buf[16384]; // 4 x page size. + + bool r (true); + + do + { + is.read (buf, sizeof (buf)); + + if (is.bad () || (is.fail () && !is.eof ())) + { + // If the stream is not using exceptions then the user + // will have to test for stream failures before calling + // post. + // + break; + } + + if (XML_Parse ( + parser, buf, is.gcount (), is.eof ()) == XML_STATUS_ERROR) + { + r = false; + break; + } + } while (!is.eof ()); + + parse_end (); + return r; + } + + template <typename C> + bool document<C>:: + parse (const void* data, + std::size_t size, + bool last, + const std::basic_string<C>* system_id, + const std::basic_string<C>* public_id, + xml::error_handler<C>& eh) + { + // First call. + // + if (auto_xml_parser_ == 0) + { + auto_xml_parser_ = XML_ParserCreateNS (0, XML_Char (' ')); + + if (auto_xml_parser_ == 0) + throw std::bad_alloc (); + + if (system_id || public_id) + parse_begin (auto_xml_parser_, + system_id ? *system_id : *public_id, eh); + else + parse_begin (auto_xml_parser_, eh); + } + + bool r (XML_Parse (xml_parser_, + static_cast<const char*> (data), + static_cast<int> (size), + last) != XML_STATUS_ERROR); + parse_end (); + return r; + } + + // XML_Parser + // + + template <typename C> + void document<C>:: + parse_begin (XML_Parser parser) + { + xml_parser_ = parser; + eh_ = &default_eh_; + public_id_.clear (); + set (); + } + + template <typename C> + void document<C>:: + parse_begin (XML_Parser parser, + const std::basic_string<C>& public_id) + { + xml_parser_ = parser; + eh_ = &default_eh_; + public_id_ = public_id; + set (); + } + + template <typename C> + void document<C>:: + parse_begin (XML_Parser parser, xml::error_handler<C>& eh) + { + xml_parser_ = parser; + eh_ = &eh; + public_id_.clear (); + set (); + } + + template <typename C> + void document<C>:: + parse_begin (XML_Parser parser, + const std::basic_string<C>& public_id, + xml::error_handler<C>& eh) + { + xml_parser_ = parser; + eh_ = &eh; + public_id_ = public_id; + set (); + } + + template <typename C> + void document<C>:: + parse_end () + { + XML_Error e (XML_GetErrorCode (xml_parser_)); + + if (e == XML_ERROR_NONE || e == XML_ERROR_ABORTED) + { + clear (); + xml_parser_ = 0; + auto_xml_parser_ = 0; + } + else + { + unsigned long l = XML_GetCurrentLineNumber (xml_parser_); + unsigned long c = XML_GetCurrentColumnNumber (xml_parser_); + std::basic_string<C> message (XML_ErrorString (e)); + + eh_->handle (public_id_, + l, c, + xml::error_handler<C>::severity::fatal, + message); + + clear (); + xml_parser_ = 0; + auto_xml_parser_ = 0; + + // We don't want to throw an empty parsing exception here + // since the user probably already knows about the error. + } + + if (eh_ == &default_eh_) + default_eh_.throw_if_failed (); + } + + // + // + template <typename C> + void document<C>:: + set () + { + assert (xml_parser_ != 0); + + XML_SetUserData(xml_parser_, this); + + XML_SetStartElementHandler (xml_parser_, start_element_thunk_); + XML_SetEndElementHandler (xml_parser_, end_element_thunk_); + XML_SetCharacterDataHandler (xml_parser_, characters_thunk_); + + if (polymorphic_) + { + XML_SetNamespaceDeclHandler (xml_parser_, + start_namespace_decl_thunk_, + end_namespace_decl_thunk_); + } + } + + template <typename C> + void document<C>:: + clear () + { + assert (xml_parser_ != 0); + + XML_SetUserData (xml_parser_, 0); + XML_SetStartElementHandler (xml_parser_, 0); + XML_SetEndElementHandler (xml_parser_, 0); + XML_SetCharacterDataHandler (xml_parser_, 0); + + if (polymorphic_) + XML_SetNamespaceDeclHandler (xml_parser_, 0, 0); + } + + template <typename C> + void document<C>:: + translate_schema_exception (const schema_exception<C>& e) + { + unsigned long l = XML_GetCurrentLineNumber (xml_parser_); + unsigned long c = XML_GetCurrentColumnNumber (xml_parser_); + + eh_->handle (public_id_, + l, c, + xml::error_handler<C>::severity::fatal, + e.message ()); + + XML_StopParser (xml_parser_, false); + } + + // Event routing. + // + + // Expat thunks. + // + template <typename C> + void XMLCALL document<C>:: + start_element_thunk_ (void* data, + const XML_Char* ns_name, + const XML_Char** atts) + { + document& d (*reinterpret_cast<document*> (data)); + d.start_element_ (ns_name, atts); + } + + template <typename C> + void XMLCALL document<C>:: + end_element_thunk_ (void* data, const XML_Char* ns_name) + { + document& d (*reinterpret_cast<document*> (data)); + d.end_element_ (ns_name); + } + + template <typename C> + void XMLCALL document<C>:: + characters_thunk_ (void* data, const XML_Char* s, int n) + { + document& d (*reinterpret_cast<document*> (data)); + d.characters_ (s, static_cast<std::size_t> (n)); + } + + template <typename C> + void XMLCALL document<C>:: + start_namespace_decl_thunk_ (void* data, + const XML_Char* prefix, + const XML_Char* ns) + { + document& d (*reinterpret_cast<document*> (data)); + d.start_namespace_decl_ (prefix, ns); + } + + template <typename C> + void XMLCALL document<C>:: + end_namespace_decl_thunk_ (void* data, const XML_Char* prefix) + { + document& d (*reinterpret_cast<document*> (data)); + d.end_namespace_decl_ (prefix); + } + + namespace bits + { + inline void + split_name (const XML_Char* s, + const char*& ns, std::size_t& ns_s, + const char*& name, std::size_t& name_s) + { + const char* p (std::strchr (s, ' ')); + + if (p) + { + ns = s; + ns_s = p - s; + name = p + 1; + } + else + { + ns = s; + ns_s = 0; + name = s; + } + + name_s = std::char_traits<char>::length (name); + } + } + + template <typename C> + void document<C>:: + start_element_ (const XML_Char* ns_name, const XML_Char** atts) + { + // Current Expat (2.0.0) has a (mis)-feature of a possibility of + // calling callbacks even after the non-resumable XML_StopParser + // call. The following code accounts for this. + // + { + XML_ParsingStatus s; + XML_GetParsingStatus (xml_parser_, &s); + if (s.parsing == XML_FINISHED) + return; + } + + typedef std::basic_string<C> string; + + const char* ns_p; + const char* name_p; + size_t ns_s, name_s; + + bits::split_name (ns_name, ns_p, ns_s, name_p, name_s); + + { + const ro_string<C> ns (ns_p, ns_s), name (name_p, name_s); + + if (!polymorphic_) + { + try + { + start_element (ns, name, 0); + } + catch (const schema_exception<C>& e) + { + translate_schema_exception (e); + return; + } + } + else + { + // Search for the xsi:type attribute. + // + const XML_Char** p = atts; // VC8 can't handle p (atts) + for (; *p != 0; p += 2) + { + bits::split_name (*p, ns_p, ns_s, name_p, name_s); + const ro_string<C> ns (ns_p, ns_s), name (name_p, name_s); + + if (name == xml::bits::type<C> () && + ns == xml::bits::xsi_namespace<C> ()) + break; + } + + if (*p == 0) + { + try + { + start_element (ns, name, 0); + } + catch (const schema_exception<C>& e) + { + translate_schema_exception (e); + return; + } + } + else + { + // @@ Need proper QName validation. + // + // Get the qualified type name and try to resolve it. + // + ro_string<C> qn (*(p + 1)); + + ro_string<C> tp, tn; + typename ro_string<C>::size_type pos (qn.find (C (':'))); + + try + { + if (pos != ro_string<C>::npos) + { + tp.assign (qn.data (), pos); + tn.assign (qn.data () + pos + 1); + + if (tp.empty ()) + throw dynamic_type<C> (qn); + } + else + tn.assign (qn.data (), qn.size ()); + + if (tn.empty ()) + throw dynamic_type<C> (qn); + + // Search our namespace declaration stack. Note that + // we need to do this even if prefix is empty. Sun CC + // 5.7 blows if we use const_reverse_iterator. + // + ro_string<C> tns; + for (typename ns_decls::reverse_iterator + it (ns_decls_.rbegin ()), e (ns_decls_.rend ()); + it != e; ++it) + { + if (it->prefix == tp) + { + tns.assign (it->ns); + break; + } + } + + if (!tp.empty () && tns.empty ()) + { + // The 'xml' prefix requires special handling. + // + if (tp == xml::bits::xml_prefix<C> ()) + tns.assign (xml::bits::xml_namespace<C> ()); + else + throw dynamic_type<C> (qn); + } + + // Construct the compound type id. + // + string id (tn.data (), tn.size ()); + + if (!tns.empty ()) + { + id += C (' '); + id.append (tns.data (), tns.size ()); + } + + ro_string<C> ro_id (id); + start_element (ns, name, &ro_id); + } + catch (const schema_exception<C>& e) + { + translate_schema_exception (e); + return; + } + } + } + } + + for (; *atts != 0; atts += 2) + { + bits::split_name (*atts, ns_p, ns_s, name_p, name_s); + + const ro_string<C> ns (ns_p, ns_s), name (name_p, name_s); + const ro_string<C> value (*(atts + 1)); + + try + { + attribute (ns, name, value); + } + catch (const schema_exception<C>& e) + { + translate_schema_exception (e); + break; + } + } + } + + template <typename C> + void document<C>:: + end_element_ (const XML_Char* ns_name) + { + // Current Expat (2.0.0) has a (mis)-feature of a possibility of + // calling callbacks even after the non-resumable XML_StopParser + // call. The following code accounts for this. + // + { + XML_ParsingStatus s; + XML_GetParsingStatus (xml_parser_, &s); + if (s.parsing == XML_FINISHED) + return; + } + + const char* ns_p; + const char* name_p; + size_t ns_s, name_s; + + bits::split_name (ns_name, ns_p, ns_s, name_p, name_s); + + const ro_string<C> ns (ns_p, ns_s), name (name_p, name_s); + + try + { + end_element (ns, name); + } + catch (const schema_exception<C>& e) + { + translate_schema_exception (e); + } + } + + template <typename C> + void document<C>:: + characters_ (const XML_Char* s, std::size_t n) + { + // Current Expat (2.0.0) has a (mis)-feature of a possibility of + // calling callbacks even after the non-resumable XML_StopParser + // call. The following code accounts for this. + // + { + XML_ParsingStatus s; + XML_GetParsingStatus (xml_parser_, &s); + if (s.parsing == XML_FINISHED) + return; + } + + if (n != 0) + { + const ro_string<C> str (s, n); + + try + { + characters (str); + } + catch (const schema_exception<C>& e) + { + translate_schema_exception (e); + } + } + } + + template <typename C> + void document<C>:: + start_namespace_decl_ (const XML_Char* p, const XML_Char* ns) + { + // prefix is 0 for default namespace + // namespace is 0 when unsetting default namespace + // + if (polymorphic_) + ns_decls_.push_back (ns_decl ((p ? p : ""), (ns ? ns : ""))); + } + + template <typename C> + void document<C>:: + end_namespace_decl_ (const XML_Char* p) + { + // prefix is 0 for default namespace + // + if (polymorphic_) + { + // Here we assume the prefixes are removed in the reverse + // order of them being added. This appears to how every + // sensible implementation works. + // + assert (p + ? ns_decls_.back ().prefix == p + : ns_decls_.back ().prefix.empty ()); + + ns_decls_.pop_back (); + } + } + } + } + } +} |