1 #ifndef RAPIDXML_HPP_INCLUDED
2 #define RAPIDXML_HPP_INCLUDED
4 // Copyright (C) 2006, 2009 Marcin Kalicinski
6 // Revision $DateTime: 2009/05/13 01:46:17 $
7 //! \file rapidxml.hpp This file contains rapidxml parser and DOM implementation
9 // If standard library is disabled, user must provide implementations of required functions and typedefs
10 #if !defined(RAPIDXML_NO_STDLIB)
11 #include <cstdlib> // For std::size_t
12 #include <cassert> // For assert
13 #include <new> // For placement new
16 // On MSVC, disable "conditional expression is constant" warning (level 4).
17 // This warning is almost impossible to avoid with certain types of templated code
20 #pragma warning(disable:4127) // Conditional expression is constant
23 ///////////////////////////////////////////////////////////////////////////
24 // RAPIDXML_PARSE_ERROR
26 #if defined(RAPIDXML_NO_EXCEPTIONS)
28 #define RAPIDXML_PARSE_ERROR(what, where) { parse_error_handler(what, where); assert(0); }
32 //! When exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS,
33 //! this function is called to notify user about the error.
34 //! It must be defined by the user.
36 //! This function cannot return. If it does, the results are undefined.
38 //! A very simple definition might look like that:
40 //! void %rapidxml::%parse_error_handler(const char *what, void *where)
42 //! std::cout << "Parse error: " << what << "\n";
46 //! \param what Human readable description of the error.
47 //! \param where Pointer to character data where error was detected.
48 void parse_error_handler(const char *what
, void *where
);
53 #include <exception> // For std::exception
55 #define RAPIDXML_PARSE_ERROR(what, where) throw parse_error(what, where)
60 //! Parse error exception.
61 //! This exception is thrown by the parser when an error occurs.
62 //! Use what() function to get human-readable error message.
63 //! Use where() function to get a pointer to position within source text where error was detected.
65 //! If throwing exceptions by the parser is undesirable,
66 //! it can be disabled by defining RAPIDXML_NO_EXCEPTIONS macro before rapidxml.hpp is included.
67 //! This will cause the parser to call rapidxml::parse_error_handler() function instead of throwing an exception.
68 //! This function must be defined by the user.
70 //! This class derives from <code>std::exception</code> class.
71 class parse_error
: public std::exception
76 //! Constructs parse error
77 parse_error(const char *what
, void *where
)
83 //! Gets human readable description of error.
84 //! \return Pointer to null terminated description of the error.
85 virtual const char *what() const throw()
90 //! Gets pointer to character data where error happened.
91 //! Ch should be the same as char type of xml_document that produced the error.
92 //! \return Pointer to location within the parsed string where error occured.
96 return reinterpret_cast<Ch
*>(m_where
);
109 ///////////////////////////////////////////////////////////////////////////
112 #ifndef RAPIDXML_STATIC_POOL_SIZE
113 // Size of static memory block of memory_pool.
114 // Define RAPIDXML_STATIC_POOL_SIZE before including rapidxml.hpp if you want to override the default value.
115 // No dynamic memory allocations are performed by memory_pool until static memory is exhausted.
116 #define RAPIDXML_STATIC_POOL_SIZE (64 * 1024)
119 #ifndef RAPIDXML_DYNAMIC_POOL_SIZE
120 // Size of dynamic memory block of memory_pool.
121 // Define RAPIDXML_DYNAMIC_POOL_SIZE before including rapidxml.hpp if you want to override the default value.
122 // After the static block is exhausted, dynamic blocks with approximately this size are allocated by memory_pool.
123 #define RAPIDXML_DYNAMIC_POOL_SIZE (64 * 1024)
126 #ifndef RAPIDXML_ALIGNMENT
127 // Memory allocation alignment.
128 // Define RAPIDXML_ALIGNMENT before including rapidxml.hpp if you want to override the default value, which is the size of pointer.
129 // All memory allocations for nodes, attributes and strings will be aligned to this value.
130 // This must be a power of 2 and at least 1, otherwise memory_pool will not work.
131 #define RAPIDXML_ALIGNMENT sizeof(void *)
136 // Forward declarations
137 template<class Ch
> class xml_node
;
138 template<class Ch
> class xml_attribute
;
139 template<class Ch
> class xml_document
;
141 //! Enumeration listing all node types produced by the parser.
142 //! Use xml_node::type() function to query node type.
145 node_document
, //!< A document node. Name and value are empty.
146 node_element
, //!< An element node. Name contains element name. Value contains text of first data node.
147 node_data
, //!< A data node. Name is empty. Value contains data text.
148 node_cdata
, //!< A CDATA node. Name is empty. Value contains data text.
149 node_comment
, //!< A comment node. Name is empty. Value contains comment text.
150 node_declaration
, //!< A declaration node. Name and value are empty. Declaration parameters (version, encoding and standalone) are in node attributes.
151 node_doctype
, //!< A DOCTYPE node. Name is empty. Value contains DOCTYPE text.
152 node_pi
//!< A PI node. Name contains target. Value contains instructions.
155 ///////////////////////////////////////////////////////////////////////
158 //! Parse flag instructing the parser to not create data nodes.
159 //! Text of first data node will still be placed in value of parent element, unless rapidxml::parse_no_element_values flag is also specified.
160 //! Can be combined with other flags by use of | operator.
162 //! See xml_document::parse() function.
163 const int parse_no_data_nodes
= 0x1;
165 //! Parse flag instructing the parser to not use text of first data node as a value of parent element.
166 //! Can be combined with other flags by use of | operator.
167 //! Note that child data nodes of element node take precendence over its value when printing.
168 //! That is, if element has one or more child data nodes <em>and</em> a value, the value will be ignored.
169 //! Use rapidxml::parse_no_data_nodes flag to prevent creation of data nodes if you want to manipulate data using values of elements.
171 //! See xml_document::parse() function.
172 const int parse_no_element_values
= 0x2;
174 //! Parse flag instructing the parser to not place zero terminators after strings in the source text.
175 //! By default zero terminators are placed, modifying source text.
176 //! Can be combined with other flags by use of | operator.
178 //! See xml_document::parse() function.
179 const int parse_no_string_terminators
= 0x4;
181 //! Parse flag instructing the parser to not translate entities in the source text.
182 //! By default entities are translated, modifying source text.
183 //! Can be combined with other flags by use of | operator.
185 //! See xml_document::parse() function.
186 const int parse_no_entity_translation
= 0x8;
188 //! Parse flag instructing the parser to disable UTF-8 handling and assume plain 8 bit characters.
189 //! By default, UTF-8 handling is enabled.
190 //! Can be combined with other flags by use of | operator.
192 //! See xml_document::parse() function.
193 const int parse_no_utf8
= 0x10;
195 //! Parse flag instructing the parser to create XML declaration node.
196 //! By default, declaration node is not created.
197 //! Can be combined with other flags by use of | operator.
199 //! See xml_document::parse() function.
200 const int parse_declaration_node
= 0x20;
202 //! Parse flag instructing the parser to create comments nodes.
203 //! By default, comment nodes are not created.
204 //! Can be combined with other flags by use of | operator.
206 //! See xml_document::parse() function.
207 const int parse_comment_nodes
= 0x40;
209 //! Parse flag instructing the parser to create DOCTYPE node.
210 //! By default, doctype node is not created.
211 //! Although W3C specification allows at most one DOCTYPE node, RapidXml will silently accept documents with more than one.
212 //! Can be combined with other flags by use of | operator.
214 //! See xml_document::parse() function.
215 const int parse_doctype_node
= 0x80;
217 //! Parse flag instructing the parser to create PI nodes.
218 //! By default, PI nodes are not created.
219 //! Can be combined with other flags by use of | operator.
221 //! See xml_document::parse() function.
222 const int parse_pi_nodes
= 0x100;
224 //! Parse flag instructing the parser to validate closing tag names.
225 //! If not set, name inside closing tag is irrelevant to the parser.
226 //! By default, closing tags are not validated.
227 //! Can be combined with other flags by use of | operator.
229 //! See xml_document::parse() function.
230 const int parse_validate_closing_tags
= 0x200;
232 //! Parse flag instructing the parser to trim all leading and trailing whitespace of data nodes.
233 //! By default, whitespace is not trimmed.
234 //! This flag does not cause the parser to modify source text.
235 //! Can be combined with other flags by use of | operator.
237 //! See xml_document::parse() function.
238 const int parse_trim_whitespace
= 0x400;
240 //! Parse flag instructing the parser to condense all whitespace runs of data nodes to a single space character.
241 //! Trimming of leading and trailing whitespace of data is controlled by rapidxml::parse_trim_whitespace flag.
242 //! By default, whitespace is not normalized.
243 //! If this flag is specified, source text will be modified.
244 //! Can be combined with other flags by use of | operator.
246 //! See xml_document::parse() function.
247 const int parse_normalize_whitespace
= 0x800;
251 //! Parse flags which represent default behaviour of the parser.
252 //! This is always equal to 0, so that all other flags can be simply ored together.
253 //! Normally there is no need to inconveniently disable flags by anding with their negated (~) values.
254 //! This also means that meaning of each flag is a <i>negation</i> of the default setting.
255 //! For example, if flag name is rapidxml::parse_no_utf8, it means that utf-8 is <i>enabled</i> by default,
256 //! and using the flag will disable it.
258 //! See xml_document::parse() function.
259 const int parse_default
= 0;
261 //! A combination of parse flags that forbids any modifications of the source text.
262 //! This also results in faster parsing. However, note that the following will occur:
264 //! <li>names and values of nodes will not be zero terminated, you have to use xml_base::name_size() and xml_base::value_size() functions to determine where name and value ends</li>
265 //! <li>entities will not be translated</li>
266 //! <li>whitespace will not be normalized</li>
268 //! See xml_document::parse() function.
269 const int parse_non_destructive
= parse_no_string_terminators
| parse_no_entity_translation
;
271 //! A combination of parse flags resulting in fastest possible parsing, without sacrificing important data.
273 //! See xml_document::parse() function.
274 const int parse_fastest
= parse_non_destructive
| parse_no_data_nodes
;
276 //! A combination of parse flags resulting in largest amount of data being extracted.
277 //! This usually results in slowest parsing.
279 //! See xml_document::parse() function.
280 const int parse_full
= parse_declaration_node
| parse_comment_nodes
| parse_doctype_node
| parse_pi_nodes
| parse_validate_closing_tags
;
282 ///////////////////////////////////////////////////////////////////////
289 // Struct that contains lookup tables for the parser
290 // It must be a template to allow correct linking (because it has static data members, which are defined in a header file).
294 static const unsigned char lookup_whitespace
[256]; // Whitespace table
295 static const unsigned char lookup_node_name
[256]; // Node name table
296 static const unsigned char lookup_text
[256]; // Text table
297 static const unsigned char lookup_text_pure_no_ws
[256]; // Text table
298 static const unsigned char lookup_text_pure_with_ws
[256]; // Text table
299 static const unsigned char lookup_attribute_name
[256]; // Attribute name table
300 static const unsigned char lookup_attribute_data_1
[256]; // Attribute data table with single quote
301 static const unsigned char lookup_attribute_data_1_pure
[256]; // Attribute data table with single quote
302 static const unsigned char lookup_attribute_data_2
[256]; // Attribute data table with double quotes
303 static const unsigned char lookup_attribute_data_2_pure
[256]; // Attribute data table with double quotes
304 static const unsigned char lookup_digits
[256]; // Digits
305 static const unsigned char lookup_upcase
[256]; // To uppercase conversion table for ASCII characters
308 // Find length of the string
310 inline std::size_t measure(const Ch
*p
)
318 // Compare strings for equality
320 inline bool compare(const Ch
*p1
, std::size_t size1
, const Ch
*p2
, std::size_t size2
, bool case_sensitive
)
326 for (const Ch
*end
= p1
+ size1
; p1
< end
; ++p1
, ++p2
)
332 for (const Ch
*end
= p1
+ size1
; p1
< end
; ++p1
, ++p2
)
333 if (lookup_tables
<0>::lookup_upcase
[static_cast<unsigned char>(*p1
)] != lookup_tables
<0>::lookup_upcase
[static_cast<unsigned char>(*p2
)])
341 ///////////////////////////////////////////////////////////////////////
344 //! This class is used by the parser to create new nodes and attributes, without overheads of dynamic memory allocation.
345 //! In most cases, you will not need to use this class directly.
346 //! However, if you need to create nodes manually or modify names/values of nodes,
347 //! you are encouraged to use memory_pool of relevant xml_document to allocate the memory.
348 //! Not only is this faster than allocating them by using <code>new</code> operator,
349 //! but also their lifetime will be tied to the lifetime of document,
350 //! possibly simplyfing memory management.
352 //! Call allocate_node() or allocate_attribute() functions to obtain new nodes or attributes from the pool.
353 //! You can also call allocate_string() function to allocate strings.
354 //! Such strings can then be used as names or values of nodes without worrying about their lifetime.
355 //! Note that there is no <code>free()</code> function -- all allocations are freed at once when clear() function is called,
356 //! or when the pool is destroyed.
358 //! It is also possible to create a standalone memory_pool, and use it
359 //! to allocate nodes, whose lifetime will not be tied to any document.
361 //! Pool maintains <code>RAPIDXML_STATIC_POOL_SIZE</code> bytes of statically allocated memory.
362 //! Until static memory is exhausted, no dynamic memory allocations are done.
363 //! When static memory is exhausted, pool allocates additional blocks of memory of size <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> each,
364 //! by using global <code>new[]</code> and <code>delete[]</code> operators.
365 //! This behaviour can be changed by setting custom allocation routines.
366 //! Use set_allocator() function to set them.
368 //! Allocations for nodes, attributes and strings are aligned at <code>RAPIDXML_ALIGNMENT</code> bytes.
369 //! This value defaults to the size of pointer on target architecture.
371 //! To obtain absolutely top performance from the parser,
372 //! it is important that all nodes are allocated from a single, contiguous block of memory.
373 //! Otherwise, cache misses when jumping between two (or more) disjoint blocks of memory can slow down parsing quite considerably.
374 //! If required, you can tweak <code>RAPIDXML_STATIC_POOL_SIZE</code>, <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> and <code>RAPIDXML_ALIGNMENT</code>
375 //! to obtain best wasted memory to performance compromise.
376 //! To do it, define their values before rapidxml.hpp file is included.
377 //! \param Ch Character type of created nodes.
378 template<class Ch
= char>
385 typedef void *(alloc_func
)(std::size_t); // Type of user-defined function used to allocate memory
386 typedef void (free_func
)(void *); // Type of user-defined function used to free memory
389 //! Constructs empty pool with default allocator functions.
397 //! Destroys pool and frees all the memory.
398 //! This causes memory occupied by nodes allocated by the pool to be freed.
399 //! Nodes allocated from the pool are no longer valid.
405 //! Allocates a new node from the pool, and optionally assigns name and value to it.
406 //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
407 //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
408 //! will call rapidxml::parse_error_handler() function.
409 //! \param type Type of node to create.
410 //! \param name Name to assign to the node, or 0 to assign no name.
411 //! \param value Value to assign to the node, or 0 to assign no value.
412 //! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.
413 //! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.
414 //! \return Pointer to allocated node. This pointer will never be NULL.
415 xml_node
<Ch
> *allocate_node(node_type type
,
416 const Ch
*name
= 0, const Ch
*value
= 0,
417 std::size_t name_size
= 0, std::size_t value_size
= 0)
419 void *memory
= allocate_aligned(sizeof(xml_node
<Ch
>));
420 xml_node
<Ch
> *node
= new(memory
) xml_node
<Ch
>(type
);
424 node
->name(name
, name_size
);
431 node
->value(value
, value_size
);
438 //! Allocates a new attribute from the pool, and optionally assigns name and value to it.
439 //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
440 //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
441 //! will call rapidxml::parse_error_handler() function.
442 //! \param name Name to assign to the attribute, or 0 to assign no name.
443 //! \param value Value to assign to the attribute, or 0 to assign no value.
444 //! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.
445 //! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.
446 //! \return Pointer to allocated attribute. This pointer will never be NULL.
447 xml_attribute
<Ch
> *allocate_attribute(const Ch
*name
= 0, const Ch
*value
= 0,
448 std::size_t name_size
= 0, std::size_t value_size
= 0)
450 void *memory
= allocate_aligned(sizeof(xml_attribute
<Ch
>));
451 xml_attribute
<Ch
> *attribute
= new(memory
) xml_attribute
<Ch
>;
455 attribute
->name(name
, name_size
);
457 attribute
->name(name
);
462 attribute
->value(value
, value_size
);
464 attribute
->value(value
);
469 //! Allocates a char array of given size from the pool, and optionally copies a given string to it.
470 //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
471 //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
472 //! will call rapidxml::parse_error_handler() function.
473 //! \param source String to initialize the allocated memory with, or 0 to not initialize it.
474 //! \param size Number of characters to allocate, or zero to calculate it automatically from source string length; if size is 0, source string must be specified and null terminated.
475 //! \return Pointer to allocated char array. This pointer will never be NULL.
476 Ch
*allocate_string(const Ch
*source
= 0, std::size_t size
= 0)
478 assert(source
|| size
); // Either source or size (or both) must be specified
480 size
= internal::measure(source
) + 1;
481 Ch
*result
= static_cast<Ch
*>(allocate_aligned(size
* sizeof(Ch
)));
483 for (std::size_t i
= 0; i
< size
; ++i
)
484 result
[i
] = source
[i
];
488 //! Clones an xml_node and its hierarchy of child nodes and attributes.
489 //! Nodes and attributes are allocated from this memory pool.
490 //! Names and values are not cloned, they are shared between the clone and the source.
491 //! Result node can be optionally specified as a second parameter,
492 //! in which case its contents will be replaced with cloned source node.
493 //! This is useful when you want to clone entire document.
494 //! \param source Node to clone.
495 //! \param result Node to put results in, or 0 to automatically allocate result node
496 //! \return Pointer to cloned node. This pointer will never be NULL.
497 xml_node
<Ch
> *clone_node(const xml_node
<Ch
> *source
, xml_node
<Ch
> *result
= 0)
499 // Prepare result node
502 result
->remove_all_attributes();
503 result
->remove_all_nodes();
504 result
->type(source
->type());
507 result
= allocate_node(source
->type());
509 // Clone name and value
510 result
->name(source
->name(), source
->name_size());
511 result
->value(source
->value(), source
->value_size());
513 // Clone child nodes and attributes
514 for (xml_node
<Ch
> *child
= source
->first_node(); child
; child
= child
->next_sibling())
515 result
->append_node(clone_node(child
));
516 for (xml_attribute
<Ch
> *attr
= source
->first_attribute(); attr
; attr
= attr
->next_attribute())
517 result
->append_attribute(allocate_attribute(attr
->name(), attr
->value(), attr
->name_size(), attr
->value_size()));
523 //! This causes memory occupied by nodes allocated by the pool to be freed.
524 //! Any nodes or strings allocated from the pool will no longer be valid.
527 while (m_begin
!= m_static_memory
)
529 char *previous_begin
= reinterpret_cast<header
*>(align(m_begin
))->previous_begin
;
531 m_free_func(m_begin
);
534 m_begin
= previous_begin
;
539 //! Sets or resets the user-defined memory allocation functions for the pool.
540 //! This can only be called when no memory is allocated from the pool yet, otherwise results are undefined.
541 //! Allocation function must not return invalid pointer on failure. It should either throw,
542 //! stop the program, or use <code>longjmp()</code> function to pass control to other place of program.
543 //! If it returns invalid pointer, results are undefined.
545 //! User defined allocation functions must have the following forms:
547 //! <br>void *allocate(std::size_t size);
548 //! <br>void free(void *pointer);
550 //! \param af Allocation function, or 0 to restore default function
551 //! \param ff Free function, or 0 to restore default function
552 void set_allocator(alloc_func
*af
, free_func
*ff
)
554 assert(m_begin
== m_static_memory
&& m_ptr
== align(m_begin
)); // Verify that no memory is allocated yet
563 char *previous_begin
;
568 m_begin
= m_static_memory
;
569 m_ptr
= align(m_begin
);
570 m_end
= m_static_memory
+ sizeof(m_static_memory
);
573 char *align(char *ptr
)
575 std::size_t alignment
= ((RAPIDXML_ALIGNMENT
- (std::size_t(ptr
) & (RAPIDXML_ALIGNMENT
- 1))) & (RAPIDXML_ALIGNMENT
- 1));
576 return ptr
+ alignment
;
579 char *allocate_raw(std::size_t size
)
583 if (m_alloc_func
) // Allocate memory using either user-specified allocation function or global operator new[]
585 memory
= m_alloc_func(size
);
586 assert(memory
); // Allocator is not allowed to return 0, on failure it must either throw, stop the program or use longjmp
590 memory
= new char[size
];
591 #ifdef RAPIDXML_NO_EXCEPTIONS
592 if (!memory
) // If exceptions are disabled, verify memory allocation, because new will not be able to throw bad_alloc
593 RAPIDXML_PARSE_ERROR("out of memory", 0);
596 return static_cast<char *>(memory
);
599 void *allocate_aligned(std::size_t size
)
601 // Calculate aligned pointer
602 char *result
= align(m_ptr
);
604 // If not enough memory left in current pool, allocate a new pool
605 if (result
+ size
> m_end
)
607 // Calculate required pool size (may be bigger than RAPIDXML_DYNAMIC_POOL_SIZE)
608 std::size_t pool_size
= RAPIDXML_DYNAMIC_POOL_SIZE
;
609 if (pool_size
< size
)
613 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
614 char *raw_memory
= allocate_raw(alloc_size
);
616 // Setup new pool in allocated memory
617 char *pool
= align(raw_memory
);
618 header
*new_header
= reinterpret_cast<header
*>(pool
);
619 new_header
->previous_begin
= m_begin
;
620 m_begin
= raw_memory
;
621 m_ptr
= pool
+ sizeof(header
);
622 m_end
= raw_memory
+ alloc_size
;
624 // Calculate aligned pointer again using new pool
625 result
= align(m_ptr
);
628 // Update pool and return aligned pointer
629 m_ptr
= result
+ size
;
633 char *m_begin
; // Start of raw memory making up current pool
634 char *m_ptr
; // First free byte in current pool
635 char *m_end
; // One past last available byte in current pool
636 char m_static_memory
[RAPIDXML_STATIC_POOL_SIZE
]; // Static raw memory
637 alloc_func
*m_alloc_func
; // Allocator function, or 0 if default is to be used
638 free_func
*m_free_func
; // Free function, or 0 if default is to be used
641 ///////////////////////////////////////////////////////////////////////////
644 //! Base class for xml_node and xml_attribute implementing common functions:
645 //! name(), name_size(), value(), value_size() and parent().
646 //! \param Ch Character type to use
647 template<class Ch
= char>
653 ///////////////////////////////////////////////////////////////////////////
654 // Construction & destruction
656 // Construct a base with empty name, value and parent
664 ///////////////////////////////////////////////////////////////////////////
667 //! Gets name of the node.
668 //! Interpretation of name depends on type of node.
669 //! Note that name will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.
671 //! Use name_size() function to determine length of the name.
672 //! \return Name of node, or empty string if node has no name.
675 return m_name
? m_name
: nullstr();
678 //! Gets size of node name, not including terminator character.
679 //! This function works correctly irrespective of whether name is or is not zero terminated.
680 //! \return Size of node name, in characters.
681 std::size_t name_size() const
683 return m_name
? m_name_size
: 0;
686 //! Gets value of node.
687 //! Interpretation of value depends on type of node.
688 //! Note that value will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.
690 //! Use value_size() function to determine length of the value.
691 //! \return Value of node, or empty string if node has no value.
694 return m_value
? m_value
: nullstr();
697 //! Gets size of node value, not including terminator character.
698 //! This function works correctly irrespective of whether value is or is not zero terminated.
699 //! \return Size of node value, in characters.
700 std::size_t value_size() const
702 return m_value
? m_value_size
: 0;
705 ///////////////////////////////////////////////////////////////////////////
708 //! Sets name of node to a non zero-terminated string.
709 //! See \ref ownership_of_strings.
711 //! Note that node does not own its name or value, it only stores a pointer to it.
712 //! It will not delete or otherwise free the pointer on destruction.
713 //! It is reponsibility of the user to properly manage lifetime of the string.
714 //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
715 //! on destruction of the document the string will be automatically freed.
717 //! Size of name must be specified separately, because name does not have to be zero terminated.
718 //! Use name(const Ch *) function to have the length automatically calculated (string must be zero terminated).
719 //! \param name Name of node to set. Does not have to be zero terminated.
720 //! \param size Size of name, in characters. This does not include zero terminator, if one is present.
721 void name(const Ch
*name
, std::size_t size
)
723 m_name
= const_cast<Ch
*>(name
);
727 //! Sets name of node to a zero-terminated string.
728 //! See also \ref ownership_of_strings and xml_node::name(const Ch *, std::size_t).
729 //! \param name Name of node to set. Must be zero terminated.
730 void name(const Ch
*name
)
732 this->name(name
, internal::measure(name
));
735 //! Sets value of node to a non zero-terminated string.
736 //! See \ref ownership_of_strings.
738 //! Note that node does not own its name or value, it only stores a pointer to it.
739 //! It will not delete or otherwise free the pointer on destruction.
740 //! It is reponsibility of the user to properly manage lifetime of the string.
741 //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
742 //! on destruction of the document the string will be automatically freed.
744 //! Size of value must be specified separately, because it does not have to be zero terminated.
745 //! Use value(const Ch *) function to have the length automatically calculated (string must be zero terminated).
747 //! If an element has a child node of type node_data, it will take precedence over element value when printing.
748 //! If you want to manipulate data of elements using values, use parser flag rapidxml::parse_no_data_nodes to prevent creation of data nodes by the parser.
749 //! \param value value of node to set. Does not have to be zero terminated.
750 //! \param size Size of value, in characters. This does not include zero terminator, if one is present.
751 void value(const Ch
*value
, std::size_t size
)
753 m_value
= const_cast<Ch
*>(value
);
757 //! Sets value of node to a zero-terminated string.
758 //! See also \ref ownership_of_strings and xml_node::value(const Ch *, std::size_t).
759 //! \param value Vame of node to set. Must be zero terminated.
760 void value(const Ch
*value
)
762 this->value(value
, internal::measure(value
));
765 ///////////////////////////////////////////////////////////////////////////
766 // Related nodes access
768 //! Gets node parent.
769 //! \return Pointer to parent node, or 0 if there is no parent.
770 xml_node
<Ch
> *parent() const
777 // Return empty string
780 static Ch zero
= Ch('\0');
784 Ch
*m_name
; // Name of node, or 0 if no name
785 Ch
*m_value
; // Value of node, or 0 if no value
786 std::size_t m_name_size
; // Length of node name, or undefined of no name
787 std::size_t m_value_size
; // Length of node value, or undefined if no value
788 xml_node
<Ch
> *m_parent
; // Pointer to parent node, or 0 if none
792 //! Class representing attribute node of XML document.
793 //! Each attribute has name and value strings, which are available through name() and value() functions (inherited from xml_base).
794 //! Note that after parse, both name and value of attribute will point to interior of source text used for parsing.
795 //! Thus, this text must persist in memory for the lifetime of attribute.
796 //! \param Ch Character type to use.
797 template<class Ch
= char>
798 class xml_attribute
: public xml_base
<Ch
>
801 friend class xml_node
<Ch
>;
805 ///////////////////////////////////////////////////////////////////////////
806 // Construction & destruction
808 //! Constructs an empty attribute with the specified type.
809 //! Consider using memory_pool of appropriate xml_document if allocating attributes manually.
814 ///////////////////////////////////////////////////////////////////////////
815 // Related nodes access
817 //! Gets document of which attribute is a child.
818 //! \return Pointer to document that contains this attribute, or 0 if there is no parent document.
819 xml_document
<Ch
> *document() const
821 if (xml_node
<Ch
> *node
= this->parent())
823 while (node
->parent())
824 node
= node
->parent();
825 return node
->type() == node_document
? static_cast<xml_document
<Ch
> *>(node
) : 0;
831 //! Gets previous attribute, optionally matching attribute name.
832 //! \param name Name of attribute to find, or 0 to return previous attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
833 //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
834 //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
835 //! \return Pointer to found attribute, or 0 if not found.
836 xml_attribute
<Ch
> *previous_attribute(const Ch
*name
= 0, std::size_t name_size
= 0, bool case_sensitive
= true) const
841 name_size
= internal::measure(name
);
842 for (xml_attribute
<Ch
> *attribute
= m_prev_attribute
; attribute
; attribute
= attribute
->m_prev_attribute
)
843 if (internal::compare(attribute
->name(), attribute
->name_size(), name
, name_size
, case_sensitive
))
848 return this->m_parent
? m_prev_attribute
: 0;
851 //! Gets next attribute, optionally matching attribute name.
852 //! \param name Name of attribute to find, or 0 to return next attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
853 //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
854 //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
855 //! \return Pointer to found attribute, or 0 if not found.
856 xml_attribute
<Ch
> *next_attribute(const Ch
*name
= 0, std::size_t name_size
= 0, bool case_sensitive
= true) const
861 name_size
= internal::measure(name
);
862 for (xml_attribute
<Ch
> *attribute
= m_next_attribute
; attribute
; attribute
= attribute
->m_next_attribute
)
863 if (internal::compare(attribute
->name(), attribute
->name_size(), name
, name_size
, case_sensitive
))
868 return this->m_parent
? m_next_attribute
: 0;
873 xml_attribute
<Ch
> *m_prev_attribute
; // Pointer to previous sibling of attribute, or 0 if none; only valid if parent is non-zero
874 xml_attribute
<Ch
> *m_next_attribute
; // Pointer to next sibling of attribute, or 0 if none; only valid if parent is non-zero
878 ///////////////////////////////////////////////////////////////////////////
881 //! Class representing a node of XML document.
882 //! Each node may have associated name and value strings, which are available through name() and value() functions.
883 //! Interpretation of name and value depends on type of the node.
884 //! Type of node can be determined by using type() function.
886 //! Note that after parse, both name and value of node, if any, will point interior of source text used for parsing.
887 //! Thus, this text must persist in the memory for the lifetime of node.
888 //! \param Ch Character type to use.
889 template<class Ch
= char>
890 class xml_node
: public xml_base
<Ch
>
895 ///////////////////////////////////////////////////////////////////////////
896 // Construction & destruction
898 //! Constructs an empty node with the specified type.
899 //! Consider using memory_pool of appropriate document to allocate nodes manually.
900 //! \param type Type of node to construct.
901 xml_node(node_type type
)
904 , m_first_attribute(0)
908 ///////////////////////////////////////////////////////////////////////////
911 //! Gets type of node.
912 //! \return Type of node.
913 node_type
type() const
918 ///////////////////////////////////////////////////////////////////////////
919 // Related nodes access
921 //! Gets document of which node is a child.
922 //! \return Pointer to document that contains this node, or 0 if there is no parent document.
923 xml_document
<Ch
> *document() const
925 xml_node
<Ch
> *node
= const_cast<xml_node
<Ch
> *>(this);
926 while (node
->parent())
927 node
= node
->parent();
928 return node
->type() == node_document
? static_cast<xml_document
<Ch
> *>(node
) : 0;
931 //! Gets first child node, optionally matching node name.
932 //! \param name Name of child to find, or 0 to return first child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
933 //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
934 //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
935 //! \return Pointer to found child, or 0 if not found.
936 xml_node
<Ch
> *first_node(const Ch
*name
= 0, std::size_t name_size
= 0, bool case_sensitive
= true) const
941 name_size
= internal::measure(name
);
942 for (xml_node
<Ch
> *child
= m_first_node
; child
; child
= child
->next_sibling())
943 if (internal::compare(child
->name(), child
->name_size(), name
, name_size
, case_sensitive
))
951 //! Gets last child node, optionally matching node name.
952 //! Behaviour is undefined if node has no children.
953 //! Use first_node() to test if node has children.
954 //! \param name Name of child to find, or 0 to return last child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
955 //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
956 //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
957 //! \return Pointer to found child, or 0 if not found.
958 xml_node
<Ch
> *last_node(const Ch
*name
= 0, std::size_t name_size
= 0, bool case_sensitive
= true) const
960 assert(m_first_node
); // Cannot query for last child if node has no children
964 name_size
= internal::measure(name
);
965 for (xml_node
<Ch
> *child
= m_last_node
; child
; child
= child
->previous_sibling())
966 if (internal::compare(child
->name(), child
->name_size(), name
, name_size
, case_sensitive
))
974 //! Gets previous sibling node, optionally matching node name.
975 //! Behaviour is undefined if node has no parent.
976 //! Use parent() to test if node has a parent.
977 //! \param name Name of sibling to find, or 0 to return previous sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
978 //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
979 //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
980 //! \return Pointer to found sibling, or 0 if not found.
981 xml_node
<Ch
> *previous_sibling(const Ch
*name
= 0, std::size_t name_size
= 0, bool case_sensitive
= true) const
983 assert(this->m_parent
); // Cannot query for siblings if node has no parent
987 name_size
= internal::measure(name
);
988 for (xml_node
<Ch
> *sibling
= m_prev_sibling
; sibling
; sibling
= sibling
->m_prev_sibling
)
989 if (internal::compare(sibling
->name(), sibling
->name_size(), name
, name_size
, case_sensitive
))
994 return m_prev_sibling
;
997 //! Gets next sibling node, optionally matching node name.
998 //! Behaviour is undefined if node has no parent.
999 //! Use parent() to test if node has a parent.
1000 //! \param name Name of sibling to find, or 0 to return next sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
1001 //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
1002 //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
1003 //! \return Pointer to found sibling, or 0 if not found.
1004 xml_node
<Ch
> *next_sibling(const Ch
*name
= 0, std::size_t name_size
= 0, bool case_sensitive
= true) const
1006 assert(this->m_parent
); // Cannot query for siblings if node has no parent
1010 name_size
= internal::measure(name
);
1011 for (xml_node
<Ch
> *sibling
= m_next_sibling
; sibling
; sibling
= sibling
->m_next_sibling
)
1012 if (internal::compare(sibling
->name(), sibling
->name_size(), name
, name_size
, case_sensitive
))
1017 return m_next_sibling
;
1020 //! Gets first attribute of node, optionally matching attribute name.
1021 //! \param name Name of attribute to find, or 0 to return first attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
1022 //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
1023 //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
1024 //! \return Pointer to found attribute, or 0 if not found.
1025 xml_attribute
<Ch
> *first_attribute(const Ch
*name
= 0, std::size_t name_size
= 0, bool case_sensitive
= true) const
1030 name_size
= internal::measure(name
);
1031 for (xml_attribute
<Ch
> *attribute
= m_first_attribute
; attribute
; attribute
= attribute
->m_next_attribute
)
1032 if (internal::compare(attribute
->name(), attribute
->name_size(), name
, name_size
, case_sensitive
))
1037 return m_first_attribute
;
1040 //! Gets last attribute of node, optionally matching attribute name.
1041 //! \param name Name of attribute to find, or 0 to return last attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
1042 //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
1043 //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
1044 //! \return Pointer to found attribute, or 0 if not found.
1045 xml_attribute
<Ch
> *last_attribute(const Ch
*name
= 0, std::size_t name_size
= 0, bool case_sensitive
= true) const
1050 name_size
= internal::measure(name
);
1051 for (xml_attribute
<Ch
> *attribute
= m_last_attribute
; attribute
; attribute
= attribute
->m_prev_attribute
)
1052 if (internal::compare(attribute
->name(), attribute
->name_size(), name
, name_size
, case_sensitive
))
1057 return m_first_attribute
? m_last_attribute
: 0;
1060 ///////////////////////////////////////////////////////////////////////////
1061 // Node modification
1063 //! Sets type of node.
1064 //! \param type Type of node to set.
1065 void type(node_type type
)
1070 ///////////////////////////////////////////////////////////////////////////
1071 // Node manipulation
1073 //! Prepends a new child node.
1074 //! The prepended child becomes the first child, and all existing children are moved one position back.
1075 //! \param child Node to prepend.
1076 void prepend_node(xml_node
<Ch
> *child
)
1078 assert(child
&& !child
->parent() && child
->type() != node_document
);
1081 child
->m_next_sibling
= m_first_node
;
1082 m_first_node
->m_prev_sibling
= child
;
1086 child
->m_next_sibling
= 0;
1087 m_last_node
= child
;
1089 m_first_node
= child
;
1090 child
->m_parent
= this;
1091 child
->m_prev_sibling
= 0;
1094 //! Appends a new child node.
1095 //! The appended child becomes the last child.
1096 //! \param child Node to append.
1097 void append_node(xml_node
<Ch
> *child
)
1099 assert(child
&& !child
->parent() && child
->type() != node_document
);
1102 child
->m_prev_sibling
= m_last_node
;
1103 m_last_node
->m_next_sibling
= child
;
1107 child
->m_prev_sibling
= 0;
1108 m_first_node
= child
;
1110 m_last_node
= child
;
1111 child
->m_parent
= this;
1112 child
->m_next_sibling
= 0;
1115 //! Inserts a new child node at specified place inside the node.
1116 //! All children after and including the specified node are moved one position back.
1117 //! \param where Place where to insert the child, or 0 to insert at the back.
1118 //! \param child Node to insert.
1119 void insert_node(xml_node
<Ch
> *where
, xml_node
<Ch
> *child
)
1121 assert(!where
|| where
->parent() == this);
1122 assert(child
&& !child
->parent() && child
->type() != node_document
);
1123 if (where
== m_first_node
)
1124 prepend_node(child
);
1125 else if (where
== 0)
1129 child
->m_prev_sibling
= where
->m_prev_sibling
;
1130 child
->m_next_sibling
= where
;
1131 where
->m_prev_sibling
->m_next_sibling
= child
;
1132 where
->m_prev_sibling
= child
;
1133 child
->m_parent
= this;
1137 //! Removes first child node.
1138 //! If node has no children, behaviour is undefined.
1139 //! Use first_node() to test if node has children.
1140 void remove_first_node()
1142 assert(first_node());
1143 xml_node
<Ch
> *child
= m_first_node
;
1144 m_first_node
= child
->m_next_sibling
;
1145 if (child
->m_next_sibling
)
1146 child
->m_next_sibling
->m_prev_sibling
= 0;
1149 child
->m_parent
= 0;
1152 //! Removes last child of the node.
1153 //! If node has no children, behaviour is undefined.
1154 //! Use first_node() to test if node has children.
1155 void remove_last_node()
1157 assert(first_node());
1158 xml_node
<Ch
> *child
= m_last_node
;
1159 if (child
->m_prev_sibling
)
1161 m_last_node
= child
->m_prev_sibling
;
1162 child
->m_prev_sibling
->m_next_sibling
= 0;
1166 child
->m_parent
= 0;
1169 //! Removes specified child from the node
1170 // \param where Pointer to child to be removed.
1171 void remove_node(xml_node
<Ch
> *where
)
1173 assert(where
&& where
->parent() == this);
1174 assert(first_node());
1175 if (where
== m_first_node
)
1176 remove_first_node();
1177 else if (where
== m_last_node
)
1181 where
->m_prev_sibling
->m_next_sibling
= where
->m_next_sibling
;
1182 where
->m_next_sibling
->m_prev_sibling
= where
->m_prev_sibling
;
1183 where
->m_parent
= 0;
1187 //! Removes all child nodes (but not attributes).
1188 void remove_all_nodes()
1190 for (xml_node
<Ch
> *node
= first_node(); node
; node
= node
->m_next_sibling
)
1195 //! Prepends a new attribute to the node.
1196 //! \param attribute Attribute to prepend.
1197 void prepend_attribute(xml_attribute
<Ch
> *attribute
)
1199 assert(attribute
&& !attribute
->parent());
1200 if (first_attribute())
1202 attribute
->m_next_attribute
= m_first_attribute
;
1203 m_first_attribute
->m_prev_attribute
= attribute
;
1207 attribute
->m_next_attribute
= 0;
1208 m_last_attribute
= attribute
;
1210 m_first_attribute
= attribute
;
1211 attribute
->m_parent
= this;
1212 attribute
->m_prev_attribute
= 0;
1215 //! Appends a new attribute to the node.
1216 //! \param attribute Attribute to append.
1217 void append_attribute(xml_attribute
<Ch
> *attribute
)
1219 assert(attribute
&& !attribute
->parent());
1220 if (first_attribute())
1222 attribute
->m_prev_attribute
= m_last_attribute
;
1223 m_last_attribute
->m_next_attribute
= attribute
;
1227 attribute
->m_prev_attribute
= 0;
1228 m_first_attribute
= attribute
;
1230 m_last_attribute
= attribute
;
1231 attribute
->m_parent
= this;
1232 attribute
->m_next_attribute
= 0;
1235 //! Inserts a new attribute at specified place inside the node.
1236 //! All attributes after and including the specified attribute are moved one position back.
1237 //! \param where Place where to insert the attribute, or 0 to insert at the back.
1238 //! \param attribute Attribute to insert.
1239 void insert_attribute(xml_attribute
<Ch
> *where
, xml_attribute
<Ch
> *attribute
)
1241 assert(!where
|| where
->parent() == this);
1242 assert(attribute
&& !attribute
->parent());
1243 if (where
== m_first_attribute
)
1244 prepend_attribute(attribute
);
1245 else if (where
== 0)
1246 append_attribute(attribute
);
1249 attribute
->m_prev_attribute
= where
->m_prev_attribute
;
1250 attribute
->m_next_attribute
= where
;
1251 where
->m_prev_attribute
->m_next_attribute
= attribute
;
1252 where
->m_prev_attribute
= attribute
;
1253 attribute
->m_parent
= this;
1257 //! Removes first attribute of the node.
1258 //! If node has no attributes, behaviour is undefined.
1259 //! Use first_attribute() to test if node has attributes.
1260 void remove_first_attribute()
1262 assert(first_attribute());
1263 xml_attribute
<Ch
> *attribute
= m_first_attribute
;
1264 if (attribute
->m_next_attribute
)
1266 attribute
->m_next_attribute
->m_prev_attribute
= 0;
1269 m_last_attribute
= 0;
1270 attribute
->m_parent
= 0;
1271 m_first_attribute
= attribute
->m_next_attribute
;
1274 //! Removes last attribute of the node.
1275 //! If node has no attributes, behaviour is undefined.
1276 //! Use first_attribute() to test if node has attributes.
1277 void remove_last_attribute()
1279 assert(first_attribute());
1280 xml_attribute
<Ch
> *attribute
= m_last_attribute
;
1281 if (attribute
->m_prev_attribute
)
1283 attribute
->m_prev_attribute
->m_next_attribute
= 0;
1284 m_last_attribute
= attribute
->m_prev_attribute
;
1287 m_first_attribute
= 0;
1288 attribute
->m_parent
= 0;
1291 //! Removes specified attribute from node.
1292 //! \param where Pointer to attribute to be removed.
1293 void remove_attribute(xml_attribute
<Ch
> *where
)
1295 assert(first_attribute() && where
->parent() == this);
1296 if (where
== m_first_attribute
)
1297 remove_first_attribute();
1298 else if (where
== m_last_attribute
)
1299 remove_last_attribute();
1302 where
->m_prev_attribute
->m_next_attribute
= where
->m_next_attribute
;
1303 where
->m_next_attribute
->m_prev_attribute
= where
->m_prev_attribute
;
1304 where
->m_parent
= 0;
1308 //! Removes all attributes of node.
1309 void remove_all_attributes()
1311 for (xml_attribute
<Ch
> *attribute
= first_attribute(); attribute
; attribute
= attribute
->m_next_attribute
)
1312 attribute
->m_parent
= 0;
1313 m_first_attribute
= 0;
1318 ///////////////////////////////////////////////////////////////////////////
1322 xml_node(const xml_node
&);
1323 void operator =(const xml_node
&);
1325 ///////////////////////////////////////////////////////////////////////////
1328 // Note that some of the pointers below have UNDEFINED values if certain other pointers are 0.
1329 // This is required for maximum performance, as it allows the parser to omit initialization of
1330 // unneded/redundant values.
1332 // The rules are as follows:
1333 // 1. first_node and first_attribute contain valid pointers, or 0 if node has no children/attributes respectively
1334 // 2. last_node and last_attribute are valid only if node has at least one child/attribute respectively, otherwise they contain garbage
1335 // 3. prev_sibling and next_sibling are valid only if node has a parent, otherwise they contain garbage
1337 node_type m_type
; // Type of node; always valid
1338 xml_node
<Ch
> *m_first_node
; // Pointer to first child node, or 0 if none; always valid
1339 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
1340 xml_attribute
<Ch
> *m_first_attribute
; // Pointer to first attribute of node, or 0 if none; always valid
1341 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
1342 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
1343 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
1347 ///////////////////////////////////////////////////////////////////////////
1350 //! This class represents root of the DOM hierarchy.
1351 //! It is also an xml_node and a memory_pool through public inheritance.
1352 //! Use parse() function to build a DOM tree from a zero-terminated XML text string.
1353 //! parse() function allocates memory for nodes and attributes by using functions of xml_document,
1354 //! which are inherited from memory_pool.
1355 //! To access root node of the document, use the document itself, as if it was an xml_node.
1356 //! \param Ch Character type to use.
1357 template<class Ch
= char>
1358 class xml_document
: public xml_node
<Ch
>, public memory_pool
<Ch
>
1363 //! Constructs empty XML document
1365 : xml_node
<Ch
>(node_document
)
1369 //! Parses zero-terminated XML string according to given flags.
1370 //! Passed string will be modified by the parser, unless rapidxml::parse_non_destructive flag is used.
1371 //! The string must persist for the lifetime of the document.
1372 //! In case of error, rapidxml::parse_error exception will be thrown.
1374 //! If you want to parse contents of a file, you must first load the file into the memory, and pass pointer to its beginning.
1375 //! Make sure that data is zero-terminated.
1377 //! Document can be parsed into multiple times.
1378 //! Each new call to parse removes previous nodes and attributes (if any), but does not clear memory pool.
1379 //! \param text XML data to parse; pointer is non-const to denote fact that this data may be modified by the parser.
1381 void parse(Ch
*text
)
1385 // Remove current contents
1386 this->remove_all_nodes();
1387 this->remove_all_attributes();
1389 // Parse BOM, if any
1390 parse_bom
<Flags
>(text
);
1395 // Skip whitespace before node
1396 skip
<whitespace_pred
, Flags
>(text
);
1400 // Parse and append new child
1401 if (*text
== Ch('<'))
1404 if (xml_node
<Ch
> *node
= parse_node
<Flags
>(text
))
1405 this->append_node(node
);
1408 RAPIDXML_PARSE_ERROR("expected <", text
);
1413 //! Clears the document by deleting all nodes and clearing the memory pool.
1414 //! All nodes owned by document pool are destroyed.
1417 this->remove_all_nodes();
1418 this->remove_all_attributes();
1419 memory_pool
<Ch
>::clear();
1424 ///////////////////////////////////////////////////////////////////////
1425 // Internal character utility functions
1427 // Detect whitespace character
1428 struct whitespace_pred
1430 static unsigned char test(Ch ch
)
1432 return internal::lookup_tables
<0>::lookup_whitespace
[static_cast<unsigned char>(ch
)];
1436 // Detect node name character
1437 struct node_name_pred
1439 static unsigned char test(Ch ch
)
1441 return internal::lookup_tables
<0>::lookup_node_name
[static_cast<unsigned char>(ch
)];
1445 // Detect attribute name character
1446 struct attribute_name_pred
1448 static unsigned char test(Ch ch
)
1450 return internal::lookup_tables
<0>::lookup_attribute_name
[static_cast<unsigned char>(ch
)];
1454 // Detect text character (PCDATA)
1457 static unsigned char test(Ch ch
)
1459 return internal::lookup_tables
<0>::lookup_text
[static_cast<unsigned char>(ch
)];
1463 // Detect text character (PCDATA) that does not require processing
1464 struct text_pure_no_ws_pred
1466 static unsigned char test(Ch ch
)
1468 return internal::lookup_tables
<0>::lookup_text_pure_no_ws
[static_cast<unsigned char>(ch
)];
1472 // Detect text character (PCDATA) that does not require processing
1473 struct text_pure_with_ws_pred
1475 static unsigned char test(Ch ch
)
1477 return internal::lookup_tables
<0>::lookup_text_pure_with_ws
[static_cast<unsigned char>(ch
)];
1481 // Detect attribute value character
1483 struct attribute_value_pred
1485 static unsigned char test(Ch ch
)
1487 if (Quote
== Ch('\''))
1488 return internal::lookup_tables
<0>::lookup_attribute_data_1
[static_cast<unsigned char>(ch
)];
1489 if (Quote
== Ch('\"'))
1490 return internal::lookup_tables
<0>::lookup_attribute_data_2
[static_cast<unsigned char>(ch
)];
1491 return 0; // Should never be executed, to avoid warnings on Comeau
1495 // Detect attribute value character
1497 struct attribute_value_pure_pred
1499 static unsigned char test(Ch ch
)
1501 if (Quote
== Ch('\''))
1502 return internal::lookup_tables
<0>::lookup_attribute_data_1_pure
[static_cast<unsigned char>(ch
)];
1503 if (Quote
== Ch('\"'))
1504 return internal::lookup_tables
<0>::lookup_attribute_data_2_pure
[static_cast<unsigned char>(ch
)];
1505 return 0; // Should never be executed, to avoid warnings on Comeau
1509 // Insert coded character, using UTF8 or 8-bit ASCII
1511 static void insert_coded_character(Ch
*&text
, unsigned long code
)
1513 if (Flags
& parse_no_utf8
)
1515 // Insert 8-bit ASCII character
1516 // Todo: possibly verify that code is less than 256 and use replacement char otherwise?
1517 text
[0] = static_cast<unsigned char>(code
);
1522 // Insert UTF8 sequence
1523 if (code
< 0x80) // 1 byte sequence
1525 text
[0] = static_cast<unsigned char>(code
);
1528 else if (code
< 0x800) // 2 byte sequence
1530 text
[1] = static_cast<unsigned char>((code
| 0x80) & 0xBF); code
>>= 6;
1531 text
[0] = static_cast<unsigned char>(code
| 0xC0);
1534 else if (code
< 0x10000) // 3 byte sequence
1536 text
[2] = static_cast<unsigned char>((code
| 0x80) & 0xBF); code
>>= 6;
1537 text
[1] = static_cast<unsigned char>((code
| 0x80) & 0xBF); code
>>= 6;
1538 text
[0] = static_cast<unsigned char>(code
| 0xE0);
1541 else if (code
< 0x110000) // 4 byte sequence
1543 text
[3] = static_cast<unsigned char>((code
| 0x80) & 0xBF); code
>>= 6;
1544 text
[2] = static_cast<unsigned char>((code
| 0x80) & 0xBF); code
>>= 6;
1545 text
[1] = static_cast<unsigned char>((code
| 0x80) & 0xBF); code
>>= 6;
1546 text
[0] = static_cast<unsigned char>(code
| 0xF0);
1549 else // Invalid, only codes up to 0x10FFFF are allowed in Unicode
1551 RAPIDXML_PARSE_ERROR("invalid numeric character entity", text
);
1556 // Skip characters until predicate evaluates to true
1557 template<class StopPred
, int Flags
>
1558 static void skip(Ch
*&text
)
1561 while (StopPred::test(*tmp
))
1566 // Skip characters until predicate evaluates to true while doing the following:
1567 // - replacing XML character entity references with proper characters (' & " < > &#...;)
1568 // - condensing whitespace sequences to single space character
1569 template<class StopPred
, class StopPredPure
, int Flags
>
1570 static Ch
*skip_and_expand_character_refs(Ch
*&text
)
1572 // If entity translation, whitespace condense and whitespace trimming is disabled, use plain skip
1573 if (Flags
& parse_no_entity_translation
&&
1574 !(Flags
& parse_normalize_whitespace
) &&
1575 !(Flags
& parse_trim_whitespace
))
1577 skip
<StopPred
, Flags
>(text
);
1581 // Use simple skip until first modification is detected
1582 skip
<StopPredPure
, Flags
>(text
);
1584 // Use translation skip
1587 while (StopPred::test(*src
))
1589 // If entity translation is enabled
1590 if (!(Flags
& parse_no_entity_translation
))
1592 // Test if replacement is needed
1593 if (src
[0] == Ch('&'))
1600 if (src
[2] == Ch('m') && src
[3] == Ch('p') && src
[4] == Ch(';'))
1607 if (src
[2] == Ch('p') && src
[3] == Ch('o') && src
[4] == Ch('s') && src
[5] == Ch(';'))
1618 if (src
[2] == Ch('u') && src
[3] == Ch('o') && src
[4] == Ch('t') && src
[5] == Ch(';'))
1629 if (src
[2] == Ch('t') && src
[3] == Ch(';'))
1640 if (src
[2] == Ch('t') && src
[3] == Ch(';'))
1649 // &#...; - assumes ASCII
1651 if (src
[2] == Ch('x'))
1653 unsigned long code
= 0;
1654 src
+= 3; // Skip &#x
1657 unsigned char digit
= internal::lookup_tables
<0>::lookup_digits
[static_cast<unsigned char>(*src
)];
1660 code
= code
* 16 + digit
;
1663 insert_coded_character
<Flags
>(dest
, code
); // Put character in output
1667 unsigned long code
= 0;
1668 src
+= 2; // Skip &#
1671 unsigned char digit
= internal::lookup_tables
<0>::lookup_digits
[static_cast<unsigned char>(*src
)];
1674 code
= code
* 10 + digit
;
1677 insert_coded_character
<Flags
>(dest
, code
); // Put character in output
1679 if (*src
== Ch(';'))
1682 RAPIDXML_PARSE_ERROR("expected ;", src
);
1687 // Ignore, just copy '&' verbatim
1694 // If whitespace condensing is enabled
1695 if (Flags
& parse_normalize_whitespace
)
1697 // Test if condensing is needed
1698 if (whitespace_pred::test(*src
))
1700 *dest
= Ch(' '); ++dest
; // Put single space in dest
1701 ++src
; // Skip first whitespace char
1702 // Skip remaining whitespace chars
1703 while (whitespace_pred::test(*src
))
1709 // No replacement, only copy character
1720 ///////////////////////////////////////////////////////////////////////
1721 // Internal parsing functions
1723 // Parse BOM, if any
1725 void parse_bom(Ch
*&text
)
1728 if (static_cast<unsigned char>(text
[0]) == 0xEF &&
1729 static_cast<unsigned char>(text
[1]) == 0xBB &&
1730 static_cast<unsigned char>(text
[2]) == 0xBF)
1732 text
+= 3; // Skup utf-8 bom
1736 // Parse XML declaration (<?xml...)
1738 xml_node
<Ch
> *parse_xml_declaration(Ch
*&text
)
1740 // If parsing of declaration is disabled
1741 if (!(Flags
& parse_declaration_node
))
1743 // Skip until end of declaration
1744 while (text
[0] != Ch('?') || text
[1] != Ch('>'))
1747 RAPIDXML_PARSE_ERROR("unexpected end of data", text
);
1750 text
+= 2; // Skip '?>'
1754 // Create declaration
1755 xml_node
<Ch
> *declaration
= this->allocate_node(node_declaration
);
1757 // Skip whitespace before attributes or ?>
1758 skip
<whitespace_pred
, Flags
>(text
);
1760 // Parse declaration attributes
1761 parse_node_attributes
<Flags
>(text
, declaration
);
1764 if (text
[0] != Ch('?') || text
[1] != Ch('>'))
1765 RAPIDXML_PARSE_ERROR("expected ?>", text
);
1771 // Parse XML comment (<!--...)
1773 xml_node
<Ch
> *parse_comment(Ch
*&text
)
1775 // If parsing of comments is disabled
1776 if (!(Flags
& parse_comment_nodes
))
1778 // Skip until end of comment
1779 while (text
[0] != Ch('-') || text
[1] != Ch('-') || text
[2] != Ch('>'))
1782 RAPIDXML_PARSE_ERROR("unexpected end of data", text
);
1785 text
+= 3; // Skip '-->'
1786 return 0; // Do not produce comment node
1789 // Remember value start
1792 // Skip until end of comment
1793 while (text
[0] != Ch('-') || text
[1] != Ch('-') || text
[2] != Ch('>'))
1796 RAPIDXML_PARSE_ERROR("unexpected end of data", text
);
1800 // Create comment node
1801 xml_node
<Ch
> *comment
= this->allocate_node(node_comment
);
1802 comment
->value(value
, text
- value
);
1804 // Place zero terminator after comment value
1805 if (!(Flags
& parse_no_string_terminators
))
1808 text
+= 3; // Skip '-->'
1814 xml_node
<Ch
> *parse_doctype(Ch
*&text
)
1816 // Remember value start
1820 while (*text
!= Ch('>'))
1822 // Determine character type
1826 // If '[' encountered, scan for matching ending ']' using naive algorithm with depth
1827 // This works for all W3C test files except for 2 most wicked
1836 case Ch('['): ++depth
; break;
1837 case Ch(']'): --depth
; break;
1838 case 0: RAPIDXML_PARSE_ERROR("unexpected end of data", text
);
1845 // Error on end of text
1847 RAPIDXML_PARSE_ERROR("unexpected end of data", text
);
1849 // Other character, skip it
1856 // If DOCTYPE nodes enabled
1857 if (Flags
& parse_doctype_node
)
1859 // Create a new doctype node
1860 xml_node
<Ch
> *doctype
= this->allocate_node(node_doctype
);
1861 doctype
->value(value
, text
- value
);
1863 // Place zero terminator after value
1864 if (!(Flags
& parse_no_string_terminators
))
1867 text
+= 1; // skip '>'
1872 text
+= 1; // skip '>'
1880 xml_node
<Ch
> *parse_pi(Ch
*&text
)
1882 // If creation of PI nodes is enabled
1883 if (Flags
& parse_pi_nodes
)
1886 xml_node
<Ch
> *pi
= this->allocate_node(node_pi
);
1888 // Extract PI target name
1890 skip
<node_name_pred
, Flags
>(text
);
1892 RAPIDXML_PARSE_ERROR("expected PI target", text
);
1893 pi
->name(name
, text
- name
);
1895 // Skip whitespace between pi target and pi
1896 skip
<whitespace_pred
, Flags
>(text
);
1898 // Remember start of pi
1902 while (text
[0] != Ch('?') || text
[1] != Ch('>'))
1904 if (*text
== Ch('\0'))
1905 RAPIDXML_PARSE_ERROR("unexpected end of data", text
);
1909 // Set pi value (verbatim, no entity expansion or whitespace normalization)
1910 pi
->value(value
, text
- value
);
1912 // Place zero terminator after name and value
1913 if (!(Flags
& parse_no_string_terminators
))
1915 pi
->name()[pi
->name_size()] = Ch('\0');
1916 pi
->value()[pi
->value_size()] = Ch('\0');
1919 text
+= 2; // Skip '?>'
1925 while (text
[0] != Ch('?') || text
[1] != Ch('>'))
1927 if (*text
== Ch('\0'))
1928 RAPIDXML_PARSE_ERROR("unexpected end of data", text
);
1931 text
+= 2; // Skip '?>'
1936 // Parse and append data
1937 // Return character that ends data.
1938 // This is necessary because this character might have been overwritten by a terminating 0
1940 Ch
parse_and_append_data(xml_node
<Ch
> *node
, Ch
*&text
, Ch
*contents_start
)
1942 // Backup to contents start if whitespace trimming is disabled
1943 if (!(Flags
& parse_trim_whitespace
))
1944 text
= contents_start
;
1946 // Skip until end of data
1947 Ch
*value
= text
, *end
;
1948 if (Flags
& parse_normalize_whitespace
)
1949 end
= skip_and_expand_character_refs
<text_pred
, text_pure_with_ws_pred
, Flags
>(text
);
1951 end
= skip_and_expand_character_refs
<text_pred
, text_pure_no_ws_pred
, Flags
>(text
);
1953 // Trim trailing whitespace if flag is set; leading was already trimmed by whitespace skip after >
1954 if (Flags
& parse_trim_whitespace
)
1956 if (Flags
& parse_normalize_whitespace
)
1958 // Whitespace is already condensed to single space characters by skipping function, so just trim 1 char off the end
1959 if (*(end
- 1) == Ch(' '))
1964 // Backup until non-whitespace character is found
1965 while (whitespace_pred::test(*(end
- 1)))
1970 // If characters are still left between end and value (this test is only necessary if normalization is enabled)
1971 // Create new data node
1972 if (!(Flags
& parse_no_data_nodes
))
1974 xml_node
<Ch
> *data
= this->allocate_node(node_data
);
1975 data
->value(value
, end
- value
);
1976 node
->append_node(data
);
1979 // Add data to parent node if no data exists yet
1980 if (!(Flags
& parse_no_element_values
))
1981 if (*node
->value() == Ch('\0'))
1982 node
->value(value
, end
- value
);
1984 // Place zero terminator after value
1985 if (!(Flags
& parse_no_string_terminators
))
1989 return ch
; // Return character that ends data; this is required because zero terminator overwritten it
1992 // Return character that ends data
1998 xml_node
<Ch
> *parse_cdata(Ch
*&text
)
2000 // If CDATA is disabled
2001 if (Flags
& parse_no_data_nodes
)
2003 // Skip until end of cdata
2004 while (text
[0] != Ch(']') || text
[1] != Ch(']') || text
[2] != Ch('>'))
2007 RAPIDXML_PARSE_ERROR("unexpected end of data", text
);
2010 text
+= 3; // Skip ]]>
2011 return 0; // Do not produce CDATA node
2014 // Skip until end of cdata
2016 while (text
[0] != Ch(']') || text
[1] != Ch(']') || text
[2] != Ch('>'))
2019 RAPIDXML_PARSE_ERROR("unexpected end of data", text
);
2023 // Create new cdata node
2024 xml_node
<Ch
> *cdata
= this->allocate_node(node_cdata
);
2025 cdata
->value(value
, text
- value
);
2027 // Place zero terminator after value
2028 if (!(Flags
& parse_no_string_terminators
))
2031 text
+= 3; // Skip ]]>
2035 // Parse element node
2037 xml_node
<Ch
> *parse_element(Ch
*&text
)
2039 // Create element node
2040 xml_node
<Ch
> *element
= this->allocate_node(node_element
);
2042 // Extract element name
2044 skip
<node_name_pred
, Flags
>(text
);
2046 RAPIDXML_PARSE_ERROR("expected element name", text
);
2047 element
->name(name
, text
- name
);
2049 // Skip whitespace between element name and attributes or >
2050 skip
<whitespace_pred
, Flags
>(text
);
2052 // Parse attributes, if any
2053 parse_node_attributes
<Flags
>(text
, element
);
2055 // Determine ending type
2056 if (*text
== Ch('>'))
2059 parse_node_contents
<Flags
>(text
, element
);
2061 else if (*text
== Ch('/'))
2064 if (*text
!= Ch('>'))
2065 RAPIDXML_PARSE_ERROR("expected >", text
);
2069 RAPIDXML_PARSE_ERROR("expected >", text
);
2071 // Place zero terminator after name
2072 if (!(Flags
& parse_no_string_terminators
))
2073 element
->name()[element
->name_size()] = Ch('\0');
2075 // Return parsed element
2079 // Determine node type, and parse it
2081 xml_node
<Ch
> *parse_node(Ch
*&text
)
2083 // Parse proper node type
2089 // Parse and append element node
2090 return parse_element
<Flags
>(text
);
2095 if ((text
[0] == Ch('x') || text
[0] == Ch('X')) &&
2096 (text
[1] == Ch('m') || text
[1] == Ch('M')) &&
2097 (text
[2] == Ch('l') || text
[2] == Ch('L')) &&
2098 whitespace_pred::test(text
[3]))
2100 // '<?xml ' - xml declaration
2101 text
+= 4; // Skip 'xml '
2102 return parse_xml_declaration
<Flags
>(text
);
2107 return parse_pi
<Flags
>(text
);
2113 // Parse proper subset of <! node
2119 if (text
[2] == Ch('-'))
2121 // '<!--' - xml comment
2122 text
+= 3; // Skip '!--'
2123 return parse_comment
<Flags
>(text
);
2129 if (text
[2] == Ch('C') && text
[3] == Ch('D') && text
[4] == Ch('A') &&
2130 text
[5] == Ch('T') && text
[6] == Ch('A') && text
[7] == Ch('['))
2132 // '<![CDATA[' - cdata
2133 text
+= 8; // Skip '![CDATA['
2134 return parse_cdata
<Flags
>(text
);
2140 if (text
[2] == Ch('O') && text
[3] == Ch('C') && text
[4] == Ch('T') &&
2141 text
[5] == Ch('Y') && text
[6] == Ch('P') && text
[7] == Ch('E') &&
2142 whitespace_pred::test(text
[8]))
2144 // '<!DOCTYPE ' - doctype
2145 text
+= 9; // skip '!DOCTYPE '
2146 return parse_doctype
<Flags
>(text
);
2151 // Attempt to skip other, unrecognized node types starting with <!
2153 while (*text
!= Ch('>'))
2156 RAPIDXML_PARSE_ERROR("unexpected end of data", text
);
2160 return 0; // No node recognized
2165 // Parse contents of the node - children, data etc.
2167 void parse_node_contents(Ch
*&text
, xml_node
<Ch
> *node
)
2169 // For all children and text
2172 // Skip whitespace between > and node contents
2173 Ch
*contents_start
= text
; // Store start of node contents before whitespace is skipped
2174 skip
<whitespace_pred
, Flags
>(text
);
2175 Ch next_char
= *text
;
2177 // After data nodes, instead of continuing the loop, control jumps here.
2178 // This is because zero termination inside parse_and_append_data() function
2179 // would wreak havoc with the above code.
2180 // Also, skipping whitespace after data nodes is unnecessary.
2183 // Determine what comes next: node closing, child node, data node, or 0?
2187 // Node closing or child node
2189 if (text
[1] == Ch('/'))
2192 text
+= 2; // Skip '</'
2193 if (Flags
& parse_validate_closing_tags
)
2195 // Skip and validate closing tag name
2196 Ch
*closing_name
= text
;
2197 skip
<node_name_pred
, Flags
>(text
);
2198 if (!internal::compare(node
->name(), node
->name_size(), closing_name
, text
- closing_name
, true))
2199 RAPIDXML_PARSE_ERROR("invalid closing tag name", text
);
2203 // No validation, just skip name
2204 skip
<node_name_pred
, Flags
>(text
);
2206 // Skip remaining whitespace after node name
2207 skip
<whitespace_pred
, Flags
>(text
);
2208 if (*text
!= Ch('>'))
2209 RAPIDXML_PARSE_ERROR("expected >", text
);
2211 return; // Node closed, finished parsing contents
2217 if (xml_node
<Ch
> *child
= parse_node
<Flags
>(text
))
2218 node
->append_node(child
);
2222 // End of data - error
2224 RAPIDXML_PARSE_ERROR("unexpected end of data", text
);
2228 next_char
= parse_and_append_data
<Flags
>(node
, text
, contents_start
);
2229 goto after_data_node
; // Bypass regular processing after data nodes
2235 // Parse XML attributes of the node
2237 void parse_node_attributes(Ch
*&text
, xml_node
<Ch
> *node
)
2239 // For all attributes
2240 while (attribute_name_pred::test(*text
))
2242 // Extract attribute name
2244 ++text
; // Skip first character of attribute name
2245 skip
<attribute_name_pred
, Flags
>(text
);
2247 RAPIDXML_PARSE_ERROR("expected attribute name", name
);
2249 // Create new attribute
2250 xml_attribute
<Ch
> *attribute
= this->allocate_attribute();
2251 attribute
->name(name
, text
- name
);
2252 node
->append_attribute(attribute
);
2254 // Skip whitespace after attribute name
2255 skip
<whitespace_pred
, Flags
>(text
);
2258 if (*text
!= Ch('='))
2259 RAPIDXML_PARSE_ERROR("expected =", text
);
2262 // Add terminating zero after name
2263 if (!(Flags
& parse_no_string_terminators
))
2264 attribute
->name()[attribute
->name_size()] = 0;
2266 // Skip whitespace after =
2267 skip
<whitespace_pred
, Flags
>(text
);
2269 // Skip quote and remember if it was ' or "
2271 if (quote
!= Ch('\'') && quote
!= Ch('"'))
2272 RAPIDXML_PARSE_ERROR("expected ' or \"", text
);
2275 // Extract attribute value and expand char refs in it
2276 Ch
*value
= text
, *end
;
2277 const int AttFlags
= Flags
& ~parse_normalize_whitespace
; // No whitespace normalization in attributes
2278 if (quote
== Ch('\''))
2279 end
= skip_and_expand_character_refs
<attribute_value_pred
<Ch('\'')>, attribute_value_pure_pred
<Ch('\'')>, AttFlags
>(text
);
2281 end
= skip_and_expand_character_refs
<attribute_value_pred
<Ch('"')>, attribute_value_pure_pred
<Ch('"')>, AttFlags
>(text
);
2283 // Set attribute value
2284 attribute
->value(value
, end
- value
);
2286 // Make sure that end quote is present
2288 RAPIDXML_PARSE_ERROR("expected ' or \"", text
);
2289 ++text
; // Skip quote
2291 // Add terminating zero after value
2292 if (!(Flags
& parse_no_string_terminators
))
2293 attribute
->value()[attribute
->value_size()] = 0;
2295 // Skip whitespace after attribute value
2296 skip
<whitespace_pred
, Flags
>(text
);
2306 // Whitespace (space \n \r \t)
2308 const unsigned char lookup_tables
<Dummy
>::lookup_whitespace
[256] =
2310 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2311 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, // 0
2312 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1
2313 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 2
2314 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 3
2315 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 4
2316 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 5
2317 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 6
2318 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 7
2319 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8
2320 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9
2321 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // A
2322 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // B
2323 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // C
2324 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // D
2325 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // E
2326 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // F
2329 // Node name (anything but space \n \r \t / > ? \0)
2331 const unsigned char lookup_tables
<Dummy
>::lookup_node_name
[256] =
2333 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2334 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, // 0
2335 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
2336 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, // 2
2337 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, // 3
2338 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
2339 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
2340 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
2341 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
2342 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
2343 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
2344 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
2345 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
2346 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
2347 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
2348 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
2349 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
2352 // Text (i.e. PCDATA) (anything but < \0)
2354 const unsigned char lookup_tables
<Dummy
>::lookup_text
[256] =
2356 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2357 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0
2358 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
2359 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2
2360 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, // 3
2361 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
2362 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
2363 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
2364 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
2365 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
2366 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
2367 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
2368 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
2369 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
2370 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
2371 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
2372 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
2375 // Text (i.e. PCDATA) that does not require processing when ws normalization is disabled
2376 // (anything but < \0 &)
2378 const unsigned char lookup_tables
<Dummy
>::lookup_text_pure_no_ws
[256] =
2380 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2381 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0
2382 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
2383 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2
2384 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, // 3
2385 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
2386 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
2387 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
2388 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
2389 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
2390 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
2391 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
2392 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
2393 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
2394 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
2395 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
2396 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
2399 // Text (i.e. PCDATA) that does not require processing when ws normalizationis is enabled
2400 // (anything but < \0 & space \n \r \t)
2402 const unsigned char lookup_tables
<Dummy
>::lookup_text_pure_with_ws
[256] =
2404 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2405 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, // 0
2406 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
2407 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2
2408 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, // 3
2409 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
2410 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
2411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
2412 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
2413 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
2414 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
2415 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
2416 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
2417 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
2418 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
2419 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
2420 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
2423 // Attribute name (anything but space \n \r \t / < > = ? ! \0)
2425 const unsigned char lookup_tables
<Dummy
>::lookup_attribute_name
[256] =
2427 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2428 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, // 0
2429 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
2430 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, // 2
2431 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, // 3
2432 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
2433 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
2434 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
2435 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
2436 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
2437 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
2438 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
2439 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
2440 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
2441 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
2442 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
2443 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
2446 // Attribute data with single quote (anything but ' \0)
2448 const unsigned char lookup_tables
<Dummy
>::lookup_attribute_data_1
[256] =
2450 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2451 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0
2452 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
2453 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, // 2
2454 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 3
2455 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
2456 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
2457 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
2458 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
2459 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
2460 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
2461 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
2462 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
2463 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
2464 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
2465 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
2466 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
2469 // Attribute data with single quote that does not require processing (anything but ' \0 &)
2471 const unsigned char lookup_tables
<Dummy
>::lookup_attribute_data_1_pure
[256] =
2473 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2474 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0
2475 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
2476 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, // 2
2477 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 3
2478 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
2479 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
2480 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
2481 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
2482 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
2483 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
2484 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
2485 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
2486 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
2487 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
2488 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
2489 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
2492 // Attribute data with double quote (anything but " \0)
2494 const unsigned char lookup_tables
<Dummy
>::lookup_attribute_data_2
[256] =
2496 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2497 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0
2498 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
2499 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2
2500 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 3
2501 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
2502 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
2503 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
2504 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
2505 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
2506 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
2507 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
2508 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
2509 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
2510 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
2511 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
2512 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
2515 // Attribute data with double quote that does not require processing (anything but " \0 &)
2517 const unsigned char lookup_tables
<Dummy
>::lookup_attribute_data_2_pure
[256] =
2519 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2520 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0
2521 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 1
2522 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2
2523 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 3
2524 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 4
2525 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 5
2526 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 6
2527 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 7
2528 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 8
2529 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 9
2530 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A
2531 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B
2532 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // C
2533 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // D
2534 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // E
2535 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // F
2538 // Digits (dec and hex, 255 denotes end of numeric character reference)
2540 const unsigned char lookup_tables
<Dummy
>::lookup_digits
[256] =
2542 // 0 1 2 3 4 5 6 7 8 9 A B C D E F
2543 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 0
2544 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 1
2545 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 2
2546 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,255,255,255,255,255,255, // 3
2547 255, 10, 11, 12, 13, 14, 15,255,255,255,255,255,255,255,255,255, // 4
2548 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 5
2549 255, 10, 11, 12, 13, 14, 15,255,255,255,255,255,255,255,255,255, // 6
2550 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 7
2551 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 8
2552 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // 9
2553 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // A
2554 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // B
2555 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // C
2556 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // D
2557 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, // E
2558 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255 // F
2561 // Upper case conversion
2563 const unsigned char lookup_tables
<Dummy
>::lookup_upcase
[256] =
2565 // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A B C D E F
2566 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, // 0
2567 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, // 1
2568 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, // 2
2569 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, // 3
2570 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, // 4
2571 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, // 5
2572 96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, // 6
2573 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 123,124,125,126,127, // 7
2574 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, // 8
2575 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159, // 9
2576 160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175, // A
2577 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, // B
2578 192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207, // C
2579 208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223, // D
2580 224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239, // E
2581 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255 // F
2588 // Undefine internal macros
2589 #undef RAPIDXML_PARSE_ERROR
2591 // On MSVC, restore warnings state
2593 #pragma warning(pop)