From 0a97bad6608a2b1ea01ae6ce18bab63abf0c9210 Mon Sep 17 00:00:00 2001 From: "arseny.kapoulkine" Date: Wed, 21 Feb 2007 19:41:31 +0000 Subject: Merged 0.3 in trunk git-svn-id: http://pugixml.googlecode.com/svn/trunk@68 99668b35-9821-0410-8761-19e4c4f06640 --- docs/html/annotated.html | 37 + docs/html/classpugi_1_1xml__attribute-members.html | 52 + docs/html/classpugi_1_1xml__attribute.html | 881 ++++ .../classpugi_1_1xml__attribute__coll__graph.map | 1 + .../classpugi_1_1xml__attribute__coll__graph.md5 | 1 + .../classpugi_1_1xml__attribute__coll__graph.png | Bin 0 -> 876 bytes ...sspugi_1_1xml__attribute__iterator-members.html | 37 + .../classpugi_1_1xml__attribute__iterator.html | 414 ++ ...gi_1_1xml__attribute__iterator__coll__graph.map | 2 + ...gi_1_1xml__attribute__iterator__coll__graph.md5 | 1 + ...gi_1_1xml__attribute__iterator__coll__graph.png | Bin 0 -> 3027 bytes ...1_1xml__attribute__iterator__inherit__graph.map | 1 + ...1_1xml__attribute__iterator__inherit__graph.md5 | 1 + ...1_1xml__attribute__iterator__inherit__graph.png | Bin 0 -> 1386 bytes docs/html/classpugi_1_1xml__document-members.html | 103 + docs/html/classpugi_1_1xml__document.html | 365 ++ .../classpugi_1_1xml__document__coll__graph.map | 2 + .../classpugi_1_1xml__document__coll__graph.md5 | 1 + .../classpugi_1_1xml__document__coll__graph.png | Bin 0 -> 2396 bytes .../classpugi_1_1xml__document__inherit__graph.map | 2 + .../classpugi_1_1xml__document__inherit__graph.md5 | 1 + .../classpugi_1_1xml__document__inherit__graph.png | Bin 0 -> 697 bytes docs/html/classpugi_1_1xml__node-members.html | 95 + docs/html/classpugi_1_1xml__node.html | 2473 +++++++++++ docs/html/classpugi_1_1xml__node__coll__graph.map | 1 + docs/html/classpugi_1_1xml__node__coll__graph.md5 | 1 + docs/html/classpugi_1_1xml__node__coll__graph.png | Bin 0 -> 756 bytes .../classpugi_1_1xml__node__inherit__graph.map | 2 + .../classpugi_1_1xml__node__inherit__graph.md5 | 1 + .../classpugi_1_1xml__node__inherit__graph.png | Bin 0 -> 704 bytes .../classpugi_1_1xml__node__iterator-members.html | 37 + docs/html/classpugi_1_1xml__node__iterator.html | 414 ++ ...asspugi_1_1xml__node__iterator__coll__graph.map | 2 + ...asspugi_1_1xml__node__iterator__coll__graph.md5 | 1 + ...asspugi_1_1xml__node__iterator__coll__graph.png | Bin 0 -> 2813 bytes ...pugi_1_1xml__node__iterator__inherit__graph.map | 1 + ...pugi_1_1xml__node__iterator__inherit__graph.md5 | 1 + ...pugi_1_1xml__node__iterator__inherit__graph.png | Bin 0 -> 1300 bytes .../classpugi_1_1xml__tree__walker-members.html | 32 + docs/html/classpugi_1_1xml__tree__walker.html | 186 + ...classpugi_1_1xml__tree__walker__coll__graph.map | 1 + ...classpugi_1_1xml__tree__walker__coll__graph.md5 | 1 + ...classpugi_1_1xml__tree__walker__coll__graph.png | Bin 0 -> 738 bytes .../classpugi_1_1xpath__exception-members.html | 27 + docs/html/classpugi_1_1xpath__exception.html | 108 + .../classpugi_1_1xpath__exception__coll__graph.map | 1 + .../classpugi_1_1xpath__exception__coll__graph.md5 | 1 + .../classpugi_1_1xpath__exception__coll__graph.png | Bin 0 -> 1442 bytes ...asspugi_1_1xpath__exception__inherit__graph.map | 1 + ...asspugi_1_1xpath__exception__inherit__graph.md5 | 1 + ...asspugi_1_1xpath__exception__inherit__graph.png | Bin 0 -> 764 bytes docs/html/classpugi_1_1xpath__node-members.html | 34 + docs/html/classpugi_1_1xpath__node.html | 341 ++ .../html/classpugi_1_1xpath__node__coll__graph.map | 3 + .../html/classpugi_1_1xpath__node__coll__graph.md5 | 1 + .../html/classpugi_1_1xpath__node__coll__graph.png | Bin 0 -> 2333 bytes .../classpugi_1_1xpath__node__set-members.html | 42 + docs/html/classpugi_1_1xpath__node__set.html | 413 ++ .../classpugi_1_1xpath__node__set__coll__graph.map | 4 + .../classpugi_1_1xpath__node__set__coll__graph.md5 | 1 + .../classpugi_1_1xpath__node__set__coll__graph.png | Bin 0 -> 4399 bytes docs/html/classpugi_1_1xpath__query-members.html | 31 + docs/html/classpugi_1_1xpath__query.html | 239 + .../classpugi_1_1xpath__query__coll__graph.map | 1 + .../classpugi_1_1xpath__query__coll__graph.md5 | 1 + .../classpugi_1_1xpath__query__coll__graph.png | Bin 0 -> 1519 bytes docs/html/doxygen.css | 310 ++ docs/html/doxygen.png | Bin 0 -> 1281 bytes docs/html/functions.html | 195 + docs/html/functions_enum.html | 38 + docs/html/functions_eval.html | 40 + docs/html/functions_func.html | 188 + docs/html/functions_type.html | 40 + docs/html/graph_legend.dot | 22 + docs/html/graph_legend.html | 80 + docs/html/graph_legend.png | Bin 0 -> 3938 bytes docs/html/hierarchy.html | 45 + docs/html/index.html | 20 + docs/html/inherit__graph__0.map | 2 + docs/html/inherit__graph__0.md5 | 1 + docs/html/inherit__graph__0.png | Bin 0 -> 582 bytes docs/html/inherit__graph__1.map | 2 + docs/html/inherit__graph__1.md5 | 1 + docs/html/inherit__graph__1.png | Bin 0 -> 428 bytes docs/html/inherit__graph__2.map | 3 + docs/html/inherit__graph__2.md5 | 1 + docs/html/inherit__graph__2.png | Bin 0 -> 1068 bytes docs/html/inherit__graph__3.map | 3 + docs/html/inherit__graph__3.md5 | 1 + docs/html/inherit__graph__3.png | Bin 0 -> 596 bytes docs/html/inherit__graph__4.map | 2 + docs/html/inherit__graph__4.md5 | 1 + docs/html/inherit__graph__4.png | Bin 0 -> 485 bytes docs/html/inherit__graph__5.map | 2 + docs/html/inherit__graph__5.md5 | 1 + docs/html/inherit__graph__5.png | Bin 0 -> 644 bytes docs/html/inherit__graph__6.map | 2 + docs/html/inherit__graph__6.md5 | 1 + docs/html/inherit__graph__6.png | Bin 0 -> 404 bytes docs/html/inherit__graph__7.map | 2 + docs/html/inherit__graph__7.md5 | 1 + docs/html/inherit__graph__7.png | Bin 0 -> 470 bytes docs/html/inherit__graph__8.map | 2 + docs/html/inherit__graph__8.md5 | 1 + docs/html/inherit__graph__8.png | Bin 0 -> 437 bytes docs/html/inherits.html | 66 + docs/html/namespacemembers.html | 62 + docs/html/namespacemembers_enum.html | 37 + docs/html/namespacemembers_eval.html | 43 + docs/html/namespacemembers_func.html | 38 + docs/html/namespacemembers_vars.html | 52 + docs/html/namespacepugi.html | 668 +++ docs/html/namespaces.html | 26 + .../structpugi_1_1transfer__ownership__tag.html | 35 + docs/html/tab_b.gif | Bin 0 -> 35 bytes docs/html/tab_l.gif | Bin 0 -> 706 bytes docs/html/tab_r.gif | Bin 0 -> 2585 bytes docs/html/tabs.css | 102 + docs/index.html | 1059 ++--- src/pugiconfig.hpp | 23 + src/pugixml.cpp | 4697 +++++++++++--------- src/pugixml.hpp | 2399 +++++++--- src/pugixpath.cpp | 3537 +++++++++++++++ 123 files changed, 16700 insertions(+), 3552 deletions(-) create mode 100644 docs/html/annotated.html create mode 100644 docs/html/classpugi_1_1xml__attribute-members.html create mode 100644 docs/html/classpugi_1_1xml__attribute.html create mode 100644 docs/html/classpugi_1_1xml__attribute__coll__graph.map create mode 100644 docs/html/classpugi_1_1xml__attribute__coll__graph.md5 create mode 100644 docs/html/classpugi_1_1xml__attribute__coll__graph.png create mode 100644 docs/html/classpugi_1_1xml__attribute__iterator-members.html create mode 100644 docs/html/classpugi_1_1xml__attribute__iterator.html create mode 100644 docs/html/classpugi_1_1xml__attribute__iterator__coll__graph.map create mode 100644 docs/html/classpugi_1_1xml__attribute__iterator__coll__graph.md5 create mode 100644 docs/html/classpugi_1_1xml__attribute__iterator__coll__graph.png create mode 100644 docs/html/classpugi_1_1xml__attribute__iterator__inherit__graph.map create mode 100644 docs/html/classpugi_1_1xml__attribute__iterator__inherit__graph.md5 create mode 100644 docs/html/classpugi_1_1xml__attribute__iterator__inherit__graph.png create mode 100644 docs/html/classpugi_1_1xml__document-members.html create mode 100644 docs/html/classpugi_1_1xml__document.html create mode 100644 docs/html/classpugi_1_1xml__document__coll__graph.map create mode 100644 docs/html/classpugi_1_1xml__document__coll__graph.md5 create mode 100644 docs/html/classpugi_1_1xml__document__coll__graph.png create mode 100644 docs/html/classpugi_1_1xml__document__inherit__graph.map create mode 100644 docs/html/classpugi_1_1xml__document__inherit__graph.md5 create mode 100644 docs/html/classpugi_1_1xml__document__inherit__graph.png create mode 100644 docs/html/classpugi_1_1xml__node-members.html create mode 100644 docs/html/classpugi_1_1xml__node.html create mode 100644 docs/html/classpugi_1_1xml__node__coll__graph.map create mode 100644 docs/html/classpugi_1_1xml__node__coll__graph.md5 create mode 100644 docs/html/classpugi_1_1xml__node__coll__graph.png create mode 100644 docs/html/classpugi_1_1xml__node__inherit__graph.map create mode 100644 docs/html/classpugi_1_1xml__node__inherit__graph.md5 create mode 100644 docs/html/classpugi_1_1xml__node__inherit__graph.png create mode 100644 docs/html/classpugi_1_1xml__node__iterator-members.html create mode 100644 docs/html/classpugi_1_1xml__node__iterator.html create mode 100644 docs/html/classpugi_1_1xml__node__iterator__coll__graph.map create mode 100644 docs/html/classpugi_1_1xml__node__iterator__coll__graph.md5 create mode 100644 docs/html/classpugi_1_1xml__node__iterator__coll__graph.png create mode 100644 docs/html/classpugi_1_1xml__node__iterator__inherit__graph.map create mode 100644 docs/html/classpugi_1_1xml__node__iterator__inherit__graph.md5 create mode 100644 docs/html/classpugi_1_1xml__node__iterator__inherit__graph.png create mode 100644 docs/html/classpugi_1_1xml__tree__walker-members.html create mode 100644 docs/html/classpugi_1_1xml__tree__walker.html create mode 100644 docs/html/classpugi_1_1xml__tree__walker__coll__graph.map create mode 100644 docs/html/classpugi_1_1xml__tree__walker__coll__graph.md5 create mode 100644 docs/html/classpugi_1_1xml__tree__walker__coll__graph.png create mode 100644 docs/html/classpugi_1_1xpath__exception-members.html create mode 100644 docs/html/classpugi_1_1xpath__exception.html create mode 100644 docs/html/classpugi_1_1xpath__exception__coll__graph.map create mode 100644 docs/html/classpugi_1_1xpath__exception__coll__graph.md5 create mode 100644 docs/html/classpugi_1_1xpath__exception__coll__graph.png create mode 100644 docs/html/classpugi_1_1xpath__exception__inherit__graph.map create mode 100644 docs/html/classpugi_1_1xpath__exception__inherit__graph.md5 create mode 100644 docs/html/classpugi_1_1xpath__exception__inherit__graph.png create mode 100644 docs/html/classpugi_1_1xpath__node-members.html create mode 100644 docs/html/classpugi_1_1xpath__node.html create mode 100644 docs/html/classpugi_1_1xpath__node__coll__graph.map create mode 100644 docs/html/classpugi_1_1xpath__node__coll__graph.md5 create mode 100644 docs/html/classpugi_1_1xpath__node__coll__graph.png create mode 100644 docs/html/classpugi_1_1xpath__node__set-members.html create mode 100644 docs/html/classpugi_1_1xpath__node__set.html create mode 100644 docs/html/classpugi_1_1xpath__node__set__coll__graph.map create mode 100644 docs/html/classpugi_1_1xpath__node__set__coll__graph.md5 create mode 100644 docs/html/classpugi_1_1xpath__node__set__coll__graph.png create mode 100644 docs/html/classpugi_1_1xpath__query-members.html create mode 100644 docs/html/classpugi_1_1xpath__query.html create mode 100644 docs/html/classpugi_1_1xpath__query__coll__graph.map create mode 100644 docs/html/classpugi_1_1xpath__query__coll__graph.md5 create mode 100644 docs/html/classpugi_1_1xpath__query__coll__graph.png create mode 100644 docs/html/doxygen.css create mode 100644 docs/html/doxygen.png create mode 100644 docs/html/functions.html create mode 100644 docs/html/functions_enum.html create mode 100644 docs/html/functions_eval.html create mode 100644 docs/html/functions_func.html create mode 100644 docs/html/functions_type.html create mode 100644 docs/html/graph_legend.dot create mode 100644 docs/html/graph_legend.html create mode 100644 docs/html/graph_legend.png create mode 100644 docs/html/hierarchy.html create mode 100644 docs/html/index.html create mode 100644 docs/html/inherit__graph__0.map create mode 100644 docs/html/inherit__graph__0.md5 create mode 100644 docs/html/inherit__graph__0.png create mode 100644 docs/html/inherit__graph__1.map create mode 100644 docs/html/inherit__graph__1.md5 create mode 100644 docs/html/inherit__graph__1.png create mode 100644 docs/html/inherit__graph__2.map create mode 100644 docs/html/inherit__graph__2.md5 create mode 100644 docs/html/inherit__graph__2.png create mode 100644 docs/html/inherit__graph__3.map create mode 100644 docs/html/inherit__graph__3.md5 create mode 100644 docs/html/inherit__graph__3.png create mode 100644 docs/html/inherit__graph__4.map create mode 100644 docs/html/inherit__graph__4.md5 create mode 100644 docs/html/inherit__graph__4.png create mode 100644 docs/html/inherit__graph__5.map create mode 100644 docs/html/inherit__graph__5.md5 create mode 100644 docs/html/inherit__graph__5.png create mode 100644 docs/html/inherit__graph__6.map create mode 100644 docs/html/inherit__graph__6.md5 create mode 100644 docs/html/inherit__graph__6.png create mode 100644 docs/html/inherit__graph__7.map create mode 100644 docs/html/inherit__graph__7.md5 create mode 100644 docs/html/inherit__graph__7.png create mode 100644 docs/html/inherit__graph__8.map create mode 100644 docs/html/inherit__graph__8.md5 create mode 100644 docs/html/inherit__graph__8.png create mode 100644 docs/html/inherits.html create mode 100644 docs/html/namespacemembers.html create mode 100644 docs/html/namespacemembers_enum.html create mode 100644 docs/html/namespacemembers_eval.html create mode 100644 docs/html/namespacemembers_func.html create mode 100644 docs/html/namespacemembers_vars.html create mode 100644 docs/html/namespacepugi.html create mode 100644 docs/html/namespaces.html create mode 100644 docs/html/structpugi_1_1transfer__ownership__tag.html create mode 100644 docs/html/tab_b.gif create mode 100644 docs/html/tab_l.gif create mode 100644 docs/html/tab_r.gif create mode 100644 docs/html/tabs.css create mode 100644 src/pugiconfig.hpp create mode 100644 src/pugixpath.cpp diff --git a/docs/html/annotated.html b/docs/html/annotated.html new file mode 100644 index 0000000..92baeb6 --- /dev/null +++ b/docs/html/annotated.html @@ -0,0 +1,37 @@ + + +pugixml: Class List + + + + +
+
+
+
+

pugixml Class List

Here are the classes, structs, unions and interfaces with brief descriptions: + + + + + + + + + + + +
pugi::transfer_ownership_tagStruct used to distinguish parsing with ownership transfer from parsing without it
pugi::xml_attributeA light-weight wrapper for manipulating attributes in DOM tree
pugi::xml_attribute_iteratorAttribute iterator
pugi::xml_documentDocument class (DOM tree root)
pugi::xml_nodeA light-weight wrapper for manipulating nodes in DOM tree
pugi::xml_node_iteratorChild node iterator
pugi::xml_tree_walkerAbstract tree walker class
pugi::xpath_exceptionXPath exception class
pugi::xpath_nodeXPath node class
pugi::xpath_node_setNot necessarily ordered constant collection of XPath nodes
pugi::xpath_queryA class that holds compiled XPath query and allows to evaluate query result
+
Generated on Wed Feb 21 22:19:50 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xml__attribute-members.html b/docs/html/classpugi_1_1xml__attribute-members.html new file mode 100644 index 0000000..83c136c --- /dev/null +++ b/docs/html/classpugi_1_1xml__attribute-members.html @@ -0,0 +1,52 @@ + + +pugixml: Member List + + + + +
+
+
+
+

pugi::xml_attribute Member List

This is the complete list of members for pugi::xml_attribute, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
as_bool() const pugi::xml_attribute
as_double() const pugi::xml_attribute
as_float() const pugi::xml_attribute
as_int() const pugi::xml_attribute
document_order() const (defined in pugi::xml_attribute)pugi::xml_attribute
empty() const pugi::xml_attribute
name() const pugi::xml_attribute
next_attribute() const pugi::xml_attribute
operator unspecified_bool_type() const pugi::xml_attribute
operator!() const (defined in pugi::xml_attribute)pugi::xml_attribute
operator!=(const xml_attribute &r) const pugi::xml_attribute
operator<(const xml_attribute &r) const pugi::xml_attribute
operator<=(const xml_attribute &r) const pugi::xml_attribute
operator=(const char *rhs)pugi::xml_attribute
operator=(int rhs)pugi::xml_attribute
operator=(double rhs)pugi::xml_attribute
operator=(bool rhs)pugi::xml_attribute
operator==(const xml_attribute &r) const pugi::xml_attribute
operator>(const xml_attribute &r) const pugi::xml_attribute
operator>=(const xml_attribute &r) const pugi::xml_attribute
previous_attribute() const pugi::xml_attribute
set_name(const char *rhs)pugi::xml_attribute
set_value(const char *rhs)pugi::xml_attribute
value() const pugi::xml_attribute
xml_attribute()pugi::xml_attribute
xml_attribute_iterator (defined in pugi::xml_attribute)pugi::xml_attribute [friend]
xml_node (defined in pugi::xml_attribute)pugi::xml_attribute [friend]

Generated on Wed Feb 21 22:19:51 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xml__attribute.html b/docs/html/classpugi_1_1xml__attribute.html new file mode 100644 index 0000000..840a4a7 --- /dev/null +++ b/docs/html/classpugi_1_1xml__attribute.html @@ -0,0 +1,881 @@ + + +pugixml: pugi::xml_attribute Class Reference + + + + +
+
+
+
+
+pugi::xml_attribute
+

pugi::xml_attribute Class Reference

Collaboration diagram for pugi::xml_attribute:

Collaboration graph
+
[legend]
List of all members.

Detailed Description

+A light-weight wrapper for manipulating attributes in DOM tree. +

+Note: xml_attribute does not allocate any memory for the attribute it wraps; it only wraps a pointer to existing attribute. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

 xml_attribute ()
 Default ctor.
 operator unspecified_bool_type () const
 Safe bool conversion.
+bool operator! () const
bool operator== (const xml_attribute &r) const
 Compare wrapped pointer to the attribute to the pointer that is wrapped by r.
bool operator!= (const xml_attribute &r) const
 Compare wrapped pointer to the attribute to the pointer that is wrapped by r.
bool operator< (const xml_attribute &r) const
 Compare wrapped pointer to the attribute to the pointer that is wrapped by r.
bool operator> (const xml_attribute &r) const
 Compare wrapped pointer to the attribute to the pointer that is wrapped by r.
bool operator<= (const xml_attribute &r) const
 Compare wrapped pointer to the attribute to the pointer that is wrapped by r.
bool operator>= (const xml_attribute &r) const
 Compare wrapped pointer to the attribute to the pointer that is wrapped by r.
xml_attribute next_attribute () const
 Get next attribute in attribute list of node that contains the attribute.
xml_attribute previous_attribute () const
 Get previous attribute in attribute list of node that contains the attribute.
int as_int () const
 Cast attribute value as int.
double as_double () const
 Cast attribute value as double.
float as_float () const
 Cast attribute value as float.
bool as_bool () const
 Cast attribute value as bool.
+unsigned int document_order () const
xml_attribute & operator= (const char *rhs)
 Set attribute value to rhs.
xml_attribute & operator= (int rhs)
 Set attribute value to rhs.
xml_attribute & operator= (double rhs)
 Set attribute value to rhs.
xml_attribute & operator= (bool rhs)
 Set attribute value to either 'true' or 'false' (depends on whether rhs is true or false).
bool set_name (const char *rhs)
 Set attribute name to rhs.
bool set_value (const char *rhs)
 Set attribute value to rhs.
bool empty () const
 Check if attribute is empty.
const char * name () const
 Get attribute name.
const char * value () const
 Get attribute value.

Friends

+class xml_attribute_iterator
+class xml_node
+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + +
pugi::xml_attribute::xml_attribute (   ) 
+
+ + + + + +
+   + + +

+Default ctor. +

+Constructs an empty attribute.

+

Member Function Documentation

+

+ + + + +
+ + + + + + + + +
pugi::xml_attribute::operator unspecified_bool_type (   )  const
+
+ + + + + +
+   + + +

+Safe bool conversion. +

+Allows xml_node to be used in a context where boolean variable is expected, such as 'if (node)'.

+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_attribute::operator== ( const xml_attribute &  r  )  const
+
+ + + + + +
+   + + +

+Compare wrapped pointer to the attribute to the pointer that is wrapped by r. +

+

Parameters:
+ + +
r - value to compare to
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_attribute::operator!= ( const xml_attribute &  r  )  const
+
+ + + + + +
+   + + +

+Compare wrapped pointer to the attribute to the pointer that is wrapped by r. +

+

Parameters:
+ + +
r - value to compare to
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_attribute::operator< ( const xml_attribute &  r  )  const
+
+ + + + + +
+   + + +

+Compare wrapped pointer to the attribute to the pointer that is wrapped by r. +

+

Parameters:
+ + +
r - value to compare to
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_attribute::operator> ( const xml_attribute &  r  )  const
+
+ + + + + +
+   + + +

+Compare wrapped pointer to the attribute to the pointer that is wrapped by r. +

+

Parameters:
+ + +
r - value to compare to
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_attribute::operator<= ( const xml_attribute &  r  )  const
+
+ + + + + +
+   + + +

+Compare wrapped pointer to the attribute to the pointer that is wrapped by r. +

+

Parameters:
+ + +
r - value to compare to
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_attribute::operator>= ( const xml_attribute &  r  )  const
+
+ + + + + +
+   + + +

+Compare wrapped pointer to the attribute to the pointer that is wrapped by r. +

+

Parameters:
+ + +
r - value to compare to
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + +
xml_attribute pugi::xml_attribute::next_attribute (   )  const
+
+ + + + + +
+   + + +

+Get next attribute in attribute list of node that contains the attribute. +

+

Returns:
next attribute, if any; empty attribute otherwise
+
+

+ + + + +
+ + + + + + + + +
xml_attribute pugi::xml_attribute::previous_attribute (   )  const
+
+ + + + + +
+   + + +

+Get previous attribute in attribute list of node that contains the attribute. +

+

Returns:
previous attribute, if any; empty attribute otherwise
+
+

+ + + + +
+ + + + + + + + +
int pugi::xml_attribute::as_int (   )  const
+
+ + + + + +
+   + + +

+Cast attribute value as int. +

+

Returns:
attribute value as int, or 0 if conversion did not succeed or attribute is empty
+
+

+ + + + +
+ + + + + + + + +
double pugi::xml_attribute::as_double (   )  const
+
+ + + + + +
+   + + +

+Cast attribute value as double. +

+

Returns:
attribute value as double, or 0.0 if conversion did not succeed or attribute is empty
+
+

+ + + + +
+ + + + + + + + +
float pugi::xml_attribute::as_float (   )  const
+
+ + + + + +
+   + + +

+Cast attribute value as float. +

+

Returns:
attribute value as float, or 0.0f if conversion did not succeed or attribute is empty
+
+

+ + + + +
+ + + + + + + + +
bool pugi::xml_attribute::as_bool (   )  const
+
+ + + + + +
+   + + +

+Cast attribute value as bool. +

+Returns true for attributes with values that start with '1', 't', 'T', 'y', 'Y', returns false for other attributes.

+

Returns:
attribute value as bool, or false if conversion did not succeed or attribute is empty
+
+

+ + + + +
+ + + + + + + + + +
xml_attribute& pugi::xml_attribute::operator= ( const char *  rhs  ) 
+
+ + + + + +
+   + + +

+Set attribute value to rhs. +

+

Parameters:
+ + +
rhs - new attribute value
+
+
Returns:
self
+
+

+ + + + +
+ + + + + + + + + +
xml_attribute& pugi::xml_attribute::operator= ( int  rhs  ) 
+
+ + + + + +
+   + + +

+Set attribute value to rhs. +

+

Parameters:
+ + +
rhs - new attribute value
+
+
Returns:
self
+
+

+ + + + +
+ + + + + + + + + +
xml_attribute& pugi::xml_attribute::operator= ( double  rhs  ) 
+
+ + + + + +
+   + + +

+Set attribute value to rhs. +

+

Parameters:
+ + +
rhs - new attribute value
+
+
Returns:
self
+
+

+ + + + +
+ + + + + + + + + +
xml_attribute& pugi::xml_attribute::operator= ( bool  rhs  ) 
+
+ + + + + +
+   + + +

+Set attribute value to either 'true' or 'false' (depends on whether rhs is true or false). +

+

Parameters:
+ + +
rhs - new attribute value
+
+
Returns:
self
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_attribute::set_name ( const char *  rhs  ) 
+
+ + + + + +
+   + + +

+Set attribute name to rhs. +

+

Parameters:
+ + +
rhs - new attribute name
+
+
Returns:
success flag (call fails if attribute is empty or there is not enough memory)
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_attribute::set_value ( const char *  rhs  ) 
+
+ + + + + +
+   + + +

+Set attribute value to rhs. +

+

Parameters:
+ + +
rhs - new attribute value
+
+
Returns:
success flag (call fails if attribute is empty or there is not enough memory)
+
+

+ + + + +
+ + + + + + + + +
bool pugi::xml_attribute::empty (   )  const
+
+ + + + + +
+   + + +

+Check if attribute is empty. +

+

Returns:
true if attribute is empty, false otherwise
+
+

+ + + + +
+ + + + + + + + +
const char* pugi::xml_attribute::name (   )  const
+
+ + + + + +
+   + + +

+Get attribute name. +

+

Returns:
attribute name, or "" if attribute is empty
+
+

+ + + + +
+ + + + + + + + +
const char* pugi::xml_attribute::value (   )  const
+
+ + + + + +
+   + + +

+Get attribute value. +

+

Returns:
attribute value, or "" if attribute is empty
+
+

Generated on Wed Feb 21 22:19:51 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xml__attribute__coll__graph.map b/docs/html/classpugi_1_1xml__attribute__coll__graph.map new file mode 100644 index 0000000..5a14779 --- /dev/null +++ b/docs/html/classpugi_1_1xml__attribute__coll__graph.map @@ -0,0 +1 @@ +base referer diff --git a/docs/html/classpugi_1_1xml__attribute__coll__graph.md5 b/docs/html/classpugi_1_1xml__attribute__coll__graph.md5 new file mode 100644 index 0000000..5c6e354 --- /dev/null +++ b/docs/html/classpugi_1_1xml__attribute__coll__graph.md5 @@ -0,0 +1 @@ +bbcc1bb9d46dc6d7963d87bb57d9c972 \ No newline at end of file diff --git a/docs/html/classpugi_1_1xml__attribute__coll__graph.png b/docs/html/classpugi_1_1xml__attribute__coll__graph.png new file mode 100644 index 0000000..92a5dc0 Binary files /dev/null and b/docs/html/classpugi_1_1xml__attribute__coll__graph.png differ diff --git a/docs/html/classpugi_1_1xml__attribute__iterator-members.html b/docs/html/classpugi_1_1xml__attribute__iterator-members.html new file mode 100644 index 0000000..48c5720 --- /dev/null +++ b/docs/html/classpugi_1_1xml__attribute__iterator-members.html @@ -0,0 +1,37 @@ + + +pugixml: Member List + + + + +
+
+
+
+

pugi::xml_attribute_iterator Member List

This is the complete list of members for pugi::xml_attribute_iterator, including all inherited members.

+ + + + + + + + + + + + +
operator *()pugi::xml_attribute_iterator
operator!=(const xml_attribute_iterator &rhs) const pugi::xml_attribute_iterator
operator++()pugi::xml_attribute_iterator
operator++(int)pugi::xml_attribute_iterator
operator--()pugi::xml_attribute_iterator
operator--(int)pugi::xml_attribute_iterator
operator->()pugi::xml_attribute_iterator
operator==(const xml_attribute_iterator &rhs) const pugi::xml_attribute_iterator
xml_attribute_iterator()pugi::xml_attribute_iterator
xml_attribute_iterator(const xml_attribute &node)pugi::xml_attribute_iterator
xml_attribute_iterator(xml_attribute_struct *ref, xml_attribute_struct *prev)pugi::xml_attribute_iterator
xml_node (defined in pugi::xml_attribute_iterator)pugi::xml_attribute_iterator [friend]

Generated on Wed Feb 21 22:19:51 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xml__attribute__iterator.html b/docs/html/classpugi_1_1xml__attribute__iterator.html new file mode 100644 index 0000000..81b80cb --- /dev/null +++ b/docs/html/classpugi_1_1xml__attribute__iterator.html @@ -0,0 +1,414 @@ + + +pugixml: pugi::xml_attribute_iterator Class Reference + + + + +
+
+
+
+
+pugi::xml_attribute_iterator
+

pugi::xml_attribute_iterator Class Reference

Inheritance diagram for pugi::xml_attribute_iterator:

Inheritance graph
+
[legend]
Collaboration diagram for pugi::xml_attribute_iterator:

Collaboration graph
+ + + +
[legend]
List of all members.

Detailed Description

+Attribute iterator. +

+It's a bidirectional iterator with value type 'xml_attribute'. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

+ xml_attribute_iterator ()
 Default ctor.
 xml_attribute_iterator (const xml_attribute &node)
 Initializing ctor.
 xml_attribute_iterator (xml_attribute_struct *ref, xml_attribute_struct *prev)
 Initializing ctor (for past-the-end).
bool operator== (const xml_attribute_iterator &rhs) const
 Check if this iterator is equal to rhs.
bool operator!= (const xml_attribute_iterator &rhs) const
 Check if this iterator is not equal to rhs.
xml_attribute & operator * ()
 Dereferencing operator.
xml_attribute * operator-> ()
 Member access operator.
const xml_attribute_iterator & operator++ ()
 Pre-increment operator.
xml_attribute_iterator operator++ (int)
 Post-increment operator.
const xml_attribute_iterator & operator-- ()
 Pre-decrement operator.
xml_attribute_iterator operator-- (int)
 Post-decrement operator.

Friends

+class xml_node
+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
pugi::xml_attribute_iterator::xml_attribute_iterator ( const xml_attribute &  node  ) 
+
+ + + + + +
+   + + +

+Initializing ctor. +

+

Parameters:
+ + +
node - node that iterator will point at
+
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + +
pugi::xml_attribute_iterator::xml_attribute_iterator ( xml_attribute_struct *  ref,
xml_attribute_struct *  prev
) 
+
+ + + + + +
+   + + +

+Initializing ctor (for past-the-end). +

+

Parameters:
+ + + +
ref - should be 0
prev - previous node
+
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_attribute_iterator::operator== ( const xml_attribute_iterator &  rhs  )  const
+
+ + + + + +
+   + + +

+Check if this iterator is equal to rhs. +

+

Parameters:
+ + +
rhs - other iterator
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_attribute_iterator::operator!= ( const xml_attribute_iterator &  rhs  )  const
+
+ + + + + +
+   + + +

+Check if this iterator is not equal to rhs. +

+

Parameters:
+ + +
rhs - other iterator
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + +
xml_attribute& pugi::xml_attribute_iterator::operator * (   ) 
+
+ + + + + +
+   + + +

+Dereferencing operator. +

+

Returns:
reference to the node iterator points at
+
+

+ + + + +
+ + + + + + + + +
xml_attribute* pugi::xml_attribute_iterator::operator-> (   ) 
+
+ + + + + +
+   + + +

+Member access operator. +

+

Returns:
poitner to the node iterator points at
+
+

+ + + + +
+ + + + + + + + +
const xml_attribute_iterator& pugi::xml_attribute_iterator::operator++ (   ) 
+
+ + + + + +
+   + + +

+Pre-increment operator. +

+

Returns:
self
+
+

+ + + + +
+ + + + + + + + + +
xml_attribute_iterator pugi::xml_attribute_iterator::operator++ ( int   ) 
+
+ + + + + +
+   + + +

+Post-increment operator. +

+

Returns:
old value
+
+

+ + + + +
+ + + + + + + + +
const xml_attribute_iterator& pugi::xml_attribute_iterator::operator-- (   ) 
+
+ + + + + +
+   + + +

+Pre-decrement operator. +

+

Returns:
self
+
+

+ + + + +
+ + + + + + + + + +
xml_attribute_iterator pugi::xml_attribute_iterator::operator-- ( int   ) 
+
+ + + + + +
+   + + +

+Post-decrement operator. +

+

Returns:
old value
+
+

Generated on Wed Feb 21 22:19:51 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xml__attribute__iterator__coll__graph.map b/docs/html/classpugi_1_1xml__attribute__iterator__coll__graph.map new file mode 100644 index 0000000..8ab0214 --- /dev/null +++ b/docs/html/classpugi_1_1xml__attribute__iterator__coll__graph.map @@ -0,0 +1,2 @@ +base referer +rect $classpugi_1_1xml__attribute.html 394,98 528,125 diff --git a/docs/html/classpugi_1_1xml__attribute__iterator__coll__graph.md5 b/docs/html/classpugi_1_1xml__attribute__iterator__coll__graph.md5 new file mode 100644 index 0000000..374ea03 --- /dev/null +++ b/docs/html/classpugi_1_1xml__attribute__iterator__coll__graph.md5 @@ -0,0 +1 @@ +fca591ae465868d5d6efde7fe15693de \ No newline at end of file diff --git a/docs/html/classpugi_1_1xml__attribute__iterator__coll__graph.png b/docs/html/classpugi_1_1xml__attribute__iterator__coll__graph.png new file mode 100644 index 0000000..d188df2 Binary files /dev/null and b/docs/html/classpugi_1_1xml__attribute__iterator__coll__graph.png differ diff --git a/docs/html/classpugi_1_1xml__attribute__iterator__inherit__graph.map b/docs/html/classpugi_1_1xml__attribute__iterator__inherit__graph.map new file mode 100644 index 0000000..5a14779 --- /dev/null +++ b/docs/html/classpugi_1_1xml__attribute__iterator__inherit__graph.map @@ -0,0 +1 @@ +base referer diff --git a/docs/html/classpugi_1_1xml__attribute__iterator__inherit__graph.md5 b/docs/html/classpugi_1_1xml__attribute__iterator__inherit__graph.md5 new file mode 100644 index 0000000..c6bbcb8 --- /dev/null +++ b/docs/html/classpugi_1_1xml__attribute__iterator__inherit__graph.md5 @@ -0,0 +1 @@ +4426af196a7b9222c3d5e7c1a18fcd84 \ No newline at end of file diff --git a/docs/html/classpugi_1_1xml__attribute__iterator__inherit__graph.png b/docs/html/classpugi_1_1xml__attribute__iterator__inherit__graph.png new file mode 100644 index 0000000..8b08b13 Binary files /dev/null and b/docs/html/classpugi_1_1xml__attribute__iterator__inherit__graph.png differ diff --git a/docs/html/classpugi_1_1xml__document-members.html b/docs/html/classpugi_1_1xml__document-members.html new file mode 100644 index 0000000..e25d78d --- /dev/null +++ b/docs/html/classpugi_1_1xml__document-members.html @@ -0,0 +1,103 @@ + + +pugixml: Member List + + + + +
+
+
+
+

pugi::xml_document Member List

This is the complete list of members for pugi::xml_document, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
_root (defined in pugi::xml_node)pugi::xml_node [protected]
all_elements_by_name(const char *name, OutputIterator it) const pugi::xml_node
all_elements_by_name_w(const char *name, OutputIterator it) const pugi::xml_node
append_attribute(const char *name)pugi::xml_node
append_child(xml_node_type type=node_element)pugi::xml_node
attribute(const char *name) const pugi::xml_node
attribute_iterator typedefpugi::xml_node
attribute_w(const char *name) const pugi::xml_node
attributes_begin() const pugi::xml_node
attributes_end() const pugi::xml_node
begin() const pugi::xml_node
child(const char *name) const pugi::xml_node
child_value() const pugi::xml_node
child_value(const char *name) const pugi::xml_node
child_value_w(const char *name) const pugi::xml_node
child_w(const char *name) const pugi::xml_node
document_order() const (defined in pugi::xml_node)pugi::xml_node
empty() const pugi::xml_node
end() const pugi::xml_node
find_attribute(Predicate pred) const pugi::xml_node [inline]
find_child(Predicate pred) const pugi::xml_node [inline]
find_node(Predicate pred) const pugi::xml_node [inline]
first_attribute() const pugi::xml_node
first_child() const pugi::xml_node
first_element_by_path(const char *path, char delimiter= '/') const pugi::xml_node
get_allocator() const (defined in pugi::xml_node)pugi::xml_node [protected]
insert_attribute_after(const char *name, const xml_attribute &attr)pugi::xml_node
insert_attribute_before(const char *name, const xml_attribute &attr)pugi::xml_node
insert_child_after(xml_node_type type, const xml_node &node)pugi::xml_node
insert_child_before(xml_node_type type, const xml_node &node)pugi::xml_node
iterator typedefpugi::xml_node
last_attribute() const pugi::xml_node
last_child() const pugi::xml_node
load(std::istream &stream, unsigned int options=parse_default)pugi::xml_document
load(const char *contents, unsigned int options=parse_default)pugi::xml_document
load_file(const char *name, unsigned int options=parse_default)pugi::xml_document
name() const pugi::xml_node
next_sibling(const char *name) const pugi::xml_node
next_sibling() const pugi::xml_node
next_sibling_w(const char *name) const pugi::xml_node
operator unspecified_bool_type() const pugi::xml_node
operator!() const (defined in pugi::xml_node)pugi::xml_node
operator!=(const xml_node &r) const pugi::xml_node
operator<(const xml_node &r) const pugi::xml_node
operator<=(const xml_node &r) const pugi::xml_node
operator==(const xml_node &r) const pugi::xml_node
operator>(const xml_node &r) const pugi::xml_node
operator>=(const xml_node &r) const pugi::xml_node
parent() const pugi::xml_node
parse(char *xmlstr, unsigned int options=parse_default)pugi::xml_document
parse(const transfer_ownership_tag &, char *xmlstr, unsigned int options=parse_default)pugi::xml_document
path(char delimiter= '/') const pugi::xml_node
precompute_document_order()pugi::xml_document
precompute_document_order_impl() (defined in pugi::xml_node)pugi::xml_node [protected]
previous_sibling(const char *name) const pugi::xml_node
previous_sibling() const pugi::xml_node
previous_sibling_w(const char *name) const pugi::xml_node
print(std::ostream &os, const char *indent="\t", unsigned int flags=format_default, unsigned int depth=0)pugi::xml_node
remove_attribute(const xml_attribute &a)pugi::xml_node
remove_attribute(const char *name)pugi::xml_node
remove_child(const xml_node &n)pugi::xml_node
remove_child(const char *name)pugi::xml_node
root() const pugi::xml_node
save_file(const char *name, const char *indent="\t", unsigned int flags=format_default)pugi::xml_document
select_nodes(const char *query) const pugi::xml_node
select_nodes(xpath_query &query) const pugi::xml_node
select_single_node(const char *query) const pugi::xml_node
select_single_node(xpath_query &query) const pugi::xml_node
set_name(const char *rhs)pugi::xml_node
set_value(const char *rhs)pugi::xml_node
traverse(xml_tree_walker &walker)pugi::xml_node
type() const pugi::xml_node
unspecified_bool_type typedef (defined in pugi::xml_node)pugi::xml_node [protected]
value() const pugi::xml_node
xml_document()pugi::xml_document
xml_node(xml_node_struct *p) (defined in pugi::xml_node)pugi::xml_node [explicit, protected]
xml_node()pugi::xml_node
~xml_document()pugi::xml_document

Generated on Wed Feb 21 22:19:52 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xml__document.html b/docs/html/classpugi_1_1xml__document.html new file mode 100644 index 0000000..c3a4bd4 --- /dev/null +++ b/docs/html/classpugi_1_1xml__document.html @@ -0,0 +1,365 @@ + + +pugixml: pugi::xml_document Class Reference + + + + +
+
+
+
+
+pugi::xml_document
+

pugi::xml_document Class Reference

Inheritance diagram for pugi::xml_document:

Inheritance graph
+ + + +
[legend]
Collaboration diagram for pugi::xml_document:

Collaboration graph
+ + + +
[legend]
List of all members.

Detailed Description

+Document class (DOM tree root). +

+This class has noncopyable semantics (private copy ctor/assignment operator). +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

+ xml_document ()
 Default ctor, makes empty document.
+ ~xml_document ()
 Dtor.
bool load (std::istream &stream, unsigned int options=parse_default)
 Load document from stream.
bool load (const char *contents, unsigned int options=parse_default)
 Load document from string.
bool load_file (const char *name, unsigned int options=parse_default)
 Load document from file.
bool parse (char *xmlstr, unsigned int options=parse_default)
 Parse the given XML string in-situ.
bool parse (const transfer_ownership_tag &, char *xmlstr, unsigned int options=parse_default)
 Parse the given XML string in-situ (gains ownership).
bool save_file (const char *name, const char *indent="\t", unsigned int flags=format_default)
 Save XML to file.
+void precompute_document_order ()
 Compute document order for the whole tree Sometimes this makes evaluation of XPath queries faster.
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + + + + + + + + + + +
bool pugi::xml_document::load ( std::istream &  stream,
unsigned int  options = parse_default
) 
+
+ + + + + +
+   + + +

+Load document from stream. +

+

Parameters:
+ + + +
stream - stream with xml data
options - parsing options
+
+
Returns:
success flag
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + +
bool pugi::xml_document::load ( const char *  contents,
unsigned int  options = parse_default
) 
+
+ + + + + +
+   + + +

+Load document from string. +

+

Parameters:
+ + + +
contents - input string
options - parsing options
+
+
Returns:
success flag
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + +
bool pugi::xml_document::load_file ( const char *  name,
unsigned int  options = parse_default
) 
+
+ + + + + +
+   + + +

+Load document from file. +

+

Parameters:
+ + + +
name - file name
options - parsing options
+
+
Returns:
success flag
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + +
bool pugi::xml_document::parse ( char *  xmlstr,
unsigned int  options = parse_default
) 
+
+ + + + + +
+   + + +

+Parse the given XML string in-situ. +

+The string is modified; you should ensure that string data will persist throughout the document's lifetime. Although, document does not gain ownership over the string, so you should free the memory occupied by it manually.

+

Parameters:
+ + + +
xmlstr - readwrite string with xml data
options - parsing options
+
+
Returns:
success flag
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool pugi::xml_document::parse ( const transfer_ownership_tag & ,
char *  xmlstr,
unsigned int  options = parse_default
) 
+
+ + + + + +
+   + + +

+Parse the given XML string in-situ (gains ownership). +

+The string is modified; document gains ownership over the string, so you don't have to worry about it's lifetime. Call example: doc.parse(transfer_ownership_tag(), string, options);

+

Parameters:
+ + + +
xmlstr - readwrite string with xml data
options - parsing options
+
+
Returns:
success flag
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + +
bool pugi::xml_document::save_file ( const char *  name,
const char *  indent = "\t",
unsigned int  flags = format_default
) 
+
+ + + + + +
+   + + +

+Save XML to file. +

+

Parameters:
+ + + + +
name - file name
indent - indentation string
flags - formatting flags
+
+
Returns:
success flag
+
+

Generated on Wed Feb 21 22:19:52 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xml__document__coll__graph.map b/docs/html/classpugi_1_1xml__document__coll__graph.map new file mode 100644 index 0000000..78dbed9 --- /dev/null +++ b/docs/html/classpugi_1_1xml__document__coll__graph.map @@ -0,0 +1,2 @@ +base referer +rect $classpugi_1_1xml__node.html 17,98 129,125 diff --git a/docs/html/classpugi_1_1xml__document__coll__graph.md5 b/docs/html/classpugi_1_1xml__document__coll__graph.md5 new file mode 100644 index 0000000..6da3440 --- /dev/null +++ b/docs/html/classpugi_1_1xml__document__coll__graph.md5 @@ -0,0 +1 @@ +3e4052a1037be38a0cdf2df3c750dd84 \ No newline at end of file diff --git a/docs/html/classpugi_1_1xml__document__coll__graph.png b/docs/html/classpugi_1_1xml__document__coll__graph.png new file mode 100644 index 0000000..ac5f77f Binary files /dev/null and b/docs/html/classpugi_1_1xml__document__coll__graph.png differ diff --git a/docs/html/classpugi_1_1xml__document__inherit__graph.map b/docs/html/classpugi_1_1xml__document__inherit__graph.map new file mode 100644 index 0000000..a324f1d --- /dev/null +++ b/docs/html/classpugi_1_1xml__document__inherit__graph.map @@ -0,0 +1,2 @@ +base referer +rect $classpugi_1_1xml__node.html 24,7 136,34 diff --git a/docs/html/classpugi_1_1xml__document__inherit__graph.md5 b/docs/html/classpugi_1_1xml__document__inherit__graph.md5 new file mode 100644 index 0000000..71d9ecc --- /dev/null +++ b/docs/html/classpugi_1_1xml__document__inherit__graph.md5 @@ -0,0 +1 @@ +68a77824c939d2564bd1548379a7c1e1 \ No newline at end of file diff --git a/docs/html/classpugi_1_1xml__document__inherit__graph.png b/docs/html/classpugi_1_1xml__document__inherit__graph.png new file mode 100644 index 0000000..8f89193 Binary files /dev/null and b/docs/html/classpugi_1_1xml__document__inherit__graph.png differ diff --git a/docs/html/classpugi_1_1xml__node-members.html b/docs/html/classpugi_1_1xml__node-members.html new file mode 100644 index 0000000..0a4dcee --- /dev/null +++ b/docs/html/classpugi_1_1xml__node-members.html @@ -0,0 +1,95 @@ + + +pugixml: Member List + + + + +
+
+
+
+

pugi::xml_node Member List

This is the complete list of members for pugi::xml_node, including all inherited members.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
_root (defined in pugi::xml_node)pugi::xml_node [protected]
all_elements_by_name(const char *name, OutputIterator it) const pugi::xml_node
all_elements_by_name_w(const char *name, OutputIterator it) const pugi::xml_node
append_attribute(const char *name)pugi::xml_node
append_child(xml_node_type type=node_element)pugi::xml_node
attribute(const char *name) const pugi::xml_node
attribute_iterator typedefpugi::xml_node
attribute_w(const char *name) const pugi::xml_node
attributes_begin() const pugi::xml_node
attributes_end() const pugi::xml_node
begin() const pugi::xml_node
child(const char *name) const pugi::xml_node
child_value() const pugi::xml_node
child_value(const char *name) const pugi::xml_node
child_value_w(const char *name) const pugi::xml_node
child_w(const char *name) const pugi::xml_node
document_order() const (defined in pugi::xml_node)pugi::xml_node
empty() const pugi::xml_node
end() const pugi::xml_node
find_attribute(Predicate pred) const pugi::xml_node [inline]
find_child(Predicate pred) const pugi::xml_node [inline]
find_node(Predicate pred) const pugi::xml_node [inline]
first_attribute() const pugi::xml_node
first_child() const pugi::xml_node
first_element_by_path(const char *path, char delimiter= '/') const pugi::xml_node
get_allocator() const (defined in pugi::xml_node)pugi::xml_node [protected]
insert_attribute_after(const char *name, const xml_attribute &attr)pugi::xml_node
insert_attribute_before(const char *name, const xml_attribute &attr)pugi::xml_node
insert_child_after(xml_node_type type, const xml_node &node)pugi::xml_node
insert_child_before(xml_node_type type, const xml_node &node)pugi::xml_node
iterator typedefpugi::xml_node
last_attribute() const pugi::xml_node
last_child() const pugi::xml_node
name() const pugi::xml_node
next_sibling(const char *name) const pugi::xml_node
next_sibling() const pugi::xml_node
next_sibling_w(const char *name) const pugi::xml_node
operator unspecified_bool_type() const pugi::xml_node
operator!() const (defined in pugi::xml_node)pugi::xml_node
operator!=(const xml_node &r) const pugi::xml_node
operator<(const xml_node &r) const pugi::xml_node
operator<=(const xml_node &r) const pugi::xml_node
operator==(const xml_node &r) const pugi::xml_node
operator>(const xml_node &r) const pugi::xml_node
operator>=(const xml_node &r) const pugi::xml_node
parent() const pugi::xml_node
path(char delimiter= '/') const pugi::xml_node
precompute_document_order_impl() (defined in pugi::xml_node)pugi::xml_node [protected]
previous_sibling(const char *name) const pugi::xml_node
previous_sibling() const pugi::xml_node
previous_sibling_w(const char *name) const pugi::xml_node
print(std::ostream &os, const char *indent="\t", unsigned int flags=format_default, unsigned int depth=0)pugi::xml_node
remove_attribute(const xml_attribute &a)pugi::xml_node
remove_attribute(const char *name)pugi::xml_node
remove_child(const xml_node &n)pugi::xml_node
remove_child(const char *name)pugi::xml_node
root() const pugi::xml_node
select_nodes(const char *query) const pugi::xml_node
select_nodes(xpath_query &query) const pugi::xml_node
select_single_node(const char *query) const pugi::xml_node
select_single_node(xpath_query &query) const pugi::xml_node
set_name(const char *rhs)pugi::xml_node
set_value(const char *rhs)pugi::xml_node
traverse(xml_tree_walker &walker)pugi::xml_node
type() const pugi::xml_node
unspecified_bool_type typedef (defined in pugi::xml_node)pugi::xml_node [protected]
value() const pugi::xml_node
xml_node(xml_node_struct *p) (defined in pugi::xml_node)pugi::xml_node [explicit, protected]
xml_node()pugi::xml_node
xml_node_iterator (defined in pugi::xml_node)pugi::xml_node [friend]

Generated on Wed Feb 21 22:19:51 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xml__node.html b/docs/html/classpugi_1_1xml__node.html new file mode 100644 index 0000000..2be96f3 --- /dev/null +++ b/docs/html/classpugi_1_1xml__node.html @@ -0,0 +1,2473 @@ + + +pugixml: pugi::xml_node Class Reference + + + + +
+
+
+
+
+pugi::xml_node
+

pugi::xml_node Class Reference

Inheritance diagram for pugi::xml_node:

Inheritance graph
+ + + +
[legend]
Collaboration diagram for pugi::xml_node:

Collaboration graph
+
[legend]
List of all members.

Detailed Description

+A light-weight wrapper for manipulating nodes in DOM tree. +

+Note: xml_node does not allocate any memory for the node it wraps; it only wraps a pointer to existing node. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Types

typedef xml_node_iterator iterator
 Node iterator type (for child nodes).
typedef xml_attribute_iterator attribute_iterator
 Node iterator type (for child nodes).

Public Member Functions

 xml_node ()
 Default ctor.
 operator unspecified_bool_type () const
 Safe bool conversion.
+bool operator! () const
bool operator== (const xml_node &r) const
 Compare wrapped pointer to the attribute to the pointer that is wrapped by r.
bool operator!= (const xml_node &r) const
 Compare wrapped pointer to the attribute to the pointer that is wrapped by r.
bool operator< (const xml_node &r) const
 Compare wrapped pointer to the attribute to the pointer that is wrapped by r.
bool operator> (const xml_node &r) const
 Compare wrapped pointer to the attribute to the pointer that is wrapped by r.
bool operator<= (const xml_node &r) const
 Compare wrapped pointer to the attribute to the pointer that is wrapped by r.
bool operator>= (const xml_node &r) const
 Compare wrapped pointer to the attribute to the pointer that is wrapped by r.
iterator begin () const
 Access the begin iterator for this node's collection of child nodes.
iterator end () const
 Access the end iterator for this node's collection of child nodes.
attribute_iterator attributes_begin () const
 Access the begin iterator for this node's collection of attributes.
attribute_iterator attributes_end () const
 Access the end iterator for this node's collection of attributes.
bool empty () const
 Check if node is empty.
xml_node_type type () const
 Get node type.
const char * name () const
 Get node name (element name for element nodes, PI target for PI).
const char * value () const
 Get node value (comment/PI/PCDATA/CDATA contents, depending on node type).
xml_node child (const char *name) const
 Get child with the specified name.
xml_node child_w (const char *name) const
 Get child with the name that matches specified pattern.
xml_attribute attribute (const char *name) const
 Get attribute with the specified name.
xml_attribute attribute_w (const char *name) const
 Get attribute with the name that matches specified pattern.
xml_node next_sibling (const char *name) const
 Get first of following sibling nodes with the specified name.
xml_node next_sibling_w (const char *name) const
 Get first of the following sibling nodes with the name that matches specified pattern.
xml_node next_sibling () const
 Get following sibling.
xml_node previous_sibling (const char *name) const
 Get first of preceding sibling nodes with the specified name.
xml_node previous_sibling_w (const char *name) const
 Get first of the preceding sibling nodes with the name that matches specified pattern.
xml_node previous_sibling () const
 Get preceding sibling.
xml_node parent () const
 Get parent node.
xml_node root () const
 Get root of DOM tree this node belongs to.
const char * child_value () const
 Get child value of current node; that is, value of the first child node of type PCDATA/CDATA.
const char * child_value (const char *name) const
 Get child value of child with specified name.
const char * child_value_w (const char *name) const
 Get child value of child with name that matches the specified pattern.
bool set_name (const char *rhs)
 Set node name to rhs (for PI/element nodes).
bool set_value (const char *rhs)
 Set node value to rhs (for PI/PCDATA/CDATA/comment nodes).
xml_attribute append_attribute (const char *name)
 Add attribute with specified name (for element nodes).
xml_attribute insert_attribute_after (const char *name, const xml_attribute &attr)
 Insert attribute with specified name after attr (for element nodes).
xml_attribute insert_attribute_before (const char *name, const xml_attribute &attr)
 Insert attribute with specified name before attr (for element nodes).
xml_node append_child (xml_node_type type=node_element)
 Add child node with specified type (for element nodes).
xml_node insert_child_after (xml_node_type type, const xml_node &node)
 Insert child node with specified type after node (for element nodes).
xml_node insert_child_before (xml_node_type type, const xml_node &node)
 Insert child node with specified type before node (for element nodes).
void remove_attribute (const xml_attribute &a)
 Remove specified attribute.
void remove_attribute (const char *name)
 Remove attribute with the specified name, if any.
void remove_child (const xml_node &n)
 Remove specified child.
void remove_child (const char *name)
 Remove child with the specified name, if any.
xml_attribute first_attribute () const
 Get first attribute.
xml_attribute last_attribute () const
 Get last attribute.
template<typename OutputIterator>
void all_elements_by_name (const char *name, OutputIterator it) const
 Get all elements from subtree with given name.
template<typename OutputIterator>
void all_elements_by_name_w (const char *name, OutputIterator it) const
 Get all elements from subtree with name that matches given pattern.
xml_node first_child () const
 Get first child.
xml_node last_child () const
 Get last child.
template<typename Predicate>
xml_attribute find_attribute (Predicate pred) const
 Find attribute using predicate.
template<typename Predicate>
xml_node find_child (Predicate pred) const
 Find child node using predicate.
template<typename Predicate>
xml_node find_node (Predicate pred) const
 Find node from subtree using predicate.
std::string path (char delimiter= '/') const
 Get the absolute node path from root as a text string.
xml_node first_element_by_path (const char *path, char delimiter= '/') const
 Search for a node by path.
bool traverse (xml_tree_walker &walker)
 Recursively traverse subtree with xml_tree_walker.
xpath_node select_single_node (const char *query) const
 Select single node by evaluating XPath query.
xpath_node select_single_node (xpath_query &query) const
 Select single node by evaluating XPath query.
xpath_node_set select_nodes (const char *query) const
 Select node set by evaluating XPath query.
xpath_node_set select_nodes (xpath_query &query) const
 Select node set by evaluating XPath query.
+unsigned int document_order () const
void print (std::ostream &os, const char *indent="\t", unsigned int flags=format_default, unsigned int depth=0)
 Print subtree to stream.

Protected Types

+typedef xml_node_struct *xml_node::* unspecified_bool_type

Protected Member Functions

+ xml_node (xml_node_struct *p)
+void precompute_document_order_impl ()
+xml_allocator & get_allocator () const

Protected Attributes

+xml_node_struct * _root

Friends

+class xml_node_iterator
+

Member Typedef Documentation

+

+ + + + +
+ + + + +
typedef xml_node_iterator pugi::xml_node::iterator
+
+ + + + + +
+   + + +

+Node iterator type (for child nodes). +

+

See also:
xml_node_iterator
+
+

+ + + + +
+ + + + +
typedef xml_attribute_iterator pugi::xml_node::attribute_iterator
+
+ + + + + +
+   + + +

+Node iterator type (for child nodes). +

+

See also:
xml_attribute_iterator
+
+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + +
pugi::xml_node::xml_node (   ) 
+
+ + + + + +
+   + + +

+Default ctor. +

+Constructs an empty node.

+

Member Function Documentation

+

+ + + + +
+ + + + + + + + +
pugi::xml_node::operator unspecified_bool_type (   )  const
+
+ + + + + +
+   + + +

+Safe bool conversion. +

+Allows xml_node to be used in a context where boolean variable is expected, such as 'if (node)'.

+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_node::operator== ( const xml_node &  r  )  const
+
+ + + + + +
+   + + +

+Compare wrapped pointer to the attribute to the pointer that is wrapped by r. +

+

Parameters:
+ + +
r - value to compare to
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_node::operator!= ( const xml_node &  r  )  const
+
+ + + + + +
+   + + +

+Compare wrapped pointer to the attribute to the pointer that is wrapped by r. +

+

Parameters:
+ + +
r - value to compare to
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_node::operator< ( const xml_node &  r  )  const
+
+ + + + + +
+   + + +

+Compare wrapped pointer to the attribute to the pointer that is wrapped by r. +

+

Parameters:
+ + +
r - value to compare to
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_node::operator> ( const xml_node &  r  )  const
+
+ + + + + +
+   + + +

+Compare wrapped pointer to the attribute to the pointer that is wrapped by r. +

+

Parameters:
+ + +
r - value to compare to
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_node::operator<= ( const xml_node &  r  )  const
+
+ + + + + +
+   + + +

+Compare wrapped pointer to the attribute to the pointer that is wrapped by r. +

+

Parameters:
+ + +
r - value to compare to
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_node::operator>= ( const xml_node &  r  )  const
+
+ + + + + +
+   + + +

+Compare wrapped pointer to the attribute to the pointer that is wrapped by r. +

+

Parameters:
+ + +
r - value to compare to
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + +
iterator pugi::xml_node::begin (   )  const
+
+ + + + + +
+   + + +

+Access the begin iterator for this node's collection of child nodes. +

+

Returns:
iterator that points to the first child node, or past-the-end iterator if node is empty or has no children
+
+

+ + + + +
+ + + + + + + + +
iterator pugi::xml_node::end (   )  const
+
+ + + + + +
+   + + +

+Access the end iterator for this node's collection of child nodes. +

+

Returns:
past-the-end iterator for child list
+
+

+ + + + +
+ + + + + + + + +
attribute_iterator pugi::xml_node::attributes_begin (   )  const
+
+ + + + + +
+   + + +

+Access the begin iterator for this node's collection of attributes. +

+

Returns:
iterator that points to the first attribute, or past-the-end iterator if node is empty or has no attributes
+
+

+ + + + +
+ + + + + + + + +
attribute_iterator pugi::xml_node::attributes_end (   )  const
+
+ + + + + +
+   + + +

+Access the end iterator for this node's collection of attributes. +

+

Returns:
past-the-end iterator for attribute list
+
+

+ + + + +
+ + + + + + + + +
bool pugi::xml_node::empty (   )  const
+
+ + + + + +
+   + + +

+Check if node is empty. +

+

Returns:
true if node is empty, false otherwise
+
+

+ + + + +
+ + + + + + + + +
xml_node_type pugi::xml_node::type (   )  const
+
+ + + + + +
+   + + +

+Get node type. +

+

Returns:
node type; node_null for empty nodes
+
+

+ + + + +
+ + + + + + + + +
const char* pugi::xml_node::name (   )  const
+
+ + + + + +
+   + + +

+Get node name (element name for element nodes, PI target for PI). +

+

Returns:
node name, if any; "" otherwise
+
+

+ + + + +
+ + + + + + + + +
const char* pugi::xml_node::value (   )  const
+
+ + + + + +
+   + + +

+Get node value (comment/PI/PCDATA/CDATA contents, depending on node type). +

+

Returns:
node value, if any; "" otherwise
+
+

+ + + + +
+ + + + + + + + + +
xml_node pugi::xml_node::child ( const char *  name  )  const
+
+ + + + + +
+   + + +

+Get child with the specified name. +

+

Parameters:
+ + +
name - child name
+
+
Returns:
child with the specified name, if any; empty node otherwise
+
+

+ + + + +
+ + + + + + + + + +
xml_node pugi::xml_node::child_w ( const char *  name  )  const
+
+ + + + + +
+   + + +

+Get child with the name that matches specified pattern. +

+

Parameters:
+ + +
name - child name pattern
+
+
Returns:
child with the name that matches pattern, if any; empty node otherwise
+
+

+ + + + +
+ + + + + + + + + +
xml_attribute pugi::xml_node::attribute ( const char *  name  )  const
+
+ + + + + +
+   + + +

+Get attribute with the specified name. +

+

Parameters:
+ + +
name - attribute name
+
+
Returns:
attribute with the specified name, if any; empty attribute otherwise
+
+

+ + + + +
+ + + + + + + + + +
xml_attribute pugi::xml_node::attribute_w ( const char *  name  )  const
+
+ + + + + +
+   + + +

+Get attribute with the name that matches specified pattern. +

+

Parameters:
+ + +
name - attribute name pattern
+
+
Returns:
attribute with the name that matches pattern, if any; empty attribute otherwise
+
+

+ + + + +
+ + + + + + + + + +
xml_node pugi::xml_node::next_sibling ( const char *  name  )  const
+
+ + + + + +
+   + + +

+Get first of following sibling nodes with the specified name. +

+

Parameters:
+ + +
name - sibling name
+
+
Returns:
node with the specified name, if any; empty node otherwise
+
+

+ + + + +
+ + + + + + + + + +
xml_node pugi::xml_node::next_sibling_w ( const char *  name  )  const
+
+ + + + + +
+   + + +

+Get first of the following sibling nodes with the name that matches specified pattern. +

+

Parameters:
+ + +
name - sibling name pattern
+
+
Returns:
node with the name that matches pattern, if any; empty node otherwise
+
+

+ + + + +
+ + + + + + + + +
xml_node pugi::xml_node::next_sibling (   )  const
+
+ + + + + +
+   + + +

+Get following sibling. +

+

Returns:
following sibling node, if any; empty node otherwise
+
+

+ + + + +
+ + + + + + + + + +
xml_node pugi::xml_node::previous_sibling ( const char *  name  )  const
+
+ + + + + +
+   + + +

+Get first of preceding sibling nodes with the specified name. +

+

Parameters:
+ + +
name - sibling name
+
+
Returns:
node with the specified name, if any; empty node otherwise
+
+

+ + + + +
+ + + + + + + + + +
xml_node pugi::xml_node::previous_sibling_w ( const char *  name  )  const
+
+ + + + + +
+   + + +

+Get first of the preceding sibling nodes with the name that matches specified pattern. +

+

Parameters:
+ + +
name - sibling name pattern
+
+
Returns:
node with the name that matches pattern, if any; empty node otherwise
+
+

+ + + + +
+ + + + + + + + +
xml_node pugi::xml_node::previous_sibling (   )  const
+
+ + + + + +
+   + + +

+Get preceding sibling. +

+

Returns:
preceding sibling node, if any; empty node otherwise
+
+

+ + + + +
+ + + + + + + + +
xml_node pugi::xml_node::parent (   )  const
+
+ + + + + +
+   + + +

+Get parent node. +

+

Returns:
parent node if any; empty node otherwise
+
+

+ + + + +
+ + + + + + + + +
xml_node pugi::xml_node::root (   )  const
+
+ + + + + +
+   + + +

+Get root of DOM tree this node belongs to. +

+

Returns:
tree root
+
+

+ + + + +
+ + + + + + + + +
const char* pugi::xml_node::child_value (   )  const
+
+ + + + + +
+   + + +

+Get child value of current node; that is, value of the first child node of type PCDATA/CDATA. +

+

Returns:
child value of current node, if any; "" otherwise
+
+

+ + + + +
+ + + + + + + + + +
const char* pugi::xml_node::child_value ( const char *  name  )  const
+
+ + + + + +
+   + + +

+Get child value of child with specified name. +

+

See also:
child_value node.child_value(name) is equivalent to node.child(name).child_value()
+
Parameters:
+ + +
name - child name
+
+
Returns:
child value of specified child node, if any; "" otherwise
+
+

+ + + + +
+ + + + + + + + + +
const char* pugi::xml_node::child_value_w ( const char *  name  )  const
+
+ + + + + +
+   + + +

+Get child value of child with name that matches the specified pattern. +

+

See also:
child_value node.child_value_w(name) is equivalent to node.child_w(name).child_value()
+
Parameters:
+ + +
name - child name pattern
+
+
Returns:
child value of specified child node, if any; "" otherwise
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_node::set_name ( const char *  rhs  ) 
+
+ + + + + +
+   + + +

+Set node name to rhs (for PI/element nodes). +

+

See also:
name
+
Parameters:
+ + +
rhs - new node name
+
+
Returns:
success flag (call fails if node is of the wrong type or there is not enough memory)
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_node::set_value ( const char *  rhs  ) 
+
+ + + + + +
+   + + +

+Set node value to rhs (for PI/PCDATA/CDATA/comment nodes). +

+

See also:
value
+
Parameters:
+ + +
rhs - new node value
+
+
Returns:
success flag (call fails if node is of the wrong type or there is not enough memory)
+
+

+ + + + +
+ + + + + + + + + +
xml_attribute pugi::xml_node::append_attribute ( const char *  name  ) 
+
+ + + + + +
+   + + +

+Add attribute with specified name (for element nodes). +

+

Parameters:
+ + +
name - attribute name
+
+
Returns:
added attribute, or empty attribute if there was an error (wrong node type)
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + +
xml_attribute pugi::xml_node::insert_attribute_after ( const char *  name,
const xml_attribute &  attr
) 
+
+ + + + + +
+   + + +

+Insert attribute with specified name after attr (for element nodes). +

+

Parameters:
+ + + +
name - attribute name
attr - attribute to insert a new one after
+
+
Returns:
inserted attribute, or empty attribute if there was an error (wrong node type, or attr does not belong to node)
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + +
xml_attribute pugi::xml_node::insert_attribute_before ( const char *  name,
const xml_attribute &  attr
) 
+
+ + + + + +
+   + + +

+Insert attribute with specified name before attr (for element nodes). +

+

Parameters:
+ + + +
name - attribute name
attr - attribute to insert a new one before
+
+
Returns:
inserted attribute, or empty attribute if there was an error (wrong node type, or attr does not belong to node)
+
+

+ + + + +
+ + + + + + + + + +
xml_node pugi::xml_node::append_child ( xml_node_type  type = node_element  ) 
+
+ + + + + +
+   + + +

+Add child node with specified type (for element nodes). +

+

Parameters:
+ + +
type - node type
+
+
Returns:
added node, or empty node if there was an error (wrong node type)
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + +
xml_node pugi::xml_node::insert_child_after ( xml_node_type  type,
const xml_node &  node
) 
+
+ + + + + +
+   + + +

+Insert child node with specified type after node (for element nodes). +

+

Parameters:
+ + + +
type - node type
node - node to insert a new one after
+
+
Returns:
inserted node, or empty node if there was an error (wrong node type, or node is not a child of this node)
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + +
xml_node pugi::xml_node::insert_child_before ( xml_node_type  type,
const xml_node &  node
) 
+
+ + + + + +
+   + + +

+Insert child node with specified type before node (for element nodes). +

+

Parameters:
+ + + +
type - node type
node - node to insert a new one before
+
+
Returns:
inserted node, or empty node if there was an error (wrong node type, or node is not a child of this node)
+
+

+ + + + +
+ + + + + + + + + +
void pugi::xml_node::remove_attribute ( const xml_attribute &  a  ) 
+
+ + + + + +
+   + + +

+Remove specified attribute. +

+

Parameters:
+ + +
a - attribute to be removed
+
+
+

+ + + + +
+ + + + + + + + + +
void pugi::xml_node::remove_attribute ( const char *  name  ) 
+
+ + + + + +
+   + + +

+Remove attribute with the specified name, if any. +

+

Parameters:
+ + +
name - attribute name
+
+
+

+ + + + +
+ + + + + + + + + +
void pugi::xml_node::remove_child ( const xml_node &  n  ) 
+
+ + + + + +
+   + + +

+Remove specified child. +

+

Parameters:
+ + +
n - child node to be removed
+
+
+

+ + + + +
+ + + + + + + + + +
void pugi::xml_node::remove_child ( const char *  name  ) 
+
+ + + + + +
+   + + +

+Remove child with the specified name, if any. +

+

Parameters:
+ + +
name - child name
+
+
+

+ + + + +
+ + + + + + + + +
xml_attribute pugi::xml_node::first_attribute (   )  const
+
+ + + + + +
+   + + +

+Get first attribute. +

+

Returns:
first attribute, if any; empty attribute otherwise
+
+

+ + + + +
+ + + + + + + + +
xml_attribute pugi::xml_node::last_attribute (   )  const
+
+ + + + + +
+   + + +

+Get last attribute. +

+

Returns:
last attribute, if any; empty attribute otherwise
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + +
+template<typename OutputIterator>
void pugi::xml_node::all_elements_by_name ( const char *  name,
OutputIterator  it
)  const
+
+ + + + + +
+   + + +

+Get all elements from subtree with given name. +

+

Parameters:
+ + + +
name - node name
it - output iterator (for example, std::back_insert_iterator (result of std::back_inserter))
+
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + +
+template<typename OutputIterator>
void pugi::xml_node::all_elements_by_name_w ( const char *  name,
OutputIterator  it
)  const
+
+ + + + + +
+   + + +

+Get all elements from subtree with name that matches given pattern. +

+

Parameters:
+ + + +
name - node name pattern
it - output iterator (for example, std::back_insert_iterator (result of std::back_inserter))
+
+
+

+ + + + +
+ + + + + + + + +
xml_node pugi::xml_node::first_child (   )  const
+
+ + + + + +
+   + + +

+Get first child. +

+

Returns:
first child, if any; empty node otherwise
+
+

+ + + + +
+ + + + + + + + +
xml_node pugi::xml_node::last_child (   )  const
+
+ + + + + +
+   + + +

+Get last child. +

+

Returns:
last child, if any; empty node otherwise
+
+

+ + + + +
+ + + + + + + + + + + + +
+template<typename Predicate>
xml_attribute pugi::xml_node::find_attribute ( Predicate  pred  )  const [inline]
+
+ + + + + +
+   + + +

+Find attribute using predicate. +

+

Parameters:
+ + +
pred - predicate, that takes xml_attribute and returns bool
+
+
Returns:
first attribute for which predicate returned true, or empty attribute
+
+

+ + + + +
+ + + + + + + + + + + + +
+template<typename Predicate>
xml_node pugi::xml_node::find_child ( Predicate  pred  )  const [inline]
+
+ + + + + +
+   + + +

+Find child node using predicate. +

+

Parameters:
+ + +
pred - predicate, that takes xml_node and returns bool
+
+
Returns:
first child node for which predicate returned true, or empty node
+
+

+ + + + +
+ + + + + + + + + + + + +
+template<typename Predicate>
xml_node pugi::xml_node::find_node ( Predicate  pred  )  const [inline]
+
+ + + + + +
+   + + +

+Find node from subtree using predicate. +

+

Parameters:
+ + +
pred - predicate, that takes xml_node and returns bool
+
+
Returns:
first node from subtree for which predicate returned true, or empty node
+
+

+ + + + +
+ + + + + + + + + +
std::string pugi::xml_node::path ( char  delimiter = '/'  )  const
+
+ + + + + +
+   + + +

+Get the absolute node path from root as a text string. +

+

Parameters:
+ + +
delimiter - delimiter character to insert between element names
+
+
Returns:
path string (e.g. '/bookstore/book/author').
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + +
xml_node pugi::xml_node::first_element_by_path ( const char *  path,
char  delimiter = '/'
)  const
+
+ + + + + +
+   + + +

+Search for a node by path. +

+

Parameters:
+ + + +
path - path string; e.g. './foo/bar' (relative to node), '/foo/bar' (relative to root), '../foo/bar'.
delimiter - delimiter character to use while tokenizing path
+
+
Returns:
matching node, if any; empty node otherwise
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_node::traverse ( xml_tree_walker &  walker  ) 
+
+ + + + + +
+   + + +

+Recursively traverse subtree with xml_tree_walker. +

+

See also:
xml_tree_walker::begin

+xml_tree_walker::for_each

+xml_tree_walker::end

+
Parameters:
+ + +
walker - tree walker to traverse subtree with
+
+
Returns:
traversal result
+
+

+ + + + +
+ + + + + + + + + +
xpath_node pugi::xml_node::select_single_node ( const char *  query  )  const
+
+ + + + + +
+   + + +

+Select single node by evaluating XPath query. +

+

Parameters:
+ + +
query - query string
+
+
Returns:
first node from the resulting node set by document order, or empty node if none found
+
+

+ + + + +
+ + + + + + + + + +
xpath_node pugi::xml_node::select_single_node ( xpath_query &  query  )  const
+
+ + + + + +
+   + + +

+Select single node by evaluating XPath query. +

+

Parameters:
+ + +
query - compiled query
+
+
Returns:
first node from the resulting node set by document order, or empty node if none found
+
+

+ + + + +
+ + + + + + + + + +
xpath_node_set pugi::xml_node::select_nodes ( const char *  query  )  const
+
+ + + + + +
+   + + +

+Select node set by evaluating XPath query. +

+

Parameters:
+ + +
query - query string
+
+
Returns:
resulting node set
+
+

+ + + + +
+ + + + + + + + + +
xpath_node_set pugi::xml_node::select_nodes ( xpath_query &  query  )  const
+
+ + + + + +
+   + + +

+Select node set by evaluating XPath query. +

+

Parameters:
+ + +
query - compiled query
+
+
Returns:
resulting node set
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
void pugi::xml_node::print ( std::ostream &  os,
const char *  indent = "\t",
unsigned int  flags = format_default,
unsigned int  depth = 0
) 
+
+ + + + + +
+   + + +

+Print subtree to stream. +

+

Parameters:
+ + + + + +
os - output stream
indent - indentation string
flags - formatting flags
depth - starting depth (used for indentation)
+
+
+

Generated on Wed Feb 21 22:19:51 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xml__node__coll__graph.map b/docs/html/classpugi_1_1xml__node__coll__graph.map new file mode 100644 index 0000000..5a14779 --- /dev/null +++ b/docs/html/classpugi_1_1xml__node__coll__graph.map @@ -0,0 +1 @@ +base referer diff --git a/docs/html/classpugi_1_1xml__node__coll__graph.md5 b/docs/html/classpugi_1_1xml__node__coll__graph.md5 new file mode 100644 index 0000000..2572420 --- /dev/null +++ b/docs/html/classpugi_1_1xml__node__coll__graph.md5 @@ -0,0 +1 @@ +8b5be5e31df5c5adb3a803e79757f0d2 \ No newline at end of file diff --git a/docs/html/classpugi_1_1xml__node__coll__graph.png b/docs/html/classpugi_1_1xml__node__coll__graph.png new file mode 100644 index 0000000..db6620e Binary files /dev/null and b/docs/html/classpugi_1_1xml__node__coll__graph.png differ diff --git a/docs/html/classpugi_1_1xml__node__inherit__graph.map b/docs/html/classpugi_1_1xml__node__inherit__graph.map new file mode 100644 index 0000000..e1b3a3b --- /dev/null +++ b/docs/html/classpugi_1_1xml__node__inherit__graph.map @@ -0,0 +1,2 @@ +base referer +rect $classpugi_1_1xml__document.html 8,82 152,109 diff --git a/docs/html/classpugi_1_1xml__node__inherit__graph.md5 b/docs/html/classpugi_1_1xml__node__inherit__graph.md5 new file mode 100644 index 0000000..a6ac927 --- /dev/null +++ b/docs/html/classpugi_1_1xml__node__inherit__graph.md5 @@ -0,0 +1 @@ +feb1f5b174d36f4f52a15fdc9a9e8309 \ No newline at end of file diff --git a/docs/html/classpugi_1_1xml__node__inherit__graph.png b/docs/html/classpugi_1_1xml__node__inherit__graph.png new file mode 100644 index 0000000..d889c51 Binary files /dev/null and b/docs/html/classpugi_1_1xml__node__inherit__graph.png differ diff --git a/docs/html/classpugi_1_1xml__node__iterator-members.html b/docs/html/classpugi_1_1xml__node__iterator-members.html new file mode 100644 index 0000000..0910691 --- /dev/null +++ b/docs/html/classpugi_1_1xml__node__iterator-members.html @@ -0,0 +1,37 @@ + + +pugixml: Member List + + + + +
+
+
+
+

pugi::xml_node_iterator Member List

This is the complete list of members for pugi::xml_node_iterator, including all inherited members.

+ + + + + + + + + + + + +
operator *()pugi::xml_node_iterator
operator!=(const xml_node_iterator &rhs) const pugi::xml_node_iterator
operator++()pugi::xml_node_iterator
operator++(int)pugi::xml_node_iterator
operator--()pugi::xml_node_iterator
operator--(int)pugi::xml_node_iterator
operator->()pugi::xml_node_iterator
operator==(const xml_node_iterator &rhs) const pugi::xml_node_iterator
xml_node (defined in pugi::xml_node_iterator)pugi::xml_node_iterator [friend]
xml_node_iterator()pugi::xml_node_iterator
xml_node_iterator(const xml_node &node)pugi::xml_node_iterator
xml_node_iterator(xml_node_struct *ref, xml_node_struct *prev)pugi::xml_node_iterator

Generated on Wed Feb 21 22:19:51 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xml__node__iterator.html b/docs/html/classpugi_1_1xml__node__iterator.html new file mode 100644 index 0000000..225c11a --- /dev/null +++ b/docs/html/classpugi_1_1xml__node__iterator.html @@ -0,0 +1,414 @@ + + +pugixml: pugi::xml_node_iterator Class Reference + + + + +
+
+
+
+
+pugi::xml_node_iterator
+

pugi::xml_node_iterator Class Reference

Inheritance diagram for pugi::xml_node_iterator:

Inheritance graph
+
[legend]
Collaboration diagram for pugi::xml_node_iterator:

Collaboration graph
+ + + +
[legend]
List of all members.

Detailed Description

+Child node iterator. +

+It's a bidirectional iterator with value type 'xml_node'. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

+ xml_node_iterator ()
 Default ctor.
 xml_node_iterator (const xml_node &node)
 Initializing ctor.
 xml_node_iterator (xml_node_struct *ref, xml_node_struct *prev)
 Initializing ctor (for past-the-end).
bool operator== (const xml_node_iterator &rhs) const
 Check if this iterator is equal to rhs.
bool operator!= (const xml_node_iterator &rhs) const
 Check if this iterator is not equal to rhs.
xml_node & operator * ()
 Dereferencing operator.
xml_node * operator-> ()
 Member access operator.
const xml_node_iterator & operator++ ()
 Pre-increment operator.
xml_node_iterator operator++ (int)
 Post-increment operator.
const xml_node_iterator & operator-- ()
 Pre-decrement operator.
xml_node_iterator operator-- (int)
 Post-decrement operator.

Friends

+class xml_node
+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
pugi::xml_node_iterator::xml_node_iterator ( const xml_node &  node  ) 
+
+ + + + + +
+   + + +

+Initializing ctor. +

+

Parameters:
+ + +
node - node that iterator will point at
+
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + +
pugi::xml_node_iterator::xml_node_iterator ( xml_node_struct *  ref,
xml_node_struct *  prev
) 
+
+ + + + + +
+   + + +

+Initializing ctor (for past-the-end). +

+

Parameters:
+ + + +
ref - should be 0
prev - previous node
+
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_node_iterator::operator== ( const xml_node_iterator &  rhs  )  const
+
+ + + + + +
+   + + +

+Check if this iterator is equal to rhs. +

+

Parameters:
+ + +
rhs - other iterator
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xml_node_iterator::operator!= ( const xml_node_iterator &  rhs  )  const
+
+ + + + + +
+   + + +

+Check if this iterator is not equal to rhs. +

+

Parameters:
+ + +
rhs - other iterator
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + +
xml_node& pugi::xml_node_iterator::operator * (   ) 
+
+ + + + + +
+   + + +

+Dereferencing operator. +

+

Returns:
reference to the node iterator points at
+
+

+ + + + +
+ + + + + + + + +
xml_node* pugi::xml_node_iterator::operator-> (   ) 
+
+ + + + + +
+   + + +

+Member access operator. +

+

Returns:
poitner to the node iterator points at
+
+

+ + + + +
+ + + + + + + + +
const xml_node_iterator& pugi::xml_node_iterator::operator++ (   ) 
+
+ + + + + +
+   + + +

+Pre-increment operator. +

+

Returns:
self
+
+

+ + + + +
+ + + + + + + + + +
xml_node_iterator pugi::xml_node_iterator::operator++ ( int   ) 
+
+ + + + + +
+   + + +

+Post-increment operator. +

+

Returns:
old value
+
+

+ + + + +
+ + + + + + + + +
const xml_node_iterator& pugi::xml_node_iterator::operator-- (   ) 
+
+ + + + + +
+   + + +

+Pre-decrement operator. +

+

Returns:
self
+
+

+ + + + +
+ + + + + + + + + +
xml_node_iterator pugi::xml_node_iterator::operator-- ( int   ) 
+
+ + + + + +
+   + + +

+Post-decrement operator. +

+

Returns:
old value
+
+

Generated on Wed Feb 21 22:19:51 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xml__node__iterator__coll__graph.map b/docs/html/classpugi_1_1xml__node__iterator__coll__graph.map new file mode 100644 index 0000000..a1778b4 --- /dev/null +++ b/docs/html/classpugi_1_1xml__node__iterator__coll__graph.map @@ -0,0 +1,2 @@ +base referer +rect $classpugi_1_1xml__node.html 375,98 487,125 diff --git a/docs/html/classpugi_1_1xml__node__iterator__coll__graph.md5 b/docs/html/classpugi_1_1xml__node__iterator__coll__graph.md5 new file mode 100644 index 0000000..90c4c46 --- /dev/null +++ b/docs/html/classpugi_1_1xml__node__iterator__coll__graph.md5 @@ -0,0 +1 @@ +22bd4d00266db939271000f74fa43d5f \ No newline at end of file diff --git a/docs/html/classpugi_1_1xml__node__iterator__coll__graph.png b/docs/html/classpugi_1_1xml__node__iterator__coll__graph.png new file mode 100644 index 0000000..820aee7 Binary files /dev/null and b/docs/html/classpugi_1_1xml__node__iterator__coll__graph.png differ diff --git a/docs/html/classpugi_1_1xml__node__iterator__inherit__graph.map b/docs/html/classpugi_1_1xml__node__iterator__inherit__graph.map new file mode 100644 index 0000000..5a14779 --- /dev/null +++ b/docs/html/classpugi_1_1xml__node__iterator__inherit__graph.map @@ -0,0 +1 @@ +base referer diff --git a/docs/html/classpugi_1_1xml__node__iterator__inherit__graph.md5 b/docs/html/classpugi_1_1xml__node__iterator__inherit__graph.md5 new file mode 100644 index 0000000..c91b5e0 --- /dev/null +++ b/docs/html/classpugi_1_1xml__node__iterator__inherit__graph.md5 @@ -0,0 +1 @@ +0215459dad00cd6fcdc98555bd24087b \ No newline at end of file diff --git a/docs/html/classpugi_1_1xml__node__iterator__inherit__graph.png b/docs/html/classpugi_1_1xml__node__iterator__inherit__graph.png new file mode 100644 index 0000000..e3f04ba Binary files /dev/null and b/docs/html/classpugi_1_1xml__node__iterator__inherit__graph.png differ diff --git a/docs/html/classpugi_1_1xml__tree__walker-members.html b/docs/html/classpugi_1_1xml__tree__walker-members.html new file mode 100644 index 0000000..956ef8a --- /dev/null +++ b/docs/html/classpugi_1_1xml__tree__walker-members.html @@ -0,0 +1,32 @@ + + +pugixml: Member List + + + + +
+
+
+
+

pugi::xml_tree_walker Member List

This is the complete list of members for pugi::xml_tree_walker, including all inherited members.

+ + + + + + + +
begin(xml_node &)pugi::xml_tree_walker [virtual]
depth() const pugi::xml_tree_walker [protected]
end(xml_node &)pugi::xml_tree_walker [virtual]
for_each(xml_node &)=0pugi::xml_tree_walker [pure virtual]
xml_node (defined in pugi::xml_tree_walker)pugi::xml_tree_walker [friend]
xml_tree_walker()pugi::xml_tree_walker
~xml_tree_walker()pugi::xml_tree_walker [virtual]

Generated on Wed Feb 21 22:19:51 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xml__tree__walker.html b/docs/html/classpugi_1_1xml__tree__walker.html new file mode 100644 index 0000000..2e73c1a --- /dev/null +++ b/docs/html/classpugi_1_1xml__tree__walker.html @@ -0,0 +1,186 @@ + + +pugixml: pugi::xml_tree_walker Class Reference + + + + +
+
+
+
+
+pugi::xml_tree_walker
+

pugi::xml_tree_walker Class Reference

Collaboration diagram for pugi::xml_tree_walker:

Collaboration graph
+
[legend]
List of all members.

Detailed Description

+Abstract tree walker class. +

+

See also:
xml_node::traverse
+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

+ xml_tree_walker ()
 Default ctor.
+virtual ~xml_tree_walker ()
 Virtual dtor.
virtual bool begin (xml_node &)
 Callback that is called when traversal of node begins.
virtual bool for_each (xml_node &)=0
 Callback that is called for each node traversed.
virtual bool end (xml_node &)
 Callback that is called when traversal of node ends.

Protected Member Functions

int depth () const
 Get node depth.

Friends

+class xml_node
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + +
int pugi::xml_tree_walker::depth (   )  const [protected]
+
+ + + + + +
+   + + +

+Get node depth. +

+

Returns:
node depth
+
+

+ + + + +
+ + + + + + + + + +
virtual bool pugi::xml_tree_walker::begin ( xml_node &   )  [virtual]
+
+ + + + + +
+   + + +

+Callback that is called when traversal of node begins. +

+

Returns:
returning false will abort the traversal
+
+

+ + + + +
+ + + + + + + + + +
virtual bool pugi::xml_tree_walker::for_each ( xml_node &   )  [pure virtual]
+
+ + + + + +
+   + + +

+Callback that is called for each node traversed. +

+

Returns:
returning false will abort the traversal
+
+

+ + + + +
+ + + + + + + + + +
virtual bool pugi::xml_tree_walker::end ( xml_node &   )  [virtual]
+
+ + + + + +
+   + + +

+Callback that is called when traversal of node ends. +

+

Returns:
returning false will abort the traversal
+
+

Generated on Wed Feb 21 22:19:51 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xml__tree__walker__coll__graph.map b/docs/html/classpugi_1_1xml__tree__walker__coll__graph.map new file mode 100644 index 0000000..5a14779 --- /dev/null +++ b/docs/html/classpugi_1_1xml__tree__walker__coll__graph.map @@ -0,0 +1 @@ +base referer diff --git a/docs/html/classpugi_1_1xml__tree__walker__coll__graph.md5 b/docs/html/classpugi_1_1xml__tree__walker__coll__graph.md5 new file mode 100644 index 0000000..a7106de --- /dev/null +++ b/docs/html/classpugi_1_1xml__tree__walker__coll__graph.md5 @@ -0,0 +1 @@ +d990bdcfb4fd4dd9f8f3a6fe4ee6759b \ No newline at end of file diff --git a/docs/html/classpugi_1_1xml__tree__walker__coll__graph.png b/docs/html/classpugi_1_1xml__tree__walker__coll__graph.png new file mode 100644 index 0000000..39c90dd Binary files /dev/null and b/docs/html/classpugi_1_1xml__tree__walker__coll__graph.png differ diff --git a/docs/html/classpugi_1_1xpath__exception-members.html b/docs/html/classpugi_1_1xpath__exception-members.html new file mode 100644 index 0000000..3fa5c6f --- /dev/null +++ b/docs/html/classpugi_1_1xpath__exception-members.html @@ -0,0 +1,27 @@ + + +pugixml: Member List + + + + +
+
+
+
+

pugi::xpath_exception Member List

This is the complete list of members for pugi::xpath_exception, including all inherited members.

+ + +
what() const pugi::xpath_exception [virtual]
xpath_exception(const char *message)pugi::xpath_exception [explicit]

Generated on Wed Feb 21 22:19:52 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xpath__exception.html b/docs/html/classpugi_1_1xpath__exception.html new file mode 100644 index 0000000..4278767 --- /dev/null +++ b/docs/html/classpugi_1_1xpath__exception.html @@ -0,0 +1,108 @@ + + +pugixml: pugi::xpath_exception Class Reference + + + + +
+
+
+
+
+pugi::xpath_exception
+

pugi::xpath_exception Class Reference

Inheritance diagram for pugi::xpath_exception:

Inheritance graph
+
[legend]
Collaboration diagram for pugi::xpath_exception:

Collaboration graph
+
[legend]
List of all members.

Detailed Description

+XPath exception class. +

+ + + + + + + + + +

Public Member Functions

 xpath_exception (const char *message)
 Construct exception from static error string.
virtual const char * what () const throw ()
 Return error message.
+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
pugi::xpath_exception::xpath_exception ( const char *  message  )  [explicit]
+
+ + + + + +
+   + + +

+Construct exception from static error string. +

+

Parameters:
+ + +
message - error string
+
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + +
virtual const char* pugi::xpath_exception::what (   )  const throw () [virtual]
+
+ + + + + +
+   + + +

+Return error message. +

+

Returns:
error message
+
+

Generated on Wed Feb 21 22:19:52 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xpath__exception__coll__graph.map b/docs/html/classpugi_1_1xpath__exception__coll__graph.map new file mode 100644 index 0000000..5a14779 --- /dev/null +++ b/docs/html/classpugi_1_1xpath__exception__coll__graph.map @@ -0,0 +1 @@ +base referer diff --git a/docs/html/classpugi_1_1xpath__exception__coll__graph.md5 b/docs/html/classpugi_1_1xpath__exception__coll__graph.md5 new file mode 100644 index 0000000..c917263 --- /dev/null +++ b/docs/html/classpugi_1_1xpath__exception__coll__graph.md5 @@ -0,0 +1 @@ +e513ec4c3dceb21149d86032837e55f8 \ No newline at end of file diff --git a/docs/html/classpugi_1_1xpath__exception__coll__graph.png b/docs/html/classpugi_1_1xpath__exception__coll__graph.png new file mode 100644 index 0000000..f713014 Binary files /dev/null and b/docs/html/classpugi_1_1xpath__exception__coll__graph.png differ diff --git a/docs/html/classpugi_1_1xpath__exception__inherit__graph.map b/docs/html/classpugi_1_1xpath__exception__inherit__graph.map new file mode 100644 index 0000000..5a14779 --- /dev/null +++ b/docs/html/classpugi_1_1xpath__exception__inherit__graph.map @@ -0,0 +1 @@ +base referer diff --git a/docs/html/classpugi_1_1xpath__exception__inherit__graph.md5 b/docs/html/classpugi_1_1xpath__exception__inherit__graph.md5 new file mode 100644 index 0000000..900b385 --- /dev/null +++ b/docs/html/classpugi_1_1xpath__exception__inherit__graph.md5 @@ -0,0 +1 @@ +531210d868031d4dfad14e6148fd793e \ No newline at end of file diff --git a/docs/html/classpugi_1_1xpath__exception__inherit__graph.png b/docs/html/classpugi_1_1xpath__exception__inherit__graph.png new file mode 100644 index 0000000..a88837e Binary files /dev/null and b/docs/html/classpugi_1_1xpath__exception__inherit__graph.png differ diff --git a/docs/html/classpugi_1_1xpath__node-members.html b/docs/html/classpugi_1_1xpath__node-members.html new file mode 100644 index 0000000..f1efe50 --- /dev/null +++ b/docs/html/classpugi_1_1xpath__node-members.html @@ -0,0 +1,34 @@ + + +pugixml: Member List + + + + +
+
+
+
+

pugi::xpath_node Member List

This is the complete list of members for pugi::xpath_node, including all inherited members.

+ + + + + + + + + +
attribute() const pugi::xpath_node
node() const pugi::xpath_node
operator unspecified_bool_type() const pugi::xpath_node
operator!=(const xpath_node &n) const pugi::xpath_node
operator==(const xpath_node &n) const pugi::xpath_node
parent() const pugi::xpath_node
xpath_node()pugi::xpath_node
xpath_node(const xml_node &node)pugi::xpath_node
xpath_node(const xml_attribute &attribute, const xml_node &parent)pugi::xpath_node

Generated on Wed Feb 21 22:19:52 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xpath__node.html b/docs/html/classpugi_1_1xpath__node.html new file mode 100644 index 0000000..87b5b59 --- /dev/null +++ b/docs/html/classpugi_1_1xpath__node.html @@ -0,0 +1,341 @@ + + +pugixml: pugi::xpath_node Class Reference + + + + +
+
+
+
+
+pugi::xpath_node
+

pugi::xpath_node Class Reference

Collaboration diagram for pugi::xpath_node:

Collaboration graph
+ + + + +
[legend]
List of all members.

Detailed Description

+XPath node class. +

+XPath defines node to be either xml_node or xml_attribute in pugixml terminology, so xpath_node is either xml_node or xml_attribute. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

+ xpath_node ()
 Construct empty XPath node.
 xpath_node (const xml_node &node)
 Construct XPath node from XML node.
 xpath_node (const xml_attribute &attribute, const xml_node &parent)
 Construct XPath node from XML attribute.
xml_node node () const
 Get XML node, if any.
xml_attribute attribute () const
 Get XML attribute, if any.
xml_node parent () const
 Get parent of contained XML attribute, if any.
 operator unspecified_bool_type () const
 Safe bool conversion.
bool operator== (const xpath_node &n) const
 Compares two XPath nodes.
bool operator!= (const xpath_node &n) const
 Compares two XPath nodes.
+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
pugi::xpath_node::xpath_node ( const xml_node &  node  ) 
+
+ + + + + +
+   + + +

+Construct XPath node from XML node. +

+

Parameters:
+ + +
node - XML node
+
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + +
pugi::xpath_node::xpath_node ( const xml_attribute &  attribute,
const xml_node &  parent
) 
+
+ + + + + +
+   + + +

+Construct XPath node from XML attribute. +

+

Parameters:
+ + + +
attribute - XML attribute
parent - attribute's parent node
+
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + +
xml_node pugi::xpath_node::node (   )  const
+
+ + + + + +
+   + + +

+Get XML node, if any. +

+

Returns:
contained XML node, empty node otherwise
+
+

+ + + + +
+ + + + + + + + +
xml_attribute pugi::xpath_node::attribute (   )  const
+
+ + + + + +
+   + + +

+Get XML attribute, if any. +

+

Returns:
contained XML attribute, if any, empty attribute otherwise
+
+

+ + + + +
+ + + + + + + + +
xml_node pugi::xpath_node::parent (   )  const
+
+ + + + + +
+   + + +

+Get parent of contained XML attribute, if any. +

+

Returns:
parent of contained XML attribute, if any, empty node otherwise
+
+

+ + + + +
+ + + + + + + + +
pugi::xpath_node::operator unspecified_bool_type (   )  const
+
+ + + + + +
+   + + +

+Safe bool conversion. +

+Allows xpath_node to be used in a context where boolean variable is expected, such as 'if (node)'.

+

+ + + + +
+ + + + + + + + + +
bool pugi::xpath_node::operator== ( const xpath_node &  n  )  const
+
+ + + + + +
+   + + +

+Compares two XPath nodes. +

+

Parameters:
+ + +
n - XPath node to compare to
+
+
Returns:
comparison result
+
+

+ + + + +
+ + + + + + + + + +
bool pugi::xpath_node::operator!= ( const xpath_node &  n  )  const
+
+ + + + + +
+   + + +

+Compares two XPath nodes. +

+

Parameters:
+ + +
n - XPath node to compare to
+
+
Returns:
comparison result
+
+

Generated on Wed Feb 21 22:19:52 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xpath__node__coll__graph.map b/docs/html/classpugi_1_1xpath__node__coll__graph.map new file mode 100644 index 0000000..dd6359e --- /dev/null +++ b/docs/html/classpugi_1_1xpath__node__coll__graph.map @@ -0,0 +1,3 @@ +base referer +rect $classpugi_1_1xml__node.html 22,98 134,125 +rect $classpugi_1_1xml__attribute.html 166,98 300,125 diff --git a/docs/html/classpugi_1_1xpath__node__coll__graph.md5 b/docs/html/classpugi_1_1xpath__node__coll__graph.md5 new file mode 100644 index 0000000..5b4d30d --- /dev/null +++ b/docs/html/classpugi_1_1xpath__node__coll__graph.md5 @@ -0,0 +1 @@ +6221c8e84c73ffa18f2147cf42452f28 \ No newline at end of file diff --git a/docs/html/classpugi_1_1xpath__node__coll__graph.png b/docs/html/classpugi_1_1xpath__node__coll__graph.png new file mode 100644 index 0000000..ba8c62b Binary files /dev/null and b/docs/html/classpugi_1_1xpath__node__coll__graph.png differ diff --git a/docs/html/classpugi_1_1xpath__node__set-members.html b/docs/html/classpugi_1_1xpath__node__set-members.html new file mode 100644 index 0000000..4f9a678 --- /dev/null +++ b/docs/html/classpugi_1_1xpath__node__set-members.html @@ -0,0 +1,42 @@ + + +pugixml: Member List + + + + +
+
+
+
+

pugi::xpath_node_set Member List

This is the complete list of members for pugi::xpath_node_set, including all inherited members.

+ + + + + + + + + + + + + + + + + +
begin() const pugi::xpath_node_set
const_iterator typedefpugi::xpath_node_set
empty() const pugi::xpath_node_set
end() const pugi::xpath_node_set
first() const pugi::xpath_node_set
operator=(const xpath_node_set &ns)pugi::xpath_node_set
size() const pugi::xpath_node_set
sort(bool reverse=false)pugi::xpath_node_set
type() const pugi::xpath_node_set
type_sorted enum valuepugi::xpath_node_set
type_sorted_reverse enum valuepugi::xpath_node_set
type_t enum namepugi::xpath_node_set
type_unsorted enum valuepugi::xpath_node_set
xpath_ast_node (defined in pugi::xpath_node_set)pugi::xpath_node_set [friend]
xpath_node_set()pugi::xpath_node_set
xpath_node_set(const xpath_node_set &ns)pugi::xpath_node_set
~xpath_node_set()pugi::xpath_node_set

Generated on Wed Feb 21 22:19:52 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xpath__node__set.html b/docs/html/classpugi_1_1xpath__node__set.html new file mode 100644 index 0000000..2773fb6 --- /dev/null +++ b/docs/html/classpugi_1_1xpath__node__set.html @@ -0,0 +1,413 @@ + + +pugixml: pugi::xpath_node_set Class Reference + + + + +
+
+
+
+
+pugi::xpath_node_set
+

pugi::xpath_node_set Class Reference

Collaboration diagram for pugi::xpath_node_set:

Collaboration graph
+ + + + + +
[legend]
List of all members.

Detailed Description

+Not necessarily ordered constant collection of XPath nodes. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Types

+typedef const xpath_node * const_iterator
 Constant iterator type.
enum  type_t { type_unsorted, +type_sorted, +type_sorted_reverse + }
 Collection type. More...

Public Member Functions

+ xpath_node_set ()
 Default ctor Constructs empty set.
+ ~xpath_node_set ()
 Dtor.
 xpath_node_set (const xpath_node_set &ns)
 Copy ctor.
xpath_node_set & operator= (const xpath_node_set &ns)
 Assignment operator.
type_t type () const
 Get collection type.
size_t size () const
 Get collection size.
const_iterator begin () const
 Get begin constant iterator for collection.
const_iterator end () const
 Get end iterator for collection.
void sort (bool reverse=false)
 Sort the collection in ascending/descending order by document order.
xpath_node first () const
 Get first node in the collection by document order.
bool empty () const
 Return true if collection is empty.

Friends

+class xpath_ast_node
+

Member Enumeration Documentation

+

+ + + + +
+ + + + +
enum pugi::xpath_node_set::type_t
+
+ + + + + +
+   + + +

+Collection type. +

+

Enumerator:
+ + + + +
type_unsorted  +Not ordered.
type_sorted  +Sorted by document order (ascending).
type_sorted_reverse  +Sorted by document order (descending).
+
+
+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
pugi::xpath_node_set::xpath_node_set ( const xpath_node_set &  ns  ) 
+
+ + + + + +
+   + + +

+Copy ctor. +

+

Parameters:
+ + +
ns - set to copy
+
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + +
xpath_node_set& pugi::xpath_node_set::operator= ( const xpath_node_set &  ns  ) 
+
+ + + + + +
+   + + +

+Assignment operator. +

+

Parameters:
+ + +
ns - set to assign
+
+
Returns:
self
+
+

+ + + + +
+ + + + + + + + +
type_t pugi::xpath_node_set::type (   )  const
+
+ + + + + +
+   + + +

+Get collection type. +

+

Returns:
collection type
+
+

+ + + + +
+ + + + + + + + +
size_t pugi::xpath_node_set::size (   )  const
+
+ + + + + +
+   + + +

+Get collection size. +

+

Returns:
collection size
+
+

+ + + + +
+ + + + + + + + +
const_iterator pugi::xpath_node_set::begin (   )  const
+
+ + + + + +
+   + + +

+Get begin constant iterator for collection. +

+

Returns:
begin constant iterator
+
+

+ + + + +
+ + + + + + + + +
const_iterator pugi::xpath_node_set::end (   )  const
+
+ + + + + +
+   + + +

+Get end iterator for collection. +

+

Returns:
end iterator
+
+

+ + + + +
+ + + + + + + + + +
void pugi::xpath_node_set::sort ( bool  reverse = false  ) 
+
+ + + + + +
+   + + +

+Sort the collection in ascending/descending order by document order. +

+

Parameters:
+ + +
reverse - whether to sort in ascending (false) or descending (true) order
+
+
+

+ + + + +
+ + + + + + + + +
xpath_node pugi::xpath_node_set::first (   )  const
+
+ + + + + +
+   + + +

+Get first node in the collection by document order. +

+

Returns:
first node by document order
+
+

+ + + + +
+ + + + + + + + +
bool pugi::xpath_node_set::empty (   )  const
+
+ + + + + +
+   + + +

+Return true if collection is empty. +

+

Returns:
true if collection is empty, false otherwise
+
+

Generated on Wed Feb 21 22:19:52 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xpath__node__set__coll__graph.map b/docs/html/classpugi_1_1xpath__node__set__coll__graph.map new file mode 100644 index 0000000..6f67906 --- /dev/null +++ b/docs/html/classpugi_1_1xpath__node__set__coll__graph.map @@ -0,0 +1,4 @@ +base referer +rect $classpugi_1_1xpath__node.html 82,189 207,216 +rect $classpugi_1_1xml__node.html 25,98 137,125 +rect $classpugi_1_1xml__attribute.html 166,98 299,125 diff --git a/docs/html/classpugi_1_1xpath__node__set__coll__graph.md5 b/docs/html/classpugi_1_1xpath__node__set__coll__graph.md5 new file mode 100644 index 0000000..f36e93e --- /dev/null +++ b/docs/html/classpugi_1_1xpath__node__set__coll__graph.md5 @@ -0,0 +1 @@ +dae803c90d7e38f8b78eec2188afc6b8 \ No newline at end of file diff --git a/docs/html/classpugi_1_1xpath__node__set__coll__graph.png b/docs/html/classpugi_1_1xpath__node__set__coll__graph.png new file mode 100644 index 0000000..81c6982 Binary files /dev/null and b/docs/html/classpugi_1_1xpath__node__set__coll__graph.png differ diff --git a/docs/html/classpugi_1_1xpath__query-members.html b/docs/html/classpugi_1_1xpath__query-members.html new file mode 100644 index 0000000..5edc682 --- /dev/null +++ b/docs/html/classpugi_1_1xpath__query-members.html @@ -0,0 +1,31 @@ + + +pugixml: Member List + + + + +
+
+
+
+

pugi::xpath_query Member List

This is the complete list of members for pugi::xpath_query, including all inherited members.

+ + + + + + +
evaluate_boolean(const xml_node &n)pugi::xpath_query
evaluate_node_set(const xml_node &n)pugi::xpath_query
evaluate_number(const xml_node &n)pugi::xpath_query
evaluate_string(const xml_node &n)pugi::xpath_query
xpath_query(const char *query)pugi::xpath_query [explicit]
~xpath_query()pugi::xpath_query

Generated on Wed Feb 21 22:19:50 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xpath__query.html b/docs/html/classpugi_1_1xpath__query.html new file mode 100644 index 0000000..a55cb0d --- /dev/null +++ b/docs/html/classpugi_1_1xpath__query.html @@ -0,0 +1,239 @@ + + +pugixml: pugi::xpath_query Class Reference + + + + +
+
+
+
+
+pugi::xpath_query
+

pugi::xpath_query Class Reference

Collaboration diagram for pugi::xpath_query:

Collaboration graph
+
[legend]
List of all members.

Detailed Description

+A class that holds compiled XPath query and allows to evaluate query result. +

+ + + + + + + + + + + + + + + + + + + + + +

Public Member Functions

 xpath_query (const char *query)
 Ctor from string with XPath expression.
+ ~xpath_query ()
 Dtor.
bool evaluate_boolean (const xml_node &n)
 Evaluate expression as boolean value for the context node n.
double evaluate_number (const xml_node &n)
 Evaluate expression as double value for the context node n.
std::string evaluate_string (const xml_node &n)
 Evaluate expression as string value for the context node n.
xpath_node_set evaluate_node_set (const xml_node &n)
 Evaluate expression as node set for the context node n.
+

Constructor & Destructor Documentation

+

+ + + + +
+ + + + + + + + + +
pugi::xpath_query::xpath_query ( const char *  query  )  [explicit]
+
+ + + + + +
+   + + +

+Ctor from string with XPath expression. +

+Throws xpath_exception on compilation error, std::bad_alloc on out of memory error.

+

Parameters:
+ + +
query - string with XPath expression
+
+
+

Member Function Documentation

+

+ + + + +
+ + + + + + + + + +
bool pugi::xpath_query::evaluate_boolean ( const xml_node &  n  ) 
+
+ + + + + +
+   + + +

+Evaluate expression as boolean value for the context node n. +

+If expression does not directly evaluate to boolean, the expression result is converted as through boolean() XPath function call. Throws std::bad_alloc on out of memory error.

+

Parameters:
+ + +
n - context node
+
+
Returns:
evaluation result
+
+

+ + + + +
+ + + + + + + + + +
double pugi::xpath_query::evaluate_number ( const xml_node &  n  ) 
+
+ + + + + +
+   + + +

+Evaluate expression as double value for the context node n. +

+If expression does not directly evaluate to double, the expression result is converted as through number() XPath function call. Throws std::bad_alloc on out of memory error.

+

Parameters:
+ + +
n - context node
+
+
Returns:
evaluation result
+
+

+ + + + +
+ + + + + + + + + +
std::string pugi::xpath_query::evaluate_string ( const xml_node &  n  ) 
+
+ + + + + +
+   + + +

+Evaluate expression as string value for the context node n. +

+If expression does not directly evaluate to string, the expression result is converted as through string() XPath function call. Throws std::bad_alloc on out of memory error.

+

Parameters:
+ + +
n - context node
+
+
Returns:
evaluation result
+
+

+ + + + +
+ + + + + + + + + +
xpath_node_set pugi::xpath_query::evaluate_node_set ( const xml_node &  n  ) 
+
+ + + + + +
+   + + +

+Evaluate expression as node set for the context node n. +

+If expression does not directly evaluate to node set, function returns empty node set. Throws std::bad_alloc on out of memory error.

+

Parameters:
+ + +
n - context node
+
+
Returns:
evaluation result
+
+

Generated on Wed Feb 21 22:19:50 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/classpugi_1_1xpath__query__coll__graph.map b/docs/html/classpugi_1_1xpath__query__coll__graph.map new file mode 100644 index 0000000..5a14779 --- /dev/null +++ b/docs/html/classpugi_1_1xpath__query__coll__graph.map @@ -0,0 +1 @@ +base referer diff --git a/docs/html/classpugi_1_1xpath__query__coll__graph.md5 b/docs/html/classpugi_1_1xpath__query__coll__graph.md5 new file mode 100644 index 0000000..f1a2247 --- /dev/null +++ b/docs/html/classpugi_1_1xpath__query__coll__graph.md5 @@ -0,0 +1 @@ +8954c6e562b8b9c0f96734834320e6c2 \ No newline at end of file diff --git a/docs/html/classpugi_1_1xpath__query__coll__graph.png b/docs/html/classpugi_1_1xpath__query__coll__graph.png new file mode 100644 index 0000000..f7b3e06 Binary files /dev/null and b/docs/html/classpugi_1_1xpath__query__coll__graph.png differ diff --git a/docs/html/doxygen.css b/docs/html/doxygen.css new file mode 100644 index 0000000..05615b2 --- /dev/null +++ b/docs/html/doxygen.css @@ -0,0 +1,310 @@ +BODY,H1,H2,H3,H4,H5,H6,P,CENTER,TD,TH,UL,DL,DIV { + font-family: Geneva, Arial, Helvetica, sans-serif; +} +BODY,TD { + font-size: 90%; +} +H1 { + text-align: center; + font-size: 160%; +} +H2 { + font-size: 120%; +} +H3 { + font-size: 100%; +} +CAPTION { font-weight: bold } +DIV.qindex { + width: 100%; + background-color: #e8eef2; + border: 1px solid #84b0c7; + text-align: center; + margin: 2px; + padding: 2px; + line-height: 140%; +} +DIV.nav { + width: 100%; + background-color: #e8eef2; + border: 1px solid #84b0c7; + text-align: center; + margin: 2px; + padding: 2px; + line-height: 140%; +} +DIV.navtab { + background-color: #e8eef2; + border: 1px solid #84b0c7; + text-align: center; + margin: 2px; + margin-right: 15px; + padding: 2px; +} +TD.navtab { + font-size: 70%; +} +A.qindex { + text-decoration: none; + font-weight: bold; + color: #1A419D; +} +A.qindex:visited { + text-decoration: none; + font-weight: bold; + color: #1A419D +} +A.qindex:hover { + text-decoration: none; + background-color: #ddddff; +} +A.qindexHL { + text-decoration: none; + font-weight: bold; + background-color: #6666cc; + color: #ffffff; + border: 1px double #9295C2; +} +A.qindexHL:hover { + text-decoration: none; + background-color: #6666cc; + color: #ffffff; +} +A.qindexHL:visited { text-decoration: none; background-color: #6666cc; color: #ffffff } +A.el { text-decoration: none; font-weight: bold } +A.elRef { font-weight: bold } +A.code:link { text-decoration: none; font-weight: normal; color: #0000FF} +A.code:visited { text-decoration: none; font-weight: normal; color: #0000FF} +A.codeRef:link { font-weight: normal; color: #0000FF} +A.codeRef:visited { font-weight: normal; color: #0000FF} +A:hover { text-decoration: none; background-color: #f2f2ff } +DL.el { margin-left: -1cm } +.fragment { + font-family: Fixed, monospace; + font-size: 95%; +} +PRE.fragment { + border: 1px solid #CCCCCC; + background-color: #f5f5f5; + margin-top: 4px; + margin-bottom: 4px; + margin-left: 2px; + margin-right: 8px; + padding-left: 6px; + padding-right: 6px; + padding-top: 4px; + padding-bottom: 4px; +} +DIV.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px } +TD.md { background-color: #F4F4FB; font-weight: bold; } +TD.mdPrefix { + background-color: #F4F4FB; + color: #606060; + font-size: 80%; +} +TD.mdname1 { background-color: #F4F4FB; font-weight: bold; color: #602020; } +TD.mdname { background-color: #F4F4FB; font-weight: bold; color: #602020; width: 600px; } +DIV.groupHeader { + margin-left: 16px; + margin-top: 12px; + margin-bottom: 6px; + font-weight: bold; +} +DIV.groupText { margin-left: 16px; font-style: italic; font-size: 90% } +BODY { + background: white; + color: black; + margin-right: 20px; + margin-left: 20px; +} +TD.indexkey { + background-color: #e8eef2; + font-weight: bold; + padding-right : 10px; + padding-top : 2px; + padding-left : 10px; + padding-bottom : 2px; + margin-left : 0px; + margin-right : 0px; + margin-top : 2px; + margin-bottom : 2px; + border: 1px solid #CCCCCC; +} +TD.indexvalue { + background-color: #e8eef2; + font-style: italic; + padding-right : 10px; + padding-top : 2px; + padding-left : 10px; + padding-bottom : 2px; + margin-left : 0px; + margin-right : 0px; + margin-top : 2px; + margin-bottom : 2px; + border: 1px solid #CCCCCC; +} +TR.memlist { + background-color: #f0f0f0; +} +P.formulaDsp { text-align: center; } +IMG.formulaDsp { } +IMG.formulaInl { vertical-align: middle; } +SPAN.keyword { color: #008000 } +SPAN.keywordtype { color: #604020 } +SPAN.keywordflow { color: #e08000 } +SPAN.comment { color: #800000 } +SPAN.preprocessor { color: #806020 } +SPAN.stringliteral { color: #002080 } +SPAN.charliteral { color: #008080 } +.mdTable { + border: 1px solid #868686; + background-color: #F4F4FB; +} +.mdRow { + padding: 8px 10px; +} +.mdescLeft { + padding: 0px 8px 4px 8px; + font-size: 80%; + font-style: italic; + background-color: #FAFAFA; + border-top: 1px none #E0E0E0; + border-right: 1px none #E0E0E0; + border-bottom: 1px none #E0E0E0; + border-left: 1px none #E0E0E0; + margin: 0px; +} +.mdescRight { + padding: 0px 8px 4px 8px; + font-size: 80%; + font-style: italic; + background-color: #FAFAFA; + border-top: 1px none #E0E0E0; + border-right: 1px none #E0E0E0; + border-bottom: 1px none #E0E0E0; + border-left: 1px none #E0E0E0; + margin: 0px; +} +.memItemLeft { + padding: 1px 0px 0px 8px; + margin: 4px; + border-top-width: 1px; + border-right-width: 1px; + border-bottom-width: 1px; + border-left-width: 1px; + border-top-color: #E0E0E0; + border-right-color: #E0E0E0; + border-bottom-color: #E0E0E0; + border-left-color: #E0E0E0; + border-top-style: solid; + border-right-style: none; + border-bottom-style: none; + border-left-style: none; + background-color: #FAFAFA; + font-size: 80%; +} +.memItemRight { + padding: 1px 8px 0px 8px; + margin: 4px; + border-top-width: 1px; + border-right-width: 1px; + border-bottom-width: 1px; + border-left-width: 1px; + border-top-color: #E0E0E0; + border-right-color: #E0E0E0; + border-bottom-color: #E0E0E0; + border-left-color: #E0E0E0; + border-top-style: solid; + border-right-style: none; + border-bottom-style: none; + border-left-style: none; + background-color: #FAFAFA; + font-size: 80%; +} +.memTemplItemLeft { + padding: 1px 0px 0px 8px; + margin: 4px; + border-top-width: 1px; + border-right-width: 1px; + border-bottom-width: 1px; + border-left-width: 1px; + border-top-color: #E0E0E0; + border-right-color: #E0E0E0; + border-bottom-color: #E0E0E0; + border-left-color: #E0E0E0; + border-top-style: none; + border-right-style: none; + border-bottom-style: none; + border-left-style: none; + background-color: #FAFAFA; + font-size: 80%; +} +.memTemplItemRight { + padding: 1px 8px 0px 8px; + margin: 4px; + border-top-width: 1px; + border-right-width: 1px; + border-bottom-width: 1px; + border-left-width: 1px; + border-top-color: #E0E0E0; + border-right-color: #E0E0E0; + border-bottom-color: #E0E0E0; + border-left-color: #E0E0E0; + border-top-style: none; + border-right-style: none; + border-bottom-style: none; + border-left-style: none; + background-color: #FAFAFA; + font-size: 80%; +} +.memTemplParams { + padding: 1px 0px 0px 8px; + margin: 4px; + border-top-width: 1px; + border-right-width: 1px; + border-bottom-width: 1px; + border-left-width: 1px; + border-top-color: #E0E0E0; + border-right-color: #E0E0E0; + border-bottom-color: #E0E0E0; + border-left-color: #E0E0E0; + border-top-style: solid; + border-right-style: none; + border-bottom-style: none; + border-left-style: none; + color: #606060; + background-color: #FAFAFA; + font-size: 80%; +} +.search { color: #003399; + font-weight: bold; +} +FORM.search { + margin-bottom: 0px; + margin-top: 0px; +} +INPUT.search { font-size: 75%; + color: #000080; + font-weight: normal; + background-color: #e8eef2; +} +TD.tiny { font-size: 75%; +} +a { + color: #1A41A8; +} +a:visited { + color: #2A3798; +} +.dirtab { padding: 4px; + border-collapse: collapse; + border: 1px solid #84b0c7; +} +TH.dirtab { background: #e8eef2; + font-weight: bold; +} +HR { height: 1px; + border: none; + border-top: 1px solid black; +} + diff --git a/docs/html/doxygen.png b/docs/html/doxygen.png new file mode 100644 index 0000000..f0a274b Binary files /dev/null and b/docs/html/doxygen.png differ diff --git a/docs/html/functions.html b/docs/html/functions.html new file mode 100644 index 0000000..7870ea7 --- /dev/null +++ b/docs/html/functions.html @@ -0,0 +1,195 @@ + + +pugixml: Class Members + + + + +
+
+
+
+
+ +
+
+ +
+ +

+Here is a list of all documented class members with links to the class documentation for each member: +

+

- a -

+

- b -

+

- c -

+

- d -

+

- e -

+

- f -

+

- i -

+

- l -

+

- n -

+

- o -

+

- p -

+

- r -

+

- s -

+

- t -

+

- v -

+

- w -

+

- x -

+

- ~ -

+
Generated on Wed Feb 21 22:19:50 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/functions_enum.html b/docs/html/functions_enum.html new file mode 100644 index 0000000..5f676d1 --- /dev/null +++ b/docs/html/functions_enum.html @@ -0,0 +1,38 @@ + + +pugixml: Class Members - Enumerations + + + + +
+
+
+
+
+ +
+  +

+

+
Generated on Wed Feb 21 22:19:50 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/functions_eval.html b/docs/html/functions_eval.html new file mode 100644 index 0000000..ae211d9 --- /dev/null +++ b/docs/html/functions_eval.html @@ -0,0 +1,40 @@ + + +pugixml: Class Members - Enumerator + + + + +
+
+
+
+
+ +
+  +

+

+
Generated on Wed Feb 21 22:19:50 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/functions_func.html b/docs/html/functions_func.html new file mode 100644 index 0000000..a68a6c0 --- /dev/null +++ b/docs/html/functions_func.html @@ -0,0 +1,188 @@ + + +pugixml: Class Members - Functions + + + + +
+
+
+
+
+ +
+
+ +
+ +

+  +

+

- a -

+

- b -

+

- c -

+

- d -

+

- e -

+

- f -

+

- i -

+

- l -

+

- n -

+

- o -

+

- p -

+

- r -

+

- s -

+

- t -

+

- v -

+

- w -

+

- x -

+

- ~ -

+
Generated on Wed Feb 21 22:19:50 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/functions_type.html b/docs/html/functions_type.html new file mode 100644 index 0000000..e732be9 --- /dev/null +++ b/docs/html/functions_type.html @@ -0,0 +1,40 @@ + + +pugixml: Class Members - Typedefs + + + + +
+
+
+
+
+ +
+  +

+

+
Generated on Wed Feb 21 22:19:50 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/graph_legend.dot b/docs/html/graph_legend.dot new file mode 100644 index 0000000..5420927 --- /dev/null +++ b/docs/html/graph_legend.dot @@ -0,0 +1,22 @@ +digraph G +{ + edge [fontname="Helvetica",fontsize=10,labelfontname="Helvetica",labelfontsize=10]; + node [fontname="Helvetica",fontsize=10,shape=record]; + Node9 [shape="box",label="Inherited",fontsize=10,height=0.2,width=0.4,fontname="Helvetica",color="black",style="filled" fontcolor="white"]; + Node10 -> Node9 [dir=back,color="midnightblue",fontsize=10,style="solid",fontname="Helvetica"]; + Node10 [shape="box",label="PublicBase",fontsize=10,height=0.2,width=0.4,fontname="Helvetica",color="black",URL="$classPublicBase.html"]; + Node11 -> Node10 [dir=back,color="midnightblue",fontsize=10,style="solid",fontname="Helvetica"]; + Node11 [shape="box",label="Truncated",fontsize=10,height=0.2,width=0.4,fontname="Helvetica",color="red",URL="$classTruncated.html"]; + Node13 -> Node9 [dir=back,color="darkgreen",fontsize=10,style="solid",fontname="Helvetica"]; + Node13 [shape="box",label="ProtectedBase",fontsize=10,height=0.2,width=0.4,fontname="Helvetica",color="black",URL="$classProtectedBase.html"]; + Node14 -> Node9 [dir=back,color="firebrick4",fontsize=10,style="solid",fontname="Helvetica"]; + Node14 [shape="box",label="PrivateBase",fontsize=10,height=0.2,width=0.4,fontname="Helvetica",color="black",URL="$classPrivateBase.html"]; + Node15 -> Node9 [dir=back,color="midnightblue",fontsize=10,style="solid",fontname="Helvetica"]; + Node15 [shape="box",label="Undocumented",fontsize=10,height=0.2,width=0.4,fontname="Helvetica",color="grey75"]; + Node16 -> Node9 [dir=back,color="midnightblue",fontsize=10,style="solid",fontname="Helvetica"]; + Node16 [shape="box",label="Templ< int >",fontsize=10,height=0.2,width=0.4,fontname="Helvetica",color="black",URL="$classTempl.html"]; + Node17 -> Node16 [dir=back,color="orange",fontsize=10,style="dashed",label="< int >",fontname="Helvetica"]; + Node17 [shape="box",label="Templ< T >",fontsize=10,height=0.2,width=0.4,fontname="Helvetica",color="black",URL="$classTempl.html"]; + Node18 -> Node9 [dir=back,color="darkorchid3",fontsize=10,style="dashed",label="m_usedClass",fontname="Helvetica"]; + Node18 [shape="box",label="Used",fontsize=10,height=0.2,width=0.4,fontname="Helvetica",color="black",URL="$classUsed.html"]; +} diff --git a/docs/html/graph_legend.html b/docs/html/graph_legend.html new file mode 100644 index 0000000..a07c58e --- /dev/null +++ b/docs/html/graph_legend.html @@ -0,0 +1,80 @@ + + +pugixml: Graph Legend + + + + +
+
+

Graph Legend

This page explains how to interpret the graphs that are generated by doxygen.

+Consider the following example: 

/*! Invisible class because of truncation */
+class Invisible { };
+
+/*! Truncated class, inheritance relation is hidden */
+class Truncated : public Invisible { };
+
+/* Class not documented with doxygen comments */
+class Undocumented { };
+
+/*! Class that is inherited using public inheritance */
+class PublicBase : public Truncated { };
+
+/*! A template class */
+template<class T> class Templ { };
+
+/*! Class that is inherited using protected inheritance */
+class ProtectedBase { };
+
+/*! Class that is inherited using private inheritance */
+class PrivateBase { };
+
+/*! Class that is used by the Inherited class */
+class Used { };
+
+/*! Super class that inherits a number of other classes */
+class Inherited : public PublicBase,
+                  protected ProtectedBase,
+                  private PrivateBase,
+                  public Undocumented
+                  public Templ<int>
+{
+  private:
+    Used *m_usedClass;
+};
+
If the MAX_DOT_GRAPH_HEIGHT tag in the configuration file is set to 240 this will result in the following graph:

+

+graph_legend.png +
+

+The boxes in the above graph have the following meaning:

+The arrows have the following meaning: +
Generated on Wed Feb 21 22:19:53 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/graph_legend.png b/docs/html/graph_legend.png new file mode 100644 index 0000000..b8cfe42 Binary files /dev/null and b/docs/html/graph_legend.png differ diff --git a/docs/html/hierarchy.html b/docs/html/hierarchy.html new file mode 100644 index 0000000..bcd7f02 --- /dev/null +++ b/docs/html/hierarchy.html @@ -0,0 +1,45 @@ + + +pugixml: Hierarchical Index + + + + +
+
+
+
+

pugixml Class Hierarchy

Go to the graphical class hierarchy +

+This inheritance list is sorted roughly, but not completely, alphabetically:

+
Generated on Wed Feb 21 22:19:50 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/index.html b/docs/html/index.html new file mode 100644 index 0000000..39fb2e8 --- /dev/null +++ b/docs/html/index.html @@ -0,0 +1,20 @@ + + +pugixml: Main Page + + + + +
+
+

pugixml Documentation

+

+

0.3

Generated on Wed Feb 21 22:19:50 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/inherit__graph__0.map b/docs/html/inherit__graph__0.map new file mode 100644 index 0000000..795e91c --- /dev/null +++ b/docs/html/inherit__graph__0.map @@ -0,0 +1,2 @@ +base referer +rect $structpugi_1_1transfer__ownership__tag.html 8,8 202,34 diff --git a/docs/html/inherit__graph__0.md5 b/docs/html/inherit__graph__0.md5 new file mode 100644 index 0000000..dcd3819 --- /dev/null +++ b/docs/html/inherit__graph__0.md5 @@ -0,0 +1 @@ +fa65747bb299b27710c65a261c62df42 \ No newline at end of file diff --git a/docs/html/inherit__graph__0.png b/docs/html/inherit__graph__0.png new file mode 100644 index 0000000..1f839bd Binary files /dev/null and b/docs/html/inherit__graph__0.png differ diff --git a/docs/html/inherit__graph__1.map b/docs/html/inherit__graph__1.map new file mode 100644 index 0000000..8f51b91 --- /dev/null +++ b/docs/html/inherit__graph__1.map @@ -0,0 +1,2 @@ +base referer +rect $classpugi_1_1xml__attribute.html 7,8 141,34 diff --git a/docs/html/inherit__graph__1.md5 b/docs/html/inherit__graph__1.md5 new file mode 100644 index 0000000..584e00e --- /dev/null +++ b/docs/html/inherit__graph__1.md5 @@ -0,0 +1 @@ +8a34c90a8a44150412d4efe4e02856c6 \ No newline at end of file diff --git a/docs/html/inherit__graph__1.png b/docs/html/inherit__graph__1.png new file mode 100644 index 0000000..1984539 Binary files /dev/null and b/docs/html/inherit__graph__1.png differ diff --git a/docs/html/inherit__graph__2.map b/docs/html/inherit__graph__2.map new file mode 100644 index 0000000..c81fa55 --- /dev/null +++ b/docs/html/inherit__graph__2.map @@ -0,0 +1,3 @@ +base referer +rect $classpugi_1_1xml__attribute__iterator.html 121,7 302,34 +rect $classpugi_1_1xml__node__iterator.html 130,58 293,85 diff --git a/docs/html/inherit__graph__2.md5 b/docs/html/inherit__graph__2.md5 new file mode 100644 index 0000000..0ced39c --- /dev/null +++ b/docs/html/inherit__graph__2.md5 @@ -0,0 +1 @@ +0a31bb256f9ea1e428ad381426e2138a \ No newline at end of file diff --git a/docs/html/inherit__graph__2.png b/docs/html/inherit__graph__2.png new file mode 100644 index 0000000..c0f9a3f Binary files /dev/null and b/docs/html/inherit__graph__2.png differ diff --git a/docs/html/inherit__graph__3.map b/docs/html/inherit__graph__3.map new file mode 100644 index 0000000..ac3e60d --- /dev/null +++ b/docs/html/inherit__graph__3.map @@ -0,0 +1,3 @@ +base referer +rect $classpugi_1_1xml__node.html 9,8 121,34 +rect $classpugi_1_1xml__document.html 170,8 314,34 diff --git a/docs/html/inherit__graph__3.md5 b/docs/html/inherit__graph__3.md5 new file mode 100644 index 0000000..0b2554a --- /dev/null +++ b/docs/html/inherit__graph__3.md5 @@ -0,0 +1 @@ +3ac52082f65d390a3aa62f772b82deb2 \ No newline at end of file diff --git a/docs/html/inherit__graph__3.png b/docs/html/inherit__graph__3.png new file mode 100644 index 0000000..4d9a231 Binary files /dev/null and b/docs/html/inherit__graph__3.png differ diff --git a/docs/html/inherit__graph__4.map b/docs/html/inherit__graph__4.map new file mode 100644 index 0000000..a42cb31 --- /dev/null +++ b/docs/html/inherit__graph__4.map @@ -0,0 +1,2 @@ +base referer +rect $classpugi_1_1xml__tree__walker.html 9,8 161,34 diff --git a/docs/html/inherit__graph__4.md5 b/docs/html/inherit__graph__4.md5 new file mode 100644 index 0000000..0ef35dc --- /dev/null +++ b/docs/html/inherit__graph__4.md5 @@ -0,0 +1 @@ +660d4318c9e8103b2831b4787c62da46 \ No newline at end of file diff --git a/docs/html/inherit__graph__4.png b/docs/html/inherit__graph__4.png new file mode 100644 index 0000000..96d08a5 Binary files /dev/null and b/docs/html/inherit__graph__4.png differ diff --git a/docs/html/inherit__graph__5.map b/docs/html/inherit__graph__5.map new file mode 100644 index 0000000..4cda6cd --- /dev/null +++ b/docs/html/inherit__graph__5.map @@ -0,0 +1,2 @@ +base referer +rect $classpugi_1_1xpath__exception.html 137,8 289,34 diff --git a/docs/html/inherit__graph__5.md5 b/docs/html/inherit__graph__5.md5 new file mode 100644 index 0000000..68b862c --- /dev/null +++ b/docs/html/inherit__graph__5.md5 @@ -0,0 +1 @@ +fffb0beaca2cbe6da35b67b995ae9ff1 \ No newline at end of file diff --git a/docs/html/inherit__graph__5.png b/docs/html/inherit__graph__5.png new file mode 100644 index 0000000..f833cf9 Binary files /dev/null and b/docs/html/inherit__graph__5.png differ diff --git a/docs/html/inherit__graph__6.map b/docs/html/inherit__graph__6.map new file mode 100644 index 0000000..a984b26 --- /dev/null +++ b/docs/html/inherit__graph__6.map @@ -0,0 +1,2 @@ +base referer +rect $classpugi_1_1xpath__node.html 7,8 133,34 diff --git a/docs/html/inherit__graph__6.md5 b/docs/html/inherit__graph__6.md5 new file mode 100644 index 0000000..2019dc5 --- /dev/null +++ b/docs/html/inherit__graph__6.md5 @@ -0,0 +1 @@ +0a388cc004e983eab729bc6d5c666cce \ No newline at end of file diff --git a/docs/html/inherit__graph__6.png b/docs/html/inherit__graph__6.png new file mode 100644 index 0000000..1468a8b Binary files /dev/null and b/docs/html/inherit__graph__6.png differ diff --git a/docs/html/inherit__graph__7.map b/docs/html/inherit__graph__7.map new file mode 100644 index 0000000..95b7466 --- /dev/null +++ b/docs/html/inherit__graph__7.map @@ -0,0 +1,2 @@ +base referer +rect $classpugi_1_1xpath__node__set.html 9,8 158,34 diff --git a/docs/html/inherit__graph__7.md5 b/docs/html/inherit__graph__7.md5 new file mode 100644 index 0000000..e3b0507 --- /dev/null +++ b/docs/html/inherit__graph__7.md5 @@ -0,0 +1 @@ +7052cf580394885a252e97fd06476596 \ No newline at end of file diff --git a/docs/html/inherit__graph__7.png b/docs/html/inherit__graph__7.png new file mode 100644 index 0000000..adc2e3a Binary files /dev/null and b/docs/html/inherit__graph__7.png differ diff --git a/docs/html/inherit__graph__8.map b/docs/html/inherit__graph__8.map new file mode 100644 index 0000000..442f8f7 --- /dev/null +++ b/docs/html/inherit__graph__8.map @@ -0,0 +1,2 @@ +base referer +rect $classpugi_1_1xpath__query.html 9,8 137,34 diff --git a/docs/html/inherit__graph__8.md5 b/docs/html/inherit__graph__8.md5 new file mode 100644 index 0000000..563962a --- /dev/null +++ b/docs/html/inherit__graph__8.md5 @@ -0,0 +1 @@ +965d93716ac65e345066d158b1bec3f1 \ No newline at end of file diff --git a/docs/html/inherit__graph__8.png b/docs/html/inherit__graph__8.png new file mode 100644 index 0000000..6bfb42e Binary files /dev/null and b/docs/html/inherit__graph__8.png differ diff --git a/docs/html/inherits.html b/docs/html/inherits.html new file mode 100644 index 0000000..310e5fa --- /dev/null +++ b/docs/html/inherits.html @@ -0,0 +1,66 @@ + + +pugixml: Graphical Class Hierarchy + + + + +
+
+
+
+

pugixml Graphical Class Hierarchy

Go to the textual class hierarchy +

+ + + + + + + + + + +
+ + +
+ + +
+ + + +
+ + + +
+ + +
+ + +
+ + +
+ + +
+ + +
+

Generated on Wed Feb 21 22:19:53 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/namespacemembers.html b/docs/html/namespacemembers.html new file mode 100644 index 0000000..3a874c4 --- /dev/null +++ b/docs/html/namespacemembers.html @@ -0,0 +1,62 @@ + + +pugixml: Class Members + + + + +
+
+
+
+
+ +
+Here is a list of all documented namespace members with links to the namespaces they belong to: +

+

+
Generated on Wed Feb 21 22:19:52 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/namespacemembers_enum.html b/docs/html/namespacemembers_enum.html new file mode 100644 index 0000000..e682fba --- /dev/null +++ b/docs/html/namespacemembers_enum.html @@ -0,0 +1,37 @@ + + +pugixml: Class Members + + + + +
+
+
+
+
+ +
+  +

+

+
Generated on Wed Feb 21 22:19:52 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/namespacemembers_eval.html b/docs/html/namespacemembers_eval.html new file mode 100644 index 0000000..4c55750 --- /dev/null +++ b/docs/html/namespacemembers_eval.html @@ -0,0 +1,43 @@ + + +pugixml: Class Members + + + + +
+
+
+
+
+ +
+  +

+

+
Generated on Wed Feb 21 22:19:52 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/namespacemembers_func.html b/docs/html/namespacemembers_func.html new file mode 100644 index 0000000..1c6e897 --- /dev/null +++ b/docs/html/namespacemembers_func.html @@ -0,0 +1,38 @@ + + +pugixml: Class Members + + + + +
+
+
+
+
+ +
+  +

+

+
Generated on Wed Feb 21 22:19:52 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/namespacemembers_vars.html b/docs/html/namespacemembers_vars.html new file mode 100644 index 0000000..9c6d3e2 --- /dev/null +++ b/docs/html/namespacemembers_vars.html @@ -0,0 +1,52 @@ + + +pugixml: Class Members + + + + +
+
+
+
+
+ +
+  +

+

+
Generated on Wed Feb 21 22:19:52 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/namespacepugi.html b/docs/html/namespacepugi.html new file mode 100644 index 0000000..30b9247 --- /dev/null +++ b/docs/html/namespacepugi.html @@ -0,0 +1,668 @@ + + +pugixml: pugi Namespace Reference + + + + +
+
+
+
+

pugi Namespace Reference

Detailed Description

+The PugiXML Parser namespace. +

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Classes

class  xpath_query
 A class that holds compiled XPath query and allows to evaluate query result. More...
class  xml_attribute
 A light-weight wrapper for manipulating attributes in DOM tree. More...
class  xml_node
 A light-weight wrapper for manipulating nodes in DOM tree. More...
class  xml_node_iterator
 Child node iterator. More...
class  xml_attribute_iterator
 Attribute iterator. More...
class  xml_tree_walker
 Abstract tree walker class. More...
struct  xml_memory_block
struct  transfer_ownership_tag
 Struct used to distinguish parsing with ownership transfer from parsing without it. More...
class  xml_document
 Document class (DOM tree root). More...
class  xpath_exception
 XPath exception class. More...
class  xpath_node
 XPath node class. More...
class  xpath_node_set
 Not necessarily ordered constant collection of XPath nodes. More...

Enumerations

enum  xml_node_type {
+  node_null, +node_document, +node_element, +node_pcdata, +
+  node_cdata, +node_comment, +node_pi +
+ }
 Tree node classification. More...

Functions

std::string as_utf8 (const wchar_t *str)
 Convert utf16 to utf8.
std::wstring as_utf16 (const char *str)
 Convert utf8 to utf16.

Variables

const size_t memory_block_size = 32768
 Memory block size, used for fast allocator.
const unsigned int parse_minimal = 0x0000
 Minimal parsing mode.
const unsigned int parse_pi = 0x0001
 This flag determines if processing instructions (nodes with type node_pi; such nodes have the form of <? target content ?> or <? target ?> in XML) are to be put in DOM tree.
const unsigned int parse_comments = 0x0002
 This flag determines if comments (nodes with type node_comment; such nodes have the form of in XML) are to be put in DOM tree.
const unsigned int parse_cdata = 0x0004
 This flag determines if CDATA sections (nodes with type node_cdata; such nodes have the form of <![CDATA[[content]]> in XML) are to be put in DOM tree.
const unsigned int parse_ws_pcdata = 0x0008
 This flag determines if nodes with PCDATA (regular text) that consist only of whitespace characters are to be put in DOM tree.
const unsigned int parse_escapes = 0x0010
 This flag determines if character and entity references are to be expanded during the parsing process.
const unsigned int parse_eol = 0x0020
 This flag determines if EOL handling (that is, replacing sequences 0x0d 0x0a by a single 0x0a character, and replacing all standalone 0x0d characters by 0x0a) is to be performed on input data (that is, comments contents, PCDATA/CDATA contents and attribute values).
const unsigned int parse_wnorm_attribute = 0x0040
 This flag determines if attribute value normalization should be performed for all attributes, assuming that their type is not CDATA.
const unsigned int parse_wconv_attribute = 0x0080
 This flag determines if attribute value normalization should be performed for all attributes, assuming that their type is CDATA.
const unsigned int parse_default = parse_cdata | parse_escapes | parse_wconv_attribute | parse_eol
 This is the default set of flags.
const unsigned int format_indent = 0x01
 Indent the nodes that are written to output stream with as many indentation strings as deep the node is in DOM tree.
const unsigned int format_utf8 = 0x02
 This flag determines how the non-printable symbols are written to output stream - they are either considered UTF-8 and are written as UTF-8 character, escaped with &#.
const unsigned int format_write_bom = 0x04
 This flag determines if UTF-8 BOM is to be written to output stream.
const unsigned int format_raw = 0x08
 If this flag is on, no indentation is performed and no line breaks are written to output file.
const unsigned int format_default = format_indent | format_utf8
 This is the default set of formatting flags.
+

Enumeration Type Documentation

+

+ + + + +
+ + + + +
enum pugi::xml_node_type
+
+ + + + + +
+   + + +

+Tree node classification. +

+

Enumerator:
+ + + + + + + + +
node_null  +Undifferentiated entity.
node_document  +A document tree's absolute root.
node_element  +E.g. '<...>'.
node_pcdata  +E.g. '>...<'.
node_cdata  +E.g. '<![CDATA[...]]>'.
node_comment  +E.g. ''.
node_pi  +E.g. '<?...?>'.
+
+
+

Function Documentation

+

+ + + + +
+ + + + + + + + + +
std::string pugi::as_utf8 ( const wchar_t *  str  ) 
+
+ + + + + +
+   + + +

+Convert utf16 to utf8. +

+

Parameters:
+ + +
str - input UTF16 string
+
+
Returns:
output UTF8 string
+
+

+ + + + +
+ + + + + + + + + +
std::wstring pugi::as_utf16 ( const char *  str  ) 
+
+ + + + + +
+   + + +

+Convert utf8 to utf16. +

+

Parameters:
+ + +
str - input UTF8 string
+
+
Returns:
output UTF16 string
+
+

Variable Documentation

+

+ + + + +
+ + + + +
const size_t pugi::memory_block_size = 32768
+
+ + + + + +
+   + + +

+Memory block size, used for fast allocator. +

+Memory for DOM tree is allocated in blocks of memory_block_size + 4. This value affects size of xml_memory class.

+

+ + + + +
+ + + + +
const unsigned int pugi::parse_minimal = 0x0000
+
+ + + + + +
+   + + +

+Minimal parsing mode. +

+Equivalent to turning all other flags off. This set of flags means that pugixml does not add pi/cdata sections or comments to DOM tree and does not perform any conversions for input data, meaning fastest parsing.

+

+ + + + +
+ + + + +
const unsigned int pugi::parse_pi = 0x0001
+
+ + + + + +
+   + + +

+This flag determines if processing instructions (nodes with type node_pi; such nodes have the form of <? target content ?> or <? target ?> in XML) are to be put in DOM tree. +

+If this flag is off, they are not put in the tree, but are still parsed and checked for correctness.

+The corresponding node in DOM tree will have type node_pi, name "target" and value "content", if any.

+Note that <?xml ...?> (document declaration) is not considered to be a PI.

+This flag is off by default.

+

+ + + + +
+ + + + +
const unsigned int pugi::parse_comments = 0x0002
+
+ + + + + +
+   + + +

+This flag determines if comments (nodes with type node_comment; such nodes have the form of in XML) are to be put in DOM tree. +

+If this flag is off, they are not put in the tree, but are still parsed and checked for correctness.

+The corresponding node in DOM tree will have type node_comment, empty name and value "content".

+This flag is off by default.

+

+ + + + +
+ + + + +
const unsigned int pugi::parse_cdata = 0x0004
+
+ + + + + +
+   + + +

+This flag determines if CDATA sections (nodes with type node_cdata; such nodes have the form of <![CDATA[[content]]> in XML) are to be put in DOM tree. +

+If this flag is off, they are not put in the tree, but are still parsed and checked for correctness.

+The corresponding node in DOM tree will have type node_cdata, empty name and value "content".

+This flag is on by default.

+

+ + + + +
+ + + + +
const unsigned int pugi::parse_ws_pcdata = 0x0008
+
+ + + + + +
+   + + +

+This flag determines if nodes with PCDATA (regular text) that consist only of whitespace characters are to be put in DOM tree. +

+Often whitespace-only data is not significant for the application, and the cost of allocating and storing such nodes (both memory and speed-wise) can be significant. For example, after parsing XML string "<node> <a/> </node>", <node> element will have 3 children when parse_ws_pcdata is set (child with type node_pcdata and value=" ", child with type node_element and name "a", and another child with type node_pcdata and value=" "), and only 1 child when parse_ws_pcdata is not set.

+This flag is off by default.

+

+ + + + +
+ + + + +
const unsigned int pugi::parse_escapes = 0x0010
+
+ + + + + +
+   + + +

+This flag determines if character and entity references are to be expanded during the parsing process. +

+Character references are &#...; or &x...; (... is Unicode numeric representation of character in either decimal (&#...;) or hexadecimal (&x...;) form), entity references are &...; Note that as pugixml does not handle DTD, the only allowed entities are predefined ones - &lt;, &gt;, &amp;, &apos; and &quot;. If character/entity reference can not be expanded, it is leaved as is, so you can do additional processing later. Reference expansion is performed in attribute values and PCDATA content.

+This flag is on by default.

+

+ + + + +
+ + + + +
const unsigned int pugi::parse_eol = 0x0020
+
+ + + + + +
+   + + +

+This flag determines if EOL handling (that is, replacing sequences 0x0d 0x0a by a single 0x0a character, and replacing all standalone 0x0d characters by 0x0a) is to be performed on input data (that is, comments contents, PCDATA/CDATA contents and attribute values). +

+This flag is on by default.

+

+ + + + +
+ + + + +
const unsigned int pugi::parse_wnorm_attribute = 0x0040
+
+ + + + + +
+   + + +

+This flag determines if attribute value normalization should be performed for all attributes, assuming that their type is not CDATA. +

+This means, that: 1. Whitespace characters (new line, tab and space) are replaced with space (' ') 2. Afterwards sequences of spaces are replaced with a single space 3. Leading/trailing whitespace characters are trimmed

+This flag is off by default.

+

+ + + + +
+ + + + +
const unsigned int pugi::parse_wconv_attribute = 0x0080
+
+ + + + + +
+   + + +

+This flag determines if attribute value normalization should be performed for all attributes, assuming that their type is CDATA. +

+This means, that whitespace characters (new line, tab and space) are replaced with space (' '). Note, that the actions performed while this flag is on are also performed if parse_wnorm_attribute is on, so this flag has no effect if parse_wnorm_attribute flag is set.

+This flag is on by default.

+

+ + + + +
+ + + + +
const unsigned int pugi::parse_default = parse_cdata | parse_escapes | parse_wconv_attribute | parse_eol
+
+ + + + + +
+   + + +

+This is the default set of flags. +

+It includes parsing CDATA sections (comments/PIs are not parsed), performing character and entity reference expansion, replacing whitespace characters with spaces in attribute values and performing EOL handling. Note, that PCDATA sections consisting only of whitespace characters are not parsed (by default) for performance reasons.

+

+ + + + +
+ + + + +
const unsigned int pugi::format_indent = 0x01
+
+ + + + + +
+   + + +

+Indent the nodes that are written to output stream with as many indentation strings as deep the node is in DOM tree. +

+This flag is on by default.

+

+ + + + +
+ + + + +
const unsigned int pugi::format_utf8 = 0x02
+
+ + + + + +
+   + + +

+This flag determines how the non-printable symbols are written to output stream - they are either considered UTF-8 and are written as UTF-8 character, escaped with &#. +

+..;, or they are considered to be ASCII and each ASCII character is escaped separately.

+This flag is on by default.

+

+ + + + +
+ + + + +
const unsigned int pugi::format_write_bom = 0x04
+
+ + + + + +
+   + + +

+This flag determines if UTF-8 BOM is to be written to output stream. +

+This flag is off by default.

+

+ + + + +
+ + + + +
const unsigned int pugi::format_raw = 0x08
+
+ + + + + +
+   + + +

+If this flag is on, no indentation is performed and no line breaks are written to output file. +

+This means that the data is written to output stream as is.

+This flag is off by default.

+

+ + + + +
+ + + + +
const unsigned int pugi::format_default = format_indent | format_utf8
+
+ + + + + +
+   + + +

+This is the default set of formatting flags. +

+It includes indenting nodes depending on their depth in DOM tree and considering input data to be UTF-8.

+

Generated on Wed Feb 21 22:19:50 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/namespaces.html b/docs/html/namespaces.html new file mode 100644 index 0000000..b52fc10 --- /dev/null +++ b/docs/html/namespaces.html @@ -0,0 +1,26 @@ + + +pugixml: Namespace Index + + + + +
+
+
+
+

pugixml Namespace List

Here is a list of all documented namespaces with brief descriptions: + +
pugiThe PugiXML Parser namespace
+
Generated on Wed Feb 21 22:19:50 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/structpugi_1_1transfer__ownership__tag.html b/docs/html/structpugi_1_1transfer__ownership__tag.html new file mode 100644 index 0000000..aea2270 --- /dev/null +++ b/docs/html/structpugi_1_1transfer__ownership__tag.html @@ -0,0 +1,35 @@ + + +pugixml: pugi::transfer_ownership_tag Struct Reference + + + + +
+
+
+
+
+pugi::transfer_ownership_tag
+

pugi::transfer_ownership_tag Struct Reference

Detailed Description

+Struct used to distinguish parsing with ownership transfer from parsing without it. +

+

See also:
xml_document::parse
+ +

+ + +
+

Generated on Wed Feb 21 22:19:51 2007 for pugixml by  + +doxygen 1.4.6-NO
+ + diff --git a/docs/html/tab_b.gif b/docs/html/tab_b.gif new file mode 100644 index 0000000..0d62348 Binary files /dev/null and b/docs/html/tab_b.gif differ diff --git a/docs/html/tab_l.gif b/docs/html/tab_l.gif new file mode 100644 index 0000000..9b1e633 Binary files /dev/null and b/docs/html/tab_l.gif differ diff --git a/docs/html/tab_r.gif b/docs/html/tab_r.gif new file mode 100644 index 0000000..ce9dd9f Binary files /dev/null and b/docs/html/tab_r.gif differ diff --git a/docs/html/tabs.css b/docs/html/tabs.css new file mode 100644 index 0000000..a61552a --- /dev/null +++ b/docs/html/tabs.css @@ -0,0 +1,102 @@ +/* tabs styles, based on http://www.alistapart.com/articles/slidingdoors */ + +DIV.tabs +{ + float : left; + width : 100%; + background : url("tab_b.gif") repeat-x bottom; + margin-bottom : 4px; +} + +DIV.tabs UL +{ + margin : 0px; + padding-left : 10px; + list-style : none; +} + +DIV.tabs LI, DIV.tabs FORM +{ + display : inline; + margin : 0px; + padding : 0px; +} + +DIV.tabs FORM +{ + float : right; +} + +DIV.tabs A +{ + float : left; + background : url("tab_r.gif") no-repeat right top; + border-bottom : 1px solid #84B0C7; + font-size : x-small; + font-weight : bold; + text-decoration : none; +} + +DIV.tabs A:hover +{ + background-position: 100% -150px; +} + +DIV.tabs A:link, DIV.tabs A:visited, +DIV.tabs A:active, DIV.tabs A:hover +{ + color: #1A419D; +} + +DIV.tabs SPAN +{ + float : left; + display : block; + background : url("tab_l.gif") no-repeat left top; + padding : 5px 9px; + white-space : nowrap; +} + +DIV.tabs INPUT +{ + float : right; + display : inline; + font-size : 1em; +} + +DIV.tabs TD +{ + font-size : x-small; + font-weight : bold; + text-decoration : none; +} + + + +/* Commented Backslash Hack hides rule from IE5-Mac \*/ +DIV.tabs SPAN {float : none;} +/* End IE5-Mac hack */ + +DIV.tabs A:hover SPAN +{ + background-position: 0% -150px; +} + +DIV.tabs LI#current A +{ + background-position: 100% -150px; + border-width : 0px; +} + +DIV.tabs LI#current SPAN +{ + background-position: 0% -150px; + padding-bottom : 6px; +} + +DIV.nav +{ + background : none; + border : none; + border-bottom : 1px solid #84B0C7; +} diff --git a/docs/index.html b/docs/index.html index c843bdb..7c8392f 100644 --- a/docs/index.html +++ b/docs/index.html @@ -15,17 +15,8 @@

Contents

Introduction
-
Document Object Model
-
Documentation -
Introduction
-
xml_parser class
-
xml_node class
-
xml_attribute class
-
Iterators
-
Miscellaneous
-
Lifetime issues and memory management
- -
Parsing process
+
Quick start
+
Reference
W3C compliance
Comparison with existing parsers
FAQ
@@ -43,7 +34,7 @@

pugixml is just another XML parser. This is a successor to pugxml (well, to be honest, the only part that is left as is is wildcard matching code; the rest was either heavily refactored or rewritten -from scratch). The main features (call it USP) are:

+from scratch). The main features are:

@@ -84,10 +75,8 @@ ok with DOM - it should not be a problem, because the overall memory consumption you'll need a contiguous chunk of memory, which can be a problem).
  • lack of validation, DTD processing, XML namespaces, proper handling of encoding. If you need those - go take MSXML or XercesC or anything like that.
    • -
  • lack of XPath & UTF-16/32 parsing. These are not implemented for now, but they are the features -for the next release.
    • -
  • immutability of DOM tree. It's constant. You can't change it. There are good reasons for prohibiting -that, though it is a thing that will likely be in the next release.
    • +
  • lack of UTF-16/32 parsing. This is not implemented for now, but this is the features for the next +release.
    • @@ -101,803 +90,345 @@ an XML file were measured.
    - -

    Document Object Model

    +     +

    Quick start

    -

    pugixml is a DOM-based parser. This means, that the XML document is converted to a tree. -Each XML tag is converted to a node in DOM tree. If a tag is contained in some other tag, its node -is a child to the outer tag's one. Comments, CDATA sections and PIs (Processing Instructions) also are -transformed into tree nodes, as is the standalone text. Each node has its type.

    +

    Here there is a small collection of code snippets to help the reader begin using pugixml.

    -

    Here is an example of an XML document: +

    For everything you can do with pugixml, you need a document. There are several ways to obtain it:

    -
    -<?xml version="1.0"?>
-<mesh name="mesh_root">
-    <!-- here is a mesh node -->
-    some text
-    <![CDATA[[someothertext]]>
-    some more text
-    <node attr1="value1" />
-    <node attr1="value2">
-        <?TARGET somedata?>
-        <innernode/>
-    </node>
-</mesh>
-
    - -It gets converted to the following tree (note, that with some parsing options comments, PIs and CDATA -sections are not stored in the tree, and with some options there are also nodes with whitespaces -and the contents of PCDATA sections is a bit different (with trailing/leading whitespaces). So generally -the resulting DOM tree depends on the parsing options):

    - -

    - -

    The parent-children relations are shown with lines. Some nodes have previous and next siblings -(for example, the next sibling for node_comment node is node_pcdata with value "some text", and the -previous sibling for node_element with name "mesh" is node_pi with target "xml" (target for PI nodes -is stored in the node name)).

    -
    - -     -

    Documentation

    - -     -

    Introduction

    - -

    pugixml is a library for parsing XML files, which means that you give it XML data some way, -and it gives you the DOM tree and the ways to traverse it and to get some useful information from it. -The library source consist of two files, the header pugixml.hpp, and the source code pugixml.cpp. -You can either compile cpp file in your project, or build a static library (or perhaps even a DLL), -or make the whole code use inline linkage and make one big file (as it was done in pugxml). -All library classes reside in namespace pugi, so you can either use fully qualified -names (pugi::xml_node) or write a using declaration (using namespace pugi;, using -pugi::xml_node) and use plain names. All classes have the xml_ prefix.

    - -

    By default it's supposed that you compile the source file with your project (add it into your -project, or add relevant entry in your Makefile, or do whatever you need to do with your compilation -environment). The library is written in standard-conformant C++ and was tested on win32 platform -(MSVC 7.1 (2003), MSVC 8.0 (2005)).

    - -     -

    xml_parser class

    - -

    xml_parser class is the core of parsing process; you initiate parsing with it, you get DOM -tree from it, the nodes and attributes are stored in it. You have two ways to load a file: either -provide a string with XML-data (it has to be null-terminated, and it will be modified during parsing -process, so it can not be a piece of read-only memory), or with an std::istream object (any input -stream, like std::ifstream, std::istringstream, etc.) - in this case the parser will allocate -the necessary amount of memory (equivalent to stream's size) and read everything from the stream.

    - -

    The functions for parsing are: -

    -
    -
    
-        void parse(std::istream& stream, unsigned int optmsk = parse_noset);
    -
    This function will create a buffer with the size equal to that of provided stream, -read the chunk of data from the stream and parse it with provided options (optmsk). -The stream does not have to persist after the call to the function, the lifetime of internal buffer -with stream's data is managed by pugixml. -
    - -
     
    -
    -
    
-        char* parse(char* xmlstr, unsigned int optmsk = parse_noset);
-
    -
    This function parses the provided string with provided options, and returns the position where the -parsing stopped (do not expect, that parsing will stop on every error, or on most of them - as I've -said, pugixml is error ignorant). The input string is modified. The string must persist for the -lifetime of the parser. - -
     
    -
    -
    
-        char* parse(const ownership_transfer_tag&, char* xmlstr, unsigned int optmsk = parse_noset);
-
    -
    This function parses the provided string with provided options, and returns the position where the -parsing stopped (do not expect, that parsing will stop on every error, or on most of them - as I've -said, pugixml is error ignorant). The input string is modified. The string's ownership is -managed by parser (string's memory is freed automatically when parser's destructor is called). -
     
    -
    -
    
-        xml_parser(std::istream& stream, unsigned int optmsk = parse_default);
    -
    Just a convenience ctor, that calls the corresponding parse() function.
    - -
     
    -
    -
    
-        xml_parser(char* xmlstr, unsigned int optmsk = parse_default);
    -
    Just a convenience ctor, that calls the corresponding parse() function.
    - -
     
    -
    
-        xml_parser(const ownership_transfer_tag&, char* xmlstr, unsigned int optmsk = parse_default);
    -
    Just a convenience ctor, that calls the corresponding parse() function.
    - -
    - -

    If you want to provide XML data after the creation of the parser, use the default ctor. Otherwise -you are free to use either parsing ctors or default ctor and later - parsing function.

    - -

    After parsing an XML file, you'll get a DOM tree. To get access to it (or, more precisely, to its -root), call either document() function or cast xml_parser object to xml_node by -using the following functions:

    - -
    
-        operator xml_node() const;
-        xml_node document() const;
-
    - -

    Ok, easy part is behind - now let's dive into parsing options. There is a variety of them, and you -must choose them wisely to get the needed results and the best speed/least memory overhead. At first, -there are flags that determine which parts of the document will be put into DOM tree, and which will -be just skipped:

    - -
      -
    • If parse_pi is on, then processing instructions (<? ... ?>) are put into DOM -tree (with node type node_pi) otherwise they are discarded. Note that for now the prolog -(<?xml ... ?>) is parsed as a processing instruction. -
      Default value: off -
      In W3C mode: on
      • -
    • If parse_comments is on, then comments (<!-- ... -->) are put into DOM -tree (with node type node_comment) otherwise they are discarded. -
      Default value: off -
      In W3C mode: on
      • -
    • If parse_cdata is on, then the content of CDATA section (<![CDATA[[ ... ]]>) -is put into DOM tree (with node type node_cdata) otherwise it is discarded. -
      Default value: on -
      In W3C mode: on
      • -
    • If parse_ws_pcdata is off, then the content of PCDATA section (it's the plain text -in the node, like in <some_tag>Hello!</some_tag>) is discarded if it consists only -of space-like characters (spaces, tabs and newlines). -
      Default value: off -
      In W3C mode: on
      • -
    • If parse_ext_pcdata is off, then the content of PCDATA section is discarded if it belongs -to root (document) node, that is it does not have a parent tag. -
      Default value: on -
      In W3C mode: off
      • -
    - -

    Then there are flags that determine how the processing of the retrieved data is done. There are -several reasons for these flags, mainly: -

      -
    • parsing speed. The less processing - the more speed.
      • -
    • data fetching comfort. Sometimes you're ok with messed linefeeds, sometimes you're not. Sometimes -you want your PCDATA trimmed, sometimes you do not. Sometimes you want your attribute values normalized, -sometimes you do not. Some of these are normally specified in DOCTYPE, though... -
    • ...parser is not DOCTYPE aware (and will never be), so you need a way to set those properties - -if not on per-node basis, then on per-document
      • -
    -So, these are the processing flags: -

    - -
      -
    • If parse_escapes is on, then the character reference expansion is done for PCDATA content -and for attribute values (replacing <lt; with <, &#4c; with L, etc.). -
      Default value: on -
      In W3C mode: on
      • -
    • If parse_wnorm_attribute is on, then the whitespace normalisation is done for attribute -values (this includes replacing any space-like character by a space character, converting sequences of -spaces into a single space and trimming of leading/trailing spaces) -
      Default value: off -
      In W3C mode: off
      • -
    • If parse_wconv_attribute is on, then the whitespace conversion is done for attribute -values (this is a subset of whitespace normalization, and includes only replacing space-like characters -with spaces). If parse_wnorm_attribute is on, this flag has no effect. -
      Default value: on -
      In W3C mode: on
      • -
    • If parse_eol is on, then the end-of-line handling is done for PCDATA/CDATA content and for -attribute values (this includes converting any pair of 0x0d 0x0a characters to a single 0x0a and -converting any standalone 0x0d to 0x0a). -
      Default value: on -
      In W3C mode: on
      • -
    - -

    Finally, there are two more flags, that indicate closing tag parsing. When pugixml meets a -close tags, there are three ways: -

      -
    • check that the tag name matches the opening tag, return an error if it does not. This is a -standard-compliant way, is controlled by parse_check_end_tags flag, which is on in W3C mode
      • -
    • try to find the corresponding tag name (so that <foo> <bar> </foo> will be parsed -correctly). This is controlled by parse_match_end_tags, which is on by default
      • -
    • just treat the tag as a closing tag for the node (so that <foo> ... </bar> will -be parsed as <foo> ... </foo>). This is the fastest way, and this is what pugxml -is doing, but it can corrupt your DOM tree. This way is chosen if both parse_check_end_tags and -parse_match_end_tags are off. -
    -Note, that these 2 flags are mutually exclusive. -

    - -

    Did I say finally? Ok, so finally there are some helper flags, or better groups of flags. -These are: -

      -
    • parse_minimal - no flag is set (this also means the fastest parsing)
      • -
    • parse_default - default set of flags
      • -
    • parse_noset - use the current parser options (see below)
      • -
    • parse_w3c - use the W3C compliance mode
      • -
    -

    - -

    A couple of words on flag usage. The parsing options are just a set of bits, with each bit corresponding -to one flag. You can turn the flag on by OR-ing the options value with this flag's constant: -

    -	parse_w3c | parse_wnorm_attribute
-
    -or turn the flag off by AND-ing the options value with the NEGation of this flag's constant: -
    -	parse_w3c & ~parse_comments
-
    -You can access the current options of parser by options() method: -
    
-        unsigned int options() const;
-        unsigned int options(unsigned int optmsk);
-
    -(the latter one returns previous options). These options are used when parse_noset flag set is -passed to parse() functions (which is the default value of corresponding parameter). -

    - -     -

    xml_node class

    - -

    If xml_parser is a heart of constructing a DOM tree from file, xml_node is a heart -of processing the tree. This is a simple wrapper, so it's small (4/8 bytes, depending on the size of -pointer), you're free to copy it and it does not own anything. I'll continue with a list of methods -with their description, with one note in advance. Some functions, that do something according to a -string-like parameter, have a pair with a suffix _w. The _w suffix tells, that this -function is doing a wildcard matching, instead of simple string comparison. You're free to use wildcards -* (that is equal to any sequence of characters (possibly empty)), ? (that is equal to -any character) and character sets ([Abc] means 'any symbol of A, b and c', [A-Z4] means -'any symbol from A to Z, or 4', [!0-9] means 'any symbol, that is not a digit'). So the wildcard -?ell_[0-9][0-9]_* will match strings like 'cell_23_xref', 'hell_00_', but will not match the -strings like 'ell_23_xref', 'cell_0_x' or 'cell_0a_x'.

    - -
    
-        /// Access iterators for this node's collection of child nodes.
-        iterator begin() const;
-        iterator end() const;
-        
-        /// Access iterators for this node's collection of child nodes (same as begin/end).
-        iterator children_begin() const;
-        iterator children_end() const;
-    
-        /// Access iterators for this node's collection of attributes.
-        attribute_iterator attributes_begin() const;
-        attribute_iterator attributes_end() const;
-
-        /// Access iterators for this node's collection of siblings.
-        iterator siblings_begin() const;
-        iterator siblings_end() const;
-
    - -

    Functions, returning the iterators to walk through children/siblings/attributes. More on that in -Iterators section.

    - -
    
-        operator unspecified_bool_type() const;
-
    - -

    This is a safe bool-like conversion operator. You can check node's validity (if (xml_node), - if (!xml_node), if (node1 && node2 && !node3 && cond1 && ...) - you get the idea) with -it. -

    - -
    
-        bool operator==(const xml_node& r) const;
-        bool operator!=(const xml_node& r) const;
-        bool operator<(const xml_node& r) const;
-        bool operator>(const xml_node& r) const;
-        bool operator<=(const xml_node& r) const;
-        bool operator>=(const xml_node& r) const;
-
    - -

    Comparison operators

    - -
    
-        bool empty() const;
-
    - -

    if (node.empty()) is equivalent to if (!node)

    - -
    
-        xml_node_type type() const;
-        const char* name() const;
-        const char* value() const;
-
    - -

    Access node's properties (type, name and value). If there is no name/value, the corresponding functions -return "" - they never return NULL.

    - -
    
-        xml_node child(const char* name) const;
-        xml_node child_w(const char* name) const;
-
    - -

    Get a child node with specified name, or xml_node() (this is an invalid node) if nothing is -found

    - -
    
-        xml_attribute attribute(const char* name) const;
-        xml_attribute attribute_w(const char* name) const;
-
    - -

    Get an attribute with specified name, or xml_attribute() (this is an invalid attribute) if -nothing is found

    - -
    
-        xml_node sibling(const char* name) const;
-        xml_node sibling_w(const char* name) const;
-
    - -

    Get a node's sibling with specified name, or xml_node() if nothing is found.
    -node.sibling(name) is equivalent to node.parent().child(name).

    - -
    
-        xml_node next_sibling(const char* name) const;
-        xml_node next_sibling_w(const char* name) const;
-        xml_node next_sibling() const;
-
    - -

    These functions get the next sibling, that is, one of the siblings of that node, that is to the -right. next_sibling() just returns the right brother of the node (or xml_node()), -the two other functions are searching for the sibling with the given name

    - -
    
-        xml_node previous_sibling(const char* name) const;
-        xml_node previous_sibling_w(const char* name) const;
-        xml_node previous_sibling() const;
-
    - -

    These functions do exactly the same as next_sibling ones, with the exception that they -search for the left siblings.

    - -
    
-        xml_node parent() const;
-
    - -

    Get a parent node. The parent node for the root one (the document) is considered to be the document -itself.

    - -
    
-        const char* child_value() const;
-
    - -

    Look for the first node of type node_pcdata or node_cdata among the -children of the current node and return its contents (or "" if nothing is found)

    - -
    
-    const char* child_value(const char* name) const;
-
    +#include <fstream> +#include <iostream> -

    This is the convenient way of looking into child's child value - that is, node.child_value(name) is equivalent to node.child(name).child_value().

    +#include "pugixml.hpp" -
    
-    const char* child_value_w(const char* name) const;
-
    +using namespace std; +using namespace pugi; -

    This is the convenient way of looking into child's child value - that is, node.child_value_w(name) is equivalent to node.child_w(name).child_value().

    +int main() +{ + // Several ways to get XML document -
    
-        xml_attribute first_attribute() const;
-        xml_attribute last_attribute() const;
-
    + { + // Load from string + xml_document doc; -

    These functions get the first and last attributes of the node (or xml_attribute() if the node -has no attributes).

    + cout << doc.load("<sample-xml>some text <b>in bold</b> here</sample-xml>") << endl; + } -
    
-        xml_node first_child() const;
-        xml_node last_child() const;
-
    + { + // Load from file + xml_document doc; -

    These functions get the first and last children of the node (or xml_node() if the node has -no children).

    + cout << doc.load_file("sample.xml") << endl; + } -
    
-        template <typename OutputIterator> void all_elements_by_name(const char* name, OutputIterator it) const;
-        template <typename OutputIterator> void all_elements_by_name_w(const char* name, OutputIterator it) const;
-
    + { + // Load from any input stream (STL) + xml_document doc; -

    Get all elements with the specified name in the subtree (depth-first search) and return them with -the help of output iterator (i.e. std::back_inserter)

    + std::ifstream in("sample.xml"); + cout << doc.load(in) << endl; + } -
    
-        template <typename Predicate> xml_attribute find_attribute(Predicate pred) const;
-        template <typename Predicate> xml_node find_child(Predicate pred) const;
-        template <typename Predicate> xml_node find_element(Predicate pred) const;
-
    + { + // More advanced: parse the specified string without duplicating it + xml_document doc; -

    Find attribute, child or a node in the subtree (find_element - depth-first search) with the help -of the given predicate. Predicate should behave like a function which accepts a xml_node or -xml_attribute (for find_attribute) parameter and returns bool. The first entity for which -the predicate returned true is returned. If predicate returned false for all entities, xml_node() -or xml_attribute() is returned.

    + char* s = new char[100]; + strcpy(s, "<sample-xml>some text <b>in bold</b> here</sample-xml>"); + cout << doc.parse(transfer_ownership_tag(), s) << endl; + } -
    
-        xml_node first_element(const char* name) const;
-        xml_node first_element_w(const char* name) const;
+    {
+        // Even more advanced: assume manual lifetime control
+        xml_document doc;
 
-        xml_node first_element_by_value(const char* name, const char* value) const;
-        xml_node first_element_by_value_w(const char* name, const char* value) const;
+        char* s = new char[100];
+        strcpy(s, "<sample-xml>some text <b>in bold</b> here</sample-xml>");
+        cout << doc.parse(transfer_ownership_tag(), s) << endl;
 
-        xml_node first_element_by_attribute(const char* name, const char* attr_name, const char* attr_value) const;
-        xml_node first_element_by_attribute_w(const char* name, const char* attr_name, const char* attr_value) const;
+        delete[] s; // <-- after this point, all string contents of document is invalid!
+    }
 
-        xml_node first_element_by_attribute(const char* attr_name, const char* attr_value) const;
-        xml_node first_element_by_attribute_w(const char* attr_name, const char* attr_value) const;
-
    + { + // Or just create document from code? + xml_document doc; -

    Find the first node (depth-first search), which corresponds to the given criteria (i.e. either has -a matching name, or a matching value, or has an attribute with given name/value, or has an attribute -and has a matching name). Note that _w versions treat all parameters as wildcards.

    + // add nodes to document (see next samples) + } +} +_Winnie C++ Colorizer -
    
-        xml_node first_node(xml_node_type type) const;
-
    +

    This sample should print a row of 1, meaning that all load/parse functions returned true (of course, if sample.xml does not exist or is malformed, there will be 0's)

    -

    Return a first node (depth-first search) with a given type, or xml_node().

    +

    Once you have your document, there are several ways to extract data from it.

    
-        std::string path(char delimiter = '/') const;
-
    +#include <iostream> -

    Get a path of the node (i.e. the string of names of the nodes on the path from the DOM tree root -to the node, separated with delimiter (/ by default).

    +#include "pugixml.hpp" -
    
-        xml_node first_element_by_path(const char* path, char delimiter = '/') const;
-
    +using namespace std; +using namespace pugi; -

    Get the first element that has the following path. The path can be absolute (beginning with delimiter) or -relative, '..' means 'up-level' (so if we are at the path mesh/fragment/geometry/stream, ../.. -will lead us to mesh/fragment, and /mesh will lead us to mesh).

    +struct bookstore_traverser: public xml_tree_walker +{ + virtual bool for_each(xml_node& n) + { + for (int i = 0; i < depth(); ++i) cout << " "; // indentation -
    
-        bool traverse(xml_tree_walker& walker) const;
-
    + if (n.type() == node_element) cout << n.name() << endl; + else cout << n.value() << endl; -

    Traverse the subtree (beginning with current node) with the walker, return the result. See -Miscellaneous section for details.

    + return true; // continue traversal + } +}; - -

    xml_attribute class

    +int main() +{ + xml_document doc; + doc.load("<bookstore><book title='ShaderX'><price>3</price></book><book title='GPU Gems'><price>4</price></book></bookstore>"); -

    Like xml_node, xml_attribute is a simple wrapper of the node's attribute.

    + // If you want to iterate through nodes... -
    
-        bool operator==(const xml_attribute& r) const;
-        bool operator!=(const xml_attribute& r) const;
-        bool operator<(const xml_attribute& r) const;
-        bool operator>(const xml_attribute& r) const;
-        bool operator<=(const xml_attribute& r) const;
-        bool operator>=(const xml_attribute& r) const;
-
    + { + // Get a bookstore node + xml_node bookstore = doc.child("bookstore"); -

    Comparison operators.

    + // Iterate through books + for (xml_node book = bookstore.child("book"); book; book = book.next_sibling("book")) + { + cout << "Book " << book.attribute("title").value() << ", price " << book.child("price").first_child().value() << endl; + } -
    
-        operator unspecified_bool_type() const;
-
    + // Output: + // Book ShaderX, price 3 + // Book GPU Gems, price 4 + } -

    Safe bool conversion - like in xml_node, use this to check for validity.

    + { + // Alternative way to get a bookstore node (wildcards) + xml_node bookstore = doc.child_w("*[sS]tore"); // this will select bookstore, anyStore, Store, etc. -
    
-        bool empty() const;
-
    + // Iterate through books with STL compatible iterators + for (xml_node::iterator it = bookstore.begin(); it != bookstore.end(); ++it) + { + // Note the use of helper function child_value() + cout << "Book " << it->attribute("title").value() << ", price " << it->child_value("price") << endl; + } + + // Output: + // Book ShaderX, price 3 + // Book GPU Gems, price 4 + } -

    Like with xml_node, if (attr.empty()) is equivalent to if (!attr). -

    + { + // You can also traverse the whole tree (or a subtree) + bookstore_traverser t; -
    
-        xml_attribute next_attribute() const;
-        xml_attribute previous_attribute() const;
-
    + doc.traverse(t); + + // Output: + // bookstore + // book + // price + // 3 + // book + // price + // 4 + + doc.first_child().traverse(t); + + // Output: + // book + // price + // 3 + // book + // price + // 4 + } -

    Get the next/previous attribute of the node, that owns the current attribute. Return xml_attribute() -if no such attribute is found.

    + // If you want a distinct node... -
    
-        const char* name() const;
-        const char* value() const;
-
    + { + // You can specify the way to it through child() functions + cout << doc.child("bookstore").child("book").next_sibling().attribute("title").value() << endl; -

    Get the name and value of the attribute. These methods never return NULL - they return "" instead.

    + // Output: + // GPU Gems + + // You can use a sometimes convenient path function + cout << doc.first_element_by_path("bookstore/book/price").child_value() << endl; + + // Output: + // 3 -
    
-        int as_int() const;
-        double as_double() const;
-        float as_float() const;
-
    + // And you can use powerful XPath expressions + cout << doc.select_single_node("/bookstore/book[@title = 'ShaderX']/price").node().child_value() << endl; + + // Output: + // 3 -

    Convert the value of an attribute to the desired type. If the conversion is not successfull, return -default value (0 for int, 0.0 for double, 0.0f for float). These functions rely on CRT functions ato*.

    + // Of course, XPath is much more powerful -
    
-        bool as_bool() const;
-
    + // Compile query that prints total price of all Gems book in store + xpath_query query("sum(/bookstore/book[contains(@title, 'Gems')]/price)"); -

    Convert the value of an attribute to bool. This method returns true if the first character of the -value is '1', 't', 'T', 'y' or 'Y'. Otherwise it returns false.

    + cout << query.evaluate_number(doc) << endl; -     -

    Iterators

    + // Output: + // 4 -

    Sometimes you have to cycle through the children or the attributes of the node. You can do it either -by using next_sibling, previous_sibling, next_attribute and previous_attribute -(along with first_child, last_child, first_attribute and last_attribute), -or you can use an iterator-like interface. There are two iterator types, xml_node_iterator and -xml_attribute_iterator. They are bidirectional constant iterators, which means that you can -either increment or decrement them, and use dereferencing and member access operators to get constant -access to node/attribute (the constness of iterators may change with the introducing of mutable trees).

    + // You can apply the same XPath query to any document. For example, let's add another Gems + // book (more detail about modifying tree in next sample): + xml_node book = doc.child("bookstore").append_child(); + book.set_name("book"); + book.append_attribute("title") = "Game Programming Gems 2"; + + xml_node price = book.append_child(); + price.set_name("price"); -

    In order to get the iterators, use corresponding functions of xml_node. Note that _end() -functions return past-the-end iterator, that is, in order to get the last attribute, you'll have to -do something like: + xml_node price_text = price.append_child(node_pcdata); + price_text.set_value("5.3"); + + // Now let's reevaluate query + cout << query.evaluate_number(doc) << endl; -
    
-    if (node.attributes_begin() != node.attributes_end()) // we have at least one attribute
-    {
-        xml_attribute last_attrib = *(--node.attributes_end());
-        ...
+        // Output:
+        // 9.3
     }
-
    -

    - -     -

    Miscellaneous

    - -

    If you want to traverse a subtree, you can use traverse function. There is a class -xml_tree_walker, which has some functions that you can override in order to get custom traversing -(the default one just does nothing). - -
    
-        virtual bool begin(const xml_node&);
-        virtual bool end(const xml_node&);
-
    - -

    These functions are called when the processing of the node starts/ends. First begin() -is called, then all children of the node are processed recursively, then end() is called. If -any of these functions returns false, the traversing is stopped and the traverse() function -returns false.

    - -
    
-        virtual void push();
-        virtual void pop();
-
    +} +    _Winnie C++ Colorizer -

    These functions are called before and after the processing of node's children. If node has no children, -none of these is called. The default behavior is to increment/decrement current node depth.

    +

    Finally, let's get into more details about tree modification and saving.

    
-        virtual int depth() const;
-
    - -

    Get the current depth. You can use this function to do your own indentation, for example.

    - -

    Lets get to some minor notes. You can safely write something like: +#include <iostream> -
    
-        bool value = node.child("stream").attribute("compress").as_bool();
-
    - -If node has a child with the name 'geometry', and this child has an attribute 'compress', than everything -is ok. If node has a child with the name 'geometry' with no attribute 'compress', then attribute("compress") -will return xml_attribute(), and the corresponding call to as_bool() will return default value (false). -If there is no child node 'geometry', the child(...) call will return xml_node(), the subsequent call -to attribute(...) will return xml_attribute() (because there are no attributes belonging to invalid -node), and as_bool() will again return false, so this call sequence is perfectly safe.

    - - -

    Lifetime issues and memory management

    - -

    As parsing is done in-situ, the XML data is to persist during the lifetime of xml_parser. If -the parsing is called via a function of xml_parser, that accepts char*, you have to ensure -yourself, that the string will outlive the xml_parser object.

    - -

    The memory for nodes and attributes is allocated in blocks of data (the blocks form a linked list; -the default size of the block is 32 kb, though you can change it via changing a memory_block_size -constant in pugixml.hpp file. Remember that the first block is allocated on stack (it resides -inside xml_parser object), and all subsequent blocks are allocated on heap, so expect a stack overflow -when setting too large memory block size), so the xml_parser object (which contains the blocks) -should outlive all xml_node and xml_attribute objects (as well as iterators), which belong -to the parser's tree. Again, you should ensure it yourself.

    +#include "pugixml.hpp" -
    +using namespace std; +using namespace pugi; -     -

    Example

    +int main() +{ + // For this example, we'll start with an empty document and create nodes in it from code + xml_document doc; -

    Ok, so you are not much of documentation reader, are you? So am I. Let's assume that you're going -to parse an xml file... something like this: + // Append several children and set values/names at once + doc.append_child(node_comment).set_value("This is a test comment"); + doc.append_child().set_name("application"); -

    -<?xml version="1.0" encoding="UTF-8"?>
-<mesh name="Cathedral">
-    <fragment name="Cathedral">    
-        <geometry>
-            <stream usage="main" source="StAnna.dmesh" compress="true" />
-            <stream usage="ao" source="StAnna.ao" />
-        </geometry>
-    </fragment>
-    <fragment name="Cathedral">    
-    	...
-    </fragment>
-	...
-</mesh>
-
    + // Let's add a few modules + xml_node application = doc.child("application"); -

    <mesh> is a root node, it has 0 or more <fragment>s, each of them has a <geometry> -node, and there are <stream> nodes with the shown attributes. We'd like to parse the file and... -well, and do something with it's contents. There are several methods of doing that; I'll show 2 of them -(the remaining one is using iterators).

    + // Save node wrapper for convenience + xml_node module_a = application.append_child(); + module_a.set_name("module"); + + // Add an attribute, immediately setting it's value + module_a.append_attribute("name").set_value("A"); -

    Here we exploit the knowledge of the strict hierarchy of our XML document and read the nodes from -DOM tree accordingly. When we have an xml_node object, we can get the desired information from -it (name, value, attributes list, nearby nodes in a tree - siblings, parent and children).

    + // You can use operator= + module_a.append_attribute("folder") = "/work/app/module_a"; -
    
-#include <fstream>
-#include <vector>
-#include <algorithm>
-#include <iterator>
+    // Or even assign numbers
+    module_a.append_attribute("status") = 85.4;
 
-#include "pugixml.hpp"
+    // Let's add another module
+    xml_node module_c = application.append_child();
+    module_c.set_name("module");
+    module_c.append_attribute("name") = "C";
+    module_c.append_attribute("folder") = "/work/app/module_c";
 
-using namespace pugi;
+    // Oh, we missed module B. Not a problem, let's insert it before module C
+    xml_node module_b = application.insert_child_before(node_element, module_c);
+    module_b.set_name("module");
+    module_b.append_attribute("folder") = "/work/app/module_b";
 
-int main()
-{
-    std::ifstream in("mesh.xml");
-    in.unsetf(std::ios::skipws);
-                
-    std::vector<char> buf;
-    std::copy(std::istream_iterator<char>(in), std::istream_iterator<char>(), std::back_inserter(buf));
-    buf.push_back(0); // zero-terminate
+    // We can do the same thing for attributes
+    module_b.insert_attribute_before("name", module_b.attribute("folder")) = "B";
     
-    xml_parser parser(&buf[0], pugi::parse_w3c);
+    // Let's add some text in module A
+    module_a.append_child(node_pcdata).set_value("Module A description");
 
-    xml_node doc = parser.document();
-        
-    if (xml_node mesh = doc.first_element("mesh"))
-    {
-        // store mesh.attribute("name").value()
+    // Well, there's not much left to do here. Let's output our document to file using several formatting options
 
-        for (xml_node fragment = mesh.first_element("fragment"); fragment; fragment = fragment.next_sibling())
-        {
-            // store fragment.attribute("name").value()
+    doc.save_file("sample_saved_1.xml");
     
-            if (xml_node geometry = fragment.first_element("geometry"))
-                for (xml_node stream = geometry.first_element("stream"); stream; stream = stream.next_sibling())
-                {
-                    // store stream.attribute("usage").value()
-                    // store stream.attribute("source").value()
-                    
-                    if (stream.attribute("compress"))
-                        // store stream.attribute("compress").as_bool()
+    // Contents of file sample_saved_1.xml (tab size = 4):
+    // <?xml version="1.0"?>
+    // <!--This is a test comment-->
+    // <application>
+    //     <module name="A" folder="/work/app/module_a" status="85.4">Module A description</module>
+    //     <module name="B" folder="/work/app/module_b" />
+    //     <module name="C" folder="/work/app/module_c" />
+    // </application>
+
+    // Let's use two spaces for indentation instead of tab character
+    doc.save_file("sample_saved_2.xml", "  ");
+
+    // Contents of file sample_saved_2.xml:
+    // <?xml version="1.0"?>
+    // <!--This is a test comment-->
+    // <application>
+    //   <module name="A" folder="/work/app/module_a" status="85.4">Module A description</module>
+    //   <module name="B" folder="/work/app/module_b" />
+    //   <module name="C" folder="/work/app/module_c" />
+    // </application>
     
-                }
-        }
-    }
-}
-
    + // Let's save a raw XML file + doc.save_file("sample_saved_3.xml", "", format_raw); + + // Contents of file sample_saved_3.xml: + // <?xml version="1.0"?><!--This is a test comment--><application><module name="A" folder="/work/app/module_a" status="85.4">Module A description</module><module name="B" folder="/work/app/module_b" /><module name="C" folder="/work/app/module_c" /></application> -

    We can also write a class that will traverse the DOM tree and store the information from nodes based -on their names, depths, attributes, etc. This way is well known by the users of SAX parsers. To do that, -we have to write an implementation of xml_tree_walker interface

    + // Finally, you can print a subtree to any output stream (including cout) + doc.child("application").child("module").print(cout); -
                       
-#include <fstream>
-#include <vector>
-#include <algorithm>
-#include <iterator>
+    // Output:
+    // <module name="A" folder="/work/app/module_a" status="85.4">Module A description</module>
+}
+
    _Winnie C++ Colorizer
    -#include "pugixml.hpp" +

    Note, that these examples do not cover the whole pugixml API. For further information, look into reference section.

    -using namespace pugi; +
    -struct mesh_parser: public xml_tree_walker -{ - virtual bool begin(const xml_node& node) - { - if (strcmp(node.name(), "mesh") == 0) - { - // store node.attribute("name").value() - } - else if (strcmp(node.name(), "fragment") == 0) - { - // store node.attribute("name").value() - } - else if (strcmp(node.name(), "geometry") == 0) - { - // ... - } - else if (strcmp(node.name(), "stream") == 0) - { - // store node.attribute("usage").value() - // store node.attribute("source").value() - - if (node.attribute("compress")) - // store stream.attribute("compress").as_bool() - } - else return false; +     +

    Reference

    - return true; - } -}; +

    pugixml is a library for parsing XML files, which means that you give it XML data some way, +and it gives you the DOM tree and the ways to traverse it and to get some useful information from it. +The library source consist of two headers, pugixml.hpp and pugiconfig.hpp, and two source +files, pugixml.cpp and pugixpath.cpp. +You can either compile cpp files in your project, or build a static library. +All library classes reside in namespace pugi, so you can either use fully qualified +names (pugi::xml_node) or write a using declaration (using namespace pugi;, using +pugi::xml_node) and use plain names. All classes have eitther xml_ or xpath_ prefix.

    -int main() -{ - std::ifstream in("mesh.xml"); - in.unsetf(std::ios::skipws); - - std::vector<char> buf; - std::copy(std::istream_iterator<char>(in), std::istream_iterator<char>(), std::back_inserter(buf)); - buf.push_back(0); // zero-terminate - - xml_parser parser(&buf[0], pugi::parse_w3c); +

    By default it's supposed that you compile the source file with your project (add it into your +project, or add relevant entry in your Makefile, or do whatever you need to do with your compilation +environment). The library is written in standard-conformant C++ and was tested on following platforms:

    - mesh_parser mp; +

    +

     +

    - if (!parser.document().traverse(mp)) - // generate an error -} - +

    The documentation for pugixml classes, functions and constants is available here.

    - -

    Parsing process

    - -

    So, let's talk a bit about parsing process, and about the reason for providing XML data as a contiguous -writeable block of memory. Parsing is done in-situ. This means, that the strings, representing the -parts of DOM tree (node names, attribute names and values, CDATA content, etc.) are not separately -allocated on heap, but instead are parts of the original data. This is the keypoint to parsing speed, -because it helps achieve the minimal amount of memory allocations (more on that below) and minimal -amount of copying data.

    - -

    In-situ parsing can be done in two ways, with zero-segmenting the string (that is, set the past-the-end -character for the part of XML string to 0, see -this image for further details), and storing pointer + size of the string instead of pointer to -the beginning of ASCIIZ string.

    - -

    Originally, pugxml had only the first way, but then authors added the second method, 'non-segmenting' -or non-destructive parsing. The advantages of this method are: you no longer need non-constant storage; -you can even read data from memory-mapped files directly. Well, there are disadvantages. -For one thing, you can not do any of the transformations in-situ. The transformations that are required -by XML standard are: -

    - -None of these can be done in-situ. pugxml did neither character nor entity reference expansion, -and allocated new memory when normalizing white spaces when in non-destructive mode. I chose complete -in-situ parsing (the good thing about it is that any transformation, except entity reference, can be -done in-situ because it does not increase the amount of characters - even converting a character -reference to UTF-8). There is no entity reference expansion because of this and because I do not want -to parse DOCTYPE and, moreover, use DOCTYPE in following parsing (performing selective whitespace -normalization in attributes and CDATA sections and so on).

    - -

    In order to be able to modify the tree (change attribute/node names & values) with in-situ parsing, -one needs to implement two ways of storing data (both in-situ and not). The DOM tree is now mutable, -but it will change in the future releases (without introducing speed/memory overhead, except on clean- -up stage).

    - -

    The parsing process itself is more or less straightforward, when you see it - but the impression -is fake, because the explicit jumps are made (i.e. we know, that if we come to a closing brace (>), -we should expect CDATA after it (or a new tag), so let's just jump to the corresponding code), and, -well, there can be bugs (see Bugs section).

    - -

    And, to make things worse, memory allocation (which is done only for node and attribute structures) -is done in pools. The pools are single-linked lists with predefined block size (32 kb by default), and -well, it increases speed a lot (allocations are slow, and the memory gets fragmented when allocating -a bunch of 16-byte (attribute) or 40-byte (node) structures)

    +3 MSVC is Microsoft Visual C++ Compiler
    +    4 ICC is Intel C++ Compiler
    +    5 BCC is Borland C++ Compiler
    @@ -913,20 +444,17 @@ of ones when using parse_w3c mode): correctly, let alone use them for parsing
  • It accepts multiple attributes with the same name in one node
  • It is charset-ignorant -
  • It accepts invalid names of tags
  • It accepts invalid attribute values (those with < in them) and does not reject invalid entity references or character references (in fact, it does not do DOCTYPE parsing, so it does not perform entity reference expansion)
  • It does not reject comments with -- inside -
  • It does not reject PI with the names of 'xml' and alike; in fact, it parses prolog as a PI, which -is not conformant -
  • All characters from #x1 to #x20 are considered to be whitespaces +
  • It does not reject PI with the names of 'xml' and alike
  • And some other things that I forgot to mention -In short, it accepts most malformed XML files and does not do anything that is related to DOCTYPE. -This is because the main goal was developing fast, easy-to-use and error ignorant (so you can always -get something even from a malformed document) parser, there are some good validating and conformant +In short, it accepts some malformed XML files and does not do anything that is related to DOCTYPE. +This is because the main goal was developing fast, easy-to-use and error ignorant (so you can get +something even from a malformed document) parser, there are some good validating and conformant parsers already.

    @@ -1015,9 +543,10 @@ off. The test system is AMD Sempron 2500+, 512 Mb RAM.

    Q: I do not have/want STL support. How can I compile pugixml without STL?

    A: There is an undocumented define PUGIXML_NO_STL. If you uncomment the relevant line in pugixml header file, it will compile without any STL classes. The reason it is undocumented -are that it will make some documented functions not available (specifically, xml_parser() ctor and -parse() function that operate on std::istream, xml_node::path function, utf16 and utf8 conversion -functions). Otherwise, it will work fine.

    +are that it will make some documented functions not available (specifically, xml_document::load, that +operates on std::istream, xml_node::path function, saving functions (xml_node::print, xml_document::save), +XPath-related functions and classes and as_utf16 and as_utf8 conversion functions). Otherwise, it will +work fine.

    Q: Do paths that are accepted by first_element_by_path have to end with delimiter?

    A: Either way will work, both /path/to/node/ and /path/to/node is fine.

    @@ -1048,16 +577,10 @@ do not send executable files.

    upper ones will get there sooner).

      -
    • Support for altering the tree (both changing nodes'/attributes' names and values and adding/deleting -attributes/nodes) and writing the tree to stream
    • Support for UTF-16 files (parsing BOM to get file's type and converting UTF-16 file to UTF-8 buffer if necessary) -
    • Improved API (I'm going to look at SelectNode from MS XML and perhaps there will be some other -changes) -
    • Externally provided entity reference table (or perhaps even taken from DOCTYPE?)
    • More intelligent parsing of DOCTYPE (it does not always skip DOCTYPE for now)
    • XML 1.1 changes (changed EOL handling, normalization issues, etc.) -
    • XPath support
    • Name your own?
    @@ -1079,6 +602,28 @@ changes)
  • Optimizations of strconv_t +
    21.02.2007 - v0.3 +
    Refactored, reworked and improved version. Changes:
      +
    • Interface:
        +
      • Added XPath +
      • Added tree modification functions +
      • Added no STL compilation mode +
      • Added saving document to file +
      • Refactored parsing flags +
      • Removed xml_parser class in favor of xml_document +
      • Added transfer ownership parsing mode +
      • Modified the way xml_tree_walker works +
      • Iterators are now non-constant +
      +
    • Implementation:
        +
      • Support of several compilers and platforms +
      • Refactored and sped up parsing core +
      • Improved standard compliancy +
      • Added XPath implementation +
      • Fixed several bugs +
      +
    +
    • @@ -1099,7 +644,7 @@ changes)

    The pugixml parser is distributed under the MIT license:

    -Copyright (c) 2006 Arseny Kapoulkine
+Copyright (c) 2006-2007 Arseny Kapoulkine
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation
@@ -1125,7 +670,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 
    
 
-
    Revised 8 December, 2006
    
-
    © Copyright Arseny Kapoulkine 2006. All Rights Reserved.
    
+
    Revised 21 February, 2007
    
+
    © Copyright Arseny Kapoulkine 2006-2007. All Rights Reserved.
    
 
 
diff --git a/src/pugiconfig.hpp b/src/pugiconfig.hpp
new file mode 100644
index 0000000..795a66f
--- /dev/null
+++ b/src/pugiconfig.hpp
@@ -0,0 +1,23 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Pug Improved XML Parser - Version 0.3
+// --------------------------------------------------------
+// Copyright (C) 2006-2007, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+// This work is based on the pugxml parser, which is:
+// Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
+// Released into the Public Domain. Use at your own risk.
+// See pugxml.xml for further information, history, etc.
+// Contributions by Neville Franks (readonly@getsoft.com).
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef HEADER_PUGICONFIG_HPP
+#define HEADER_PUGICONFIG_HPP
+
+// Uncomment this to disable STL
+// #define PUGIXML_NO_STL
+
+// Uncomment this to disable XPath
+// #define PUGIXML_NO_XPATH
+
+#endif
diff --git a/src/pugixml.cpp b/src/pugixml.cpp
index cf74eed..e812710 100644
--- a/src/pugixml.cpp
+++ b/src/pugixml.cpp
@@ -1,2134 +1,2569 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Pug Improved XML Parser - Version 0.2
-// --------------------------------------------------------
-// Copyright (C) 2006-2007, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
-// This work is based on the pugxml parser, which is:
-// Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
-// Released into the Public Domain. Use at your own risk.
-// See pugxml.xml for further information, history, etc.
-// Contributions by Neville Franks (readonly@getsoft.com).
-//
-///////////////////////////////////////////////////////////////////////////////
-
+///////////////////////////////////////////////////////////////////////////////
+//
+// Pug Improved XML Parser - Version 0.3
+// --------------------------------------------------------
+// Copyright (C) 2006-2007, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+// This work is based on the pugxml parser, which is:
+// Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
+// Released into the Public Domain. Use at your own risk.
+// See pugxml.xml for further information, history, etc.
+// Contributions by Neville Franks (readonly@getsoft.com).
+//
+///////////////////////////////////////////////////////////////////////////////
+
 #include "pugixml.hpp"
-
-#include 
-
-#include 
-
-namespace pugi
-{
-	/// A 'name=value' XML attribute structure.
-	struct xml_attribute_struct
-	{
-		/// Default ctor
-		xml_attribute_struct();
-
-		char*		name;			///< Pointer to attribute name.
-		char*		value;			///< Pointer to attribute value.
-
-		xml_attribute_struct* prev_attribute;	///< Previous attribute
-		xml_attribute_struct* next_attribute;	///< Next attribute
-	};
-
-	/// An XML document tree node.
-	struct xml_node_struct
-	{
-		/// Default ctor
-		/// \param type - node type
-		xml_node_struct(xml_node_type type = node_element);
-
-		xml_node_type			type;					///< Node type; see xml_node_type.
-		xml_node_struct*		parent;					///< Pointer to parent
-
-		char*					name;					///< Pointer to element name.
-		char*					value;					///< Pointer to any associated string data.
-
-		xml_node_struct*		first_child;			///< First child
-		xml_node_struct*		last_child;				///< Last child
-		
-		xml_node_struct*		prev_sibling;			///< Left brother
-		xml_node_struct*		next_sibling;			///< Right brother
-		
-		xml_attribute_struct*	first_attribute;		///< First attribute
-		xml_attribute_struct*	last_attribute;			///< Last attribute
-	};
-
-	class xml_allocator
-	{
-	public:
-		xml_allocator(xml_memory_block* root): _root(root), _count(0)
-		{
-		}
-
-		template  T* allocate()
-		{
-			void* buf = memalloc(sizeof(T));
-			return new (buf) T();
-		}
-		
-		template  T* allocate(U val)
-		{
-			void* buf = memalloc(sizeof(T));
-			return new (buf) T(val);
-		}
-
-	private:
-		xml_memory_block* _root;
-		unsigned int _count;
-
-		void* memalloc(size_t size)
-		{
-			if (_root->size + size <= memory_block_size)
-			{
-				void* buf = _root->data + _root->size;
-				_root->size += size;
-				return buf;
-			}
-			else
-			{
-				_root->next = new xml_memory_block();
-				_root = _root->next;
-
-				_root->size = size;
-
-				++_count;
-
-				return _root->data;
-			}
-		}
-	};
-}
-
-namespace
-{	
-	namespace utf8
-	{
-		const unsigned char BYTE_MASK = 0xBF;
-		const unsigned char BYTE_MARK = 0x80;
-		const unsigned char BYTE_MASK_READ = 0x3F;
-		const unsigned char FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
-	}
-
-	enum chartype
-	{
-		ct_parse_pcdata = 1,	// \0, &, \r, <
-		ct_parse_attr = 2,		// \0, &, \r, ', "
-		ct_parse_attr_ws = 4,	// \0, &, \r, ', ", \n, space, tab
-		ct_space = 8,			// \r, \n, space, tab
-		ct_parse_cdata = 16,	// \0, ], >, \r
-		ct_parse_comment = 32,	// \0, -, >, \r
-		ct_symbol = 64			// Any symbol > 127, a-z, A-Z, 0-9, _, :, -, .
-		
-	};
-
-	static unsigned char chartype_table[256] =
-	{
-		55, 0, 0, 0, 0, 0, 0, 0,				0, 12, 12, 0, 0, 63, 0, 0,			// 0-15
-		0, 0, 0, 0, 0, 0, 0, 0,					0, 0, 0, 0, 0, 0, 0, 0,				// 16-31
-		12, 0, 6, 0, 0, 0, 7, 6,				0, 0, 0, 0, 0, 96, 64, 0,			// 32-47
-		64, 64, 64, 64, 64, 64, 64, 64,			64, 64, 64, 0, 1, 0, 48, 0,			// 48-63
-		0, 64, 64, 64, 64, 64, 64, 64,			64, 64, 64, 64, 64, 64, 64, 64,		// 64-79
-		64, 64, 64, 64, 64, 64, 64, 64,			64, 64, 64, 0, 0, 16, 0, 64,		// 80-95
-		0, 64, 64, 64, 64, 64, 64, 64,			64, 64, 64, 64, 64, 64, 64, 64,		// 96-111
-		64, 64, 64, 64, 64, 64, 64, 64,			64, 64, 64, 0, 0, 0, 0, 0,			// 112-127
-
-		64, 64, 64, 64, 64, 64, 64, 64,			64, 64, 64, 64, 64, 64, 64, 64,
-		64, 64, 64, 64, 64, 64, 64, 64,			64, 64, 64, 64, 64, 64, 64, 64,
-		64, 64, 64, 64, 64, 64, 64, 64,			64, 64, 64, 64, 64, 64, 64, 64,
-		64, 64, 64, 64, 64, 64, 64, 64,			64, 64, 64, 64, 64, 64, 64, 64,
-		64, 64, 64, 64, 64, 64, 64, 64,			64, 64, 64, 64, 64, 64, 64, 64,
-		64, 64, 64, 64, 64, 64, 64, 64,			64, 64, 64, 64, 64, 64, 64, 64,
-		64, 64, 64, 64, 64, 64, 64, 64,			64, 64, 64, 64, 64, 64, 64, 64,
-		64, 64, 64, 64, 64, 64, 64, 64,			64, 64, 64, 64, 64, 64, 64, 64
-	};
-	
-	bool is_chartype(char c, chartype ct)
-	{
-		return !!(chartype_table[static_cast(c)] & ct);
-	}
-}
-
-namespace pugi
-{
-	// Get the size that is needed for strutf16_utf8 applied to all s characters
-	static size_t strutf16_utf8_size(const wchar_t* s)
-	{
-		size_t length = 0;
-
-		for (; *s; ++s)
-		{
-			if (*s < 0x80) length += 1;
-			else if (*s < 0x800) length += 2;
-			else if (*s < 0x10000) length += 3;
-			else if (*s < 0x200000) length += 4;
-		}
-
-		return length;
-	}
-
-	// Write utf16 char to stream, return position after the last written char
-	// \param s - pointer to string
-	// \param ch - char
-	// \return position after the last char
-	// \rem yes, this is trom TinyXML. How would you write it the other way, without switch trick?..
-	static char* strutf16_utf8(char* s, unsigned int ch)
-	{
-		unsigned int length;
-
-		if (ch < 0x80) length = 1;
-		else if (ch < 0x800) length = 2;
-		else if (ch < 0x10000) length = 3;
-		else if (ch < 0x200000) length = 4;
-		else return s;
-	
-		s += length;
-
-		// Scary scary fall throughs.
-		switch (length) 
-		{
-			case 4:
-				*--s = (char)((ch | utf8::BYTE_MARK) & utf8::BYTE_MASK); 
-				ch >>= 6;
-			case 3:
-				*--s = (char)((ch | utf8::BYTE_MARK) & utf8::BYTE_MASK); 
-				ch >>= 6;
-			case 2:
-				*--s = (char)((ch | utf8::BYTE_MARK) & utf8::BYTE_MASK); 
-				ch >>= 6;
-			case 1:
-				*--s = (char)(ch | utf8::FIRST_BYTE_MARK[length]);
-		}
-		
-		return s + length;
-	}
-
-	// Get the size that is needed for strutf8_utf16 applied to all s characters
-	static size_t strutf8_utf16_size(const char* s)
-	{
-		size_t length = 0;
-
-		for (; *s; ++s)
-		{
-			unsigned char ch = static_cast(*s);
-
-			if (ch < 0x80 || (ch >= 0xC0 && ch < 0xFC)) ++length;
-		}
-
-		return length;
-	}
-
-	// Read utf16 char from utf8 stream, return position after the last read char
-	// \param s - pointer to string
-	// \param ch - char
-	// \return position after the last char
-	static const char* strutf8_utf16(const char* s, unsigned int& ch)
-	{
-		unsigned int length;
-
-		const unsigned char* str = reinterpret_cast(s);
-
-		if (*str < utf8::BYTE_MARK)
-		{
-			ch = *str;
-			return s + 1;
-		}
-		else if (*str < 0xC0)
-		{
-			ch = ' ';
-			return s + 1;
-		}
-		else if (*str < 0xE0) length = 2;
-		else if (*str < 0xF0) length = 3;
-		else if (*str < 0xF8) length = 4;
-		else if (*str < 0xFC) length = 5;
-		else
-		{
-			ch = ' ';
-			return s + 1;
-		}
-
-		ch = (*str++ & ~utf8::FIRST_BYTE_MARK[length]);
-	
-		// Scary scary fall throughs.
-		switch (length) 
-		{
-			case 5:
-				ch <<= 6;
-				ch += (*str++ & utf8::BYTE_MASK_READ);
-			case 4:
-				ch <<= 6;
-				ch += (*str++ & utf8::BYTE_MASK_READ);
-			case 3:
-				ch <<= 6;
-				ch += (*str++ & utf8::BYTE_MASK_READ);
-			case 2:
-				ch <<= 6;
-				ch += (*str++ & utf8::BYTE_MASK_READ);
-		}
-		
-		return reinterpret_cast(str);
-	}
-
-	struct xml_parser_impl
-	{
-		xml_allocator& alloc;
-		
-		struct gap
-		{
-			char* end;
-			size_t size;
-			
-			gap(): end(0), size(0)
-			{
-			}
-			
-			// Push new gap, move s count bytes further (skipping the gap).
-			// Collapse previous gap.
-			void push(char*& s, size_t count)
-			{
-				if (end) // there was a gap already; collapse it
-				{
-					// Move [old_gap_end, new_gap_start) to [old_gap_start, ...)
-					memmove(end - size, end, s - end);
-				}
-				
-				s += count; // end of current gap
-				
-				// "merge" two gaps
-				end = s;
-				size += count;
-			}
-			
-			// Collapse all gaps, return past-the-end pointer
-			char* flush(char* s)
-			{
-				if (end)
-				{
-					// Move [old_gap_end, current_pos) to [old_gap_start, ...)
-					memmove(end - size, end, s - end);
-
-					return s - size;
-				}
-				else return s;
-			}
-		};
-		
-		static char* strconv_escape(char* s, gap& g)
-		{
-			char* stre = s + 1;
-
-			switch (*stre)
-			{
-				case '#':	// &#...
-				{
-					unsigned int ucsc = 0;
-
-					++stre;
-
-					if (*stre == 'x') // &#x... (hex code)
-					{
-						++stre;
-						
-						while (*stre)
-						{
-							if (*stre >= '0' && *stre <= '9')
-								ucsc = 16 * ucsc + (*stre++ - '0');
-							else if (*stre >= 'A' && *stre <= 'F')
-								ucsc = 16 * ucsc + (*stre++ - 'A' + 10);
-							else if (*stre >= 'a' && *stre <= 'f')
-								ucsc = 16 * ucsc + (*stre++ - 'a' + 10);
-							else break;
-						}
-
-						if (*stre == ';') ++stre;
-					}
-					else	// &#... (dec code)
-					{
-						while (*stre >= '0' && *stre <= '9')
-							ucsc = 10 * ucsc + (*stre++ - '0');
-
-						if (*stre == ';') ++stre;
-					}
-
-					s = strutf16_utf8(s, ucsc);
-					
-					g.push(s, stre - s);
-					return stre;
-				}
-				case 'a':	// &a
-				{
-					++stre;
-
-					if (*stre == 'm') // &am
-					{
-						if (*++stre == 'p' && *++stre == ';') // &
-						{
-							*s++ = '&';
-							++stre;
-							
-							g.push(s, stre - s);
-							return stre;
-						}
-					}
-					else if (*stre == 'p') // &ap
-					{
-						if (*++stre == 'o' && *++stre == 's' && *++stre == ';') // '
-						{
-							*s++ = '\'';
-							++stre;
-
-							g.push(s, stre - s);
-							return stre;
-						}
-					}
-					break;
-				}
-				case 'g': // &g
-				{
-					if (*++stre == 't' && *++stre == ';') // >
-					{
-						*s++ = '>';
-						++stre;
-						
-						g.push(s, stre - s);
-						return stre;
-					}
-					break;
-				}
-				case 'l': // &l
-				{
-					if (*++stre == 't' && *++stre == ';') // <
-					{
-						*s++ = '<';
-						++stre;
-						
-						g.push(s, stre - s);
-						return stre;
-					}
-					break;
-				}
-				case 'q': // &q
-				{
-					if (*++stre == 'u' && *++stre == 'o' && *++stre == 't' && *++stre == ';') // "
-					{
-						*s++ = '"';
-						++stre;
-						
-						g.push(s, stre - s);
-						return stre;
-					}
-					break;
-				}
-			}
-			
-			return stre;
-		}
-
-		static char* strconv_comment(char* s)
-		{
-			if (!*s) return 0;
-			
-			gap g;
-			
-			while (true)
-			{
-				while (!is_chartype(*s, ct_parse_comment)) ++s;
-				
-				if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
-				{
-					*s++ = '\n'; // replace first one with 0x0a
-					
-					if (*s == '\n') g.push(s, 1);
-				}
-				else if (*s == '-' && *(s+1) == '-' && *(s+2) == '>') // comment ends here
-				{
-					*g.flush(s) = 0;
-					
-					return s + 3;
-				}
-				else if (*s == 0)
-				{
-					return 0;
-				}
-				else ++s;
-			}
-		}
-
-		static char* strconv_cdata(char* s)
-		{
-			if (!*s) return 0;
-			
-			gap g;
-			
-			while (true)
-			{
-				while (!is_chartype(*s, ct_parse_cdata)) ++s;
-				
-				if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
-				{
-					*s++ = '\n'; // replace first one with 0x0a
-					
-					if (*s == '\n') g.push(s, 1);
-				}
-				else if (*s == ']' && *(s+1) == ']' && *(s+2) == '>') // CDATA ends here
-				{
-					*g.flush(s) = 0;
-					
-					return s + 1;
-				}
-				else if (*s == 0)
-				{
-					return 0;
-				}
-				else ++s;
-			}
-		}
-		
-		template  static char* strconv_pcdata(char* s)
-		{
-			if (!*s) return 0;
-
-			gap g;
-			
-			while (true)
-			{
-				while (!is_chartype(*s, ct_parse_pcdata)) ++s;
-				
-				if (opt_eol && *s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
-				{
-					*s++ = '\n'; // replace first one with 0x0a
-					
-					if (*s == '\n') g.push(s, 1);
-				}
-				else if (opt_escape && *s == '&')
-				{
-					s = strconv_escape(s, g);
-				}
-				else if (*s == '<') // PCDATA ends here
-				{
-					*g.flush(s) = 0;
-					
-					return s + 1;
-				}
-				else if (*s == 0)
-				{
-					return 0;
-				}
-				else ++s;
-			}
-		}
-
-		static char* strconv_pcdata(char* s, unsigned int opt_escape, unsigned int opt_eol)
-		{
-			if (opt_escape)
-				return opt_eol ? strconv_pcdata(s) : strconv_pcdata(s);
-			else
-				return opt_eol ? strconv_pcdata(s) : strconv_pcdata(s);
-		}
-
-		template  static char* strconv_attr(char* s, char end_quote)
-		{
-			if (!*s) return 0;
-			
-			gap g;
-
-			// Trim whitespaces
-			if (opt_wnorm)
-			{
-				char* str = s;
-				
-				while (is_chartype(*str, ct_space)) ++str;
-				
-				if (str != s)
-					g.push(s, str - s);
-			}
-			
-			while (true)
-			{
-				while (!is_chartype(*s, (opt_wnorm || opt_wconv) ? ct_parse_attr_ws : ct_parse_attr)) ++s;
-				
-				if (opt_escape && *s == '&')
-				{
-					s = strconv_escape(s, g);
-				}
-				else if (opt_wnorm && is_chartype(*s, ct_space))
-				{
-					*s++ = ' ';
-		
-					if (is_chartype(*s, ct_space))
-					{
-						char* str = s + 1;
-						while (is_chartype(*str, ct_space)) ++str;
-						
-						g.push(s, str - s);
-					}
-				}
-				else if (opt_wconv && is_chartype(*s, ct_space))
-				{
-					if (opt_eol)
-					{
-						if (*s == '\r')
-						{
-							*s++ = ' ';
-					
-							if (*s == '\n') g.push(s, 1);
-						}
-						else *s++ = ' ';
-					}
-					else *s++ = ' ';
-				}
-				else if (opt_eol && *s == '\r')
-				{
-					*s++ = '\n';
-					
-					if (*s == '\n') g.push(s, 1);
-				}
-				else if (*s == end_quote)
-				{
-					char* str = g.flush(s);
-					
-					if (opt_wnorm)
-					{
-						do *str-- = 0;
-						while (is_chartype(*str, ct_space));
-					}
-					else *str = 0;
-					
-					return s + 1;
-				}
-				else if (!*s)
-				{
-					return 0;
-				}
-				else ++s;
-			}
-		}
-	
-		static void strconv_attr_setup(char* (*&func)(char*, char), unsigned int opt_escape, unsigned int opt_wnorm, unsigned int opt_wconv, unsigned int opt_eol)
-		{
-			if (opt_eol)
-			{
-				if (opt_wconv)
-				{
-					if (opt_escape)
-					{
-						if (opt_wnorm) func = &strconv_attr;
-						else func = &strconv_attr;
-					}
-					else
-					{
-						if (opt_wnorm) func = &strconv_attr;
-						else func = &strconv_attr;
-					}
-				}
-				else
-				{
-					if (opt_escape)
-					{
-						if (opt_wnorm) func = &strconv_attr;
-						else func = &strconv_attr;
-					}
-					else
-					{
-						if (opt_wnorm) func = &strconv_attr;
-						else func = &strconv_attr;
-					}
-				}
-			}
-			else
-			{
-				if (opt_wconv)
-				{
-					if (opt_escape)
-					{
-						if (opt_wnorm) func = &strconv_attr;
-						else func = &strconv_attr;
-					}
-					else
-					{
-						if (opt_wnorm) func = &strconv_attr;
-						else func = &strconv_attr;
-					}
-				}
-				else
-				{
-					if (opt_escape)
-					{
-						if (opt_wnorm) func = &strconv_attr;
-						else func = &strconv_attr;
-					}
-					else
-					{
-						if (opt_wnorm) func = &strconv_attr;
-						else func = &strconv_attr;
-					}
-				}
-			}
-		}
-
-		// Allocate & append a new xml_node_struct onto the given parent.
-		// \param parent - pointer to parent node.
-		// \param type - desired node type.
-		// \return pointer to the new node
-		xml_node_struct* append_node(xml_node_struct* parent, xml_node_type type = node_element)
-		{
-			if(!parent) return 0; // Must have a parent.
-
-			xml_node_struct* child = alloc.allocate(type); // Allocate a new child.
-			child->parent = parent; // Set it's parent pointer.
-			if (parent->last_child)
-			{
-				parent->last_child->next_sibling = child;
-				child->prev_sibling = parent->last_child;
-				parent->last_child = child;
-			}
-			else parent->first_child = parent->last_child = child;
-			return child;
-		}
-
-		// Allocate & append a new attribute to the given xml_node_struct.
-		// \param node - pointer to parent node.
-		// \return pointer to appended xml_attribute_struct.
-		xml_attribute_struct* append_attribute(xml_node_struct* node)
-		{
-			if(!node) return 0;
-			xml_attribute_struct* a = alloc.allocate();
-
-			if (node->last_attribute)
-			{
-				node->last_attribute->next_attribute = a;
-				a->prev_attribute = node->last_attribute;
-				node->last_attribute = a;
-			}
-			else node->first_attribute = node->last_attribute = a;
-			
-			return a;
-		}
-		
-		// Parser utilities.
-		#define SKIPWS()			{ while(is_chartype(*s, ct_space)) ++s; if(*s==0) return s; }
-		#define OPTSET(OPT)			( optmsk & OPT )
-		#define PUSHNODE(TYPE)		{ cursor = append_node(cursor,TYPE); }
-		#define POPNODE()			{ cursor = cursor->parent; }
-		#define SCANFOR(X)			{ while(*s!=0 && !(X)) ++s; if(*s==0) return s; }
-		#define SCANWHILE(X)		{ while((X)) ++s; if(*s==0) return s; }
-		#define ENDSEG()			{ ch = *s; *s = 0; ++s; if(*s==0) return s; }
-		
-		xml_parser_impl(xml_allocator& alloc): alloc(alloc)
-		{
-			for (unsigned int c = 0; c < 256; ++c)
-			{
-			}
-		}
-		
-		// Static single-pass in-situ parse the given xml string.
-		// \param s - pointer to XML-formatted string.
-		// \param xmldoc - pointer to root.
-		// \param optmsk - parse options mask.
-		// \return last string position or NULL.
-		char* parse(register char* s,xml_node_struct* xmldoc,unsigned int optmsk = parse_default)
-		{
-			if(!s || !xmldoc) return s;
-
-			char* (*strconv_attribute)(char*, char);
-
-			strconv_attr_setup(strconv_attribute, OPTSET(parse_escapes), OPTSET(parse_wnorm_attribute), OPTSET(parse_wconv_attribute), OPTSET(parse_eol));
-
-			char ch = 0; // Current char, in cases where we must null-terminate before we test.
-			xml_node_struct* cursor = xmldoc; // Tree node cursor.
-			char* mark = s; // Marked string position for temporary look-ahead.
-			while(*s!=0)
-			{
-			LOC_SEARCH: // Obliviously search for next element.
-				SCANFOR(*s == '<'); // Find the next '<'.
-				if(*s == '<')
-				{
-					++s;
-				LOC_CLASSIFY: // What kind of element?
-					if(*s == '?') // 'name = mark;
-
-							if (is_chartype(ch, ct_space))
-							{
-								SKIPWS();
-
-								mark = s;
-							}
-							else mark = 0;
-
-							SCANFOR(*s == '?' && *(s+1) == '>'); // Look for '?>'.
-							ENDSEG();
-
-							cursor->value = mark;
-
-							POPNODE();
-
-							goto LOC_LEAVE;
-						}
-						else // Bad PI or parse_pi not set.
-						{
-							SCANFOR(*s == '?' && *(s+1) == '>'); // Look for '?>'.
-							++s;
-							goto LOC_LEAVE;
-						}
-					}
-					else if(*s == '!') // 'value = s; // Save the offset.
-								}
-
-								if (OPTSET(parse_eol) && OPTSET(parse_comments))
-								{
-									s = strconv_comment(s);
-									
-									if (!s) return s;
-								}
-								else
-								{
-									// Scan for terminating '-->'.
-									SCANFOR(*s == '-' && *(s+1) == '-' && *(s+2) == '>');
-								
-									if (OPTSET(parse_comments))
-										*s = 0; // Zero-terminate this segment at the first terminating '-'.
-									
-									s += 2; // Step over the '\0-'.
-								}
-								
-								if (OPTSET(parse_comments))
-								{
-									POPNODE(); // Pop since this is a standalone.
-								}
-								
-								goto LOC_LEAVE; // Look for any following PCDATA.
-							}
-						}
-						else if(*s == '[')
-						{
-							// 'value = s; // Save the offset.
-
-									if (OPTSET(parse_eol))
-									{
-										s = strconv_cdata(s);
-										
-										if (!s) return s;
-									}
-									else
-									{
-										// Scan for terminating ']]>'.
-										SCANFOR(*s == ']' && *(s+1) == ']' && *(s+2) == '>');
-										ENDSEG(); // Zero-terminate this segment.
-									}
-
-									POPNODE(); // Pop since this is a standalone.
-								}
-								else // Flagged for discard, but we still have to scan for the terminator.
-								{
-									// Scan for terminating ']]>'.
-									SCANFOR(*s == ']' && *(s+1) == ']' && *(s+2) == '>');
-									++s;
-								}
-								++s; // Step over the last ']'.
-								goto LOC_LEAVE; // Look for any following PCDATA.
-							}
-							continue; // Probably a corrupted CDATA section, so just eat it.
-						}
-						else if(*s=='D' && *++s=='O' && *++s=='C' && *++s=='T' && *++s=='Y' && *++s=='P' && *++s=='E')
-						{
-							++s;
-							SKIPWS(); // Eat any whitespace.
-						LOC_DOCTYPE:
-							SCANWHILE(*s == '\'' || *s == '"' || *s == '[' || *s == '>');
-							if(*s == '\'' || *s == '"') // '...SYSTEM "..."
-							{
-								ch = *s++;
-								SCANFOR(*s == ch);
-								++s;
-								goto LOC_DOCTYPE;
-							}
-							if(*s == '[') // '...[...'
-							{
-								++s;
-								unsigned int bd = 1; // Bracket depth counter.
-								while(*s!=0) // Loop till we're out of all brackets.
-								{
-									if(*s == ']') --bd;
-									else if(*s == '[') ++bd;
-									if(bd == 0) break;
-									++s;
-								}
-								// Note: 's' now points to end of DTD, i.e.: ']'.
-								SCANFOR(*s == '>');
-								continue;
-							}
-							// Fall-through
-							continue;
-						}
-					}
-					else if(is_chartype(*s, ct_symbol)) // '<#...'
-					{
-						cursor = append_node(cursor); // Append a new node to the tree.
-
-						cursor->name = s;
-						SCANWHILE(is_chartype(*s, ct_symbol)); // Scan for a terminator.
-						ENDSEG(); // Save char in 'ch', terminate & step over.
-						if (*s!=0 && ch == '/') // ''); // Scan for '>'
-							POPNODE(); // Pop.
-							goto LOC_LEAVE;
-						}
-						else if(*s!=0 && !is_chartype(ch, ct_space))
-						{
-							if (ch != '>') SCANWHILE(*s != '>');
-							if (!*s) return s;
-							goto LOC_PCDATA; // No attributes, so scan for PCDATA.
-						}
-						else if(*s!=0 && is_chartype(ch, ct_space))
-						{
-							SKIPWS(); // Eat any whitespace.
-						LOC_ATTRIBUTE:
-							if(is_chartype(*s, ct_symbol)) // <... #...
-							{
-								xml_attribute_struct* a = append_attribute(cursor); // Make space for this attribute.
-								a->name = s; // Save the offset.
-								SCANWHILE(is_chartype(*s, ct_symbol)); // Scan for a terminator.
-								ENDSEG(); // Save char in 'ch', terminate & step over.
-								if(*s!=0 && is_chartype(ch, ct_space)) SKIPWS(); // Eat any whitespace.
-								if(*s!=0 && (ch == '=' || *s == '=')) // '<... #=...'
-								{
-									if(*s == '=') ++s;
-									SKIPWS(); // Eat any whitespace.
-									if(*s == '\'' || *s == '"') // '<... #="...'
-									{
-										ch = *s; // Save quote char to avoid breaking on "''" -or- '""'.
-										++s; // Step over the quote.
-										a->value = s; // Save the offset.
-
-										s = strconv_attribute(s, ch);
-										
-										if (!s) return s;
-
-										if(*s == '>')
-										{
-											++s;
-											goto LOC_PCDATA;
-										}
-										else if(*s == '/')
-										{
-											++s;
-											POPNODE();
-											SKIPWS(); // Eat any whitespace.
-											goto LOC_LEAVE;
-										}
-										else if(is_chartype(*s, ct_space)) // This may indicate a following attribute.
-										{
-											SKIPWS(); // Eat any whitespace.
-											goto LOC_ATTRIBUTE; // Go scan for additional attributes.
-										}
-									}
-								}
-								goto LOC_ATTRIBUTE;
-							}
-
-							SCANWHILE(*s != '>' && *s != '/');
-						}
-					LOC_LEAVE:
-						if(*s == '>') // '...>'
-						{
-							++s; // Step over the '>'.
-						LOC_PCDATA: // '>...<'
-							mark = s; // Save this offset while searching for a terminator.
-							SKIPWS(); // Eat whitespace if no genuine PCDATA here.
-							// We hit a '<...', with only whitespace, so don't bother storing anything.
- 							if((mark == s || !OPTSET(parse_ws_pcdata)) && *s == '<')
-							{
-								if(*(s+1) == '/') // 'type != node_document;
-
-							if (preserve)
-							{
-								PUSHNODE(node_pcdata); // Append a new node on the tree.
-								cursor->value = s; // Save the offset.
-
-								s = strconv_pcdata(s, OPTSET(parse_escapes), OPTSET(parse_eol));
-								
-								if (!s) return s;
-								
-								POPNODE(); // Pop since this is a standalone.
-							}
-							else
-							{
-								SCANFOR(*s == '<'); // '...<'
-							}
-
-							// We're after '<...', otherwise we would not get here
-							if(*s == '/') goto LOC_CLOSE;
-							else if(*s == '!') goto LOC_CLASSIFY; // We hit a '') // '.../>'
-							{
-								POPNODE(); // Pop.
-								goto LOC_LEAVE;
-							}
-						}
-					}
-					// Fall-through B.
-					else if(*s == '/') // '.../'
-					{
-					LOC_CLOSE:
-						++s;
-						
-						if (OPTSET(parse_match_end_tags))
-						{
-							while (cursor && cursor->type != node_document)
-							{
-								char* tagname = s;
-	
-								// is it the matching tag?
-								char* name = cursor->name;
-								
-								if (name)
-								{
-									while (*tagname && is_chartype(*tagname, ct_symbol))
-									{
-										if (*tagname++ != *name++) goto TAG_NEXTMATCH;
-									}
-									
-									if (!*name)
-									{
-										// we've found matching tag
-										POPNODE();
-										s = tagname;
-										break;
-									}
-								}
-
-							TAG_NEXTMATCH:
-								POPNODE();
-							}
-						}
-						else if (OPTSET(parse_check_end_tags))
-						{
-							char* name = cursor->name;
-							if (!name) return s;
-						
-							while (*s && is_chartype(*s, ct_symbol))
-							{
-								if (*s++ != *name++) return s;
-							}
-							if (*name) return s;
-							
-							POPNODE(); // Pop.
-						}
-						else
-						{
-							SCANFOR(*s == '>'); // '...>'
-							POPNODE(); // Pop.
-						}
-
-						SKIPWS();
-												
-						goto LOC_LEAVE;
-					}
-				}
-			}
-			return s;
-		}
-		
-	private:
-		const xml_parser_impl& operator=(const xml_parser_impl&);
-	};
-
-	// Compare lhs with [rhs_begin, rhs_end)
-	static int strcmprange(const char* lhs, const char* rhs_begin, const char* rhs_end)
-	{
-		while (*lhs && rhs_begin != rhs_end && *lhs == *rhs_begin)
-		{
-			++lhs;
-			++rhs_begin;
-		}
-		
-		if (rhs_begin == rhs_end && *lhs == 0) return 0;
-		else return 1;
-	}
-	
-	// Character set pattern match.
-	static int strcmpwild_cset(const char** src, const char** dst)
-	{
-		int find = 0, excl = 0, star = 0;
-		
-		if (**src == '!')
-		{
-			excl = 1;
-			++(*src);
-		}
-		
-		while (**src != ']' || star == 1)
-		{
-			if (find == 0)
-			{
-				if (**src == '-' && *(*src-1) < *(*src+1) && *(*src+1) != ']' && star == 0)
-				{
-					if (**dst >= *(*src-1) && **dst <= *(*src+1))
-					{
-						find = 1;
-						++(*src);
-					}
-				}
-				else if (**src == **dst) find = 1;
-			}
-			++(*src);
-			star = 0;
-		}
-
-		if (excl == 1) find = (1 - find);
-		if (find == 1) ++(*dst);
-	
-		return find;
-	}
-
-	// Wildcard pattern match.
-	static int strcmpwild_astr(const char** src, const char** dst)
-	{
-		int find = 1;
-		++(*src);
-		while ((**dst != 0 && **src == '?') || **src == '*')
-		{
-			if(**src == '?') ++(*dst);
-			++(*src);
-		}
-		while (**src == '*') ++(*src);
-		if (**dst == 0 && **src != 0) return 0;
-		if (**dst == 0 && **src == 0) return 1;
-		else
-		{
-			if (impl::strcmpwild(*src,*dst))
-			{
-				do
-				{
-					++(*dst);
-					while(**src != **dst && **src != '[' && **dst != 0) 
-						++(*dst);
-				}
-				while ((**dst != 0) ? impl::strcmpwild(*src,*dst) : 0 != (find=0));
-			}
-			if (**dst == 0 && **src == 0) find = 1;
-			return find;
-		}
-	}
-
-	namespace impl
-	{
-		// Compare two strings, with globbing, and character sets.
-		int strcmpwild(const char* src, const char* dst)
-		{
-			int find = 1;
-			for(; *src != 0 && find == 1 && *dst != 0; ++src)
-			{
-				switch (*src)
-				{
-					case '?': ++dst; break;
-					case '[': ++src; find = strcmpwild_cset(&src,&dst); break;
-					case '*': find = strcmpwild_astr(&src,&dst); --src; break;
-					default : find = (int) (*src == *dst); ++dst;
-				}
-			}
-			while (*src == '*' && find == 1) ++src;
-			return (find == 1 && *dst == 0 && *src == 0) ? 0 : 1;
-		}
-	}
-
-	int strcmp(const char* lhs, const char* rhs)
-	{
-		return ::strcmp(lhs, rhs);
-	}
-
-	int strcmpwildimpl(const char* src, const char* dst)
-	{
-		return impl::strcmpwild(src, dst);
-	}
-
-	typedef int (*strcmpfunc)(const char*, const char*);
-
-	xml_attribute_struct::xml_attribute_struct(): name(0), value(0), prev_attribute(0), next_attribute(0)
-	{
-	}
-	
-	xml_node_struct::xml_node_struct(xml_node_type type): type(type), parent(0), name(0), value(0), first_child(0), last_child(0), prev_sibling(0), next_sibling(0), first_attribute(0), last_attribute(0)
-	{
-	}
-
-	xml_tree_walker::xml_tree_walker() : _deep(0)
-	{
-	}
-	
-	xml_tree_walker::~xml_tree_walker()
-	{
-	}
-
-	void xml_tree_walker::push()
-	{
-		++_deep;
-	}
-
-	void xml_tree_walker::pop()
-	{
-		--_deep;
-	}
-
-	int xml_tree_walker::depth() const
-	{
-		return (_deep > 0) ? _deep : 0;
-	}
-
-	bool xml_tree_walker::begin(const xml_node&)
-	{
-		return true;
-	}
-
-	bool xml_tree_walker::end(const xml_node&)
-	{
-		return true;
-	}
-
-	xml_attribute::xml_attribute(): _attr(0)
-	{
-	}
-
-	xml_attribute::xml_attribute(const xml_attribute_struct* attr): _attr(attr)
-	{
-	}
-
-	xml_attribute::operator xml_attribute::unspecified_bool_type() const
-	{
-      	return empty() ? 0 : &xml_attribute::_attr;
-   	}
-
-	bool xml_attribute::operator==(const xml_attribute& r) const
-	{
-		return (_attr == r._attr);
-	}
-	
-	bool xml_attribute::operator!=(const xml_attribute& r) const
-	{
-		return (_attr != r._attr);
-	}
-
-	bool xml_attribute::operator<(const xml_attribute& r) const
-	{
-		return (_attr < r._attr);
-	}
-	
-	bool xml_attribute::operator>(const xml_attribute& r) const
-	{
-		return (_attr > r._attr);
-	}
-	
-	bool xml_attribute::operator<=(const xml_attribute& r) const
-	{
-		return (_attr <= r._attr);
-	}
-	
-	bool xml_attribute::operator>=(const xml_attribute& r) const
-	{
-		return (_attr >= r._attr);
-	}
-
-   	xml_attribute xml_attribute::next_attribute() const
-   	{
-    	return _attr ? xml_attribute(_attr->next_attribute) : xml_attribute();
-   	}
-
-    xml_attribute xml_attribute::previous_attribute() const
-    {
-    	return _attr ? xml_attribute(_attr->prev_attribute) : xml_attribute();
-    }
-
-	int xml_attribute::as_int() const
-	{
-		if(empty() || !_attr->value) return 0;
-		return atoi(_attr->value);
-	}
-
-	double xml_attribute::as_double() const
-	{
-		if(empty() || !_attr->value) return 0.0;
-		return atof(_attr->value);
-	}
-
-	float xml_attribute::as_float() const
-	{
-		if(empty() || !_attr->value) return 0.0f;
-		return (float)atof(_attr->value);
-	}
-
-	bool xml_attribute::as_bool() const
-	{
-		if(empty() || !_attr->value) return false;
-		if(*(_attr->value))
-		{
-			return // Only look at first char:
-			(
-				*(_attr->value) == '1' || // 1*
-				*(_attr->value) == 't' || // t* (true)
-				*(_attr->value) == 'T' || // T* (true|true)
-				*(_attr->value) == 'y' || // y* (yes)
-				*(_attr->value) == 'Y' // Y* (Yes|YES)
-			)
-				? true : false; // Return true if matches above, else false.
-		}
-		else return false;
-	}
-
-	bool xml_attribute::empty() const
-	{
-		return (_attr == 0);
-	}
-
-	const char* xml_attribute::name() const
-	{
-		return (!empty() && _attr->name) ? _attr->name : "";
-	}
-
-	const char* xml_attribute::value() const
-	{
-		return (!empty() && _attr->value) ? _attr->value : "";
-	}
-
-	xml_node::xml_node(): _root(0)
-	{
-	}
-
-	xml_node::xml_node(const xml_node_struct* p): _root(p)
-	{
-	}
-	
-	xml_node::operator xml_node::unspecified_bool_type() const
-	{
-      	return empty() ? 0 : &xml_node::_root;
-   	}
-
-	xml_node::iterator xml_node::begin() const
-	{
-		return iterator(_root->first_child);
-	}
-
-	xml_node::iterator xml_node::end() const
-	{
-		return iterator(0, _root->last_child);
-	}
-	
-	xml_node::iterator xml_node::children_begin() const
-	{
-		return iterator(_root->first_child);
-	}
-
-	xml_node::iterator xml_node::children_end() const
-	{
-		return iterator(0, _root->last_child);
-	}
-	
-	xml_node::attribute_iterator xml_node::attributes_begin() const
-	{
-		return attribute_iterator(_root->first_attribute);
-	}
-
-	xml_node::attribute_iterator xml_node::attributes_end() const
-	{
-		return attribute_iterator(0, _root->last_attribute);
-	}
-
-	xml_node::iterator xml_node::siblings_begin() const
-	{
-		return parent().children_begin();
-	}
-
-	xml_node::iterator xml_node::siblings_end() const
-	{
-		return parent().children_end();
-	}
-
-	bool xml_node::operator==(const xml_node& r) const
-	{
-		return (_root == r._root);
-	}
-
-	bool xml_node::operator!=(const xml_node& r) const
-	{
-		return (_root != r._root);
-	}
-
-	bool xml_node::operator<(const xml_node& r) const
-	{
-		return (_root < r._root);
-	}
-	
-	bool xml_node::operator>(const xml_node& r) const
-	{
-		return (_root > r._root);
-	}
-	
-	bool xml_node::operator<=(const xml_node& r) const
-	{
-		return (_root <= r._root);
-	}
-	
-	bool xml_node::operator>=(const xml_node& r) const
-	{
-		return (_root >= r._root);
-	}
-
-	bool xml_node::empty() const
-	{
-		return (_root == 0 || _root->type == node_null);
-	}
-	
-	bool xml_node::type_document() const
-	{
-		return (_root && _root == _root->parent && _root->type == node_document);
-	}
-	
-	const char* xml_node::name() const
-	{
-		return (!empty() && _root->name) ? _root->name : "";
-	}
-
-	xml_node_type xml_node::type() const
-	{
-		return (_root) ? (xml_node_type)_root->type : node_null;
-	}
-	
-	const char* xml_node::value() const
-	{
-		return (!empty() && _root->value) ? _root->value : "";
-	}
-	
-	xml_node xml_node::child(const char* name) const
-	{
-		if (!empty())
-			for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
-				if (i->name && !strcmp(name, i->name)) return xml_node(i);
-
-		return xml_node();
-	}
-
-	xml_node xml_node::child_w(const char* name) const
-	{
-		if (!empty())
-			for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
-				if (i->name && !impl::strcmpwild(name, i->name)) return xml_node(i);
-
-		return xml_node();
-	}
-
-	xml_attribute xml_node::attribute(const char* name) const
-	{
-		if (!_root) return xml_attribute();
-
-		for (xml_attribute_struct* i = _root->first_attribute; i; i = i->next_attribute)
-			if (i->name && !strcmp(name, i->name))
-				return xml_attribute(i);
-		
-		return xml_attribute();
-	}
-	
-	xml_attribute xml_node::attribute_w(const char* name) const
-	{
-		if (!_root) return xml_attribute();
-
-		for (xml_attribute_struct* i = _root->first_attribute; i; i = i->next_attribute)
-			if (i->name && !impl::strcmpwild(name, i->name))
-				return xml_attribute(i);
-		
-		return xml_attribute();
-	}
-
-	xml_node xml_node::sibling(const char* name) const
-	{
-		if (!empty() && !type_document()) return parent().child(name);
-		else return xml_node();
-	}
-	
-	xml_node xml_node::sibling_w(const char* name) const
-	{
-		if (!empty() && !type_document()) return parent().child_w(name);
-		else return xml_node();
-	}
-
-	xml_node xml_node::next_sibling(const char* name) const
-	{
-		if(empty()) return xml_node();
-		
-		for (xml_node_struct* i = _root->next_sibling; i; i = i->next_sibling)
-			if (i->name && !strcmp(name, i->name)) return xml_node(i);
-
-		return xml_node();
-	}
-
-	xml_node xml_node::next_sibling_w(const char* name) const
-	{
-		if(empty()) return xml_node();
-		
-		for (xml_node_struct* i = _root->next_sibling; i; i = i->next_sibling)
-			if (i->name && !impl::strcmpwild(name, i->name)) return xml_node(i);
-
-		return xml_node();
-	}
-
-	xml_node xml_node::next_sibling() const
-	{
-		if(empty()) return xml_node();
-		
-		if (_root->next_sibling) return xml_node(_root->next_sibling);
-		else return xml_node();
-	}
-
-	xml_node xml_node::previous_sibling(const char* name) const
-	{
-		if (empty()) return xml_node();
-		
-		for (xml_node_struct* i = _root->prev_sibling; i; i = i->prev_sibling)
-			if (i->name && !strcmp(name, i->name)) return xml_node(i);
-
-		return xml_node();
-	}
-
-	xml_node xml_node::previous_sibling_w(const char* name) const
-	{
-		if (empty()) return xml_node();
-		
-		for (xml_node_struct* i = _root->prev_sibling; i; i = i->prev_sibling)
-			if (i->name && !impl::strcmpwild(name, i->name)) return xml_node(i);
-
-		return xml_node();
-	}
-
-	xml_node xml_node::previous_sibling() const
-	{
-		if(empty()) return xml_node();
-		
-		if (_root->prev_sibling) return xml_node(_root->prev_sibling);
-		else return xml_node();
-	}
-
-	xml_node xml_node::parent() const
-	{
-		return (!type_document()) ? xml_node(_root->parent) : xml_node();
-	}
-
-	const char* xml_node::child_value() const
-	{
-		if (!empty())
-			for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
-				if ((i->type == node_pcdata || i->type == node_cdata) && i->value)
-					return i->value;
-		return "";
-	}
-
-	const char* xml_node::child_value(const char* name) const
-	{
-		return child(name).child_value();
-	}
-
-	const char* xml_node::child_value_w(const char* name) const
-	{
-		return child_w(name).child_value();
-	}
-
-	xml_attribute xml_node::first_attribute() const
-	{
-		return _root ? xml_attribute(_root->first_attribute) : xml_attribute();
-	}
-
-	xml_attribute xml_node::last_attribute() const
-	{
-		return _root ? xml_attribute(_root->last_attribute) : xml_attribute();
-	}
-
-	xml_node xml_node::first_child() const
-	{
-		if (_root) return xml_node(_root->first_child);
-		else return xml_node();
-	}
-
-	xml_node xml_node::last_child() const
-	{
-		if (_root) return xml_node(_root->last_child);
-		else return xml_node();
-	}
-
-	namespace impl
-	{
-		xml_node first_element(const xml_node_struct* node, const char* name, strcmpfunc pred)
-		{
-			for (xml_node_struct* i = node->first_child; i; i = i->next_sibling)
-			{
-				if (i->name && !pred(name, i->name)) return xml_node(i);
-				else if (i->first_child)
-				{
-					xml_node found = first_element(i, name, pred);
-					if (found) return found; // Found.
-				}
-			}
-			return xml_node(); // Not found.
-		}
-	}
-
-	xml_node xml_node::first_element(const char* name) const
-	{
-		if (empty()) return xml_node();
-
-		return impl::first_element(_root, name, &strcmp);
-	}
-
-	xml_node xml_node::first_element_w(const char* name) const
-	{
-		if (empty()) return xml_node();
-
-		return impl::first_element(_root, name, &strcmpwildimpl);
-	}
-
-	namespace impl
-	{
-		xml_node first_element_by_value(const xml_node_struct* node, const char* name, const char* value, strcmpfunc pred)
-		{
-			for (xml_node_struct* i = node->first_child; i; i = i->next_sibling)
-			{
-				if (i->name && !pred(name,i->name))
-				{
-					for (xml_node_struct* j = i->first_child; j; j = j->next_sibling)
-						if (j->type == node_pcdata && j->value && !pred(value, j->value))
-							return xml_node(i);
-				}
-				else if (i->first_child)
-				{
-					xml_node found = first_element_by_value(i, name, value, pred);
-					if(!found.empty()) return found; // Found.
-				}
-			}
-			return xml_node(); // Not found.
-		}
-	}
-
-	xml_node xml_node::first_element_by_value(const char* name,const char* value) const
-	{
-		if (empty()) return xml_node();
-
-		return impl::first_element_by_value(_root, name, value, &strcmp);
-	}
-
-	xml_node xml_node::first_element_by_value_w(const char* name,const char* value) const
-	{
-		if (empty()) return xml_node();
-
-		return impl::first_element_by_value(_root, name, value, &strcmpwildimpl);
-	}
-
-	namespace impl
-	{
-		xml_node first_element_by_attribute(const xml_node_struct* node, const char* name, const char* attr_name, const char* attr_value, strcmpfunc pred)
-		{
-			for (xml_node_struct* i = node->first_child; i; i = i->next_sibling)
-			{
-				if (i->name && !pred(name, i->name))
-				{
-					for (xml_attribute_struct* j = i->first_attribute; j; j = j->next_attribute)
-					{
-						if (j->name && j->value && !pred(attr_name, j->name) && !pred(attr_value, j->value))
-							return xml_node(i); // Wrap it up and return.
-					}
-				}
-				else if (i->first_child)
-				{
-					xml_node found = first_element_by_attribute(i, name, attr_name, attr_value, pred);
-					if(!found.empty()) return found; // Found.
-				}
-			}
-			return xml_node(); // Not found.
-		}
-	}
-	
-	xml_node xml_node::first_element_by_attribute(const char* name,const char* attr_name,const char* attr_value) const
-	{
-		if (empty()) return xml_node();
-
-		return impl::first_element_by_attribute(_root, name, attr_name, attr_value, &strcmp);
-	}
-
-	xml_node xml_node::first_element_by_attribute_w(const char* name,const char* attr_name,const char* attr_value) const
-	{
-		if (empty()) return xml_node();
-
-		return impl::first_element_by_attribute(_root, name, attr_name, attr_value, &strcmpwildimpl);
-	}
-
-	namespace impl
-	{
-		xml_node first_element_by_attribute(const xml_node_struct* node, const char* attr_name,const char* attr_value, strcmpfunc pred)
-		{
-			for (xml_node_struct* i = node->first_child; i; i = i->next_sibling)
-			{
-				for (xml_attribute_struct* j = i->first_attribute; j; j = j->next_attribute)
-				{
-					if (j->name && j->value && !pred(attr_name, j->name) && !pred(attr_value, j->value))
-						return xml_node(i); // Wrap it up and return.
-				}
-				
-				if (i->first_child)
-				{
-					xml_node found = first_element_by_attribute(i->first_child, attr_name, attr_value, pred);
-					if (!found.empty()) return found; // Found.
-				}
-			}
-			return xml_node(); // Not found.
-		}
-	}
-
-	xml_node xml_node::first_element_by_attribute(const char* attr_name,const char* attr_value) const
-	{
-		if (empty()) return xml_node();
-
-		return impl::first_element_by_attribute(_root, attr_name, attr_value, &strcmp);
-	}
-
-	xml_node xml_node::first_element_by_attribute_w(const char* attr_name,const char* attr_value) const
-	{
-		if (empty()) return xml_node();
-
-		return impl::first_element_by_attribute(_root, attr_name, attr_value, &strcmpwildimpl);
-	}
-
-	xml_node xml_node::first_node(xml_node_type type) const
-	{
-		if(!_root) return xml_node();
-		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
-		{
-			if (i->type == type) return xml_node(i);
-			else if (i->first_child)
-			{
-				xml_node subsearch(i);
-				xml_node found = subsearch.first_node(type);
-				if(!found.empty()) return found; // Found.
-			}
-		}
-		return xml_node(); // Not found.
-	}
-
+
+#include 
+#include 
+
+#include 
+
+#ifndef PUGIXML_NO_STL
+# include 
+#endif
+
+#ifdef _MSC_VER
+#	pragma warning(disable: 4127) // conditional expression is constant
+#	pragma warning(disable: 4996) // this function or variable may be unsafe
+#endif
+
+#ifdef __BORLANDC__
+#	pragma warn -8008 // condition is always false
+#	pragma warn -8066 // unreachable code
+#endif
+
+#define STATIC_ASSERT(cond) { static const char condition_failed[(cond) ? 1 : -1] = {0}; (void)condition_failed; }
+
+namespace pugi
+{
+	class xml_allocator
+	{
+	public:
+		xml_allocator(xml_memory_block* root): _root(root)
+		{
+		}
+
+		template  T* allocate()
+		{
+			void* buf = memalloc(sizeof(T));
+			return new (buf) T();
+		}
+		
+		template  T* allocate(U val)
+		{
+			void* buf = memalloc(sizeof(T));
+			return new (buf) T(val);
+		}
+
+	private:
+		xml_memory_block* _root;
+
+		void* memalloc(size_t size)
+		{
+			if (_root->size + size <= memory_block_size)
+			{
+				void* buf = _root->data + _root->size;
+				_root->size += size;
+				return buf;
+			}
+			else
+			{
+				_root->next = new xml_memory_block();
+				_root = _root->next;
+
+				_root->size = size;
+
+				return _root->data;
+			}
+		}
+	};
+
+	/// A 'name=value' XML attribute structure.
+	struct xml_attribute_struct
+	{
+		/// Default ctor
+		xml_attribute_struct(): name_insitu(true), value_insitu(true), document_order(0), name(0), value(0), prev_attribute(0), next_attribute(0)
+		{
+		}
+
+		void free()
+		{
+			if (!name_insitu) delete[] name;
+			if (!value_insitu) delete[] value;
+		}
+	
+		bool		name_insitu : 1;
+		bool		value_insitu : 1;
+		unsigned int document_order : 30; ///< Document order value
+
+		char*		name;			///< Pointer to attribute name.
+		char*		value;			///< Pointer to attribute value.
+
+		xml_attribute_struct* prev_attribute;	///< Previous attribute
+		xml_attribute_struct* next_attribute;	///< Next attribute
+	};
+
+	/// An XML document tree node.
+	struct xml_node_struct
+	{
+		/// Default ctor
+		/// \param type - node type
+		xml_node_struct(xml_node_type type = node_element): type(type), name_insitu(true), value_insitu(true), document_order(0), parent(0), name(0), value(0), first_child(0), last_child(0), prev_sibling(0), next_sibling(0), first_attribute(0), last_attribute(0)
+		{
+		}
+
+		void free()
+		{
+			if (!name_insitu) delete[] name;
+			if (!value_insitu) delete[] value;
+
+			for (xml_node_struct* cur = first_child; cur; cur = cur->next_sibling)
+				cur->free();
+			
+			for (xml_attribute_struct* cur = first_attribute; cur; cur = cur->next_attribute)
+				cur->free();
+		}
+
+		xml_node_struct* append_node(xml_allocator& alloc, xml_node_type type = node_element)
+		{
+			xml_node_struct* child = alloc.allocate(type);
+			child->parent = this;
+			
+			if (last_child)
+			{
+				last_child->next_sibling = child;
+				child->prev_sibling = last_child;
+				last_child = child;
+			}
+			else first_child = last_child = child;
+			
+			return child;
+		}
+
+		xml_attribute_struct* append_attribute(xml_allocator& alloc)
+		{
+			xml_attribute_struct* a = alloc.allocate();
+
+			if (last_attribute)
+			{
+				last_attribute->next_attribute = a;
+				a->prev_attribute = last_attribute;
+				last_attribute = a;
+			}
+			else first_attribute = last_attribute = a;
+			
+			return a;
+		}
+
+		unsigned int			type : 3;				///< Node type; see xml_node_type.
+		bool					name_insitu : 1;
+		bool					value_insitu : 1;
+		unsigned int			document_order : 27;	///< Document order value
+
+		xml_node_struct*		parent;					///< Pointer to parent
+
+		char*					name;					///< Pointer to element name.
+		char*					value;					///< Pointer to any associated string data.
+
+		xml_node_struct*		first_child;			///< First child
+		xml_node_struct*		last_child;				///< Last child
+		
+		xml_node_struct*		prev_sibling;			///< Left brother
+		xml_node_struct*		next_sibling;			///< Right brother
+		
+		xml_attribute_struct*	first_attribute;		///< First attribute
+		xml_attribute_struct*	last_attribute;			///< Last attribute
+	};
+
+	struct xml_document_struct: public xml_node_struct
+	{
+		xml_document_struct(): xml_node_struct(node_document), allocator(0)
+		{
+		}
+
+		xml_allocator allocator;
+	};
+}
+
+namespace
+{	
+	using namespace pugi;
+
+	const unsigned char UTF8_BYTE_MASK = 0xBF;
+	const unsigned char UTF8_BYTE_MARK = 0x80;
+	const unsigned char UTF8_BYTE_MASK_READ = 0x3F;
+	const unsigned char UTF8_FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+	enum chartype
+	{
+		ct_parse_pcdata = 1,	// \0, &, \r, <
+		ct_parse_attr = 2,		// \0, &, \r, ', "
+		ct_parse_attr_ws = 4,	// \0, &, \r, ', ", \n, space, tab
+		ct_space = 8,			// \r, \n, space, tab
+		ct_parse_cdata = 16,	// \0, ], >, \r
+		ct_parse_comment = 32,	// \0, -, >, \r
+		ct_symbol = 64,			// Any symbol > 127, a-z, A-Z, 0-9, _, :, -, .
+		ct_start_symbol = 128	// Any symbol > 127, a-z, A-Z, _, :
+	};
+
+	const unsigned char chartype_table[256] =
+	{
+		55,  0,   0,   0,   0,   0,   0,   0,      0,   12,  12,  0,   0,   63,  0,   0,   // 0-15
+		0,   0,   0,   0,   0,   0,   0,   0,      0,   0,   0,   0,   0,   0,   0,   0,   // 16-31
+		12,  0,   6,   0,   0,   0,   7,   6,      0,   0,   0,   0,   0,   96,  64,  0,   // 32-47
+		64,  64,  64,  64,  64,  64,  64,  64,     64,  64,  192, 0,   1,   0,   48,  0,   // 48-63
+		0,   192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192, // 64-79
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 0,   0,   16,  0,   192, // 80-95
+		0,   192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192, // 96-111
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 0, 0, 0, 0, 0,           // 112-127
+
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192, // 128+
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192,
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192,
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192,
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192,
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192,
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192,
+		192, 192, 192, 192, 192, 192, 192, 192,    192, 192, 192, 192, 192, 192, 192, 192
+	};
+	
+	bool is_chartype(char c, chartype ct)
+	{
+		return !!(chartype_table[static_cast(c)] & ct);
+	}
+
+	bool strcpy_insitu(char*& dest, bool& insitu, const char* source)
+	{
+		size_t source_size = strlen(source);
+
+		if (dest && strlen(dest) >= source_size)
+		{
+			strcpy(dest, source);
+			
+			return true;
+		}
+		else
+		{
+			char* buf;
+
+			try
+			{
+				buf = new char[source_size + 1];
+			}
+			catch (const std::bad_alloc&)
+			{
+				return false;
+			}
+
+			strcpy(buf, source);
+
+			if (!insitu) delete[] dest;
+			
+			dest = buf;
+			insitu = false;
+
+			return true;
+		}
+	}
+
+	// Get the size that is needed for strutf16_utf8 applied to all s characters
+	size_t strutf16_utf8_size(const wchar_t* s)
+	{
+		size_t length = 0;
+
+		for (; *s; ++s)
+		{
+			unsigned int ch = *s;
+
+			if (ch < 0x80) length += 1;
+			else if (ch < 0x800) length += 2;
+			else if (ch < 0x10000) length += 3;
+			else if (ch < 0x200000) length += 4;
+		}
+
+		return length;
+	}
+
+	// Write utf16 char to stream, return position after the last written char
+	// \return position after last char
+	char* strutf16_utf8(char* s, unsigned int ch)
+	{
+		unsigned int length;
+
+		if (ch < 0x80) length = 1;
+		else if (ch < 0x800) length = 2;
+		else if (ch < 0x10000) length = 3;
+		else if (ch < 0x200000) length = 4;
+		else return s;
+	
+		s += length;
+
+		// Scary scary fall throughs.
+		switch (length)
+		{
+			case 4:
+				*--s = (char)((ch | UTF8_BYTE_MARK) & UTF8_BYTE_MASK); 
+				ch >>= 6;
+			case 3:
+				*--s = (char)((ch | UTF8_BYTE_MARK) & UTF8_BYTE_MASK); 
+				ch >>= 6;
+			case 2:
+				*--s = (char)((ch | UTF8_BYTE_MARK) & UTF8_BYTE_MASK); 
+				ch >>= 6;
+			case 1:
+				*--s = (char)(ch | UTF8_FIRST_BYTE_MARK[length]);
+		}
+		
+		return s + length;
+	}
+
+	// Get the size that is needed for strutf8_utf16 applied to all s characters
+	size_t strutf8_utf16_size(const char* s)
+	{
+		size_t length = 0;
+
+		for (; *s; ++s)
+		{
+			unsigned char ch = static_cast(*s);
+
+			if (ch < 0x80 || (ch >= 0xC0 && ch < 0xFC)) ++length;
+		}
+
+		return length;
+	}
+
+	// Read utf16 char from utf8 stream, return position after the last read char
+	// \return position after the last char
+	const char* strutf8_utf16(const char* s, unsigned int& ch)
+	{
+		unsigned int length;
+
+		const unsigned char* str = reinterpret_cast(s);
+
+		if (*str < UTF8_BYTE_MARK)
+		{
+			ch = *str;
+			return s + 1;
+		}
+		else if (*str < 0xC0)
+		{
+			ch = ' ';
+			return s + 1;
+		}
+		else if (*str < 0xE0) length = 2;
+		else if (*str < 0xF0) length = 3;
+		else if (*str < 0xF8) length = 4;
+		else if (*str < 0xFC) length = 5;
+		else
+		{
+			ch = ' ';
+			return s + 1;
+		}
+
+		ch = (*str++ & ~UTF8_FIRST_BYTE_MARK[length]);
+	
+		// Scary scary fall throughs.
+		switch (length) 
+		{
+			case 5:
+				ch <<= 6;
+				ch += (*str++ & UTF8_BYTE_MASK_READ);
+			case 4:
+				ch <<= 6;
+				ch += (*str++ & UTF8_BYTE_MASK_READ);
+			case 3:
+				ch <<= 6;
+				ch += (*str++ & UTF8_BYTE_MASK_READ);
+			case 2:
+				ch <<= 6;
+				ch += (*str++ & UTF8_BYTE_MASK_READ);
+		}
+		
+		return reinterpret_cast(str);
+	}
+
 #ifndef PUGIXML_NO_STL
-	std::string xml_node::path(char delimiter) const
-	{
-		std::string path;
-
-		xml_node cursor = *this; // Make a copy.
-		
-		path = cursor.name();
-
-		while (cursor.parent() && !cursor.type_document()) // Loop to parent (stopping on actual root because it has no name).
-		{
-			cursor = cursor.parent();
-			
-			std::string temp = cursor.name();
-			temp += delimiter;
-			temp += path;
-			path.swap(temp);
-		}
-
-		return path;
-	}
+	template  void text_output_escaped(std::ostream& os, const char* s)
+	{
+		while (*s)
+		{
+			const char* prev = s;
+			
+			// While *s is a usual symbol
+			while (*s && *s != '&' && *s != '<' && *s != '>' && ((*s != '"' && *s != '\'') || !quotes)
+					&& (*s >= 32 || *s == '\r' || *s == '\n' || *s == '\t'))
+				++s;
+		
+			if (prev != s) os.write(prev, static_cast(s - prev));
+
+			switch (*s)
+			{
+				case 0: break;
+				case '&':
+					os << "&";
+					++s;
+					break;
+				case '<':
+					os << "<";
+					++s;
+					break;
+				case '>':
+					os << ">";
+					++s;
+					break;
+				case '"':
+					os << """;
+					++s;
+					break;
+				case '\'':
+					os << "'";
+					++s;
+					break;
+				default: // s is not a usual symbol
+				{
+					unsigned int ch;
+					
+					if (utf8)
+						s = strutf8_utf16(s, ch);
+					else
+						ch = (unsigned char)*s++;
+
+					os << "&#" << ch << ";";
+				}
+			}
+		}
+	}
 #endif
-
-	xml_node xml_node::first_element_by_path(const char* path, char delimiter) const
-	{
-		xml_node found = *this; // Current search context.
-
-		if (empty() || !path || !path[0]) return found;
-
-		if (path[0] == delimiter)
-		{
-			// Absolute path; e.g. '/foo/bar'
-			while (found.parent()) found = found.parent();
-			++path;
-		}
-
-		const char* path_segment = path;
-
-		while (*path_segment == delimiter) ++path_segment;
-
-		const char* path_segment_end = path_segment;
-
-		while (*path_segment_end && *path_segment_end != delimiter) ++path_segment_end;
-
-		if (path_segment == path_segment_end) return found;
-
-		const char* next_segment = path_segment_end;
-
-		while (*next_segment == delimiter) ++next_segment;
-
-		if (*path_segment == '.' && path_segment + 1 == path_segment_end)
-			return found.first_element_by_path(next_segment, delimiter);
-		else if (*path_segment == '.' && *(path_segment+1) == '.' && path_segment + 2 == path_segment_end)
-			return found.parent().first_element_by_path(next_segment, delimiter);
-		else
-		{
-			for (xml_node_struct* j = found._root->first_child; j; j = j->next_sibling)
-			{
-				if (j->name && !strcmprange(j->name, path_segment, path_segment_end))
-				{
-					xml_node subsearch = xml_node(j).first_element_by_path(next_segment, delimiter);
-
-					if (subsearch) return subsearch;
-				}
-			}
-
-			return xml_node();
-		}
-	}
-
-	bool xml_node::traverse(xml_tree_walker& walker) const
-	{
-		if (!walker.begin(*this)) return false; // Send the callback for begin traverse if depth is zero.
-		if(!empty()) // Don't traverse if this is a null node.
-		{
-			walker.push(); // Increment the walker depth counter.
-
-			for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
-			{
-				xml_node subsearch(i);
-				if (!subsearch.traverse(walker)) return false;
-			}
-			walker.pop(); // Decrement the walker depth counter.
-		}
-		if (!walker.end(*this)) return false; // Send the callback for end traverse if depth is zero.
-		
-		return true;
-	}
-
-	xml_node_iterator::xml_node_iterator()
-	{
-	}
-
-	xml_node_iterator::xml_node_iterator(const xml_node& node): _wrap(node)
-	{
-	}
-
-	xml_node_iterator::xml_node_iterator(const xml_node_struct* ref): _wrap(ref)
-	{
-	}
-		
-	xml_node_iterator::xml_node_iterator(const xml_node_struct* ref, const xml_node_struct* prev): _prev(prev), _wrap(ref)
-	{
-	}
-
-	bool xml_node_iterator::operator==(const xml_node_iterator& rhs) const
-	{
-		return (_wrap == rhs._wrap);
-	}
-	
-	bool xml_node_iterator::operator!=(const xml_node_iterator& rhs) const
-	{
-		return (_wrap != rhs._wrap);
-	}
-
-	const xml_node& xml_node_iterator::operator*() const
-	{
-		return _wrap;
-	}
-
-	const xml_node* xml_node_iterator::operator->() const
-	{
-		return &_wrap;
-	}
-
-	const xml_node_iterator& xml_node_iterator::operator++()
-	{
-		_prev = _wrap;
-		_wrap = xml_node(_wrap._root->next_sibling);
-		return *this;
-	}
-
-	xml_node_iterator xml_node_iterator::operator++(int)
-	{
-		xml_node_iterator temp = *this;
-		++*this;
-		return temp;
-	}
-
-	const xml_node_iterator& xml_node_iterator::operator--()
-	{
-		if (_wrap._root) _wrap = xml_node(_wrap._root->prev_sibling);
-		else _wrap = _prev;
-		return *this;
-	}
-
-	xml_node_iterator xml_node_iterator::operator--(int)
-	{
-		xml_node_iterator temp = *this;
-		--*this;
-		return temp;
-	}
-
-	xml_attribute_iterator::xml_attribute_iterator()
-	{
-	}
-
-	xml_attribute_iterator::xml_attribute_iterator(const xml_attribute& attr): _wrap(attr)
-	{
-	}
-
-	xml_attribute_iterator::xml_attribute_iterator(const xml_attribute_struct* ref): _wrap(ref)
-	{
-	}
-		
-	xml_attribute_iterator::xml_attribute_iterator(const xml_attribute_struct* ref, const xml_attribute_struct* prev): _prev(prev), _wrap(ref)
-	{
-	}
-
-	bool xml_attribute_iterator::operator==(const xml_attribute_iterator& rhs) const
-	{
-		return (_wrap == rhs._wrap);
-	}
-	
-	bool xml_attribute_iterator::operator!=(const xml_attribute_iterator& rhs) const
-	{
-		return (_wrap != rhs._wrap);
-	}
-
-	const xml_attribute& xml_attribute_iterator::operator*() const
-	{
-		return _wrap;
-	}
-
-	const xml_attribute* xml_attribute_iterator::operator->() const
-	{
-		return &_wrap;
-	}
-
-	const xml_attribute_iterator& xml_attribute_iterator::operator++()
-	{
-		_prev = _wrap;
-		_wrap = xml_attribute(_wrap._attr->next_attribute);
-		return *this;
-	}
-
-	xml_attribute_iterator xml_attribute_iterator::operator++(int)
-	{
-		xml_attribute_iterator temp = *this;
-		++*this;
-		return temp;
-	}
-
-	const xml_attribute_iterator& xml_attribute_iterator::operator--()
-	{
-		if (_wrap._attr) _wrap = xml_attribute(_wrap._attr->prev_attribute);
-		else _wrap = _prev;
-		return *this;
-	}
-
-	xml_attribute_iterator xml_attribute_iterator::operator--(int)
-	{
-		xml_attribute_iterator temp = *this;
-		--*this;
-		return temp;
-	}
-
-	xml_memory_block::xml_memory_block(): next(0), size(0)
-	{
-	}
-
-	xml_parser::xml_parser(unsigned int optmsk): _buffer(0), _xmldoc(0), _optmsk(optmsk)
-	{
-	}
-
-#ifndef PUGIXML_NO_STL
-	xml_parser::xml_parser(std::istream& stream,unsigned int optmsk): _buffer(0), _xmldoc(0), _optmsk(optmsk)
-	{
-		parse(stream, _optmsk);
-	}
-#endif
-
-	xml_parser::xml_parser(char* xmlstr,unsigned int optmsk): _buffer(0), _xmldoc(0), _optmsk(optmsk)
-	{
-		parse(xmlstr, _optmsk);
-	}
-
-	xml_parser::xml_parser(const transfer_ownership_tag& tag, char* xmlstr ,unsigned int optmsk): _buffer(0), _xmldoc(0), _optmsk(optmsk)
-	{
-		parse(tag, xmlstr, _optmsk);
-	}
-
-	xml_parser::~xml_parser()
-	{
-		free();
-	}
-
-	void xml_parser::free()
-	{
-		delete _buffer;
-		_buffer = 0;
-
-		xml_memory_block* current = _memory.next;
-
-		while (current)
-		{
-			xml_memory_block* next = current->next;
-			delete current;
-			current = next;
-		}
-		
-		_memory.next = 0;
-		_memory.size = 0;
-	}
-
-	xml_parser::operator xml_node() const
-	{
-		return xml_node(_xmldoc);
-	}
-	
-	xml_node xml_parser::document() const
-	{
-		return xml_node(_xmldoc);
-	}
-
-	unsigned int xml_parser::options() const
-	{
-		return _optmsk;
-	}
-
-	unsigned int xml_parser::options(unsigned int optmsk)
-	{
-		unsigned int prev = _optmsk;
-		_optmsk = optmsk;
-		return prev;
-	}
-
-#ifndef PUGIXML_NO_STL
-	void xml_parser::parse(std::istream& stream,unsigned int optmsk)
-	{
-		free();
-
-		std::streamoff length = 0, pos = stream.tellg();
-		stream.seekg(0, std::ios_base::end);
-		length = stream.tellg();
-		stream.seekg(pos, std::ios_base::beg);
-
-		char* s = new char[length + 1];
-		stream.read(s, length);
-		s[length] = 0;
-
-		parse(transfer_ownership_tag(), s, optmsk); // Parse the input string.
-	}
-#endif
-
-	char* xml_parser::parse(char* xmlstr,unsigned int optmsk)
-	{
-		free();
-
-		if(!xmlstr) return 0;
-
-		xml_allocator alloc(&_memory);
-		
-		_xmldoc = alloc.allocate(node_document); // Allocate a new root.
-		_xmldoc->parent = _xmldoc; // Point to self.
-		if(optmsk != parse_noset) _optmsk = optmsk;
-		
-		xml_parser_impl parser(alloc);
-		
-		return parser.parse(xmlstr,_xmldoc,_optmsk); // Parse the input string.
-	}
-	
-	char* xml_parser::parse(const transfer_ownership_tag&, char* xmlstr,unsigned int optmsk)
-	{
-		free();
-
-		if(!xmlstr) return 0;
-
-		_buffer = xmlstr;
-
-		xml_allocator alloc(&_memory);
-		
-		_xmldoc = alloc.allocate(node_document); // Allocate a new root.
-		_xmldoc->parent = _xmldoc; // Point to self.
-		if(optmsk != parse_noset) _optmsk = optmsk;
-		
-		xml_parser_impl parser(alloc);
-		
-		return parser.parse(xmlstr,_xmldoc,_optmsk); // Parse the input string.
-	}
-
-#ifndef PUGIXML_NO_STL
-	std::string utf8(const wchar_t* str)
-	{
-		std::string result;
-		result.reserve(strutf16_utf8_size(str));
-	  
-		for (; *str; ++str)
-		{
-			char buffer[6];
-	  	
-			result.append(buffer, strutf16_utf8(buffer, *str));
-		}
-	  	
-	  	return result;
-	}
-	
-	std::wstring utf16(const char* str)
-	{
-		std::wstring result;
-		result.reserve(strutf8_utf16_size(str));
-
-		for (; *str;)
-		{
-			unsigned int ch;
-			str = strutf8_utf16(str, ch);
-			result += (wchar_t)ch;
-		}
-
-		return result;
-	}
-#endif
-}
+
+	struct gap
+	{
+		char* end;
+		size_t size;
+			
+		gap(): end(0), size(0)
+		{
+		}
+			
+		// Push new gap, move s count bytes further (skipping the gap).
+		// Collapse previous gap.
+		void push(char*& s, size_t count)
+		{
+			if (end) // there was a gap already; collapse it
+			{
+				// Move [old_gap_end, new_gap_start) to [old_gap_start, ...)
+				std::memmove(end - size, end, s - end);
+			}
+				
+			s += count; // end of current gap
+				
+			// "merge" two gaps
+			end = s;
+			size += count;
+		}
+			
+		// Collapse all gaps, return past-the-end pointer
+		char* flush(char* s)
+		{
+			if (end)
+			{
+				// Move [old_gap_end, current_pos) to [old_gap_start, ...)
+				std::memmove(end - size, end, s - end);
+
+				return s - size;
+			}
+			else return s;
+		}
+	};
+	
+	char* strconv_escape(char* s, gap& g)
+	{
+		char* stre = s + 1;
+
+		switch (*stre)
+		{
+			case '#':	// &#...
+			{
+				unsigned int ucsc = 0;
+
+				++stre;
+
+				if (*stre == 'x') // &#x... (hex code)
+				{
+					++stre;
+					
+					while (*stre)
+					{
+						if (*stre >= '0' && *stre <= '9')
+							ucsc = 16 * ucsc + (*stre++ - '0');
+						else if (*stre >= 'A' && *stre <= 'F')
+							ucsc = 16 * ucsc + (*stre++ - 'A' + 10);
+						else if (*stre >= 'a' && *stre <= 'f')
+							ucsc = 16 * ucsc + (*stre++ - 'a' + 10);
+						else if (*stre == ';')
+							break;
+						else // cancel
+							return stre;
+					}
+
+					if (*stre != ';') return stre;
+						
+					++stre;
+				}
+				else	// &#... (dec code)
+				{
+					while (*stre >= '0' && *stre <= '9')
+						ucsc = 10 * ucsc + (*stre++ - '0');
+
+					if (*stre != ';') return stre;
+						
+					++stre;
+				}
+
+				s = strutf16_utf8(s, ucsc);
+					
+				g.push(s, stre - s);
+				return stre;
+			}
+			case 'a':	// &a
+			{
+				++stre;
+
+				if (*stre == 'm') // &am
+				{
+					if (*++stre == 'p' && *++stre == ';') // &
+					{
+						*s++ = '&';
+						++stre;
+							
+						g.push(s, stre - s);
+						return stre;
+					}
+				}
+				else if (*stre == 'p') // &ap
+				{
+					if (*++stre == 'o' && *++stre == 's' && *++stre == ';') // '
+					{
+						*s++ = '\'';
+						++stre;
+
+						g.push(s, stre - s);
+						return stre;
+					}
+				}
+				break;
+			}
+			case 'g': // &g
+			{
+				if (*++stre == 't' && *++stre == ';') // >
+				{
+					*s++ = '>';
+					++stre;
+					
+					g.push(s, stre - s);
+					return stre;
+				}
+				break;
+			}
+			case 'l': // &l
+			{
+				if (*++stre == 't' && *++stre == ';') // <
+				{
+					*s++ = '<';
+					++stre;
+						
+					g.push(s, stre - s);
+					return stre;
+				}
+				break;
+			}
+			case 'q': // &q
+			{
+				if (*++stre == 'u' && *++stre == 'o' && *++stre == 't' && *++stre == ';') // "
+				{
+					*s++ = '"';
+					++stre;
+					
+					g.push(s, stre - s);
+					return stre;
+				}
+				break;
+			}
+		}
+		
+		return stre;
+	}
+
+	char* strconv_comment(char* s)
+	{
+		if (!*s) return 0;
+		
+		gap g;
+		
+		while (true)
+		{
+			while (!is_chartype(*s, ct_parse_comment)) ++s;
+		
+			if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
+			{
+				*s++ = '\n'; // replace first one with 0x0a
+				
+				if (*s == '\n') g.push(s, 1);
+			}
+			else if (*s == '-' && *(s+1) == '-' && *(s+2) == '>') // comment ends here
+			{
+				*g.flush(s) = 0;
+				
+				return s + 3;
+			}
+			else if (*s == 0)
+			{
+				return 0;
+			}
+			else ++s;
+		}
+	}
+
+	char* strconv_cdata(char* s)
+	{
+		if (!*s) return 0;
+			
+		gap g;
+			
+		while (true)
+		{
+			while (!is_chartype(*s, ct_parse_cdata)) ++s;
+			
+			if (*s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
+			{
+				*s++ = '\n'; // replace first one with 0x0a
+				
+				if (*s == '\n') g.push(s, 1);
+			}
+			else if (*s == ']' && *(s+1) == ']' && *(s+2) == '>') // CDATA ends here
+			{
+				*g.flush(s) = 0;
+				
+				return s + 1;
+			}
+			else if (*s == 0)
+			{
+				return 0;
+			}
+			else ++s;
+		}
+	}
+		
+	template  char* strconv_pcdata_t(char* s)
+	{
+		if (!*s) return 0;
+
+		gap g;
+		
+		while (true)
+		{
+			while (!is_chartype(*s, ct_parse_pcdata)) ++s;
+				
+			if (opt_eol && *s == '\r') // Either a single 0x0d or 0x0d 0x0a pair
+			{
+				*s++ = '\n'; // replace first one with 0x0a
+				
+				if (*s == '\n') g.push(s, 1);
+			}
+			else if (opt_escape && *s == '&')
+			{
+				s = strconv_escape(s, g);
+			}
+			else if (*s == '<') // PCDATA ends here
+			{
+				*g.flush(s) = 0;
+				
+				return s + 1;
+			}
+			else if (*s == 0)
+			{
+				return s;
+			}
+			else ++s;
+		}
+	}
+
+	char* strconv_pcdata(char* s, unsigned int optmask)
+	{
+		STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20);
+
+		switch ((optmask >> 4) & 3) // get bitmask for flags (eol escapes)
+		{
+		case 0: return strconv_pcdata_t<0, 0>(s);
+		case 1: return strconv_pcdata_t<0, 1>(s);
+		case 2: return strconv_pcdata_t<1, 0>(s);
+		case 3: return strconv_pcdata_t<1, 1>(s);
+		default: return 0; // should not get here
+		}
+	}
+
+	template  char* strconv_attribute_t(char* s, char end_quote)
+	{
+		if (!*s) return 0;
+			
+		gap g;
+
+		// Trim whitespaces
+		if (opt_wnorm)
+		{
+			char* str = s;
+			
+			while (is_chartype(*str, ct_space)) ++str;
+			
+			if (str != s)
+				g.push(s, str - s);
+		}
+			
+		while (true)
+		{
+			while (!is_chartype(*s, (opt_wnorm || opt_wconv) ? ct_parse_attr_ws : ct_parse_attr)) ++s;
+			
+			if (opt_escape && *s == '&')
+			{
+				s = strconv_escape(s, g);
+			}
+			else if (opt_wnorm && is_chartype(*s, ct_space))
+			{
+				*s++ = ' ';
+	
+				if (is_chartype(*s, ct_space))
+				{
+					char* str = s + 1;
+					while (is_chartype(*str, ct_space)) ++str;
+					
+					g.push(s, str - s);
+				}
+			}
+			else if (opt_wconv && is_chartype(*s, ct_space))
+			{
+				if (opt_eol)
+				{
+					if (*s == '\r')
+					{
+						*s++ = ' ';
+				
+						if (*s == '\n') g.push(s, 1);
+					}
+					else *s++ = ' ';
+				}
+				else *s++ = ' ';
+			}
+			else if (opt_eol && *s == '\r')
+			{
+				*s++ = '\n';
+				
+				if (*s == '\n') g.push(s, 1);
+			}
+			else if (*s == end_quote)
+			{
+				char* str = g.flush(s);
+				
+				if (opt_wnorm)
+				{
+					do *str-- = 0;
+					while (is_chartype(*str, ct_space));
+				}
+				else *str = 0;
+			
+				return s + 1;
+			}
+			else if (!*s)
+			{
+				return 0;
+			}
+			else ++s;
+		}
+	}
+	
+	char* strconv_attribute(char* s, char end_quote, unsigned int optmask)
+	{
+		STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20 && parse_wnorm_attribute == 0x40 && parse_wconv_attribute == 0x80);
+	
+		switch ((optmask >> 4) & 15) // get bitmask for flags (wconv wnorm eol escapes)
+		{
+		case 0: return strconv_attribute_t <0, 0, 0, 0>(s, end_quote);
+		case 1: return strconv_attribute_t <0, 0, 0, 1>(s, end_quote);
+		case 2: return strconv_attribute_t <0, 0, 1, 0>(s, end_quote);
+		case 3: return strconv_attribute_t <0, 0, 1, 1>(s, end_quote);
+		case 4: return strconv_attribute_t <0, 1, 0, 0>(s, end_quote);
+		case 5: return strconv_attribute_t <0, 1, 0, 1>(s, end_quote);
+		case 6: return strconv_attribute_t <0, 1, 1, 0>(s, end_quote);
+		case 7: return strconv_attribute_t <0, 1, 1, 1>(s, end_quote);
+		case 8: return strconv_attribute_t <1, 0, 0, 0>(s, end_quote);
+		case 9: return strconv_attribute_t <1, 0, 0, 1>(s, end_quote);
+		case 10: return strconv_attribute_t<1, 0, 1, 0>(s, end_quote);
+		case 11: return strconv_attribute_t<1, 0, 1, 1>(s, end_quote);
+		case 12: return strconv_attribute_t<1, 1, 0, 0>(s, end_quote);
+		case 13: return strconv_attribute_t<1, 1, 0, 1>(s, end_quote);
+		case 14: return strconv_attribute_t<1, 1, 1, 0>(s, end_quote);
+		case 15: return strconv_attribute_t<1, 1, 1, 1>(s, end_quote);
+		default: return 0; // should not get here
+		}
+	}
+
+	struct xml_parser
+	{
+		xml_allocator& alloc;
+		
+		// Parser utilities.
+		#define SKIPWS()			{ while (is_chartype(*s, ct_space)) ++s; }
+		#define OPTSET(OPT)			( optmsk & OPT )
+		#define PUSHNODE(TYPE)		{ cursor = cursor->append_node(alloc,TYPE); }
+		#define POPNODE()			{ cursor = cursor->parent; }
+		#define SCANFOR(X)			{ while (*s != 0 && !(X)) ++s; }
+		#define SCANWHILE(X)		{ while ((X)) ++s; }
+		#define ENDSEG()			{ ch = *s; *s = 0; ++s; }
+		#define CHECK_ERROR()		{ if (*s == 0) return false; }
+		
+		xml_parser(xml_allocator& alloc): alloc(alloc)
+		{
+		}
+		
+		bool parse(char* s, xml_node_struct* xmldoc, unsigned int optmsk = parse_default)
+		{
+			if (!s || !xmldoc) return false;
+
+			// UTF-8 BOM
+			if ((unsigned char)*s == 0xEF && (unsigned char)*(s+1) == 0xBB && (unsigned char)*(s+2) == 0xBF)
+				s += 3;
+				
+			char ch = 0;
+			xml_node_struct* cursor = xmldoc;
+			char* mark = s;
+
+			while (*s != 0)
+			{
+				if (*s == '<')
+				{
+					++s;
+
+				LOC_TAG:
+					if (*s == '?') // '') return false;
+								++s;
+
+								// stricmp / strcasecmp is not portable
+								if ((mark[0] == 'x' || mark[0] == 'X') && (mark[1] == 'm' || mark[1] == 'M')
+									&& (mark[2] == 'l' || mark[2] == 'L') && mark[3] == 0)
+								{
+								}
+								else
+								{
+									PUSHNODE(node_pi); // Append a new node on the tree.
+
+									cursor->name = mark;
+
+									POPNODE();
+								}
+							}
+							// stricmp / strcasecmp is not portable
+							else if ((mark[0] == 'x' || mark[0] == 'X') && (mark[1] == 'm' || mark[1] == 'M')
+								&& (mark[2] == 'l' || mark[2] == 'L') && mark[3] == 0)
+							{
+								SCANFOR(*s == '?' && *(s+1) == '>'); // Look for '?>'.
+								CHECK_ERROR();
+								s += 2;
+							}
+							else
+							{
+								PUSHNODE(node_pi); // Append a new node on the tree.
+
+								cursor->name = mark;
+
+								if (is_chartype(ch, ct_space))
+								{
+									SKIPWS();
+									CHECK_ERROR();
+	
+									mark = s;
+								}
+								else mark = 0;
+
+								SCANFOR(*s == '?' && *(s+1) == '>'); // Look for '?>'.
+								CHECK_ERROR();
+
+								ENDSEG();
+								CHECK_ERROR();
+
+								++s; // Step over >
+
+								cursor->value = mark;
+
+								POPNODE();
+							}
+						}
+						else // not parsing PI
+						{
+							SCANFOR(*s == '?' && *(s+1) == '>'); // Look for '?>'.
+							CHECK_ERROR();
+
+							s += 2;
+						}
+					}
+					else if (*s == '!') // 'value = s; // Save the offset.
+								}
+
+								if (OPTSET(parse_eol) && OPTSET(parse_comments))
+								{
+									s = strconv_comment(s);
+									
+									if (!s) return false;
+								}
+								else
+								{
+									// Scan for terminating '-->'.
+									SCANFOR(*s == '-' && *(s+1) == '-' && *(s+2) == '>');
+									CHECK_ERROR();
+								
+									if (OPTSET(parse_comments))
+										*s = 0; // Zero-terminate this segment at the first terminating '-'.
+									
+									s += 3; // Step over the '\0->'.
+								}
+								
+								if (OPTSET(parse_comments))
+								{
+									POPNODE(); // Pop since this is a standalone.
+								}
+							}
+							else return false;
+						}
+						else if(*s == '[')
+						{
+							// 'value = s; // Save the offset.
+
+									if (OPTSET(parse_eol))
+									{
+										s = strconv_cdata(s);
+										
+										if (!s) return false;
+									}
+									else
+									{
+										// Scan for terminating ']]>'.
+										SCANFOR(*s == ']' && *(s+1) == ']' && *(s+2) == '>');
+										CHECK_ERROR();
+
+										ENDSEG(); // Zero-terminate this segment.
+										CHECK_ERROR();
+									}
+
+									POPNODE(); // Pop since this is a standalone.
+								}
+								else // Flagged for discard, but we still have to scan for the terminator.
+								{
+									// Scan for terminating ']]>'.
+									SCANFOR(*s == ']' && *(s+1) == ']' && *(s+2) == '>');
+									CHECK_ERROR();
+
+									++s;
+								}
+
+								s += 2; // Step over the last ']>'.
+							}
+							else return false;
+						}
+						else if (*s=='D' && *++s=='O' && *++s=='C' && *++s=='T' && *++s=='Y' && *++s=='P' && *++s=='E')
+						{
+							++s;
+
+							SKIPWS(); // Eat any whitespace.
+							CHECK_ERROR();
+
+						LOC_DOCTYPE:
+							SCANFOR(*s == '\'' || *s == '"' || *s == '[' || *s == '>');
+							CHECK_ERROR();
+
+							if (*s == '\'' || *s == '"') // '...SYSTEM "..."
+							{
+								ch = *s++;
+								SCANFOR(*s == ch);
+								CHECK_ERROR();
+
+								++s;
+								goto LOC_DOCTYPE;
+							}
+
+							if(*s == '[') // '...[...'
+							{
+								++s;
+								unsigned int bd = 1; // Bracket depth counter.
+								while (*s!=0) // Loop till we're out of all brackets.
+								{
+									if (*s == ']') --bd;
+									else if (*s == '[') ++bd;
+									if (bd == 0) break;
+									++s;
+								}
+							}
+							
+							SCANFOR(*s == '>');
+							CHECK_ERROR();
+
+							++s;
+						}
+						else return false;
+					}
+					else if (is_chartype(*s, ct_start_symbol)) // '<#...'
+					{
+						PUSHNODE(node_element); // Append a new node to the tree.
+
+						cursor->name = s;
+
+						SCANWHILE(is_chartype(*s, ct_symbol)); // Scan for a terminator.
+						CHECK_ERROR();
+
+						ENDSEG(); // Save char in 'ch', terminate & step over.
+						CHECK_ERROR();
+
+						if (ch == '/') // '<#.../'
+						{
+							if (*s != '>') return false;
+							
+							POPNODE(); // Pop.
+
+							++s;
+						}
+						else if (ch == '>')
+						{
+							// end of tag
+						}
+						else if (is_chartype(ch, ct_space))
+						{
+						    while (*s)
+						    {
+								SKIPWS(); // Eat any whitespace.
+								CHECK_ERROR();
+						
+								if (is_chartype(*s, ct_start_symbol)) // <... #...
+								{
+									xml_attribute_struct* a = cursor->append_attribute(alloc); // Make space for this attribute.
+									a->name = s; // Save the offset.
+
+									SCANWHILE(is_chartype(*s, ct_symbol)); // Scan for a terminator.
+									CHECK_ERROR();
+
+									ENDSEG(); // Save char in 'ch', terminate & step over.
+									CHECK_ERROR();
+
+									if (is_chartype(ch, ct_space))
+									{
+										SKIPWS(); // Eat any whitespace.
+										CHECK_ERROR();
+
+										ch = *s;
+										++s;
+									}
+									
+									if (ch == '=') // '<... #=...'
+									{
+										SKIPWS(); // Eat any whitespace.
+										CHECK_ERROR();
+
+										if (*s == '\'' || *s == '"') // '<... #="...'
+										{
+											ch = *s; // Save quote char to avoid breaking on "''" -or- '""'.
+											++s; // Step over the quote.
+											a->value = s; // Save the offset.
+
+											s = strconv_attribute(s, ch, optmsk);
+										
+											if (!s) return false;
+
+											// After this line the loop continues from the start;
+											// Whitespaces, / and > are ok, symbols are wrong,
+											// everything else will be detected
+											if (is_chartype(*s, ct_start_symbol)) return false;
+										}
+										else return false;
+									}
+									else return false;
+								}
+								else if (*s == '/')
+								{
+									++s;
+
+									if (*s != '>') return false;
+							
+									POPNODE(); // Pop.
+
+									++s;
+
+									break;
+								}
+								else if (*s == '>')
+								{
+									++s;
+
+									break;
+								}
+								else return false;
+							}
+						}
+						else return false;
+					}
+					else if (*s == '/')
+					{
+						++s;
+
+						if (!cursor) return false;
+
+						char* name = cursor->name;
+						if (!name) return false;
+						
+						while (*s && is_chartype(*s, ct_symbol))
+						{
+							if (*s++ != *name++) return false;
+						}
+
+						if (*name) return false;
+							
+						POPNODE(); // Pop.
+
+						SKIPWS();
+						CHECK_ERROR();
+
+						if (*s != '>') return false;
+						++s;
+					}
+					else return false;
+				}
+				else
+				{
+					mark = s; // Save this offset while searching for a terminator.
+
+					SKIPWS(); // Eat whitespace if no genuine PCDATA here.
+
+					if ((mark == s || !OPTSET(parse_ws_pcdata)) && (!*s || *s == '<'))
+					{
+						continue;
+					}
+
+					s = mark;
+							
+					if (static_cast(cursor->type) != node_document)
+					{
+						PUSHNODE(node_pcdata); // Append a new node on the tree.
+						cursor->value = s; // Save the offset.
+
+						s = strconv_pcdata(s, optmsk);
+								
+						if (!s) return false;
+								
+						POPNODE(); // Pop since this is a standalone.
+						
+						if (!*s) break;
+					}
+					else
+					{
+						SCANFOR(*s == '<'); // '...<'
+						if (!*s) break;
+						
+						++s;
+					}
+
+					// We're after '<'
+					goto LOC_TAG;
+				}
+			}
+
+			if (cursor != xmldoc) return false;
+			
+			return true;
+		}
+		
+	private:
+		xml_parser(const xml_parser&);
+		const xml_parser& operator=(const xml_parser&);
+	};
+
+	// Compare lhs with [rhs_begin, rhs_end)
+	int strcmprange(const char* lhs, const char* rhs_begin, const char* rhs_end)
+	{
+		while (*lhs && rhs_begin != rhs_end && *lhs == *rhs_begin)
+		{
+			++lhs;
+			++rhs_begin;
+		}
+		
+		if (rhs_begin == rhs_end && *lhs == 0) return 0;
+		else return 1;
+	}
+	
+	// Character set pattern match.
+	int strcmpwild_cset(const char** src, const char** dst)
+	{
+		int find = 0, excl = 0, star = 0;
+		
+		if (**src == '!')
+		{
+			excl = 1;
+			++(*src);
+		}
+		
+		while (**src != ']' || star == 1)
+		{
+			if (find == 0)
+			{
+				if (**src == '-' && *(*src-1) < *(*src+1) && *(*src+1) != ']' && star == 0)
+				{
+					if (**dst >= *(*src-1) && **dst <= *(*src+1))
+					{
+						find = 1;
+						++(*src);
+					}
+				}
+				else if (**src == **dst) find = 1;
+			}
+			++(*src);
+			star = 0;
+		}
+
+		if (excl == 1) find = (1 - find);
+		if (find == 1) ++(*dst);
+	
+		return find;
+	}
+
+	// Wildcard pattern match.
+	int strcmpwild_astr(const char** src, const char** dst)
+	{
+		int find = 1;
+		++(*src);
+		while ((**dst != 0 && **src == '?') || **src == '*')
+		{
+			if(**src == '?') ++(*dst);
+			++(*src);
+		}
+		while (**src == '*') ++(*src);
+		if (**dst == 0 && **src != 0) return 0;
+		if (**dst == 0 && **src == 0) return 1;
+		else
+		{
+			if (impl::strcmpwild(*src,*dst))
+			{
+				do
+				{
+					++(*dst);
+					while(**src != **dst && **src != '[' && **dst != 0) 
+						++(*dst);
+				}
+				while ((**dst != 0) ? impl::strcmpwild(*src,*dst) : 0 != (find=0));
+			}
+			if (**dst == 0 && **src == 0) find = 1;
+			return find;
+		}
+	}
+}
+
+namespace pugi
+{
+	namespace impl
+	{
+		// Compare two strings, with globbing, and character sets.
+		int strcmpwild(const char* src, const char* dst)
+		{
+			int find = 1;
+			for(; *src != 0 && find == 1 && *dst != 0; ++src)
+			{
+				switch (*src)
+				{
+					case '?': ++dst; break;
+					case '[': ++src; find = strcmpwild_cset(&src,&dst); break;
+					case '*': find = strcmpwild_astr(&src,&dst); --src; break;
+					default : find = (int) (*src == *dst); ++dst;
+				}
+			}
+			while (*src == '*' && find == 1) ++src;
+			return (find == 1 && *dst == 0 && *src == 0) ? 0 : 1;
+		}
+	}
+
+	xml_tree_walker::xml_tree_walker(): _depth(0)
+	{
+	}
+	
+	xml_tree_walker::~xml_tree_walker()
+	{
+	}
+
+	int xml_tree_walker::depth() const
+	{
+		return _depth;
+	}
+
+	bool xml_tree_walker::begin(xml_node&)
+	{
+		return true;
+	}
+
+	bool xml_tree_walker::end(xml_node&)
+	{
+		return true;
+	}
+
+	xml_attribute::xml_attribute(): _attr(0)
+	{
+	}
+
+	xml_attribute::xml_attribute(xml_attribute_struct* attr): _attr(attr)
+	{
+	}
+
+	xml_attribute::operator xml_attribute::unspecified_bool_type() const
+	{
+      	return empty() ? 0 : &xml_attribute::_attr;
+   	}
+
+   	bool xml_attribute::operator!() const
+   	{
+   		return empty();
+   	}
+
+	bool xml_attribute::operator==(const xml_attribute& r) const
+	{
+		return (_attr == r._attr);
+	}
+	
+	bool xml_attribute::operator!=(const xml_attribute& r) const
+	{
+		return (_attr != r._attr);
+	}
+
+	bool xml_attribute::operator<(const xml_attribute& r) const
+	{
+		return (_attr < r._attr);
+	}
+	
+	bool xml_attribute::operator>(const xml_attribute& r) const
+	{
+		return (_attr > r._attr);
+	}
+	
+	bool xml_attribute::operator<=(const xml_attribute& r) const
+	{
+		return (_attr <= r._attr);
+	}
+	
+	bool xml_attribute::operator>=(const xml_attribute& r) const
+	{
+		return (_attr >= r._attr);
+	}
+
+   	xml_attribute xml_attribute::next_attribute() const
+   	{
+    	return _attr ? xml_attribute(_attr->next_attribute) : xml_attribute();
+   	}
+
+    xml_attribute xml_attribute::previous_attribute() const
+    {
+    	return _attr ? xml_attribute(_attr->prev_attribute) : xml_attribute();
+    }
+
+	int xml_attribute::as_int() const
+	{
+		if(empty() || !_attr->value) return 0;
+		return atoi(_attr->value);
+	}
+
+	double xml_attribute::as_double() const
+	{
+		if(empty() || !_attr->value) return 0.0;
+		return atof(_attr->value);
+	}
+
+	float xml_attribute::as_float() const
+	{
+		if(empty() || !_attr->value) return 0.0f;
+		return (float)atof(_attr->value);
+	}
+
+	bool xml_attribute::as_bool() const
+	{
+		if(empty() || !_attr->value) return false;
+		if(*(_attr->value))
+		{
+			return // Only look at first char:
+			(
+				*(_attr->value) == '1' || // 1*
+				*(_attr->value) == 't' || // t* (true)
+				*(_attr->value) == 'T' || // T* (true|true)
+				*(_attr->value) == 'y' || // y* (yes)
+				*(_attr->value) == 'Y' // Y* (Yes|YES)
+			)
+				? true : false; // Return true if matches above, else false.
+		}
+		else return false;
+	}
+
+	bool xml_attribute::empty() const
+	{
+		return (_attr == 0);
+	}
+
+	const char* xml_attribute::name() const
+	{
+		return (!empty() && _attr->name) ? _attr->name : "";
+	}
+
+	const char* xml_attribute::value() const
+	{
+		return (!empty() && _attr->value) ? _attr->value : "";
+	}
+
+	unsigned int xml_attribute::document_order() const
+	{
+		return empty() ? 0 : _attr->document_order;
+	}
+
+	xml_attribute& xml_attribute::operator=(const char* rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+	
+	xml_attribute& xml_attribute::operator=(int rhs)
+	{
+		char buf[128];
+		sprintf(buf, "%d", rhs);
+		set_value(buf);
+		return *this;
+	}
+
+	xml_attribute& xml_attribute::operator=(double rhs)
+	{
+		char buf[128];
+		sprintf(buf, "%g", rhs);
+		set_value(buf);
+		return *this;
+	}
+	
+	xml_attribute& xml_attribute::operator=(bool rhs)
+	{
+		set_value(rhs ? "true" : "false");
+		return *this;
+	}
+
+	bool xml_attribute::set_name(const char* rhs)
+	{
+		if (empty()) return false;
+		
+		bool insitu = _attr->name_insitu;
+		bool res = strcpy_insitu(_attr->name, insitu, rhs);
+		_attr->name_insitu = insitu;
+		
+		return res;
+	}
+		
+	bool xml_attribute::set_value(const char* rhs)
+	{
+		if (empty()) return false;
+
+		bool insitu = _attr->value_insitu;
+		bool res = strcpy_insitu(_attr->value, insitu, rhs);
+		_attr->value_insitu = insitu;
+		
+		return res;
+	}
+
+#ifdef __BORLANDC__
+	bool operator&&(const xml_attribute& lhs, bool rhs)
+	{
+		return lhs ? rhs : false;
+	}
+
+	bool operator||(const xml_attribute& lhs, bool rhs)
+	{
+		return lhs ? true : rhs;
+	}
+#endif
+
+	xml_node::xml_node(): _root(0)
+	{
+	}
+
+	xml_node::xml_node(xml_node_struct* p): _root(p)
+	{
+	}
+	
+	xml_node::operator xml_node::unspecified_bool_type() const
+	{
+      	return empty() ? 0 : &xml_node::_root;
+   	}
+
+   	bool xml_node::operator!() const
+   	{
+   		return empty();
+   	}
+
+	xml_node::iterator xml_node::begin() const
+	{
+		return iterator(_root->first_child);
+	}
+
+	xml_node::iterator xml_node::end() const
+	{
+		return iterator(0, _root->last_child);
+	}
+	
+	xml_node::attribute_iterator xml_node::attributes_begin() const
+	{
+		return attribute_iterator(_root->first_attribute);
+	}
+
+	xml_node::attribute_iterator xml_node::attributes_end() const
+	{
+		return attribute_iterator(0, _root->last_attribute);
+	}
+
+	bool xml_node::operator==(const xml_node& r) const
+	{
+		return (_root == r._root);
+	}
+
+	bool xml_node::operator!=(const xml_node& r) const
+	{
+		return (_root != r._root);
+	}
+
+	bool xml_node::operator<(const xml_node& r) const
+	{
+		return (_root < r._root);
+	}
+	
+	bool xml_node::operator>(const xml_node& r) const
+	{
+		return (_root > r._root);
+	}
+	
+	bool xml_node::operator<=(const xml_node& r) const
+	{
+		return (_root <= r._root);
+	}
+	
+	bool xml_node::operator>=(const xml_node& r) const
+	{
+		return (_root >= r._root);
+	}
+
+	bool xml_node::empty() const
+	{
+		return (_root == 0);
+	}
+	
+	xml_allocator& xml_node::get_allocator() const
+	{
+		xml_node_struct* r = root()._root;
+
+		return static_cast(r)->allocator;
+	}
+
+	const char* xml_node::name() const
+	{
+		return (!empty() && _root->name) ? _root->name : "";
+	}
+
+	xml_node_type xml_node::type() const
+	{
+		return _root ? static_cast(_root->type) : node_null;
+	}
+	
+	const char* xml_node::value() const
+	{
+		return (!empty() && _root->value) ? _root->value : "";
+	}
+	
+	xml_node xml_node::child(const char* name) const
+	{
+		if (!empty())
+			for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+				if (i->name && !strcmp(name, i->name)) return xml_node(i);
+
+		return xml_node();
+	}
+
+	xml_node xml_node::child_w(const char* name) const
+	{
+		if (!empty())
+			for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+				if (i->name && !impl::strcmpwild(name, i->name)) return xml_node(i);
+
+		return xml_node();
+	}
+
+	xml_attribute xml_node::attribute(const char* name) const
+	{
+		if (!_root) return xml_attribute();
+
+		for (xml_attribute_struct* i = _root->first_attribute; i; i = i->next_attribute)
+			if (i->name && !strcmp(name, i->name))
+				return xml_attribute(i);
+		
+		return xml_attribute();
+	}
+	
+	xml_attribute xml_node::attribute_w(const char* name) const
+	{
+		if (!_root) return xml_attribute();
+
+		for (xml_attribute_struct* i = _root->first_attribute; i; i = i->next_attribute)
+			if (i->name && !impl::strcmpwild(name, i->name))
+				return xml_attribute(i);
+		
+		return xml_attribute();
+	}
+
+	xml_node xml_node::next_sibling(const char* name) const
+	{
+		if(empty()) return xml_node();
+		
+		for (xml_node_struct* i = _root->next_sibling; i; i = i->next_sibling)
+			if (i->name && !strcmp(name, i->name)) return xml_node(i);
+
+		return xml_node();
+	}
+
+	xml_node xml_node::next_sibling_w(const char* name) const
+	{
+		if(empty()) return xml_node();
+		
+		for (xml_node_struct* i = _root->next_sibling; i; i = i->next_sibling)
+			if (i->name && !impl::strcmpwild(name, i->name)) return xml_node(i);
+
+		return xml_node();
+	}
+
+	xml_node xml_node::next_sibling() const
+	{
+		if(empty()) return xml_node();
+		
+		if (_root->next_sibling) return xml_node(_root->next_sibling);
+		else return xml_node();
+	}
+
+	xml_node xml_node::previous_sibling(const char* name) const
+	{
+		if (empty()) return xml_node();
+		
+		for (xml_node_struct* i = _root->prev_sibling; i; i = i->prev_sibling)
+			if (i->name && !strcmp(name, i->name)) return xml_node(i);
+
+		return xml_node();
+	}
+
+	xml_node xml_node::previous_sibling_w(const char* name) const
+	{
+		if (empty()) return xml_node();
+		
+		for (xml_node_struct* i = _root->prev_sibling; i; i = i->prev_sibling)
+			if (i->name && !impl::strcmpwild(name, i->name)) return xml_node(i);
+
+		return xml_node();
+	}
+
+	xml_node xml_node::previous_sibling() const
+	{
+		if(empty()) return xml_node();
+		
+		if (_root->prev_sibling) return xml_node(_root->prev_sibling);
+		else return xml_node();
+	}
+
+	xml_node xml_node::parent() const
+	{
+		return empty() ? xml_node() : xml_node(_root->parent);
+	}
+
+	xml_node xml_node::root() const
+	{
+		xml_node r = *this;
+		while (r && r.parent()) r = r.parent();
+		return r;
+	}
+
+	const char* xml_node::child_value() const
+	{
+		if (!empty())
+			for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+				if ((static_cast(i->type) == node_pcdata || static_cast(i->type) == node_cdata) && i->value)
+					return i->value;
+		return "";
+	}
+
+	const char* xml_node::child_value(const char* name) const
+	{
+		return child(name).child_value();
+	}
+
+	const char* xml_node::child_value_w(const char* name) const
+	{
+		return child_w(name).child_value();
+	}
+
+	xml_attribute xml_node::first_attribute() const
+	{
+		return _root ? xml_attribute(_root->first_attribute) : xml_attribute();
+	}
+
+	xml_attribute xml_node::last_attribute() const
+	{
+		return _root ? xml_attribute(_root->last_attribute) : xml_attribute();
+	}
+
+	xml_node xml_node::first_child() const
+	{
+		if (_root) return xml_node(_root->first_child);
+		else return xml_node();
+	}
+
+	xml_node xml_node::last_child() const
+	{
+		if (_root) return xml_node(_root->last_child);
+		else return xml_node();
+	}
+
+	bool xml_node::set_name(const char* rhs)
+	{
+		switch (type())
+		{
+		case node_pi:
+		case node_element:
+		{
+			bool insitu = _root->name_insitu;
+			bool res = strcpy_insitu(_root->name, insitu, rhs);
+			_root->name_insitu = insitu;
+		
+			return res;
+		}
+
+		default:
+			return false;
+		}
+	}
+		
+	bool xml_node::set_value(const char* rhs)
+	{
+		switch (type())
+		{
+		case node_pi:
+		case node_cdata:
+		case node_pcdata:
+		case node_comment:
+		{
+			bool insitu = _root->value_insitu;
+			bool res = strcpy_insitu(_root->value, insitu, rhs);
+			_root->value_insitu = insitu;
+		
+			return res;
+		}
+
+		default:
+			return false;
+		}
+	}
+
+	xml_attribute xml_node::append_attribute(const char* name)
+	{
+		if (type() != node_element) return xml_attribute();
+		
+		xml_attribute a(_root->append_attribute(get_allocator()));
+		a.set_name(name);
+		
+		return a;
+	}
+
+	xml_attribute xml_node::insert_attribute_before(const char* name, const xml_attribute& attr)
+	{
+		if (type() != node_element || attr.empty()) return xml_attribute();
+		
+		// check that attribute belongs to *this
+		xml_attribute_struct* cur = attr._attr;
+
+		while (cur->prev_attribute) cur = cur->prev_attribute;
+
+		if (cur != _root->first_attribute) return xml_attribute();
+
+		xml_attribute a(get_allocator().allocate());
+		a.set_name(name);
+
+		if (attr._attr->prev_attribute)
+			attr._attr->prev_attribute->next_attribute = a._attr;
+		else
+			_root->first_attribute = a._attr;
+		
+		a._attr->prev_attribute = attr._attr->prev_attribute;
+		a._attr->next_attribute = attr._attr;
+		attr._attr->prev_attribute = a._attr;
+				
+		return a;
+	}
+
+	xml_attribute xml_node::insert_attribute_after(const char* name, const xml_attribute& attr)
+	{
+		if (type() != node_element || attr.empty()) return xml_attribute();
+		
+		// check that attribute belongs to *this
+		xml_attribute_struct* cur = attr._attr;
+
+		while (cur->prev_attribute) cur = cur->prev_attribute;
+
+		if (cur != _root->first_attribute) return xml_attribute();
+
+		xml_attribute a(get_allocator().allocate());
+		a.set_name(name);
+
+		if (attr._attr->next_attribute)
+			attr._attr->next_attribute->prev_attribute = a._attr;
+		else
+			_root->last_attribute = a._attr;
+		
+		a._attr->next_attribute = attr._attr->next_attribute;
+		a._attr->prev_attribute = attr._attr;
+		attr._attr->next_attribute = a._attr;
+
+		return a;
+	}
+
+	xml_node xml_node::append_child(xml_node_type type)
+	{
+		if ((this->type() != node_element && this->type() != node_document) || type == node_document || type == node_null) return xml_node();
+		
+		return xml_node(_root->append_node(get_allocator(), type));
+	}
+
+	xml_node xml_node::insert_child_before(xml_node_type type, const xml_node& node)
+	{
+		if ((this->type() != node_element && this->type() != node_document) || type == node_document || type == node_null) return xml_node();
+		if (node.parent() != *this) return xml_node();
+	
+		xml_node n(get_allocator().allocate(type));
+		n._root->parent = _root;
+		
+		if (node._root->prev_sibling)
+			node._root->prev_sibling->next_sibling = n._root;
+		else
+			_root->first_child = n._root;
+		
+		n._root->prev_sibling = node._root->prev_sibling;
+		n._root->next_sibling = node._root;
+		node._root->prev_sibling = n._root;
+
+		return n;
+	}
+
+	xml_node xml_node::insert_child_after(xml_node_type type, const xml_node& node)
+	{
+		if ((this->type() != node_element && this->type() != node_document) || type == node_document || type == node_null) return xml_node();
+		if (node.parent() != *this) return xml_node();
+	
+		xml_node n(get_allocator().allocate(type));
+		n._root->parent = _root;
+	
+		if (node._root->next_sibling)
+			node._root->next_sibling->prev_sibling = n._root;
+		else
+			_root->last_child = n._root;
+		
+		n._root->next_sibling = node._root->next_sibling;
+		n._root->prev_sibling = node._root;
+		node._root->next_sibling = n._root;
+
+		return n;
+	}
+
+	void xml_node::remove_attribute(const char* name)
+	{
+		remove_attribute(attribute(name));
+	}
+
+	void xml_node::remove_attribute(const xml_attribute& a)
+	{
+		if (empty()) return;
+
+		// check that attribute belongs to *this
+		xml_attribute_struct* attr = a._attr;
+
+		while (attr->prev_attribute) attr = attr->prev_attribute;
+
+		if (attr != _root->first_attribute) return;
+
+		if (a._attr->next_attribute) a._attr->next_attribute->prev_attribute = a._attr->prev_attribute;
+		else _root->last_attribute = a._attr->prev_attribute;
+		
+		if (a._attr->prev_attribute) a._attr->prev_attribute->next_attribute = a._attr->next_attribute;
+		else _root->first_attribute = a._attr->next_attribute;
+
+		a._attr->free();
+	}
+
+	void xml_node::remove_child(const char* name)
+	{
+		remove_child(child(name));
+	}
+
+	void xml_node::remove_child(const xml_node& n)
+	{
+		if (empty() || n.parent() != *this) return;
+
+		if (n._root->next_sibling) n._root->next_sibling->prev_sibling = n._root->prev_sibling;
+		else _root->last_child = n._root->prev_sibling;
+		
+		if (n._root->prev_sibling) n._root->prev_sibling->next_sibling = n._root->next_sibling;
+		else _root->first_child = n._root->next_sibling;
+        
+        n._root->free();
+	}
+
+#ifndef PUGIXML_NO_STL
+	std::string xml_node::path(char delimiter) const
+	{
+		std::string path;
+
+		xml_node cursor = *this; // Make a copy.
+		
+		path = cursor.name();
+
+		while (cursor.parent())
+		{
+			cursor = cursor.parent();
+			
+			std::string temp = cursor.name();
+			temp += delimiter;
+			temp += path;
+			path.swap(temp);
+		}
+
+		return path;
+	}
+#endif
+
+	xml_node xml_node::first_element_by_path(const char* path, char delimiter) const
+	{
+		xml_node found = *this; // Current search context.
+
+		if (empty() || !path || !path[0]) return found;
+
+		if (path[0] == delimiter)
+		{
+			// Absolute path; e.g. '/foo/bar'
+			while (found.parent()) found = found.parent();
+			++path;
+		}
+
+		const char* path_segment = path;
+
+		while (*path_segment == delimiter) ++path_segment;
+
+		const char* path_segment_end = path_segment;
+
+		while (*path_segment_end && *path_segment_end != delimiter) ++path_segment_end;
+
+		if (path_segment == path_segment_end) return found;
+
+		const char* next_segment = path_segment_end;
+
+		while (*next_segment == delimiter) ++next_segment;
+
+		if (*path_segment == '.' && path_segment + 1 == path_segment_end)
+			return found.first_element_by_path(next_segment, delimiter);
+		else if (*path_segment == '.' && *(path_segment+1) == '.' && path_segment + 2 == path_segment_end)
+			return found.parent().first_element_by_path(next_segment, delimiter);
+		else
+		{
+			for (xml_node_struct* j = found._root->first_child; j; j = j->next_sibling)
+			{
+				if (j->name && !strcmprange(j->name, path_segment, path_segment_end))
+				{
+					xml_node subsearch = xml_node(j).first_element_by_path(next_segment, delimiter);
+
+					if (subsearch) return subsearch;
+				}
+			}
+
+			return xml_node();
+		}
+	}
+
+	bool xml_node::traverse(xml_tree_walker& walker)
+	{
+		walker._depth = 0;
+		
+		if (!walker.begin(*this)) return false;
+
+		xml_node cur = first_child();
+				
+		if (cur)
+		{
+			do 
+			{
+				if (!walker.for_each(cur))
+					return false;
+						
+				if (cur.first_child())
+				{
+					++walker._depth;
+					cur = cur.first_child();
+				}
+				else if (cur.next_sibling())
+					cur = cur.next_sibling();
+				else
+				{
+					// Borland C++ workaround
+					while (!cur.next_sibling() && cur != *this && (bool)cur.parent())
+					{
+						--walker._depth;
+						cur = cur.parent();
+					}
+						
+					if (cur != *this)
+						cur = cur.next_sibling();
+				}
+			}
+			while (cur && cur != *this);
+		}
+
+		if (!walker.end(*this)) return false;
+		
+		return true;
+	}
+
+	unsigned int xml_node::document_order() const
+	{
+		return empty() ? 0 : _root->document_order;
+	}
+
+	void xml_node::precompute_document_order_impl()
+	{
+		if (type() != node_document) return;
+
+		unsigned int current = 1;
+		xml_node cur = *this;
+
+		for (;;)
+		{
+			cur._root->document_order = current++;
+			
+			for (xml_attribute a = cur.first_attribute(); a; a = a.next_attribute())
+				a._attr->document_order = current++;
+					
+			if (cur.first_child())
+				cur = cur.first_child();
+			else if (cur.next_sibling())
+				cur = cur.next_sibling();
+			else
+			{
+				while (cur && !cur.next_sibling()) cur = cur.parent();
+				cur = cur.next_sibling();
+				
+				if (!cur) break;
+			}
+		}
+	}
+
+#ifndef PUGIXML_NO_STL
+	void xml_node::print(std::ostream& os, const char* indent, unsigned int flags, unsigned int depth)
+	{
+		if (empty()) return;
+
+		if ((flags & format_indent) != 0 && (flags & format_raw) == 0)
+			for (unsigned int i = 0; i < depth; ++i) os << indent;
+
+		switch (type())
+		{
+		case node_document:
+			for (xml_node n = first_child(); n; n = n.next_sibling())
+				n.print(os, indent, flags, depth);
+			break;
+			
+		case node_element:
+		{
+			os << '<' << name();
+
+			for (xml_attribute a = first_attribute(); a; a = a.next_attribute())
+			{
+				os << ' ' << a.name() << "=\"";
+
+				if (flags & format_utf8)
+					text_output_escaped(os, a.value());
+				else
+					text_output_escaped(os, a.value());
+
+				os << "\"";
+			}
+
+			if (flags & format_raw)
+			{
+				if (!_root->first_child) // 0 children
+					os << " />";
+				else
+				{
+					os << ">";
+					for (xml_node n = first_child(); n; n = n.next_sibling())
+						n.print(os, indent, flags, depth + 1);
+					os << "";
+				}
+			}
+			else if (!_root->first_child) // 0 children
+				os << " />\n";
+			else if (_root->first_child == _root->last_child && first_child().type() == node_pcdata)
+			{
+				os << ">";
+				
+				if (flags & format_utf8)
+					text_output_escaped(os, first_child().value());
+				else
+					text_output_escaped(os, first_child().value());
+					
+				os << "\n";
+			}
+			else
+			{
+				os << ">\n";
+				
+				for (xml_node n = first_child(); n; n = n.next_sibling())
+					n.print(os, indent, flags, depth + 1);
+
+				if ((flags & format_indent) != 0 && (flags & format_raw) == 0)
+					for (unsigned int i = 0; i < depth; ++i) os << indent;
+				
+				os << "\n";
+			}
+
+			break;
+		}
+		case node_pcdata:
+			if (flags & format_utf8)
+				text_output_escaped(os, value());
+			else
+				text_output_escaped(os, value());
+			break;
+
+		case node_cdata:
+			os << "";
+			if ((flags & format_raw) == 0) os << "\n";
+			break;
+
+		case node_comment:
+			os << "";
+			if ((flags & format_raw) == 0) os << "\n";
+			break;
+
+		case node_pi:
+			os << "";
+			if ((flags & format_raw) == 0) os << "\n";
+			break;
+		
+		default:
+			;
+		}
+	}
+#endif
+
+#ifdef __BORLANDC__
+	bool operator&&(const xml_node& lhs, bool rhs)
+	{
+		return lhs ? rhs : false;
+	}
+
+	bool operator||(const xml_node& lhs, bool rhs)
+	{
+		return lhs ? true : rhs;
+	}
+#endif
+
+	xml_node_iterator::xml_node_iterator()
+	{
+	}
+
+	xml_node_iterator::xml_node_iterator(const xml_node& node): _wrap(node)
+	{
+	}
+
+	xml_node_iterator::xml_node_iterator(xml_node_struct* ref): _wrap(ref)
+	{
+	}
+		
+	xml_node_iterator::xml_node_iterator(xml_node_struct* ref, xml_node_struct* prev): _prev(prev), _wrap(ref)
+	{
+	}
+
+	bool xml_node_iterator::operator==(const xml_node_iterator& rhs) const
+	{
+		return (_wrap == rhs._wrap);
+	}
+	
+	bool xml_node_iterator::operator!=(const xml_node_iterator& rhs) const
+	{
+		return (_wrap != rhs._wrap);
+	}
+
+	xml_node& xml_node_iterator::operator*()
+	{
+		return _wrap;
+	}
+
+	xml_node* xml_node_iterator::operator->()
+	{
+		return &_wrap;
+	}
+
+	const xml_node_iterator& xml_node_iterator::operator++()
+	{
+		_prev = _wrap;
+		_wrap = xml_node(_wrap._root->next_sibling);
+		return *this;
+	}
+
+	xml_node_iterator xml_node_iterator::operator++(int)
+	{
+		xml_node_iterator temp = *this;
+		++*this;
+		return temp;
+	}
+
+	const xml_node_iterator& xml_node_iterator::operator--()
+	{
+		if (_wrap._root) _wrap = xml_node(_wrap._root->prev_sibling);
+		else _wrap = _prev;
+		return *this;
+	}
+
+	xml_node_iterator xml_node_iterator::operator--(int)
+	{
+		xml_node_iterator temp = *this;
+		--*this;
+		return temp;
+	}
+
+	xml_attribute_iterator::xml_attribute_iterator()
+	{
+	}
+
+	xml_attribute_iterator::xml_attribute_iterator(const xml_attribute& attr): _wrap(attr)
+	{
+	}
+
+	xml_attribute_iterator::xml_attribute_iterator(xml_attribute_struct* ref): _wrap(ref)
+	{
+	}
+		
+	xml_attribute_iterator::xml_attribute_iterator(xml_attribute_struct* ref, xml_attribute_struct* prev): _prev(prev), _wrap(ref)
+	{
+	}
+
+	bool xml_attribute_iterator::operator==(const xml_attribute_iterator& rhs) const
+	{
+		return (_wrap == rhs._wrap);
+	}
+	
+	bool xml_attribute_iterator::operator!=(const xml_attribute_iterator& rhs) const
+	{
+		return (_wrap != rhs._wrap);
+	}
+
+	xml_attribute& xml_attribute_iterator::operator*()
+	{
+		return _wrap;
+	}
+
+	xml_attribute* xml_attribute_iterator::operator->()
+	{
+		return &_wrap;
+	}
+
+	const xml_attribute_iterator& xml_attribute_iterator::operator++()
+	{
+		_prev = _wrap;
+		_wrap = xml_attribute(_wrap._attr->next_attribute);
+		return *this;
+	}
+
+	xml_attribute_iterator xml_attribute_iterator::operator++(int)
+	{
+		xml_attribute_iterator temp = *this;
+		++*this;
+		return temp;
+	}
+
+	const xml_attribute_iterator& xml_attribute_iterator::operator--()
+	{
+		if (_wrap._attr) _wrap = xml_attribute(_wrap._attr->prev_attribute);
+		else _wrap = _prev;
+		return *this;
+	}
+
+	xml_attribute_iterator xml_attribute_iterator::operator--(int)
+	{
+		xml_attribute_iterator temp = *this;
+		--*this;
+		return temp;
+	}
+
+	xml_memory_block::xml_memory_block(): next(0), size(0)
+	{
+	}
+
+	xml_document::xml_document(): _buffer(0)
+	{
+		create();
+	}
+
+	xml_document::~xml_document()
+	{
+		free();
+	}
+
+	void xml_document::create()
+	{
+		xml_allocator alloc(&_memory);
+		
+		_root = alloc.allocate(); // Allocate a new root.
+		xml_allocator& a = static_cast(_root)->allocator;
+		a = alloc;
+	}
+
+	void xml_document::free()
+	{
+		delete[] _buffer;
+		_buffer = 0;
+
+		if (_root) _root->free();
+
+		xml_memory_block* current = _memory.next;
+
+		while (current)
+		{
+			xml_memory_block* next = current->next;
+			delete current;
+			current = next;
+		}
+		
+		_memory.next = 0;
+		_memory.size = 0;
+
+		create();
+	}
+
+#ifndef PUGIXML_NO_STL
+	bool xml_document::load(std::istream& stream, unsigned int options)
+	{
+		if (!stream.good()) return false;
+
+		std::streamoff length, pos = stream.tellg();
+		stream.seekg(0, std::ios_base::end);
+		length = stream.tellg();
+		stream.seekg(pos, std::ios_base::beg);
+
+		if (!stream.good()) return false;
+
+		char* s;
+
+		try
+		{
+			s = new char[length + 1];
+		}
+		catch (const std::bad_alloc&)
+		{
+			return false;
+		}
+
+		stream.read(s, length);
+		s[length] = 0;
+
+		if (!stream.good())
+		{
+			delete[] s;
+			return false;
+		}
+
+		return parse(transfer_ownership_tag(), s, options); // Parse the input string.
+	}
+#endif
+
+	bool xml_document::load(const char* contents, unsigned int options)
+	{
+		char* s;
+
+		try
+		{
+			s = new char[strlen(contents) + 1];
+		}
+		catch (const std::bad_alloc&)
+		{
+			return false;
+		}
+
+		strcpy(s, contents);
+
+		return parse(transfer_ownership_tag(), s, options); // Parse the input string.
+	}
+
+	bool xml_document::load_file(const char* name, unsigned int options)
+	{
+		FILE* file = fopen(name, "rb");
+		if (!file) return false;
+
+		fseek(file, 0, SEEK_END);
+		long length = ftell(file);
+		fseek(file, 0, SEEK_SET);
+
+		if (length < 0)
+		{
+			fclose(file);
+			return false;
+		}
+		
+		char* s;
+
+		try
+		{
+			s = new char[length + 1];
+		}
+		catch (const std::bad_alloc&)
+		{
+			fclose(file);
+			return false;
+		}
+
+		size_t read = fread(s, (size_t)length, 1, file);
+		fclose(file);
+
+		if (read != 1)
+		{
+			delete[] s;
+			return false;
+		}
+
+		s[length] = 0;
+		
+		return parse(transfer_ownership_tag(), s, options); // Parse the input string.
+	}
+
+	bool xml_document::parse(char* xmlstr, unsigned int options)
+	{
+		free();
+
+		xml_allocator& alloc = static_cast(_root)->allocator;
+		
+		xml_parser parser(alloc);
+		
+		return parser.parse(xmlstr, _root, options); // Parse the input string.
+	}
+		
+	bool xml_document::parse(const transfer_ownership_tag&, char* xmlstr, unsigned int options)
+	{
+		bool res = parse(xmlstr, options);
+
+		if (res) _buffer = xmlstr;
+
+		return res;
+	}
+
+#ifndef PUGIXML_NO_STL
+	bool xml_document::save_file(const char* name, const char* indent, unsigned int flags)
+	{
+		std::ofstream out(name, std::ios::out);
+		if (!out) return false;
+
+		if (flags & format_write_bom)
+		{
+			if (flags & format_utf8)
+			{
+				static const unsigned char utf8_bom[] = {0xEF, 0xBB, 0xBF};
+				out.write(reinterpret_cast(utf8_bom), 3);
+			}
+		}
+
+		out << "";
+		if (!(flags & format_raw)) out << "\n";
+		print(out, indent, flags);
+		
+		return true;
+	}
+#endif
+
+	void xml_document::precompute_document_order()
+	{
+		precompute_document_order_impl();
+	}
+
+#ifndef PUGIXML_NO_STL
+	std::string as_utf8(const wchar_t* str)
+	{
+		std::string result;
+		result.reserve(strutf16_utf8_size(str));
+	  
+		for (; *str; ++str)
+		{
+			char buffer[6];
+	  	
+			result.append(buffer, strutf16_utf8(buffer, *str));
+		}
+	  	
+	  	return result;
+	}
+	
+	std::wstring as_utf16(const char* str)
+	{
+		std::wstring result;
+		result.reserve(strutf8_utf16_size(str));
+
+		for (; *str;)
+		{
+			unsigned int ch;
+			str = strutf8_utf16(str, ch);
+			result += (wchar_t)ch;
+		}
+
+		return result;
+	}
+#endif
+}
diff --git a/src/pugixml.hpp b/src/pugixml.hpp
index de7939e..323994d 100644
--- a/src/pugixml.hpp
+++ b/src/pugixml.hpp
@@ -1,664 +1,1735 @@
-///////////////////////////////////////////////////////////////////////////////
-//
-// Pug Improved XML Parser - Version 0.2
-// --------------------------------------------------------
-// Copyright (C) 2006-2007, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
-// This work is based on the pugxml parser, which is:
-// Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
-// Released into the Public Domain. Use at your own risk.
-// See pugxml.xml for further information, history, etc.
-// Contributions by Neville Franks (readonly@getsoft.com).
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef HEADER_PUGIXML_HPP
-#define HEADER_PUGIXML_HPP
-
-// Uncomment this to disable STL
-// #define PUGIXML_NO_STL
-
-#ifndef PUGIXML_NO_STL
-#	include 
-#	include 
-#endif
-
-#include 
-#include 
-
-/// The PugiXML Parser namespace.
-namespace pugi
-{
-	/// Tree node classification.
-	/// See 'xml_node_struct::type'
-	enum xml_node_type
-	{
-		node_null,			///< An undifferentiated entity.
-		node_document,		///< A document tree's absolute root.
-		node_element,		///< E.g. '<...>'
-		node_pcdata,		///< E.g. '>...<'
-		node_cdata,			///< E.g. ''
-		node_comment,		///< E.g. ''
-		node_pi				///< E.g. ''
-	};
-
-	/// Parser Options
-	const size_t memory_block_size = 32768;		///< Memory block size, 32 kb
-
-	const unsigned int parse_minimal			= 0x00000000; ///< Unset the following flags.
-	const unsigned int parse_pi					= 0x00000001; ///< Parse ''
-	const unsigned int parse_comments			= 0x00000002; ///< Parse ''
-	const unsigned int parse_cdata				= 0x00000004; ///< Parse ''
-	const unsigned int parse_ws_pcdata			= 0x00000008; ///< Do not skip PCDATA that consists only of whitespaces
-	const unsigned int parse_ext_pcdata			= 0x00000010; ///< Do not skip PCDATA that is outside all tags (i.e. root)
-	const unsigned int parse_escapes			= 0x00000020; ///< Parse <, >, &, ", ', &#.. sequences
-	const unsigned int parse_wnorm_attribute	= 0x00000080; ///< Normalize spaces in attributes (convert space-like characters to spaces + merge adjacent spaces + trim leading/trailing spaces)
-	const unsigned int parse_wconv_attribute	= 0x00000100; ///< Convert space-like characters to spaces in attributes (only if wnorm is not set)
-	const unsigned int parse_eol				= 0x00000200; ///< Perform EOL handling
-	const unsigned int parse_check_end_tags		= 0x00000400; ///< Check start and end tag names and return error if names mismatch
-	const unsigned int parse_match_end_tags		= 0x00000800; ///< Try to find corresponding start tag for an end tag
-	///< Set all flags, except parse_ws_pcdata, parse_trim_attribute, parse_pi and parse_comments
-	const unsigned int parse_default			= parse_cdata | parse_ext_pcdata | parse_escapes | parse_wconv_attribute | parse_eol | parse_check_end_tags;
-	const unsigned int parse_noset				= 0x80000000; ///< Parse with flags in xml_parser
-
-	const unsigned int parse_w3c				= parse_pi | parse_comments | parse_cdata |
-												parse_escapes | parse_wconv_attribute |
-												parse_check_end_tags | parse_ws_pcdata | parse_eol;
-
-	/// Forward declarations
-	struct xml_attribute_struct;
-	struct xml_node_struct;
-
-	class xml_node_iterator;
-	class xml_attribute_iterator;
-
-	class xml_tree_walker;
-
-	/// Provides a light-weight wrapper for manipulating xml_attribute_struct structures.
-	///	Note: xml_attribute does not create any memory for the attribute it wraps; 
-	///	it only wraps a pointer to an existing xml_attribute_struct.
-	class xml_attribute
-	{
-		friend class xml_attribute_iterator;
-		friend class xml_node;
-
-	private:
-		const xml_attribute_struct* _attr; ///< The internal attribute pointer.
-	
-    	/// Safe bool type
-    	typedef const xml_attribute_struct* xml_attribute::*unspecified_bool_type;
-
-		/// Initializing ctor
-		explicit xml_attribute(const xml_attribute_struct* attr);
-
-	public:
-		/// Default ctor
-		xml_attribute();
-		
-	public:
-		/// Comparison operators
-		bool operator==(const xml_attribute& r) const;
-		bool operator!=(const xml_attribute& r) const;
-		bool operator<(const xml_attribute& r) const;
-		bool operator>(const xml_attribute& r) const;
-		bool operator<=(const xml_attribute& r) const;
-		bool operator>=(const xml_attribute& r) const;
-	
-    	/// Safe bool conversion
-    	operator unspecified_bool_type() const;
-
-    	/// Get next attribute if any, else xml_attribute()
-    	xml_attribute next_attribute() const;
-
-    	/// Get previous attribute if any, else xml_attribute()
-    	xml_attribute previous_attribute() const;
-
-		/// Cast attribute value as int. If not found, return 0.
-		/// \return Attribute value as int, or 0.
-		int as_int() const;
-
-		/// Cast attribute value as double. If not found, return 0.0.
-		/// \return Attribute value as double, or 0.0.
-		double as_double() const;
-	
-		/// Cast attribute value as float. If not found, return 0.0.
-		/// \return Attribute value as float, or 0.0.
-		float as_float() const;
-
-		/// Cast attribute value as bool. If not found, return false.
-		/// \return Attribute value as bool, or false.
-		bool as_bool() const;
-
-	public:
-		/// True if internal pointer is valid
-		bool empty() const;
-
-	public:
-		/// Access the attribute name.
-		const char* name() const;
-
-		/// Access the attribute value.
-		const char* value() const;
-	};
-
-	/// Provides a light-weight wrapper for manipulating xml_node_struct structures.
-	class xml_node
-	{
-		friend class xml_node_iterator;
-		friend class xml_parser;
-
-	private:
-		const xml_node_struct* _root; ///< Pointer to node root.
-
-    	/// Safe bool type
-    	typedef const xml_node_struct* xml_node::*unspecified_bool_type;
-
-	private:
-		/// Node is tree root.
-		bool type_document() const;
-
-	public:
-		/// Default constructor.
-		///	Node root points to a dummy 'xml_node_struct' structure. Test for this 
-		///	with 'empty'.
-		xml_node();
-
-		/// Construct, wrapping the given 'xml_node_struct' pointer.
-		explicit xml_node(const xml_node_struct* p);
-
-	public:
-		/// Base iterator type (for child nodes). Same as 'child_iterator'.
-		typedef xml_node_iterator iterator;
-
-		/// Attribute iterator type.
-		typedef xml_attribute_iterator attribute_iterator;
-
-		/// Access the begin iterator for this node's collection of child nodes.
-		/// Same as 'children_begin'.
-		iterator begin() const;
-	
-		/// Access the end iterator for this node's collection of child nodes.
-		/// Same as 'children_end'.
-		iterator end() const;
-		
-		/// Access the begin iterator for this node's collection of child nodes.
-		/// Same as 'begin'.
-		iterator children_begin() const;
-	
-		/// Access the end iterator for this node's collection of child nodes.
-		/// Same as 'end'.
-		iterator children_end() const;
-	
-		/// Access the begin iterator for this node's collection of attributes.
-		attribute_iterator attributes_begin() const;
-	
-		/// Access the end iterator for this node's collection of attributes.
-		attribute_iterator attributes_end() const;
-
-		/// Access the begin iterator for this node's collection of siblings.
-		iterator siblings_begin() const;
-	
-		/// Access the end iterator for this node's collection of siblings.
-		iterator siblings_end() const;
-	
-	public:
-    	/// Safe bool conversion
-		operator unspecified_bool_type() const;
-	
-		/// Comparison operators
-		bool operator==(const xml_node& r) const;
-		bool operator!=(const xml_node& r) const;
-		bool operator<(const xml_node& r) const;
-		bool operator>(const xml_node& r) const;
-		bool operator<=(const xml_node& r) const;
-		bool operator>=(const xml_node& r) const;
-
-	public:
-		/// Node pointer is null, or type is node_null. Same as type_null.
-		bool empty() const;
-
-	public:
-		/// Access node entity type.
-		xml_node_type type() const;
-
-		/// Access pointer to node name if any, else empty string.
-		const char* name() const;
-
-		/// Access pointer to data if any, else empty string.
-		const char* value() const;
-	
-		/// Access child node at name as xml_node or xml_node(NULL) if bad name.
-		xml_node child(const char* name) const;
-
-		/// Access child node at name as xml_node or xml_node(NULL) if bad name.
-		/// Enable wildcard matching.
-		xml_node child_w(const char* name) const;
-
-		/// Access the attribute having 'name'.
-		xml_attribute attribute(const char* name) const;
-
-		/// Access the attribute having 'name'.
-		/// Enable wildcard matching.
-		xml_attribute attribute_w(const char* name) const;
-
-		/// Access sibling node at name as xml_node or xml_node(NULL) if bad name.
-		xml_node sibling(const char* name) const;
-
-		/// Access sibling node at name as xml_node or xml_node(NULL) if bad name.
-		/// Enable wildcard matching.
-		xml_node sibling_w(const char* name) const;
-
-		/// Access current node's next sibling by position and name.
-		xml_node next_sibling(const char* name) const;
-
-		/// Access current node's next sibling by position and name.
-		/// Enable wildcard matching.
-		xml_node next_sibling_w(const char* name) const;
-
-		/// Access current node's next sibling by position.
-		xml_node next_sibling() const;
-
-		/// Access current node's previous sibling by position and name.
-		xml_node previous_sibling(const char* name) const;
-
-		/// Access current node's previous sibling by position and name.
-		/// Enable wildcard matching.
-		xml_node previous_sibling_w(const char* name) const;
-
-		/// Access current node's previous sibling by position.
-		xml_node previous_sibling() const;
-
-		/// Access node's parent if any, else xml_node(NULL)
-		xml_node parent() const;
-
-		/// Return PCDATA/CDATA that is child of current node. If none, return empty string.
-		const char* child_value() const;
-
-		/// Return PCDATA/CDATA that is child of specified child node. If none, return empty string.
-		const char* child_value(const char* name) const;
-
-		/// Return PCDATA/CDATA that is child of specified child node. If none, return empty string.
-		/// Enable wildcard matching.
-		const char* child_value_w(const char* name) const;
-
-	public:
-		/// Access node's first attribute if any, else xml_attribute()
-		xml_attribute first_attribute() const;
-
-		/// Access node's last attribute if any, else xml_attribute()
-        xml_attribute last_attribute() const;
-
-		/// Find all elements having the given name.
-		template  void all_elements_by_name(const char* name, OutputIterator it) const;
-
-		/// Find all elements having the given name.
-		/// Enable wildcard matching.
-		template  void all_elements_by_name_w(const char* name, OutputIterator it) const;
-
-		/// Access node's first child if any, else xml_node()
-		xml_node first_child() const;
-
-		/// Access node's last child if any, else xml_node()
-        xml_node last_child() const;
-		
-		/// Find attribute using the predicate
-		/// Predicate should take xml_attribute and return bool.
-		template  xml_attribute find_attribute(Predicate pred) const;
-
-		/// Find child using the predicate
-		/// Predicate should take xml_node and return bool.
-		template  xml_node find_child(Predicate pred) const;
-
-		/// Recursively-implemented depth-first find element using the predicate
-		/// Predicate should take xml_node and return bool.
-		template  xml_node find_element(Predicate pred) const;
-
-		/// Recursively-implemented depth-first find the first matching element. 
-		/// Use for shallow drill-downs.
-		xml_node first_element(const char* name) const;
-
-		/// Recursively-implemented depth-first find the first matching element. 
-		/// Use for shallow drill-downs.
-		/// Enable wildcard matching.
-		xml_node first_element_w(const char* name) const;
-
-		/// Recursively-implemented depth-first find the first matching element 
-		/// also having matching PCDATA.
-		xml_node first_element_by_value(const char* name, const char* value) const;
-
-		/// Recursively-implemented depth-first find the first matching element 
-		/// also having matching PCDATA.
-		/// Enable wildcard matching.
-		xml_node first_element_by_value_w(const char* name, const char* value) const;
-
-		/// Recursively-implemented depth-first find the first matching element 
-		/// also having matching attribute.
-		xml_node first_element_by_attribute(const char* name, const char* attr_name, const char* attr_value) const;
-
-		/// Recursively-implemented depth-first find the first matching element 
-		/// also having matching attribute.
-		/// Enable wildcard matching.
-		xml_node first_element_by_attribute_w(const char* name, const char* attr_name, const char* attr_value) const;
-
-		/// Recursively-implemented depth-first find the first element 
-		/// having matching attribute.
-		xml_node first_element_by_attribute(const char* attr_name, const char* attr_value) const;
-
-		/// Recursively-implemented depth-first find the first element 
-		/// having matching attribute.
-		/// Enable wildcard matching.
-		xml_node first_element_by_attribute_w(const char* attr_name, const char* attr_value) const;
-
-		/// Recursively-implemented depth-first find the first matching entity. 
-		/// Use for shallow drill-downs.
-		xml_node first_node(xml_node_type type) const;
-
-#ifndef PUGIXML_NO_STL
-		/// Compile the absolute node path from root as a text string.
-		/// \param delimiter - Delimiter character to insert between element names.
-		/// \return path string (e.g. with '/' as delimiter, '/document/.../this'.
-		std::string path(char delimiter = '/') const;
-#endif
-
-		/// Search for a node by path.
-		/// \param path - Path string; e.g. './foo/bar' (relative to node), '/foo/bar' (relative 
-		/// to root), '../foo/bar' (pop relative position).
-		/// \param delimiter - Delimiter character to use in tokenizing path.
-		/// \return Matching node, or xml_node() if not found.
-		xml_node first_element_by_path(const char* path, char delimiter = '/') const;
-
-		/// Recursively traverse the tree.
-		bool traverse(xml_tree_walker& walker) const;
-	};
-
-	/// Child node iterator.
-	class xml_node_iterator
-#ifndef PUGIXML_NO_STL
-	: public std::iterator
-#endif
-	{
-		friend class xml_node;
-
-	private:
-		xml_node _prev;
-		xml_node _wrap;
-
-		/// Initializing ctor
-		explicit xml_node_iterator(const xml_node_struct* ref);
-	public:
-		/// Default ctor
-		xml_node_iterator();
-
-		/// Initializing ctor
-		xml_node_iterator(const xml_node& node);
-
-		/// Initializing ctor (for past-the-end)
-		xml_node_iterator(const xml_node_struct* ref, const xml_node_struct* prev);
-
-		bool operator==(const xml_node_iterator& rhs) const;
-		bool operator!=(const xml_node_iterator& rhs) const;
-
-		const xml_node& operator*() const;
-		const xml_node* operator->() const;
-
-		const xml_node_iterator& operator++();
-		xml_node_iterator operator++(int);
-		
-		const xml_node_iterator& operator--();
-		xml_node_iterator operator--(int);
-	};
-
-	/// Attribute iterator.
-	class xml_attribute_iterator
-#ifndef PUGIXML_NO_STL
-	: public std::iterator
-#endif
-	{
-		friend class xml_node;
-
-	private:
-		xml_attribute _prev;
-		xml_attribute _wrap;
-
-		/// Initializing ctor
-		explicit xml_attribute_iterator(const xml_attribute_struct* ref);
-	public:
-		/// Default ctor
-		xml_attribute_iterator();
-
-		/// Initializing ctor
-		xml_attribute_iterator(const xml_attribute& attr);
-
-		/// Initializing ctor (for past-the-end)
-		xml_attribute_iterator(const xml_attribute_struct* ref, const xml_attribute_struct* prev);
-
-		bool operator==(const xml_attribute_iterator& rhs) const;
-		bool operator!=(const xml_attribute_iterator& rhs) const;
-
-		const xml_attribute& operator*() const;
-		const xml_attribute* operator->() const;
-
-		const xml_attribute_iterator& operator++();
-		xml_attribute_iterator operator++(int);
-		
-		const xml_attribute_iterator& operator--();
-		xml_attribute_iterator operator--(int);
-	};
-
-	/// Abstract tree walker class for xml_node::traverse().
-	class xml_tree_walker
-	{
-	private:
-		int _deep; ///< Current node depth.
-	public:
-		/// Default ctor
-		xml_tree_walker();
-
-		/// Virtual dtor
-		virtual ~xml_tree_walker();
-
-	public:
-		/// Increment node depth.
-		virtual void push();
-
-		/// Decrement node depth
-		virtual void pop();
-
-		/// Access node depth
-		virtual int depth() const;
-	
-	public:
-		/// Callback when traverse on a node begins.
-		/// \return returning false will abort the traversal.
-		virtual bool begin(const xml_node&);
-
-		/// Callback when traverse on a node ends.
-		/// \return Returning false will abort the traversal.
-		virtual bool end(const xml_node&);
-	};
-
-	/// Memory block (internal)
-	struct xml_memory_block
-	{
-		xml_memory_block();
-
-		xml_memory_block* next;
-		size_t size;
-
-		char data[memory_block_size];
-	};
-
-	struct transfer_ownership_tag {};
-
-	/// Provides a high-level interface to the XML parser.
-	class xml_parser
-	{
-	private:
-		char*				_buffer; ///< character buffer
-
-		xml_memory_block	_memory; ///< Memory block
-		
-		xml_node_struct*	_xmldoc; ///< Pointer to current XML document tree root.
-		unsigned int		_optmsk; ///< Parser options.
-	
-		xml_parser(const xml_parser&);
-		const xml_parser& operator=(const xml_parser&);
-
-		void free();	///< free memory
-
-	public:
-		/// Constructor.
-		/// \param optmsk - Options mask.
-		xml_parser(unsigned int optmsk = parse_default);
-
-		/// Parse constructor.
-		/// \param xmlstr - readwrite string with xml data
-		/// \param optmsk - Options mask.
-		/// \see parse
-		xml_parser(char* xmlstr, unsigned int optmsk = parse_default);
-
-		/// Parse constructor that gains ownership.
-		/// \param xmlstr - readwrite string with xml data
-		/// \param optmsk - Options mask.
-		/// \see parse
-		xml_parser(const transfer_ownership_tag&, char* xmlstr, unsigned int optmsk = parse_default);
-
-#ifndef PUGIXML_NO_STL
-		/// Parse constructor.
-		/// \param stream - stream with xml data
-		/// \param optmsk - Options mask.
-		/// \see parse
-		xml_parser(std::istream& stream, unsigned int optmsk = parse_default);
-#endif
-
-		/// Dtor
-		~xml_parser();
-
-	public:
-		/// Cast as xml_node (same as document).
-		operator xml_node() const;
-
-		/// Returns the root wrapped by an xml_node.
-		xml_node document() const;
-
-	public:
-		/// Get parser options mask.
-		unsigned int options() const;
-
-		/// Set parser options mask.
-		unsigned int options(unsigned int optmsk);
-
-	public:
-#ifndef PUGIXML_NO_STL
-		/// Parse the given XML stream
-		/// \param stream - stream with xml data
-		/// \param optmsk - Options mask.
-		void parse(std::istream& stream, unsigned int optmsk = parse_noset);
-#endif
-
-		/// Parse the given XML string in-situ.
-		/// \param xmlstr - readwrite string with xml data
-		/// \param optmsk - Options mask.
-		/// \return last position or NULL
-		/// \rem input string is zero-segmented
-		char* parse(char* xmlstr, unsigned int optmsk = parse_noset);
-		
-		/// Parse the given XML string in-situ (gains ownership).
-		/// \param xmlstr - readwrite string with xml data
-		/// \param optmsk - Options mask.
-		/// \return last position or NULL
-		/// \rem input string is zero-segmented
-		char* parse(const transfer_ownership_tag&, char* xmlstr, unsigned int optmsk = parse_noset);
-	};
-
-	/// Utility functions for xml
-	
-#ifndef PUGIXML_NO_STL
-	/// Convert utf16 to utf8
-	std::string utf8(const wchar_t* str);
-	
-	/// Convert utf8 to utf16
-	std::wstring utf16(const char* str);
-#endif
-}
-
-/// Inline implementation
-
-namespace pugi
-{
-	namespace impl
-	{
-		int strcmpwild(const char*, const char*);
-	}
-
-	template  void xml_node::all_elements_by_name(const char* name, OutputIterator it) const
-	{
-		if (empty()) return;
-		
-		for (xml_node node = first_child(); node; node = node.next_sibling())
-		{
-			if (!strcmp(name, node.name()))
-			{
-				*it = node;
-				++it;
-			}
-			
-			if (node.first_child()) node.all_elements_by_name(name, it);
-		}
-	}
-
-	template  void xml_node::all_elements_by_name_w(const char* name, OutputIterator it) const
-	{
-		if (empty()) return;
-		
-		for (xml_node node = first_child(); node; node = node.next_sibling())
-		{
-			if (!impl::strcmpwild(name, node.name()))
-			{
-				*it = node;
-				++it;
-			}
-			
-			if (node.first_child()) node.all_elements_by_name_w(name, it);
-		}
-	}
-	
-	template  inline xml_attribute xml_node::find_attribute(Predicate pred) const
-	{
-		if (!empty())
-			for (xml_attribute attrib = first_attribute(); attrib; attrib = attrib.next_attribute())
-				if (pred(attrib))
-					return attrib;
-		
-		return xml_attribute();
-	}
-
-	template  inline xml_node xml_node::find_child(Predicate pred) const
-	{
-		if (!empty())
-			for (xml_node node = first_child(); node; node = node.next_sibling())
-				if (pred(node))
-					return node;
-
-		return xml_node();
-	}
-
-	template  inline xml_node xml_node::find_element(Predicate pred) const
-	{
-		if (!empty())
-			for (xml_node node = first_child(); node; node = node.next_sibling())
-			{
-				if (pred(node))
-					return node;
-				
-				if (node.first_child())
-				{
-					xml_node found = node.find_element(pred);
-					if (found) return found;
-				}
-			}
-
-		return xml_node();
-	}
-}
-
-#endif
+///////////////////////////////////////////////////////////////////////////////
+//
+// Pug Improved XML Parser - Version 0.3
+// --------------------------------------------------------
+// Copyright (C) 2006-2007, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+// This work is based on the pugxml parser, which is:
+// Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
+// Released into the Public Domain. Use at your own risk.
+// See pugxml.xml for further information, history, etc.
+// Contributions by Neville Franks (readonly@getsoft.com).
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef HEADER_PUGIXML_HPP
+#define HEADER_PUGIXML_HPP
+
+#include "pugiconfig.hpp"
+
+#ifndef PUGIXML_NO_STL
+#	include 
+#	include 
+#	include 
+#endif
+
+// No XPath without STL
+#ifdef PUGIXML_NO_STL
+#	ifndef PUGIXML_NO_XPATH
+#		define PUGIXML_NO_XPATH
+#	endif
+#endif
+
+#include 
+#include 
+
+/// The PugiXML Parser namespace.
+namespace pugi
+{
+	/// Tree node classification.
+	enum xml_node_type
+	{
+		node_null,			///< Undifferentiated entity
+		node_document,		///< A document tree's absolute root.
+		node_element,		///< E.g. '<...>'
+		node_pcdata,		///< E.g. '>...<'
+		node_cdata,			///< E.g. ''
+		node_comment,		///< E.g. ''
+		node_pi				///< E.g. ''
+	};
+
+	// Parsing options
+
+	/**
+	 * Memory block size, used for fast allocator. Memory for DOM tree is allocated in blocks of
+	 * memory_block_size + 4.
+	 * This value affects size of xml_memory class.
+	 */
+	const size_t memory_block_size = 32768;
+
+	/**
+	 * Minimal parsing mode. Equivalent to turning all other flags off. This set of flags means
+	 * that pugixml does not add pi/cdata sections or comments to DOM tree and does not perform
+	 * any conversions for input data, meaning fastest parsing.
+	 */
+	const unsigned int parse_minimal			= 0x0000;
+
+	/**
+	 * This flag determines if processing instructions (nodes with type node_pi; such nodes have the
+	 * form of  or  in XML) are to be put in DOM tree. If this flag is off,
+	 * they are not put in the tree, but are still parsed and checked for correctness.
+	 *
+	 * The corresponding node in DOM tree will have type node_pi, name "target" and value "content",
+	 * if any.
+	 *
+	 * Note that  (document declaration) is not considered to be a PI.
+	 *
+	 * This flag is off by default.
+	 */
+	const unsigned int parse_pi					= 0x0001;
+
+	/**
+	 * This flag determines if comments (nodes with type node_comment; such nodes have the form of
+	 *  in XML) are to be put in DOM tree. If this flag is off, they are not put in
+	 * the tree, but are still parsed and checked for correctness.
+	 *
+	 * The corresponding node in DOM tree will have type node_comment, empty name and value "content".
+	 *
+	 * This flag is off by default.
+	 */
+	const unsigned int parse_comments			= 0x0002;
+
+	/**
+	 * This flag determines if CDATA sections (nodes with type node_cdata; such nodes have the form
+	 * of  in XML) are to be put in DOM tree. If this flag is off, they are not
+	 * put in the tree, but are still parsed and checked for correctness.
+	 *
+	 * The corresponding node in DOM tree will have type node_cdata, empty name and value "content".
+	 *
+	 * This flag is on by default.
+	 */
+	const unsigned int parse_cdata				= 0x0004;
+
+	/**
+	 * This flag determines if nodes with PCDATA (regular text) that consist only of whitespace
+	 * characters are to be put in DOM tree. Often whitespace-only data is not significant for the
+	 * application, and the cost of allocating and storing such nodes (both memory and speed-wise)
+	 * can be significant. For example, after parsing XML string "  ",  element
+	 * will have 3 children when parse_ws_pcdata is set (child with type node_pcdata and value=" ",
+	 * child with type node_element and name "a", and another child with type node_pcdata and
+	 * value=" "), and only 1 child when parse_ws_pcdata is not set.
+	 * 
+	 * This flag is off by default.
+	 */
+	const unsigned int parse_ws_pcdata			= 0x0008;
+
+	/**
+	 * This flag determines if character and entity references are to be expanded during the parsing
+	 * process. Character references are &#...; or &#x...; (... is Unicode numeric representation of
+     * character in either decimal (&#...;) or hexadecimal (&#x...;) form), entity references are &...;
+     * Note that as pugixml does not handle DTD, the only allowed entities are predefined ones - 
+     * &lt;, &gt;, &amp;, &apos; and &quot;. If character/entity reference can not be expanded, it is
+     * leaved as is, so you can do additional processing later.
+     * Reference expansion is performed in attribute values and PCDATA content.
+     *
+     * This flag is on by default.
+     */
+	const unsigned int parse_escapes			= 0x0010;
+
+	/**
+	 * This flag determines if EOL handling (that is, replacing sequences 0x0d 0x0a by a single 0x0a
+	 * character, and replacing all standalone 0x0d characters by 0x0a) is to be performed on input
+	 * data (that is, comments contents, PCDATA/CDATA contents and attribute values).
+	 *
+	 * This flag is on by default.
+	 */
+	const unsigned int parse_eol				= 0x0020;
+	
+ 	/**
+ 	 * This flag determines if attribute value normalization should be performed for all attributes,
+ 	 * assuming that their type is not CDATA. This means, that:
+ 	 * 1. Whitespace characters (new line, tab and space) are replaced with space (' ')
+ 	 * 2. Afterwards sequences of spaces are replaced with a single space
+ 	 * 3. Leading/trailing whitespace characters are trimmed
+ 	 * 
+ 	 * This flag is off by default.
+ 	 */
+ 	const unsigned int parse_wnorm_attribute	= 0x0040;
+
+ 	/**
+ 	 * This flag determines if attribute value normalization should be performed for all attributes,
+ 	 * assuming that their type is CDATA. This means, that whitespace characters (new line, tab and
+ 	 * space) are replaced with space (' '). Note, that the actions performed while this flag is on
+ 	 * are also performed if parse_wnorm_attribute is on, so this flag has no effect if
+ 	 * parse_wnorm_attribute flag is set.
+ 	 * 
+ 	 * This flag is on by default.
+ 	 */
+ 	const unsigned int parse_wconv_attribute	= 0x0080;
+	
+	/**
+     * This is the default set of flags. It includes parsing CDATA sections (comments/PIs are not
+     * parsed), performing character and entity reference expansion, replacing whitespace characters
+     * with spaces in attribute values and performing EOL handling. Note, that PCDATA sections
+     * consisting only of whitespace characters are not parsed (by default) for performance reasons.
+     */
+	const unsigned int parse_default			= parse_cdata | parse_escapes | parse_wconv_attribute | parse_eol;
+
+	// Formatting flags
+	
+	/**
+	 * Indent the nodes that are written to output stream with as many indentation strings as deep
+	 * the node is in DOM tree.
+	 *
+	 * This flag is on by default.
+	 */
+	const unsigned int format_indent	= 0x01;
+	
+	/**
+	 * This flag determines how the non-printable symbols are written to output stream - they are
+	 * either considered UTF-8 and are written as UTF-8 character, escaped with &#...;, or they are
+	 * considered to be ASCII and each ASCII character is escaped separately.
+	 *
+	 * This flag is on by default.
+	 */
+	const unsigned int format_utf8		= 0x02;
+	
+	/**
+	 * This flag determines if UTF-8 BOM is to be written to output stream.
+	 *
+	 * This flag is off by default.
+	 */
+	const unsigned int format_write_bom	= 0x04;
+	
+	/**
+	 * If this flag is on, no indentation is performed and no line breaks are written to output file.
+	 * This means that the data is written to output stream as is.
+	 *
+	 * This flag is off by default.
+	 */
+	const unsigned int format_raw		= 0x08;
+	
+	/**
+	 * This is the default set of formatting flags. It includes indenting nodes depending on their
+	 * depth in DOM tree and considering input data to be UTF-8.
+	 */
+	const unsigned int format_default	= format_indent | format_utf8;
+		
+	// Forward declarations
+	struct xml_attribute_struct;
+	struct xml_node_struct;
+
+	class xml_allocator;
+
+	class xml_node_iterator;
+	class xml_attribute_iterator;
+
+	class xml_tree_walker;
+	
+	class xml_node;
+
+	#ifndef PUGIXML_NO_XPATH
+	class xpath_node;
+	class xpath_node_set;
+	class xpath_ast_node;
+	class xpath_allocator;
+	
+	/**
+	 * A class that holds compiled XPath query and allows to evaluate query result
+	 */
+	class xpath_query
+	{
+	private:
+		// Noncopyable semantics
+		xpath_query(const xpath_query&);
+		xpath_query& operator=(const xpath_query&);
+
+		xpath_allocator* m_alloc;
+		xpath_ast_node* m_root;
+
+		void compile(const char* query);
+
+	public:
+		/**
+		 * Ctor from string with XPath expression.
+		 * Throws xpath_exception on compilation error, std::bad_alloc on out of memory error.
+		 *
+		 * \param query - string with XPath expression
+		 */
+		explicit xpath_query(const char* query);
+
+		/**
+		 * Dtor
+		 */
+		~xpath_query();
+		
+		/**
+		 * Evaluate expression as boolean value for the context node \a n.
+		 * If expression does not directly evaluate to boolean, the expression result is converted
+		 * as through boolean() XPath function call.
+		 * Throws std::bad_alloc on out of memory error.
+		 *
+		 * \param n - context node
+		 * \return evaluation result
+		 */
+		bool evaluate_boolean(const xml_node& n);
+		
+		/**
+		 * Evaluate expression as double value for the context node \a n.
+		 * If expression does not directly evaluate to double, the expression result is converted
+		 * as through number() XPath function call.
+		 * Throws std::bad_alloc on out of memory error.
+		 *
+		 * \param n - context node
+		 * \return evaluation result
+		 */
+		double evaluate_number(const xml_node& n);
+		
+		/**
+		 * Evaluate expression as string value for the context node \a n.
+		 * If expression does not directly evaluate to string, the expression result is converted
+		 * as through string() XPath function call.
+		 * Throws std::bad_alloc on out of memory error.
+		 *
+		 * \param n - context node
+		 * \return evaluation result
+		 */
+		std::string evaluate_string(const xml_node& n);
+		
+		/**
+		 * Evaluate expression as node set for the context node \a n.
+		 * If expression does not directly evaluate to node set, function returns empty node set.
+		 * Throws std::bad_alloc on out of memory error.
+		 *
+		 * \param n - context node
+		 * \return evaluation result
+		 */
+		xpath_node_set evaluate_node_set(const xml_node& n);
+	};
+	#endif
+	
+	/**
+	 * A light-weight wrapper for manipulating attributes in DOM tree.
+	 * Note: xml_attribute does not allocate any memory for the attribute it wraps; it only wraps a
+	 * pointer to existing attribute.
+	 */
+	class xml_attribute
+	{
+		friend class xml_attribute_iterator;
+		friend class xml_node;
+
+	private:
+		xml_attribute_struct* _attr;
+	
+    	/// \internal Safe bool type
+    	typedef xml_attribute_struct* xml_attribute::*unspecified_bool_type;
+
+		/// \internal Initializing ctor
+		explicit xml_attribute(xml_attribute_struct* attr);
+
+	public:
+		/**
+		 * Default ctor. Constructs an empty attribute.
+		 */
+		xml_attribute();
+		
+	public:
+    	/**
+    	 * Safe bool conversion.
+    	 * Allows xml_node to be used in a context where boolean variable is expected, such as 'if (node)'.
+    	 */
+    	operator unspecified_bool_type() const;
+
+    	// Borland C++ workaround
+    	bool operator!() const;
+
+		/**
+		 * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+		 *
+		 * \param r - value to compare to
+		 * \return comparison result
+		 */
+		bool operator==(const xml_attribute& r) const;
+		
+		/**
+		 * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+		 *
+		 * \param r - value to compare to
+		 * \return comparison result
+		 */
+		bool operator!=(const xml_attribute& r) const;
+		
+		/**
+		 * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+		 *
+		 * \param r - value to compare to
+		 * \return comparison result
+		 */
+		bool operator<(const xml_attribute& r) const;
+		
+		/**
+		 * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+		 *
+		 * \param r - value to compare to
+		 * \return comparison result
+		 */
+		bool operator>(const xml_attribute& r) const;
+		
+		/**
+		 * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+		 *
+		 * \param r - value to compare to
+		 * \return comparison result
+		 */
+		bool operator<=(const xml_attribute& r) const;
+		
+		/**
+		 * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+		 *
+		 * \param r - value to compare to
+		 * \return comparison result
+		 */
+		bool operator>=(const xml_attribute& r) const;
+
+	public:
+    	/**
+    	 * Get next attribute in attribute list of node that contains the attribute.
+    	 *
+    	 * \return next attribute, if any; empty attribute otherwise
+    	 */
+    	xml_attribute next_attribute() const;
+
+    	/**
+    	 * Get previous attribute in attribute list of node that contains the attribute.
+    	 *
+    	 * \return previous attribute, if any; empty attribute otherwise
+    	 */
+    	xml_attribute previous_attribute() const;
+
+		/**
+		 * Cast attribute value as int.
+		 *
+		 * \return attribute value as int, or 0 if conversion did not succeed or attribute is empty
+		 */
+		int as_int() const;
+
+		/**
+		 * Cast attribute value as double.
+		 *
+		 * \return attribute value as double, or 0.0 if conversion did not succeed or attribute is empty
+		 */
+		double as_double() const;
+	
+		/**
+		 * Cast attribute value as float.
+		 *
+		 * \return attribute value as float, or 0.0f if conversion did not succeed or attribute is empty
+		 */
+		float as_float() const;
+
+		/**
+		 * Cast attribute value as bool. Returns true for attributes with values that start with '1',
+		 * 't', 'T', 'y', 'Y', returns false for other attributes.
+		 *
+		 * \return attribute value as bool, or false if conversion did not succeed or attribute is empty
+		 */
+		bool as_bool() const;
+
+		/// \internal Document order or 0 if not set
+		unsigned int document_order() const;
+
+	public:
+		/**
+         * Set attribute value to \a rhs.
+         *
+         * \param rhs - new attribute value
+         * \return self
+         */
+		xml_attribute& operator=(const char* rhs);
+	
+		/**
+         * Set attribute value to \a rhs.
+         *
+         * \param rhs - new attribute value
+         * \return self
+         */
+		xml_attribute& operator=(int rhs);
+	
+		/**
+         * Set attribute value to \a rhs.
+         *
+         * \param rhs - new attribute value
+         * \return self
+         */
+		xml_attribute& operator=(double rhs);
+		
+		/**
+         * Set attribute value to either 'true' or 'false' (depends on whether \a rhs is true or false).
+         *
+         * \param rhs - new attribute value
+         * \return self
+         */
+		xml_attribute& operator=(bool rhs);
+
+		/**
+		 * Set attribute name to \a rhs.
+		 *
+		 * \param rhs - new attribute name
+		 * \return success flag (call fails if attribute is empty or there is not enough memory)
+		 */
+		bool set_name(const char* rhs);
+		
+		/**
+		 * Set attribute value to \a rhs.
+		 *
+		 * \param rhs - new attribute value
+		 * \return success flag (call fails if attribute is empty or there is not enough memory)
+		 */
+		bool set_value(const char* rhs);
+
+	public:
+		/**
+		 * Check if attribute is empty.
+		 *
+		 * \return true if attribute is empty, false otherwise
+		 */
+		bool empty() const;
+
+	public:
+		/**
+		 * Get attribute name.
+		 *
+		 * \return attribute name, or "" if attribute is empty
+		 */
+		const char* name() const;
+
+		/**
+		 * Get attribute value.
+		 *
+		 * \return attribute value, or "" if attribute is empty
+		 */
+		const char* value() const;
+	};
+
+#ifdef __BORLANDC__
+	// Borland C++ workaround
+	bool operator&&(const xml_attribute& lhs, bool rhs);
+	bool operator||(const xml_attribute& lhs, bool rhs);
+#endif
+
+	/**
+	 * A light-weight wrapper for manipulating nodes in DOM tree.
+	 * Note: xml_node does not allocate any memory for the node it wraps; it only wraps a pointer to
+	 * existing node.
+	 */
+	class xml_node
+	{
+		friend class xml_node_iterator;
+
+	protected:
+		xml_node_struct* _root;
+
+    	/// \internal Safe bool type
+    	typedef xml_node_struct* xml_node::*unspecified_bool_type;
+
+		/// \internal Initializing ctor
+		explicit xml_node(xml_node_struct* p);
+
+		/// \internal Precompute document order (valid only for document node)
+		void precompute_document_order_impl();
+
+		/// \internal Get allocator
+		xml_allocator& get_allocator() const;
+
+	public:
+		/**
+		 * Default ctor. Constructs an empty node.
+		 */
+		xml_node();
+
+	public:
+    	/**
+    	 * Safe bool conversion.
+    	 * Allows xml_node to be used in a context where boolean variable is expected, such as 'if (node)'.
+    	 */
+		operator unspecified_bool_type() const;
+
+		// Borland C++ workaround
+		bool operator!() const;
+	
+		/**
+		 * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+		 *
+		 * \param r - value to compare to
+		 * \return comparison result
+		 */
+		bool operator==(const xml_node& r) const;
+
+		/**
+		 * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+		 *
+		 * \param r - value to compare to
+		 * \return comparison result
+		 */
+		bool operator!=(const xml_node& r) const;
+
+		/**
+		 * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+		 *
+		 * \param r - value to compare to
+		 * \return comparison result
+		 */
+		bool operator<(const xml_node& r) const;
+
+		/**
+		 * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+		 *
+		 * \param r - value to compare to
+		 * \return comparison result
+		 */
+		bool operator>(const xml_node& r) const;
+
+		/**
+		 * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+		 *
+		 * \param r - value to compare to
+		 * \return comparison result
+		 */
+		bool operator<=(const xml_node& r) const;
+		
+		/**
+		 * Compare wrapped pointer to the attribute to the pointer that is wrapped by \a r.
+		 *
+		 * \param r - value to compare to
+		 * \return comparison result
+		 */
+		bool operator>=(const xml_node& r) const;
+
+	public:
+		/**
+		 * Node iterator type (for child nodes).
+		 * \see xml_node_iterator
+		 */
+		typedef xml_node_iterator iterator;
+
+		/**
+		 * Node iterator type (for child nodes).
+		 * \see xml_attribute_iterator
+		 */
+		typedef xml_attribute_iterator attribute_iterator;
+
+		/**
+		 * Access the begin iterator for this node's collection of child nodes.
+		 *
+		 * \return iterator that points to the first child node, or past-the-end iterator if node is empty or has no children
+		 */
+		iterator begin() const;
+	
+		/**
+		 * Access the end iterator for this node's collection of child nodes.
+		 *
+		 * \return past-the-end iterator for child list
+		 */
+		iterator end() const;
+	
+		/**
+		 * Access the begin iterator for this node's collection of attributes.
+		 *
+		 * \return iterator that points to the first attribute, or past-the-end iterator if node is empty or has no attributes
+		 */
+		attribute_iterator attributes_begin() const;
+	
+		/**
+		 * Access the end iterator for this node's collection of attributes.
+		 *
+		 * \return past-the-end iterator for attribute list
+		 */
+		attribute_iterator attributes_end() const;
+
+	public:
+		/**
+		 * Check if node is empty.
+		 *
+		 * \return true if node is empty, false otherwise
+		 */
+		bool empty() const;
+
+	public:
+		/**
+		 * Get node type
+		 *
+		 * \return node type; node_null for empty nodes
+		 */
+		xml_node_type type() const;
+
+		/**
+		 * Get node name (element name for element nodes, PI target for PI)
+		 *
+		 * \return node name, if any; "" otherwise
+		 */
+		const char* name() const;
+
+		/**
+		 * Get node value (comment/PI/PCDATA/CDATA contents, depending on node type)
+		 *
+		 * \return node value, if any; "" otherwise
+		 */
+		const char* value() const;
+	
+		/**
+		 * Get child with the specified name
+		 *
+		 * \param name - child name
+		 * \return child with the specified name, if any; empty node otherwise
+		 */
+		xml_node child(const char* name) const;
+
+		/**
+		 * Get child with the name that matches specified pattern
+		 *
+		 * \param name - child name pattern
+		 * \return child with the name that matches pattern, if any; empty node otherwise
+		 */
+		xml_node child_w(const char* name) const;
+
+		/**
+		 * Get attribute with the specified name
+		 *
+		 * \param name - attribute name
+		 * \return attribute with the specified name, if any; empty attribute otherwise
+		 */
+		xml_attribute attribute(const char* name) const;
+
+		/**
+		 * Get attribute with the name that matches specified pattern
+		 *
+		 * \param name - attribute name pattern
+		 * \return attribute with the name that matches pattern, if any; empty attribute otherwise
+		 */
+		xml_attribute attribute_w(const char* name) const;
+
+		/**
+		 * Get first of following sibling nodes with the specified name
+		 *
+		 * \param name - sibling name
+		 * \return node with the specified name, if any; empty node otherwise
+		 */
+		xml_node next_sibling(const char* name) const;
+
+		/**
+		 * Get first of the following sibling nodes with the name that matches specified pattern
+		 *
+		 * \param name - sibling name pattern
+		 * \return node with the name that matches pattern, if any; empty node otherwise
+		 */
+		xml_node next_sibling_w(const char* name) const;
+
+		/**
+		 * Get following sibling
+		 *
+		 * \return following sibling node, if any; empty node otherwise
+		 */
+		xml_node next_sibling() const;
+
+		/**
+		 * Get first of preceding sibling nodes with the specified name
+		 *
+		 * \param name - sibling name
+		 * \return node with the specified name, if any; empty node otherwise
+		 */
+		xml_node previous_sibling(const char* name) const;
+
+		/**
+		 * Get first of the preceding sibling nodes with the name that matches specified pattern
+		 *
+		 * \param name - sibling name pattern
+		 * \return node with the name that matches pattern, if any; empty node otherwise
+		 */
+		xml_node previous_sibling_w(const char* name) const;
+
+		/**
+		 * Get preceding sibling
+		 *
+		 * \return preceding sibling node, if any; empty node otherwise
+		 */
+		xml_node previous_sibling() const;
+
+		/**
+		 * Get parent node
+		 *
+		 * \return parent node if any; empty node otherwise
+		 */
+		xml_node parent() const;
+
+		/**
+		 * Get root of DOM tree this node belongs to.
+		 *
+		 * \return tree root
+		 */
+		xml_node root() const;
+
+		/**
+		 * Get child value of current node; that is, value of the first child node of type PCDATA/CDATA
+		 *
+		 * \return child value of current node, if any; "" otherwise
+		 */
+		const char* child_value() const;
+
+		/**
+		 * Get child value of child with specified name. \see child_value
+		 * node.child_value(name) is equivalent to node.child(name).child_value()
+		 *
+		 * \param name - child name
+		 * \return child value of specified child node, if any; "" otherwise
+		 */
+		const char* child_value(const char* name) const;
+
+		/**
+		 * Get child value of child with name that matches the specified pattern. \see child_value
+		 * node.child_value_w(name) is equivalent to node.child_w(name).child_value()
+		 *
+		 * \param name - child name pattern
+		 * \return child value of specified child node, if any; "" otherwise
+		 */
+		const char* child_value_w(const char* name) const;
+
+	public:	
+		/**
+		 * Set node name to \a rhs (for PI/element nodes). \see name
+		 *
+		 * \param rhs - new node name
+		 * \return success flag (call fails if node is of the wrong type or there is not enough memory)
+		 */
+		bool set_name(const char* rhs);
+		
+		/**
+		 * Set node value to \a rhs (for PI/PCDATA/CDATA/comment nodes). \see value
+		 *
+		 * \param rhs - new node value
+		 * \return success flag (call fails if node is of the wrong type or there is not enough memory)
+		 */
+		bool set_value(const char* rhs);
+
+		/**
+		 * Add attribute with specified name (for element nodes)
+		 *
+		 * \param name - attribute name
+		 * \return added attribute, or empty attribute if there was an error (wrong node type)
+		 */
+		xml_attribute append_attribute(const char* name);
+
+		/**
+		 * Insert attribute with specified name after \a attr (for element nodes)
+		 *
+		 * \param name - attribute name
+		 * \param attr - attribute to insert a new one after
+		 * \return inserted attribute, or empty attribute if there was an error (wrong node type, or attr does not belong to node)
+		 */
+		xml_attribute insert_attribute_after(const char* name, const xml_attribute& attr);
+
+		/**
+		 * Insert attribute with specified name before \a attr (for element nodes)
+		 *
+		 * \param name - attribute name
+		 * \param attr - attribute to insert a new one before
+		 * \return inserted attribute, or empty attribute if there was an error (wrong node type, or attr does not belong to node)
+		 */
+		xml_attribute insert_attribute_before(const char* name, const xml_attribute& attr);
+
+		/**
+		 * Add child node with specified type (for element nodes)
+		 *
+		 * \param type - node type
+		 * \return added node, or empty node if there was an error (wrong node type)
+		 */
+		xml_node append_child(xml_node_type type = node_element);
+
+		/**
+		 * Insert child node with specified type after \a node (for element nodes)
+		 *
+		 * \param type - node type
+		 * \param node - node to insert a new one after
+		 * \return inserted node, or empty node if there was an error (wrong node type, or \a node is not a child of this node)
+		 */
+		xml_node insert_child_after(xml_node_type type, const xml_node& node);
+
+		/**
+		 * Insert child node with specified type before \a node (for element nodes)
+		 *
+		 * \param type - node type
+		 * \param node - node to insert a new one before
+		 * \return inserted node, or empty node if there was an error (wrong node type, or \a node is not a child of this node)
+		 */
+		xml_node insert_child_before(xml_node_type type, const xml_node& node);
+
+		/**
+		 * Remove specified attribute
+		 *
+		 * \param a - attribute to be removed
+		 */
+		void remove_attribute(const xml_attribute& a);
+
+		/**
+		 * Remove attribute with the specified name, if any
+		 *
+		 * \param name - attribute name
+		 */
+		void remove_attribute(const char* name);
+
+		/**
+		 * Remove specified child
+		 *
+		 * \param n - child node to be removed
+		 */
+		void remove_child(const xml_node& n);
+
+		/**
+		 * Remove child with the specified name, if any
+		 *
+		 * \param name - child name
+		 */
+		void remove_child(const char* name);
+
+	public:
+		/**
+		 * Get first attribute
+		 *
+		 * \return first attribute, if any; empty attribute otherwise
+		 */
+		xml_attribute first_attribute() const;
+
+		/**
+		 * Get last attribute
+		 *
+		 * \return last attribute, if any; empty attribute otherwise
+		 */
+        xml_attribute last_attribute() const;
+
+		/**
+		 * Get all elements from subtree with given name
+		 *
+		 * \param name - node name
+		 * \param it - output iterator (for example, std::back_insert_iterator (result of std::back_inserter))
+		 */
+		template  void all_elements_by_name(const char* name, OutputIterator it) const;
+
+		/**
+		 * Get all elements from subtree with name that matches given pattern
+		 *
+		 * \param name - node name pattern
+		 * \param it - output iterator (for example, std::back_insert_iterator (result of std::back_inserter))
+		 */
+		template  void all_elements_by_name_w(const char* name, OutputIterator it) const;
+
+		/**
+		 * Get first child
+		 *
+		 * \return first child, if any; empty node otherwise
+		 */
+		xml_node first_child() const;
+
+		/**
+		 * Get last child
+		 *
+		 * \return last child, if any; empty node otherwise
+		 */
+        xml_node last_child() const;
+		
+		/**
+		 * Find attribute using predicate
+		 *
+		 * \param pred - predicate, that takes xml_attribute and returns bool
+		 * \return first attribute for which predicate returned true, or empty attribute
+		 */
+		template  xml_attribute find_attribute(Predicate pred) const;
+
+		/**
+		 * Find child node using predicate
+		 *
+		 * \param pred - predicate, that takes xml_node and returns bool
+		 * \return first child node for which predicate returned true, or empty node
+		 */
+		template  xml_node find_child(Predicate pred) const;
+
+		/**
+		 * Find node from subtree using predicate
+		 *
+		 * \param pred - predicate, that takes xml_node and returns bool
+		 * \return first node from subtree for which predicate returned true, or empty node
+		 */
+		template  xml_node find_node(Predicate pred) const;
+
+#ifndef PUGIXML_NO_STL
+		/**
+		 * Get the absolute node path from root as a text string.
+		 *
+		 * \param delimiter - delimiter character to insert between element names
+		 * \return path string (e.g. '/bookstore/book/author').
+		 */
+		std::string path(char delimiter = '/') const;
+#endif
+
+		/**
+		 * Search for a node by path.
+		 * \param path - path string; e.g. './foo/bar' (relative to node), '/foo/bar' (relative 
+		 * to root), '../foo/bar'.
+		 * \param delimiter - delimiter character to use while tokenizing path
+		 * \return matching node, if any; empty node otherwise
+		 */
+		xml_node first_element_by_path(const char* path, char delimiter = '/') const;
+
+		/**
+		 * Recursively traverse subtree with xml_tree_walker
+		 * \see xml_tree_walker::begin
+		 * \see xml_tree_walker::for_each
+		 * \see xml_tree_walker::end
+		 *
+		 * \param walker - tree walker to traverse subtree with
+		 * \return traversal result
+		 */
+		bool traverse(xml_tree_walker& walker);
+	
+	#ifndef PUGIXML_NO_XPATH
+		/**
+		 * Select single node by evaluating XPath query
+		 * 
+		 * \param query - query string
+		 * \return first node from the resulting node set by document order, or empty node if none found
+		 */
+		xpath_node select_single_node(const char* query) const;
+
+		/**
+		 * Select single node by evaluating XPath query
+		 *
+		 * \param query - compiled query
+		 * \return first node from the resulting node set by document order, or empty node if none found
+		 */
+		xpath_node select_single_node(xpath_query& query) const;
+
+		/**
+		 * Select node set by evaluating XPath query
+		 *
+		 * \param query - query string
+		 * \return resulting node set
+		 */
+		xpath_node_set select_nodes(const char* query) const;
+
+		/**
+		 * Select node set by evaluating XPath query
+		 *
+		 * \param query - compiled query
+		 * \return resulting node set
+		 */
+		xpath_node_set select_nodes(xpath_query& query) const;
+	#endif
+		
+		/// \internal Document order or 0 if not set
+		unsigned int document_order() const;
+
+	#ifndef PUGIXML_NO_STL
+		/**
+		 * Print subtree to stream
+		 *
+		 * \param os - output stream
+		 * \param indent - indentation string
+		 * \param flags - formatting flags
+		 * \param depth - starting depth (used for indentation)
+		 */
+		void print(std::ostream& os, const char* indent = "\t", unsigned int flags = format_default, unsigned int depth = 0);
+	#endif
+	};
+
+#ifdef __BORLANDC__
+	// Borland C++ workaround
+	bool operator&&(const xml_node& lhs, bool rhs);
+	bool operator||(const xml_node& lhs, bool rhs);
+#endif
+
+	/**
+	 * Child node iterator.
+	 * It's a bidirectional iterator with value type 'xml_node'.
+	 */
+	class xml_node_iterator
+#ifndef PUGIXML_NO_STL
+	: public std::iterator
+#endif
+	{
+		friend class xml_node;
+
+	private:
+		xml_node _prev;
+		xml_node _wrap;
+
+		/// \internal Initializing ctor
+		explicit xml_node_iterator(xml_node_struct* ref);
+
+	public:
+		/**
+		 * Default ctor
+		 */
+		xml_node_iterator();
+
+		/**
+		 * Initializing ctor
+		 *
+		 * \param node - node that iterator will point at
+		 */
+		xml_node_iterator(const xml_node& node);
+
+		/**
+		 * Initializing ctor (for past-the-end)
+		 *
+		 * \param ref - should be 0
+		 * \param prev - previous node
+		 */
+		xml_node_iterator(xml_node_struct* ref, xml_node_struct* prev);
+
+		/**
+		 * Check if this iterator is equal to \a rhs
+		 *
+		 * \param rhs - other iterator
+		 * \return comparison result
+		 */
+		bool operator==(const xml_node_iterator& rhs) const;
+		
+		/**
+		 * Check if this iterator is not equal to \a rhs
+		 *
+		 * \param rhs - other iterator
+		 * \return comparison result
+		 */
+		bool operator!=(const xml_node_iterator& rhs) const;
+
+		/**
+		 * Dereferencing operator
+		 *
+		 * \return reference to the node iterator points at
+		 */
+		xml_node& operator*();
+
+		/**
+		 * Member access operator
+		 *
+		 * \return poitner to the node iterator points at
+		 */
+		xml_node* operator->();
+
+		/**
+		 * Pre-increment operator
+		 *
+		 * \return self
+		 */
+		const xml_node_iterator& operator++();
+
+		/**
+		 * Post-increment operator
+		 *
+		 * \return old value
+		 */
+		xml_node_iterator operator++(int);
+		
+		/**
+		 * Pre-decrement operator
+		 *
+		 * \return self
+		 */
+		const xml_node_iterator& operator--();
+		
+		/**
+		 * Post-decrement operator
+		 *
+		 * \return old value
+		 */
+		xml_node_iterator operator--(int);
+	};
+
+	/**
+	 * Attribute iterator.
+	 * It's a bidirectional iterator with value type 'xml_attribute'.
+	 */
+	class xml_attribute_iterator
+#ifndef PUGIXML_NO_STL
+	: public std::iterator
+#endif
+	{
+		friend class xml_node;
+
+	private:
+		xml_attribute _prev;
+		xml_attribute _wrap;
+
+		/// \internal Initializing ctor
+		explicit xml_attribute_iterator(xml_attribute_struct* ref);
+
+	public:
+		/**
+		 * Default ctor
+		 */
+		xml_attribute_iterator();
+
+		/**
+		 * Initializing ctor
+		 *
+		 * \param node - node that iterator will point at
+		 */
+		xml_attribute_iterator(const xml_attribute& node);
+
+		/**
+		 * Initializing ctor (for past-the-end)
+		 *
+		 * \param ref - should be 0
+		 * \param prev - previous node
+		 */
+		xml_attribute_iterator(xml_attribute_struct* ref, xml_attribute_struct* prev);
+
+		/**
+		 * Check if this iterator is equal to \a rhs
+		 *
+		 * \param rhs - other iterator
+		 * \return comparison result
+		 */
+		bool operator==(const xml_attribute_iterator& rhs) const;
+		
+		/**
+		 * Check if this iterator is not equal to \a rhs
+		 *
+		 * \param rhs - other iterator
+		 * \return comparison result
+		 */
+		bool operator!=(const xml_attribute_iterator& rhs) const;
+
+		/**
+		 * Dereferencing operator
+		 *
+		 * \return reference to the node iterator points at
+		 */
+		xml_attribute& operator*();
+
+		/**
+		 * Member access operator
+		 *
+		 * \return poitner to the node iterator points at
+		 */
+		xml_attribute* operator->();
+
+		/**
+		 * Pre-increment operator
+		 *
+		 * \return self
+		 */
+		const xml_attribute_iterator& operator++();
+
+		/**
+		 * Post-increment operator
+		 *
+		 * \return old value
+		 */
+		xml_attribute_iterator operator++(int);
+		
+		/**
+		 * Pre-decrement operator
+		 *
+		 * \return self
+		 */
+		const xml_attribute_iterator& operator--();
+		
+		/**
+		 * Post-decrement operator
+		 *
+		 * \return old value
+		 */
+		xml_attribute_iterator operator--(int);
+	};
+
+	/**
+	 * Abstract tree walker class
+	 * \see xml_node::traverse
+	 */
+	class xml_tree_walker
+	{
+		friend class xml_node;
+
+	private:
+		int _depth;
+	
+	protected:
+		/**
+		 * Get node depth
+		 * 
+		 * \return node depth
+		 */
+		int depth() const;
+	
+	public:
+		/**
+		 * Default ctor
+		 */
+		xml_tree_walker();
+
+		/**
+		 * Virtual dtor
+		 */
+		virtual ~xml_tree_walker();
+
+	public:
+		/**
+		 * Callback that is called when traversal of node begins.
+		 *
+		 * \return returning false will abort the traversal
+		 */
+		virtual bool begin(xml_node&);
+
+		/**
+		 * Callback that is called for each node traversed
+		 *
+		 * \return returning false will abort the traversal
+		 */
+		virtual bool for_each(xml_node&) = 0;
+
+		/**
+		 * Callback that is called when traversal of node ends.
+		 *
+		 * \return returning false will abort the traversal
+		 */
+		virtual bool end(xml_node&);
+	};
+
+	/// \internal Memory block
+	struct xml_memory_block
+	{
+		xml_memory_block();
+
+		xml_memory_block* next;
+		size_t size;
+
+		char data[memory_block_size];
+	};
+
+	/**
+	 * Struct used to distinguish parsing with ownership transfer from parsing without it.
+	 * \see xml_document::parse
+	 */
+	struct transfer_ownership_tag {};
+
+	/**
+	 * Document class (DOM tree root).
+	 * This class has noncopyable semantics (private copy ctor/assignment operator).
+	 */
+	class xml_document: public xml_node
+	{
+	private:
+		char*				_buffer;
+
+		xml_memory_block	_memory;
+		
+		xml_document(const xml_document&);
+		const xml_document& operator=(const xml_document&);
+
+		void create();
+		void free();
+
+	public:
+		/**
+		 * Default ctor, makes empty document
+		 */
+		xml_document();
+
+		/**
+		 * Dtor
+		 */
+		~xml_document();
+
+	public:
+#ifndef PUGIXML_NO_STL
+		/**
+		 * Load document from stream.
+		 *
+		 * \param stream - stream with xml data
+		 * \param options - parsing options
+		 * \return success flag
+		 */
+		bool load(std::istream& stream, unsigned int options = parse_default);
+#endif
+
+		/**
+		 * Load document from string.
+		 *
+		 * \param contents - input string
+		 * \param options - parsing options
+		 * \return success flag
+		 */
+		bool load(const char* contents, unsigned int options = parse_default);
+
+		/**
+		 * Load document from file
+		 *
+		 * \param name - file name
+		 * \param options - parsing options
+		 * \return success flag
+		 */
+		bool load_file(const char* name, unsigned int options = parse_default);
+
+		/**
+		 * Parse the given XML string in-situ.
+		 * The string is modified; you should ensure that string data will persist throughout the
+		 * document's lifetime. Although, document does not gain ownership over the string, so you
+		 * should free the memory occupied by it manually.
+		 *
+		 * \param xmlstr - readwrite string with xml data
+		 * \param options - parsing options
+		 * \return success flag
+		 */
+		bool parse(char* xmlstr, unsigned int options = parse_default);
+		
+		/**
+		 * Parse the given XML string in-situ (gains ownership).
+		 * The string is modified; document gains ownership over the string, so you don't have to worry
+		 * about it's lifetime.
+		 * Call example: doc.parse(transfer_ownership_tag(), string, options);
+		 *
+		 * \param xmlstr - readwrite string with xml data
+		 * \param options - parsing options
+		 * \return success flag
+		 */
+		bool parse(const transfer_ownership_tag&, char* xmlstr, unsigned int options = parse_default);
+		
+#ifndef PUGIXML_NO_STL
+		/**
+		 * Save XML to file
+		 *
+		 * \param name - file name
+		 * \param indent - indentation string
+		 * \param flags - formatting flags
+		 * \return success flag
+		 */
+		bool save_file(const char* name, const char* indent = "\t", unsigned int flags = format_default);
+#endif
+
+		/**
+		 * Compute document order for the whole tree
+		 * Sometimes this makes evaluation of XPath queries faster.
+		 */
+		void precompute_document_order();
+	};
+
+#ifndef PUGIXML_NO_XPATH
+	/**
+	 * XPath exception class.
+	 */
+	class xpath_exception: public std::exception
+	{
+	private:
+		const char* m_message;
+
+	public:
+		/**
+		 * Construct exception from static error string
+		 *
+		 * \param message - error string
+		 */
+		explicit xpath_exception(const char* message);
+
+		/**
+		 * Return error message
+		 *
+		 * \return error message
+		 */
+		virtual const char* what() const throw();
+	};
+	
+	/**
+	 * XPath node class.
+	 * 
+	 * XPath defines node to be either xml_node or xml_attribute in pugixml terminology, so xpath_node
+	 * is either xml_node or xml_attribute.
+	 */
+	class xpath_node
+	{
+	private:
+		xml_node m_node;
+		xml_attribute m_attribute;
+	
+    	/// \internal Safe bool type
+    	typedef xml_node xpath_node::*unspecified_bool_type;
+
+	public:
+		/**
+		 * Construct empty XPath node
+		 */
+		xpath_node();
+		
+		/**
+		 * Construct XPath node from XML node
+		 *
+		 * \param node - XML node
+		 */
+		xpath_node(const xml_node& node);
+
+		/**
+		 * Construct XPath node from XML attribute
+		 *
+		 * \param attribute - XML attribute
+		 * \param parent - attribute's parent node
+		 */
+		xpath_node(const xml_attribute& attribute, const xml_node& parent);
+
+		/**
+		 * Get XML node, if any
+		 *
+		 * \return contained XML node, empty node otherwise
+		 */
+		xml_node node() const;
+		
+		/**
+		 * Get XML attribute, if any
+		 *
+		 * \return contained XML attribute, if any, empty attribute otherwise
+		 */
+		xml_attribute attribute() const;
+		
+		/**
+		 * Get parent of contained XML attribute, if any
+		 *
+		 * \return parent of contained XML attribute, if any, empty node otherwise
+		 */
+		xml_node parent() const;
+
+    	/**
+    	 * Safe bool conversion.
+    	 * Allows xpath_node to be used in a context where boolean variable is expected, such as 'if (node)'.
+    	 */
+		operator unspecified_bool_type() const;
+		
+		/**
+		 * Compares two XPath nodes
+		 *
+		 * \param n - XPath node to compare to
+		 * \return comparison result
+		 */
+		bool operator==(const xpath_node& n) const;
+		
+		/**
+		 * Compares two XPath nodes
+		 *
+		 * \param n - XPath node to compare to
+		 * \return comparison result
+		 */
+		bool operator!=(const xpath_node& n) const;
+	};
+
+	/**
+	 * Not necessarily ordered constant collection of XPath nodes
+	 */
+	class xpath_node_set
+	{
+		friend class xpath_ast_node;
+		
+	public:
+		/// Collection type
+		enum type_t
+		{
+			type_unsorted,			///< Not ordered
+			type_sorted,			///< Sorted by document order (ascending)
+			type_sorted_reverse		///< Sorted by document order (descending)
+		};
+		
+		/// Constant iterator type
+		typedef const xpath_node* const_iterator;
+	
+	private:
+		type_t m_type;
+		
+		xpath_node m_storage;
+		
+		xpath_node* m_begin;
+		xpath_node* m_end;
+		xpath_node* m_eos;
+		
+		bool m_using_storage;
+		
+		typedef xpath_node* iterator;
+
+		iterator mut_begin();
+		iterator mut_end();
+		
+		void push_back(const xpath_node& n);
+		
+		template  void append(Iterator begin, Iterator end);
+		
+		void truncate(iterator it);
+
+		void remove_duplicates();
+
+	public:
+		/**
+		 * Default ctor
+		 * Constructs empty set
+		 */
+		xpath_node_set();
+
+		/**
+         * Dtor
+         */
+		~xpath_node_set();
+		
+		/**
+		 * Copy ctor
+		 *
+		 * \param ns - set to copy
+		 */
+		xpath_node_set(const xpath_node_set& ns);
+
+		/**
+		 * Assignment operator
+		 *
+		 * \param ns - set to assign
+		 * \return self
+		 */
+		xpath_node_set& operator=(const xpath_node_set& ns);
+		
+		/**
+		 * Get collection type
+		 *
+		 * \return collection type
+		 */
+		type_t type() const;
+		
+		/**
+		 * Get collection size
+		 *
+		 * \return collection size
+		 */
+		size_t size() const;
+		
+		/**
+		 * Get begin constant iterator for collection
+		 *
+		 * \return begin constant iterator
+		 */
+		const_iterator begin() const;
+		
+		/**
+		 * Get end iterator for collection
+		 *
+		 * \return end iterator
+		 */
+		const_iterator end() const;
+		
+		/**
+		 * Sort the collection in ascending/descending order by document order
+		 *
+		 * \param reverse - whether to sort in ascending (false) or descending (true) order
+		 */
+		void sort(bool reverse = false);
+		
+		/**
+		 * Get first node in the collection by document order
+		 *
+		 * \return first node by document order
+		 */
+		xpath_node first() const;
+		
+		/**
+		 * Return true if collection is empty
+		 *
+		 * \return true if collection is empty, false otherwise
+		 */
+		bool empty() const;
+	};
+#endif
+
+#ifndef PUGIXML_NO_STL
+	/**
+	 * Convert utf16 to utf8
+	 *
+	 * \param str - input UTF16 string
+	 * \return output UTF8 string
+	 */
+	std::string as_utf8(const wchar_t* str);
+	
+	/**
+	 * Convert utf8 to utf16
+	 *
+	 * \param str - input UTF8 string
+	 * \return output UTF16 string
+	 */
+	std::wstring as_utf16(const char* str);
+#endif
+}
+
+// Inline implementation
+
+namespace pugi
+{
+	namespace impl
+	{
+		int strcmpwild(const char*, const char*);
+	}
+
+	template  void xml_node::all_elements_by_name(const char* name, OutputIterator it) const
+	{
+		if (empty()) return;
+		
+		for (xml_node node = first_child(); node; node = node.next_sibling())
+		{
+			if (node.type() == node_element)
+			{
+				if (!strcmp(name, node.name()))
+				{
+					*it = node;
+					++it;
+				}
+			
+				if (node.first_child()) node.all_elements_by_name(name, it);
+			}
+		}
+	}
+
+	template  void xml_node::all_elements_by_name_w(const char* name, OutputIterator it) const
+	{
+		if (empty()) return;
+		
+		for (xml_node node = first_child(); node; node = node.next_sibling())
+		{
+			if (node.type() == node_element)
+			{
+				if (!impl::strcmpwild(name, node.name()))
+				{
+					*it = node;
+					++it;
+				}
+					
+				if (node.first_child()) node.all_elements_by_name_w(name, it);
+			}
+		}
+	}
+	
+	template  inline xml_attribute xml_node::find_attribute(Predicate pred) const
+	{
+		if (!empty())
+			for (xml_attribute attrib = first_attribute(); attrib; attrib = attrib.next_attribute())
+				if (pred(attrib))
+					return attrib;
+		
+		return xml_attribute();
+	}
+
+	template  inline xml_node xml_node::find_child(Predicate pred) const
+	{
+		if (!empty())
+			for (xml_node node = first_child(); node; node = node.next_sibling())
+				if (pred(node))
+					return node;
+
+		return xml_node();
+	}
+
+	template  inline xml_node xml_node::find_node(Predicate pred) const
+	{
+		if (!empty())
+			for (xml_node node = first_child(); node; node = node.next_sibling())
+			{
+				if (pred(node))
+					return node;
+				
+				if (node.first_child())
+				{
+					xml_node found = node.find_element(pred);
+					if (found) return found;
+				}
+			}
+
+		return xml_node();
+	}
+}
+
+#endif
diff --git a/src/pugixpath.cpp b/src/pugixpath.cpp
new file mode 100644
index 0000000..75b5844
--- /dev/null
+++ b/src/pugixpath.cpp
@@ -0,0 +1,3537 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Pug Improved XML Parser - Version 0.3
+// --------------------------------------------------------
+// Copyright (C) 2006-2007, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+// This work is based on the pugxml parser, which is:
+// Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
+// Released into the Public Domain. Use at your own risk.
+// See pugxml.xml for further information, history, etc.
+// Contributions by Neville Franks (readonly@getsoft.com).
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "pugixml.hpp"
+
+#ifndef PUGIXML_NO_XPATH
+
+#include 
+
+#include 
+
+#include 
+#include 
+#include 
+#include 
+
+#if defined(_MSC_VER)
+#	pragma warning(disable: 4127) // conditional expression is constant
+#	pragma warning(disable: 4702) // unreachable code
+#	pragma warning(disable: 4996) // this function or variable may be unsafe
+#endif
+
+namespace
+{
+	using namespace pugi;
+		
+	enum chartype
+	{
+		ct_space = 1,			// \r, \n, space, tab
+		ct_start_symbol = 2,	// Any symbol > 127, a-z, A-Z, _, :
+		ct_digit = 4,			// 0-9
+		ct_symbol = 8			// Any symbol > 127, a-z, A-Z, 0-9, _, :, -, .
+	};
+	
+	const unsigned char chartype_table[256] =
+	{
+		0,  0,  0,  0,  0,  0,  0,  0,     0,  1,  1,  0,  0,  1,  0,  0,     // 0-15
+		0,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  0,  0,  0,     // 16-31
+		1,  0,  0,  0,  0,  0,  0,  0,     0,  0,  0,  0,  0,  8,  8,  0,     // 32-47
+		12, 12, 12, 12, 12, 12, 12, 12,    12, 12, 10, 0,  0,  0,  0,  0,     // 48-63
+		0,  10, 10, 10, 10, 10, 10, 10,    10, 10, 10, 10, 10, 10, 10, 10,    // 64-79
+		10, 10, 10, 10, 10, 10, 10, 10,    10, 10, 10, 0,  0,  0,  0,  10,    // 80-95
+		0,  10, 10, 10, 10, 10, 10, 10,    10, 10, 10, 10, 10, 10, 10, 10,    // 96-111
+		10, 10, 10, 10, 10, 10, 10, 10,    10, 10, 10, 0,  0,  0,  0,  0,     // 112-127
+
+		10, 10, 10, 10, 10, 10, 10, 10,    10, 10, 10, 10, 10, 10, 10, 10,    // 128+
+		10, 10, 10, 10, 10, 10, 10, 10,    10, 10, 10, 10, 10, 10, 10, 10,
+		10, 10, 10, 10, 10, 10, 10, 10,    10, 10, 10, 10, 10, 10, 10, 10,
+		10, 10, 10, 10, 10, 10, 10, 10,    10, 10, 10, 10, 10, 10, 10, 10,
+		10, 10, 10, 10, 10, 10, 10, 10,    10, 10, 10, 10, 10, 10, 10, 10,
+		10, 10, 10, 10, 10, 10, 10, 10,    10, 10, 10, 10, 10, 10, 10, 10,
+		10, 10, 10, 10, 10, 10, 10, 10,    10, 10, 10, 10, 10, 10, 10, 10,
+		10, 10, 10, 10, 10, 10, 10, 10,    10, 10, 10, 10, 10, 10, 10, 10
+	};
+	
+	bool is_chartype(char c, chartype ct)
+	{
+		return !!(chartype_table[static_cast(c)] & ct);
+	}
+
+	bool starts_with(const std::string& s, const char* pattern)
+	{
+		return s.compare(0, strlen(pattern), pattern) == 0;
+	}
+
+	std::string string_value(const xpath_node& na)
+	{
+		if (na.attribute())
+			return na.attribute().value();
+		else
+		{
+			const xml_node& n = na.node();
+
+			switch (n.type())
+			{
+			case node_pcdata:
+			case node_cdata:
+			case node_comment:
+			case node_pi:
+				return n.value();
+			
+			case node_document:
+			case node_element:
+			{
+				std::string result;
+
+				xml_node c = n.first_child();
+				
+				while (c)
+				{
+					if (c.type() == node_pcdata || c.type() == node_cdata)
+						result += c.value();
+				
+					if (c.first_child())
+						c = c.first_child();
+					else if (c.next_sibling())
+						c = c.next_sibling();
+					else
+					{
+						while (c && c != n) c = c.parent();
+						
+						if (c == n) break;
+						
+						c = c.next_sibling();
+					}
+				}
+				
+				return result;
+			}
+			
+			default:
+				return "";
+			}
+		}
+	}
+	
+	struct document_order_comparator
+	{
+		bool operator()(const xpath_node& lhs, const xpath_node& rhs) const
+		{
+			unsigned int lo = lhs.attribute() ? lhs.attribute().document_order() : lhs.node().document_order();
+			unsigned int ro = rhs.attribute() ? rhs.attribute().document_order() : rhs.node().document_order();
+			
+			if (lo != 0 && ro != 0)
+				return lo < ro;
+
+			xml_node ln = lhs.node(), rn = rhs.node();
+
+			if (lhs.attribute() && rhs.attribute())
+			{
+				if (lhs.parent() == rhs.parent()) return lhs.attribute() < rhs.attribute();
+				
+				ln = lhs.parent();
+				rn = rhs.parent();
+			}
+			else if (lhs.attribute())
+			{
+				if (lhs.parent() == rhs.node()) return false;
+				
+				ln = lhs.parent();
+			}
+			else if (rhs.attribute())
+			{
+				if (rhs.parent() == lhs.node()) return true;
+				
+				rn = rhs.parent();
+			}
+
+			if (ln == rn) return false;
+				
+			xml_node lp = ln, rp = rn;
+				
+			while (lp != rp)
+			{
+				ln = lp;
+				lp = lp.parent();
+					
+				if (lp != rp)
+				{
+					rn = rp;
+					rp = rp.parent();
+				}
+			}
+				
+			if (!lp) // no common parent - ???
+				return false;
+			else // lp is parent, ln & rn are distinct siblings
+			{
+				for (; ln; ln = ln.next_sibling());
+					if (ln == rn)
+						return true;
+			
+				return false;
+			}
+		}
+	};
+
+	struct duplicate_comparator
+	{
+		bool operator()(const xpath_node& lhs, const xpath_node& rhs) const
+		{
+			if (lhs.attribute()) return rhs.attribute() ? lhs.attribute() < rhs.attribute() : true;
+			else return rhs.attribute() ? false : lhs.node() < rhs.node();
+		}
+	};
+	
+	/* From trio
+	 *
+	 * Endian-agnostic indexing macro.
+	 *
+	 * The value of internalEndianMagic, when converted into a 64-bit
+	 * integer, becomes 0x0706050403020100 (we could have used a 64-bit
+	 * integer value instead of a double, but not all platforms supports
+	 * that type). The value is automatically encoded with the correct
+	 * endianess by the compiler, which means that we can support any
+	 * kind of endianess. The individual bytes are then used as an index
+	 * for the IEEE 754 bit-patterns and masks.
+	 */
+	#define DOUBLE_INDEX(x) (((unsigned char *)&internal_endian_magic)[7-(x)])
+
+	static const double internal_endian_magic = 7.949928895127363e-275;
+
+	static const unsigned char ieee_754_exponent_mask[] = { 0x7F, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+	static const unsigned char ieee_754_mantissa_mask[] = { 0x00, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
+
+	static const unsigned char ieee_754_qnan_array[] = { 0x7F, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+	
+	bool is_special(double value, bool& has_mantissa)
+	{
+		bool is_special_quantity = true;
+
+		has_mantissa = false;
+
+		for (unsigned int i = 0; i < sizeof(double); ++i)
+		{
+			unsigned char current = ((unsigned char *)&value)[DOUBLE_INDEX(i)];
+			
+			is_special_quantity = is_special_quantity && (current & ieee_754_exponent_mask[i]) == ieee_754_exponent_mask[i];
+			has_mantissa = has_mantissa || (current & ieee_754_mantissa_mask[i]) != 0;
+		}
+		
+		return is_special_quantity;
+	}
+
+	double gen_nan()
+	{
+#if FLT_RADIX == 2 && DBL_MAX_EXP == 1024 && DBL_MANT_DIG == 53
+		// IEEE 754
+		
+		double result = 0;
+
+		for (unsigned int i = 0; i < sizeof(double); ++i)
+		{
+			((unsigned char *)&result)[DOUBLE_INDEX(i)] = ieee_754_qnan_array[i];
+		}
+		
+		return result;
+#else
+		const volatile double zero = 0.0;
+		return zero / zero;
+#endif
+	}
+	
+	bool is_nan(double value)
+	{
+#if defined(__USE_ISOC99)
+		return isnan(value);
+#elif defined(_MSC_VER) || defined(__BORLANDC__)
+		return !!_isnan(value);
+#elif FLT_RADIX == 2 && DBL_MAX_EXP == 1024 && DBL_MANT_DIG == 53
+		// IEEE 754
+
+		bool has_mantissa;
+		
+		bool is_special_quantity = is_special(value, has_mantissa);
+  
+		return (is_special_quantity && has_mantissa);
+#else
+		return value != value;
+#endif
+	}
+	
+	bool is_inf(double value)
+	{
+#if defined(__USE_ISOC99)
+		return !isfinite(value);
+#elif defined(_MSC_VER) || defined(__BORLANDC__)
+		return !_finite(value);
+#elif FLT_RADIX == 2 && DBL_MAX_EXP == 1024 && DBL_MANT_DIG == 53
+		// IEEE 754
+  
+		bool has_mantissa;
+		
+		bool is_special_quantity = is_special(value, has_mantissa);
+  
+		return (is_special_quantity && !has_mantissa);
+#else
+		return value + 1 == value && value - 1 == value;
+#endif
+	}
+	
+	bool convert_number_to_boolean(double value)
+	{
+		return (value != 0 && !is_nan(value));
+	}
+	
+	const char* convert_number_to_string(double value)
+	{
+		if (is_nan(value)) return "NaN";
+		else if (is_inf(value)) return value < 0 ? "-Infinity" : "Infinity";
+		
+		static char buf[100];
+		
+		if (value == (int)value) sprintf(buf, "%d", (int)value);
+		else
+		{
+			sprintf(buf, "%f", value);
+			
+			// trim trailing zeros after decimal point
+			if (strchr(buf, '.'))
+			{
+				char* ptr = buf + strlen(buf) - 1;
+				for (; *ptr == '0'; --ptr) ;
+				*(ptr+1) = 0;
+			}
+		}
+		
+		return buf;
+	}
+	
+	double convert_string_to_number(const char* string)
+	{
+		while (is_chartype(*string, ct_space)) ++string;
+		
+		double sign = 1;
+		
+		if (*string == '-')
+		{
+			sign = -1;
+			++string;
+		}
+		
+		double r = 0;
+		
+		if (!*string) return gen_nan();
+		
+		while (is_chartype(*string, ct_digit))
+		{
+			r = r * 10 + (*string - '0');
+			++string;
+		}
+		
+		if (*string)
+		{
+			if (is_chartype(*string, ct_space))
+			{
+				while (is_chartype(*string, ct_space)) ++string;
+				if (*string) return gen_nan();
+			}
+			
+			if (*string != '.') return gen_nan();
+			
+			++string;
+			
+			double power = 0.1;
+			
+			while (is_chartype(*string, ct_digit))
+			{
+				r += power * (*string - '0');
+				power /= 10;
+				++string;
+			}
+			
+			while (is_chartype(*string, ct_space)) ++string;
+			if (*string) return gen_nan();
+		}
+		
+		return r * sign;
+	}
+	
+	double ieee754_round(double value)
+	{
+		return value == value ? floor(value + 0.5) : value;
+	}
+	
+	const char* local_name(const char* name)
+	{
+		const char* p = strchr(name, ':');
+		
+		return p ? p + 1 : name;
+	}
+	
+	const char* namespace_uri(const xml_node& node)
+	{
+		const char* pos = strchr(node.name(), ':');
+		
+		std::string ns = "xmlns";
+		
+		if (pos)
+		{
+			ns += ':';
+			ns.append(node.name(), pos);
+		}
+		
+		xml_node p = node.parent();
+		
+		while (p)
+		{
+			xml_attribute a = p.attribute(ns.c_str());
+			
+			if (a) return a.value();
+			
+			p = p.parent();
+		}
+		
+		return "";
+	}
+
+	const char* namespace_uri(const xml_attribute& attr, const xml_node& parent)
+	{
+		const char* pos = strchr(attr.name(), ':');
+		
+		// Default namespace does not apply to attributes
+		if (!pos) return "";
+		
+		std::string ns = "xmlns:";
+		ns.append(attr.name(), pos);
+		
+		xml_node p = parent;
+		
+		while (p)
+		{
+			xml_attribute a = p.attribute(ns.c_str());
+			
+			if (a) return a.value();
+			
+			p = p.parent();
+		}
+		
+		return "";
+	}
+
+	template  struct equal_to
+	{
+		bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs == rhs;
+		}
+	};
+
+	template  struct not_equal_to
+	{
+		bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs != rhs;
+		}
+	};
+
+	template  struct greater
+	{
+		bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs > rhs;
+		}
+	};
+	
+	template  struct less
+	{
+		bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs < rhs;
+		}
+	};
+
+	template  struct greater_equal
+	{
+		bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs >= rhs;
+		}
+	};
+
+	template  struct less_equal
+	{
+		bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs <= rhs;
+		}
+	};
+}
+
+namespace pugi
+{
+	xpath_exception::xpath_exception(const char* message): m_message(message)
+	{
+	}
+	
+	const char* xpath_exception::what() const throw()
+	{
+		return m_message;
+	}
+	
+	const size_t xpath_memory_block_size = 4096;		///< Memory block size, 4 kb
+
+	class xpath_allocator
+	{
+		struct memory_block
+		{	
+			memory_block(): next(0), size(0)
+			{
+			}
+	
+			memory_block* next;
+			size_t size;
+	
+			char data[xpath_memory_block_size];
+		};
+		
+		memory_block* m_root;
+		
+	public:
+		xpath_allocator(): m_root(0)
+		{
+			m_root = new memory_block;
+		}
+		
+		~xpath_allocator()
+		{
+			while (m_root)
+			{
+				memory_block* cur = m_root->next;
+				delete m_root;
+				m_root = cur;
+			}
+		}
+
+		void* alloc(size_t size)
+		{
+			if (m_root->size + size <= xpath_memory_block_size)
+			{
+				void* buf = m_root->data + m_root->size;
+				m_root->size += size;
+				return buf;
+			}
+			else
+			{
+				memory_block* block;
+				
+				if (size > xpath_memory_block_size)
+					block = static_cast(operator new(size + sizeof(memory_block) - xpath_memory_block_size));
+				else
+					block = new memory_block;
+					
+				block->next = m_root;
+				block->size = size;
+				
+				m_root = block;
+				
+				return block->data;
+			}
+		}
+	};
+
+	xpath_node::xpath_node()
+	{
+	}
+		
+	xpath_node::xpath_node(const xml_node& node): m_node(node)
+	{
+	}
+		
+	xpath_node::xpath_node(const xml_attribute& attribute, const xml_node& parent): m_node(parent), m_attribute(attribute)
+	{
+	}
+
+	xml_node xpath_node::node() const
+	{
+		return m_attribute ? xml_node() : m_node;
+	}
+		
+	xml_attribute xpath_node::attribute() const
+	{
+		return m_attribute;
+	}
+	
+	xml_node xpath_node::parent() const
+	{
+		return m_attribute ? m_node : m_node.parent();
+	}
+
+	xpath_node::operator xpath_node::unspecified_bool_type() const
+	{
+		return (m_node || m_attribute) ? &xpath_node::m_node : 0;
+	}
+	
+	bool xpath_node::operator==(const xpath_node& n) const
+	{
+		return m_node == n.m_node && m_attribute == n.m_attribute;
+	}
+	
+	bool xpath_node::operator!=(const xpath_node& n) const
+	{
+		return m_node != n.m_node || m_attribute != n.m_attribute;
+	}
+
+	xpath_node_set::xpath_node_set(): m_type(type_unsorted), m_begin(&m_storage), m_end(&m_storage), m_eos(&m_storage + 1), m_using_storage(true)
+	{
+	}
+
+	xpath_node_set::~xpath_node_set()
+	{
+		if (!m_using_storage) delete[] m_begin;
+	}
+		
+	xpath_node_set::xpath_node_set(const xpath_node_set& ns): m_type(type_unsorted), m_begin(&m_storage), m_end(&m_storage), m_eos(&m_storage + 1), m_using_storage(true)
+	{
+		*this = ns;
+	}
+	
+	xpath_node_set& xpath_node_set::operator=(const xpath_node_set& ns)
+	{
+		if (!m_using_storage) delete[] m_begin;
+		
+		m_begin = m_end = m_eos = 0;
+		
+		if (ns.size() == 1)
+		{
+			m_storage = *ns.m_begin;
+			m_begin = &m_storage;
+			m_end = m_eos = &m_storage + 1;
+			m_using_storage = true;
+		}
+		else
+		{
+			m_using_storage = false;
+			append(ns.begin(), ns.end());
+		}
+		
+		return *this;
+	}	
+
+	xpath_node_set::type_t xpath_node_set::type() const
+	{
+		return m_type;
+	}
+		
+	size_t xpath_node_set::size() const
+	{
+		return m_end - m_begin;
+	}
+		
+	bool xpath_node_set::empty() const
+	{
+		return size() == 0;
+	}
+		
+	xpath_node_set::iterator xpath_node_set::mut_begin()
+	{
+		return m_begin;
+	}
+	
+	xpath_node_set::const_iterator xpath_node_set::begin() const
+	{
+		return m_begin;
+	}
+		
+	xpath_node_set::iterator xpath_node_set::mut_end()
+	{
+		return m_end;
+	}
+	
+	xpath_node_set::const_iterator xpath_node_set::end() const
+	{
+		return m_end;
+	}
+	
+	void xpath_node_set::sort(bool reverse)
+	{
+		std::sort(m_begin, m_end, document_order_comparator());
+		
+		if (reverse)
+			std::reverse(m_begin, m_end);
+			
+		m_type = reverse ? type_sorted_reverse : type_sorted;
+	}
+
+	void xpath_node_set::push_back(const xpath_node& n)
+	{
+		if (m_end == m_eos)
+			append(&n, &n + 1);
+		else
+		{
+			*m_end = n;
+			++m_end;
+		}
+	}
+
+	template  void xpath_node_set::append(Iterator begin, Iterator end)
+	{
+		size_t count = std::distance(begin, end);
+		size_t size = m_end - m_begin;
+		size_t capacity = m_eos - m_begin;
+		
+		if (capacity < size + count)
+		{
+			if (capacity < 2) capacity = 2;
+			
+			while (capacity < size + count) capacity += capacity / 2;
+			
+			xpath_node* storage = new xpath_node[capacity];
+			std::copy(m_begin, m_end, storage);
+			
+			if (!m_using_storage) delete[] m_begin;
+			
+			m_using_storage = false;
+			
+			m_begin = storage;
+			m_end = storage + size;
+			m_eos = storage + capacity;
+		}
+		
+		std::copy(begin, end, m_end);
+		m_end += count;
+	}
+
+	void xpath_node_set::truncate(iterator it)
+	{
+		m_end = it;
+	}
+
+	xpath_node xpath_node_set::first() const
+	{
+		switch (m_type)
+		{
+		case type_sorted: return *m_begin;
+		case type_sorted_reverse: return *(m_end - 1);
+		case type_unsorted: return *std::min_element(begin(), end(), document_order_comparator());
+		default: return xpath_node();
+		}
+	}
+
+	void xpath_node_set::remove_duplicates()
+	{
+		if (m_type == type_unsorted)
+		{
+			std::sort(m_begin, m_end, duplicate_comparator());
+		}
+		
+		truncate(std::unique(m_begin, m_end));
+	}
+
+	struct xpath_context
+	{
+		xml_node root;
+		xpath_node n;
+		size_t position, size;
+	};
+
+	enum lexeme_t
+	{
+		lex_none = 0,
+		lex_equal,
+		lex_not_equal,
+		lex_less,
+		lex_greater,
+		lex_less_or_equal,
+		lex_greater_or_equal,
+		lex_plus,
+		lex_minus,
+		lex_multiply,
+		lex_union,
+		lex_var_ref,
+		lex_open_brace,
+		lex_close_brace,
+		lex_quoted_string,
+		lex_number,
+		lex_slash,
+		lex_double_slash,
+		lex_open_square_brace,
+		lex_close_square_brace,
+		lex_string,
+		lex_comma,
+		lex_axis_attribute,
+		lex_dot,
+		lex_double_dot
+	};
+
+	class xpath_lexer
+	{
+	private:
+		const char* m_cur;
+
+		char* m_cur_lexeme_contents;
+		size_t m_clc_size;
+		size_t m_clc_capacity;
+
+		lexeme_t m_cur_lexeme;
+
+		void contents_clear()
+		{
+			m_clc_size = 0;
+		}
+
+		void contents_push(char c)
+		{
+			if (m_clc_size == m_clc_capacity)
+			{
+				if (!m_clc_capacity) m_clc_capacity = 16;
+				else m_clc_capacity *= 2;
+
+				char* s = new char[m_clc_capacity + 1];
+				if (m_cur_lexeme_contents) strcpy(s, m_cur_lexeme_contents);
+				
+				delete[] m_cur_lexeme_contents;
+				m_cur_lexeme_contents = s;
+			}
+
+			m_cur_lexeme_contents[m_clc_size++] = c;
+			m_cur_lexeme_contents[m_clc_size] = 0;
+		}
+
+	public:
+		explicit xpath_lexer(const char* query): m_cur(query)
+		{
+			m_clc_capacity = m_clc_size = 0;
+			m_cur_lexeme_contents = 0;
+
+			next();
+		}
+		
+		~xpath_lexer()
+		{
+			delete[] m_cur_lexeme_contents;
+		}
+		
+		const char* state() const
+		{
+			return m_cur;
+		}
+		
+		void reset(const char* state)
+		{
+			m_cur = state;
+			next();
+		}
+
+		void next()
+		{
+			contents_clear();
+
+			while (is_chartype(*m_cur, ct_space)) ++m_cur;
+
+			switch (*m_cur)
+			{
+			case 0:
+				m_cur_lexeme = lex_none;
+				break;
+			
+			case '>':
+				if (*(m_cur+1) == '=')
+				{
+					m_cur += 2;
+					m_cur_lexeme = lex_greater_or_equal;
+				}
+				else
+				{
+					m_cur += 1;
+					m_cur_lexeme = lex_greater;
+				}
+				break;
+
+			case '<':
+				if (*(m_cur+1) == '=')
+				{
+					m_cur += 2;
+					m_cur_lexeme = lex_less_or_equal;
+				}
+				else
+				{
+					m_cur += 1;
+					m_cur_lexeme = lex_less;
+				}
+				break;
+
+			case '!':
+				if (*(m_cur+1) == '=')
+				{
+					m_cur += 2;
+					m_cur_lexeme = lex_not_equal;
+				}
+				else
+				{
+					m_cur_lexeme = lex_none;
+				}
+				break;
+
+			case '=':
+				m_cur += 1;
+				m_cur_lexeme = lex_equal;
+
+				break;
+			
+			case '+':
+				m_cur += 1;
+				m_cur_lexeme = lex_plus;
+
+				break;
+
+			case '-':
+				m_cur += 1;
+				m_cur_lexeme = lex_minus;
+
+				break;
+
+			case '*':
+				m_cur += 1;
+				m_cur_lexeme = lex_multiply;
+
+				break;
+
+			case '|':
+				m_cur += 1;
+				m_cur_lexeme = lex_union;
+
+				break;
+
+			case '$':
+				m_cur += 1;
+				m_cur_lexeme = lex_var_ref;
+
+				break;
+			
+			case '(':
+				m_cur += 1;
+				m_cur_lexeme = lex_open_brace;
+
+				break;
+
+			case ')':
+				m_cur += 1;
+				m_cur_lexeme = lex_close_brace;
+
+				break;
+			
+			case '[':
+				m_cur += 1;
+				m_cur_lexeme = lex_open_square_brace;
+
+				break;
+
+			case ']':
+				m_cur += 1;
+				m_cur_lexeme = lex_close_square_brace;
+
+				break;
+
+			case ',':
+				m_cur += 1;
+				m_cur_lexeme = lex_comma;
+
+				break;
+
+			case '/':
+				if (*(m_cur+1) == '/')
+				{
+					m_cur += 2;
+					m_cur_lexeme = lex_double_slash;
+				}
+				else
+				{
+					m_cur += 1;
+					m_cur_lexeme = lex_slash;
+				}
+				break;
+		
+			case '.':
+				if (*(m_cur+1) == '.')
+				{
+					m_cur += 2;
+					m_cur_lexeme = lex_double_dot;
+				}
+				else if (is_chartype(*(m_cur+1), ct_digit))
+				{
+					contents_push('0');
+					contents_push('.');
+
+					++m_cur;
+
+					while (is_chartype(*m_cur, ct_digit))
+						contents_push(*m_cur++);
+					
+					m_cur_lexeme = lex_number;
+				}
+				else
+				{
+					m_cur += 1;
+					m_cur_lexeme = lex_dot;
+				}
+				break;
+
+			case '@':
+				m_cur += 1;
+				m_cur_lexeme = lex_axis_attribute;
+
+				break;
+
+			case '"':
+			case '\'':
+			{
+				char terminator = *m_cur;
+
+				++m_cur;
+
+				while (*m_cur && *m_cur != terminator)
+					contents_push(*m_cur++);
+				
+				if (!*m_cur)
+					m_cur_lexeme = lex_none;
+				else
+				{
+					m_cur += 1;
+					m_cur_lexeme = lex_quoted_string;
+				}
+
+				break;
+			}
+
+			default:
+				if (is_chartype(*m_cur, ct_digit))
+				{
+					while (is_chartype(*m_cur, ct_digit))
+						contents_push(*m_cur++);
+				
+					if (*m_cur == '.' && is_chartype(*(m_cur+1), ct_digit))
+					{
+						contents_push(*m_cur++);
+
+						while (is_chartype(*m_cur, ct_digit))
+							contents_push(*m_cur++);
+					}
+
+					m_cur_lexeme = lex_number;
+				}
+				else if (is_chartype(*m_cur, ct_start_symbol))
+				{
+					while (is_chartype(*m_cur, ct_symbol))
+						contents_push(*m_cur++);
+				
+					while (is_chartype(*m_cur, ct_space)) ++m_cur;
+
+					m_cur_lexeme = lex_string;
+				}
+			}
+		}
+
+		lexeme_t current() const
+		{
+			return m_cur_lexeme;
+		}
+
+		const char* contents() const
+		{
+			return m_cur_lexeme_contents;
+		}
+	};
+
+	enum ast_type_t
+	{
+		ast_none,
+		ast_op_or,						// left or right
+		ast_op_and,						// left and right
+		ast_op_equal,					// left = right
+		ast_op_not_equal, 				// left != right
+		ast_op_less,					// left < right
+		ast_op_greater,					// left > right
+		ast_op_less_or_equal,			// left <= right
+		ast_op_greater_or_equal,		// left >= right
+		ast_op_add,						// left + right
+		ast_op_subtract,				// left - right
+		ast_op_multiply,				// left * right
+		ast_op_divide,					// left / right
+		ast_op_mod,						// left % right
+		ast_op_negate,					// left - right
+		ast_op_union,					// left | right
+		ast_predicate,					// apply predicate to set; next points to next predicate
+		ast_filter,						// select * from left where right
+		ast_filter_posinv,				// select * from left where right; proximity position invariant
+		ast_variable,					// variable value
+		ast_string_constant,			// string constant
+		ast_number_constant,			// number constant
+		ast_func_last,					// last()
+		ast_func_position,				// position()
+		ast_func_count,					// count(left)
+		ast_func_id,					// id(left)
+		ast_func_local_name_0,			// local-name()
+		ast_func_local_name_1,			// local-name(left)
+		ast_func_namespace_uri_0,		// namespace-uri()
+		ast_func_namespace_uri_1,		// namespace-uri(left)
+		ast_func_name_0,				// name()
+		ast_func_name_1,				// name(left)
+		ast_func_string_0,				// string()
+		ast_func_string_1,				// string(left)
+		ast_func_concat,				// concat(left, right, siblings)
+		ast_func_starts_with,			// starts_with(left, right)
+		ast_func_contains,				// contains(left, right)
+		ast_func_substring_before,		// substring-before(left, right)
+		ast_func_substring_after,		// substring-after(left, right)
+		ast_func_substring_2,			// substring(left, right)
+		ast_func_substring_3,			// substring(left, right, third)
+		ast_func_string_length_0,		// string-length()
+		ast_func_string_length_1,		// string-length(left)
+		ast_func_normalize_space_0,		// normalize-space()
+		ast_func_normalize_space_1,		// normalize-space(left)
+		ast_func_translate,				// translate(left, right, third)
+		ast_func_boolean,				// boolean(left)
+		ast_func_not,					// not(left)
+		ast_func_true,					// true()
+		ast_func_false,					// false()
+		ast_func_lang,					// lang(left)
+		ast_func_number_0,				// number()
+		ast_func_number_1,				// number(left)
+		ast_func_sum,					// sum(left)
+		ast_func_floor,					// floor(left)
+		ast_func_ceiling,				// ceiling(left)
+		ast_func_round,					// round(left)
+		ast_step,						// process set left with step
+		ast_step_root					// select root node
+	};
+
+	enum ast_rettype_t
+	{
+		ast_type_none,
+		ast_type_node_set,
+		ast_type_number,
+		ast_type_string,
+		ast_type_boolean
+	};
+
+	enum axis_t
+	{
+		axis_ancestor,
+		axis_ancestor_or_self,
+		axis_attribute,
+		axis_child,
+		axis_descendant,
+		axis_descendant_or_self,
+		axis_following,
+		axis_following_sibling,
+		axis_namespace,
+		axis_parent,
+		axis_preceding,
+		axis_preceding_sibling,
+		axis_self
+	};
+	
+	enum nodetest_t
+	{
+		nodetest_name,
+		nodetest_type_node,
+		nodetest_type_comment,
+		nodetest_type_pi,
+		nodetest_type_text,
+		nodetest_pi,
+		nodetest_all,
+		nodetest_all_in_namespace
+	};
+		
+	class xpath_ast_node
+	{
+	private:
+		ast_type_t m_type;
+		
+		ast_rettype_t m_rettype;
+
+		// tree node structure
+		xpath_ast_node* m_left;
+		xpath_ast_node*	m_right;
+		xpath_ast_node* m_third;
+		xpath_ast_node* m_next;
+
+		// variable name for ast_variable
+		// string value for ast_constant
+		// node test for ast_step (node name/namespace/node type/pi target)
+		const char* m_contents;
+
+		// for t_step / t_predicate
+		axis_t m_axis;
+		nodetest_t m_test;
+		
+		xpath_ast_node(const xpath_ast_node&);
+		xpath_ast_node& operator=(const xpath_ast_node&);
+
+		template  bool compare_eq(xpath_ast_node* lhs, xpath_ast_node* rhs, xpath_context& c)
+		{
+			if (lhs->rettype() != ast_type_node_set && rhs->rettype() != ast_type_node_set)
+			{
+				if (lhs->rettype() == ast_type_boolean || rhs->rettype() == ast_type_boolean)
+					return Cbool()(lhs->eval_boolean(c), rhs->eval_boolean(c));
+				else if (lhs->rettype() == ast_type_number || rhs->rettype() == ast_type_number)
+					return Cdouble()(lhs->eval_number(c), rhs->eval_number(c));
+				else if (lhs->rettype() == ast_type_string || rhs->rettype() == ast_type_string)
+					return Cstring()(lhs->eval_string(c), rhs->eval_string(c));
+				else
+				{
+					assert(!"Wrong types");
+					return false;
+				}
+			}
+			else if (lhs->rettype() == ast_type_node_set && rhs->rettype() == ast_type_node_set)
+			{
+				xpath_node_set ls = lhs->eval_node_set(c);
+				xpath_node_set rs = rhs->eval_node_set(c);
+				
+				for (xpath_node_set::const_iterator li = ls.begin(); li != ls.end(); ++li)
+				for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri)
+				{
+					if (Cstring()(string_value(*li), string_value(*ri)))
+						return true;
+				}
+				
+				return false;
+			}
+			else if (lhs->rettype() != ast_type_node_set && rhs->rettype() == ast_type_node_set)
+			{
+				if (lhs->rettype() == ast_type_boolean)
+					return Cbool()(lhs->eval_boolean(c), rhs->eval_boolean(c));
+				else if (lhs->rettype() == ast_type_number)
+				{
+					double l = lhs->eval_number(c);
+					xpath_node_set rs = rhs->eval_node_set(c);
+					
+					for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri)
+					{
+						if (Cdouble()(l, convert_string_to_number(string_value(*ri).c_str())) == true)
+							return true;
+					}
+					
+					return false;
+				}
+				else if (lhs->rettype() == ast_type_string)
+				{
+					std::string l = lhs->eval_string(c);
+					xpath_node_set rs = rhs->eval_node_set(c);
+
+					for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri)
+					{
+						if (Cstring()(l, string_value(*ri)) == true)
+							return true;
+					}
+					
+					return false;
+				}
+				else
+				{
+					assert(!"Wrong types");
+					return false;
+				}
+			}
+			else if (lhs->rettype() == ast_type_node_set && rhs->rettype() != ast_type_node_set)
+			{
+				if (rhs->rettype() == ast_type_boolean)
+					return Cbool()(lhs->eval_boolean(c), rhs->eval_boolean(c));
+				else if (rhs->rettype() == ast_type_number)
+				{
+					xpath_node_set ls = lhs->eval_node_set(c);
+					double r = rhs->eval_number(c);
+
+					for (xpath_node_set::const_iterator li = ls.begin(); li != ls.end(); ++li)
+					{
+						if (Cdouble()(convert_string_to_number(string_value(*li).c_str()), r) == true)
+							return true;
+					}
+					
+					return false;
+				}
+				else if (rhs->rettype() == ast_type_string)
+				{
+					xpath_node_set ls = lhs->eval_node_set(c);
+					std::string r = rhs->eval_string(c);
+
+					for (xpath_node_set::const_iterator li = ls.begin(); li != ls.end(); ++li)
+					{
+						if (Cstring()(string_value(*li), r) == true)
+							return true;
+					}
+					
+					return false;
+				}
+				else
+				{
+					assert(!"Wrong types");
+					return false;
+				}
+			}
+			else
+			{
+				assert(!"Wrong types");
+				return false;
+			}
+		}
+
+		template  bool compare_rel(xpath_ast_node* lhs, xpath_ast_node* rhs, xpath_context& c)
+		{
+			if (lhs->rettype() != ast_type_node_set && rhs->rettype() != ast_type_node_set)
+				return Cdouble()(lhs->eval_number(c), rhs->eval_number(c));
+			else if (lhs->rettype() == ast_type_node_set && rhs->rettype() == ast_type_node_set)
+			{
+				xpath_node_set ls = lhs->eval_node_set(c);
+				xpath_node_set rs = rhs->eval_node_set(c);
+				
+				for (xpath_node_set::const_iterator li = ls.begin(); li != ls.end(); ++li)
+				{
+					double l = convert_string_to_number(string_value(*li).c_str());
+					
+					for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri)
+					{
+						if (Cdouble()(l, convert_string_to_number(string_value(*ri).c_str())) == true)
+							return true;
+					}
+				}
+				
+				return false;
+			}
+			else if (lhs->rettype() != ast_type_node_set && rhs->rettype() == ast_type_node_set)
+			{
+				double l = lhs->eval_number(c);
+				xpath_node_set rs = rhs->eval_node_set(c);
+					
+				for (xpath_node_set::const_iterator ri = rs.begin(); ri != rs.end(); ++ri)
+				{
+					if (Cdouble()(l, convert_string_to_number(string_value(*ri).c_str())) == true)
+						return true;
+				}
+				
+				return false;
+			}
+			else if (lhs->rettype() == ast_type_node_set && rhs->rettype() != ast_type_node_set)
+			{
+				xpath_node_set ls = lhs->eval_node_set(c);
+				double r = rhs->eval_number(c);
+
+				for (xpath_node_set::const_iterator li = ls.begin(); li != ls.end(); ++li)
+				{
+					if (Cdouble()(convert_string_to_number(string_value(*li).c_str()), r) == true)
+						return true;
+				}
+				
+				return false;
+			}
+			else
+			{
+				assert(!"Wrong types");
+				return false;
+			}
+		}
+		
+		void apply_predicate(xpath_node_set& ns, size_t first, xpath_ast_node* expr, const xpath_context& context)
+		{
+			xpath_context c;
+			c.root = context.root;
+			
+			size_t i = 0;
+			size_t size = ns.size() - first;
+				
+			xpath_node_set::iterator last = ns.mut_begin() + first;
+				
+			// remove_if... or well, sort of
+			for (xpath_node_set::iterator it = last; it != ns.end(); ++it, ++i)
+			{
+				c.n = *it;
+				c.position = i + 1;
+				c.size = size;
+				
+				if (expr->rettype() == ast_type_number)
+				{
+					if (expr->eval_number(c) == i + 1)
+						*last++ = *it;
+				}
+				else if (expr->eval_boolean(c))
+					*last++ = *it;
+			}
+			
+			ns.truncate(last);
+		}
+
+		void apply_predicates(xpath_node_set& ns, size_t first, const xpath_context& context)
+		{
+			if (ns.size() <= first) return;
+			
+			for (xpath_ast_node* pred = m_right; pred; pred = pred->m_next)
+			{
+				apply_predicate(ns, first, pred->m_left, context);
+			}
+		}
+
+		void step_push(xpath_node_set& ns, const xml_attribute& a, const xml_node& parent)
+		{
+			// There are no attribute nodes corresponding to attributes that declare namespaces
+			// That is, "xmlns:..." or "xmlns"
+			if (!strncmp(a.name(), "xmlns", 5) && (a.name()[5] == 0 || a.name()[5] == ':')) return;
+			
+			switch (m_test)
+			{
+			case nodetest_name:
+				if (!strcmp(a.name(), m_contents)) ns.push_back(xpath_node(a, parent));
+				break;
+				
+			case nodetest_type_node:
+			case nodetest_all:
+				ns.push_back(xpath_node(a, parent));
+				break;
+				
+			case nodetest_all_in_namespace:
+				if (!strncmp(a.name(), m_contents, strlen(m_contents)) && a.name()[strlen(m_contents)] == ':')
+					ns.push_back(xpath_node(a, parent));
+				break;
+			
+			default:
+				;
+			}
+		}
+		
+		void step_push(xpath_node_set& ns, const xml_node& n)
+		{
+			switch (m_test)
+			{
+			case nodetest_name:
+				if (n.type() == node_element && !strcmp(n.name(), m_contents)) ns.push_back(n);
+				break;
+				
+			case nodetest_type_node:
+				ns.push_back(n);
+				break;
+				
+			case nodetest_type_comment:
+				if (n.type() == node_comment)
+					ns.push_back(n);
+				break;
+				
+			case nodetest_type_text:
+				if (n.type() == node_pcdata || n.type() == node_cdata)
+					ns.push_back(n);
+				break;
+				
+			case nodetest_type_pi:
+				if (n.type() == node_pi)
+					ns.push_back(n);
+				break;
+									
+			case nodetest_pi:
+				if (n.type() == node_pi && !strcmp(n.name(), m_contents))
+					ns.push_back(n);
+				break;
+				
+			case nodetest_all:
+				if (n.type() == node_element)
+					ns.push_back(n);
+				break;
+				
+			case nodetest_all_in_namespace:
+				if (n.type() == node_element && !strncmp(n.name(), m_contents, strlen(m_contents)) &&
+					n.name()[strlen(m_contents)] == ':')
+					ns.push_back(n);
+				break;
+			} 
+		}
+
+		template  void step_fill(xpath_node_set& ns, const xml_node& n)
+		{
+			switch (axis)
+			{
+			case axis_attribute:
+				ns.m_type = ns.empty() ? xpath_node_set::type_sorted : xpath_node_set::type_unsorted;
+				
+				for (xml_attribute a = n.first_attribute(); a; a = a.next_attribute())
+					step_push(ns, a, n);
+				
+				break;
+			
+			case axis_child:
+				ns.m_type = ns.empty() ? xpath_node_set::type_sorted : xpath_node_set::type_unsorted;
+
+				for (xml_node c = n.first_child(); c; c = c.next_sibling())
+					step_push(ns, c);
+					
+				break;
+			
+			case axis_descendant:
+			case axis_descendant_or_self:
+			{
+				ns.m_type = ns.empty() ? xpath_node_set::type_sorted : xpath_node_set::type_unsorted;
+				
+				if (axis == axis_descendant_or_self)
+					step_push(ns, n);
+					
+				xml_node cur = n.first_child();
+				
+				if (cur)
+				{
+					do 
+					{
+						step_push(ns, cur);
+						
+						if (cur.first_child())
+							cur = cur.first_child();
+						else if (cur.next_sibling())
+							cur = cur.next_sibling();
+						else
+						{
+							// Borland C++ workaround
+							while (!cur.next_sibling() && cur != n && (bool)cur.parent())
+								cur = cur.parent();
+						
+							if (cur != n)
+								cur = cur.next_sibling();
+						}
+					}
+					while (cur && cur != n);
+				}
+				
+				break;
+			}
+			
+			case axis_following_sibling:
+				ns.m_type = ns.empty() ? xpath_node_set::type_sorted : xpath_node_set::type_unsorted;
+
+				for (xml_node c = n.next_sibling(); c; c = c.next_sibling())
+					step_push(ns, c);
+				
+				break;
+			
+			case axis_preceding_sibling:
+				ns.m_type = ns.empty() ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_unsorted;
+
+				for (xml_node c = n.previous_sibling(); c; c = c.previous_sibling())
+					step_push(ns, c);
+				
+				break;
+			
+			case axis_following:
+			{
+				ns.m_type = ns.empty() ? xpath_node_set::type_sorted : xpath_node_set::type_unsorted;
+				
+				xml_node cur = n;
+				
+				for (;;)
+				{
+					if (cur.first_child())
+						cur = cur.first_child();
+					else if (cur.next_sibling())
+						cur = cur.next_sibling();
+					else
+					{
+						while (cur && !cur.next_sibling()) cur = cur.parent();
+						cur = cur.next_sibling();
+						
+						if (!cur) break;
+					}
+					
+					step_push(ns, cur);
+				}
+
+				break;
+			}
+
+			case axis_preceding:
+			{
+				ns.m_type = ns.empty() ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_unsorted;
+
+				xml_node cur = n;
+				
+				while (cur && !cur.previous_sibling()) cur = cur.parent();
+				cur = cur.previous_sibling();
+				
+				if (cur)
+				{
+					for (;;)
+					{
+						if (cur.last_child())
+							cur = cur.last_child();
+						else
+						{
+							// leaf node
+							step_push(ns, cur);
+							
+							if (cur.previous_sibling())
+								cur = cur.previous_sibling();
+							else
+							{
+								do 
+								{
+									cur = cur.parent();
+									if (!cur) break;
+								
+									step_push(ns, cur);
+								}
+								while (!cur.previous_sibling());
+													
+								cur = cur.previous_sibling();
+								
+								if (!cur) break;
+							}
+						}
+					}
+				}
+				
+				break;
+			}
+			
+			case axis_ancestor:
+			case axis_ancestor_or_self:
+			{
+				ns.m_type = ns.empty() ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_unsorted;
+
+				if (axis == axis_ancestor_or_self)
+					step_push(ns, n);
+
+				xml_node cur = n.parent();
+				
+				while (cur)
+				{
+					step_push(ns, cur);
+					
+					cur = cur.parent();
+				}
+				
+				break;
+			}
+				
+			default:
+				assert(!"Unimplemented axis");
+			}
+		}
+		
+		template  void step_fill(xpath_node_set& ns, const xml_attribute& a, const xml_node& p)
+		{
+			switch (axis)
+			{
+			case axis_ancestor:
+			case axis_ancestor_or_self:
+			{
+				ns.m_type = ns.empty() ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_unsorted;
+
+				if (axis == axis_ancestor_or_self)
+					step_push(ns, a, p);
+
+				xml_node cur = p;
+				
+				while (cur)
+				{
+					step_push(ns, cur);
+					
+					cur = cur.parent();
+				}
+				
+				break;
+			}
+			
+			default:
+				assert(!"Unimplemented axis");
+			}
+		}
+		
+		template  void step_do(xpath_node_set& ns, xpath_context& c)
+		{
+			switch (axis)
+			{
+			case axis_parent:
+				if (m_left)
+				{
+					xpath_node_set s = m_left->eval_node_set(c);
+					
+					for (xpath_node_set::const_iterator it = s.begin(); it != s.end(); ++it)
+					{
+						xml_node p = it->parent();
+						if (p)
+						{
+							size_t s = ns.size();
+							
+							step_push(ns, p);
+							
+							apply_predicates(ns, s, c);
+						}
+					}
+				}
+				else
+				{
+					xml_node p = c.n.parent();
+					if (p)
+					{
+						step_push(ns, p);
+						
+						apply_predicates(ns, 0, c);
+					}
+				}
+
+				break;
+				
+			case axis_self:
+				if (m_left)
+				{
+					xpath_node_set s = m_left->eval_node_set(c);
+					
+					for (xpath_node_set::const_iterator it = s.begin(); it != s.end(); ++it)
+					{
+						size_t s = ns.size();
+						
+						if (it->attribute()) step_push(ns, it->attribute(), it->parent());
+						else step_push(ns, it->node());
+						
+						apply_predicates(ns, s, c);
+					}
+				}
+				else
+				{
+					if (c.n.node()) step_push(ns, c.n.node());
+					else step_push(ns, c.n.attribute(), c.n.parent());
+					
+					apply_predicates(ns, 0, c);
+				}
+
+				break;
+				
+			case axis_namespace:
+				break;
+				
+			case axis_ancestor:
+			case axis_ancestor_or_self:
+				if (m_left)
+				{
+					xpath_node_set s = m_left->eval_node_set(c);
+							
+					for (xpath_node_set::const_iterator it = s.begin(); it != s.end(); ++it)
+					{
+						size_t s = ns.size();
+						
+						if (it->node())
+							step_fill(ns, it->node());
+						else
+							step_fill(ns, it->attribute(), it->parent());
+							
+						apply_predicates(ns, s, c);
+					}
+				}
+				else
+				{
+					if (c.n.node()) step_fill(ns, c.n.node());
+					else step_fill(ns, c.n.attribute(), c.n.parent());
+					
+					apply_predicates(ns, 0, c);
+				}
+				
+				break;
+		
+			case axis_following:
+			case axis_following_sibling:
+			case axis_preceding:
+			case axis_preceding_sibling:
+			case axis_attribute:
+			case axis_child:
+			case axis_descendant:
+			case axis_descendant_or_self:
+				if (m_left)
+				{
+					xpath_node_set s = m_left->eval_node_set(c);
+					
+					for (xpath_node_set::const_iterator it = s.begin(); it != s.end(); ++it)
+					{
+						size_t s = ns.size();
+						
+						if (it->node())
+							step_fill(ns, it->node());
+						
+						apply_predicates(ns, s, c);
+					}
+				}
+				else if (c.n.node())
+				{
+					step_fill(ns, c.n.node());
+					
+					apply_predicates(ns, 0, c);
+				}
+				
+				break;
+			
+			default:
+				assert(!"Unimplemented axis");
+			}
+		}
+		
+		void set_contents(const char* value, xpath_allocator& a)
+		{
+			if (value)
+			{
+				char* c = static_cast(a.alloc(strlen(value) + 1));
+				strcpy(c, value);
+				m_contents = c;
+			}
+			else m_contents = 0;
+		}
+	public:
+		xpath_ast_node(ast_type_t type, const char* contents, xpath_allocator& a): m_type(type), m_rettype(ast_type_none), m_contents(0)
+		{
+			set_contents(contents, a);
+		}
+		
+		xpath_ast_node(ast_type_t type, xpath_ast_node* left, xpath_ast_node* right, axis_t axis): m_type(type),
+			m_rettype(ast_type_none), m_left(left), m_right(right), m_third(0), m_next(0), m_contents(0),
+			m_axis(axis)
+		{
+		}
+
+		xpath_ast_node(ast_type_t type, xpath_ast_node* left = 0, xpath_ast_node* right = 0, xpath_ast_node* third = 0): m_type(type),
+			m_rettype(ast_type_none), m_left(left), m_right(right), m_third(third), m_next(0), m_contents(0)
+		{
+		}
+
+		xpath_ast_node(ast_type_t type, xpath_ast_node* left, axis_t axis, nodetest_t test, const char* contents, xpath_allocator& a):
+			m_type(type), m_rettype(ast_type_none), m_left(left), m_right(0), m_third(0), m_next(0),
+			m_contents(0), m_axis(axis), m_test(test)
+		{
+			set_contents(contents, a);
+		}
+
+		void set_next(xpath_ast_node* value)
+		{
+			m_next = value;
+		}
+
+		void set_right(xpath_ast_node* value)
+		{
+			m_right = value;
+		}
+
+		bool eval_boolean(xpath_context& c)
+		{
+			switch (m_type)
+			{
+			case ast_op_or:
+				if (m_left->eval_boolean(c)) return true;
+				else return m_right->eval_boolean(c);
+				
+			case ast_op_and:
+				if (!m_left->eval_boolean(c)) return false;
+				else return m_right->eval_boolean(c);
+				
+			case ast_op_equal:
+				return compare_eq, equal_to, equal_to >(m_left, m_right, c);
+
+			case ast_op_not_equal:
+				return compare_eq, not_equal_to, not_equal_to >(m_left, m_right, c);
+	
+			case ast_op_less:
+				return compare_rel >(m_left, m_right, c);
+			
+			case ast_op_greater:
+				return compare_rel >(m_left, m_right, c);
+
+			case ast_op_less_or_equal:
+				return compare_rel >(m_left, m_right, c);
+			
+			case ast_op_greater_or_equal:
+				return compare_rel >(m_left, m_right, c);
+
+			case ast_func_starts_with:
+				return starts_with(m_left->eval_string(c), m_right->eval_string(c).c_str());
+
+			case ast_func_contains:
+				return m_left->eval_string(c).find(m_right->eval_string(c)) != std::string::npos;
+
+			case ast_func_boolean:
+				return m_left->eval_boolean(c);
+				
+			case ast_func_not:
+				return !m_left->eval_boolean(c);
+				
+			case ast_func_true:
+				return true;
+				
+			case ast_func_false:
+				return false;
+
+			case ast_func_lang:
+			{
+				if (c.n.attribute()) return false;
+				
+				std::string lang = m_left->eval_string(c);
+				
+				xml_node n = c.n.node();
+				
+				while (n.type() != node_document)
+				{
+					xml_attribute a = n.attribute("xml:lang");
+					
+					if (a)
+					{
+						const char* value = a.value();
+						
+						// strnicmp / strncasecmp is not portable
+						for (std::string::iterator it = lang.begin(); it != lang.end(); ++it)
+						{
+							if (tolower(*it) != tolower(*value)) return false;
+							++value;
+						}
+						
+						return *value == 0 || *value == '-';
+					}
+				}
+				
+				return false;
+			}
+
+			default:
+			{
+				switch (m_rettype)
+				{
+				case ast_type_number:
+					return convert_number_to_boolean(eval_number(c));
+					
+				case ast_type_string:
+					return !eval_string(c).empty();
+					
+				case ast_type_node_set:				
+					return !eval_node_set(c).empty();
+					
+				default:
+					assert(!"Wrong expression for ret type boolean");
+					return false;
+				}
+			}
+			}
+		}
+
+		double eval_number(xpath_context& c)
+		{
+			switch (m_type)
+			{
+			case ast_op_add:
+				return m_left->eval_number(c) + m_right->eval_number(c);
+				
+			case ast_op_subtract:
+				return m_left->eval_number(c) - m_right->eval_number(c);
+
+			case ast_op_multiply:
+				return m_left->eval_number(c) * m_right->eval_number(c);
+
+			case ast_op_divide:
+				return m_left->eval_number(c) / m_right->eval_number(c);
+
+			case ast_op_mod:
+				return fmod(m_left->eval_number(c), m_right->eval_number(c));
+
+			case ast_op_negate:
+				return -m_left->eval_number(c);
+
+			case ast_number_constant:
+				return convert_string_to_number(m_contents);
+
+			case ast_func_last:
+				return (double)c.size;
+			
+			case ast_func_position:
+				return (double)c.position;
+
+			case ast_func_count:
+				return (double)m_left->eval_node_set(c).size();
+			
+			case ast_func_string_length_0:
+				return (double)string_value(c.n).size();
+			
+			case ast_func_string_length_1:
+				return (double)m_left->eval_string(c).size();
+			
+			case ast_func_number_0:
+				return convert_string_to_number(string_value(c.n).c_str());
+			
+			case ast_func_number_1:
+				return m_left->eval_number(c);
+
+			case ast_func_sum:
+			{
+				double r = 0;
+				
+				xpath_node_set ns = m_left->eval_node_set(c);
+				
+				for (xpath_node_set::const_iterator it = ns.begin(); it != ns.end(); ++it)
+					r += convert_string_to_number(string_value(*it).c_str());
+			
+				return r;
+			}
+
+			case ast_func_floor:
+			{
+				double r = m_left->eval_number(c);
+				
+				return r == r ? floor(r) : r;
+			}
+
+			case ast_func_ceiling:
+			{
+				double r = m_left->eval_number(c);
+				
+				return r == r ? ceil(r) : r;
+			}
+
+			case ast_func_round:
+				// correct except for negative zero (it returns positive zero instead of negative)
+				return ieee754_round(m_left->eval_number(c));
+			
+			default:
+			{
+				switch (m_rettype)
+				{
+				case ast_type_boolean:
+					return eval_boolean(c) ? 1 : 0;
+					
+				case ast_type_string:
+					return convert_string_to_number(eval_string(c).c_str());
+					
+				case ast_type_node_set:
+					return convert_string_to_number(eval_string(c).c_str());
+					
+				default:
+					assert(!"Wrong expression for ret type number");
+					return 0;
+				}
+				
+			}
+			}
+		}
+		
+		std::string eval_string(xpath_context& c)
+		{
+			switch (m_type)
+			{
+			case ast_string_constant:
+				return m_contents;
+			
+			case ast_func_local_name_0:
+			{
+				xpath_node na = c.n;
+				
+				if (na.attribute()) return local_name(na.attribute().name());
+				else return local_name(na.node().name());
+			}
+
+			case ast_func_local_name_1:
+			{
+				xpath_node_set ns = m_left->eval_node_set(c);
+				if (ns.empty()) return "";
+				
+				xpath_node na = ns.first();
+				
+				if (na.attribute()) return local_name(na.attribute().name());
+				else return local_name(na.node().name());
+			}
+
+			case ast_func_name_0:
+			{
+				xpath_node na = c.n;
+				
+				if (na.attribute()) return na.attribute().name();
+				else return na.node().name();
+			}
+
+			case ast_func_name_1:
+			{
+				xpath_node_set ns = m_left->eval_node_set(c);
+				if (ns.empty()) return "";
+				
+				xpath_node na = ns.first();
+				
+				if (na.attribute()) return na.attribute().name();
+				else return na.node().name();
+			}
+
+			case ast_func_namespace_uri_0:
+			{
+				xpath_node na = c.n;
+				
+				if (na.attribute()) return namespace_uri(na.attribute(), na.parent());
+				else return namespace_uri(na.node());
+			}
+
+			case ast_func_namespace_uri_1:
+			{
+				xpath_node_set ns = m_left->eval_node_set(c);
+				if (ns.empty()) return "";
+				
+				xpath_node na = ns.first();
+				
+				if (na.attribute()) return namespace_uri(na.attribute(), na.parent());
+				else return namespace_uri(na.node());
+			}
+
+			case ast_func_string_0:
+				return string_value(c.n);
+
+			case ast_func_string_1:
+				return m_left->eval_string(c);
+
+			case ast_func_concat:
+			{
+				std::string r = m_left->eval_string(c);
+				
+				for (xpath_ast_node* n = m_right; n; n = n->m_next)
+					r += n->eval_string(c);
+			
+				return r;
+			}
+
+			case ast_func_substring_before:
+			{
+				std::string s = m_left->eval_string(c);
+				std::string::size_type pos = s.find(m_right->eval_string(c));
+				
+				if (pos == std::string::npos) return "";
+				else return std::string(s.begin(), s.begin() + pos);
+			}
+			
+			case ast_func_substring_after:
+			{
+				std::string s = m_left->eval_string(c);
+				std::string p = m_right->eval_string(c);
+				
+				std::string::size_type pos = s.find(p);
+				
+				if (pos == std::string::npos) return "";
+				else return std::string(s.begin() + pos + p.length(), s.end());
+			}
+
+			case ast_func_substring_2:
+			{
+				std::string s = m_left->eval_string(c);
+				double first = ieee754_round(m_right->eval_number(c));
+				
+				if (first != first) return ""; // NaN
+				else if (first >= s.length() + 1) return "";
+				
+				size_t pos = first < 1 ? 1 : (size_t)first;
+				
+				return s.substr(pos - 1);
+			}
+			
+			case ast_func_substring_3:
+			{
+				std::string s = m_left->eval_string(c);
+				double first = ieee754_round(m_right->eval_number(c));
+				double last = first + ieee754_round(m_third->eval_number(c));
+				
+				if (first != first || last != last) return "";
+				else if (first >= s.length() + 1) return "";
+				else if (first >= last) return "";
+				
+				size_t pos = first < 1 ? 1 : (size_t)first;
+				size_t end = last >= s.length() + 1 ? s.length() + 1 : (size_t)last;
+				
+				return s.substr(pos - 1, std::min(end - pos, s.length() - pos + 1));
+			}
+
+			case ast_func_normalize_space_0:
+			case ast_func_normalize_space_1:
+			{
+				std::string s = m_type == ast_func_normalize_space_0 ? string_value(c.n) : m_left->eval_string(c);
+				
+				std::string r;
+				r.reserve(s.size());
+				
+				for (std::string::const_iterator it = s.begin(); it != s.end(); ++it)
+				{
+					if (is_chartype(*it, ct_space))
+					{
+						if (!r.empty() && r[r.size() - 1] != ' ')
+							r += ' ';
+					}
+					else r += *it;
+				}
+				
+				std::string::size_type pos = r.find_last_not_of(' ');
+				if (pos == std::string::npos) r = "";
+				else r.erase(r.begin() + pos + 1, r.end());
+			
+				return r;
+			}
+
+			case ast_func_translate:
+			{
+				std::string s = m_left->eval_string(c);
+				std::string from = m_right->eval_string(c);
+				std::string to = m_third->eval_string(c);
+				
+				for (std::string::iterator it = s.begin(); it != s.end(); )
+				{
+					std::string::size_type pos = from.find(*it);
+					
+					if (pos != std::string::npos && pos >= to.length())
+						it = s.erase(it);
+					else if (pos != std::string::npos)
+						*it = to[pos];
+				}
+				
+				return s;
+			}
+
+			default:
+			{
+				switch (m_rettype)
+				{
+				case ast_type_boolean:
+					return eval_boolean(c) ? "true" : "false";
+					
+				case ast_type_number:
+					return convert_number_to_string(eval_number(c));
+					
+				case ast_type_node_set:
+				{
+					xpath_node_set ns = eval_node_set(c);
+					return ns.empty() ? std::string("") : string_value(ns.first());
+				}
+				
+				default:
+					assert(!"Wrong expression for ret type string");
+					return "";
+				}
+			}
+			}
+		}
+
+		xpath_node_set eval_node_set(xpath_context& c)
+		{
+			switch (m_type)
+			{
+			case ast_op_union:
+			{
+				xpath_node_set ls = m_left->eval_node_set(c);
+				xpath_node_set rs = m_right->eval_node_set(c);
+				
+				ls.append(rs.begin(), rs.end());
+				
+				ls.remove_duplicates();
+				
+				return ls;
+			}
+
+			case ast_filter:
+			{
+				xpath_node_set set = m_left->eval_node_set(c);
+				set.sort();
+				
+				xpath_context oc = c;
+			
+				size_t i = 0;
+				
+				xpath_node_set::iterator last = set.mut_begin();
+				
+				// remove_if... or well, sort of
+				for (xpath_node_set::const_iterator it = set.begin(); it != set.end(); ++it, ++i)
+				{
+					c.n = *it;
+					c.position = i + 1;
+					c.size = set.size();
+				
+					if (m_right->rettype() == ast_type_number)
+					{
+						if (m_right->eval_number(c) == i + 1)
+							*last++ = *it;
+					}
+					else if (m_right->eval_boolean(c))
+						*last++ = *it;
+				}
+			
+				c = oc;
+				
+				set.truncate(last);
+			
+				return set;
+			}
+			
+			case ast_filter_posinv:
+			{
+				xpath_node_set set = m_left->eval_node_set(c);
+				
+				xpath_context oc = c;
+			
+				size_t i = 0;
+				
+				xpath_node_set::iterator last = set.mut_begin();
+				
+				// remove_if... or well, sort of
+				for (xpath_node_set::const_iterator it = set.begin(); it != set.end(); ++it, ++i)
+				{
+					c.n = *it;
+					c.position = i + 1;
+					c.size = set.size();
+				
+					if (m_right->eval_boolean(c))
+						*last++ = *it;
+				}
+			
+				c = oc;
+				
+				set.truncate(last);
+			
+				return set;
+			}
+
+			case ast_func_id:
+				return xpath_node_set();
+			
+			case ast_step:
+			{
+				xpath_node_set ns;
+				
+				switch (m_axis)
+				{
+				case axis_ancestor:
+					step_do(ns, c);
+					break;
+					
+				case axis_ancestor_or_self:
+					step_do(ns, c);
+					break;
+
+				case axis_attribute:
+					step_do(ns, c);
+					break;
+
+				case axis_child:
+					step_do(ns, c);
+					break;
+				
+				case axis_descendant:
+					step_do(ns, c);
+					break;
+
+				case axis_descendant_or_self:
+					step_do(ns, c);
+					break;
+
+				case axis_following:
+					step_do(ns, c);
+					break;
+				
+				case axis_following_sibling:
+					step_do(ns, c);
+					break;
+				
+				case axis_namespace:
+					step_do(ns, c);
+					break;
+				
+				case axis_parent:
+					step_do(ns, c);
+					break;
+				
+				case axis_preceding:
+					step_do(ns, c);
+					break;
+
+				case axis_preceding_sibling:
+					step_do(ns, c);
+					break;
+				
+				case axis_self:
+					step_do(ns, c);
+					break;
+
+				default:
+					assert(!"Axis not implemented");
+					return xpath_node_set();
+				}
+				
+				ns.remove_duplicates();
+				
+				return ns;
+			}
+
+			case ast_step_root:
+			{
+				xpath_node_set ns;
+			
+				ns.push_back(c.root);
+				
+				apply_predicates(ns, 0, c);
+			
+				return ns;
+			}
+
+			default:
+				assert(!"Wrong expression for ret type node set");
+				return xpath_node_set();
+			}
+		}
+		
+		bool contains(ast_type_t type)
+		{
+			if (m_type == type) return true;
+			
+			switch (m_type)
+			{
+			case ast_op_or:
+			case ast_op_and:
+			case ast_op_equal:
+			case ast_op_not_equal:
+			case ast_op_less:
+			case ast_op_greater:
+			case ast_op_less_or_equal:
+			case ast_op_greater_or_equal:
+			case ast_op_add:
+			case ast_op_subtract:
+			case ast_op_multiply:
+			case ast_op_divide:
+			case ast_op_mod:
+			case ast_op_negate:
+				return m_left->contains(type) || m_right->contains(type);
+			
+			case ast_op_union:
+			case ast_predicate:
+			case ast_filter:
+			case ast_filter_posinv:
+				return false;
+			
+			case ast_variable:
+				throw xpath_exception("Semantics error: variables are not supported");
+				
+			case ast_string_constant:
+			case ast_number_constant:
+			case ast_func_last:
+			case ast_func_position:
+				return false;
+		
+			case ast_func_count:
+			case ast_func_id:
+			case ast_func_local_name_0:
+			case ast_func_local_name_1:
+			case ast_func_namespace_uri_0:
+			case ast_func_namespace_uri_1:
+			case ast_func_name_0:
+			case ast_func_name_1:
+			case ast_func_string_0:
+			case ast_func_string_1:
+				if (m_left) return m_left->contains(type);
+				return false;
+				
+			case ast_func_concat:
+				if (m_left->contains(type)) return true;
+				
+				for (xpath_ast_node* n = m_right; n; n = n->m_next)
+					if (n->contains(type)) return true;
+					
+				return false;
+		
+			case ast_func_starts_with:
+			case ast_func_contains:
+			case ast_func_substring_before:
+			case ast_func_substring_after:
+			case ast_func_substring_2:
+			case ast_func_substring_3:
+			case ast_func_string_length_0:
+			case ast_func_string_length_1:
+			case ast_func_normalize_space_0:
+			case ast_func_normalize_space_1:
+			case ast_func_translate:
+			case ast_func_boolean:
+			case ast_func_not:
+			case ast_func_true:
+			case ast_func_false:
+			case ast_func_lang:
+			case ast_func_number_0:
+			case ast_func_number_1:
+			case ast_func_sum:
+			case ast_func_floor:
+			case ast_func_ceiling:
+			case ast_func_round:
+				if (m_left && m_left->contains(type)) return true;
+				if (m_right && m_right->contains(type)) return true;
+				if (m_third && m_third->contains(type)) return true;
+
+				return false;
+		
+			case ast_step:
+			case ast_step_root:
+				return false;
+			
+			default:
+				throw xpath_exception("Unknown semantics error");
+			}
+		}
+
+		void check_semantics()
+		{
+			switch (m_type)
+			{
+			case ast_op_or:
+			case ast_op_and:
+			case ast_op_equal:
+			case ast_op_not_equal:
+			case ast_op_less:
+			case ast_op_greater:
+			case ast_op_less_or_equal:
+			case ast_op_greater_or_equal:
+				m_left->check_semantics();
+				m_right->check_semantics();
+				m_rettype = ast_type_boolean;
+				break;
+				
+			case ast_op_add:
+			case ast_op_subtract:
+			case ast_op_multiply:
+			case ast_op_divide:
+			case ast_op_mod:
+				m_left->check_semantics();
+				m_right->check_semantics();
+				m_rettype = ast_type_number;
+				break;
+				
+			case ast_op_negate:
+				m_left->check_semantics();
+				m_rettype = ast_type_number;
+				break;
+			
+			case ast_op_union:
+				m_left->check_semantics();
+				m_right->check_semantics();
+				if (m_left->rettype() != ast_type_node_set || m_right->rettype() != ast_type_node_set)
+					throw xpath_exception("Semantics error: union operator has to be applied to node sets");
+				m_rettype = ast_type_node_set;
+				break;
+			
+			case ast_filter:
+			case ast_filter_posinv:
+				m_left->check_semantics();
+				m_right->check_semantics();
+				if (m_left->rettype() != ast_type_node_set)
+					throw xpath_exception("Semantics error: predicate has to be applied to node set");
+				m_rettype = ast_type_node_set;
+				
+				if (!m_right->contains(ast_func_position) && m_right->rettype() != ast_type_number)
+					m_type = ast_filter_posinv;
+				break;
+			
+			case ast_predicate:
+				m_left->check_semantics();
+				m_rettype = ast_type_node_set;
+				break;
+
+			case ast_variable:
+				throw xpath_exception("Semantics error: variable are not supported");
+				
+			case ast_string_constant:
+				m_rettype = ast_type_string;
+				break;
+				
+			case ast_number_constant:
+				m_rettype = ast_type_number;
+				break;
+				
+			case ast_func_last:
+			case ast_func_position:
+				m_rettype = ast_type_number;
+				break;
+		
+			case ast_func_count:
+				m_left->check_semantics();
+				if (m_left->rettype() != ast_type_node_set)
+					throw xpath_exception("Semantics error: count() has to be applied to node set");
+				m_rettype = ast_type_number;
+				break;
+				
+			case ast_func_id:
+				m_left->check_semantics();
+				m_rettype = ast_type_node_set;
+				break;
+				
+			case ast_func_local_name_0:
+			case ast_func_local_name_1:
+			case ast_func_namespace_uri_0:
+			case ast_func_namespace_uri_1:
+			case ast_func_name_0:
+			case ast_func_name_1:
+				if (m_left)
+				{
+					m_left->check_semantics();
+					if (m_left->rettype() != ast_type_node_set)
+						throw xpath_exception("Semantics error: function has to be applied to node set");
+				}
+				m_rettype = ast_type_string;
+				break;
+				
+			case ast_func_string_0:
+			case ast_func_string_1:
+				if (m_left) m_left->check_semantics();
+				m_rettype = ast_type_string;
+				break;
+				
+			case ast_func_concat:
+				m_left->check_semantics();
+				
+				for (xpath_ast_node* n = m_right; n; n = n->m_next)
+					n->check_semantics();
+					
+				m_rettype = ast_type_string;
+				break;
+		
+			case ast_func_starts_with:
+			case ast_func_contains:
+				m_left->check_semantics();
+				m_right->check_semantics();
+				m_rettype = ast_type_boolean;
+				break;
+				
+			case ast_func_substring_before:
+			case ast_func_substring_after:
+			case ast_func_substring_2:
+			case ast_func_substring_3:
+				m_left->check_semantics();
+				m_right->check_semantics();
+				if (m_third) m_third->check_semantics();
+				m_rettype = ast_type_string;
+				break;
+		
+			case ast_func_string_length_0:
+			case ast_func_string_length_1:
+				if (m_left) m_left->check_semantics();
+				m_rettype = ast_type_number;
+				break;
+				
+			case ast_func_normalize_space_0:
+			case ast_func_normalize_space_1:
+			case ast_func_translate:
+				if (m_left) m_left->check_semantics();
+				if (m_right) m_right->check_semantics();
+				if (m_third) m_third->check_semantics();
+				m_rettype = ast_type_string;
+				break;
+		
+			case ast_func_boolean:
+			case ast_func_not:
+			case ast_func_true:
+			case ast_func_false:
+			case ast_func_lang:
+				if (m_left) m_left->check_semantics();
+				m_rettype = ast_type_boolean;
+				break;
+			
+			case ast_func_number_0:
+			case ast_func_number_1:
+				if (m_left) m_left->check_semantics();
+				m_rettype = ast_type_number;
+				break;
+		
+			case ast_func_sum:
+				m_left->check_semantics();
+				if (m_left->rettype() != ast_type_node_set)
+					throw xpath_exception("Semantics error: sum() has to be applied to node set");
+				m_rettype = ast_type_number;
+				break;
+				
+			case ast_func_floor:
+			case ast_func_ceiling:
+			case ast_func_round:
+				if (m_left) m_left->check_semantics();
+				m_rettype = ast_type_number;
+				break;
+		
+			case ast_step:
+				if (m_left)
+				{
+					m_left->check_semantics();
+					if (m_left->rettype() != ast_type_node_set)
+						throw xpath_exception("Semantics error: step has to be applied to node set");
+				}
+				
+				for (xpath_ast_node* n = m_right; n; n = n->m_next)
+					n->check_semantics();
+				
+				m_rettype = ast_type_node_set;
+				break;
+				
+			case ast_step_root:
+				m_rettype = ast_type_node_set;
+				break;
+			
+			default:
+				throw xpath_exception("Unknown semantics error");
+			}
+		}
+		
+		ast_rettype_t rettype() const
+		{
+			return m_rettype;
+		}
+		
+		void* operator new(size_t size, xpath_allocator& a)
+		{
+			return a.alloc(size);
+		}
+		
+		void operator delete(void*, xpath_allocator&)
+		{
+		}
+	};
+
+	class xpath_parser
+	{
+	private:
+	    xpath_allocator& m_alloc;
+	    xpath_lexer m_lexer;
+
+		xpath_parser(const xpath_parser&);
+		xpath_parser& operator=(const xpath_parser&);
+	    
+	    // PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
+	    xpath_ast_node* parse_primary_expression()
+	    {
+	    	switch (m_lexer.current())
+	    	{
+	    	case lex_var_ref:
+	    	{
+	    		m_lexer.next();
+
+	    		if (m_lexer.current() != lex_string)
+	    			throw xpath_exception("incorrect variable reference");
+
+				xpath_ast_node* n = new (m_alloc) xpath_ast_node(ast_variable, m_lexer.contents(), m_alloc);
+				m_lexer.next();
+
+				return n;
+			}
+
+			case lex_open_brace:
+			{
+				m_lexer.next();
+
+				xpath_ast_node* n = parse_expression();
+
+				if (m_lexer.current() != lex_close_brace)
+					throw xpath_exception("unmatched braces");
+
+				m_lexer.next();
+
+				return n;
+			}
+
+			case lex_quoted_string:
+			{
+				xpath_ast_node* n = new (m_alloc) xpath_ast_node(ast_string_constant, m_lexer.contents(), m_alloc);
+				m_lexer.next();
+
+				return n;
+			}
+
+			case lex_number:
+			{
+				xpath_ast_node* n = new (m_alloc) xpath_ast_node(ast_number_constant, m_lexer.contents(), m_alloc);
+				m_lexer.next();
+
+				return n;
+			}
+
+			case lex_string:
+			{
+				xpath_ast_node* args[4];
+				size_t argc = 0;
+				
+				std::string function = m_lexer.contents();
+				m_lexer.next();
+				
+				bool func_concat = (function == "concat");
+				xpath_ast_node* last_concat = 0;
+				
+				if (m_lexer.current() != lex_open_brace)
+					throw xpath_exception("Unrecognized function call");
+				m_lexer.next();
+
+				if (m_lexer.current() != lex_close_brace)
+					args[argc++] = parse_expression();
+
+				while (m_lexer.current() != lex_close_brace)
+				{
+					if (m_lexer.current() != lex_comma)
+						throw xpath_exception("no comma between function arguments");
+					m_lexer.next();
+					
+					xpath_ast_node* n = parse_expression();
+					
+					if (func_concat)
+					{
+						if (argc < 2) args[argc++] = last_concat = n;
+						else
+						{
+							last_concat->set_next(n);
+							last_concat = n;
+						}
+					}
+					else if (argc >= 4)
+						throw xpath_exception("Too many function arguments");
+					else
+						args[argc++] = n;
+				}
+				
+				m_lexer.next();
+				
+				ast_type_t type = ast_none;
+				
+				switch (function[0])
+				{
+				case 'b':
+				{
+					if (function == "boolean" && argc == 1)
+						type = ast_func_boolean;
+						
+					break;
+				}
+				
+				case 'c':
+				{
+					if (function == "count" && argc == 1)
+						type = ast_func_count;
+					else if (function == "contains" && argc == 2)
+						type = ast_func_contains;
+					else if (function == "concat" && argc == 2)
+					{
+						// set_next was done earlier
+						return new (m_alloc) xpath_ast_node(ast_func_concat, args[0], args[1]);
+					}
+					else if (function == "ceiling" && argc == 1)
+						type = ast_func_ceiling;
+						
+					break;
+				}
+				
+				case 'f':
+				{
+					if (function == "false" && argc == 0)
+						type = ast_func_false;
+					else if (function == "floor" && argc == 1)
+						type = ast_func_floor;
+						
+					break;
+				}
+				
+				case 'i':
+				{
+					if (function == "id" && argc == 1)
+						type = ast_func_id;
+						
+					break;
+				}
+				
+				case 'l':
+				{
+					if (function == "last" && argc == 0)
+						type = ast_func_last;
+					else if (function == "lang" && argc == 1)
+						type = ast_func_lang;
+					else if (function == "local-name" && argc <= 1)
+						type = argc == 0 ? ast_func_local_name_0 : ast_func_local_name_1;
+				
+					break;
+				}
+				
+				case 'n':
+				{
+					if (function == "name" && argc <= 1)
+						type = argc == 0 ? ast_func_name_0 : ast_func_name_1;
+					else if (function == "namespace-uri" && argc <= 1)
+						type = argc == 0 ? ast_func_namespace_uri_0 : ast_func_namespace_uri_1;
+					else if (function == "normalize-space" && argc <= 1)
+						type = argc == 0 ? ast_func_normalize_space_0 : ast_func_normalize_space_1;
+					else if (function == "not" && argc == 1)
+						type = ast_func_not;
+					else if (function == "number" && argc <= 1)
+						type = argc == 0 ? ast_func_number_0 : ast_func_number_1;
+				
+					break;
+				}
+				
+				case 'p':
+				{
+					if (function == "position" && argc == 0)
+						type = ast_func_position;
+					
+					break;
+				}
+				
+				case 'r':
+				{
+					if (function == "round" && argc == 1)
+						type = ast_func_round;
+
+					break;
+				}
+				
+				case 's':
+				{
+					if (function == "string" && argc <= 1)
+						type = argc == 0 ? ast_func_string_0 : ast_func_string_1;
+					else if (function == "string-length" && argc <= 1)
+						type = argc == 0 ? ast_func_string_length_0 : ast_func_string_length_1;
+					else if (function == "starts-with" && argc == 2)
+						type = ast_func_starts_with;
+					else if (function == "substring-before" && argc == 2)
+						type = ast_func_substring_before;
+					else if (function == "substring-after" && argc == 2)
+						type = ast_func_substring_after;
+					else if (function == "substring" && (argc == 2 || argc == 3))
+						type = argc == 2 ? ast_func_substring_2 : ast_func_substring_3;
+					else if (function == "sum" && argc == 1)
+						type = ast_func_sum;
+
+					break;
+				}
+				
+				case 't':
+				{
+					if (function == "translate" && argc == 3)
+						type = ast_func_translate;
+					else if (function == "true" && argc == 0)
+						type = ast_func_true;
+						
+					break;
+				}
+				
+				}
+				
+				if (type != ast_none)
+				{
+					switch (argc)
+					{
+					case 0: return new (m_alloc) xpath_ast_node(type);
+					case 1: return new (m_alloc) xpath_ast_node(type, args[0]);
+					case 2: return new (m_alloc) xpath_ast_node(type, args[0], args[1]);
+					case 3: return new (m_alloc) xpath_ast_node(type, args[0], args[1], args[2]);
+					}
+				}
+				
+				throw xpath_exception("Unrecognized function or wrong parameter count");
+			}
+
+	    	default:
+	    		throw xpath_exception("unrecognizable primary expression");
+	    	}
+	    }
+	    
+	    // FilterExpr ::= PrimaryExpr | FilterExpr Predicate
+	    // Predicate ::= '[' PredicateExpr ']'
+	    // PredicateExpr ::= Expr
+	    xpath_ast_node* parse_filter_expression()
+	    {
+	    	xpath_ast_node* n = parse_primary_expression();
+
+	    	while (m_lexer.current() == lex_open_square_brace)
+	    	{
+	    		m_lexer.next();
+
+	    		n = new (m_alloc) xpath_ast_node(ast_filter, n, parse_expression(), axis_child);
+
+	    		if (m_lexer.current() != lex_close_square_brace)
+	    			throw xpath_exception("Unmatched square brace");
+	    	
+	    		m_lexer.next();
+	    	}
+	    	
+	    	return n;
+	    }
+	    
+	    // Step ::= AxisSpecifier NodeTest Predicate* | AbbreviatedStep
+	    // AxisSpecifier ::= AxisName '::' | '@'?
+	    // NodeTest ::= NameTest | NodeType '(' ')' | 'processing-instruction' '(' Literal ')'
+	    // NameTest ::= '*' | NCName ':' '*' | QName
+	    // AbbreviatedStep ::= '.' | '..'
+	    xpath_ast_node* parse_step(xpath_ast_node* set)
+	    {
+			axis_t axis;
+			
+			if (m_lexer.current() == lex_axis_attribute)
+			{
+				axis = axis_attribute;
+				
+				m_lexer.next();
+			}
+			else if (m_lexer.current() == lex_dot)
+			{
+				m_lexer.next();
+				
+				return new (m_alloc) xpath_ast_node(ast_step, set, axis_self, nodetest_type_node, 0, m_alloc);
+			}
+			else if (m_lexer.current() == lex_double_dot)
+			{
+				m_lexer.next();
+				
+				return new (m_alloc) xpath_ast_node(ast_step, set, axis_parent, nodetest_type_node, 0, m_alloc);
+			}
+			else // implied child axis
+				axis = axis_child;
+	    
+			nodetest_t nt_type;
+			std::string nt_name;
+			
+			if (m_lexer.current() == lex_string)
+			{
+				// node name test
+				nt_name = m_lexer.contents();
+				m_lexer.next();
+				
+				// possible axis name here - check.
+				if (nt_name.find("::") == std::string::npos && m_lexer.current() == lex_string && m_lexer.contents()[0] == ':' && m_lexer.contents()[1] == ':')
+				{
+					nt_name += m_lexer.contents();
+					m_lexer.next();
+				}
+				
+				// possible namespace test
+				if (m_lexer.current() == lex_string && m_lexer.contents()[0] == ':')
+				{
+					std::string::size_type colon_pos = nt_name.find(':');
+					
+					// either there is no : in current string or there is, but it's :: and there's nothing more
+					if (colon_pos == std::string::npos ||
+						(colon_pos + 1 < nt_name.size() && nt_name[colon_pos + 1] == ':' &&
+						 nt_name.find(':', colon_pos + 2) == std::string::npos))
+					{
+						nt_name += m_lexer.contents();
+						m_lexer.next();
+					}
+				}
+				
+				bool axis_specified = true;
+				
+				switch (nt_name[0])
+				{
+				case 'a':
+					if (starts_with(nt_name, "ancestor::")) axis = axis_ancestor;
+					else if (starts_with(nt_name, "ancestor-or-self::")) axis = axis_ancestor_or_self;
+					else if (starts_with(nt_name, "attribute::")) axis = axis_attribute;
+					else axis_specified = false;
+					
+					break;
+				
+				case 'c':
+					if (starts_with(nt_name, "child::")) axis = axis_child;
+					else axis_specified = false;
+					
+					break;
+				
+				case 'd':
+					if (starts_with(nt_name, "descendant::")) axis = axis_descendant;
+					else if (starts_with(nt_name, "descendant-or-self::")) axis = axis_descendant_or_self;
+					else axis_specified = false;
+					
+					break;
+				
+				case 'f':
+					if (starts_with(nt_name, "following::")) axis = axis_following;
+					else if (starts_with(nt_name, "following-sibling::")) axis = axis_following_sibling;
+					else axis_specified = false;
+					
+					break;
+				
+				case 'n':
+					if (starts_with(nt_name, "namespace::")) axis = axis_namespace;
+					else axis_specified = false;
+					
+					break;
+				
+				case 'p':
+					if (starts_with(nt_name, "parent::")) axis = axis_parent;
+					else if (starts_with(nt_name, "preceding::")) axis = axis_preceding;
+					else if (starts_with(nt_name, "preceding-sibling::")) axis = axis_preceding_sibling;
+					else axis_specified = false;
+					
+					break;
+				
+				case 's':
+					if (starts_with(nt_name, "self::")) axis = axis_ancestor_or_self;
+					else axis_specified = false;
+					
+					break;
+
+				default:
+					axis_specified = false;
+				}
+				
+				if (axis_specified)
+				{
+					nt_name.erase(0, nt_name.find("::") + 2);
+				}
+				
+				if (nt_name.empty() && m_lexer.current() == lex_string)
+				{
+					nt_name += m_lexer.contents();
+					m_lexer.next();
+				}
+
+				// node type test or processing-instruction
+				if (m_lexer.current() == lex_open_brace)
+				{
+					m_lexer.next();
+					
+					if (m_lexer.current() == lex_close_brace)
+					{
+						m_lexer.next();
+						
+						if (nt_name == "node")
+							nt_type = nodetest_type_node;
+						else if (nt_name == "text")
+							nt_type = nodetest_type_text;
+						else if (nt_name == "comment")
+							nt_type = nodetest_type_comment;
+						else if (nt_name == "processing-instruction")
+							nt_type = nodetest_type_pi;
+						else
+							throw xpath_exception("Unrecognized node type");
+						
+						nt_name.clear();
+					}
+					else if (nt_name == "processing-instruction")
+					{
+						if (m_lexer.current() != lex_quoted_string)
+							throw xpath_exception("Only literals are allowed as arguments to processing-instruction()");
+					
+						nt_type = nodetest_pi;
+						nt_name = m_lexer.contents();
+						m_lexer.next();
+						
+						if (m_lexer.current() != lex_close_brace)
+							throw xpath_exception("Unmatched brace near processing-instruction()");
+						m_lexer.next();
+					}
+					else
+						throw xpath_exception("Unmatched brace near node type test");
+
+				}
+				// namespace *
+				else if (m_lexer.current() == lex_multiply)
+				{
+					// Only strings of form 'namespace:*' are permitted
+					if (nt_name.empty())
+						nt_type = nodetest_all;
+					else
+					{
+						if (nt_name.find(':') != nt_name.size() - 1)
+							throw xpath_exception("Wrong namespace-like node test");
+						
+						nt_name.erase(nt_name.size() - 1);
+						
+						nt_type = nodetest_all_in_namespace;
+					}
+					
+					m_lexer.next();
+				}
+				else nt_type = nodetest_name;
+			}
+			else if (m_lexer.current() == lex_multiply)
+			{
+				nt_type = nodetest_all;
+				m_lexer.next();
+			}
+			else throw xpath_exception("Unrecognized node test");
+			
+			xpath_ast_node* n = new (m_alloc) xpath_ast_node(ast_step, set, axis, nt_type, nt_name.c_str(), m_alloc);
+			
+			xpath_ast_node* last = 0;
+			
+			while (m_lexer.current() == lex_open_square_brace)
+			{
+				m_lexer.next();
+				
+				xpath_ast_node* pred = new (m_alloc) xpath_ast_node(ast_predicate, parse_expression(), 0, axis);
+				
+				if (m_lexer.current() != lex_close_square_brace)
+	    			throw xpath_exception("unmatched square brace");
+				m_lexer.next();
+				
+				if (last) last->set_next(pred);
+				else n->set_right(pred);
+				
+				last = pred;
+			}
+			
+			return n;
+	    }
+	    
+	    // RelativeLocationPath ::= Step | RelativeLocationPath '/' Step | RelativeLocationPath '//' Step
+	    xpath_ast_node* parse_relative_location_path(xpath_ast_node* set)
+	    {
+			xpath_ast_node* n = parse_step(set);
+			
+			while (m_lexer.current() == lex_slash || m_lexer.current() == lex_double_slash)
+			{
+				lexeme_t l = m_lexer.current();
+				m_lexer.next();
+
+				if (l == lex_double_slash)
+					n = new (m_alloc) xpath_ast_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0, m_alloc);
+				
+				n = parse_step(n);
+			}
+			
+			return n;
+	    }
+	    
+	    // LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
+	    // AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
+	    xpath_ast_node* parse_location_path()
+	    {
+			if (m_lexer.current() == lex_slash)
+			{
+				// Save state for next lexeme - that is, whatever follows '/'
+				const char* state = m_lexer.state();
+				
+				m_lexer.next();
+				
+				xpath_ast_node* n = new (m_alloc) xpath_ast_node(ast_step_root);
+				
+				try
+				{
+					n = parse_relative_location_path(n);
+				}
+				catch (const xpath_exception&)
+				{
+					m_lexer.reset(state);
+				}
+				
+				return n;
+			}
+			else if (m_lexer.current() == lex_double_slash)
+			{
+				m_lexer.next();
+				
+				xpath_ast_node* n = new (m_alloc) xpath_ast_node(ast_step_root);
+				n = new (m_alloc) xpath_ast_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0, m_alloc);
+				
+				return parse_relative_location_path(n);
+			}
+			else
+			{
+				return parse_relative_location_path(0);
+			}
+	    }
+	    
+	    // PathExpr ::= LocationPath
+	    //				| FilterExpr
+	    //				| FilterExpr '/' RelativeLocationPath
+	    //				| FilterExpr '//' RelativeLocationPath
+	    xpath_ast_node* parse_path_expression()
+	    {
+			// Clarification.
+			// PathExpr begins with either LocationPath or FilterExpr.
+			// FilterExpr begins with PrimaryExpr
+			// PrimaryExpr begins with '$' in case of it being a variable reference,
+			// '(' in case of it being an expression, string literal, number constant or
+			// function call.
+
+			if (m_lexer.current() == lex_var_ref || m_lexer.current() == lex_open_brace || 
+				m_lexer.current() == lex_quoted_string || m_lexer.current() == lex_number ||
+				m_lexer.current() == lex_string)
+	    	{
+	    		if (m_lexer.current() == lex_string)
+	    		{
+	    			// This is either a function call, or not - if not, we shall proceed with location path
+	    			const char* state = m_lexer.state();
+	    			
+	    			while (*state && *state <= 32) ++state;
+	    			
+	    			if (*state != '(') return parse_location_path();
+	    		}
+	    		
+	    		xpath_ast_node* n = parse_filter_expression();
+
+	    		if (m_lexer.current() == lex_slash || m_lexer.current() == lex_double_slash)
+	    		{
+					lexeme_t l = m_lexer.current();
+	    			m_lexer.next();
+	    			
+					if (l == lex_double_slash)
+						n = new (m_alloc) xpath_ast_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0, m_alloc);
+	
+	    			// select from location path
+	    			return parse_relative_location_path(n);
+	    		}
+
+	    		return n;
+	    	}
+	    	else return parse_location_path();
+	    }
+
+	    // UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
+	    xpath_ast_node* parse_union_expression()
+	    {
+	    	xpath_ast_node* n = parse_path_expression();
+
+	    	while (m_lexer.current() == lex_union)
+	    	{
+	    		m_lexer.next();
+
+	    		n = new (m_alloc) xpath_ast_node(ast_op_union, n, parse_union_expression());
+	    	}
+
+	    	return n;
+	    }
+
+	    // UnaryExpr ::= UnionExpr | '-' UnaryExpr
+	    xpath_ast_node* parse_unary_expression()
+	    {
+	    	if (m_lexer.current() == lex_minus)
+	    	{
+	    		m_lexer.next();
+
+	    		return new (m_alloc) xpath_ast_node(ast_op_negate, parse_unary_expression());
+	    	}
+	    	else return parse_union_expression();
+	    }
+	    
+	    // MultiplicativeExpr ::= UnaryExpr
+	    //						  | MultiplicativeExpr '*' UnaryExpr
+	    //						  | MultiplicativeExpr 'div' UnaryExpr
+	    //						  | MultiplicativeExpr 'mod' UnaryExpr
+	    xpath_ast_node* parse_multiplicative_expression()
+	    {
+	    	xpath_ast_node* n = parse_unary_expression();
+
+	    	while (m_lexer.current() == lex_multiply || (m_lexer.current() == lex_string &&
+	    		   (!strcmp(m_lexer.contents(), "mod") || !strcmp(m_lexer.contents(), "div"))))
+	    	{
+	    		ast_type_t op = m_lexer.current() == lex_multiply ? ast_op_multiply :
+	    			!strcmp(m_lexer.contents(), "div") ? ast_op_divide : ast_op_mod;
+	    		m_lexer.next();
+
+	    		n = new (m_alloc) xpath_ast_node(op, n, parse_unary_expression());
+	    	}
+
+	    	return n;
+	    }
+
+	    // AdditiveExpr ::= MultiplicativeExpr
+	    //					| AdditiveExpr '+' MultiplicativeExpr
+	    //					| AdditiveExpr '-' MultiplicativeExpr
+	    xpath_ast_node* parse_additive_expression()
+	    {
+	    	xpath_ast_node* n = parse_multiplicative_expression();
+
+	    	while (m_lexer.current() == lex_plus || m_lexer.current() == lex_minus)
+	    	{
+	    		lexeme_t l = m_lexer.current();
+
+	    		m_lexer.next();
+
+	    		n = new (m_alloc) xpath_ast_node(l == lex_plus ? ast_op_add : ast_op_subtract, n, parse_multiplicative_expression());
+	    	}
+
+	    	return n;
+	    }
+
+	    // RelationalExpr ::= AdditiveExpr
+	    //					  | RelationalExpr '<' AdditiveExpr
+	    //					  | RelationalExpr '>' AdditiveExpr
+	    //					  | RelationalExpr '<=' AdditiveExpr
+	    //					  | RelationalExpr '>=' AdditiveExpr
+	    xpath_ast_node* parse_relational_expression()
+	    {
+	    	xpath_ast_node* n = parse_additive_expression();
+
+	    	while (m_lexer.current() == lex_less || m_lexer.current() == lex_less_or_equal || 
+	    		   m_lexer.current() == lex_greater || m_lexer.current() == lex_greater_or_equal)
+	    	{
+	    		lexeme_t l = m_lexer.current();
+	    		m_lexer.next();
+
+	    		n = new (m_alloc) xpath_ast_node(l == lex_less ? ast_op_less : l == lex_greater ? ast_op_greater :
+	    						l == lex_less_or_equal ? ast_op_less_or_equal : ast_op_greater_or_equal,
+	    						n, parse_additive_expression());
+	    	}
+
+	    	return n;
+	    }
+	    
+	    // EqualityExpr ::= RelationalExpr
+	    //					| EqualityExpr '=' RelationalExpr
+	    //					| EqualityExpr '!=' RelationalExpr
+	    xpath_ast_node* parse_equality_expression()
+	    {
+	    	xpath_ast_node* n = parse_relational_expression();
+
+	    	while (m_lexer.current() == lex_equal || m_lexer.current() == lex_not_equal)
+	    	{
+	    		lexeme_t l = m_lexer.current();
+
+	    		m_lexer.next();
+
+	    		n = new (m_alloc) xpath_ast_node(l == lex_equal ? ast_op_equal : ast_op_not_equal, n, parse_relational_expression());
+	    	}
+
+	    	return n;
+	    }
+	    
+	    // AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
+	    xpath_ast_node* parse_and_expression()
+	    {
+	    	xpath_ast_node* n = parse_equality_expression();
+
+	    	while (m_lexer.current() == lex_string && !strcmp(m_lexer.contents(), "and"))
+	    	{
+	    		m_lexer.next();
+
+	    		n = new (m_alloc) xpath_ast_node(ast_op_and, n, parse_equality_expression());
+	    	}
+
+	    	return n;
+	    }
+
+	    // OrExpr ::= AndExpr | OrExpr 'or' AndExpr
+	    xpath_ast_node* parse_or_expression()
+	    {
+	    	xpath_ast_node* n = parse_and_expression();
+
+	    	while (m_lexer.current() == lex_string && !strcmp(m_lexer.contents(), "or"))
+	    	{
+	    		m_lexer.next();
+
+	    		n = new (m_alloc) xpath_ast_node(ast_op_or, n, parse_and_expression());
+	    	}
+
+	    	return n;
+	    }
+		
+		// Expr ::= OrExpr
+		xpath_ast_node* parse_expression()
+		{
+			return parse_or_expression();
+		}
+
+	public:
+		explicit xpath_parser(const char* query, xpath_allocator& alloc): m_alloc(alloc), m_lexer(query)
+		{
+		}
+
+		xpath_ast_node* parse()
+		{
+			return parse_expression();
+		}
+	};
+
+	xpath_query::xpath_query(const char* query): m_alloc(0), m_root(0)
+	{
+		compile(query);
+	}
+
+	xpath_query::~xpath_query()
+	{
+		delete m_alloc;
+	}
+
+	void xpath_query::compile(const char* query)
+	{
+		delete m_alloc;
+		m_alloc = new xpath_allocator;
+
+		xpath_parser p(query, *m_alloc);
+
+		m_root = p.parse();
+		m_root->check_semantics();
+	}
+
+	bool xpath_query::evaluate_boolean(const xml_node& n)
+	{
+		if (!m_root) return false;
+		
+		xpath_context c;
+		
+		c.root = n.root();
+		c.n = n;
+		c.position = 1;
+		c.size = 1;
+		
+		return m_root->eval_boolean(c);
+	}
+	
+	double xpath_query::evaluate_number(const xml_node& n)
+	{
+		if (!m_root) return gen_nan();
+		
+		xpath_context c;
+		
+		c.root = n.root();
+		c.n = n;
+		c.position = 1;
+		c.size = 1;
+		
+		return m_root->eval_number(c);
+	}
+	
+	std::string xpath_query::evaluate_string(const xml_node& n)
+	{
+		if (!m_root) return std::string();
+		
+		xpath_context c;
+		
+		c.root = n.root();
+		c.n = n;
+		c.position = 1;
+		c.size = 1;
+		
+		return m_root->eval_string(c);
+	}
+	
+	xpath_node_set xpath_query::evaluate_node_set(const xml_node& n)
+	{
+		if (!m_root) return xpath_node_set();
+		
+		xpath_context c;
+		
+		c.root = n.root();
+		c.n = n;
+		c.position = 1;
+		c.size = 1;
+		
+		return m_root->eval_node_set(c);
+	}
+
+	xpath_node xml_node::select_single_node(const char* query) const
+	{
+		xpath_query q(query);
+		return select_single_node(q);
+	}
+
+	xpath_node xml_node::select_single_node(xpath_query& query) const
+	{
+		xpath_node_set s = query.evaluate_node_set(*this);
+		return s.empty() ? xpath_node() : s.first();
+	}
+
+	xpath_node_set xml_node::select_nodes(const char* query) const
+	{
+		xpath_query q(query);
+		return select_nodes(q);
+	}
+
+	xpath_node_set xml_node::select_nodes(xpath_query& query) const
+	{
+		return query.evaluate_node_set(*this);
+	}
+}
+
+#endif
-- 
cgit v1.2.3