|
|
@@ -1,2596 +0,0 @@
|
|
|
-#ifndef RAPIDXML_HPP_INCLUDED
|
|
|
-#define RAPIDXML_HPP_INCLUDED
|
|
|
-
|
|
|
-// Copyright (C) 2006, 2009 Marcin Kalicinski
|
|
|
-// Version 1.13
|
|
|
-// Revision $DateTime: 2009/05/13 01:46:17 $
|
|
|
-//! \file rapidxml.hpp This file contains rapidxml parser and DOM implementation
|
|
|
-
|
|
|
-// If standard library is disabled, user must provide implementations of required functions and typedefs
|
|
|
-#if !defined(RAPIDXML_NO_STDLIB)
|
|
|
- #include <cstdlib> // For std::size_t
|
|
|
- #include <cassert> // For assert
|
|
|
- #include <new> // For placement new
|
|
|
-#endif
|
|
|
-
|
|
|
-// On MSVC, disable "conditional expression is constant" warning (level 4).
|
|
|
-// This warning is almost impossible to avoid with certain types of templated code
|
|
|
-#ifdef _MSC_VER
|
|
|
- #pragma warning(push)
|
|
|
- #pragma warning(disable:4127) // Conditional expression is constant
|
|
|
-#endif
|
|
|
-
|
|
|
-///////////////////////////////////////////////////////////////////////////
|
|
|
-// RAPIDXML_PARSE_ERROR
|
|
|
-
|
|
|
-#if defined(RAPIDXML_NO_EXCEPTIONS)
|
|
|
-
|
|
|
-#define RAPIDXML_PARSE_ERROR(what, where) { parse_error_handler(what, where); assert(0); }
|
|
|
-
|
|
|
-namespace rapidxml
|
|
|
-{
|
|
|
- //! When exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS,
|
|
|
- //! this function is called to notify user about the error.
|
|
|
- //! It must be defined by the user.
|
|
|
- //! <br><br>
|
|
|
- //! This function cannot return. If it does, the results are undefined.
|
|
|
- //! <br><br>
|
|
|
- //! A very simple definition might look like that:
|
|
|
- //! <pre>
|
|
|
- //! void %rapidxml::%parse_error_handler(const char *what, void *where)
|
|
|
- //! {
|
|
|
- //! std::cout << "Parse error: " << what << "\n";
|
|
|
- //! std::abort();
|
|
|
- //! }
|
|
|
- //! </pre>
|
|
|
- //! \param what Human readable description of the error.
|
|
|
- //! \param where Pointer to character data where error was detected.
|
|
|
- void parse_error_handler(const char *what, void *where);
|
|
|
-}
|
|
|
-
|
|
|
-#else
|
|
|
-
|
|
|
-#include <exception> // For std::exception
|
|
|
-
|
|
|
-#define RAPIDXML_PARSE_ERROR(what, where) throw parse_error(what, where)
|
|
|
-
|
|
|
-namespace rapidxml
|
|
|
-{
|
|
|
-
|
|
|
- //! Parse error exception.
|
|
|
- //! This exception is thrown by the parser when an error occurs.
|
|
|
- //! Use what() function to get human-readable error message.
|
|
|
- //! Use where() function to get a pointer to position within source text where error was detected.
|
|
|
- //! <br><br>
|
|
|
- //! If throwing exceptions by the parser is undesirable,
|
|
|
- //! it can be disabled by defining RAPIDXML_NO_EXCEPTIONS macro before rapidxml.hpp is included.
|
|
|
- //! This will cause the parser to call rapidxml::parse_error_handler() function instead of throwing an exception.
|
|
|
- //! This function must be defined by the user.
|
|
|
- //! <br><br>
|
|
|
- //! This class derives from <code>std::exception</code> class.
|
|
|
- class parse_error: public std::exception
|
|
|
- {
|
|
|
-
|
|
|
- public:
|
|
|
-
|
|
|
- //! Constructs parse error
|
|
|
- parse_error(const char *what, void *where)
|
|
|
- : m_what(what)
|
|
|
- , m_where(where)
|
|
|
- {
|
|
|
- }
|
|
|
-
|
|
|
- //! Gets human readable description of error.
|
|
|
- //! \return Pointer to null terminated description of the error.
|
|
|
- virtual const char *what() const throw()
|
|
|
- {
|
|
|
- return m_what;
|
|
|
- }
|
|
|
-
|
|
|
- //! Gets pointer to character data where error happened.
|
|
|
- //! Ch should be the same as char type of xml_document that produced the error.
|
|
|
- //! \return Pointer to location within the parsed string where error occured.
|
|
|
- template<class Ch>
|
|
|
- Ch *where() const
|
|
|
- {
|
|
|
- return reinterpret_cast<Ch *>(m_where);
|
|
|
- }
|
|
|
-
|
|
|
- private:
|
|
|
-
|
|
|
- const char *m_what;
|
|
|
- void *m_where;
|
|
|
-
|
|
|
- };
|
|
|
-}
|
|
|
-
|
|
|
-#endif
|
|
|
-
|
|
|
-///////////////////////////////////////////////////////////////////////////
|
|
|
-// Pool sizes
|
|
|
-
|
|
|
-#ifndef RAPIDXML_STATIC_POOL_SIZE
|
|
|
- // Size of static memory block of memory_pool.
|
|
|
- // Define RAPIDXML_STATIC_POOL_SIZE before including rapidxml.hpp if you want to override the default value.
|
|
|
- // No dynamic memory allocations are performed by memory_pool until static memory is exhausted.
|
|
|
- #define RAPIDXML_STATIC_POOL_SIZE (64 * 1024)
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifndef RAPIDXML_DYNAMIC_POOL_SIZE
|
|
|
- // Size of dynamic memory block of memory_pool.
|
|
|
- // Define RAPIDXML_DYNAMIC_POOL_SIZE before including rapidxml.hpp if you want to override the default value.
|
|
|
- // After the static block is exhausted, dynamic blocks with approximately this size are allocated by memory_pool.
|
|
|
- #define RAPIDXML_DYNAMIC_POOL_SIZE (64 * 1024)
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifndef RAPIDXML_ALIGNMENT
|
|
|
- // Memory allocation alignment.
|
|
|
- // Define RAPIDXML_ALIGNMENT before including rapidxml.hpp if you want to override the default value, which is the size of pointer.
|
|
|
- // All memory allocations for nodes, attributes and strings will be aligned to this value.
|
|
|
- // This must be a power of 2 and at least 1, otherwise memory_pool will not work.
|
|
|
- #define RAPIDXML_ALIGNMENT sizeof(void *)
|
|
|
-#endif
|
|
|
-
|
|
|
-namespace rapidxml
|
|
|
-{
|
|
|
- // Forward declarations
|
|
|
- template<class Ch> class xml_node;
|
|
|
- template<class Ch> class xml_attribute;
|
|
|
- template<class Ch> class xml_document;
|
|
|
-
|
|
|
- //! Enumeration listing all node types produced by the parser.
|
|
|
- //! Use xml_node::type() function to query node type.
|
|
|
- enum node_type
|
|
|
- {
|
|
|
- node_document, //!< A document node. Name and value are empty.
|
|
|
- node_element, //!< An element node. Name contains element name. Value contains text of first data node.
|
|
|
- node_data, //!< A data node. Name is empty. Value contains data text.
|
|
|
- node_cdata, //!< A CDATA node. Name is empty. Value contains data text.
|
|
|
- node_comment, //!< A comment node. Name is empty. Value contains comment text.
|
|
|
- node_declaration, //!< A declaration node. Name and value are empty. Declaration parameters (version, encoding and standalone) are in node attributes.
|
|
|
- node_doctype, //!< A DOCTYPE node. Name is empty. Value contains DOCTYPE text.
|
|
|
- node_pi //!< A PI node. Name contains target. Value contains instructions.
|
|
|
- };
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////
|
|
|
- // Parsing flags
|
|
|
-
|
|
|
- //! Parse flag instructing the parser to not create data nodes.
|
|
|
- //! Text of first data node will still be placed in value of parent element, unless rapidxml::parse_no_element_values flag is also specified.
|
|
|
- //! Can be combined with other flags by use of | operator.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_no_data_nodes = 0x1;
|
|
|
-
|
|
|
- //! Parse flag instructing the parser to not use text of first data node as a value of parent element.
|
|
|
- //! Can be combined with other flags by use of | operator.
|
|
|
- //! Note that child data nodes of element node take precendence over its value when printing.
|
|
|
- //! That is, if element has one or more child data nodes <em>and</em> a value, the value will be ignored.
|
|
|
- //! Use rapidxml::parse_no_data_nodes flag to prevent creation of data nodes if you want to manipulate data using values of elements.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_no_element_values = 0x2;
|
|
|
-
|
|
|
- //! Parse flag instructing the parser to not place zero terminators after strings in the source text.
|
|
|
- //! By default zero terminators are placed, modifying source text.
|
|
|
- //! Can be combined with other flags by use of | operator.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_no_string_terminators = 0x4;
|
|
|
-
|
|
|
- //! Parse flag instructing the parser to not translate entities in the source text.
|
|
|
- //! By default entities are translated, modifying source text.
|
|
|
- //! Can be combined with other flags by use of | operator.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_no_entity_translation = 0x8;
|
|
|
-
|
|
|
- //! Parse flag instructing the parser to disable UTF-8 handling and assume plain 8 bit characters.
|
|
|
- //! By default, UTF-8 handling is enabled.
|
|
|
- //! Can be combined with other flags by use of | operator.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_no_utf8 = 0x10;
|
|
|
-
|
|
|
- //! Parse flag instructing the parser to create XML declaration node.
|
|
|
- //! By default, declaration node is not created.
|
|
|
- //! Can be combined with other flags by use of | operator.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_declaration_node = 0x20;
|
|
|
-
|
|
|
- //! Parse flag instructing the parser to create comments nodes.
|
|
|
- //! By default, comment nodes are not created.
|
|
|
- //! Can be combined with other flags by use of | operator.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_comment_nodes = 0x40;
|
|
|
-
|
|
|
- //! Parse flag instructing the parser to create DOCTYPE node.
|
|
|
- //! By default, doctype node is not created.
|
|
|
- //! Although W3C specification allows at most one DOCTYPE node, RapidXml will silently accept documents with more than one.
|
|
|
- //! Can be combined with other flags by use of | operator.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_doctype_node = 0x80;
|
|
|
-
|
|
|
- //! Parse flag instructing the parser to create PI nodes.
|
|
|
- //! By default, PI nodes are not created.
|
|
|
- //! Can be combined with other flags by use of | operator.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_pi_nodes = 0x100;
|
|
|
-
|
|
|
- //! Parse flag instructing the parser to validate closing tag names.
|
|
|
- //! If not set, name inside closing tag is irrelevant to the parser.
|
|
|
- //! By default, closing tags are not validated.
|
|
|
- //! Can be combined with other flags by use of | operator.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_validate_closing_tags = 0x200;
|
|
|
-
|
|
|
- //! Parse flag instructing the parser to trim all leading and trailing whitespace of data nodes.
|
|
|
- //! By default, whitespace is not trimmed.
|
|
|
- //! This flag does not cause the parser to modify source text.
|
|
|
- //! Can be combined with other flags by use of | operator.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_trim_whitespace = 0x400;
|
|
|
-
|
|
|
- //! Parse flag instructing the parser to condense all whitespace runs of data nodes to a single space character.
|
|
|
- //! Trimming of leading and trailing whitespace of data is controlled by rapidxml::parse_trim_whitespace flag.
|
|
|
- //! By default, whitespace is not normalized.
|
|
|
- //! If this flag is specified, source text will be modified.
|
|
|
- //! Can be combined with other flags by use of | operator.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_normalize_whitespace = 0x800;
|
|
|
-
|
|
|
- // Compound flags
|
|
|
-
|
|
|
- //! Parse flags which represent default behaviour of the parser.
|
|
|
- //! This is always equal to 0, so that all other flags can be simply ored together.
|
|
|
- //! Normally there is no need to inconveniently disable flags by anding with their negated (~) values.
|
|
|
- //! This also means that meaning of each flag is a <i>negation</i> of the default setting.
|
|
|
- //! For example, if flag name is rapidxml::parse_no_utf8, it means that utf-8 is <i>enabled</i> by default,
|
|
|
- //! and using the flag will disable it.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_default = 0;
|
|
|
-
|
|
|
- //! A combination of parse flags that forbids any modifications of the source text.
|
|
|
- //! This also results in faster parsing. However, note that the following will occur:
|
|
|
- //! <ul>
|
|
|
- //! <li>names and values of nodes will not be zero terminated, you have to use xml_base::name_size() and xml_base::value_size() functions to determine where name and value ends</li>
|
|
|
- //! <li>entities will not be translated</li>
|
|
|
- //! <li>whitespace will not be normalized</li>
|
|
|
- //! </ul>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_non_destructive = parse_no_string_terminators | parse_no_entity_translation;
|
|
|
-
|
|
|
- //! A combination of parse flags resulting in fastest possible parsing, without sacrificing important data.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_fastest = parse_non_destructive | parse_no_data_nodes;
|
|
|
-
|
|
|
- //! A combination of parse flags resulting in largest amount of data being extracted.
|
|
|
- //! This usually results in slowest parsing.
|
|
|
- //! <br><br>
|
|
|
- //! See xml_document::parse() function.
|
|
|
- const int parse_full = parse_declaration_node | parse_comment_nodes | parse_doctype_node | parse_pi_nodes | parse_validate_closing_tags;
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////
|
|
|
- // Internals
|
|
|
-
|
|
|
- //! \cond internal
|
|
|
- namespace internal
|
|
|
- {
|
|
|
-
|
|
|
- // Struct that contains lookup tables for the parser
|
|
|
- // It must be a template to allow correct linking (because it has static data members, which are defined in a header file).
|
|
|
- template<int Dummy>
|
|
|
- struct lookup_tables
|
|
|
- {
|
|
|
- static const unsigned char lookup_whitespace[256]; // Whitespace table
|
|
|
- static const unsigned char lookup_node_name[256]; // Node name table
|
|
|
- static const unsigned char lookup_text[256]; // Text table
|
|
|
- static const unsigned char lookup_text_pure_no_ws[256]; // Text table
|
|
|
- static const unsigned char lookup_text_pure_with_ws[256]; // Text table
|
|
|
- static const unsigned char lookup_attribute_name[256]; // Attribute name table
|
|
|
- static const unsigned char lookup_attribute_data_1[256]; // Attribute data table with single quote
|
|
|
- static const unsigned char lookup_attribute_data_1_pure[256]; // Attribute data table with single quote
|
|
|
- static const unsigned char lookup_attribute_data_2[256]; // Attribute data table with double quotes
|
|
|
- static const unsigned char lookup_attribute_data_2_pure[256]; // Attribute data table with double quotes
|
|
|
- static const unsigned char lookup_digits[256]; // Digits
|
|
|
- static const unsigned char lookup_upcase[256]; // To uppercase conversion table for ASCII characters
|
|
|
- };
|
|
|
-
|
|
|
- // Find length of the string
|
|
|
- template<class Ch>
|
|
|
- inline std::size_t measure(const Ch *p)
|
|
|
- {
|
|
|
- const Ch *tmp = p;
|
|
|
- while (*tmp)
|
|
|
- ++tmp;
|
|
|
- return tmp - p;
|
|
|
- }
|
|
|
-
|
|
|
- // Compare strings for equality
|
|
|
- template<class Ch>
|
|
|
- inline bool compare(const Ch *p1, std::size_t size1, const Ch *p2, std::size_t size2, bool case_sensitive)
|
|
|
- {
|
|
|
- if (size1 != size2)
|
|
|
- return false;
|
|
|
- if (case_sensitive)
|
|
|
- {
|
|
|
- for (const Ch *end = p1 + size1; p1 < end; ++p1, ++p2)
|
|
|
- if (*p1 != *p2)
|
|
|
- return false;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- for (const Ch *end = p1 + size1; p1 < end; ++p1, ++p2)
|
|
|
- if (lookup_tables<0>::lookup_upcase[static_cast<unsigned char>(*p1)] != lookup_tables<0>::lookup_upcase[static_cast<unsigned char>(*p2)])
|
|
|
- return false;
|
|
|
- }
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- //! \endcond
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////
|
|
|
- // Memory pool
|
|
|
-
|
|
|
- //! This class is used by the parser to create new nodes and attributes, without overheads of dynamic memory allocation.
|
|
|
- //! In most cases, you will not need to use this class directly.
|
|
|
- //! However, if you need to create nodes manually or modify names/values of nodes,
|
|
|
- //! you are encouraged to use memory_pool of relevant xml_document to allocate the memory.
|
|
|
- //! Not only is this faster than allocating them by using <code>new</code> operator,
|
|
|
- //! but also their lifetime will be tied to the lifetime of document,
|
|
|
- //! possibly simplyfing memory management.
|
|
|
- //! <br><br>
|
|
|
- //! Call allocate_node() or allocate_attribute() functions to obtain new nodes or attributes from the pool.
|
|
|
- //! You can also call allocate_string() function to allocate strings.
|
|
|
- //! Such strings can then be used as names or values of nodes without worrying about their lifetime.
|
|
|
- //! Note that there is no <code>free()</code> function -- all allocations are freed at once when clear() function is called,
|
|
|
- //! or when the pool is destroyed.
|
|
|
- //! <br><br>
|
|
|
- //! It is also possible to create a standalone memory_pool, and use it
|
|
|
- //! to allocate nodes, whose lifetime will not be tied to any document.
|
|
|
- //! <br><br>
|
|
|
- //! Pool maintains <code>RAPIDXML_STATIC_POOL_SIZE</code> bytes of statically allocated memory.
|
|
|
- //! Until static memory is exhausted, no dynamic memory allocations are done.
|
|
|
- //! When static memory is exhausted, pool allocates additional blocks of memory of size <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> each,
|
|
|
- //! by using global <code>new[]</code> and <code>delete[]</code> operators.
|
|
|
- //! This behaviour can be changed by setting custom allocation routines.
|
|
|
- //! Use set_allocator() function to set them.
|
|
|
- //! <br><br>
|
|
|
- //! Allocations for nodes, attributes and strings are aligned at <code>RAPIDXML_ALIGNMENT</code> bytes.
|
|
|
- //! This value defaults to the size of pointer on target architecture.
|
|
|
- //! <br><br>
|
|
|
- //! To obtain absolutely top performance from the parser,
|
|
|
- //! it is important that all nodes are allocated from a single, contiguous block of memory.
|
|
|
- //! Otherwise, cache misses when jumping between two (or more) disjoint blocks of memory can slow down parsing quite considerably.
|
|
|
- //! If required, you can tweak <code>RAPIDXML_STATIC_POOL_SIZE</code>, <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> and <code>RAPIDXML_ALIGNMENT</code>
|
|
|
- //! to obtain best wasted memory to performance compromise.
|
|
|
- //! To do it, define their values before rapidxml.hpp file is included.
|
|
|
- //! \param Ch Character type of created nodes.
|
|
|
- template<class Ch = char>
|
|
|
- class memory_pool
|
|
|
- {
|
|
|
-
|
|
|
- public:
|
|
|
-
|
|
|
- //! \cond internal
|
|
|
- typedef void *(alloc_func)(std::size_t); // Type of user-defined function used to allocate memory
|
|
|
- typedef void (free_func)(void *); // Type of user-defined function used to free memory
|
|
|
- //! \endcond
|
|
|
-
|
|
|
- //! Constructs empty pool with default allocator functions.
|
|
|
- memory_pool()
|
|
|
- : m_alloc_func(0)
|
|
|
- , m_free_func(0)
|
|
|
- {
|
|
|
- init();
|
|
|
- }
|
|
|
-
|
|
|
- //! Destroys pool and frees all the memory.
|
|
|
- //! This causes memory occupied by nodes allocated by the pool to be freed.
|
|
|
- //! Nodes allocated from the pool are no longer valid.
|
|
|
- ~memory_pool()
|
|
|
- {
|
|
|
- clear();
|
|
|
- }
|
|
|
-
|
|
|
- //! Allocates a new node from the pool, and optionally assigns name and value to it.
|
|
|
- //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
|
|
|
- //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
|
|
|
- //! will call rapidxml::parse_error_handler() function.
|
|
|
- //! \param type Type of node to create.
|
|
|
- //! \param name Name to assign to the node, or 0 to assign no name.
|
|
|
- //! \param value Value to assign to the node, or 0 to assign no value.
|
|
|
- //! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.
|
|
|
- //! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.
|
|
|
- //! \return Pointer to allocated node. This pointer will never be NULL.
|
|
|
- xml_node<Ch> *allocate_node(node_type type,
|
|
|
- const Ch *name = 0, const Ch *value = 0,
|
|
|
- std::size_t name_size = 0, std::size_t value_size = 0)
|
|
|
- {
|
|
|
- void *memory = allocate_aligned(sizeof(xml_node<Ch>));
|
|
|
- xml_node<Ch> *node = new(memory) xml_node<Ch>(type);
|
|
|
- if (name)
|
|
|
- {
|
|
|
- if (name_size > 0)
|
|
|
- node->name(name, name_size);
|
|
|
- else
|
|
|
- node->name(name);
|
|
|
- }
|
|
|
- if (value)
|
|
|
- {
|
|
|
- if (value_size > 0)
|
|
|
- node->value(value, value_size);
|
|
|
- else
|
|
|
- node->value(value);
|
|
|
- }
|
|
|
- return node;
|
|
|
- }
|
|
|
-
|
|
|
- //! Allocates a new attribute from the pool, and optionally assigns name and value to it.
|
|
|
- //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
|
|
|
- //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
|
|
|
- //! will call rapidxml::parse_error_handler() function.
|
|
|
- //! \param name Name to assign to the attribute, or 0 to assign no name.
|
|
|
- //! \param value Value to assign to the attribute, or 0 to assign no value.
|
|
|
- //! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.
|
|
|
- //! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.
|
|
|
- //! \return Pointer to allocated attribute. This pointer will never be NULL.
|
|
|
- xml_attribute<Ch> *allocate_attribute(const Ch *name = 0, const Ch *value = 0,
|
|
|
- std::size_t name_size = 0, std::size_t value_size = 0)
|
|
|
- {
|
|
|
- void *memory = allocate_aligned(sizeof(xml_attribute<Ch>));
|
|
|
- xml_attribute<Ch> *attribute = new(memory) xml_attribute<Ch>;
|
|
|
- if (name)
|
|
|
- {
|
|
|
- if (name_size > 0)
|
|
|
- attribute->name(name, name_size);
|
|
|
- else
|
|
|
- attribute->name(name);
|
|
|
- }
|
|
|
- if (value)
|
|
|
- {
|
|
|
- if (value_size > 0)
|
|
|
- attribute->value(value, value_size);
|
|
|
- else
|
|
|
- attribute->value(value);
|
|
|
- }
|
|
|
- return attribute;
|
|
|
- }
|
|
|
-
|
|
|
- //! Allocates a char array of given size from the pool, and optionally copies a given string to it.
|
|
|
- //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
|
|
|
- //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
|
|
|
- //! will call rapidxml::parse_error_handler() function.
|
|
|
- //! \param source String to initialize the allocated memory with, or 0 to not initialize it.
|
|
|
- //! \param size Number of characters to allocate, or zero to calculate it automatically from source string length; if size is 0, source string must be specified and null terminated.
|
|
|
- //! \return Pointer to allocated char array. This pointer will never be NULL.
|
|
|
- Ch *allocate_string(const Ch *source = 0, std::size_t size = 0)
|
|
|
- {
|
|
|
- assert(source || size); // Either source or size (or both) must be specified
|
|
|
- if (size == 0)
|
|
|
- size = internal::measure(source) + 1;
|
|
|
- Ch *result = static_cast<Ch *>(allocate_aligned(size * sizeof(Ch)));
|
|
|
- if (source)
|
|
|
- for (std::size_t i = 0; i < size; ++i)
|
|
|
- result[i] = source[i];
|
|
|
- return result;
|
|
|
- }
|
|
|
-
|
|
|
- //! Clones an xml_node and its hierarchy of child nodes and attributes.
|
|
|
- //! Nodes and attributes are allocated from this memory pool.
|
|
|
- //! Names and values are not cloned, they are shared between the clone and the source.
|
|
|
- //! Result node can be optionally specified as a second parameter,
|
|
|
- //! in which case its contents will be replaced with cloned source node.
|
|
|
- //! This is useful when you want to clone entire document.
|
|
|
- //! \param source Node to clone.
|
|
|
- //! \param result Node to put results in, or 0 to automatically allocate result node
|
|
|
- //! \return Pointer to cloned node. This pointer will never be NULL.
|
|
|
- xml_node<Ch> *clone_node(const xml_node<Ch> *source, xml_node<Ch> *result = 0)
|
|
|
- {
|
|
|
- // Prepare result node
|
|
|
- if (result)
|
|
|
- {
|
|
|
- result->remove_all_attributes();
|
|
|
- result->remove_all_nodes();
|
|
|
- result->type(source->type());
|
|
|
- }
|
|
|
- else
|
|
|
- result = allocate_node(source->type());
|
|
|
-
|
|
|
- // Clone name and value
|
|
|
- result->name(source->name(), source->name_size());
|
|
|
- result->value(source->value(), source->value_size());
|
|
|
-
|
|
|
- // Clone child nodes and attributes
|
|
|
- for (xml_node<Ch> *child = source->first_node(); child; child = child->next_sibling())
|
|
|
- result->append_node(clone_node(child));
|
|
|
- for (xml_attribute<Ch> *attr = source->first_attribute(); attr; attr = attr->next_attribute())
|
|
|
- result->append_attribute(allocate_attribute(attr->name(), attr->value(), attr->name_size(), attr->value_size()));
|
|
|
-
|
|
|
- return result;
|
|
|
- }
|
|
|
-
|
|
|
- //! Clears the pool.
|
|
|
- //! This causes memory occupied by nodes allocated by the pool to be freed.
|
|
|
- //! Any nodes or strings allocated from the pool will no longer be valid.
|
|
|
- void clear()
|
|
|
- {
|
|
|
- while (m_begin != m_static_memory)
|
|
|
- {
|
|
|
- char *previous_begin = reinterpret_cast<header *>(align(m_begin))->previous_begin;
|
|
|
- if (m_free_func)
|
|
|
- m_free_func(m_begin);
|
|
|
- else
|
|
|
- delete[] m_begin;
|
|
|
- m_begin = previous_begin;
|
|
|
- }
|
|
|
- init();
|
|
|
- }
|
|
|
-
|
|
|
- //! Sets or resets the user-defined memory allocation functions for the pool.
|
|
|
- //! This can only be called when no memory is allocated from the pool yet, otherwise results are undefined.
|
|
|
- //! Allocation function must not return invalid pointer on failure. It should either throw,
|
|
|
- //! stop the program, or use <code>longjmp()</code> function to pass control to other place of program.
|
|
|
- //! If it returns invalid pointer, results are undefined.
|
|
|
- //! <br><br>
|
|
|
- //! User defined allocation functions must have the following forms:
|
|
|
- //! <br><code>
|
|
|
- //! <br>void *allocate(std::size_t size);
|
|
|
- //! <br>void free(void *pointer);
|
|
|
- //! </code><br>
|
|
|
- //! \param af Allocation function, or 0 to restore default function
|
|
|
- //! \param ff Free function, or 0 to restore default function
|
|
|
- void set_allocator(alloc_func *af, free_func *ff)
|
|
|
- {
|
|
|
- assert(m_begin == m_static_memory && m_ptr == align(m_begin)); // Verify that no memory is allocated yet
|
|
|
- m_alloc_func = af;
|
|
|
- m_free_func = ff;
|
|
|
- }
|
|
|
-
|
|
|
- private:
|
|
|
-
|
|
|
- struct header
|
|
|
- {
|
|
|
- char *previous_begin;
|
|
|
- };
|
|
|
-
|
|
|
- void init()
|
|
|
- {
|
|
|
- m_begin = m_static_memory;
|
|
|
- m_ptr = align(m_begin);
|
|
|
- m_end = m_static_memory + sizeof(m_static_memory);
|
|
|
- }
|
|
|
-
|
|
|
- char *align(char *ptr)
|
|
|
- {
|
|
|
- std::size_t alignment = ((RAPIDXML_ALIGNMENT - (std::size_t(ptr) & (RAPIDXML_ALIGNMENT - 1))) & (RAPIDXML_ALIGNMENT - 1));
|
|
|
- return ptr + alignment;
|
|
|
- }
|
|
|
-
|
|
|
- char *allocate_raw(std::size_t size)
|
|
|
- {
|
|
|
- // Allocate
|
|
|
- void *memory;
|
|
|
- if (m_alloc_func) // Allocate memory using either user-specified allocation function or global operator new[]
|
|
|
- {
|
|
|
- memory = m_alloc_func(size);
|
|
|
- assert(memory); // Allocator is not allowed to return 0, on failure it must either throw, stop the program or use longjmp
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- memory = new char[size];
|
|
|
-#ifdef RAPIDXML_NO_EXCEPTIONS
|
|
|
- if (!memory) // If exceptions are disabled, verify memory allocation, because new will not be able to throw bad_alloc
|
|
|
- RAPIDXML_PARSE_ERROR("out of memory", 0);
|
|
|
-#endif
|
|
|
- }
|
|
|
- return static_cast<char *>(memory);
|
|
|
- }
|
|
|
-
|
|
|
- void *allocate_aligned(std::size_t size)
|
|
|
- {
|
|
|
- // Calculate aligned pointer
|
|
|
- char *result = align(m_ptr);
|
|
|
-
|
|
|
- // If not enough memory left in current pool, allocate a new pool
|
|
|
- if (result + size > m_end)
|
|
|
- {
|
|
|
- // Calculate required pool size (may be bigger than RAPIDXML_DYNAMIC_POOL_SIZE)
|
|
|
- std::size_t pool_size = RAPIDXML_DYNAMIC_POOL_SIZE;
|
|
|
- if (pool_size < size)
|
|
|
- pool_size = size;
|
|
|
-
|
|
|
- // Allocate
|
|
|
- std::size_t alloc_size = sizeof(header) + (2 * RAPIDXML_ALIGNMENT - 2) + pool_size; // 2 alignments required in worst case: one for header, one for actual allocation
|
|
|
- char *raw_memory = allocate_raw(alloc_size);
|
|
|
-
|
|
|
- // Setup new pool in allocated memory
|
|
|
- char *pool = align(raw_memory);
|
|
|
- header *new_header = reinterpret_cast<header *>(pool);
|
|
|
- new_header->previous_begin = m_begin;
|
|
|
- m_begin = raw_memory;
|
|
|
- m_ptr = pool + sizeof(header);
|
|
|
- m_end = raw_memory + alloc_size;
|
|
|
-
|
|
|
- // Calculate aligned pointer again using new pool
|
|
|
- result = align(m_ptr);
|
|
|
- }
|
|
|
-
|
|
|
- // Update pool and return aligned pointer
|
|
|
- m_ptr = result + size;
|
|
|
- return result;
|
|
|
- }
|
|
|
-
|
|
|
- char *m_begin; // Start of raw memory making up current pool
|
|
|
- char *m_ptr; // First free byte in current pool
|
|
|
- char *m_end; // One past last available byte in current pool
|
|
|
- char m_static_memory[RAPIDXML_STATIC_POOL_SIZE]; // Static raw memory
|
|
|
- alloc_func *m_alloc_func; // Allocator function, or 0 if default is to be used
|
|
|
- free_func *m_free_func; // Free function, or 0 if default is to be used
|
|
|
- };
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // XML base
|
|
|
-
|
|
|
- //! Base class for xml_node and xml_attribute implementing common functions:
|
|
|
- //! name(), name_size(), value(), value_size() and parent().
|
|
|
- //! \param Ch Character type to use
|
|
|
- template<class Ch = char>
|
|
|
- class xml_base
|
|
|
- {
|
|
|
-
|
|
|
- public:
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // Construction & destruction
|
|
|
-
|
|
|
- // Construct a base with empty name, value and parent
|
|
|
- xml_base()
|
|
|
- : m_name(0)
|
|
|
- , m_value(0)
|
|
|
- , m_parent(0)
|
|
|
- {
|
|
|
- }
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // Node data access
|
|
|
-
|
|
|
- //! Gets name of the node.
|
|
|
- //! Interpretation of name depends on type of node.
|
|
|
- //! Note that name will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.
|
|
|
- //! <br><br>
|
|
|
- //! Use name_size() function to determine length of the name.
|
|
|
- //! \return Name of node, or empty string if node has no name.
|
|
|
- Ch *name() const
|
|
|
- {
|
|
|
- return m_name ? m_name : nullstr();
|
|
|
- }
|
|
|
-
|
|
|
- //! Gets size of node name, not including terminator character.
|
|
|
- //! This function works correctly irrespective of whether name is or is not zero terminated.
|
|
|
- //! \return Size of node name, in characters.
|
|
|
- std::size_t name_size() const
|
|
|
- {
|
|
|
- return m_name ? m_name_size : 0;
|
|
|
- }
|
|
|
-
|
|
|
- //! Gets value of node.
|
|
|
- //! Interpretation of value depends on type of node.
|
|
|
- //! Note that value will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.
|
|
|
- //! <br><br>
|
|
|
- //! Use value_size() function to determine length of the value.
|
|
|
- //! \return Value of node, or empty string if node has no value.
|
|
|
- Ch *value() const
|
|
|
- {
|
|
|
- return m_value ? m_value : nullstr();
|
|
|
- }
|
|
|
-
|
|
|
- //! Gets size of node value, not including terminator character.
|
|
|
- //! This function works correctly irrespective of whether value is or is not zero terminated.
|
|
|
- //! \return Size of node value, in characters.
|
|
|
- std::size_t value_size() const
|
|
|
- {
|
|
|
- return m_value ? m_value_size : 0;
|
|
|
- }
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // Node modification
|
|
|
-
|
|
|
- //! Sets name of node to a non zero-terminated string.
|
|
|
- //! See \ref ownership_of_strings.
|
|
|
- //! <br><br>
|
|
|
- //! Note that node does not own its name or value, it only stores a pointer to it.
|
|
|
- //! It will not delete or otherwise free the pointer on destruction.
|
|
|
- //! It is reponsibility of the user to properly manage lifetime of the string.
|
|
|
- //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
|
|
|
- //! on destruction of the document the string will be automatically freed.
|
|
|
- //! <br><br>
|
|
|
- //! Size of name must be specified separately, because name does not have to be zero terminated.
|
|
|
- //! Use name(const Ch *) function to have the length automatically calculated (string must be zero terminated).
|
|
|
- //! \param name Name of node to set. Does not have to be zero terminated.
|
|
|
- //! \param size Size of name, in characters. This does not include zero terminator, if one is present.
|
|
|
- void name(const Ch *name, std::size_t size)
|
|
|
- {
|
|
|
- m_name = const_cast<Ch *>(name);
|
|
|
- m_name_size = size;
|
|
|
- }
|
|
|
-
|
|
|
- //! Sets name of node to a zero-terminated string.
|
|
|
- //! See also \ref ownership_of_strings and xml_node::name(const Ch *, std::size_t).
|
|
|
- //! \param name Name of node to set. Must be zero terminated.
|
|
|
- void name(const Ch *name)
|
|
|
- {
|
|
|
- this->name(name, internal::measure(name));
|
|
|
- }
|
|
|
-
|
|
|
- //! Sets value of node to a non zero-terminated string.
|
|
|
- //! See \ref ownership_of_strings.
|
|
|
- //! <br><br>
|
|
|
- //! Note that node does not own its name or value, it only stores a pointer to it.
|
|
|
- //! It will not delete or otherwise free the pointer on destruction.
|
|
|
- //! It is reponsibility of the user to properly manage lifetime of the string.
|
|
|
- //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
|
|
|
- //! on destruction of the document the string will be automatically freed.
|
|
|
- //! <br><br>
|
|
|
- //! Size of value must be specified separately, because it does not have to be zero terminated.
|
|
|
- //! Use value(const Ch *) function to have the length automatically calculated (string must be zero terminated).
|
|
|
- //! <br><br>
|
|
|
- //! If an element has a child node of type node_data, it will take precedence over element value when printing.
|
|
|
- //! If you want to manipulate data of elements using values, use parser flag rapidxml::parse_no_data_nodes to prevent creation of data nodes by the parser.
|
|
|
- //! \param value value of node to set. Does not have to be zero terminated.
|
|
|
- //! \param size Size of value, in characters. This does not include zero terminator, if one is present.
|
|
|
- void value(const Ch *value, std::size_t size)
|
|
|
- {
|
|
|
- m_value = const_cast<Ch *>(value);
|
|
|
- m_value_size = size;
|
|
|
- }
|
|
|
-
|
|
|
- //! Sets value of node to a zero-terminated string.
|
|
|
- //! See also \ref ownership_of_strings and xml_node::value(const Ch *, std::size_t).
|
|
|
- //! \param value Vame of node to set. Must be zero terminated.
|
|
|
- void value(const Ch *value)
|
|
|
- {
|
|
|
- this->value(value, internal::measure(value));
|
|
|
- }
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // Related nodes access
|
|
|
-
|
|
|
- //! Gets node parent.
|
|
|
- //! \return Pointer to parent node, or 0 if there is no parent.
|
|
|
- xml_node<Ch> *parent() const
|
|
|
- {
|
|
|
- return m_parent;
|
|
|
- }
|
|
|
-
|
|
|
- protected:
|
|
|
-
|
|
|
- // Return empty string
|
|
|
- static Ch *nullstr()
|
|
|
- {
|
|
|
- static Ch zero = Ch('\0');
|
|
|
- return &zero;
|
|
|
- }
|
|
|
-
|
|
|
- Ch *m_name; // Name of node, or 0 if no name
|
|
|
- Ch *m_value; // Value of node, or 0 if no value
|
|
|
- std::size_t m_name_size; // Length of node name, or undefined of no name
|
|
|
- std::size_t m_value_size; // Length of node value, or undefined if no value
|
|
|
- xml_node<Ch> *m_parent; // Pointer to parent node, or 0 if none
|
|
|
-
|
|
|
- };
|
|
|
-
|
|
|
- //! Class representing attribute node of XML document.
|
|
|
- //! Each attribute has name and value strings, which are available through name() and value() functions (inherited from xml_base).
|
|
|
- //! Note that after parse, both name and value of attribute will point to interior of source text used for parsing.
|
|
|
- //! Thus, this text must persist in memory for the lifetime of attribute.
|
|
|
- //! \param Ch Character type to use.
|
|
|
- template<class Ch = char>
|
|
|
- class xml_attribute: public xml_base<Ch>
|
|
|
- {
|
|
|
-
|
|
|
- friend class xml_node<Ch>;
|
|
|
-
|
|
|
- public:
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // Construction & destruction
|
|
|
-
|
|
|
- //! Constructs an empty attribute with the specified type.
|
|
|
- //! Consider using memory_pool of appropriate xml_document if allocating attributes manually.
|
|
|
- xml_attribute()
|
|
|
- {
|
|
|
- }
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // Related nodes access
|
|
|
-
|
|
|
- //! Gets document of which attribute is a child.
|
|
|
- //! \return Pointer to document that contains this attribute, or 0 if there is no parent document.
|
|
|
- xml_document<Ch> *document() const
|
|
|
- {
|
|
|
- if (xml_node<Ch> *node = this->parent())
|
|
|
- {
|
|
|
- while (node->parent())
|
|
|
- node = node->parent();
|
|
|
- return node->type() == node_document ? static_cast<xml_document<Ch> *>(node) : 0;
|
|
|
- }
|
|
|
- else
|
|
|
- return 0;
|
|
|
- }
|
|
|
-
|
|
|
- //! Gets previous attribute, optionally matching attribute name.
|
|
|
- //! \param name Name of attribute to find, or 0 to return previous attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
|
|
|
- //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
|
|
|
- //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
|
|
|
- //! \return Pointer to found attribute, or 0 if not found.
|
|
|
- xml_attribute<Ch> *previous_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
|
|
|
- {
|
|
|
- if (name)
|
|
|
- {
|
|
|
- if (name_size == 0)
|
|
|
- name_size = internal::measure(name);
|
|
|
- for (xml_attribute<Ch> *attribute = m_prev_attribute; attribute; attribute = attribute->m_prev_attribute)
|
|
|
- if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
|
|
|
- return attribute;
|
|
|
- return 0;
|
|
|
- }
|
|
|
- else
|
|
|
- return this->m_parent ? m_prev_attribute : 0;
|
|
|
- }
|
|
|
-
|
|
|
- //! Gets next attribute, optionally matching attribute name.
|
|
|
- //! \param name Name of attribute to find, or 0 to return next attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
|
|
|
- //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
|
|
|
- //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
|
|
|
- //! \return Pointer to found attribute, or 0 if not found.
|
|
|
- xml_attribute<Ch> *next_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
|
|
|
- {
|
|
|
- if (name)
|
|
|
- {
|
|
|
- if (name_size == 0)
|
|
|
- name_size = internal::measure(name);
|
|
|
- for (xml_attribute<Ch> *attribute = m_next_attribute; attribute; attribute = attribute->m_next_attribute)
|
|
|
- if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
|
|
|
- return attribute;
|
|
|
- return 0;
|
|
|
- }
|
|
|
- else
|
|
|
- return this->m_parent ? m_next_attribute : 0;
|
|
|
- }
|
|
|
-
|
|
|
- private:
|
|
|
-
|
|
|
- xml_attribute<Ch> *m_prev_attribute; // Pointer to previous sibling of attribute, or 0 if none; only valid if parent is non-zero
|
|
|
- xml_attribute<Ch> *m_next_attribute; // Pointer to next sibling of attribute, or 0 if none; only valid if parent is non-zero
|
|
|
-
|
|
|
- };
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // XML node
|
|
|
-
|
|
|
- //! Class representing a node of XML document.
|
|
|
- //! Each node may have associated name and value strings, which are available through name() and value() functions.
|
|
|
- //! Interpretation of name and value depends on type of the node.
|
|
|
- //! Type of node can be determined by using type() function.
|
|
|
- //! <br><br>
|
|
|
- //! Note that after parse, both name and value of node, if any, will point interior of source text used for parsing.
|
|
|
- //! Thus, this text must persist in the memory for the lifetime of node.
|
|
|
- //! \param Ch Character type to use.
|
|
|
- template<class Ch = char>
|
|
|
- class xml_node: public xml_base<Ch>
|
|
|
- {
|
|
|
-
|
|
|
- public:
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // Construction & destruction
|
|
|
-
|
|
|
- //! Constructs an empty node with the specified type.
|
|
|
- //! Consider using memory_pool of appropriate document to allocate nodes manually.
|
|
|
- //! \param type Type of node to construct.
|
|
|
- xml_node(node_type type)
|
|
|
- : m_type(type)
|
|
|
- , m_first_node(0)
|
|
|
- , m_first_attribute(0)
|
|
|
- {
|
|
|
- }
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // Node data access
|
|
|
-
|
|
|
- //! Gets type of node.
|
|
|
- //! \return Type of node.
|
|
|
- node_type type() const
|
|
|
- {
|
|
|
- return m_type;
|
|
|
- }
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // Related nodes access
|
|
|
-
|
|
|
- //! Gets document of which node is a child.
|
|
|
- //! \return Pointer to document that contains this node, or 0 if there is no parent document.
|
|
|
- xml_document<Ch> *document() const
|
|
|
- {
|
|
|
- xml_node<Ch> *node = const_cast<xml_node<Ch> *>(this);
|
|
|
- while (node->parent())
|
|
|
- node = node->parent();
|
|
|
- return node->type() == node_document ? static_cast<xml_document<Ch> *>(node) : 0;
|
|
|
- }
|
|
|
-
|
|
|
- //! Gets first child node, optionally matching node name.
|
|
|
- //! \param name Name of child to find, or 0 to return first child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
|
|
|
- //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
|
|
|
- //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
|
|
|
- //! \return Pointer to found child, or 0 if not found.
|
|
|
- xml_node<Ch> *first_node(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
|
|
|
- {
|
|
|
- if (name)
|
|
|
- {
|
|
|
- if (name_size == 0)
|
|
|
- name_size = internal::measure(name);
|
|
|
- for (xml_node<Ch> *child = m_first_node; child; child = child->next_sibling())
|
|
|
- if (internal::compare(child->name(), child->name_size(), name, name_size, case_sensitive))
|
|
|
- return child;
|
|
|
- return 0;
|
|
|
- }
|
|
|
- else
|
|
|
- return m_first_node;
|
|
|
- }
|
|
|
-
|
|
|
- //! Gets last child node, optionally matching node name.
|
|
|
- //! Behaviour is undefined if node has no children.
|
|
|
- //! Use first_node() to test if node has children.
|
|
|
- //! \param name Name of child to find, or 0 to return last child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
|
|
|
- //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
|
|
|
- //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
|
|
|
- //! \return Pointer to found child, or 0 if not found.
|
|
|
- xml_node<Ch> *last_node(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
|
|
|
- {
|
|
|
- assert(m_first_node); // Cannot query for last child if node has no children
|
|
|
- if (name)
|
|
|
- {
|
|
|
- if (name_size == 0)
|
|
|
- name_size = internal::measure(name);
|
|
|
- for (xml_node<Ch> *child = m_last_node; child; child = child->previous_sibling())
|
|
|
- if (internal::compare(child->name(), child->name_size(), name, name_size, case_sensitive))
|
|
|
- return child;
|
|
|
- return 0;
|
|
|
- }
|
|
|
- else
|
|
|
- return m_last_node;
|
|
|
- }
|
|
|
-
|
|
|
- //! Gets previous sibling node, optionally matching node name.
|
|
|
- //! Behaviour is undefined if node has no parent.
|
|
|
- //! Use parent() to test if node has a parent.
|
|
|
- //! \param name Name of sibling to find, or 0 to return previous sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
|
|
|
- //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
|
|
|
- //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
|
|
|
- //! \return Pointer to found sibling, or 0 if not found.
|
|
|
- xml_node<Ch> *previous_sibling(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
|
|
|
- {
|
|
|
- assert(this->m_parent); // Cannot query for siblings if node has no parent
|
|
|
- if (name)
|
|
|
- {
|
|
|
- if (name_size == 0)
|
|
|
- name_size = internal::measure(name);
|
|
|
- for (xml_node<Ch> *sibling = m_prev_sibling; sibling; sibling = sibling->m_prev_sibling)
|
|
|
- if (internal::compare(sibling->name(), sibling->name_size(), name, name_size, case_sensitive))
|
|
|
- return sibling;
|
|
|
- return 0;
|
|
|
- }
|
|
|
- else
|
|
|
- return m_prev_sibling;
|
|
|
- }
|
|
|
-
|
|
|
- //! Gets next sibling node, optionally matching node name.
|
|
|
- //! Behaviour is undefined if node has no parent.
|
|
|
- //! Use parent() to test if node has a parent.
|
|
|
- //! \param name Name of sibling to find, or 0 to return next sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
|
|
|
- //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
|
|
|
- //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
|
|
|
- //! \return Pointer to found sibling, or 0 if not found.
|
|
|
- xml_node<Ch> *next_sibling(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
|
|
|
- {
|
|
|
- assert(this->m_parent); // Cannot query for siblings if node has no parent
|
|
|
- if (name)
|
|
|
- {
|
|
|
- if (name_size == 0)
|
|
|
- name_size = internal::measure(name);
|
|
|
- for (xml_node<Ch> *sibling = m_next_sibling; sibling; sibling = sibling->m_next_sibling)
|
|
|
- if (internal::compare(sibling->name(), sibling->name_size(), name, name_size, case_sensitive))
|
|
|
- return sibling;
|
|
|
- return 0;
|
|
|
- }
|
|
|
- else
|
|
|
- return m_next_sibling;
|
|
|
- }
|
|
|
-
|
|
|
- //! Gets first attribute of node, optionally matching attribute name.
|
|
|
- //! \param name Name of attribute to find, or 0 to return first attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
|
|
|
- //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
|
|
|
- //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
|
|
|
- //! \return Pointer to found attribute, or 0 if not found.
|
|
|
- xml_attribute<Ch> *first_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
|
|
|
- {
|
|
|
- if (name)
|
|
|
- {
|
|
|
- if (name_size == 0)
|
|
|
- name_size = internal::measure(name);
|
|
|
- for (xml_attribute<Ch> *attribute = m_first_attribute; attribute; attribute = attribute->m_next_attribute)
|
|
|
- if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
|
|
|
- return attribute;
|
|
|
- return 0;
|
|
|
- }
|
|
|
- else
|
|
|
- return m_first_attribute;
|
|
|
- }
|
|
|
-
|
|
|
- //! Gets last attribute of node, optionally matching attribute name.
|
|
|
- //! \param name Name of attribute to find, or 0 to return last attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
|
|
|
- //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
|
|
|
- //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
|
|
|
- //! \return Pointer to found attribute, or 0 if not found.
|
|
|
- xml_attribute<Ch> *last_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
|
|
|
- {
|
|
|
- if (name)
|
|
|
- {
|
|
|
- if (name_size == 0)
|
|
|
- name_size = internal::measure(name);
|
|
|
- for (xml_attribute<Ch> *attribute = m_last_attribute; attribute; attribute = attribute->m_prev_attribute)
|
|
|
- if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
|
|
|
- return attribute;
|
|
|
- return 0;
|
|
|
- }
|
|
|
- else
|
|
|
- return m_first_attribute ? m_last_attribute : 0;
|
|
|
- }
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // Node modification
|
|
|
-
|
|
|
- //! Sets type of node.
|
|
|
- //! \param type Type of node to set.
|
|
|
- void type(node_type type)
|
|
|
- {
|
|
|
- m_type = type;
|
|
|
- }
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // Node manipulation
|
|
|
-
|
|
|
- //! Prepends a new child node.
|
|
|
- //! The prepended child becomes the first child, and all existing children are moved one position back.
|
|
|
- //! \param child Node to prepend.
|
|
|
- void prepend_node(xml_node<Ch> *child)
|
|
|
- {
|
|
|
- assert(child && !child->parent() && child->type() != node_document);
|
|
|
- if (first_node())
|
|
|
- {
|
|
|
- child->m_next_sibling = m_first_node;
|
|
|
- m_first_node->m_prev_sibling = child;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- child->m_next_sibling = 0;
|
|
|
- m_last_node = child;
|
|
|
- }
|
|
|
- m_first_node = child;
|
|
|
- child->m_parent = this;
|
|
|
- child->m_prev_sibling = 0;
|
|
|
- }
|
|
|
-
|
|
|
- //! Appends a new child node.
|
|
|
- //! The appended child becomes the last child.
|
|
|
- //! \param child Node to append.
|
|
|
- void append_node(xml_node<Ch> *child)
|
|
|
- {
|
|
|
- assert(child && !child->parent() && child->type() != node_document);
|
|
|
- if (first_node())
|
|
|
- {
|
|
|
- child->m_prev_sibling = m_last_node;
|
|
|
- m_last_node->m_next_sibling = child;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- child->m_prev_sibling = 0;
|
|
|
- m_first_node = child;
|
|
|
- }
|
|
|
- m_last_node = child;
|
|
|
- child->m_parent = this;
|
|
|
- child->m_next_sibling = 0;
|
|
|
- }
|
|
|
-
|
|
|
- //! Inserts a new child node at specified place inside the node.
|
|
|
- //! All children after and including the specified node are moved one position back.
|
|
|
- //! \param where Place where to insert the child, or 0 to insert at the back.
|
|
|
- //! \param child Node to insert.
|
|
|
- void insert_node(xml_node<Ch> *where, xml_node<Ch> *child)
|
|
|
- {
|
|
|
- assert(!where || where->parent() == this);
|
|
|
- assert(child && !child->parent() && child->type() != node_document);
|
|
|
- if (where == m_first_node)
|
|
|
- prepend_node(child);
|
|
|
- else if (where == 0)
|
|
|
- append_node(child);
|
|
|
- else
|
|
|
- {
|
|
|
- child->m_prev_sibling = where->m_prev_sibling;
|
|
|
- child->m_next_sibling = where;
|
|
|
- where->m_prev_sibling->m_next_sibling = child;
|
|
|
- where->m_prev_sibling = child;
|
|
|
- child->m_parent = this;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //! Removes first child node.
|
|
|
- //! If node has no children, behaviour is undefined.
|
|
|
- //! Use first_node() to test if node has children.
|
|
|
- void remove_first_node()
|
|
|
- {
|
|
|
- assert(first_node());
|
|
|
- xml_node<Ch> *child = m_first_node;
|
|
|
- m_first_node = child->m_next_sibling;
|
|
|
- if (child->m_next_sibling)
|
|
|
- child->m_next_sibling->m_prev_sibling = 0;
|
|
|
- else
|
|
|
- m_last_node = 0;
|
|
|
- child->m_parent = 0;
|
|
|
- }
|
|
|
-
|
|
|
- //! Removes last child of the node.
|
|
|
- //! If node has no children, behaviour is undefined.
|
|
|
- //! Use first_node() to test if node has children.
|
|
|
- void remove_last_node()
|
|
|
- {
|
|
|
- assert(first_node());
|
|
|
- xml_node<Ch> *child = m_last_node;
|
|
|
- if (child->m_prev_sibling)
|
|
|
- {
|
|
|
- m_last_node = child->m_prev_sibling;
|
|
|
- child->m_prev_sibling->m_next_sibling = 0;
|
|
|
- }
|
|
|
- else
|
|
|
- m_first_node = 0;
|
|
|
- child->m_parent = 0;
|
|
|
- }
|
|
|
-
|
|
|
- //! Removes specified child from the node
|
|
|
- // \param where Pointer to child to be removed.
|
|
|
- void remove_node(xml_node<Ch> *where)
|
|
|
- {
|
|
|
- assert(where && where->parent() == this);
|
|
|
- assert(first_node());
|
|
|
- if (where == m_first_node)
|
|
|
- remove_first_node();
|
|
|
- else if (where == m_last_node)
|
|
|
- remove_last_node();
|
|
|
- else
|
|
|
- {
|
|
|
- where->m_prev_sibling->m_next_sibling = where->m_next_sibling;
|
|
|
- where->m_next_sibling->m_prev_sibling = where->m_prev_sibling;
|
|
|
- where->m_parent = 0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //! Removes all child nodes (but not attributes).
|
|
|
- void remove_all_nodes()
|
|
|
- {
|
|
|
- for (xml_node<Ch> *node = first_node(); node; node = node->m_next_sibling)
|
|
|
- node->m_parent = 0;
|
|
|
- m_first_node = 0;
|
|
|
- }
|
|
|
-
|
|
|
- //! Prepends a new attribute to the node.
|
|
|
- //! \param attribute Attribute to prepend.
|
|
|
- void prepend_attribute(xml_attribute<Ch> *attribute)
|
|
|
- {
|
|
|
- assert(attribute && !attribute->parent());
|
|
|
- if (first_attribute())
|
|
|
- {
|
|
|
- attribute->m_next_attribute = m_first_attribute;
|
|
|
- m_first_attribute->m_prev_attribute = attribute;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- attribute->m_next_attribute = 0;
|
|
|
- m_last_attribute = attribute;
|
|
|
- }
|
|
|
- m_first_attribute = attribute;
|
|
|
- attribute->m_parent = this;
|
|
|
- attribute->m_prev_attribute = 0;
|
|
|
- }
|
|
|
-
|
|
|
- //! Appends a new attribute to the node.
|
|
|
- //! \param attribute Attribute to append.
|
|
|
- void append_attribute(xml_attribute<Ch> *attribute)
|
|
|
- {
|
|
|
- assert(attribute && !attribute->parent());
|
|
|
- if (first_attribute())
|
|
|
- {
|
|
|
- attribute->m_prev_attribute = m_last_attribute;
|
|
|
- m_last_attribute->m_next_attribute = attribute;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- attribute->m_prev_attribute = 0;
|
|
|
- m_first_attribute = attribute;
|
|
|
- }
|
|
|
- m_last_attribute = attribute;
|
|
|
- attribute->m_parent = this;
|
|
|
- attribute->m_next_attribute = 0;
|
|
|
- }
|
|
|
-
|
|
|
- //! Inserts a new attribute at specified place inside the node.
|
|
|
- //! All attributes after and including the specified attribute are moved one position back.
|
|
|
- //! \param where Place where to insert the attribute, or 0 to insert at the back.
|
|
|
- //! \param attribute Attribute to insert.
|
|
|
- void insert_attribute(xml_attribute<Ch> *where, xml_attribute<Ch> *attribute)
|
|
|
- {
|
|
|
- assert(!where || where->parent() == this);
|
|
|
- assert(attribute && !attribute->parent());
|
|
|
- if (where == m_first_attribute)
|
|
|
- prepend_attribute(attribute);
|
|
|
- else if (where == 0)
|
|
|
- append_attribute(attribute);
|
|
|
- else
|
|
|
- {
|
|
|
- attribute->m_prev_attribute = where->m_prev_attribute;
|
|
|
- attribute->m_next_attribute = where;
|
|
|
- where->m_prev_attribute->m_next_attribute = attribute;
|
|
|
- where->m_prev_attribute = attribute;
|
|
|
- attribute->m_parent = this;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //! Removes first attribute of the node.
|
|
|
- //! If node has no attributes, behaviour is undefined.
|
|
|
- //! Use first_attribute() to test if node has attributes.
|
|
|
- void remove_first_attribute()
|
|
|
- {
|
|
|
- assert(first_attribute());
|
|
|
- xml_attribute<Ch> *attribute = m_first_attribute;
|
|
|
- if (attribute->m_next_attribute)
|
|
|
- {
|
|
|
- attribute->m_next_attribute->m_prev_attribute = 0;
|
|
|
- }
|
|
|
- else
|
|
|
- m_last_attribute = 0;
|
|
|
- attribute->m_parent = 0;
|
|
|
- m_first_attribute = attribute->m_next_attribute;
|
|
|
- }
|
|
|
-
|
|
|
- //! Removes last attribute of the node.
|
|
|
- //! If node has no attributes, behaviour is undefined.
|
|
|
- //! Use first_attribute() to test if node has attributes.
|
|
|
- void remove_last_attribute()
|
|
|
- {
|
|
|
- assert(first_attribute());
|
|
|
- xml_attribute<Ch> *attribute = m_last_attribute;
|
|
|
- if (attribute->m_prev_attribute)
|
|
|
- {
|
|
|
- attribute->m_prev_attribute->m_next_attribute = 0;
|
|
|
- m_last_attribute = attribute->m_prev_attribute;
|
|
|
- }
|
|
|
- else
|
|
|
- m_first_attribute = 0;
|
|
|
- attribute->m_parent = 0;
|
|
|
- }
|
|
|
-
|
|
|
- //! Removes specified attribute from node.
|
|
|
- //! \param where Pointer to attribute to be removed.
|
|
|
- void remove_attribute(xml_attribute<Ch> *where)
|
|
|
- {
|
|
|
- assert(first_attribute() && where->parent() == this);
|
|
|
- if (where == m_first_attribute)
|
|
|
- remove_first_attribute();
|
|
|
- else if (where == m_last_attribute)
|
|
|
- remove_last_attribute();
|
|
|
- else
|
|
|
- {
|
|
|
- where->m_prev_attribute->m_next_attribute = where->m_next_attribute;
|
|
|
- where->m_next_attribute->m_prev_attribute = where->m_prev_attribute;
|
|
|
- where->m_parent = 0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //! Removes all attributes of node.
|
|
|
- void remove_all_attributes()
|
|
|
- {
|
|
|
- for (xml_attribute<Ch> *attribute = first_attribute(); attribute; attribute = attribute->m_next_attribute)
|
|
|
- attribute->m_parent = 0;
|
|
|
- m_first_attribute = 0;
|
|
|
- }
|
|
|
-
|
|
|
- private:
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // Restrictions
|
|
|
-
|
|
|
- // No copying
|
|
|
- xml_node(const xml_node &);
|
|
|
- void operator =(const xml_node &);
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // Data members
|
|
|
-
|
|
|
- // Note that some of the pointers below have UNDEFINED values if certain other pointers are 0.
|
|
|
- // This is required for maximum performance, as it allows the parser to omit initialization of
|
|
|
- // unneded/redundant values.
|
|
|
- //
|
|
|
- // The rules are as follows:
|
|
|
- // 1. first_node and first_attribute contain valid pointers, or 0 if node has no children/attributes respectively
|
|
|
- // 2. last_node and last_attribute are valid only if node has at least one child/attribute respectively, otherwise they contain garbage
|
|
|
- // 3. prev_sibling and next_sibling are valid only if node has a parent, otherwise they contain garbage
|
|
|
-
|
|
|
- node_type m_type; // Type of node; always valid
|
|
|
- xml_node<Ch> *m_first_node; // Pointer to first child node, or 0 if none; always valid
|
|
|
- xml_node<Ch> *m_last_node; // Pointer to last child node, or 0 if none; this value is only valid if m_first_node is non-zero
|
|
|
- xml_attribute<Ch> *m_first_attribute; // Pointer to first attribute of node, or 0 if none; always valid
|
|
|
- xml_attribute<Ch> *m_last_attribute; // Pointer to last attribute of node, or 0 if none; this value is only valid if m_first_attribute is non-zero
|
|
|
- xml_node<Ch> *m_prev_sibling; // Pointer to previous sibling of node, or 0 if none; this value is only valid if m_parent is non-zero
|
|
|
- xml_node<Ch> *m_next_sibling; // Pointer to next sibling of node, or 0 if none; this value is only valid if m_parent is non-zero
|
|
|
-
|
|
|
- };
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////////
|
|
|
- // XML document
|
|
|
-
|
|
|
- //! This class represents root of the DOM hierarchy.
|
|
|
- //! It is also an xml_node and a memory_pool through public inheritance.
|
|
|
- //! Use parse() function to build a DOM tree from a zero-terminated XML text string.
|
|
|
- //! parse() function allocates memory for nodes and attributes by using functions of xml_document,
|
|
|
- //! which are inherited from memory_pool.
|
|
|
- //! To access root node of the document, use the document itself, as if it was an xml_node.
|
|
|
- //! \param Ch Character type to use.
|
|
|
- template<class Ch = char>
|
|
|
- class xml_document: public xml_node<Ch>, public memory_pool<Ch>
|
|
|
- {
|
|
|
-
|
|
|
- public:
|
|
|
-
|
|
|
- //! Constructs empty XML document
|
|
|
- xml_document()
|
|
|
- : xml_node<Ch>(node_document)
|
|
|
- {
|
|
|
- }
|
|
|
-
|
|
|
- //! Parses zero-terminated XML string according to given flags.
|
|
|
- //! Passed string will be modified by the parser, unless rapidxml::parse_non_destructive flag is used.
|
|
|
- //! The string must persist for the lifetime of the document.
|
|
|
- //! In case of error, rapidxml::parse_error exception will be thrown.
|
|
|
- //! <br><br>
|
|
|
- //! If you want to parse contents of a file, you must first load the file into the memory, and pass pointer to its beginning.
|
|
|
- //! Make sure that data is zero-terminated.
|
|
|
- //! <br><br>
|
|
|
- //! Document can be parsed into multiple times.
|
|
|
- //! Each new call to parse removes previous nodes and attributes (if any), but does not clear memory pool.
|
|
|
- //! \param text XML data to parse; pointer is non-const to denote fact that this data may be modified by the parser.
|
|
|
- template<int Flags>
|
|
|
- void parse(Ch *text)
|
|
|
- {
|
|
|
- assert(text);
|
|
|
-
|
|
|
- // Remove current contents
|
|
|
- this->remove_all_nodes();
|
|
|
- this->remove_all_attributes();
|
|
|
-
|
|
|
- // Parse BOM, if any
|
|
|
- parse_bom<Flags>(text);
|
|
|
-
|
|
|
- // Parse children
|
|
|
- while (1)
|
|
|
- {
|
|
|
- // Skip whitespace before node
|
|
|
- skip<whitespace_pred, Flags>(text);
|
|
|
- if (*text == 0)
|
|
|
- break;
|
|
|
-
|
|
|
- // Parse and append new child
|
|
|
- if (*text == Ch('<'))
|
|
|
- {
|
|
|
- ++text; // Skip '<'
|
|
|
- if (xml_node<Ch> *node = parse_node<Flags>(text))
|
|
|
- this->append_node(node);
|
|
|
- }
|
|
|
- else
|
|
|
- RAPIDXML_PARSE_ERROR("expected <", text);
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- //! Clears the document by deleting all nodes and clearing the memory pool.
|
|
|
- //! All nodes owned by document pool are destroyed.
|
|
|
- void clear()
|
|
|
- {
|
|
|
- this->remove_all_nodes();
|
|
|
- this->remove_all_attributes();
|
|
|
- memory_pool<Ch>::clear();
|
|
|
- }
|
|
|
-
|
|
|
- private:
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////
|
|
|
- // Internal character utility functions
|
|
|
-
|
|
|
- // Detect whitespace character
|
|
|
- struct whitespace_pred
|
|
|
- {
|
|
|
- static unsigned char test(Ch ch)
|
|
|
- {
|
|
|
- return internal::lookup_tables<0>::lookup_whitespace[static_cast<unsigned char>(ch)];
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- // Detect node name character
|
|
|
- struct node_name_pred
|
|
|
- {
|
|
|
- static unsigned char test(Ch ch)
|
|
|
- {
|
|
|
- return internal::lookup_tables<0>::lookup_node_name[static_cast<unsigned char>(ch)];
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- // Detect attribute name character
|
|
|
- struct attribute_name_pred
|
|
|
- {
|
|
|
- static unsigned char test(Ch ch)
|
|
|
- {
|
|
|
- return internal::lookup_tables<0>::lookup_attribute_name[static_cast<unsigned char>(ch)];
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- // Detect text character (PCDATA)
|
|
|
- struct text_pred
|
|
|
- {
|
|
|
- static unsigned char test(Ch ch)
|
|
|
- {
|
|
|
- return internal::lookup_tables<0>::lookup_text[static_cast<unsigned char>(ch)];
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- // Detect text character (PCDATA) that does not require processing
|
|
|
- struct text_pure_no_ws_pred
|
|
|
- {
|
|
|
- static unsigned char test(Ch ch)
|
|
|
- {
|
|
|
- return internal::lookup_tables<0>::lookup_text_pure_no_ws[static_cast<unsigned char>(ch)];
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- // Detect text character (PCDATA) that does not require processing
|
|
|
- struct text_pure_with_ws_pred
|
|
|
- {
|
|
|
- static unsigned char test(Ch ch)
|
|
|
- {
|
|
|
- return internal::lookup_tables<0>::lookup_text_pure_with_ws[static_cast<unsigned char>(ch)];
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- // Detect attribute value character
|
|
|
- template<Ch Quote>
|
|
|
- struct attribute_value_pred
|
|
|
- {
|
|
|
- static unsigned char test(Ch ch)
|
|
|
- {
|
|
|
- if (Quote == Ch('\''))
|
|
|
- return internal::lookup_tables<0>::lookup_attribute_data_1[static_cast<unsigned char>(ch)];
|
|
|
- if (Quote == Ch('\"'))
|
|
|
- return internal::lookup_tables<0>::lookup_attribute_data_2[static_cast<unsigned char>(ch)];
|
|
|
- return 0; // Should never be executed, to avoid warnings on Comeau
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- // Detect attribute value character
|
|
|
- template<Ch Quote>
|
|
|
- struct attribute_value_pure_pred
|
|
|
- {
|
|
|
- static unsigned char test(Ch ch)
|
|
|
- {
|
|
|
- if (Quote == Ch('\''))
|
|
|
- return internal::lookup_tables<0>::lookup_attribute_data_1_pure[static_cast<unsigned char>(ch)];
|
|
|
- if (Quote == Ch('\"'))
|
|
|
- return internal::lookup_tables<0>::lookup_attribute_data_2_pure[static_cast<unsigned char>(ch)];
|
|
|
- return 0; // Should never be executed, to avoid warnings on Comeau
|
|
|
- }
|
|
|
- };
|
|
|
-
|
|
|
- // Insert coded character, using UTF8 or 8-bit ASCII
|
|
|
- template<int Flags>
|
|
|
- static void insert_coded_character(Ch *&text, unsigned long code)
|
|
|
- {
|
|
|
- if (Flags & parse_no_utf8)
|
|
|
- {
|
|
|
- // Insert 8-bit ASCII character
|
|
|
- // Todo: possibly verify that code is less than 256 and use replacement char otherwise?
|
|
|
- text[0] = static_cast<unsigned char>(code);
|
|
|
- text += 1;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- // Insert UTF8 sequence
|
|
|
- if (code < 0x80) // 1 byte sequence
|
|
|
- {
|
|
|
- text[0] = static_cast<unsigned char>(code);
|
|
|
- text += 1;
|
|
|
- }
|
|
|
- else if (code < 0x800) // 2 byte sequence
|
|
|
- {
|
|
|
- text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
|
|
|
- text[0] = static_cast<unsigned char>(code | 0xC0);
|
|
|
- text += 2;
|
|
|
- }
|
|
|
- else if (code < 0x10000) // 3 byte sequence
|
|
|
- {
|
|
|
- text[2] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
|
|
|
- text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
|
|
|
- text[0] = static_cast<unsigned char>(code | 0xE0);
|
|
|
- text += 3;
|
|
|
- }
|
|
|
- else if (code < 0x110000) // 4 byte sequence
|
|
|
- {
|
|
|
- text[3] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
|
|
|
- text[2] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
|
|
|
- text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
|
|
|
- text[0] = static_cast<unsigned char>(code | 0xF0);
|
|
|
- text += 4;
|
|
|
- }
|
|
|
- else // Invalid, only codes up to 0x10FFFF are allowed in Unicode
|
|
|
- {
|
|
|
- RAPIDXML_PARSE_ERROR("invalid numeric character entity", text);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Skip characters until predicate evaluates to true
|
|
|
- template<class StopPred, int Flags>
|
|
|
- static void skip(Ch *&text)
|
|
|
- {
|
|
|
- Ch *tmp = text;
|
|
|
- while (StopPred::test(*tmp))
|
|
|
- ++tmp;
|
|
|
- text = tmp;
|
|
|
- }
|
|
|
-
|
|
|
- // Skip characters until predicate evaluates to true while doing the following:
|
|
|
- // - replacing XML character entity references with proper characters (' & " < > &#...;)
|
|
|
- // - condensing whitespace sequences to single space character
|
|
|
- template<class StopPred, class StopPredPure, int Flags>
|
|
|
- static Ch *skip_and_expand_character_refs(Ch *&text)
|
|
|
- {
|
|
|
- // If entity translation, whitespace condense and whitespace trimming is disabled, use plain skip
|
|
|
- if (Flags & parse_no_entity_translation &&
|
|
|
- !(Flags & parse_normalize_whitespace) &&
|
|
|
- !(Flags & parse_trim_whitespace))
|
|
|
- {
|
|
|
- skip<StopPred, Flags>(text);
|
|
|
- return text;
|
|
|
- }
|
|
|
-
|
|
|
- // Use simple skip until first modification is detected
|
|
|
- skip<StopPredPure, Flags>(text);
|
|
|
-
|
|
|
- // Use translation skip
|
|
|
- Ch *src = text;
|
|
|
- Ch *dest = src;
|
|
|
- while (StopPred::test(*src))
|
|
|
- {
|
|
|
- // If entity translation is enabled
|
|
|
- if (!(Flags & parse_no_entity_translation))
|
|
|
- {
|
|
|
- // Test if replacement is needed
|
|
|
- if (src[0] == Ch('&'))
|
|
|
- {
|
|
|
- switch (src[1])
|
|
|
- {
|
|
|
-
|
|
|
- // & '
|
|
|
- case Ch('a'):
|
|
|
- if (src[2] == Ch('m') && src[3] == Ch('p') && src[4] == Ch(';'))
|
|
|
- {
|
|
|
- *dest = Ch('&');
|
|
|
- ++dest;
|
|
|
- src += 5;
|
|
|
- continue;
|
|
|
- }
|
|
|
- if (src[2] == Ch('p') && src[3] == Ch('o') && src[4] == Ch('s') && src[5] == Ch(';'))
|
|
|
- {
|
|
|
- *dest = Ch('\'');
|
|
|
- ++dest;
|
|
|
- src += 6;
|
|
|
- continue;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- // "
|
|
|
- case Ch('q'):
|
|
|
- if (src[2] == Ch('u') && src[3] == Ch('o') && src[4] == Ch('t') && src[5] == Ch(';'))
|
|
|
- {
|
|
|
- *dest = Ch('"');
|
|
|
- ++dest;
|
|
|
- src += 6;
|
|
|
- continue;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- // >
|
|
|
- case Ch('g'):
|
|
|
- if (src[2] == Ch('t') && src[3] == Ch(';'))
|
|
|
- {
|
|
|
- *dest = Ch('>');
|
|
|
- ++dest;
|
|
|
- src += 4;
|
|
|
- continue;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- // <
|
|
|
- case Ch('l'):
|
|
|
- if (src[2] == Ch('t') && src[3] == Ch(';'))
|
|
|
- {
|
|
|
- *dest = Ch('<');
|
|
|
- ++dest;
|
|
|
- src += 4;
|
|
|
- continue;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- // &#...; - assumes ASCII
|
|
|
- case Ch('#'):
|
|
|
- if (src[2] == Ch('x'))
|
|
|
- {
|
|
|
- unsigned long code = 0;
|
|
|
- src += 3; // Skip &#x
|
|
|
- while (1)
|
|
|
- {
|
|
|
- unsigned char digit = internal::lookup_tables<0>::lookup_digits[static_cast<unsigned char>(*src)];
|
|
|
- if (digit == 0xFF)
|
|
|
- break;
|
|
|
- code = code * 16 + digit;
|
|
|
- ++src;
|
|
|
- }
|
|
|
- insert_coded_character<Flags>(dest, code); // Put character in output
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- unsigned long code = 0;
|
|
|
- src += 2; // Skip &#
|
|
|
- while (1)
|
|
|
- {
|
|
|
- unsigned char digit = internal::lookup_tables<0>::lookup_digits[static_cast<unsigned char>(*src)];
|
|
|
- if (digit == 0xFF)
|
|
|
- break;
|
|
|
- code = code * 10 + digit;
|
|
|
- ++src;
|
|
|
- }
|
|
|
- insert_coded_character<Flags>(dest, code); // Put character in output
|
|
|
- }
|
|
|
- if (*src == Ch(';'))
|
|
|
- ++src;
|
|
|
- else
|
|
|
- RAPIDXML_PARSE_ERROR("expected ;", src);
|
|
|
- continue;
|
|
|
-
|
|
|
- // Something else
|
|
|
- default:
|
|
|
- // Ignore, just copy '&' verbatim
|
|
|
- break;
|
|
|
-
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // If whitespace condensing is enabled
|
|
|
- if (Flags & parse_normalize_whitespace)
|
|
|
- {
|
|
|
- // Test if condensing is needed
|
|
|
- if (whitespace_pred::test(*src))
|
|
|
- {
|
|
|
- *dest = Ch(' '); ++dest; // Put single space in dest
|
|
|
- ++src; // Skip first whitespace char
|
|
|
- // Skip remaining whitespace chars
|
|
|
- while (whitespace_pred::test(*src))
|
|
|
- ++src;
|
|
|
- continue;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // No replacement, only copy character
|
|
|
- *dest++ = *src++;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- // Return new end
|
|
|
- text = src;
|
|
|
- return dest;
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- ///////////////////////////////////////////////////////////////////////
|
|
|
- // Internal parsing functions
|
|
|
-
|
|
|
- // Parse BOM, if any
|
|
|
- template<int Flags>
|
|
|
- void parse_bom(Ch *&text)
|
|
|
- {
|
|
|
- // UTF-8?
|
|
|
- if (static_cast<unsigned char>(text[0]) == 0xEF &&
|
|
|
- static_cast<unsigned char>(text[1]) == 0xBB &&
|
|
|
- static_cast<unsigned char>(text[2]) == 0xBF)
|
|
|
- {
|
|
|
- text += 3; // Skup utf-8 bom
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Parse XML declaration (<?xml...)
|
|
|
- template<int Flags>
|
|
|
- xml_node<Ch> *parse_xml_declaration(Ch *&text)
|
|
|
- {
|
|
|
- // If parsing of declaration is disabled
|
|
|
- if (!(Flags & parse_declaration_node))
|
|
|
- {
|
|
|
- // Skip until end of declaration
|
|
|
- while (text[0] != Ch('?') || text[1] != Ch('>'))
|
|
|
- {
|
|
|
- if (!text[0])
|
|
|
- RAPIDXML_PARSE_ERROR("unexpected end of data", text);
|
|
|
- ++text;
|
|
|
- }
|
|
|
- text += 2; // Skip '?>'
|
|
|
- return 0;
|
|
|
- }
|
|
|
-
|
|
|
- // Create declaration
|
|
|
- xml_node<Ch> *declaration = this->allocate_node(node_declaration);
|
|
|
-
|
|
|
- // Skip whitespace before attributes or ?>
|
|
|
- skip<whitespace_pred, Flags>(text);
|
|
|
-
|
|
|
- // Parse declaration attributes
|
|
|
- parse_node_attributes<Flags>(text, declaration);
|
|
|
-
|
|
|
- // Skip ?>
|
|
|
- if (text[0] != Ch('?') || text[1] != Ch('>'))
|
|
|
- RAPIDXML_PARSE_ERROR("expected ?>", text);
|
|
|
- text += 2;
|
|
|
-
|
|
|
- return declaration;
|
|
|
- }
|
|
|
-
|
|
|
- // Parse XML comment (<!--...)
|
|
|
- template<int Flags>
|
|
|
- xml_node<Ch> *parse_comment(Ch *&text)
|
|
|
- {
|
|
|
- // If parsing of comments is disabled
|
|
|
- if (!(Flags & parse_comment_nodes))
|
|
|
- {
|
|
|
- // Skip until end of comment
|
|
|
- while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
|
|
|
- {
|
|
|
- if (!text[0])
|
|
|
- RAPIDXML_PARSE_ERROR("unexpected end of data", text);
|
|
|
- ++text;
|
|
|
- }
|
|
|
- text += 3; // Skip '-->'
|
|
|
- return 0; // Do not produce comment node
|
|
|
- }
|
|
|
-
|
|
|
- // Remember value start
|
|
|
- Ch *value = text;
|
|
|
-
|
|
|
- // Skip until end of comment
|
|
|
- while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
|
|
|
- {
|
|
|
- if (!text[0])
|
|
|
- RAPIDXML_PARSE_ERROR("unexpected end of data", text);
|
|
|
- ++text;
|
|
|
- }
|
|
|
-
|
|
|
- // Create comment node
|
|
|
- xml_node<Ch> *comment = this->allocate_node(node_comment);
|
|
|
- comment->value(value, text - value);
|
|
|
-
|
|
|
- // Place zero terminator after comment value
|
|
|
- if (!(Flags & parse_no_string_terminators))
|
|
|
- *text = Ch('\0');
|
|
|
-
|
|
|
- text += 3; // Skip '-->'
|
|
|
- return comment;
|
|
|
- }
|
|
|
-
|
|
|
- // Parse DOCTYPE
|
|
|
- template<int Flags>
|
|
|
- xml_node<Ch> *parse_doctype(Ch *&text)
|
|
|
- {
|
|
|
- // Remember value start
|
|
|
- Ch *value = text;
|
|
|
-
|
|
|
- // Skip to >
|
|
|
- while (*text != Ch('>'))
|
|
|
- {
|
|
|
- // Determine character type
|
|
|
- switch (*text)
|
|
|
- {
|
|
|
-
|
|
|
- // If '[' encountered, scan for matching ending ']' using naive algorithm with depth
|
|
|
- // This works for all W3C test files except for 2 most wicked
|
|
|
- case Ch('['):
|
|
|
- {
|
|
|
- ++text; // Skip '['
|
|
|
- int depth = 1;
|
|
|
- while (depth > 0)
|
|
|
- {
|
|
|
- switch (*text)
|
|
|
- {
|
|
|
- case Ch('['): ++depth; break;
|
|
|
- case Ch(']'): --depth; break;
|
|
|
- case 0: RAPIDXML_PARSE_ERROR("unexpected end of data", text);
|
|
|
- }
|
|
|
- ++text;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- // Error on end of text
|
|
|
- case Ch('\0'):
|
|
|
- RAPIDXML_PARSE_ERROR("unexpected end of data", text);
|
|
|
-
|
|
|
- // Other character, skip it
|
|
|
- default:
|
|
|
- ++text;
|
|
|
-
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // If DOCTYPE nodes enabled
|
|
|
- if (Flags & parse_doctype_node)
|
|
|
- {
|
|
|
- // Create a new doctype node
|
|
|
- xml_node<Ch> *doctype = this->allocate_node(node_doctype);
|
|
|
- doctype->value(value, text - value);
|
|
|
-
|
|
|
- // Place zero terminator after value
|
|
|
- if (!(Flags & parse_no_string_terminators))
|
|
|
- *text = Ch('\0');
|
|
|
-
|
|
|
- text += 1; // skip '>'
|
|
|
- return doctype;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- text += 1; // skip '>'
|
|
|
- return 0;
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- // Parse PI
|
|
|
- template<int Flags>
|
|
|
- xml_node<Ch> *parse_pi(Ch *&text)
|
|
|
- {
|
|
|
- // If creation of PI nodes is enabled
|
|
|
- if (Flags & parse_pi_nodes)
|
|
|
- {
|
|
|
- // Create pi node
|
|
|
- xml_node<Ch> *pi = this->allocate_node(node_pi);
|
|
|
-
|
|
|
- // Extract PI target name
|
|
|
- Ch *name = text;
|
|
|
- skip<node_name_pred, Flags>(text);
|
|
|
- if (text == name)
|
|
|
- RAPIDXML_PARSE_ERROR("expected PI target", text);
|
|
|
- pi->name(name, text - name);
|
|
|
-
|
|
|
- // Skip whitespace between pi target and pi
|
|
|
- skip<whitespace_pred, Flags>(text);
|
|
|
-
|
|
|
- // Remember start of pi
|
|
|
- Ch *value = text;
|
|
|
-
|
|
|
- // Skip to '?>'
|
|
|
- while (text[0] != Ch('?') || text[1] != Ch('>'))
|
|
|
- {
|
|
|
- if (*text == Ch('\0'))
|
|
|
- RAPIDXML_PARSE_ERROR("unexpected end of data", text);
|
|
|
- ++text;
|
|
|
- }
|
|
|
-
|
|
|
- // Set pi value (verbatim, no entity expansion or whitespace normalization)
|
|
|
- pi->value(value, text - value);
|
|
|
-
|
|
|
- // Place zero terminator after name and value
|
|
|
- if (!(Flags & parse_no_string_terminators))
|
|
|
- {
|
|
|
- pi->name()[pi->name_size()] = Ch('\0');
|
|
|
- pi->value()[pi->value_size()] = Ch('\0');
|
|
|
- }
|
|
|
-
|
|
|
- text += 2; // Skip '?>'
|
|
|
- return pi;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- // Skip to '?>'
|
|
|
- while (text[0] != Ch('?') || text[1] != Ch('>'))
|
|
|
- {
|
|
|
- if (*text == Ch('\0'))
|
|
|
- RAPIDXML_PARSE_ERROR("unexpected end of data", text);
|
|
|
- ++text;
|
|
|
- }
|
|
|
- text += 2; // Skip '?>'
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Parse and append data
|
|
|
- // Return character that ends data.
|
|
|
- // This is necessary because this character might have been overwritten by a terminating 0
|
|
|
- template<int Flags>
|
|
|
- Ch parse_and_append_data(xml_node<Ch> *node, Ch *&text, Ch *contents_start)
|
|
|
- {
|
|
|
- // Backup to contents start if whitespace trimming is disabled
|
|
|
- if (!(Flags & parse_trim_whitespace))
|
|
|
- text = contents_start;
|
|
|
-
|
|
|
- // Skip until end of data
|
|
|
- Ch *value = text, *end;
|
|
|
- if (Flags & parse_normalize_whitespace)
|
|
|
- end = skip_and_expand_character_refs<text_pred, text_pure_with_ws_pred, Flags>(text);
|
|
|
- else
|
|
|
- end = skip_and_expand_character_refs<text_pred, text_pure_no_ws_pred, Flags>(text);
|
|
|
-
|
|
|
- // Trim trailing whitespace if flag is set; leading was already trimmed by whitespace skip after >
|
|
|
- if (Flags & parse_trim_whitespace)
|
|
|
- {
|
|
|
- if (Flags & parse_normalize_whitespace)
|
|
|
- {
|
|
|
- // Whitespace is already condensed to single space characters by skipping function, so just trim 1 char off the end
|
|
|
- if (*(end - 1) == Ch(' '))
|
|
|
- --end;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- // Backup until non-whitespace character is found
|
|
|
- while (whitespace_pred::test(*(end - 1)))
|
|
|
- --end;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // If characters are still left between end and value (this test is only necessary if normalization is enabled)
|
|
|
- // Create new data node
|
|
|
- if (!(Flags & parse_no_data_nodes))
|
|
|
- {
|
|
|
- xml_node<Ch> *data = this->allocate_node(node_data);
|
|
|
- data->value(value, end - value);
|
|
|
- node->append_node(data);
|
|
|
- }
|
|
|
-
|
|
|
- // Add data to parent node if no data exists yet
|
|
|
- if (!(Flags & parse_no_element_values))
|
|
|
- if (*node->value() == Ch('\0'))
|
|
|
- node->value(value, end - value);
|
|
|
-
|
|
|
- // Place zero terminator after value
|
|
|
- if (!(Flags & parse_no_string_terminators))
|
|
|
- {
|
|
|
- Ch ch = *text;
|
|
|
- *end = Ch('\0');
|
|
|
- return ch; // Return character that ends data; this is required because zero terminator overwritten it
|
|
|
- }
|
|
|
-
|
|
|
- // Return character that ends data
|
|
|
- return *text;
|
|
|
- }
|
|
|
-
|
|
|
- // Parse CDATA
|
|
|
- template<int Flags>
|
|
|
- xml_node<Ch> *parse_cdata(Ch *&text)
|
|
|
- {
|
|
|
- // If CDATA is disabled
|
|
|
- if (Flags & parse_no_data_nodes)
|
|
|
- {
|
|
|
- // Skip until end of cdata
|
|
|
- while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
|
|
|
- {
|
|
|
- if (!text[0])
|
|
|
- RAPIDXML_PARSE_ERROR("unexpected end of data", text);
|
|
|
- ++text;
|
|
|
- }
|
|
|
- text += 3; // Skip ]]>
|
|
|
- return 0; // Do not produce CDATA node
|
|
|
- }
|
|
|
-
|
|
|
- // Skip until end of cdata
|
|
|
- Ch *value = text;
|
|
|
- while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
|
|
|
- {
|
|
|
- if (!text[0])
|
|
|
- RAPIDXML_PARSE_ERROR("unexpected end of data", text);
|
|
|
- ++text;
|
|
|
- }
|
|
|
-
|
|
|
- // Create new cdata node
|
|
|
- xml_node<Ch> *cdata = this->allocate_node(node_cdata);
|
|
|
- cdata->value(value, text - value);
|
|
|
-
|
|
|
- // Place zero terminator after value
|
|
|
- if (!(Flags & parse_no_string_terminators))
|
|
|
- *text = Ch('\0');
|
|
|
-
|
|
|
- text += 3; // Skip ]]>
|
|
|
- return cdata;
|
|
|
- }
|
|
|
-
|
|
|
- // Parse element node
|
|
|
- template<int Flags>
|
|
|
- xml_node<Ch> *parse_element(Ch *&text)
|
|
|
- {
|
|
|
- // Create element node
|
|
|
- xml_node<Ch> *element = this->allocate_node(node_element);
|
|
|
-
|
|
|
- // Extract element name
|
|
|
- Ch *name = text;
|
|
|
- skip<node_name_pred, Flags>(text);
|
|
|
- if (text == name)
|
|
|
- RAPIDXML_PARSE_ERROR("expected element name", text);
|
|
|
- element->name(name, text - name);
|
|
|
-
|
|
|
- // Skip whitespace between element name and attributes or >
|
|
|
- skip<whitespace_pred, Flags>(text);
|
|
|
-
|
|
|
- // Parse attributes, if any
|
|
|
- parse_node_attributes<Flags>(text, element);
|
|
|
-
|
|
|
- // Determine ending type
|
|
|
- if (*text == Ch('>'))
|
|
|
- {
|
|
|
- ++text;
|
|
|
- parse_node_contents<Flags>(text, element);
|
|
|
- }
|
|
|
- else if (*text == Ch('/'))
|
|
|
- {
|
|
|
- ++text;
|
|
|
- if (*text != Ch('>'))
|
|
|
- RAPIDXML_PARSE_ERROR("expected >", text);
|
|
|
- ++text;
|
|
|
- }
|
|
|
- else
|
|
|
- RAPIDXML_PARSE_ERROR("expected >", text);
|
|
|
-
|
|
|
- // Place zero terminator after name
|
|
|
- if (!(Flags & parse_no_string_terminators))
|
|
|
- element->name()[element->name_size()] = Ch('\0');
|
|
|
-
|
|
|
- // Return parsed element
|
|
|
- return element;
|
|
|
- }
|
|
|
-
|
|
|
- // Determine node type, and parse it
|
|
|
- template<int Flags>
|
|
|
- xml_node<Ch> *parse_node(Ch *&text)
|
|
|
- {
|
|
|
- // Parse proper node type
|
|
|
- switch (text[0])
|
|
|
- {
|
|
|
-
|
|
|
- // <...
|
|
|
- default:
|
|
|
- // Parse and append element node
|
|
|
- return parse_element<Flags>(text);
|
|
|
-
|
|
|
- // <?...
|
|
|
- case Ch('?'):
|
|
|
- ++text; // Skip ?
|
|
|
- if ((text[0] == Ch('x') || text[0] == Ch('X')) &&
|
|
|
- (text[1] == Ch('m') || text[1] == Ch('M')) &&
|
|
|
- (text[2] == Ch('l') || text[2] == Ch('L')) &&
|
|
|
- whitespace_pred::test(text[3]))
|
|
|
- {
|
|
|
- // '<?xml ' - xml declaration
|
|
|
- text += 4; // Skip 'xml '
|
|
|
- return parse_xml_declaration<Flags>(text);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- // Parse PI
|
|
|
- return parse_pi<Flags>(text);
|
|
|
- }
|
|
|
-
|
|
|
- // <!...
|
|
|
- case Ch('!'):
|
|
|
-
|
|
|
- // Parse proper subset of <! node
|
|
|
- switch (text[1])
|
|
|
- {
|
|
|
-
|
|
|
- // <!-
|
|
|
- case Ch('-'):
|
|
|
- if (text[2] == Ch('-'))
|
|
|
- {
|
|
|
- // '<!--' - xml comment
|
|
|
- text += 3; // Skip '!--'
|
|
|
- return parse_comment<Flags>(text);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- // <![
|
|
|
- case Ch('['):
|
|
|
- if (text[2] == Ch('C') && text[3] == Ch('D') && text[4] == Ch('A') &&
|
|
|
- text[5] == Ch('T') && text[6] == Ch('A') && text[7] == Ch('['))
|
|
|
- {
|
|
|
- // '<![CDATA[' - cdata
|
|
|
- text += 8; // Skip '![CDATA['
|
|
|
- return parse_cdata<Flags>(text);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- // <!D
|
|
|
- case Ch('D'):
|
|
|
- if (text[2] == Ch('O') && text[3] == Ch('C') && text[4] == Ch('T') &&
|
|
|
- text[5] == Ch('Y') && text[6] == Ch('P') && text[7] == Ch('E') &&
|
|
|
- whitespace_pred::test(text[8]))
|
|
|
- {
|
|
|
- // '<!DOCTYPE ' - doctype
|
|
|
- text += 9; // skip '!DOCTYPE '
|
|
|
- return parse_doctype<Flags>(text);
|
|
|
- }
|
|
|
-
|
|
|
- } // switch
|
|
|
-
|
|
|
- // Attempt to skip other, unrecognized node types starting with <!
|
|
|
- ++text; // Skip !
|
|
|
- while (*text != Ch('>'))
|
|
|
- {
|
|
|
- if (*text == 0)
|
|
|
- RAPIDXML_PARSE_ERROR("unexpected end of data", text);
|
|
|
- ++text;
|
|
|
- }
|
|
|
- ++text; // Skip '>'
|
|
|
- return 0; // No node recognized
|
|
|
-
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Parse contents of the node - children, data etc.
|
|
|
- template<int Flags>
|
|
|
- void parse_node_contents(Ch *&text, xml_node<Ch> *node)
|
|
|
- {
|
|
|
- // For all children and text
|
|
|
- while (1)
|
|
|
- {
|
|
|
- // Skip whitespace between > and node contents
|
|
|
- Ch *contents_start = text; // Store start of node contents before whitespace is skipped
|
|
|
- skip<whitespace_pred, Flags>(text);
|
|
|
- Ch next_char = *text;
|
|
|
-
|
|
|
- // After data nodes, instead of continuing the loop, control jumps here.
|
|
|
- // This is because zero termination inside parse_and_append_data() function
|
|
|
- // would wreak havoc with the above code.
|
|
|
- // Also, skipping whitespace after data nodes is unnecessary.
|
|
|
- after_data_node:
|
|
|
-
|
|
|
- // Determine what comes next: node closing, child node, data node, or 0?
|
|
|
- switch (next_char)
|
|
|
- {
|
|
|
-
|
|
|
- // Node closing or child node
|
|
|
- case Ch('<'):
|
|
|
- if (text[1] == Ch('/'))
|
|
|
- {
|
|
|
- // Node closing
|
|
|
- text += 2; // Skip '</'
|
|
|
- if (Flags & parse_validate_closing_tags)
|
|
|
- {
|
|
|
- // Skip and validate closing tag name
|
|
|
- Ch *closing_name = text;
|
|
|
- skip<node_name_pred, Flags>(text);
|
|
|
- if (!internal::compare(node->name(), node->name_size(), closing_name, text - closing_name, true))
|
|
|
- RAPIDXML_PARSE_ERROR("invalid closing tag name", text);
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- // No validation, just skip name
|
|
|
- skip<node_name_pred, Flags>(text);
|
|
|
- }
|
|
|
- // Skip remaining whitespace after node name
|
|
|
- skip<whitespace_pred, Flags>(text);
|
|
|
- if (*text != Ch('>'))
|
|
|
- RAPIDXML_PARSE_ERROR("expected >", text);
|
|
|
- ++text; // Skip '>'
|
|
|
- return; // Node closed, finished parsing contents
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- // Child node
|
|
|
- ++text; // Skip '<'
|
|
|
- if (xml_node<Ch> *child = parse_node<Flags>(text))
|
|
|
- node->append_node(child);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- // End of data - error
|
|
|
- case Ch('\0'):
|
|
|
- RAPIDXML_PARSE_ERROR("unexpected end of data", text);
|
|
|
-
|
|
|
- // Data node
|
|
|
- default:
|
|
|
- next_char = parse_and_append_data<Flags>(node, text, contents_start);
|
|
|
- goto after_data_node; // Bypass regular processing after data nodes
|
|
|
-
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Parse XML attributes of the node
|
|
|
- template<int Flags>
|
|
|
- void parse_node_attributes(Ch *&text, xml_node<Ch> *node)
|
|
|
- {
|
|
|
- // For all attributes
|
|
|
- while (attribute_name_pred::test(*text))
|
|
|
- {
|
|
|
- // Extract attribute name
|
|
|
- Ch *name = text;
|
|
|
- ++text; // Skip first character of attribute name
|
|
|
- skip<attribute_name_pred, Flags>(text);
|
|
|
- if (text == name)
|
|
|
- RAPIDXML_PARSE_ERROR("expected attribute name", name);
|
|
|
-
|
|
|
- // Create new attribute
|
|
|
- xml_attribute<Ch> *attribute = this->allocate_attribute();
|
|
|
- attribute->name(name, text - name);
|
|
|
- node->append_attribute(attribute);
|
|
|
-
|
|
|
- // Skip whitespace after attribute name
|
|
|
- skip<whitespace_pred, Flags>(text);
|
|
|
-
|
|
|
- // Skip =
|
|
|
- if (*text != Ch('='))
|
|
|
- RAPIDXML_PARSE_ERROR("expected =", text);
|
|
|
- ++text;
|
|
|
-
|
|
|
- // Add terminating zero after name
|
|
|
- if (!(Flags & parse_no_string_terminators))
|
|
|
- attribute->name()[attribute->name_size()] = 0;
|
|
|
-
|
|
|
- // Skip whitespace after =
|
|
|
- skip<whitespace_pred, Flags>(text);
|
|
|
-
|
|
|
- // Skip quote and remember if it was ' or "
|
|
|
- Ch quote = *text;
|
|
|
- if (quote != Ch('\'') && quote != Ch('"'))
|
|
|
- RAPIDXML_PARSE_ERROR("expected ' or \"", text);
|
|
|
- ++text;
|
|
|
-
|
|
|
- // Extract attribute value and expand char refs in it
|
|
|
- Ch *value = text, *end;
|
|
|
- const int AttFlags = Flags & ~parse_normalize_whitespace; // No whitespace normalization in attributes
|
|
|
- if (quote == Ch('\''))
|
|
|
- end = skip_and_expand_character_refs<attribute_value_pred<Ch('\'')>, attribute_value_pure_pred<Ch('\'')>, AttFlags>(text);
|
|
|
- else
|
|
|
- end = skip_and_expand_character_refs<attribute_value_pred<Ch('"')>, attribute_value_pure_pred<Ch('"')>, AttFlags>(text);
|
|
|
-
|
|
|
- // Set attribute value
|
|
|
- attribute->value(value, end - value);
|
|
|
-
|
|
|
- // Make sure that end quote is present
|
|
|
- if (*text != quote)
|
|
|
- RAPIDXML_PARSE_ERROR("expected ' or \"", text);
|
|
|
- ++text; // Skip quote
|
|
|
-
|
|
|
- // Add terminating zero after value
|
|
|
- if (!(Flags & parse_no_string_terminators))
|
|
|
- attribute->value()[attribute->value_size()] = 0;
|
|
|
-
|
|
|
- // Skip whitespace after attribute value
|
|
|
- skip<whitespace_pred, Flags>(text);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- };
|
|
|
-
|
|
|
- //! \cond internal
|
|
|
- namespace internal
|
|
|
- {
|
|
|
-
|
|
|
- // Whitespace (space \n \r \t)
|
|
|
- template<int Dummy>
|
|
|
- const unsigned char lookup_tables<Dummy>::lookup_whitespace[256] =
|
|
|
- {
|
|
|
- // 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, // 0
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1
|
|
|
- 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 3
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 4
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 5
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 6
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 7
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // A
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // B
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // C
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // D
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // E
|
|
|
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // F
|
|
|
- };
|
|
|
-
|
|
|
- // Node name (anything but space \n \r \t / > ? \0)
|
|
|
- template<int Dummy>
|
|
|
- const unsigned char lookup_tables<Dummy>::lookup_node_name[256] =
|
|
|
- {
|
|
|
- // 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
|
|
- 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, // 0
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
|
|
|
- 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, // 2
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, // 3
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
|
|
|
- };
|
|
|
-
|
|
|
- // Text (i.e. PCDATA) (anything but < \0)
|
|
|
- template<int Dummy>
|
|
|
- const unsigned char lookup_tables<Dummy>::lookup_text[256] =
|
|
|
- {
|
|
|
- // 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
|
|
- 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, // 3
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
|
|
|
- };
|
|
|
-
|
|
|
- // Text (i.e. PCDATA) that does not require processing when ws normalization is disabled
|
|
|
- // (anything but < \0 &)
|
|
|
- template<int Dummy>
|
|
|
- const unsigned char lookup_tables<Dummy>::lookup_text_pure_no_ws[256] =
|
|
|
- {
|
|
|
- // 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
|
|
- 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
|
|
|
- 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, // 3
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
|
|
|
- };
|
|
|
-
|
|
|
- // Text (i.e. PCDATA) that does not require processing when ws normalizationis is enabled
|
|
|
- // (anything but < \0 & space \n \r \t)
|
|
|
- template<int Dummy>
|
|
|
- const unsigned char lookup_tables<Dummy>::lookup_text_pure_with_ws[256] =
|
|
|
- {
|
|
|
- // 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
|
|
- 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, // 0
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
|
|
|
- 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, // 3
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
|
|
|
- };
|
|
|
-
|
|
|
- // Attribute name (anything but space \n \r \t / < > = ? ! \0)
|
|
|
- template<int Dummy>
|
|
|
- const unsigned char lookup_tables<Dummy>::lookup_attribute_name[256] =
|
|
|
- {
|
|
|
- // 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
|
|
- 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, // 0
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
|
|
|
- 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, // 2
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, // 3
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
|
|
|
- };
|
|
|
-
|
|
|
- // Attribute data with single quote (anything but ' \0)
|
|
|
- template<int Dummy>
|
|
|
- const unsigned char lookup_tables<Dummy>::lookup_attribute_data_1[256] =
|
|
|
- {
|
|
|
- // 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
|
|
- 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, // 2
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 3
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
|
|
|
- };
|
|
|
-
|
|
|
- // Attribute data with single quote that does not require processing (anything but ' \0 &)
|
|
|
- template<int Dummy>
|
|
|
- const unsigned char lookup_tables<Dummy>::lookup_attribute_data_1_pure[256] =
|
|
|
- {
|
|
|
- // 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
|
|
- 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
|
|
|
- 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, // 2
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 3
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
|
|
|
- };
|
|
|
-
|
|
|
- // Attribute data with double quote (anything but " \0)
|
|
|
- template<int Dummy>
|
|
|
- const unsigned char lookup_tables<Dummy>::lookup_attribute_data_2[256] =
|
|
|
- {
|
|
|
- // 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
|
|
- 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
|
|
|
- 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 3
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
|
|
|
- };
|
|
|
-
|
|
|
- // Attribute data with double quote that does not require processing (anything but " \0 &)
|
|
|
- template<int Dummy>
|
|
|
- const unsigned char lookup_tables<Dummy>::lookup_attribute_data_2_pure[256] =
|
|
|
- {
|
|
|
- // 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
|
|
- 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
|
|
|
- 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 3
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
|
|
|
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
|
|
|
- };
|
|
|
-
|
|
|
- // Digits (dec and hex, 255 denotes end of numeric character reference)
|
|
|
- template<int Dummy>
|
|
|
- const unsigned char lookup_tables<Dummy>::lookup_digits[256] =
|
|
|
- {
|
|
|
- // 0 1 2 3 4 5 6 7 8 9 A B C D E F
|
|
|
- 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 0
|
|
|
- 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 1
|
|
|
- 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 2
|
|
|
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,255,255,255,255,255,255, // 3
|
|
|
- 255, 10, 11, 12, 13, 14, 15,255,255,255,255,255,255,255,255,255, // 4
|
|
|
- 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 5
|
|
|
- 255, 10, 11, 12, 13, 14, 15,255,255,255,255,255,255,255,255,255, // 6
|
|
|
- 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 7
|
|
|
- 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 8
|
|
|
- 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 9
|
|
|
- 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // A
|
|
|
- 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // B
|
|
|
- 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // C
|
|
|
- 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // D
|
|
|
- 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // E
|
|
|
- 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255 // F
|
|
|
- };
|
|
|
-
|
|
|
- // Upper case conversion
|
|
|
- template<int Dummy>
|
|
|
- const unsigned char lookup_tables<Dummy>::lookup_upcase[256] =
|
|
|
- {
|
|
|
- // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A B C D E F
|
|
|
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, // 0
|
|
|
- 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, // 1
|
|
|
- 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, // 2
|
|
|
- 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, // 3
|
|
|
- 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, // 4
|
|
|
- 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, // 5
|
|
|
- 96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, // 6
|
|
|
- 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 123,124,125,126,127, // 7
|
|
|
- 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, // 8
|
|
|
- 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159, // 9
|
|
|
- 160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175, // A
|
|
|
- 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, // B
|
|
|
- 192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207, // C
|
|
|
- 208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223, // D
|
|
|
- 224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239, // E
|
|
|
- 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255 // F
|
|
|
- };
|
|
|
- }
|
|
|
- //! \endcond
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-// Undefine internal macros
|
|
|
-#undef RAPIDXML_PARSE_ERROR
|
|
|
-
|
|
|
-// On MSVC, restore warnings state
|
|
|
-#ifdef _MSC_VER
|
|
|
- #pragma warning(pop)
|
|
|
-#endif
|
|
|
-
|
|
|
-#endif
|
