rapidxml.hpp

Go to the documentation of this file.

#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 $
 
// If standard library is disabled, user must provide implementations of required functions and typedefs
#if !defined(RAPIDXML_NO_STDLIB)
#include <cassert> // For assert
#include <cstdlib> // For std::size_t
#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
{
    void parse_error_handler(const char* what, void* where);
} // namespace rapidxml
 
#else
 
#include <exception> // For std::exception
 
#define RAPIDXML_PARSE_ERROR(what, where) throw parse_error(what, where)
 
namespace rapidxml
{
 
    class parse_error : public std::exception
    {
 
      public:
        parse_error(const char* what, void* where) : m_what(what), m_where(where)
        {
        }
 
        virtual const char* what() const throw()
        {
            return m_what;
        }
 
        template <class Ch> Ch* where() const
        {
            return reinterpret_cast<Ch*>(m_where);
        }
 
      private:
        const char* m_what;
        void* m_where;
    };
} // namespace rapidxml
 
#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;
 
    enum node_type
    {
        node_document,    
        node_element,     
        node_data,        
        node_cdata,       
        node_comment,     
        node_declaration, 
        node_doctype,     
        node_pi           
    };
 
    // Parsing flags
 
    const int parse_no_data_nodes = 0x1;
 
    const int parse_no_element_values = 0x2;
 
    const int parse_no_string_terminators = 0x4;
 
    const int parse_no_entity_translation = 0x8;
 
    const int parse_no_utf8 = 0x10;
 
    const int parse_declaration_node = 0x20;
 
    const int parse_comment_nodes = 0x40;
 
    const int parse_doctype_node = 0x80;
 
    const int parse_pi_nodes = 0x100;
 
    const int parse_validate_closing_tags = 0x200;
 
    const int parse_trim_whitespace = 0x400;
 
    const int parse_normalize_whitespace = 0x800;
 
    // Compound flags
 
    const int parse_default = 0;
 
    const int parse_non_destructive = parse_no_string_terminators | parse_no_entity_translation;
 
    const int parse_fastest = parse_non_destructive | parse_no_data_nodes;
 
    const int parse_full = parse_declaration_node | parse_comment_nodes | parse_doctype_node | parse_pi_nodes |
                           parse_validate_closing_tags;
 
    // Internals
 
    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;
        }
    } // namespace internal
 
    // Memory pool
 
    template <class Ch = char> class memory_pool
    {
 
      public:
        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
 
        memory_pool() : m_alloc_func(0), m_free_func(0)
        {
            init();
        }
 
        ~memory_pool()
        {
            clear();
        }
 
        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;
        }
 
        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;
        }
 
        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;
        }
 
        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;
        }
 
        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();
        }
 
        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
 
    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
 
        Ch* name() const
        {
            return m_name ? m_name : nullstr();
        }
 
        std::size_t name_size() const
        {
            return m_name ? m_name_size : 0;
        }
 
        Ch* value() const
        {
            return m_value ? m_value : nullstr();
        }
 
        std::size_t value_size() const
        {
            return m_value ? m_value_size : 0;
        }
 
        // Node modification
 
        void name(const Ch* name, std::size_t size)
        {
            m_name = const_cast<Ch*>(name);
            m_name_size = size;
        }
 
        void name(const Ch* name)
        {
            this->name(name, internal::measure(name));
        }
 
        void value(const Ch* value, std::size_t size)
        {
            m_value = const_cast<Ch*>(value);
            m_value_size = size;
        }
 
        void value(const Ch* value)
        {
            this->value(value, internal::measure(value));
        }
 
        // Related nodes access
 
        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
    };
 
    template <class Ch = char> class xml_attribute : public xml_base<Ch>
    {
 
        friend class xml_node<Ch>;
 
      public:
        // Construction & destruction
 
        xml_attribute()
        {
        }
 
        // Related nodes access
 
        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;
        }
 
        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;
        }
 
        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
 
    template <class Ch = char> class xml_node : public xml_base<Ch>
    {
 
      public:
        // Construction & destruction
 
        xml_node(node_type type) : m_type(type), m_first_node(0), m_first_attribute(0)
        {
        }
 
        // Node data access
 
        node_type type() const
        {
            return m_type;
        }
 
        // Related nodes access
 
        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;
        }
 
        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;
        }
 
        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;
        }
 
        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;
        }
 
        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;
        }
 
        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;
        }
 
        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
 
        void type(node_type type)
        {
            m_type = type;
        }
 
        // Node manipulation
 
        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;
        }
 
        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;
        }
 
        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;
            }
        }
 
        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;
        }
 
        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;
        }
 
        // \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;
            }
        }
 
        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;
        }
 
        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;
        }
 
        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;
        }
 
        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;
            }
        }
 
        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;
        }
 
        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;
        }
 
        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;
            }
        }
 
        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
 
    template <class Ch = char> class xml_document : public xml_node<Ch>, public memory_pool<Ch>
    {
 
      public:
        xml_document() : xml_node<Ch>(node_document)
        {
        }
 
        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);
            }
        }
 
        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 (&apos; &amp; &quot; &lt; &gt; &#...;)
        // - 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])
                        {
 
                        // &amp; &apos;
                        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;
 
                        // &quot;
                        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;
 
                        // &gt;
                        case Ch('g'):
                            if (src[2] == Ch('t') && src[3] == Ch(';'))
                            {
                                *dest = Ch('>');
                                ++dest;
                                src += 4;
                                continue;
                            }
                            break;
 
                        // &lt;
                        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);
            }
        }
    };
 
    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
        };
    } // namespace internal
 
} // namespace rapidxml
 
// Undefine internal macros
#undef RAPIDXML_PARSE_ERROR
 
// On MSVC, restore warnings state
#ifdef _MSC_VER
#pragma warning(pop)
#endif
 
#endif