You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2596 lines
116 KiB
2596 lines
116 KiB
#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
|
|
|