rapidxml.h

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 $

#include <cstdlib>      // For std::size_t
#include <cassert>      // For assert
#include <new>          // For placement new

#include <exception>    // For std::exception
#include <ostream>
#include <iterator>

namespace rapidxml
{

    class parse_error: public std::exception
    {
    
    public:
    
        parse_error(const char *what, void *where);

        const char *what() const noexcept override;

        char *where() const;

    private:  

        const char *m_what;
        void *m_where;

    };
}

// 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
{
    class xml_node;
    class xml_attribute;
    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;

    // Memory pool
    
    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();

        ~memory_pool();

        xml_node* allocate_node(node_type type, const char *name = nullptr, const char *value = nullptr, std::size_t name_size = 0, std::size_t value_size = 0);

        xml_attribute *allocate_attribute(const char *name = nullptr, const char *value = nullptr, std::size_t name_size = 0, std::size_t value_size = 0);

        char *allocate_string(const char *source = nullptr, std::size_t size = 0);

        xml_node *clone_node(const xml_node *source, xml_node *result = nullptr);

        void clear();

        void set_allocator(alloc_func *af, free_func *ff);

    private:

        struct header
        {
            char *previous_begin;
        };

        void init();
        
        char *align(char *ptr);
        
        char *allocate_raw(std::size_t size);
        
        void *allocate_aligned(std::size_t size);

        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

    class xml_base
    {

    public:
        
        // Construction & destruction
    
        // Construct a base with empty name, value and parent
        xml_base();

        // Node data access
    
        char *name() const;

        std::size_t name_size() const;

        char *value() const;

        std::size_t value_size() const;

        // Node modification
    
        void name(const char *name, std::size_t size);

        void name(const char *name);

        void value(const char *value, std::size_t size);

        void value(const char *value);

        // Related nodes access
    
        xml_node *parent() const;

    protected:

        // Return empty string
        static char *nullstr();

        char *m_name;                         // Name of node, or 0 if no name
        char *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 *m_parent;             // Pointer to parent node, or 0 if none

    };

    class xml_attribute: public xml_base
    {

        friend class xml_node;
    
    public:

        // Construction & destruction
    
        xml_attribute() = default;

        // Related nodes access
    
        xml_document *document() const;

        xml_attribute *previous_attribute(const char *name = nullptr, std::size_t name_size = 0, bool case_sensitive = true) const;

        xml_attribute *next_attribute(const char *name = nullptr, std::size_t name_size = 0, bool case_sensitive = true) const;

    private:

        xml_attribute *m_prev_attribute;        // Pointer to previous sibling of attribute, or 0 if none; only valid if parent is non-zero
        xml_attribute *m_next_attribute;        // Pointer to next sibling of attribute, or 0 if none; only valid if parent is non-zero
    
    };

    // XML node

    class xml_node : public xml_base
    {

    public:

        // Construction & destruction
    
        xml_node(node_type type);

        // Node data access
    
        node_type type() const;

        // Related nodes access
    
        xml_document *document() const;

        xml_node *first_node(const char *name = nullptr, std::size_t name_size = 0, bool case_sensitive = true) const;

        xml_node *last_node(const char *name = nullptr, std::size_t name_size = 0, bool case_sensitive = true) const;

        xml_node *previous_sibling(const char *name = nullptr, std::size_t name_size = 0, bool case_sensitive = true) const;

        xml_node *next_sibling(const char *name = nullptr, std::size_t name_size = 0, bool case_sensitive = true) const;

        xml_attribute *first_attribute(const char *name = nullptr, std::size_t name_size = 0, bool case_sensitive = true) const;

        xml_attribute *last_attribute(const char *name = nullptr, std::size_t name_size = 0, bool case_sensitive = true) const;

        // Node modification
    
        void type(node_type type);

        // Node manipulation

        void prepend_node(xml_node *child);

        void append_node(xml_node *child);

        void insert_node(xml_node *where, xml_node *child);

        void remove_first_node();

        void remove_last_node();

        // \param where Pointer to child to be removed.
        void remove_node(xml_node *where);

        void remove_all_nodes();

        void prepend_attribute(xml_attribute *attribute);

        void append_attribute(xml_attribute *attribute);

        void insert_attribute(xml_attribute *where, xml_attribute *attribute);

        void remove_first_attribute();

        void remove_last_attribute();

        void remove_attribute(xml_attribute *where);

        void remove_all_attributes();
        
    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 *m_first_node;             // Pointer to first child node, or 0 if none; always valid
        xml_node *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 *m_first_attribute;   // Pointer to first attribute of node, or 0 if none; always valid
        xml_attribute *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 *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 *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
    
    class xml_document: public xml_node, public memory_pool
    {
    
    public:

        xml_document();

        template<int Flags>
        void parse(char *text);

        void clear();
        
    private:

        // Internal character utility functions
        
        // Detect whitespace character
        struct whitespace_pred
        {
            static unsigned char test(char ch);
        };

        // Detect node name character
        struct node_name_pred
        {
            static unsigned char test(char ch);
        };

        // Detect attribute name character
        struct attribute_name_pred
        {
            static unsigned char test(char ch);
        };

        // Detect text character (PCDATA)
        struct text_pred
        {
            static unsigned char test(char ch);
        };

        // Detect text character (PCDATA) that does not require processing
        struct text_pure_no_ws_pred
        {
            static unsigned char test(char ch);
        };

        // Detect text character (PCDATA) that does not require processing
        struct text_pure_with_ws_pred
        {
            static unsigned char test(char ch);
        };

        // Detect attribute value character
        template<char Quote>
        struct attribute_value_pred
        {
            static unsigned char test(char ch);
        };

        // Detect attribute value character
        template<char Quote>
        struct attribute_value_pure_pred
        {
            static unsigned char test(char ch);
        };

        // Insert coded character, using UTF8 or 8-bit ASCII
        template<int Flags>
        static void insert_coded_character(char *&text, unsigned long code);

        // Skip characters until predicate evaluates to true
        template<class StopPred, int Flags>
        static void skip(char *&text);

        // 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 char *skip_and_expand_character_refs(char *&text);

        // Internal parsing functions
        
        // Parse BOM, if any
        template<int Flags>
        void parse_bom(char *&text);

        // Parse XML declaration (<?xml...)
        template<int Flags>
        xml_node *parse_xml_declaration(char *&text);

        // Parse XML comment (<!--...)
        template<int Flags>
        xml_node *parse_comment(char *&text);

        // Parse DOCTYPE
        template<int Flags>
        xml_node *parse_doctype(char *&text);

        // Parse PI
        template<int Flags>
        xml_node *parse_pi(char *&text);

        // 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>
        char parse_and_append_data(xml_node *node, char *&text, char *contents_start);

        // Parse CDATA
        template<int Flags>
        xml_node *parse_cdata(char *&text);
        
        // Parse element node
        template<int Flags>
        xml_node *parse_element(char *&text);

        // Determine node type, and parse it
        template<int Flags>
        xml_node *parse_node(char *&text);

        // Parse contents of the node - children, data etc.
        template<int Flags>
        void parse_node_contents(char *&text, xml_node *node);
        
        // Parse XML attributes of the node
        template<int Flags>
        void parse_node_attributes(char *&text, xml_node *node);

    };
}

#endif