SDL 3.8!

Signed-off-by: Justin Dickow <jjdickow@gmail.com>

182 files changed, 36109 insertions, 0 deletions

diff --git a/tools/intergen/CMakeLists.txt b/tools/intergen/CMakeLists.txt
new file mode 100644
index 0000000000..b7fc7ed025
--- /dev/null
+++ b/tools/intergen/CMakeLists.txt
@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 2.8)
+project(intergen)
+
+if (${UNIX})
+  add_definitions(-DOS_POSIX)
+endif(${UNIX})
+
+add_subdirectory(third_party/pugixml/scripts)
+add_subdirectory(utils)
+add_subdirectory(model)
+add_subdirectory(cppgen)
+add_subdirectory(tool)
diff --git a/tools/intergen/GenerateInterfaceLibrary.cmake b/tools/intergen/GenerateInterfaceLibrary.cmake
new file mode 100644
index 0000000000..8482a8206a
--- /dev/null
+++ b/tools/intergen/GenerateInterfaceLibrary.cmake
@@ -0,0 +1,60 @@
+set(INTERGEN_CMD ${CMAKE_BINARY_DIR}/tools/intergen/bin/intergen)
+set(GENERATED_LIB_DEPENDENCIES jsoncpp)
+set(GENERATED_LIB_HEADER_DEPENDENCIES
+  ${CMAKE_SOURCE_DIR}/src/components/rpc_base/include
+  ${CMAKE_SOURCE_DIR}/src/thirdPartyLibs/jsoncpp/include
+)
+
+# Generates interface library from given xml file and builds it
+# in CMAKE_CURRENT_BINARY_DIR
+# |xml_file_name| contains path to xml spec files
+# |generated_interface_names| should contain list of generated interfaces
+# if |AUTO_FUNC_IDS| is added to argument list, intergen is called with "-a"
+#   flag telling intergen to generate function ids automatically
+# if |DBUS_SUPPORT| is added to argument list, intergen is called with "-d"
+#   flag that enables DBus serialization code generation
+# from xml_file (intergen creates separate directory for every interface).
+# Their names are written lowercase_underscored_style.
+function (GenerateInterfaceLibrary xml_file_name generated_interface_names)
+  set(options AUTO_FUNC_IDS DBUS_SUPPORT)
+  cmake_parse_arguments(GenerateInterfaceLibrary "${options}" "" "" ${ARGN})
+  if (GenerateInterfaceLibrary_AUTO_FUNC_IDS)
+    set(AUTOID "-a")
+  endif()
+  if (GenerateInterfaceLibrary_DBUS_SUPPORT)
+    set(NEED_DBUS "-d")
+    list(APPEND GENERATED_LIB_HEADER_DEPENDENCIES ${DBUS_INCLUDE_DIRS})
+  endif()
+
+  foreach(interface_name ${generated_interface_names})
+    set(HEADERS
+        ${interface_name}/enums.h
+        ${interface_name}/types.h
+        ${interface_name}/functions.h
+        ${interface_name}/interface.h
+    )
+    set(SOURCES
+        ${interface_name}/enums.cc
+        ${interface_name}/types.cc
+        ${interface_name}/functions.cc
+        ${interface_name}/validation.cc
+        ${interface_name}/interface.cc
+    )
+    add_custom_command( OUTPUT ${HEADERS} ${SOURCES}
+                        COMMAND ${INTERGEN_CMD} -f ${CMAKE_CURRENT_SOURCE_DIR}/${xml_file_name} -j ${AUTOID} ${NEED_DBUS} -i ${interface_name}
+                        DEPENDS ${INTERGEN_CMD} ${xml_file_name}
+                        COMMENT "Generating interface ${interface_name} from ${xml_file_name}"
+                        VERBATIM
+                       )
+    include_directories(
+      ${CMAKE_CURRENT_BINARY_DIR}
+      ${GENERATED_LIB_HEADER_DEPENDENCIES}
+    )
+    add_library(${interface_name} ${SOURCES})
+
+    # |previous_interface| ensures that interface libraries are built in the same order
+    # as they defined in |generated_interface_names|
+    target_link_libraries(${interface_name} ${GENERATED_LIB_DEPENDENCIES} ${previous_interface})
+    set(previous_interface ${interface_name})
+  endforeach(interface_name)
+endfunction(GenerateInterfaceLibrary xml_file_name generated_interface_names)
diff --git a/tools/intergen/cppgen/CMakeLists.txt b/tools/intergen/cppgen/CMakeLists.txt
new file mode 100644
index 0000000000..c6e052a2ae
--- /dev/null
+++ b/tools/intergen/cppgen/CMakeLists.txt
@@ -0,0 +1,70 @@
+include_directories(
+  include
+  ${intergen_SOURCE_DIR}/model/include
+  ${intergen_SOURCE_DIR}/utils/include
+)
+
+set (SOURCES
+  src/cppgen/comment.cc
+  src/cppgen/cpp_api_code_generator.cc
+  src/cppgen/cpp_class.cc
+  src/cppgen/cpp_file.cc
+  src/cppgen/cpp_function.cc
+  src/cppgen/cpp_interface_code_generator.cc
+  src/cppgen/declaration_generator.cc
+  src/cppgen/definition_generator.cc
+  src/cppgen/enum_from_json_value_function.cc
+  src/cppgen/enum_to_json_value_function.cc
+  src/cppgen/function_id_method.cc
+  src/cppgen/generator_preferences.cc
+  src/cppgen/handler_interface.cc
+  src/cppgen/is_valid_enum_function.cc
+  src/cppgen/literal_generator.cc
+  src/cppgen/message_factory_function.cc
+  src/cppgen/message_handle_with_method.cc
+  src/cppgen/message_interface.cc
+  src/cppgen/module_manager.cc
+  src/cppgen/namespace.cc
+  src/cppgen/naming_convention.cc
+  src/cppgen/struct_type_constructor.cc
+  src/cppgen/struct_type_dbus_serializer.cc
+  src/cppgen/struct_type_from_json_method.cc
+  src/cppgen/struct_type_is_initialized_method.cc
+  src/cppgen/struct_type_is_valid_method.cc
+  src/cppgen/struct_type_report_erros_method.cc
+  src/cppgen/type_name_code_generator.cc
+)
+
+set (HEADERS
+  include/cppgen/comment.h
+  include/cppgen/cpp_api_code_generator.h
+  include/cppgen/cpp_class.h
+  include/cppgen/cpp_file.h
+  include/cppgen/cpp_function.h
+  include/cppgen/cpp_interface_code_generator.h
+  include/cppgen/declaration_generator.h
+  include/cppgen/definition_generator.h
+  include/cppgen/enum_from_json_value_function.h
+  include/cppgen/enum_to_json_value_function.h
+  include/cppgen/function_id_method.h
+  include/cppgen/generator_preferences.h
+  include/cppgen/handler_interface.h
+  include/cppgen/is_valid_enum_function.h
+  include/cppgen/literal_generator.h
+  include/cppgen/message_factory_function.h
+  include/cppgen/message_handle_with_method.h
+  include/cppgen/message_interface.h
+  include/cppgen/module_manager.h
+  include/cppgen/namespace.h
+  include/cppgen/naming_convention.h
+  include/cppgen/struct_type_constructor.h
+  include/cppgen/struct_type_dbus_serializer.h
+  include/cppgen/struct_type_from_json_method.h
+  include/cppgen/struct_type_is_initialized_method.h
+  include/cppgen/struct_type_is_valid_method.h
+  include/cppgen/struct_type_report_erros_method.h
+  include/cppgen/type_name_code_generator.h
+)
+
+add_library(intergen_cppgen ${HEADERS} ${SOURCES})
+target_link_libraries(intergen_cppgen intergen_model intergen_utils)
diff --git a/tools/intergen/cppgen/include/cppgen/comment.h b/tools/intergen/cppgen/include/cppgen/comment.h
new file mode 100644
index 0000000000..f4fdfb45ed
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/comment.h
@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef COMMENT_H_
+#define COMMENT_H_
+
+#include <iosfwd>
+
+#include "utils/common_types.h"
+
+namespace codegen {
+
+// Class that represents C++ comment that can easily be output to
+// ostream,
+// comment text is wrapped with C++ comment marks (//) or /star automatically
+class Comment {
+ public:
+  // Create comment object from Description collected from xml
+  explicit Comment(const Description& description);
+  // Create single-line comment from string
+  explicit Comment(const std::string& text);
+  ~Comment();
+ private:
+  Description description_;
+  friend std::ostream& operator<<(std::ostream& os, const Comment& comment);
+};
+
+std::ostream& operator<<(std::ostream& os, const Comment& comment);
+
+}  // namespace codegen
+
+#endif /* COMMENT_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/cpp_api_code_generator.h b/tools/intergen/cppgen/include/cppgen/cpp_api_code_generator.h
new file mode 100644
index 0000000000..c7ecf267b8
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/cpp_api_code_generator.h
@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CPP_API_CODE_GENERATOR_H_
+#define CPP_API_CODE_GENERATOR_H_
+
+#include <set>
+#include <string>
+
+#include "cppgen/generator_preferences.h"
+
+namespace codegen {
+class API;
+class Interface;
+
+/*
+ * Main C++ code generator class, takes parsed API object and produces
+ * header and implementation files for that code
+ */
+class CppApiCodeGenerator {
+ public:
+  CppApiCodeGenerator(const API* api);
+  ~CppApiCodeGenerator();
+  // Generate code for requested interfaces. Interface name id taken from
+  // Interface::name field converting it to a lower_case_identifier
+  std::set<std::string> Generate(const Preferences& preferences);
+ private:
+  // Produces code for single interface
+  bool GenerateInterface(const Interface* interface,
+                         const TypePreferences& preferences);
+ private:
+  const API* api_;
+};
+
+}  // namespace codegen
+
+#endif /* CPP_API_CODE_GENERATOR_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/cpp_class.h b/tools/intergen/cppgen/include/cppgen/cpp_class.h
new file mode 100644
index 0000000000..5f2ff4193c
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/cpp_class.h
@@ -0,0 +1,114 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CODEGEN_CPP_CLASS_H
+#define CODEGEN_CPP_CLASS_H
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+#include "cppgen/cpp_function.h"
+
+namespace codegen {
+/*
+ * Class helper abstract class for C++ classes generation
+ * Must be inherited by a concrete class that provides
+ * class information by implementing pure virtual methods
+ */
+class CppClass {
+ public:
+  // Types
+  class Method;
+  class Superclass;
+  typedef std::vector<const Method*> MethodsList;
+  typedef std::vector<Superclass> SuperclassList;
+  // Member and inheritance access types specifier
+  enum AccessSpec {
+    kPublic, kProtected, kPrivate
+  };
+ public:
+  // Methods
+  // Creates class named |name|
+  CppClass(const std::string& name);
+  ~CppClass();
+  // Add superclass to classess parent's list
+  void Add(const Superclass& superclass);
+  // Output class declaration code to |os|
+  void Declare(std::ostream* os);
+  // Output class member's definition code to |os|
+  void Define(std::ostream* os);
+  // Class name
+  std::string name() const;
+protected:
+  // Methods
+  // To be defined by a concrete class, to provide
+  // Class member methods list
+  virtual const MethodsList& methods() = 0;
+private:
+  // Helper method that gives method list filtered by
+  // |access_spec|
+  MethodsList functions(AccessSpec access_spec);
+  // Fields
+  std::string name_;
+  SuperclassList superclasses_;
+};
+
+/*
+ * Helper class produces code for class method
+ */
+class CppClass::Method: public CppFunction {
+ public:
+  Method(const CppClass* cls, AccessSpec access, const std::string& name,
+           const std::string& return_type_name, int qualifiers = 0);
+  AccessSpec access_specifier() const;
+
+private:
+  AccessSpec access_specifier_;
+};
+
+/*
+ * Helper class that is used to specify class's parrents
+ */
+class CppClass::Superclass {
+public:
+  Superclass(const std::string& name, AccessSpec inheritance_type);
+  const std::string& name() const;
+  AccessSpec inheritance_type() const;
+
+private:
+  std::string name_;
+  AccessSpec inheritance_type_;
+};
+
+} // namespace codegen
+
+#endif // CODEGEN_CPP_CLASS_H
diff --git a/tools/intergen/cppgen/include/cppgen/cpp_file.h b/tools/intergen/cppgen/include/cppgen/cpp_file.h
new file mode 100644
index 0000000000..07857ccf4c
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/cpp_file.h
@@ -0,0 +1,121 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CPP_FILE_H_
+#define CPP_FILE_H_
+
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+
+#include "cppgen/namespace.h"
+#include "model/function.h"
+#include "utils/common_types.h"
+
+namespace codegen {
+class Type;
+
+/*
+ * Class representing C++ source file (generic) which contains C++ declarations
+ * and definitions placed in namespaces
+ * Can represent header or source file which basically differ in whether
+ * file's contents is wrapped with include guards
+ */
+class CppFile {
+ public:
+  // Types
+  class Header;
+ public:
+  // Methods
+  // Creates C++ file with name |file_name| that is part of module
+  // |module_name|.
+  // If |write_guards| is true, file contents is wrapped with include guards
+  // Module name is used to generate header guards and as a directory to
+  // write file into.
+  CppFile(const std::string& file_name, const std::string& module_name, bool write_guards);
+  ~CppFile();
+  const std::string& file_name() const;
+  // Adds header to file's include list
+  void Include(const Header& header);
+  // Automatically adds header where given type is defined
+  void IncludeType(const Type& type);
+  // Returns predefined namespaces for entities of different type
+  Namespace& global_namespace();
+  Namespace& types_ns();
+  Namespace& requests_ns();
+  Namespace& responses_ns();
+  Namespace& notifications_ns();
+  Namespace& NamespaceByMessageType(FunctionMessage::MessageType type);
+
+  // Generates code file named module_name/file_name and saves all namespaces
+  // into it.
+  void Write(std::ostream* os);
+
+ private:
+  Namespace& module_namespace();
+  // Methods
+ private:
+  bool write_guards_;
+  std::string file_name_;
+  std::string module_name_;
+  // Fields
+  std::stringstream contents_;
+  std::set<Header> headers_;
+  Namespace global_namespace_;
+};
+
+/*
+ *  Class representing single header that is to be included into current one
+ */
+class CppFile::Header {
+ public:
+  // Methods
+
+  // Creates include directive with |name|.
+  // If |local| is true, name will be included in quotes, else
+  // it is included in <>
+  Header(const std::string& name, bool local);
+  bool is_local() const;
+  const std::string& name() const;
+  bool operator<(const Header& that) const;
+
+ private:
+  // Fields
+  std::string name_;
+  bool local_;
+};
+
+}  // namespace codegen
+
+#endif /* CPP_FILE_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/cpp_function.h b/tools/intergen/cppgen/include/cppgen/cpp_function.h
new file mode 100644
index 0000000000..4aaecd75cc
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/cpp_function.h
@@ -0,0 +1,174 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CPP_FUNCTION_H_
+#define CPP_FUNCTION_H_
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+namespace codegen {
+
+/*
+ * Class representing single generated C++ function or method
+ * Has methods to output that function declaration or definition to
+ * ostream
+ */
+class CppFunction {
+ public:
+  // Types and constants
+  struct Parameter;
+  struct OptionalParameter;
+  struct Initializer;
+  // C++ Function qualifiers
+  static const int kVirtual  = 1 << 0;
+  static const int kStatic   = 1 << 1;
+  static const int kExplicit = 1 << 2;
+  static const int kConst    = 1 << 3;
+  static const int kVolatile = 1 << 4;
+  static const int kAbstract = 1 << 5;
+ public:
+  // Methods
+  // Creates a C++ function that belongs to |class_name|
+  // (should be empty for free functions), has a |name| and returns
+  // value of |return_type_name|. Might have combination of optional
+  // |qualifiers| (kVirtual | kConst, etc.)
+  CppFunction(const std::string& class_name, const std::string& name,
+              const std::string& return_type_name, int qualifiers = 0);
+  virtual ~CppFunction();
+  // Adds a (mandatory) parameter to a function, parameters are declared in the
+  // same order they were added
+  void Add(const Parameter& parameter);
+  // Adds an optional parameter. Optional parameters are declared
+  // after mandatory parameters in the order they were added
+  void Add(const OptionalParameter& parameter);
+  // Adds initializer statement, used by constructors
+  void Add(const Initializer& initializer);
+  // Outputs function declaration to ostream |os|, if
+  // |in_class| is true, declaration will have all the
+  // qualifiers present and class name omitted
+  // following C++ rules of method declaration
+  void Declare(std::ostream* os, bool in_class) const;
+  // Outputs function definition (signature and body) to  ostream |os|.
+  // if |in_class| is true, declaration will have all the
+  // qualifiers present and class name omitted
+  // following C++ rules of method declaration
+  void Define(std::ostream* os, bool in_class) const;
+  // Returns true if generated function has at least one parameter that is not
+  // optional e.g. can not be called without parameters.
+  bool has_mandatory_parameters() const;
+ private:
+  // Outputs function prototype to |os|.
+  // if |in_class| is true, declaration will have all the
+  // qualifiers present and class name omitted
+  // following C++ rules of method declaration
+  // If |default_values| is true, output values for optional
+  // parameters (these should be written when function is declared).
+  void WriteFunctionPrototype(std::ostream* os, bool in_class,
+                              bool default_values) const;
+  // Outputs constructor initializer list
+  void WriteInitializerList(std::ostream* os) const;
+ protected:
+  // A method to be defined by derived classes that outputs function code
+  virtual void DefineBody(std::ostream* os) const;
+  int qualifiers_;
+  std::string class_name_;
+  std::string name_;
+  std::string return_type_name_;
+  std::vector<Parameter> parameters_;
+  std::vector<OptionalParameter> optional_params_;
+  std::vector<Initializer> initializers_;
+};
+
+/*
+ * Represents single function parameter
+ */
+struct CppFunction::Parameter {
+  // Every parameter has name and type, which are passed as
+  // |name| and |type_name|
+  Parameter(const std::string& name, const std::string& type_name);
+  ~Parameter();
+  std::string name;
+  std::string type_name;
+};
+
+/*
+ * Represents single optional parameter function can accept
+ * it is different from usual parameter as it has default value
+ */
+struct CppFunction::OptionalParameter : CppFunction::Parameter {
+  // Every optional parameter has name and type, which are passed as
+  // |name| and |type_name|. Default initializer expression is passed as
+  // |default_value| parameter.
+  OptionalParameter(const std::string& name, const std::string& type_name,
+                    const std::string& default_value);
+  ~OptionalParameter();
+  std::string default_value;
+};
+
+/*
+ * Represents initializer entry for constructor initializer list.
+ * Every entry consists of |field_name| to be initialized and it's
+ * |initializer| expression.
+ */
+struct CppFunction::Initializer {
+  Initializer(const std::string& field_name, const std::string& initializer);
+  ~Initializer();
+  std::string field_name;
+  std::string initializer;
+};
+
+/*
+ * Constructor is a specialized C++ function that only needs type_name
+ * to be defined. Parameters (if any) can be added later.
+ */
+class CppStructConstructor: public CppFunction {
+ public:
+  // Generates a constructor for type named |type_name|.
+  CppStructConstructor(const std::string& type_name);
+  ~CppStructConstructor();
+};
+
+/*
+ * Destructor is a specialized C++ function that only needs type_name
+ * to be defined.
+ */
+class CppStructDestructor: public CppFunction {
+ public:
+  CppStructDestructor(const std::string& type_name, bool abstract = false);
+  ~CppStructDestructor();
+};
+
+}  // namespace codegen
+
+#endif /* CPP_FUNCTION_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/cpp_interface_code_generator.h b/tools/intergen/cppgen/include/cppgen/cpp_interface_code_generator.h
new file mode 100644
index 0000000000..52937fb115
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/cpp_interface_code_generator.h
@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CPP_INTERFACE_CODE_GENERATOR_H_
+#define CPP_INTERFACE_CODE_GENERATOR_H_
+
+#include "cppgen/declaration_generator.h"
+#include "cppgen/definition_generator.h"
+
+namespace codegen {
+class Interface;
+class ModuleManager;
+class TypePreferences;
+
+/*
+ * Generates code for all the entities of single interface
+ */
+class CppInterfaceCodeGenerator {
+ public:
+  // Creates code generator for |interface|, using
+  // |module_manager| to find where to output the code
+  CppInterfaceCodeGenerator(const Interface* interface,
+                            const TypePreferences* preferences,
+                            ModuleManager* module_manager);
+  ~CppInterfaceCodeGenerator();
+  // Generate all the interface code
+  void GenerateCode();
+ private:
+  // Generate code for different interface entities
+  void GenerateEnums();
+  void GenerateStructs();
+  void GenerateTypedefs();
+  void GenerateFunctions();
+  void GenerateResponses();
+  void GenerateNotifications();
+  void GenerateHandlerInterfaces();
+  void GenerateMessageBaseClasses();
+  void GenerateMessageFactories();
+private:
+  // Fields
+  const Interface* interface_;
+  const TypePreferences* preferences_;
+  ModuleManager* module_manager_;
+  DeclarationGenerator declaration_generator_;
+  DefinitionGenerator definition_generator_;
+};
+
+}  // namespace codegen
+
+#endif /* CPP_INTERFACE_CODE_GENERATOR_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/declaration_generator.h b/tools/intergen/cppgen/include/cppgen/declaration_generator.h
new file mode 100644
index 0000000000..6858d6f02e
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/declaration_generator.h
@@ -0,0 +1,109 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DECLARATION_GENERATOR_H_
+#define DECLARATION_GENERATOR_H_
+
+#include "model/composite_type.h"
+#include "model/constant.h"
+#include "model/function.h"
+
+namespace codegen {
+class CppFile;
+class GeneratorPreferences;
+class ModuleManager;
+class Namespace;
+class TypePreferences;
+
+/*
+ * Generates declaration code of different entities that is to be
+ * put into header file
+ */
+class DeclarationGenerator {
+ public:
+  // Methods
+  DeclarationGenerator(const TypePreferences* preferences,
+                       ModuleManager* module_manager);
+  ~DeclarationGenerator();
+
+  // Methods that generate code for different code model entities
+  void GenerateCodeForEnum(const Enum* enm);
+  void GenerateCodeForStruct(const Struct* strct);
+  void GenerateCodeForTypedef(const Typedef* tdef);
+  void GenerateCodeForFunction(const Function& function);
+  void GenerateCodeForResponse(const Response& response);
+  void GenerateCodeForNotification(const Notification& notification);
+ private:
+  // Methods
+  void GenerateCodeForRequest(const Request& response, CppFile* header_file);
+  void GenerateCodeForEnumConstant(const Enum::Constant& enm,
+                                   CppFile* header_file,
+                                   bool skip_coma);
+  void GenerateCodeForStructField(const Struct& strct,
+                                  const Struct::Field& field,
+                                  CppFile* header_file,
+                                  Namespace* name_space);
+  void GenerateCodeForStructFields(const Struct& strct,
+                                   CppFile* header_file,
+                                   Namespace* name_space);
+ private:
+  // Fields
+  const TypePreferences* preferences_;
+  ModuleManager* module_manager_;
+};
+
+/*
+ * This class is used to add forward declaration of specific type
+ * to file's namespace
+ */
+class TypeForwardDeclarator : public TypeCodeGenerator {
+ public:
+  // Creates objec and automatically forward declares |type| in namespace
+  // |ns|
+  TypeForwardDeclarator(Namespace* ns, const Type* type);
+ private:
+  // TypeCodeGenerator interface
+
+  // Only structs can be forward declared but they can be part of array declaration
+  // All other types don't need forward declaration
+  virtual void GenerateCodeForNullable(const NullableType* nullable);
+  virtual void GenerateCodeForArray(const Array* array);
+  virtual void GenerateCodeForMap(const Map* map);
+  virtual void GenerateCodeForStruct(const Struct* strct);
+ private:
+  // Fields
+  Namespace* ns_;
+};
+
+}  // namespace codegen
+
+#endif /* DECLARATION_GENERATOR_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/definition_generator.h b/tools/intergen/cppgen/include/cppgen/definition_generator.h
new file mode 100644
index 0000000000..21c379f8ea
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/definition_generator.h
@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef DEFINITION_GENERATOR_H_
+#define DEFINITION_GENERATOR_H_
+
+#include "model/builtin_type.h"
+#include "model/function.h"
+
+namespace codegen {
+class CppFile;
+class ModuleManager;
+class Namespace;
+class TypePreferences;
+
+/*
+ * Generates definition code of different entities that is to be
+ * put into implementation (.cc) file
+ */
+
+class DefinitionGenerator {
+ public:
+  DefinitionGenerator(const TypePreferences* preferences,
+                      ModuleManager* module_manager);
+  ~DefinitionGenerator();
+
+  void GenerateCodeForEnum(const Enum* enm);
+  void GenerateCodeForStruct(const Struct* strct);
+  void GenerateCodeForFunction(const Function& function);
+  void GenerateCodeForResponse(const Response& response);
+  void GenerateCodeForNotification(const Notification& notification);
+ private:
+  // Methods
+  void GenerateCodeForRequest(const Request& request, CppFile* source_file);
+private:
+  // Fields
+  const TypePreferences* preferences_;
+  ModuleManager* module_manager_;
+};
+
+}  // namespace codegen
+
+#endif /* DEFINITION_GENERATOR_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/enum_from_json_value_function.h b/tools/intergen/cppgen/include/cppgen/enum_from_json_value_function.h
new file mode 100644
index 0000000000..6195d4d247
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/enum_from_json_value_function.h
@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ENUM_FROM_STRING_FUNCTION_H_
+#define ENUM_FROM_STRING_FUNCTION_H_
+
+#include "cppgen/cpp_function.h"
+
+namespace codegen {
+class Enum;
+
+/*
+ * Generates function that translates given string value to JSON value.
+ * Enum constants are serialized/deserialized as strings having value from
+ * predefined set.
+ */
+class EnumFromJsonStringFunction : public CppFunction {
+ public:
+  EnumFromJsonStringFunction(const Enum* enm);
+  ~EnumFromJsonStringFunction();
+  virtual void DefineBody(std::ostream* os) const;
+ private:
+  const Enum* enm_;
+};
+
+}  // namespace codegen
+
+#endif /* ENUM_FROM_STRING_FUNCTION_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/enum_to_json_value_function.h b/tools/intergen/cppgen/include/cppgen/enum_to_json_value_function.h
new file mode 100644
index 0000000000..ce8e39be59
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/enum_to_json_value_function.h
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef ENUM_TO_JSON_VALUE_FUNCTION_H_
+#define ENUM_TO_JSON_VALUE_FUNCTION_H_
+
+#include "cppgen/cpp_function.h"
+
+namespace codegen {
+class Enum;
+
+/*
+ * Generates function that maps enum values to their string representations.
+ */
+class EnumToJsonValueFunction : public CppFunction {
+ public:
+  EnumToJsonValueFunction(const Enum* enm);
+  ~EnumToJsonValueFunction();
+  virtual void DefineBody(std::ostream* os) const;
+ private:
+  const Enum* enm_;
+};
+}  // namespace codegen
+
+#endif // ENUM_TO_JSON_VALUE_FUNCTION_H_
diff --git a/tools/intergen/cppgen/include/cppgen/function_id_method.h b/tools/intergen/cppgen/include/cppgen/function_id_method.h
new file mode 100644
index 0000000000..109d46791b
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/function_id_method.h
@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FUNCTION_ID_METHOD_H_
+#define FUNCTION_ID_METHOD_H_
+
+#include "cppgen/cpp_function.h"
+
+namespace codegen {
+class FunctionMessage;
+
+/*
+ * Generates function_id() virtual method that is to be declared/defined
+ * in every API message struct.
+ */
+class FunctionIdMethod : public CppFunction {
+ public:
+  FunctionIdMethod(const FunctionMessage* func);
+  ~FunctionIdMethod();
+ private:
+  // Methods
+  // CppFunction interface
+  virtual void DefineBody(std::ostream* os) const;
+ private:
+  // Fields
+  const FunctionMessage* func_;
+};
+
+/*
+ * Generates function_string_id() virtual method that is to be declared/defined
+ * in every API message struct.
+ */
+class FunctionStringIdMethod : public CppFunction {
+ public:
+  FunctionStringIdMethod(const FunctionMessage* func);
+  ~FunctionStringIdMethod();
+ private:
+  // Methods
+  // CppFunction interface
+  virtual void DefineBody(std::ostream* os) const;
+ private:
+  // Fields
+  const FunctionMessage* func_;
+};
+
+}  // namespace codegen
+
+#endif /* FUNCTION_ID_METHOD_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/generator_preferences.h b/tools/intergen/cppgen/include/cppgen/generator_preferences.h
new file mode 100644
index 0000000000..5278a24417
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/generator_preferences.h
@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef GENERATOR_PREFERENCES_H_
+#define GENERATOR_PREFERENCES_H_
+
+#include <set>
+#include <string>
+
+
+namespace codegen {
+
+struct TypePreferences {
+  int minimum_interger_size;
+  bool avoid_unsigned;
+  bool generate_json;
+  bool generate_dbus;
+  TypePreferences(int minimum_interger_size,
+                  bool avoid_unsigned,
+                  bool generate_json,
+                  bool generate_dbus);
+};
+
+struct Preferences {
+  Preferences(int minimum_interger_size,
+              bool avoid_unsigned,
+              bool generate_json,
+              bool generate_dbus,
+              const std::set<std::string>& requested_interfaces);
+  TypePreferences type_preferences;
+  std::set<std::string> requested_interfaces;
+};
+
+/*
+ * Text entity names to be used in generated code
+ */
+namespace func_names {
+extern const char* kAdditionalValidation;
+}
+
+}  // namespace codegen
+
+#endif /* GENERATOR_PREFERENCES_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/handler_interface.h b/tools/intergen/cppgen/include/cppgen/handler_interface.h
new file mode 100644
index 0000000000..a7b5a7c924
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/handler_interface.h
@@ -0,0 +1,85 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef HANDLER_INTERFACE_H
+#define HANDLER_INTERFACE_H
+
+#include "cppgen/cpp_class.h"
+
+#include "model/function.h"
+#include "utils/stl_utils.h"
+
+namespace codegen {
+class CppFile;
+class Namespace;
+
+/*
+ * Class is used to declare message handler interfaces for specific messages of
+ * given type for given interface
+ */
+class HandlerInterface: public CppClass {
+public:
+  // Methods
+  // Creates HandlerInterface object that is used to produce declaration of
+  // Handler interface. This interface defines handler methods for messages of
+  // given |type| defined in given rpc |interface|.
+  // Interface declaration requires message types to be forward-declared, these
+  // declarations are placed into given |header_file|.
+  HandlerInterface(FunctionMessage::MessageType type,
+                   const Interface* interface,
+                   CppFile* header_file);
+protected:
+  // Methods
+  // CppClass interface
+  virtual const MethodsList& methods();
+
+private:
+  // Types
+  typedef std::vector<const FunctionMessage*> FunctionMessages;
+private:
+  // Methods
+  // Collects all the messages that are to be handled and defines
+  // Handler methods for them. Also declares virtual destructor.
+  void CollectMethods();
+  // Helper method that actually generates handler functions
+  void AddFunctionMessageHandlers(const FunctionMessages& function_messages);
+private:
+  // Fields
+  FunctionMessage::MessageType type_;
+  const Interface* interface_;
+  CppFile* header_file_;
+  MethodsList methods_;
+  utils::StdContainerDeleter<MethodsList> methods_deleter_;
+};
+
+}  // namespace codegen
+
+#endif // HANDLER_INTERFACE_H
diff --git a/tools/intergen/cppgen/include/cppgen/is_valid_enum_function.h b/tools/intergen/cppgen/include/cppgen/is_valid_enum_function.h
new file mode 100644
index 0000000000..b62332e1e5
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/is_valid_enum_function.h
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef IS_VALID_ENUM_FUNCTION_H_
+#define IS_VALID_ENUM_FUNCTION_H_
+
+#include "cppgen/cpp_function.h"
+
+namespace codegen {
+class Enum;
+
+/*
+ * Generates function that tells whether the value of particular enum is
+ * valid one (belongs to enum values set).
+ */
+class IsValidEnumFunction : public CppFunction {
+ public:
+  IsValidEnumFunction(const Enum* enm);
+  ~IsValidEnumFunction();
+ private:
+  virtual void DefineBody(std::ostream* os) const;
+  const Enum* enm_;
+};
+
+}  // namespace codegen
+
+#endif /* IS_VALID_ENUM_FUNCTION_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/literal_generator.h b/tools/intergen/cppgen/include/cppgen/literal_generator.h
new file mode 100644
index 0000000000..c0818f1b1e
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/literal_generator.h
@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LITERAL_GENERATOR_H_
+#define LITERAL_GENERATOR_H_
+
+#include <string>
+
+#include "model/constant.h"
+
+namespace codegen {
+
+/*
+ * This class generates string literal representing value of a given constant
+ * depending on constant type.
+ */
+class LiteralGenerator : ConstantCodeGenerator {
+ public:
+  // Literal for |constant| is automatically generated on construction and
+  // can be accessd with result method
+  LiteralGenerator(const Constant& constant);
+  ~LiteralGenerator();
+  // Returns a string value representing given constant
+  std::string result() const;
+ private:
+  // ConstantCodeGenerator interface
+  virtual void GenerateCodeForBooleanConstant(const Boolean::Constant* boolean);
+  virtual void GenerateCodeForIntegerConstant(const Integer::Constant* integer);
+  virtual void GenerateCodeForFloatConstant(const Float::Constant* flt);
+  virtual void GenerateCodeForEnumConstant(const Enum::Constant* enm);
+ private:
+  std::string result_;
+};
+
+}  // namespace codegen
+
+#endif /* LITERAL_GENERATOR_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/message_factory_function.h b/tools/intergen/cppgen/include/cppgen/message_factory_function.h
new file mode 100644
index 0000000000..da63b4453a
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/message_factory_function.h
@@ -0,0 +1,76 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CODEGEN_MESSAGE_FACTORY_FUNCTION_H
+#define CODEGEN_MESSAGE_FACTORY_FUNCTION_H
+
+#include "cppgen/cpp_function.h"
+#include "model/function.h"
+
+namespace codegen {
+class Interface;
+
+/*
+ * This class is used to produce interface-specific,
+ * Message-type specific message factory function that is
+ * to be used to produce message from Json::Value object
+ */
+class MessageFactoryFunction: public CppFunction {
+ public:
+  enum SerializationType {
+    kJson,
+    kDbus
+  };
+
+  // Methods
+  // Creates function code generation object that produces
+  // declaration and definition of a factory for messages of type
+  // |factory_type| that belong to given |interface|
+  MessageFactoryFunction(const Interface* interface,
+                         SerializationType serialization_type,
+                         FunctionMessage::MessageType factory_type);
+ private:
+  // Types
+  typedef std::vector<const FunctionMessage*> MessageList;
+ private:
+  // Methods
+  virtual void DefineBody(std::ostream* os) const;
+  void DefineCases(std::ostream* os,
+                   const MessageList& functions) const;
+ private:
+  // Fields
+  const Interface* interface_;
+  FunctionMessage::MessageType factory_type_;
+};
+
+} // namespace codegen
+
+#endif // CODEGEN_MESSAGE_FACTORY_FUNCTION_H
diff --git a/tools/intergen/cppgen/include/cppgen/message_handle_with_method.h b/tools/intergen/cppgen/include/cppgen/message_handle_with_method.h
new file mode 100644
index 0000000000..6546a38cec
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/message_handle_with_method.h
@@ -0,0 +1,60 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CODEGEN_MESSAGE_HANDLE_WITH_METHOD_H
+#define CODEGEN_MESSAGE_HANDLE_WITH_METHOD_H
+
+#include "cppgen/cpp_function.h"
+
+namespace codegen {
+
+/*
+ * Generates declaration and definiton of HandleWith method
+ * that is required in every structure representing a message.
+ * This method takes Message Handler implementation and calls
+ * Appropriate function on it to handle current message.
+ * (see Visitor pattern).
+ */
+class MessageHandleWithMethod: public CppFunction {
+public:
+  MessageHandleWithMethod(const std::string& class_name);
+
+protected:
+  // CppFunction methods
+  virtual void DefineBody(std::ostream* os) const;
+private:
+  // Fields
+  std::string class_name_;
+};
+
+} // namespace codegen
+
+#endif // CODEGEN_MESSAGE_HANDLE_WITH_METHOD_H
diff --git a/tools/intergen/cppgen/include/cppgen/message_interface.h b/tools/intergen/cppgen/include/cppgen/message_interface.h
new file mode 100644
index 0000000000..8cc2d10b31
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/message_interface.h
@@ -0,0 +1,82 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CODEGEN_MESSAGE_INTERFACE_H
+#define CODEGEN_MESSAGE_INTERFACE_H
+
+#include "cppgen/cpp_class.h"
+#include "model/function.h"
+
+namespace codegen {
+class Interface;
+class MessageInterface;
+
+/*
+ * Helper class that is used to produce code for
+ * interface() method for interface-specific.
+ * message base class.
+ */
+class InterfaceStringIdMethod: public CppClass::Method {
+ public:
+  InterfaceStringIdMethod(
+      const MessageInterface* message_interface,
+      const Interface* interface);
+ protected:
+  // CppFunction interface
+  void DefineBody(std::ostream* os) const;
+ private:
+  const Interface* interface_;
+};
+
+/*
+ * Helper class that is used to produce declaration and
+ * definition of interface-specific message base class
+ * for messages of given type
+ */
+class MessageInterface: public CppClass {
+ public:
+  MessageInterface(const Interface* interface,
+                   FunctionMessage::MessageType message_type);
+ private:
+  // Methods
+  // CppClass interface
+  virtual const MethodsList& methods();
+ private:
+  // Fields
+  Method constructor_;
+  Method handle_with_method_;
+  InterfaceStringIdMethod interface_string_id_method_;
+  std::vector<const Method*> methods_;
+};
+
+} // namespace codegen
+
+#endif // CODEGEN_MESSAGE_INTERFACE_H
diff --git a/tools/intergen/cppgen/include/cppgen/module_manager.h b/tools/intergen/cppgen/include/cppgen/module_manager.h
new file mode 100644
index 0000000000..6ec13c9140
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/module_manager.h
@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MODULE_MANAGER_H_
+#define MODULE_MANAGER_H_
+
+#include <vector>
+
+#include "cppgen/cpp_file.h"
+#include "model/composite_type.h"
+#include "model/function.h"
+
+namespace codegen {
+class Namespace;
+class TypePreferences;
+
+/*
+ * Manages all the source files generated for given interface.
+ * Every interface is a separate module.
+ * Also manages namespaces used to store generated code.
+ */
+class ModuleManager {
+ public:
+  ModuleManager(const std::string& name, const TypePreferences& prefs);
+  ~ModuleManager();
+
+  /*
+   * Methods that are used to find header file for entity that is being
+   * generated
+   */
+  CppFile& HeaderForInterface();
+  CppFile& HeaderForEnum(const Enum& enm);
+  CppFile& HeaderForStruct(const Struct& strct);
+  CppFile& HeaderForTypedef(const Typedef& tdef);
+  CppFile& HeaderForFunction(const Function& function);
+  CppFile& HeaderForResponse(const Response& request);
+  CppFile& HeaderForNotification(const Notification& notification);
+
+  /*
+   * Methods that are used to find implementation file for entity that
+   * is being generated
+   */
+  CppFile& SourceForInterface();
+  CppFile& SourceForEnum(const Enum& enm);
+  CppFile& SourceForStruct(const Struct& strct);
+  CppFile& SourceForFunction(const Function& function);
+  CppFile& SourceForResponse(const Response& request);
+  CppFile& SourceForNotification(const Notification& notification);
+  CppFile& SourceForValidator();
+
+  /*
+   * Creates and writes all the generated code to appropriate files
+   */
+  bool Write();
+private:
+  std::string module_name_;
+  CppFile enums_header_;
+  CppFile enums_source_;
+  CppFile structs_header_;
+  CppFile structs_source_;
+  CppFile functions_header_;
+  CppFile functions_source_;
+  CppFile interface_header_;
+  CppFile interface_source_;
+  CppFile additional_validation_source_;
+};
+
+}  // namespace codegen
+
+#endif /* MODULE_MANAGER_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/namespace.h b/tools/intergen/cppgen/include/cppgen/namespace.h
new file mode 100644
index 0000000000..29207313af
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/namespace.h
@@ -0,0 +1,152 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef NAMESPACE_H_
+#define NAMESPACE_H_
+
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+
+namespace codegen {
+
+/*
+ * Represents single C++ namespace where all the declarations and definitions live.
+ * Automatically generates all the namespace scope declarations,
+ * type forward declarations and 'using' type import directives.
+ */
+class Namespace {
+ public:
+  // Types
+  class ForwardDeclaration;
+  class ImportedName;
+ public:
+  // Methods
+  // Constructs unnamed (anonymous) namespace
+  Namespace();
+  // Constructs named namespace
+  explicit Namespace(const std::string& name);
+  Namespace(const Namespace& that);
+  ~Namespace();
+  // Creates (if absent) nested namespace with |name|
+  // and provides access to it.
+  Namespace& nested(const std::string& name);
+  // Namespace ostream, used to write actual code into namespace
+  std::ostream& os();
+  // Add type described with |type_name| forward declaration
+  // to the top of namespace block
+  void ForwardDeclare(const ForwardDeclaration& type_name);
+  // Add import directive for thing described with |name| to the top
+  // of the current namespace block.
+  void ImportName(const ImportedName& name);
+  // Write this namespace and all it's nested namespaces to the given ostream.
+  void Write(std::ostream* os);
+  // Name (relative) of this namespace
+  const std::string& name() const;
+
+ private:
+  // Methods
+  // Tells whether this namespace or any of it's nested namspaces
+  // has non-empty list of forward declarations or using directives
+  bool HasForwardDeclarations();
+  // Tells whether this namespace or any of it's nested namspaces
+  // has any contents
+  bool HasContents();
+  // Output nested namespaces's list of forward declarations and
+  // 'using' import directives followed by this namespace's list of
+  // forward declarations and import directives
+  void WriteForwardDeclarations(std::ostream* os);
+  // Writes all nested namespaces' contents followed by this namespace contents
+  void WriteContents(std::ostream* os);
+  // Writes namespace begin declaratoin
+  void BeginNamespace(std::ostream* os);
+  // Writes namespace end declaration
+  void EndNamespace(std::ostream* os);
+ private:
+  // Types
+  bool global_;
+  std::string name_;
+  std::set<ImportedName> imported_names_;
+  std::set<ForwardDeclaration> forward_declarations_;
+  std::map<std::string, Namespace> nested_;
+  std::stringstream contents_;
+};
+
+/*
+ * Represents namespace forward declaration item
+ */
+class Namespace::ForwardDeclaration {
+ public:
+   // Only classes and structs can be forward-declared
+  enum Type {
+    kClass,
+    kStruct
+  };
+ public:
+  // Constructs forward declaration item of |type| and |name|
+  ForwardDeclaration(Type type, const std::string& name);
+  // Forward declarations are sorted in alphabetical order of their names
+  bool operator<(const ForwardDeclaration& that) const;
+  const std::string& name() const;
+  Type type() const;
+
+ private:
+  Type type_;
+  std::string name_;
+
+};
+
+/*
+ * Represents single namespace import item
+ */
+class Namespace::ImportedName {
+ public:
+  // Imports a |name| into current namespace. |name| must specify fully
+  // qualified name including namespace name from which it is imported.
+  // If |single_name| is false, the whole namespace is imported
+  ImportedName(std::string name, bool single_name);
+  // Imports are sorted by their type (single name or whole namespace)
+  // then by name alphabetically
+  bool operator<(const ImportedName& that) const;
+  const std::string& name() const;
+  bool is_single_name() const;
+
+ private:
+  bool single_name_;
+  std::string name_;
+};
+
+
+}  // namespace codegen
+
+#endif /* NAMESPACE_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/naming_convention.h b/tools/intergen/cppgen/include/cppgen/naming_convention.h
new file mode 100644
index 0000000000..3aef239ea2
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/naming_convention.h
@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef NAMING_CONVENTION_H_
+#define NAMING_CONVENTION_H_
+
+#include <string>
+#include <vector>
+
+namespace codegen {
+class Interface;
+
+/*
+ * Helper class that constructs word list from a sentence or
+ * single-word identifier written in UPPER_CASE, lower_case,
+ * camelCase or UpperCamelCase and provides conversion between these
+ * identifier naming conventions.
+ */
+class WordList {
+ public:
+  WordList();
+  ~WordList();
+  // Guess identifier naming convention and construct WordList from it
+  static WordList FromUnknown(const std::string& identifier);
+  // Split identifier as UPPER_CASE_ONE, also used to split
+  // lower_case_identifiers
+  static WordList FromUnderscoreSeparated(const std::string& identifier);
+  // Split identifier as camelCase identifier or upperCamelCase
+  static WordList FromCamelCase(const std::string& identifier);
+  // Concatenates |that| word list to this one producing single word list
+  WordList& operator+=(const WordList& that);
+  // Converts word list to one of the supported identifier naming conventions
+  std::string ToUpperCase() const;
+  std::string ToCamelCase() const;
+  std::string ToLowerCase() const;
+  std::string ToUpperCamelCase() const;
+  // Produces lower-case abbreviaton of a given WordList
+  std::string Abbreviate() const;
+
+ private:
+  // Normalizes word list: all words are converted to lower case,
+  // spaces are trimmed
+  void Normalize();
+  std::vector<std::string> words_;
+};
+
+// Capitalizes given string
+std::string Capitalize(const std::string& str);
+
+// Translate interface name to lower case
+std::string LowercaseIntefaceName(const Interface& interface);
+
+std::string UpperCamelCaseInterfaceName(const Interface& interface);
+
+// Produces namespace name for |interface|.
+// Currently it just lower_case_interface_name
+std::string InterfaceNamespaceName(const Interface& interface);
+
+// Produces new name (generally for struct fields) if it
+// conflicts with known keywords
+std::string AvoidKeywords(const std::string& name);
+
+}  // namespace codegen
+
+#endif /* NAMING_CONVENTION_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/struct_type_constructor.h b/tools/intergen/cppgen/include/cppgen/struct_type_constructor.h
new file mode 100644
index 0000000000..a9f5ffec1d
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/struct_type_constructor.h
@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STRUCT_TYPE_CONSTRUCTOR_H_
+#define STRUCT_TYPE_CONSTRUCTOR_H_
+
+#include "cppgen/cpp_function.h"
+
+namespace codegen {
+class Struct;
+class TypePreferences;
+
+/*
+ * Generates code of struct default constructor without parameters
+ */
+class StructTypeDefaultConstructor : public CppStructConstructor {
+ public:
+  StructTypeDefaultConstructor(const Struct* strct,
+                               const std::string& base_class_name);
+  ~StructTypeDefaultConstructor();
+ private:
+};
+
+/*
+ * Generates code of struct mandatory constructor.
+ * Mandatory constructor is a constructor that requires values for all
+ * mandatory fields to be passed as parameters.
+ */
+class StructTypeMandatoryConstructor : public CppStructConstructor {
+ public:
+  StructTypeMandatoryConstructor(const TypePreferences* preferences,
+                                 const Struct* strct,
+                                 const std::string& base_class_name);
+  ~StructTypeMandatoryConstructor();
+ private:
+  // CppFunction pure virtual methods implementation
+  virtual void DefineBody(std::ostream* os) const;
+};
+
+}  // namespace codegen
+
+#endif /* STRUCT_TYPE_CONSTRUCTOR_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/struct_type_dbus_serializer.h b/tools/intergen/cppgen/include/cppgen/struct_type_dbus_serializer.h
new file mode 100644
index 0000000000..64872f3265
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/struct_type_dbus_serializer.h
@@ -0,0 +1,88 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CPPGEN_STRUCT_TYPE_DBUS_SERIALIZER_H
+#define CPPGEN_STRUCT_TYPE_DBUS_SERIALIZER_H
+
+#include "cppgen/cpp_function.h"
+
+namespace codegen {
+class Interface;
+class Struct;
+class TypePreferences;
+
+class StructTypeDbusMessageSignatureMethod: public CppFunction {
+ public:
+  StructTypeDbusMessageSignatureMethod(const TypePreferences* preferences,
+                                       const Struct* strct,
+                                       bool substructure);
+  ~StructTypeDbusMessageSignatureMethod();
+ private:
+  // CppFunction interface
+  void DefineBody(std::ostream* os) const;
+ private:
+  const TypePreferences* preferences_;
+  bool substructure_;
+  const Struct* strct_;
+};
+
+class StructTypeFromDbusReaderConstructor : public CppStructConstructor {
+ public:
+  StructTypeFromDbusReaderConstructor(const TypePreferences* preferences,
+                                      const Struct* strct,
+                                      bool substructure,
+                                      const std::string& base_class_name);
+  ~StructTypeFromDbusReaderConstructor();
+ private:
+  // CppFunction interface
+  void DefineBody(std::ostream* os) const;
+ private:
+  const TypePreferences* preferences_;
+  bool substructure_;
+  const Struct* strct_;
+};
+
+class StructTypeToDbusWriterMethod : public CppFunction {
+ public:
+  StructTypeToDbusWriterMethod(const Struct* strct,
+                               bool substructure);
+  ~StructTypeToDbusWriterMethod();
+ private:
+  // CppFunction interface
+  void DefineBody(std::ostream* os) const;
+ private:
+  bool substructure_;
+  const Struct* strct_;
+};
+
+} // namespace codegen
+
+#endif // CPPGEN_STRUCT_TYPE_DBUS_SERIALIZER_H
diff --git a/tools/intergen/cppgen/include/cppgen/struct_type_from_json_method.h b/tools/intergen/cppgen/include/cppgen/struct_type_from_json_method.h
new file mode 100644
index 0000000000..270fe30248
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/struct_type_from_json_method.h
@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STRUCT_TYPE_FROM_JSON_METHOD_H_
+#define STRUCT_TYPE_FROM_JSON_METHOD_H_
+
+#include "cppgen/cpp_function.h"
+
+namespace codegen {
+class Struct;
+
+/*
+ * Generates struct constructor that assigns fields values taking them from
+ * parsed json tree
+ */
+class StructTypeFromJsonConstructor : public CppStructConstructor {
+ public:
+  StructTypeFromJsonConstructor(const Struct* strct,
+                                const std::string& base_class_name);
+  ~StructTypeFromJsonConstructor();
+ private:
+  // CppFunction pure virtual methods implementation
+  virtual void DefineBody(std::ostream* os) const;
+ private:
+  // Fields
+  const Struct* strct_;
+};
+
+/*
+ * Generates struct method that serializes the struct fields into json tree.
+ */
+class StructTypeToJsonMethod : public CppFunction {
+ public:
+  StructTypeToJsonMethod(const Struct* strct);
+  ~StructTypeToJsonMethod();
+ private:
+  // CppFunction pure virtual methods implementation
+  virtual void DefineBody(std::ostream* os) const;
+ private:
+  const Struct* strct_;
+};
+}  // namespace codegen
+
+#endif /* STRUCT_TYPE_FROM_JSON_METHOD_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/struct_type_is_initialized_method.h b/tools/intergen/cppgen/include/cppgen/struct_type_is_initialized_method.h
new file mode 100644
index 0000000000..48e2d761f0
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/struct_type_is_initialized_method.h
@@ -0,0 +1,76 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STRUCT_TYPE_IS_INITIALIZED_METHOD_H_
+#define STRUCT_TYPE_IS_INITIALIZED_METHOD_H_
+
+#include "cppgen/cpp_function.h"
+
+namespace codegen {
+class Struct;
+
+/*
+ * Generates struct method that is used to tell whether at least
+ * one of struct fields have been initialized
+ */
+class StructTypeIsInitializedMethod : public CppFunction {
+ public:
+  StructTypeIsInitializedMethod(const Struct* strct);
+  ~StructTypeIsInitializedMethod();
+ private:
+  // CppFunction pure virtual methods implementation
+  virtual void DefineBody(std::ostream* os) const;
+ private:
+  // Fields
+  const Struct* strct_;
+};
+
+/**
+ * @brief Generates bool empty() method for struct types
+ * this method has no is_ prefix to support stl style
+ * that is dictated by maps and arrays
+ */
+class StructTypeStructEmptyMethod : public CppFunction {
+ public:
+  StructTypeStructEmptyMethod(const Struct* strct);
+  ~StructTypeStructEmptyMethod();
+ private:
+  // CppFunction pure virtual methods implementation
+  virtual void DefineBody(std::ostream* os) const;
+ private:
+  // Fields
+  const Struct* strct_;
+};
+
+}  // namespace codegen
+
+#endif /* STRUCT_TYPE_IS_INITIALIZED_METHOD_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/struct_type_is_valid_method.h b/tools/intergen/cppgen/include/cppgen/struct_type_is_valid_method.h
new file mode 100644
index 0000000000..284f7ba45e
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/struct_type_is_valid_method.h
@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STRUCT_TYPE_IS_VALID_METHOD_H_
+#define STRUCT_TYPE_IS_VALID_METHOD_H_
+
+#include "cppgen/cpp_function.h"
+
+namespace codegen {
+class Struct;
+
+/*
+ * Generates a method that is used to tell whether all the
+ * struct fields have valid values
+ */
+class StructTypeIsValidMethod : public CppFunction {
+ public:
+  StructTypeIsValidMethod(const Struct* strct);
+  ~StructTypeIsValidMethod();
+ private:
+  // CppFunction pure virtual methods implementation
+  virtual void DefineBody(std::ostream* os) const;
+  const Struct* strct_;
+};
+
+/*
+ * Generates empty struct method stub that is to be edited by
+ * generated code user to implement additional validation that could not be
+ * defined in API XML specification
+ */
+class StructTypeAdditionalValidationMethod : public CppFunction {
+ public:
+  StructTypeAdditionalValidationMethod(const Struct* strct);
+  ~StructTypeAdditionalValidationMethod();
+ private:
+  // CppFunction pure virtual methods implementation
+  virtual void DefineBody(std::ostream* os) const;
+  const Struct* strct_;
+};
+
+}  // namespace codegen
+
+#endif /* STRUCT_TYPE_IS_VALID_METHOD_H_ */
diff --git a/tools/intergen/cppgen/include/cppgen/struct_type_report_erros_method.h b/tools/intergen/cppgen/include/cppgen/struct_type_report_erros_method.h
new file mode 100644
index 0000000000..3dd851ccc4
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/struct_type_report_erros_method.h
@@ -0,0 +1,53 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CPPGEN_STRUCT_TYPE_REPORT_ERROS_METHOD_H
+#define CPPGEN_STRUCT_TYPE_REPORT_ERROS_METHOD_H
+
+#include "cppgen/cpp_function.h"
+
+namespace codegen {
+class Struct;
+
+class StructTypeReportErrosMethod: public CppFunction {
+ public:
+  StructTypeReportErrosMethod(const Struct* strct);
+ private:
+  // CppFunction pure virtual methods implementation
+  virtual void DefineBody(std::ostream* os) const;
+ private:
+  // Fields
+  const Struct* strct_;
+};
+
+} // namespace codegen
+
+#endif // CPPGEN_STRUCT_TYPE_REPORT_ERROS_METHOD_H
diff --git a/tools/intergen/cppgen/include/cppgen/type_name_code_generator.h b/tools/intergen/cppgen/include/cppgen/type_name_code_generator.h
new file mode 100644
index 0000000000..5fd75760aa
--- /dev/null
+++ b/tools/intergen/cppgen/include/cppgen/type_name_code_generator.h
@@ -0,0 +1,153 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TYPE_NAME_CODE_GENERATOR_H_
+#define TYPE_NAME_CODE_GENERATOR_H_
+
+#include "model/type.h"
+
+#include <sstream>
+
+namespace codegen {
+class Interface;
+class Type;
+class TypePreferences;
+
+/*
+ * These visitor classes are used to generate C++ type name for given
+ * model types.
+ */
+
+/*
+ * Generates primitive or STL type name for given model type.
+ * Used to generate struct constructor parameters.
+ */
+class TypeNameGenerator: public TypeCodeGenerator {
+ public:
+  // Generates primitive type name for |type|.
+  // |interface| specifies the interface where code is currently
+  // being generated. Depending on that relative or fully qualified
+  // type names are generated.
+  // Generates type name can be accessed with result() method.
+  TypeNameGenerator(const Interface* interface,
+                    const TypePreferences* preferences,
+                    const Type* type);
+  ~TypeNameGenerator();
+  // Generated type name
+  std::string result() const;
+ private:
+  virtual void GenerateCodeForBoolean(const Boolean* boolean);
+  virtual void GenerateCodeForInteger(const Integer* integer);
+  virtual void GenerateCodeForFloat(const Float* flt);
+  virtual void GenerateCodeForString(const String* string);
+  virtual void GenerateCodeForEnum(const Enum* enm);
+  virtual void GenerateCodeForArray(const Array* array);
+  virtual void GenerateCodeForMap(const Map* map);
+  virtual void GenerateCodeForNullable(const NullableType* nullable);
+  virtual void GenerateCodeForStruct(const Struct* strct);
+  virtual void GenerateCodeForTypedef(const Typedef* tdef);
+
+ private:
+  const Interface* interface_;
+  const TypePreferences* preferences_;
+  bool prefer_reference_type_;
+  std::stringstream os_;
+};
+
+/*
+ * Generates type name from rpc_base template library.
+ * Used to define struct fields.
+ */
+class RpcTypeNameGenerator: public TypeCodeGenerator {
+ public:
+  // Types
+ public:
+  // Generates name of type that is able to validate given primitive value
+  // |interface| specifies the interface where code is currently
+  // being generated. Depending on that relative or fully qualified
+  // type names are generated.
+  // Depending on |availability| option optionally wraps declaration into
+  // Mandatory or Optional template
+  RpcTypeNameGenerator(const Interface* interface,
+                       const TypePreferences* preferences,
+                       const Type* type,
+                       bool optional);
+  ~RpcTypeNameGenerator();
+  // Generated type name
+  std::string result() const;
+ private:
+  // TypeCodeGenerator methods
+  virtual void GenerateCodeForBoolean(const Boolean* boolean);
+  virtual void GenerateCodeForInteger(const Integer* integer);
+  virtual void GenerateCodeForFloat(const Float* flt);
+  virtual void GenerateCodeForString(const String* string);
+  virtual void GenerateCodeForEnum(const Enum* enm);
+  virtual void GenerateCodeForArray(const Array* array);
+  virtual void GenerateCodeForMap(const Map* map);
+  virtual void GenerateCodeForNullable(const NullableType* nullable);
+  virtual void GenerateCodeForStruct(const Struct* strct);
+  virtual void GenerateCodeForTypedef(const Typedef* tdef);
+ private:
+  const Interface* interface_;
+  const TypePreferences* preferences_;
+  std::stringstream os_;
+};
+
+/*
+ * Not a real code generator but helper class that is used to collect
+ * properties of composite types
+ */
+class TypeProperties: public TypeCodeGenerator {
+public:
+  TypeProperties(const Type* type);
+  // Tells whether type is map, array or typedef alias of map or array
+  bool is_container() const;
+
+private:
+  // TypeCodeGenerator methods
+  virtual void GenerateCodeForBoolean(const Boolean* boolean);
+  virtual void GenerateCodeForInteger(const Integer* integer);
+  virtual void GenerateCodeForFloat(const Float* flt);
+  virtual void GenerateCodeForString(const String* string);
+  virtual void GenerateCodeForEnum(const Enum* enm);
+  virtual void GenerateCodeForArray(const Array* array);
+  virtual void GenerateCodeForMap(const Map* map);
+  virtual void GenerateCodeForNullable(const NullableType* nullable);
+  virtual void GenerateCodeForStruct(const Struct* strct);
+  virtual void GenerateCodeForTypedef(const Typedef* tdef);
+private:
+  bool container_;
+};
+
+}  // namespace codegen
+
+#endif /* TYPE_NAME_CODE_GENERATOR_H_ */
diff --git a/tools/intergen/cppgen/src/cppgen/comment.cc b/tools/intergen/cppgen/src/cppgen/comment.cc
new file mode 100644
index 0000000000..f6bf2ef93f
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/comment.cc
@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/comment.h"
+
+#include <iostream>
+#include <ostream>
+#include <sstream>
+
+#include "utils/string_utils.h"
+
+using std::endl;
+using std::string;
+using std::stringstream;
+
+namespace codegen {
+
+Comment::Comment(const Description& description) {
+  for (Description::const_iterator i = description.begin();
+      i != description.end(); ++i) {
+    stringstream str(*i);
+    string line;
+    while (std::getline(str, line)) {
+      line = trim(line);
+      if (!line.empty()) {
+        description_.push_back(line);
+      }
+    }
+  }
+}
+
+Comment::Comment(const std::string& text) {
+  description_.push_back(text);
+}
+
+Comment::~Comment() {
+}
+
+}  // namespace codegen
+
+std::ostream& codegen::operator <<(std::ostream& os, const Comment& comment) {
+  if (!comment.description_.empty()) {
+    if (comment.description_.size() == 1) {
+      os << "// " << comment.description_.front();
+    } else {
+      os << "/* ";
+      for (Description::const_iterator i = comment.description_.begin(), end =
+          comment.description_.end(); i != end; ++i) {
+        os << *i << " ";
+      }
+      os << "*/";
+    }
+  }
+  return os;
+}
diff --git a/tools/intergen/cppgen/src/cppgen/cpp_api_code_generator.cc b/tools/intergen/cppgen/src/cppgen/cpp_api_code_generator.cc
new file mode 100644
index 0000000000..d8c277fa71
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/cpp_api_code_generator.cc
@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/cpp_api_code_generator.h"
+
+#include <iostream>
+
+#include "cppgen/cpp_file.h"
+#include "cppgen/cpp_interface_code_generator.h"
+#include "cppgen/module_manager.h"
+#include "cppgen/naming_convention.h"
+#include "model/api.h"
+#include "model/interface.h"
+
+using std::cout;
+
+namespace codegen {
+
+CppApiCodeGenerator::CppApiCodeGenerator(const API* api)
+    : api_(api) {
+}
+
+CppApiCodeGenerator::~CppApiCodeGenerator() {
+}
+
+std::set<std::string> codegen::CppApiCodeGenerator::Generate(
+    const codegen::Preferences& preferences) {
+  std::set<std::string> problematic_interafces = preferences.requested_interfaces;
+  const std::vector<Interface*>& interfaces = api_->interfaces();
+  for (std::vector<Interface*>::const_iterator i = interfaces.begin(), end =
+      interfaces.end(); i != end; ++i) {
+    const Interface* intf = *i;
+    std::string interface_name = LowercaseIntefaceName(*intf);
+    if (!preferences.requested_interfaces.empty()) {
+      // If interface list provided, skip unneeded interfaces
+      if (preferences.requested_interfaces.count(interface_name) == 0) {
+        continue;
+      }
+    }
+
+    if (GenerateInterface(intf, preferences.type_preferences)) {
+      // Mark this interface as sucessfully generated
+      problematic_interafces.erase(interface_name);
+    }
+  }
+  return problematic_interafces;
+}
+
+bool CppApiCodeGenerator::GenerateInterface(const Interface* interface,
+                                            const TypePreferences& preferences) {
+  ModuleManager mgr(LowercaseIntefaceName(*interface), preferences);
+  CppInterfaceCodeGenerator interface_generator(interface,
+                                                &preferences,
+                                                &mgr);
+  interface_generator.GenerateCode();
+  return mgr.Write();
+}
+
+}  // namespace codegen
+
diff --git a/tools/intergen/cppgen/src/cppgen/cpp_class.cc b/tools/intergen/cppgen/src/cppgen/cpp_class.cc
new file mode 100644
index 0000000000..d2fd9fa4f2
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/cpp_class.cc
@@ -0,0 +1,194 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/cpp_class.h"
+
+#include <algorithm>
+
+#include "cppgen/cpp_function.h"
+#include "utils/safeformat.h"
+#include "utils/string_utils.h"
+
+using std::endl;
+using std::ostream;
+using std::string;
+using typesafe_format::strmfmt;
+
+
+namespace codegen {
+
+namespace {
+
+// Produces C++ literals for given access specifier
+const char* AccessSpecName(CppClass::AccessSpec access) {
+  switch (access) {
+    case CppClass::kPublic:
+      return "public";
+    case CppClass::kPrivate:
+      return "private";
+    case CppClass::kProtected:
+      return "protected";
+    default:
+      assert(!"Invalid access specifier");
+      return "";
+  }
+}
+
+/*
+ * Helper class that automatically declares section inside
+ * C++ class declaration and manages indentation
+ */
+class Section {
+  struct SectionDeclarer {
+    SectionDeclarer(const char* name, ostream* os) {
+      *os << " " << name << ":" << endl;
+    }
+  };
+ public:
+  Section(const char* name, ostream* os)
+      : declarer_(name, os),
+        indent_(*os) {
+  }
+ private:
+  SectionDeclarer declarer_;
+  Indent indent_;
+};
+
+void DeclareMethods(const CppClass::MethodsList& method_list,
+                    ostream* os, bool in_class) {
+  for (CppClass::MethodsList::const_iterator i = method_list.begin(),
+       end = method_list.end(); i != end; ++i) {
+    const CppClass::Method* method = *i;
+    method->Declare(os, in_class);
+  }
+}
+
+void DefineMethods(const CppClass::MethodsList& method_list,
+                    ostream* os) {
+  for (CppClass::MethodsList::const_iterator i = method_list.begin(),
+       end = method_list.end(); i != end; ++i) {
+    const CppClass::Method* method = *i;
+    method->Define(os, false);
+  }
+}
+
+}  // namespace
+
+CppClass::CppClass(const string& name)
+    : name_(name) {
+}
+
+CppClass::~CppClass() {
+}
+
+void CppClass::Add(const CppClass::Superclass& superclass) {
+  superclasses_.push_back(superclass);
+}
+
+void CppClass::Declare(ostream* os) {
+  strmfmt(*os, "class {0}{1} ",
+          name_, superclasses_.empty() ? "" : ":");
+  for (SuperclassList::const_iterator i = superclasses_.begin(),
+       end = superclasses_.end(); i != end; ++i) {
+    strmfmt(*os, "{0} {1}",
+            AccessSpecName(i->inheritance_type()),
+            i->name());
+  }
+  *os << " {\n";
+  MethodsList public_methods = functions(kPublic);
+  if (!public_methods.empty()) {
+    Section pub("public", os);
+    DeclareMethods(public_methods, os, true);
+  }
+  MethodsList protected_methods = functions(kProtected);
+  if (!protected_methods.empty()) {
+    Section prot("protected", os);
+    DeclareMethods(protected_methods, os, true);
+  }
+  MethodsList private_methods = functions(kPrivate);
+  if (!private_methods.empty()) {
+    Section priv("private", os);
+    DeclareMethods(private_methods, os, true);
+  }
+  *os << "};\n";
+}
+
+void CppClass::Define(std::ostream* os) {
+  DefineMethods(functions(kPublic), os);
+  DefineMethods(functions(kProtected), os);
+  DefineMethods(functions(kPrivate), os);
+}
+
+std::string CppClass::name() const {
+  return name_;
+}
+
+CppClass::MethodsList CppClass::functions(
+    CppClass::AccessSpec access_spec) {
+  std::vector<const CppClass::Method*> specific_methods;
+  const std::vector<const CppClass::Method*>& all_methods = methods();
+  for (MethodsList::const_iterator i = all_methods.begin(),
+       end = all_methods.end(); i != end; ++i) {
+    const Method* method = *i;
+    if (method->access_specifier() == access_spec) {
+      specific_methods.push_back(method);
+    }
+  }
+  return specific_methods;
+}
+
+CppClass::Method::Method(const CppClass* cls, AccessSpec access,
+                         const std::string& name,
+                         const std::string& return_type_name,
+                         int qualifiers)
+    : CppFunction(cls->name(), name, return_type_name, qualifiers),
+      access_specifier_(access){
+}
+
+CppClass::AccessSpec CppClass::Method::access_specifier() const {
+  return access_specifier_;
+}
+
+CppClass::Superclass::Superclass(const std::string& name,
+                                 AccessSpec inheritance_type)
+    : name_(name),
+      inheritance_type_(inheritance_type) {
+
+}
+CppClass::AccessSpec CppClass::Superclass::inheritance_type() const {
+  return inheritance_type_;
+}
+
+const std::string& CppClass::Superclass::name() const {
+  return name_;
+}
+
+} // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/cpp_file.cc b/tools/intergen/cppgen/src/cppgen/cpp_file.cc
new file mode 100644
index 0000000000..b346e16df7
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/cpp_file.cc
@@ -0,0 +1,225 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/cpp_file.h"
+
+#include <cassert>
+#include <ostream>
+
+#include "cppgen/naming_convention.h"
+#include "model/interface.h"
+#include "model/type.h"
+#include "utils/safeformat.h"
+
+using std::ostream;
+using std::endl;
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+namespace {
+const char* kAutoGeneratedComment = "// This file is generated, do not edit";
+
+// This class is used to find and automatically include appropriate
+// header file where given type is defined
+class IncludeTypeHelper: public TypeCodeGenerator {
+ public:
+  // Constructs include helper and immediately includes
+  // appropriate header file for passed |type|
+  // into |cpp_file|
+  IncludeTypeHelper(CppFile* cpp_file, const Type* type);
+ private:
+  // Methods
+  // Returns interface name where given |type| is defined
+  // Accepts Enum, Struct or Typedef types.
+  template<class T>
+  std::string GetTypeInterfaceName(const T* type);
+  // TypeCodeGenerator interface
+  virtual void GenerateCodeForArray(const Array* array);
+  virtual void GenerateCodeForMap(const Map* map);
+  virtual void GenerateCodeForEnum(const Enum* enm);
+  virtual void GenerateCodeForNullable(const NullableType* nullable);
+  virtual void GenerateCodeForStruct(const Struct* strct);
+  virtual void GenerateCodeForTypedef(const Typedef* tdef);
+ private:
+  // Fields
+  CppFile* cpp_file_;
+};
+
+IncludeTypeHelper::IncludeTypeHelper(CppFile* cpp_file, const Type* type)
+  : cpp_file_(cpp_file) {
+  type->Apply(this);
+}
+
+template<class T>
+std::string IncludeTypeHelper::GetTypeInterfaceName(const T* type) {
+  return LowercaseIntefaceName(type->interface());
+}
+
+void IncludeTypeHelper::GenerateCodeForArray(const Array* array) {
+  array->type()->Apply(this);
+}
+
+void IncludeTypeHelper::GenerateCodeForMap(const Map* map) {
+  map->type()->Apply(this);
+}
+
+void IncludeTypeHelper::GenerateCodeForEnum(const Enum *enm) {
+  cpp_file_->Include(CppFile::Header(
+                       GetTypeInterfaceName(enm) + "/enums.h",
+                       true));
+}
+
+void IncludeTypeHelper::GenerateCodeForNullable(const NullableType* nullable) {
+  nullable->type()->Apply(this);
+}
+
+void IncludeTypeHelper::GenerateCodeForStruct(const Struct* strct) {
+  cpp_file_->Include(CppFile::Header(
+                       GetTypeInterfaceName(strct) + "/types.h",
+                       true));
+}
+
+void IncludeTypeHelper::GenerateCodeForTypedef(const Typedef* tdef) {
+  cpp_file_->Include(CppFile::Header(
+                       GetTypeInterfaceName(tdef) + "/types.h",
+                       true));
+}
+
+}
+
+CppFile::CppFile(const std::string& file_name, const std::string& module_name,
+                 bool write_guards)
+    : write_guards_(write_guards),
+      file_name_(file_name),
+      module_name_(module_name) {
+}
+
+CppFile::~CppFile() {
+}
+
+const std::string& CppFile::file_name() const {
+  return file_name_;
+}
+
+void CppFile::Include(const Header& header) {
+  headers_.insert(header);
+}
+
+void CppFile::IncludeType(const Type& type) {
+  IncludeTypeHelper(this, &type);
+}
+
+void CppFile::Write(std::ostream* os) {
+  std::string guard_name =
+      WordList::FromUnknown(module_name_+"_"+file_name_).ToUpperCase() + "_";
+  *os << kAutoGeneratedComment << endl;
+  if (write_guards_) {
+    *os << "#ifndef " << guard_name << endl;
+    *os << "#define " << guard_name << endl;
+  }
+  for (std::set<Header>::iterator i = headers_.begin(), end = headers_.end();
+      i != end; ++i) {
+    if (i->is_local()) {
+      strmfmt(*os, "#include \"{0}\"", i->name()) << endl;
+    } else {
+      strmfmt(*os, "#include <{0}>", i->name()) << endl;
+    }
+  }
+  global_namespace_.Write(os);
+  if (write_guards_) {
+    *os << "#endif  // " << guard_name << endl;
+  }
+}
+
+bool CppFile::Header::is_local() const {
+  return local_;
+}
+
+const std::string& CppFile::Header::name() const {
+  return name_;
+}
+
+CppFile::Header::Header(const std::string& name, bool local)
+    : name_(name),
+      local_(local) {
+}
+
+bool CppFile::Header::operator <(const Header& that) const {
+  if (this->local_ != that.local_) {
+    return int(this->local_) < int(that.local_);
+  }
+  return this->name_ < that.name_;
+}
+
+Namespace& CppFile::global_namespace() {
+  return global_namespace_;
+}
+
+Namespace& CppFile::module_namespace() {
+  return
+      module_name_.empty() ?
+          global_namespace() : global_namespace().nested("rpc").nested(module_name_);
+}
+
+Namespace& CppFile::types_ns() {
+  return module_namespace();
+}
+
+Namespace& CppFile::requests_ns() {
+  return module_namespace().nested("request");
+}
+
+Namespace& CppFile::responses_ns() {
+  return module_namespace().nested("response");
+}
+
+Namespace& CppFile::notifications_ns() {
+  return module_namespace().nested("notification");
+}
+
+Namespace& CppFile::NamespaceByMessageType(FunctionMessage::MessageType type) {
+  switch(type) {
+    case FunctionMessage::kRequest:
+      return requests_ns();
+    case FunctionMessage::kResponse:
+      return responses_ns();
+    case FunctionMessage::kNotification:
+      return notifications_ns();
+    default:
+      assert(!"Invalid message type");
+      return global_namespace();
+  }
+}
+
+}  // namespace codegen
+
diff --git a/tools/intergen/cppgen/src/cppgen/cpp_function.cc b/tools/intergen/cppgen/src/cppgen/cpp_function.cc
new file mode 100644
index 0000000000..67364a2576
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/cpp_function.cc
@@ -0,0 +1,209 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/cpp_function.h"
+
+#include <cassert>
+#include <ostream>
+
+#include "utils/safeformat.h"
+#include "utils/string_utils.h"
+
+using std::endl;
+using std::ostream;
+using std::string;
+using std::vector;
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+CppFunction::CppFunction(const string& class_name, const string& name,
+                         const string& return_type_name, int qualifiers)
+    : qualifiers_(qualifiers),
+      class_name_(class_name),
+      name_(name),
+      return_type_name_(return_type_name) {
+  assert(!((qualifiers & kVirtual) && (qualifiers & kStatic)));
+}
+
+CppFunction::~CppFunction() {
+}
+
+CppFunction::Parameter::Parameter(const string& name, const string& type_name)
+    : name(name),
+      type_name(type_name) {
+}
+
+CppFunction::Parameter::~Parameter() {
+}
+
+CppFunction::OptionalParameter::OptionalParameter(
+    const std::string& name, const std::string& type_name,
+    const std::string& default_value)
+    : Parameter(name, type_name),
+      default_value(default_value) {
+}
+
+CppFunction::OptionalParameter::~OptionalParameter() {
+}
+
+codegen::CppFunction::Initializer::Initializer(const std::string& field_name,
+                                               const std::string& initializer)
+    : field_name(field_name),
+      initializer(initializer) {
+}
+
+codegen::CppFunction::Initializer::~Initializer() {
+}
+
+void CppFunction::Add(const Parameter& parameter) {
+  parameters_.push_back(parameter);
+}
+
+void CppFunction::Add(const OptionalParameter& parameter) {
+  optional_params_.push_back(parameter);
+}
+
+void CppFunction::Declare(ostream* os, bool in_class) const {
+  WriteFunctionPrototype(os, in_class, true);
+  if (qualifiers_ & kAbstract) {
+    *os << " = 0";
+  }
+  *os << ";" << endl;
+}
+
+void CppFunction::Define(ostream* os, bool in_class) const {
+  // No definitions for abstract functions
+  if (qualifiers_ & kAbstract)
+    return;
+  WriteFunctionPrototype(os, in_class, false);
+  if (!initializers_.empty()) {
+    *os << endl;
+    WriteInitializerList(os);
+  }
+  *os << " {" << endl;
+  {
+    Indent indent(*os);
+    DefineBody(os);
+  }
+  *os << "}" << endl;
+}
+
+void CppFunction::Add(const Initializer& initializer) {
+  initializers_.push_back(initializer);
+}
+
+bool CppFunction::has_mandatory_parameters() const {
+  return !parameters_.empty();
+}
+
+void CppFunction::WriteInitializerList(std::ostream* os) const {
+  bool first = true;
+  Indent indent1(*os), indent2(*os);
+  for (std::vector<Initializer>::const_iterator i = initializers_.begin(), end =
+      initializers_.end(); i != end; ++i) {
+    bool last = i == end - 1;
+    *os << (first ? ": " : "  ");
+    strmfmt(*os, "{0}({1})", i->field_name, i->initializer);
+    if (!last) {
+      *os << "," << endl;
+    }
+    first = false;
+  }
+}
+
+void CppFunction::DefineBody(std::ostream *os) const {
+}
+
+void CppFunction::WriteFunctionPrototype(ostream* os, bool in_class,
+                                         bool default_values) const {
+  if (in_class && (qualifiers_ & kExplicit)) {
+    if (parameters_.size() == 1) {
+      *os << "explicit ";
+    }
+  } else if (in_class && (qualifiers_ & kStatic)) {
+    *os << "static ";
+  } else if (in_class && (qualifiers_ & kVirtual)) {
+    *os << "virtual ";
+  }
+  if (!return_type_name_.empty()) {
+    *os << return_type_name_ << " ";
+  }
+  if (!in_class && !class_name_.empty()) {
+    *os << class_name_ << "::";
+  }
+  *os << name_ << "(";
+  bool separate = false;
+  for (vector<Parameter>::const_iterator i = parameters_.begin();
+      i != parameters_.end(); ++i) {
+    if (separate) {
+      *os << ", ";
+    }
+    *os << i->type_name << " " << i->name;
+    separate = true;
+  }
+  for (vector<OptionalParameter>::const_iterator i = optional_params_.begin();
+      i != optional_params_.end(); ++i) {
+    if (separate) {
+      *os << ", ";
+    }
+    *os << i->type_name << " " << i->name;
+    if (default_values) {
+      *os << " = " << i->default_value;
+    }
+    separate = true;
+  }
+  *os << ")";
+  if (qualifiers_ & kConst) {
+    *os << " const";
+  }
+  if (qualifiers_ & kVolatile) {
+    *os << " volatile";
+  }
+}
+
+CppStructConstructor::CppStructConstructor(const std::string& type_name)
+    : CppFunction(type_name, type_name, "", kExplicit) {
+}
+
+CppStructConstructor::~CppStructConstructor() {
+}
+
+CppStructDestructor::CppStructDestructor(const std::string& type_name,
+                                         bool abstract)
+    : CppFunction(type_name, "~" + type_name, "", abstract ? kAbstract : 0) {
+}
+
+CppStructDestructor::~CppStructDestructor() {
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/cpp_interface_code_generator.cc b/tools/intergen/cppgen/src/cppgen/cpp_interface_code_generator.cc
new file mode 100644
index 0000000000..49bd758b6e
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/cpp_interface_code_generator.cc
@@ -0,0 +1,212 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/cpp_interface_code_generator.h"
+
+#include "cppgen/generator_preferences.h"
+#include "cppgen/handler_interface.h"
+#include "cppgen/message_factory_function.h"
+#include "cppgen/message_interface.h"
+#include "cppgen/module_manager.h"
+#include "model/interface.h"
+#include "model/type_registry.h"
+
+namespace codegen {
+
+CppInterfaceCodeGenerator::CppInterfaceCodeGenerator(
+    const Interface* interface,
+    const TypePreferences* preferences,
+    ModuleManager* module_manager)
+    : interface_(interface),
+      preferences_(preferences),
+      module_manager_(module_manager),
+      declaration_generator_(preferences, module_manager_),
+      definition_generator_(preferences, module_manager_) {
+}
+
+CppInterfaceCodeGenerator::~CppInterfaceCodeGenerator() {
+}
+
+void CppInterfaceCodeGenerator::GenerateCode() {
+  GenerateEnums();
+  GenerateTypedefs();
+  GenerateStructs();
+  bool type_only_interface =
+      interface_->function_id_enum()->constants().empty();
+  if (!type_only_interface) {
+    GenerateFunctions();
+    GenerateResponses();
+    GenerateNotifications();
+    GenerateHandlerInterfaces();
+    GenerateMessageBaseClasses();
+    GenerateMessageFactories();
+  }
+}
+
+void CppInterfaceCodeGenerator::GenerateEnums() {
+  const Interface::EnumList& enums = interface_->enums();
+  for (Interface::EnumList::const_iterator i = enums.begin(), end = enums.end();
+      i != end; ++i) {
+    const Enum* e = *i;
+    declaration_generator_.GenerateCodeForEnum(e);
+    definition_generator_.GenerateCodeForEnum(e);
+  }
+
+  const Enum* func_id_enum = interface_->function_id_enum();
+  // Not all interfaces declare functions, avoid empty enum generation
+  if (!func_id_enum->constants().empty()) {
+    declaration_generator_.GenerateCodeForEnum(func_id_enum);
+    definition_generator_.GenerateCodeForEnum(func_id_enum);
+  }
+}
+
+void CppInterfaceCodeGenerator::GenerateStructs() {
+  const Interface::StructList& structs = interface_->structs();
+  for (Interface::StructList::const_iterator i = structs.begin(), end = structs
+      .end(); i != end; ++i) {
+    const Struct* s = *i;
+    declaration_generator_.GenerateCodeForStruct(s);
+    definition_generator_.GenerateCodeForStruct(s);
+  }
+}
+
+void CppInterfaceCodeGenerator::GenerateTypedefs() {
+  const Interface::TypedefList& typedefs = interface_->typedefs();
+  for (Interface::TypedefList::const_iterator i = typedefs.begin(), end =
+      typedefs.end(); i != end; ++i) {
+    const Typedef* tdef = *i;
+    declaration_generator_.GenerateCodeForTypedef(tdef);
+  }
+}
+
+void CppInterfaceCodeGenerator::GenerateFunctions() {
+  const Interface::FunctionsList& functions = interface_->functions();
+  for (Interface::FunctionsList::const_iterator i = functions.begin(), end =
+      functions.end(); i != end; ++i) {
+    const Function& function = *i;
+    declaration_generator_.GenerateCodeForFunction(function);
+    definition_generator_.GenerateCodeForFunction(function);
+  }
+}
+
+void CppInterfaceCodeGenerator::GenerateResponses() {
+  const Interface::ResponseList& responses = interface_->generic_responses();
+  for (Interface::ResponseList::const_iterator i = responses.begin(), end =
+      responses.end(); i != end; ++i) {
+    const Response& response = **i;
+    declaration_generator_.GenerateCodeForResponse(response);
+    definition_generator_.GenerateCodeForResponse(response);
+  }
+}
+
+void CppInterfaceCodeGenerator::GenerateNotifications() {
+  const Interface::NotificationList& notifications =
+      interface_->notifications();
+  for (Interface::NotificationList::const_iterator i = notifications.begin(),
+      end = notifications.end(); i != end; ++i) {
+    const Notification& notification = **i;
+    declaration_generator_.GenerateCodeForNotification(notification);
+    definition_generator_.GenerateCodeForNotification(notification);
+  }
+}
+
+void CppInterfaceCodeGenerator::GenerateHandlerInterfaces() {
+  CppFile& handler_header = module_manager_->HeaderForInterface();
+  CppFile& handler_source = module_manager_->SourceForInterface();
+  HandlerInterface notif_handler(
+        FunctionMessage::kNotification, interface_, &handler_header);
+  notif_handler.Declare(&handler_header.notifications_ns().os());
+  notif_handler.Define(&handler_source.notifications_ns().os());
+
+  HandlerInterface req_handler(
+        FunctionMessage::kRequest, interface_, &handler_header);
+  req_handler.Declare(&handler_header.requests_ns().os());
+  req_handler.Define(&handler_source.requests_ns().os());
+
+  HandlerInterface resp_handler(
+        FunctionMessage::kResponse, interface_, &handler_header);
+  resp_handler.Declare(&handler_header.responses_ns().os());
+  resp_handler.Define(&handler_source.responses_ns().os());
+}
+
+void CppInterfaceCodeGenerator::GenerateMessageBaseClasses() {
+  CppFile& message_base_header = module_manager_->HeaderForInterface();
+  CppFile& message_base_source = module_manager_->SourceForInterface();
+  MessageInterface notif_message(interface_, FunctionMessage::kNotification);
+  notif_message.Declare(&message_base_header.notifications_ns().os());
+  notif_message.Define(&message_base_source.notifications_ns().os());
+
+  MessageInterface request_message(interface_, FunctionMessage::kRequest);
+  request_message.Declare(&message_base_header.requests_ns().os());
+  request_message.Define(&message_base_source.requests_ns().os());
+
+  MessageInterface response_message(interface_, FunctionMessage::kResponse);
+  response_message.Declare(&message_base_header.responses_ns().os());
+  response_message.Define(&message_base_source.responses_ns().os());
+}
+
+void CppInterfaceCodeGenerator::GenerateMessageFactories() {
+  CppFile& factories_header = module_manager_->HeaderForInterface();
+  CppFile& factories_source = module_manager_->SourceForInterface();
+
+  MessageFactoryFunction::SerializationType ser_types[2];
+  size_t ser_types_count = 0;
+  if (preferences_->generate_json) {
+    ser_types[ser_types_count++] = MessageFactoryFunction::kJson;
+  }
+  if (preferences_->generate_dbus) {
+    ser_types[ser_types_count++] = MessageFactoryFunction::kDbus;
+  }
+
+  for (size_t i = 0; i < ser_types_count; ++i) {
+    MessageFactoryFunction request_factory(interface_,
+                                           ser_types[i],
+                                           FunctionMessage::kRequest);
+    request_factory.Declare(&factories_header.requests_ns().os(), true);
+    request_factory.Define(&factories_source.requests_ns().os(), true);
+    MessageFactoryFunction response_factory(interface_,
+                                            ser_types[i],
+                                            FunctionMessage::kResponse);
+    response_factory.Declare(&factories_header.responses_ns().os(), true);
+    response_factory.Define(&factories_source.responses_ns().os(), true);
+    MessageFactoryFunction notification_factory(
+          interface_,
+          ser_types[i],
+          FunctionMessage::kNotification);
+    notification_factory.Declare(&factories_header.notifications_ns().os(),
+                                 true);
+    notification_factory.Define(&factories_source.notifications_ns().os(), true);
+  }
+
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/declaration_generator.cc b/tools/intergen/cppgen/src/cppgen/declaration_generator.cc
new file mode 100644
index 0000000000..46e459198e
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/declaration_generator.cc
@@ -0,0 +1,452 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/declaration_generator.h"
+
+#include <ostream>
+#include <memory>
+
+#include "cppgen/comment.h"
+#include "cppgen/cpp_file.h"
+#include "cppgen/enum_from_json_value_function.h"
+#include "cppgen/enum_to_json_value_function.h"
+#include "cppgen/function_id_method.h"
+#include "cppgen/generator_preferences.h"
+#include "cppgen/is_valid_enum_function.h"
+#include "cppgen/literal_generator.h"
+#include "cppgen/message_handle_with_method.h"
+#include "cppgen/module_manager.h"
+#include "cppgen/naming_convention.h"
+#include "cppgen/struct_type_constructor.h"
+#include "cppgen/struct_type_dbus_serializer.h"
+#include "cppgen/struct_type_from_json_method.h"
+#include "cppgen/struct_type_is_initialized_method.h"
+#include "cppgen/struct_type_is_valid_method.h"
+#include "cppgen/struct_type_report_erros_method.h"
+#include "cppgen/type_name_code_generator.h"
+#include "model/composite_type.h"
+#include "model/constant.h"
+#include "model/function.h"
+#include "utils/safeformat.h"
+#include "utils/string_utils.h"
+
+using std::endl;
+using std::ostream;
+using std::string;
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+namespace {
+
+class Section {
+  struct SectionDeclarer {
+    SectionDeclarer(const char* name, ostream* os) {
+      *os << " " << name << ":" << endl;
+    }
+  };
+ public:
+  Section(const char* name, ostream* os)
+      : declarer_(name, os),
+        indent_(*os) {
+  }
+ private:
+  SectionDeclarer declarer_;
+  Indent indent_;
+};
+
+void DeclareStructureBegin(ostream& o, const string& name,
+                           const string& base_type, const Comment& comment) {
+  o << comment << endl;
+  strmfmt(o, "struct {0}{1} {",
+          name,
+          base_type.empty() ? "" : " : " + base_type) << endl;
+}
+
+void DeclareExternalTypes(const TypePreferences& prefs, Namespace* ns) {
+  if (prefs.generate_json) {
+    ns->nested("Json").ForwardDeclare(
+        Namespace::ForwardDeclaration(
+            Namespace::ForwardDeclaration::kClass, "Value"));
+  }
+  if (prefs.generate_dbus) {
+    ns->nested("dbus").ForwardDeclare(
+        Namespace::ForwardDeclaration(
+            Namespace::ForwardDeclaration::kClass, "MessageReader"));
+    ns->nested("dbus").ForwardDeclare(
+        Namespace::ForwardDeclaration(
+            Namespace::ForwardDeclaration::kClass, "MessageWriter"));
+  }
+}
+
+}
+
+DeclarationGenerator::DeclarationGenerator(const TypePreferences* preferences,
+                                           ModuleManager* module_manager)
+    : preferences_(preferences),
+      module_manager_(module_manager) {
+}
+
+DeclarationGenerator::~DeclarationGenerator() {
+}
+
+void DeclarationGenerator::GenerateCodeForEnum(const Enum* enm) {
+  CppFile& header_file = module_manager_->HeaderForEnum(*enm);
+  ostream& o = header_file.types_ns().os();
+  o << Comment(enm->description()) << endl;
+  o << "enum " << enm->name() << " {" << endl;
+  const Enum::ConstantsList& constants = enm->constants();
+  {
+    Indent indent(o);
+    for (Enum::ConstantsList::const_iterator i = constants.begin(), end =
+        constants.end(); i != end; ++i) {
+      const Enum::Constant& enum_constant = *i;
+      GenerateCodeForEnumConstant(enum_constant, &header_file, false);
+    }
+  }
+  o << "};" << endl;
+  IsValidEnumFunction(enm).Declare(&o, false);
+  EnumToJsonValueFunction(enm).Declare(&o, false);
+  EnumFromJsonStringFunction(enm).Declare(&o, false);
+  o << endl;
+}
+
+void DeclarationGenerator::GenerateCodeForStruct(const Struct* strct) {
+  CppFile& header_file = module_manager_->HeaderForStruct(*strct);
+  DeclareExternalTypes(*preferences_, &header_file.global_namespace());
+  ostream& o = header_file.types_ns().os();
+  std::string base_class_name = "CompositeType";
+  if (strct->frankenstruct()) {
+    base_class_name = RpcTypeNameGenerator(
+                        &strct->interface(),
+                        preferences_,
+                        strct->frankenstruct(),
+                        false).result();
+  }
+  DeclareStructureBegin(o, strct->name(), base_class_name,
+                        Comment(strct->description()));
+  {
+    Section pub("public", &o);
+    GenerateCodeForStructFields(*strct, &header_file, &header_file.types_ns());
+  }
+  {
+    Section pub("public", &o);
+    StructTypeDefaultConstructor(strct, base_class_name).Declare(&o, true);
+    StructTypeMandatoryConstructor mandatory_constructor(preferences_,
+                                                         strct,
+                                                         base_class_name);
+    if (mandatory_constructor.has_mandatory_parameters()) {
+      mandatory_constructor.Declare(&o, true);
+    }
+    CppStructDestructor(strct->name()).Declare(&o, true);
+    if (preferences_->generate_json) {
+      StructTypeFromJsonConstructor(strct, base_class_name).Declare(&o , true);
+      StructTypeToJsonMethod(strct).Declare(&o , true);
+    }
+    if (preferences_->generate_dbus) {
+      StructTypeFromDbusReaderConstructor(
+            preferences_, strct, true, base_class_name).Declare(&o, true);
+      StructTypeToDbusWriterMethod(strct, true).Declare(&o , true);
+      StructTypeDbusMessageSignatureMethod(preferences_,
+                                           strct, true).Declare(&o, true);
+    }
+    StructTypeIsValidMethod(strct).Declare(&o, true);
+    StructTypeIsInitializedMethod(strct).Declare(&o, true);
+    StructTypeStructEmptyMethod(strct).Declare(&o, true);
+    StructTypeReportErrosMethod(strct).Declare(&o, true);
+  }
+  {
+    Section priv("private", &o);
+    StructTypeAdditionalValidationMethod(strct).Declare(&o, true);
+
+  }
+  o << "};" << endl;
+}
+
+void DeclarationGenerator::GenerateCodeForTypedef(const Typedef* tdef) {
+  CppFile& header_file = module_manager_->HeaderForTypedef(*tdef);
+  Namespace& types_ns = header_file.types_ns();
+  TypeForwardDeclarator(&types_ns, tdef->type());
+  types_ns.os() << Comment(tdef->description()) << '\n';
+  strmfmt(types_ns.os(), "typedef {0} {1};",
+          RpcTypeNameGenerator(&tdef->interface(),
+                               preferences_,
+                               tdef->type(),
+                               false).result(),
+          tdef->name())
+      << '\n';
+}
+
+void DeclarationGenerator::GenerateCodeForEnumConstant(
+    const Enum::Constant& enm, CppFile* header_file, bool skip_coma) {
+  ostream& o = header_file->types_ns().os();
+  o << LiteralGenerator(enm).result();
+  if (enm.is_value_explicit()) {
+    o << " = " << enm.value();
+  }
+  if (!skip_coma) {
+    o << ",";
+  }
+  o << " " << Comment(enm.description()) << endl;
+}
+
+void DeclarationGenerator::GenerateCodeForStructField(
+    const Struct& strct,
+    const Struct::Field& field,
+    CppFile* header_file,
+    Namespace* name_space) {
+  ostream& o = name_space->os();
+  // Field is considered optional if it has mandatory=false attribute and
+  // if it does NOT have default values. Fields that have default values are
+  // always available no mater if they present in input or not
+  bool field_is_optional = false;
+  if (!field.is_mandatory()) {
+    if (field.default_value() == NULL) {
+      field_is_optional = true;
+    }
+  }
+  header_file->IncludeType(*field.type());
+  o << RpcTypeNameGenerator(&strct.interface(),
+                            preferences_,
+                            field.type(),
+                            field_is_optional).result();
+  o << " " << AvoidKeywords(field.name()) << ";";
+  if (!field.description().empty()) {
+    o << " " << Comment(field.description());
+  }
+  o << endl;
+}
+
+void DeclarationGenerator::GenerateCodeForFunction(const Function& function) {
+  CppFile& header_file = module_manager_->HeaderForFunction(function);
+
+  GenerateCodeForRequest(function.request(), &header_file);
+  GenerateCodeForResponse(function.response());
+}
+
+void DeclarationGenerator::GenerateCodeForRequest(const Request& request,
+                                                  CppFile* header_file) {
+  DeclareExternalTypes(*preferences_, &header_file->global_namespace());
+  Namespace& requests_ns = header_file->requests_ns();
+  ostream& o = requests_ns.os();
+  const char* base_class_name = "Request";
+  DeclareStructureBegin(o, request.name(), base_class_name,
+                        Comment(request.description()));
+  {
+    Section pub("public", &o);
+    strmfmt(o, "typedef {0}::{1} ResponseType;",
+            header_file->responses_ns().name(), request.name()) << endl;
+    GenerateCodeForStructFields(request,
+                                header_file,
+                                &header_file->requests_ns());
+  }
+  {
+    Section pub("public", &o);
+    StructTypeDefaultConstructor(&request, base_class_name).Declare(&o, true);
+    StructTypeMandatoryConstructor mandatory_constructor(preferences_,
+                                                         &request,
+                                                         base_class_name);
+    if (mandatory_constructor.has_mandatory_parameters()) {
+      mandatory_constructor.Declare(&o, true);
+    }
+    CppStructDestructor(request.name()).Declare(&o, true);
+
+    if (preferences_->generate_json) {
+      StructTypeFromJsonConstructor(&request, base_class_name).Declare(&o , true);
+      StructTypeToJsonMethod(&request).Declare(&o , true);
+    }
+    if (preferences_->generate_dbus) {
+      StructTypeFromDbusReaderConstructor(preferences_, &request, false,
+                                          base_class_name).Declare(&o, true);
+      StructTypeToDbusWriterMethod(&request, false).Declare(&o , true);
+      StructTypeDbusMessageSignatureMethod(preferences_,
+                                           &request, false).Declare(&o, true);
+    }
+    StructTypeIsValidMethod(&request).Declare(&o, true);
+    StructTypeIsInitializedMethod(&request).Declare(&o, true);
+    StructTypeStructEmptyMethod(&request).Declare(&o, true);
+    StructTypeReportErrosMethod(&request).Declare(&o, true);
+    MessageHandleWithMethod(request.name()).Declare(&o, true);
+    FunctionIdMethod(&request).Define(&o, true);
+    FunctionStringIdMethod(&request).Define(&o, true);
+  }
+  {
+    Section priv("private", &o);
+    StructTypeAdditionalValidationMethod(&request).Declare(&o, true);
+  }
+
+  o << "};" << endl;
+}
+
+void DeclarationGenerator::GenerateCodeForResponse(const Response& response) {
+  CppFile& header_file = module_manager_->HeaderForResponse(response);
+  DeclareExternalTypes(*preferences_, &header_file.global_namespace());
+  Namespace& responses_ns = header_file.responses_ns();
+  ostream& o = responses_ns.os();
+  const char* base_class_name = "Response";
+  DeclareStructureBegin(o, response.name(), base_class_name,
+                        Comment(response.description()));
+  {
+    Section pub("public", &o);
+    GenerateCodeForStructFields(response,
+                                &header_file,
+                                &header_file.responses_ns());
+  }
+  {
+    Section pub("public", &o);
+    StructTypeDefaultConstructor(&response, base_class_name).Declare(&o, true);
+    StructTypeMandatoryConstructor mandatory_constructor(preferences_,
+                                                         &response,
+                                                         base_class_name);
+    if (mandatory_constructor.has_mandatory_parameters()) {
+      mandatory_constructor.Declare(&o, true);
+    }
+    CppStructDestructor(response.name()).Declare(&o, true);
+    if (preferences_->generate_json) {
+      StructTypeFromJsonConstructor(&response, base_class_name).Declare(&o, true);
+      StructTypeToJsonMethod(&response).Declare(&o , true);
+
+    }
+    if (preferences_->generate_dbus) {
+      StructTypeFromDbusReaderConstructor(preferences_, &response, false,
+                                          base_class_name).Declare(&o, true);
+      StructTypeToDbusWriterMethod(&response, false).Declare(&o , true);
+
+      StructTypeDbusMessageSignatureMethod(preferences_,
+                                           &response, false).Declare(&o, true);
+    }
+    StructTypeIsValidMethod(&response).Declare(&o, true);
+    StructTypeIsInitializedMethod(&response).Declare(&o, true);
+    StructTypeStructEmptyMethod(&response).Declare(&o, true);
+    StructTypeReportErrosMethod(&response).Declare(&o, true);
+    MessageHandleWithMethod(response.name()).Declare(&o, true);
+    FunctionIdMethod(&response).Define(&o, true);
+    FunctionStringIdMethod(&response).Define(&o, true);
+  }
+  {
+    Section priv("private", &o);
+    StructTypeAdditionalValidationMethod(&response).Declare(&o, true);
+  }
+
+  o << "};" << endl;
+}
+
+void DeclarationGenerator::GenerateCodeForNotification(
+    const Notification& notification) {
+  CppFile& header_file = module_manager_->HeaderForNotification(notification);
+  DeclareExternalTypes(*preferences_, &header_file.global_namespace());
+  Namespace& notifications_ns = header_file.notifications_ns();
+  ostream& o = notifications_ns.os();
+  const char* base_class_name = "Notification";
+  DeclareStructureBegin(o, notification.name(), base_class_name,
+                        Comment(notification.description()));
+  {
+    Section pub("public", &o);
+    GenerateCodeForStructFields(notification,
+                                &header_file,
+                                &header_file.notifications_ns());
+  }
+  {
+    Section pub("public", &o);
+    StructTypeDefaultConstructor(&notification, base_class_name).Declare(&o, true);
+    StructTypeMandatoryConstructor mandatory_constructor(preferences_,
+                                                         &notification,
+                                                         base_class_name);
+    if (mandatory_constructor.has_mandatory_parameters()) {
+      mandatory_constructor.Declare(&o, true);
+    }
+    CppStructDestructor(notification.name()).Declare(&o, true);
+    if (preferences_->generate_json) {
+      StructTypeFromJsonConstructor(&notification, base_class_name).Declare(&o , true);
+      StructTypeToJsonMethod(&notification).Declare(&o , true);
+    }
+    if (preferences_->generate_dbus) {
+      StructTypeFromDbusReaderConstructor(preferences_, &notification, false,
+                                          base_class_name).Declare(&o , true);
+      StructTypeToDbusWriterMethod(&notification, false).Declare(&o , true);
+      StructTypeDbusMessageSignatureMethod(preferences_,
+                                           &notification, false).Declare(&o, true);
+    }
+    StructTypeIsValidMethod(&notification).Declare(&o, true);
+    StructTypeIsInitializedMethod(&notification).Declare(&o, true);
+    StructTypeStructEmptyMethod(&notification).Declare(&o, true);
+    StructTypeReportErrosMethod(&notification).Declare(&o, true);
+    MessageHandleWithMethod(notification.name()).Declare(&o, true);
+    FunctionIdMethod(&notification).Define(&o, true);
+    FunctionStringIdMethod(&notification).Define(&o, true);
+  }
+  {
+    Section priv("private", &o);
+    StructTypeAdditionalValidationMethod(&notification).Declare(&o, true);
+  }
+
+  o << "};" << endl;
+}
+
+void DeclarationGenerator::GenerateCodeForStructFields(
+    const Struct& strct,
+    CppFile* header_file,
+    Namespace* name_space) {
+  const FunctionMessage::ParametersList& params = strct.fields();
+  for (FunctionMessage::ParametersList::const_iterator i = params.begin(), end =
+      params.end(); i != end; ++i) {
+    const FunctionMessage::Parameter& param = *i;
+    GenerateCodeForStructField(strct, param, header_file, name_space);
+  }
+}
+
+TypeForwardDeclarator::TypeForwardDeclarator(Namespace* ns, const Type* type)
+    : ns_(ns) {
+  assert(ns_);
+  type->Apply(this);
+}
+
+void TypeForwardDeclarator::GenerateCodeForNullable(
+    const NullableType* nullable) {
+  nullable->type()->Apply(this);
+}
+
+void TypeForwardDeclarator::GenerateCodeForArray(const Array* array) {
+  array->type()->Apply(this);
+}
+
+void TypeForwardDeclarator::GenerateCodeForMap(const Map* map) {
+  map->type()->Apply(this);
+}
+
+void TypeForwardDeclarator::GenerateCodeForStruct(const Struct* strct) {
+  ns_->ForwardDeclare(
+      Namespace::ForwardDeclaration(Namespace::ForwardDeclaration::kStruct,
+                                    strct->name()));
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/definition_generator.cc b/tools/intergen/cppgen/src/cppgen/definition_generator.cc
new file mode 100644
index 0000000000..e2ad0ded04
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/definition_generator.cc
@@ -0,0 +1,231 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/definition_generator.h"
+
+#include "cppgen/comment.h"
+#include "cppgen/enum_from_json_value_function.h"
+#include "cppgen/enum_to_json_value_function.h"
+#include "cppgen/generator_preferences.h"
+#include "cppgen/is_valid_enum_function.h"
+#include "cppgen/message_handle_with_method.h"
+#include "cppgen/module_manager.h"
+#include "cppgen/struct_type_constructor.h"
+#include "cppgen/struct_type_dbus_serializer.h"
+#include "cppgen/struct_type_from_json_method.h"
+#include "cppgen/struct_type_is_initialized_method.h"
+#include "cppgen/struct_type_is_valid_method.h"
+#include "cppgen/struct_type_report_erros_method.h"
+#include "cppgen/type_name_code_generator.h"
+#include "model/composite_type.h"
+#include "utils/safeformat.h"
+
+using std::endl;
+using std::ostream;
+using typesafe_format::format;
+
+namespace codegen {
+
+DefinitionGenerator::DefinitionGenerator(const TypePreferences* preferences,
+                                         ModuleManager* module_manager)
+    : preferences_(preferences),
+      module_manager_(module_manager) {
+}
+
+DefinitionGenerator::~DefinitionGenerator() {
+}
+
+void DefinitionGenerator::GenerateCodeForEnum(const Enum* enm) {
+  CppFile& source_file = module_manager_->SourceForEnum(*enm);
+  ostream& o = source_file.types_ns().os();
+  IsValidEnumFunction(enm).Define(&o, false);
+  EnumToJsonValueFunction(enm).Define(&o, false);
+  EnumFromJsonStringFunction(enm).Define(&o, false);
+  o << endl;
+}
+
+void DefinitionGenerator::GenerateCodeForStruct(const Struct* strct) {
+  CppFile& source_file = module_manager_->SourceForStruct(*strct);
+  ostream& o = source_file.types_ns().os();
+  o << Comment(format("{0} methods", strct->name())) << endl;
+  std::string base_class_name = "CompositeType";
+  if (strct->frankenstruct()) {
+    base_class_name = RpcTypeNameGenerator(
+                        &strct->interface(),
+                        preferences_,
+                        strct->frankenstruct(),
+                        false).result();
+  }
+  StructTypeDefaultConstructor(strct, base_class_name).Define(&o, false);
+  StructTypeMandatoryConstructor mandatory_constructor(preferences_,
+                                                       strct,
+                                                       base_class_name);
+  if (mandatory_constructor.has_mandatory_parameters()){
+    mandatory_constructor.Define(&o, false);
+  }
+  CppStructDestructor(strct->name()).Define(&o, false);
+  if (preferences_->generate_json) {
+    StructTypeFromJsonConstructor(strct, base_class_name).Define(&o , false);
+    StructTypeToJsonMethod(strct).Define(&o , false);
+  }
+  if (preferences_->generate_dbus) {
+    StructTypeFromDbusReaderConstructor(preferences_, strct, true,
+                                        base_class_name).Define(&o , false);
+    StructTypeToDbusWriterMethod(strct, true).Define(&o , false);
+    StructTypeDbusMessageSignatureMethod(preferences_,
+                                         strct, true).Define(&o, false);
+  }
+  StructTypeIsValidMethod(strct).Define(&o, false);
+  StructTypeIsInitializedMethod(strct).Define(&o, false);
+  StructTypeStructEmptyMethod(strct).Define(&o, false);
+  StructTypeReportErrosMethod(strct).Define(&o, false);
+  o << endl;
+
+  Namespace& val_ns = module_manager_->SourceForValidator().types_ns();
+  StructTypeAdditionalValidationMethod(strct).Define(&val_ns.os(), false);
+}
+
+void DefinitionGenerator::GenerateCodeForFunction(const Function& function) {
+  CppFile& source_file = module_manager_->SourceForFunction(function);
+  GenerateCodeForRequest(function.request(), &source_file);
+  GenerateCodeForResponse(function.response());
+}
+
+void DefinitionGenerator::GenerateCodeForResponse(const Response& response) {
+  CppFile& source_file = module_manager_->SourceForResponse(response);
+  ostream& o = source_file.responses_ns().os();
+  o << Comment(format("{0} response methods", response.name())) << endl;
+  const char* base_class_name = "Response";
+  StructTypeDefaultConstructor(&response, base_class_name).Define(&o, false);
+  StructTypeMandatoryConstructor mandatory_constructor(preferences_,
+                                                       &response,
+                                                       base_class_name);
+  if (mandatory_constructor.has_mandatory_parameters()){
+    mandatory_constructor.Define(&o, false);
+  }
+  CppStructDestructor(response.name()).Define(&o, false);
+  if (preferences_->generate_json) {
+    StructTypeFromJsonConstructor(&response, base_class_name).Define(&o , false);
+    StructTypeToJsonMethod(&response).Define(&o , false);
+  }
+  if (preferences_->generate_dbus) {
+    StructTypeFromDbusReaderConstructor(preferences_, &response, false,
+                                        base_class_name).Define(&o , false);
+    StructTypeToDbusWriterMethod(&response, false).Define(&o , false);
+    StructTypeDbusMessageSignatureMethod(preferences_,
+                                         &response, false).Define(&o, false);
+  }
+  MessageHandleWithMethod(response.name()).Define(&o, false);
+  StructTypeIsValidMethod(&response).Define(&o, false);
+  StructTypeIsInitializedMethod(&response).Define(&o, false);
+  StructTypeStructEmptyMethod(&response).Define(&o, false);
+  StructTypeReportErrosMethod(&response).Define(&o, false);
+  o << endl;
+
+  Namespace& val_ns = module_manager_->SourceForValidator().responses_ns();
+  StructTypeAdditionalValidationMethod(&response).Define(&val_ns.os(), false);
+}
+
+void DefinitionGenerator::GenerateCodeForNotification(
+    const Notification& notification) {
+  CppFile& source_file = module_manager_->SourceForNotification(notification);
+  ostream& o = source_file.notifications_ns().os();
+  o << Comment(format("{0} notification methods", notification.name())) << endl;
+  const char* base_class_name = "Notification";
+  StructTypeDefaultConstructor(&notification, base_class_name).Define(&o, false);
+  StructTypeMandatoryConstructor mandatory_constructor(preferences_,
+                                                       &notification,
+                                                       base_class_name);
+  if (mandatory_constructor.has_mandatory_parameters()){
+    mandatory_constructor.Define(&o, false);
+  }
+  CppStructDestructor(notification.name()).Define(&o, false);
+  if (preferences_->generate_json) {
+    StructTypeFromJsonConstructor(&notification, base_class_name).Define(&o , false);
+    StructTypeToJsonMethod(&notification).Define(&o , false);
+  }
+  if (preferences_->generate_dbus) {
+    StructTypeFromDbusReaderConstructor(preferences_, &notification, false,
+                                        base_class_name).Define(&o, false);
+    StructTypeToDbusWriterMethod(&notification, false).Define(&o , false);
+    StructTypeDbusMessageSignatureMethod(preferences_,
+                                         &notification, false).Define(&o, false);
+  }
+  MessageHandleWithMethod(notification.name()).Define(&o, false);
+  StructTypeIsValidMethod(&notification).Define(&o, false);
+  StructTypeIsInitializedMethod(&notification).Define(&o, false);
+  StructTypeStructEmptyMethod(&notification).Define(&o, false);
+  StructTypeReportErrosMethod(&notification).Define(&o, false);
+  o << endl;
+
+  Namespace& val_ns = module_manager_->SourceForValidator().notifications_ns();
+  StructTypeAdditionalValidationMethod(&notification).Define(&val_ns.os(),
+                                                             false);
+}
+
+void DefinitionGenerator::GenerateCodeForRequest(const Request& request,
+                                                 CppFile* source_file) {
+  ostream& o = source_file->requests_ns().os();
+  o << Comment(format("{0} request methods", request.name())) << endl;
+  const char* base_class_name = "Request";
+  StructTypeDefaultConstructor(&request, base_class_name).Define(&o, false);
+  StructTypeMandatoryConstructor mandatory_constructor(preferences_,
+                                                       &request,
+                                                       base_class_name);
+  if (mandatory_constructor.has_mandatory_parameters()){
+    mandatory_constructor.Define(&o, false);
+  }
+  CppStructDestructor(request.name()).Define(&o, false);
+  if (preferences_->generate_json) {
+    StructTypeFromJsonConstructor(&request, base_class_name).Define(&o , false);
+    StructTypeToJsonMethod(&request).Define(&o , false);
+  }
+  if (preferences_->generate_dbus) {
+    StructTypeFromDbusReaderConstructor(preferences_, &request, false,
+                                        base_class_name).Define(&o , false);
+    StructTypeToDbusWriterMethod(&request, false).Define(&o , false);
+    StructTypeDbusMessageSignatureMethod(preferences_,
+                                         &request, false).Define(&o, false);
+  }
+  StructTypeIsValidMethod(&request).Define(&o, false);
+  StructTypeIsInitializedMethod(&request).Define(&o, false);
+  StructTypeStructEmptyMethod(&request).Define(&o, false);
+  StructTypeReportErrosMethod(&request).Define(&o, false);
+  MessageHandleWithMethod(request.name()).Define(&o, false);
+  o << endl;
+
+  Namespace& val_ns = module_manager_->SourceForValidator().requests_ns();
+  StructTypeAdditionalValidationMethod(&request).Define(&val_ns.os(), false);
+}
+
+}  // namespace codegen
+
diff --git a/tools/intergen/cppgen/src/cppgen/enum_from_json_value_function.cc b/tools/intergen/cppgen/src/cppgen/enum_from_json_value_function.cc
new file mode 100644
index 0000000000..1b663c081a
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/enum_from_json_value_function.cc
@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/enum_from_json_value_function.h"
+
+#include <ostream>
+
+#include "cppgen/generator_preferences.h"
+#include "cppgen/literal_generator.h"
+#include "model/composite_type.h"
+#include "utils/safeformat.h"
+
+using std::endl;
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+EnumFromJsonStringFunction::EnumFromJsonStringFunction(
+    const Enum* enm)
+    : CppFunction("", "EnumFromJsonString", "bool"),
+      enm_(enm) {
+  Add(Parameter("literal", "const std::string&"));
+  Add(Parameter("*result", enm->name()));
+}
+
+EnumFromJsonStringFunction::~EnumFromJsonStringFunction() {
+}
+
+void EnumFromJsonStringFunction::DefineBody(std::ostream* os) const {
+  const Enum::ConstantsList& consts = enm_->constants();
+  if (!consts.empty()) {
+    const char* if_statement = "if (\"{0}\" == {1}) {";
+    for (Enum::ConstantsList::const_iterator i = consts.begin();
+        i != consts.end(); ++i) {
+      const Enum::Constant& c = *i;
+      strmfmt(*os, if_statement, c.name(), parameters_[0].name) << endl;
+      {
+        Indent indent(*os);
+        strmfmt(*os, "{0} = {1};", parameters_[1].name,
+                LiteralGenerator(c).result()) << '\n';
+        *os << "return true;" << '\n';
+      }
+      if_statement = "} else if (\"{0}\" == {1}) {";
+    }
+  }
+  *os << "} else {" << endl;
+  {
+    Indent indent(*os);
+    *os << "return false;" << '\n';
+  }
+  *os << "}" << endl;
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/enum_to_json_value_function.cc b/tools/intergen/cppgen/src/cppgen/enum_to_json_value_function.cc
new file mode 100644
index 0000000000..ac88b5b963
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/enum_to_json_value_function.cc
@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/enum_to_json_value_function.h"
+
+#include <ostream>
+
+#include "cppgen/generator_preferences.h"
+#include "cppgen/literal_generator.h"
+#include "model/composite_type.h"
+#include "utils/safeformat.h"
+
+using std::endl;
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+EnumToJsonValueFunction::EnumToJsonValueFunction(const Enum* enm)
+    : CppFunction("", "EnumToJsonString", "const char*"),
+      enm_(enm) {
+  Add(Parameter("val", enm->name()));
+}
+
+EnumToJsonValueFunction::~EnumToJsonValueFunction() {
+}
+
+void EnumToJsonValueFunction::DefineBody(std::ostream* os) const {
+  strmfmt(*os, "switch({0}) {", parameters_[0].name) << endl;
+  {
+    Indent indent(*os);
+    const Enum::ConstantsList& consts = enm_->constants();
+    for (Enum::ConstantsList::const_iterator i = consts.begin();
+        i != consts.end(); ++i) {
+      const Enum::Constant& c = *i;
+      strmfmt(*os, "case {0}: return \"{1}\";", LiteralGenerator(c).result(),
+              c.name()) << endl;
+    }
+    *os << "default: return \"\";" << endl;
+  }
+  *os << "}" << endl;
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/function_id_method.cc b/tools/intergen/cppgen/src/cppgen/function_id_method.cc
new file mode 100644
index 0000000000..2ada8b7231
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/function_id_method.cc
@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/function_id_method.h"
+
+#include <cassert>
+#include <ostream>
+#include "model/interface.h"
+#include "model/function.h"
+#include "utils/safeformat.h"
+#include "cppgen/literal_generator.h"
+
+using std::endl;
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+FunctionIdMethod::FunctionIdMethod(const FunctionMessage* func)
+    : CppFunction(func->name(),
+                  "function_id",
+                  "int32_t", kConst),
+      func_(func) {
+  assert(func);
+}
+
+FunctionIdMethod::~FunctionIdMethod() {
+}
+
+void FunctionIdMethod::DefineBody(std::ostream* os) const {
+  const Enum::Constant* id = func_->id();
+  strmfmt(*os, "return {0};", LiteralGenerator(*id).result()) << endl;
+}
+
+FunctionStringIdMethod::FunctionStringIdMethod(const FunctionMessage* func)
+    : CppFunction(func->name(),
+                  "function_string_id",
+                  "const char*",
+                  kConst),
+      func_(func) {
+  assert(func);
+}
+
+FunctionStringIdMethod::~FunctionStringIdMethod() {
+}
+
+void FunctionStringIdMethod::DefineBody(std::ostream* os) const {
+  const Enum::Constant* id = func_->id();
+  strmfmt(*os, "return \"{0}\";" ,
+          id->name()) << endl;
+}
+
+}  // namespace codegen
+
diff --git a/tools/intergen/cppgen/src/cppgen/generator_preferences.cc b/tools/intergen/cppgen/src/cppgen/generator_preferences.cc
new file mode 100644
index 0000000000..ca5b12e2d9
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/generator_preferences.cc
@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/generator_preferences.h"
+
+#include <algorithm>
+
+#include "cppgen/naming_convention.h"
+#include "utils/safeformat.h"
+#include "utils/string_utils.h"
+
+using typesafe_format::format;
+
+namespace codegen {
+
+TypePreferences::TypePreferences(int minimum_interger_size,
+                                 bool avoid_unsigned,
+                                 bool generate_json,
+                                 bool generate_dbus)
+    : minimum_interger_size(minimum_interger_size),
+      avoid_unsigned(avoid_unsigned),
+      generate_json(generate_json),
+      generate_dbus(generate_dbus) {
+}
+
+Preferences::Preferences(int minimum_interger_size,
+                         bool avoid_unsigned,
+                         bool generate_json,
+                         bool generate_dbus,
+                         const std::set<std::string>& requested_interfaces)
+    : type_preferences(minimum_interger_size, avoid_unsigned,
+                       generate_json, generate_dbus),
+      requested_interfaces(requested_interfaces) {
+}
+
+namespace func_names {
+const char* kAdditionalValidation = "Validate";
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/handler_interface.cc b/tools/intergen/cppgen/src/cppgen/handler_interface.cc
new file mode 100644
index 0000000000..57b41523fd
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/handler_interface.cc
@@ -0,0 +1,107 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/handler_interface.h"
+
+#include <cassert>
+#include <memory>
+
+#include "cppgen/cpp_file.h"
+#include "cppgen/naming_convention.h"
+#include "model/interface.h"
+
+namespace codegen {
+
+HandlerInterface::HandlerInterface(FunctionMessage::MessageType type,
+                                   const Interface* interface,
+                                   CppFile* header_file)
+    : CppClass("Handler"),
+      type_(type),
+      interface_(interface),
+      header_file_(header_file),
+      methods_deleter_(&methods_) {
+  assert(interface);
+  CollectMethods();
+}
+
+const CppClass::MethodsList& HandlerInterface::methods(){
+  return methods_;
+}
+
+void HandlerInterface::CollectMethods() {
+  switch(type_) {
+    case FunctionMessage::kNotification: {
+      AddFunctionMessageHandlers(interface_->notifications());
+      break;
+    }
+    case FunctionMessage::kRequest: {
+      const Interface::FunctionsList& functions =
+          interface_->functions();
+      AddFunctionMessageHandlers(interface_->all_requests());
+      break;
+    }
+    case FunctionMessage::kResponse: {
+      AddFunctionMessageHandlers(interface_->all_responses());
+      break;
+    }
+    default: {
+      assert(!"Unexpected function message type");
+    }
+  }
+  std::auto_ptr<CppClass::Method> destructor(
+        new CppClass::Method(this, CppClass::kPublic,
+                             "~"+name(), "",
+                             CppFunction::kVirtual));
+  methods_.push_back(destructor.get());
+  destructor.release();
+}
+
+void HandlerInterface::AddFunctionMessageHandlers(
+    const FunctionMessages& function_messages) {
+  for (FunctionMessages::const_iterator i = function_messages.begin(),
+       end = function_messages.end(); i != end; ++i) {
+    const FunctionMessage* func_msg = *i;
+    Namespace& message_ns = header_file_->NamespaceByMessageType(type_);
+    message_ns.ForwardDeclare(Namespace::ForwardDeclaration(
+                              Namespace::ForwardDeclaration::kStruct,
+                              func_msg->name()));
+    std::auto_ptr<CppClass::Method> method(
+        new CppClass::Method(
+          this, CppClass::kPublic, "Handle" + func_msg->name(),
+          "void", CppFunction::kVirtual | CppFunction::kAbstract));
+    method->Add(CppClass::Method::Parameter(
+                  "params", "const " + func_msg->name() + "&"));
+    methods_.push_back(method.get());
+    method.release();
+  }
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/is_valid_enum_function.cc b/tools/intergen/cppgen/src/cppgen/is_valid_enum_function.cc
new file mode 100644
index 0000000000..3ebb9d3bca
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/is_valid_enum_function.cc
@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/is_valid_enum_function.h"
+
+#include <ostream>
+
+#include "cppgen/generator_preferences.h"
+#include "cppgen/literal_generator.h"
+#include "model/composite_type.h"
+#include "model/constant.h"
+#include "utils/safeformat.h"
+#include "utils/string_utils.h"
+
+using std::endl;
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+IsValidEnumFunction::IsValidEnumFunction(const Enum* enm)
+    : CppFunction("", "IsValidEnum", "bool"),
+      enm_(enm) {
+  Add(Parameter("val", enm->name()));
+}
+
+IsValidEnumFunction::~IsValidEnumFunction() {
+}
+
+void IsValidEnumFunction::DefineBody(std::ostream* os) const {
+  strmfmt(*os, "switch({0}) {", parameters_[0].name) << endl;
+  {
+    Indent indent(*os);
+    const Enum::ConstantsList& consts = enm_->constants();
+    for (Enum::ConstantsList::const_iterator i = consts.begin();
+        i != consts.end(); ++i) {
+      const Enum::Constant& c = *i;
+      strmfmt(*os, "case {0}: return true;", LiteralGenerator(c).result()) << endl;
+    }
+    *os << "default: return false;" << endl;
+  }
+  *os << "}" << endl;
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/literal_generator.cc b/tools/intergen/cppgen/src/cppgen/literal_generator.cc
new file mode 100644
index 0000000000..71c542ac6b
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/literal_generator.cc
@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/literal_generator.h"
+
+#include "cppgen/naming_convention.h"
+
+namespace codegen {
+
+LiteralGenerator::LiteralGenerator(const Constant& constant) {
+  constant.Apply(this);
+}
+
+LiteralGenerator::~LiteralGenerator() {
+}
+
+std::string LiteralGenerator::result() const {
+  return result_;
+}
+
+void LiteralGenerator::GenerateCodeForBooleanConstant(
+    const Boolean::Constant* boolean) {
+  result_ = boolean->value() ? "true" : "false";
+}
+
+void LiteralGenerator::GenerateCodeForIntegerConstant(
+    const Integer::Constant* integer) {
+  result_ = NumberToString(integer->value());
+}
+
+void LiteralGenerator::GenerateCodeForFloatConstant(
+    const Float::Constant* flt) {
+  result_ = NumberToString(flt->value());
+}
+
+void LiteralGenerator::GenerateCodeForEnumConstant(const Enum::Constant* enm) {
+  std::string type_name = enm->type()->name();
+  if (Enum::kFunctionIdEnumName == type_name) {
+    result_ = "k" + enm->name();
+  } else {
+    std::string constant_name = enm->name();
+    std::replace(constant_name.begin(), constant_name.end(), '-', '_');
+    result_ = to_upper(
+        WordList::FromCamelCase(type_name).Abbreviate() + "_" + constant_name);
+  }
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/message_factory_function.cc b/tools/intergen/cppgen/src/cppgen/message_factory_function.cc
new file mode 100644
index 0000000000..2cfc3ea0cd
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/message_factory_function.cc
@@ -0,0 +1,98 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/message_factory_function.h"
+
+#include "cppgen/literal_generator.h"
+#include "cppgen/naming_convention.h"
+#include "model/interface.h"
+#include "utils/safeformat.h"
+#include "utils/string_utils.h"
+
+using typesafe_format::format;
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+MessageFactoryFunction::MessageFactoryFunction(
+    const Interface* interface,
+    SerializationType serialization_type,
+    FunctionMessage::MessageType factory_type)
+    : CppFunction("",
+                  serialization_type == kJson ? "NewFromJson" : "NewFromDbus",
+                  Capitalize(
+                    FunctionMessage::MessageTypeToString(
+                      factory_type)) + "*"),
+      interface_(interface),
+      factory_type_(factory_type) {
+  Add(MessageFactoryFunction::Parameter(
+        serialization_type == kJson ? "json" : "reader",
+        serialization_type == kJson ? "const Json::Value*": "dbus::MessageReader*"));
+  Add(MessageFactoryFunction::Parameter("function_id", "FunctionID"));
+}
+
+void MessageFactoryFunction::DefineBody(std::ostream* os) const {
+  *os << "switch (function_id) {\n";
+  {
+    Indent indent(*os);
+    switch(factory_type_) {
+      case FunctionMessage::kRequest: {
+        DefineCases(os, interface_->all_requests());
+        break;
+      }
+      case FunctionMessage::kResponse: {
+        DefineCases(os, interface_->all_responses());
+        break;
+      }
+      case FunctionMessage::kNotification: {
+        DefineCases(os, interface_->notifications());
+        break;
+      }
+    }
+  }
+  *os << "}\n";
+}
+
+void MessageFactoryFunction::DefineCases(
+    std::ostream* os,
+    const MessageList& functions) const {
+  for (MessageList::const_iterator i = functions.begin(),
+       end = functions.end(); i != end; ++i) {
+    const FunctionMessage* message = *i;
+    strmfmt(*os, "case {0}: return new {1}({2});\n",
+            LiteralGenerator(*message->id()).result(),
+            message->name(),
+            parameters_[0].name);
+  }
+  *os << "default: return NULL;\n";
+}
+
+} // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/message_handle_with_method.cc b/tools/intergen/cppgen/src/cppgen/message_handle_with_method.cc
new file mode 100644
index 0000000000..897356439c
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/message_handle_with_method.cc
@@ -0,0 +1,53 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <ostream>
+
+#include "cppgen/message_handle_with_method.h"
+#include "utils/safeformat.h"
+
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+MessageHandleWithMethod::MessageHandleWithMethod(const std::string& class_name)
+    : CppFunction(class_name, "HandleWith", "void", kVirtual),
+      class_name_(class_name){
+  Add(Parameter("handler", "Handler*"));
+}
+
+void MessageHandleWithMethod::DefineBody(std::ostream* os) const {
+  strmfmt(*os, "return handler->Handle{0}(*this);",
+          class_name_) << '\n';
+}
+
+} // namespace codegen
+
diff --git a/tools/intergen/cppgen/src/cppgen/message_interface.cc b/tools/intergen/cppgen/src/cppgen/message_interface.cc
new file mode 100644
index 0000000000..cd683801b5
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/message_interface.cc
@@ -0,0 +1,79 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/message_interface.h"
+
+#include "cppgen/naming_convention.h"
+#include "model/interface.h"
+#include "utils/safeformat.h"
+
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+InterfaceStringIdMethod::InterfaceStringIdMethod(
+    const MessageInterface* message_interface,
+    const Interface* interface)
+    : CppClass::Method(message_interface, CppClass::kPublic,
+         "interface_string_id", "const char*", kConst),
+      interface_(interface) {
+}
+
+void InterfaceStringIdMethod::DefineBody(std::ostream* os) const {
+  strmfmt(*os, "return \"{0}\";\n", interface_->name());
+}
+
+MessageInterface::MessageInterface(const Interface* interface,
+                                   FunctionMessage::MessageType message_type)
+  : CppClass(Capitalize(FunctionMessage::MessageTypeToString(message_type))),
+    constructor_(this, CppClass::kPublic, name(), "", Method::kExplicit),
+    handle_with_method_(this, kPublic,
+                        "HandleWith", "void",
+                        Method::kVirtual|Method::kAbstract),
+    interface_string_id_method_(this, interface){
+  std::string superclass_name = "rpc::" + name() + "Base";
+  Add(Superclass(superclass_name, kPublic));
+  constructor_.Add(Method::Parameter("init_state", "InitializationState"));
+  constructor_.Add(Method::Initializer(superclass_name, "init_state"));
+
+  handle_with_method_.Add(Method::Parameter(
+                            "handler", "Handler*"));
+
+  methods_.push_back(&constructor_);
+  methods_.push_back(&handle_with_method_);
+  methods_.push_back(&interface_string_id_method_);
+}
+
+const CppClass::MethodsList& MessageInterface::methods() {
+  return methods_;
+}
+
+} // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/module_manager.cc b/tools/intergen/cppgen/src/cppgen/module_manager.cc
new file mode 100644
index 0000000000..494e279e5c
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/module_manager.cc
@@ -0,0 +1,197 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/module_manager.h"
+
+#include <errno.h>
+#include <fstream>
+
+#include "cppgen/generator_preferences.h"
+
+#ifdef OS_POSIX
+#include <sys/stat.h>
+#include <sys/types.h>
+
+namespace {
+bool CreateDirectory(const std::string& name) {
+  int result = mkdir(name.c_str(), 0777) == 0;
+  if (0 == result) {
+    return true;
+  } else if (EEXIST == result || EPERM == result) {
+    struct stat s;
+    result = stat(name.c_str(), &s);
+    if (result != 0) {
+      return false;
+    }
+    return (S_ISDIR(s.st_mode));
+  }
+  return false;
+}
+
+}  // namespace
+
+#else
+#error Please provide create directory function for your platform
+#endif
+
+
+namespace codegen {
+
+ModuleManager::ModuleManager(const std::string& name,
+                             const TypePreferences& prefs)
+    : module_name_(name),
+      enums_header_(module_name_ + "/enums.h", module_name_, true),
+      enums_source_(module_name_ + "/enums.cc", module_name_, false),
+      structs_header_(module_name_ + "/types.h", module_name_, true),
+      structs_source_(module_name_ + "/types.cc", module_name_, false),
+      functions_header_(module_name_ + "/functions.h", module_name_, true),
+      functions_source_(module_name_ + "/functions.cc", module_name_, false),
+      interface_header_(module_name_ + "/interface.h", module_name_, true),
+      interface_source_(module_name_ + "/interface.cc", module_name_, false),
+      additional_validation_source_(module_name_ + "/validation.cc", module_name_, false){
+  structs_header_.Include(CppFile::Header("rpc_base/rpc_message.h", true));
+  structs_header_.Include(CppFile::Header(enums_header_.file_name(), true));
+  functions_header_.Include(CppFile::Header(enums_header_.file_name(), true));
+  functions_header_.Include(CppFile::Header(structs_header_.file_name(), true));
+  functions_header_.Include(CppFile::Header(interface_header_.file_name(), true));
+  interface_header_.Include(CppFile::Header("rpc_base/rpc_message.h", true));
+  interface_header_.Include(CppFile::Header(enums_header_.file_name(), true));
+  enums_header_.Include(CppFile::Header("string", false));
+  enums_source_.Include(CppFile::Header(enums_header_.file_name(), true));
+  structs_source_.Include(CppFile::Header(structs_header_.file_name(), true));
+  functions_source_.Include(CppFile::Header(functions_header_.file_name(),
+                                            true));
+  interface_source_.Include((CppFile::Header(interface_header_.file_name(),
+                                             true)));
+  interface_source_.Include(CppFile::Header(functions_header_.file_name(),
+                                            true));
+
+  additional_validation_source_.Include(
+      CppFile::Header(structs_header_.file_name(), true));
+  additional_validation_source_.Include(
+      CppFile::Header(functions_header_.file_name(), true));
+  if (prefs.generate_json) {
+    structs_source_.Include(
+        CppFile::Header("rpc_base/rpc_base_json_inl.h", true));
+    functions_source_.Include(
+        CppFile::Header("rpc_base/rpc_base_json_inl.h", true));
+  }
+  if (prefs.generate_dbus) {
+    structs_source_.Include(
+        CppFile::Header("rpc_base/rpc_base_dbus_inl.h", true));
+    functions_source_.Include(
+        CppFile::Header("rpc_base/rpc_base_dbus_inl.h", true));
+  }
+}
+
+ModuleManager::~ModuleManager() {
+}
+
+CppFile& ModuleManager::HeaderForInterface() {
+  return interface_header_;
+}
+
+CppFile& ModuleManager::HeaderForEnum(const Enum& enm) {
+  return enums_header_;
+}
+
+CppFile& ModuleManager::HeaderForStruct(const Struct& strct) {
+  return structs_header_;
+}
+
+CppFile& ModuleManager::HeaderForTypedef(const Typedef& tdef) {
+  return structs_header_;
+}
+
+CppFile& ModuleManager::HeaderForFunction(const Function& function) {
+  return functions_header_;
+}
+
+CppFile& ModuleManager::HeaderForResponse(const Response& request) {
+  return functions_header_;
+}
+
+CppFile& ModuleManager::HeaderForNotification(
+    const Notification& notification) {
+  return functions_header_;
+}
+
+CppFile& ModuleManager::SourceForInterface() {
+  return interface_source_;
+}
+
+CppFile& ModuleManager::SourceForEnum(const Enum& enm) {
+  return enums_source_;
+}
+
+CppFile& ModuleManager::SourceForStruct(const Struct& strct) {
+  return structs_source_;
+}
+
+CppFile& ModuleManager::SourceForFunction(const Function& function) {
+  return functions_source_;
+}
+
+CppFile& ModuleManager::SourceForResponse(const Response& request) {
+  return functions_source_;
+}
+
+CppFile& ModuleManager::SourceForNotification(
+    const Notification& notification) {
+  return functions_source_;
+}
+
+CppFile& ModuleManager::SourceForValidator() {
+  return additional_validation_source_;
+}
+
+bool ModuleManager::Write() {
+  if (!CreateDirectory(module_name_)) {
+    return false;
+  }
+  CppFile* files[] = { &enums_header_, &enums_source_,
+                       &structs_header_, &structs_source_,
+                       &functions_header_, &functions_source_,
+                       &interface_header_, &interface_source_,
+                       &additional_validation_source_ };
+  for (size_t i = 0; i != sizeof(files)/sizeof(files[0]); ++i) {
+    CppFile* file = files[i];
+    std::ofstream stream(file->file_name().c_str());
+    file->Write(&stream);
+    if (!stream) {
+      return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/namespace.cc b/tools/intergen/cppgen/src/cppgen/namespace.cc
new file mode 100644
index 0000000000..f02657358f
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/namespace.cc
@@ -0,0 +1,213 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/namespace.h"
+
+#include "cppgen/comment.h"
+#include "utils/safeformat.h"
+
+using std::endl;
+using std::make_pair;
+using std::map;
+using std::set;
+using std::string;
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+Namespace::Namespace()
+    : global_(true) {
+}
+
+Namespace::Namespace(const std::string& name)
+    : global_(false),
+      name_(name) {
+}
+
+Namespace::~Namespace() {
+}
+
+Namespace::Namespace(const Namespace& that)
+    : global_(that.global_),
+      name_(that.name_),
+      nested_(that.nested_),
+      contents_(that.contents_.str()) {
+}
+
+const std::string& Namespace::name() const {
+  return name_;
+}
+
+Namespace& codegen::Namespace::nested(const std::string& name) {
+  map<string, Namespace>::iterator res = nested_.find(name);
+  if (res == nested_.end()) {
+    return nested_.insert(make_pair(name, Namespace(name))).first->second;
+  } else {
+    return res->second;
+  }
+}
+
+std::ostream& Namespace::os() {
+  return contents_;
+}
+
+void Namespace::ForwardDeclare(const ForwardDeclaration& type_name) {
+  forward_declarations_.insert(type_name);
+}
+
+void Namespace::Write(std::ostream* os) {
+  WriteForwardDeclarations(os);
+  *os << endl;
+  WriteContents(os);
+}
+
+void Namespace::WriteForwardDeclarations(std::ostream* os) {
+  if (HasForwardDeclarations()) {
+    BeginNamespace(os);
+    for (map<string, Namespace>::iterator i = nested_.begin(), end =
+        nested_.end(); i != end; ++i) {
+      i->second.WriteForwardDeclarations(os);
+    }
+    for (set<ImportedName>::iterator i = imported_names_.begin(), end =
+        imported_names_.end(); i != end; ++i) {
+      *os << (i->is_single_name() ? "using " : "using namespace ") << i->name()
+          << ";" << endl;
+    }
+    for (set<ForwardDeclaration>::iterator i = forward_declarations_.begin(), end =
+        forward_declarations_.end(); i != end; ++i) {
+      const char* metatype = i->type() == ForwardDeclaration::kClass ? "class" : "struct";
+      const string& type_name = i->name();
+      strmfmt(*os, "{0} {1};", metatype, type_name) << '\n';
+    }
+    EndNamespace(os);
+  }
+}
+
+void Namespace::WriteContents(std::ostream* os) {
+  if (HasContents()) {
+    BeginNamespace(os);
+    for (map<string, Namespace>::iterator i = nested_.begin(), end =
+        nested_.end(); i != end; ++i) {
+      i->second.WriteContents(os);
+    }
+    *os << contents_.str();
+    EndNamespace(os);
+  }
+}
+
+bool Namespace::HasForwardDeclarations() {
+  if (!forward_declarations_.empty() || !imported_names_.empty()) {
+    return true;
+  }
+  for (map<string, Namespace>::iterator i = nested_.begin(), end =
+      nested_.end(); i != end; ++i) {
+    if (i->second.HasForwardDeclarations()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool Namespace::HasContents() {
+  if (contents_.rdbuf()->in_avail()) {
+    return true;
+  }
+  for (map<string, Namespace>::iterator i = nested_.begin(), end =
+      nested_.end(); i != end; ++i) {
+    if (i->second.HasContents()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void Namespace::BeginNamespace(std::ostream* os) {
+  if (!global_) {
+    *os << "namespace";
+    if (!name_.empty()) {
+      *os << " " << name_;
+    }
+    *os << " {" << endl;
+  }
+}
+
+void Namespace::ImportName(const ImportedName& name) {
+  imported_names_.insert(name);
+}
+
+void Namespace::EndNamespace(std::ostream* os) {
+  if (!global_) {
+    *os << "}  " << Comment("namespace " + name_);
+  }
+  *os << endl;
+}
+
+Namespace::ForwardDeclaration::ForwardDeclaration(Type type,
+                                                  const std::string& name)
+    : type_(type),
+      name_(name) {
+}
+
+bool Namespace::ForwardDeclaration::operator <(
+    const ForwardDeclaration& that) const {
+  return this->name_ < that.name_;
+}
+
+const std::string& Namespace::ForwardDeclaration::name() const {
+  return name_;
+}
+
+Namespace::ForwardDeclaration::Type Namespace::ForwardDeclaration::type() const {
+  return type_;
+}
+
+Namespace::ImportedName::ImportedName(std::string name, bool single_name)
+    : single_name_(single_name),
+      name_(name) {
+}
+
+bool Namespace::ImportedName::operator <(const ImportedName& that) const {
+  if (single_name_ == that.single_name_)
+    return int(single_name_) < int(that.single_name_);
+  return name_ < that.name_;
+}
+
+const std::string& Namespace::ImportedName::name() const {
+  return name_;
+}
+
+bool Namespace::ImportedName::is_single_name() const {
+  return single_name_;
+}
+
+}  // namespace codegen
+
diff --git a/tools/intergen/cppgen/src/cppgen/naming_convention.cc b/tools/intergen/cppgen/src/cppgen/naming_convention.cc
new file mode 100644
index 0000000000..668577ec29
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/naming_convention.cc
@@ -0,0 +1,298 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/naming_convention.h"
+
+#include <algorithm>
+#include <cctype>
+#include <memory>
+#include <set>
+
+#include "model/interface.h"
+#include "utils/string_utils.h"
+
+using std::string;
+using std::vector;
+
+namespace codegen {
+
+namespace {
+
+bool IsAllUpper(const string& id) {
+  for (string::const_iterator i = id.begin(); i != id.end(); ++i) {
+    if (std::isalpha(*i) && std::islower(*i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool IsAllLower(const string& id) {
+  for (string::const_iterator i = id.begin(); i != id.end(); ++i) {
+    if (std::isalpha(*i) && std::isupper(*i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+}
+
+WordList::WordList() {
+}
+
+WordList::~WordList() {
+}
+
+WordList WordList::FromUnknown(const string& identifier) {
+  if (IsAllUpper(identifier)) {
+    return FromUnderscoreSeparated(identifier);
+  } else if (IsAllLower(identifier)) {
+    return FromUnderscoreSeparated(identifier);
+  } else {
+    return FromCamelCase(identifier);
+  }
+}
+
+WordList WordList::FromUnderscoreSeparated(const string& id) {
+  WordList res;
+  string::const_iterator word_begin = id.begin();
+  bool know_word_begin = true;
+  for (string::const_iterator i = id.begin() + 1; i != id.end(); ++i) {
+    if (std::isalnum(*i)) {
+      if (!know_word_begin) {
+        word_begin = i;
+        know_word_begin = true;
+      } else {
+      }
+    } else {  // not isalnum
+      if (know_word_begin) {
+        res.words_.push_back(string(word_begin, i));
+        know_word_begin = false;
+      } else {
+      }
+    }
+  }
+  res.words_.push_back(string(word_begin, id.end()));
+  res.Normalize();
+  return res;
+}
+
+WordList WordList::FromCamelCase(const string& id) {
+  WordList res;
+  string::const_iterator word_begin = id.begin();
+  bool last_upper = true;
+  bool multiple_upper = false;
+  for (string::const_iterator i = id.begin() + 1; i != id.end(); ++i) {
+    if (std::isupper(*i)) {
+      if (last_upper) {
+        multiple_upper = true;
+      } else {
+        res.words_.push_back(string(word_begin, i));
+        word_begin = i;
+        last_upper = true;
+        multiple_upper = false;
+      }
+    } else { // not isupper
+      if (multiple_upper) {
+        res.words_.push_back(string(word_begin, i - 1));
+        word_begin = i - 1;
+        last_upper = false;
+        multiple_upper = false;
+      } else {
+        last_upper = false;
+      }
+    }
+  }
+  res.words_.push_back(string(word_begin, id.end()));
+  res.Normalize();
+  return res;
+}
+
+WordList& WordList::operator +=(const WordList& that) {
+  words_.insert(words_.end(), that.words_.begin(), that.words_.end());
+  return *this;
+}
+
+string WordList::ToUpperCase() const {
+  string res;
+  if (!words_.empty())
+    res = to_upper(words_.front());
+  for (vector<string>::const_iterator i = words_.begin() + 1; i != words_.end();
+      ++i) {
+    res += "_" + to_upper(*i);
+  }
+  return res;
+}
+
+string WordList::ToCamelCase() const {
+  string res;
+  if (!words_.empty())
+    res = words_.front();
+  for (vector<string>::const_iterator i = words_.begin() + 1; i != words_.end();
+      ++i) {
+    string word = *i;
+    word[0] = std::toupper(word[0]);
+    res += word;
+  }
+  return res;
+}
+
+string WordList::ToLowerCase() const {
+  string res;
+  if (!words_.empty())
+    res = words_.front();
+  for (vector<string>::const_iterator i = words_.begin() + 1; i != words_.end();
+      ++i) {
+    res += "_" + *i;
+  }
+  return res;
+}
+
+string WordList::ToUpperCamelCase() const {
+  string res;
+  for (vector<string>::const_iterator i = words_.begin(); i != words_.end();
+      ++i) {
+    string word = *i;
+    word[0] = std::toupper(word[0]);
+    res += word;
+  }
+  return res;
+}
+
+void WordList::Normalize() {
+  for (vector<string>::iterator i = words_.begin(); i != words_.end(); ++i) {
+    *i = to_lower(*i);
+    trim(*i);
+  }
+}
+
+string WordList::Abbreviate() const {
+  string res;
+  for (vector<string>::const_iterator i = words_.begin(); i != words_.end(); ++i) {
+    res += (*i)[0];
+  }
+  return res;
+}
+
+std::string LowercaseIntefaceName(const Interface& interface) {
+  return WordList::FromUnknown(interface.name()).ToLowerCase();
+}
+
+std::string UpperCamelCaseInterfaceName(const Interface& interface) {
+  return WordList::FromUnknown(interface.name()).ToUpperCamelCase();
+}
+
+std::string InterfaceNamespaceName(const Interface& interface) {
+  return LowercaseIntefaceName(interface);
+}
+
+std::string Capitalize(const std::string& str) {
+  string res = str;
+  res[0] = std::toupper(res[0]);
+  return res;
+}
+
+std::string AvoidKeywords(const std::string& name) {
+  static const char* keywords_init[] = {
+    "asm",
+    "bool",
+    "catch",
+    "class",
+    "const_cast",
+    "default",
+    "delete",
+    "dynamic_cast",
+    "explicit",
+    "false",
+    "final",
+    "friend",
+    "inline",
+    "mutable",
+    "namespace",
+    "new",
+    "operator",
+    "override",
+    "private",
+    "protected",
+    "public",
+    "reinterpret_cast",
+    "static_cast",
+    "template",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeid",
+    "typename",
+    "using",
+    "virtual",
+    // std map functions to avoid collisions in frankenstruct
+    "at",
+    "begin",
+    "cbegin",
+    "cend",
+    "clear",
+    "count",
+    "crbegin",
+    "crend",
+    "emplace",
+    "emplace_hint",
+    "empty",
+    "end",
+    "equal_range",
+    "erase",
+    "find",
+    "get_allocator",
+    "insert",
+    "key_comp",
+    "lower_bound",
+    "max_size",
+    "rbegin",
+    "rend",
+    "size",
+    "swap",
+    "upper_bound",
+    "value_comp",
+  };
+  static const std::set<std::string> keywords(
+      keywords_init,
+      keywords_init + sizeof(keywords_init) / sizeof(keywords_init[0]));
+  if (keywords.count(name) != 0) {
+    return name + "_";
+  } else {
+    return name;
+  }
+}
+
+}  // namespace codegen
+
diff --git a/tools/intergen/cppgen/src/cppgen/struct_type_constructor.cc b/tools/intergen/cppgen/src/cppgen/struct_type_constructor.cc
new file mode 100644
index 0000000000..33256c7e27
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/struct_type_constructor.cc
@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/struct_type_constructor.h"
+
+#include <string>
+
+#include "cppgen/literal_generator.h"
+#include "cppgen/naming_convention.h"
+#include "cppgen/type_name_code_generator.h"
+#include "model/composite_type.h"
+#include "model/constant.h"
+
+using std::string;
+
+namespace codegen {
+
+StructTypeDefaultConstructor::StructTypeDefaultConstructor(
+    const Struct* strct,
+    const std::string& base_class_name)
+    : CppStructConstructor(strct->name()) {
+  if (!strct->frankenstruct()) {
+    Add(Initializer(base_class_name, "kUninitialized"));
+  }
+}
+
+StructTypeDefaultConstructor::~StructTypeDefaultConstructor() {
+}
+
+StructTypeMandatoryConstructor::StructTypeMandatoryConstructor(
+    const TypePreferences* preferences,
+    const Struct* strct,
+    const std::string& base_class_name)
+    : CppStructConstructor(strct->name()) {
+  // Pass kUnitialized to CompositeType constructor
+  // there is no actual difference which value to pick
+  if (!strct->frankenstruct()) {
+    Add(Initializer(base_class_name, "kUninitialized"));
+  }
+  const Struct::FieldsList& fields = strct->fields();
+  for (Struct::FieldsList::const_iterator i = fields.begin(), end =
+      fields.end(); i != end; ++i) {
+    const Struct::Field& field = *i;
+    if (field.default_value() || field.is_mandatory()) {
+      Add(Parameter(AvoidKeywords(field.name()),
+                    TypeNameGenerator(
+                      &strct->interface(),
+                      preferences,
+                      field.type()).result()));
+      Add(Initializer(AvoidKeywords(field.name()),
+                      AvoidKeywords(field.name())));
+    }
+  }
+}
+
+StructTypeMandatoryConstructor::~StructTypeMandatoryConstructor() {
+}
+
+void StructTypeMandatoryConstructor::DefineBody(std::ostream* os) const {
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/struct_type_dbus_serializer.cc b/tools/intergen/cppgen/src/cppgen/struct_type_dbus_serializer.cc
new file mode 100644
index 0000000000..5040652e43
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/struct_type_dbus_serializer.cc
@@ -0,0 +1,177 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/struct_type_dbus_serializer.h"
+
+#include "cppgen/naming_convention.h"
+#include "cppgen/type_name_code_generator.h"
+#include "model/composite_type.h"
+#include "utils/safeformat.h"
+
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+StructTypeDbusMessageSignatureMethod::StructTypeDbusMessageSignatureMethod(
+    const TypePreferences* preferences,
+    const Struct* strct,
+    bool substructure)
+    : CppFunction(strct->name(), "GetDbusSignature", "void", kStatic),
+      preferences_(preferences),
+      substructure_(substructure),
+      strct_(strct) {
+  Add(Parameter("signature", "std::string*"));
+}
+
+StructTypeDbusMessageSignatureMethod::~StructTypeDbusMessageSignatureMethod() {
+}
+
+void StructTypeDbusMessageSignatureMethod::DefineBody(std::ostream* os) const {
+  const Struct::FieldsList& fields = strct_->fields();
+  if (!fields.empty()) {
+    if (substructure_) {
+      *os << "(*signature) += DBUS_STRUCT_BEGIN_CHAR;\n";
+    }
+    for (Struct::FieldsList::const_iterator i = fields.begin(),
+         end = fields.end(); i != end; ++i) {
+      // Field is considered optional if it has mandatory=false attribute and
+      // if it does NOT have default values. Fields that have default values are
+      // always available no mater if they present in input or not
+      bool field_is_optional = false;
+      if (!i->is_mandatory()) {
+        if (i->default_value() == NULL) {
+          field_is_optional = true;
+        }
+      }
+      std::string field_type = RpcTypeNameGenerator(&strct_->interface(),
+                                                    preferences_,
+                                                    i->type(),
+                                                    field_is_optional).result();
+      strmfmt(*os, "rpc::DbusSignature< {0} >({1});\n",
+              field_type, parameters_[0].name);
+
+    }
+    if (substructure_) {
+      *os << "(*signature) += DBUS_STRUCT_END_CHAR;\n";
+    }
+  }
+}
+
+StructTypeFromDbusReaderConstructor::StructTypeFromDbusReaderConstructor(
+    const TypePreferences* preferences,
+    const Struct* strct,
+    bool substructure,
+    const std::string& base_class_name)
+    : CppStructConstructor(strct->name()),
+      preferences_(preferences),
+      strct_(strct),
+      substructure_(substructure) {
+  Add(Parameter("reader__", "dbus::MessageReader*"));
+  std::string base_initializer = "reader__";
+  if (!strct->frankenstruct()) {
+    base_initializer = "InitHelper(true)";
+  }
+  Add(Initializer(base_class_name, base_initializer));
+  // In case of non-substructure use initializer list to initialize fields
+  // From MessageReader passed in
+  if (!substructure_) {
+    const Struct::FieldsList& fields = strct->fields();
+    for (Struct::FieldsList::const_iterator i = fields.begin(), end = fields.end();
+         i != end; ++i) {
+      Add(Initializer(AvoidKeywords(i->name()),
+                      "reader__"));
+    }
+  }
+}
+
+StructTypeFromDbusReaderConstructor::~StructTypeFromDbusReaderConstructor() {
+}
+
+void StructTypeFromDbusReaderConstructor::DefineBody(std::ostream* os) const {
+  const Struct::FieldsList& fields = strct_->fields();
+  // If initializing substructure (a structure that is used as
+  // a field of other structure) additional structure reading iterator
+  // should be created
+  if (substructure_ && !fields.empty()) {
+    *os << "dbus::MessageReader subreader__ = reader__->TakeStructReader();\n";
+    for (Struct::FieldsList::const_iterator i = fields.begin(), end = fields.end();
+         i != end; ++i) {
+      // Field is considered optional if it has mandatory=false attribute and
+      // if it does NOT have default values. Fields that have default values are
+      // always available no mater if they present in input or not
+      bool field_is_optional = false;
+      if (!i->is_mandatory()) {
+        if (i->default_value() == NULL) {
+          field_is_optional = true;
+        }
+      }
+      std::string field_type = RpcTypeNameGenerator(&strct_->interface(),
+                                                    preferences_,
+                                                    i->type(),
+                                                    field_is_optional).result();
+      strmfmt(*os, "{0} = {1}(&subreader__);\n", i->name(), field_type);
+    }
+  }
+}
+
+StructTypeToDbusWriterMethod::StructTypeToDbusWriterMethod(
+    const Struct* strct,
+    bool substructure)
+    : CppFunction(strct->name(), "ToDbusWriter", "void", kConst),
+      substructure_(substructure),
+      strct_(strct) {
+  Add(Parameter("writer__", "dbus::MessageWriter*"));
+}
+
+StructTypeToDbusWriterMethod::~StructTypeToDbusWriterMethod() {
+
+}
+
+void StructTypeToDbusWriterMethod::DefineBody(std::ostream* os) const {
+  const Struct::FieldsList& fields = strct_->fields();
+  if (!fields.empty()) {
+    std::string writer_ptr_name = parameters_[0].name;
+    if (substructure_) {
+      strmfmt(*os, "dbus::MessageWriter subwriter__({0}, dbus::kStruct, NULL);\n",
+              writer_ptr_name);
+      writer_ptr_name = "&subwriter__";
+    }
+    for (Struct::FieldsList::const_iterator i = fields.begin(), end = fields.end();
+         i != end; ++i) {
+      strmfmt(*os, "{0}.ToDbusWriter({1});\n",
+              i->name(),
+              writer_ptr_name);
+    }
+  }
+}
+
+
+} // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/struct_type_from_json_method.cc b/tools/intergen/cppgen/src/cppgen/struct_type_from_json_method.cc
new file mode 100644
index 0000000000..1cdb35478e
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/struct_type_from_json_method.cc
@@ -0,0 +1,112 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/struct_type_from_json_method.h"
+
+
+#include "cppgen/literal_generator.h"
+#include "cppgen/naming_convention.h"
+#include "model/composite_type.h"
+#include "utils/safeformat.h"
+
+using typesafe_format::strmfmt;
+using typesafe_format::format;
+
+namespace codegen {
+
+StructTypeFromJsonConstructor::StructTypeFromJsonConstructor(
+    const Struct* strct,
+    const std::string& base_class_name)
+    : CppStructConstructor(strct->name()),
+      strct_(strct) {
+  Add(Parameter("value__", "const Json::Value*"));
+  std::string base_initializer = parameters_[0].name;
+  if (!strct->frankenstruct()) {
+    base_initializer =
+      format("InitHelper({0}, &Json::Value::isObject)", parameters_[0].name);
+  }
+  Add(Initializer(base_class_name, base_initializer));
+  const Struct::FieldsList& fields = strct_->fields();
+  for (Struct::FieldsList::const_iterator i = fields.begin(), end =
+      fields.end(); i != end; ++i) {
+    std::string initializer =
+        format("impl::ValueMember({0}, \"{1}\")",
+               parameters_[0].name,
+               i->name());
+    if (i->default_value()) {
+      std::string def_value = LiteralGenerator(*i->default_value()).result();
+      initializer += (", " + def_value);
+    }
+    Add(Initializer(AvoidKeywords(i->name()), initializer));
+  }
+}
+
+StructTypeFromJsonConstructor::~StructTypeFromJsonConstructor() {
+}
+
+void StructTypeFromJsonConstructor::DefineBody(std::ostream* os) const {
+  if (strct_->frankenstruct()) {
+    for (Struct::FieldsList::const_iterator i = strct_->fields().begin(),
+         end = strct_->fields().end(); i != end; ++i) {
+      const Struct::Field& field = *i;
+      strmfmt(*os, "erase(\"{0}\");\n",
+              field.name());
+    }
+  }
+}
+
+StructTypeToJsonMethod::StructTypeToJsonMethod(const Struct* strct)
+    : CppFunction(strct->name(), "ToJsonValue", "Json::Value", kConst),
+      strct_(strct) {
+}
+
+StructTypeToJsonMethod::~StructTypeToJsonMethod() {
+}
+
+void StructTypeToJsonMethod::DefineBody(std::ostream* os) const {
+  if (strct_->frankenstruct()) {
+    strmfmt(*os, "Json::Value result__(Frankenbase::{0}());\n",
+            name_);
+  } else {
+    *os << "Json::Value result__(Json::objectValue);" << '\n';
+  }
+  const Struct::FieldsList& fields = strct_->fields();
+  for (Struct::FieldsList::const_iterator i = fields.begin(), end =
+      fields.end(); i != end; ++i) {
+    const Struct::Field& field = *i;
+    strmfmt(*os, "impl::WriteJsonField(\"{0}\", {1}, &result__);\n",
+            field.name(), AvoidKeywords(field.name()));
+  }
+  *os << "return result__;" << '\n';
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/struct_type_is_initialized_method.cc b/tools/intergen/cppgen/src/cppgen/struct_type_is_initialized_method.cc
new file mode 100644
index 0000000000..d51aa7b7e9
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/struct_type_is_initialized_method.cc
@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/struct_type_is_initialized_method.h"
+
+#include <ostream>
+
+#include "cppgen/naming_convention.h"
+#include "model/composite_type.h"
+#include "utils/safeformat.h"
+
+using std::endl;
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+StructTypeIsInitializedMethod::StructTypeIsInitializedMethod(
+    const Struct* strct)
+    : CppFunction(strct->name(), "is_initialized", "bool", kConst),
+      strct_(strct) {
+}
+
+StructTypeIsInitializedMethod::~StructTypeIsInitializedMethod() {
+}
+
+void StructTypeIsInitializedMethod::DefineBody(std::ostream* os) const {
+  if (strct_->frankenstruct()) {
+    strmfmt(*os, "if (Frankenbase::{0}()) return true;\n",
+            name_);
+  }
+  *os << "return (initialization_state__ != kUninitialized) || (!struct_empty());\n";
+}
+
+StructTypeStructEmptyMethod::StructTypeStructEmptyMethod(const Struct* strct)
+    : CppFunction(strct->name(), "struct_empty", "bool", kConst),
+      strct_(strct) {
+}
+
+StructTypeStructEmptyMethod::~StructTypeStructEmptyMethod() {
+}
+
+void StructTypeStructEmptyMethod::DefineBody(std::ostream* os) const {
+  const Struct::FieldsList& fields = strct_->fields();
+  for (size_t i = 0; i != fields.size(); ++i) {
+    const Struct::Field& field = fields[i];
+    strmfmt(*os, "if ({0}.is_initialized()) return false;\n",
+            AvoidKeywords(field.name()));
+    if ((i % 2) == 1) {
+      *os << endl;
+    }
+  }
+  *os << "return true;\n";
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/struct_type_is_valid_method.cc b/tools/intergen/cppgen/src/cppgen/struct_type_is_valid_method.cc
new file mode 100644
index 0000000000..001f9a0478
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/struct_type_is_valid_method.cc
@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/struct_type_is_valid_method.h"
+
+#include <ostream>
+
+#include "cppgen/naming_convention.h"
+#include "cppgen/generator_preferences.h"
+#include "model/composite_type.h"
+#include "utils/safeformat.h"
+
+using std::endl;
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+StructTypeIsValidMethod::StructTypeIsValidMethod(const Struct* strct)
+    : CppFunction(strct->name(), "is_valid", "bool", kConst),
+      strct_(strct) {
+}
+
+StructTypeIsValidMethod::~StructTypeIsValidMethod() {
+}
+
+void StructTypeIsValidMethod::DefineBody(std::ostream* os) const {
+  if (strct_->frankenstruct()) {
+    strmfmt(*os, "if (!Frankenbase::{0}()) return false;\n",
+            name_);
+  }
+  const Struct::FieldsList& fields = strct_->fields();
+  bool struct_can_be_valid_empty = true;
+  for (size_t i = 0; i != fields.size(); ++i) {
+    if (fields[i].is_mandatory()) {
+      struct_can_be_valid_empty = false;
+    }
+  }
+  if (struct_can_be_valid_empty) {
+    *os << "if (struct_empty()) return initialization_state__ == kInitialized;\n";
+  }
+  for (size_t i = 0; i != fields.size(); ++i) {
+    strmfmt(*os, "if (!{0}.is_valid()) return false;\n",
+            AvoidKeywords(fields[i].name()));
+  }
+  *os << "return "<< func_names::kAdditionalValidation << "();\n";
+}
+
+StructTypeAdditionalValidationMethod::StructTypeAdditionalValidationMethod(
+    const Struct* strct)
+    : CppFunction(strct->name(), func_names::kAdditionalValidation, "bool",
+                  kConst),
+      strct_(strct) {
+}
+
+StructTypeAdditionalValidationMethod::~StructTypeAdditionalValidationMethod() {
+}
+
+void StructTypeAdditionalValidationMethod::DefineBody(std::ostream* os) const {
+  *os << "return true;" << endl;
+}
+
+}
+// namespace codegen
diff --git a/tools/intergen/cppgen/src/cppgen/struct_type_report_erros_method.cc b/tools/intergen/cppgen/src/cppgen/struct_type_report_erros_method.cc
new file mode 100644
index 0000000000..5b509e96aa
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/struct_type_report_erros_method.cc
@@ -0,0 +1,76 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/struct_type_report_erros_method.h"
+
+#include "cppgen/naming_convention.h"
+#include "model/composite_type.h"
+#include "utils/safeformat.h"
+#include "utils/string_utils.h"
+
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+StructTypeReportErrosMethod::StructTypeReportErrosMethod(const Struct* strct)
+  : CppFunction(strct->name(), "ReportErrors", "void", kConst),
+    strct_(strct) {
+  Add(Parameter("report__", "rpc::ValidationReport*"));
+}
+
+void StructTypeReportErrosMethod::DefineBody(std::ostream* os) const {
+  if (strct_->frankenstruct()) {
+    strmfmt(*os, "Frankenbase::{0}({1});\n",
+            name_, parameters_[0].name);
+  } else {
+    *os << "if (struct_empty()) {\n";
+    {
+      Indent ind(*os);
+      strmfmt(*os, "rpc::CompositeType::ReportErrors({0});\n", parameters_[0].name);
+    }
+    *os << "}\n";
+  }
+  const Struct::FieldsList& fields = strct_->fields();
+  for (size_t i = 0; i != fields.size(); ++i) {
+    const Struct::Field& field = fields[i];
+    strmfmt(*os, "if (!{0}.is_valid()) {\n", AvoidKeywords(field.name()));
+    {
+      Indent ind(*os);
+      strmfmt(*os, "{0}.ReportErrors(&{2}->ReportSubobject(\"{1}\"));\n",
+              AvoidKeywords(field.name()),
+              field.name(),
+              parameters_[0].name);
+    }
+    *os << "}\n";
+  }
+}
+
+} // namespace cppgen
diff --git a/tools/intergen/cppgen/src/cppgen/type_name_code_generator.cc b/tools/intergen/cppgen/src/cppgen/type_name_code_generator.cc
new file mode 100644
index 0000000000..08eedbca0f
--- /dev/null
+++ b/tools/intergen/cppgen/src/cppgen/type_name_code_generator.cc
@@ -0,0 +1,305 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "cppgen/type_name_code_generator.h"
+
+#include <algorithm>
+#include <cassert>
+#include <limits>
+
+#include "cppgen/generator_preferences.h"
+#include "cppgen/naming_convention.h"
+#include "model/builtin_type.h"
+#include "model/composite_type.h"
+#include "utils/safeformat.h"
+
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+namespace {
+template <class T>
+std::string TypeNamespacePrefix(const Interface* current_interface,
+                                const T* type) {
+  std::string ns;
+  const Interface& type_interface = type->interface();
+  if (&type_interface != current_interface) {
+    ns = InterfaceNamespaceName(type_interface) + "::";
+  }
+  return ns;
+}
+}
+
+namespace {
+const char* StdIntTypeFromRagne(
+    const TypePreferences& preferences,
+    const Integer::Range& range) {
+  if (preferences.avoid_unsigned || range.min() < 0) {
+    Integer::Range int8_t_range(-128, 127);
+    Integer::Range int16_t_range(-32768, 32767);
+    Integer::Range int32_t_range(-2147483648, 2147483647);
+    if (int8_t_range.Includes(range)
+        && preferences.minimum_interger_size <= 8) {
+      return "int8_t";
+    } else if (int16_t_range.Includes(range)
+               && preferences.minimum_interger_size <= 16) {
+      return "int16_t";
+    } else if (int32_t_range.Includes(range)
+               && preferences.minimum_interger_size <= 32) {
+      return "int32_t";
+    }
+  } else {
+    Integer::Range uint8_t_range(0, 255);
+    Integer::Range uint16_t_range(0, 65535);
+    Integer::Range uint32_t_range(0, 4294967295);
+    if (uint8_t_range.Includes(range)
+        && preferences.minimum_interger_size <= 8) {
+      return "uint8_t";
+    } else if (uint16_t_range.Includes(range)
+               && preferences.minimum_interger_size <= 16) {
+      return "uint16_t";
+    } else if (uint32_t_range.Includes(range)
+               && preferences.minimum_interger_size <= 32) {
+      return "uint32_t";
+    }
+  }
+  return "int64_t";
+}
+}  // namespace
+
+TypeNameGenerator::TypeNameGenerator(const Interface* interface,
+                                     const TypePreferences* preferences,
+                                     const Type* type)
+    : interface_(interface),
+      preferences_(preferences),
+      prefer_reference_type_(true) {
+  type->Apply(this);
+}
+
+TypeNameGenerator::~TypeNameGenerator() {
+}
+
+std::string TypeNameGenerator::result() const {
+  return os_.str();
+}
+
+void TypeNameGenerator::GenerateCodeForBoolean(const Boolean* boolean) {
+  os_ << "bool";
+}
+
+void TypeNameGenerator::GenerateCodeForInteger(const Integer* integer) {
+  os_ << StdIntTypeFromRagne(*preferences_, integer->range());
+}
+
+void TypeNameGenerator::GenerateCodeForFloat(const Float* flt) {
+  os_ << "double";
+}
+
+void TypeNameGenerator::GenerateCodeForString(const String* string) {
+  os_ << (prefer_reference_type_ ? "const std::string&" : "std::string");
+}
+
+void TypeNameGenerator::GenerateCodeForEnum(const Enum* enm) {
+  os_ << TypeNamespacePrefix(interface_, enm) << enm->name();
+}
+
+void TypeNameGenerator::GenerateCodeForArray(const Array* array) {
+  const char* vect_decl_begin =
+      prefer_reference_type_ ? "const std::vector<" : "std::vector<";
+  const char* vect_decl_end = prefer_reference_type_ ? ">&" : ">";
+  // Vector can not contain references
+  prefer_reference_type_ = false;
+  os_ << vect_decl_begin;
+  array->type()->Apply(this);
+  os_ << vect_decl_end;
+}
+
+void TypeNameGenerator::GenerateCodeForMap(const Map* map) {
+  const char* map_decl_begin =
+      prefer_reference_type_ ?
+          "const std::map<std::string, " : "std::map<std::string, ";
+  const char* map_decl_end = prefer_reference_type_ ? ">&" : ">";
+  // Map can not contain references too
+  prefer_reference_type_ = false;
+  os_ << map_decl_begin;
+  map->type()->Apply(this);
+  os_ << map_decl_end;
+}
+
+void TypeNameGenerator::GenerateCodeForNullable(const NullableType* nullable) {
+  // Just generate a type name without special qualifiers
+  nullable->type()->Apply(this);
+}
+
+void TypeNameGenerator::GenerateCodeForStruct(const Struct* strct) {
+  const char* struct_decl_begin = prefer_reference_type_ ? "const " : "";
+  const char* struct_decl_end = prefer_reference_type_ ? "&" : "";
+  os_ << struct_decl_begin
+      << TypeNamespacePrefix(interface_, strct) << strct->name()
+      << struct_decl_end;
+}
+
+void TypeNameGenerator::GenerateCodeForTypedef(const Typedef* tdef) {
+  const char* typedef_decl_begin = prefer_reference_type_ ? "const " : "";
+  const char* typedef_decl_end = prefer_reference_type_ ? "&" : "";
+  os_ << typedef_decl_begin
+      << TypeNamespacePrefix(interface_, tdef) << tdef->name()
+      << typedef_decl_end;
+}
+
+RpcTypeNameGenerator::RpcTypeNameGenerator(const Interface* interface,
+                                           const TypePreferences* preferences,
+                                           const Type* type,
+                                           bool optional)
+    : interface_(interface),
+      preferences_(preferences) {
+  if (optional) {
+    os_ << "Optional< ";
+  }
+  type->Apply(this);
+  if (optional) {
+    os_ << " >";
+  }
+}
+
+RpcTypeNameGenerator::~RpcTypeNameGenerator() {
+}
+
+std::string RpcTypeNameGenerator::result() const {
+  return os_.str();
+}
+
+void RpcTypeNameGenerator::GenerateCodeForBoolean(const Boolean* boolean) {
+  os_ << "Boolean";
+}
+
+void RpcTypeNameGenerator::GenerateCodeForInteger(const Integer* integer) {
+  const char* int_type = StdIntTypeFromRagne(*preferences_, integer->range());
+  strmfmt(os_, "Integer<{0}, {1}, {2}>", int_type, integer->range().min(),
+          integer->range().max());
+}
+
+void RpcTypeNameGenerator::GenerateCodeForFloat(const Float* flt) {
+  const Fraction& minval = flt->range().min_fract();
+  const Fraction& maxval = flt->range().max_fract();
+  strmfmt(os_, "Float<{0}, {1}", minval.numer(), maxval.numer());
+  if (minval.denumer() == 1 && maxval.denumer() == 1) {
+    os_ << ">";
+  } else {
+    strmfmt(os_, ", {0}, {1}>", minval.denumer(), maxval.denumer());
+  }
+}
+
+void RpcTypeNameGenerator::GenerateCodeForString(const String* string) {
+  strmfmt(os_, "String<{0}, {1}>", string->length_range().min(),
+          string->length_range().max());
+}
+
+void RpcTypeNameGenerator::GenerateCodeForEnum(const Enum* enm) {
+  strmfmt(os_, "Enum<{0}>", TypeNamespacePrefix(interface_, enm) + enm->name());
+}
+
+void RpcTypeNameGenerator::GenerateCodeForArray(const Array* array) {
+  os_ << "Array< ";
+  array->type()->Apply(this);
+  strmfmt(os_, ", {0}, {1} >",
+          array->range().min(),
+          array->range().max());
+}
+
+void RpcTypeNameGenerator::GenerateCodeForMap(const Map* map) {
+  os_ << "Map< ";
+  map->type()->Apply(this);
+  strmfmt(os_, ", {0}, {1} >",
+          map->range().min(),
+          map->range().max());
+}
+
+void RpcTypeNameGenerator::GenerateCodeForNullable(
+    const NullableType* nullable) {
+  os_ << "Nullable< ";
+  nullable->type()->Apply(this);
+  os_ << " >";
+}
+
+void RpcTypeNameGenerator::GenerateCodeForStruct(const Struct* strct) {
+  os_ << TypeNamespacePrefix(interface_, strct) + strct->name();
+}
+
+void RpcTypeNameGenerator::GenerateCodeForTypedef(const Typedef* tdef) {
+  os_ << TypeNamespacePrefix(interface_, tdef) + tdef->name();
+}
+
+TypeProperties::TypeProperties(const Type* type)
+  : container_(false) {
+  type->Apply(this);
+}
+
+bool TypeProperties::is_container() const {
+  return container_;
+}
+
+void TypeProperties::GenerateCodeForBoolean(const Boolean* boolean) {
+}
+
+void TypeProperties::GenerateCodeForInteger(const Integer* integer) {
+}
+
+void TypeProperties::GenerateCodeForFloat(const Float* flt) {
+}
+
+void TypeProperties::GenerateCodeForString(const String* string) {
+}
+
+void TypeProperties::GenerateCodeForEnum(const Enum* enm) {
+}
+
+void TypeProperties::GenerateCodeForArray(const Array* array) {
+  container_ = true;
+}
+
+void TypeProperties::GenerateCodeForMap(const Map* map) {
+  container_ = true;
+}
+
+void TypeProperties::GenerateCodeForNullable(const NullableType* nullable) {
+  nullable->type()->Apply(this);
+}
+
+void TypeProperties::GenerateCodeForStruct(const Struct* strct) {
+}
+
+void TypeProperties::GenerateCodeForTypedef(const Typedef* tdef) {
+  tdef->type()->Apply(this);
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/model/CMakeLists.txt b/tools/intergen/model/CMakeLists.txt
new file mode 100644
index 0000000000..e69c129211
--- /dev/null
+++ b/tools/intergen/model/CMakeLists.txt
@@ -0,0 +1,37 @@
+include_directories(
+  include
+  ${pugixml_SOURCE_DIR}/../src
+  ${intergen_SOURCE_DIR}/utils/include
+)
+
+set (SOURCES
+  src/model/api.cc
+  src/model/builtin_type.cc
+  src/model/builtin_type_registry.cc
+  src/model/composite_type.cc
+  src/model/constant.cc
+  src/model/function.cc
+  src/model/interface.cc
+  src/model/model_filter.cc
+  src/model/scope.cc
+  src/model/type.cc
+  src/model/type_registry.cc
+)
+
+set (HEADERS
+  include/model/api.h
+  include/model/builtin_type.h
+  include/model/builtin_type_registry.h
+  include/model/composite_type.h
+  include/model/constant.h
+  include/model/constants_creator.h
+  include/model/function.h
+  include/model/interface.h
+  include/model/model_filter.h
+  include/model/scope.h
+  include/model/type.h
+  include/model/type_registry.h
+)
+
+add_library(intergen_model ${HEADERS} ${SOURCES})
+target_link_libraries(intergen_model intergen_utils pugixml)
diff --git a/tools/intergen/model/include/model/api.h b/tools/intergen/model/include/model/api.h
new file mode 100644
index 0000000000..6deb18d1d0
--- /dev/null
+++ b/tools/intergen/model/include/model/api.h
@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef API_H_
+#define API_H_
+#include <vector>
+#include <map>
+
+#include "model/builtin_type_registry.h"
+#include "model/interface.h"
+#include "utils/macro.h"
+#include "utils/stl_utils.h"
+
+namespace pugi {
+class xml_document;
+}  // namespace pugi
+
+namespace codegen {
+class ModelFilter;
+
+/*
+ * Represents single parsed XML file that defines an API
+ */
+class API {
+ public:
+  // Constructs object that represents whole API that contain
+  // all the defined interfaces.
+  // |model_filter| provied information on which entites to exclude
+  // from API. If |auto_generate_func_ids| is true FunctionID enum
+  // is generated automatically.
+  API(const ModelFilter* model_filter, bool auto_generate_func_ids);
+  // Follows parsed |xmldoc| collecting and validating API definitions
+  // Returns false and prints to cerr on error
+  bool init(const pugi::xml_document& xmldoc);
+  ~API();
+  // List of all interfaces collected from xml document
+  const std::vector<Interface*>& interfaces() const;
+  // Get interface by name
+  // returns NULL if there is no interface with given name
+  const Interface* InterfaceByName(const std::string& name) const;
+ private:
+  // Types
+  typedef std::map<std::string, size_t> InterfacesIndex;
+ private:
+  // Methods
+  bool AddInterfaces(const pugi::xml_node& xmldoc);
+ private:
+  // Fields
+  const ModelFilter* model_filter_;
+  bool auto_generate_func_ids_;
+  BuiltinTypeRegistry builtin_type_registry_;
+  std::vector<Interface*> interfaces_;
+  utils::StdContainerDeleter<std::vector<Interface*> > interfaces_deleter_;
+  InterfacesIndex interfaces_index_;
+  DISALLOW_COPY_AND_ASSIGN(API);
+};
+
+}  // namespace codegen
+
+#endif /* API_H_ */
diff --git a/tools/intergen/model/include/model/builtin_type.h b/tools/intergen/model/include/model/builtin_type.h
new file mode 100644
index 0000000000..a9951a253e
--- /dev/null
+++ b/tools/intergen/model/include/model/builtin_type.h
@@ -0,0 +1,150 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef BUILTIN_TYPE_H_
+#define BUILTIN_TYPE_H_
+
+#include <stdint.h>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "model/constants_creator.h"
+#include "model/type.h"
+#include "utils/common_types.h"
+
+namespace codegen {
+
+/*
+ * Boolean type
+ */
+class Boolean : public Type, public ConstantsCreator {
+ public:
+  // Types
+  class Constant;
+ public:
+  // Methods
+  Boolean();
+  ~Boolean();
+  // codegen::Type methods
+  virtual TypeCodeGenerator* Apply(TypeCodeGenerator* code_generator) const;
+  virtual const ConstantsCreator* SupportsConstants() const;
+  // codegen::SupportsLiterals methods
+  virtual const codegen::Constant* ConstantFor(
+      const std::string& literal) const;
+
+ public:
+  // Complete inner class declarations
+
+ private:
+  // Fields
+  std::vector<Constant> constants_;
+};
+
+/*
+ * Integer type
+ */
+class Integer : public Type, public ConstantsCreator {
+ public:
+  // Types
+  typedef BasicRange<int64_t> Range;
+  class Constant;
+ public:
+  // Methods
+  Integer(const Range& range);
+  ~Integer();
+  const Range& range() const;
+  bool operator<(const Integer& that) const;
+
+  // codegen::Type methods
+  virtual TypeCodeGenerator* Apply(TypeCodeGenerator* code_generator) const;
+  virtual const ConstantsCreator* SupportsConstants() const;
+  // codegen::SupportsLiterals methods
+  virtual const codegen::Constant* ConstantFor(
+      const std::string& literal) const;
+ private:
+  // Fields
+  Range range_;
+  mutable std::set<Constant> constants_;
+};
+
+/*
+ * Float type
+ */
+class Float : public Type, public ConstantsCreator {
+ public:
+  // Types
+  typedef BasicRange<double> Range;
+  class Constant;
+ public:
+  // Methods
+  Float(const Range& range);
+  ~Float();
+  const Range& range() const;
+  bool operator<(const Float& that) const;
+
+  // codegen::Type methods
+  virtual TypeCodeGenerator* Apply(TypeCodeGenerator* code_generator) const;
+  virtual const ConstantsCreator* SupportsConstants() const;
+  // codegen::SupportsLiterals methods
+  virtual const codegen::Constant* ConstantFor(
+      const std::string& literal) const;
+ private:
+  // Fields
+  Range range_;
+  mutable std::set<Constant> constants_;
+};
+
+/*
+ * String type
+ */
+class String : public Type {
+ public:
+  // Types
+  typedef BasicRange<int64_t> Range;
+public:
+  // Methods
+  String(const Range& range);
+  bool operator<(const String& that) const;
+  const Range& length_range() const;
+  // codegen::Type methods
+  virtual TypeCodeGenerator* Apply(TypeCodeGenerator* code_generator) const;
+  virtual const ConstantsCreator* SupportsConstants() const;
+
+private:
+  // Fields
+  Range length_range_;
+};
+
+}  // namespace codegen
+
+#endif /* BUILTIN_TYPE_H_ */
diff --git a/tools/intergen/model/include/model/builtin_type_registry.h b/tools/intergen/model/include/model/builtin_type_registry.h
new file mode 100644
index 0000000000..1730984cc4
--- /dev/null
+++ b/tools/intergen/model/include/model/builtin_type_registry.h
@@ -0,0 +1,91 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef BUILTIN_TYPE_REGISTRY_H_
+#define BUILTIN_TYPE_REGISTRY_H_
+
+#include <stdint.h>
+#include <set>
+#include <string>
+
+#include "model/builtin_type.h"
+#include "model/type.h"
+
+namespace pugi {
+class xml_node;
+}  // namespace pugi
+
+namespace codegen {
+
+/*
+ * Factory and owner of all built-in types graph.
+ * Types have restrictions which are considered to be part of type
+ * (not part of struct field / function parameter definition)
+ */
+class BuiltinTypeRegistry {
+ public:
+  // List of all built-in types managed by this type registry
+  enum BuiltInType {
+    kBoolean,
+    kString,
+    kInteger,
+    kFloat,
+    kNotABuiltInType
+  };
+  BuiltinTypeRegistry();
+  ~BuiltinTypeRegistry();
+  // Checks whether |type_name| is a built-in type name and returns
+  // appropriate BuiltInType value.
+  // Returns kNotABuiltInType if |type_name| contains unknown type name.
+  BuiltInType BuiltInTypeByName(const std::string& type_name);
+  // Creates type object based on it's |type_id| and type-dependent
+  // xml |params| and stores it into |type|.
+  // If |params| doesn't contain all required parameters,
+  // |type| is left untouched and false is returned.
+  bool GetType(BuiltInType type_id, const pugi::xml_node& params,
+               const Type** type);
+ private:
+  // Caching factories for supported types
+  const Boolean* GetBoolean();
+  const Integer* GetInteger(const Integer::Range& range);
+  const Float* GetFloat(const Float::Range& range);
+  const String* GetString(const String::Range& length_range);
+ private:
+  Boolean boolean_;
+  std::set<Integer> integers_;
+  std::set<Float> floats_;
+  std::set<String> strings_;
+};
+
+}  // namespace codegen
+
+#endif /* BUILTIN_TYPE_REGISTRY_H_ */
diff --git a/tools/intergen/model/include/model/composite_type.h b/tools/intergen/model/include/model/composite_type.h
new file mode 100644
index 0000000000..ae60a53a77
--- /dev/null
+++ b/tools/intergen/model/include/model/composite_type.h
@@ -0,0 +1,257 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef COMPOSITE_TYPE_H_
+#define COMPOSITE_TYPE_H_
+
+#include <stdint.h>
+#include <map>
+#include <string>
+#include <list>
+
+#include "model/constants_creator.h"
+#include "model/scope.h"
+#include "model/type.h"
+#include "utils/common_types.h"
+#include "utils/macro.h"
+
+
+namespace codegen {
+class Interface;
+
+class Array : public Type {
+ public:
+  // Types
+  typedef BasicRange<int64_t> Range;
+ public:
+  // Methods
+  Array(const Type* type, const Range& range);
+  ~Array();
+  const Type* type() const;
+  const Range& range() const;
+  bool operator<(const Array& that) const;
+  // codegen::Type methods
+  virtual TypeCodeGenerator* Apply(TypeCodeGenerator* code_generator) const;
+  virtual const ConstantsCreator* SupportsConstants() const;
+
+ private:
+  // Fields
+  const Type* type_;
+  Range range_;
+};
+
+class Map : public Type {
+ public:
+  // Types
+  typedef BasicRange<int64_t> Range;
+ public:
+  // Methods
+  Map(const Type* type, const Range& range);
+  ~Map();
+  const Type* type() const;
+  const Range& range() const;
+  bool operator<(const Map& that) const;
+  // codegen::Type methods
+  virtual TypeCodeGenerator* Apply(TypeCodeGenerator* code_generator) const;
+  virtual const ConstantsCreator* SupportsConstants() const;
+
+ private:
+  // Fields
+  const Type* type_;
+  Range range_;
+};
+
+class Enum : public Type, public ConstantsCreator {
+ public:
+  // Types
+  class Constant;
+  typedef std::list<Enum::Constant> ConstantsList;
+  typedef std::map<std::string, Constant*> ConstantsByName;
+public:
+  // Constants
+  // Name of enum that enlists IDs of all interface functions
+  static const char* kFunctionIdEnumName;
+ public:
+  // Methods
+  Enum(const Interface* interface,
+       const std::string& name,
+       Scope scope,
+       InternalScope internal_scope,
+       const Description& description);
+  ~Enum();
+  const Interface& interface() const;
+  const std::string& name() const;
+  const ConstantsList& constants() const;
+  const ConstantsByName& constants_by_name() const;
+  const Scope& scope() const;
+  const InternalScope& internal_scope() const;
+  const Description& description() const;
+
+  // codegen::Type methods
+  virtual TypeCodeGenerator* Apply(TypeCodeGenerator* code_generator) const;
+  virtual const ConstantsCreator* SupportsConstants() const;
+  // codegen::ConstantsCreator methods
+  virtual const codegen::Constant* ConstantFor(
+      const std::string& literal) const;
+  bool AddConstant(const std::string& name, Scope scope,
+                   const std::string& internal_name,
+                   const Description& description,
+                   const std::string& design_description);
+  bool AddConstant(const std::string& name, const int64_t value, Scope scope,
+                   const std::string& internal_name,
+                   const Description& description,
+                   const std::string& design_description);
+ private:
+  // Fields
+  const Interface* interface_;
+  std::string name_;
+  ConstantsList constants_;
+  Scope scope_;
+  InternalScope internal_scope_;
+  Description description_;
+
+  ConstantsByName constants_by_name_;
+  int64_t last_constant_value_;
+  DISALLOW_COPY_AND_ASSIGN(Enum);
+};
+
+/*
+ * Struct type
+ */
+class Struct : public Type {
+ public:
+  // Types
+  class Field;
+  typedef std::vector<Field> FieldsList;
+ public:
+  // Methods
+  Struct(const Interface* interface,
+         const std::string& name,
+         const Type* frankenmap,
+         Scope scope,
+         const Description& description);
+  ~Struct();
+  const Interface& interface() const;
+  // Returns frankenstruct type if this struct is frankenstruct
+  const Type* frankenstruct() const;
+  const std::string& name() const;
+  const Description& description() const;
+  const FieldsList& fields() const;
+  const Scope& scope() const;
+  bool AddField(const Type* type, const std::string& name, bool mandatory,
+                Scope scope, const Constant* default_value,
+                const Description& description, Platform platform);
+  // codegen::Type methods
+  virtual TypeCodeGenerator* Apply(TypeCodeGenerator* code_generator) const;
+  virtual const ConstantsCreator* SupportsConstants() const;
+
+ private:
+  // Fields
+  const Interface* interface_;
+  std::string name_;
+  const Type* frankenmap_;
+  Scope scope_;
+  Description description_;
+  FieldsList fields_;
+  DISALLOW_COPY_AND_ASSIGN(Struct);
+};
+
+class Struct::Field {
+ public:
+  // Methods
+  const Type* type() const;
+  const std::string& name() const;
+  bool is_mandatory() const;
+  const Constant* default_value() const;
+  const Scope& scope() const;
+  const Description& description() const;
+
+ private:
+  // Methods
+  Field(const Type* type, const std::string& name, bool mandatory, Scope scope,
+        const Constant* default_value, const Description& description, Platform platform);
+ private:
+  // Fields
+  const Type* type_;
+  std::string name_;
+  bool mandatory_;
+  const Constant* default_value_;
+  Scope scope_;
+  Description description_;
+  Platform platform_;
+  friend class Struct;
+};
+
+/*
+ *  Nullable type decorator
+ */
+class NullableType : public Type {
+ public:
+  // Methods
+  NullableType(const Type* type);
+  const Type* type() const;
+  bool operator<(const NullableType& that) const;
+  // codegen::Type methods
+  virtual TypeCodeGenerator* Apply(TypeCodeGenerator* code_generator) const;
+  virtual const ConstantsCreator* SupportsConstants() const;
+ private:
+  const Type* type_;
+};
+
+/*
+ * Typedef type
+ */
+class Typedef : public Type {
+ public:
+  Typedef(const Interface* interface,
+          const std::string& name,
+          const Type* type,
+          const Description& description);
+
+  // codegen::Type methods
+  virtual TypeCodeGenerator* Apply(TypeCodeGenerator* code_generator) const;
+  virtual const ConstantsCreator* SupportsConstants() const;
+  const Description& description() const;
+  const Interface& interface() const;
+  const std::string& name() const;
+  const Type* type() const;
+
+ private:
+  const Interface* interface_;
+  std::string name_;
+  const Type* type_;
+  Description description_;
+};
+
+}  // namespace codegen
+
+#endif /* COMPOSITE_TYPE_H_ */
diff --git a/tools/intergen/model/include/model/constant.h b/tools/intergen/model/include/model/constant.h
new file mode 100644
index 0000000000..b3659905c0
--- /dev/null
+++ b/tools/intergen/model/include/model/constant.h
@@ -0,0 +1,164 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CONSTANT_H_
+#define CONSTANT_H_
+
+#include <string>
+
+#include "model/builtin_type.h"
+#include "model/composite_type.h"
+#include "utils/common_types.h"
+
+namespace codegen {
+class Type;
+class ConstantCodeGenerator;
+
+class Constant {
+ public:
+  virtual const Type* type() const = 0;
+  virtual void Apply(ConstantCodeGenerator* generator) const = 0;
+  virtual ~Constant();
+};
+
+class Boolean::Constant : public codegen::Constant {
+ public:
+  ~Constant();
+  bool value() const;
+  bool is_valid() const;
+  bool operator==(const Boolean::Constant& that) const;
+  // codegen::Constant methods
+  virtual const Boolean* type() const;
+  virtual void Apply(ConstantCodeGenerator* generator) const;
+ private:
+  // Methods
+  Constant(const Boolean* type, const std::string& literal);
+
+ private:
+  const Boolean* type_;
+  bool value_;
+  bool valid_;
+  friend class Boolean;
+};
+
+class Integer::Constant : public codegen::Constant {
+ public:
+  ~Constant();
+  // Methods
+  int64_t value() const;
+  bool is_valid() const;
+  bool operator<(const Constant& that) const;
+  // codegen::Constant methods
+  virtual const Integer* type() const;
+  virtual void Apply(ConstantCodeGenerator* generator) const;
+
+ private:
+  // Methods
+  Constant(const Integer* type, const std::string& literal);
+
+ private:
+  // Fields
+  const Integer* type_;
+  int64_t value_;
+  bool valid_;
+  friend class Integer;
+};
+
+class Float::Constant : public codegen::Constant {
+ public:
+  ~Constant();
+  // Methods
+  double value() const;
+  bool is_valid() const;
+  bool operator<(const Constant& that) const;
+  // codegen::Constant methods
+  virtual const Float* type() const;
+  virtual void Apply(ConstantCodeGenerator* generator) const;
+
+ private:
+  // Methods
+  Constant(const Float* type, const std::string& literal);
+
+ private:
+  // Fields
+  const Float* type_;
+  double value_;
+  bool valid_;
+  friend class Float;
+};
+
+class Enum::Constant : public codegen::Constant {
+ public:
+  // Methods
+  ~Constant();
+  const std::string& name() const;
+  int64_t value() const;
+  bool is_value_explicit() const;
+  const Scope& scope() const;
+  const std::string& internal_name() const;
+  const Description& description() const;
+  const std::string& design_description() const;
+
+  // codegen::Constant methods
+  virtual const Enum* type() const;
+  virtual void Apply(ConstantCodeGenerator* generator) const;
+
+ private:
+  // Methods
+  Constant(Enum* enm, const std::string& name, const int64_t value,
+           bool value_explicit, Scope scope, const std::string& internal_name,
+           const Description& description, const std::string& design_description);
+ private:
+  // Fields
+  Enum* type_;
+  std::string name_;
+  int64_t value_;
+  bool value_explicit_;
+  Scope scope_;
+  std::string internal_name_;
+  Description description_;
+  std::string design_description_;
+  friend class Enum;
+};
+
+class ConstantCodeGenerator {
+ public:
+  virtual void GenerateCodeForBooleanConstant(const Boolean::Constant* boolean);
+  virtual void GenerateCodeForIntegerConstant(const Integer::Constant* integer);
+  virtual void GenerateCodeForFloatConstant(const Float::Constant* flt);
+  virtual void GenerateCodeForEnumConstant(const Enum::Constant* enm);
+  virtual ~ConstantCodeGenerator();
+};
+
+}  // namespace codegen
+
+#endif /* CONSTANT_H_ */
diff --git a/tools/intergen/model/include/model/constants_creator.h b/tools/intergen/model/include/model/constants_creator.h
new file mode 100644
index 0000000000..963598418a
--- /dev/null
+++ b/tools/intergen/model/include/model/constants_creator.h
@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CONSTANTS_CREATOR_H_
+#define CONSTANTS_CREATOR_H_
+
+#include <string>
+
+namespace codegen {
+class Constant;
+
+/*
+ * Interface for all Types that can have values represented as string literals.
+ */
+class ConstantsCreator {
+ public:
+  // Creates Constant value from given string literal.
+  // Exact Constant type and literal parsing rules must be defined by Type
+  // Implementing this interface
+  // Shall return NULL if literal does not represent valid value.
+  virtual const Constant* ConstantFor(const std::string& literal) const = 0;
+  virtual ~ConstantsCreator();
+};
+
+}  // namespace codegen
+
+#endif /* CONSTANTS_CREATOR_H_ */
diff --git a/tools/intergen/model/include/model/function.h b/tools/intergen/model/include/model/function.h
new file mode 100644
index 0000000000..bbe32a076f
--- /dev/null
+++ b/tools/intergen/model/include/model/function.h
@@ -0,0 +1,126 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FUNCTION_H_
+#define FUNCTION_H_
+#include <map>
+#include <string>
+
+#include "model/constant.h"
+#include "model/scope.h"
+#include "model/type.h"
+#include "utils/common_types.h"
+#include "utils/macro.h"
+#include "utils/stl_utils.h"
+
+namespace codegen {
+class Interface;
+
+/*
+ * Class representing single RPC message and it's parameters,
+ * can be request, response or notification.
+ * Message parameters are passed as structures so message is based
+ * on it's implementation
+ */
+class FunctionMessage: public Struct {
+ public:
+  // Types
+  enum MessageType {
+    kRequest,
+    kResponse,
+    kNotification,
+    kUnknownMessageType
+  };
+  // Procudes string given MessageType to be used in class names
+  static const char* MessageTypeToString(MessageType message_type);
+
+  // Message parameters are passed as structs so every parameter
+  // is a struct field
+  typedef Field Parameter;
+  typedef FieldsList ParametersList;
+ public:
+  // Methods
+
+  // Returns message type named by string literal.
+  // Return kUnknownMessageType if literal names unknown message type
+  static MessageType MessageTypeFromLiteral(const std::string& literal);
+  // Creates Function message and associates it with given |interface|
+  FunctionMessage(const Interface* interface, const std::string& name,
+                  const Enum::Constant* id, MessageType message_type,
+                  const Description& description, Scope scope);
+  ~FunctionMessage();
+  // Returns function ID which is one of the "FunctionID" enum constants
+  const Enum::Constant* id() const;
+  // List of function parameters
+  const ParametersList& parameters() const;
+  // Constructs message parameter and stores it
+  bool AddParameter(const std::string& name, const Type* type,
+                    const Constant* default_value, bool is_mandatory,
+                    const Description& description, Scope scope,
+                    Platform platform);
+  const Interface* interface() const;
+
+private:
+  const Interface* interface_;
+  const Enum::Constant* id_;
+  MessageType message_type_;
+  DISALLOW_COPY_AND_ASSIGN(FunctionMessage);
+};
+
+typedef FunctionMessage Request;
+typedef FunctionMessage Response;
+typedef FunctionMessage Notification;
+
+/*
+ * A container that bounds a request type to it's corresponding response
+ * type
+ */
+class Function {
+ public:
+  Function(const Request* request, const Response* response);
+
+  const Request& request() const {
+    return *request_;
+  }
+
+  const Response& response() const {
+    return *response_;
+  }
+
+ private:
+  const Request* request_;
+  const Response* response_;
+};
+
+}  // namespace codegen
+
+#endif /* FUNCTION_H_ */
diff --git a/tools/intergen/model/include/model/interface.h b/tools/intergen/model/include/model/interface.h
new file mode 100644
index 0000000000..dc9398eb3e
--- /dev/null
+++ b/tools/intergen/model/include/model/interface.h
@@ -0,0 +1,144 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef INTERFACE_H_
+#define INTERFACE_H_
+
+#include <vector>
+
+#include "model/function.h"
+#include "model/composite_type.h"
+#include "model/type_registry.h"
+#include "utils/stl_utils.h"
+
+namespace pugi {
+class xml_node;
+}  // namespace pugi
+
+namespace codegen {
+class API;
+class BuiltinTypeRegistry;
+class Interface;
+class ModelFilter;
+
+/*
+ * An interface found in XML document. Holds a registry of all the
+ * structs, enums and functions found in interface definition
+ */
+class Interface {
+ public:
+  // Types
+  typedef std::map<std::string, FunctionMessage*> MessagesMap;
+  typedef std::vector<Function> FunctionsList;
+  typedef std::vector<const Request*> RequestList;
+  typedef std::vector<const Response*> ResponseList;
+  typedef std::vector<const Notification*> NotificationList;
+  typedef TypeRegistry::EnumList EnumList;
+  typedef TypeRegistry::StructList StructList;
+  typedef TypeRegistry::TypedefList TypedefList;
+ public:
+  // Methods
+  Interface(const API* api,
+            bool auto_generate_function_ids,
+            BuiltinTypeRegistry* builtin_type_registry,
+            const ModelFilter* model_filter);
+  ~Interface();
+  // API this interface belongs to
+  const API& api() const;
+  // Name of the interface
+  const std::string& name() const;
+  // List of all functions (requests and appropriate responses) in the interface
+  const FunctionsList& functions() const;
+  // List of all requests in the interface
+  RequestList all_requests() const;
+  // List of all the responses (including generic) in the interface
+  ResponseList all_responses() const;
+  // List of all the notifications in the interface
+  const NotificationList& notifications() const;
+  // List of generic responses that are not connected to particular request
+  const ResponseList& generic_responses() const;
+  // List of all the enums defined in the interface (exept FunctionID special purpose enum)
+  const EnumList& enums() const;
+  // List of all structs defined in the interface
+  const StructList& structs() const;
+  // List of all typedefs defined in the interface
+  const TypedefList& typedefs() const;
+  // Special-purpose enum that assigns numerical ID's for all API messages
+  const Enum* function_id_enum() const;
+
+  // Follows parsed |xml| document validating and constructin type tree
+  bool init(const pugi::xml_node& xml);
+
+  // Finds a type with |name| defined in this interface
+  const Type* GetNamedType(const std::string& name) const;
+
+ private:
+  // Methods
+  // Finds (or creates, depending on generation prefs) function id
+  // enum constant given |function_id|
+  const Enum::Constant* GetFunctionIdEnumConstant(
+      const std::string& function_id);
+  // Find and add all the functions from the given |xml_interafce|
+  bool AddFunctions(const pugi::xml_node& xml_interface);
+  // Validate and add single function message
+  bool AddFunctionMessage(MessagesMap* list,
+                          FunctionMessage::MessageType message_type,
+                          const pugi::xml_node& xml_message);
+  // Validate and add all the function message parameters
+  bool AddFunctionMessageParameters(FunctionMessage* function_message,
+                                    const pugi::xml_node& xml_message);
+  bool SeparateFunctionMessages();
+ private:
+  // Fields
+  std::string name_;
+  const API* api_;
+  BuiltinTypeRegistry* builtin_type_registry_;
+  const ModelFilter* model_filter_;
+  bool auto_generate_function_ids_;
+  Enum function_ids_enum_;
+  TypeRegistry type_registry_;
+  MessagesMap requests_;
+  utils::StdMapDeleter<MessagesMap> requests_deleter_;
+  MessagesMap responses_;
+  utils::StdMapDeleter<MessagesMap> responses_deleter_;
+  MessagesMap notifications_;
+  utils::StdMapDeleter<MessagesMap> notifications_deleter_;
+  FunctionsList functions_list_;
+  ResponseList generic_responses_list_;
+  NotificationList notifications_list_;
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Interface);
+};
+
+}  // namespace codegen
+
+#endif /* INTERFACE_H_ */
diff --git a/tools/intergen/model/include/model/model_filter.h b/tools/intergen/model/include/model/model_filter.h
new file mode 100644
index 0000000000..e0e4f1f6cf
--- /dev/null
+++ b/tools/intergen/model/include/model/model_filter.h
@@ -0,0 +1,57 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MODEL_FILTER_H
+#define MODEL_FILTER_H
+
+#include <set>
+
+#include "model/scope.h"
+
+namespace codegen {
+
+/*
+ * Class represents modifications that should be done to parsed model while
+ * building it from xml
+ */
+class ModelFilter {
+public:
+  // Creates filter that skips all entities marked with scope
+  ModelFilter(const std::set<std::string>& filtered_scope_names);
+  // Tells whether entity with this scope should be skipped
+  bool ShouldFilterScope(const Scope& scope) const;
+private:
+  const std::set<Scope> filtered_scopes_;
+};
+
+}  // namespace codegen
+
+#endif // MODEL_FILTER_H
diff --git a/tools/intergen/model/include/model/scope.h b/tools/intergen/model/include/model/scope.h
new file mode 100644
index 0000000000..92dbbd5d5a
--- /dev/null
+++ b/tools/intergen/model/include/model/scope.h
@@ -0,0 +1,52 @@
+/**
+* Copyright (c) 2014, Ford Motor Company
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* Redistributions of source code must retain the above copyright notice, this
+* list of conditions and the following disclaimer.
+*
+* Redistributions in binary form must reproduce the above copyright notice,
+* this list of conditions and the following
+* disclaimer in the documentation and/or other materials provided with the
+* distribution.
+*
+* Neither the name of the Ford Motor Company nor the names of its contributors
+* may be used to endorse or promote products derived from this software
+* without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+* POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef SCOPE_H_
+#define SCOPE_H_
+#include <string>
+#include <iosfwd>
+
+namespace codegen {
+
+// Here are defined types for different scope qualifier found in XML specification
+// It is not yet clear what they are and how to use them so they are just strings
+typedef std::string Scope;
+typedef std::string InternalScope;
+typedef std::string Platform;
+
+Scope ScopeFromLiteral(const std::string& literal);
+InternalScope InternalScopeFromLiteral(const std::string& literal);
+Platform PlatformFromLiteral(const std::string& literal);
+
+}  // namespace codegen
+
+#endif /* SCOPE_H_ */
diff --git a/tools/intergen/model/include/model/type.h b/tools/intergen/model/include/model/type.h
new file mode 100644
index 0000000000..25aa55b652
--- /dev/null
+++ b/tools/intergen/model/include/model/type.h
@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TYPE_H_
+#define TYPE_H_
+
+
+namespace codegen {
+
+class Boolean;
+class Integer;
+class Float;
+class String;
+class Enum;
+class Array;
+class Map;
+class Struct;
+class NullableType;
+class Typedef;
+
+class ConstantsCreator;
+
+/*
+ * An interface for Type visitor that is used to generate code
+ * for one of the types (built-in or composite)
+ * An object implementing TypeCodeGenerator should be applied to
+ * the abstract Type, which in turn calls one of the methods below
+ * methods depending on it's exact type.
+ */
+class TypeCodeGenerator {
+ public:
+  // Called to generate code for exact type
+  virtual void GenerateCodeForBoolean(const Boolean* boolean);
+  virtual void GenerateCodeForInteger(const Integer* integer);
+  virtual void GenerateCodeForFloat(const Float* flt);
+  virtual void GenerateCodeForString(const String* string);
+  virtual void GenerateCodeForEnum(const Enum* enm);
+  virtual void GenerateCodeForArray(const Array* array);
+  virtual void GenerateCodeForMap(const Map* map);
+  virtual void GenerateCodeForNullable(const NullableType* nullable);
+  virtual void GenerateCodeForStruct(const Struct* strct);
+  virtual void GenerateCodeForTypedef(const Typedef* tdef);
+  virtual ~TypeCodeGenerator();
+};
+
+/*
+ * An interface for all the types that can be defined by XML interface specification.
+ */
+class Type {
+ public:
+  // Accepts |code_generator| visitor calling one of it's methods
+  // (depending on exact type) with this object
+  virtual TypeCodeGenerator* Apply(TypeCodeGenerator* code_generator) const = 0;
+  // Get factory that creates constants from given string literals
+  // Returns NULL if type values can not be represented with string literals
+  virtual const ConstantsCreator* SupportsConstants() const = 0;
+  virtual ~Type();
+};
+
+
+}  // namespace codegen
+
+#endif /* TYPE_H_ */
diff --git a/tools/intergen/model/include/model/type_registry.h b/tools/intergen/model/include/model/type_registry.h
new file mode 100644
index 0000000000..6263d28fe4
--- /dev/null
+++ b/tools/intergen/model/include/model/type_registry.h
@@ -0,0 +1,152 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef TYPE_REGISTRY_H_
+#define TYPE_REGISTRY_H_
+
+#include <map>
+#include <set>
+#include <string>
+#include <list>
+
+#include "model/composite_type.h"
+#include "model/type.h"
+#include "utils/macro.h"
+#include "utils/stl_utils.h"
+
+namespace pugi {
+class xml_node;
+}  // namespace pugi
+
+namespace codegen {
+class BuiltinTypeRegistry;
+class ModelFilter;
+
+/*
+ * Type registry is a container holding definitions of all the structs and
+ * enums found in a single interface xml document element.
+ */
+class TypeRegistry {
+ public:
+  // Types
+  typedef std::list<Enum*> EnumList;
+  typedef std::map<std::string, const Enum*> EnumByName;
+  typedef std::list<Struct*> StructList;
+  typedef std::map<std::string, const Struct*> StructByName;
+  typedef std::list<Typedef*> TypedefList;
+  typedef std::map<std::string, const Typedef*> TypedefByName;
+ public:
+  // Methods
+  TypeRegistry(const Interface* interface,
+               BuiltinTypeRegistry* builtin_type_registry,
+               Enum* function_ids_enum,
+               const ModelFilter* model_filter,
+               bool create_function_id_enum);
+  ~TypeRegistry();
+  // Follows given xml_node collectin all the struct and enum definitons
+  // Returns false and prints to cerr if invalid type definition was found
+  bool init(const pugi::xml_node& xml);
+  // Finds (or creates) Type object corresponding to type name and parameters
+  // found in |params|.
+  // Returns false if unknown type or invalid params were found
+  bool GetCompositeType(const pugi::xml_node& params, const Type** type);
+  // Finds type delcare in this interface with given name.
+  // Type can be enum, struct or typedef
+  // Returns NULL no type with such name registered
+  const Type* GetType(const std::string& name) const;
+
+  // Returns list of all enums keeping order of definitions in xml
+  const EnumList& enums() const;
+  // Returns list of all structs keeping order of definitions in xml
+  const StructList& structs() const;
+
+  // Returns list of all typedefs keeping order of definitions in xml
+  const TypedefList& typedefs() const;
+
+  // Tells if param which properties are passed in |param| is mandatory
+  static bool IsMandatoryParam(const pugi::xml_node& param);
+
+ private:
+  // methods
+  bool AddEnums(const pugi::xml_node& xml);
+  bool AddStructsAndTypedefs(const pugi::xml_node& xml);
+  bool AddEnum(const pugi::xml_node& xml_enum);
+  bool AddStruct(const pugi::xml_node& xml_struct);
+  bool AddTypedef(const pugi::xml_node& xml_typedef);
+  bool AddEnumConstants(Enum* enm, const pugi::xml_node& xml_enum);
+  bool AddStructureFields(Struct* strct, const pugi::xml_node& xml_struct);
+  // Create container (map or array) |type| object based on xml |params|
+  // if |get_array| is true array is created, otherwise map is created
+  // Returns false and prints to cerr on error
+  bool GetContainer(const pugi::xml_node& params, const Type** type,
+                    bool get_array, bool container_nullable);
+  bool GetNonArray(const pugi::xml_node& params,
+                   const Type** type,
+                   bool nullable);
+  bool GetNullable(const Type* original_type, const Type** type);
+  bool GetEnum(const std::string& name, const Type** type) const;
+  bool GetStruct(const std::string& name, const Type** type) const;
+  bool GetTypedef(const std::string& name, const Type** type) const;
+  bool GetExternalType(const std::string& full_type_name,
+                       const Type** type) const;
+  bool IsRegisteredEnum(const std::string& enum_name) const;
+  bool IsRegisteredStruct(const std::string& struct_name) const;
+  bool IsRegisteredTypedef(const std::string& typedef_name) const;
+  // Returns true if given type is defined in external interface
+  bool IsExternalType(const std::string& full_type_name) const;
+ private:
+  // fields
+  const Interface* interface_;
+  BuiltinTypeRegistry* builtin_type_registry_;
+  // Special FunctionID enum. Enum is filled by TypeRegistry if it is
+  // defined in input file. Otherwise it is filled when interface is parsed.
+  Enum* function_ids_enum_;
+  const ModelFilter* model_filter_;
+  std::set<Array> arrays_;
+  std::set<Map> maps_;
+  std::set<NullableType> nullables_;
+  EnumList enums_;
+  utils::StdContainerDeleter<EnumList> enums_deleter_;
+  EnumByName enum_by_name_;
+  StructList structs_;
+  utils::StdContainerDeleter<StructList> structs_deleter_;
+  StructByName struct_by_name_;
+  TypedefList typedefs_;
+  utils::StdContainerDeleter<TypedefList> typedefs_deleter_;
+  TypedefByName typedef_by_name_;
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TypeRegistry);
+};
+
+}  // namespace codegen
+
+#endif /* TYPE_REGISTRY_H_ */
diff --git a/tools/intergen/model/src/model/api.cc b/tools/intergen/model/src/model/api.cc
new file mode 100644
index 0000000000..8fa3987fac
--- /dev/null
+++ b/tools/intergen/model/src/model/api.cc
@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "model/api.h"
+
+#include <cassert>
+#include <iostream>
+
+#include "model/constant.h"
+#include "pugixml.hpp"
+
+namespace codegen {
+
+API::API(const ModelFilter* model_filter, bool auto_generate_func_ids)
+    : model_filter_(model_filter),
+      auto_generate_func_ids_(auto_generate_func_ids),
+      interfaces_deleter_(&interfaces_) {
+  assert(model_filter_);
+}
+
+bool API::init(const pugi::xml_document& xmldoc) {
+  // Search for interfaces defined directly in given root document
+  if (!AddInterfaces(xmldoc)) {
+    return false;
+  }
+  // Then search for interfaces defined in <interfaces> elements
+  for (pugi::xml_node i = xmldoc.child("interfaces"); i;
+      i = i.next_sibling("interfaces")) {
+    if (!AddInterfaces(i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+API::~API() {
+}
+
+const std::vector<Interface*>& API::interfaces() const {
+  return interfaces_;
+}
+
+const Interface* API::InterfaceByName(const std::string& name) const {
+  InterfacesIndex::const_iterator i = interfaces_index_.find(name);
+  if (i != interfaces_index_.end()) {
+    size_t interface_id = i->second;
+    assert(interface_id < interfaces_.size());
+    return interfaces_[interface_id];
+  }
+  return NULL;
+}
+
+bool API::AddInterfaces(const pugi::xml_node& xmldoc) {
+  for (pugi::xml_node i = xmldoc.child("interface"); i;
+      i = i.next_sibling("interface")) {
+    Interface* interface = new Interface(this,
+                                         auto_generate_func_ids_,
+                                         &builtin_type_registry_,
+                                         model_filter_);
+    interfaces_.push_back(interface);
+    if (!interface->init(i)) {
+      return false;
+    }
+    bool inserted = interfaces_index_.insert(
+          std::make_pair(
+            interface->name(),
+            interfaces_.size() - 1)
+        ).second;
+    if (!inserted) {
+      std::cerr << "Duplicate interface: " << interface->name() << '\n';
+      return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/model/src/model/builtin_type.cc b/tools/intergen/model/src/model/builtin_type.cc
new file mode 100644
index 0000000000..b551bb76f2
--- /dev/null
+++ b/tools/intergen/model/src/model/builtin_type.cc
@@ -0,0 +1,162 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "model/builtin_type.h"
+
+#include "model/constant.h"
+
+namespace codegen {
+
+/*
+ * Boolean type
+ */
+Boolean::Boolean() {
+  constants_.push_back(Constant(this, "false"));
+  constants_.push_back(Constant(this, "true"));
+}
+
+Boolean::~Boolean() {
+}
+
+TypeCodeGenerator* Boolean::Apply(TypeCodeGenerator* code_generator) const {
+  code_generator->GenerateCodeForBoolean(this);
+  return code_generator;
+}
+
+const ConstantsCreator* Boolean::SupportsConstants() const {
+  return this;
+}
+
+const codegen::Constant* Boolean::ConstantFor(
+    const std::string& literal) const {
+  Boolean::Constant constant(this, literal);
+  if (constant.is_valid()) {
+    return constant == constants_[0] ? &constants_[0] : &constants_[1];
+  } else {
+    return NULL;
+  }
+}
+
+Integer::Integer(const Range& range)
+    : range_(range) {
+}
+
+Integer::~Integer() {
+}
+
+const Integer::Range& Integer::range() const {
+  return range_;
+}
+
+bool Integer::operator <(const Integer& that) const {
+  if (range_.min() != that.range_.min())
+    return range_.min() < that.range_.min();
+  return range_.max() < that.range_.max();
+}
+
+TypeCodeGenerator* Integer::Apply(TypeCodeGenerator* code_generator) const {
+  code_generator->GenerateCodeForInteger(this);
+  return code_generator;
+}
+
+const ConstantsCreator* Integer::SupportsConstants() const {
+  return this;
+}
+
+const Constant* Integer::ConstantFor(const std::string& literal) const {
+  Integer::Constant constant(this, literal);
+  if (constant.is_valid()) {
+    return &*constants_.insert(constant).first;
+  } else {
+    return NULL;
+  }
+}
+
+Float::Float(const Range& range)
+    : range_(range) {
+}
+
+Float::~Float() {
+}
+
+const Float::Range& Float::range() const {
+  return range_;
+}
+
+bool Float::operator <(const Float& that) const {
+  if (range_.min() != that.range_.min())
+    return range_.min() < that.range_.min();
+  return range_.max() < that.range_.max();
+}
+
+TypeCodeGenerator* Float::Apply(TypeCodeGenerator* code_generator) const {
+  code_generator->GenerateCodeForFloat(this);
+  return code_generator;
+}
+
+const ConstantsCreator* Float::SupportsConstants() const {
+  return this;
+}
+
+const Constant* Float::ConstantFor(const std::string& literal) const {
+  Float::Constant constant(this, literal);
+  if (constant.is_valid()) {
+    return &*constants_.insert(constant).first;
+  } else {
+    return NULL;
+  }
+}
+
+String::String(const Range& range)
+    : length_range_(range) {
+}
+
+bool String::operator <(const String& that) const {
+  if (length_range_.min() != that.length_range_.min())
+    return length_range_.min() < that.length_range_.min();
+  return length_range_.max() < that.length_range_.max();
+}
+
+const String::Range& String::length_range() const {
+  return length_range_;
+}
+
+TypeCodeGenerator* String::Apply(TypeCodeGenerator* code_generator) const {
+  code_generator->GenerateCodeForString(this);
+  return code_generator;
+}
+
+const ConstantsCreator* String::SupportsConstants() const {
+  return NULL;
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/model/src/model/builtin_type_registry.cc b/tools/intergen/model/src/model/builtin_type_registry.cc
new file mode 100644
index 0000000000..2c5460352e
--- /dev/null
+++ b/tools/intergen/model/src/model/builtin_type_registry.cc
@@ -0,0 +1,144 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "model/builtin_type_registry.h"
+
+#include <stdint.h>
+#include <iostream>
+#include <map>
+#include <utility>
+
+#include "pugixml.hpp"
+#include "model/constant.h"
+#include "utils/string_utils.h"
+
+namespace codegen {
+
+BuiltinTypeRegistry::BuiltinTypeRegistry() {
+}
+
+BuiltinTypeRegistry::~BuiltinTypeRegistry() {
+}
+
+const Boolean* BuiltinTypeRegistry::GetBoolean() {
+  return &boolean_;
+}
+
+const Integer* BuiltinTypeRegistry::GetInteger(const Integer::Range& range) {
+  Integer integer(range);
+  return &*integers_.insert(integer).first;
+}
+
+const Float* BuiltinTypeRegistry::GetFloat(const Float::Range& range) {
+  Float flt(range);
+  return &*floats_.insert(flt).first;
+}
+
+const String* BuiltinTypeRegistry::GetString(const String::Range& length_range) {
+  String string(length_range);
+  return &*strings_.insert(string).first;
+}
+
+BuiltinTypeRegistry::BuiltInType BuiltinTypeRegistry::BuiltInTypeByName(
+    const std::string& type_name) {
+  if (type_name == "Boolean") {
+    return kBoolean;
+  } else if (type_name == "Integer") {
+    return kInteger;
+  } else if (type_name == "String") {
+    return kString;
+  } else if (type_name == "Float") {
+    return kFloat;
+  } else {
+    return kNotABuiltInType;
+  }
+}
+
+bool BuiltinTypeRegistry::GetType(BuiltInType type_id,
+                                  const pugi::xml_node& params,
+                                  const Type** type) {
+  switch (type_id) {
+    case kBoolean: {
+      *type = GetBoolean();
+      return true;
+    }
+    case kString: {
+      std::string min_length_str = params.attribute("minlength").as_string("1");
+      std::string max_length_str = params.attribute("maxlength").as_string("0");
+      int64_t min_length, max_length;
+      if (StringToNumber(min_length_str, &min_length)
+          && StringToNumber(max_length_str, &max_length)) {
+        *type = GetString(String::Range(min_length, max_length));
+        return true;
+      } else {
+        std::cerr << "Incorrect length value provided for string: "
+                  << max_length_str << std::endl;
+        *type = NULL;
+        return false;
+      }
+    }
+    case kInteger: {
+      std::string min_val_str = params.attribute("minvalue").as_string("0"),
+          max_val_str = params.attribute("maxvalue").as_string("0");
+      int64_t min_val, max_val;
+      if (StringToNumber(min_val_str, &min_val) && StringToNumber(max_val_str, &max_val)) {
+        *type = GetInteger(Integer::Range(min_val, max_val));
+        return true;
+      } else {
+        std::cerr << "Incorrect range for integer provided: " << min_val_str
+                  << ", " << max_val_str << std::endl;
+        return false;
+      }
+    }
+    case kFloat: {
+      std::string min_val_str = params.attribute("minvalue").as_string("0"),
+          max_val_str = params.attribute("maxvalue").as_string("0");
+      double min_val, max_val;
+      if (StringToNumber(min_val_str, &min_val) && StringToNumber(max_val_str, &max_val)) {
+        *type = GetFloat(Float::Range(min_val, max_val));
+        return true;
+      } else {
+        std::cerr << "Incorrect range for float provided: " << min_val_str
+                  << ", " << max_val_str << std::endl;
+        return false;
+      }
+    }
+    default: {
+      std::cerr << "Unknown built-in type";
+      *type = NULL;
+      return false;
+    }
+  }
+}
+
+}  // namespace codegen
+
diff --git a/tools/intergen/model/src/model/composite_type.cc b/tools/intergen/model/src/model/composite_type.cc
new file mode 100644
index 0000000000..57e89cce54
--- /dev/null
+++ b/tools/intergen/model/src/model/composite_type.cc
@@ -0,0 +1,383 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "model/composite_type.h"
+
+#include <cassert>
+#include <iostream>
+#include <utility>
+
+#include "model/constant.h"
+#include "utils/safeformat.h"
+#include "utils/common_types.h"
+
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+/*
+ * Array type
+ */
+Array::Array(const Type* type, const Range& range)
+    : type_(type),
+      range_(range) {
+}
+
+Array::~Array() {
+}
+
+const Type* Array::type() const {
+  return type_;
+}
+
+const Array::Range& Array::range() const {
+  return range_;
+}
+
+bool Array::operator <(const Array& that) const {
+  if (type_ != that.type_) {
+    return size_t(type_) < size_t(that.type_);
+  }
+  if (range_.min() == that.range_.min())
+    return range_.min() < that.range_.min();
+  return range_.max() < that.range_.max();
+}
+
+TypeCodeGenerator* Array::Apply(TypeCodeGenerator* code_generator) const {
+  code_generator->GenerateCodeForArray(this);
+  return code_generator;
+}
+
+const ConstantsCreator* Array::SupportsConstants() const {
+  return NULL;
+}
+
+/*
+ * Map type
+ */
+Map::Map(const Type* type, const Range& range)
+    : type_(type),
+      range_(range) {
+}
+
+Map::~Map() {
+}
+
+const Type* Map::type() const {
+  return type_;
+}
+
+const Map::Range& Map::range() const {
+  return range_;
+}
+
+bool Map::operator <(const Map& that) const {
+  if (type_ != that.type_) {
+    return size_t(type_) < size_t(that.type_);
+  }
+  if (range_.min() == that.range_.min())
+    return range_.min() < that.range_.min();
+  return range_.max() < that.range_.max();
+}
+
+TypeCodeGenerator* Map::Apply(TypeCodeGenerator* code_generator) const {
+  code_generator->GenerateCodeForMap(this);
+  return code_generator;
+}
+
+const ConstantsCreator* Map::SupportsConstants() const {
+  return NULL;
+}
+
+/*
+ * Enum type
+ */
+
+// static
+const char* Enum::kFunctionIdEnumName = "FunctionID";
+
+Enum::Enum(const Interface* interface,
+           const std::string& name,
+           Scope scope,
+           InternalScope internal_scope,
+           const Description& description)
+    : interface_(interface),
+      name_(name),
+      scope_(scope),
+      internal_scope_(internal_scope),
+      description_(description),
+      last_constant_value_(-1) {
+  assert(interface);
+}
+
+Enum::~Enum() {
+}
+
+const Interface& Enum::interface() const {
+  return *interface_;
+}
+
+const std::string& Enum::name() const {
+  return name_;
+}
+
+const Enum::ConstantsList& Enum::constants() const {
+  return constants_;
+}
+
+const Enum::ConstantsByName& Enum::constants_by_name() const {
+  return constants_by_name_;
+}
+
+const Scope& Enum::scope() const {
+  return scope_;
+}
+
+const InternalScope& Enum::internal_scope() const {
+  return internal_scope_;
+}
+
+const Description& Enum::description() const {
+  return description_;
+}
+
+TypeCodeGenerator* Enum::Apply(TypeCodeGenerator* code_generator) const {
+  code_generator->GenerateCodeForEnum(this);
+  return code_generator;
+}
+
+const ConstantsCreator* Enum::SupportsConstants() const {
+  return this;
+}
+
+const codegen::Constant* Enum::ConstantFor(const std::string& literal) const {
+  ConstantsByName::const_iterator i = constants_by_name_.find(literal);
+  if (i != constants_by_name_.end())
+    return i->second;
+  else {
+    return NULL;
+  }
+}
+
+bool Enum::AddConstant(const std::string& name, Scope scope,
+                       const std::string& internal_name,
+                       const Description& description,
+                       const std::string& design_description) {
+  if (ConstantFor(name) != NULL) {
+    strmfmt(std::cerr, "Constant {0} already defined in enum {1}\n", name,
+            name_);
+    return false;
+  }
+  constants_.push_back(
+      Constant(this, name, last_constant_value_ + 1, false, scope, internal_name,
+               description, design_description));
+  constants_by_name_[name] = &constants_.back();
+  ++last_constant_value_;
+  return true;
+}
+
+bool Enum::AddConstant(const std::string& name, const int64_t value,
+                       Scope scope, const std::string& internal_name,
+                       const Description& description,
+                       const std::string& design_description) {
+  if (ConstantFor(name) != NULL) {
+    strmfmt(std::cerr, "Constant {0} already defined in enum {1}\n", name,
+            name_);
+    return false;
+  }
+  constants_.push_back(
+      Constant(this, name, value, true, scope, internal_name, description,
+               design_description));
+  constants_by_name_[name] = &constants_.back();
+  last_constant_value_ = value;
+  return true;
+}
+
+
+/*
+ * Struct type
+ */
+Struct::Struct(const Interface* interface,
+               const std::string& name,
+               const Type* frankenmap,
+               Scope scope,
+               const Description& description)
+    : interface_(interface),
+      name_(name),
+      frankenmap_(frankenmap),
+      scope_(scope),
+      description_(description) {
+  assert(interface_);
+}
+
+Struct::~Struct() {
+}
+
+const std::string& Struct::Field::name() const {
+  return name_;
+}
+
+bool Struct::Field::is_mandatory() const {
+  return mandatory_;
+}
+
+const Description& Struct::description() const {
+  return description_;
+}
+
+const Struct::FieldsList& Struct::fields() const {
+  return fields_;
+}
+
+const Scope& Struct::scope() const {
+  return scope_;
+}
+
+bool Struct::AddField(const Type* type, const std::string& name, bool mandatory,
+                      Scope scope, const Constant* default_value,
+                      const Description& description, Platform platform) {
+  fields_.push_back(
+      Field(type, name, mandatory, scope, default_value, description, platform));
+  return true;
+}
+
+TypeCodeGenerator* Struct::Apply(TypeCodeGenerator* code_generator) const {
+  code_generator->GenerateCodeForStruct(this);
+  return code_generator;
+}
+
+const ConstantsCreator* Struct::SupportsConstants() const {
+  return NULL;
+}
+
+const Type* Struct::Field::type() const {
+  return type_;
+}
+
+const Interface& Struct::interface() const {
+  return *interface_;
+}
+
+const Type* Struct::frankenstruct() const {
+  return frankenmap_;
+}
+
+const std::string& Struct::name() const {
+  return name_;
+}
+
+const Constant* Struct::Field::default_value() const {
+  return default_value_;
+}
+
+const Scope& Struct::Field::scope() const {
+  return scope_;
+}
+
+const Description& Struct::Field::description() const {
+  return description_;
+}
+
+Struct::Field::Field(const Type* type, const std::string& name, bool mandatory,
+                     Scope scope, const Constant* default_value,
+                     const Description& description, Platform platform)
+    : type_(type),
+      name_(name),
+      mandatory_(mandatory),
+      default_value_(default_value),
+      scope_(scope),
+      description_(description),
+      platform_(platform){
+}
+
+NullableType::NullableType(const Type* type)
+    : type_(type) {
+}
+
+const Type* NullableType::type() const {
+  return type_;
+}
+
+bool NullableType::operator<(const NullableType& that) const {
+  // Simple pointer comparison should be enough here
+  if (type_ != that.type_) {
+    return type_ < that.type_;
+  }
+}
+
+TypeCodeGenerator* NullableType::Apply(
+    TypeCodeGenerator* code_generator) const {
+  code_generator->GenerateCodeForNullable(this);
+  return code_generator;
+}
+
+const ConstantsCreator* NullableType::SupportsConstants() const {
+  return type_->SupportsConstants();
+}
+
+Typedef::Typedef(const Interface* interface,
+                 const std::string& name,
+                 const Type* type,
+                 const Description& description)
+    : interface_(interface),
+      name_(name),
+      type_(type),
+      description_(description) {
+  assert(interface_);
+}
+
+const Description& Typedef::description() const {
+  return description_;
+}
+
+const Interface& Typedef::interface() const {
+  return *interface_;
+}
+
+const std::string& Typedef::name() const {
+  return name_;
+}
+
+const Type* Typedef::type() const {
+  return type_;
+}
+
+TypeCodeGenerator* Typedef::Apply(TypeCodeGenerator* code_generator) const {
+  code_generator->GenerateCodeForTypedef(this);
+  return code_generator;
+}
+
+const ConstantsCreator* Typedef::SupportsConstants() const {
+  return NULL;
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/model/src/model/constant.cc b/tools/intergen/model/src/model/constant.cc
new file mode 100644
index 0000000000..8320718ad9
--- /dev/null
+++ b/tools/intergen/model/src/model/constant.cc
@@ -0,0 +1,219 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "model/constant.h"
+
+#include "utils/string_utils.h"
+
+namespace codegen {
+
+Constant::~Constant() {
+}
+
+ConstantsCreator::~ConstantsCreator() {
+}
+
+Boolean::Constant::~Constant() {
+}
+
+bool Boolean::Constant::value() const {
+  return value_;
+}
+
+bool Boolean::Constant::is_valid() const {
+  return valid_;
+}
+
+bool Boolean::Constant::operator ==(const Boolean::Constant& that) const {
+  return type_ == that.type_ && value_ == that.value_;
+}
+
+const Boolean* Boolean::Constant::type() const {
+  return type_;
+}
+
+void Boolean::Constant::Apply(ConstantCodeGenerator* generator) const {
+  generator->GenerateCodeForBooleanConstant(this);
+}
+
+Boolean::Constant::Constant(const Boolean* type, const std::string& literal)
+    : type_(type),
+      value_(literal == "true" ? true : false),
+      valid_(literal == "true" || literal == "false") {
+}
+
+Integer::Constant::~Constant() {
+}
+
+int64_t Integer::Constant::value() const {
+  return value_;
+}
+
+bool Integer::Constant::is_valid() const {
+  return valid_;
+}
+
+bool Integer::Constant::operator <(const Integer::Constant& that) const {
+  if (valid_ != that.valid_) {
+    return int(valid_) < int(that.valid_);
+  }
+  if (type_ != that.type_) {
+    return type_ < that.type_;
+  }
+  return value_ < that.value_;
+}
+
+const Integer* Integer::Constant::type() const {
+  return type_;
+}
+
+void Integer::Constant::Apply(ConstantCodeGenerator* generator) const {
+  generator->GenerateCodeForIntegerConstant(this);
+}
+
+Integer::Constant::Constant(const Integer* type, const std::string& literal)
+    : type_(type),
+      value_(0) {
+  valid_ = StringToNumber(literal, &value_) && type_->range().Includes(value_);
+}
+
+Float::Constant::~Constant() {
+}
+
+double Float::Constant::value() const {
+  return value_;
+}
+
+bool Float::Constant::is_valid() const {
+  return valid_;
+}
+
+bool Float::Constant::operator <(const Float::Constant& that) const {
+  if (valid_ != that.valid_) {
+    return int(valid_) < int(that.valid_);
+  }
+  if (type_ != that.type_) {
+    return type_ < that.type_;
+  }
+  return value_ < that.value_;
+}
+
+const Float* Float::Constant::type() const {
+  return type_;
+}
+
+void Float::Constant::Apply(ConstantCodeGenerator* generator) const {
+  generator->GenerateCodeForFloatConstant(this);
+}
+
+Float::Constant::Constant(const Float* type, const std::string& literal)
+    : type_(type),
+      value_(0) {
+  valid_ = StringToNumber(literal, &value_) && type_->range().Includes(value_);
+}
+
+Enum::Constant::~Constant() {
+}
+
+const std::string& Enum::Constant::name() const {
+  return name_;
+}
+
+int64_t Enum::Constant::value() const {
+  return value_;
+}
+
+bool Enum::Constant::is_value_explicit() const {
+  return value_explicit_;
+}
+
+const Scope& Enum::Constant::scope() const {
+  return scope_;
+}
+
+const std::string& Enum::Constant::internal_name() const {
+  return internal_name_;
+}
+
+const Description& Enum::Constant::description() const {
+  return description_;
+}
+
+const std::string& Enum::Constant::design_description() const {
+  return design_description_;
+}
+
+const Enum* Enum::Constant::type() const {
+  return type_;
+}
+
+void Enum::Constant::Apply(ConstantCodeGenerator* generator) const {
+  generator->GenerateCodeForEnumConstant(this);
+}
+
+Enum::Constant::Constant(Enum* enm, const std::string& name,
+                         const int64_t value, bool value_explicit, Scope scope,
+                         const std::string& internal_name,
+                         const Description& description,
+                         const std::string& design_description)
+    : type_(enm),
+      name_(name),
+      value_(value),
+      value_explicit_(value_explicit),
+      scope_(scope),
+      internal_name_(internal_name),
+      description_(description),
+      design_description_(design_description) {
+
+}
+
+void ConstantCodeGenerator::GenerateCodeForBooleanConstant(
+    const Boolean::Constant* boolean) {
+}
+
+void ConstantCodeGenerator::GenerateCodeForIntegerConstant(
+    const Integer::Constant* integer) {
+}
+
+void ConstantCodeGenerator::GenerateCodeForFloatConstant(
+    const Float::Constant* flt) {
+}
+
+void ConstantCodeGenerator::GenerateCodeForEnumConstant(
+    const Enum::Constant* enm) {
+}
+
+ConstantCodeGenerator::~ConstantCodeGenerator() {
+}
+
+}  // namespace codegen
+
diff --git a/tools/intergen/model/src/model/function.cc b/tools/intergen/model/src/model/function.cc
new file mode 100644
index 0000000000..9c9765ead3
--- /dev/null
+++ b/tools/intergen/model/src/model/function.cc
@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "model/function.h"
+
+#include <cassert>
+#include <iostream>
+
+#include "utils/safeformat.h"
+
+using std::cerr;
+using std::endl;
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+// static
+const char* FunctionMessage::MessageTypeToString(
+    FunctionMessage::MessageType message_type) {
+  switch (message_type) {
+    case FunctionMessage::kRequest:
+      return "request";
+    case FunctionMessage::kResponse:
+      return "response";
+    case FunctionMessage::kNotification:
+      return "notification";
+    default:
+      return "";
+  }
+}
+
+// static
+FunctionMessage::MessageType FunctionMessage::MessageTypeFromLiteral(
+    const std::string& literal) {
+  if (literal == "request") {
+    return kRequest;
+  } else if (literal == "response") {
+    return kResponse;
+  } else if (literal == "notification") {
+    return kNotification;
+  } else {
+    return kUnknownMessageType;
+  }
+}
+
+FunctionMessage::FunctionMessage(const Interface* interface,
+                                 const std::string& name,
+                                 const Enum::Constant* id,
+                                 MessageType message_type,
+                                 const Description& description, Scope scope)
+    : Struct(interface, name, NULL, scope, description), // Functions can not be frankenmaps
+      interface_(interface),
+      id_(id),
+      message_type_(message_type) {
+}
+
+FunctionMessage::~FunctionMessage() {
+}
+
+const Enum::Constant* FunctionMessage::id() const {
+  return id_;
+}
+
+const FunctionMessage::ParametersList& FunctionMessage::parameters() const {
+  return fields();
+}
+
+bool FunctionMessage::AddParameter(const std::string& param_name, const Type* type,
+                                   const Constant* default_value,
+                                   bool is_mandatory,
+                                   const Description& description, Scope scope,
+                                   Platform platformn) {
+  return AddField(type, param_name, is_mandatory, scope, default_value, description, platformn);
+}
+const Interface* FunctionMessage::interface() const {
+    return interface_;
+}
+
+Function::Function(const Request* request, const Response* response)
+    : request_(request),
+      response_(response) {
+    assert(request_);
+    assert(response_);
+}
+
+
+}  // namespace codegen
diff --git a/tools/intergen/model/src/model/interface.cc b/tools/intergen/model/src/model/interface.cc
new file mode 100644
index 0000000000..af1bae2c5d
--- /dev/null
+++ b/tools/intergen/model/src/model/interface.cc
@@ -0,0 +1,352 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "model/interface.h"
+
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+
+#include "model/constant.h"
+#include "model/model_filter.h"
+#include "model/scope.h"
+#include "pugixml.hpp"
+#include "utils/safeformat.h"
+#include "utils/stl_utils.h"
+#include "utils/xml_utils.h"
+
+using std::cerr;
+using std::endl;
+using std::make_pair;
+using std::pair;
+using std::set;
+using std::string;
+using typesafe_format::format;
+using typesafe_format::strmfmt;
+
+namespace codegen {
+class ModelFilter;
+
+namespace {
+
+// standard algorithm helper to access request() member of a function
+const FunctionMessage* FunctionRequest(const Function& function) {
+  return &function.request();
+}
+
+// standard algorithm helper to access response() member of a function
+const FunctionMessage* FunctionResponse(const Function& function) {
+  return &function.response();
+}
+
+}  // namespace
+
+Interface::Interface(const API* api,
+                     bool auto_generate_function_ids,
+                     BuiltinTypeRegistry* builtin_type_registry,
+                     const ModelFilter* model_filter)
+    : api_(api),
+      builtin_type_registry_(builtin_type_registry),
+      model_filter_(model_filter),
+      auto_generate_function_ids_(auto_generate_function_ids),
+      function_ids_enum_(this,
+                         Enum::kFunctionIdEnumName,
+                         Scope(),
+                         InternalScope(),
+                         Description()),
+      type_registry_(this,
+                     builtin_type_registry_,
+                     &function_ids_enum_,
+                     model_filter,
+                     auto_generate_function_ids_),
+      requests_deleter_(&requests_),
+      responses_deleter_(&responses_),
+      notifications_deleter_(&notifications_) {
+  assert(api_);
+  assert(builtin_type_registry_);
+  assert(model_filter_);
+}
+
+Interface::~Interface() {
+}
+
+bool Interface::init(const pugi::xml_node& xml) {
+  name_ = xml.attribute("name").value();
+  if (name_.empty()) {
+    std::cerr << "Interface must have 'name' attribute specified" << '\n';
+    return false;
+  }
+  if (!type_registry_.init(xml) || !AddFunctions(xml))
+    return false;
+  return true;
+}
+
+const Type* Interface::GetNamedType(const std::string& name) const {
+  return type_registry_.GetType(name);
+}
+
+const API& Interface::api() const {
+  return *api_;
+}
+
+const std::string& Interface::name() const {
+  return name_;
+}
+
+const Interface::FunctionsList& Interface::functions() const {
+  return functions_list_;
+}
+
+Interface::RequestList Interface::all_requests() const {
+  RequestList requests(functions_list_.size());
+  std::transform(functions_list_.begin(), functions_list_.end(),
+                 requests.begin(), std::ptr_fun(&FunctionRequest));
+  return requests;
+}
+
+Interface::ResponseList Interface::all_responses() const {
+  ResponseList responses(
+        functions_list_.size() + generic_responses_list_.size());
+  ResponseList::iterator response_iter =
+    std::transform(functions_list_.begin(), functions_list_.end(),
+                   responses.begin(), std::ptr_fun(&FunctionResponse));
+  response_iter =
+  std::copy(generic_responses_list_.begin(), generic_responses_list_.end(),
+            response_iter);
+  assert(response_iter == responses.end());
+  return responses;
+}
+
+const Interface::NotificationList& Interface::notifications() const {
+  return notifications_list_;
+}
+
+const Interface::ResponseList& Interface::generic_responses() const {
+  return generic_responses_list_;
+}
+
+const Interface::EnumList& Interface::enums() const {
+  return type_registry_.enums();
+}
+
+const Interface::StructList& Interface::structs() const {
+  return type_registry_.structs();
+}
+
+const Interface::TypedefList& Interface::typedefs() const {
+  return type_registry_.typedefs();
+}
+
+const Enum* Interface::function_id_enum() const {
+  return &function_ids_enum_;
+}
+
+const Enum::Constant* Interface::GetFunctionIdEnumConstant(
+    const std::string& function_id) {
+  Enum* func_id_enum = &function_ids_enum_;
+
+  const Constant* func_id = func_id_enum->ConstantFor(function_id);
+  if (!func_id && auto_generate_function_ids_) {
+    bool added = func_id_enum->AddConstant(function_id, Scope(), "", Description(), "");
+    assert(added);
+    func_id = func_id_enum->ConstantFor(function_id);
+  }
+  return static_cast<const Enum::Constant*>(func_id);
+}
+
+bool Interface::AddFunctions(const pugi::xml_node& xml_interface) {
+  for (pugi::xml_node i = xml_interface.child("function"); i; i =
+      i.next_sibling("function")) {
+    std::string message_type_str = i.attribute("messagetype").value();
+    FunctionMessage::MessageType message_type =
+        FunctionMessage::MessageTypeFromLiteral(message_type_str);
+    MessagesMap* map_for_message = NULL;
+    switch (message_type) {
+      case FunctionMessage::kRequest: {
+        map_for_message = &requests_;
+        break;
+      }
+      case FunctionMessage::kResponse: {
+        map_for_message = &responses_;
+        break;
+      }
+      case FunctionMessage::kNotification: {
+        map_for_message = &notifications_;
+        break;
+      }
+      default: {
+        std::cerr << "Invalid message type: " << message_type_str << std::endl;
+        return false;
+      }
+    }
+    if (!AddFunctionMessage(map_for_message, message_type, i)) {
+      return false;
+    }
+  }
+  return SeparateFunctionMessages();
+}
+
+bool Interface::AddFunctionMessage(MessagesMap* list,
+                                   FunctionMessage::MessageType message_type,
+                                   const pugi::xml_node& xml_message) {
+  Scope scope = ScopeFromLiteral(xml_message.attribute("scope").value());
+  if (model_filter_->ShouldFilterScope(scope)) {
+    return true;
+  }
+  std::string name = xml_message.attribute("name").value();
+  if (name.empty()) {
+    std::cerr << "Message with empty function name found\n";
+    return false;
+  }
+
+  std::string func_id_str;
+  if (auto_generate_function_ids_) {
+    if (!xml_message.attribute("functionID").empty()) {
+      strmfmt(std::cerr,
+              "Auto generation of function IDs is requested "
+              "but function {0} has funcitionID specified",
+              name) << '\n';
+      return false;
+    }
+    func_id_str = name;
+  } else {
+    func_id_str = xml_message.attribute("functionID").value();
+    if (func_id_str.empty()) {
+      std::cerr << "Message with empty functionID found\n";
+      return false;
+    }
+  }
+  const Enum::Constant* func_id = GetFunctionIdEnumConstant(func_id_str);
+  if (!func_id) {
+    std::cerr << "Function " << name << " has invalid functionID: "
+              << func_id_str << std::endl;
+    return false;
+  }
+  Description description = CollectDescription(xml_message);
+  pair<MessagesMap::iterator, bool> res = list->insert(
+      make_pair(
+          name,
+          new FunctionMessage(this, name, func_id, message_type, description,
+                              scope)));
+  if (!res.second) {
+    strmfmt(cerr, "Duplicate function message {0} of type {1}", name,
+            message_type) << endl;
+    return false;
+  }
+  if (!AddFunctionMessageParameters(res.first->second, xml_message)) {
+    std::cerr << "While parsing function " << name << '\n';
+    return false;
+  }
+  return true;
+}
+
+bool Interface::AddFunctionMessageParameters(
+    FunctionMessage* function_message, const pugi::xml_node& xml_message) {
+  for (pugi::xml_node i = xml_message.child("param"); i;
+      i = i.next_sibling("param")) {
+    Scope scope = ScopeFromLiteral(i.attribute("scope").value());
+    if (model_filter_->ShouldFilterScope(scope)) {
+      continue;
+    }
+    std::string name = i.attribute("name").value();
+    if (name.empty()) {
+      strmfmt(cerr, "Function message {0}, has parameter with empty name",
+              function_message->name()) << endl;
+      return false;
+    }
+    const Type* type = NULL;
+    if (!type_registry_.GetCompositeType(i, &type)) {
+      std::cerr << "While parsing function parameter " << name << '\n';
+      return false;
+    }
+    const Constant* default_value = NULL;
+    std::string default_value_literal = i.attribute("defvalue").value();
+    if (!default_value_literal.empty()) {
+      const ConstantsCreator* const_creator = type->SupportsConstants();
+      if (!const_creator) {
+        strmfmt(cerr, "Can not use {0} as a default value",
+                default_value_literal) << endl;
+        return false;
+      }
+      default_value = const_creator->ConstantFor(default_value_literal);
+      if (!default_value) {
+        strmfmt(cerr, "Incorrect default value: {0}",
+               default_value_literal) << '\n';
+        return false;
+      }
+    }
+    bool is_mandatory = TypeRegistry::IsMandatoryParam(i);
+    Description description = CollectDescription(i);
+    Platform platform = PlatformFromLiteral(i.attribute("platform").value());
+    if (!function_message->AddParameter(name, type, default_value, is_mandatory,
+                                        description, scope, platform)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool Interface::SeparateFunctionMessages() {
+  set<string> requests = utils::MapKeys(requests_);
+  set<string> response_names = utils::MapKeys(responses_);
+  // Generic responses are responses that do not have matching request
+  set<string> responses;
+  std::set_difference(response_names.begin(), response_names.end(),
+                      requests.begin(), requests.end(),
+                      std::inserter(responses, responses.begin()));
+  for (set<string>::iterator i = requests.begin(), end = requests.end();
+      i != end; ++i) {
+    const string& name = *i;
+    assert(requests_.find(name) != requests_.end());
+    const FunctionMessage* request = requests_.find(name)->second;
+    MessagesMap::iterator have_response = responses_.find(name);
+    if (have_response == responses_.end()) {
+      strmfmt(cerr, "Request {0} doesn't have matching response", name);
+      return false;
+    }
+    const FunctionMessage* response = have_response->second;
+    functions_list_.push_back(Function(request, response));
+  }
+  for (set<string>::iterator i = responses.begin(), end = responses.end();
+      i != end; ++i) {
+    const std::string& name = *i;
+    assert(responses_.find(name) != responses_.end());
+    generic_responses_list_.push_back(responses_.find(name)->second);
+  }
+  for (MessagesMap::iterator i = notifications_.begin(), end = notifications_
+      .end(); i != end; ++i) {
+    notifications_list_.push_back(i->second);
+  }
+  return true;
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/model/src/model/model_filter.cc b/tools/intergen/model/src/model/model_filter.cc
new file mode 100644
index 0000000000..b6674c1e2e
--- /dev/null
+++ b/tools/intergen/model/src/model/model_filter.cc
@@ -0,0 +1,46 @@
+/* Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "model/model_filter.h"
+
+namespace codegen {
+
+ModelFilter::ModelFilter(const std::set<std::string>& filtered_scope_names)
+  : filtered_scopes_(filtered_scope_names) {
+}
+
+bool ModelFilter::ShouldFilterScope(const Scope& scope) const {
+  return filtered_scopes_.count(scope) != 0;
+}
+
+
+
+}  // namespace codegen
diff --git a/tools/intergen/model/src/model/scope.cc b/tools/intergen/model/src/model/scope.cc
new file mode 100644
index 0000000000..a57b9a0db4
--- /dev/null
+++ b/tools/intergen/model/src/model/scope.cc
@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "model/scope.h"
+
+#include <iostream>
+
+namespace codegen {
+
+Scope ScopeFromLiteral(const std::string& literal) {
+  return literal;
+}
+
+InternalScope InternalScopeFromLiteral(const std::string& literal) {
+  return literal;
+}
+
+Platform PlatformFromLiteral(const std::string& literal) {
+  return literal;
+}
+
+}  // namespace codegen
diff --git a/tools/intergen/model/src/model/type.cc b/tools/intergen/model/src/model/type.cc
new file mode 100644
index 0000000000..849168054c
--- /dev/null
+++ b/tools/intergen/model/src/model/type.cc
@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "model/type.h"
+
+namespace codegen {
+
+// Abstract interface destructor
+TypeCodeGenerator::~TypeCodeGenerator() {
+}
+
+// Abstract interface destructor
+Type::~Type() {
+}
+
+// Default no-op code generator
+void TypeCodeGenerator::GenerateCodeForBoolean(const Boolean* boolean) {
+}
+
+void TypeCodeGenerator::GenerateCodeForInteger(const Integer* integer) {
+}
+
+void TypeCodeGenerator::GenerateCodeForFloat(const Float* flt) {
+}
+
+void TypeCodeGenerator::GenerateCodeForString(const String* string) {
+}
+
+void TypeCodeGenerator::GenerateCodeForEnum(const Enum* enm) {
+}
+
+void TypeCodeGenerator::GenerateCodeForArray(const Array* array) {
+}
+
+void TypeCodeGenerator::GenerateCodeForMap(const Map* map) {
+}
+
+void TypeCodeGenerator::GenerateCodeForNullable(
+    const NullableType* nullable) {
+}
+
+void TypeCodeGenerator::GenerateCodeForStruct(const Struct* strct) {
+}
+
+void TypeCodeGenerator::GenerateCodeForTypedef(const Typedef* tdef) {
+}
+
+}  // namespace codegen
+
diff --git a/tools/intergen/model/src/model/type_registry.cc b/tools/intergen/model/src/model/type_registry.cc
new file mode 100644
index 0000000000..fa173eb06c
--- /dev/null
+++ b/tools/intergen/model/src/model/type_registry.cc
@@ -0,0 +1,449 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "model/type_registry.h"
+
+#include <iostream>
+#include <utility>
+
+#include "model/api.h"
+#include "model/builtin_type_registry.h"
+#include "model/constant.h"
+#include "model/interface.h"
+#include "model/model_filter.h"
+#include "model/scope.h"
+#include "pugixml.hpp"
+#include "utils/safeformat.h"
+#include "utils/string_utils.h"
+#include "utils/xml_utils.h"
+
+using typesafe_format::strmfmt;
+
+namespace codegen {
+
+TypeRegistry::TypeRegistry(const Interface* interface,
+                           BuiltinTypeRegistry* builtin_type_registry,
+                           Enum* function_ids_enum,
+                           const ModelFilter* model_filter,
+                           bool create_function_id_enum)
+    : interface_(interface),
+      builtin_type_registry_(builtin_type_registry),
+      function_ids_enum_(function_ids_enum),
+      model_filter_(model_filter),
+      enums_deleter_(&enums_),
+      structs_deleter_(&structs_),
+      typedefs_deleter_(&typedefs_) {
+  assert(builtin_type_registry_);
+  assert(function_ids_enum_);
+  assert(model_filter_);
+}
+
+TypeRegistry::~TypeRegistry() {
+}
+
+bool TypeRegistry::init(const pugi::xml_node& xml) {
+  if (!AddEnums(xml) || !AddStructsAndTypedefs(xml)) {
+    return false;
+  }
+  return true;
+}
+
+bool TypeRegistry::GetCompositeType(const pugi::xml_node& params, const Type** type) {
+  bool is_array = params.attribute("array").as_bool(false);
+  bool is_map = params.attribute("map").as_bool(false);
+  bool is_nullable = params.attribute("nullable").as_bool(false);
+  if (is_array && is_map) {
+    strmfmt(std::cerr, "Entity {0} has both map and array attributes specified",
+            params.attribute("name").as_string(""));
+    return false;
+  }
+  if (is_map) {
+    return GetContainer(params, type, false, is_nullable);
+  } else if (is_array) {
+    return GetContainer(params, type, true, is_nullable);
+  } else {
+    return GetNonArray(params, type, is_nullable);
+  }
+}
+
+const Type* TypeRegistry::GetType(const std::string& name) const {
+  const Type* type = NULL;
+  if (IsRegisteredEnum(name)
+      && GetEnum(name, &type)) {
+    return type;
+  } else if (IsRegisteredStruct(name)
+             && GetStruct(name, &type)) {
+    return type;
+  } else if (IsRegisteredTypedef(name)
+             && GetTypedef(name, &type)) {
+    return type;
+  }
+  return NULL;
+}
+
+const TypeRegistry::EnumList& TypeRegistry::enums() const {
+  return enums_;
+}
+
+const TypeRegistry::StructList& TypeRegistry::structs() const {
+  return structs_;
+}
+
+const TypeRegistry::TypedefList& TypeRegistry::typedefs() const {
+  return typedefs_;
+}
+
+// static
+bool TypeRegistry::IsMandatoryParam(const pugi::xml_node& param) {
+  return param.attribute("mandatory").as_bool("true");
+}
+
+bool TypeRegistry::AddEnums(const pugi::xml_node& xml) {
+  for (pugi::xml_node i = xml.child("enum"); i; i = i.next_sibling("enum")) {
+    if (!AddEnum(i)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool TypeRegistry::AddStructsAndTypedefs(const pugi::xml_node& xml) {
+  for (pugi::xml_node i = xml.first_child(); i;
+      i = i.next_sibling()) {
+    if (std::string("struct") == i.name()) {
+      if (!AddStruct(i)) {
+        return false;
+      }
+    } else if (std::string("typedef") == i.name()) {
+      if (!AddTypedef(i)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool TypeRegistry::AddEnum(const pugi::xml_node& xml_enum) {
+  Scope scope = ScopeFromLiteral(xml_enum.attribute("scope").value());
+  if (model_filter_->ShouldFilterScope(scope)) {
+    return true;
+  }
+  std::string name = xml_enum.attribute("name").value();
+  InternalScope internal_scope = InternalScopeFromLiteral(
+      xml_enum.attribute("internal_scope").value());
+  Description description = CollectDescription(xml_enum);
+  if (IsRegisteredEnum(name)) {
+    std::cerr << "Duplicate enum: " << name << std::endl;
+    return false;
+  }
+  Enum* this_enum = NULL;
+  // FunctionID enum is already created, avoid creation of duplicate FunctionID enum
+  if (name == Enum::kFunctionIdEnumName) {
+    this_enum = function_ids_enum_;
+  } else {
+    enums_.push_back(new Enum(interface_, name, scope, internal_scope, description));
+    this_enum = enums_.back();
+    enum_by_name_[name] = this_enum;
+  }
+  if (!AddEnumConstants(this_enum, xml_enum)) {
+    return false;
+  }
+  return true;
+}
+
+bool TypeRegistry::AddStruct(const pugi::xml_node& xml_struct) {
+  Scope scope = ScopeFromLiteral(xml_struct.attribute("scope").value());
+  if (model_filter_->ShouldFilterScope(scope)) {
+    return true;
+  }
+  std::string name = xml_struct.attribute("name").value();
+  const Type* frankenmap = NULL;
+  if (!xml_struct.attribute("type").empty()) {
+    if (!GetContainer(xml_struct,
+                      &frankenmap,
+                      false,
+                      false)) {
+      std::cerr << "Invalid frankenstruct: " << name << std::endl;
+      return false;
+    }
+  }
+  Description description = CollectDescription(xml_struct);
+  if (IsRegisteredStruct(name)) {
+    std::cerr << "Duplicate structure: " << name << std::endl;
+    return false;
+  }
+  structs_.push_back(new Struct(interface_, name, frankenmap,
+                                scope, description));
+  struct_by_name_[name] = structs_.back();
+  if (!AddStructureFields(structs_.back(), xml_struct)) {
+    return false;
+  }
+  return true;
+}
+
+bool TypeRegistry::AddTypedef(const pugi::xml_node& xml_typedef) {
+  std::string name = xml_typedef.attribute("name").value();
+  if (name.empty()) {
+    std::cerr << "Typedef with empty name found" << std::endl;
+    return false;
+  }
+  const Type* type = NULL;
+  if (!GetCompositeType(xml_typedef, &type)) {
+    std::cerr<< "While parsing typedef " << name << '\n';
+    return false;
+  }
+  Description description = CollectDescription(xml_typedef);
+  if (IsRegisteredTypedef(name)) {
+    std::cerr << "Duplicate typedef: " << name << std::endl;
+    return false;
+  }
+  typedefs_.push_back(new Typedef(interface_, name, type, description));
+  typedef_by_name_[name] = typedefs_.back();
+
+  return true;
+}
+
+bool TypeRegistry::GetContainer(const pugi::xml_node& params, const Type** type,
+                                bool get_array, bool container_nullable) {
+  const Type* element_type = NULL;
+  bool null_values_allowed =
+      params.attribute("null_values_allowed").as_bool(false);
+  if (GetNonArray(params, &element_type, null_values_allowed)) {
+    assert(element_type);
+    std::string minsize_str = params.attribute("minsize").as_string("0");
+    std::string maxsize_str = params.attribute("maxsize").as_string("0");
+    int64_t minsize, maxsize;
+    if (StringToNumber(minsize_str, &minsize)
+        && StringToNumber(maxsize_str, &maxsize)) {
+      if (get_array) {
+        *type = &*arrays_.insert(
+            Array(element_type, Array::Range(minsize, maxsize))).first;
+      } else {
+        *type = &*maps_.insert(Map(element_type, Map::Range(minsize, maxsize)))
+            .first;
+      }
+      if (container_nullable) {
+        return GetNullable(*type, type);
+      } else {
+        return true;
+      }
+    } else {
+      std::cerr << "Incorrect container size range: " << minsize_str << ", "
+                << maxsize_str << std::endl;
+    }
+  }
+  return false;
+}
+
+bool TypeRegistry::GetNonArray(const pugi::xml_node& params,
+                               const Type** type, bool nullable) {
+  bool type_found = false;
+  pugi::xml_attribute type_name = params.attribute("type");
+  if (type_name) {
+    std::string type_name_str = type_name.value();
+    BuiltinTypeRegistry::BuiltInType builtin_type = builtin_type_registry_
+        ->BuiltInTypeByName(type_name_str);
+    if (BuiltinTypeRegistry::kNotABuiltInType != builtin_type) {
+      type_found = builtin_type_registry_->GetType(builtin_type, params, type);
+    } else if (IsExternalType(type_name_str)) {
+      type_found = GetExternalType(type_name_str, type);
+    } else if (*type = GetType(type_name_str)) {
+      type_found = true;
+    } else {
+      std::cerr << "Unregistered type: " << type_name_str << std::endl;
+      type_found = false;
+    }
+  } else {
+    std::cerr << "Absent type name" << std::endl;
+    type_found = false;
+  }
+
+  if (type_found && nullable) {
+    type_found = GetNullable(*type, type);
+  }
+  return type_found;
+}
+
+bool TypeRegistry::GetNullable(const Type* original_type,
+                               const Type** type) {
+  std::set<NullableType>::const_iterator inserted =
+      nullables_.insert(NullableType(original_type)).first;
+  *type = &*inserted;
+  return true;
+}
+
+bool TypeRegistry::GetEnum(const std::string& name, const Type** type) const {
+  EnumByName::const_iterator i = enum_by_name_.find(name);
+  if (i != enum_by_name_.end()) {
+    *type = i->second;
+    return true;
+  } else {
+    std::cerr << "Unregistered enum " << name << std::endl;
+    return false;
+  }
+}
+
+bool TypeRegistry::GetStruct(const std::string& name, const Type** type) const {
+  StructByName::const_iterator i = struct_by_name_.find(name);
+  if (i != struct_by_name_.end()) {
+    *type = i->second;
+    return true;
+  } else {
+    std::cerr << "Unregistered struct " << name << std::endl;
+    return false;
+  }
+}
+
+bool TypeRegistry::GetTypedef(const std::string& name, const Type** type) const {
+  TypedefByName::const_iterator i = typedef_by_name_.find(name);
+  if (i != typedef_by_name_.end()) {
+    *type = i->second;
+    return true;
+  } else {
+    std::cerr<< "Unregistered typedef " << name << std::endl;
+    return false;
+  }
+}
+
+bool TypeRegistry::GetExternalType(const std::string& full_type_name,
+                                   const Type** type) const {
+  size_t dotpos = full_type_name.find('.');
+  if (dotpos == full_type_name.npos) {
+    std::cerr << full_type_name << " is not valid fully qualified type name" << '\n';
+    return false;
+  }
+  std::string interface_name = full_type_name.substr(0, dotpos);
+  std::string type_name = full_type_name.substr(dotpos + 1);
+  const API& api = interface_->api();
+  const Interface* that_interface =
+      interface_name == interface_->name() ?
+        interface_ : api.InterfaceByName(interface_name);
+  if (!that_interface) {
+    std::cerr << "Unknown interface " << interface_name << '\n';
+    return false;
+  }
+  const Type* found_type = that_interface->GetNamedType(type_name);
+  if (!found_type) {
+    strmfmt(std::cerr, "Unknown type {0} in interface {1}",
+            type_name, interface_name) << '\n';
+    return false;
+  }
+  *type = found_type;
+  return true;
+}
+
+bool TypeRegistry::IsRegisteredEnum(const std::string& enum_name) const {
+  return enum_by_name_.find(enum_name) != enum_by_name_.end();
+}
+
+bool TypeRegistry::IsRegisteredStruct(const std::string& struct_name) const {
+  return struct_by_name_.find(struct_name) != struct_by_name_.end();
+}
+
+bool TypeRegistry::IsExternalType(const std::string& full_type_name) const {
+  return full_type_name.find('.') != full_type_name.npos;
+}
+
+bool TypeRegistry::AddEnumConstants(Enum* enm, const pugi::xml_node& xml_enum) {
+  for (pugi::xml_node i = xml_enum.child("element"); i;
+      i = i.next_sibling("element")) {
+    Scope scope = ScopeFromLiteral(i.attribute("scope").value());
+    if (model_filter_->ShouldFilterScope(scope)) {
+      continue;
+    }
+    std::string name = i.attribute("name").value();
+    std::string internal_name = i.attribute("internal_name").value();
+    Description description = CollectDescription(i);
+    std::string design_description = i.child_value("designdescription");
+    pugi::xml_attribute xml_value = i.attribute("value");
+    if (xml_value) {
+      int64_t val;
+      if (!StringToNumber(xml_value.value(), &val)) {
+        std::cerr << "Non-numeric value of enum constant " << name << std::endl;
+      }
+      if (!enm->AddConstant(name, val, scope, internal_name, description,
+                            design_description)) {
+        return false;
+      }
+    } else {
+      if (!enm->AddConstant(name, scope, internal_name, description,
+                            design_description)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool TypeRegistry::AddStructureFields(Struct* strct,
+                                      const pugi::xml_node& xml_struct) {
+  for (pugi::xml_node i = xml_struct.child("param"); i;
+      i = i.next_sibling("param")) {
+    Scope scope = ScopeFromLiteral(i.attribute("scope").value());
+    if (model_filter_->ShouldFilterScope(scope)) {
+      continue;
+    }
+    std::string type_name = i.attribute("type").value();
+    const Type* type = NULL;
+    if (!GetCompositeType(i, &type)) {
+      std::cerr << "While parsing struct " << strct->name()
+                << std::endl;
+      return false;
+    }
+    std::string name = i.attribute("name").value();
+    std::string defvalue = i.attribute("defvalue").value();
+    bool mandatory = IsMandatoryParam(i);
+    const Constant* defvalue_constant = NULL;
+    if (!defvalue.empty()) {
+      const ConstantsCreator* const_creator = type->SupportsConstants();
+      if (!const_creator) {
+        std::cerr << "Default value can not be provided for " << type_name
+                  << std::endl;
+        return false;
+      } else {
+        defvalue_constant = const_creator->ConstantFor(defvalue);
+      }
+    }
+    Description description = CollectDescription(i);
+    Platform platform = PlatformFromLiteral(i.attribute("platform").value());
+    strct->AddField(type, name, mandatory, scope, defvalue_constant,
+                    description, platform);
+  }
+  return true;
+}
+
+bool TypeRegistry::IsRegisteredTypedef(const std::string& typedef_name) const {
+  return typedef_by_name_.find(typedef_name) != typedef_by_name_.end();
+}
+
+}  // namespace codegen
+
diff --git a/tools/intergen/third_party/pugixml/contrib/foreach.hpp b/tools/intergen/third_party/pugixml/contrib/foreach.hpp
new file mode 100644
index 0000000000..319807771c
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/contrib/foreach.hpp
@@ -0,0 +1,64 @@
+/*
+ * Boost.Foreach support for pugixml classes.
+ * This file is provided to the public domain.
+ * Written by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+ */
+
+#ifndef HEADER_PUGIXML_FOREACH_HPP
+#define HEADER_PUGIXML_FOREACH_HPP
+
+#include "pugixml.hpp"
+
+/*
+ * These types add support for BOOST_FOREACH macro to xml_node and xml_document classes (child iteration only).
+ * Example usage:
+ * BOOST_FOREACH(xml_node n, doc) {}
+ */
+
+namespace boost
+{
+	template <typename> struct range_mutable_iterator;
+	template <typename> struct range_const_iterator;
+
+	template<> struct range_mutable_iterator<pugi::xml_node>
+	{
+		typedef pugi::xml_node::iterator type;
+	};
+
+	template<> struct range_const_iterator<pugi::xml_node>
+	{
+		typedef pugi::xml_node::iterator type;
+	};
+
+	template<> struct range_mutable_iterator<pugi::xml_document>
+	{
+		typedef pugi::xml_document::iterator type;
+	};
+
+	template<> struct range_const_iterator<pugi::xml_document>
+	{
+		typedef pugi::xml_document::iterator type;
+	};
+}
+
+/*
+ * These types add support for BOOST_FOREACH macro to xml_node and xml_document classes (child/attribute iteration).
+ * Example usage:
+ * BOOST_FOREACH(xml_node n, children(doc)) {}
+ * BOOST_FOREACH(xml_node n, attributes(doc)) {}
+ */
+
+namespace pugi
+{
+	inline xml_object_range<xml_node_iterator> children(const pugi::xml_node& node)
+	{
+        return node.children();
+	}
+
+	inline xml_object_range<xml_attribute_iterator> attributes(const pugi::xml_node& node)
+	{
+        return node.attributes();
+	}
+}
+
+#endif
diff --git a/tools/intergen/third_party/pugixml/docs/images/caution.png b/tools/intergen/third_party/pugixml/docs/images/caution.png
new file mode 100644
index 0000000000..5adc3779c7
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/caution.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/dom_tree.png b/tools/intergen/third_party/pugixml/docs/images/dom_tree.png
new file mode 100644
index 0000000000..2e28ce8d04
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/dom_tree.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/dom_tree_thumb.png b/tools/intergen/third_party/pugixml/docs/images/dom_tree_thumb.png
new file mode 100644
index 0000000000..8b0ba85b02
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/dom_tree_thumb.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/home.png b/tools/intergen/third_party/pugixml/docs/images/home.png
new file mode 100644
index 0000000000..124a56b79c
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/home.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/next.png b/tools/intergen/third_party/pugixml/docs/images/next.png
new file mode 100644
index 0000000000..fbb2fdc5b7
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/next.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/note.png b/tools/intergen/third_party/pugixml/docs/images/note.png
new file mode 100644
index 0000000000..e960b3956f
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/note.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/prev.png b/tools/intergen/third_party/pugixml/docs/images/prev.png
new file mode 100644
index 0000000000..ceadadaa82
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/prev.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/up.png b/tools/intergen/third_party/pugixml/docs/images/up.png
new file mode 100644
index 0000000000..23e4aec4f1
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/up.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2005_link1.png b/tools/intergen/third_party/pugixml/docs/images/vs2005_link1.png
new file mode 100644
index 0000000000..6da6366afa
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2005_link1.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2005_link1_thumb.png b/tools/intergen/third_party/pugixml/docs/images/vs2005_link1_thumb.png
new file mode 100644
index 0000000000..86882e0105
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2005_link1_thumb.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2005_link2.png b/tools/intergen/third_party/pugixml/docs/images/vs2005_link2.png
new file mode 100644
index 0000000000..9f75a4f773
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2005_link2.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2005_link2_thumb.png b/tools/intergen/third_party/pugixml/docs/images/vs2005_link2_thumb.png
new file mode 100644
index 0000000000..64954d5560
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2005_link2_thumb.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2005_pch1.png b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch1.png
new file mode 100644
index 0000000000..ddbb93cb7c
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch1.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2005_pch1_thumb.png b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch1_thumb.png
new file mode 100644
index 0000000000..96df958c91
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch1_thumb.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2005_pch2.png b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch2.png
new file mode 100644
index 0000000000..7f15ebc181
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch2.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2005_pch2_thumb.png b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch2_thumb.png
new file mode 100644
index 0000000000..9d443b1dc0
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch2_thumb.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2005_pch3.png b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch3.png
new file mode 100644
index 0000000000..3bb450cf78
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch3.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2005_pch3_thumb.png b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch3_thumb.png
new file mode 100644
index 0000000000..60fa8f80d6
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch3_thumb.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2005_pch4.png b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch4.png
new file mode 100644
index 0000000000..c9fe63da7d
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch4.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2005_pch4_thumb.png b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch4_thumb.png
new file mode 100644
index 0000000000..3b6e53c0b6
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2005_pch4_thumb.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2010_link1.png b/tools/intergen/third_party/pugixml/docs/images/vs2010_link1.png
new file mode 100644
index 0000000000..5d32bf6437
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2010_link1.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2010_link1_thumb.png b/tools/intergen/third_party/pugixml/docs/images/vs2010_link1_thumb.png
new file mode 100644
index 0000000000..223b429b72
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2010_link1_thumb.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2010_link2.png b/tools/intergen/third_party/pugixml/docs/images/vs2010_link2.png
new file mode 100644
index 0000000000..b6446a29a6
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2010_link2.png
diff --git a/tools/intergen/third_party/pugixml/docs/images/vs2010_link2_thumb.png b/tools/intergen/third_party/pugixml/docs/images/vs2010_link2_thumb.png
new file mode 100644
index 0000000000..34d9dd951c
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/images/vs2010_link2_thumb.png
diff --git a/tools/intergen/third_party/pugixml/docs/manual.html b/tools/intergen/third_party/pugixml/docs/manual.html
new file mode 100644
index 0000000000..8f3089bb20
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/manual.html
@@ -0,0 +1,205 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>pugixml 1.2</title>
+<link rel="stylesheet" href="pugixml.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="manual.html" title="pugixml 1.2">
+<link rel="next" href="manual/install.html" title="Installation">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<b>Overview</b> |
+		<a href="manual/install.html">Installation</a> |
+		Document:
+		<a href="manual/dom.html">Object model</a> &middot; <a href="manual/loading.html">Loading</a> &middot; <a href="manual/access.html">Accessing</a> &middot; <a href="manual/modify.html">Modifying</a> &middot; <a href="manual/saving.html">Saving</a> |
+		<a href="manual/xpath.html">XPath</a> |
+		<a href="manual/apiref.html">API Reference</a> |
+		<a href="manual/toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav"><a accesskey="n" href="manual/install.html"><img src="images/next.png" alt="Next"></a></div></td>
+</tr></table>
+<hr>
+<div class="book"><div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="manual.overview"></a><a class="link" href="manual.html#manual.overview" title="Overview"> Overview</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="manual.html#manual.overview.introduction"> Introduction</a></span></dt>
+<dt><span class="section"><a href="manual.html#manual.overview.feedback"> Feedback</a></span></dt>
+<dt><span class="section"><a href="manual.html#manual.overview.thanks"> Acknowledgments</a></span></dt>
+<dt><span class="section"><a href="manual.html#manual.overview.license"> License</a></span></dt>
+</dl></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.overview.introduction"></a><a class="link" href="manual.html#manual.overview.introduction" title="Introduction"> Introduction</a>
+</h3></div></div></div>
+<p>
+        <a href="http://pugixml.org/" target="_top">pugixml</a> is a light-weight C++ XML
+        processing library. It consists of a DOM-like interface with rich traversal/modification
+        capabilities, an extremely fast XML parser which constructs the DOM tree
+        from an XML file/buffer, and an <a class="link" href="manual/xpath.html" title="XPath">XPath 1.0 implementation</a>
+        for complex data-driven tree queries. Full Unicode support is also available,
+        with <a class="link" href="manual/dom.html#manual.dom.unicode" title="Unicode interface">two Unicode interface variants</a>
+        and conversions between different Unicode encodings (which happen automatically
+        during parsing/saving). The library is <a class="link" href="manual/install.html#manual.install.portability" title="Portability">extremely
+        portable</a> and easy to integrate and use. pugixml is developed and maintained
+        since 2006 and has many users. All code is distributed under the <a class="link" href="manual.html#manual.overview.license" title="License">MIT
+        license</a>, making it completely free to use in both open-source and
+        proprietary applications.
+      </p>
+<p>
+        pugixml enables very fast, convenient and memory-efficient XML document processing.
+        However, since pugixml has a DOM parser, it can't process XML documents that
+        do not fit in memory; also the parser is a non-validating one, so if you
+        need DTD or XML Schema validation, the library is not for you.
+      </p>
+<p>
+        This is the complete manual for pugixml, which describes all features of
+        the library in detail. If you want to start writing code as quickly as possible,
+        you are advised to <a href="quickstart.html" target="_top">read the quick start guide
+        first</a>.
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          No documentation is perfect, neither is this one. If you encounter a description
+          that is unclear, please file an issue as described in <a class="xref" href="manual.html#manual.overview.feedback" title="Feedback"> Feedback</a>.
+          Also if you can spare the time for a full proof-reading, including spelling
+          and grammar, that would be great! Please <a class="link" href="manual.html#email">send me
+          an e-mail</a>; as a token of appreciation, your name will be included
+          into the <a class="link" href="manual.html#manual.overview.thanks" title="Acknowledgments">corresponding section</a>
+          of this documentation.
+        </p></td></tr>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.overview.feedback"></a><a class="link" href="manual.html#manual.overview.feedback" title="Feedback"> Feedback</a>
+</h3></div></div></div>
+<p>
+        If you believe you've found a bug in pugixml (bugs include compilation problems
+        (errors/warnings), crashes, performance degradation and incorrect behavior),
+        please file an issue via <a href="http://code.google.com/p/pugixml/issues/entry" target="_top">issue
+        submission form</a>. Be sure to include the relevant information so that
+        the bug can be reproduced: the version of pugixml, compiler version and target
+        architecture, the code that uses pugixml and exhibits the bug, etc.
+      </p>
+<p>
+        Feature requests can be reported the same way as bugs, so if you're missing
+        some functionality in pugixml or if the API is rough in some places and you
+        can suggest an improvement, <a href="http://code.google.com/p/pugixml/issues/entry?template=Feature%20request" target="_top">file
+        an issue</a>. However please note that there are many factors when considering
+        API changes (compatibility with previous versions, API redundancy, etc.),
+        so generally features that can be implemented via a small function without
+        pugixml modification are not accepted. However, all rules have exceptions.
+      </p>
+<p>
+        If you have a contribution to pugixml, such as build script for some build
+        system/IDE, or a well-designed set of helper functions, or a binding to some
+        language other than C++, please <a href="http://code.google.com/p/pugixml/issues/entry?template=Feature%20request" target="_top">file
+        an issue</a>. You can include the relevant patches as issue attachments.
+        Your contribution has to be distributed under the terms of a license that's
+        compatible with pugixml license; i.e. GPL/LGPL licensed code is not accepted.
+      </p>
+<a name="email"></a><p>
+        If filing an issue is not possible due to privacy or other concerns, you
+        can contact pugixml author by e-mail directly: <a href="mailto:arseny.kapoulkine@gmail.com" target="_top">arseny.kapoulkine@gmail.com</a>.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.overview.thanks"></a><a class="link" href="manual.html#manual.overview.thanks" title="Acknowledgments"> Acknowledgments</a>
+</h3></div></div></div>
+<p>
+        pugixml could not be developed without the help from many people; some of
+        them are listed in this section. If you've played a part in pugixml development
+        and you can not find yourself on this list, I'm truly sorry; please <a class="link" href="manual.html#email">send me an e-mail</a> so I can fix this.
+      </p>
+<p>
+        Thanks to <span class="bold"><strong>Kristen Wegner</strong></span> for pugxml parser,
+        which was used as a basis for pugixml.
+      </p>
+<p>
+        Thanks to <span class="bold"><strong>Neville Franks</strong></span> for contributions
+        to pugxml parser.
+      </p>
+<p>
+        Thanks to <span class="bold"><strong>Artyom Palvelev</strong></span> for suggesting
+        a lazy gap contraction approach.
+      </p>
+<p>
+        Thanks to <span class="bold"><strong>Vyacheslav Egorov</strong></span> for documentation
+        proofreading.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.overview.license"></a><a class="link" href="manual.html#manual.overview.license" title="License"> License</a>
+</h3></div></div></div>
+<p>
+        The pugixml library is distributed under the MIT license:
+      </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          Copyright (c) 2006-2012 Arseny Kapoulkine
+        </p>
+<p>
+          Permission is hereby granted, free of charge, to any person obtaining a
+          copy of this software and associated documentation files (the "Software"),
+          to deal in the Software without restriction, including without limitation
+          the rights to use, copy, modify, merge, publish, distribute, sublicense,
+          and/or sell copies of the Software, and to permit persons to whom the Software
+          is furnished to do so, subject to the following conditions:
+        </p>
+<p>
+          The above copyright notice and this permission notice shall be included
+          in all copies or substantial portions of the Software.
+        </p>
+<p>
+          THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+          EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+          FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+          THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+          LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+          FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+          IN THE SOFTWARE.
+        </p>
+</blockquote></div>
+<p>
+        This means that you can freely use pugixml in your applications, both open-source
+        and proprietary. If you use pugixml in a product, it is sufficient to add
+        an acknowledgment like this to the product distribution:
+      </p>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          This software is based on pugixml library (http://pugixml.org).<br>
+pugixml
+          is Copyright (C) 2006-2012 Arseny Kapoulkine.
+        </p></blockquote></div>
+</div>
+</div></div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"><p><small>Last revised: April 30, 2012 at 15:36:33 GMT</small></p></td>
+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
+<hr>
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<b>Overview</b> |
+		<a href="manual/install.html">Installation</a> |
+		Document:
+		<a href="manual/dom.html">Object model</a> &middot; <a href="manual/loading.html">Loading</a> &middot; <a href="manual/access.html">Accessing</a> &middot; <a href="manual/modify.html">Modifying</a> &middot; <a href="manual/saving.html">Saving</a> |
+		<a href="manual/xpath.html">XPath</a> |
+		<a href="manual/apiref.html">API Reference</a> |
+		<a href="manual/toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav"><a accesskey="n" href="manual/install.html"><img src="images/next.png" alt="Next"></a></div></td>
+</tr></table>
+</body>
+</html>
diff --git a/tools/intergen/third_party/pugixml/docs/manual/access.html b/tools/intergen/third_party/pugixml/docs/manual/access.html
new file mode 100644
index 0000000000..c6abd052db
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/manual/access.html
@@ -0,0 +1,892 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Accessing document data</title>
+<link rel="stylesheet" href="../pugixml.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../manual.html" title="pugixml 1.2">
+<link rel="up" href="../manual.html" title="pugixml 1.2">
+<link rel="prev" href="loading.html" title="Loading document">
+<link rel="next" href="modify.html" title="Modifying document data">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <b>Accessing</b> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="loading.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="modify.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+<hr>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="manual.access"></a><a class="link" href="access.html" title="Accessing document data"> Accessing document data</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="access.html#manual.access.basic"> Basic traversal functions</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.nodedata"> Getting node data</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.attrdata"> Getting attribute data</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.contents"> Contents-based traversal functions</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.rangefor"> Range-based for-loop support</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.iterators"> Traversing node/attribute lists
+      via iterators</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.walker"> Recursive traversal with xml_tree_walker</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.predicate"> Searching for nodes/attributes
+      with predicates</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.text"> Working with text contents</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.misc"> Miscellaneous functions</a></span></dt>
+</dl></div>
+<p>
+      pugixml features an extensive interface for getting various types of data from
+      the document and for traversing the document. This section provides documentation
+      for all such functions that do not modify the tree except for XPath-related
+      functions; see <a class="xref" href="xpath.html" title="XPath"> XPath</a> for XPath reference. As discussed in <a class="xref" href="dom.html#manual.dom.cpp" title="C++ interface"> C++ interface</a>,
+      there are two types of handles to tree data - <a class="link" href="dom.html#xml_node">xml_node</a>
+      and <a class="link" href="dom.html#xml_attribute">xml_attribute</a>. The handles have special
+      null (empty) values which propagate through various functions and thus are
+      useful for writing more concise code; see <a class="link" href="dom.html#node_null">this description</a>
+      for details. The documentation in this section will explicitly state the results
+      of all function in case of null inputs.
+    </p>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.access.basic"></a><a class="link" href="access.html#manual.access.basic" title="Basic traversal functions"> Basic traversal functions</a>
+</h3></div></div></div>
+<a name="xml_node::parent"></a><a name="xml_node::first_child"></a><a name="xml_node::last_child"></a><a name="xml_node::next_sibling"></a><a name="xml_node::previous_sibling"></a><a name="xml_node::first_attribute"></a><a name="xml_node::last_attribute"></a><a name="xml_attribute::next_attribute"></a><a name="xml_attribute::previous_attribute"></a><p>
+        The internal representation of the document is a tree, where each node has
+        a list of child nodes (the order of children corresponds to their order in
+        the XML representation), and additionally element nodes have a list of attributes,
+        which is also ordered. Several functions are provided in order to let you
+        get from one node in the tree to the other. These functions roughly correspond
+        to the internal representation, and thus are usually building blocks for
+        other methods of traversing (i.e. XPath traversals are based on these functions).
+      </p>
+<pre class="programlisting"><span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">parent</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">first_child</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">last_child</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">next_sibling</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">previous_sibling</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+<span class="identifier">xml_attribute</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">first_attribute</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_attribute</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">last_attribute</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_attribute</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">next_attribute</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_attribute</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">previous_attribute</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        <code class="computeroutput"><span class="identifier">parent</span></code> function returns the
+        node's parent; all non-null nodes except the document have non-null parent.
+        <code class="computeroutput"><span class="identifier">first_child</span></code> and <code class="computeroutput"><span class="identifier">last_child</span></code> return the first and last child
+        of the node, respectively; note that only document nodes and element nodes
+        can have non-empty child node list. If node has no children, both functions
+        return null nodes. <code class="computeroutput"><span class="identifier">next_sibling</span></code>
+        and <code class="computeroutput"><span class="identifier">previous_sibling</span></code> return
+        the node that's immediately to the right/left of this node in the children
+        list, respectively - for example, in <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">a</span><span class="special">/&gt;&lt;</span><span class="identifier">b</span><span class="special">/&gt;&lt;</span><span class="identifier">c</span><span class="special">/&gt;</span></code>,
+        calling <code class="computeroutput"><span class="identifier">next_sibling</span></code> for
+        a handle that points to <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">b</span><span class="special">/&gt;</span></code>
+        results in a handle pointing to <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">c</span><span class="special">/&gt;</span></code>,
+        and calling <code class="computeroutput"><span class="identifier">previous_sibling</span></code>
+        results in handle pointing to <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">a</span><span class="special">/&gt;</span></code>.
+        If node does not have next/previous sibling (this happens if it is the last/first
+        node in the list, respectively), the functions return null nodes. <code class="computeroutput"><span class="identifier">first_attribute</span></code>, <code class="computeroutput"><span class="identifier">last_attribute</span></code>,
+        <code class="computeroutput"><span class="identifier">next_attribute</span></code> and <code class="computeroutput"><span class="identifier">previous_attribute</span></code> functions behave similarly
+        to the corresponding child node functions and allow to iterate through attribute
+        list in the same way.
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          Because of memory consumption reasons, attributes do not have a link to
+          their parent nodes. Thus there is no <code class="computeroutput"><span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">parent</span><span class="special">()</span></code> function.
+        </p></td></tr>
+</table></div>
+<p>
+        Calling any of the functions above on the null handle results in a null handle
+        - i.e. <code class="computeroutput"><span class="identifier">node</span><span class="special">.</span><span class="identifier">first_child</span><span class="special">().</span><span class="identifier">next_sibling</span><span class="special">()</span></code>
+        returns the second child of <code class="computeroutput"><span class="identifier">node</span></code>,
+        and null handle if <code class="computeroutput"><span class="identifier">node</span></code> is
+        null, has no children at all or if it has only one child node.
+      </p>
+<p>
+        With these functions, you can iterate through all child nodes and display
+        all attributes like this (<a href="../samples/traverse_base.cpp" target="_top">samples/traverse_base.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">first_child</span><span class="special">();</span> <span class="identifier">tool</span><span class="special">;</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">next_sibling</span><span class="special">())</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Tool:"</span><span class="special">;</span>
+
+    <span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_attribute</span> <span class="identifier">attr</span> <span class="special">=</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">first_attribute</span><span class="special">();</span> <span class="identifier">attr</span><span class="special">;</span> <span class="identifier">attr</span> <span class="special">=</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">next_attribute</span><span class="special">())</span>
+    <span class="special">{</span>
+        <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"="</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">value</span><span class="special">();</span>
+    <span class="special">}</span>
+
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.access.nodedata"></a><a class="link" href="access.html#manual.access.nodedata" title="Getting node data"> Getting node data</a>
+</h3></div></div></div>
+<a name="xml_node::name"></a><a name="xml_node::value"></a><p>
+        Apart from structural information (parent, child nodes, attributes), nodes
+        can have name and value, both of which are strings. Depending on node type,
+        name or value may be absent. <a class="link" href="dom.html#node_document">node_document</a>
+        nodes do not have a name or value, <a class="link" href="dom.html#node_element">node_element</a>
+        and <a class="link" href="dom.html#node_declaration">node_declaration</a> nodes always
+        have a name but never have a value, <a class="link" href="dom.html#node_pcdata">node_pcdata</a>,
+        <a class="link" href="dom.html#node_cdata">node_cdata</a>, <a class="link" href="dom.html#node_comment">node_comment</a>
+        and <a class="link" href="dom.html#node_doctype">node_doctype</a> nodes never have a name
+        but always have a value (it may be empty though), <a class="link" href="dom.html#node_pi">node_pi</a>
+        nodes always have a name and a value (again, value may be empty). In order
+        to get node's name or value, you can use the following functions:
+      </p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">name</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">value</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        In case node does not have a name or value or if the node handle is null,
+        both functions return empty strings - they never return null pointers.
+      </p>
+<a name="xml_node::child_value"></a><p>
+        It is common to store data as text contents of some node - i.e. <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">node</span><span class="special">&gt;&lt;</span><span class="identifier">description</span><span class="special">&gt;</span><span class="identifier">This</span> <span class="identifier">is</span> <span class="identifier">a</span> <span class="identifier">node</span><span class="special">&lt;/</span><span class="identifier">description</span><span class="special">&gt;&lt;/</span><span class="identifier">node</span><span class="special">&gt;</span></code>.
+        In this case, <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">description</span><span class="special">&gt;</span></code> node does not have a value, but instead
+        has a child of type <a class="link" href="dom.html#node_pcdata">node_pcdata</a> with value
+        <code class="computeroutput"><span class="string">"This is a node"</span></code>. pugixml
+        provides several helper functions to parse such data:
+      </p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">child_value</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">child_value</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_text</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">text</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        <code class="computeroutput"><span class="identifier">child_value</span><span class="special">()</span></code>
+        returns the value of the first child with type <a class="link" href="dom.html#node_pcdata">node_pcdata</a>
+        or <a class="link" href="dom.html#node_cdata">node_cdata</a>; <code class="computeroutput"><span class="identifier">child_value</span><span class="special">(</span><span class="identifier">name</span><span class="special">)</span></code>
+        is a simple wrapper for <code class="computeroutput"><span class="identifier">child</span><span class="special">(</span><span class="identifier">name</span><span class="special">).</span><span class="identifier">child_value</span><span class="special">()</span></code>.
+        For the above example, calling <code class="computeroutput"><span class="identifier">node</span><span class="special">.</span><span class="identifier">child_value</span><span class="special">(</span><span class="string">"description"</span><span class="special">)</span></code> and <code class="computeroutput"><span class="identifier">description</span><span class="special">.</span><span class="identifier">child_value</span><span class="special">()</span></code> will both produce string <code class="computeroutput"><span class="string">"This is a node"</span></code>. If there is no
+        child with relevant type, or if the handle is null, <code class="computeroutput"><span class="identifier">child_value</span></code>
+        functions return empty string.
+      </p>
+<p>
+        <code class="computeroutput"><span class="identifier">text</span><span class="special">()</span></code>
+        returns a special object that can be used for working with PCDATA contents
+        in more complex cases than just retrieving the value; it is described in
+        <a class="xref" href="access.html#manual.access.text" title="Working with text contents"> Working with text contents</a> sections.
+      </p>
+<p>
+        There is an example of using some of these functions <a class="link" href="access.html#code_traverse_base_data">at
+        the end of the next section</a>.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.access.attrdata"></a><a class="link" href="access.html#manual.access.attrdata" title="Getting attribute data"> Getting attribute data</a>
+</h3></div></div></div>
+<a name="xml_attribute::name"></a><a name="xml_attribute::value"></a><p>
+        All attributes have name and value, both of which are strings (value may
+        be empty). There are two corresponding accessors, like for <code class="computeroutput"><span class="identifier">xml_node</span></code>:
+      </p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">name</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">value</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        In case the attribute handle is null, both functions return empty strings
+        - they never return null pointers.
+      </p>
+<a name="xml_attribute::as_string"></a><p>
+        If you need a non-empty string if the attribute handle is null (for example,
+        you need to get the option value from XML attribute, but if it is not specified,
+        you need it to default to <code class="computeroutput"><span class="string">"sorted"</span></code>
+        instead of <code class="computeroutput"><span class="string">""</span></code>), you
+        can use <code class="computeroutput"><span class="identifier">as_string</span></code> accessor:
+      </p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">as_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">def</span> <span class="special">=</span> <span class="string">""</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        It returns <code class="computeroutput"><span class="identifier">def</span></code> argument if
+        the attribute handle is null. If you do not specify the argument, the function
+        is equivalent to <code class="computeroutput"><span class="identifier">value</span><span class="special">()</span></code>.
+      </p>
+<a name="xml_attribute::as_int"></a><a name="xml_attribute::as_uint"></a><a name="xml_attribute::as_double"></a><a name="xml_attribute::as_float"></a><a name="xml_attribute::as_bool"></a><p>
+        In many cases attribute values have types that are not strings - i.e. an
+        attribute may always contain values that should be treated as integers, despite
+        the fact that they are represented as strings in XML. pugixml provides several
+        accessors that convert attribute value to some other type:
+      </p>
+<pre class="programlisting"><span class="keyword">int</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">as_int</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">def</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">as_uint</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">def</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">double</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">as_double</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">def</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">float</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">as_float</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">def</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">bool</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">as_bool</span><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">def</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        <code class="computeroutput"><span class="identifier">as_int</span></code>, <code class="computeroutput"><span class="identifier">as_uint</span></code>,
+        <code class="computeroutput"><span class="identifier">as_double</span></code> and <code class="computeroutput"><span class="identifier">as_float</span></code> convert attribute values to numbers.
+        If attribute handle is null or attribute value is empty, <code class="computeroutput"><span class="identifier">def</span></code>
+        argument is returned (which is 0 by default). Otherwise, all leading whitespace
+        characters are truncated, and the remaining string is parsed as a decimal
+        number (<code class="computeroutput"><span class="identifier">as_int</span></code> or <code class="computeroutput"><span class="identifier">as_uint</span></code>) or as a floating point number
+        in either decimal or scientific form (<code class="computeroutput"><span class="identifier">as_double</span></code>
+        or <code class="computeroutput"><span class="identifier">as_float</span></code>). Any extra characters
+        are silently discarded, i.e. <code class="computeroutput"><span class="identifier">as_int</span></code>
+        will return <code class="computeroutput"><span class="number">1</span></code> for string <code class="computeroutput"><span class="string">"1abc"</span></code>.
+      </p>
+<p>
+        In case the input string contains a number that is out of the target numeric
+        range, the result is undefined.
+      </p>
+<div class="caution"><table border="0" summary="Caution">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="../images/caution.png"></td>
+<th align="left">Caution</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          Number conversion functions depend on current C locale as set with <code class="computeroutput"><span class="identifier">setlocale</span></code>, so may return unexpected results
+          if the locale is different from <code class="computeroutput"><span class="string">"C"</span></code>.
+        </p></td></tr>
+</table></div>
+<p>
+        <code class="computeroutput"><span class="identifier">as_bool</span></code> converts attribute
+        value to boolean as follows: if attribute handle is null, <code class="computeroutput"><span class="identifier">def</span></code>
+        argument is returned (which is <code class="computeroutput"><span class="keyword">false</span></code>
+        by default). If attribute value is empty, <code class="computeroutput"><span class="keyword">false</span></code>
+        is returned. Otherwise, <code class="computeroutput"><span class="keyword">true</span></code>
+        is returned if the first character is one of <code class="computeroutput"><span class="char">'1'</span><span class="special">,</span> <span class="char">'t'</span><span class="special">,</span>
+        <span class="char">'T'</span><span class="special">,</span> <span class="char">'y'</span><span class="special">,</span> <span class="char">'Y'</span></code>.
+        This means that strings like <code class="computeroutput"><span class="string">"true"</span></code>
+        and <code class="computeroutput"><span class="string">"yes"</span></code> are recognized
+        as <code class="computeroutput"><span class="keyword">true</span></code>, while strings like
+        <code class="computeroutput"><span class="string">"false"</span></code> and <code class="computeroutput"><span class="string">"no"</span></code> are recognized as <code class="computeroutput"><span class="keyword">false</span></code>. For more complex matching you'll have
+        to write your own function.
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          There are no portable 64-bit types in C++, so there is no corresponding
+          conversion function. If your platform has a 64-bit integer, you can easily
+          write a conversion function yourself.
+        </p></td></tr>
+</table></div>
+<a name="code_traverse_base_data"></a><p>
+        This is an example of using these functions, along with node data retrieval
+        ones (<a href="../samples/traverse_base.cpp" target="_top">samples/traverse_base.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">);</span> <span class="identifier">tool</span><span class="special">;</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">next_sibling</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">))</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Tool "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Filename"</span><span class="special">).</span><span class="identifier">value</span><span class="special">();</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">": AllowRemote "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"AllowRemote"</span><span class="special">).</span><span class="identifier">as_bool</span><span class="special">();</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">", Timeout "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Timeout"</span><span class="special">).</span><span class="identifier">as_int</span><span class="special">();</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">", Description '"</span> <span class="special">&lt;&lt;</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">child_value</span><span class="special">(</span><span class="string">"Description"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">"'\n"</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.access.contents"></a><a class="link" href="access.html#manual.access.contents" title="Contents-based traversal functions"> Contents-based traversal functions</a>
+</h3></div></div></div>
+<a name="xml_node::child"></a><a name="xml_node::attribute"></a><a name="xml_node::next_sibling_name"></a><a name="xml_node::previous_sibling_name"></a><p>
+        Since a lot of document traversal consists of finding the node/attribute
+        with the correct name, there are special functions for that purpose:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">child</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_attribute</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">attribute</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">next_sibling</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">previous_sibling</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        <code class="computeroutput"><span class="identifier">child</span></code> and <code class="computeroutput"><span class="identifier">attribute</span></code>
+        return the first child/attribute with the specified name; <code class="computeroutput"><span class="identifier">next_sibling</span></code>
+        and <code class="computeroutput"><span class="identifier">previous_sibling</span></code> return
+        the first sibling in the corresponding direction with the specified name.
+        All string comparisons are case-sensitive. In case the node handle is null
+        or there is no node/attribute with the specified name, null handle is returned.
+      </p>
+<p>
+        <code class="computeroutput"><span class="identifier">child</span></code> and <code class="computeroutput"><span class="identifier">next_sibling</span></code>
+        functions can be used together to loop through all child nodes with the desired
+        name like this:
+      </p>
+<pre class="programlisting"><span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">);</span> <span class="identifier">tool</span><span class="special">;</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">next_sibling</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">))</span>
+</pre>
+<a name="xml_node::find_child_by_attribute"></a><p>
+        Occasionally the needed node is specified not by the unique name but instead
+        by the value of some attribute; for example, it is common to have node collections
+        with each node having a unique id: <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">group</span><span class="special">&gt;&lt;</span><span class="identifier">item</span> <span class="identifier">id</span><span class="special">=</span><span class="string">"1"</span><span class="special">/&gt;</span> <span class="special">&lt;</span><span class="identifier">item</span> <span class="identifier">id</span><span class="special">=</span><span class="string">"2"</span><span class="special">/&gt;&lt;/</span><span class="identifier">group</span><span class="special">&gt;</span></code>. There are two functions for finding
+        child nodes based on the attribute values:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">find_child_by_attribute</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">attr_name</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">attr_value</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">find_child_by_attribute</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">attr_name</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">attr_value</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        The three-argument function returns the first child node with the specified
+        name which has an attribute with the specified name/value; the two-argument
+        function skips the name test for the node, which can be useful for searching
+        in heterogeneous collections. If the node handle is null or if no node is
+        found, null handle is returned. All string comparisons are case-sensitive.
+      </p>
+<p>
+        In all of the above functions, all arguments have to be valid strings; passing
+        null pointers results in undefined behavior.
+      </p>
+<p>
+        This is an example of using these functions (<a href="../samples/traverse_base.cpp" target="_top">samples/traverse_base.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Tool for *.dae generation: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">find_child_by_attribute</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">,</span> <span class="string">"OutputFileMasks"</span><span class="special">,</span> <span class="string">"*.dae"</span><span class="special">).</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Filename"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
+
+<span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">);</span> <span class="identifier">tool</span><span class="special">;</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">next_sibling</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">))</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Tool "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Filename"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.access.rangefor"></a><a class="link" href="access.html#manual.access.rangefor" title="Range-based for-loop support"> Range-based for-loop support</a>
+</h3></div></div></div>
+<a name="xml_node::children"></a><a name="xml_node::attributes"></a><p>
+        If your C++ compiler supports range-based for-loop (this is a C++11 feature,
+        at the time of writing it's supported by Microsoft Visual Studio 11 Beta,
+        GCC 4.6 and Clang 3.0), you can use it to enumerate nodes/attributes. Additional
+        helpers are provided to support this; note that they are also compatible
+        with <a href="http://www.boost.org/libs/foreach/" target="_top">Boost Foreach</a>,
+        and possibly other pre-C++11 foreach facilities.
+      </p>
+<pre class="programlisting"><span class="emphasis"><em>implementation-defined type</em></span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">children</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="emphasis"><em>implementation-defined type</em></span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">children</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="emphasis"><em>implementation-defined type</em></span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">attributes</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        <code class="computeroutput"><span class="identifier">children</span></code> function allows
+        you to enumerate all child nodes; <code class="computeroutput"><span class="identifier">children</span></code>
+        function with <code class="computeroutput"><span class="identifier">name</span></code> argument
+        allows you to enumerate all child nodes with a specific name; <code class="computeroutput"><span class="identifier">attributes</span></code> function allows you to enumerate
+        all attributes of the node. Note that you can also use node object itself
+        in a range-based for construct, which is equivalent to using <code class="computeroutput"><span class="identifier">children</span><span class="special">()</span></code>.
+      </p>
+<p>
+        This is an example of using these functions (<a href="../samples/traverse_rangefor.cpp" target="_top">samples/traverse_rangefor.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">tool</span><span class="special">:</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">children</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">))</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Tool:"</span><span class="special">;</span>
+
+    <span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_attribute</span> <span class="identifier">attr</span><span class="special">:</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">attributes</span><span class="special">())</span>
+    <span class="special">{</span>
+        <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"="</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">value</span><span class="special">();</span>
+    <span class="special">}</span>
+
+    <span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">child</span><span class="special">:</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">children</span><span class="special">())</span>
+    <span class="special">{</span>
+        <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">", child "</span> <span class="special">&lt;&lt;</span> <span class="identifier">child</span><span class="special">.</span><span class="identifier">name</span><span class="special">();</span>
+    <span class="special">}</span>
+
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.access.iterators"></a><a class="link" href="access.html#manual.access.iterators" title="Traversing node/attribute lists via iterators"> Traversing node/attribute lists
+      via iterators</a>
+</h3></div></div></div>
+<a name="xml_node_iterator"></a><a name="xml_attribute_iterator"></a><a name="xml_node::begin"></a><a name="xml_node::end"></a><a name="xml_node::attributes_begin"></a><a name="xml_node::attributes_end"></a><p>
+        Child node lists and attribute lists are simply double-linked lists; while
+        you can use <code class="computeroutput"><span class="identifier">previous_sibling</span></code>/<code class="computeroutput"><span class="identifier">next_sibling</span></code> and other such functions for
+        iteration, pugixml additionally provides node and attribute iterators, so
+        that you can treat nodes as containers of other nodes or attributes:
+      </p>
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">xml_node_iterator</span><span class="special">;</span>
+<span class="keyword">class</span> <span class="identifier">xml_attribute_iterator</span><span class="special">;</span>
+
+<span class="keyword">typedef</span> <span class="identifier">xml_node_iterator</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">iterator</span><span class="special">;</span>
+<span class="identifier">iterator</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">begin</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">iterator</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">end</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+
+<span class="keyword">typedef</span> <span class="identifier">xml_attribute_iterator</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">attribute_iterator</span><span class="special">;</span>
+<span class="identifier">attribute_iterator</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">attributes_begin</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">attribute_iterator</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">attributes_end</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        <code class="computeroutput"><span class="identifier">begin</span></code> and <code class="computeroutput"><span class="identifier">attributes_begin</span></code>
+        return iterators that point to the first node/attribute, respectively; <code class="computeroutput"><span class="identifier">end</span></code> and <code class="computeroutput"><span class="identifier">attributes_end</span></code>
+        return past-the-end iterator for node/attribute list, respectively - this
+        iterator can't be dereferenced, but decrementing it results in an iterator
+        pointing to the last element in the list (except for empty lists, where decrementing
+        past-the-end iterator results in undefined behavior). Past-the-end iterator
+        is commonly used as a termination value for iteration loops (see sample below).
+        If you want to get an iterator that points to an existing handle, you can
+        construct the iterator with the handle as a single constructor argument,
+        like so: <code class="computeroutput"><span class="identifier">xml_node_iterator</span><span class="special">(</span><span class="identifier">node</span><span class="special">)</span></code>.
+        For <code class="computeroutput"><span class="identifier">xml_attribute_iterator</span></code>,
+        you'll have to provide both an attribute and its parent node.
+      </p>
+<p>
+        <code class="computeroutput"><span class="identifier">begin</span></code> and <code class="computeroutput"><span class="identifier">end</span></code>
+        return equal iterators if called on null node; such iterators can't be dereferenced.
+        <code class="computeroutput"><span class="identifier">attributes_begin</span></code> and <code class="computeroutput"><span class="identifier">attributes_end</span></code> behave the same way. For
+        correct iterator usage this means that child node/attribute collections of
+        null nodes appear to be empty.
+      </p>
+<p>
+        Both types of iterators have bidirectional iterator semantics (i.e. they
+        can be incremented and decremented, but efficient random access is not supported)
+        and support all usual iterator operations - comparison, dereference, etc.
+        The iterators are invalidated if the node/attribute objects they're pointing
+        to are removed from the tree; adding nodes/attributes does not invalidate
+        any iterators.
+      </p>
+<p>
+        Here is an example of using iterators for document traversal (<a href="../samples/traverse_iter.cpp" target="_top">samples/traverse_iter.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node_iterator</span> <span class="identifier">it</span> <span class="special">=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span> <span class="identifier">it</span> <span class="special">!=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span> <span class="special">++</span><span class="identifier">it</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Tool:"</span><span class="special">;</span>
+
+    <span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_attribute_iterator</span> <span class="identifier">ait</span> <span class="special">=</span> <span class="identifier">it</span><span class="special">-&gt;</span><span class="identifier">attributes_begin</span><span class="special">();</span> <span class="identifier">ait</span> <span class="special">!=</span> <span class="identifier">it</span><span class="special">-&gt;</span><span class="identifier">attributes_end</span><span class="special">();</span> <span class="special">++</span><span class="identifier">ait</span><span class="special">)</span>
+    <span class="special">{</span>
+        <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">ait</span><span class="special">-&gt;</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"="</span> <span class="special">&lt;&lt;</span> <span class="identifier">ait</span><span class="special">-&gt;</span><span class="identifier">value</span><span class="special">();</span>
+    <span class="special">}</span>
+
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+<div class="caution"><table border="0" summary="Caution">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="../images/caution.png"></td>
+<th align="left">Caution</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          Node and attribute iterators are somewhere in the middle between const
+          and non-const iterators. While dereference operation yields a non-constant
+          reference to the object, so that you can use it for tree modification operations,
+          modifying this reference by assignment - i.e. passing iterators to a function
+          like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">sort</span></code> - will not give expected results,
+          as assignment modifies local handle that's stored in the iterator.
+        </p></td></tr>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.access.walker"></a><a class="link" href="access.html#manual.access.walker" title="Recursive traversal with xml_tree_walker"> Recursive traversal with xml_tree_walker</a>
+</h3></div></div></div>
+<a name="xml_tree_walker"></a><p>
+        The methods described above allow traversal of immediate children of some
+        node; if you want to do a deep tree traversal, you'll have to do it via a
+        recursive function or some equivalent method. However, pugixml provides a
+        helper for depth-first traversal of a subtree. In order to use it, you have
+        to implement <code class="computeroutput"><span class="identifier">xml_tree_walker</span></code>
+        interface and to call <code class="computeroutput"><span class="identifier">traverse</span></code>
+        function:
+      </p>
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">xml_tree_walker</span>
+<span class="special">{</span>
+<span class="keyword">public</span><span class="special">:</span>
+    <span class="keyword">virtual</span> <span class="keyword">bool</span> <span class="identifier">begin</span><span class="special">(</span><span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+    <span class="keyword">virtual</span> <span class="keyword">bool</span> <span class="identifier">for_each</span><span class="special">(</span><span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
+    <span class="keyword">virtual</span> <span class="keyword">bool</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+    <span class="keyword">int</span> <span class="identifier">depth</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="keyword">bool</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">traverse</span><span class="special">(</span><span class="identifier">xml_tree_walker</span><span class="special">&amp;</span> <span class="identifier">walker</span><span class="special">);</span>
+</pre>
+<a name="xml_tree_walker::begin"></a><a name="xml_tree_walker::for_each"></a><a name="xml_tree_walker::end"></a><a name="xml_node::traverse"></a><p>
+        The traversal is launched by calling <code class="computeroutput"><span class="identifier">traverse</span></code>
+        function on traversal root and proceeds as follows:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            First, <code class="computeroutput"><span class="identifier">begin</span></code> function
+            is called with traversal root as its argument.
+          </li>
+<li class="listitem">
+            Then, <code class="computeroutput"><span class="identifier">for_each</span></code> function
+            is called for all nodes in the traversal subtree in depth first order,
+            excluding the traversal root. Node is passed as an argument.
+          </li>
+<li class="listitem">
+            Finally, <code class="computeroutput"><span class="identifier">end</span></code> function
+            is called with traversal root as its argument.
+          </li>
+</ul></div>
+<p>
+        If <code class="computeroutput"><span class="identifier">begin</span></code>, <code class="computeroutput"><span class="identifier">end</span></code>
+        or any of the <code class="computeroutput"><span class="identifier">for_each</span></code> calls
+        return <code class="computeroutput"><span class="keyword">false</span></code>, the traversal
+        is terminated and <code class="computeroutput"><span class="keyword">false</span></code> is returned
+        as the traversal result; otherwise, the traversal results in <code class="computeroutput"><span class="keyword">true</span></code>. Note that you don't have to override
+        <code class="computeroutput"><span class="identifier">begin</span></code> or <code class="computeroutput"><span class="identifier">end</span></code>
+        functions; their default implementations return <code class="computeroutput"><span class="keyword">true</span></code>.
+      </p>
+<a name="xml_tree_walker::depth"></a><p>
+        You can get the node's depth relative to the traversal root at any point
+        by calling <code class="computeroutput"><span class="identifier">depth</span></code> function.
+        It returns <code class="computeroutput"><span class="special">-</span><span class="number">1</span></code>
+        if called from <code class="computeroutput"><span class="identifier">begin</span></code>/<code class="computeroutput"><span class="identifier">end</span></code>, and returns 0-based depth if called
+        from <code class="computeroutput"><span class="identifier">for_each</span></code> - depth is
+        0 for all children of the traversal root, 1 for all grandchildren and so
+        on.
+      </p>
+<p>
+        This is an example of traversing tree hierarchy with xml_tree_walker (<a href="../samples/traverse_walker.cpp" target="_top">samples/traverse_walker.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">simple_walker</span><span class="special">:</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_tree_walker</span>
+<span class="special">{</span>
+    <span class="keyword">virtual</span> <span class="keyword">bool</span> <span class="identifier">for_each</span><span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">)</span>
+    <span class="special">{</span>
+        <span class="keyword">for</span> <span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">depth</span><span class="special">();</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"  "</span><span class="special">;</span> <span class="comment">// indentation
+</span>
+        <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">node_types</span><span class="special">[</span><span class="identifier">node</span><span class="special">.</span><span class="identifier">type</span><span class="special">()]</span> <span class="special">&lt;&lt;</span> <span class="string">": name='"</span> <span class="special">&lt;&lt;</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"', value='"</span> <span class="special">&lt;&lt;</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"'\n"</span><span class="special">;</span>
+
+        <span class="keyword">return</span> <span class="keyword">true</span><span class="special">;</span> <span class="comment">// continue traversal
+</span>    <span class="special">}</span>
+<span class="special">};</span>
+</pre>
+<p>
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">simple_walker</span> <span class="identifier">walker</span><span class="special">;</span>
+<span class="identifier">doc</span><span class="special">.</span><span class="identifier">traverse</span><span class="special">(</span><span class="identifier">walker</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.access.predicate"></a><a class="link" href="access.html#manual.access.predicate" title="Searching for nodes/attributes with predicates"> Searching for nodes/attributes
+      with predicates</a>
+</h3></div></div></div>
+<a name="xml_node::find_attribute"></a><a name="xml_node::find_child"></a><a name="xml_node::find_node"></a><p>
+        While there are existing functions for getting a node/attribute with known
+        contents, they are often not sufficient for simple queries. As an alternative
+        for manual iteration through nodes/attributes until the needed one is found,
+        you can make a predicate and call one of <code class="computeroutput"><span class="identifier">find_</span></code>
+        functions:
+      </p>
+<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span> <span class="identifier">xml_attribute</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">find_attribute</span><span class="special">(</span><span class="identifier">Predicate</span> <span class="identifier">pred</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span> <span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">find_child</span><span class="special">(</span><span class="identifier">Predicate</span> <span class="identifier">pred</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span> <span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">find_node</span><span class="special">(</span><span class="identifier">Predicate</span> <span class="identifier">pred</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        The predicate should be either a plain function or a function object which
+        accepts one argument of type <code class="computeroutput"><span class="identifier">xml_attribute</span></code>
+        (for <code class="computeroutput"><span class="identifier">find_attribute</span></code>) or
+        <code class="computeroutput"><span class="identifier">xml_node</span></code> (for <code class="computeroutput"><span class="identifier">find_child</span></code> and <code class="computeroutput"><span class="identifier">find_node</span></code>),
+        and returns <code class="computeroutput"><span class="keyword">bool</span></code>. The predicate
+        is never called with null handle as an argument.
+      </p>
+<p>
+        <code class="computeroutput"><span class="identifier">find_attribute</span></code> function iterates
+        through all attributes of the specified node, and returns the first attribute
+        for which the predicate returned <code class="computeroutput"><span class="keyword">true</span></code>.
+        If the predicate returned <code class="computeroutput"><span class="keyword">false</span></code>
+        for all attributes or if there were no attributes (including the case where
+        the node is null), null attribute is returned.
+      </p>
+<p>
+        <code class="computeroutput"><span class="identifier">find_child</span></code> function iterates
+        through all child nodes of the specified node, and returns the first node
+        for which the predicate returned <code class="computeroutput"><span class="keyword">true</span></code>.
+        If the predicate returned <code class="computeroutput"><span class="keyword">false</span></code>
+        for all nodes or if there were no child nodes (including the case where the
+        node is null), null node is returned.
+      </p>
+<p>
+        <code class="computeroutput"><span class="identifier">find_node</span></code> function performs
+        a depth-first traversal through the subtree of the specified node (excluding
+        the node itself), and returns the first node for which the predicate returned
+        <code class="computeroutput"><span class="keyword">true</span></code>. If the predicate returned
+        <code class="computeroutput"><span class="keyword">false</span></code> for all nodes or if subtree
+        was empty, null node is returned.
+      </p>
+<p>
+        This is an example of using predicate-based functions (<a href="../samples/traverse_predicate.cpp" target="_top">samples/traverse_predicate.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">small_timeout</span><span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">node</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="keyword">return</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Timeout"</span><span class="special">).</span><span class="identifier">as_int</span><span class="special">()</span> <span class="special">&lt;</span> <span class="number">20</span><span class="special">;</span>
+<span class="special">}</span>
+
+<span class="keyword">struct</span> <span class="identifier">allow_remote_predicate</span>
+<span class="special">{</span>
+    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_attribute</span> <span class="identifier">attr</span><span class="special">)</span> <span class="keyword">const</span>
+    <span class="special">{</span>
+        <span class="keyword">return</span> <span class="identifier">strcmp</span><span class="special">(</span><span class="identifier">attr</span><span class="special">.</span><span class="identifier">name</span><span class="special">(),</span> <span class="string">"AllowRemote"</span><span class="special">)</span> <span class="special">==</span> <span class="number">0</span><span class="special">;</span>
+    <span class="special">}</span>
+
+    <span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">node</span><span class="special">)</span> <span class="keyword">const</span>
+    <span class="special">{</span>
+        <span class="keyword">return</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"AllowRemote"</span><span class="special">).</span><span class="identifier">as_bool</span><span class="special">();</span>
+    <span class="special">}</span>
+<span class="special">};</span>
+</pre>
+<p>
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// Find child via predicate (looks for direct children only)
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">find_child</span><span class="special">(</span><span class="identifier">allow_remote_predicate</span><span class="special">()).</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Filename"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// Find node via predicate (looks for all descendants in depth-first order)
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">find_node</span><span class="special">(</span><span class="identifier">allow_remote_predicate</span><span class="special">()).</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Filename"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// Find attribute via predicate
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">last_child</span><span class="special">().</span><span class="identifier">find_attribute</span><span class="special">(</span><span class="identifier">allow_remote_predicate</span><span class="special">()).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// We can use simple functions instead of function objects
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">find_child</span><span class="special">(</span><span class="identifier">small_timeout</span><span class="special">).</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Filename"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.access.text"></a><a class="link" href="access.html#manual.access.text" title="Working with text contents"> Working with text contents</a>
+</h3></div></div></div>
+<a name="xml_text"></a><p>
+        It is common to store data as text contents of some node - i.e. <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">node</span><span class="special">&gt;&lt;</span><span class="identifier">description</span><span class="special">&gt;</span><span class="identifier">This</span> <span class="identifier">is</span> <span class="identifier">a</span> <span class="identifier">node</span><span class="special">&lt;/</span><span class="identifier">description</span><span class="special">&gt;&lt;/</span><span class="identifier">node</span><span class="special">&gt;</span></code>.
+        In this case, <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">description</span><span class="special">&gt;</span></code> node does not have a value, but instead
+        has a child of type <a class="link" href="dom.html#node_pcdata">node_pcdata</a> with value
+        <code class="computeroutput"><span class="string">"This is a node"</span></code>. pugixml
+        provides a special class, <code class="computeroutput"><span class="identifier">xml_text</span></code>,
+        to work with such data. Working with text objects to modify data is described
+        in <a class="link" href="modify.html#manual.modify.text" title="Working with text contents">the documentation for modifying document
+        data</a>; this section describes the access interface of <code class="computeroutput"><span class="identifier">xml_text</span></code>.
+      </p>
+<a name="xml_node::text"></a><p>
+        You can get the text object from a node by using <code class="computeroutput"><span class="identifier">text</span><span class="special">()</span></code> method:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_text</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">text</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        If the node has a type <code class="computeroutput"><span class="identifier">node_pcdata</span></code>
+        or <code class="computeroutput"><span class="identifier">node_cdata</span></code>, then the node
+        itself is used to return data; otherwise, a first child node of type <code class="computeroutput"><span class="identifier">node_pcdata</span></code> or <code class="computeroutput"><span class="identifier">node_cdata</span></code>
+        is used.
+      </p>
+<a name="xml_text::empty"></a><a name="xml_text::unspecified_bool_type"></a><p>
+        You can check if the text object is bound to a valid PCDATA/CDATA node by
+        using it as a boolean value, i.e. <code class="computeroutput"><span class="keyword">if</span>
+        <span class="special">(</span><span class="identifier">text</span><span class="special">)</span> <span class="special">{</span> <span class="special">...</span>
+        <span class="special">}</span></code> or <code class="computeroutput"><span class="keyword">if</span>
+        <span class="special">(!</span><span class="identifier">text</span><span class="special">)</span> <span class="special">{</span> <span class="special">...</span>
+        <span class="special">}</span></code>. Alternatively you can check it
+        by using the <code class="computeroutput"><span class="identifier">empty</span><span class="special">()</span></code>
+        method:
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<a name="xml_text::get"></a><p>
+        Given a text object, you can get the contents (i.e. the value of PCDATA/CDATA
+        node) by using the following function:
+      </p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">get</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        In case text object is empty, the function returns an empty string - it never
+        returns a null pointer.
+      </p>
+<a name="xml_text::as_string"></a><a name="xml_text::as_int"></a><a name="xml_text::as_uint"></a><a name="xml_text::as_double"></a><a name="xml_text::as_float"></a><a name="xml_text::as_bool"></a><p>
+        If you need a non-empty string if the text object is empty, or if the text
+        contents is actually a number or a boolean that is stored as a string, you
+        can use the following accessors:
+      </p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">as_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">def</span> <span class="special">=</span> <span class="string">""</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">int</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">as_int</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">def</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">as_uint</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">def</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">double</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">as_double</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">def</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">float</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">as_float</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">def</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">bool</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">as_bool</span><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">def</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        All of the above functions have the same semantics as similar <code class="computeroutput"><span class="identifier">xml_attribute</span></code> members: they return the
+        default argument if the text object is empty, they convert the text contents
+        to a target type using the same rules and restrictions. You can <a class="link" href="access.html#xml_attribute::as_int">refer
+        to documentation for the attribute functions</a> for details.
+      </p>
+<a name="xml_text::data"></a><p>
+        <code class="computeroutput"><span class="identifier">xml_text</span></code> is essentially a
+        helper class that operates on <code class="computeroutput"><span class="identifier">xml_node</span></code>
+        values. It is bound to a node of type <a class="link" href="dom.html#node_pcdata">node_pcdata</a>
+        or <a class="link" href="dom.html#node_cdata">node_cdata</a>. You can use the following
+        function to retrieve this node:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_node</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">data</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        Essentially, assuming <code class="computeroutput"><span class="identifier">text</span></code>
+        is an <code class="computeroutput"><span class="identifier">xml_text</span></code> object, calling
+        <code class="computeroutput"><span class="identifier">text</span><span class="special">.</span><span class="identifier">get</span><span class="special">()</span></code> is
+        equivalent to calling <code class="computeroutput"><span class="identifier">text</span><span class="special">.</span><span class="identifier">data</span><span class="special">().</span><span class="identifier">value</span><span class="special">()</span></code>.
+      </p>
+<p>
+        This is an example of using <code class="computeroutput"><span class="identifier">xml_text</span></code>
+        object (<a href="../samples/text.cpp" target="_top">samples/text.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Project name: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">project</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"name"</span><span class="special">).</span><span class="identifier">text</span><span class="special">().</span><span class="identifier">get</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Project version: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">project</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"version"</span><span class="special">).</span><span class="identifier">text</span><span class="special">().</span><span class="identifier">as_double</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Project visibility: "</span> <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">project</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"public"</span><span class="special">).</span><span class="identifier">text</span><span class="special">().</span><span class="identifier">as_bool</span><span class="special">(/*</span> <span class="identifier">def</span><span class="special">=</span> <span class="special">*/</span> <span class="keyword">true</span><span class="special">)</span> <span class="special">?</span> <span class="string">"public"</span> <span class="special">:</span> <span class="string">"private"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Project description: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">project</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"description"</span><span class="special">).</span><span class="identifier">text</span><span class="special">().</span><span class="identifier">get</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.access.misc"></a><a class="link" href="access.html#manual.access.misc" title="Miscellaneous functions"> Miscellaneous functions</a>
+</h3></div></div></div>
+<a name="xml_node::root"></a><p>
+        If you need to get the document root of some node, you can use the following
+        function:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">root</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        This function returns the node with type <a class="link" href="dom.html#node_document">node_document</a>,
+        which is the root node of the document the node belongs to (unless the node
+        is null, in which case null node is returned).
+      </p>
+<a name="xml_node::path"></a><a name="xml_node::first_element_by_path"></a><p>
+        While pugixml supports complex XPath expressions, sometimes a simple path
+        handling facility is needed. There are two functions, for getting node path
+        and for converting path to a node:
+      </p>
+<pre class="programlisting"><span class="identifier">string_t</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">path</span><span class="special">(</span><span class="identifier">char_t</span> <span class="identifier">delimiter</span> <span class="special">=</span> <span class="char">'/'</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">first_element_by_path</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">path</span><span class="special">,</span> <span class="identifier">char_t</span> <span class="identifier">delimiter</span> <span class="special">=</span> <span class="char">'/'</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        Node paths consist of node names, separated with a delimiter (which is <code class="computeroutput"><span class="special">/</span></code> by default); also paths can contain self
+        (<code class="computeroutput"><span class="special">.</span></code>) and parent (<code class="computeroutput"><span class="special">..</span></code>) pseudo-names, so that this is a valid
+        path: <code class="computeroutput"><span class="string">"../../foo/./bar"</span></code>.
+        <code class="computeroutput"><span class="identifier">path</span></code> returns the path to
+        the node from the document root, <code class="computeroutput"><span class="identifier">first_element_by_path</span></code>
+        looks for a node represented by a given path; a path can be an absolute one
+        (absolute paths start with the delimiter), in which case the rest of the
+        path is treated as document root relative, and relative to the given node.
+        For example, in the following document: <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">a</span><span class="special">&gt;&lt;</span><span class="identifier">b</span><span class="special">&gt;&lt;</span><span class="identifier">c</span><span class="special">/&gt;&lt;/</span><span class="identifier">b</span><span class="special">&gt;&lt;/</span><span class="identifier">a</span><span class="special">&gt;</span></code>,
+        node <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">c</span><span class="special">/&gt;</span></code> has path <code class="computeroutput"><span class="string">"a/b/c"</span></code>;
+        calling <code class="computeroutput"><span class="identifier">first_element_by_path</span></code>
+        for document with path <code class="computeroutput"><span class="string">"a/b"</span></code>
+        results in node <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">b</span><span class="special">/&gt;</span></code>; calling <code class="computeroutput"><span class="identifier">first_element_by_path</span></code>
+        for node <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">a</span><span class="special">/&gt;</span></code> with path <code class="computeroutput"><span class="string">"../a/./b/../."</span></code>
+        results in node <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">a</span><span class="special">/&gt;</span></code>; calling <code class="computeroutput"><span class="identifier">first_element_by_path</span></code>
+        with path <code class="computeroutput"><span class="string">"/a"</span></code> results
+        in node <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">a</span><span class="special">/&gt;</span></code> for any node.
+      </p>
+<p>
+        In case path component is ambiguous (if there are two nodes with given name),
+        the first one is selected; paths are not guaranteed to uniquely identify
+        nodes in a document. If any component of a path is not found, the result
+        of <code class="computeroutput"><span class="identifier">first_element_by_path</span></code>
+        is null node; also <code class="computeroutput"><span class="identifier">first_element_by_path</span></code>
+        returns null node for null nodes, in which case the path does not matter.
+        <code class="computeroutput"><span class="identifier">path</span></code> returns an empty string
+        for null nodes.
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          <code class="computeroutput"><span class="identifier">path</span></code> function returns the
+          result as STL string, and thus is not available if <a class="link" href="install.html#PUGIXML_NO_STL">PUGIXML_NO_STL</a>
+          is defined.
+        </p></td></tr>
+</table></div>
+<a name="xml_node::offset_debug"></a><p>
+        pugixml does not record row/column information for nodes upon parsing for
+        efficiency reasons. However, if the node has not changed in a significant
+        way since parsing (the name/value are not changed, and the node itself is
+        the original one, i.e. it was not deleted from the tree and re-added later),
+        it is possible to get the offset from the beginning of XML buffer:
+      </p>
+<pre class="programlisting"><span class="identifier">ptrdiff_t</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">offset_debug</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        If the offset is not available (this happens if the node is null, was not
+        originally parsed from a stream, or has changed in a significant way), the
+        function returns -1. Otherwise it returns the offset to node's data from
+        the beginning of XML buffer in <a class="link" href="dom.html#char_t">pugi::char_t</a>
+        units. For more information on parsing offsets, see <a class="link" href="loading.html#xml_parse_result::offset">parsing
+        error handling documentation</a>.
+      </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2012 Arseny Kapoulkine<p>
+        Distributed under the MIT License
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <b>Accessing</b> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="loading.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="modify.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+</body>
+</html>
diff --git a/tools/intergen/third_party/pugixml/docs/manual/apiref.html b/tools/intergen/third_party/pugixml/docs/manual/apiref.html
new file mode 100644
index 0000000000..cf1a137432
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/manual/apiref.html
@@ -0,0 +1,1554 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>API Reference</title>
+<link rel="stylesheet" href="../pugixml.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../manual.html" title="pugixml 1.2">
+<link rel="up" href="../manual.html" title="pugixml 1.2">
+<link rel="prev" href="changes.html" title="Changelog">
+<link rel="next" href="toc.html" title="Table of Contents">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<b>API Reference</b> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="changes.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="toc.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+<hr>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="manual.apiref"></a><a class="link" href="apiref.html" title="API Reference"> API Reference</a>
+</h2></div></div></div>
+<p>
+      This is the reference for all macros, types, enumerations, classes and functions
+      in pugixml. Each symbol is a link that leads to the relevant section of the
+      manual.
+    </p>
+<p>
+      Macros:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          <code class="computeroutput"><span class="preprocessor">#define</span> </code><a class="link" href="install.html#PUGIXML_WCHAR_MODE">PUGIXML_WCHAR_MODE</a>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="preprocessor">#define</span> </code><a class="link" href="install.html#PUGIXML_NO_XPATH">PUGIXML_NO_XPATH</a>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="preprocessor">#define</span> </code><a class="link" href="install.html#PUGIXML_NO_STL">PUGIXML_NO_STL</a>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="preprocessor">#define</span> </code><a class="link" href="install.html#PUGIXML_NO_EXCEPTIONS">PUGIXML_NO_EXCEPTIONS</a>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="preprocessor">#define</span> </code><a class="link" href="install.html#PUGIXML_API">PUGIXML_API</a>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="preprocessor">#define</span> </code><a class="link" href="install.html#PUGIXML_CLASS">PUGIXML_CLASS</a>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="preprocessor">#define</span> </code><a class="link" href="install.html#PUGIXML_FUNCTION">PUGIXML_FUNCTION</a>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="preprocessor">#define</span> </code><a class="link" href="install.html#PUGIXML_MEMORY_PAGE_SIZE">PUGIXML_MEMORY_PAGE_SIZE</a>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="preprocessor">#define</span> </code><a class="link" href="install.html#PUGIXML_MEMORY_OUTPUT_STACK">PUGIXML_MEMORY_OUTPUT_STACK</a>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="preprocessor">#define</span> </code><a class="link" href="install.html#PUGIXML_MEMORY_XPATH_PAGE_SIZE">PUGIXML_MEMORY_XPATH_PAGE_SIZE</a>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="preprocessor">#define</span> </code><a class="link" href="install.html#PUGIXML_HEADER_ONLY">PUGIXML_HEADER_ONLY</a>
+        </li>
+</ul></div>
+<p>
+      Types:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">typedef</span> </code><span class="emphasis"><em>configuration-defined
+          type</em></span><code class="computeroutput"> </code><a class="link" href="dom.html#char_t">char_t</a><code class="computeroutput"><span class="special">;</span></code>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">typedef</span> </code><span class="emphasis"><em>configuration-defined
+          type</em></span><code class="computeroutput"> </code><a class="link" href="dom.html#string_t">string_t</a><code class="computeroutput"><span class="special">;</span></code>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">typedef</span> <span class="keyword">void</span><span class="special">*</span> <span class="special">(*</span></code><a class="link" href="dom.html#allocation_function">allocation_function</a><code class="computeroutput"><span class="special">)(</span><span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">);</span></code>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">typedef</span> <span class="keyword">void</span>
+          <span class="special">(*</span></code><a class="link" href="dom.html#deallocation_function">deallocation_function</a><code class="computeroutput"><span class="special">)(</span><span class="keyword">void</span><span class="special">*</span>
+          <span class="identifier">ptr</span><span class="special">);</span></code>
+        </li>
+</ul></div>
+<p>
+      Enumerations:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">enum</span> </code><a class="link" href="dom.html#xml_node_type">xml_node_type</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <a class="link" href="dom.html#node_null">node_null</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="dom.html#node_document">node_document</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="dom.html#node_element">node_element</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="dom.html#node_pcdata">node_pcdata</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="dom.html#node_cdata">node_cdata</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="dom.html#node_comment">node_comment</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="dom.html#node_pi">node_pi</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="dom.html#node_declaration">node_declaration</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="dom.html#node_doctype">node_doctype</a> <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">enum</span> </code><a class="link" href="loading.html#xml_parse_status">xml_parse_status</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <a class="link" href="loading.html#status_ok">status_ok</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_file_not_found">status_file_not_found</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_io_error">status_io_error</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_out_of_memory">status_out_of_memory</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_internal_error">status_internal_error</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_unrecognized_tag">status_unrecognized_tag</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_bad_pi">status_bad_pi</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_bad_comment">status_bad_comment</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_bad_cdata">status_bad_cdata</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_bad_doctype">status_bad_doctype</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_bad_pcdata">status_bad_pcdata</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_bad_start_element">status_bad_start_element</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_bad_attribute">status_bad_attribute</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_bad_end_element">status_bad_end_element</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#status_end_element_mismatch">status_end_element_mismatch</a>
+                <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">enum</span> </code><a class="link" href="loading.html#xml_encoding">xml_encoding</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <a class="link" href="loading.html#encoding_auto">encoding_auto</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#encoding_utf8">encoding_utf8</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#encoding_utf16_le">encoding_utf16_le</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#encoding_utf16_be">encoding_utf16_be</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#encoding_utf16">encoding_utf16</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#encoding_utf32_le">encoding_utf32_le</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#encoding_utf32_be">encoding_utf32_be</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#encoding_utf32">encoding_utf32</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#encoding_wchar">encoding_wchar</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#encoding_latin1">encoding_latin1</a> <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">enum</span> </code><a class="link" href="xpath.html#xpath_value_type">xpath_value_type</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <a class="link" href="xpath.html#xpath_type_none">xpath_type_none</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="xpath.html#xpath_type_node_set">xpath_type_node_set</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="xpath.html#xpath_type_number">xpath_type_number</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="xpath.html#xpath_type_string">xpath_type_string</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="xpath.html#xpath_type_boolean">xpath_type_boolean</a>
+              </li>
+</ul></div>
+        </li>
+</ul></div>
+<p>
+      Constants:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          Formatting options bit flags:
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <a class="link" href="saving.html#format_default">format_default</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="saving.html#format_indent">format_indent</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="saving.html#format_no_declaration">format_no_declaration</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="saving.html#format_no_escapes">format_no_escapes</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="saving.html#format_raw">format_raw</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="saving.html#format_save_file_text">format_save_file_text</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="saving.html#format_write_bom">format_write_bom</a> <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          Parsing options bit flags:
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <a class="link" href="loading.html#parse_cdata">parse_cdata</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#parse_comments">parse_comments</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#parse_declaration">parse_declaration</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#parse_default">parse_default</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#parse_doctype">parse_doctype</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#parse_eol">parse_eol</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#parse_escapes">parse_escapes</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#parse_full">parse_full</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#parse_minimal">parse_minimal</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#parse_pi">parse_pi</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#parse_ws_pcdata">parse_ws_pcdata</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#parse_ws_pcdata_single">parse_ws_pcdata_single</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#parse_wconv_attribute">parse_wconv_attribute</a>
+              </li>
+<li class="listitem">
+                <a class="link" href="loading.html#parse_wnorm_attribute">parse_wnorm_attribute</a>
+              </li>
+</ul></div>
+        </li>
+</ul></div>
+<p>
+      Classes:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="dom.html#xml_attribute">xml_attribute</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <a class="link" href="dom.html#xml_attribute::ctor">xml_attribute</a><code class="computeroutput"><span class="special">();</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_attribute::empty">empty</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">operator</span> </code><a class="link" href="dom.html#xml_attribute::unspecified_bool_type">unspecified_bool_type</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_attribute::comparison">operator==</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                <span class="identifier">r</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_attribute::comparison">operator!=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                <span class="identifier">r</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_attribute::comparison">operator&lt;</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                <span class="identifier">r</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_attribute::comparison">operator&gt;</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                <span class="identifier">r</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_attribute::comparison">operator&lt;=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                <span class="identifier">r</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_attribute::comparison">operator&gt;=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                <span class="identifier">r</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">size_t</span> </code><a class="link" href="dom.html#xml_attribute::hash_value">hash_value</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="access.html#xml_attribute::next_attribute">next_attribute</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="access.html#xml_attribute::previous_attribute">previous_attribute</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> </code><a class="link" href="access.html#xml_attribute::name">name</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> </code><a class="link" href="access.html#xml_attribute::value">value</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> </code><a class="link" href="access.html#xml_attribute::as_string">as_string</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">def</span> <span class="special">=</span>
+                <span class="string">""</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">int</span> </code><a class="link" href="access.html#xml_attribute::as_int">as_int</a><code class="computeroutput"><span class="special">(</span><span class="keyword">int</span> <span class="identifier">def</span> <span class="special">=</span>
+                <span class="number">0</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">unsigned</span> <span class="keyword">int</span>
+                </code><a class="link" href="access.html#xml_attribute::as_uint">as_uint</a><code class="computeroutput"><span class="special">(</span><span class="keyword">unsigned</span>
+                <span class="keyword">int</span> <span class="identifier">def</span>
+                <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">double</span> </code><a class="link" href="access.html#xml_attribute::as_double">as_double</a><code class="computeroutput"><span class="special">(</span><span class="keyword">double</span>
+                <span class="identifier">def</span> <span class="special">=</span>
+                <span class="number">0</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">float</span> </code><a class="link" href="access.html#xml_attribute::as_float">as_float</a><code class="computeroutput"><span class="special">(</span><span class="keyword">float</span> <span class="identifier">def</span> <span class="special">=</span>
+                <span class="number">0</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="access.html#xml_attribute::as_bool">as_bool</a><code class="computeroutput"><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">def</span> <span class="special">=</span>
+                <span class="keyword">false</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_attribute::set_name">set_name</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_attribute::set_value">set_value</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_attribute::set_value">set_value</a><code class="computeroutput"><span class="special">(</span><span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_attribute::set_value">set_value</a><code class="computeroutput"><span class="special">(</span><span class="keyword">unsigned</span>
+                <span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_attribute::set_value">set_value</a><code class="computeroutput"><span class="special">(</span><span class="keyword">double</span>
+                <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_attribute::set_value">set_value</a><code class="computeroutput"><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">rhs</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                </code><a class="link" href="modify.html#xml_attribute::assign">operator=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                </code><a class="link" href="modify.html#xml_attribute::assign">operator=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                </code><a class="link" href="modify.html#xml_attribute::assign">operator=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">unsigned</span>
+                <span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                </code><a class="link" href="modify.html#xml_attribute::assign">operator=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">double</span>
+                <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                </code><a class="link" href="modify.html#xml_attribute::assign">operator=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">rhs</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="dom.html#xml_node">xml_node</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <a class="link" href="dom.html#xml_node::ctor">xml_node</a><code class="computeroutput"><span class="special">();</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_node::empty">empty</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">operator</span> </code><a class="link" href="dom.html#xml_node::unspecified_bool_type">unspecified_bool_type</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_node::comparison">operator==</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span>
+                <span class="identifier">r</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_node::comparison">operator!=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span>
+                <span class="identifier">r</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_node::comparison">operator&lt;</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span>
+                <span class="identifier">r</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_node::comparison">operator&gt;</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span>
+                <span class="identifier">r</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_node::comparison">operator&lt;=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span>
+                <span class="identifier">r</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="dom.html#xml_node::comparison">operator&gt;=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span>
+                <span class="identifier">r</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">size_t</span> </code><a class="link" href="dom.html#xml_node::hash_value">hash_value</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node_type</span> </code><a class="link" href="dom.html#xml_node::type">type</a><code class="computeroutput"><span class="special">()</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> </code><a class="link" href="access.html#xml_node::name">name</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> </code><a class="link" href="access.html#xml_node::value">value</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="access.html#xml_node::parent">parent</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="access.html#xml_node::first_child">first_child</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="access.html#xml_node::last_child">last_child</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="access.html#xml_node::next_sibling">next_sibling</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="access.html#xml_node::previous_sibling">previous_sibling</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="access.html#xml_node::first_attribute">first_attribute</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="access.html#xml_node::last_attribute">last_attribute</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <span class="emphasis"><em>implementation-defined type</em></span> <a class="link" href="access.html#xml_node::children">children</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <span class="emphasis"><em>implementation-defined type</em></span> <a class="link" href="access.html#xml_node::children">children</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <span class="emphasis"><em>implementation-defined type</em></span> <a class="link" href="access.html#xml_node::attributes">attributes</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="access.html#xml_node::child">child</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="access.html#xml_node::attribute">attribute</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="access.html#xml_node::next_sibling_name">next_sibling</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="access.html#xml_node::previous_sibling_name">previous_sibling</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="access.html#xml_node::find_child_by_attribute">find_child_by_attribute</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">attr_name</span><span class="special">,</span> <span class="keyword">const</span>
+                <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">attr_value</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="access.html#xml_node::find_child_by_attribute">find_child_by_attribute</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">attr_name</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">attr_value</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> </code><a class="link" href="access.html#xml_node::child_value">child_value</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> </code><a class="link" href="access.html#xml_node::child_value">child_value</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_text</span> </code><a class="link" href="access.html#xml_node::text">text</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">typedef</span> <span class="identifier">xml_node_iterator</span>
+                </code><a class="link" href="access.html#xml_node_iterator">iterator</a><code class="computeroutput"><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">iterator</span> </code><a class="link" href="access.html#xml_node::begin">begin</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">iterator</span> </code><a class="link" href="access.html#xml_node::end">end</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">typedef</span> <span class="identifier">xml_attribute_iterator</span>
+                </code><a class="link" href="access.html#xml_attribute_iterator">attribute_iterator</a><code class="computeroutput"><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">attribute_iterator</span> </code><a class="link" href="access.html#xml_node::attributes_begin">attributes_begin</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">attribute_iterator</span> </code><a class="link" href="access.html#xml_node::attributes_end">attributes_end</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="access.html#xml_node::traverse">traverse</a><code class="computeroutput"><span class="special">(</span><span class="identifier">xml_tree_walker</span><span class="special">&amp;</span> <span class="identifier">walker</span><span class="special">);</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span> <span class="identifier">xml_attribute</span>
+                </code><a class="link" href="access.html#xml_node::find_attribute">find_attribute</a><code class="computeroutput"><span class="special">(</span><span class="identifier">Predicate</span>
+                <span class="identifier">pred</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span> <span class="identifier">xml_node</span>
+                </code><a class="link" href="access.html#xml_node::find_child">find_child</a><code class="computeroutput"><span class="special">(</span><span class="identifier">Predicate</span>
+                <span class="identifier">pred</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Predicate</span><span class="special">&gt;</span> <span class="identifier">xml_node</span>
+                </code><a class="link" href="access.html#xml_node::find_node">find_node</a><code class="computeroutput"><span class="special">(</span><span class="identifier">Predicate</span>
+                <span class="identifier">pred</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">string_t</span> </code><a class="link" href="access.html#xml_node::path">path</a><code class="computeroutput"><span class="special">(</span><span class="identifier">char_t</span>
+                <span class="identifier">delimiter</span> <span class="special">=</span>
+                <span class="char">'/'</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="access.html#xml_node::first_element_by_path">xml_node::first_element_by_path</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">path</span><span class="special">,</span>
+                <span class="identifier">char_t</span> <span class="identifier">delimiter</span>
+                <span class="special">=</span> <span class="char">'/'</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="access.html#xml_node::root">root</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">ptrdiff_t</span> </code><a class="link" href="access.html#xml_node::offset_debug">offset_debug</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_node::set_name">set_name</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_node::set_value">set_value</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">rhs</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="modify.html#xml_node::append_attribute">append_attribute</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="modify.html#xml_node::prepend_attribute">prepend_attribute</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="modify.html#xml_node::insert_attribute_after">insert_attribute_after</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">attr</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="modify.html#xml_node::insert_attribute_before">insert_attribute_before</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">attr</span><span class="special">);</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="modify.html#xml_node::append_child">append_child</a><code class="computeroutput"><span class="special">(</span><span class="identifier">xml_node_type</span>
+                <span class="identifier">type</span> <span class="special">=</span>
+                <span class="identifier">node_element</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="modify.html#xml_node::prepend_child">prepend_child</a><code class="computeroutput"><span class="special">(</span><span class="identifier">xml_node_type</span>
+                <span class="identifier">type</span> <span class="special">=</span>
+                <span class="identifier">node_element</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="modify.html#xml_node::insert_child_after">insert_child_after</a><code class="computeroutput"><span class="special">(</span><span class="identifier">xml_node_type</span>
+                <span class="identifier">type</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="modify.html#xml_node::insert_child_before">insert_child_before</a><code class="computeroutput"><span class="special">(</span><span class="identifier">xml_node_type</span>
+                <span class="identifier">type</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="modify.html#xml_node::append_child">append_child</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="modify.html#xml_node::prepend_child">prepend_child</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="modify.html#xml_node::insert_child_after">insert_child_after</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="modify.html#xml_node::insert_child_before">insert_child_before</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="modify.html#xml_node::append_copy">append_copy</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">proto</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="modify.html#xml_node::prepend_copy">prepend_copy</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                <span class="identifier">proto</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="modify.html#xml_node::insert_copy_after">insert_copy_after</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                <span class="identifier">proto</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">attr</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="modify.html#xml_node::insert_copy_before">insert_copy_before</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                <span class="identifier">proto</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">attr</span><span class="special">);</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="modify.html#xml_node::append_copy">append_copy</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span>
+                <span class="identifier">proto</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="modify.html#xml_node::prepend_copy">prepend_copy</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span>
+                <span class="identifier">proto</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="modify.html#xml_node::insert_copy_after">insert_copy_after</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span>
+                <span class="identifier">proto</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="modify.html#xml_node::insert_copy_before">insert_copy_before</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span>
+                <span class="identifier">proto</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_node::remove_attribute">remove_attribute</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span>
+                <span class="identifier">a</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_node::remove_attribute">remove_attribute</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_node::remove_child">remove_child</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span>
+                <span class="identifier">n</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_node::remove_child">remove_child</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">void</span> </code><a class="link" href="saving.html#xml_node::print">print</a><code class="computeroutput"><span class="special">(</span><span class="identifier">xml_writer</span><span class="special">&amp;</span> <span class="identifier">writer</span><span class="special">,</span> <span class="keyword">const</span>
+                <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">indent</span> <span class="special">=</span>
+                <span class="string">"\t"</span><span class="special">,</span>
+                <span class="keyword">unsigned</span> <span class="keyword">int</span>
+                <span class="identifier">flags</span> <span class="special">=</span>
+                <span class="identifier">format_default</span><span class="special">,</span>
+                <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span>
+                <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">,</span> <span class="keyword">unsigned</span>
+                <span class="keyword">int</span> <span class="identifier">depth</span>
+                <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">void</span> </code><a class="link" href="saving.html#xml_node::print_stream">print</a><code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span>
+                <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">indent</span> <span class="special">=</span>
+                <span class="string">"\t"</span><span class="special">,</span>
+                <span class="keyword">unsigned</span> <span class="keyword">int</span>
+                <span class="identifier">flags</span> <span class="special">=</span>
+                <span class="identifier">format_default</span><span class="special">,</span>
+                <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span>
+                <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">,</span> <span class="keyword">unsigned</span>
+                <span class="keyword">int</span> <span class="identifier">depth</span>
+                <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">void</span> </code><a class="link" href="saving.html#xml_node::print_stream">print</a><code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">wostream</span><span class="special">&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span>
+                <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">indent</span> <span class="special">=</span>
+                <span class="string">"\t"</span><span class="special">,</span>
+                <span class="keyword">unsigned</span> <span class="keyword">int</span>
+                <span class="identifier">flags</span> <span class="special">=</span>
+                <span class="identifier">format_default</span><span class="special">,</span>
+                <span class="keyword">unsigned</span> <span class="keyword">int</span>
+                <span class="identifier">depth</span> <span class="special">=</span>
+                <span class="number">0</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xpath_node</span> </code><a class="link" href="xpath.html#xml_node::select_single_node">select_single_node</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">query</span><span class="special">,</span>
+                <span class="identifier">xpath_variable_set</span><span class="special">*</span>
+                <span class="identifier">variables</span> <span class="special">=</span>
+                <span class="number">0</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xpath_node</span> </code><a class="link" href="xpath.html#xml_node::select_single_node_precomp">select_single_node</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_query</span><span class="special">&amp;</span>
+                <span class="identifier">query</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xpath_node_set</span> </code><a class="link" href="xpath.html#xml_node::select_nodes">select_nodes</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">query</span><span class="special">,</span>
+                <span class="identifier">xpath_variable_set</span><span class="special">*</span>
+                <span class="identifier">variables</span> <span class="special">=</span>
+                <span class="number">0</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xpath_node_set</span> </code><a class="link" href="xpath.html#xml_node::select_nodes_precomp">select_nodes</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_query</span><span class="special">&amp;</span>
+                <span class="identifier">query</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="dom.html#xml_document">xml_document</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <a class="link" href="dom.html#xml_document::ctor">xml_document</a><code class="computeroutput"><span class="special">();</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="special">~</span></code><a class="link" href="dom.html#xml_document::dtor">xml_document</a><code class="computeroutput"><span class="special">();</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">void</span> </code><a class="link" href="dom.html#xml_document::reset">reset</a><code class="computeroutput"><span class="special">();</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">void</span> </code><a class="link" href="dom.html#xml_document::reset">reset</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_document</span><span class="special">&amp;</span>
+                <span class="identifier">proto</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_parse_result</span> </code><a class="link" href="loading.html#xml_document::load_stream">load</a><code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">&amp;</span>
+                <span class="identifier">stream</span><span class="special">,</span>
+                <span class="keyword">unsigned</span> <span class="keyword">int</span>
+                <span class="identifier">options</span> <span class="special">=</span>
+                <span class="identifier">parse_default</span><span class="special">,</span>
+                <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span>
+                <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_parse_result</span> </code><a class="link" href="loading.html#xml_document::load_stream">load</a><code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">wistream</span><span class="special">&amp;</span>
+                <span class="identifier">stream</span><span class="special">,</span>
+                <span class="keyword">unsigned</span> <span class="keyword">int</span>
+                <span class="identifier">options</span> <span class="special">=</span>
+                <span class="identifier">parse_default</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_parse_result</span> </code><a class="link" href="loading.html#xml_document::load_string">load</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">contents</span><span class="special">,</span> <span class="keyword">unsigned</span>
+                <span class="keyword">int</span> <span class="identifier">options</span>
+                <span class="special">=</span> <span class="identifier">parse_default</span><span class="special">);</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_parse_result</span> </code><a class="link" href="loading.html#xml_document::load_file">load_file</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">path</span><span class="special">,</span> <span class="keyword">unsigned</span>
+                <span class="keyword">int</span> <span class="identifier">options</span>
+                <span class="special">=</span> <span class="identifier">parse_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span>
+                <span class="identifier">encoding</span> <span class="special">=</span>
+                <span class="identifier">encoding_auto</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_parse_result</span> </code><a class="link" href="loading.html#xml_document::load_file_wide">load_file</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*</span>
+                <span class="identifier">path</span><span class="special">,</span>
+                <span class="keyword">unsigned</span> <span class="keyword">int</span>
+                <span class="identifier">options</span> <span class="special">=</span>
+                <span class="identifier">parse_default</span><span class="special">,</span>
+                <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span>
+                <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">);</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_parse_result</span> </code><a class="link" href="loading.html#xml_document::load_buffer">load_buffer</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">contents</span><span class="special">,</span>
+                <span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">,</span> <span class="keyword">unsigned</span>
+                <span class="keyword">int</span> <span class="identifier">options</span>
+                <span class="special">=</span> <span class="identifier">parse_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span>
+                <span class="identifier">encoding</span> <span class="special">=</span>
+                <span class="identifier">encoding_auto</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_parse_result</span> </code><a class="link" href="loading.html#xml_document::load_buffer_inplace">load_buffer_inplace</a><code class="computeroutput"><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">contents</span><span class="special">,</span> <span class="identifier">size_t</span>
+                <span class="identifier">size</span><span class="special">,</span>
+                <span class="keyword">unsigned</span> <span class="keyword">int</span>
+                <span class="identifier">options</span> <span class="special">=</span>
+                <span class="identifier">parse_default</span><span class="special">,</span>
+                <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span>
+                <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_parse_result</span> </code><a class="link" href="loading.html#xml_document::load_buffer_inplace_own">load_buffer_inplace_own</a><code class="computeroutput"><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">contents</span><span class="special">,</span> <span class="identifier">size_t</span>
+                <span class="identifier">size</span><span class="special">,</span>
+                <span class="keyword">unsigned</span> <span class="keyword">int</span>
+                <span class="identifier">options</span> <span class="special">=</span>
+                <span class="identifier">parse_default</span><span class="special">,</span>
+                <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span>
+                <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">);</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="saving.html#xml_document::save_file">save_file</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">path</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">indent</span>
+                <span class="special">=</span> <span class="string">"\t"</span><span class="special">,</span> <span class="keyword">unsigned</span>
+                <span class="keyword">int</span> <span class="identifier">flags</span>
+                <span class="special">=</span> <span class="identifier">format_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span>
+                <span class="identifier">encoding</span> <span class="special">=</span>
+                <span class="identifier">encoding_auto</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="saving.html#xml_document::save_file_wide">save_file</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*</span>
+                <span class="identifier">path</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">indent</span>
+                <span class="special">=</span> <span class="string">"\t"</span><span class="special">,</span> <span class="keyword">unsigned</span>
+                <span class="keyword">int</span> <span class="identifier">flags</span>
+                <span class="special">=</span> <span class="identifier">format_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span>
+                <span class="identifier">encoding</span> <span class="special">=</span>
+                <span class="identifier">encoding_auto</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">void</span> </code><a class="link" href="saving.html#xml_document::save_stream">save</a><code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="identifier">stream</span><span class="special">,</span> <span class="keyword">const</span>
+                <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">indent</span> <span class="special">=</span>
+                <span class="string">"\t"</span><span class="special">,</span>
+                <span class="keyword">unsigned</span> <span class="keyword">int</span>
+                <span class="identifier">flags</span> <span class="special">=</span>
+                <span class="identifier">format_default</span><span class="special">,</span>
+                <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span>
+                <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">void</span> </code><a class="link" href="saving.html#xml_document::save_stream">save</a><code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">wostream</span><span class="special">&amp;</span> <span class="identifier">stream</span><span class="special">,</span> <span class="keyword">const</span>
+                <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">indent</span> <span class="special">=</span>
+                <span class="string">"\t"</span><span class="special">,</span>
+                <span class="keyword">unsigned</span> <span class="keyword">int</span>
+                <span class="identifier">flags</span> <span class="special">=</span>
+                <span class="identifier">format_default</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">void</span> </code><a class="link" href="saving.html#xml_document::save">save</a><code class="computeroutput"><span class="special">(</span><span class="identifier">xml_writer</span><span class="special">&amp;</span> <span class="identifier">writer</span><span class="special">,</span> <span class="keyword">const</span>
+                <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">indent</span> <span class="special">=</span>
+                <span class="string">"\t"</span><span class="special">,</span>
+                <span class="keyword">unsigned</span> <span class="keyword">int</span>
+                <span class="identifier">flags</span> <span class="special">=</span>
+                <span class="identifier">format_default</span><span class="special">,</span>
+                <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span>
+                <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="dom.html#xml_document::document_element">document_element</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">struct</span> </code><a class="link" href="loading.html#xml_parse_result">xml_parse_result</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_parse_status</span> </code><a class="link" href="loading.html#xml_parse_result::status">status</a><code class="computeroutput"><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">ptrdiff_t</span> </code><a class="link" href="loading.html#xml_parse_result::offset">offset</a><code class="computeroutput"><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_encoding</span> </code><a class="link" href="loading.html#xml_parse_result::encoding">encoding</a><code class="computeroutput"><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">operator</span> </code><a class="link" href="loading.html#xml_parse_result::bool">bool</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> </code><a class="link" href="loading.html#xml_parse_result::description">description</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="access.html#xml_node_iterator">xml_node_iterator</a>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="access.html#xml_attribute_iterator">xml_attribute_iterator</a>
+          <br><br>
+
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="access.html#xml_tree_walker">xml_tree_walker</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">virtual</span> <span class="keyword">bool</span>
+                </code><a class="link" href="access.html#xml_tree_walker::begin">begin</a><code class="computeroutput"><span class="special">(</span><span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">virtual</span> <span class="keyword">bool</span>
+                </code><a class="link" href="access.html#xml_tree_walker::for_each">for_each</a><code class="computeroutput"><span class="special">(</span><span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">virtual</span> <span class="keyword">bool</span>
+                </code><a class="link" href="access.html#xml_tree_walker::end">end</a><code class="computeroutput"><span class="special">(</span><span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">int</span> </code><a class="link" href="access.html#xml_tree_walker::depth">depth</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="access.html#xml_text">xml_text</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="access.html#xml_text::empty">empty</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">operator</span> </code><a class="link" href="access.html#xml_text::unspecified_bool_type">xml_text::unspecified_bool_type</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> </code><a class="link" href="access.html#xml_text::get">xml_text::get</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> </code><a class="link" href="access.html#xml_text::as_string">as_string</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">def</span> <span class="special">=</span>
+                <span class="string">""</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">int</span> </code><a class="link" href="access.html#xml_text::as_int">as_int</a><code class="computeroutput"><span class="special">(</span><span class="keyword">int</span> <span class="identifier">def</span> <span class="special">=</span>
+                <span class="number">0</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">unsigned</span> <span class="keyword">int</span>
+                </code><a class="link" href="access.html#xml_text::as_uint">as_uint</a><code class="computeroutput"><span class="special">(</span><span class="keyword">unsigned</span>
+                <span class="keyword">int</span> <span class="identifier">def</span>
+                <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">double</span> </code><a class="link" href="access.html#xml_text::as_double">as_double</a><code class="computeroutput"><span class="special">(</span><span class="keyword">double</span>
+                <span class="identifier">def</span> <span class="special">=</span>
+                <span class="number">0</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">float</span> </code><a class="link" href="access.html#xml_text::as_float">as_float</a><code class="computeroutput"><span class="special">(</span><span class="keyword">float</span> <span class="identifier">def</span> <span class="special">=</span>
+                <span class="number">0</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="access.html#xml_text::as_bool">as_bool</a><code class="computeroutput"><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">def</span> <span class="special">=</span>
+                <span class="keyword">false</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_text::set">set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">rhs</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_text::set">set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_text::set">set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">unsigned</span>
+                <span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_text::set">set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">double</span>
+                <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="modify.html#xml_text::set">set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">rhs</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_text</span><span class="special">&amp;</span>
+                </code><a class="link" href="modify.html#xml_text::assign">operator=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_text</span><span class="special">&amp;</span>
+                </code><a class="link" href="modify.html#xml_text::assign">operator=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_text</span><span class="special">&amp;</span>
+                </code><a class="link" href="modify.html#xml_text::assign">operator=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">unsigned</span>
+                <span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_text</span><span class="special">&amp;</span>
+                </code><a class="link" href="modify.html#xml_text::assign">operator=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">double</span>
+                <span class="identifier">rhs</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_text</span><span class="special">&amp;</span>
+                </code><a class="link" href="modify.html#xml_text::assign">operator=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">rhs</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="access.html#xml_text::data">data</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="saving.html#xml_writer">xml_writer</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle"><li class="listitem">
+                <code class="computeroutput"><span class="keyword">virtual</span> <span class="keyword">void</span>
+                </code><a class="link" href="saving.html#xml_writer::write">write</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">data</span><span class="special">,</span>
+                <span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span></code>
+                <br><br>
+
+              </li></ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="saving.html#xml_writer_file">xml_writer_file</a><code class="computeroutput"><span class="special">:</span> <span class="keyword">public</span> <span class="identifier">xml_writer</span></code>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle"><li class="listitem">
+                <a class="link" href="saving.html#xml_writer_file">xml_writer_file</a><code class="computeroutput"><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">file</span><span class="special">);</span></code> <br><br>
+
+              </li></ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="saving.html#xml_writer_stream">xml_writer_stream</a><code class="computeroutput"><span class="special">:</span> <span class="keyword">public</span> <span class="identifier">xml_writer</span></code>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <a class="link" href="saving.html#xml_writer_stream">xml_writer_stream</a><code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="identifier">stream</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <a class="link" href="saving.html#xml_writer_stream">xml_writer_stream</a><code class="computeroutput"><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">wostream</span><span class="special">&amp;</span> <span class="identifier">stream</span><span class="special">);</span></code> <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">struct</span> </code><a class="link" href="xpath.html#xpath_parse_result">xpath_parse_result</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> </code><a class="link" href="xpath.html#xpath_parse_result::error">error</a><code class="computeroutput"><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">ptrdiff_t</span> </code><a class="link" href="xpath.html#xpath_parse_result::offset">offset</a><code class="computeroutput"><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">operator</span> </code><a class="link" href="xpath.html#xpath_parse_result::bool">bool</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> </code><a class="link" href="xpath.html#xpath_parse_result::description">description</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="xpath.html#xpath_query">xpath_query</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">explicit</span> </code><a class="link" href="xpath.html#xpath_query::ctor">xpath_query</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">query</span><span class="special">,</span>
+                <span class="identifier">xpath_variable_set</span><span class="special">*</span>
+                <span class="identifier">variables</span> <span class="special">=</span>
+                <span class="number">0</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="xpath.html#xpath_query::evaluate_boolean">evaluate_boolean</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span>
+                <span class="identifier">n</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">double</span> </code><a class="link" href="xpath.html#xpath_query::evaluate_number">evaluate_number</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span>
+                <span class="identifier">n</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">string_t</span> </code><a class="link" href="xpath.html#xpath_query::evaluate_string">evaluate_string</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span>
+                <span class="identifier">n</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">size_t</span> </code><a class="link" href="xpath.html#xpath_query::evaluate_string_buffer">evaluate_string</a><code class="computeroutput"><span class="special">(</span><span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">size_t</span>
+                <span class="identifier">capacity</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xpath_node_set</span> </code><a class="link" href="xpath.html#xpath_query::evaluate_node_set">evaluate_node_set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span>
+                <span class="identifier">n</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xpath_value_type</span> </code><a class="link" href="xpath.html#xpath_query::return_type">return_type</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">xpath_parse_result</span><span class="special">&amp;</span> </code><a class="link" href="xpath.html#xpath_query::result">result</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">operator</span> </code><a class="link" href="xpath.html#xpath_query::unspecified_bool_type">unspecified_bool_type</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="xpath.html#xpath_exception">xpath_exception</a><code class="computeroutput"><span class="special">:</span> <span class="keyword">public</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">exception</span></code>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">virtual</span> <span class="keyword">const</span>
+                <span class="keyword">char</span><span class="special">*</span>
+                </code><a class="link" href="xpath.html#xpath_exception::what">what</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span>
+                <span class="keyword">throw</span><span class="special">();</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">xpath_parse_result</span><span class="special">&amp;</span> </code><a class="link" href="xpath.html#xpath_exception::result">result</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="xpath.html#xpath_node">xpath_node</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <a class="link" href="xpath.html#xpath_node::ctor">xpath_node</a><code class="computeroutput"><span class="special">();</span></code>
+              </li>
+<li class="listitem">
+                <a class="link" href="xpath.html#xpath_node::ctor">xpath_node</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <a class="link" href="xpath.html#xpath_node::ctor">xpath_node</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">attribute</span><span class="special">,</span> <span class="keyword">const</span>
+                <span class="identifier">xml_node</span><span class="special">&amp;</span>
+                <span class="identifier">parent</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="xpath.html#xpath_node::node">node</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_attribute</span> </code><a class="link" href="xpath.html#xpath_node::attribute">attribute</a><code class="computeroutput"><span class="special">()</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xml_node</span> </code><a class="link" href="xpath.html#xpath_node::parent">parent</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">operator</span> </code><a class="link" href="xpath.html#xpath_node::unspecified_bool_type">unspecified_bool_type</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="xpath.html#xpath_node::comparison">operator==</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span>
+                <span class="identifier">n</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="xpath.html#xpath_node::comparison">operator!=</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span>
+                <span class="identifier">n</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="xpath.html#xpath_node_set">xpath_node_set</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <a class="link" href="xpath.html#xpath_node_set::ctor">xpath_node_set</a><code class="computeroutput"><span class="special">();</span></code>
+              </li>
+<li class="listitem">
+                <a class="link" href="xpath.html#xpath_node_set::ctor">xpath_node_set</a><code class="computeroutput"><span class="special">(</span><span class="identifier">const_iterator</span>
+                <span class="identifier">begin</span><span class="special">,</span>
+                <span class="identifier">const_iterator</span> <span class="identifier">end</span><span class="special">,</span> <span class="identifier">type_t</span>
+                <span class="identifier">type</span> <span class="special">=</span>
+                <span class="identifier">type_unsorted</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">typedef</span> <span class="keyword">const</span>
+                <span class="identifier">xpath_node</span><span class="special">*</span>
+                </code><a class="link" href="xpath.html#xpath_node_set::const_iterator">const_iterator</a><code class="computeroutput"><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">const_iterator</span> </code><a class="link" href="xpath.html#xpath_node_set::begin">begin</a><code class="computeroutput"><span class="special">()</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">const_iterator</span> </code><a class="link" href="xpath.html#xpath_node_set::end">end</a><code class="computeroutput"><span class="special">()</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span> </code><a class="link" href="xpath.html#xpath_node_set::index">operator[]</a><code class="computeroutput"><span class="special">(</span><span class="identifier">size_t</span>
+                <span class="identifier">index</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">size_t</span> </code><a class="link" href="xpath.html#xpath_node_set::size">size</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="xpath.html#xpath_node_set::empty">empty</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xpath_node</span> </code><a class="link" href="xpath.html#xpath_node_set::first">first</a><code class="computeroutput"><span class="special">()</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">enum</span> <span class="identifier">type_t</span>
+                <span class="special">{</span></code><a class="link" href="xpath.html#xpath_node_set::type_unsorted">type_unsorted</a>,
+                <a class="link" href="xpath.html#xpath_node_set::type_sorted">type_sorted</a>,
+                <a class="link" href="xpath.html#xpath_node_set::type_sorted_reverse">type_sorted_reverse</a><code class="computeroutput"><span class="special">};</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">type_t</span> </code><a class="link" href="xpath.html#xpath_node_set::type">type</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">void</span> </code><a class="link" href="xpath.html#xpath_node_set::sort">sort</a><code class="computeroutput"><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">reverse</span> <span class="special">=</span>
+                <span class="keyword">false</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="xpath.html#xpath_variable">xpath_variable</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> </code><a class="link" href="xpath.html#xpath_variable::name">name</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xpath_value_type</span> </code><a class="link" href="xpath.html#xpath_variable::type">type</a><code class="computeroutput"><span class="special">()</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="xpath.html#xpath_variable::get_boolean">get_boolean</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">double</span> </code><a class="link" href="xpath.html#xpath_variable::get_number">get_number</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> </code><a class="link" href="xpath.html#xpath_variable::get_string">get_string</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">xpath_node_set</span><span class="special">&amp;</span> </code><a class="link" href="xpath.html#xpath_variable::get_node_set">get_node_set</a><code class="computeroutput"><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="xpath.html#xpath_variable::set">set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">value</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="xpath.html#xpath_variable::set">set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">double</span>
+                <span class="identifier">value</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="xpath.html#xpath_variable::set">set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">value</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="xpath.html#xpath_variable::set">set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_node_set</span><span class="special">&amp;</span>
+                <span class="identifier">value</span><span class="special">);</span></code>
+                <br><br>
+
+              </li>
+</ul></div>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">class</span> </code><a class="link" href="xpath.html#xpath_variable_set">xpath_variable_set</a>
+          <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xpath_variable</span><span class="special">*</span>
+                </code><a class="link" href="xpath.html#xpath_variable_set::add">add</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">,</span>
+                <span class="identifier">xpath_value_type</span> <span class="identifier">type</span><span class="special">);</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="xpath.html#xpath_variable_set::set">set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">,</span>
+                <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="xpath.html#xpath_variable_set::set">set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">,</span>
+                <span class="keyword">double</span> <span class="identifier">value</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="xpath.html#xpath_variable_set::set">set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">value</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">bool</span> </code><a class="link" href="xpath.html#xpath_variable_set::set">set</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">,</span>
+                <span class="keyword">const</span> <span class="identifier">xpath_node_set</span><span class="special">&amp;</span> <span class="identifier">value</span><span class="special">);</span></code> <br><br>
+
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="identifier">xpath_variable</span><span class="special">*</span>
+                </code><a class="link" href="xpath.html#xpath_variable_set::get">get</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">);</span></code>
+              </li>
+<li class="listitem">
+                <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">xpath_variable</span><span class="special">*</span> </code><a class="link" href="xpath.html#xpath_variable_set::get">get</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span>
+                <span class="identifier">name</span><span class="special">)</span>
+                <span class="keyword">const</span><span class="special">;</span></code>
+                <br><br>
+
+              </li>
+</ul></div>
+        </li>
+</ul></div>
+<p>
+      Functions:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> </code><a class="link" href="dom.html#as_utf8">as_utf8</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*</span> <span class="identifier">str</span><span class="special">);</span></code>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> </code><a class="link" href="dom.html#as_utf8">as_utf8</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">wstring</span><span class="special">&amp;</span>
+          <span class="identifier">str</span><span class="special">);</span></code>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">wstring</span> </code><a class="link" href="dom.html#as_wide">as_wide</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">str</span><span class="special">);</span></code>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">wstring</span> </code><a class="link" href="dom.html#as_wide">as_wide</a><code class="computeroutput"><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span>
+          <span class="identifier">str</span><span class="special">);</span></code>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="keyword">void</span> </code><a class="link" href="dom.html#set_memory_management_functions">set_memory_management_functions</a><code class="computeroutput"><span class="special">(</span><span class="identifier">allocation_function</span>
+          <span class="identifier">allocate</span><span class="special">,</span>
+          <span class="identifier">deallocation_function</span> <span class="identifier">deallocate</span><span class="special">);</span></code>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="identifier">allocation_function</span> </code><a class="link" href="dom.html#get_memory_allocation_function">get_memory_allocation_function</a><code class="computeroutput"><span class="special">();</span></code>
+        </li>
+<li class="listitem">
+          <code class="computeroutput"><span class="identifier">deallocation_function</span> </code><a class="link" href="dom.html#get_memory_deallocation_function">get_memory_deallocation_function</a><code class="computeroutput"><span class="special">();</span></code>
+        </li>
+</ul></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2012 Arseny Kapoulkine<p>
+        Distributed under the MIT License
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<b>API Reference</b> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="changes.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="toc.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+</body>
+</html>
diff --git a/tools/intergen/third_party/pugixml/docs/manual/changes.html b/tools/intergen/third_party/pugixml/docs/manual/changes.html
new file mode 100644
index 0000000000..d119532b36
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/manual/changes.html
@@ -0,0 +1,879 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Changelog</title>
+<link rel="stylesheet" href="../pugixml.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../manual.html" title="pugixml 1.2">
+<link rel="up" href="../manual.html" title="pugixml 1.2">
+<link rel="prev" href="xpath.html" title="XPath">
+<link rel="next" href="apiref.html" title="API Reference">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="xpath.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="apiref.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+<hr>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="manual.changes"></a><a class="link" href="changes.html" title="Changelog"> Changelog</a>
+</h2></div></div></div>
+<a name="manual.changes.1_05_2012___version_1_2"></a><h6>
+      <a class="link" href="changes.html#manual.changes.1_05_2012___version_1_2">1.05.2012 - version
+      1.2</a>
+    </h6>
+<p>
+      Major release, featuring header-only mode, various interface enhancements (i.e.
+      PCDATA manipulation and C++11 iteration), many other features and compatibility
+      improvements.
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          New features:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Added xml_text helper class for working with PCDATA/CDATA contents
+                of an element node
+              </li>
+<li class="listitem">
+                Added optional header-only mode (controlled by PUGIXML_HEADER_ONLY
+                define)
+              </li>
+<li class="listitem">
+                Added xml_node::children() and xml_node::attributes() for C++11 ranged
+                for loop or BOOST_FOREACH
+              </li>
+<li class="listitem">
+                Added support for Latin-1 (ISO-8859-1) encoding conversion during
+                loading and saving
+              </li>
+<li class="listitem">
+                Added custom default values for xml_attribute::as_* (they are returned if the attribute
+                does not exist)
+              </li>
+<li class="listitem">
+                Added parse_ws_pcdata_single flag for preserving whitespace-only
+                PCDATA in case it's the only child
+              </li>
+<li class="listitem">
+                Added format_save_file_text for xml_document::save_file to open files
+                as text instead of binary (changes newlines on Windows)
+              </li>
+<li class="listitem">
+                Added format_no_escapes flag to disable special symbol escaping (complements
+                ~parse_escapes)
+              </li>
+<li class="listitem">
+                Added support for loading document from streams that do not support
+                seeking
+              </li>
+<li class="listitem">
+                Added PUGIXML_MEMORY_* constants for tweaking allocation behavior (useful for embedded
+                systems)
+              </li>
+<li class="listitem">
+                Added PUGIXML_VERSION preprocessor define
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Compatibility improvements:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Parser does not require setjmp support (improves compatibility with
+                some embedded platforms, enables clr:pure compilation)
+              </li>
+<li class="listitem">
+                STL forward declarations are no longer used (fixes SunCC/RWSTL compilation,
+                fixes clang compilation in C++11 mode)
+              </li>
+<li class="listitem">
+                Fixed AirPlay SDK, Android, Windows Mobile (WinCE) and C++/CLI compilation
+              </li>
+<li class="listitem">
+                Fixed several compilation warnings for various GCC versions, Intel
+                C++ compiler and Clang
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Bug fixes:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Fixed unsafe bool conversion to avoid problems on C++/CLI
+              </li>
+<li class="listitem">
+                Iterator dereference operator is const now (fixes Boost filter_iterator
+                support)
+              </li>
+<li class="listitem">
+                xml_document::save_file now checks for file I/O errors during saving
+              </li>
+</ol></div>
+        </li>
+</ul></div>
+<a name="manual.changes.1_11_2010___version_1_0"></a><h6>
+      <a class="link" href="changes.html#manual.changes.1_11_2010___version_1_0">1.11.2010 - version
+      1.0</a>
+    </h6>
+<p>
+      Major release, featuring many XPath enhancements, wide character filename support,
+      miscellaneous performance improvements, bug fixes and more.
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          XPath:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                XPath implementation is moved to pugixml.cpp (which is the only source
+                file now); use PUGIXML_NO_XPATH if you want to disable XPath to reduce
+                code size
+              </li>
+<li class="listitem">
+                XPath is now supported without exceptions (PUGIXML_NO_EXCEPTIONS);
+                the error handling mechanism depends on the presence of exception
+                support
+              </li>
+<li class="listitem">
+                XPath is now supported without STL (PUGIXML_NO_STL)
+              </li>
+<li class="listitem">
+                Introduced variable support
+              </li>
+<li class="listitem">
+                Introduced new xpath_query::evaluate_string, which works without
+                STL
+              </li>
+<li class="listitem">
+                Introduced new xpath_node_set constructor (from an iterator range)
+              </li>
+<li class="listitem">
+                Evaluation function now accept attribute context nodes
+              </li>
+<li class="listitem">
+                All internal allocations use custom allocation functions
+              </li>
+<li class="listitem">
+                Improved error reporting; now a last parsed offset is returned together
+                with the parsing error
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Bug fixes:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Fixed memory leak for loading from streams with stream exceptions
+                turned on
+              </li>
+<li class="listitem">
+                Fixed custom deallocation function calling with null pointer in one
+                case
+              </li>
+<li class="listitem">
+                Fixed missing attributes for iterator category functions; all functions/classes
+                can now be DLL-exported
+              </li>
+<li class="listitem">
+                Worked around Digital Mars compiler bug, which lead to minor read
+                overfetches in several functions
+              </li>
+<li class="listitem">
+                load_file now works with 2+ Gb files in MSVC/MinGW
+              </li>
+<li class="listitem">
+                XPath: fixed memory leaks for incorrect queries
+              </li>
+<li class="listitem">
+                XPath: fixed xpath_node() attribute constructor with empty attribute
+                argument
+              </li>
+<li class="listitem">
+                XPath: fixed lang() function for non-ASCII arguments
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Specification changes:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                CDATA nodes containing ]]&gt; are printed as several nodes; while
+                this changes the internal structure, this is the only way to escape
+                CDATA contents
+              </li>
+<li class="listitem">
+                Memory allocation errors during parsing now preserve last parsed
+                offset (to give an idea about parsing progress)
+              </li>
+<li class="listitem">
+                If an element node has the only child, and it is of CDATA type, then
+                the extra indentation is omitted (previously this behavior only held
+                for PCDATA children)
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Additional functionality:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Added xml_parse_result default constructor
+              </li>
+<li class="listitem">
+                Added xml_document::load_file and xml_document::save_file with wide
+                character paths
+              </li>
+<li class="listitem">
+                Added as_utf8 and as_wide overloads for std::wstring/std::string
+                arguments
+              </li>
+<li class="listitem">
+                Added DOCTYPE node type (node_doctype) and a special parse flag,
+                parse_doctype, to add such nodes to the document during parsing
+              </li>
+<li class="listitem">
+                Added parse_full parse flag mask, which extends parse_default with
+                all node type parsing flags except parse_ws_pcdata
+              </li>
+<li class="listitem">
+                Added xml_node::hash_value() and xml_attribute::hash_value() functions
+                for use in hash-based containers
+              </li>
+<li class="listitem">
+                Added internal_object() and additional constructor for both xml_node
+                and xml_attribute for easier marshalling (useful for language bindings)
+              </li>
+<li class="listitem">
+                Added xml_document::document_element() function
+              </li>
+<li class="listitem">
+                Added xml_node::prepend_attribute, xml_node::prepend_child and xml_node::prepend_copy
+                functions
+              </li>
+<li class="listitem">
+                Added xml_node::append_child, xml_node::prepend_child, xml_node::insert_child_before
+                and xml_node::insert_child_after overloads for element nodes (with
+                name instead of type)
+              </li>
+<li class="listitem">
+                Added xml_document::reset() function
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Performance improvements:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                xml_node::root() and xml_node::offset_debug() are now O(1) instead
+                of O(logN)
+              </li>
+<li class="listitem">
+                Minor parsing optimizations
+              </li>
+<li class="listitem">
+                Minor memory optimization for strings in DOM tree (set_name/set_value)
+              </li>
+<li class="listitem">
+                Memory optimization for string memory reclaiming in DOM tree (set_name/set_value
+                now reallocate the buffer if memory waste is too big)
+              </li>
+<li class="listitem">
+                XPath: optimized document order sorting
+              </li>
+<li class="listitem">
+                XPath: optimized child/attribute axis step
+              </li>
+<li class="listitem">
+                XPath: optimized number-to-string conversions in MSVC
+              </li>
+<li class="listitem">
+                XPath: optimized concat for many arguments
+              </li>
+<li class="listitem">
+                XPath: optimized evaluation allocation mechanism: constant and document
+                strings are not heap-allocated
+              </li>
+<li class="listitem">
+                XPath: optimized evaluation allocation mechanism: all temporaries'
+                allocations use fast stack-like allocator
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Compatibility:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Removed wildcard functions (xml_node::child_w, xml_node::attribute_w,
+                etc.)
+              </li>
+<li class="listitem">
+                Removed xml_node::all_elements_by_name
+              </li>
+<li class="listitem">
+                Removed xpath_type_t enumeration; use xpath_value_type instead
+              </li>
+<li class="listitem">
+                Removed format_write_bom_utf8 enumeration; use format_write_bom instead
+              </li>
+<li class="listitem">
+                Removed xml_document::precompute_document_order, xml_attribute::document_order
+                and xml_node::document_order functions; document order sort optimization
+                is now automatic
+              </li>
+<li class="listitem">
+                Removed xml_document::parse functions and transfer_ownership struct;
+                use xml_document::load_buffer_inplace and xml_document::load_buffer_inplace_own
+                instead
+              </li>
+<li class="listitem">
+                Removed as_utf16 function; use as_wide instead
+              </li>
+</ol></div>
+        </li>
+</ul></div>
+<a name="manual.changes.1_07_2010___version_0_9"></a><h6>
+      <a class="link" href="changes.html#manual.changes.1_07_2010___version_0_9">1.07.2010 - version
+      0.9</a>
+    </h6>
+<p>
+      Major release, featuring extended and improved Unicode support, miscellaneous
+      performance improvements, bug fixes and more.
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          Major Unicode improvements:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Introduced encoding support (automatic/manual encoding detection
+                on load, manual encoding selection on save, conversion from/to UTF8,
+                UTF16 LE/BE, UTF32 LE/BE)
+              </li>
+<li class="listitem">
+                Introduced wchar_t mode (you can set PUGIXML_WCHAR_MODE define to
+                switch pugixml internal encoding from UTF8 to wchar_t; all functions
+                are switched to their Unicode variants)
+              </li>
+<li class="listitem">
+                Load/save functions now support wide streams
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Bug fixes:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Fixed document corruption on failed parsing bug
+              </li>
+<li class="listitem">
+                XPath string &lt;-&gt; number conversion improvements (increased
+                precision, fixed crash for huge numbers)
+              </li>
+<li class="listitem">
+                Improved DOCTYPE parsing: now parser recognizes all well-formed DOCTYPE
+                declarations
+              </li>
+<li class="listitem">
+                Fixed xml_attribute::as_uint() for large numbers (i.e. 2^32-1)
+              </li>
+<li class="listitem">
+                Fixed xml_node::first_element_by_path for path components that are
+                prefixes of node names, but are not exactly equal to them.
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Specification changes:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                parse() API changed to load_buffer/load_buffer_inplace/load_buffer_inplace_own;
+                load_buffer APIs do not require zero-terminated strings.
+              </li>
+<li class="listitem">
+                Renamed as_utf16 to as_wide
+              </li>
+<li class="listitem">
+                Changed xml_node::offset_debug return type and xml_parse_result::offset
+                type to ptrdiff_t
+              </li>
+<li class="listitem">
+                Nodes/attributes with empty names are now printed as :anonymous
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Performance improvements:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Optimized document parsing and saving
+              </li>
+<li class="listitem">
+                Changed internal memory management: internal allocator is used for
+                both metadata and name/value data; allocated pages are deleted if
+                all allocations from them are deleted
+              </li>
+<li class="listitem">
+                Optimized memory consumption: sizeof(xml_node_struct) reduced from
+                40 bytes to 32 bytes on x86
+              </li>
+<li class="listitem">
+                Optimized debug mode parsing/saving by order of magnitude
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Miscellaneous:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                All STL includes except &lt;exception&gt; in pugixml.hpp are replaced
+                with forward declarations
+              </li>
+<li class="listitem">
+                xml_node::remove_child and xml_node::remove_attribute now return
+                the operation result
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Compatibility:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                parse() and as_utf16 are left for compatibility (these functions
+                are deprecated and will be removed in version 1.0)
+              </li>
+<li class="listitem">
+                Wildcard functions, document_order/precompute_document_order functions,
+                all_elements_by_name function and format_write_bom_utf8 flag are
+                deprecated and will be removed in version 1.0
+              </li>
+<li class="listitem">
+                xpath_type_t enumeration was renamed to xpath_value_type; xpath_type_t
+                is deprecated and will be removed in version 1.0
+              </li>
+</ol></div>
+        </li>
+</ul></div>
+<a name="manual.changes.8_11_2009___version_0_5"></a><h6>
+      <a class="link" href="changes.html#manual.changes.8_11_2009___version_0_5">8.11.2009 - version
+      0.5</a>
+    </h6>
+<p>
+      Major bugfix release. Changes:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          XPath bugfixes:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Fixed translate(), lang() and concat() functions (infinite loops/crashes)
+              </li>
+<li class="listitem">
+                Fixed compilation of queries with empty literal strings ("")
+              </li>
+<li class="listitem">
+                Fixed axis tests: they never add empty nodes/attributes to the resulting
+                node set now
+              </li>
+<li class="listitem">
+                Fixed string-value evaluation for node-set (the result excluded some
+                text descendants)
+              </li>
+<li class="listitem">
+                Fixed self:: axis (it behaved like ancestor-or-self::)
+              </li>
+<li class="listitem">
+                Fixed following:: and preceding:: axes (they included descendent
+                and ancestor nodes, respectively)
+              </li>
+<li class="listitem">
+                Minor fix for namespace-uri() function (namespace declaration scope
+                includes the parent element of namespace declaration attribute)
+              </li>
+<li class="listitem">
+                Some incorrect queries are no longer parsed now (i.e. foo: *)
+              </li>
+<li class="listitem">
+                Fixed text()/etc. node test parsing bug (i.e. foo[text()] failed
+                to compile)
+              </li>
+<li class="listitem">
+                Fixed root step (/) - it now selects empty node set if query is evaluated
+                on empty node
+              </li>
+<li class="listitem">
+                Fixed string to number conversion ("123 " converted to
+                NaN, "123 .456" converted to 123.456 - now the results
+                are 123 and NaN, respectively)
+              </li>
+<li class="listitem">
+                Node set copying now preserves sorted type; leads to better performance
+                on some queries
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Miscellaneous bugfixes:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Fixed xml_node::offset_debug for PI nodes
+              </li>
+<li class="listitem">
+                Added empty attribute checks to xml_node::remove_attribute
+              </li>
+<li class="listitem">
+                Fixed node_pi and node_declaration copying
+              </li>
+<li class="listitem">
+                Const-correctness fixes
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Specification changes:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                xpath_node::select_nodes() and related functions now throw exception
+                if expression return type is not node set (instead of assertion)
+              </li>
+<li class="listitem">
+                xml_node::traverse() now sets depth to -1 for both begin() and end()
+                callbacks (was 0 at begin() and -1 at end())
+              </li>
+<li class="listitem">
+                In case of non-raw node printing a newline is output after PCDATA
+                inside nodes if the PCDATA has siblings
+              </li>
+<li class="listitem">
+                UTF8 -&gt; wchar_t conversion now considers 5-byte UTF8-like sequences
+                as invalid
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          New features:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Added xpath_node_set::operator[] for index-based iteration
+              </li>
+<li class="listitem">
+                Added xpath_query::return_type()
+              </li>
+<li class="listitem">
+                Added getter accessors for memory-management functions
+              </li>
+</ol></div>
+        </li>
+</ul></div>
+<a name="manual.changes.17_09_2009___version_0_42"></a><h6>
+      <a class="link" href="changes.html#manual.changes.17_09_2009___version_0_42">17.09.2009 - version
+      0.42</a>
+    </h6>
+<p>
+      Maintenance release. Changes:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          Bug fixes:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Fixed deallocation in case of custom allocation functions or if delete[]
+                / free are incompatible
+              </li>
+<li class="listitem">
+                XPath parser fixed for incorrect queries (i.e. incorrect XPath queries
+                should now always fail to compile)
+              </li>
+<li class="listitem">
+                Const-correctness fixes for find_child_by_attribute
+              </li>
+<li class="listitem">
+                Improved compatibility (miscellaneous warning fixes, fixed cstring
+                include dependency for GCC)
+              </li>
+<li class="listitem">
+                Fixed iterator begin/end and print function to work correctly for
+                empty nodes
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          New features:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Added PUGIXML_API/PUGIXML_CLASS/PUGIXML_FUNCTION configuration macros
+                to control class/function attributes
+              </li>
+<li class="listitem">
+                Added xml_attribute::set_value overloads for different types
+              </li>
+</ol></div>
+        </li>
+</ul></div>
+<a name="manual.changes.8_02_2009___version_0_41"></a><h6>
+      <a class="link" href="changes.html#manual.changes.8_02_2009___version_0_41">8.02.2009 - version
+      0.41</a>
+    </h6>
+<p>
+      Maintenance release. Changes:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+          Bug fixes:
+          <div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem">
+                Fixed bug with node printing (occasionally some content was not written
+                to output stream)
+              </li></ol></div>
+        </li></ul></div>
+<a name="manual.changes.18_01_2009___version_0_4"></a><h6>
+      <a class="link" href="changes.html#manual.changes.18_01_2009___version_0_4">18.01.2009 - version
+      0.4</a>
+    </h6>
+<p>
+      Changes:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          Bug fixes:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Documentation fix in samples for parse() with manual lifetime control
+              </li>
+<li class="listitem">
+                Fixed document order sorting in XPath (it caused wrong order of nodes
+                after xpath_node_set::sort and wrong results of some XPath queries)
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Node printing changes:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Single quotes are no longer escaped when printing nodes
+              </li>
+<li class="listitem">
+                Symbols in second half of ASCII table are no longer escaped when
+                printing nodes; because of this, format_utf8 flag is deleted as it's
+                no longer needed and format_write_bom is renamed to format_write_bom_utf8.
+              </li>
+<li class="listitem">
+                Reworked node printing - now it works via xml_writer interface; implementations
+                for FILE* and std::ostream are available. As a side-effect, xml_document::save_file
+                now works without STL.
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          New features:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Added unsigned integer support for attributes (xml_attribute::as_uint,
+                xml_attribute::operator=)
+              </li>
+<li class="listitem">
+                Now document declaration (&lt;?xml ...?&gt;) is parsed as node with
+                type node_declaration when parse_declaration flag is specified (access
+                to encoding/version is performed as if they were attributes, i.e.
+                doc.child("xml").attribute("version").as_float());
+                corresponding flags for node printing were also added
+              </li>
+<li class="listitem">
+                Added support for custom memory management (see set_memory_management_functions
+                for details)
+              </li>
+<li class="listitem">
+                Implemented node/attribute copying (see xml_node::insert_copy_* and
+                xml_node::append_copy for details)
+              </li>
+<li class="listitem">
+                Added find_child_by_attribute and find_child_by_attribute_w to simplify
+                parsing code in some cases (i.e. COLLADA files)
+              </li>
+<li class="listitem">
+                Added file offset information querying for debugging purposes (now
+                you're able to determine exact location of any xml_node in parsed
+                file, see xml_node::offset_debug for details)
+              </li>
+<li class="listitem">
+                Improved error handling for parsing - now load(), load_file() and
+                parse() return xml_parse_result, which contains error code and last
+                parsed offset; this does not break old interface as xml_parse_result
+                can be implicitly casted to bool.
+              </li>
+</ol></div>
+        </li>
+</ul></div>
+<a name="manual.changes.31_10_2007___version_0_34"></a><h6>
+      <a class="link" href="changes.html#manual.changes.31_10_2007___version_0_34">31.10.2007 - version
+      0.34</a>
+    </h6>
+<p>
+      Maintenance release. Changes:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          Bug fixes:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Fixed bug with loading from text-mode iostreams
+              </li>
+<li class="listitem">
+                Fixed leak when transfer_ownership is true and parsing is failing
+              </li>
+<li class="listitem">
+                Fixed bug in saving (\r and \n are now escaped in attribute values)
+              </li>
+<li class="listitem">
+                Renamed free() to destroy() - some macro conflicts were reported
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          New features:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Improved compatibility (supported Digital Mars C++, MSVC 6, CodeWarrior
+                8, PGI C++, Comeau, supported PS3 and XBox360)
+              </li>
+<li class="listitem">
+                PUGIXML_NO_EXCEPTION flag for platforms without exception handling
+              </li>
+</ol></div>
+        </li>
+</ul></div>
+<a name="manual.changes.21_02_2007___version_0_3"></a><h6>
+      <a class="link" href="changes.html#manual.changes.21_02_2007___version_0_3">21.02.2007 - version
+      0.3</a>
+    </h6>
+<p>
+      Refactored, reworked and improved version. Changes:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          Interface:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Added XPath
+              </li>
+<li class="listitem">
+                Added tree modification functions
+              </li>
+<li class="listitem">
+                Added no STL compilation mode
+              </li>
+<li class="listitem">
+                Added saving document to file
+              </li>
+<li class="listitem">
+                Refactored parsing flags
+              </li>
+<li class="listitem">
+                Removed xml_parser class in favor of xml_document
+              </li>
+<li class="listitem">
+                Added transfer ownership parsing mode
+              </li>
+<li class="listitem">
+                Modified the way xml_tree_walker works
+              </li>
+<li class="listitem">
+                Iterators are now non-constant
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          Implementation:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Support of several compilers and platforms
+              </li>
+<li class="listitem">
+                Refactored and sped up parsing core
+              </li>
+<li class="listitem">
+                Improved standard compliancy
+              </li>
+<li class="listitem">
+                Added XPath implementation
+              </li>
+<li class="listitem">
+                Fixed several bugs
+              </li>
+</ol></div>
+        </li>
+</ul></div>
+<a name="manual.changes.6_11_2006___version_0_2"></a><h6>
+      <a class="link" href="changes.html#manual.changes.6_11_2006___version_0_2">6.11.2006 - version
+      0.2</a>
+    </h6>
+<p>
+      First public release. Changes:
+    </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+          Bug fixes:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Fixed child_value() (for empty nodes)
+              </li>
+<li class="listitem">
+                Fixed xml_parser_impl warning at W4
+              </li>
+</ol></div>
+        </li>
+<li class="listitem">
+          New features:
+          <div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+                Introduced child_value(name) and child_value_w(name)
+              </li>
+<li class="listitem">
+                parse_eol_pcdata and parse_eol_attribute flags + parse_minimal optimizations
+              </li>
+<li class="listitem">
+                Optimizations of strconv_t
+              </li>
+</ol></div>
+        </li>
+</ul></div>
+<a name="manual.changes.15_07_2006___version_0_1"></a><h6>
+      <a class="link" href="changes.html#manual.changes.15_07_2006___version_0_1">15.07.2006 - version
+      0.1</a>
+    </h6>
+<p>
+      First private release for testing purposes
+    </p>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2012 Arseny Kapoulkine<p>
+        Distributed under the MIT License
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="xpath.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="apiref.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+</body>
+</html>
diff --git a/tools/intergen/third_party/pugixml/docs/manual/dom.html b/tools/intergen/third_party/pugixml/docs/manual/dom.html
new file mode 100644
index 0000000000..22d8d835ab
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/manual/dom.html
@@ -0,0 +1,732 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Document object model</title>
+<link rel="stylesheet" href="../pugixml.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../manual.html" title="pugixml 1.2">
+<link rel="up" href="../manual.html" title="pugixml 1.2">
+<link rel="prev" href="install.html" title="Installation">
+<link rel="next" href="loading.html" title="Loading document">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<b>Object model</b> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="install.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="loading.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+<hr>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="manual.dom"></a><a class="link" href="dom.html" title="Document object model"> Document object model</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="dom.html#manual.dom.tree"> Tree structure</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.cpp"> C++ interface</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.unicode"> Unicode interface</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.thread"> Thread-safety guarantees</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.exception"> Exception guarantees</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.memory"> Memory management</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="dom.html#manual.dom.memory.custom"> Custom memory allocation/deallocation
+        functions</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.memory.tuning"> Memory consumption tuning</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.memory.internals"> Document memory management
+        internals</a></span></dt>
+</dl></dd>
+</dl></div>
+<p>
+      pugixml stores XML data in DOM-like way: the entire XML document (both document
+      structure and element data) is stored in memory as a tree. The tree can be
+      loaded from a character stream (file, string, C++ I/O stream), then traversed
+      with the special API or XPath expressions. The whole tree is mutable: both
+      node structure and node/attribute data can be changed at any time. Finally,
+      the result of document transformations can be saved to a character stream (file,
+      C++ I/O stream or custom transport).
+    </p>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.dom.tree"></a><a class="link" href="dom.html#manual.dom.tree" title="Tree structure"> Tree structure</a>
+</h3></div></div></div>
+<p>
+        The XML document is represented with a tree data structure. The root of the
+        tree is the document itself, which corresponds to C++ type <a class="link" href="dom.html#xml_document">xml_document</a>.
+        Document has one or more child nodes, which correspond to C++ type <a class="link" href="dom.html#xml_node">xml_node</a>. Nodes have different types; depending
+        on a type, a node can have a collection of child nodes, a collection of attributes,
+        which correspond to C++ type <a class="link" href="dom.html#xml_attribute">xml_attribute</a>,
+        and some additional data (i.e. name).
+      </p>
+<a name="xml_node_type"></a><p>
+        The tree nodes can be of one of the following types (which together form
+        the enumeration <code class="computeroutput"><span class="identifier">xml_node_type</span></code>):
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            Document node (<a name="node_document"></a><code class="literal">node_document</code>) - this
+            is the root of the tree, which consists of several child nodes. This
+            node corresponds to <a class="link" href="dom.html#xml_document">xml_document</a>
+            class; note that <a class="link" href="dom.html#xml_document">xml_document</a> is
+            a sub-class of <a class="link" href="dom.html#xml_node">xml_node</a>, so the entire
+            node interface is also available. However, document node is special in
+            several ways, which are covered below. There can be only one document
+            node in the tree; document node does not have any XML representation.
+            <br><br>
+
+          </li>
+<li class="listitem">
+            Element/tag node (<a name="node_element"></a><code class="literal">node_element</code>) - this
+            is the most common type of node, which represents XML elements. Element
+            nodes have a name, a collection of attributes and a collection of child
+            nodes (both of which may be empty). The attribute is a simple name/value
+            pair. The example XML representation of element nodes is as follows:
+          </li>
+</ul></div>
+<pre class="programlisting"><span class="special">&lt;</span><span class="identifier">node</span> <span class="identifier">attr</span><span class="special">=</span><span class="string">"value"</span><span class="special">&gt;&lt;</span><span class="identifier">child</span><span class="special">/&gt;&lt;/</span><span class="identifier">node</span><span class="special">&gt;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          There are two element nodes here: one has name <code class="computeroutput"><span class="string">"node"</span></code>,
+          single attribute <code class="computeroutput"><span class="string">"attr"</span></code>
+          and single child <code class="computeroutput"><span class="string">"child"</span></code>,
+          another has name <code class="computeroutput"><span class="string">"child"</span></code>
+          and does not have any attributes or child nodes.
+        </p></blockquote></div>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+            Plain character data nodes (<a name="node_pcdata"></a><code class="literal">node_pcdata</code>)
+            represent plain text in XML. PCDATA nodes have a value, but do not have
+            a name or children/attributes. Note that <span class="bold"><strong>plain
+            character data is not a part of the element node but instead has its
+            own node</strong></span>; an element node can have several child PCDATA nodes.
+            The example XML representation of text nodes is as follows:
+          </li></ul></div>
+<pre class="programlisting"><span class="special">&lt;</span><span class="identifier">node</span><span class="special">&gt;</span> <span class="identifier">text1</span> <span class="special">&lt;</span><span class="identifier">child</span><span class="special">/&gt;</span> <span class="identifier">text2</span> <span class="special">&lt;/</span><span class="identifier">node</span><span class="special">&gt;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          Here <code class="computeroutput"><span class="string">"node"</span></code> element
+          has three children, two of which are PCDATA nodes with values <code class="computeroutput"><span class="string">" text1 "</span></code> and <code class="computeroutput"><span class="string">"
+          text2 "</span></code>.
+        </p></blockquote></div>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+            Character data nodes (<a name="node_cdata"></a><code class="literal">node_cdata</code>) represent
+            text in XML that is quoted in a special way. CDATA nodes do not differ
+            from PCDATA nodes except in XML representation - the above text example
+            looks like this with CDATA:
+          </li></ul></div>
+<pre class="programlisting"><span class="special">&lt;</span><span class="identifier">node</span><span class="special">&gt;</span> <span class="special">&lt;![</span><span class="identifier">CDATA</span><span class="special">[[</span><span class="identifier">text1</span><span class="special">]]&gt;</span> <span class="special">&lt;</span><span class="identifier">child</span><span class="special">/&gt;</span> <span class="special">&lt;![</span><span class="identifier">CDATA</span><span class="special">[[</span><span class="identifier">text2</span><span class="special">]]&gt;</span> <span class="special">&lt;/</span><span class="identifier">node</span><span class="special">&gt;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          CDATA nodes make it easy to include non-escaped &lt;, &amp; and &gt; characters
+          in plain text. CDATA value can not contain the character sequence ]]&gt;,
+          since it is used to determine the end of node contents.
+        </p></blockquote></div>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+            Comment nodes (<a name="node_comment"></a><code class="literal">node_comment</code>) represent
+            comments in XML. Comment nodes have a value, but do not have a name or
+            children/attributes. The example XML representation of a comment node
+            is as follows:
+          </li></ul></div>
+<pre class="programlisting"><span class="special">&lt;!--</span> <span class="identifier">comment</span> <span class="identifier">text</span> <span class="special">--&gt;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          Here the comment node has value <code class="computeroutput"><span class="string">"comment
+          text"</span></code>. By default comment nodes are treated as non-essential
+          part of XML markup and are not loaded during XML parsing. You can override
+          this behavior with <a class="link" href="loading.html#parse_comments">parse_comments</a>
+          flag.
+        </p></blockquote></div>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+            Processing instruction node (<a name="node_pi"></a><code class="literal">node_pi</code>) represent
+            processing instructions (PI) in XML. PI nodes have a name and an optional
+            value, but do not have children/attributes. The example XML representation
+            of a PI node is as follows:
+          </li></ul></div>
+<pre class="programlisting"><span class="special">&lt;?</span><span class="identifier">name</span> <span class="identifier">value</span><span class="special">?&gt;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          Here the name (also called PI target) is <code class="computeroutput"><span class="string">"name"</span></code>,
+          and the value is <code class="computeroutput"><span class="string">"value"</span></code>.
+          By default PI nodes are treated as non-essential part of XML markup and
+          are not loaded during XML parsing. You can override this behavior with
+          <a class="link" href="loading.html#parse_pi">parse_pi</a> flag.
+        </p></blockquote></div>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+            Declaration node (<a name="node_declaration"></a><code class="literal">node_declaration</code>)
+            represents document declarations in XML. Declaration nodes have a name
+            (<code class="computeroutput"><span class="string">"xml"</span></code>) and an
+            optional collection of attributes, but do not have value or children.
+            There can be only one declaration node in a document; moreover, it should
+            be the topmost node (its parent should be the document). The example
+            XML representation of a declaration node is as follows:
+          </li></ul></div>
+<pre class="programlisting"><span class="special">&lt;?</span><span class="identifier">xml</span> <span class="identifier">version</span><span class="special">=</span><span class="string">"1.0"</span><span class="special">?&gt;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          Here the node has name <code class="computeroutput"><span class="string">"xml"</span></code>
+          and a single attribute with name <code class="computeroutput"><span class="string">"version"</span></code>
+          and value <code class="computeroutput"><span class="string">"1.0"</span></code>.
+          By default declaration nodes are treated as non-essential part of XML markup
+          and are not loaded during XML parsing. You can override this behavior with
+          <a class="link" href="loading.html#parse_declaration">parse_declaration</a> flag. Also,
+          by default a dummy declaration is output when XML document is saved unless
+          there is already a declaration in the document; you can disable this with
+          <a class="link" href="saving.html#format_no_declaration">format_no_declaration</a> flag.
+        </p></blockquote></div>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+            Document type declaration node (<a name="node_doctype"></a><code class="literal">node_doctype</code>)
+            represents document type declarations in XML. Document type declaration
+            nodes have a value, which corresponds to the entire document type contents;
+            no additional nodes are created for inner elements like <code class="computeroutput"><span class="special">&lt;!</span><span class="identifier">ENTITY</span><span class="special">&gt;</span></code>. There can be only one document type
+            declaration node in a document; moreover, it should be the topmost node
+            (its parent should be the document). The example XML representation of
+            a document type declaration node is as follows:
+          </li></ul></div>
+<pre class="programlisting"><span class="special">&lt;!</span><span class="identifier">DOCTYPE</span> <span class="identifier">greeting</span> <span class="special">[</span> <span class="special">&lt;!</span><span class="identifier">ELEMENT</span> <span class="identifier">greeting</span> <span class="special">(</span><span class="preprocessor">#PCDATA</span><span class="special">)&gt;</span> <span class="special">]&gt;</span>
+</pre>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          Here the node has value <code class="computeroutput"><span class="string">"greeting [ &lt;!ELEMENT
+          greeting (#PCDATA)&gt; ]"</span></code>. By default document type
+          declaration nodes are treated as non-essential part of XML markup and are
+          not loaded during XML parsing. You can override this behavior with <a class="link" href="loading.html#parse_doctype">parse_doctype</a> flag.
+        </p></blockquote></div>
+<p>
+        Finally, here is a complete example of XML document and the corresponding
+        tree representation (<a href="../samples/tree.xml" target="_top">samples/tree.xml</a>):
+      </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<tbody><tr>
+<td>
+                <p>
+                  
+</p>
+<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="special">&lt;?</span><span class="identifier">xml</span> <span class="identifier">version</span><span class="special">=</span><span class="string">"1.0"</span><span class="special">?&gt;</span>
+<span class="special">&lt;</span><span class="identifier">mesh</span> <span class="identifier">name</span><span class="special">=</span><span class="string">"mesh_root"</span><span class="special">&gt;</span>
+    <span class="special">&lt;!--</span> <span class="identifier">here</span> <span class="identifier">is</span> <span class="identifier">a</span> <span class="identifier">mesh</span> <span class="identifier">node</span> <span class="special">--&gt;</span>
+    <span class="identifier">some</span> <span class="identifier">text</span>
+    <span class="special">&lt;![</span><span class="identifier">CDATA</span><span class="special">[</span><span class="identifier">someothertext</span><span class="special">]]&gt;</span>
+    <span class="identifier">some</span> <span class="identifier">more</span> <span class="identifier">text</span>
+    <span class="special">&lt;</span><span class="identifier">node</span> <span class="identifier">attr1</span><span class="special">=</span><span class="string">"value1"</span> <span class="identifier">attr2</span><span class="special">=</span><span class="string">"value2"</span> <span class="special">/&gt;</span>
+    <span class="special">&lt;</span><span class="identifier">node</span> <span class="identifier">attr1</span><span class="special">=</span><span class="string">"value2"</span><span class="special">&gt;</span>
+        <span class="special">&lt;</span><span class="identifier">innernode</span><span class="special">/&gt;</span>
+    <span class="special">&lt;/</span><span class="identifier">node</span><span class="special">&gt;</span>
+<span class="special">&lt;/</span><span class="identifier">mesh</span><span class="special">&gt;</span>
+<span class="special">&lt;?</span><span class="identifier">include</span> <span class="identifier">somedata</span><span class="special">?&gt;</span>
+</pre>
+<p>
+                </p>
+              </td>
+<td>
+                <p>
+                  <a href="../images/dom_tree.png" target="_top"><span class="inlinemediaobject"><img src="../images/dom_tree_thumb.png" alt="dom_tree_thumb"></span></a>
+                </p>
+              </td>
+</tr></tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.dom.cpp"></a><a class="link" href="dom.html#manual.dom.cpp" title="C++ interface"> C++ interface</a>
+</h3></div></div></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          All pugixml classes and functions are located in the <code class="computeroutput"><span class="identifier">pugi</span></code>
+          namespace; you have to either use explicit name qualification (i.e. <code class="computeroutput"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span></code>), or to gain access to relevant
+          symbols via <code class="computeroutput"><span class="keyword">using</span></code> directive
+          (i.e. <code class="computeroutput"><span class="keyword">using</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span><span class="special">;</span></code> or <code class="computeroutput"><span class="keyword">using</span>
+          <span class="keyword">namespace</span> <span class="identifier">pugi</span><span class="special">;</span></code>). The namespace will be omitted from all
+          declarations in this documentation hereafter; all code examples will use
+          fully qualified names.
+        </p></td></tr>
+</table></div>
+<p>
+        Despite the fact that there are several node types, there are only three
+        C++ classes representing the tree (<code class="computeroutput"><span class="identifier">xml_document</span></code>,
+        <code class="computeroutput"><span class="identifier">xml_node</span></code>, <code class="computeroutput"><span class="identifier">xml_attribute</span></code>);
+        some operations on <code class="computeroutput"><span class="identifier">xml_node</span></code>
+        are only valid for certain node types. The classes are described below.
+      </p>
+<a name="xml_document"></a><a name="xml_document::document_element"></a><p>
+        <code class="computeroutput"><span class="identifier">xml_document</span></code> is the owner
+        of the entire document structure; it is a non-copyable class. The interface
+        of <code class="computeroutput"><span class="identifier">xml_document</span></code> consists
+        of loading functions (see <a class="xref" href="loading.html" title="Loading document"> Loading document</a>), saving functions (see <a class="xref" href="saving.html" title="Saving document"> Saving document</a>)
+        and the entire interface of <code class="computeroutput"><span class="identifier">xml_node</span></code>,
+        which allows for document inspection and/or modification. Note that while
+        <code class="computeroutput"><span class="identifier">xml_document</span></code> is a sub-class
+        of <code class="computeroutput"><span class="identifier">xml_node</span></code>, <code class="computeroutput"><span class="identifier">xml_node</span></code> is not a polymorphic type; the
+        inheritance is present only to simplify usage. Alternatively you can use
+        the <code class="computeroutput"><span class="identifier">document_element</span></code> function
+        to get the element node that's the immediate child of the document.
+      </p>
+<a name="xml_document::ctor"></a><a name="xml_document::dtor"></a><a name="xml_document::reset"></a><p>
+        Default constructor of <code class="computeroutput"><span class="identifier">xml_document</span></code>
+        initializes the document to the tree with only a root node (document node).
+        You can then populate it with data using either tree modification functions
+        or loading functions; all loading functions destroy the previous tree with
+        all occupied memory, which puts existing node/attribute handles for this
+        document to invalid state. If you want to destroy the previous tree, you
+        can use the <code class="computeroutput"><span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">reset</span></code>
+        function; it destroys the tree and replaces it with either an empty one or
+        a copy of the specified document. Destructor of <code class="computeroutput"><span class="identifier">xml_document</span></code>
+        also destroys the tree, thus the lifetime of the document object should exceed
+        the lifetimes of any node/attribute handles that point to the tree.
+      </p>
+<div class="caution"><table border="0" summary="Caution">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="../images/caution.png"></td>
+<th align="left">Caution</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          While technically node/attribute handles can be alive when the tree they're
+          referring to is destroyed, calling any member function for these handles
+          results in undefined behavior. Thus it is recommended to make sure that
+          the document is destroyed only after all references to its nodes/attributes
+          are destroyed.
+        </p></td></tr>
+</table></div>
+<a name="xml_node"></a><a name="xml_node::type"></a><p>
+        <code class="computeroutput"><span class="identifier">xml_node</span></code> is the handle to
+        document node; it can point to any node in the document, including the document
+        node itself. There is a common interface for nodes of all types; the actual
+        <a class="link" href="dom.html#xml_node_type">node type</a> can be queried via the <code class="computeroutput"><span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">type</span><span class="special">()</span></code>
+        method. Note that <code class="computeroutput"><span class="identifier">xml_node</span></code>
+        is only a handle to the actual node, not the node itself - you can have several
+        <code class="computeroutput"><span class="identifier">xml_node</span></code> handles pointing
+        to the same underlying object. Destroying <code class="computeroutput"><span class="identifier">xml_node</span></code>
+        handle does not destroy the node and does not remove it from the tree. The
+        size of <code class="computeroutput"><span class="identifier">xml_node</span></code> is equal
+        to that of a pointer, so it is nothing more than a lightweight wrapper around
+        a pointer; you can safely pass or return <code class="computeroutput"><span class="identifier">xml_node</span></code>
+        objects by value without additional overhead.
+      </p>
+<a name="node_null"></a><p>
+        There is a special value of <code class="computeroutput"><span class="identifier">xml_node</span></code>
+        type, known as null node or empty node (such nodes have type <code class="computeroutput"><span class="identifier">node_null</span></code>). It does not correspond to any
+        node in any document, and thus resembles null pointer. However, all operations
+        are defined on empty nodes; generally the operations don't do anything and
+        return empty nodes/attributes or empty strings as their result (see documentation
+        for specific functions for more detailed information). This is useful for
+        chaining calls; i.e. you can get the grandparent of a node like so: <code class="computeroutput"><span class="identifier">node</span><span class="special">.</span><span class="identifier">parent</span><span class="special">().</span><span class="identifier">parent</span><span class="special">()</span></code>; if a node is a null node or it does not
+        have a parent, the first <code class="computeroutput"><span class="identifier">parent</span><span class="special">()</span></code> call returns null node; the second <code class="computeroutput"><span class="identifier">parent</span><span class="special">()</span></code>
+        call then also returns null node, which makes error handling easier.
+      </p>
+<a name="xml_attribute"></a><p>
+        <code class="computeroutput"><span class="identifier">xml_attribute</span></code> is the handle
+        to an XML attribute; it has the same semantics as <code class="computeroutput"><span class="identifier">xml_node</span></code>,
+        i.e. there can be several <code class="computeroutput"><span class="identifier">xml_attribute</span></code>
+        handles pointing to the same underlying object and there is a special null
+        attribute value, which propagates to function results.
+      </p>
+<a name="xml_attribute::ctor"></a><a name="xml_node::ctor"></a><p>
+        Both <code class="computeroutput"><span class="identifier">xml_node</span></code> and <code class="computeroutput"><span class="identifier">xml_attribute</span></code> have the default constructor
+        which initializes them to null objects.
+      </p>
+<a name="xml_attribute::comparison"></a><a name="xml_node::comparison"></a><p>
+        <code class="computeroutput"><span class="identifier">xml_node</span></code> and <code class="computeroutput"><span class="identifier">xml_attribute</span></code> try to behave like pointers,
+        that is, they can be compared with other objects of the same type, making
+        it possible to use them as keys in associative containers. All handles to
+        the same underlying object are equal, and any two handles to different underlying
+        objects are not equal. Null handles only compare as equal to themselves.
+        The result of relational comparison can not be reliably determined from the
+        order of nodes in file or in any other way. Do not use relational comparison
+        operators except for search optimization (i.e. associative container keys).
+      </p>
+<a name="xml_attribute::hash_value"></a><a name="xml_node::hash_value"></a><p>
+        If you want to use <code class="computeroutput"><span class="identifier">xml_node</span></code>
+        or <code class="computeroutput"><span class="identifier">xml_attribute</span></code> objects
+        as keys in hash-based associative containers, you can use the <code class="computeroutput"><span class="identifier">hash_value</span></code> member functions. They return
+        the hash values that are guaranteed to be the same for all handles to the
+        same underlying object. The hash value for null handles is 0.
+      </p>
+<a name="xml_attribute::unspecified_bool_type"></a><a name="xml_node::unspecified_bool_type"></a><a name="xml_attribute::empty"></a><a name="xml_node::empty"></a><p>
+        Finally handles can be implicitly cast to boolean-like objects, so that you
+        can test if the node/attribute is empty with the following code: <code class="computeroutput"><span class="keyword">if</span> <span class="special">(</span><span class="identifier">node</span><span class="special">)</span> <span class="special">{</span> <span class="special">...</span>
+        <span class="special">}</span></code> or <code class="computeroutput"><span class="keyword">if</span>
+        <span class="special">(!</span><span class="identifier">node</span><span class="special">)</span> <span class="special">{</span> <span class="special">...</span>
+        <span class="special">}</span> <span class="keyword">else</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span></code>.
+        Alternatively you can check if a given <code class="computeroutput"><span class="identifier">xml_node</span></code>/<code class="computeroutput"><span class="identifier">xml_attribute</span></code> handle is null by calling
+        the following methods:
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">bool</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        Nodes and attributes do not exist without a document tree, so you can't create
+        them without adding them to some document. Once underlying node/attribute
+        objects are destroyed, the handles to those objects become invalid. While
+        this means that destruction of the entire tree invalidates all node/attribute
+        handles, it also means that destroying a subtree (by calling <a class="link" href="modify.html#xml_node::remove_child">xml_node::remove_child</a>)
+        or removing an attribute invalidates the corresponding handles. There is
+        no way to check handle validity; you have to ensure correctness through external
+        mechanisms.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.dom.unicode"></a><a class="link" href="dom.html#manual.dom.unicode" title="Unicode interface"> Unicode interface</a>
+</h3></div></div></div>
+<p>
+        There are two choices of interface and internal representation when configuring
+        pugixml: you can either choose the UTF-8 (also called char) interface or
+        UTF-16/32 (also called wchar_t) one. The choice is controlled via <a class="link" href="install.html#PUGIXML_WCHAR_MODE">PUGIXML_WCHAR_MODE</a>
+        define; you can set it via <code class="filename">pugiconfig.hpp</code> or via preprocessor options, as
+        discussed in <a class="xref" href="install.html#manual.install.building.config" title="Additional configuration options"> Additional configuration
+        options</a>. If this define is set, the wchar_t
+        interface is used; otherwise (by default) the char interface is used. The
+        exact wide character encoding is assumed to be either UTF-16 or UTF-32 and
+        is determined based on the size of <code class="computeroutput"><span class="keyword">wchar_t</span></code>
+        type.
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          If the size of <code class="computeroutput"><span class="keyword">wchar_t</span></code> is
+          2, pugixml assumes UTF-16 encoding instead of UCS-2, which means that some
+          characters are represented as two code points.
+        </p></td></tr>
+</table></div>
+<p>
+        All tree functions that work with strings work with either C-style null terminated
+        strings or STL strings of the selected character type. For example, node
+        name accessors look like this in char mode:
+      </p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">name</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">bool</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">set_name</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">value</span><span class="special">);</span>
+</pre>
+<p>
+        and like this in wchar_t mode:
+      </p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">name</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">bool</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">set_name</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*</span> <span class="identifier">value</span><span class="special">);</span>
+</pre>
+<a name="char_t"></a><a name="string_t"></a><p>
+        There is a special type, <code class="computeroutput"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">char_t</span></code>,
+        that is defined as the character type and depends on the library configuration;
+        it will be also used in the documentation hereafter. There is also a type
+        <code class="computeroutput"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">string_t</span></code>, which is defined as the STL string
+        of the character type; it corresponds to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>
+        in char mode and to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">wstring</span></code> in wchar_t mode.
+      </p>
+<p>
+        In addition to the interface, the internal implementation changes to store
+        XML data as <code class="computeroutput"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">char_t</span></code>; this means that these two modes
+        have different memory usage characteristics. The conversion to <code class="computeroutput"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">char_t</span></code> upon document loading and from
+        <code class="computeroutput"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">char_t</span></code> upon document saving happen automatically,
+        which also carries minor performance penalty. The general advice however
+        is to select the character mode based on usage scenario, i.e. if UTF-8 is
+        inconvenient to process and most of your XML data is non-ASCII, wchar_t mode
+        is probably a better choice.
+      </p>
+<a name="as_utf8"></a><a name="as_wide"></a><p>
+        There are cases when you'll have to convert string data between UTF-8 and
+        wchar_t encodings; the following helper functions are provided for such purposes:
+      </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">as_utf8</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*</span> <span class="identifier">str</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">wstring</span> <span class="identifier">as_wide</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">str</span><span class="special">);</span>
+</pre>
+<p>
+        Both functions accept a null-terminated string as an argument <code class="computeroutput"><span class="identifier">str</span></code>, and return the converted string.
+        <code class="computeroutput"><span class="identifier">as_utf8</span></code> performs conversion
+        from UTF-16/32 to UTF-8; <code class="computeroutput"><span class="identifier">as_wide</span></code>
+        performs conversion from UTF-8 to UTF-16/32. Invalid UTF sequences are silently
+        discarded upon conversion. <code class="computeroutput"><span class="identifier">str</span></code>
+        has to be a valid string; passing null pointer results in undefined behavior.
+        There are also two overloads with the same semantics which accept a string
+        as an argument:
+      </p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">as_utf8</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">wstring</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">wstring</span> <span class="identifier">as_wide</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">);</span>
+</pre>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top">
+<p>
+          Most examples in this documentation assume char interface and therefore
+          will not compile with <a class="link" href="install.html#PUGIXML_WCHAR_MODE">PUGIXML_WCHAR_MODE</a>.
+          This is done to simplify the documentation; usually the only changes you'll
+          have to make is to pass <code class="computeroutput"><span class="keyword">wchar_t</span></code>
+          string literals, i.e. instead of
+        </p>
+<p>
+          <code class="computeroutput"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">node</span>
+          <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"bookstore"</span><span class="special">).</span><span class="identifier">find_child_by_attribute</span><span class="special">(</span><span class="string">"book"</span><span class="special">,</span> <span class="string">"id"</span><span class="special">,</span> <span class="string">"12345"</span><span class="special">);</span></code>
+        </p>
+<p>
+          you'll have to do
+        </p>
+<p>
+          <code class="computeroutput"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">node</span>
+          <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="identifier">L</span><span class="string">"bookstore"</span><span class="special">).</span><span class="identifier">find_child_by_attribute</span><span class="special">(</span><span class="identifier">L</span><span class="string">"book"</span><span class="special">,</span> <span class="identifier">L</span><span class="string">"id"</span><span class="special">,</span> <span class="identifier">L</span><span class="string">"12345"</span><span class="special">);</span></code>
+        </p>
+</td></tr>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.dom.thread"></a><a class="link" href="dom.html#manual.dom.thread" title="Thread-safety guarantees"> Thread-safety guarantees</a>
+</h3></div></div></div>
+<p>
+        Almost all functions in pugixml have the following thread-safety guarantees:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            it is safe to call free (non-member) functions from multiple threads
+          </li>
+<li class="listitem">
+            it is safe to perform concurrent read-only accesses to the same tree
+            (all constant member functions do not modify the tree)
+          </li>
+<li class="listitem">
+            it is safe to perform concurrent read/write accesses, if there is only
+            one read or write access to the single tree at a time
+          </li>
+</ul></div>
+<p>
+        Concurrent modification and traversing of a single tree requires synchronization,
+        for example via reader-writer lock. Modification includes altering document
+        structure and altering individual node/attribute data, i.e. changing names/values.
+      </p>
+<p>
+        The only exception is <a class="link" href="dom.html#set_memory_management_functions">set_memory_management_functions</a>;
+        it modifies global variables and as such is not thread-safe. Its usage policy
+        has more restrictions, see <a class="xref" href="dom.html#manual.dom.memory.custom" title="Custom memory allocation/deallocation functions"> Custom memory allocation/deallocation
+        functions</a>.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.dom.exception"></a><a class="link" href="dom.html#manual.dom.exception" title="Exception guarantees"> Exception guarantees</a>
+</h3></div></div></div>
+<p>
+        With the exception of XPath, pugixml itself does not throw any exceptions.
+        Additionally, most pugixml functions have a no-throw exception guarantee.
+      </p>
+<p>
+        This is not applicable to functions that operate on STL strings or IOstreams;
+        such functions have either strong guarantee (functions that operate on strings)
+        or basic guarantee (functions that operate on streams). Also functions that
+        call user-defined callbacks (i.e. <a class="link" href="access.html#xml_node::traverse">xml_node::traverse</a>
+        or <a class="link" href="access.html#xml_node::find_node">xml_node::find_node</a>) do not
+        provide any exception guarantees beyond the ones provided by the callback.
+      </p>
+<p>
+        If exception handling is not disabled with <a class="link" href="install.html#PUGIXML_NO_EXCEPTIONS">PUGIXML_NO_EXCEPTIONS</a>
+        define, XPath functions may throw <a class="link" href="xpath.html#xpath_exception">xpath_exception</a>
+        on parsing errors; also, XPath functions may throw <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span></code>
+        in low memory conditions. Still, XPath functions provide strong exception
+        guarantee.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.dom.memory"></a><a class="link" href="dom.html#manual.dom.memory" title="Memory management"> Memory management</a>
+</h3></div></div></div>
+<p>
+        pugixml requests the memory needed for document storage in big chunks, and
+        allocates document data inside those chunks. This section discusses replacing
+        functions used for chunk allocation and internal memory management implementation.
+      </p>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="manual.dom.memory.custom"></a><a class="link" href="dom.html#manual.dom.memory.custom" title="Custom memory allocation/deallocation functions"> Custom memory allocation/deallocation
+        functions</a>
+</h4></div></div></div>
+<a name="allocation_function"></a><a name="deallocation_function"></a><p>
+          All memory for tree structure, tree data and XPath objects is allocated
+          via globally specified functions, which default to malloc/free. You can
+          set your own allocation functions with set_memory_management function.
+          The function interfaces are the same as that of malloc/free:
+        </p>
+<pre class="programlisting"><span class="keyword">typedef</span> <span class="keyword">void</span><span class="special">*</span> <span class="special">(*</span><span class="identifier">allocation_function</span><span class="special">)(</span><span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">);</span>
+<span class="keyword">typedef</span> <span class="keyword">void</span> <span class="special">(*</span><span class="identifier">deallocation_function</span><span class="special">)(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">);</span>
+</pre>
+<a name="set_memory_management_functions"></a><a name="get_memory_allocation_function"></a><a name="get_memory_deallocation_function"></a><p>
+          You can use the following accessor functions to change or get current memory
+          management functions:
+        </p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">set_memory_management_functions</span><span class="special">(</span><span class="identifier">allocation_function</span> <span class="identifier">allocate</span><span class="special">,</span> <span class="identifier">deallocation_function</span> <span class="identifier">deallocate</span><span class="special">);</span>
+<span class="identifier">allocation_function</span> <span class="identifier">get_memory_allocation_function</span><span class="special">();</span>
+<span class="identifier">deallocation_function</span> <span class="identifier">get_memory_deallocation_function</span><span class="special">();</span>
+</pre>
+<p>
+          Allocation function is called with the size (in bytes) as an argument and
+          should return a pointer to a memory block with alignment that is suitable
+          for storage of primitive types (usually a maximum of <code class="computeroutput"><span class="keyword">void</span><span class="special">*</span></code> and <code class="computeroutput"><span class="keyword">double</span></code>
+          types alignment is sufficient) and size that is greater than or equal to
+          the requested one. If the allocation fails, the function has to return
+          null pointer (throwing an exception from allocation function results in
+          undefined behavior).
+        </p>
+<p>
+          Deallocation function is called with the pointer that was returned by some
+          call to allocation function; it is never called with a null pointer. If
+          memory management functions are not thread-safe, library thread safety
+          is not guaranteed.
+        </p>
+<p>
+          This is a simple example of custom memory management (<a href="../samples/custom_memory_management.cpp" target="_top">samples/custom_memory_management.cpp</a>):
+        </p>
+<p>
+          
+</p>
+<pre class="programlisting"><span class="keyword">void</span><span class="special">*</span> <span class="identifier">custom_allocate</span><span class="special">(</span><span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="keyword">return</span> <span class="keyword">new</span> <span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">nothrow</span><span class="special">)</span> <span class="keyword">char</span><span class="special">[</span><span class="identifier">size</span><span class="special">];</span>
+<span class="special">}</span>
+
+<span class="keyword">void</span> <span class="identifier">custom_deallocate</span><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">ptr</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="keyword">delete</span><span class="special">[]</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&gt;(</span><span class="identifier">ptr</span><span class="special">);</span>
+<span class="special">}</span>
+</pre>
+<p>
+        </p>
+<p>
+          
+</p>
+<pre class="programlisting"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">set_memory_management_functions</span><span class="special">(</span><span class="identifier">custom_allocate</span><span class="special">,</span> <span class="identifier">custom_deallocate</span><span class="special">);</span>
+</pre>
+<p>
+        </p>
+<p>
+          When setting new memory management functions, care must be taken to make
+          sure that there are no live pugixml objects. Otherwise when the objects
+          are destroyed, the new deallocation function will be called with the memory
+          obtained by the old allocation function, resulting in undefined behavior.
+        </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="manual.dom.memory.tuning"></a><a class="link" href="dom.html#manual.dom.memory.tuning" title="Memory consumption tuning"> Memory consumption tuning</a>
+</h4></div></div></div>
+<p>
+          There are several important buffering optimizations in pugixml that rely
+          on predefined constants. These constants have default values that were
+          tuned for common usage patterns; for some applications, changing these
+          constants might improve memory consumption or increase performance. Changing
+          these constants is not recommended unless their default values result in
+          visible problems.
+        </p>
+<p>
+          These constants can be tuned via configuration defines, as discussed in
+          <a class="xref" href="install.html#manual.install.building.config" title="Additional configuration options"> Additional configuration
+        options</a>; it is recommended to set them in <code class="filename">pugiconfig.hpp</code>.
+        </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+              <code class="computeroutput"><span class="identifier">PUGIXML_MEMORY_PAGE_SIZE</span></code>
+              controls the page size for document memory allocation. Memory for node/attribute
+              objects is allocated in pages of the specified size. The default size
+              is 32 Kb; for some applications the size is too large (i.e. embedded
+              systems with little heap space or applications that keep lots of XML
+              documents in memory). A minimum size of 1 Kb is recommended. <br><br>
+
+            </li>
+<li class="listitem">
+              <code class="computeroutput"><span class="identifier">PUGIXML_MEMORY_OUTPUT_STACK</span></code>
+              controls the cumulative stack space required to output the node. Any
+              output operation (i.e. saving a subtree to file) uses an internal buffering
+              scheme for performance reasons. The default size is 10 Kb; if you're
+              using node output from threads with little stack space, decreasing
+              this value can prevent stack overflows. A minimum size of 1 Kb is recommended.
+              <br><br>
+
+            </li>
+<li class="listitem">
+              <code class="computeroutput"><span class="identifier">PUGIXML_MEMORY_XPATH_PAGE_SIZE</span></code>
+              controls the page size for XPath memory allocation. Memory for XPath
+              query objects as well as internal memory for XPath evaluation is allocated
+              in pages of the specified size. The default size is 4 Kb; if you have
+              a lot of resident XPath query objects, you might need to decrease the
+              size to improve memory consumption. A minimum size of 256 bytes is
+              recommended.
+            </li>
+</ul></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="manual.dom.memory.internals"></a><a class="link" href="dom.html#manual.dom.memory.internals" title="Document memory management internals"> Document memory management
+        internals</a>
+</h4></div></div></div>
+<p>
+          Constructing a document object using the default constructor does not result
+          in any allocations; document node is stored inside the <a class="link" href="dom.html#xml_document">xml_document</a>
+          object.
+        </p>
+<p>
+          When the document is loaded from file/buffer, unless an inplace loading
+          function is used (see <a class="xref" href="loading.html#manual.loading.memory" title="Loading document from memory"> Loading document from memory</a>), a complete copy of character
+          stream is made; all names/values of nodes and attributes are allocated
+          in this buffer. This buffer is allocated via a single large allocation
+          and is only freed when document memory is reclaimed (i.e. if the <a class="link" href="dom.html#xml_document">xml_document</a> object is destroyed or if another
+          document is loaded in the same object). Also when loading from file or
+          stream, an additional large allocation may be performed if encoding conversion
+          is required; a temporary buffer is allocated, and it is freed before load
+          function returns.
+        </p>
+<p>
+          All additional memory, such as memory for document structure (node/attribute
+          objects) and memory for node/attribute names/values is allocated in pages
+          on the order of 32 kilobytes; actual objects are allocated inside the pages
+          using a memory management scheme optimized for fast allocation/deallocation
+          of many small objects. Because of the scheme specifics, the pages are only
+          destroyed if all objects inside them are destroyed; also, generally destroying
+          an object does not mean that subsequent object creation will reuse the
+          same memory. This means that it is possible to devise a usage scheme which
+          will lead to higher memory usage than expected; one example is adding a
+          lot of nodes, and them removing all even numbered ones; not a single page
+          is reclaimed in the process. However this is an example specifically crafted
+          to produce unsatisfying behavior; in all practical usage scenarios the
+          memory consumption is less than that of a general-purpose allocator because
+          allocation meta-data is very small in size.
+        </p>
+</div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2012 Arseny Kapoulkine<p>
+        Distributed under the MIT License
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<b>Object model</b> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="install.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="loading.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+</body>
+</html>
diff --git a/tools/intergen/third_party/pugixml/docs/manual/install.html b/tools/intergen/third_party/pugixml/docs/manual/install.html
new file mode 100644
index 0000000000..df7b322c88
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/manual/install.html
@@ -0,0 +1,498 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Installation</title>
+<link rel="stylesheet" href="../pugixml.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../manual.html" title="pugixml 1.2">
+<link rel="up" href="../manual.html" title="pugixml 1.2">
+<link rel="prev" href="../manual.html" title="pugixml 1.2">
+<link rel="next" href="dom.html" title="Document object model">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<b>Installation</b> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="../manual.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="dom.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+<hr>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="manual.install"></a><a class="link" href="install.html" title="Installation"> Installation</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="install.html#manual.install.getting"> Getting pugixml</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="install.html#manual.install.getting.source"> Source distributions</a></span></dt>
+<dt><span class="section"><a href="install.html#manual.install.getting.subversion"> Subversion repository</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="install.html#manual.install.building"> Building pugixml</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="install.html#manual.install.building.embed"> Building pugixml as
+        a part of another static library/executable</a></span></dt>
+<dt><span class="section"><a href="install.html#manual.install.building.static"> Building pugixml as
+        a standalone static library</a></span></dt>
+<dt><span class="section"><a href="install.html#manual.install.building.shared"> Building pugixml as
+        a standalone shared library</a></span></dt>
+<dt><span class="section"><a href="install.html#manual.install.building.header"> Using pugixml in header-only
+        mode</a></span></dt>
+<dt><span class="section"><a href="install.html#manual.install.building.config"> Additional configuration
+        options</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="install.html#manual.install.portability"> Portability</a></span></dt>
+</dl></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.install.getting"></a><a class="link" href="install.html#manual.install.getting" title="Getting pugixml"> Getting pugixml</a>
+</h3></div></div></div>
+<p>
+        pugixml is distributed in source form. You can either download a source distribution
+        or checkout the Subversion repository.
+      </p>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="manual.install.getting.source"></a><a class="link" href="install.html#manual.install.getting.source" title="Source distributions"> Source distributions</a>
+</h4></div></div></div>
+<p>
+          You can download the latest source distribution via one of the following
+          links:
+        </p>
+<pre class="programlisting"><a href="http://pugixml.googlecode.com/files/pugixml-1.2.zip" target="_top">http://pugixml.googlecode.com/files/pugixml-1.2.zip</a>
+<a href="http://pugixml.googlecode.com/files/pugixml-1.2.tar.gz" target="_top">http://pugixml.googlecode.com/files/pugixml-1.2.tar.gz</a>
+</pre>
+<p>
+          The distribution contains library source, documentation (the manual you're
+          reading now and the quick start guide) and some code examples. After downloading
+          the distribution, install pugixml by extracting all files from the compressed
+          archive. The files have different line endings depending on the archive
+          format - <code class="filename">.zip</code> archive has Windows line endings, <code class="filename">.tar.gz</code> archive has Unix
+          line endings. Otherwise the files in both archives are identical.
+        </p>
+<p>
+          If you need an older version, you can download it from the <a href="http://code.google.com/p/pugixml/downloads/list" target="_top">version
+          archive</a>.
+        </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="manual.install.getting.subversion"></a><a class="link" href="install.html#manual.install.getting.subversion" title="Subversion repository"> Subversion repository</a>
+</h4></div></div></div>
+<p>
+          The Subversion repository is located at <a href="http://pugixml.googlecode.com/svn/" target="_top">http://pugixml.googlecode.com/svn/</a>.
+          There is a Subversion tag "release-{version}" for each version;
+          also there is the "latest" tag, which always points to the latest
+          stable release.
+        </p>
+<p>
+          For example, to checkout the current version, you can use this command:
+        </p>
+<pre class="programlisting">svn checkout http://pugixml.googlecode.com/svn/tags/release-1.2 pugixml</pre>
+<p>
+          To checkout the latest version, you can use this command:
+        </p>
+<pre class="programlisting">svn checkout http://pugixml.googlecode.com/svn/tags/latest pugixml</pre>
+<p>
+          The repository contains library source, documentation, code examples and
+          full unit test suite.
+        </p>
+<p>
+          Use latest version tag if you want to automatically get new versions via
+          <code class="literal">svn update</code>. Use other tags if you want to switch to
+          new versions only explicitly (for example, using <code class="literal">svn switch</code>
+          command). Also please note that Subversion trunk contains the work-in-progress
+          version of the code; while this means that you can get new features and
+          bug fixes from trunk without waiting for a new release, this also means
+          that occasionally the code can be broken in some configurations.
+        </p>
+</div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.install.building"></a><a class="link" href="install.html#manual.install.building" title="Building pugixml"> Building pugixml</a>
+</h3></div></div></div>
+<p>
+        pugixml is distributed in source form without any pre-built binaries; you
+        have to build them yourself.
+      </p>
+<p>
+        The complete pugixml source consists of three files - one source file, <code class="filename">pugixml.cpp</code>,
+        and two header files, <code class="filename">pugixml.hpp</code> and <code class="filename">pugiconfig.hpp</code>. <code class="filename">pugixml.hpp</code> is the primary
+        header which you need to include in order to use pugixml classes/functions;
+        <code class="filename">pugiconfig.hpp</code> is a supplementary configuration file (see <a class="xref" href="install.html#manual.install.building.config" title="Additional configuration options"> Additional configuration
+        options</a>).
+        The rest of this guide assumes that <code class="filename">pugixml.hpp</code> is either in the current directory
+        or in one of include directories of your projects, so that <code class="computeroutput"><span class="preprocessor">#include</span> <span class="string">"pugixml.hpp"</span></code>
+        can find the header; however you can also use relative path (i.e. <code class="computeroutput"><span class="preprocessor">#include</span> <span class="string">"../libs/pugixml/src/pugixml.hpp"</span></code>)
+        or include directory-relative path (i.e. <code class="computeroutput"><span class="preprocessor">#include</span>
+        <span class="special">&lt;</span><span class="identifier">xml</span><span class="special">/</span><span class="identifier">thirdparty</span><span class="special">/</span><span class="identifier">pugixml</span><span class="special">/</span><span class="identifier">src</span><span class="special">/</span><span class="identifier">pugixml</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>).
+      </p>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="manual.install.building.embed"></a><a class="link" href="install.html#manual.install.building.embed" title="Building pugixml as a part of another static library/executable"> Building pugixml as
+        a part of another static library/executable</a>
+</h4></div></div></div>
+<p>
+          The easiest way to build pugixml is to compile the source file, <code class="filename">pugixml.cpp</code>,
+          along with the existing library/executable. This process depends on the
+          method of building your application; for example, if you're using Microsoft
+          Visual Studio<sup>[<a name="trademarks" href="#ftn.trademarks" class="footnote">1</a>]</sup>, Apple Xcode, Code::Blocks or any other IDE, just add <code class="filename">pugixml.cpp</code> to
+          one of your projects.
+        </p>
+<p>
+          If you're using Microsoft Visual Studio and the project has precompiled
+          headers turned on, you'll see the following error messages:
+        </p>
+<pre class="programlisting">pugixml.cpp(3477) : fatal error C1010: unexpected end of file while looking for precompiled header. Did you forget to add '#include "stdafx.h"' to your source?</pre>
+<p>
+          The correct way to resolve this is to disable precompiled headers for <code class="filename">pugixml.cpp</code>;
+          you have to set "Create/Use Precompiled Header" option (Properties
+          dialog -&gt; C/C++ -&gt; Precompiled Headers -&gt; Create/Use Precompiled
+          Header) to "Not Using Precompiled Headers". You'll have to do
+          it for all project configurations/platforms (you can select Configuration
+          "All Configurations" and Platform "All Platforms" before
+          editing the option):
+        </p>
+<div class="informaltable"><table class="table">
+<colgroup><col></colgroup>
+<tbody><tr><td>
+                  <p>
+                    <a href="../images/vs2005_pch1.png" target="_top"><span class="inlinemediaobject"><img src="../images/vs2005_pch1_thumb.png" alt="vs2005_pch1_thumb"></span></a> <span class="inlinemediaobject"><img src="../images/next.png" alt="next"></span> <a href="../images/vs2005_pch2.png" target="_top"><span class="inlinemediaobject"><img src="../images/vs2005_pch2_thumb.png" alt="vs2005_pch2_thumb"></span></a> <span class="inlinemediaobject"><img src="../images/next.png" alt="next"></span> <a href="../images/vs2005_pch3.png" target="_top"><span class="inlinemediaobject"><img src="../images/vs2005_pch3_thumb.png" alt="vs2005_pch3_thumb"></span></a> <span class="inlinemediaobject"><img src="../images/next.png" alt="next"></span> <a href="../images/vs2005_pch4.png" target="_top"><span class="inlinemediaobject"><img src="../images/vs2005_pch4_thumb.png" alt="vs2005_pch4_thumb"></span></a>
+                  </p>
+                </td></tr></tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="manual.install.building.static"></a><a class="link" href="install.html#manual.install.building.static" title="Building pugixml as a standalone static library"> Building pugixml as
+        a standalone static library</a>
+</h4></div></div></div>
+<p>
+          It's possible to compile pugixml as a standalone static library. This process
+          depends on the method of building your application; pugixml distribution
+          comes with project files for several popular IDEs/build systems. There
+          are project files for Apple XCode3, Code::Blocks, Codelite, Microsoft Visual
+          Studio 2005, 2008, 2010, and configuration scripts for CMake and premake4.
+          You're welcome to submit project files/build scripts for other software;
+          see <a class="xref" href="../manual.html#manual.overview.feedback" title="Feedback"> Feedback</a>.
+        </p>
+<p>
+          There are two projects for each version of Microsoft Visual Studio: one
+          for dynamically linked CRT, which has a name like <code class="filename">pugixml_vs2008.vcproj</code>,
+          and another one for statically linked CRT, which has a name like <code class="filename">pugixml_vs2008_static.vcproj</code>.
+          You should select the version that matches the CRT used in your application;
+          the default option for new projects created by Microsoft Visual Studio
+          is dynamically linked CRT, so unless you changed the defaults, you should
+          use the version with dynamic CRT (i.e. <code class="filename">pugixml_vs2008.vcproj</code> for Microsoft
+          Visual Studio 2008).
+        </p>
+<p>
+          In addition to adding pugixml project to your workspace, you'll have to
+          make sure that your application links with pugixml library. If you're using
+          Microsoft Visual Studio 2005/2008, you can add a dependency from your application
+          project to pugixml one. If you're using Microsoft Visual Studio 2010, you'll
+          have to add a reference to your application project instead. For other
+          IDEs/systems, consult the relevant documentation.
+        </p>
+<div class="informaltable"><table class="table">
+<colgroup>
+<col>
+<col>
+</colgroup>
+<thead><tr>
+<th>
+                  <p>
+                    Microsoft Visual Studio 2005/2008
+                  </p>
+                </th>
+<th>
+                  <p>
+                    Microsoft Visual Studio 2010
+                  </p>
+                </th>
+</tr></thead>
+<tbody><tr>
+<td>
+                  <p>
+                    <a href="../images/vs2005_link1.png" target="_top"><span class="inlinemediaobject"><img src="../images/vs2005_link1_thumb.png" alt="vs2005_link1_thumb"></span></a> <span class="inlinemediaobject"><img src="../images/next.png" alt="next"></span> <a href="../images/vs2005_link2.png" target="_top"><span class="inlinemediaobject"><img src="../images/vs2005_link2_thumb.png" alt="vs2005_link2_thumb"></span></a>
+                  </p>
+                </td>
+<td>
+                  <p>
+                    <a href="../images/vs2010_link1.png" target="_top"><span class="inlinemediaobject"><img src="../images/vs2010_link1_thumb.png" alt="vs2010_link1_thumb"></span></a> <span class="inlinemediaobject"><img src="../images/next.png" alt="next"></span> <a href="../images/vs2010_link2.png" target="_top"><span class="inlinemediaobject"><img src="../images/vs2010_link2_thumb.png" alt="vs2010_link2_thumb"></span></a>
+                  </p>
+                </td>
+</tr></tbody>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="manual.install.building.shared"></a><a class="link" href="install.html#manual.install.building.shared" title="Building pugixml as a standalone shared library"> Building pugixml as
+        a standalone shared library</a>
+</h4></div></div></div>
+<p>
+          It's possible to compile pugixml as a standalone shared library. The process
+          is usually similar to the static library approach; however, no preconfigured
+          projects/scripts are included into pugixml distribution, so you'll have
+          to do it yourself. Generally, if you're using GCC-based toolchain, the
+          process does not differ from building any other library as DLL (adding
+          -shared to compilation flags should suffice); if you're using MSVC-based
+          toolchain, you'll have to explicitly mark exported symbols with a declspec
+          attribute. You can do it by defining <a class="link" href="install.html#PUGIXML_API">PUGIXML_API</a>
+          macro, i.e. via <code class="filename">pugiconfig.hpp</code>:
+        </p>
+<pre class="programlisting"><span class="preprocessor">#ifdef</span> <span class="identifier">_DLL</span>
+<span class="preprocessor">#define</span> <span class="identifier">PUGIXML_API</span> <span class="identifier">__declspec</span><span class="special">(</span><span class="identifier">dllexport</span><span class="special">)</span>
+<span class="preprocessor">#else</span>
+<span class="preprocessor">#define</span> <span class="identifier">PUGIXML_API</span> <span class="identifier">__declspec</span><span class="special">(</span><span class="identifier">dllimport</span><span class="special">)</span>
+<span class="preprocessor">#endif</span>
+</pre>
+<div class="caution"><table border="0" summary="Caution">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="../images/caution.png"></td>
+<th align="left">Caution</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+            If you're using STL-related functions, you should use the shared runtime
+            library to ensure that a single heap is used for STL allocations in your
+            application and in pugixml; in MSVC, this means selecting the 'Multithreaded
+            DLL' or 'Multithreaded Debug DLL' to 'Runtime library' property (/MD
+            or /MDd linker switch). You should also make sure that your runtime library
+            choice is consistent between different projects.
+          </p></td></tr>
+</table></div>
+</div>
+<a name="PUGIXML_HEADER_ONLY"></a><div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="manual.install.building.header"></a><a class="link" href="install.html#manual.install.building.header" title="Using pugixml in header-only mode"> Using pugixml in header-only
+        mode</a>
+</h4></div></div></div>
+<p>
+          It's possible to use pugixml in header-only mode. This means that all source
+          code for pugixml will be included in every translation unit that includes
+          <code class="filename">pugixml.hpp</code>. This is how most of Boost and STL libraries work.
+        </p>
+<p>
+          Note that there are advantages and drawbacks of this approach. Header mode
+          may improve tree traversal/modification performance (because many simple
+          functions will be inlined), if your compiler toolchain does not support
+          link-time optimization, or if you have it turned off (with link-time optimization
+          the performance should be similar to non-header mode). However, since compiler
+          now has to compile pugixml source once for each translation unit that includes
+          it, compilation times may increase noticeably. If you want to use pugixml
+          in header mode but do not need XPath support, you can consider disabling
+          it by using <a class="link" href="install.html#PUGIXML_NO_XPATH">PUGIXML_NO_XPATH</a> define
+          to improve compilation time.
+        </p>
+<p>
+          Enabling header-only mode is a two-step process:
+        </p>
+<div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+              You have to define <code class="computeroutput"><span class="identifier">PUGIXML_HEADER_ONLY</span></code>
+            </li>
+<li class="listitem">
+              You have to include <code class="filename">pugixml.cpp</code> whenever you include pugixml.hpp
+            </li>
+</ol></div>
+<p>
+          Both of these are best done via <code class="filename">pugiconfig.hpp</code> like this:
+        </p>
+<pre class="programlisting"><span class="preprocessor">#define</span> <span class="identifier">PUGIXML_HEADER_ONLY</span>
+<span class="preprocessor">#include</span> <span class="string">"pugixml.cpp"</span>
+</pre>
+<p>
+          Note that it is safe to compile <code class="filename">pugixml.cpp</code> if <code class="computeroutput"><span class="identifier">PUGIXML_HEADER_ONLY</span></code>
+          is defined - so if you want to i.e. use header-only mode only in Release
+          configuration, you can include pugixml.cpp in your project (see <a class="xref" href="install.html#manual.install.building.embed" title="Building pugixml as a part of another static library/executable"> Building pugixml as
+        a part of another static library/executable</a>),
+          and conditionally enable header-only mode in <code class="filename">pugiconfig.hpp</code>, i.e.:
+        </p>
+<pre class="programlisting"><span class="preprocessor">#ifndef</span> <span class="identifier">_DEBUG</span>
+    <span class="preprocessor">#define</span> <span class="identifier">PUGIXML_HEADER_ONLY</span>
+    <span class="preprocessor">#include</span> <span class="string">"pugixml.cpp"</span>
+<span class="preprocessor">#endif</span>
+</pre>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h4 class="title">
+<a name="manual.install.building.config"></a><a class="link" href="install.html#manual.install.building.config" title="Additional configuration options"> Additional configuration
+        options</a>
+</h4></div></div></div>
+<p>
+          pugixml uses several defines to control the compilation process. There
+          are two ways to define them: either put the needed definitions to <code class="filename">pugiconfig.hpp</code> (it
+          has some examples that are commented out) or provide them via compiler
+          command-line. Consistency is important: the definitions should match in
+          all source files that include <code class="filename">pugixml.hpp</code> (including pugixml sources) throughout
+          the application. Adding defines to <code class="filename">pugiconfig.hpp</code> lets you guarantee this,
+          unless your macro definition is wrapped in preprocessor <code class="computeroutput"><span class="preprocessor">#if</span></code>/<code class="computeroutput"><span class="preprocessor">#ifdef</span></code> directive and this directive
+          is not consistent. <code class="filename">pugiconfig.hpp</code> will never contain anything but comments,
+          which means that when upgrading to a new version, you can safely leave
+          your modified version intact.
+        </p>
+<p>
+          <a name="PUGIXML_WCHAR_MODE"></a><code class="literal">PUGIXML_WCHAR_MODE</code> define toggles
+          between UTF-8 style interface (the in-memory text encoding is assumed to
+          be UTF-8, most functions use <code class="computeroutput"><span class="keyword">char</span></code>
+          as character type) and UTF-16/32 style interface (the in-memory text encoding
+          is assumed to be UTF-16/32, depending on <code class="computeroutput"><span class="keyword">wchar_t</span></code>
+          size, most functions use <code class="computeroutput"><span class="keyword">wchar_t</span></code>
+          as character type). See <a class="xref" href="dom.html#manual.dom.unicode" title="Unicode interface"> Unicode interface</a> for more details.
+        </p>
+<p>
+          <a name="PUGIXML_NO_XPATH"></a><code class="literal">PUGIXML_NO_XPATH</code> define disables XPath.
+          Both XPath interfaces and XPath implementation are excluded from compilation.
+          This option is provided in case you do not need XPath functionality and
+          need to save code space.
+        </p>
+<p>
+          <a name="PUGIXML_NO_STL"></a><code class="literal">PUGIXML_NO_STL</code> define disables use of
+          STL in pugixml. The functions that operate on STL types are no longer present
+          (i.e. load/save via iostream) if this macro is defined. This option is
+          provided in case your target platform does not have a standard-compliant
+          STL implementation.
+        </p>
+<p>
+          <a name="PUGIXML_NO_EXCEPTIONS"></a><code class="literal">PUGIXML_NO_EXCEPTIONS</code> define disables
+          use of exceptions in pugixml. This option is provided in case your target
+          platform does not have exception handling capabilities.
+        </p>
+<p>
+          <a name="PUGIXML_API"></a><code class="literal">PUGIXML_API</code>, <a name="PUGIXML_CLASS"></a><code class="literal">PUGIXML_CLASS</code>
+          and <a name="PUGIXML_FUNCTION"></a><code class="literal">PUGIXML_FUNCTION</code> defines let you
+          specify custom attributes (i.e. declspec or calling conventions) for pugixml
+          classes and non-member functions. In absence of <code class="computeroutput"><span class="identifier">PUGIXML_CLASS</span></code>
+          or <code class="computeroutput"><span class="identifier">PUGIXML_FUNCTION</span></code> definitions,
+          <code class="computeroutput"><span class="identifier">PUGIXML_API</span></code> definition
+          is used instead. For example, to specify fixed calling convention, you
+          can define <code class="computeroutput"><span class="identifier">PUGIXML_FUNCTION</span></code>
+          to i.e. <code class="computeroutput"><span class="identifier">__fastcall</span></code>. Another
+          example is DLL import/export attributes in MSVC (see <a class="xref" href="install.html#manual.install.building.shared" title="Building pugixml as a standalone shared library"> Building pugixml as
+        a standalone shared library</a>).
+        </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+            In that example <code class="computeroutput"><span class="identifier">PUGIXML_API</span></code>
+            is inconsistent between several source files; this is an exception to
+            the consistency rule.
+          </p></td></tr>
+</table></div>
+<p>
+          <a name="PUGIXML_MEMORY_PAGE_SIZE"></a><code class="literal">PUGIXML_MEMORY_PAGE_SIZE</code>, <a name="PUGIXML_MEMORY_OUTPUT_STACK"></a><code class="literal">PUGIXML_MEMORY_OUTPUT_STACK</code>
+          and <a name="PUGIXML_MEMORY_XPATH_PAGE_SIZE"></a><code class="literal">PUGIXML_MEMORY_XPATH_PAGE_SIZE</code>
+          can be used to customize certain important sizes to optimize memory usage
+          for the application-specific patterns. For details see <a class="xref" href="dom.html#manual.dom.memory.tuning" title="Memory consumption tuning"> Memory consumption tuning</a>.
+        </p>
+</div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.install.portability"></a><a class="link" href="install.html#manual.install.portability" title="Portability"> Portability</a>
+</h3></div></div></div>
+<p>
+        pugixml is written in standard-compliant C++ with some compiler-specific
+        workarounds where appropriate. pugixml is compatible with the upcoming C++0x
+        standard (verified using GCC 4.5). Each version is tested with a unit test
+        suite (with code coverage about 99%) on the following platforms:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            Microsoft Windows:
+            <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                  Borland C++ Compiler 5.82
+                </li>
+<li class="listitem">
+                  Digital Mars C++ Compiler 8.51
+                </li>
+<li class="listitem">
+                  Intel C++ Compiler 8.0, 9.0 x86/x64, 10.0 x86/x64, 11.0 x86/x64
+                </li>
+<li class="listitem">
+                  Metrowerks CodeWarrior 8.0
+                </li>
+<li class="listitem">
+                  Microsoft Visual C++ 6.0, 7.0 (2002), 7.1 (2003), 8.0 (2005) x86/x64,
+                  9.0 (2008) x86/x64, 10.0 (2010) x86/x64, 11.0 x86/x64/ARM and some
+                  CLR versions
+                </li>
+<li class="listitem">
+                  MinGW (GCC) 3.4, 4.4, 4.5, 4.6 x64
+                </li>
+</ul></div>
+          </li>
+<li class="listitem">
+            Linux (GCC 4.4.3 x86/x64)
+          </li>
+<li class="listitem">
+            FreeBSD (GCC 4.2.1 x86/x64)
+          </li>
+<li class="listitem">
+            Apple MacOSX (GCC 4.0.1 x86/x64/PowerPC)
+          </li>
+<li class="listitem">
+            Sun Solaris (sunCC x86/x64)
+          </li>
+<li class="listitem">
+            Microsoft Xbox 360
+          </li>
+<li class="listitem">
+            Nintendo Wii (Metrowerks CodeWarrior 4.1)
+          </li>
+<li class="listitem">
+            Sony Playstation Portable (GCC 3.4.2)
+          </li>
+<li class="listitem">
+            Sony Playstation 3 (GCC 4.1.1, SNC 310.1)
+          </li>
+<li class="listitem">
+            Various portable platforms (Android NDK, BlackBerry NDK, Samsung bada,
+            Windows CE)
+          </li>
+</ul></div>
+</div>
+<div class="footnotes">
+<br><hr width="100" align="left">
+<div class="footnote"><p><sup>[<a name="ftn.trademarks" href="#trademarks" class="para">1</a>] </sup>All trademarks used are properties of their respective
+          owners.</p></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2012 Arseny Kapoulkine<p>
+        Distributed under the MIT License
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<b>Installation</b> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="../manual.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="dom.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+</body>
+</html>
diff --git a/tools/intergen/third_party/pugixml/docs/manual/loading.html b/tools/intergen/third_party/pugixml/docs/manual/loading.html
new file mode 100644
index 0000000000..a26b62c1b5
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/manual/loading.html
@@ -0,0 +1,873 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Loading document</title>
+<link rel="stylesheet" href="../pugixml.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../manual.html" title="pugixml 1.2">
+<link rel="up" href="../manual.html" title="pugixml 1.2">
+<link rel="prev" href="dom.html" title="Document object model">
+<link rel="next" href="access.html" title="Accessing document data">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <b>Loading</b> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="dom.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="access.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+<hr>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="manual.loading"></a><a class="link" href="loading.html" title="Loading document"> Loading document</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="loading.html#manual.loading.file"> Loading document from file</a></span></dt>
+<dt><span class="section"><a href="loading.html#manual.loading.memory"> Loading document from memory</a></span></dt>
+<dt><span class="section"><a href="loading.html#manual.loading.stream"> Loading document from C++ IOstreams</a></span></dt>
+<dt><span class="section"><a href="loading.html#manual.loading.errors"> Handling parsing errors</a></span></dt>
+<dt><span class="section"><a href="loading.html#manual.loading.options"> Parsing options</a></span></dt>
+<dt><span class="section"><a href="loading.html#manual.loading.encoding"> Encodings</a></span></dt>
+<dt><span class="section"><a href="loading.html#manual.loading.w3c"> Conformance to W3C specification</a></span></dt>
+</dl></div>
+<p>
+      pugixml provides several functions for loading XML data from various places
+      - files, C++ iostreams, memory buffers. All functions use an extremely fast
+      non-validating parser. This parser is not fully W3C conformant - it can load
+      any valid XML document, but does not perform some well-formedness checks. While
+      considerable effort is made to reject invalid XML documents, some validation
+      is not performed for performance reasons. Also some XML transformations (i.e.
+      EOL handling or attribute value normalization) can impact parsing speed and
+      thus can be disabled. However for vast majority of XML documents there is no
+      performance difference between different parsing options. Parsing options also
+      control whether certain XML nodes are parsed; see <a class="xref" href="loading.html#manual.loading.options" title="Parsing options"> Parsing options</a> for
+      more information.
+    </p>
+<p>
+      XML data is always converted to internal character format (see <a class="xref" href="dom.html#manual.dom.unicode" title="Unicode interface"> Unicode interface</a>)
+      before parsing. pugixml supports all popular Unicode encodings (UTF-8, UTF-16
+      (big and little endian), UTF-32 (big and little endian); UCS-2 is naturally
+      supported since it's a strict subset of UTF-16) and handles all encoding conversions
+      automatically. Unless explicit encoding is specified, loading functions perform
+      automatic encoding detection based on first few characters of XML data, so
+      in almost all cases you do not have to specify document encoding. Encoding
+      conversion is described in more detail in <a class="xref" href="loading.html#manual.loading.encoding" title="Encodings"> Encodings</a>.
+    </p>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.loading.file"></a><a class="link" href="loading.html#manual.loading.file" title="Loading document from file"> Loading document from file</a>
+</h3></div></div></div>
+<a name="xml_document::load_file"></a><a name="xml_document::load_file_wide"></a><p>
+        The most common source of XML data is files; pugixml provides dedicated functions
+        for loading an XML document from file:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_parse_result</span> <span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">load_file</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">path</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">options</span> <span class="special">=</span> <span class="identifier">parse_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span> <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">);</span>
+<span class="identifier">xml_parse_result</span> <span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">load_file</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*</span> <span class="identifier">path</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">options</span> <span class="special">=</span> <span class="identifier">parse_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span> <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">);</span>
+</pre>
+<p>
+        These functions accept the file path as its first argument, and also two
+        optional arguments, which specify parsing options (see <a class="xref" href="loading.html#manual.loading.options" title="Parsing options"> Parsing options</a>)
+        and input data encoding (see <a class="xref" href="loading.html#manual.loading.encoding" title="Encodings"> Encodings</a>). The path has the target
+        operating system format, so it can be a relative or absolute one, it should
+        have the delimiters of the target system, it should have the exact case if
+        the target file system is case-sensitive, etc.
+      </p>
+<p>
+        File path is passed to the system file opening function as is in case of
+        the first function (which accepts <code class="computeroutput"><span class="keyword">const</span>
+        <span class="keyword">char</span><span class="special">*</span> <span class="identifier">path</span></code>); the second function either uses
+        a special file opening function if it is provided by the runtime library
+        or converts the path to UTF-8 and uses the system file opening function.
+      </p>
+<p>
+        <code class="computeroutput"><span class="identifier">load_file</span></code> destroys the existing
+        document tree and then tries to load the new tree from the specified file.
+        The result of the operation is returned in an <a class="link" href="loading.html#xml_parse_result">xml_parse_result</a>
+        object; this object contains the operation status and the related information
+        (i.e. last successfully parsed position in the input file, if parsing fails).
+        See <a class="xref" href="loading.html#manual.loading.errors" title="Handling parsing errors"> Handling parsing errors</a> for error handling details.
+      </p>
+<p>
+        This is an example of loading XML document from file (<a href="../samples/load_file.cpp" target="_top">samples/load_file.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_document</span> <span class="identifier">doc</span><span class="special">;</span>
+
+<span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_parse_result</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">load_file</span><span class="special">(</span><span class="string">"tree.xml"</span><span class="special">);</span>
+
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Load result: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">result</span><span class="special">.</span><span class="identifier">description</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">", mesh name: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"mesh"</span><span class="special">).</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"name"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.loading.memory"></a><a class="link" href="loading.html#manual.loading.memory" title="Loading document from memory"> Loading document from memory</a>
+</h3></div></div></div>
+<a name="xml_document::load_buffer"></a><a name="xml_document::load_buffer_inplace"></a><a name="xml_document::load_buffer_inplace_own"></a><p>
+        Sometimes XML data should be loaded from some other source than a file, i.e.
+        HTTP URL; also you may want to load XML data from file using non-standard
+        functions, i.e. to use your virtual file system facilities or to load XML
+        from gzip-compressed files. All these scenarios require loading document
+        from memory. First you should prepare a contiguous memory block with all
+        XML data; then you have to invoke one of buffer loading functions. These
+        functions will handle the necessary encoding conversions, if any, and then
+        will parse the data into the corresponding XML tree. There are several buffer
+        loading functions, which differ in the behavior and thus in performance/memory
+        usage:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_parse_result</span> <span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">load_buffer</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">contents</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">options</span> <span class="special">=</span> <span class="identifier">parse_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span> <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">);</span>
+<span class="identifier">xml_parse_result</span> <span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">load_buffer_inplace</span><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">contents</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">options</span> <span class="special">=</span> <span class="identifier">parse_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span> <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">);</span>
+<span class="identifier">xml_parse_result</span> <span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">load_buffer_inplace_own</span><span class="special">(</span><span class="keyword">void</span><span class="special">*</span> <span class="identifier">contents</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">options</span> <span class="special">=</span> <span class="identifier">parse_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span> <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">);</span>
+</pre>
+<p>
+        All functions accept the buffer which is represented by a pointer to XML
+        data, <code class="computeroutput"><span class="identifier">contents</span></code>, and data
+        size in bytes. Also there are two optional arguments, which specify parsing
+        options (see <a class="xref" href="loading.html#manual.loading.options" title="Parsing options"> Parsing options</a>) and input data encoding (see <a class="xref" href="loading.html#manual.loading.encoding" title="Encodings"> Encodings</a>).
+        The buffer does not have to be zero-terminated.
+      </p>
+<p>
+        <code class="computeroutput"><span class="identifier">load_buffer</span></code> function works
+        with immutable buffer - it does not ever modify the buffer. Because of this
+        restriction it has to create a private buffer and copy XML data to it before
+        parsing (applying encoding conversions if necessary). This copy operation
+        carries a performance penalty, so inplace functions are provided - <code class="computeroutput"><span class="identifier">load_buffer_inplace</span></code> and <code class="computeroutput"><span class="identifier">load_buffer_inplace_own</span></code>
+        store the document data in the buffer, modifying it in the process. In order
+        for the document to stay valid, you have to make sure that the buffer's lifetime
+        exceeds that of the tree if you're using inplace functions. In addition to
+        that, <code class="computeroutput"><span class="identifier">load_buffer_inplace</span></code>
+        does not assume ownership of the buffer, so you'll have to destroy it yourself;
+        <code class="computeroutput"><span class="identifier">load_buffer_inplace_own</span></code> assumes
+        ownership of the buffer and destroys it once it is not needed. This means
+        that if you're using <code class="computeroutput"><span class="identifier">load_buffer_inplace_own</span></code>,
+        you have to allocate memory with pugixml allocation function (you can get
+        it via <a class="link" href="dom.html#get_memory_allocation_function">get_memory_allocation_function</a>).
+      </p>
+<p>
+        The best way from the performance/memory point of view is to load document
+        using <code class="computeroutput"><span class="identifier">load_buffer_inplace_own</span></code>;
+        this function has maximum control of the buffer with XML data so it is able
+        to avoid redundant copies and reduce peak memory usage while parsing. This
+        is the recommended function if you have to load the document from memory
+        and performance is critical.
+      </p>
+<a name="xml_document::load_string"></a><p>
+        There is also a simple helper function for cases when you want to load the
+        XML document from null-terminated character string:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_parse_result</span> <span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">load</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">contents</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">options</span> <span class="special">=</span> <span class="identifier">parse_default</span><span class="special">);</span>
+</pre>
+<p>
+        It is equivalent to calling <code class="computeroutput"><span class="identifier">load_buffer</span></code>
+        with <code class="computeroutput"><span class="identifier">size</span></code> being either <code class="computeroutput"><span class="identifier">strlen</span><span class="special">(</span><span class="identifier">contents</span><span class="special">)</span></code>
+        or <code class="computeroutput"><span class="identifier">wcslen</span><span class="special">(</span><span class="identifier">contents</span><span class="special">)</span> <span class="special">*</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="keyword">wchar_t</span><span class="special">)</span></code>,
+        depending on the character type. This function assumes native encoding for
+        input data, so it does not do any encoding conversion. In general, this function
+        is fine for loading small documents from string literals, but has more overhead
+        and less functionality than the buffer loading functions.
+      </p>
+<p>
+        This is an example of loading XML document from memory using different functions
+        (<a href="../samples/load_memory.cpp" target="_top">samples/load_memory.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="keyword">char</span> <span class="identifier">source</span><span class="special">[]</span> <span class="special">=</span> <span class="string">"&lt;mesh name='sphere'&gt;&lt;bounds&gt;0 0 1 1&lt;/bounds&gt;&lt;/mesh&gt;"</span><span class="special">;</span>
+<span class="identifier">size_t</span> <span class="identifier">size</span> <span class="special">=</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">source</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// You can use load_buffer to load document from immutable memory block:
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_parse_result</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">load_buffer</span><span class="special">(</span><span class="identifier">source</span><span class="special">,</span> <span class="identifier">size</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// You can use load_buffer_inplace to load document from mutable memory block; the block's lifetime must exceed that of document
+</span><span class="keyword">char</span><span class="special">*</span> <span class="identifier">buffer</span> <span class="special">=</span> <span class="keyword">new</span> <span class="keyword">char</span><span class="special">[</span><span class="identifier">size</span><span class="special">];</span>
+<span class="identifier">memcpy</span><span class="special">(</span><span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">source</span><span class="special">,</span> <span class="identifier">size</span><span class="special">);</span>
+
+<span class="comment">// The block can be allocated by any method; the block is modified during parsing
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_parse_result</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">load_buffer_inplace</span><span class="special">(</span><span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">size</span><span class="special">);</span>
+
+<span class="comment">// You have to destroy the block yourself after the document is no longer used
+</span><span class="keyword">delete</span><span class="special">[]</span> <span class="identifier">buffer</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// You can use load_buffer_inplace_own to load document from mutable memory block and to pass the ownership of this block
+</span><span class="comment">// The block has to be allocated via pugixml allocation function - using i.e. operator new here is incorrect
+</span><span class="keyword">char</span><span class="special">*</span> <span class="identifier">buffer</span> <span class="special">=</span> <span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">char</span><span class="special">*&gt;(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">get_memory_allocation_function</span><span class="special">()(</span><span class="identifier">size</span><span class="special">));</span>
+<span class="identifier">memcpy</span><span class="special">(</span><span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">source</span><span class="special">,</span> <span class="identifier">size</span><span class="special">);</span>
+
+<span class="comment">// The block will be deleted by the document
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_parse_result</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">load_buffer_inplace_own</span><span class="special">(</span><span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">size</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// You can use load to load document from null-terminated strings, for example literals:
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_parse_result</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">load</span><span class="special">(</span><span class="string">"&lt;mesh name='sphere'&gt;&lt;bounds&gt;0 0 1 1&lt;/bounds&gt;&lt;/mesh&gt;"</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.loading.stream"></a><a class="link" href="loading.html#manual.loading.stream" title="Loading document from C++ IOstreams"> Loading document from C++ IOstreams</a>
+</h3></div></div></div>
+<a name="xml_document::load_stream"></a><p>
+        To enhance interoperability, pugixml provides functions for loading document
+        from any object which implements C++ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span></code>
+        interface. This allows you to load documents from any standard C++ stream
+        (i.e. file stream) or any third-party compliant implementation (i.e. Boost
+        Iostreams). There are two functions, one works with narrow character streams,
+        another handles wide character ones:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_parse_result</span> <span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">load</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span><span class="special">&amp;</span> <span class="identifier">stream</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">options</span> <span class="special">=</span> <span class="identifier">parse_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span> <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">);</span>
+<span class="identifier">xml_parse_result</span> <span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">load</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">wistream</span><span class="special">&amp;</span> <span class="identifier">stream</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">options</span> <span class="special">=</span> <span class="identifier">parse_default</span><span class="special">);</span>
+</pre>
+<p>
+        <code class="computeroutput"><span class="identifier">load</span></code> with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span></code>
+        argument loads the document from stream from the current read position to
+        the end, treating the stream contents as a byte stream of the specified encoding
+        (with encoding autodetection as necessary). Thus calling <code class="computeroutput"><span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">load</span></code>
+        on an opened <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ifstream</span></code> object is equivalent to calling
+        <code class="computeroutput"><span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">load_file</span></code>.
+      </p>
+<p>
+        <code class="computeroutput"><span class="identifier">load</span></code> with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">wstream</span></code>
+        argument treats the stream contents as a wide character stream (encoding
+        is always <a class="link" href="loading.html#encoding_wchar">encoding_wchar</a>). Because
+        of this, using <code class="computeroutput"><span class="identifier">load</span></code> with
+        wide character streams requires careful (usually platform-specific) stream
+        setup (i.e. using the <code class="computeroutput"><span class="identifier">imbue</span></code>
+        function). Generally use of wide streams is discouraged, however it provides
+        you the ability to load documents from non-Unicode encodings, i.e. you can
+        load Shift-JIS encoded data if you set the correct locale.
+      </p>
+<p>
+        This is a simple example of loading XML document from file using streams
+        (<a href="../samples/load_stream.cpp" target="_top">samples/load_stream.cpp</a>); read
+        the sample code for more complex examples involving wide streams and locales:
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ifstream</span> <span class="identifier">stream</span><span class="special">(</span><span class="string">"weekly-utf-8.xml"</span><span class="special">);</span>
+<span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_parse_result</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">load</span><span class="special">(</span><span class="identifier">stream</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.loading.errors"></a><a class="link" href="loading.html#manual.loading.errors" title="Handling parsing errors"> Handling parsing errors</a>
+</h3></div></div></div>
+<a name="xml_parse_result"></a><p>
+        All document loading functions return the parsing result via <code class="computeroutput"><span class="identifier">xml_parse_result</span></code> object. It contains parsing
+        status, the offset of last successfully parsed character from the beginning
+        of the source stream, and the encoding of the source stream:
+      </p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">xml_parse_result</span>
+<span class="special">{</span>
+    <span class="identifier">xml_parse_status</span> <span class="identifier">status</span><span class="special">;</span>
+    <span class="identifier">ptrdiff_t</span> <span class="identifier">offset</span><span class="special">;</span>
+    <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span><span class="special">;</span>
+
+    <span class="keyword">operator</span> <span class="keyword">bool</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+    <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">description</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="special">};</span>
+</pre>
+<a name="xml_parse_status"></a><a name="xml_parse_result::status"></a><p>
+        Parsing status is represented as the <code class="computeroutput"><span class="identifier">xml_parse_status</span></code>
+        enumeration and can be one of the following:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            <a name="status_ok"></a><code class="literal">status_ok</code> means that no error was encountered
+            during parsing; the source stream represents the valid XML document which
+            was fully parsed and converted to a tree. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="status_file_not_found"></a><code class="literal">status_file_not_found</code> is only
+            returned by <code class="computeroutput"><span class="identifier">load_file</span></code>
+            function and means that file could not be opened.
+          </li>
+<li class="listitem">
+            <a name="status_io_error"></a><code class="literal">status_io_error</code> is returned by <code class="computeroutput"><span class="identifier">load_file</span></code> function and by <code class="computeroutput"><span class="identifier">load</span></code> functions with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span></code>/<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">wstream</span></code> arguments; it means that some
+            I/O error has occurred during reading the file/stream.
+          </li>
+<li class="listitem">
+            <a name="status_out_of_memory"></a><code class="literal">status_out_of_memory</code> means that
+            there was not enough memory during some allocation; any allocation failure
+            during parsing results in this error.
+          </li>
+<li class="listitem">
+            <a name="status_internal_error"></a><code class="literal">status_internal_error</code> means that
+            something went horribly wrong; currently this error does not occur <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="status_unrecognized_tag"></a><code class="literal">status_unrecognized_tag</code> means
+            that parsing stopped due to a tag with either an empty name or a name
+            which starts with incorrect character, such as <code class="literal">#</code>.
+          </li>
+<li class="listitem">
+            <a name="status_bad_pi"></a><code class="literal">status_bad_pi</code> means that parsing stopped
+            due to incorrect document declaration/processing instruction
+          </li>
+<li class="listitem">
+            <a name="status_bad_comment"></a><code class="literal">status_bad_comment</code>, <a name="status_bad_cdata"></a><code class="literal">status_bad_cdata</code>,
+            <a name="status_bad_doctype"></a><code class="literal">status_bad_doctype</code> and <a name="status_bad_pcdata"></a><code class="literal">status_bad_pcdata</code>
+            mean that parsing stopped due to the invalid construct of the respective
+            type
+          </li>
+<li class="listitem">
+            <a name="status_bad_start_element"></a><code class="literal">status_bad_start_element</code> means
+            that parsing stopped because starting tag either had no closing <code class="computeroutput"><span class="special">&gt;</span></code> symbol or contained some incorrect
+            symbol
+          </li>
+<li class="listitem">
+            <a name="status_bad_attribute"></a><code class="literal">status_bad_attribute</code> means that
+            parsing stopped because there was an incorrect attribute, such as an
+            attribute without value or with value that is not quoted (note that
+            <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">node</span>
+            <span class="identifier">attr</span><span class="special">=</span><span class="number">1</span><span class="special">&gt;</span></code> is
+            incorrect in XML)
+          </li>
+<li class="listitem">
+            <a name="status_bad_end_element"></a><code class="literal">status_bad_end_element</code> means
+            that parsing stopped because ending tag had incorrect syntax (i.e. extra
+            non-whitespace symbols between tag name and <code class="computeroutput"><span class="special">&gt;</span></code>)
+          </li>
+<li class="listitem">
+            <a name="status_end_element_mismatch"></a><code class="literal">status_end_element_mismatch</code>
+            means that parsing stopped because the closing tag did not match the
+            opening one (i.e. <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">node</span><span class="special">&gt;&lt;/</span><span class="identifier">nedo</span><span class="special">&gt;</span></code>) or because some tag was not closed
+            at all
+          </li>
+</ul></div>
+<a name="xml_parse_result::description"></a><p>
+        <code class="computeroutput"><span class="identifier">description</span><span class="special">()</span></code>
+        member function can be used to convert parsing status to a string; the returned
+        message is always in English, so you'll have to write your own function if
+        you need a localized string. However please note that the exact messages
+        returned by <code class="computeroutput"><span class="identifier">description</span><span class="special">()</span></code>
+        function may change from version to version, so any complex status handling
+        should be based on <code class="computeroutput"><span class="identifier">status</span></code>
+        value. Note that <code class="computeroutput"><span class="identifier">description</span><span class="special">()</span></code> returns a <code class="computeroutput"><span class="keyword">char</span></code>
+        string even in <code class="computeroutput"><span class="identifier">PUGIXML_WCHAR_MODE</span></code>;
+        you'll have to call <a class="link" href="dom.html#as_wide">as_wide</a> to get the <code class="computeroutput"><span class="keyword">wchar_t</span></code> string.
+      </p>
+<p>
+        If parsing failed because the source data was not a valid XML, the resulting
+        tree is not destroyed - despite the fact that load function returns error,
+        you can use the part of the tree that was successfully parsed. Obviously,
+        the last element may have an unexpected name/value; for example, if the attribute
+        value does not end with the necessary quotation mark, like in <code class="literal">&lt;node
+        attr="value&gt;some data&lt;/node&gt;</code> example, the value of
+        attribute <code class="computeroutput"><span class="identifier">attr</span></code> will contain
+        the string <code class="computeroutput"><span class="identifier">value</span><span class="special">&gt;</span><span class="identifier">some</span> <span class="identifier">data</span><span class="special">&lt;/</span><span class="identifier">node</span><span class="special">&gt;</span></code>.
+      </p>
+<a name="xml_parse_result::offset"></a><p>
+        In addition to the status code, parsing result has an <code class="computeroutput"><span class="identifier">offset</span></code>
+        member, which contains the offset of last successfully parsed character if
+        parsing failed because of an error in source data; otherwise <code class="computeroutput"><span class="identifier">offset</span></code> is 0. For parsing efficiency reasons,
+        pugixml does not track the current line during parsing; this offset is in
+        units of <a class="link" href="dom.html#char_t">pugi::char_t</a> (bytes for character
+        mode, wide characters for wide character mode). Many text editors support
+        'Go To Position' feature - you can use it to locate the exact error position.
+        Alternatively, if you're loading the document from memory, you can display
+        the error chunk along with the error description (see the example code below).
+      </p>
+<div class="caution"><table border="0" summary="Caution">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="../images/caution.png"></td>
+<th align="left">Caution</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          Offset is calculated in the XML buffer in native encoding; if encoding
+          conversion is performed during parsing, offset can not be used to reliably
+          track the error position.
+        </p></td></tr>
+</table></div>
+<a name="xml_parse_result::encoding"></a><p>
+        Parsing result also has an <code class="computeroutput"><span class="identifier">encoding</span></code>
+        member, which can be used to check that the source data encoding was correctly
+        guessed. It is equal to the exact encoding used during parsing (i.e. with
+        the exact endianness); see <a class="xref" href="loading.html#manual.loading.encoding" title="Encodings"> Encodings</a> for more information.
+      </p>
+<a name="xml_parse_result::bool"></a><p>
+        Parsing result object can be implicitly converted to <code class="computeroutput"><span class="keyword">bool</span></code>;
+        if you do not want to handle parsing errors thoroughly, you can just check
+        the return value of load functions as if it was a <code class="computeroutput"><span class="keyword">bool</span></code>:
+        <code class="computeroutput"><span class="keyword">if</span> <span class="special">(</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">load_file</span><span class="special">(</span><span class="string">"file.xml"</span><span class="special">))</span> <span class="special">{</span> <span class="special">...</span>
+        <span class="special">}</span> <span class="keyword">else</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span></code>.
+      </p>
+<p>
+        This is an example of handling loading errors (<a href="../samples/load_error_handling.cpp" target="_top">samples/load_error_handling.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_document</span> <span class="identifier">doc</span><span class="special">;</span>
+<span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_parse_result</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">load</span><span class="special">(</span><span class="identifier">source</span><span class="special">);</span>
+
+<span class="keyword">if</span> <span class="special">(</span><span class="identifier">result</span><span class="special">)</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"XML ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">source</span> <span class="special">&lt;&lt;</span> <span class="string">"] parsed without errors, attr value: ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"node"</span><span class="special">).</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"attr"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"]\n\n"</span><span class="special">;</span>
+<span class="keyword">else</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"XML ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">source</span> <span class="special">&lt;&lt;</span> <span class="string">"] parsed with errors, attr value: ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"node"</span><span class="special">).</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"attr"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"]\n"</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Error description: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">result</span><span class="special">.</span><span class="identifier">description</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Error offset: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">result</span><span class="special">.</span><span class="identifier">offset</span> <span class="special">&lt;&lt;</span> <span class="string">" (error at [..."</span> <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">source</span> <span class="special">+</span> <span class="identifier">result</span><span class="special">.</span><span class="identifier">offset</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">"]\n\n"</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.loading.options"></a><a class="link" href="loading.html#manual.loading.options" title="Parsing options"> Parsing options</a>
+</h3></div></div></div>
+<p>
+        All document loading functions accept the optional parameter <code class="computeroutput"><span class="identifier">options</span></code>. This is a bitmask that customizes
+        the parsing process: you can select the node types that are parsed and various
+        transformations that are performed with the XML text. Disabling certain transformations
+        can improve parsing performance for some documents; however, the code for
+        all transformations is very well optimized, and thus the majority of documents
+        won't get any performance benefit. As a rule of thumb, only modify parsing
+        flags if you want to get some nodes in the document that are excluded by
+        default (i.e. declaration or comment nodes).
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          You should use the usual bitwise arithmetics to manipulate the bitmask:
+          to enable a flag, use <code class="computeroutput"><span class="identifier">mask</span> <span class="special">|</span> <span class="identifier">flag</span></code>;
+          to disable a flag, use <code class="computeroutput"><span class="identifier">mask</span> <span class="special">&amp;</span> <span class="special">~</span><span class="identifier">flag</span></code>.
+        </p></td></tr>
+</table></div>
+<p>
+        These flags control the resulting tree contents:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            <a name="parse_declaration"></a><code class="literal">parse_declaration</code> determines if XML
+            document declaration (node with type <a class="link" href="dom.html#node_declaration">node_declaration</a>)
+            is to be put in DOM tree. If this flag is off, it is not put in the tree,
+            but is still parsed and checked for correctness. This flag is <span class="bold"><strong>off</strong></span> by default. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="parse_doctype"></a><code class="literal">parse_doctype</code> determines if XML document
+            type declaration (node with type <a class="link" href="dom.html#node_doctype">node_doctype</a>)
+            is to be put in DOM tree. If this flag is off, it is not put in the tree,
+            but is still parsed and checked for correctness. This flag is <span class="bold"><strong>off</strong></span> by default. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="parse_pi"></a><code class="literal">parse_pi</code> determines if processing instructions
+            (nodes with type <a class="link" href="dom.html#node_pi">node_pi</a>) 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. Note that <code class="computeroutput"><span class="special">&lt;?</span><span class="identifier">xml</span> <span class="special">...?&gt;</span></code>
+            (document declaration) is not considered to be a PI. This flag is <span class="bold"><strong>off</strong></span> by default. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="parse_comments"></a><code class="literal">parse_comments</code> determines if comments
+            (nodes with type <a class="link" href="dom.html#node_comment">node_comment</a>) 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. This flag is <span class="bold"><strong>off</strong></span> by default. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="parse_cdata"></a><code class="literal">parse_cdata</code> determines if CDATA sections
+            (nodes with type <a class="link" href="dom.html#node_cdata">node_cdata</a>) 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. This flag is <span class="bold"><strong>on</strong></span> by default. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="parse_ws_pcdata"></a><code class="literal">parse_ws_pcdata</code> determines if PCDATA
+            nodes (nodes with type <a class="link" href="dom.html#node_pcdata">node_pcdata</a>)
+            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 <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">node</span><span class="special">&gt;</span> <span class="special">&lt;</span><span class="identifier">a</span><span class="special">/&gt;</span> <span class="special">&lt;/</span><span class="identifier">node</span><span class="special">&gt;</span></code>, <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">node</span><span class="special">&gt;</span></code>
+            element will have three children when <code class="computeroutput"><span class="identifier">parse_ws_pcdata</span></code>
+            is set (child with type <a class="link" href="dom.html#node_pcdata">node_pcdata</a>
+            and value <code class="computeroutput"><span class="string">" "</span></code>,
+            child with type <a class="link" href="dom.html#node_element">node_element</a> and
+            name <code class="computeroutput"><span class="string">"a"</span></code>, and another
+            child with type <a class="link" href="dom.html#node_pcdata">node_pcdata</a> and value
+            <code class="computeroutput"><span class="string">" "</span></code>), and only
+            one child when <code class="computeroutput"><span class="identifier">parse_ws_pcdata</span></code>
+            is not set. This flag is <span class="bold"><strong>off</strong></span> by default.
+            <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="parse_ws_pcdata_single"></a><code class="literal">parse_ws_pcdata_single</code> determines
+            if whitespace-only PCDATA nodes that have no sibling nodes are to be
+            put in DOM tree. In some cases application needs to parse the whitespace-only
+            contents of nodes, i.e. <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">node</span><span class="special">&gt;</span>
+            <span class="special">&lt;/</span><span class="identifier">node</span><span class="special">&gt;</span></code>, but is not interested in whitespace
+            markup elsewhere. It is possible to use <a class="link" href="loading.html#parse_ws_pcdata">parse_ws_pcdata</a>
+            flag in this case, but it results in excessive allocations and complicates
+            document processing in some cases; this flag is intended to avoid that.
+            As an example, after parsing XML string <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">node</span><span class="special">&gt;</span>
+            <span class="special">&lt;</span><span class="identifier">a</span><span class="special">&gt;</span> <span class="special">&lt;/</span><span class="identifier">a</span><span class="special">&gt;</span> <span class="special">&lt;/</span><span class="identifier">node</span><span class="special">&gt;</span></code> with <code class="computeroutput"><span class="identifier">parse_ws_pcdata_single</span></code>
+            flag set, <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">node</span><span class="special">&gt;</span></code> element will have one child <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">a</span><span class="special">&gt;</span></code>, and <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">a</span><span class="special">&gt;</span></code>
+            element will have one child with type <a class="link" href="dom.html#node_pcdata">node_pcdata</a>
+            and value <code class="computeroutput"><span class="string">" "</span></code>.
+            This flag has no effect if <a class="link" href="loading.html#parse_ws_pcdata">parse_ws_pcdata</a>
+            is enabled. This flag is <span class="bold"><strong>off</strong></span> by default.
+          </li>
+</ul></div>
+<p>
+        These flags control the transformation of tree element contents:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            <a name="parse_escapes"></a><code class="literal">parse_escapes</code> determines if character
+            and entity references are to be expanded during the parsing process.
+            Character references have the form <code class="literal">&amp;#...;</code> or
+            <code class="literal">&amp;#x...;</code> (<code class="literal">...</code> is Unicode numeric
+            representation of character in either decimal (<code class="literal">&amp;#...;</code>)
+            or hexadecimal (<code class="literal">&amp;#x...;</code>) form), entity references
+            are <code class="literal">&amp;lt;</code>, <code class="literal">&amp;gt;</code>, <code class="literal">&amp;amp;</code>,
+            <code class="literal">&amp;apos;</code> and <code class="literal">&amp;quot;</code> (note
+            that as pugixml does not handle DTD, the only allowed entities are predefined
+            ones). If character/entity reference can not be expanded, it is left
+            as is, so you can do additional processing later. Reference expansion
+            is performed on attribute values and PCDATA content. This flag is <span class="bold"><strong>on</strong></span> by default. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="parse_eol"></a><code class="literal">parse_eol</code> determines if EOL handling (that
+            is, replacing sequences <code class="computeroutput"><span class="number">0x0d</span> <span class="number">0x0a</span></code> by a single <code class="computeroutput"><span class="number">0x0a</span></code>
+            character, and replacing all standalone <code class="computeroutput"><span class="number">0x0d</span></code>
+            characters by <code class="computeroutput"><span class="number">0x0a</span></code>) is to
+            be performed on input data (that is, comments contents, PCDATA/CDATA
+            contents and attribute values). This flag is <span class="bold"><strong>on</strong></span>
+            by default. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="parse_wconv_attribute"></a><code class="literal">parse_wconv_attribute</code> determines
+            if attribute value normalization should be performed for all attributes.
+            This means, that whitespace characters (new line, tab and space) are
+            replaced with space (<code class="computeroutput"><span class="char">' '</span></code>).
+            New line characters are always treated as if <a class="link" href="loading.html#parse_eol">parse_eol</a>
+            is set, i.e. <code class="computeroutput"><span class="special">\</span><span class="identifier">r</span><span class="special">\</span><span class="identifier">n</span></code>
+            is converted to a single space. This flag is <span class="bold"><strong>on</strong></span>
+            by default. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="parse_wnorm_attribute"></a><code class="literal">parse_wnorm_attribute</code> determines
+            if extended attribute value normalization should be performed for all
+            attributes. This means, that after attribute values are normalized as
+            if <a class="link" href="loading.html#parse_wconv_attribute">parse_wconv_attribute</a>
+            was set, leading and trailing space characters are removed, and all sequences
+            of space characters are replaced by a single space character. <a class="link" href="loading.html#parse_wconv_attribute">parse_wconv_attribute</a>
+            has no effect if this flag is on. This flag is <span class="bold"><strong>off</strong></span>
+            by default.
+          </li>
+</ul></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          <code class="computeroutput"><span class="identifier">parse_wconv_attribute</span></code> option
+          performs transformations that are required by W3C specification for attributes
+          that are declared as <code class="literal">CDATA</code>; <a class="link" href="loading.html#parse_wnorm_attribute">parse_wnorm_attribute</a>
+          performs transformations required for <code class="literal">NMTOKENS</code> attributes.
+          In the absence of document type declaration all attributes should behave
+          as if they are declared as <code class="literal">CDATA</code>, thus <a class="link" href="loading.html#parse_wconv_attribute">parse_wconv_attribute</a>
+          is the default option.
+        </p></td></tr>
+</table></div>
+<p>
+        Additionally there are three predefined option masks:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            <a name="parse_minimal"></a><code class="literal">parse_minimal</code> has all options turned
+            off. This option mask means that pugixml does not add declaration nodes,
+            document type declaration nodes, PI nodes, CDATA sections and comments
+            to the resulting tree and does not perform any conversion for input data,
+            so theoretically it is the fastest mode. However, as mentioned above,
+            in practice <a class="link" href="loading.html#parse_default">parse_default</a> is usually
+            equally fast. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="parse_default"></a><code class="literal">parse_default</code> is the default set of flags,
+            i.e. it has all options set to their default values. 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. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="parse_full"></a><code class="literal">parse_full</code> is the set of flags which adds
+            nodes of all types to the resulting tree and performs default conversions
+            for input data. It includes parsing CDATA sections, comments, PI nodes,
+            document declaration node and document type declaration node, 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
+            in this mode.
+          </li>
+</ul></div>
+<p>
+        This is an example of using different parsing options (<a href="../samples/load_options.cpp" target="_top">samples/load_options.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">source</span> <span class="special">=</span> <span class="string">"&lt;!--comment--&gt;&lt;node&gt;&amp;lt;&lt;/node&gt;"</span><span class="special">;</span>
+
+<span class="comment">// Parsing with default options; note that comment node is not added to the tree, and entity reference &amp;lt; is expanded
+</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">load</span><span class="special">(</span><span class="identifier">source</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"First node value: ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">first_child</span><span class="special">().</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"], node child value: ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child_value</span><span class="special">(</span><span class="string">"node"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">"]\n"</span><span class="special">;</span>
+
+<span class="comment">// Parsing with additional parse_comments option; comment node is now added to the tree
+</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">load</span><span class="special">(</span><span class="identifier">source</span><span class="special">,</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">parse_default</span> <span class="special">|</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">parse_comments</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"First node value: ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">first_child</span><span class="special">().</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"], node child value: ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child_value</span><span class="special">(</span><span class="string">"node"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">"]\n"</span><span class="special">;</span>
+
+<span class="comment">// Parsing with additional parse_comments option and without the (default) parse_escapes option; &amp;lt; is not expanded
+</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">load</span><span class="special">(</span><span class="identifier">source</span><span class="special">,</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">parse_default</span> <span class="special">|</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">parse_comments</span><span class="special">)</span> <span class="special">&amp;</span> <span class="special">~</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">parse_escapes</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"First node value: ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">first_child</span><span class="special">().</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"], node child value: ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child_value</span><span class="special">(</span><span class="string">"node"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">"]\n"</span><span class="special">;</span>
+
+<span class="comment">// Parsing with minimal option mask; comment node is not added to the tree, and &amp;lt; is not expanded
+</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">load</span><span class="special">(</span><span class="identifier">source</span><span class="special">,</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">parse_minimal</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"First node value: ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">first_child</span><span class="special">().</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"], node child value: ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child_value</span><span class="special">(</span><span class="string">"node"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">"]\n"</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.loading.encoding"></a><a class="link" href="loading.html#manual.loading.encoding" title="Encodings"> Encodings</a>
+</h3></div></div></div>
+<a name="xml_encoding"></a><p>
+        pugixml supports all popular Unicode encodings (UTF-8, UTF-16 (big and little
+        endian), UTF-32 (big and little endian); UCS-2 is naturally supported since
+        it's a strict subset of UTF-16) and handles all encoding conversions. Most
+        loading functions accept the optional parameter <code class="computeroutput"><span class="identifier">encoding</span></code>.
+        This is a value of enumeration type <code class="computeroutput"><span class="identifier">xml_encoding</span></code>,
+        that can have the following values:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            <a name="encoding_auto"></a><code class="literal">encoding_auto</code> means that pugixml will
+            try to guess the encoding based on source XML data. The algorithm is
+            a modified version of the one presented in Appendix F.1 of XML recommendation;
+            it tries to match the first few bytes of input data with the following
+            patterns in strict order: <br><br>
+            <div class="itemizedlist"><ul class="itemizedlist" type="circle">
+<li class="listitem">
+                  If first four bytes match UTF-32 BOM (Byte Order Mark), encoding
+                  is assumed to be UTF-32 with the endianness equal to that of BOM;
+                </li>
+<li class="listitem">
+                  If first two bytes match UTF-16 BOM, encoding is assumed to be
+                  UTF-16 with the endianness equal to that of BOM;
+                </li>
+<li class="listitem">
+                  If first three bytes match UTF-8 BOM, encoding is assumed to be
+                  UTF-8;
+                </li>
+<li class="listitem">
+                  If first four bytes match UTF-32 representation of <code class="literal">&lt;</code>,
+                  encoding is assumed to be UTF-32 with the corresponding endianness;
+                </li>
+<li class="listitem">
+                  If first four bytes match UTF-16 representation of <code class="literal">&lt;?</code>,
+                  encoding is assumed to be UTF-16 with the corresponding endianness;
+                </li>
+<li class="listitem">
+                  If first two bytes match UTF-16 representation of <code class="literal">&lt;</code>,
+                  encoding is assumed to be UTF-16 with the corresponding endianness
+                  (this guess may yield incorrect result, but it's better than UTF-8);
+                </li>
+<li class="listitem">
+                  Otherwise encoding is assumed to be UTF-8. <br><br>
+
+                </li>
+</ul></div>
+          </li>
+<li class="listitem">
+            <a name="encoding_utf8"></a><code class="literal">encoding_utf8</code> corresponds to UTF-8 encoding
+            as defined in the Unicode standard; UTF-8 sequences with length equal
+            to 5 or 6 are not standard and are rejected.
+          </li>
+<li class="listitem">
+            <a name="encoding_utf16_le"></a><code class="literal">encoding_utf16_le</code> corresponds to
+            little-endian UTF-16 encoding as defined in the Unicode standard; surrogate
+            pairs are supported.
+          </li>
+<li class="listitem">
+            <a name="encoding_utf16_be"></a><code class="literal">encoding_utf16_be</code> corresponds to
+            big-endian UTF-16 encoding as defined in the Unicode standard; surrogate
+            pairs are supported.
+          </li>
+<li class="listitem">
+            <a name="encoding_utf16"></a><code class="literal">encoding_utf16</code> corresponds to UTF-16
+            encoding as defined in the Unicode standard; the endianness is assumed
+            to be that of the target platform.
+          </li>
+<li class="listitem">
+            <a name="encoding_utf32_le"></a><code class="literal">encoding_utf32_le</code> corresponds to
+            little-endian UTF-32 encoding as defined in the Unicode standard.
+          </li>
+<li class="listitem">
+            <a name="encoding_utf32_be"></a><code class="literal">encoding_utf32_be</code> corresponds to
+            big-endian UTF-32 encoding as defined in the Unicode standard.
+          </li>
+<li class="listitem">
+            <a name="encoding_utf32"></a><code class="literal">encoding_utf32</code> corresponds to UTF-32
+            encoding as defined in the Unicode standard; the endianness is assumed
+            to be that of the target platform.
+          </li>
+<li class="listitem">
+            <a name="encoding_wchar"></a><code class="literal">encoding_wchar</code> corresponds to the encoding
+            of <code class="computeroutput"><span class="keyword">wchar_t</span></code> type; it has
+            the same meaning as either <code class="computeroutput"><span class="identifier">encoding_utf16</span></code>
+            or <code class="computeroutput"><span class="identifier">encoding_utf32</span></code>, depending
+            on <code class="computeroutput"><span class="keyword">wchar_t</span></code> size.
+          </li>
+<li class="listitem">
+            <a name="encoding_latin1"></a><code class="literal">encoding_latin1</code> corresponds to ISO-8859-1
+            encoding (also known as Latin-1).
+          </li>
+</ul></div>
+<p>
+        The algorithm used for <code class="computeroutput"><span class="identifier">encoding_auto</span></code>
+        correctly detects any supported Unicode encoding for all well-formed XML
+        documents (since they start with document declaration) and for all other
+        XML documents that start with <code class="literal">&lt;</code>; if your XML document
+        does not start with <code class="literal">&lt;</code> and has encoding that is different
+        from UTF-8, use the specific encoding.
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          The current behavior for Unicode conversion is to skip all invalid UTF
+          sequences during conversion. This behavior should not be relied upon; moreover,
+          in case no encoding conversion is performed, the invalid sequences are
+          not removed, so you'll get them as is in node/attribute contents.
+        </p></td></tr>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.loading.w3c"></a><a class="link" href="loading.html#manual.loading.w3c" title="Conformance to W3C specification"> Conformance to W3C specification</a>
+</h3></div></div></div>
+<p>
+        pugixml is not fully W3C conformant - it can load any valid XML document,
+        but does not perform some well-formedness checks. While considerable effort
+        is made to reject invalid XML documents, some validation is not performed
+        because of performance reasons.
+      </p>
+<p>
+        There is only one non-conformant behavior when dealing with valid XML documents:
+        pugixml does not use information supplied in document type declaration for
+        parsing. This means that entities declared in DOCTYPE are not expanded, and
+        all attribute/PCDATA values are always processed in a uniform way that depends
+        only on parsing options.
+      </p>
+<p>
+        As for rejecting invalid XML documents, there are a number of incompatibilities
+        with W3C specification, including:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            Multiple attributes of the same node can have equal names.
+          </li>
+<li class="listitem">
+            All non-ASCII characters are treated in the same way as symbols of English
+            alphabet, so some invalid tag names are not rejected.
+          </li>
+<li class="listitem">
+            Attribute values which contain <code class="literal">&lt;</code> are not rejected.
+          </li>
+<li class="listitem">
+            Invalid entity/character references are not rejected and are instead
+            left as is.
+          </li>
+<li class="listitem">
+            Comment values can contain <code class="literal">--</code>.
+          </li>
+<li class="listitem">
+            XML data is not required to begin with document declaration; additionally,
+            document declaration can appear after comments and other nodes.
+          </li>
+<li class="listitem">
+            Invalid document type declarations are silently ignored in some cases.
+          </li>
+</ul></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2012 Arseny Kapoulkine<p>
+        Distributed under the MIT License
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <b>Loading</b> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="dom.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="access.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+</body>
+</html>
diff --git a/tools/intergen/third_party/pugixml/docs/manual/modify.html b/tools/intergen/third_party/pugixml/docs/manual/modify.html
new file mode 100644
index 0000000000..f2f7785200
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/manual/modify.html
@@ -0,0 +1,632 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Modifying document data</title>
+<link rel="stylesheet" href="../pugixml.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../manual.html" title="pugixml 1.2">
+<link rel="up" href="../manual.html" title="pugixml 1.2">
+<link rel="prev" href="access.html" title="Accessing document data">
+<link rel="next" href="saving.html" title="Saving document">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <b>Modifying</b> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="access.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="saving.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+<hr>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="manual.modify"></a><a class="link" href="modify.html" title="Modifying document data"> Modifying document data</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="modify.html#manual.modify.nodedata"> Setting node data</a></span></dt>
+<dt><span class="section"><a href="modify.html#manual.modify.attrdata"> Setting attribute data</a></span></dt>
+<dt><span class="section"><a href="modify.html#manual.modify.add"> Adding nodes/attributes</a></span></dt>
+<dt><span class="section"><a href="modify.html#manual.modify.remove"> Removing nodes/attributes</a></span></dt>
+<dt><span class="section"><a href="modify.html#manual.modify.text"> Working with text contents</a></span></dt>
+<dt><span class="section"><a href="modify.html#manual.modify.clone"> Cloning nodes/attributes</a></span></dt>
+</dl></div>
+<p>
+      The document in pugixml is fully mutable: you can completely change the document
+      structure and modify the data of nodes/attributes. This section provides documentation
+      for the relevant functions. All functions take care of memory management and
+      structural integrity themselves, so they always result in structurally valid
+      tree - however, it is possible to create an invalid XML tree (for example,
+      by adding two attributes with the same name or by setting attribute/node name
+      to empty/invalid string). Tree modification is optimized for performance and
+      for memory consumption, so if you have enough memory you can create documents
+      from scratch with pugixml and later save them to file/stream instead of relying
+      on error-prone manual text writing and without too much overhead.
+    </p>
+<p>
+      All member functions that change node/attribute data or structure are non-constant
+      and thus can not be called on constant handles. However, you can easily convert
+      constant handle to non-constant one by simple assignment: <code class="computeroutput"><span class="keyword">void</span>
+      <span class="identifier">foo</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">)</span>
+      <span class="special">{</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">nc</span> <span class="special">=</span> <span class="identifier">n</span><span class="special">;</span> <span class="special">}</span></code>, so const-correctness
+      here mainly provides additional documentation.
+    </p>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.modify.nodedata"></a><a class="link" href="modify.html#manual.modify.nodedata" title="Setting node data"> Setting node data</a>
+</h3></div></div></div>
+<a name="xml_node::set_name"></a><a name="xml_node::set_value"></a><p>
+        As discussed before, nodes can have name and value, both of which are strings.
+        Depending on node type, name or value may be absent. <a class="link" href="dom.html#node_document">node_document</a>
+        nodes do not have a name or value, <a class="link" href="dom.html#node_element">node_element</a>
+        and <a class="link" href="dom.html#node_declaration">node_declaration</a> nodes always
+        have a name but never have a value, <a class="link" href="dom.html#node_pcdata">node_pcdata</a>,
+        <a class="link" href="dom.html#node_cdata">node_cdata</a>, <a class="link" href="dom.html#node_comment">node_comment</a>
+        and <a class="link" href="dom.html#node_doctype">node_doctype</a> nodes never have a name
+        but always have a value (it may be empty though), <a class="link" href="dom.html#node_pi">node_pi</a>
+        nodes always have a name and a value (again, value may be empty). In order
+        to set node's name or value, you can use the following functions:
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">set_name</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">set_value</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">rhs</span><span class="special">);</span>
+</pre>
+<p>
+        Both functions try to set the name/value to the specified string, and return
+        the operation result. The operation fails if the node can not have name or
+        value (for instance, when trying to call <code class="computeroutput"><span class="identifier">set_name</span></code>
+        on a <a class="link" href="dom.html#node_pcdata">node_pcdata</a> node), if the node handle
+        is null, or if there is insufficient memory to handle the request. The provided
+        string is copied into document managed memory and can be destroyed after
+        the function returns (for example, you can safely pass stack-allocated buffers
+        to these functions). The name/value content is not verified, so take care
+        to use only valid XML names, or the document may become malformed.
+      </p>
+<p>
+        There is no equivalent of <a class="link" href="access.html#xml_node::child_value">child_value</a>
+        function for modifying text children of the node.
+      </p>
+<p>
+        This is an example of setting node name and value (<a href="../samples/modify_base.cpp" target="_top">samples/modify_base.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">node</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"node"</span><span class="special">);</span>
+
+<span class="comment">// change node name
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">set_name</span><span class="special">(</span><span class="string">"notnode"</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">", new node name: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// change comment text
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">last_child</span><span class="special">().</span><span class="identifier">set_value</span><span class="special">(</span><span class="string">"useless comment"</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">", new comment text: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">last_child</span><span class="special">().</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// we can't change value of the element or name of the comment
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">set_value</span><span class="special">(</span><span class="string">"1"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">", "</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">last_child</span><span class="special">().</span><span class="identifier">set_name</span><span class="special">(</span><span class="string">"2"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.modify.attrdata"></a><a class="link" href="modify.html#manual.modify.attrdata" title="Setting attribute data"> Setting attribute data</a>
+</h3></div></div></div>
+<a name="xml_attribute::set_name"></a><a name="xml_attribute::set_value"></a><p>
+        All attributes have name and value, both of which are strings (value may
+        be empty). You can set them with the following functions:
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">set_name</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">set_value</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">rhs</span><span class="special">);</span>
+</pre>
+<p>
+        Both functions try to set the name/value to the specified string, and return
+        the operation result. The operation fails if the attribute handle is null,
+        or if there is insufficient memory to handle the request. The provided string
+        is copied into document managed memory and can be destroyed after the function
+        returns (for example, you can safely pass stack-allocated buffers to these
+        functions). The name/value content is not verified, so take care to use only
+        valid XML names, or the document may become malformed.
+      </p>
+<p>
+        In addition to string functions, several functions are provided for handling
+        attributes with numbers and booleans as values:
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">set_value</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">set_value</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">set_value</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="identifier">set_value</span><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">rhs</span><span class="special">);</span>
+</pre>
+<p>
+        The above functions convert the argument to string and then call the base
+        <code class="computeroutput"><span class="identifier">set_value</span></code> function. Integers
+        are converted to a decimal form, floating-point numbers are converted to
+        either decimal or scientific form, depending on the number magnitude, boolean
+        values are converted to either <code class="computeroutput"><span class="string">"true"</span></code>
+        or <code class="computeroutput"><span class="string">"false"</span></code>.
+      </p>
+<div class="caution"><table border="0" summary="Caution">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="../images/caution.png"></td>
+<th align="left">Caution</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          Number conversion functions depend on current C locale as set with <code class="computeroutput"><span class="identifier">setlocale</span></code>, so may generate unexpected
+          results if the locale is different from <code class="computeroutput"><span class="string">"C"</span></code>.
+        </p></td></tr>
+</table></div>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          There are no portable 64-bit types in C++, so there is no corresponding
+          <code class="computeroutput"><span class="identifier">set_value</span></code> function. If
+          your platform has a 64-bit integer, you can easily write such a function
+          yourself.
+        </p></td></tr>
+</table></div>
+<a name="xml_attribute::assign"></a><p>
+        For convenience, all <code class="computeroutput"><span class="identifier">set_value</span></code>
+        functions have the corresponding assignment operators:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span><span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span><span class="keyword">double</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">xml_attribute</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span><span class="keyword">bool</span> <span class="identifier">rhs</span><span class="special">);</span>
+</pre>
+<p>
+        These operators simply call the right <code class="computeroutput"><span class="identifier">set_value</span></code>
+        function and return the attribute they're called on; the return value of
+        <code class="computeroutput"><span class="identifier">set_value</span></code> is ignored, so
+        errors are ignored.
+      </p>
+<p>
+        This is an example of setting attribute name and value (<a href="../samples/modify_base.cpp" target="_top">samples/modify_base.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_attribute</span> <span class="identifier">attr</span> <span class="special">=</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"id"</span><span class="special">);</span>
+
+<span class="comment">// change attribute name/value
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">set_name</span><span class="special">(</span><span class="string">"key"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">", "</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">set_value</span><span class="special">(</span><span class="string">"345"</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">", new attribute: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"="</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// we can use numbers or booleans
+</span><span class="identifier">attr</span><span class="special">.</span><span class="identifier">set_value</span><span class="special">(</span><span class="number">1.234</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"new attribute value: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// we can also use assignment operators for more concise code
+</span><span class="identifier">attr</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"final attribute value: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.modify.add"></a><a class="link" href="modify.html#manual.modify.add" title="Adding nodes/attributes"> Adding nodes/attributes</a>
+</h3></div></div></div>
+<a name="xml_node::prepend_attribute"></a><a name="xml_node::append_attribute"></a><a name="xml_node::insert_attribute_after"></a><a name="xml_node::insert_attribute_before"></a><a name="xml_node::prepend_child"></a><a name="xml_node::append_child"></a><a name="xml_node::insert_child_after"></a><a name="xml_node::insert_child_before"></a><p>
+        Nodes and attributes do not exist without a document tree, so you can't create
+        them without adding them to some document. A node or attribute can be created
+        at the end of node/attribute list or before/after some other node:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_attribute</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">append_attribute</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">);</span>
+<span class="identifier">xml_attribute</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">prepend_attribute</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">);</span>
+<span class="identifier">xml_attribute</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">insert_attribute_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">attr</span><span class="special">);</span>
+<span class="identifier">xml_attribute</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">insert_attribute_before</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">attr</span><span class="special">);</span>
+
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">append_child</span><span class="special">(</span><span class="identifier">xml_node_type</span> <span class="identifier">type</span> <span class="special">=</span> <span class="identifier">node_element</span><span class="special">);</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">prepend_child</span><span class="special">(</span><span class="identifier">xml_node_type</span> <span class="identifier">type</span> <span class="special">=</span> <span class="identifier">node_element</span><span class="special">);</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">insert_child_after</span><span class="special">(</span><span class="identifier">xml_node_type</span> <span class="identifier">type</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">insert_child_before</span><span class="special">(</span><span class="identifier">xml_node_type</span> <span class="identifier">type</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">append_child</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">);</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">prepend_child</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">);</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">insert_child_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">insert_child_before</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+</pre>
+<p>
+        <code class="computeroutput"><span class="identifier">append_attribute</span></code> and <code class="computeroutput"><span class="identifier">append_child</span></code> create a new node/attribute
+        at the end of the corresponding list of the node the method is called on;
+        <code class="computeroutput"><span class="identifier">prepend_attribute</span></code> and <code class="computeroutput"><span class="identifier">prepend_child</span></code> create a new node/attribute
+        at the beginning of the list; <code class="computeroutput"><span class="identifier">insert_attribute_after</span></code>,
+        <code class="computeroutput"><span class="identifier">insert_attribute_before</span></code>,
+        <code class="computeroutput"><span class="identifier">insert_child_after</span></code> and <code class="computeroutput"><span class="identifier">insert_attribute_before</span></code> add the node/attribute
+        before or after the specified node/attribute.
+      </p>
+<p>
+        Attribute functions create an attribute with the specified name; you can
+        specify the empty name and change the name later if you want to. Node functions
+        with the <code class="computeroutput"><span class="identifier">type</span></code> argument create
+        the node with the specified type; since node type can't be changed, you have
+        to know the desired type beforehand. Also note that not all types can be
+        added as children; see below for clarification. Node functions with the
+        <code class="computeroutput"><span class="identifier">name</span></code> argument create the
+        element node (<a class="link" href="dom.html#node_element">node_element</a>) with the
+        specified name.
+      </p>
+<p>
+        All functions return the handle to the created object on success, and null
+        handle on failure. There are several reasons for failure:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            Adding fails if the target node is null;
+          </li>
+<li class="listitem">
+            Only <a class="link" href="dom.html#node_element">node_element</a> nodes can contain
+            attributes, so attribute adding fails if node is not an element;
+          </li>
+<li class="listitem">
+            Only <a class="link" href="dom.html#node_document">node_document</a> and <a class="link" href="dom.html#node_element">node_element</a>
+            nodes can contain children, so child node adding fails if the target
+            node is not an element or a document;
+          </li>
+<li class="listitem">
+            <a class="link" href="dom.html#node_document">node_document</a> and <a class="link" href="dom.html#node_null">node_null</a>
+            nodes can not be inserted as children, so passing <a class="link" href="dom.html#node_document">node_document</a>
+            or <a class="link" href="dom.html#node_null">node_null</a> value as <code class="computeroutput"><span class="identifier">type</span></code> results in operation failure;
+          </li>
+<li class="listitem">
+            <a class="link" href="dom.html#node_declaration">node_declaration</a> nodes can only
+            be added as children of the document node; attempt to insert declaration
+            node as a child of an element node fails;
+          </li>
+<li class="listitem">
+            Adding node/attribute results in memory allocation, which may fail;
+          </li>
+<li class="listitem">
+            Insertion functions fail if the specified node or attribute is null or
+            is not in the target node's children/attribute list.
+          </li>
+</ul></div>
+<p>
+        Even if the operation fails, the document remains in consistent state, but
+        the requested node/attribute is not added.
+      </p>
+<div class="caution"><table border="0" summary="Caution">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="../images/caution.png"></td>
+<th align="left">Caution</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          attribute() and child() functions do not add attributes or nodes to the
+          tree, so code like <code class="computeroutput"><span class="identifier">node</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"id"</span><span class="special">)</span> <span class="special">=</span> <span class="number">123</span><span class="special">;</span></code> will not do anything if <code class="computeroutput"><span class="identifier">node</span></code> does not have an attribute with
+          name <code class="computeroutput"><span class="string">"id"</span></code>. Make sure
+          you're operating with existing attributes/nodes by adding them if necessary.
+        </p></td></tr>
+</table></div>
+<p>
+        This is an example of adding new attributes/nodes to the document (<a href="../samples/modify_add.cpp" target="_top">samples/modify_add.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// add node with some name
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">node</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">append_child</span><span class="special">(</span><span class="string">"node"</span><span class="special">);</span>
+
+<span class="comment">// add description node with text child
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">descr</span> <span class="special">=</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">append_child</span><span class="special">(</span><span class="string">"description"</span><span class="special">);</span>
+<span class="identifier">descr</span><span class="special">.</span><span class="identifier">append_child</span><span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">node_pcdata</span><span class="special">).</span><span class="identifier">set_value</span><span class="special">(</span><span class="string">"Simple node"</span><span class="special">);</span>
+
+<span class="comment">// add param node before the description
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">param</span> <span class="special">=</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">insert_child_before</span><span class="special">(</span><span class="string">"param"</span><span class="special">,</span> <span class="identifier">descr</span><span class="special">);</span>
+
+<span class="comment">// add attributes to param node
+</span><span class="identifier">param</span><span class="special">.</span><span class="identifier">append_attribute</span><span class="special">(</span><span class="string">"name"</span><span class="special">)</span> <span class="special">=</span> <span class="string">"version"</span><span class="special">;</span>
+<span class="identifier">param</span><span class="special">.</span><span class="identifier">append_attribute</span><span class="special">(</span><span class="string">"value"</span><span class="special">)</span> <span class="special">=</span> <span class="number">1.1</span><span class="special">;</span>
+<span class="identifier">param</span><span class="special">.</span><span class="identifier">insert_attribute_after</span><span class="special">(</span><span class="string">"type"</span><span class="special">,</span> <span class="identifier">param</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"name"</span><span class="special">))</span> <span class="special">=</span> <span class="string">"float"</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.modify.remove"></a><a class="link" href="modify.html#manual.modify.remove" title="Removing nodes/attributes"> Removing nodes/attributes</a>
+</h3></div></div></div>
+<a name="xml_node::remove_attribute"></a><a name="xml_node::remove_child"></a><p>
+        If you do not want your document to contain some node or attribute, you can
+        remove it with one of the following functions:
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">remove_attribute</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">a</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">remove_child</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">);</span>
+</pre>
+<p>
+        <code class="computeroutput"><span class="identifier">remove_attribute</span></code> removes
+        the attribute from the attribute list of the node, and returns the operation
+        result. <code class="computeroutput"><span class="identifier">remove_child</span></code> removes
+        the child node with the entire subtree (including all descendant nodes and
+        attributes) from the document, and returns the operation result. Removing
+        fails if one of the following is true:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            The node the function is called on is null;
+          </li>
+<li class="listitem">
+            The attribute/node to be removed is null;
+          </li>
+<li class="listitem">
+            The attribute/node to be removed is not in the node's attribute/child
+            list.
+          </li>
+</ul></div>
+<p>
+        Removing the attribute or node invalidates all handles to the same underlying
+        object, and also invalidates all iterators pointing to the same object. Removing
+        node also invalidates all past-the-end iterators to its attribute or child
+        node list. Be careful to ensure that all such handles and iterators either
+        do not exist or are not used after the attribute/node is removed.
+      </p>
+<p>
+        If you want to remove the attribute or child node by its name, two additional
+        helper functions are available:
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">remove_attribute</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">remove_child</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">);</span>
+</pre>
+<p>
+        These functions look for the first attribute or child with the specified
+        name, and then remove it, returning the result. If there is no attribute
+        or child with such name, the function returns <code class="computeroutput"><span class="keyword">false</span></code>;
+        if there are two nodes with the given name, only the first node is deleted.
+        If you want to delete all nodes with the specified name, you can use code
+        like this: <code class="computeroutput"><span class="keyword">while</span> <span class="special">(</span><span class="identifier">node</span><span class="special">.</span><span class="identifier">remove_child</span><span class="special">(</span><span class="string">"tool"</span><span class="special">))</span> <span class="special">;</span></code>.
+      </p>
+<p>
+        This is an example of removing attributes/nodes from the document (<a href="../samples/modify_remove.cpp" target="_top">samples/modify_remove.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// remove description node with the whole subtree
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">node</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"node"</span><span class="special">);</span>
+<span class="identifier">node</span><span class="special">.</span><span class="identifier">remove_child</span><span class="special">(</span><span class="string">"description"</span><span class="special">);</span>
+
+<span class="comment">// remove id attribute
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">param</span> <span class="special">=</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"param"</span><span class="special">);</span>
+<span class="identifier">param</span><span class="special">.</span><span class="identifier">remove_attribute</span><span class="special">(</span><span class="string">"value"</span><span class="special">);</span>
+
+<span class="comment">// we can also remove nodes/attributes by handles
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_attribute</span> <span class="identifier">id</span> <span class="special">=</span> <span class="identifier">param</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"name"</span><span class="special">);</span>
+<span class="identifier">param</span><span class="special">.</span><span class="identifier">remove_attribute</span><span class="special">(</span><span class="identifier">id</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.modify.text"></a><a class="link" href="modify.html#manual.modify.text" title="Working with text contents"> Working with text contents</a>
+</h3></div></div></div>
+<p>
+        pugixml provides a special class, <code class="computeroutput"><span class="identifier">xml_text</span></code>,
+        to work with text contents stored as a value of some node, i.e. <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">node</span><span class="special">&gt;&lt;</span><span class="identifier">description</span><span class="special">&gt;</span><span class="identifier">This</span> <span class="identifier">is</span> <span class="identifier">a</span> <span class="identifier">node</span><span class="special">&lt;/</span><span class="identifier">description</span><span class="special">&gt;&lt;/</span><span class="identifier">node</span><span class="special">&gt;</span></code>.
+        Working with text objects to retrieve data is described in <a class="link" href="access.html#manual.access.text" title="Working with text contents">the
+        documentation for accessing document data</a>; this section describes
+        the modification interface of <code class="computeroutput"><span class="identifier">xml_text</span></code>.
+      </p>
+<a name="xml_text::set"></a><p>
+        Once you have an <code class="computeroutput"><span class="identifier">xml_text</span></code>
+        object, you can set the text contents using the following function:
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">set</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">rhs</span><span class="special">);</span>
+</pre>
+<p>
+        This function tries to set the contents to the specified string, and returns
+        the operation result. The operation fails if the text object was retrieved
+        from a node that can not have a value and is not an element node (i.e. it
+        is a <a class="link" href="dom.html#node_declaration">node_declaration</a> node), if the
+        text object is empty, or if there is insufficient memory to handle the request.
+        The provided string is copied into document managed memory and can be destroyed
+        after the function returns (for example, you can safely pass stack-allocated
+        buffers to this function). Note that if the text object was retrieved from
+        an element node, this function creates the PCDATA child node if necessary
+        (i.e. if the element node does not have a PCDATA/CDATA child already).
+      </p>
+<a name="xml_text::set_value"></a><p>
+        In addition to a string function, several functions are provided for handling
+        text with numbers and booleans as contents:
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">set</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">set</span><span class="special">(</span><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">set</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="identifier">set</span><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">rhs</span><span class="special">);</span>
+</pre>
+<p>
+        The above functions convert the argument to string and then call the base
+        <code class="computeroutput"><span class="identifier">set</span></code> function. These functions
+        have the same semantics as similar <code class="computeroutput"><span class="identifier">xml_attribute</span></code>
+        functions. You can <a class="link" href="modify.html#xml_attribute::set_value">refer to documentation
+        for the attribute functions</a> for details.
+      </p>
+<a name="xml_text::assign"></a><p>
+        For convenience, all <code class="computeroutput"><span class="identifier">set</span></code>
+        functions have the corresponding assignment operators:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_text</span><span class="special">&amp;</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="identifier">xml_text</span><span class="special">&amp;</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span><span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="identifier">xml_text</span><span class="special">&amp;</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="identifier">xml_text</span><span class="special">&amp;</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span><span class="keyword">double</span> <span class="identifier">rhs</span><span class="special">);</span>
+<span class="identifier">xml_text</span><span class="special">&amp;</span> <span class="identifier">xml_text</span><span class="special">::</span><span class="keyword">operator</span><span class="special">=(</span><span class="keyword">bool</span> <span class="identifier">rhs</span><span class="special">);</span>
+</pre>
+<p>
+        These operators simply call the right <code class="computeroutput"><span class="identifier">set</span></code>
+        function and return the attribute they're called on; the return value of
+        <code class="computeroutput"><span class="identifier">set</span></code> is ignored, so errors
+        are ignored.
+      </p>
+<p>
+        This is an example of using <code class="computeroutput"><span class="identifier">xml_text</span></code>
+        object to modify text contents (<a href="../samples/text.cpp" target="_top">samples/text.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// change project version
+</span><span class="identifier">project</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"version"</span><span class="special">).</span><span class="identifier">text</span><span class="special">()</span> <span class="special">=</span> <span class="number">1.2</span><span class="special">;</span>
+
+<span class="comment">// add description element and set the contents
+</span><span class="comment">// note that we do not have to explicitly add the node_pcdata child
+</span><span class="identifier">project</span><span class="special">.</span><span class="identifier">append_child</span><span class="special">(</span><span class="string">"description"</span><span class="special">).</span><span class="identifier">text</span><span class="special">().</span><span class="identifier">set</span><span class="special">(</span><span class="string">"a test project"</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.modify.clone"></a><a class="link" href="modify.html#manual.modify.clone" title="Cloning nodes/attributes"> Cloning nodes/attributes</a>
+</h3></div></div></div>
+<a name="xml_node::prepend_copy"></a><a name="xml_node::append_copy"></a><a name="xml_node::insert_copy_after"></a><a name="xml_node::insert_copy_before"></a><p>
+        With the help of previously described functions, it is possible to create
+        trees with any contents and structure, including cloning the existing data.
+        However since this is an often needed operation, pugixml provides built-in
+        node/attribute cloning facilities. Since nodes and attributes do not exist
+        without a document tree, you can't create a standalone copy - you have to
+        immediately insert it somewhere in the tree. For this, you can use one of
+        the following functions:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_attribute</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">append_copy</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">proto</span><span class="special">);</span>
+<span class="identifier">xml_attribute</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">prepend_copy</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">proto</span><span class="special">);</span>
+<span class="identifier">xml_attribute</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">insert_copy_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">proto</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">attr</span><span class="special">);</span>
+<span class="identifier">xml_attribute</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">insert_copy_before</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">proto</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">xml_attribute</span><span class="special">&amp;</span> <span class="identifier">attr</span><span class="special">);</span>
+
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">append_copy</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">proto</span><span class="special">);</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">prepend_copy</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">proto</span><span class="special">);</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">insert_copy_after</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">proto</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+<span class="identifier">xml_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">insert_copy_before</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">proto</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">);</span>
+</pre>
+<p>
+        These functions mirror the structure of <code class="computeroutput"><span class="identifier">append_child</span></code>,
+        <code class="computeroutput"><span class="identifier">prepend_child</span></code>, <code class="computeroutput"><span class="identifier">insert_child_before</span></code> and related functions
+        - they take the handle to the prototype object, which is to be cloned, insert
+        a new attribute/node at the appropriate place, and then copy the attribute
+        data or the whole node subtree to the new object. The functions return the
+        handle to the resulting duplicate object, or null handle on failure.
+      </p>
+<p>
+        The attribute is copied along with the name and value; the node is copied
+        along with its type, name and value; additionally attribute list and all
+        children are recursively cloned, resulting in the deep subtree clone. The
+        prototype object can be a part of the same document, or a part of any other
+        document.
+      </p>
+<p>
+        The failure conditions resemble those of <code class="computeroutput"><span class="identifier">append_child</span></code>,
+        <code class="computeroutput"><span class="identifier">insert_child_before</span></code> and related
+        functions, <a class="link" href="modify.html#xml_node::append_child">consult their documentation
+        for more information</a>. There are additional caveats specific to cloning
+        functions:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            Cloning null handles results in operation failure;
+          </li>
+<li class="listitem">
+            Node cloning starts with insertion of the node of the same type as that
+            of the prototype; for this reason, cloning functions can not be directly
+            used to clone entire documents, since <a class="link" href="dom.html#node_document">node_document</a>
+            is not a valid insertion type. The example below provides a workaround.
+          </li>
+<li class="listitem">
+            It is possible to copy a subtree as a child of some node inside this
+            subtree, i.e. <code class="computeroutput"><span class="identifier">node</span><span class="special">.</span><span class="identifier">append_copy</span><span class="special">(</span><span class="identifier">node</span><span class="special">.</span><span class="identifier">parent</span><span class="special">().</span><span class="identifier">parent</span><span class="special">());</span></code>.
+            This is a valid operation, and it results in a clone of the subtree in
+            the state before cloning started, i.e. no infinite recursion takes place.
+          </li>
+</ul></div>
+<p>
+        This is an example with one possible implementation of include tags in XML
+        (<a href="../samples/include.cpp" target="_top">samples/include.cpp</a>). It illustrates
+        node cloning and usage of other document modification functions:
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">load_preprocess</span><span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_document</span><span class="special">&amp;</span> <span class="identifier">doc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">path</span><span class="special">);</span>
+
+<span class="keyword">bool</span> <span class="identifier">preprocess</span><span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">node</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">child</span> <span class="special">=</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">first_child</span><span class="special">();</span> <span class="identifier">child</span><span class="special">;</span> <span class="special">)</span>
+    <span class="special">{</span>
+        <span class="keyword">if</span> <span class="special">(</span><span class="identifier">child</span><span class="special">.</span><span class="identifier">type</span><span class="special">()</span> <span class="special">==</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">node_pi</span> <span class="special">&amp;&amp;</span> <span class="identifier">strcmp</span><span class="special">(</span><span class="identifier">child</span><span class="special">.</span><span class="identifier">name</span><span class="special">(),</span> <span class="string">"include"</span><span class="special">)</span> <span class="special">==</span> <span class="number">0</span><span class="special">)</span>
+        <span class="special">{</span>
+            <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">include</span> <span class="special">=</span> <span class="identifier">child</span><span class="special">;</span>
+
+            <span class="comment">// load new preprocessed document (note: ideally this should handle relative paths)
+</span>            <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">path</span> <span class="special">=</span> <span class="identifier">include</span><span class="special">.</span><span class="identifier">value</span><span class="special">();</span>
+
+            <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_document</span> <span class="identifier">doc</span><span class="special">;</span>
+            <span class="keyword">if</span> <span class="special">(!</span><span class="identifier">load_preprocess</span><span class="special">(</span><span class="identifier">doc</span><span class="special">,</span> <span class="identifier">path</span><span class="special">))</span> <span class="keyword">return</span> <span class="keyword">false</span><span class="special">;</span>
+
+            <span class="comment">// insert the comment marker above include directive
+</span>            <span class="identifier">node</span><span class="special">.</span><span class="identifier">insert_child_before</span><span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">node_comment</span><span class="special">,</span> <span class="identifier">include</span><span class="special">).</span><span class="identifier">set_value</span><span class="special">(</span><span class="identifier">path</span><span class="special">);</span>
+
+            <span class="comment">// copy the document above the include directive (this retains the original order!)
+</span>            <span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">ic</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">first_child</span><span class="special">();</span> <span class="identifier">ic</span><span class="special">;</span> <span class="identifier">ic</span> <span class="special">=</span> <span class="identifier">ic</span><span class="special">.</span><span class="identifier">next_sibling</span><span class="special">())</span>
+            <span class="special">{</span>
+                <span class="identifier">node</span><span class="special">.</span><span class="identifier">insert_copy_before</span><span class="special">(</span><span class="identifier">ic</span><span class="special">,</span> <span class="identifier">include</span><span class="special">);</span>
+            <span class="special">}</span>
+
+            <span class="comment">// remove the include node and move to the next child
+</span>            <span class="identifier">child</span> <span class="special">=</span> <span class="identifier">child</span><span class="special">.</span><span class="identifier">next_sibling</span><span class="special">();</span>
+
+            <span class="identifier">node</span><span class="special">.</span><span class="identifier">remove_child</span><span class="special">(</span><span class="identifier">include</span><span class="special">);</span>
+        <span class="special">}</span>
+        <span class="keyword">else</span>
+        <span class="special">{</span>
+            <span class="keyword">if</span> <span class="special">(!</span><span class="identifier">preprocess</span><span class="special">(</span><span class="identifier">child</span><span class="special">))</span> <span class="keyword">return</span> <span class="keyword">false</span><span class="special">;</span>
+
+            <span class="identifier">child</span> <span class="special">=</span> <span class="identifier">child</span><span class="special">.</span><span class="identifier">next_sibling</span><span class="special">();</span>
+        <span class="special">}</span>
+    <span class="special">}</span>
+
+    <span class="keyword">return</span> <span class="keyword">true</span><span class="special">;</span>
+<span class="special">}</span>
+
+<span class="keyword">bool</span> <span class="identifier">load_preprocess</span><span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_document</span><span class="special">&amp;</span> <span class="identifier">doc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">path</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_parse_result</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">load_file</span><span class="special">(</span><span class="identifier">path</span><span class="special">,</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">parse_default</span> <span class="special">|</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">parse_pi</span><span class="special">);</span> <span class="comment">// for &lt;?include?&gt;
+</span>    
+    <span class="keyword">return</span> <span class="identifier">result</span> <span class="special">?</span> <span class="identifier">preprocess</span><span class="special">(</span><span class="identifier">doc</span><span class="special">)</span> <span class="special">:</span> <span class="keyword">false</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2012 Arseny Kapoulkine<p>
+        Distributed under the MIT License
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <b>Modifying</b> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="access.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="saving.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+</body>
+</html>
diff --git a/tools/intergen/third_party/pugixml/docs/manual/saving.html b/tools/intergen/third_party/pugixml/docs/manual/saving.html
new file mode 100644
index 0000000000..d0b2e02f79
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/manual/saving.html
@@ -0,0 +1,543 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Saving document</title>
+<link rel="stylesheet" href="../pugixml.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../manual.html" title="pugixml 1.2">
+<link rel="up" href="../manual.html" title="pugixml 1.2">
+<link rel="prev" href="modify.html" title="Modifying document data">
+<link rel="next" href="xpath.html" title="XPath">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <b>Saving</b> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="modify.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="xpath.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+<hr>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="manual.saving"></a><a class="link" href="saving.html" title="Saving document"> Saving document</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="saving.html#manual.saving.file"> Saving document to a file</a></span></dt>
+<dt><span class="section"><a href="saving.html#manual.saving.stream"> Saving document to C++ IOstreams</a></span></dt>
+<dt><span class="section"><a href="saving.html#manual.saving.writer"> Saving document via writer interface</a></span></dt>
+<dt><span class="section"><a href="saving.html#manual.saving.subtree"> Saving a single subtree</a></span></dt>
+<dt><span class="section"><a href="saving.html#manual.saving.options"> Output options</a></span></dt>
+<dt><span class="section"><a href="saving.html#manual.saving.encoding"> Encodings</a></span></dt>
+<dt><span class="section"><a href="saving.html#manual.saving.declaration"> Customizing document declaration</a></span></dt>
+</dl></div>
+<p>
+      Often after creating a new document or loading the existing one and processing
+      it, it is necessary to save the result back to file. Also it is occasionally
+      useful to output the whole document or a subtree to some stream; use cases
+      include debug printing, serialization via network or other text-oriented medium,
+      etc. pugixml provides several functions to output any subtree of the document
+      to a file, stream or another generic transport interface; these functions allow
+      to customize the output format (see <a class="xref" href="saving.html#manual.saving.options" title="Output options"> Output options</a>), and also perform
+      necessary encoding conversions (see <a class="xref" href="saving.html#manual.saving.encoding" title="Encodings"> Encodings</a>). This section documents
+      the relevant functionality.
+    </p>
+<p>
+      Before writing to the destination the node/attribute data is properly formatted
+      according to the node type; all special XML symbols, such as &lt; and &amp;,
+      are properly escaped (unless <a class="link" href="saving.html#format_no_escapes">format_no_escapes</a>
+      flag is set). In order to guard against forgotten node/attribute names, empty
+      node/attribute names are printed as <code class="computeroutput"><span class="string">":anonymous"</span></code>.
+      For well-formed output, make sure all node and attribute names are set to meaningful
+      values.
+    </p>
+<p>
+      CDATA sections with values that contain <code class="computeroutput"><span class="string">"]]&gt;"</span></code>
+      are split into several sections as follows: section with value <code class="computeroutput"><span class="string">"pre]]&gt;post"</span></code> is written as <code class="computeroutput"><span class="special">&lt;![</span><span class="identifier">CDATA</span><span class="special">[</span><span class="identifier">pre</span><span class="special">]]]]&gt;&lt;![</span><span class="identifier">CDATA</span><span class="special">[&gt;</span><span class="identifier">post</span><span class="special">]]&gt;</span></code>.
+      While this alters the structure of the document (if you load the document after
+      saving it, there will be two CDATA sections instead of one), this is the only
+      way to escape CDATA contents.
+    </p>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.saving.file"></a><a class="link" href="saving.html#manual.saving.file" title="Saving document to a file"> Saving document to a file</a>
+</h3></div></div></div>
+<a name="xml_document::save_file"></a><a name="xml_document::save_file_wide"></a><p>
+        If you want to save the whole document to a file, you can use one of the
+        following functions:
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">save_file</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">path</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">indent</span> <span class="special">=</span> <span class="string">"\t"</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">format_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span> <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">bool</span> <span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">save_file</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*</span> <span class="identifier">path</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">indent</span> <span class="special">=</span> <span class="string">"\t"</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">format_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span> <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        These functions accept file path as its first argument, and also three optional
+        arguments, which specify indentation and other output options (see <a class="xref" href="saving.html#manual.saving.options" title="Output options"> Output options</a>)
+        and output data encoding (see <a class="xref" href="saving.html#manual.saving.encoding" title="Encodings"> Encodings</a>). The path has the target
+        operating system format, so it can be a relative or absolute one, it should
+        have the delimiters of the target system, it should have the exact case if
+        the target file system is case-sensitive, etc.
+      </p>
+<p>
+        File path is passed to the system file opening function as is in case of
+        the first function (which accepts <code class="computeroutput"><span class="keyword">const</span>
+        <span class="keyword">char</span><span class="special">*</span> <span class="identifier">path</span></code>); the second function either uses
+        a special file opening function if it is provided by the runtime library
+        or converts the path to UTF-8 and uses the system file opening function.
+      </p>
+<a name="xml_writer_file"></a><p>
+        <code class="computeroutput"><span class="identifier">save_file</span></code> opens the target
+        file for writing, outputs the requested header (by default a document declaration
+        is output, unless the document already has one), and then saves the document
+        contents. If the file could not be opened, the function returns <code class="computeroutput"><span class="keyword">false</span></code>. Calling <code class="computeroutput"><span class="identifier">save_file</span></code>
+        is equivalent to creating an <code class="computeroutput"><span class="identifier">xml_writer_file</span></code>
+        object with <code class="computeroutput"><span class="identifier">FILE</span><span class="special">*</span></code>
+        handle as the only constructor argument and then calling <code class="computeroutput"><span class="identifier">save</span></code>;
+        see <a class="xref" href="saving.html#manual.saving.writer" title="Saving document via writer interface"> Saving document via writer interface</a> for writer interface details.
+      </p>
+<p>
+        This is a simple example of saving XML document to file (<a href="../samples/save_file.cpp" target="_top">samples/save_file.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// save document to file
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Saving result: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">save_file</span><span class="special">(</span><span class="string">"save_file_output.xml"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.saving.stream"></a><a class="link" href="saving.html#manual.saving.stream" title="Saving document to C++ IOstreams"> Saving document to C++ IOstreams</a>
+</h3></div></div></div>
+<a name="xml_document::save_stream"></a><p>
+        To enhance interoperability pugixml provides functions for saving document
+        to any object which implements C++ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span></code>
+        interface. This allows you to save documents to any standard C++ stream (i.e.
+        file stream) or any third-party compliant implementation (i.e. Boost Iostreams).
+        Most notably, this allows for easy debug output, since you can use <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span></code>
+        stream as saving target. There are two functions, one works with narrow character
+        streams, another handles wide character ones:
+      </p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">save</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="identifier">stream</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">indent</span> <span class="special">=</span> <span class="string">"\t"</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">format_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span> <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">void</span> <span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">save</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">wostream</span><span class="special">&amp;</span> <span class="identifier">stream</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">indent</span> <span class="special">=</span> <span class="string">"\t"</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">format_default</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        <code class="computeroutput"><span class="identifier">save</span></code> with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span></code>
+        argument saves the document to the stream in the same way as <code class="computeroutput"><span class="identifier">save_file</span></code> (i.e. with requested header and
+        with encoding conversions). On the other hand, <code class="computeroutput"><span class="identifier">save</span></code>
+        with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">wstream</span></code> argument saves the document to
+        the wide stream with <a class="link" href="loading.html#encoding_wchar">encoding_wchar</a>
+        encoding. Because of this, using <code class="computeroutput"><span class="identifier">save</span></code>
+        with wide character streams requires careful (usually platform-specific)
+        stream setup (i.e. using the <code class="computeroutput"><span class="identifier">imbue</span></code>
+        function). Generally use of wide streams is discouraged, however it provides
+        you with the ability to save documents to non-Unicode encodings, i.e. you
+        can save Shift-JIS encoded data if you set the correct locale.
+      </p>
+<a name="xml_writer_stream"></a><p>
+        Calling <code class="computeroutput"><span class="identifier">save</span></code> with stream
+        target is equivalent to creating an <code class="computeroutput"><span class="identifier">xml_writer_stream</span></code>
+        object with stream as the only constructor argument and then calling <code class="computeroutput"><span class="identifier">save</span></code>; see <a class="xref" href="saving.html#manual.saving.writer" title="Saving document via writer interface"> Saving document via writer interface</a> for writer
+        interface details.
+      </p>
+<p>
+        This is a simple example of saving XML document to standard output (<a href="../samples/save_stream.cpp" target="_top">samples/save_stream.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// save document to standard output
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Document:\n"</span><span class="special">;</span>
+<span class="identifier">doc</span><span class="special">.</span><span class="identifier">save</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.saving.writer"></a><a class="link" href="saving.html#manual.saving.writer" title="Saving document via writer interface"> Saving document via writer interface</a>
+</h3></div></div></div>
+<a name="xml_document::save"></a><a name="xml_writer"></a><a name="xml_writer::write"></a><p>
+        All of the above saving functions are implemented in terms of writer interface.
+        This is a simple interface with a single function, which is called several
+        times during output process with chunks of document data as input:
+      </p>
+<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">xml_writer</span>
+<span class="special">{</span>
+<span class="keyword">public</span><span class="special">:</span>
+    <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="identifier">write</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">data</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">)</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
+<span class="special">};</span>
+
+<span class="keyword">void</span> <span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">save</span><span class="special">(</span><span class="identifier">xml_writer</span><span class="special">&amp;</span> <span class="identifier">writer</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">indent</span> <span class="special">=</span> <span class="string">"\t"</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">format_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span> <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        In order to output the document via some custom transport, for example sockets,
+        you should create an object which implements <code class="computeroutput"><span class="identifier">xml_writer</span></code>
+        interface and pass it to <code class="computeroutput"><span class="identifier">save</span></code>
+        function. <code class="computeroutput"><span class="identifier">xml_writer</span><span class="special">::</span><span class="identifier">write</span></code> function is called with a buffer
+        as an input, where <code class="computeroutput"><span class="identifier">data</span></code> points
+        to buffer start, and <code class="computeroutput"><span class="identifier">size</span></code>
+        is equal to the buffer size in bytes. <code class="computeroutput"><span class="identifier">write</span></code>
+        implementation must write the buffer to the transport; it can not save the
+        passed buffer pointer, as the buffer contents will change after <code class="computeroutput"><span class="identifier">write</span></code> returns. The buffer contains the
+        chunk of document data in the desired encoding.
+      </p>
+<p>
+        <code class="computeroutput"><span class="identifier">write</span></code> function is called
+        with relatively large blocks (size is usually several kilobytes, except for
+        the last block that may be small), so there is often no need for additional
+        buffering in the implementation.
+      </p>
+<p>
+        This is a simple example of custom writer for saving document data to STL
+        string (<a href="../samples/save_custom_writer.cpp" target="_top">samples/save_custom_writer.cpp</a>);
+        read the sample code for more complex examples:
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">xml_string_writer</span><span class="special">:</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_writer</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">result</span><span class="special">;</span>
+
+    <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="identifier">write</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">data</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">)</span>
+    <span class="special">{</span>
+        <span class="identifier">result</span> <span class="special">+=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;(</span><span class="identifier">data</span><span class="special">),</span> <span class="identifier">size</span><span class="special">);</span>
+    <span class="special">}</span>
+<span class="special">};</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.saving.subtree"></a><a class="link" href="saving.html#manual.saving.subtree" title="Saving a single subtree"> Saving a single subtree</a>
+</h3></div></div></div>
+<a name="xml_node::print"></a><a name="xml_node::print_stream"></a><p>
+        While the previously described functions save the whole document to the destination,
+        it is easy to save a single subtree. The following functions are provided:
+      </p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">print</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span><span class="special">&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">indent</span> <span class="special">=</span> <span class="string">"\t"</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">format_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span> <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">depth</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">void</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">print</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">wostream</span><span class="special">&amp;</span> <span class="identifier">os</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">indent</span> <span class="special">=</span> <span class="string">"\t"</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">format_default</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">depth</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">void</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">print</span><span class="special">(</span><span class="identifier">xml_writer</span><span class="special">&amp;</span> <span class="identifier">writer</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">indent</span> <span class="special">=</span> <span class="string">"\t"</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">format_default</span><span class="special">,</span> <span class="identifier">xml_encoding</span> <span class="identifier">encoding</span> <span class="special">=</span> <span class="identifier">encoding_auto</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="identifier">depth</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        These functions have the same arguments with the same meaning as the corresponding
+        <code class="computeroutput"><span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">save</span></code> functions, and allow you to save the
+        subtree to either a C++ IOstream or to any object that implements <code class="computeroutput"><span class="identifier">xml_writer</span></code> interface.
+      </p>
+<p>
+        Saving a subtree differs from saving the whole document: the process behaves
+        as if <a class="link" href="saving.html#format_write_bom">format_write_bom</a> is off, and
+        <a class="link" href="saving.html#format_no_declaration">format_no_declaration</a> is on,
+        even if actual values of the flags are different. This means that BOM is
+        not written to the destination, and document declaration is only written
+        if it is the node itself or is one of node's children. Note that this also
+        holds if you're saving a document; this example (<a href="../samples/save_subtree.cpp" target="_top">samples/save_subtree.cpp</a>)
+        illustrates the difference:
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// get a test document
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_document</span> <span class="identifier">doc</span><span class="special">;</span>
+<span class="identifier">doc</span><span class="special">.</span><span class="identifier">load</span><span class="special">(</span><span class="string">"&lt;foo bar='baz'&gt;&lt;call&gt;hey&lt;/call&gt;&lt;/foo&gt;"</span><span class="special">);</span>
+
+<span class="comment">// print document to standard output (prints &lt;?xml version="1.0"?&gt;&lt;foo bar="baz"&gt;&lt;call&gt;hey&lt;/call&gt;&lt;/foo&gt;)
+</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">save</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">""</span><span class="special">,</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">format_raw</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// print document to standard output as a regular node (prints &lt;foo bar="baz"&gt;&lt;call&gt;hey&lt;/call&gt;&lt;/foo&gt;)
+</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">print</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">""</span><span class="special">,</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">format_raw</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// print a subtree to standard output (prints &lt;call&gt;hey&lt;/call&gt;)
+</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"foo"</span><span class="special">).</span><span class="identifier">child</span><span class="special">(</span><span class="string">"call"</span><span class="special">).</span><span class="identifier">print</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">""</span><span class="special">,</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">format_raw</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.saving.options"></a><a class="link" href="saving.html#manual.saving.options" title="Output options"> Output options</a>
+</h3></div></div></div>
+<p>
+        All saving functions accept the optional parameter <code class="computeroutput"><span class="identifier">flags</span></code>.
+        This is a bitmask that customizes the output format; you can select the way
+        the document nodes are printed and select the needed additional information
+        that is output before the document contents.
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          You should use the usual bitwise arithmetics to manipulate the bitmask:
+          to enable a flag, use <code class="computeroutput"><span class="identifier">mask</span> <span class="special">|</span> <span class="identifier">flag</span></code>;
+          to disable a flag, use <code class="computeroutput"><span class="identifier">mask</span> <span class="special">&amp;</span> <span class="special">~</span><span class="identifier">flag</span></code>.
+        </p></td></tr>
+</table></div>
+<p>
+        These flags control the resulting tree contents:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            <a name="format_indent"></a><code class="literal">format_indent</code> determines if all nodes
+            should be indented with the indentation string (this is an additional
+            parameter for all saving functions, and is <code class="computeroutput"><span class="string">"\t"</span></code>
+            by default). If this flag is on, before every node the indentation string
+            is output several times, where the amount of indentation depends on the
+            node's depth relative to the output subtree. This flag has no effect
+            if <a class="link" href="saving.html#format_raw">format_raw</a> is enabled. This flag
+            is <span class="bold"><strong>on</strong></span> by default. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="format_raw"></a><code class="literal">format_raw</code> switches between formatted and
+            raw output. If this flag is on, the nodes are not indented in any way,
+            and also no newlines that are not part of document text are printed.
+            Raw mode can be used for serialization where the result is not intended
+            to be read by humans; also it can be useful if the document was parsed
+            with <a class="link" href="loading.html#parse_ws_pcdata">parse_ws_pcdata</a> flag, to
+            preserve the original document formatting as much as possible. This flag
+            is <span class="bold"><strong>off</strong></span> by default. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="format_no_escapes"></a><code class="literal">format_no_escapes</code> disables output
+            escaping for attribute values and PCDATA contents. If this flag is on,
+            special symbols (', &amp;, &lt;, &gt;) and all non-printable characters
+            (those with codepoint values less than 32) are converted to XML escape
+            sequences (i.e. &amp;amp;) during output. If this flag is off, no text
+            processing is performed; therefore, output XML can be malformed if output
+            contents contains invalid symbols (i.e. having a stray &lt; in the PCDATA
+            will make the output malformed). This flag is <span class="bold"><strong>on</strong></span>
+            by default.
+          </li>
+</ul></div>
+<p>
+        These flags control the additional output information:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            <a name="format_no_declaration"></a><code class="literal">format_no_declaration</code> disables
+            default node declaration output. By default, if the document is saved
+            via <code class="computeroutput"><span class="identifier">save</span></code> or <code class="computeroutput"><span class="identifier">save_file</span></code> function, and it does not
+            have any document declaration, a default declaration is output before
+            the document contents. Enabling this flag disables this declaration.
+            This flag has no effect in <code class="computeroutput"><span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">print</span></code>
+            functions: they never output the default declaration. This flag is <span class="bold"><strong>off</strong></span> by default. <br><br>
+
+          </li>
+<li class="listitem">
+            <a name="format_write_bom"></a><code class="literal">format_write_bom</code> enables Byte Order
+            Mark (BOM) output. By default, no BOM is output, so in case of non UTF-8
+            encodings the resulting document's encoding may not be recognized by
+            some parsers and text editors, if they do not implement sophisticated
+            encoding detection. Enabling this flag adds an encoding-specific BOM
+            to the output. This flag has no effect in <code class="computeroutput"><span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">print</span></code>
+            functions: they never output the BOM. This flag is <span class="bold"><strong>off</strong></span>
+            by default.
+          </li>
+<li class="listitem">
+            <a name="format_save_file_text"></a><code class="literal">format_save_file_text</code> changes
+            the file mode when using <code class="computeroutput"><span class="identifier">save_file</span></code>
+            function. By default, file is opened in binary mode, which means that
+            the output file will contain platform-independent newline \n (ASCII 10).
+            If this flag is on, file is opened in text mode, which on some systems
+            changes the newline format (i.e. on Windows you can use this flag to
+            output XML documents with \r\n (ASCII 13 10) newlines. This flag is
+            <span class="bold"><strong>off</strong></span> by default.
+          </li>
+</ul></div>
+<p>
+        Additionally, there is one predefined option mask:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
+            <a name="format_default"></a><code class="literal">format_default</code> is the default set of
+            flags, i.e. it has all options set to their default values. It sets formatted
+            output with indentation, without BOM and with default node declaration,
+            if necessary.
+          </li></ul></div>
+<p>
+        This is an example that shows the outputs of different output options (<a href="../samples/save_options.cpp" target="_top">samples/save_options.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// get a test document
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_document</span> <span class="identifier">doc</span><span class="special">;</span>
+<span class="identifier">doc</span><span class="special">.</span><span class="identifier">load</span><span class="special">(</span><span class="string">"&lt;foo bar='baz'&gt;&lt;call&gt;hey&lt;/call&gt;&lt;/foo&gt;"</span><span class="special">);</span>
+
+<span class="comment">// default options; prints
+</span><span class="comment">// &lt;?xml version="1.0"?&gt;
+</span><span class="comment">// &lt;foo bar="baz"&gt;
+</span><span class="comment">//         &lt;call&gt;hey&lt;/call&gt;
+</span><span class="comment">// &lt;/foo&gt;
+</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">save</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// default options with custom indentation string; prints
+</span><span class="comment">// &lt;?xml version="1.0"?&gt;
+</span><span class="comment">// &lt;foo bar="baz"&gt;
+</span><span class="comment">// --&lt;call&gt;hey&lt;/call&gt;
+</span><span class="comment">// &lt;/foo&gt;
+</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">save</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">"--"</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// default options without indentation; prints
+</span><span class="comment">// &lt;?xml version="1.0"?&gt;
+</span><span class="comment">// &lt;foo bar="baz"&gt;
+</span><span class="comment">// &lt;call&gt;hey&lt;/call&gt;
+</span><span class="comment">// &lt;/foo&gt;
+</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">save</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">"\t"</span><span class="special">,</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">format_default</span> <span class="special">&amp;</span> <span class="special">~</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">format_indent</span><span class="special">);</span> <span class="comment">// can also pass "" instead of indentation string for the same effect
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// raw output; prints
+</span><span class="comment">// &lt;?xml version="1.0"?&gt;&lt;foo bar="baz"&gt;&lt;call&gt;hey&lt;/call&gt;&lt;/foo&gt;
+</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">save</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">"\t"</span><span class="special">,</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">format_raw</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// raw output without declaration; prints
+</span><span class="comment">// &lt;foo bar="baz"&gt;&lt;call&gt;hey&lt;/call&gt;&lt;/foo&gt;
+</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">save</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">"\t"</span><span class="special">,</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">format_raw</span> <span class="special">|</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">format_no_declaration</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.saving.encoding"></a><a class="link" href="saving.html#manual.saving.encoding" title="Encodings"> Encodings</a>
+</h3></div></div></div>
+<p>
+        pugixml supports all popular Unicode encodings (UTF-8, UTF-16 (big and little
+        endian), UTF-32 (big and little endian); UCS-2 is naturally supported since
+        it's a strict subset of UTF-16) and handles all encoding conversions during
+        output. The output encoding is set via the <code class="computeroutput"><span class="identifier">encoding</span></code>
+        parameter of saving functions, which is of type <code class="computeroutput"><span class="identifier">xml_encoding</span></code>.
+        The possible values for the encoding are documented in <a class="xref" href="loading.html#manual.loading.encoding" title="Encodings"> Encodings</a>;
+        the only flag that has a different meaning is <code class="computeroutput"><span class="identifier">encoding_auto</span></code>.
+      </p>
+<p>
+        While all other flags set the exact encoding, <code class="computeroutput"><span class="identifier">encoding_auto</span></code>
+        is meant for automatic encoding detection. The automatic detection does not
+        make sense for output encoding, since there is usually nothing to infer the
+        actual encoding from, so here <code class="computeroutput"><span class="identifier">encoding_auto</span></code>
+        means UTF-8 encoding, which is the most popular encoding for XML data storage.
+        This is also the default value of output encoding; specify another value
+        if you do not want UTF-8 encoded output.
+      </p>
+<p>
+        Also note that wide stream saving functions do not have <code class="computeroutput"><span class="identifier">encoding</span></code>
+        argument and always assume <a class="link" href="loading.html#encoding_wchar">encoding_wchar</a>
+        encoding.
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          The current behavior for Unicode conversion is to skip all invalid UTF
+          sequences during conversion. This behavior should not be relied upon; if
+          your node/attribute names do not contain any valid UTF sequences, they
+          may be output as if they are empty, which will result in malformed XML
+          document.
+        </p></td></tr>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.saving.declaration"></a><a class="link" href="saving.html#manual.saving.declaration" title="Customizing document declaration"> Customizing document declaration</a>
+</h3></div></div></div>
+<p>
+        When you are saving the document using <code class="computeroutput"><span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">save</span><span class="special">()</span></code> or <code class="computeroutput"><span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">save_file</span><span class="special">()</span></code>, a default XML document declaration is
+        output, if <code class="computeroutput"><span class="identifier">format_no_declaration</span></code>
+        is not specified and if the document does not have a declaration node. However,
+        the default declaration is not customizable. If you want to customize the
+        declaration output, you need to create the declaration node yourself.
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          By default the declaration node is not added to the document during parsing.
+          If you just need to preserve the original declaration node, you have to
+          add the flag <a class="link" href="loading.html#parse_declaration">parse_declaration</a>
+          to the parsing flags; the resulting document will contain the original
+          declaration node, which will be output during saving.
+        </p></td></tr>
+</table></div>
+<p>
+        Declaration node is a node with type <a class="link" href="dom.html#node_declaration">node_declaration</a>;
+        it behaves like an element node in that it has attributes with values (but
+        it does not have child nodes). Therefore setting custom version, encoding
+        or standalone declaration involves adding attributes and setting attribute
+        values.
+      </p>
+<p>
+        This is an example that shows how to create a custom declaration node (<a href="../samples/save_declaration.cpp" target="_top">samples/save_declaration.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// get a test document
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_document</span> <span class="identifier">doc</span><span class="special">;</span>
+<span class="identifier">doc</span><span class="special">.</span><span class="identifier">load</span><span class="special">(</span><span class="string">"&lt;foo bar='baz'&gt;&lt;call&gt;hey&lt;/call&gt;&lt;/foo&gt;"</span><span class="special">);</span>
+
+<span class="comment">// add a custom declaration node
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">decl</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">prepend_child</span><span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">node_declaration</span><span class="special">);</span>
+<span class="identifier">decl</span><span class="special">.</span><span class="identifier">append_attribute</span><span class="special">(</span><span class="string">"version"</span><span class="special">)</span> <span class="special">=</span> <span class="string">"1.0"</span><span class="special">;</span>
+<span class="identifier">decl</span><span class="special">.</span><span class="identifier">append_attribute</span><span class="special">(</span><span class="string">"encoding"</span><span class="special">)</span> <span class="special">=</span> <span class="string">"UTF-8"</span><span class="special">;</span>
+<span class="identifier">decl</span><span class="special">.</span><span class="identifier">append_attribute</span><span class="special">(</span><span class="string">"standalone"</span><span class="special">)</span> <span class="special">=</span> <span class="string">"no"</span><span class="special">;</span>
+
+<span class="comment">// &lt;?xml version="1.0" encoding="UTF-8" standalone="no"?&gt; 
+</span><span class="comment">// &lt;foo bar="baz"&gt;
+</span><span class="comment">//         &lt;call&gt;hey&lt;/call&gt;
+</span><span class="comment">// &lt;/foo&gt;
+</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">save</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2012 Arseny Kapoulkine<p>
+        Distributed under the MIT License
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <b>Saving</b> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="modify.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="xpath.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+</body>
+</html>
diff --git a/tools/intergen/third_party/pugixml/docs/manual/toc.html b/tools/intergen/third_party/pugixml/docs/manual/toc.html
new file mode 100644
index 0000000000..d9fe5f876e
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/manual/toc.html
@@ -0,0 +1,160 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Table of Contents</title>
+<link rel="stylesheet" href="../pugixml.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../manual.html" title="pugixml 1.2">
+<link rel="up" href="../manual.html" title="pugixml 1.2">
+<link rel="prev" href="apiref.html" title="API Reference">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<b>Table of Contents</b>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="apiref.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a>
+</div></td>
+</tr></table>
+<hr>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="manual.toc"></a><a class="link" href="toc.html" title="Table of Contents"> Table of Contents</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="../manual.html#manual.overview"> Overview</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="../manual.html#manual.overview.introduction"> Introduction</a></span></dt>
+<dt><span class="section"><a href="../manual.html#manual.overview.feedback"> Feedback</a></span></dt>
+<dt><span class="section"><a href="../manual.html#manual.overview.thanks"> Acknowledgments</a></span></dt>
+<dt><span class="section"><a href="../manual.html#manual.overview.license"> License</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="install.html"> Installation</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="install.html#manual.install.getting"> Getting pugixml</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="install.html#manual.install.getting.source"> Source distributions</a></span></dt>
+<dt><span class="section"><a href="install.html#manual.install.getting.subversion"> Subversion repository</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="install.html#manual.install.building"> Building pugixml</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="install.html#manual.install.building.embed"> Building pugixml as
+        a part of another static library/executable</a></span></dt>
+<dt><span class="section"><a href="install.html#manual.install.building.static"> Building pugixml as
+        a standalone static library</a></span></dt>
+<dt><span class="section"><a href="install.html#manual.install.building.shared"> Building pugixml as
+        a standalone shared library</a></span></dt>
+<dt><span class="section"><a href="install.html#manual.install.building.header"> Using pugixml in header-only
+        mode</a></span></dt>
+<dt><span class="section"><a href="install.html#manual.install.building.config"> Additional configuration
+        options</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="install.html#manual.install.portability"> Portability</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="dom.html"> Document object model</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="dom.html#manual.dom.tree"> Tree structure</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.cpp"> C++ interface</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.unicode"> Unicode interface</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.thread"> Thread-safety guarantees</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.exception"> Exception guarantees</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.memory"> Memory management</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="dom.html#manual.dom.memory.custom"> Custom memory allocation/deallocation
+        functions</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.memory.tuning"> Memory consumption tuning</a></span></dt>
+<dt><span class="section"><a href="dom.html#manual.dom.memory.internals"> Document memory management
+        internals</a></span></dt>
+</dl></dd>
+</dl></dd>
+<dt><span class="section"><a href="loading.html"> Loading document</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="loading.html#manual.loading.file"> Loading document from file</a></span></dt>
+<dt><span class="section"><a href="loading.html#manual.loading.memory"> Loading document from memory</a></span></dt>
+<dt><span class="section"><a href="loading.html#manual.loading.stream"> Loading document from C++ IOstreams</a></span></dt>
+<dt><span class="section"><a href="loading.html#manual.loading.errors"> Handling parsing errors</a></span></dt>
+<dt><span class="section"><a href="loading.html#manual.loading.options"> Parsing options</a></span></dt>
+<dt><span class="section"><a href="loading.html#manual.loading.encoding"> Encodings</a></span></dt>
+<dt><span class="section"><a href="loading.html#manual.loading.w3c"> Conformance to W3C specification</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="access.html"> Accessing document data</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="access.html#manual.access.basic"> Basic traversal functions</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.nodedata"> Getting node data</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.attrdata"> Getting attribute data</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.contents"> Contents-based traversal functions</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.rangefor"> Range-based for-loop support</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.iterators"> Traversing node/attribute lists
+      via iterators</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.walker"> Recursive traversal with xml_tree_walker</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.predicate"> Searching for nodes/attributes
+      with predicates</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.text"> Working with text contents</a></span></dt>
+<dt><span class="section"><a href="access.html#manual.access.misc"> Miscellaneous functions</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="modify.html"> Modifying document data</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="modify.html#manual.modify.nodedata"> Setting node data</a></span></dt>
+<dt><span class="section"><a href="modify.html#manual.modify.attrdata"> Setting attribute data</a></span></dt>
+<dt><span class="section"><a href="modify.html#manual.modify.add"> Adding nodes/attributes</a></span></dt>
+<dt><span class="section"><a href="modify.html#manual.modify.remove"> Removing nodes/attributes</a></span></dt>
+<dt><span class="section"><a href="modify.html#manual.modify.text"> Working with text contents</a></span></dt>
+<dt><span class="section"><a href="modify.html#manual.modify.clone"> Cloning nodes/attributes</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="saving.html"> Saving document</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="saving.html#manual.saving.file"> Saving document to a file</a></span></dt>
+<dt><span class="section"><a href="saving.html#manual.saving.stream"> Saving document to C++ IOstreams</a></span></dt>
+<dt><span class="section"><a href="saving.html#manual.saving.writer"> Saving document via writer interface</a></span></dt>
+<dt><span class="section"><a href="saving.html#manual.saving.subtree"> Saving a single subtree</a></span></dt>
+<dt><span class="section"><a href="saving.html#manual.saving.options"> Output options</a></span></dt>
+<dt><span class="section"><a href="saving.html#manual.saving.encoding"> Encodings</a></span></dt>
+<dt><span class="section"><a href="saving.html#manual.saving.declaration"> Customizing document declaration</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="xpath.html"> XPath</a></span></dt>
+<dd><dl>
+<dt><span class="section"><a href="xpath.html#manual.xpath.types"> XPath types</a></span></dt>
+<dt><span class="section"><a href="xpath.html#manual.xpath.select"> Selecting nodes via XPath expression</a></span></dt>
+<dt><span class="section"><a href="xpath.html#manual.xpath.query"> Using query objects</a></span></dt>
+<dt><span class="section"><a href="xpath.html#manual.xpath.variables"> Using variables</a></span></dt>
+<dt><span class="section"><a href="xpath.html#manual.xpath.errors"> Error handling</a></span></dt>
+<dt><span class="section"><a href="xpath.html#manual.xpath.w3c"> Conformance to W3C specification</a></span></dt>
+</dl></dd>
+<dt><span class="section"><a href="changes.html"> Changelog</a></span></dt>
+<dt><span class="section"><a href="apiref.html"> API Reference</a></span></dt>
+<dt><span class="section"><a href="toc.html"> Table of Contents</a></span></dt>
+</dl></div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2012 Arseny Kapoulkine<p>
+        Distributed under the MIT License
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<a href="xpath.html">XPath</a> |
+		<a href="apiref.html">API Reference</a> |
+		<b>Table of Contents</b>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="apiref.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a>
+</div></td>
+</tr></table>
+</body>
+</html>
diff --git a/tools/intergen/third_party/pugixml/docs/manual/xpath.html b/tools/intergen/third_party/pugixml/docs/manual/xpath.html
new file mode 100644
index 0000000000..bb37f6470c
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/manual/xpath.html
@@ -0,0 +1,746 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>XPath</title>
+<link rel="stylesheet" href="../pugixml.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="../manual.html" title="pugixml 1.2">
+<link rel="up" href="../manual.html" title="pugixml 1.2">
+<link rel="prev" href="saving.html" title="Saving document">
+<link rel="next" href="changes.html" title="Changelog">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<b>XPath</b> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="saving.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="changes.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+<hr>
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="manual.xpath"></a><a class="link" href="xpath.html" title="XPath"> XPath</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="xpath.html#manual.xpath.types"> XPath types</a></span></dt>
+<dt><span class="section"><a href="xpath.html#manual.xpath.select"> Selecting nodes via XPath expression</a></span></dt>
+<dt><span class="section"><a href="xpath.html#manual.xpath.query"> Using query objects</a></span></dt>
+<dt><span class="section"><a href="xpath.html#manual.xpath.variables"> Using variables</a></span></dt>
+<dt><span class="section"><a href="xpath.html#manual.xpath.errors"> Error handling</a></span></dt>
+<dt><span class="section"><a href="xpath.html#manual.xpath.w3c"> Conformance to W3C specification</a></span></dt>
+</dl></div>
+<p>
+      If the task at hand is to select a subset of document nodes that match some
+      criteria, it is possible to code a function using the existing traversal functionality
+      for any practical criteria. However, often either a data-driven approach is
+      desirable, in case the criteria are not predefined and come from a file, or
+      it is inconvenient to use traversal interfaces and a higher-level DSL is required.
+      There is a standard language for XML processing, XPath, that can be useful
+      for these cases. pugixml implements an almost complete subset of XPath 1.0.
+      Because of differences in document object model and some performance implications,
+      there are minor violations of the official specifications, which can be found
+      in <a class="xref" href="xpath.html#manual.xpath.w3c" title="Conformance to W3C specification"> Conformance to W3C specification</a>. The rest of this section describes the interface for XPath
+      functionality. Please note that if you wish to learn to use XPath language,
+      you have to look for other tutorials or manuals; for example, you can read
+      <a href="http://www.w3schools.com/xpath/" target="_top">W3Schools XPath tutorial</a>,
+      <a href="http://www.tizag.com/xmlTutorial/xpathtutorial.php" target="_top">XPath tutorial
+      at tizag.com</a>, and <a href="http://www.w3.org/TR/xpath/" target="_top">the XPath
+      1.0 specification</a>.
+    </p>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.xpath.types"></a><a class="link" href="xpath.html#manual.xpath.types" title="XPath types"> XPath types</a>
+</h3></div></div></div>
+<a name="xpath_value_type"></a><a name="xpath_type_number"></a><a name="xpath_type_string"></a><a name="xpath_type_boolean"></a><a name="xpath_type_node_set"></a><a name="xpath_type_none"></a><p>
+        Each XPath expression can have one of the following types: boolean, number,
+        string or node set. Boolean type corresponds to <code class="computeroutput"><span class="keyword">bool</span></code>
+        type, number type corresponds to <code class="computeroutput"><span class="keyword">double</span></code>
+        type, string type corresponds to either <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code>
+        or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">wstring</span></code>, depending on whether <a class="link" href="dom.html#manual.dom.unicode" title="Unicode interface">wide
+        character interface is enabled</a>, and node set corresponds to <a class="link" href="xpath.html#xpath_node_set">xpath_node_set</a> type. There is an enumeration,
+        <code class="computeroutput"><span class="identifier">xpath_value_type</span></code>, which can
+        take the values <code class="computeroutput"><span class="identifier">xpath_type_boolean</span></code>,
+        <code class="computeroutput"><span class="identifier">xpath_type_number</span></code>, <code class="computeroutput"><span class="identifier">xpath_type_string</span></code> or <code class="computeroutput"><span class="identifier">xpath_type_node_set</span></code>,
+        accordingly.
+      </p>
+<a name="xpath_node"></a><a name="xpath_node::node"></a><a name="xpath_node::attribute"></a><a name="xpath_node::parent"></a><p>
+        Because an XPath node can be either a node or an attribute, there is a special
+        type, <code class="computeroutput"><span class="identifier">xpath_node</span></code>, which is
+        a discriminated union of these types. A value of this type contains two node
+        handles, one of <code class="computeroutput"><span class="identifier">xml_node</span></code>
+        type, and another one of <code class="computeroutput"><span class="identifier">xml_attribute</span></code>
+        type; at most one of them can be non-null. The accessors to get these handles
+        are available:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_node</span> <span class="identifier">xpath_node</span><span class="special">::</span><span class="identifier">node</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xml_attribute</span> <span class="identifier">xpath_node</span><span class="special">::</span><span class="identifier">attribute</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        XPath nodes can be null, in which case both accessors return null handles.
+      </p>
+<p>
+        Note that as per XPath specification, each XPath node has a parent, which
+        can be retrieved via this function:
+      </p>
+<pre class="programlisting"><span class="identifier">xml_node</span> <span class="identifier">xpath_node</span><span class="special">::</span><span class="identifier">parent</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        <code class="computeroutput"><span class="identifier">parent</span></code> function returns the
+        node's parent if the XPath node corresponds to <code class="computeroutput"><span class="identifier">xml_node</span></code>
+        handle (equivalent to <code class="computeroutput"><span class="identifier">node</span><span class="special">().</span><span class="identifier">parent</span><span class="special">()</span></code>), or the node to which the attribute belongs
+        to, if the XPath node corresponds to <code class="computeroutput"><span class="identifier">xml_attribute</span></code>
+        handle. For null nodes, <code class="computeroutput"><span class="identifier">parent</span></code>
+        returns null handle.
+      </p>
+<a name="xpath_node::unspecified_bool_type"></a><a name="xpath_node::comparison"></a><p>
+        Like node and attribute handles, XPath node handles can be implicitly cast
+        to boolean-like object to check if it is a null node, and also can be compared
+        for equality with each other.
+      </p>
+<a name="xpath_node::ctor"></a><p>
+        You can also create XPath nodes with one of the three constructors: the default
+        constructor, the constructor that takes node argument, and the constructor
+        that takes attribute and node arguments (in which case the attribute must
+        belong to the attribute list of the node). The constructor from <code class="computeroutput"><span class="identifier">xml_node</span></code> is implicit, so you can usually
+        pass <code class="computeroutput"><span class="identifier">xml_node</span></code> to functions
+        that expect <code class="computeroutput"><span class="identifier">xpath_node</span></code>. Apart
+        from that you usually don't need to create your own XPath node objects, since
+        they are returned to you via selection functions.
+      </p>
+<a name="xpath_node_set"></a><p>
+        XPath expressions operate not on single nodes, but instead on node sets.
+        A node set is a collection of nodes, which can be optionally ordered in either
+        a forward document order or a reverse one. Document order is defined in XPath
+        specification; an XPath node is before another node in document order if
+        it appears before it in XML representation of the corresponding document.
+      </p>
+<a name="xpath_node_set::const_iterator"></a><a name="xpath_node_set::begin"></a><a name="xpath_node_set::end"></a><p>
+        Node sets are represented by <code class="computeroutput"><span class="identifier">xpath_node_set</span></code>
+        object, which has an interface that resembles one of sequential random-access
+        containers. It has an iterator type along with usual begin/past-the-end iterator
+        accessors:
+      </p>
+<pre class="programlisting"><span class="keyword">typedef</span> <span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">*</span> <span class="identifier">xpath_node_set</span><span class="special">::</span><span class="identifier">const_iterator</span><span class="special">;</span>
+<span class="identifier">const_iterator</span> <span class="identifier">xpath_node_set</span><span class="special">::</span><span class="identifier">begin</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">const_iterator</span> <span class="identifier">xpath_node_set</span><span class="special">::</span><span class="identifier">end</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<a name="xpath_node_set::index"></a><a name="xpath_node_set::size"></a><a name="xpath_node_set::empty"></a><p>
+        And it also can be iterated via indices, just like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code>:
+      </p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span> <span class="identifier">xpath_node_set</span><span class="special">::</span><span class="keyword">operator</span><span class="special">[](</span><span class="identifier">size_t</span> <span class="identifier">index</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">size_t</span> <span class="identifier">xpath_node_set</span><span class="special">::</span><span class="identifier">size</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">bool</span> <span class="identifier">xpath_node_set</span><span class="special">::</span><span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        All of the above operations have the same semantics as that of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span></code>:
+        the iterators are random-access, all of the above operations are constant
+        time, and accessing the element at index that is greater or equal than the
+        set size results in undefined behavior. You can use both iterator-based and
+        index-based access for iteration, however the iterator-based one can be faster.
+      </p>
+<a name="xpath_node_set::type"></a><a name="xpath_node_set::type_unsorted"></a><a name="xpath_node_set::type_sorted"></a><a name="xpath_node_set::type_sorted_reverse"></a><a name="xpath_node_set::sort"></a><p>
+        The order of iteration depends on the order of nodes inside the set; the
+        order can be queried via the following function:
+      </p>
+<pre class="programlisting"><span class="keyword">enum</span> <span class="identifier">xpath_node_set</span><span class="special">::</span><span class="identifier">type_t</span> <span class="special">{</span><span class="identifier">type_unsorted</span><span class="special">,</span> <span class="identifier">type_sorted</span><span class="special">,</span> <span class="identifier">type_sorted_reverse</span><span class="special">};</span>
+<span class="identifier">type_t</span> <span class="identifier">xpath_node_set</span><span class="special">::</span><span class="identifier">type</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        <code class="computeroutput"><span class="identifier">type</span></code> function returns the
+        current order of nodes; <code class="computeroutput"><span class="identifier">type_sorted</span></code>
+        means that the nodes are in forward document order, <code class="computeroutput"><span class="identifier">type_sorted_reverse</span></code>
+        means that the nodes are in reverse document order, and <code class="computeroutput"><span class="identifier">type_unsorted</span></code>
+        means that neither order is guaranteed (nodes can accidentally be in a sorted
+        order even if <code class="computeroutput"><span class="identifier">type</span><span class="special">()</span></code>
+        returns <code class="computeroutput"><span class="identifier">type_unsorted</span></code>). If
+        you require a specific order of iteration, you can change it via <code class="computeroutput"><span class="identifier">sort</span></code> function:
+      </p>
+<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">xpath_node_set</span><span class="special">::</span><span class="identifier">sort</span><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">reverse</span> <span class="special">=</span> <span class="keyword">false</span><span class="special">);</span>
+</pre>
+<p>
+        Calling <code class="computeroutput"><span class="identifier">sort</span></code> sorts the nodes
+        in either forward or reverse document order, depending on the argument; after
+        this call <code class="computeroutput"><span class="identifier">type</span><span class="special">()</span></code>
+        will return <code class="computeroutput"><span class="identifier">type_sorted</span></code> or
+        <code class="computeroutput"><span class="identifier">type_sorted_reverse</span></code>.
+      </p>
+<a name="xpath_node_set::first"></a><p>
+        Often the actual iteration is not needed; instead, only the first element
+        in document order is required. For this, a special accessor is provided:
+      </p>
+<pre class="programlisting"><span class="identifier">xpath_node</span> <span class="identifier">xpath_node_set</span><span class="special">::</span><span class="identifier">first</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        This function returns the first node in forward document order from the set,
+        or null node if the set is empty. Note that while the result of the node
+        does not depend on the order of nodes in the set (i.e. on the result of
+        <code class="computeroutput"><span class="identifier">type</span><span class="special">()</span></code>),
+        the complexity does - if the set is sorted, the complexity is constant, otherwise
+        it is linear in the number of elements or worse.
+      </p>
+<a name="xpath_node_set::ctor"></a><p>
+        While in the majority of cases the node set is returned by XPath functions,
+        sometimes there is a need to manually construct a node set. For such cases,
+        a constructor is provided which takes an iterator range (<code class="computeroutput"><span class="identifier">const_iterator</span></code>
+        is a typedef for <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">*</span></code>), and an optional type:
+      </p>
+<pre class="programlisting"><span class="identifier">xpath_node_set</span><span class="special">::</span><span class="identifier">xpath_node_set</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">begin</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="identifier">end</span><span class="special">,</span> <span class="identifier">type_t</span> <span class="identifier">type</span> <span class="special">=</span> <span class="identifier">type_unsorted</span><span class="special">);</span>
+</pre>
+<p>
+        The constructor copies the specified range and sets the specified type. The
+        objects in the range are not checked in any way; you'll have to ensure that
+        the range contains no duplicates, and that the objects are sorted according
+        to the <code class="computeroutput"><span class="identifier">type</span></code> parameter. Otherwise
+        XPath operations with this set may produce unexpected results.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.xpath.select"></a><a class="link" href="xpath.html#manual.xpath.select" title="Selecting nodes via XPath expression"> Selecting nodes via XPath expression</a>
+</h3></div></div></div>
+<a name="xml_node::select_single_node"></a><a name="xml_node::select_nodes"></a><p>
+        If you want to select nodes that match some XPath expression, you can do
+        it with the following functions:
+      </p>
+<pre class="programlisting"><span class="identifier">xpath_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">select_single_node</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">query</span><span class="special">,</span> <span class="identifier">xpath_variable_set</span><span class="special">*</span> <span class="identifier">variables</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xpath_node_set</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">select_nodes</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">query</span><span class="special">,</span> <span class="identifier">xpath_variable_set</span><span class="special">*</span> <span class="identifier">variables</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        <code class="computeroutput"><span class="identifier">select_nodes</span></code> function compiles
+        the expression and then executes it with the node as a context node, and
+        returns the resulting node set. <code class="computeroutput"><span class="identifier">select_single_node</span></code>
+        returns only the first node in document order from the result, and is equivalent
+        to calling <code class="computeroutput"><span class="identifier">select_nodes</span><span class="special">(</span><span class="identifier">query</span><span class="special">).</span><span class="identifier">first</span><span class="special">()</span></code>.
+        If the XPath expression does not match anything, or the node handle is null,
+        <code class="computeroutput"><span class="identifier">select_nodes</span></code> returns an empty
+        set, and <code class="computeroutput"><span class="identifier">select_single_node</span></code>
+        returns null XPath node.
+      </p>
+<p>
+        If exception handling is not disabled, both functions throw <a class="link" href="xpath.html#xpath_exception">xpath_exception</a>
+        if the query can not be compiled or if it returns a value with type other
+        than node set; see <a class="xref" href="xpath.html#manual.xpath.errors" title="Error handling"> Error handling</a> for details.
+      </p>
+<a name="xml_node::select_single_node_precomp"></a><a name="xml_node::select_nodes_precomp"></a><p>
+        While compiling expressions is fast, the compilation time can introduce a
+        significant overhead if the same expression is used many times on small subtrees.
+        If you're doing many similar queries, consider compiling them into query
+        objects (see <a class="xref" href="xpath.html#manual.xpath.query" title="Using query objects"> Using query objects</a> for further reference). Once you get a compiled
+        query object, you can pass it to select functions instead of an expression
+        string:
+      </p>
+<pre class="programlisting"><span class="identifier">xpath_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">select_single_node</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_query</span><span class="special">&amp;</span> <span class="identifier">query</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xpath_node_set</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">select_nodes</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_query</span><span class="special">&amp;</span> <span class="identifier">query</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        If exception handling is not disabled, both functions throw <a class="link" href="xpath.html#xpath_exception">xpath_exception</a>
+        if the query returns a value with type other than node set.
+      </p>
+<p>
+        This is an example of selecting nodes using XPath expressions (<a href="../samples/xpath_select.cpp" target="_top">samples/xpath_select.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_node_set</span> <span class="identifier">tools</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">select_nodes</span><span class="special">(</span><span class="string">"/Profile/Tools/Tool[@AllowRemote='true' and @DeriveCaptionFrom='lastparam']"</span><span class="special">);</span>
+
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Tools:"</span><span class="special">;</span>
+
+<span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_node_set</span><span class="special">::</span><span class="identifier">const_iterator</span> <span class="identifier">it</span> <span class="special">=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span> <span class="identifier">it</span> <span class="special">!=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span> <span class="special">++</span><span class="identifier">it</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_node</span> <span class="identifier">node</span> <span class="special">=</span> <span class="special">*</span><span class="identifier">it</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">node</span><span class="special">().</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Filename"</span><span class="special">).</span><span class="identifier">value</span><span class="special">();</span>
+<span class="special">}</span>
+
+<span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_node</span> <span class="identifier">build_tool</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">select_single_node</span><span class="special">(</span><span class="string">"//Tool[contains(Description, 'build system')]"</span><span class="special">);</span>
+
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\nBuild tool: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">build_tool</span><span class="special">.</span><span class="identifier">node</span><span class="special">().</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Filename"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.xpath.query"></a><a class="link" href="xpath.html#manual.xpath.query" title="Using query objects"> Using query objects</a>
+</h3></div></div></div>
+<a name="xpath_query"></a><p>
+        When you call <code class="computeroutput"><span class="identifier">select_nodes</span></code>
+        with an expression string as an argument, a query object is created behind
+        the scenes. A query object represents a compiled XPath expression. Query
+        objects can be needed in the following circumstances:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            You can precompile expressions to query objects to save compilation time
+            if it becomes an issue;
+          </li>
+<li class="listitem">
+            You can use query objects to evaluate XPath expressions which result
+            in booleans, numbers or strings;
+          </li>
+<li class="listitem">
+            You can get the type of expression value via query object.
+          </li>
+</ul></div>
+<p>
+        Query objects correspond to <code class="computeroutput"><span class="identifier">xpath_query</span></code>
+        type. They are immutable and non-copyable: they are bound to the expression
+        at creation time and can not be cloned. If you want to put query objects
+        in a container, allocate them on heap via <code class="computeroutput"><span class="keyword">new</span></code>
+        operator and store pointers to <code class="computeroutput"><span class="identifier">xpath_query</span></code>
+        in the container.
+      </p>
+<a name="xpath_query::ctor"></a><p>
+        You can create a query object with the constructor that takes XPath expression
+        as an argument:
+      </p>
+<pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">xpath_query</span><span class="special">::</span><span class="identifier">xpath_query</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">query</span><span class="special">,</span> <span class="identifier">xpath_variable_set</span><span class="special">*</span> <span class="identifier">variables</span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span>
+</pre>
+<a name="xpath_query::return_type"></a><p>
+        The expression is compiled and the compiled representation is stored in the
+        new query object. If compilation fails, <a class="link" href="xpath.html#xpath_exception">xpath_exception</a>
+        is thrown if exception handling is not disabled (see <a class="xref" href="xpath.html#manual.xpath.errors" title="Error handling"> Error handling</a> for
+        details). After the query is created, you can query the type of the evaluation
+        result using the following function:
+      </p>
+<pre class="programlisting"><span class="identifier">xpath_value_type</span> <span class="identifier">xpath_query</span><span class="special">::</span><span class="identifier">return_type</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<a name="xpath_query::evaluate_boolean"></a><a name="xpath_query::evaluate_number"></a><a name="xpath_query::evaluate_string"></a><a name="xpath_query::evaluate_node_set"></a><p>
+        You can evaluate the query using one of the following functions:
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xpath_query</span><span class="special">::</span><span class="identifier">evaluate_boolean</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">double</span> <span class="identifier">xpath_query</span><span class="special">::</span><span class="identifier">evaluate_number</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">string_t</span> <span class="identifier">xpath_query</span><span class="special">::</span><span class="identifier">evaluate_string</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xpath_node_set</span> <span class="identifier">xpath_query</span><span class="special">::</span><span class="identifier">evaluate_node_set</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        All functions take the context node as an argument, compute the expression
+        and return the result, converted to the requested type. According to XPath
+        specification, value of any type can be converted to boolean, number or string
+        value, but no type other than node set can be converted to node set. Because
+        of this, <code class="computeroutput"><span class="identifier">evaluate_boolean</span></code>,
+        <code class="computeroutput"><span class="identifier">evaluate_number</span></code> and <code class="computeroutput"><span class="identifier">evaluate_string</span></code> always return a result,
+        but <code class="computeroutput"><span class="identifier">evaluate_node_set</span></code> results
+        in an error if the return type is not node set (see <a class="xref" href="xpath.html#manual.xpath.errors" title="Error handling"> Error handling</a>).
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          Calling <code class="computeroutput"><span class="identifier">node</span><span class="special">.</span><span class="identifier">select_nodes</span><span class="special">(</span><span class="string">"query"</span><span class="special">)</span></code>
+          is equivalent to calling <code class="computeroutput"><span class="identifier">xpath_query</span><span class="special">(</span><span class="string">"query"</span><span class="special">).</span><span class="identifier">evaluate_node_set</span><span class="special">(</span><span class="identifier">node</span><span class="special">)</span></code>.
+        </p></td></tr>
+</table></div>
+<a name="xpath_query::evaluate_string_buffer"></a><p>
+        Note that <code class="computeroutput"><span class="identifier">evaluate_string</span></code>
+        function returns the STL string; as such, it's not available in <a class="link" href="install.html#PUGIXML_NO_STL">PUGIXML_NO_STL</a>
+        mode and also usually allocates memory. There is another string evaluation
+        function:
+      </p>
+<pre class="programlisting"><span class="identifier">size_t</span> <span class="identifier">xpath_query</span><span class="special">::</span><span class="identifier">evaluate_string</span><span class="special">(</span><span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">capacity</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">xpath_node</span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        This function evaluates the string, and then writes the result to <code class="computeroutput"><span class="identifier">buffer</span></code> (but at most <code class="computeroutput"><span class="identifier">capacity</span></code>
+        characters); then it returns the full size of the result in characters, including
+        the terminating zero. If <code class="computeroutput"><span class="identifier">capacity</span></code>
+        is not 0, the resulting buffer is always zero-terminated. You can use this
+        function as follows:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            First call the function with <code class="computeroutput"><span class="identifier">buffer</span>
+            <span class="special">=</span> <span class="number">0</span></code>
+            and <code class="computeroutput"><span class="identifier">capacity</span> <span class="special">=</span>
+            <span class="number">0</span></code>; then allocate the returned amount
+            of characters, and call the function again, passing the allocated storage
+            and the amount of characters;
+          </li>
+<li class="listitem">
+            First call the function with small buffer and buffer capacity; then,
+            if the result is larger than the capacity, the output has been trimmed,
+            so allocate a larger buffer and call the function again.
+          </li>
+</ul></div>
+<p>
+        This is an example of using query objects (<a href="../samples/xpath_query.cpp" target="_top">samples/xpath_query.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// Select nodes via compiled query
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_query</span> <span class="identifier">query_remote_tools</span><span class="special">(</span><span class="string">"/Profile/Tools/Tool[@AllowRemote='true']"</span><span class="special">);</span>
+
+<span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_node_set</span> <span class="identifier">tools</span> <span class="special">=</span> <span class="identifier">query_remote_tools</span><span class="special">.</span><span class="identifier">evaluate_node_set</span><span class="special">(</span><span class="identifier">doc</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Remote tool: "</span><span class="special">;</span>
+<span class="identifier">tools</span><span class="special">[</span><span class="number">2</span><span class="special">].</span><span class="identifier">node</span><span class="special">().</span><span class="identifier">print</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">);</span>
+
+<span class="comment">// Evaluate numbers via compiled query
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_query</span> <span class="identifier">query_timeouts</span><span class="special">(</span><span class="string">"sum(//Tool/@Timeout)"</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">query_timeouts</span><span class="special">.</span><span class="identifier">evaluate_number</span><span class="special">(</span><span class="identifier">doc</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// Evaluate strings via compiled query for different context nodes
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_query</span> <span class="identifier">query_name_valid</span><span class="special">(</span><span class="string">"string-length(substring-before(@Filename, '_')) &gt; 0 and @OutputFileMasks"</span><span class="special">);</span>
+<span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_query</span> <span class="identifier">query_name</span><span class="special">(</span><span class="string">"concat(substring-before(@Filename, '_'), ' produces ', @OutputFileMasks)"</span><span class="special">);</span>
+
+<span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">first_element_by_path</span><span class="special">(</span><span class="string">"Profile/Tools/Tool"</span><span class="special">);</span> <span class="identifier">tool</span><span class="special">;</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">next_sibling</span><span class="special">())</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">s</span> <span class="special">=</span> <span class="identifier">query_name</span><span class="special">.</span><span class="identifier">evaluate_string</span><span class="special">(</span><span class="identifier">tool</span><span class="special">);</span>
+
+    <span class="keyword">if</span> <span class="special">(</span><span class="identifier">query_name_valid</span><span class="special">.</span><span class="identifier">evaluate_boolean</span><span class="special">(</span><span class="identifier">tool</span><span class="special">))</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">s</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.xpath.variables"></a><a class="link" href="xpath.html#manual.xpath.variables" title="Using variables"> Using variables</a>
+</h3></div></div></div>
+<p>
+        XPath queries may contain references to variables; this is useful if you
+        want to use queries that depend on some dynamic parameter without manually
+        preparing the complete query string, or if you want to reuse the same query
+        object for similar queries.
+      </p>
+<p>
+        Variable references have the form <code class="computeroutput"><span class="identifier">$name</span></code>; in order to use them, you have to provide
+        a variable set, which includes all variables present in the query with correct
+        types. This set is passed to <code class="computeroutput"><span class="identifier">xpath_query</span></code>
+        constructor or to <code class="computeroutput"><span class="identifier">select_nodes</span></code>/<code class="computeroutput"><span class="identifier">select_single_node</span></code> functions:
+      </p>
+<pre class="programlisting"><span class="keyword">explicit</span> <span class="identifier">xpath_query</span><span class="special">::</span><span class="identifier">xpath_query</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">query</span><span class="special">,</span> <span class="identifier">xpath_variable_set</span><span class="special">*</span> <span class="identifier">variables</span> <span class="special">=</span> <span class="number">0</span><span class="special">);</span>
+<span class="identifier">xpath_node</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">select_single_node</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">query</span><span class="special">,</span> <span class="identifier">xpath_variable_set</span><span class="special">*</span> <span class="identifier">variables</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xpath_node_set</span> <span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">select_nodes</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">query</span><span class="special">,</span> <span class="identifier">xpath_variable_set</span><span class="special">*</span> <span class="identifier">variables</span> <span class="special">=</span> <span class="number">0</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        If you're using query objects, you can change the variable values before
+        <code class="computeroutput"><span class="identifier">evaluate</span></code>/<code class="computeroutput"><span class="identifier">select</span></code>
+        calls to change the query behavior.
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          The variable set pointer is stored in the query object; you have to ensure
+          that the lifetime of the set exceeds that of query object.
+        </p></td></tr>
+</table></div>
+<a name="xpath_variable_set"></a><p>
+        Variable sets correspond to <code class="computeroutput"><span class="identifier">xpath_variable_set</span></code>
+        type, which is essentially a variable container.
+      </p>
+<a name="xpath_variable_set::add"></a><p>
+        You can add new variables with the following function:
+      </p>
+<pre class="programlisting"><span class="identifier">xpath_variable</span><span class="special">*</span> <span class="identifier">xpath_variable_set</span><span class="special">::</span><span class="identifier">add</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">,</span> <span class="identifier">xpath_value_type</span> <span class="identifier">type</span><span class="special">);</span>
+</pre>
+<p>
+        The function tries to add a new variable with the specified name and type;
+        if the variable with such name does not exist in the set, the function adds
+        a new variable and returns the variable handle; if there is already a variable
+        with the specified name, the function returns the variable handle if variable
+        has the specified type. Otherwise the function returns null pointer; it also
+        returns null pointer on allocation failure.
+      </p>
+<p>
+        New variables are assigned the default value which depends on the type:
+        <code class="computeroutput"><span class="number">0</span></code> for numbers, <code class="computeroutput"><span class="keyword">false</span></code> for booleans, empty string for strings
+        and empty set for node sets.
+      </p>
+<a name="xpath_variable_set::get"></a><p>
+        You can get the existing variables with the following functions:
+      </p>
+<pre class="programlisting"><span class="identifier">xpath_variable</span><span class="special">*</span> <span class="identifier">xpath_variable_set</span><span class="special">::</span><span class="identifier">get</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">);</span>
+<span class="keyword">const</span> <span class="identifier">xpath_variable</span><span class="special">*</span> <span class="identifier">xpath_variable_set</span><span class="special">::</span><span class="identifier">get</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        The functions return the variable handle, or null pointer if the variable
+        with the specified name is not found.
+      </p>
+<a name="xpath_variable_set::set"></a><p>
+        Additionally, there are the helper functions for setting the variable value
+        by name; they try to add the variable with the corresponding type, if it
+        does not exist, and to set the value. If the variable with the same name
+        but with different type is already present, they return <code class="computeroutput"><span class="keyword">false</span></code>;
+        they also return <code class="computeroutput"><span class="keyword">false</span></code> on allocation
+        failure. Note that these functions do not perform any type conversions.
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xpath_variable_set</span><span class="special">::</span><span class="identifier">set</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">value</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xpath_variable_set</span><span class="special">::</span><span class="identifier">set</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">,</span> <span class="keyword">double</span> <span class="identifier">value</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xpath_variable_set</span><span class="special">::</span><span class="identifier">set</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">value</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xpath_variable_set</span><span class="special">::</span><span class="identifier">set</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">name</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">xpath_node_set</span><span class="special">&amp;</span> <span class="identifier">value</span><span class="special">);</span>
+</pre>
+<p>
+        The variable values are copied to the internal variable storage, so you can
+        modify or destroy them after the functions return.
+      </p>
+<a name="xpath_variable"></a><p>
+        If setting variables by name is not efficient enough, or if you have to inspect
+        variable information or get variable values, you can use variable handles.
+        A variable corresponds to the <code class="computeroutput"><span class="identifier">xpath_variable</span></code>
+        type, and a variable handle is simply a pointer to <code class="computeroutput"><span class="identifier">xpath_variable</span></code>.
+      </p>
+<a name="xpath_variable::type"></a><a name="xpath_variable::name"></a><p>
+        In order to get variable information, you can use one of the following functions:
+      </p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">xpath_variable</span><span class="special">::</span><span class="identifier">name</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="identifier">xpath_value_type</span> <span class="identifier">xpath_variable</span><span class="special">::</span><span class="identifier">type</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        Note that each variable has a distinct type which is specified upon variable
+        creation and can not be changed later.
+      </p>
+<a name="xpath_variable::get_boolean"></a><a name="xpath_variable::get_number"></a><a name="xpath_variable::get_string"></a><a name="xpath_variable::get_node_set"></a><p>
+        In order to get variable value, you should use one of the following functions,
+        depending on the variable type:
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xpath_variable</span><span class="special">::</span><span class="identifier">get_boolean</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">double</span> <span class="identifier">xpath_variable</span><span class="special">::</span><span class="identifier">get_number</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">xpath_variable</span><span class="special">::</span><span class="identifier">get_string</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="keyword">const</span> <span class="identifier">xpath_node_set</span><span class="special">&amp;</span> <span class="identifier">xpath_variable</span><span class="special">::</span><span class="identifier">get_node_set</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        These functions return the value of the variable. Note that no type conversions
+        are performed; if the type mismatch occurs, a dummy value is returned (<code class="computeroutput"><span class="keyword">false</span></code> for booleans, <code class="computeroutput"><span class="identifier">NaN</span></code>
+        for numbers, empty string for strings and empty set for node sets).
+      </p>
+<a name="xpath_variable::set"></a><p>
+        In order to set variable value, you should use one of the following functions,
+        depending on the variable type:
+      </p>
+<pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">xpath_variable</span><span class="special">::</span><span class="identifier">set</span><span class="special">(</span><span class="keyword">bool</span> <span class="identifier">value</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xpath_variable</span><span class="special">::</span><span class="identifier">set</span><span class="special">(</span><span class="keyword">double</span> <span class="identifier">value</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xpath_variable</span><span class="special">::</span><span class="identifier">set</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">char_t</span><span class="special">*</span> <span class="identifier">value</span><span class="special">);</span>
+<span class="keyword">bool</span> <span class="identifier">xpath_variable</span><span class="special">::</span><span class="identifier">set</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">xpath_node_set</span><span class="special">&amp;</span> <span class="identifier">value</span><span class="special">);</span>
+</pre>
+<p>
+        These functions modify the variable value. Note that no type conversions
+        are performed; if the type mismatch occurs, the functions return <code class="computeroutput"><span class="keyword">false</span></code>; they also return <code class="computeroutput"><span class="keyword">false</span></code>
+        on allocation failure. The variable values are copied to the internal variable
+        storage, so you can modify or destroy them after the functions return.
+      </p>
+<p>
+        This is an example of using variables in XPath queries (<a href="../samples/xpath_variables.cpp" target="_top">samples/xpath_variables.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// Select nodes via compiled query
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_variable_set</span> <span class="identifier">vars</span><span class="special">;</span>
+<span class="identifier">vars</span><span class="special">.</span><span class="identifier">add</span><span class="special">(</span><span class="string">"remote"</span><span class="special">,</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_type_boolean</span><span class="special">);</span>
+
+<span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_query</span> <span class="identifier">query_remote_tools</span><span class="special">(</span><span class="string">"/Profile/Tools/Tool[@AllowRemote = string($remote)]"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">vars</span><span class="special">);</span>
+
+<span class="identifier">vars</span><span class="special">.</span><span class="identifier">set</span><span class="special">(</span><span class="string">"remote"</span><span class="special">,</span> <span class="keyword">true</span><span class="special">);</span>
+<span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_node_set</span> <span class="identifier">tools_remote</span> <span class="special">=</span> <span class="identifier">query_remote_tools</span><span class="special">.</span><span class="identifier">evaluate_node_set</span><span class="special">(</span><span class="identifier">doc</span><span class="special">);</span>
+
+<span class="identifier">vars</span><span class="special">.</span><span class="identifier">set</span><span class="special">(</span><span class="string">"remote"</span><span class="special">,</span> <span class="keyword">false</span><span class="special">);</span>
+<span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_node_set</span> <span class="identifier">tools_local</span> <span class="special">=</span> <span class="identifier">query_remote_tools</span><span class="special">.</span><span class="identifier">evaluate_node_set</span><span class="special">(</span><span class="identifier">doc</span><span class="special">);</span>
+
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Remote tool: "</span><span class="special">;</span>
+<span class="identifier">tools_remote</span><span class="special">[</span><span class="number">2</span><span class="special">].</span><span class="identifier">node</span><span class="special">().</span><span class="identifier">print</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">);</span>
+
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Local tool: "</span><span class="special">;</span>
+<span class="identifier">tools_local</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">node</span><span class="special">().</span><span class="identifier">print</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">);</span>
+
+<span class="comment">// You can pass the context directly to select_nodes/select_single_node
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_node_set</span> <span class="identifier">tools_local_imm</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">select_nodes</span><span class="special">(</span><span class="string">"/Profile/Tools/Tool[@AllowRemote = string($remote)]"</span><span class="special">,</span> <span class="special">&amp;</span><span class="identifier">vars</span><span class="special">);</span>
+
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Local tool imm: "</span><span class="special">;</span>
+<span class="identifier">tools_local_imm</span><span class="special">[</span><span class="number">0</span><span class="special">].</span><span class="identifier">node</span><span class="special">().</span><span class="identifier">print</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.xpath.errors"></a><a class="link" href="xpath.html#manual.xpath.errors" title="Error handling"> Error handling</a>
+</h3></div></div></div>
+<p>
+        There are two different mechanisms for error handling in XPath implementation;
+        the mechanism used depends on whether exception support is disabled (this
+        is controlled with <a class="link" href="install.html#PUGIXML_NO_EXCEPTIONS">PUGIXML_NO_EXCEPTIONS</a>
+        define).
+      </p>
+<a name="xpath_exception"></a><a name="xpath_exception::result"></a><a name="xpath_exception::what"></a><p>
+        By default, XPath functions throw <code class="computeroutput"><span class="identifier">xpath_exception</span></code>
+        object in case of errors; additionally, in the event any memory allocation
+        fails, an <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">bad_alloc</span></code> exception is thrown. Also <code class="computeroutput"><span class="identifier">xpath_exception</span></code> is thrown if the query
+        is evaluated to a node set, but the return type is not node set. If the query
+        constructor succeeds (i.e. no exception is thrown), the query object is valid.
+        Otherwise you can get the error details via one of the following functions:
+      </p>
+<pre class="programlisting"><span class="keyword">virtual</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">xpath_exception</span><span class="special">::</span><span class="identifier">what</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">throw</span><span class="special">();</span>
+<span class="keyword">const</span> <span class="identifier">xpath_parse_result</span><span class="special">&amp;</span> <span class="identifier">xpath_exception</span><span class="special">::</span><span class="identifier">result</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<a name="xpath_query::unspecified_bool_type"></a><a name="xpath_query::result"></a><p>
+        If exceptions are disabled, then in the event of parsing failure the query
+        is initialized to invalid state; you can test if the query object is valid
+        by using it in a boolean expression: <code class="computeroutput"><span class="keyword">if</span>
+        <span class="special">(</span><span class="identifier">query</span><span class="special">)</span> <span class="special">{</span> <span class="special">...</span>
+        <span class="special">}</span></code>. Additionally, you can get parsing
+        result via the result() accessor:
+      </p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="identifier">xpath_parse_result</span><span class="special">&amp;</span> <span class="identifier">xpath_query</span><span class="special">::</span><span class="identifier">result</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+</pre>
+<p>
+        Without exceptions, evaluating invalid query results in <code class="computeroutput"><span class="keyword">false</span></code>,
+        empty string, NaN or an empty node set, depending on the type; evaluating
+        a query as a node set results in an empty node set if the return type is
+        not node set.
+      </p>
+<a name="xpath_parse_result"></a><p>
+        The information about parsing result is returned via <code class="computeroutput"><span class="identifier">xpath_parse_result</span></code>
+        object. It contains parsing status and the offset of last successfully parsed
+        character from the beginning of the source stream:
+      </p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">xpath_parse_result</span>
+<span class="special">{</span>
+    <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">error</span><span class="special">;</span>
+    <span class="identifier">ptrdiff_t</span> <span class="identifier">offset</span><span class="special">;</span>
+
+    <span class="keyword">operator</span> <span class="keyword">bool</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+    <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">description</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
+<span class="special">};</span>
+</pre>
+<a name="xpath_parse_result::error"></a><p>
+        Parsing result is represented as the error message; it is either a null pointer,
+        in case there is no error, or the error message in the form of ASCII zero-terminated
+        string.
+      </p>
+<a name="xpath_parse_result::description"></a><p>
+        <code class="computeroutput"><span class="identifier">description</span><span class="special">()</span></code>
+        member function can be used to get the error message; it never returns the
+        null pointer, so you can safely use <code class="computeroutput"><span class="identifier">description</span><span class="special">()</span></code> even if query parsing succeeded. Note that
+        <code class="computeroutput"><span class="identifier">description</span><span class="special">()</span></code>
+        returns a <code class="computeroutput"><span class="keyword">char</span></code> string even in
+        <code class="computeroutput"><span class="identifier">PUGIXML_WCHAR_MODE</span></code>; you'll
+        have to call <a class="link" href="dom.html#as_wide">as_wide</a> to get the <code class="computeroutput"><span class="keyword">wchar_t</span></code> string.
+      </p>
+<a name="xpath_parse_result::offset"></a><p>
+        In addition to the error message, parsing result has an <code class="computeroutput"><span class="identifier">offset</span></code>
+        member, which contains the offset of last successfully parsed character.
+        This offset is in units of <a class="link" href="dom.html#char_t">pugi::char_t</a> (bytes
+        for character mode, wide characters for wide character mode).
+      </p>
+<a name="xpath_parse_result::bool"></a><p>
+        Parsing result object can be implicitly converted to <code class="computeroutput"><span class="keyword">bool</span></code>
+        like this: <code class="computeroutput"><span class="keyword">if</span> <span class="special">(</span><span class="identifier">result</span><span class="special">)</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span>
+        <span class="keyword">else</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span></code>.
+      </p>
+<p>
+        This is an example of XPath error handling (<a href="../samples/xpath_error.cpp" target="_top">samples/xpath_error.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// Exception is thrown for incorrect query syntax
+</span><span class="keyword">try</span>
+<span class="special">{</span>
+    <span class="identifier">doc</span><span class="special">.</span><span class="identifier">select_nodes</span><span class="special">(</span><span class="string">"//nodes[#true()]"</span><span class="special">);</span>
+<span class="special">}</span>
+<span class="keyword">catch</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_exception</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Select failed: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">e</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+
+<span class="comment">// Exception is thrown for incorrect query semantics
+</span><span class="keyword">try</span>
+<span class="special">{</span>
+    <span class="identifier">doc</span><span class="special">.</span><span class="identifier">select_nodes</span><span class="special">(</span><span class="string">"(123)/next"</span><span class="special">);</span>
+<span class="special">}</span>
+<span class="keyword">catch</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_exception</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Select failed: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">e</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+
+<span class="comment">// Exception is thrown for query with incorrect return type
+</span><span class="keyword">try</span>
+<span class="special">{</span>
+    <span class="identifier">doc</span><span class="special">.</span><span class="identifier">select_nodes</span><span class="special">(</span><span class="string">"123"</span><span class="special">);</span>
+<span class="special">}</span>
+<span class="keyword">catch</span> <span class="special">(</span><span class="keyword">const</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_exception</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Select failed: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">e</span><span class="special">.</span><span class="identifier">what</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="manual.xpath.w3c"></a><a class="link" href="xpath.html#manual.xpath.w3c" title="Conformance to W3C specification"> Conformance to W3C specification</a>
+</h3></div></div></div>
+<p>
+        Because of the differences in document object models, performance considerations
+        and implementation complexity, pugixml does not provide a fully conformant
+        XPath 1.0 implementation. This is the current list of incompatibilities:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            Consecutive text nodes sharing the same parent are not merged, i.e. in
+            <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">node</span><span class="special">&gt;</span><span class="identifier">text1</span>
+            <span class="special">&lt;![</span><span class="identifier">CDATA</span><span class="special">[</span><span class="identifier">data</span><span class="special">]]&gt;</span> <span class="identifier">text2</span><span class="special">&lt;/</span><span class="identifier">node</span><span class="special">&gt;</span></code> node should have one text node children,
+            but instead has three.
+          </li>
+<li class="listitem">
+            Since the document type declaration is not used for parsing, <code class="computeroutput"><span class="identifier">id</span><span class="special">()</span></code>
+            function always returns an empty node set.
+          </li>
+<li class="listitem">
+            Namespace nodes are not supported (affects namespace:: axis).
+          </li>
+<li class="listitem">
+            Name tests are performed on QNames in XML document instead of expanded
+            names; for <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">foo</span>
+            <span class="identifier">xmlns</span><span class="special">:</span><span class="identifier">ns1</span><span class="special">=</span><span class="char">'uri'</span> <span class="identifier">xmlns</span><span class="special">:</span><span class="identifier">ns2</span><span class="special">=</span><span class="char">'uri'</span><span class="special">&gt;&lt;</span><span class="identifier">ns1</span><span class="special">:</span><span class="identifier">child</span><span class="special">/&gt;&lt;</span><span class="identifier">ns2</span><span class="special">:</span><span class="identifier">child</span><span class="special">/&gt;&lt;/</span><span class="identifier">foo</span><span class="special">&gt;</span></code>,
+            query <code class="computeroutput"><span class="identifier">foo</span><span class="special">/</span><span class="identifier">ns1</span><span class="special">:*</span></code>
+            will return only the first child, not both of them. Compliant XPath implementations
+            can return both nodes if the user provides appropriate namespace declarations.
+          </li>
+<li class="listitem">
+            String functions consider a character to be either a single <code class="computeroutput"><span class="keyword">char</span></code> value or a single <code class="computeroutput"><span class="keyword">wchar_t</span></code>
+            value, depending on the library configuration; this means that some string
+            functions are not fully Unicode-aware. This affects <code class="computeroutput"><span class="identifier">substring</span><span class="special">()</span></code>, <code class="computeroutput"><span class="identifier">string</span><span class="special">-</span><span class="identifier">length</span><span class="special">()</span></code> and <code class="computeroutput"><span class="identifier">translate</span><span class="special">()</span></code> functions.
+          </li>
+</ul></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"></td>
+<td align="right"><div class="copyright-footer">Copyright &#169; 2012 Arseny Kapoulkine<p>
+        Distributed under the MIT License
+      </p>
+</div></td>
+</tr></table>
+<hr>
+<table width="100%"><tr>
+<td>
+<a href="http://pugixml.org/">pugixml 1.2</a> manual |
+		<a href="../manual.html">Overview</a> |
+		<a href="install.html">Installation</a> |
+		Document:
+		<a href="dom.html">Object model</a> &middot; <a href="loading.html">Loading</a> &middot; <a href="access.html">Accessing</a> &middot; <a href="modify.html">Modifying</a> &middot; <a href="saving.html">Saving</a> |
+		<b>XPath</b> |
+		<a href="apiref.html">API Reference</a> |
+		<a href="toc.html">Table of Contents</a>
+</td>
+<td width="*" align="right"><div class="spirit-nav">
+<a accesskey="p" href="saving.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../manual.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../manual.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="changes.html"><img src="../images/next.png" alt="Next"></a>
+</div></td>
+</tr></table>
+</body>
+</html>
diff --git a/tools/intergen/third_party/pugixml/docs/pugixml.css b/tools/intergen/third_party/pugixml/docs/pugixml.css
new file mode 100644
index 0000000000..0a72f78143
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/pugixml.css
@@ -0,0 +1,598 @@
+/*=============================================================================
+    Copyright (c) 2004 Joel de Guzman
+    http://spirit.sourceforge.net/
+
+    Distributed under the Boost Software License, Version 1.0. (See accompany-
+    ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+=============================================================================*/
+
+/*=============================================================================
+    Body defaults
+=============================================================================*/
+
+    body
+    {
+        margin: 1em;
+        font-family: sans-serif;
+    }
+
+/*=============================================================================
+    Paragraphs
+=============================================================================*/
+
+    p
+    {
+        text-align: left;
+        font-size: 10pt;
+        line-height: 1.15;
+    }
+
+/*=============================================================================
+    Program listings
+=============================================================================*/
+
+    /* Code on paragraphs */
+    p tt.computeroutput
+    {
+        font-size: 9pt;
+    }
+
+    pre.synopsis
+    {
+        font-size: 90%;
+        margin: 1pc 4% 0pc 4%;
+        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+    }
+
+    .programlisting,
+    .screen
+    {
+        font-size: 9pt;
+        display: block;
+        margin: 1pc 4% 0pc 4%;
+        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+    }
+
+    /* Program listings in tables don't get borders */
+    td .programlisting,
+    td .screen
+    {
+        margin: 0pc 0pc 0pc 0pc;
+        padding:  0pc 0pc 0pc 0pc;
+    }
+
+/*=============================================================================
+    Headings
+=============================================================================*/
+
+    h1, h2, h3, h4, h5, h6
+    {
+        text-align: left;
+        margin: 1em 0em 0.5em 0em;
+        font-weight: bold;
+    }
+
+    h1 { font: 140% }
+    h2 { font: bold 140% }
+    h3 { font: bold 130% }
+    h4 { font: bold 120% }
+    h5 { font: italic 110% }
+    h6 { font: italic 100% }
+
+    /* Top page titles */
+    title,
+    h1.title,
+    h2.title
+    h3.title,
+    h4.title,
+    h5.title,
+    h6.title,
+    .refentrytitle
+    {
+        font-weight: bold;
+        margin-bottom: 1pc;
+    }
+
+    h1.title { font-size: 140% }
+    h2.title { font-size: 140% }
+    h3.title { font-size: 130% }
+    h4.title { font-size: 120% }
+    h5.title { font-size: 110% }
+    h6.title { font-size: 100% }
+
+    .section h1
+    {
+        margin: 0em 0em 0.5em 0em;
+        font-size: 140%;
+    }
+
+    .section h2 { font-size: 140% }
+    .section h3 { font-size: 130% }
+    .section h4 { font-size: 120% }
+    .section h5 { font-size: 110% }
+    .section h6 { font-size: 100% }
+
+    /* Code on titles */
+    h1 tt.computeroutput { font-size: 140% }
+    h2 tt.computeroutput { font-size: 140% }
+    h3 tt.computeroutput { font-size: 130% }
+    h4 tt.computeroutput { font-size: 130% }	
+    h5 tt.computeroutput { font-size: 130% }
+    h6 tt.computeroutput { font-size: 130% }
+
+
+/*=============================================================================
+    Author
+=============================================================================*/
+
+    h3.author
+    {
+        font-size: 100%
+    }
+
+/*=============================================================================
+    Lists
+=============================================================================*/
+
+    li
+    {
+        font-size: 10pt;
+        line-height: 1.3;
+    }
+
+    /* Unordered lists */
+    ul
+    {
+        text-align: left;
+    }
+
+    /* Ordered lists */
+    ol
+    {
+        text-align: left;
+    }
+
+/*=============================================================================
+    Links
+=============================================================================*/
+
+    a
+    {
+        text-decoration: none; /* no underline */
+    }
+
+    a:hover
+    {
+        text-decoration: underline;
+    }
+
+/*=============================================================================
+    Spirit style navigation
+=============================================================================*/
+
+    .spirit-nav
+    {
+        text-align: right;
+    }
+
+    .spirit-nav a
+    {
+        color: white;
+        padding-left: 0.5em;
+    }
+
+    .spirit-nav img
+    {
+        border-width: 0px;
+    }
+
+/*=============================================================================
+    Copyright footer
+=============================================================================*/
+    .copyright-footer
+    {
+        text-align: right;
+        font-size: 70%;
+    }
+
+    .copyright-footer p
+    {
+        text-align: right;
+        font-size: 80%;
+    }
+
+/*=============================================================================
+    Table of contents
+=============================================================================*/
+
+    .toc
+    {
+       margin: 1pc 4% 0pc 4%;
+       padding: 0.1pc 1pc 0.1pc 1pc;
+       font-size: 80%;
+       line-height: 1.15;
+    }
+
+    .boost-toc
+    {
+       float: right;
+       padding: 0.5pc;
+    }
+	
+    /* Code on toc */
+    .toc .computeroutput { font-size: 120% }
+	
+/*=============================================================================
+    Tables
+=============================================================================*/
+
+    .table-title,
+    div.table p.title
+    {
+        margin-left: 4%;
+        padding-right: 0.5em;
+        padding-left: 0.5em;
+    }
+
+    .informaltable table,
+    .table table
+    {
+        width: 92%;
+        margin-left: 4%;
+        margin-right: 4%;
+    }
+
+    div.informaltable table,
+    div.table table
+    {
+        padding: 4px;
+    }
+
+    /* Table Cells */
+    div.informaltable table tr td,
+    div.table table tr td
+    {
+        padding: 0.5em;
+        text-align: left;
+        font-size: 9pt;
+    }
+
+    div.informaltable table tr th,
+    div.table table tr th
+    {
+        padding: 0.5em 0.5em 0.5em 0.5em;
+        border: 1pt solid white;
+        font-size: 80%;
+    }
+
+    table.simplelist
+    {
+        width: auto !important;
+        margin: 0em !important;
+        padding: 0em !important;
+        border: none !important;
+    }
+    table.simplelist td
+    {
+        margin: 0em !important;
+        padding: 0em !important;
+        text-align: left !important;
+        font-size: 9pt !important;
+        border: none !important;
+    }
+
+/*=============================================================================
+    Blurbs
+=============================================================================*/
+
+    div.note,
+    div.tip,
+    div.important,
+    div.caution,
+    div.warning,
+    p.blurb
+    {
+        font-size: 9pt; /* A little bit smaller than the main text */
+        line-height: 1.2;
+        display: block;
+        margin: 1pc 4% 0pc 4%;
+        padding: 0.5pc 0.5pc 0.5pc 0.5pc;
+    }
+
+    p.blurb img
+    {
+        padding: 1pt;
+    }
+
+/*=============================================================================
+    Variable Lists
+=============================================================================*/
+
+    div.variablelist
+    {
+        margin: 1em 0;
+    }
+
+    /* Make the terms in definition lists bold */
+    div.variablelist dl dt,
+    span.term
+    {
+        font-weight: bold;
+        font-size: 10pt;
+    }
+
+    div.variablelist table tbody tr td
+    {
+        text-align: left;
+        vertical-align: top;
+        padding: 0em 2em 0em 0em;
+        font-size: 10pt;
+        margin: 0em 0em 0.5em 0em;
+        line-height: 1;
+    }
+
+    div.variablelist dl dt
+    {
+        margin-bottom: 0.2em;
+    }
+
+    div.variablelist dl dd
+    {
+        margin: 0em 0em 0.5em 2em;
+        font-size: 10pt;
+    }
+
+    div.variablelist table tbody tr td p,
+    div.variablelist dl dd p
+    {
+        margin: 0em 0em 0.5em 0em;
+        line-height: 1;
+    }
+
+/*=============================================================================
+    Misc
+=============================================================================*/
+
+    /* Title of books and articles in bibliographies */
+    span.title
+    {
+        font-style: italic;
+    }
+
+    span.underline
+    {
+        text-decoration: underline;
+    }
+
+    span.strikethrough
+    {
+        text-decoration: line-through;
+    }
+
+    /* Copyright, Legal Notice */
+    div div.legalnotice p
+    {
+        text-align: left
+    }
+
+/*=============================================================================
+    Colors
+=============================================================================*/
+
+    @media screen
+    {
+        body {
+            background-color: #FFFFFF;
+            color: #000000;
+        }
+        
+    /* Links */
+        a
+        {
+            color: #005a9c;
+        }
+
+        a:visited
+        {
+            color: #9c5a9c;
+        }
+
+        h1 a, h2 a, h3 a, h4 a, h5 a, h6 a,
+        h1 a:hover, h2 a:hover, h3 a:hover, h4 a:hover, h5 a:hover, h6 a:hover,
+        h1 a:visited, h2 a:visited, h3 a:visited, h4 a:visited, h5 a:visited, h6 a:visited
+        {
+            text-decoration: none; /* no underline */
+            color: #000000;
+        }
+
+    /* Syntax Highlighting */
+        .keyword        { color: #0000AA; }
+        .identifier     { color: #000000; }
+        .special        { color: #707070; }
+        .preprocessor   { color: #402080; }
+        .char           { color: teal; }
+        .comment        { color: #800000; }
+        .string         { color: teal; }
+        .number         { color: teal; }
+        .white_bkd      { background-color: #FFFFFF; }
+        .dk_grey_bkd    { background-color: #999999; }
+
+    /* Copyright, Legal Notice */
+        .copyright
+        {
+            color: #666666;
+            font-size: small;
+        }
+
+        div div.legalnotice p
+        {
+            color: #666666;
+        }
+
+    /* Program listing */
+        pre.synopsis
+        {
+            border: 1px solid #DCDCDC;
+        }
+
+        .programlisting,
+        .screen
+        {
+            border: 1px solid #DCDCDC;
+        }
+
+        td .programlisting,
+        td .screen
+        {
+            border: 0px solid #DCDCDC;
+        }
+
+    /* Blurbs */
+        div.note,
+        div.tip,
+        div.important,
+        div.caution,
+        div.warning,
+        p.blurb
+        {
+            border: 1px solid #DCDCDC;
+        }
+
+    /* Table of contents */
+        .toc
+        {
+            border: 1px solid #DCDCDC;
+        }
+
+    /* Tables */
+        div.informaltable table tr td,
+        div.table table tr td
+        {
+            border: 1px solid #DCDCDC;
+        }
+
+        div.informaltable table tr th,
+        div.table table tr th
+        {
+            background-color: #F0F0F0;
+            border: 1px solid #DCDCDC;
+        }
+
+        .copyright-footer
+        {
+            color: #8F8F8F;
+        }
+
+    /* Misc */
+        span.highlight
+        {
+            color: #00A000;
+        }
+    }
+
+    @media print
+    {
+    /* Links */
+        a
+        {
+            color: black;
+        }
+
+        a:visited
+        {
+            color: black;
+        }
+
+        .spirit-nav
+        {
+            display: none;
+        }
+
+    /* Program listing */
+        pre.synopsis
+        {
+            border: 1px solid gray;
+        }
+
+        .programlisting,
+        .screen
+        {
+            border: 1px solid gray;
+        }
+
+        td .programlisting,
+        td .screen
+        {
+            border: 0px solid #DCDCDC;
+        }
+
+    /* Table of contents */
+        .toc
+        {
+            border: 1px solid gray;
+        }
+
+        .informaltable table,
+        .table table
+        {
+            border: 1px solid gray;
+            border-collapse: collapse;
+        }
+
+    /* Tables */
+        div.informaltable table tr td,
+        div.table table tr td
+        {
+            border: 1px solid gray;
+        }
+
+        div.informaltable table tr th,
+        div.table table tr th
+        {
+            border: 1px solid gray;
+        }
+
+        table.simplelist tr td
+        {
+            border: none !important;
+        }
+
+    /* Misc */
+        span.highlight
+        {
+            font-weight: bold;
+        }
+    }
+
+/*=============================================================================
+    Images
+=============================================================================*/
+
+    span.inlinemediaobject img
+    {
+        vertical-align: middle;
+    }
+
+/*==============================================================================
+    Super and Subscript: style so that line spacing isn't effected, see
+    http://www.adobe.com/cfusion/communityengine/index.cfm?event=showdetails&productId=1&postId=5341
+==============================================================================*/
+
+sup,
+sub {
+	height: 0;
+	line-height: 1;
+	vertical-align: baseline;
+	_vertical-align: bottom;
+	position: relative;
+	
+}
+
+sup {
+	bottom: 1ex;
+}
+
+sub {
+	top: .5ex;
+}
+
diff --git a/tools/intergen/third_party/pugixml/docs/quickstart.html b/tools/intergen/third_party/pugixml/docs/quickstart.html
new file mode 100644
index 0000000000..6afd25dd92
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/quickstart.html
@@ -0,0 +1,879 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>pugixml 1.2</title>
+<link rel="stylesheet" href="pugixml.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
+<link rel="home" href="quickstart.html" title="pugixml 1.2">
+</head>
+<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
+<div class="article">
+<div class="section">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="quickstart.main"></a><a class="link" href="quickstart.html#quickstart.main" title="pugixml 1.2 quick start guide"> pugixml 1.2 quick start guide</a>
+</h2></div></div></div>
+<div class="toc"><dl>
+<dt><span class="section"><a href="quickstart.html#quickstart.main.introduction"> Introduction</a></span></dt>
+<dt><span class="section"><a href="quickstart.html#quickstart.main.install"> Installation</a></span></dt>
+<dt><span class="section"><a href="quickstart.html#quickstart.main.dom"> Document object model</a></span></dt>
+<dt><span class="section"><a href="quickstart.html#quickstart.main.loading"> Loading document</a></span></dt>
+<dt><span class="section"><a href="quickstart.html#quickstart.main.access"> Accessing document data</a></span></dt>
+<dt><span class="section"><a href="quickstart.html#quickstart.main.modify"> Modifying document data</a></span></dt>
+<dt><span class="section"><a href="quickstart.html#quickstart.main.saving"> Saving document</a></span></dt>
+<dt><span class="section"><a href="quickstart.html#quickstart.main.feedback"> Feedback</a></span></dt>
+<dt><span class="section"><a href="quickstart.html#quickstart.main.license"> License</a></span></dt>
+</dl></div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="quickstart.main.introduction"></a><a class="link" href="quickstart.html#quickstart.main.introduction" title="Introduction"> Introduction</a>
+</h3></div></div></div>
+<p>
+        <a href="http://pugixml.org/" target="_top">pugixml</a> is a light-weight C++ XML
+        processing library. It consists of a DOM-like interface with rich traversal/modification
+        capabilities, an extremely fast XML parser which constructs the DOM tree
+        from an XML file/buffer, and an XPath 1.0 implementation for complex data-driven
+        tree queries. Full Unicode support is also available, with Unicode interface
+        variants and conversions between different Unicode encodings (which happen
+        automatically during parsing/saving). The library is extremely portable and
+        easy to integrate and use. pugixml is developed and maintained since 2006
+        and has many users. All code is distributed under the <a class="link" href="quickstart.html#quickstart.main.license" title="License">MIT
+        license</a>, making it completely free to use in both open-source and
+        proprietary applications.
+      </p>
+<p>
+        pugixml enables very fast, convenient and memory-efficient XML document processing.
+        However, since pugixml has a DOM parser, it can't process XML documents that
+        do not fit in memory; also the parser is a non-validating one, so if you
+        need DTD/Schema validation, the library is not for you.
+      </p>
+<p>
+        This is the quick start guide for pugixml, which purpose is to enable you
+        to start using the library quickly. Many important library features are either
+        not described at all or only mentioned briefly; for more complete information
+        you <a href="manual.html" target="_top">should read the complete manual</a>.
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          No documentation is perfect, neither is this one. If you encounter a description
+          that is unclear, please file an issue as described in <a class="xref" href="quickstart.html#quickstart.main.feedback" title="Feedback"> Feedback</a>. Also if
+          you can spare the time for a full proof-reading, including spelling and
+          grammar, that would be great! Please <a class="link" href="quickstart.html#email">send me an e-mail</a>;
+          as a token of appreciation, your name will be included into the corresponding
+          section of the manual.
+        </p></td></tr>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="quickstart.main.install"></a><a class="link" href="quickstart.html#quickstart.main.install" title="Installation"> Installation</a>
+</h3></div></div></div>
+<p>
+        pugixml is distributed in source form. You can download a source distribution
+        via one of the following links:
+      </p>
+<pre class="programlisting"><a href="http://pugixml.googlecode.com/files/pugixml-1.2.zip" target="_top">http://pugixml.googlecode.com/files/pugixml-1.2.zip</a>
+<a href="http://pugixml.googlecode.com/files/pugixml-1.2.tar.gz" target="_top">http://pugixml.googlecode.com/files/pugixml-1.2.tar.gz</a>
+</pre>
+<p>
+        The distribution contains library source, documentation (the guide you're
+        reading now and the manual) and some code examples. After downloading the
+        distribution, install pugixml by extracting all files from the compressed
+        archive. The files have different line endings depending on the archive format
+        - <code class="filename">.zip</code> archive has Windows line endings, <code class="filename">.tar.gz</code> archive has Unix line endings.
+        Otherwise the files in both archives are identical.
+      </p>
+<p>
+        The complete pugixml source consists of three files - one source file, <code class="filename">pugixml.cpp</code>,
+        and two header files, <code class="filename">pugixml.hpp</code> and <code class="filename">pugiconfig.hpp</code>. <code class="filename">pugixml.hpp</code> is the primary
+        header which you need to include in order to use pugixml classes/functions.
+        The rest of this guide assumes that <code class="filename">pugixml.hpp</code> is either in the current directory
+        or in one of include directories of your projects, so that <code class="computeroutput"><span class="preprocessor">#include</span> <span class="string">"pugixml.hpp"</span></code>
+        can find the header; however you can also use relative path (i.e. <code class="computeroutput"><span class="preprocessor">#include</span> <span class="string">"../libs/pugixml/src/pugixml.hpp"</span></code>)
+        or include directory-relative path (i.e. <code class="computeroutput"><span class="preprocessor">#include</span>
+        <span class="special">&lt;</span><span class="identifier">xml</span><span class="special">/</span><span class="identifier">thirdparty</span><span class="special">/</span><span class="identifier">pugixml</span><span class="special">/</span><span class="identifier">src</span><span class="special">/</span><span class="identifier">pugixml</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>).
+      </p>
+<p>
+        The easiest way to build pugixml is to compile the source file, <code class="filename">pugixml.cpp</code>,
+        along with the existing library/executable. This process depends on the method
+        of building your application; for example, if you're using Microsoft Visual
+        Studio<sup>[<a name="trademarks" href="#ftn.trademarks" class="footnote">1</a>]</sup>,
+        Apple Xcode, Code::Blocks or any other IDE, just add <code class="filename">pugixml.cpp</code> to one of
+        your projects. There are other building methods available, including building
+        pugixml as a standalone static/shared library; <a href="manual/install.html#manual.install.building" target="_top">read
+        the manual</a> for further information.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="quickstart.main.dom"></a><a class="link" href="quickstart.html#quickstart.main.dom" title="Document object model"> Document object model</a>
+</h3></div></div></div>
+<p>
+        pugixml stores XML data in DOM-like way: the entire XML document (both document
+        structure and element data) is stored in memory as a tree. The tree can be
+        loaded from character stream (file, string, C++ I/O stream), then traversed
+        via special API or XPath expressions. The whole tree is mutable: both node
+        structure and node/attribute data can be changed at any time. Finally, the
+        result of document transformations can be saved to a character stream (file,
+        C++ I/O stream or custom transport).
+      </p>
+<p>
+        The root of the tree is the document itself, which corresponds to C++ type
+        <code class="computeroutput"><span class="identifier">xml_document</span></code>. Document has
+        one or more child nodes, which correspond to C++ type <code class="computeroutput"><span class="identifier">xml_node</span></code>.
+        Nodes have different types; depending on a type, a node can have a collection
+        of child nodes, a collection of attributes, which correspond to C++ type
+        <code class="computeroutput"><span class="identifier">xml_attribute</span></code>, and some additional
+        data (i.e. name).
+      </p>
+<p>
+        The most common node types are:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            Document node (<code class="computeroutput"><span class="identifier">node_document</span></code>)
+            - this is the root of the tree, which consists of several child nodes.
+            This node corresponds to <code class="computeroutput"><span class="identifier">xml_document</span></code>
+            class; note that <code class="computeroutput"><span class="identifier">xml_document</span></code>
+            is a sub-class of <code class="computeroutput"><span class="identifier">xml_node</span></code>,
+            so the entire node interface is also available.
+          </li>
+<li class="listitem">
+            Element/tag node (<code class="computeroutput"><span class="identifier">node_element</span></code>)
+            - this is the most common type of node, which represents XML elements.
+            Element nodes have a name, a collection of attributes and a collection
+            of child nodes (both of which may be empty). The attribute is a simple
+            name/value pair.
+          </li>
+<li class="listitem">
+            Plain character data nodes (<code class="computeroutput"><span class="identifier">node_pcdata</span></code>)
+            represent plain text in XML. PCDATA nodes have a value, but do not have
+            name or children/attributes. Note that <span class="bold"><strong>plain character
+            data is not a part of the element node but instead has its own node</strong></span>;
+            for example, an element node can have several child PCDATA nodes.
+          </li>
+</ul></div>
+<p>
+        Despite the fact that there are several node types, there are only three
+        C++ types representing the tree (<code class="computeroutput"><span class="identifier">xml_document</span></code>,
+        <code class="computeroutput"><span class="identifier">xml_node</span></code>, <code class="computeroutput"><span class="identifier">xml_attribute</span></code>);
+        some operations on <code class="computeroutput"><span class="identifier">xml_node</span></code>
+        are only valid for certain node types. They are described below.
+      </p>
+<div class="note"><table border="0" summary="Note">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="images/note.png"></td>
+<th align="left">Note</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          All pugixml classes and functions are located in <code class="computeroutput"><span class="identifier">pugi</span></code>
+          namespace; you have to either use explicit name qualification (i.e. <code class="computeroutput"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span></code>), or to gain access to relevant
+          symbols via <code class="computeroutput"><span class="keyword">using</span></code> directive
+          (i.e. <code class="computeroutput"><span class="keyword">using</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span><span class="special">;</span></code> or <code class="computeroutput"><span class="keyword">using</span>
+          <span class="keyword">namespace</span> <span class="identifier">pugi</span><span class="special">;</span></code>).
+        </p></td></tr>
+</table></div>
+<p>
+        <code class="computeroutput"><span class="identifier">xml_document</span></code> is the owner
+        of the entire document structure; destroying the document destroys the whole
+        tree. The interface of <code class="computeroutput"><span class="identifier">xml_document</span></code>
+        consists of loading functions, saving functions and the entire interface
+        of <code class="computeroutput"><span class="identifier">xml_node</span></code>, which allows
+        for document inspection and/or modification. Note that while <code class="computeroutput"><span class="identifier">xml_document</span></code> is a sub-class of <code class="computeroutput"><span class="identifier">xml_node</span></code>, <code class="computeroutput"><span class="identifier">xml_node</span></code>
+        is not a polymorphic type; the inheritance is present only to simplify usage.
+      </p>
+<p>
+        <code class="computeroutput"><span class="identifier">xml_node</span></code> is the handle to
+        document node; it can point to any node in the document, including document
+        itself. There is a common interface for nodes of all types. Note that <code class="computeroutput"><span class="identifier">xml_node</span></code> is only a handle to the actual
+        node, not the node itself - you can have several <code class="computeroutput"><span class="identifier">xml_node</span></code>
+        handles pointing to the same underlying object. Destroying <code class="computeroutput"><span class="identifier">xml_node</span></code> handle does not destroy the node
+        and does not remove it from the tree.
+      </p>
+<p>
+        There is a special value of <code class="computeroutput"><span class="identifier">xml_node</span></code>
+        type, known as null node or empty node. It does not correspond to any node
+        in any document, and thus resembles null pointer. However, all operations
+        are defined on empty nodes; generally the operations don't do anything and
+        return empty nodes/attributes or empty strings as their result. This is useful
+        for chaining calls; i.e. you can get the grandparent of a node like so:
+        <code class="computeroutput"><span class="identifier">node</span><span class="special">.</span><span class="identifier">parent</span><span class="special">().</span><span class="identifier">parent</span><span class="special">()</span></code>;
+        if a node is a null node or it does not have a parent, the first <code class="computeroutput"><span class="identifier">parent</span><span class="special">()</span></code>
+        call returns null node; the second <code class="computeroutput"><span class="identifier">parent</span><span class="special">()</span></code> call then also returns null node, so you
+        don't have to check for errors twice. You can test if a handle is null via
+        implicit boolean cast: <code class="computeroutput"><span class="keyword">if</span> <span class="special">(</span><span class="identifier">node</span><span class="special">)</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span></code>
+        or <code class="computeroutput"><span class="keyword">if</span> <span class="special">(!</span><span class="identifier">node</span><span class="special">)</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span></code>.
+      </p>
+<p>
+        <code class="computeroutput"><span class="identifier">xml_attribute</span></code> is the handle
+        to an XML attribute; it has the same semantics as <code class="computeroutput"><span class="identifier">xml_node</span></code>,
+        i.e. there can be several <code class="computeroutput"><span class="identifier">xml_attribute</span></code>
+        handles pointing to the same underlying object and there is a special null
+        attribute value, which propagates to function results.
+      </p>
+<p>
+        There are two choices of interface and internal representation when configuring
+        pugixml: you can either choose the UTF-8 (also called char) interface or
+        UTF-16/32 (also called wchar_t) one. The choice is controlled via <code class="computeroutput"><span class="identifier">PUGIXML_WCHAR_MODE</span></code> define; you can set
+        it via <code class="filename">pugiconfig.hpp</code> or via preprocessor options. All tree functions that
+        work with strings work with either C-style null terminated strings or STL
+        strings of the selected character type. <a href="manual/dom.html#manual.dom.unicode" target="_top">Read
+        the manual</a> for additional information on Unicode interface.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="quickstart.main.loading"></a><a class="link" href="quickstart.html#quickstart.main.loading" title="Loading document"> Loading document</a>
+</h3></div></div></div>
+<p>
+        pugixml provides several functions for loading XML data from various places
+        - files, C++ iostreams, memory buffers. All functions use an extremely fast
+        non-validating parser. This parser is not fully W3C conformant - it can load
+        any valid XML document, but does not perform some well-formedness checks.
+        While considerable effort is made to reject invalid XML documents, some validation
+        is not performed because of performance reasons. XML data is always converted
+        to internal character format before parsing. pugixml supports all popular
+        Unicode encodings (UTF-8, UTF-16 (big and little endian), UTF-32 (big and
+        little endian); UCS-2 is naturally supported since it's a strict subset of
+        UTF-16) and handles all encoding conversions automatically.
+      </p>
+<p>
+        The most common source of XML data is files; pugixml provides a separate
+        function for loading XML document from file. This function accepts file path
+        as its first argument, and also two optional arguments, which specify parsing
+        options and input data encoding, which are described in the manual.
+      </p>
+<p>
+        This is an example of loading XML document from file (<a href="samples/load_file.cpp" target="_top">samples/load_file.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_document</span> <span class="identifier">doc</span><span class="special">;</span>
+
+<span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_parse_result</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">load_file</span><span class="special">(</span><span class="string">"tree.xml"</span><span class="special">);</span>
+
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Load result: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">result</span><span class="special">.</span><span class="identifier">description</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">", mesh name: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"mesh"</span><span class="special">).</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"name"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+<p>
+        <code class="computeroutput"><span class="identifier">load_file</span></code>, as well as other
+        loading functions, destroys the existing document tree and then tries to
+        load the new tree from the specified file. The result of the operation is
+        returned in an <code class="computeroutput"><span class="identifier">xml_parse_result</span></code>
+        object; this object contains the operation status, and the related information
+        (i.e. last successfully parsed position in the input file, if parsing fails).
+      </p>
+<p>
+        Parsing result object can be implicitly converted to <code class="computeroutput"><span class="keyword">bool</span></code>;
+        if you do not want to handle parsing errors thoroughly, you can just check
+        the return value of load functions as if it was a <code class="computeroutput"><span class="keyword">bool</span></code>:
+        <code class="computeroutput"><span class="keyword">if</span> <span class="special">(</span><span class="identifier">doc</span><span class="special">.</span><span class="identifier">load_file</span><span class="special">(</span><span class="string">"file.xml"</span><span class="special">))</span> <span class="special">{</span> <span class="special">...</span>
+        <span class="special">}</span> <span class="keyword">else</span> <span class="special">{</span> <span class="special">...</span> <span class="special">}</span></code>.
+        Otherwise you can use the <code class="computeroutput"><span class="identifier">status</span></code>
+        member to get parsing status, or the <code class="computeroutput"><span class="identifier">description</span><span class="special">()</span></code> member function to get the status in a
+        string form.
+      </p>
+<p>
+        This is an example of handling loading errors (<a href="samples/load_error_handling.cpp" target="_top">samples/load_error_handling.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_document</span> <span class="identifier">doc</span><span class="special">;</span>
+<span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_parse_result</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">load</span><span class="special">(</span><span class="identifier">source</span><span class="special">);</span>
+
+<span class="keyword">if</span> <span class="special">(</span><span class="identifier">result</span><span class="special">)</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"XML ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">source</span> <span class="special">&lt;&lt;</span> <span class="string">"] parsed without errors, attr value: ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"node"</span><span class="special">).</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"attr"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"]\n\n"</span><span class="special">;</span>
+<span class="keyword">else</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"XML ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">source</span> <span class="special">&lt;&lt;</span> <span class="string">"] parsed with errors, attr value: ["</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"node"</span><span class="special">).</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"attr"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"]\n"</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Error description: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">result</span><span class="special">.</span><span class="identifier">description</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Error offset: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">result</span><span class="special">.</span><span class="identifier">offset</span> <span class="special">&lt;&lt;</span> <span class="string">" (error at [..."</span> <span class="special">&lt;&lt;</span> <span class="special">(</span><span class="identifier">source</span> <span class="special">+</span> <span class="identifier">result</span><span class="special">.</span><span class="identifier">offset</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">"]\n\n"</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+<p>
+        Sometimes XML data should be loaded from some other source than file, i.e.
+        HTTP URL; also you may want to load XML data from file using non-standard
+        functions, i.e. to use your virtual file system facilities or to load XML
+        from gzip-compressed files. These scenarios either require loading document
+        from memory, in which case you should prepare a contiguous memory block with
+        all XML data and to pass it to one of buffer loading functions, or loading
+        document from C++ IOstream, in which case you should provide an object which
+        implements <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">istream</span></code> or <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">wistream</span></code>
+        interface.
+      </p>
+<p>
+        There are different functions for loading document from memory; they treat
+        the passed buffer as either an immutable one (<code class="computeroutput"><span class="identifier">load_buffer</span></code>),
+        a mutable buffer which is owned by the caller (<code class="computeroutput"><span class="identifier">load_buffer_inplace</span></code>),
+        or a mutable buffer which ownership belongs to pugixml (<code class="computeroutput"><span class="identifier">load_buffer_inplace_own</span></code>).
+        There is also a simple helper function, <code class="computeroutput"><span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">load</span></code>,
+        for cases when you want to load the XML document from null-terminated character
+        string.
+      </p>
+<p>
+        This is an example of loading XML document from memory using one of these
+        functions (<a href="samples/load_memory.cpp" target="_top">samples/load_memory.cpp</a>);
+        read the sample code for more examples:
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">const</span> <span class="keyword">char</span> <span class="identifier">source</span><span class="special">[]</span> <span class="special">=</span> <span class="string">"&lt;mesh name='sphere'&gt;&lt;bounds&gt;0 0 1 1&lt;/bounds&gt;&lt;/mesh&gt;"</span><span class="special">;</span>
+<span class="identifier">size_t</span> <span class="identifier">size</span> <span class="special">=</span> <span class="keyword">sizeof</span><span class="special">(</span><span class="identifier">source</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// You can use load_buffer_inplace to load document from mutable memory block; the block's lifetime must exceed that of document
+</span><span class="keyword">char</span><span class="special">*</span> <span class="identifier">buffer</span> <span class="special">=</span> <span class="keyword">new</span> <span class="keyword">char</span><span class="special">[</span><span class="identifier">size</span><span class="special">];</span>
+<span class="identifier">memcpy</span><span class="special">(</span><span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">source</span><span class="special">,</span> <span class="identifier">size</span><span class="special">);</span>
+
+<span class="comment">// The block can be allocated by any method; the block is modified during parsing
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_parse_result</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">load_buffer_inplace</span><span class="special">(</span><span class="identifier">buffer</span><span class="special">,</span> <span class="identifier">size</span><span class="special">);</span>
+
+<span class="comment">// You have to destroy the block yourself after the document is no longer used
+</span><span class="keyword">delete</span><span class="special">[]</span> <span class="identifier">buffer</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+<p>
+        This is a simple example of loading XML document from file using streams
+        (<a href="samples/load_stream.cpp" target="_top">samples/load_stream.cpp</a>); read
+        the sample code for more complex examples involving wide streams and locales:
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ifstream</span> <span class="identifier">stream</span><span class="special">(</span><span class="string">"weekly-utf-8.xml"</span><span class="special">);</span>
+<span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_parse_result</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">load</span><span class="special">(</span><span class="identifier">stream</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="quickstart.main.access"></a><a class="link" href="quickstart.html#quickstart.main.access" title="Accessing document data"> Accessing document data</a>
+</h3></div></div></div>
+<p>
+        pugixml features an extensive interface for getting various types of data
+        from the document and for traversing the document. You can use various accessors
+        to get node/attribute data, you can traverse the child node/attribute lists
+        via accessors or iterators, you can do depth-first traversals with <code class="computeroutput"><span class="identifier">xml_tree_walker</span></code> objects, and you can use
+        XPath for complex data-driven queries.
+      </p>
+<p>
+        You can get node or attribute name via <code class="computeroutput"><span class="identifier">name</span><span class="special">()</span></code> accessor, and value via <code class="computeroutput"><span class="identifier">value</span><span class="special">()</span></code> accessor. Note that both functions never
+        return null pointers - they either return a string with the relevant content,
+        or an empty string if name/value is absent or if the handle is null. Also
+        there are two notable things for reading values:
+      </p>
+<div class="itemizedlist"><ul class="itemizedlist" type="disc">
+<li class="listitem">
+            It is common to store data as text contents of some node - i.e. <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">node</span><span class="special">&gt;&lt;</span><span class="identifier">description</span><span class="special">&gt;</span><span class="identifier">This</span>
+            <span class="identifier">is</span> <span class="identifier">a</span>
+            <span class="identifier">node</span><span class="special">&lt;/</span><span class="identifier">description</span><span class="special">&gt;&lt;/</span><span class="identifier">node</span><span class="special">&gt;</span></code>.
+            In this case, <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">description</span><span class="special">&gt;</span></code> node does not have a value, but instead
+            has a child of type <code class="computeroutput"><span class="identifier">node_pcdata</span></code>
+            with value <code class="computeroutput"><span class="string">"This is a node"</span></code>.
+            pugixml provides <code class="computeroutput"><span class="identifier">child_value</span><span class="special">()</span></code> and <code class="computeroutput"><span class="identifier">text</span><span class="special">()</span></code> helper functions to parse such data.
+          </li>
+<li class="listitem">
+            In many cases attribute values have types that are not strings - i.e.
+            an attribute may always contain values that should be treated as integers,
+            despite the fact that they are represented as strings in XML. pugixml
+            provides several accessors that convert attribute value to some other
+            type.
+          </li>
+</ul></div>
+<p>
+        This is an example of using these functions (<a href="samples/traverse_base.cpp" target="_top">samples/traverse_base.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">);</span> <span class="identifier">tool</span><span class="special">;</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">next_sibling</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">))</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Tool "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Filename"</span><span class="special">).</span><span class="identifier">value</span><span class="special">();</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">": AllowRemote "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"AllowRemote"</span><span class="special">).</span><span class="identifier">as_bool</span><span class="special">();</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">", Timeout "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Timeout"</span><span class="special">).</span><span class="identifier">as_int</span><span class="special">();</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">", Description '"</span> <span class="special">&lt;&lt;</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">child_value</span><span class="special">(</span><span class="string">"Description"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">"'\n"</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+<p>
+        Since a lot of document traversal consists of finding the node/attribute
+        with the correct name, there are special functions for that purpose. For
+        example, <code class="computeroutput"><span class="identifier">child</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">)</span></code>
+        returns the first node which has the name <code class="computeroutput"><span class="string">"Tool"</span></code>,
+        or null handle if there is no such node. This is an example of using such
+        functions (<a href="samples/traverse_base.cpp" target="_top">samples/traverse_base.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Tool for *.dae generation: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">find_child_by_attribute</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">,</span> <span class="string">"OutputFileMasks"</span><span class="special">,</span> <span class="string">"*.dae"</span><span class="special">).</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Filename"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
+
+<span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">);</span> <span class="identifier">tool</span><span class="special">;</span> <span class="identifier">tool</span> <span class="special">=</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">next_sibling</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">))</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Tool "</span> <span class="special">&lt;&lt;</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Filename"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+<p>
+        Child node lists and attribute lists are simply double-linked lists; while
+        you can use <code class="computeroutput"><span class="identifier">previous_sibling</span></code>/<code class="computeroutput"><span class="identifier">next_sibling</span></code> and other such functions for
+        iteration, pugixml additionally provides node and attribute iterators, so
+        that you can treat nodes as containers of other nodes or attributes. All
+        iterators are bidirectional and support all usual iterator operations. The
+        iterators are invalidated if the node/attribute objects they're pointing
+        to are removed from the tree; adding nodes/attributes does not invalidate
+        any iterators.
+      </p>
+<p>
+        Here is an example of using iterators for document traversal (<a href="samples/traverse_iter.cpp" target="_top">samples/traverse_iter.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node_iterator</span> <span class="identifier">it</span> <span class="special">=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span> <span class="identifier">it</span> <span class="special">!=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span> <span class="special">++</span><span class="identifier">it</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Tool:"</span><span class="special">;</span>
+
+    <span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_attribute_iterator</span> <span class="identifier">ait</span> <span class="special">=</span> <span class="identifier">it</span><span class="special">-&gt;</span><span class="identifier">attributes_begin</span><span class="special">();</span> <span class="identifier">ait</span> <span class="special">!=</span> <span class="identifier">it</span><span class="special">-&gt;</span><span class="identifier">attributes_end</span><span class="special">();</span> <span class="special">++</span><span class="identifier">ait</span><span class="special">)</span>
+    <span class="special">{</span>
+        <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">ait</span><span class="special">-&gt;</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"="</span> <span class="special">&lt;&lt;</span> <span class="identifier">ait</span><span class="special">-&gt;</span><span class="identifier">value</span><span class="special">();</span>
+    <span class="special">}</span>
+
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+<p>
+        If your C++ compiler supports range-based for-loop (this is a C++11 feature,
+        at the time of writing it's supported by Microsoft Visual Studio 11 Beta,
+        GCC 4.6 and Clang 3.0), you can use it to enumerate nodes/attributes. Additional
+        helpers are provided to support this; note that they are also compatible
+        with <a href="http://www.boost.org/libs/foreach/" target="_top">Boost Foreach</a>,
+        and possibly other pre-C++11 foreach facilities.
+      </p>
+<p>
+        Here is an example of using C++11 range-based for loop for document traversal
+        (<a href="samples/traverse_rangefor.cpp" target="_top">samples/traverse_rangefor.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">tool</span><span class="special">:</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">children</span><span class="special">(</span><span class="string">"Tool"</span><span class="special">))</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Tool:"</span><span class="special">;</span>
+
+    <span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_attribute</span> <span class="identifier">attr</span><span class="special">:</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">attributes</span><span class="special">())</span>
+    <span class="special">{</span>
+        <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"="</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">value</span><span class="special">();</span>
+    <span class="special">}</span>
+
+    <span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">child</span><span class="special">:</span> <span class="identifier">tool</span><span class="special">.</span><span class="identifier">children</span><span class="special">())</span>
+    <span class="special">{</span>
+        <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">", child "</span> <span class="special">&lt;&lt;</span> <span class="identifier">child</span><span class="special">.</span><span class="identifier">name</span><span class="special">();</span>
+    <span class="special">}</span>
+
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+<span class="special">}</span>
+</pre>
+<p>
+      </p>
+<p>
+        The methods described above allow traversal of immediate children of some
+        node; if you want to do a deep tree traversal, you'll have to do it via a
+        recursive function or some equivalent method. However, pugixml provides a
+        helper for depth-first traversal of a subtree. In order to use it, you have
+        to implement <code class="computeroutput"><span class="identifier">xml_tree_walker</span></code>
+        interface and to call <code class="computeroutput"><span class="identifier">traverse</span></code>
+        function.
+      </p>
+<p>
+        This is an example of traversing tree hierarchy with xml_tree_walker (<a href="samples/traverse_walker.cpp" target="_top">samples/traverse_walker.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">simple_walker</span><span class="special">:</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_tree_walker</span>
+<span class="special">{</span>
+    <span class="keyword">virtual</span> <span class="keyword">bool</span> <span class="identifier">for_each</span><span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">node</span><span class="special">)</span>
+    <span class="special">{</span>
+        <span class="keyword">for</span> <span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="identifier">depth</span><span class="special">();</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"  "</span><span class="special">;</span> <span class="comment">// indentation
+</span>
+        <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">node_types</span><span class="special">[</span><span class="identifier">node</span><span class="special">.</span><span class="identifier">type</span><span class="special">()]</span> <span class="special">&lt;&lt;</span> <span class="string">": name='"</span> <span class="special">&lt;&lt;</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"', value='"</span> <span class="special">&lt;&lt;</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"'\n"</span><span class="special">;</span>
+
+        <span class="keyword">return</span> <span class="keyword">true</span><span class="special">;</span> <span class="comment">// continue traversal
+</span>    <span class="special">}</span>
+<span class="special">};</span>
+</pre>
+<p>
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">simple_walker</span> <span class="identifier">walker</span><span class="special">;</span>
+<span class="identifier">doc</span><span class="special">.</span><span class="identifier">traverse</span><span class="special">(</span><span class="identifier">walker</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+<p>
+        Finally, for complex queries often a higher-level DSL is needed. pugixml
+        provides an implementation of XPath 1.0 language for such queries. The complete
+        description of XPath usage can be found in the manual, but here are some
+        examples:
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_node_set</span> <span class="identifier">tools</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">select_nodes</span><span class="special">(</span><span class="string">"/Profile/Tools/Tool[@AllowRemote='true' and @DeriveCaptionFrom='lastparam']"</span><span class="special">);</span>
+
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Tools:"</span><span class="special">;</span>
+
+<span class="keyword">for</span> <span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_node_set</span><span class="special">::</span><span class="identifier">const_iterator</span> <span class="identifier">it</span> <span class="special">=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">begin</span><span class="special">();</span> <span class="identifier">it</span> <span class="special">!=</span> <span class="identifier">tools</span><span class="special">.</span><span class="identifier">end</span><span class="special">();</span> <span class="special">++</span><span class="identifier">it</span><span class="special">)</span>
+<span class="special">{</span>
+    <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_node</span> <span class="identifier">node</span> <span class="special">=</span> <span class="special">*</span><span class="identifier">it</span><span class="special">;</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">" "</span> <span class="special">&lt;&lt;</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">node</span><span class="special">().</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Filename"</span><span class="special">).</span><span class="identifier">value</span><span class="special">();</span>
+<span class="special">}</span>
+
+<span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xpath_node</span> <span class="identifier">build_tool</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">select_single_node</span><span class="special">(</span><span class="string">"//Tool[contains(Description, 'build system')]"</span><span class="special">);</span>
+
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"\nBuild tool: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">build_tool</span><span class="special">.</span><span class="identifier">node</span><span class="special">().</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"Filename"</span><span class="special">).</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"\n"</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+<div class="caution"><table border="0" summary="Caution">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="images/caution.png"></td>
+<th align="left">Caution</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          XPath functions throw <code class="computeroutput"><span class="identifier">xpath_exception</span></code>
+          objects on error; the sample above does not catch these exceptions.
+        </p></td></tr>
+</table></div>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="quickstart.main.modify"></a><a class="link" href="quickstart.html#quickstart.main.modify" title="Modifying document data"> Modifying document data</a>
+</h3></div></div></div>
+<p>
+        The document in pugixml is fully mutable: you can completely change the document
+        structure and modify the data of nodes/attributes. All functions take care
+        of memory management and structural integrity themselves, so they always
+        result in structurally valid tree - however, it is possible to create an
+        invalid XML tree (for example, by adding two attributes with the same name
+        or by setting attribute/node name to empty/invalid string). Tree modification
+        is optimized for performance and for memory consumption, so if you have enough
+        memory you can create documents from scratch with pugixml and later save
+        them to file/stream instead of relying on error-prone manual text writing
+        and without too much overhead.
+      </p>
+<p>
+        All member functions that change node/attribute data or structure are non-constant
+        and thus can not be called on constant handles. However, you can easily convert
+        constant handle to non-constant one by simple assignment: <code class="computeroutput"><span class="keyword">void</span>
+        <span class="identifier">foo</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span><span class="special">&amp;</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">nc</span> <span class="special">=</span> <span class="identifier">n</span><span class="special">;</span> <span class="special">}</span></code>, so const-correctness
+        here mainly provides additional documentation.
+      </p>
+<p>
+        As discussed before, nodes can have name and value, both of which are strings.
+        Depending on node type, name or value may be absent. You can use <code class="computeroutput"><span class="identifier">set_name</span></code> and <code class="computeroutput"><span class="identifier">set_value</span></code>
+        member functions to set them. Similar functions are available for attributes;
+        however, the <code class="computeroutput"><span class="identifier">set_value</span></code> function
+        is overloaded for some other types except strings, like floating-point numbers.
+        Also, attribute value can be set using an assignment operator. This is an
+        example of setting node/attribute name and value (<a href="samples/modify_base.cpp" target="_top">samples/modify_base.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">node</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"node"</span><span class="special">);</span>
+
+<span class="comment">// change node name
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">set_name</span><span class="special">(</span><span class="string">"notnode"</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">", new node name: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// change comment text
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">last_child</span><span class="special">().</span><span class="identifier">set_value</span><span class="special">(</span><span class="string">"useless comment"</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">", new comment text: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">last_child</span><span class="special">().</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// we can't change value of the element or name of the comment
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">set_value</span><span class="special">(</span><span class="string">"1"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">", "</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">last_child</span><span class="special">().</span><span class="identifier">set_name</span><span class="special">(</span><span class="string">"2"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_attribute</span> <span class="identifier">attr</span> <span class="special">=</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"id"</span><span class="special">);</span>
+
+<span class="comment">// change attribute name/value
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">set_name</span><span class="special">(</span><span class="string">"key"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="string">", "</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">set_value</span><span class="special">(</span><span class="string">"345"</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">", new attribute: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="string">"="</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// we can use numbers or booleans
+</span><span class="identifier">attr</span><span class="special">.</span><span class="identifier">set_value</span><span class="special">(</span><span class="number">1.234</span><span class="special">);</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"new attribute value: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+
+<span class="comment">// we can also use assignment operators for more concise code
+</span><span class="identifier">attr</span> <span class="special">=</span> <span class="keyword">true</span><span class="special">;</span>
+<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"final attribute value: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">attr</span><span class="special">.</span><span class="identifier">value</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+<p>
+        Nodes and attributes do not exist without a document tree, so you can't create
+        them without adding them to some document. A node or attribute can be created
+        at the end of node/attribute list or before/after some other node. All insertion
+        functions return the handle to newly created object on success, and null
+        handle on failure. Even if the operation fails (for example, if you're trying
+        to add a child node to PCDATA node), the document remains in consistent state,
+        but the requested node/attribute is not added.
+      </p>
+<div class="caution"><table border="0" summary="Caution">
+<tr>
+<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="images/caution.png"></td>
+<th align="left">Caution</th>
+</tr>
+<tr><td align="left" valign="top"><p>
+          attribute() and child() functions do not add attributes or nodes to the
+          tree, so code like <code class="computeroutput"><span class="identifier">node</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"id"</span><span class="special">)</span> <span class="special">=</span> <span class="number">123</span><span class="special">;</span></code> will not do anything if <code class="computeroutput"><span class="identifier">node</span></code> does not have an attribute with
+          name <code class="computeroutput"><span class="string">"id"</span></code>. Make sure
+          you're operating with existing attributes/nodes by adding them if necessary.
+        </p></td></tr>
+</table></div>
+<p>
+        This is an example of adding new attributes/nodes to the document (<a href="samples/modify_add.cpp" target="_top">samples/modify_add.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// add node with some name
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">node</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">append_child</span><span class="special">(</span><span class="string">"node"</span><span class="special">);</span>
+
+<span class="comment">// add description node with text child
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">descr</span> <span class="special">=</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">append_child</span><span class="special">(</span><span class="string">"description"</span><span class="special">);</span>
+<span class="identifier">descr</span><span class="special">.</span><span class="identifier">append_child</span><span class="special">(</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">node_pcdata</span><span class="special">).</span><span class="identifier">set_value</span><span class="special">(</span><span class="string">"Simple node"</span><span class="special">);</span>
+
+<span class="comment">// add param node before the description
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">param</span> <span class="special">=</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">insert_child_before</span><span class="special">(</span><span class="string">"param"</span><span class="special">,</span> <span class="identifier">descr</span><span class="special">);</span>
+
+<span class="comment">// add attributes to param node
+</span><span class="identifier">param</span><span class="special">.</span><span class="identifier">append_attribute</span><span class="special">(</span><span class="string">"name"</span><span class="special">)</span> <span class="special">=</span> <span class="string">"version"</span><span class="special">;</span>
+<span class="identifier">param</span><span class="special">.</span><span class="identifier">append_attribute</span><span class="special">(</span><span class="string">"value"</span><span class="special">)</span> <span class="special">=</span> <span class="number">1.1</span><span class="special">;</span>
+<span class="identifier">param</span><span class="special">.</span><span class="identifier">insert_attribute_after</span><span class="special">(</span><span class="string">"type"</span><span class="special">,</span> <span class="identifier">param</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"name"</span><span class="special">))</span> <span class="special">=</span> <span class="string">"float"</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+<p>
+        If you do not want your document to contain some node or attribute, you can
+        remove it with <code class="computeroutput"><span class="identifier">remove_attribute</span></code>
+        and <code class="computeroutput"><span class="identifier">remove_child</span></code> functions.
+        Removing the attribute or node invalidates all handles to the same underlying
+        object, and also invalidates all iterators pointing to the same object. Removing
+        node also invalidates all past-the-end iterators to its attribute or child
+        node list. Be careful to ensure that all such handles and iterators either
+        do not exist or are not used after the attribute/node is removed.
+      </p>
+<p>
+        This is an example of removing attributes/nodes from the document (<a href="samples/modify_remove.cpp" target="_top">samples/modify_remove.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// remove description node with the whole subtree
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">node</span> <span class="special">=</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"node"</span><span class="special">);</span>
+<span class="identifier">node</span><span class="special">.</span><span class="identifier">remove_child</span><span class="special">(</span><span class="string">"description"</span><span class="special">);</span>
+
+<span class="comment">// remove id attribute
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_node</span> <span class="identifier">param</span> <span class="special">=</span> <span class="identifier">node</span><span class="special">.</span><span class="identifier">child</span><span class="special">(</span><span class="string">"param"</span><span class="special">);</span>
+<span class="identifier">param</span><span class="special">.</span><span class="identifier">remove_attribute</span><span class="special">(</span><span class="string">"value"</span><span class="special">);</span>
+
+<span class="comment">// we can also remove nodes/attributes by handles
+</span><span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_attribute</span> <span class="identifier">id</span> <span class="special">=</span> <span class="identifier">param</span><span class="special">.</span><span class="identifier">attribute</span><span class="special">(</span><span class="string">"name"</span><span class="special">);</span>
+<span class="identifier">param</span><span class="special">.</span><span class="identifier">remove_attribute</span><span class="special">(</span><span class="identifier">id</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="quickstart.main.saving"></a><a class="link" href="quickstart.html#quickstart.main.saving" title="Saving document"> Saving document</a>
+</h3></div></div></div>
+<p>
+        Often after creating a new document or loading the existing one and processing
+        it, it is necessary to save the result back to file. Also it is occasionally
+        useful to output the whole document or a subtree to some stream; use cases
+        include debug printing, serialization via network or other text-oriented
+        medium, etc. pugixml provides several functions to output any subtree of
+        the document to a file, stream or another generic transport interface; these
+        functions allow to customize the output format, and also perform necessary
+        encoding conversions.
+      </p>
+<p>
+        Before writing to the destination the node/attribute data is properly formatted
+        according to the node type; all special XML symbols, such as &lt; and &amp;,
+        are properly escaped. In order to guard against forgotten node/attribute
+        names, empty node/attribute names are printed as <code class="computeroutput"><span class="string">":anonymous"</span></code>.
+        For well-formed output, make sure all node and attribute names are set to
+        meaningful values.
+      </p>
+<p>
+        If you want to save the whole document to a file, you can use the <code class="computeroutput"><span class="identifier">save_file</span></code> function, which returns <code class="computeroutput"><span class="keyword">true</span></code> on success. This is a simple example
+        of saving XML document to file (<a href="samples/save_file.cpp" target="_top">samples/save_file.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// save document to file
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Saving result: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">doc</span><span class="special">.</span><span class="identifier">save_file</span><span class="special">(</span><span class="string">"save_file_output.xml"</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
+</pre>
+<p>
+      </p>
+<p>
+        To enhance interoperability pugixml provides functions for saving document
+        to any object which implements C++ <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span></code>
+        interface. This allows you to save documents to any standard C++ stream (i.e.
+        file stream) or any third-party compliant implementation (i.e. Boost Iostreams).
+        Most notably, this allows for easy debug output, since you can use <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span></code>
+        stream as saving target. There are two functions, one works with narrow character
+        streams, another handles wide character ones.
+      </p>
+<p>
+        This is a simple example of saving XML document to standard output (<a href="samples/save_stream.cpp" target="_top">samples/save_stream.cpp</a>):
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="comment">// save document to standard output
+</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Document:\n"</span><span class="special">;</span>
+<span class="identifier">doc</span><span class="special">.</span><span class="identifier">save</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">);</span>
+</pre>
+<p>
+      </p>
+<p>
+        All of the above saving functions are implemented in terms of writer interface.
+        This is a simple interface with a single function, which is called several
+        times during output process with chunks of document data as input. In order
+        to output the document via some custom transport, for example sockets, you
+        should create an object which implements <code class="computeroutput"><span class="identifier">xml_writer_file</span></code>
+        interface and pass it to <code class="computeroutput"><span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">save</span></code>
+        function.
+      </p>
+<p>
+        This is a simple example of custom writer for saving document data to STL
+        string (<a href="samples/save_custom_writer.cpp" target="_top">samples/save_custom_writer.cpp</a>);
+        read the sample code for more complex examples:
+      </p>
+<p>
+        
+</p>
+<pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">xml_string_writer</span><span class="special">:</span> <span class="identifier">pugi</span><span class="special">::</span><span class="identifier">xml_writer</span>
+<span class="special">{</span>
+    <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">result</span><span class="special">;</span>
+
+    <span class="keyword">virtual</span> <span class="keyword">void</span> <span class="identifier">write</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">data</span><span class="special">,</span> <span class="identifier">size_t</span> <span class="identifier">size</span><span class="special">)</span>
+    <span class="special">{</span>
+        <span class="identifier">result</span> <span class="special">+=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="keyword">static_cast</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;(</span><span class="identifier">data</span><span class="special">),</span> <span class="identifier">size</span><span class="special">);</span>
+    <span class="special">}</span>
+<span class="special">};</span>
+</pre>
+<p>
+      </p>
+<p>
+        While the previously described functions save the whole document to the destination,
+        it is easy to save a single subtree. Instead of calling <code class="computeroutput"><span class="identifier">xml_document</span><span class="special">::</span><span class="identifier">save</span></code>,
+        just call <code class="computeroutput"><span class="identifier">xml_node</span><span class="special">::</span><span class="identifier">print</span></code> function on the target node. You
+        can save node contents to C++ IOstream object or custom writer in this way.
+        Saving a subtree slightly differs from saving the whole document; <a href="manual/saving.html#manual.saving.subtree" target="_top">read the manual</a> for
+        more information.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="quickstart.main.feedback"></a><a class="link" href="quickstart.html#quickstart.main.feedback" title="Feedback"> Feedback</a>
+</h3></div></div></div>
+<p>
+        If you believe you've found a bug in pugixml, please file an issue via <a href="http://code.google.com/p/pugixml/issues/entry" target="_top">issue submission form</a>.
+        Be sure to include the relevant information so that the bug can be reproduced:
+        the version of pugixml, compiler version and target architecture, the code
+        that uses pugixml and exhibits the bug, etc. Feature requests and contributions
+        can be filed as issues, too.
+      </p>
+<a name="email"></a><p>
+        If filing an issue is not possible due to privacy or other concerns, you
+        can contact pugixml author by e-mail directly: <a href="mailto:arseny.kapoulkine@gmail.com" target="_top">arseny.kapoulkine@gmail.com</a>.
+      </p>
+</div>
+<div class="section">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="quickstart.main.license"></a><a class="link" href="quickstart.html#quickstart.main.license" title="License"> License</a>
+</h3></div></div></div>
+<p>
+        The pugixml library is distributed under the MIT license:
+      </p>
+<div class="blockquote"><blockquote class="blockquote">
+<p>
+          Copyright (c) 2006-2012 Arseny Kapoulkine
+        </p>
+<p>
+          Permission is hereby granted, free of charge, to any person obtaining a
+          copy of this software and associated documentation files (the "Software"),
+          to deal in the Software without restriction, including without limitation
+          the rights to use, copy, modify, merge, publish, distribute, sublicense,
+          and/or sell copies of the Software, and to permit persons to whom the Software
+          is furnished to do so, subject to the following conditions:
+        </p>
+<p>
+          The above copyright notice and this permission notice shall be included
+          in all copies or substantial portions of the Software.
+        </p>
+<p>
+          THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+          EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+          FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+          THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+          LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+          FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+          IN THE SOFTWARE.
+        </p>
+</blockquote></div>
+<p>
+        This means that you can freely use pugixml in your applications, both open-source
+        and proprietary. If you use pugixml in a product, it is sufficient to add
+        an acknowledgment like this to the product distribution:
+      </p>
+<div class="blockquote"><blockquote class="blockquote"><p>
+          This software is based on pugixml library (http://pugixml.org).<br>
+pugixml
+          is Copyright (C) 2006-2012 Arseny Kapoulkine.
+        </p></blockquote></div>
+</div>
+</div>
+<div class="footnotes">
+<br><hr width="100" align="left">
+<div class="footnote"><p><sup>[<a name="ftn.trademarks" href="#trademarks" class="para">1</a>] </sup>All trademarks used are properties of their respective owners.</p></div>
+</div>
+</div>
+<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
+<td align="left"><p><small>Last revised: April 30, 2012 at 03:25:55 GMT</small></p></td>
+<td align="right"><div class="copyright-footer"></div></td>
+</tr></table>
+</body>
+</html>
diff --git a/tools/intergen/third_party/pugixml/docs/samples/character.xml b/tools/intergen/third_party/pugixml/docs/samples/character.xml
new file mode 100644
index 0000000000..078e0bf802
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/character.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<network>
+	<animation clip="idle" flags="loop" />
+	<animation clip="run" flags="loop" />
+	<animation clip="attack" />
+
+	<?include transitions.xml?>
+</network>
diff --git a/tools/intergen/third_party/pugixml/docs/samples/custom_memory_management.cpp b/tools/intergen/third_party/pugixml/docs/samples/custom_memory_management.cpp
new file mode 100644
index 0000000000..92ccb7112d
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/custom_memory_management.cpp
@@ -0,0 +1,27 @@
+#include "pugixml.hpp"
+
+#include <new>
+
+//[code_custom_memory_management_decl
+void* custom_allocate(size_t size)
+{
+    return new (std::nothrow) char[size];
+}
+
+void custom_deallocate(void* ptr)
+{
+    delete[] static_cast<char*>(ptr);
+}
+//]
+
+int main()
+{
+//[code_custom_memory_management_call
+    pugi::set_memory_management_functions(custom_allocate, custom_deallocate);
+//]
+
+    pugi::xml_document doc;
+    doc.load("<node/>");
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/include.cpp b/tools/intergen/third_party/pugixml/docs/samples/include.cpp
new file mode 100644
index 0000000000..fa615a451a
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/include.cpp
@@ -0,0 +1,64 @@
+#include "pugixml.hpp"
+
+#include <string.h>
+#include <iostream>
+
+//[code_include
+bool load_preprocess(pugi::xml_document& doc, const char* path);
+
+bool preprocess(pugi::xml_node node)
+{
+    for (pugi::xml_node child = node.first_child(); child; )
+    {
+        if (child.type() == pugi::node_pi && strcmp(child.name(), "include") == 0)
+        {
+            pugi::xml_node include = child;
+
+            // load new preprocessed document (note: ideally this should handle relative paths)
+            const char* path = include.value();
+
+            pugi::xml_document doc;
+            if (!load_preprocess(doc, path)) return false;
+
+            // insert the comment marker above include directive
+            node.insert_child_before(pugi::node_comment, include).set_value(path);
+
+            // copy the document above the include directive (this retains the original order!)
+            for (pugi::xml_node ic = doc.first_child(); ic; ic = ic.next_sibling())
+            {
+                node.insert_copy_before(ic, include);
+            }
+
+            // remove the include node and move to the next child
+            child = child.next_sibling();
+
+            node.remove_child(include);
+        }
+        else
+        {
+            if (!preprocess(child)) return false;
+
+            child = child.next_sibling();
+        }
+    }
+
+    return true;
+}
+
+bool load_preprocess(pugi::xml_document& doc, const char* path)
+{
+    pugi::xml_parse_result result = doc.load_file(path, pugi::parse_default | pugi::parse_pi); // for <?include?>
+    
+    return result ? preprocess(doc) : false;
+}
+//]
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!load_preprocess(doc, "character.xml")) return -1;
+
+    doc.print(std::cout);
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/load_error_handling.cpp b/tools/intergen/third_party/pugixml/docs/samples/load_error_handling.cpp
new file mode 100644
index 0000000000..18dd331d43
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/load_error_handling.cpp
@@ -0,0 +1,31 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+void check_xml(const char* source)
+{
+//[code_load_error_handling
+    pugi::xml_document doc;
+    pugi::xml_parse_result result = doc.load(source);
+
+    if (result)
+        std::cout << "XML [" << source << "] parsed without errors, attr value: [" << doc.child("node").attribute("attr").value() << "]\n\n";
+    else
+    {
+        std::cout << "XML [" << source << "] parsed with errors, attr value: [" << doc.child("node").attribute("attr").value() << "]\n";
+        std::cout << "Error description: " << result.description() << "\n";
+        std::cout << "Error offset: " << result.offset << " (error at [..." << (source + result.offset) << "]\n\n";
+    }
+//]
+}
+
+int main()
+{
+    check_xml("<node attr='value'><child>text</child></node>");
+    check_xml("<node attr='value'><child>text</chil></node>");
+    check_xml("<node attr='value'><child>text</child>");
+    check_xml("<node attr='value\"><child>text</child></node>");
+    check_xml("<node attr='value'><#tag /></node>");
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/load_file.cpp b/tools/intergen/third_party/pugixml/docs/samples/load_file.cpp
new file mode 100644
index 0000000000..f7b06c95d6
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/load_file.cpp
@@ -0,0 +1,16 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+//[code_load_file
+    pugi::xml_document doc;
+
+    pugi::xml_parse_result result = doc.load_file("tree.xml");
+
+    std::cout << "Load result: " << result.description() << ", mesh name: " << doc.child("mesh").attribute("name").value() << std::endl;
+//]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/load_memory.cpp b/tools/intergen/third_party/pugixml/docs/samples/load_memory.cpp
new file mode 100644
index 0000000000..365fb64c33
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/load_memory.cpp
@@ -0,0 +1,64 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+//[code_load_memory_decl
+    const char source[] = "<mesh name='sphere'><bounds>0 0 1 1</bounds></mesh>";
+    size_t size = sizeof(source);
+//]
+
+    pugi::xml_document doc;
+
+    {
+    //[code_load_memory_buffer
+        // You can use load_buffer to load document from immutable memory block:
+        pugi::xml_parse_result result = doc.load_buffer(source, size);
+    //]
+
+        std::cout << "Load result: " << result.description() << ", mesh name: " << doc.child("mesh").attribute("name").value() << std::endl;
+    }
+
+    {
+    //[code_load_memory_buffer_inplace
+        // You can use load_buffer_inplace to load document from mutable memory block; the block's lifetime must exceed that of document
+        char* buffer = new char[size];
+        memcpy(buffer, source, size);
+
+        // The block can be allocated by any method; the block is modified during parsing
+        pugi::xml_parse_result result = doc.load_buffer_inplace(buffer, size);
+
+    //<-
+        std::cout << "Load result: " << result.description() << ", mesh name: " << doc.child("mesh").attribute("name").value() << std::endl;
+    //->
+        // You have to destroy the block yourself after the document is no longer used
+        delete[] buffer;
+    //]
+    }
+
+    {
+    //[code_load_memory_buffer_inplace_own
+        // You can use load_buffer_inplace_own to load document from mutable memory block and to pass the ownership of this block
+        // The block has to be allocated via pugixml allocation function - using i.e. operator new here is incorrect
+        char* buffer = static_cast<char*>(pugi::get_memory_allocation_function()(size));
+        memcpy(buffer, source, size);
+
+        // The block will be deleted by the document
+        pugi::xml_parse_result result = doc.load_buffer_inplace_own(buffer, size);
+    //]
+
+        std::cout << "Load result: " << result.description() << ", mesh name: " << doc.child("mesh").attribute("name").value() << std::endl;
+    }
+
+    {
+    //[code_load_memory_string
+        // You can use load to load document from null-terminated strings, for example literals:
+        pugi::xml_parse_result result = doc.load("<mesh name='sphere'><bounds>0 0 1 1</bounds></mesh>");
+    //]
+
+        std::cout << "Load result: " << result.description() << ", mesh name: " << doc.child("mesh").attribute("name").value() << std::endl;
+    }
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/load_options.cpp b/tools/intergen/third_party/pugixml/docs/samples/load_options.cpp
new file mode 100644
index 0000000000..04b4b46553
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/load_options.cpp
@@ -0,0 +1,30 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+
+//[code_load_options
+    const char* source = "<!--comment--><node>&lt;</node>";
+
+    // Parsing with default options; note that comment node is not added to the tree, and entity reference &lt; is expanded
+    doc.load(source);
+    std::cout << "First node value: [" << doc.first_child().value() << "], node child value: [" << doc.child_value("node") << "]\n";
+
+    // Parsing with additional parse_comments option; comment node is now added to the tree
+    doc.load(source, pugi::parse_default | pugi::parse_comments);
+    std::cout << "First node value: [" << doc.first_child().value() << "], node child value: [" << doc.child_value("node") << "]\n";
+
+    // Parsing with additional parse_comments option and without the (default) parse_escapes option; &lt; is not expanded
+    doc.load(source, (pugi::parse_default | pugi::parse_comments) & ~pugi::parse_escapes);
+    std::cout << "First node value: [" << doc.first_child().value() << "], node child value: [" << doc.child_value("node") << "]\n";
+
+    // Parsing with minimal option mask; comment node is not added to the tree, and &lt; is not expanded
+    doc.load(source, pugi::parse_minimal);
+    std::cout << "First node value: [" << doc.first_child().value() << "], node child value: [" << doc.child_value("node") << "]\n";
+//]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/load_stream.cpp b/tools/intergen/third_party/pugixml/docs/samples/load_stream.cpp
new file mode 100644
index 0000000000..05cfb7f8d6
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/load_stream.cpp
@@ -0,0 +1,97 @@
+#include "pugixml.hpp"
+
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+
+void print_doc(const char* message, const pugi::xml_document& doc, const pugi::xml_parse_result& result)
+{
+    std::cout
+        << message
+        << "\t: load result '" << result.description() << "'"
+        << ", first character of root name: U+" << std::hex << std::uppercase << std::setw(4) << std::setfill('0') << pugi::as_wide(doc.first_child().name())[0]
+        << ", year: " << doc.first_child().first_child().first_child().child_value()
+        << std::endl;
+}
+
+bool try_imbue(std::wistream& stream, const char* name)
+{
+    try
+    {
+        stream.imbue(std::locale(name));
+
+        return true;
+    }
+    catch (const std::exception&)
+    {
+        return false;
+    }
+}
+
+int main()
+{
+    pugi::xml_document doc;
+
+    {
+    //[code_load_stream
+        std::ifstream stream("weekly-utf-8.xml");
+        pugi::xml_parse_result result = doc.load(stream);
+    //]
+
+        // first character of root name: U+9031, year: 1997
+        print_doc("UTF8 file from narrow stream", doc, result);
+    }
+
+    {
+        std::ifstream stream("weekly-utf-16.xml");
+        pugi::xml_parse_result result = doc.load(stream);
+
+        // first character of root name: U+9031, year: 1997
+        print_doc("UTF16 file from narrow stream", doc, result);
+    }
+
+    {
+        // Since wide streams are treated as UTF-16/32 ones, you can't load the UTF-8 file from a wide stream
+        // directly if you have localized characters; you'll have to provide a UTF8 locale (there is no
+        // standard one; you can use utf8_codecvt_facet from Boost or codecvt_utf8 from C++0x)
+        std::wifstream stream("weekly-utf-8.xml");
+
+        if (try_imbue(stream, "en_US.UTF-8")) // try Linux encoding
+        {
+            pugi::xml_parse_result result = doc.load(stream);
+
+            // first character of root name: U+00E9, year: 1997
+            print_doc("UTF8 file from wide stream", doc, result);
+        }
+        else
+        {
+            std::cout << "UTF-8 locale is not available\n";
+        }
+    }
+
+    {
+        // Since wide streams are treated as UTF-16/32 ones, you can't load the UTF-16 file from a wide stream without
+        // using custom codecvt; you can use codecvt_utf16 from C++0x
+    }
+
+    {
+        // Since encoding names are non-standard, you can't load the Shift-JIS (or any other non-ASCII) file
+        // from a wide stream portably
+        std::wifstream stream("weekly-shift_jis.xml");
+
+        if (try_imbue(stream, ".932") || // try Microsoft encoding
+            try_imbue(stream, "ja_JP.SJIS")) // try Linux encoding; run "localedef -i ja_JP -c -f SHIFT_JIS /usr/lib/locale/ja_JP.SJIS" to get it
+        {
+            pugi::xml_parse_result result = doc.load(stream);
+
+            // first character of root name: U+9031, year: 1997
+            print_doc("Shift-JIS file from wide stream", doc, result);
+        }
+        else
+        {
+            std::cout << "Shift-JIS locale is not available\n";
+        }
+    }
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/modify_add.cpp b/tools/intergen/third_party/pugixml/docs/samples/modify_add.cpp
new file mode 100644
index 0000000000..04ab4450a1
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/modify_add.cpp
@@ -0,0 +1,29 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+
+    //[code_modify_add
+    // add node with some name
+    pugi::xml_node node = doc.append_child("node");
+
+    // add description node with text child
+    pugi::xml_node descr = node.append_child("description");
+    descr.append_child(pugi::node_pcdata).set_value("Simple node");
+
+    // add param node before the description
+    pugi::xml_node param = node.insert_child_before("param", descr);
+
+    // add attributes to param node
+    param.append_attribute("name") = "version";
+    param.append_attribute("value") = 1.1;
+    param.insert_attribute_after("type", param.attribute("name")) = "float";
+    //]
+
+    doc.print(std::cout);
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/modify_base.cpp b/tools/intergen/third_party/pugixml/docs/samples/modify_base.cpp
new file mode 100644
index 0000000000..7d0959a0a4
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/modify_base.cpp
@@ -0,0 +1,43 @@
+#include "pugixml.hpp"
+
+#include <string.h>
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!doc.load("<node id='123'>text</node><!-- comment -->", pugi::parse_default | pugi::parse_comments)) return -1;
+
+    //[code_modify_base_node
+    pugi::xml_node node = doc.child("node");
+
+    // change node name
+    std::cout << node.set_name("notnode");
+    std::cout << ", new node name: " << node.name() << std::endl;
+
+    // change comment text
+    std::cout << doc.last_child().set_value("useless comment");
+    std::cout << ", new comment text: " << doc.last_child().value() << std::endl;
+
+    // we can't change value of the element or name of the comment
+    std::cout << node.set_value("1") << ", " << doc.last_child().set_name("2") << std::endl;
+    //]
+
+    //[code_modify_base_attr
+    pugi::xml_attribute attr = node.attribute("id");
+
+    // change attribute name/value
+    std::cout << attr.set_name("key") << ", " << attr.set_value("345");
+    std::cout << ", new attribute: " << attr.name() << "=" << attr.value() << std::endl;
+
+    // we can use numbers or booleans
+    attr.set_value(1.234);
+    std::cout << "new attribute value: " << attr.value() << std::endl;
+
+    // we can also use assignment operators for more concise code
+    attr = true;
+    std::cout << "final attribute value: " << attr.value() << std::endl;
+    //]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/modify_remove.cpp b/tools/intergen/third_party/pugixml/docs/samples/modify_remove.cpp
new file mode 100644
index 0000000000..28c2f6bc97
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/modify_remove.cpp
@@ -0,0 +1,27 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!doc.load("<node><description>Simple node</description><param name='id' value='123'/></node>")) return -1;
+
+    //[code_modify_remove
+    // remove description node with the whole subtree
+    pugi::xml_node node = doc.child("node");
+    node.remove_child("description");
+
+    // remove id attribute
+    pugi::xml_node param = node.child("param");
+    param.remove_attribute("value");
+
+    // we can also remove nodes/attributes by handles
+    pugi::xml_attribute id = param.attribute("name");
+    param.remove_attribute(id);
+    //]
+
+    doc.print(std::cout);
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/save_custom_writer.cpp b/tools/intergen/third_party/pugixml/docs/samples/save_custom_writer.cpp
new file mode 100644
index 0000000000..defcb33fff
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/save_custom_writer.cpp
@@ -0,0 +1,116 @@
+#include "pugixml.hpp"
+
+#include <string>
+
+#include <stdio.h>
+
+//[code_save_custom_writer
+struct xml_string_writer: pugi::xml_writer
+{
+    std::string result;
+
+    virtual void write(const void* data, size_t size)
+    {
+        result += std::string(static_cast<const char*>(data), size);
+    }
+};
+//]
+
+struct xml_memory_writer: pugi::xml_writer
+{
+    char* buffer;
+    size_t capacity;
+
+    size_t result;
+
+    xml_memory_writer(): buffer(0), capacity(0), result(0)
+    {
+    }
+
+    xml_memory_writer(char* buffer, size_t capacity): buffer(buffer), capacity(capacity), result(0)
+    {
+    }
+
+    size_t written_size() const
+    {
+        return result < capacity ? result : capacity;
+    }
+
+    virtual void write(const void* data, size_t size)
+    {
+        if (result < capacity)
+        {
+            size_t chunk = (capacity - result < size) ? capacity - result : size;
+
+            memcpy(buffer + result, data, chunk);
+        }
+
+        result += size;
+    }
+};
+
+std::string node_to_string(pugi::xml_node node)
+{
+    xml_string_writer writer;
+    node.print(writer);
+
+    return writer.result;
+}
+
+char* node_to_buffer(pugi::xml_node node, char* buffer, size_t size)
+{
+    if (size == 0) return buffer;
+
+    // leave one character for null terminator
+    xml_memory_writer writer(buffer, size - 1);
+    node.print(writer);
+
+    // null terminate
+    buffer[writer.written_size()] = 0;
+
+    return buffer;
+}
+
+char* node_to_buffer_heap(pugi::xml_node node)
+{
+    // first pass: get required memory size
+    xml_memory_writer counter;
+    node.print(counter);
+
+    // allocate necessary size (+1 for null termination)
+    char* buffer = new char[counter.result + 1];
+
+    // second pass: actual printing
+    xml_memory_writer writer(buffer, counter.result);
+    node.print(writer);
+
+    // null terminate
+    buffer[writer.written_size()] = 0;
+
+    return buffer;
+}
+
+int main()
+{
+    // get a test document
+    pugi::xml_document doc;
+    doc.load("<foo bar='baz'>hey</foo>");
+
+    // get contents as std::string (single pass)
+    printf("contents: [%s]\n", node_to_string(doc).c_str());
+
+    // get contents into fixed-size buffer (single pass)
+    char large_buf[128];
+    printf("contents: [%s]\n", node_to_buffer(doc, large_buf, sizeof(large_buf)));
+
+    // get contents into fixed-size buffer (single pass, shows truncating behavior)
+    char small_buf[22];
+    printf("contents: [%s]\n", node_to_buffer(doc, small_buf, sizeof(small_buf)));
+
+    // get contents into heap-allocated buffer (two passes)
+    char* heap_buf = node_to_buffer_heap(doc);
+    printf("contents: [%s]\n", heap_buf);
+    delete[] heap_buf;
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/save_declaration.cpp b/tools/intergen/third_party/pugixml/docs/samples/save_declaration.cpp
new file mode 100644
index 0000000000..aaed9b57be
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/save_declaration.cpp
@@ -0,0 +1,27 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    //[code_save_declaration
+    // get a test document
+    pugi::xml_document doc;
+    doc.load("<foo bar='baz'><call>hey</call></foo>");
+
+    // add a custom declaration node
+    pugi::xml_node decl = doc.prepend_child(pugi::node_declaration);
+    decl.append_attribute("version") = "1.0";
+    decl.append_attribute("encoding") = "UTF-8";
+    decl.append_attribute("standalone") = "no";
+
+    // <?xml version="1.0" encoding="UTF-8" standalone="no"?> 
+    // <foo bar="baz">
+    //         <call>hey</call>
+    // </foo>
+    doc.save(std::cout);
+    std::cout << std::endl;
+    //]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/save_file.cpp b/tools/intergen/third_party/pugixml/docs/samples/save_file.cpp
new file mode 100644
index 0000000000..30c1aa17c8
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/save_file.cpp
@@ -0,0 +1,17 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    // get a test document
+    pugi::xml_document doc;
+    doc.load("<foo bar='baz'>hey</foo>");
+
+    //[code_save_file
+    // save document to file
+    std::cout << "Saving result: " << doc.save_file("save_file_output.xml") << std::endl;
+    //]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/save_options.cpp b/tools/intergen/third_party/pugixml/docs/samples/save_options.cpp
new file mode 100644
index 0000000000..6a49f6668c
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/save_options.cpp
@@ -0,0 +1,48 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    //[code_save_options
+    // get a test document
+    pugi::xml_document doc;
+    doc.load("<foo bar='baz'><call>hey</call></foo>");
+
+    // default options; prints
+    // <?xml version="1.0"?>
+    // <foo bar="baz">
+    //         <call>hey</call>
+    // </foo>
+    doc.save(std::cout);
+    std::cout << std::endl;
+
+    // default options with custom indentation string; prints
+    // <?xml version="1.0"?>
+    // <foo bar="baz">
+    // --<call>hey</call>
+    // </foo>
+    doc.save(std::cout, "--");
+    std::cout << std::endl;
+
+    // default options without indentation; prints
+    // <?xml version="1.0"?>
+    // <foo bar="baz">
+    // <call>hey</call>
+    // </foo>
+    doc.save(std::cout, "\t", pugi::format_default & ~pugi::format_indent); // can also pass "" instead of indentation string for the same effect
+    std::cout << std::endl;
+
+    // raw output; prints
+    // <?xml version="1.0"?><foo bar="baz"><call>hey</call></foo>
+    doc.save(std::cout, "\t", pugi::format_raw);
+    std::cout << std::endl << std::endl;
+
+    // raw output without declaration; prints
+    // <foo bar="baz"><call>hey</call></foo>
+    doc.save(std::cout, "\t", pugi::format_raw | pugi::format_no_declaration);
+    std::cout << std::endl;
+    //]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/save_stream.cpp b/tools/intergen/third_party/pugixml/docs/samples/save_stream.cpp
new file mode 100644
index 0000000000..d01965d2bd
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/save_stream.cpp
@@ -0,0 +1,18 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    // get a test document
+    pugi::xml_document doc;
+    doc.load("<foo bar='baz'><call>hey</call></foo>");
+
+    //[code_save_stream
+    // save document to standard output
+    std::cout << "Document:\n";
+    doc.save(std::cout);
+    //]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/save_subtree.cpp b/tools/intergen/third_party/pugixml/docs/samples/save_subtree.cpp
new file mode 100644
index 0000000000..0091b3d8a8
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/save_subtree.cpp
@@ -0,0 +1,26 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    //[code_save_subtree
+    // get a test document
+    pugi::xml_document doc;
+    doc.load("<foo bar='baz'><call>hey</call></foo>");
+
+    // print document to standard output (prints <?xml version="1.0"?><foo bar="baz"><call>hey</call></foo>)
+    doc.save(std::cout, "", pugi::format_raw);
+    std::cout << std::endl;
+
+    // print document to standard output as a regular node (prints <foo bar="baz"><call>hey</call></foo>)
+    doc.print(std::cout, "", pugi::format_raw);
+    std::cout << std::endl;
+
+    // print a subtree to standard output (prints <call>hey</call>)
+    doc.child("foo").child("call").print(std::cout, "", pugi::format_raw);
+    std::cout << std::endl;
+    //]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/text.cpp b/tools/intergen/third_party/pugixml/docs/samples/text.cpp
new file mode 100644
index 0000000000..7e0370945e
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/text.cpp
@@ -0,0 +1,35 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+
+    // get a test document
+    doc.load("<project><name>test</name><version>1.1</version><public>yes</public></project>");
+
+    pugi::xml_node project = doc.child("project");
+
+    //[code_text_access
+    std::cout << "Project name: " << project.child("name").text().get() << std::endl;
+    std::cout << "Project version: " << project.child("version").text().as_double() << std::endl;
+    std::cout << "Project visibility: " << (project.child("public").text().as_bool(/* def= */ true) ? "public" : "private") << std::endl;
+    std::cout << "Project description: " << project.child("description").text().get() << std::endl;
+    //]
+
+    std::cout << std::endl;
+
+    //[code_text_modify
+    // change project version
+    project.child("version").text() = 1.2;
+
+    // add description element and set the contents
+    // note that we do not have to explicitly add the node_pcdata child
+    project.append_child("description").text().set("a test project");
+    //]
+
+    doc.save(std::cout);
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/transitions.xml b/tools/intergen/third_party/pugixml/docs/samples/transitions.xml
new file mode 100644
index 0000000000..a195ef8e58
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/transitions.xml
@@ -0,0 +1,7 @@
+<transition source="idle" target="run">
+	<event name="key_up|key_shift" />
+</transition>
+<transition source="run" target="attack">
+	<event name="key_ctrl" />
+	<condition expr="weapon != null" />
+</transition>
diff --git a/tools/intergen/third_party/pugixml/docs/samples/traverse_base.cpp b/tools/intergen/third_party/pugixml/docs/samples/traverse_base.cpp
new file mode 100644
index 0000000000..d59c8b0cfb
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/traverse_base.cpp
@@ -0,0 +1,51 @@
+#include "pugixml.hpp"
+
+#include <string.h>
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!doc.load_file("xgconsole.xml")) return -1;
+
+    pugi::xml_node tools = doc.child("Profile").child("Tools");
+
+    //[code_traverse_base_basic
+    for (pugi::xml_node tool = tools.first_child(); tool; tool = tool.next_sibling())
+    {
+        std::cout << "Tool:";
+
+        for (pugi::xml_attribute attr = tool.first_attribute(); attr; attr = attr.next_attribute())
+        {
+            std::cout << " " << attr.name() << "=" << attr.value();
+        }
+
+        std::cout << std::endl;
+    }
+    //]
+
+    std::cout << std::endl;
+
+    //[code_traverse_base_data
+    for (pugi::xml_node tool = tools.child("Tool"); tool; tool = tool.next_sibling("Tool"))
+    {
+        std::cout << "Tool " << tool.attribute("Filename").value();
+        std::cout << ": AllowRemote " << tool.attribute("AllowRemote").as_bool();
+        std::cout << ", Timeout " << tool.attribute("Timeout").as_int();
+        std::cout << ", Description '" << tool.child_value("Description") << "'\n";
+    }
+    //]
+
+    std::cout << std::endl;
+
+    //[code_traverse_base_contents
+    std::cout << "Tool for *.dae generation: " << tools.find_child_by_attribute("Tool", "OutputFileMasks", "*.dae").attribute("Filename").value() << "\n";
+
+    for (pugi::xml_node tool = tools.child("Tool"); tool; tool = tool.next_sibling("Tool"))
+    {
+        std::cout << "Tool " << tool.attribute("Filename").value() << "\n";
+    }
+    //]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/traverse_iter.cpp b/tools/intergen/third_party/pugixml/docs/samples/traverse_iter.cpp
new file mode 100644
index 0000000000..90e0dc62c6
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/traverse_iter.cpp
@@ -0,0 +1,27 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!doc.load_file("xgconsole.xml")) return -1;
+
+    pugi::xml_node tools = doc.child("Profile").child("Tools");
+
+    //[code_traverse_iter
+    for (pugi::xml_node_iterator it = tools.begin(); it != tools.end(); ++it)
+    {
+        std::cout << "Tool:";
+
+        for (pugi::xml_attribute_iterator ait = it->attributes_begin(); ait != it->attributes_end(); ++ait)
+        {
+            std::cout << " " << ait->name() << "=" << ait->value();
+        }
+
+        std::cout << std::endl;
+    }
+    //]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/traverse_predicate.cpp b/tools/intergen/third_party/pugixml/docs/samples/traverse_predicate.cpp
new file mode 100644
index 0000000000..9d8ded07b7
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/traverse_predicate.cpp
@@ -0,0 +1,48 @@
+#include "pugixml.hpp"
+
+#include <string.h>
+#include <iostream>
+
+//[code_traverse_predicate_decl
+bool small_timeout(pugi::xml_node node)
+{
+    return node.attribute("Timeout").as_int() < 20;
+}
+
+struct allow_remote_predicate
+{
+    bool operator()(pugi::xml_attribute attr) const
+    {
+        return strcmp(attr.name(), "AllowRemote") == 0;
+    }
+
+    bool operator()(pugi::xml_node node) const
+    {
+        return node.attribute("AllowRemote").as_bool();
+    }
+};
+//]
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!doc.load_file("xgconsole.xml")) return -1;
+
+    pugi::xml_node tools = doc.child("Profile").child("Tools");
+
+    //[code_traverse_predicate_find
+    // Find child via predicate (looks for direct children only)
+    std::cout << tools.find_child(allow_remote_predicate()).attribute("Filename").value() << std::endl;
+
+    // Find node via predicate (looks for all descendants in depth-first order)
+    std::cout << doc.find_node(allow_remote_predicate()).attribute("Filename").value() << std::endl;
+
+    // Find attribute via predicate
+    std::cout << tools.last_child().find_attribute(allow_remote_predicate()).value() << std::endl;
+
+    // We can use simple functions instead of function objects
+    std::cout << tools.find_child(small_timeout).attribute("Filename").value() << std::endl;
+    //]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/traverse_rangefor.cpp b/tools/intergen/third_party/pugixml/docs/samples/traverse_rangefor.cpp
new file mode 100644
index 0000000000..a284b9ef89
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/traverse_rangefor.cpp
@@ -0,0 +1,32 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!doc.load_file("xgconsole.xml")) return -1;
+
+    pugi::xml_node tools = doc.child("Profile").child("Tools");
+
+    //[code_traverse_rangefor
+    for (pugi::xml_node tool: tools.children("Tool"))
+    {
+        std::cout << "Tool:";
+
+        for (pugi::xml_attribute attr: tool.attributes())
+        {
+            std::cout << " " << attr.name() << "=" << attr.value();
+        }
+
+        for (pugi::xml_node child: tool.children())
+        {
+            std::cout << ", child " << child.name();
+        }
+
+        std::cout << std::endl;
+    }
+    //]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/traverse_walker.cpp b/tools/intergen/third_party/pugixml/docs/samples/traverse_walker.cpp
new file mode 100644
index 0000000000..cb999027b3
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/traverse_walker.cpp
@@ -0,0 +1,35 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+const char* node_types[] =
+{
+    "null", "document", "element", "pcdata", "cdata", "comment", "pi", "declaration"
+};
+
+//[code_traverse_walker_impl
+struct simple_walker: pugi::xml_tree_walker
+{
+    virtual bool for_each(pugi::xml_node& node)
+    {
+        for (int i = 0; i < depth(); ++i) std::cout << "  "; // indentation
+
+        std::cout << node_types[node.type()] << ": name='" << node.name() << "', value='" << node.value() << "'\n";
+
+        return true; // continue traversal
+    }
+};
+//]
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!doc.load_file("tree.xml")) return -1;
+
+    //[code_traverse_walker_traverse
+    simple_walker walker;
+    doc.traverse(walker);
+    //]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/tree.xml b/tools/intergen/third_party/pugixml/docs/samples/tree.xml
new file mode 100644
index 0000000000..b33267afa3
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/tree.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0"?>
+<mesh name="mesh_root">
+	<!-- here is a mesh node -->
+	some text
+	<![CDATA[someothertext]]>
+	some more text
+	<node attr1="value1" attr2="value2" />
+	<node attr1="value2">
+		<innernode/>
+	</node>
+</mesh>
+<?include somedata?>
diff --git a/tools/intergen/third_party/pugixml/docs/samples/weekly-shift_jis.xml b/tools/intergen/third_party/pugixml/docs/samples/weekly-shift_jis.xml
new file mode 100644
index 0000000000..097e37421c
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/weekly-shift_jis.xml
@@ -0,0 +1,78 @@
+<?xml version="1.0" encoding="Shift_JIS"?>
+<!DOCTYPE �T�� SYSTEM "weekly-shift_jis.dtd">
+<!-- �T��T���v�� -->
+<�T��>
+  <�N���T>
+    <�N�x>1997</�N�x>
+    <���x>1</���x>
+    <�T>1</�T>
+  </�N���T>
+
+  <����>
+    <��>�R�c</��>
+    <��>���Y</��>
+  </����>
+
+  <�Ɩ��񍐃��X�g>
+    <�Ɩ���>
+      <�Ɩ���>XML�G�f�B�^�[�̍쐬</�Ɩ���>
+      <�Ɩ��R�[�h>X3355-23</�Ɩ��R�[�h>
+      <�H���Ǘ�>
+        <����H��>1600</����H��>
+        <���эH��>320</���эH��>
+        <��������H��>160</��������H��>
+        <�������эH��>24</�������эH��>
+      </�H���Ǘ�>
+      <�\�荀�ڃ��X�g>
+        <�\�荀��>
+          <P>XML�G�f�B�^�[�̊�{�d�l�̍쐬</P>
+        </�\�荀��>
+      </�\�荀�ڃ��X�g>
+      <���{�������X�g>
+        <���{����>
+          <P>XML�G�f�B�^�[�̊�{�d�l�̍쐬</P>
+        </���{����>
+        <���{����>
+          <P>�������А��i�̋@�\����</P>
+        </���{����>
+      </���{�������X�g>
+      <�㒷�ւ̗v���������X�g>
+        <�㒷�ւ̗v������>
+          <P>���ɂȂ�</P>
+        </�㒷�ւ̗v������>
+      </�㒷�ւ̗v���������X�g>
+      <���_�΍�>
+        <P>XML�Ƃ͉����킩��Ȃ��B</P>
+      </���_�΍�>
+    </�Ɩ���>
+
+    <�Ɩ���>
+      <�Ɩ���>�����G���W���̊J��</�Ɩ���>
+      <�Ɩ��R�[�h>S8821-76</�Ɩ��R�[�h>
+      <�H���Ǘ�>
+        <����H��>120</����H��>
+        <���эH��>6</���эH��>
+        <��������H��>32</��������H��>
+        <�������эH��>2</�������эH��>
+      </�H���Ǘ�>
+      <�\�荀�ڃ��X�g>
+        <�\�荀��>
+          <P><A href="http://www.goo.ne.jp">goo</A>�̋@�\�𒲂ׂĂ݂�</P>
+        </�\�荀��>
+      </�\�荀�ڃ��X�g>
+      <���{�������X�g>
+        <���{����>
+          <P>�X�ɁA�ǂ����������G���W�������邩��������</P>
+        </���{����>
+      </���{�������X�g>
+      <�㒷�ւ̗v���������X�g>
+        <�㒷�ւ̗v������>
+          <P>�J��������̂͂߂�ǂ��Ȃ̂ŁAYahoo!�𔃎����ĉ������B</P>
+        </�㒷�ւ̗v������>
+      </�㒷�ւ̗v���������X�g>
+      <���_�΍�>
+        <P>�����G���W���ŎԂ𑖂点�邱�Ƃ��ł��Ȃ��B�i�v�����j</P>
+      </���_�΍�>
+    </�Ɩ���>
+  </�Ɩ��񍐃��X�g>
+</�T��>
diff --git a/tools/intergen/third_party/pugixml/docs/samples/weekly-utf-16.xml b/tools/intergen/third_party/pugixml/docs/samples/weekly-utf-16.xml
new file mode 100644
index 0000000000..6c8622aa43
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/weekly-utf-16.xml
diff --git a/tools/intergen/third_party/pugixml/docs/samples/weekly-utf-8.xml b/tools/intergen/third_party/pugixml/docs/samples/weekly-utf-8.xml
new file mode 100644
index 0000000000..d55474e5e8
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/weekly-utf-8.xml
@@ -0,0 +1,78 @@
+<?xml version="1.0"?>
+<!DOCTYPE 週報 SYSTEM "weekly-utf-8.dtd">
+<!-- 週報サンプル -->
+<週報>
+  <年月週>
+    <年度>1997</年度>
+    <月度>1</月度>
+    <週>1</週>
+  </年月週>
+
+  <氏名>
+    <氏>山田</氏>
+    <名>太郎</名>
+  </氏名>
+
+  <業務報告リスト>
+    <業務報告>
+      <業務名>XMLエディターの作成</業務名>
+      <業務コード>X3355-23</業務コード>
+      <工数管理>
+        <見積もり工数>1600</見積もり工数>
+        <実績工数>320</実績工数>
+        <当月見積もり工数>160</当月見積もり工数>
+        <当月実績工数>24</当月実績工数>
+      </工数管理>
+      <予定項目リスト>
+        <予定項目>
+          <P>XMLエディターの基本仕様の作成</P>
+        </予定項目>
+      </予定項目リスト>
+      <実施事項リスト>
+        <実施事項>
+          <P>XMLエディターの基本仕様の作成</P>
+        </実施事項>
+        <実施事項>
+          <P>競合他社製品の機能調査</P>
+        </実施事項>
+      </実施事項リスト>
+      <上長への要請事項リスト>
+        <上長への要請事項>
+          <P>特になし</P>
+        </上長への要請事項>
+      </上長への要請事項リスト>
+      <問題点対策>
+        <P>XMLとは何かわからない。</P>
+      </問題点対策>
+    </業務報告>
+
+    <業務報告>
+      <業務名>検索エンジンの開発</業務名>
+      <業務コード>S8821-76</業務コード>
+      <工数管理>
+        <見積もり工数>120</見積もり工数>
+        <実績工数>6</実績工数>
+        <当月見積もり工数>32</当月見積もり工数>
+        <当月実績工数>2</当月実績工数>
+      </工数管理>
+      <予定項目リスト>
+        <予定項目>
+          <P><A href="http://www.goo.ne.jp">goo</A>の機能を調べてみる</P>
+        </予定項目>
+      </予定項目リスト>
+      <実施事項リスト>
+        <実施事項>
+          <P>更に、どういう検索エンジンがあるか調査する</P>
+        </実施事項>
+      </実施事項リスト>
+      <上長への要請事項リスト>
+        <上長への要請事項>
+          <P>開発をするのはめんどうなので、Yahoo!を買収して下さい。</P>
+        </上長への要請事項>
+      </上長への要請事項リスト>
+      <問題点対策>
+        <P>検索エンジンで車を走らせることができない。（要調査）</P>
+      </問題点対策>
+    </業務報告>
+  </業務報告リスト>
+</週報>
diff --git a/tools/intergen/third_party/pugixml/docs/samples/xgconsole.xml b/tools/intergen/third_party/pugixml/docs/samples/xgconsole.xml
new file mode 100644
index 0000000000..b2bf5a2de3
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/xgconsole.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Profile FormatVersion="1">
+    <Tools>
+        <Tool Filename="jam" AllowIntercept="true">
+        	<Description>Jamplus build system</Description>
+        </Tool>
+        <Tool Filename="mayabatch.exe" AllowRemote="true" OutputFileMasks="*.dae" DeriveCaptionFrom="lastparam" Timeout="40" />
+        <Tool Filename="meshbuilder_*.exe" AllowRemote="false" OutputFileMasks="*.mesh" DeriveCaptionFrom="lastparam" Timeout="10" />
+        <Tool Filename="texbuilder_*.exe" AllowRemote="true" OutputFileMasks="*.tex" DeriveCaptionFrom="lastparam" />
+        <Tool Filename="shaderbuilder_*.exe" AllowRemote="true" DeriveCaptionFrom="lastparam" />
+    </Tools>
+</Profile>
diff --git a/tools/intergen/third_party/pugixml/docs/samples/xpath_error.cpp b/tools/intergen/third_party/pugixml/docs/samples/xpath_error.cpp
new file mode 100644
index 0000000000..6cb6f4fe19
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/xpath_error.cpp
@@ -0,0 +1,43 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!doc.load_file("xgconsole.xml")) return -1;
+
+//[code_xpath_error
+    // Exception is thrown for incorrect query syntax
+    try
+    {
+        doc.select_nodes("//nodes[#true()]");
+    }
+    catch (const pugi::xpath_exception& e)
+    {
+        std::cout << "Select failed: " << e.what() << std::endl;
+    }
+
+    // Exception is thrown for incorrect query semantics
+    try
+    {
+        doc.select_nodes("(123)/next");
+    }
+    catch (const pugi::xpath_exception& e)
+    {
+        std::cout << "Select failed: " << e.what() << std::endl;
+    }
+
+    // Exception is thrown for query with incorrect return type
+    try
+    {
+        doc.select_nodes("123");
+    }
+    catch (const pugi::xpath_exception& e)
+    {
+        std::cout << "Select failed: " << e.what() << std::endl;
+    }
+//]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/xpath_query.cpp b/tools/intergen/third_party/pugixml/docs/samples/xpath_query.cpp
new file mode 100644
index 0000000000..c622a9c087
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/xpath_query.cpp
@@ -0,0 +1,36 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+#include <string>
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!doc.load_file("xgconsole.xml")) return -1;
+
+//[code_xpath_query
+    // Select nodes via compiled query
+    pugi::xpath_query query_remote_tools("/Profile/Tools/Tool[@AllowRemote='true']");
+
+    pugi::xpath_node_set tools = query_remote_tools.evaluate_node_set(doc);
+    std::cout << "Remote tool: ";
+    tools[2].node().print(std::cout);
+
+    // Evaluate numbers via compiled query
+    pugi::xpath_query query_timeouts("sum(//Tool/@Timeout)");
+    std::cout << query_timeouts.evaluate_number(doc) << std::endl;
+
+    // Evaluate strings via compiled query for different context nodes
+    pugi::xpath_query query_name_valid("string-length(substring-before(@Filename, '_')) > 0 and @OutputFileMasks");
+    pugi::xpath_query query_name("concat(substring-before(@Filename, '_'), ' produces ', @OutputFileMasks)");
+
+    for (pugi::xml_node tool = doc.first_element_by_path("Profile/Tools/Tool"); tool; tool = tool.next_sibling())
+    {
+        std::string s = query_name.evaluate_string(tool);
+
+        if (query_name_valid.evaluate_boolean(tool)) std::cout << s << std::endl;
+    }
+//]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/xpath_select.cpp b/tools/intergen/third_party/pugixml/docs/samples/xpath_select.cpp
new file mode 100644
index 0000000000..c098bd17ba
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/xpath_select.cpp
@@ -0,0 +1,27 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!doc.load_file("xgconsole.xml")) return -1;
+
+//[code_xpath_select
+    pugi::xpath_node_set tools = doc.select_nodes("/Profile/Tools/Tool[@AllowRemote='true' and @DeriveCaptionFrom='lastparam']");
+
+    std::cout << "Tools:";
+
+    for (pugi::xpath_node_set::const_iterator it = tools.begin(); it != tools.end(); ++it)
+    {
+        pugi::xpath_node node = *it;
+        std::cout << " " << node.node().attribute("Filename").value();
+    }
+
+    pugi::xpath_node build_tool = doc.select_single_node("//Tool[contains(Description, 'build system')]");
+
+    std::cout << "\nBuild tool: " << build_tool.node().attribute("Filename").value() << "\n";
+//]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/docs/samples/xpath_variables.cpp b/tools/intergen/third_party/pugixml/docs/samples/xpath_variables.cpp
new file mode 100644
index 0000000000..c6e9c510a2
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/docs/samples/xpath_variables.cpp
@@ -0,0 +1,38 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+#include <string>
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!doc.load_file("xgconsole.xml")) return -1;
+
+//[code_xpath_variables
+    // Select nodes via compiled query
+    pugi::xpath_variable_set vars;
+    vars.add("remote", pugi::xpath_type_boolean);
+
+    pugi::xpath_query query_remote_tools("/Profile/Tools/Tool[@AllowRemote = string($remote)]", &vars);
+
+    vars.set("remote", true);
+    pugi::xpath_node_set tools_remote = query_remote_tools.evaluate_node_set(doc);
+
+    vars.set("remote", false);
+    pugi::xpath_node_set tools_local = query_remote_tools.evaluate_node_set(doc);
+
+    std::cout << "Remote tool: ";
+    tools_remote[2].node().print(std::cout);
+
+    std::cout << "Local tool: ";
+    tools_local[0].node().print(std::cout);
+
+    // You can pass the context directly to select_nodes/select_single_node
+    pugi::xpath_node_set tools_local_imm = doc.select_nodes("/Profile/Tools/Tool[@AllowRemote = string($remote)]", &vars);
+
+    std::cout << "Local tool imm: ";
+    tools_local_imm[0].node().print(std::cout);
+//]
+}
+
+// vim:et
diff --git a/tools/intergen/third_party/pugixml/readme.txt b/tools/intergen/third_party/pugixml/readme.txt
new file mode 100644
index 0000000000..aa3353d469
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/readme.txt
@@ -0,0 +1,52 @@
+pugixml 1.2 - an XML processing library
+
+Copyright (C) 2006-2012, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+Report bugs and download new versions at http://pugixml.org/
+
+This is the distribution of pugixml, which is a C++ XML processing library,
+which consists of a DOM-like interface with rich traversal/modification
+capabilities, an extremely fast XML parser which constructs the DOM tree from
+an XML file/buffer, and an XPath 1.0 implementation for complex data-driven
+tree queries. Full Unicode support is also available, with Unicode interface
+variants and conversions between different Unicode encodings (which happen
+automatically during parsing/saving).
+
+The distribution contains the following folders:
+
+	contrib/ - various contributions to pugixml
+
+	docs/ - documentation
+		docs/samples - pugixml usage examples
+		docs/quickstart.html - quick start guide
+		docs/manual.html - complete manual
+
+	scripts/ - project files for IDE/build systems
+
+	src/ - header and source files
+
+	readme.txt - this file.
+
+This library is distributed under the MIT License:
+
+Copyright (c) 2006-2012 Arseny Kapoulkine
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
diff --git a/tools/intergen/third_party/pugixml/scripts/CMakeLists.txt b/tools/intergen/third_party/pugixml/scripts/CMakeLists.txt
new file mode 100644
index 0000000000..c175967036
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/scripts/CMakeLists.txt
@@ -0,0 +1,18 @@
+project(pugixml)
+
+cmake_minimum_required(VERSION 2.6)
+set(BUILD_SHARED_LIBS OFF CACHE BOOL "Build shared instead of static library")
+
+set(HEADERS ../src/pugixml.hpp ../src/pugiconfig.hpp)
+set(SOURCES ${HEADERS} ../src/pugixml.cpp)
+
+if(BUILD_SHARED_LIBS)
+    add_library(pugixml SHARED ${SOURCES})
+else()
+    add_library(pugixml STATIC ${SOURCES})
+endif()
+
+set_target_properties(pugixml PROPERTIES VERSION 1.2 SOVERSION 1.2)
+
+install(TARGETS pugixml LIBRARY DESTINATION lib ARCHIVE DESTINATION lib)
+install(FILES ${HEADERS} DESTINATION include)
diff --git a/tools/intergen/third_party/pugixml/scripts/premake4.lua b/tools/intergen/third_party/pugixml/scripts/premake4.lua
new file mode 100644
index 0000000000..f1b89a0a2f
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/scripts/premake4.lua
@@ -0,0 +1,92 @@
+-- Reset RNG seed to get consistent results across runs (i.e. XCode)
+math.randomseed(12345)
+
+local static = _ARGS[1] == 'static'
+local action = premake.action.current()
+
+if string.startswith(_ACTION, "vs") then
+	if action then
+		-- Disable solution generation
+		function action.onsolution(sln)
+			sln.vstudio_configs = premake.vstudio_buildconfigs(sln)
+		end
+
+		-- Rename output file
+		function action.onproject(prj)
+            local name = "%%_" .. _ACTION .. (static and "_static" or "")
+
+            if static then
+                for k, v in pairs(prj.project.__configs) do
+                    v.objectsdir = v.objectsdir .. "Static"
+                end
+            end
+
+            if _ACTION == "vs2010" then
+                premake.generate(prj, name .. ".vcxproj", premake.vs2010_vcxproj)
+            else
+                premake.generate(prj, name .. ".vcproj", premake.vs200x_vcproj)
+            end
+		end
+	end
+elseif _ACTION == "codeblocks" then
+	action.onsolution = nil
+
+	function action.onproject(prj)
+		premake.generate(prj, "%%_" .. _ACTION .. ".cbp", premake.codeblocks_cbp)
+	end
+elseif _ACTION == "codelite" then
+	action.onsolution = nil
+
+	function action.onproject(prj)
+		premake.generate(prj, "%%_" .. _ACTION .. ".project", premake.codelite_project)
+	end
+end
+
+solution "pugixml"
+	objdir(_ACTION)
+	targetdir(_ACTION)
+
+if string.startswith(_ACTION, "vs") then
+	if _ACTION ~= "vs2002" and _ACTION ~= "vs2003" then
+		platforms { "x32", "x64" }
+
+		configuration "x32" targetdir(_ACTION .. "/x32")
+		configuration "x64" targetdir(_ACTION .. "/x64")
+	end
+
+	configurations { "Debug", "Release" }
+
+    if static then
+        configuration "Debug" targetsuffix "sd"
+        configuration "Release" targetsuffix "s"
+    else
+        configuration "Debug" targetsuffix "d"
+    end
+else
+	if _ACTION == "xcode3" then
+		platforms "universal"
+	end
+
+	configurations { "Debug", "Release" }
+
+	configuration "Debug" targetsuffix "d"
+end
+
+project "pugixml"
+	kind "StaticLib"
+	language "C++"
+	files { "../src/pugixml.hpp", "../src/pugiconfig.hpp", "../src/pugixml.cpp" }
+	flags { "NoPCH", "NoMinimalRebuild", "NoEditAndContinue", "Symbols" }
+	uuid "89A1E353-E2DC-495C-B403-742BE206ACED"
+
+configuration "Debug"
+	defines { "_DEBUG" }
+
+configuration "Release"
+	defines { "NDEBUG" }
+	flags { "Optimize" }
+
+if static then
+    configuration "*"
+        flags { "StaticRuntime" }
+end
diff --git a/tools/intergen/third_party/pugixml/scripts/pugixml.xcodeproj/project.pbxproj b/tools/intergen/third_party/pugixml/scripts/pugixml.xcodeproj/project.pbxproj
new file mode 100644
index 0000000000..7d56bafd25
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/scripts/pugixml.xcodeproj/project.pbxproj
@@ -0,0 +1,212 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 45;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		0424128F67AB5C730232235E /* pugixml.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 47481C4F0E03673E0E780637 /* pugixml.cpp */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		0B66463C5F896E6449051D38 /* pugiconfig.hpp */ = {isa = PBXFileReference; lastKnownFileType = text; name = "pugiconfig.hpp"; path = "pugiconfig.hpp"; sourceTree = "<group>"; };
+		47481C4F0E03673E0E780637 /* pugixml.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = "pugixml.cpp"; path = "pugixml.cpp"; sourceTree = "<group>"; };
+		6C911F0460FC44CD3B1B5624 /* pugixml.hpp */ = {isa = PBXFileReference; lastKnownFileType = text; name = "pugixml.hpp"; path = "pugixml.hpp"; sourceTree = "<group>"; };
+		1DA04ADC64C3566D16C45B6D /* libpugixmld.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; name = "libpugixmld.a"; path = "libpugixmld.a"; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		2BA00212518037166623673F /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		19E0517F3CF26ED63AE23641 /* pugixml */ = {
+			isa = PBXGroup;
+			children = (
+				578963B4309E714F05E01D71 /* src */,
+				219F66186DDF392149043810 /* Products */,
+			);
+			name = "pugixml";
+			sourceTree = "<group>";
+		};
+		578963B4309E714F05E01D71 /* src */ = {
+			isa = PBXGroup;
+			children = (
+				0B66463C5F896E6449051D38 /* pugiconfig.hpp */,
+				47481C4F0E03673E0E780637 /* pugixml.cpp */,
+				6C911F0460FC44CD3B1B5624 /* pugixml.hpp */,
+			);
+			name = "src";
+			path = ../src;
+			sourceTree = "<group>";
+		};
+		219F66186DDF392149043810 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				1DA04ADC64C3566D16C45B6D /* libpugixmld.a */,
+			);
+			name = "Products";
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		6B55152571905B6C3A6F39D0 /* pugixml */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 73BF376C14AA1ECC0AC517ED /* Build configuration list for PBXNativeTarget "pugixml" */;
+			buildPhases = (
+				6CA66B9B6252229A36E8733C /* Resources */,
+				287808486FBF545206A47CC1 /* Sources */,
+				2BA00212518037166623673F /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = "pugixml";
+			productName = "pugixml";
+			productReference = 1DA04ADC64C3566D16C45B6D /* libpugixmld.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		08FB7793FE84155DC02AAC07 /* Project object */ = {
+			isa = PBXProject;
+			buildConfigurationList = 1DEB928908733DD80010E9CD /* Build configuration list for PBXProject "pugixml" */;
+			compatibilityVersion = "Xcode 3.1";
+			hasScannedForEncodings = 1;
+			mainGroup = 19E0517F3CF26ED63AE23641 /* pugixml */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				6B55152571905B6C3A6F39D0 /* libpugixmld.a */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		6CA66B9B6252229A36E8733C /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		287808486FBF545206A47CC1 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				0424128F67AB5C730232235E /* pugixml.cpp in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXVariantGroup section */
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		4FDB54E4253E36FC55CE27E8 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CONFIGURATION_BUILD_DIR = xcode3;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_MODEL_TUNING = G5;
+				INSTALL_PATH = /usr/local/lib;
+				PRODUCT_NAME = "pugixmld";
+			};
+			name = "Debug";
+		};
+		0A4C28F553990E0405306C15 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CONFIGURATION_BUILD_DIR = xcode3;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_MODEL_TUNING = G5;
+				INSTALL_PATH = /usr/local/lib;
+				PRODUCT_NAME = "pugixml";
+			};
+			name = "Release";
+		};
+		65DB0F6D27EA20852B6E3BB4 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ARCHS = "$(ARCHS_STANDARD_32_64_BIT)";
+				CONFIGURATION_BUILD_DIR = "$(SYMROOT)";
+				CONFIGURATION_TEMP_DIR = "$(OBJROOT)";
+				COPY_PHASE_STRIP = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"_DEBUG",
+				);
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				OBJROOT = "xcode3/Universal/Debug";
+				ONLY_ACTIVE_ARCH = NO;
+				PREBINDING = NO;
+				SYMROOT = "xcode3";
+			};
+			name = "Debug";
+		};
+		5314084032B57C1A11945858 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ARCHS = "$(ARCHS_STANDARD_32_64_BIT)";
+				CONFIGURATION_BUILD_DIR = "$(SYMROOT)";
+				CONFIGURATION_TEMP_DIR = "$(OBJROOT)";
+				COPY_PHASE_STRIP = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_OPTIMIZATION_LEVEL = s;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"NDEBUG",
+				);
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				OBJROOT = "xcode3/Universal/Release";
+				ONLY_ACTIVE_ARCH = NO;
+				PREBINDING = NO;
+				SYMROOT = "xcode3";
+			};
+			name = "Release";
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		73BF376C14AA1ECC0AC517ED /* Build configuration list for PBXNativeTarget "libpugixmld.a" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4FDB54E4253E36FC55CE27E8 /* Debug */,
+				0A4C28F553990E0405306C15 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = "Debug";
+		};
+		1DEB928908733DD80010E9CD /* Build configuration list for PBXProject "pugixml" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				65DB0F6D27EA20852B6E3BB4 /* Debug */,
+				5314084032B57C1A11945858 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = "Debug";
+		};
+/* End XCConfigurationList section */
+
+	};
+	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
+}
diff --git a/tools/intergen/third_party/pugixml/scripts/pugixml_airplay.mkf b/tools/intergen/third_party/pugixml/scripts/pugixml_airplay.mkf
new file mode 100644
index 0000000000..477f54a9da
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/scripts/pugixml_airplay.mkf
@@ -0,0 +1,13 @@
+includepaths
+{
+"../src"
+}
+
+files
+{
+("../src")
+pugiconfig.hpp
+pugixml.cpp
+pugixml.hpp
+}
+
diff --git a/tools/intergen/third_party/pugixml/scripts/pugixml_codeblocks.cbp b/tools/intergen/third_party/pugixml/scripts/pugixml_codeblocks.cbp
new file mode 100644
index 0000000000..e18ccfca53
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/scripts/pugixml_codeblocks.cbp
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="pugixml" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="codeblocks/libpugixmld.a" prefix_auto="0" extension_auto="0" />
+				<Option object_output="codeblocks/Debug" />
+				<Option type="2" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-g" />
+					<Add option="-D_DEBUG" />
+				</Compiler>
+				<Linker>
+				</Linker>
+			</Target>
+			<Target title="Release">
+				<Option output="codeblocks/libpugixml.a" prefix_auto="0" extension_auto="0" />
+				<Option object_output="codeblocks/Release" />
+				<Option type="2" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-g" />
+					<Add option="-O2" />
+					<Add option="-DNDEBUG" />
+				</Compiler>
+				<Linker>
+				</Linker>
+			</Target>
+		</Build>
+		<Unit filename="../src/pugixml.hpp">
+		</Unit>
+		<Unit filename="../src/pugiconfig.hpp">
+		</Unit>
+		<Unit filename="../src/pugixml.cpp">
+		</Unit>
+		<Extensions />
+	</Project>
+</CodeBlocks_project_file>
+
diff --git a/tools/intergen/third_party/pugixml/scripts/pugixml_codelite.project b/tools/intergen/third_party/pugixml/scripts/pugixml_codelite.project
new file mode 100644
index 0000000000..637a81da59
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/scripts/pugixml_codelite.project
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<CodeLite_Project Name="pugixml">
+  <VirtualDirectory Name="src">
+    <File Name="../src/pugixml.hpp"/>
+    <File Name="../src/pugiconfig.hpp"/>
+    <File Name="../src/pugixml.cpp"/>
+  </VirtualDirectory>
+  <Settings Type="Static Library">
+    <Configuration Name="Debug" CompilerType="gnu g++" DebuggerType="GNU gdb debugger" Type="Static Library">
+      <General OutputFile="codelite/libpugixmld.a" IntermediateDirectory="codelite/Debug" Command="./libpugixmld.a" CommandArguments="" WorkingDirectory="codelite" PauseExecWhenProcTerminates="yes"/>
+      <Compiler Required="yes" Options="-g">
+        <Preprocessor Value="_DEBUG"/>
+      </Compiler>
+      <Linker Required="yes" Options="">
+      </Linker>
+      <ResourceCompiler Required="no" Options=""/>
+      <CustomBuild Enabled="no">
+        <CleanCommand></CleanCommand>
+        <BuildCommand></BuildCommand>
+        <SingleFileCommand></SingleFileCommand>
+        <MakefileGenerationCommand></MakefileGenerationCommand>
+        <ThirdPartyToolName>None</ThirdPartyToolName>
+        <WorkingDirectory></WorkingDirectory>
+      </CustomBuild>
+      <AdditionalRules>
+        <CustomPostBuild></CustomPostBuild>
+        <CustomPreBuild></CustomPreBuild>
+      </AdditionalRules>
+    </Configuration>
+    <Configuration Name="Release" CompilerType="gnu g++" DebuggerType="GNU gdb debugger" Type="Static Library">
+      <General OutputFile="codelite/libpugixml.a" IntermediateDirectory="codelite/Release" Command="./libpugixml.a" CommandArguments="" WorkingDirectory="codelite" PauseExecWhenProcTerminates="yes"/>
+      <Compiler Required="yes" Options="-g;-O2">
+        <Preprocessor Value="NDEBUG"/>
+      </Compiler>
+      <Linker Required="yes" Options="">
+      </Linker>
+      <ResourceCompiler Required="no" Options=""/>
+      <CustomBuild Enabled="no">
+        <CleanCommand></CleanCommand>
+        <BuildCommand></BuildCommand>
+        <SingleFileCommand></SingleFileCommand>
+        <MakefileGenerationCommand></MakefileGenerationCommand>
+        <ThirdPartyToolName>None</ThirdPartyToolName>
+        <WorkingDirectory></WorkingDirectory>
+      </CustomBuild>
+      <AdditionalRules>
+        <CustomPostBuild></CustomPostBuild>
+        <CustomPreBuild></CustomPreBuild>
+      </AdditionalRules>
+    </Configuration>
+  </Settings>
+  <Dependencies name="Debug">
+  </Dependencies>
+  <Dependencies name="Release">
+  </Dependencies>
+</CodeLite_Project>
diff --git a/tools/intergen/third_party/pugixml/scripts/pugixml_vs2005.vcproj b/tools/intergen/third_party/pugixml/scripts/pugixml_vs2005.vcproj
new file mode 100644
index 0000000000..b60f5af8f1
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/scripts/pugixml_vs2005.vcproj
@@ -0,0 +1,343 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="pugixml"
+	ProjectGUID="{89A1E353-E2DC-495C-B403-742BE206ACED}"
+	RootNamespace="pugixml"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="vs2005\x32"
+			IntermediateDirectory="vs2005\x32\Debug"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="_DEBUG"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				ProgramDataBaseFileName="$(OutDir)\pugixmld.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixmld.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="vs2005\x64"
+			IntermediateDirectory="vs2005\x64\Debug"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="_DEBUG"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				ProgramDataBaseFileName="$(OutDir)\pugixmld.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixmld.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="vs2005\x32"
+			IntermediateDirectory="vs2005\x32\Release"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				PreprocessorDefinitions="NDEBUG"
+				StringPooling="true"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				ProgramDataBaseFileName="$(OutDir)\pugixml.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixml.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|x64"
+			OutputDirectory="vs2005\x64"
+			IntermediateDirectory="vs2005\x64\Release"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				PreprocessorDefinitions="NDEBUG"
+				StringPooling="true"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				ProgramDataBaseFileName="$(OutDir)\pugixml.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixml.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="src"
+			Filter=""
+			>
+			<File
+				RelativePath="..\src\pugixml.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\src\pugiconfig.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\src\pugixml.cpp"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/tools/intergen/third_party/pugixml/scripts/pugixml_vs2005_static.vcproj b/tools/intergen/third_party/pugixml/scripts/pugixml_vs2005_static.vcproj
new file mode 100644
index 0000000000..065e0eb4ff
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/scripts/pugixml_vs2005_static.vcproj
@@ -0,0 +1,343 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="pugixml"
+	ProjectGUID="{89A1E353-E2DC-495C-B403-742BE206ACED}"
+	RootNamespace="pugixml"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="vs2005\x32"
+			IntermediateDirectory="vs2005\x32\DebugStatic"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="_DEBUG"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				ProgramDataBaseFileName="$(OutDir)\pugixmlsd.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixmlsd.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="vs2005\x64"
+			IntermediateDirectory="vs2005\x64\DebugStatic"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="_DEBUG"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				ProgramDataBaseFileName="$(OutDir)\pugixmlsd.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixmlsd.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="vs2005\x32"
+			IntermediateDirectory="vs2005\x32\ReleaseStatic"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				PreprocessorDefinitions="NDEBUG"
+				StringPooling="true"
+				RuntimeLibrary="0"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				ProgramDataBaseFileName="$(OutDir)\pugixmls.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixmls.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|x64"
+			OutputDirectory="vs2005\x64"
+			IntermediateDirectory="vs2005\x64\ReleaseStatic"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				PreprocessorDefinitions="NDEBUG"
+				StringPooling="true"
+				RuntimeLibrary="0"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="true"
+				ProgramDataBaseFileName="$(OutDir)\pugixmls.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixmls.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="src"
+			Filter=""
+			>
+			<File
+				RelativePath="..\src\pugixml.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\src\pugiconfig.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\src\pugixml.cpp"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/tools/intergen/third_party/pugixml/scripts/pugixml_vs2008.vcproj b/tools/intergen/third_party/pugixml/scripts/pugixml_vs2008.vcproj
new file mode 100644
index 0000000000..72186182de
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/scripts/pugixml_vs2008.vcproj
@@ -0,0 +1,339 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="pugixml"
+	ProjectGUID="{89A1E353-E2DC-495C-B403-742BE206ACED}"
+	RootNamespace="pugixml"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="vs2008\x32"
+			IntermediateDirectory="vs2008\x32\Debug"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="_DEBUG"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				ProgramDataBaseFileName="$(OutDir)\pugixmld.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixmld.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="vs2008\x64"
+			IntermediateDirectory="vs2008\x64\Debug"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="_DEBUG"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="3"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				ProgramDataBaseFileName="$(OutDir)\pugixmld.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixmld.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="vs2008\x32"
+			IntermediateDirectory="vs2008\x32\Release"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				PreprocessorDefinitions="NDEBUG"
+				StringPooling="true"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				ProgramDataBaseFileName="$(OutDir)\pugixml.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixml.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|x64"
+			OutputDirectory="vs2008\x64"
+			IntermediateDirectory="vs2008\x64\Release"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				PreprocessorDefinitions="NDEBUG"
+				StringPooling="true"
+				RuntimeLibrary="2"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				ProgramDataBaseFileName="$(OutDir)\pugixml.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixml.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="src"
+			Filter=""
+			>
+			<File
+				RelativePath="..\src\pugixml.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\src\pugiconfig.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\src\pugixml.cpp"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/tools/intergen/third_party/pugixml/scripts/pugixml_vs2008_static.vcproj b/tools/intergen/third_party/pugixml/scripts/pugixml_vs2008_static.vcproj
new file mode 100644
index 0000000000..a00e9d1f68
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/scripts/pugixml_vs2008_static.vcproj
@@ -0,0 +1,339 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="pugixml"
+	ProjectGUID="{89A1E353-E2DC-495C-B403-742BE206ACED}"
+	RootNamespace="pugixml"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="vs2008\x32"
+			IntermediateDirectory="vs2008\x32\DebugStatic"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="_DEBUG"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				ProgramDataBaseFileName="$(OutDir)\pugixmlsd.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixmlsd.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="vs2008\x64"
+			IntermediateDirectory="vs2008\x64\DebugStatic"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				PreprocessorDefinitions="_DEBUG"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				ProgramDataBaseFileName="$(OutDir)\pugixmlsd.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="_DEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixmlsd.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="vs2008\x32"
+			IntermediateDirectory="vs2008\x32\ReleaseStatic"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				PreprocessorDefinitions="NDEBUG"
+				StringPooling="true"
+				RuntimeLibrary="0"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				ProgramDataBaseFileName="$(OutDir)\pugixmls.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixmls.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|x64"
+			OutputDirectory="vs2008\x64"
+			IntermediateDirectory="vs2008\x64\ReleaseStatic"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="3"
+				PreprocessorDefinitions="NDEBUG"
+				StringPooling="true"
+				RuntimeLibrary="0"
+				EnableFunctionLevelLinking="true"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				ProgramDataBaseFileName="$(OutDir)\pugixmls.pdb"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+				PreprocessorDefinitions="NDEBUG"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)\pugixmls.lib"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="src"
+			Filter=""
+			>
+			<File
+				RelativePath="..\src\pugixml.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\src\pugiconfig.hpp"
+				>
+			</File>
+			<File
+				RelativePath="..\src\pugixml.cpp"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/tools/intergen/third_party/pugixml/scripts/pugixml_vs2010.vcxproj b/tools/intergen/third_party/pugixml/scripts/pugixml_vs2010.vcxproj
new file mode 100644
index 0000000000..c29b4c5765
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/scripts/pugixml_vs2010.vcxproj
@@ -0,0 +1,191 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+	<ItemGroup Label="ProjectConfigurations">
+		<ProjectConfiguration Include="Debug|Win32">
+			<Configuration>Debug</Configuration>
+			<Platform>Win32</Platform>
+		</ProjectConfiguration>
+		<ProjectConfiguration Include="Debug|x64">
+			<Configuration>Debug</Configuration>
+			<Platform>x64</Platform>
+		</ProjectConfiguration>
+		<ProjectConfiguration Include="Release|Win32">
+			<Configuration>Release</Configuration>
+			<Platform>Win32</Platform>
+		</ProjectConfiguration>
+		<ProjectConfiguration Include="Release|x64">
+			<Configuration>Release</Configuration>
+			<Platform>x64</Platform>
+		</ProjectConfiguration>
+	</ItemGroup>
+	<PropertyGroup Label="Globals">
+		<ProjectGuid>{89A1E353-E2DC-495C-B403-742BE206ACED}</ProjectGuid>
+		<RootNamespace>pugixml</RootNamespace>
+		<Keyword>Win32Proj</Keyword>
+	</PropertyGroup>
+	<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+		<ConfigurationType>StaticLibrary</ConfigurationType>
+		<CharacterSet>MultiByte</CharacterSet>
+		<UseDebugLibraries>true</UseDebugLibraries>
+	</PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+		<ConfigurationType>StaticLibrary</ConfigurationType>
+		<CharacterSet>MultiByte</CharacterSet>
+		<UseDebugLibraries>true</UseDebugLibraries>
+	</PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+		<ConfigurationType>StaticLibrary</ConfigurationType>
+		<CharacterSet>MultiByte</CharacterSet>
+		<WholeProgramOptimization>true</WholeProgramOptimization>
+		<UseDebugLibraries>false</UseDebugLibraries>
+	</PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+		<ConfigurationType>StaticLibrary</ConfigurationType>
+		<CharacterSet>MultiByte</CharacterSet>
+		<WholeProgramOptimization>true</WholeProgramOptimization>
+		<UseDebugLibraries>false</UseDebugLibraries>
+	</PropertyGroup>
+	<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+	<ImportGroup Label="ExtensionSettings">
+	</ImportGroup>
+	<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+		<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+	</ImportGroup>
+	<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+		<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+	</ImportGroup>
+	<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+		<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+	</ImportGroup>
+	<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+		<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+	</ImportGroup>
+	<PropertyGroup Label="UserMacros" />
+	<PropertyGroup>
+		<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+		<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">vs2010\x32\</OutDir>
+		<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">vs2010\x32\Debug\</IntDir>
+		<TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">pugixmld</TargetName>
+		<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">vs2010\x64\</OutDir>
+		<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">vs2010\x64\Debug\</IntDir>
+		<TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">pugixmld</TargetName>
+		<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">vs2010\x32\</OutDir>
+		<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">vs2010\x32\Release\</IntDir>
+		<TargetName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">pugixml</TargetName>
+		<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">vs2010\x64\</OutDir>
+		<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">vs2010\x64\Release\</IntDir>
+		<TargetName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">pugixml</TargetName>
+	</PropertyGroup>
+	<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+		<ClCompile>
+			<Optimization>Disabled</Optimization>
+			<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+			<MinimalRebuild>false</MinimalRebuild>
+			<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+			<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+			<FunctionLevelLinking>true</FunctionLevelLinking>
+			<PrecompiledHeader></PrecompiledHeader>
+			<WarningLevel>Level3</WarningLevel>
+			<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+		</ClCompile>
+		<ResourceCompile>
+			<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+		</ResourceCompile>
+	<Lib>
+		<OutputFile>$(OutDir)pugixmld.lib</OutputFile>
+	</Lib>
+		<Link>
+			<SubSystem>Windows</SubSystem>
+			<GenerateDebugInformation>true</GenerateDebugInformation>
+			<ProgramDataBaseFileName>$(OutDir)pugixmld.pdb</ProgramDataBaseFileName>
+		</Link>
+	</ItemDefinitionGroup>
+	<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+		<ClCompile>
+			<Optimization>Disabled</Optimization>
+			<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+			<MinimalRebuild>false</MinimalRebuild>
+			<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+			<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+			<FunctionLevelLinking>true</FunctionLevelLinking>
+			<PrecompiledHeader></PrecompiledHeader>
+			<WarningLevel>Level3</WarningLevel>
+			<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+		</ClCompile>
+		<ResourceCompile>
+			<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+		</ResourceCompile>
+	<Lib>
+		<OutputFile>$(OutDir)pugixmld.lib</OutputFile>
+	</Lib>
+		<Link>
+			<SubSystem>Windows</SubSystem>
+			<GenerateDebugInformation>true</GenerateDebugInformation>
+			<ProgramDataBaseFileName>$(OutDir)pugixmld.pdb</ProgramDataBaseFileName>
+		</Link>
+	</ItemDefinitionGroup>
+	<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+		<ClCompile>
+			<Optimization>Full</Optimization>
+			<PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+			<MinimalRebuild>false</MinimalRebuild>
+			<StringPooling>true</StringPooling>
+			<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+			<FunctionLevelLinking>true</FunctionLevelLinking>
+			<PrecompiledHeader></PrecompiledHeader>
+			<WarningLevel>Level3</WarningLevel>
+			<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+		</ClCompile>
+		<ResourceCompile>
+			<PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+		</ResourceCompile>
+	<Lib>
+		<OutputFile>$(OutDir)pugixml.lib</OutputFile>
+	</Lib>
+		<Link>
+			<SubSystem>Windows</SubSystem>
+			<GenerateDebugInformation>true</GenerateDebugInformation>
+			<OptimizeReferences>true</OptimizeReferences>
+			<EnableCOMDATFolding>true</EnableCOMDATFolding>
+			<ProgramDataBaseFileName>$(OutDir)pugixml.pdb</ProgramDataBaseFileName>
+		</Link>
+	</ItemDefinitionGroup>
+	<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+		<ClCompile>
+			<Optimization>Full</Optimization>
+			<PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+			<MinimalRebuild>false</MinimalRebuild>
+			<StringPooling>true</StringPooling>
+			<RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+			<FunctionLevelLinking>true</FunctionLevelLinking>
+			<PrecompiledHeader></PrecompiledHeader>
+			<WarningLevel>Level3</WarningLevel>
+			<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+		</ClCompile>
+		<ResourceCompile>
+			<PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+		</ResourceCompile>
+	<Lib>
+		<OutputFile>$(OutDir)pugixml.lib</OutputFile>
+	</Lib>
+		<Link>
+			<SubSystem>Windows</SubSystem>
+			<GenerateDebugInformation>true</GenerateDebugInformation>
+			<OptimizeReferences>true</OptimizeReferences>
+			<EnableCOMDATFolding>true</EnableCOMDATFolding>
+			<ProgramDataBaseFileName>$(OutDir)pugixml.pdb</ProgramDataBaseFileName>
+		</Link>
+	</ItemDefinitionGroup>
+	<ItemGroup>
+		<ClInclude Include="..\src\pugixml.hpp" />
+		<ClInclude Include="..\src\pugiconfig.hpp" />
+	</ItemGroup>
+	<ItemGroup>
+		<ClCompile Include="..\src\pugixml.cpp">
+		</ClCompile>
+	</ItemGroup>
+	<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+	<ImportGroup Label="ExtensionTargets">
+	</ImportGroup>
+</Project>
diff --git a/tools/intergen/third_party/pugixml/scripts/pugixml_vs2010_static.vcxproj b/tools/intergen/third_party/pugixml/scripts/pugixml_vs2010_static.vcxproj
new file mode 100644
index 0000000000..c1e133ce9f
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/scripts/pugixml_vs2010_static.vcxproj
@@ -0,0 +1,191 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+	<ItemGroup Label="ProjectConfigurations">
+		<ProjectConfiguration Include="Debug|Win32">
+			<Configuration>Debug</Configuration>
+			<Platform>Win32</Platform>
+		</ProjectConfiguration>
+		<ProjectConfiguration Include="Debug|x64">
+			<Configuration>Debug</Configuration>
+			<Platform>x64</Platform>
+		</ProjectConfiguration>
+		<ProjectConfiguration Include="Release|Win32">
+			<Configuration>Release</Configuration>
+			<Platform>Win32</Platform>
+		</ProjectConfiguration>
+		<ProjectConfiguration Include="Release|x64">
+			<Configuration>Release</Configuration>
+			<Platform>x64</Platform>
+		</ProjectConfiguration>
+	</ItemGroup>
+	<PropertyGroup Label="Globals">
+		<ProjectGuid>{89A1E353-E2DC-495C-B403-742BE206ACED}</ProjectGuid>
+		<RootNamespace>pugixml</RootNamespace>
+		<Keyword>Win32Proj</Keyword>
+	</PropertyGroup>
+	<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+		<ConfigurationType>StaticLibrary</ConfigurationType>
+		<CharacterSet>MultiByte</CharacterSet>
+		<UseDebugLibraries>true</UseDebugLibraries>
+	</PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+		<ConfigurationType>StaticLibrary</ConfigurationType>
+		<CharacterSet>MultiByte</CharacterSet>
+		<UseDebugLibraries>true</UseDebugLibraries>
+	</PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+		<ConfigurationType>StaticLibrary</ConfigurationType>
+		<CharacterSet>MultiByte</CharacterSet>
+		<WholeProgramOptimization>true</WholeProgramOptimization>
+		<UseDebugLibraries>false</UseDebugLibraries>
+	</PropertyGroup>
+	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+		<ConfigurationType>StaticLibrary</ConfigurationType>
+		<CharacterSet>MultiByte</CharacterSet>
+		<WholeProgramOptimization>true</WholeProgramOptimization>
+		<UseDebugLibraries>false</UseDebugLibraries>
+	</PropertyGroup>
+	<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+	<ImportGroup Label="ExtensionSettings">
+	</ImportGroup>
+	<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+		<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+	</ImportGroup>
+	<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+		<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+	</ImportGroup>
+	<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+		<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+	</ImportGroup>
+	<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+		<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+	</ImportGroup>
+	<PropertyGroup Label="UserMacros" />
+	<PropertyGroup>
+		<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
+		<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">vs2010\x32\</OutDir>
+		<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">vs2010\x32\DebugStatic\</IntDir>
+		<TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">pugixmlsd</TargetName>
+		<OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">vs2010\x64\</OutDir>
+		<IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">vs2010\x64\DebugStatic\</IntDir>
+		<TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">pugixmlsd</TargetName>
+		<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">vs2010\x32\</OutDir>
+		<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">vs2010\x32\ReleaseStatic\</IntDir>
+		<TargetName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">pugixmls</TargetName>
+		<OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">vs2010\x64\</OutDir>
+		<IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">vs2010\x64\ReleaseStatic\</IntDir>
+		<TargetName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">pugixmls</TargetName>
+	</PropertyGroup>
+	<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+		<ClCompile>
+			<Optimization>Disabled</Optimization>
+			<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+			<MinimalRebuild>false</MinimalRebuild>
+			<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+			<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+			<FunctionLevelLinking>true</FunctionLevelLinking>
+			<PrecompiledHeader></PrecompiledHeader>
+			<WarningLevel>Level3</WarningLevel>
+			<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+		</ClCompile>
+		<ResourceCompile>
+			<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+		</ResourceCompile>
+	<Lib>
+		<OutputFile>$(OutDir)pugixmlsd.lib</OutputFile>
+	</Lib>
+		<Link>
+			<SubSystem>Windows</SubSystem>
+			<GenerateDebugInformation>true</GenerateDebugInformation>
+			<ProgramDataBaseFileName>$(OutDir)pugixmlsd.pdb</ProgramDataBaseFileName>
+		</Link>
+	</ItemDefinitionGroup>
+	<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+		<ClCompile>
+			<Optimization>Disabled</Optimization>
+			<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+			<MinimalRebuild>false</MinimalRebuild>
+			<BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+			<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+			<FunctionLevelLinking>true</FunctionLevelLinking>
+			<PrecompiledHeader></PrecompiledHeader>
+			<WarningLevel>Level3</WarningLevel>
+			<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+		</ClCompile>
+		<ResourceCompile>
+			<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+		</ResourceCompile>
+	<Lib>
+		<OutputFile>$(OutDir)pugixmlsd.lib</OutputFile>
+	</Lib>
+		<Link>
+			<SubSystem>Windows</SubSystem>
+			<GenerateDebugInformation>true</GenerateDebugInformation>
+			<ProgramDataBaseFileName>$(OutDir)pugixmlsd.pdb</ProgramDataBaseFileName>
+		</Link>
+	</ItemDefinitionGroup>
+	<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+		<ClCompile>
+			<Optimization>Full</Optimization>
+			<PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+			<MinimalRebuild>false</MinimalRebuild>
+			<StringPooling>true</StringPooling>
+			<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+			<FunctionLevelLinking>true</FunctionLevelLinking>
+			<PrecompiledHeader></PrecompiledHeader>
+			<WarningLevel>Level3</WarningLevel>
+			<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+		</ClCompile>
+		<ResourceCompile>
+			<PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+		</ResourceCompile>
+	<Lib>
+		<OutputFile>$(OutDir)pugixmls.lib</OutputFile>
+	</Lib>
+		<Link>
+			<SubSystem>Windows</SubSystem>
+			<GenerateDebugInformation>true</GenerateDebugInformation>
+			<OptimizeReferences>true</OptimizeReferences>
+			<EnableCOMDATFolding>true</EnableCOMDATFolding>
+			<ProgramDataBaseFileName>$(OutDir)pugixmls.pdb</ProgramDataBaseFileName>
+		</Link>
+	</ItemDefinitionGroup>
+	<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+		<ClCompile>
+			<Optimization>Full</Optimization>
+			<PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+			<MinimalRebuild>false</MinimalRebuild>
+			<StringPooling>true</StringPooling>
+			<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+			<FunctionLevelLinking>true</FunctionLevelLinking>
+			<PrecompiledHeader></PrecompiledHeader>
+			<WarningLevel>Level3</WarningLevel>
+			<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+		</ClCompile>
+		<ResourceCompile>
+			<PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+		</ResourceCompile>
+	<Lib>
+		<OutputFile>$(OutDir)pugixmls.lib</OutputFile>
+	</Lib>
+		<Link>
+			<SubSystem>Windows</SubSystem>
+			<GenerateDebugInformation>true</GenerateDebugInformation>
+			<OptimizeReferences>true</OptimizeReferences>
+			<EnableCOMDATFolding>true</EnableCOMDATFolding>
+			<ProgramDataBaseFileName>$(OutDir)pugixmls.pdb</ProgramDataBaseFileName>
+		</Link>
+	</ItemDefinitionGroup>
+	<ItemGroup>
+		<ClInclude Include="..\src\pugixml.hpp" />
+		<ClInclude Include="..\src\pugiconfig.hpp" />
+	</ItemGroup>
+	<ItemGroup>
+		<ClCompile Include="..\src\pugixml.cpp">
+		</ClCompile>
+	</ItemGroup>
+	<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+	<ImportGroup Label="ExtensionTargets">
+	</ImportGroup>
+</Project>
diff --git a/tools/intergen/third_party/pugixml/src/pugiconfig.hpp b/tools/intergen/third_party/pugixml/src/pugiconfig.hpp
new file mode 100644
index 0000000000..c2196715cd
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/src/pugiconfig.hpp
@@ -0,0 +1,69 @@
+/**
+ * pugixml parser - version 1.2
+ * --------------------------------------------------------
+ * Copyright (C) 2006-2012, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+ * Report bugs and download new versions at http://pugixml.org/
+ *
+ * This library is distributed under the MIT License. See notice at the end
+ * of this file.
+ *
+ * This work is based on the pugxml parser, which is:
+ * Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
+ */
+
+#ifndef HEADER_PUGICONFIG_HPP
+#define HEADER_PUGICONFIG_HPP
+
+// Uncomment this to enable wchar_t mode
+// #define PUGIXML_WCHAR_MODE
+
+// Uncomment this to disable XPath
+// #define PUGIXML_NO_XPATH
+
+// Uncomment this to disable STL
+// #define PUGIXML_NO_STL
+
+// Uncomment this to disable exceptions
+// #define PUGIXML_NO_EXCEPTIONS
+
+// Set this to control attributes for public classes/functions, i.e.:
+// #define PUGIXML_API __declspec(dllexport) // to export all public symbols from DLL
+// #define PUGIXML_CLASS __declspec(dllimport) // to import all classes from DLL
+// #define PUGIXML_FUNCTION __fastcall // to set calling conventions to all public functions to fastcall
+// In absence of PUGIXML_CLASS/PUGIXML_FUNCTION definitions PUGIXML_API is used instead
+
+// Uncomment this to switch to header-only version
+// #define PUGIXML_HEADER_ONLY
+// #include "pugixml.cpp"
+
+// Tune these constants to adjust memory-related behavior
+// #define PUGIXML_MEMORY_PAGE_SIZE 32768
+// #define PUGIXML_MEMORY_OUTPUT_STACK 10240
+// #define PUGIXML_MEMORY_XPATH_PAGE_SIZE 4096
+
+#endif
+
+/**
+ * Copyright (c) 2006-2012 Arseny Kapoulkine
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
diff --git a/tools/intergen/third_party/pugixml/src/pugixml.cpp b/tools/intergen/third_party/pugixml/src/pugixml.cpp
new file mode 100644
index 0000000000..4035ab1cfd
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/src/pugixml.cpp
@@ -0,0 +1,10250 @@
+/**
+ * pugixml parser - version 1.2
+ * --------------------------------------------------------
+ * Copyright (C) 2006-2012, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+ * Report bugs and download new versions at http://pugixml.org/
+ *
+ * This library is distributed under the MIT License. See notice at the end
+ * of this file.
+ *
+ * This work is based on the pugxml parser, which is:
+ * Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
+ */
+
+#ifndef SOURCE_PUGIXML_CPP
+#define SOURCE_PUGIXML_CPP
+
+#include "pugixml.hpp"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <wchar.h>
+
+#ifndef PUGIXML_NO_XPATH
+#	include <math.h>
+#	include <float.h>
+#	ifdef PUGIXML_NO_EXCEPTIONS
+#		include <setjmp.h>
+#	endif
+#endif
+
+#ifndef PUGIXML_NO_STL
+#	include <istream>
+#	include <ostream>
+#	include <string>
+#endif
+
+// For placement new
+#include <new>
+
+#ifdef _MSC_VER
+#	pragma warning(push)
+#	pragma warning(disable: 4127) // conditional expression is constant
+#	pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#	pragma warning(disable: 4611) // interaction between '_setjmp' and C++ object destruction is non-portable
+#	pragma warning(disable: 4702) // unreachable code
+#	pragma warning(disable: 4996) // this function or variable may be unsafe
+#	pragma warning(disable: 4793) // function compiled as native: presence of '_setjmp' makes a function unmanaged
+#endif
+
+#ifdef __INTEL_COMPILER
+#	pragma warning(disable: 177) // function was declared but never referenced 
+#	pragma warning(disable: 279) // controlling expression is constant
+#	pragma warning(disable: 1478 1786) // function was declared "deprecated"
+#	pragma warning(disable: 1684) // conversion from pointer to same-sized integral type
+#endif
+
+#if defined(__BORLANDC__) && defined(PUGIXML_HEADER_ONLY)
+#	pragma warn -8080 // symbol is declared but never used; disabling this inside push/pop bracket does not make the warning go away
+#endif
+
+#ifdef __BORLANDC__
+#	pragma option push
+#	pragma warn -8008 // condition is always false
+#	pragma warn -8066 // unreachable code
+#endif
+
+#ifdef __SNC__
+// Using diag_push/diag_pop does not disable the warnings inside templates due to a compiler bug
+#	pragma diag_suppress=178 // function was declared but never referenced
+#	pragma diag_suppress=237 // controlling expression is constant
+#endif
+
+// Inlining controls
+#if defined(_MSC_VER) && _MSC_VER >= 1300
+#	define PUGI__NO_INLINE __declspec(noinline)
+#elif defined(__GNUC__)
+#	define PUGI__NO_INLINE __attribute__((noinline))
+#else
+#	define PUGI__NO_INLINE 
+#endif
+
+// Simple static assertion
+#define PUGI__STATIC_ASSERT(cond) { static const char condition_failed[(cond) ? 1 : -1] = {0}; (void)condition_failed[0]; }
+
+// Digital Mars C++ bug workaround for passing char loaded from memory via stack
+#ifdef __DMC__
+#	define PUGI__DMC_VOLATILE volatile
+#else
+#	define PUGI__DMC_VOLATILE
+#endif
+
+// Borland C++ bug workaround for not defining ::memcpy depending on header include order (can't always use std::memcpy because some compilers don't have it at all)
+#if defined(__BORLANDC__) && !defined(__MEM_H_USING_LIST)
+using std::memcpy;
+using std::memmove;
+#endif
+
+// In some environments MSVC is a compiler but the CRT lacks certain MSVC-specific features
+#if defined(_MSC_VER) && !defined(__S3E__)
+#	define PUGI__MSVC_CRT_VERSION _MSC_VER
+#endif
+
+#ifdef PUGIXML_HEADER_ONLY
+#	define PUGI__NS_BEGIN namespace pugi { namespace impl {
+#	define PUGI__NS_END } }
+#	define PUGI__FN inline
+#	define PUGI__FN_NO_INLINE inline
+#else
+#	if defined(_MSC_VER) && _MSC_VER < 1300 // MSVC6 seems to have an amusing bug with anonymous namespaces inside namespaces
+#		define PUGI__NS_BEGIN namespace pugi { namespace impl {
+#		define PUGI__NS_END } }
+#	else
+#		define PUGI__NS_BEGIN namespace pugi { namespace impl { namespace {
+#		define PUGI__NS_END } } }
+#	endif
+#	define PUGI__FN
+#	define PUGI__FN_NO_INLINE PUGI__NO_INLINE
+#endif
+
+// uintptr_t
+#if !defined(_MSC_VER) || _MSC_VER >= 1600
+#	include <stdint.h>
+#else
+#	ifndef _UINTPTR_T_DEFINED
+// No native uintptr_t in MSVC6 and in some WinCE versions
+typedef size_t uintptr_t;
+#define _UINTPTR_T_DEFINED
+#	endif
+PUGI__NS_BEGIN
+	typedef unsigned __int8 uint8_t;
+	typedef unsigned __int16 uint16_t;
+	typedef unsigned __int32 uint32_t;
+PUGI__NS_END
+#endif
+
+// Memory allocation
+PUGI__NS_BEGIN
+	PUGI__FN void* default_allocate(size_t size)
+	{
+		return malloc(size);
+	}
+
+	PUGI__FN void default_deallocate(void* ptr)
+	{
+		free(ptr);
+	}
+
+	template <typename T>
+	struct xml_memory_management_function_storage
+	{
+		static allocation_function allocate;
+		static deallocation_function deallocate;
+	};
+
+	template <typename T> allocation_function xml_memory_management_function_storage<T>::allocate = default_allocate;
+	template <typename T> deallocation_function xml_memory_management_function_storage<T>::deallocate = default_deallocate;
+
+	typedef xml_memory_management_function_storage<int> xml_memory;
+PUGI__NS_END
+
+// String utilities
+PUGI__NS_BEGIN
+	// Get string length
+	PUGI__FN size_t strlength(const char_t* s)
+	{
+		assert(s);
+
+	#ifdef PUGIXML_WCHAR_MODE
+		return wcslen(s);
+	#else
+		return strlen(s);
+	#endif
+	}
+
+	// Compare two strings
+	PUGI__FN bool strequal(const char_t* src, const char_t* dst)
+	{
+		assert(src && dst);
+
+	#ifdef PUGIXML_WCHAR_MODE
+		return wcscmp(src, dst) == 0;
+	#else
+		return strcmp(src, dst) == 0;
+	#endif
+	}
+
+	// Compare lhs with [rhs_begin, rhs_end)
+	PUGI__FN bool strequalrange(const char_t* lhs, const char_t* rhs, size_t count)
+	{
+		for (size_t i = 0; i < count; ++i)
+			if (lhs[i] != rhs[i])
+				return false;
+	
+		return lhs[count] == 0;
+	}
+	
+#ifdef PUGIXML_WCHAR_MODE
+	// Convert string to wide string, assuming all symbols are ASCII
+	PUGI__FN void widen_ascii(wchar_t* dest, const char* source)
+	{
+		for (const char* i = source; *i; ++i) *dest++ = *i;
+		*dest = 0;
+	}
+#endif
+PUGI__NS_END
+
+#if !defined(PUGIXML_NO_STL) || !defined(PUGIXML_NO_XPATH)
+// auto_ptr-like buffer holder for exception recovery
+PUGI__NS_BEGIN
+	struct buffer_holder
+	{
+		void* data;
+		void (*deleter)(void*);
+
+		buffer_holder(void* data_, void (*deleter_)(void*)): data(data_), deleter(deleter_)
+		{
+		}
+
+		~buffer_holder()
+		{
+			if (data) deleter(data);
+		}
+
+		void* release()
+		{
+			void* result = data;
+			data = 0;
+			return result;
+		}
+	};
+PUGI__NS_END
+#endif
+
+PUGI__NS_BEGIN
+	static const size_t xml_memory_page_size =
+	#ifdef PUGIXML_MEMORY_PAGE_SIZE
+		PUGIXML_MEMORY_PAGE_SIZE
+	#else
+		32768
+	#endif
+		;
+
+	static const uintptr_t xml_memory_page_alignment = 32;
+	static const uintptr_t xml_memory_page_pointer_mask = ~(xml_memory_page_alignment - 1);
+	static const uintptr_t xml_memory_page_name_allocated_mask = 16;
+	static const uintptr_t xml_memory_page_value_allocated_mask = 8;
+	static const uintptr_t xml_memory_page_type_mask = 7;
+
+	struct xml_allocator;
+
+	struct xml_memory_page
+	{
+		static xml_memory_page* construct(void* memory)
+		{
+			if (!memory) return 0; //$ redundant, left for performance
+
+			xml_memory_page* result = static_cast<xml_memory_page*>(memory);
+
+			result->allocator = 0;
+			result->memory = 0;
+			result->prev = 0;
+			result->next = 0;
+			result->busy_size = 0;
+			result->freed_size = 0;
+
+			return result;
+		}
+
+		xml_allocator* allocator;
+
+		void* memory;
+
+		xml_memory_page* prev;
+		xml_memory_page* next;
+
+		size_t busy_size;
+		size_t freed_size;
+
+		char data[1];
+	};
+
+	struct xml_memory_string_header
+	{
+		uint16_t page_offset; // offset from page->data
+		uint16_t full_size; // 0 if string occupies whole page
+	};
+
+	struct xml_allocator
+	{
+		xml_allocator(xml_memory_page* root): _root(root), _busy_size(root->busy_size)
+		{
+		}
+
+		xml_memory_page* allocate_page(size_t data_size)
+		{
+			size_t size = offsetof(xml_memory_page, data) + data_size;
+
+			// allocate block with some alignment, leaving memory for worst-case padding
+			void* memory = xml_memory::allocate(size + xml_memory_page_alignment);
+			if (!memory) return 0;
+
+			// align upwards to page boundary
+			void* page_memory = reinterpret_cast<void*>((reinterpret_cast<uintptr_t>(memory) + (xml_memory_page_alignment - 1)) & ~(xml_memory_page_alignment - 1));
+
+			// prepare page structure
+			xml_memory_page* page = xml_memory_page::construct(page_memory);
+
+			page->memory = memory;
+			page->allocator = _root->allocator;
+
+			return page;
+		}
+
+		static void deallocate_page(xml_memory_page* page)
+		{
+			xml_memory::deallocate(page->memory);
+		}
+
+		void* allocate_memory_oob(size_t size, xml_memory_page*& out_page);
+
+		void* allocate_memory(size_t size, xml_memory_page*& out_page)
+		{
+			if (_busy_size + size > xml_memory_page_size) return allocate_memory_oob(size, out_page);
+
+			void* buf = _root->data + _busy_size;
+
+			_busy_size += size;
+
+			out_page = _root;
+
+			return buf;
+		}
+
+		void deallocate_memory(void* ptr, size_t size, xml_memory_page* page)
+		{
+			if (page == _root) page->busy_size = _busy_size;
+
+			assert(ptr >= page->data && ptr < page->data + page->busy_size);
+			(void)!ptr;
+
+			page->freed_size += size;
+			assert(page->freed_size <= page->busy_size);
+
+			if (page->freed_size == page->busy_size)
+			{
+				if (page->next == 0)
+				{
+					assert(_root == page);
+
+					// top page freed, just reset sizes
+					page->busy_size = page->freed_size = 0;
+					_busy_size = 0;
+				}
+				else
+				{
+					assert(_root != page);
+					assert(page->prev);
+
+					// remove from the list
+					page->prev->next = page->next;
+					page->next->prev = page->prev;
+
+					// deallocate
+					deallocate_page(page);
+				}
+			}
+		}
+
+		char_t* allocate_string(size_t length)
+		{
+			// allocate memory for string and header block
+			size_t size = sizeof(xml_memory_string_header) + length * sizeof(char_t);
+			
+			// round size up to pointer alignment boundary
+			size_t full_size = (size + (sizeof(void*) - 1)) & ~(sizeof(void*) - 1);
+
+			xml_memory_page* page;
+			xml_memory_string_header* header = static_cast<xml_memory_string_header*>(allocate_memory(full_size, page));
+
+			if (!header) return 0;
+
+			// setup header
+			ptrdiff_t page_offset = reinterpret_cast<char*>(header) - page->data;
+
+			assert(page_offset >= 0 && page_offset < (1 << 16));
+			header->page_offset = static_cast<uint16_t>(page_offset);
+
+			// full_size == 0 for large strings that occupy the whole page
+			assert(full_size < (1 << 16) || (page->busy_size == full_size && page_offset == 0));
+			header->full_size = static_cast<uint16_t>(full_size < (1 << 16) ? full_size : 0);
+
+			// round-trip through void* to avoid 'cast increases required alignment of target type' warning
+			// header is guaranteed a pointer-sized alignment, which should be enough for char_t
+			return static_cast<char_t*>(static_cast<void*>(header + 1));
+		}
+
+		void deallocate_string(char_t* string)
+		{
+			// this function casts pointers through void* to avoid 'cast increases required alignment of target type' warnings
+			// we're guaranteed the proper (pointer-sized) alignment on the input string if it was allocated via allocate_string
+
+			// get header
+			xml_memory_string_header* header = static_cast<xml_memory_string_header*>(static_cast<void*>(string)) - 1;
+
+			// deallocate
+			size_t page_offset = offsetof(xml_memory_page, data) + header->page_offset;
+			xml_memory_page* page = reinterpret_cast<xml_memory_page*>(static_cast<void*>(reinterpret_cast<char*>(header) - page_offset));
+
+			// if full_size == 0 then this string occupies the whole page
+			size_t full_size = header->full_size == 0 ? page->busy_size : header->full_size;
+
+			deallocate_memory(header, full_size, page);
+		}
+
+		xml_memory_page* _root;
+		size_t _busy_size;
+	};
+
+	PUGI__FN_NO_INLINE void* xml_allocator::allocate_memory_oob(size_t size, xml_memory_page*& out_page)
+	{
+		const size_t large_allocation_threshold = xml_memory_page_size / 4;
+
+		xml_memory_page* page = allocate_page(size <= large_allocation_threshold ? xml_memory_page_size : size);
+		out_page = page;
+
+		if (!page) return 0;
+
+		if (size <= large_allocation_threshold)
+		{
+			_root->busy_size = _busy_size;
+
+			// insert page at the end of linked list
+			page->prev = _root;
+			_root->next = page;
+			_root = page;
+
+			_busy_size = size;
+		}
+		else
+		{
+			// insert page before the end of linked list, so that it is deleted as soon as possible
+			// the last page is not deleted even if it's empty (see deallocate_memory)
+			assert(_root->prev);
+
+			page->prev = _root->prev;
+			page->next = _root;
+
+			_root->prev->next = page;
+			_root->prev = page;
+		}
+
+		// allocate inside page
+		page->busy_size = size;
+
+		return page->data;
+	}
+PUGI__NS_END
+
+namespace pugi
+{
+	/// A 'name=value' XML attribute structure.
+	struct xml_attribute_struct
+	{
+		/// Default ctor
+		xml_attribute_struct(impl::xml_memory_page* page): header(reinterpret_cast<uintptr_t>(page)), name(0), value(0), prev_attribute_c(0), next_attribute(0)
+		{
+		}
+
+		uintptr_t header;
+
+		char_t* name;	///< Pointer to attribute name.
+		char_t*	value;	///< Pointer to attribute value.
+
+		xml_attribute_struct* prev_attribute_c;	///< Previous attribute (cyclic list)
+		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(impl::xml_memory_page* page, xml_node_type type): header(reinterpret_cast<uintptr_t>(page) | (type - 1)), parent(0), name(0), value(0), first_child(0), prev_sibling_c(0), next_sibling(0), first_attribute(0)
+		{
+		}
+
+		uintptr_t header;
+
+		xml_node_struct*		parent;					///< Pointer to parent
+
+		char_t*					name;					///< Pointer to element name.
+		char_t*					value;					///< Pointer to any associated string data.
+
+		xml_node_struct*		first_child;			///< First child
+		
+		xml_node_struct*		prev_sibling_c;			///< Left brother (cyclic list)
+		xml_node_struct*		next_sibling;			///< Right brother
+		
+		xml_attribute_struct*	first_attribute;		///< First attribute
+	};
+}
+
+PUGI__NS_BEGIN
+	struct xml_document_struct: public xml_node_struct, public xml_allocator
+	{
+		xml_document_struct(xml_memory_page* page): xml_node_struct(page, node_document), xml_allocator(page), buffer(0)
+		{
+		}
+
+		const char_t* buffer;
+	};
+
+	inline xml_allocator& get_allocator(const xml_node_struct* node)
+	{
+		assert(node);
+
+		return *reinterpret_cast<xml_memory_page*>(node->header & xml_memory_page_pointer_mask)->allocator;
+	}
+PUGI__NS_END
+
+// Low-level DOM operations
+PUGI__NS_BEGIN
+	inline xml_attribute_struct* allocate_attribute(xml_allocator& alloc)
+	{
+		xml_memory_page* page;
+		void* memory = alloc.allocate_memory(sizeof(xml_attribute_struct), page);
+
+		return new (memory) xml_attribute_struct(page);
+	}
+
+	inline xml_node_struct* allocate_node(xml_allocator& alloc, xml_node_type type)
+	{
+		xml_memory_page* page;
+		void* memory = alloc.allocate_memory(sizeof(xml_node_struct), page);
+
+		return new (memory) xml_node_struct(page, type);
+	}
+
+	inline void destroy_attribute(xml_attribute_struct* a, xml_allocator& alloc)
+	{
+		uintptr_t header = a->header;
+
+		if (header & impl::xml_memory_page_name_allocated_mask) alloc.deallocate_string(a->name);
+		if (header & impl::xml_memory_page_value_allocated_mask) alloc.deallocate_string(a->value);
+
+		alloc.deallocate_memory(a, sizeof(xml_attribute_struct), reinterpret_cast<xml_memory_page*>(header & xml_memory_page_pointer_mask));
+	}
+
+	inline void destroy_node(xml_node_struct* n, xml_allocator& alloc)
+	{
+		uintptr_t header = n->header;
+
+		if (header & impl::xml_memory_page_name_allocated_mask) alloc.deallocate_string(n->name);
+		if (header & impl::xml_memory_page_value_allocated_mask) alloc.deallocate_string(n->value);
+
+		for (xml_attribute_struct* attr = n->first_attribute; attr; )
+		{
+			xml_attribute_struct* next = attr->next_attribute;
+
+			destroy_attribute(attr, alloc);
+
+			attr = next;
+		}
+
+		for (xml_node_struct* child = n->first_child; child; )
+		{
+			xml_node_struct* next = child->next_sibling;
+
+			destroy_node(child, alloc);
+
+			child = next;
+		}
+
+		alloc.deallocate_memory(n, sizeof(xml_node_struct), reinterpret_cast<xml_memory_page*>(header & xml_memory_page_pointer_mask));
+	}
+
+	PUGI__FN_NO_INLINE xml_node_struct* append_node(xml_node_struct* node, xml_allocator& alloc, xml_node_type type = node_element)
+	{
+		xml_node_struct* child = allocate_node(alloc, type);
+		if (!child) return 0;
+
+		child->parent = node;
+
+		xml_node_struct* first_child = node->first_child;
+			
+		if (first_child)
+		{
+			xml_node_struct* last_child = first_child->prev_sibling_c;
+
+			last_child->next_sibling = child;
+			child->prev_sibling_c = last_child;
+			first_child->prev_sibling_c = child;
+		}
+		else
+		{
+			node->first_child = child;
+			child->prev_sibling_c = child;
+		}
+			
+		return child;
+	}
+
+	PUGI__FN_NO_INLINE xml_attribute_struct* append_attribute_ll(xml_node_struct* node, xml_allocator& alloc)
+	{
+		xml_attribute_struct* a = allocate_attribute(alloc);
+		if (!a) return 0;
+
+		xml_attribute_struct* first_attribute = node->first_attribute;
+
+		if (first_attribute)
+		{
+			xml_attribute_struct* last_attribute = first_attribute->prev_attribute_c;
+
+			last_attribute->next_attribute = a;
+			a->prev_attribute_c = last_attribute;
+			first_attribute->prev_attribute_c = a;
+		}
+		else
+		{
+			node->first_attribute = a;
+			a->prev_attribute_c = a;
+		}
+			
+		return a;
+	}
+PUGI__NS_END
+
+// Helper classes for code generation
+PUGI__NS_BEGIN
+	struct opt_false
+	{
+		enum { value = 0 };
+	};
+
+	struct opt_true
+	{
+		enum { value = 1 };
+	};
+PUGI__NS_END
+
+// Unicode utilities
+PUGI__NS_BEGIN
+	inline uint16_t endian_swap(uint16_t value)
+	{
+		return static_cast<uint16_t>(((value & 0xff) << 8) | (value >> 8));
+	}
+
+	inline uint32_t endian_swap(uint32_t value)
+	{
+		return ((value & 0xff) << 24) | ((value & 0xff00) << 8) | ((value & 0xff0000) >> 8) | (value >> 24);
+	}
+
+	struct utf8_counter
+	{
+		typedef size_t value_type;
+
+		static value_type low(value_type result, uint32_t ch)
+		{
+			// U+0000..U+007F
+			if (ch < 0x80) return result + 1;
+			// U+0080..U+07FF
+			else if (ch < 0x800) return result + 2;
+			// U+0800..U+FFFF
+			else return result + 3;
+		}
+
+		static value_type high(value_type result, uint32_t)
+		{
+			// U+10000..U+10FFFF
+			return result + 4;
+		}
+	};
+
+	struct utf8_writer
+	{
+		typedef uint8_t* value_type;
+
+		static value_type low(value_type result, uint32_t ch)
+		{
+			// U+0000..U+007F
+			if (ch < 0x80)
+			{
+				*result = static_cast<uint8_t>(ch);
+				return result + 1;
+			}
+			// U+0080..U+07FF
+			else if (ch < 0x800)
+			{
+				result[0] = static_cast<uint8_t>(0xC0 | (ch >> 6));
+				result[1] = static_cast<uint8_t>(0x80 | (ch & 0x3F));
+				return result + 2;
+			}
+			// U+0800..U+FFFF
+			else
+			{
+				result[0] = static_cast<uint8_t>(0xE0 | (ch >> 12));
+				result[1] = static_cast<uint8_t>(0x80 | ((ch >> 6) & 0x3F));
+				result[2] = static_cast<uint8_t>(0x80 | (ch & 0x3F));
+				return result + 3;
+			}
+		}
+
+		static value_type high(value_type result, uint32_t ch)
+		{
+			// U+10000..U+10FFFF
+			result[0] = static_cast<uint8_t>(0xF0 | (ch >> 18));
+			result[1] = static_cast<uint8_t>(0x80 | ((ch >> 12) & 0x3F));
+			result[2] = static_cast<uint8_t>(0x80 | ((ch >> 6) & 0x3F));
+			result[3] = static_cast<uint8_t>(0x80 | (ch & 0x3F));
+			return result + 4;
+		}
+
+		static value_type any(value_type result, uint32_t ch)
+		{
+			return (ch < 0x10000) ? low(result, ch) : high(result, ch);
+		}
+	};
+
+	struct utf16_counter
+	{
+		typedef size_t value_type;
+
+		static value_type low(value_type result, uint32_t)
+		{
+			return result + 1;
+		}
+
+		static value_type high(value_type result, uint32_t)
+		{
+			return result + 2;
+		}
+	};
+
+	struct utf16_writer
+	{
+		typedef uint16_t* value_type;
+
+		static value_type low(value_type result, uint32_t ch)
+		{
+			*result = static_cast<uint16_t>(ch);
+
+			return result + 1;
+		}
+
+		static value_type high(value_type result, uint32_t ch)
+		{
+			uint32_t msh = static_cast<uint32_t>(ch - 0x10000) >> 10;
+			uint32_t lsh = static_cast<uint32_t>(ch - 0x10000) & 0x3ff;
+
+			result[0] = static_cast<uint16_t>(0xD800 + msh);
+			result[1] = static_cast<uint16_t>(0xDC00 + lsh);
+
+			return result + 2;
+		}
+
+		static value_type any(value_type result, uint32_t ch)
+		{
+			return (ch < 0x10000) ? low(result, ch) : high(result, ch);
+		}
+	};
+
+	struct utf32_counter
+	{
+		typedef size_t value_type;
+
+		static value_type low(value_type result, uint32_t)
+		{
+			return result + 1;
+		}
+
+		static value_type high(value_type result, uint32_t)
+		{
+			return result + 1;
+		}
+	};
+
+	struct utf32_writer
+	{
+		typedef uint32_t* value_type;
+
+		static value_type low(value_type result, uint32_t ch)
+		{
+			*result = ch;
+
+			return result + 1;
+		}
+
+		static value_type high(value_type result, uint32_t ch)
+		{
+			*result = ch;
+
+			return result + 1;
+		}
+
+		static value_type any(value_type result, uint32_t ch)
+		{
+			*result = ch;
+
+			return result + 1;
+		}
+	};
+
+	struct latin1_writer
+	{
+		typedef uint8_t* value_type;
+
+		static value_type low(value_type result, uint32_t ch)
+		{
+			*result = static_cast<uint8_t>(ch > 255 ? '?' : ch);
+
+			return result + 1;
+		}
+
+		static value_type high(value_type result, uint32_t ch)
+		{
+			(void)ch;
+
+			*result = '?';
+
+			return result + 1;
+		}
+	};
+
+	template <size_t size> struct wchar_selector;
+
+	template <> struct wchar_selector<2>
+	{
+		typedef uint16_t type;
+		typedef utf16_counter counter;
+		typedef utf16_writer writer;
+	};
+
+	template <> struct wchar_selector<4>
+	{
+		typedef uint32_t type;
+		typedef utf32_counter counter;
+		typedef utf32_writer writer;
+	};
+
+	typedef wchar_selector<sizeof(wchar_t)>::counter wchar_counter;
+	typedef wchar_selector<sizeof(wchar_t)>::writer wchar_writer;
+
+	template <typename Traits, typename opt_swap = opt_false> struct utf_decoder
+	{
+		static inline typename Traits::value_type decode_utf8_block(const uint8_t* data, size_t size, typename Traits::value_type result)
+		{
+			const uint8_t utf8_byte_mask = 0x3f;
+
+			while (size)
+			{
+				uint8_t lead = *data;
+
+				// 0xxxxxxx -> U+0000..U+007F
+				if (lead < 0x80)
+				{
+					result = Traits::low(result, lead);
+					data += 1;
+					size -= 1;
+
+					// process aligned single-byte (ascii) blocks
+					if ((reinterpret_cast<uintptr_t>(data) & 3) == 0)
+					{
+						// round-trip through void* to silence 'cast increases required alignment of target type' warnings
+						while (size >= 4 && (*static_cast<const uint32_t*>(static_cast<const void*>(data)) & 0x80808080) == 0)
+						{
+							result = Traits::low(result, data[0]);
+							result = Traits::low(result, data[1]);
+							result = Traits::low(result, data[2]);
+							result = Traits::low(result, data[3]);
+							data += 4;
+							size -= 4;
+						}
+					}
+				}
+				// 110xxxxx -> U+0080..U+07FF
+				else if (static_cast<unsigned int>(lead - 0xC0) < 0x20 && size >= 2 && (data[1] & 0xc0) == 0x80)
+				{
+					result = Traits::low(result, ((lead & ~0xC0) << 6) | (data[1] & utf8_byte_mask));
+					data += 2;
+					size -= 2;
+				}
+				// 1110xxxx -> U+0800-U+FFFF
+				else if (static_cast<unsigned int>(lead - 0xE0) < 0x10 && size >= 3 && (data[1] & 0xc0) == 0x80 && (data[2] & 0xc0) == 0x80)
+				{
+					result = Traits::low(result, ((lead & ~0xE0) << 12) | ((data[1] & utf8_byte_mask) << 6) | (data[2] & utf8_byte_mask));
+					data += 3;
+					size -= 3;
+				}
+				// 11110xxx -> U+10000..U+10FFFF
+				else if (static_cast<unsigned int>(lead - 0xF0) < 0x08 && size >= 4 && (data[1] & 0xc0) == 0x80 && (data[2] & 0xc0) == 0x80 && (data[3] & 0xc0) == 0x80)
+				{
+					result = Traits::high(result, ((lead & ~0xF0) << 18) | ((data[1] & utf8_byte_mask) << 12) | ((data[2] & utf8_byte_mask) << 6) | (data[3] & utf8_byte_mask));
+					data += 4;
+					size -= 4;
+				}
+				// 10xxxxxx or 11111xxx -> invalid
+				else
+				{
+					data += 1;
+					size -= 1;
+				}
+			}
+
+			return result;
+		}
+
+		static inline typename Traits::value_type decode_utf16_block(const uint16_t* data, size_t size, typename Traits::value_type result)
+		{
+			const uint16_t* end = data + size;
+
+			while (data < end)
+			{
+				uint16_t lead = opt_swap::value ? endian_swap(*data) : *data;
+
+				// U+0000..U+D7FF
+				if (lead < 0xD800)
+				{
+					result = Traits::low(result, lead);
+					data += 1;
+				}
+				// U+E000..U+FFFF
+				else if (static_cast<unsigned int>(lead - 0xE000) < 0x2000)
+				{
+					result = Traits::low(result, lead);
+					data += 1;
+				}
+				// surrogate pair lead
+				else if (static_cast<unsigned int>(lead - 0xD800) < 0x400 && data + 1 < end)
+				{
+					uint16_t next = opt_swap::value ? endian_swap(data[1]) : data[1];
+
+					if (static_cast<unsigned int>(next - 0xDC00) < 0x400)
+					{
+						result = Traits::high(result, 0x10000 + ((lead & 0x3ff) << 10) + (next & 0x3ff));
+						data += 2;
+					}
+					else
+					{
+						data += 1;
+					}
+				}
+				else
+				{
+					data += 1;
+				}
+			}
+
+			return result;
+		}
+
+		static inline typename Traits::value_type decode_utf32_block(const uint32_t* data, size_t size, typename Traits::value_type result)
+		{
+			const uint32_t* end = data + size;
+
+			while (data < end)
+			{
+				uint32_t lead = opt_swap::value ? endian_swap(*data) : *data;
+
+				// U+0000..U+FFFF
+				if (lead < 0x10000)
+				{
+					result = Traits::low(result, lead);
+					data += 1;
+				}
+				// U+10000..U+10FFFF
+				else
+				{
+					result = Traits::high(result, lead);
+					data += 1;
+				}
+			}
+
+			return result;
+		}
+
+		static inline typename Traits::value_type decode_latin1_block(const uint8_t* data, size_t size, typename Traits::value_type result)
+		{
+			for (size_t i = 0; i < size; ++i)
+			{
+				result = Traits::low(result, data[i]);
+			}
+
+			return result;
+		}
+
+		static inline typename Traits::value_type decode_wchar_block_impl(const uint16_t* data, size_t size, typename Traits::value_type result)
+		{
+			return decode_utf16_block(data, size, result);
+		}
+
+		static inline typename Traits::value_type decode_wchar_block_impl(const uint32_t* data, size_t size, typename Traits::value_type result)
+		{
+			return decode_utf32_block(data, size, result);
+		}
+
+		static inline typename Traits::value_type decode_wchar_block(const wchar_t* data, size_t size, typename Traits::value_type result)
+		{
+			return decode_wchar_block_impl(reinterpret_cast<const wchar_selector<sizeof(wchar_t)>::type*>(data), size, result);
+		}
+	};
+
+	template <typename T> PUGI__FN void convert_utf_endian_swap(T* result, const T* data, size_t length)
+	{
+		for (size_t i = 0; i < length; ++i) result[i] = endian_swap(data[i]);
+	}
+
+#ifdef PUGIXML_WCHAR_MODE
+	PUGI__FN void convert_wchar_endian_swap(wchar_t* result, const wchar_t* data, size_t length)
+	{
+		for (size_t i = 0; i < length; ++i) result[i] = static_cast<wchar_t>(endian_swap(static_cast<wchar_selector<sizeof(wchar_t)>::type>(data[i])));
+	}
+#endif
+PUGI__NS_END
+
+PUGI__NS_BEGIN
+	enum chartype_t
+	{
+		ct_parse_pcdata = 1,	// \0, &, \r, <
+		ct_parse_attr = 2,		// \0, &, \r, ', "
+		ct_parse_attr_ws = 4,	// \0, &, \r, ', ", \n, 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, _, :
+	};
+
+	static 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
+		8,   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
+	};
+
+	enum chartypex_t
+	{
+		ctx_special_pcdata = 1,   // Any symbol >= 0 and < 32 (except \t, \r, \n), &, <, >
+		ctx_special_attr = 2,     // Any symbol >= 0 and < 32 (except \t), &, <, >, "
+		ctx_start_symbol = 4,	  // Any symbol > 127, a-z, A-Z, _
+		ctx_digit = 8,			  // 0-9
+		ctx_symbol = 16			  // Any symbol > 127, a-z, A-Z, 0-9, _, -, .
+	};
+	
+	static const unsigned char chartypex_table[256] =
+	{
+		3,  3,  3,  3,  3,  3,  3,  3,     3,  0,  2,  3,  3,  2,  3,  3,     // 0-15
+		3,  3,  3,  3,  3,  3,  3,  3,     3,  3,  3,  3,  3,  3,  3,  3,     // 16-31
+		0,  0,  2,  0,  0,  0,  3,  0,     0,  0,  0,  0,  0, 16, 16,  0,     // 32-47
+		24, 24, 24, 24, 24, 24, 24, 24,    24, 24, 0,  0,  3,  0,  3,  0,     // 48-63
+
+		0,  20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,    // 64-79
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 0,  0,  0,  0,  20,    // 80-95
+		0,  20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,    // 96-111
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 0,  0,  0,  0,  0,     // 112-127
+
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,    // 128+
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20,
+		20, 20, 20, 20, 20, 20, 20, 20,    20, 20, 20, 20, 20, 20, 20, 20
+	};
+	
+#ifdef PUGIXML_WCHAR_MODE
+	#define PUGI__IS_CHARTYPE_IMPL(c, ct, table) ((static_cast<unsigned int>(c) < 128 ? table[static_cast<unsigned int>(c)] : table[128]) & (ct))
+#else
+	#define PUGI__IS_CHARTYPE_IMPL(c, ct, table) (table[static_cast<unsigned char>(c)] & (ct))
+#endif
+
+	#define PUGI__IS_CHARTYPE(c, ct) PUGI__IS_CHARTYPE_IMPL(c, ct, chartype_table)
+	#define PUGI__IS_CHARTYPEX(c, ct) PUGI__IS_CHARTYPE_IMPL(c, ct, chartypex_table)
+
+	PUGI__FN bool is_little_endian()
+	{
+		unsigned int ui = 1;
+
+		return *reinterpret_cast<unsigned char*>(&ui) == 1;
+	}
+
+	PUGI__FN xml_encoding get_wchar_encoding()
+	{
+		PUGI__STATIC_ASSERT(sizeof(wchar_t) == 2 || sizeof(wchar_t) == 4);
+
+		if (sizeof(wchar_t) == 2)
+			return is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+		else 
+			return is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+	}
+
+	PUGI__FN xml_encoding guess_buffer_encoding(uint8_t d0, uint8_t d1, uint8_t d2, uint8_t d3)
+	{
+		// look for BOM in first few bytes
+		if (d0 == 0 && d1 == 0 && d2 == 0xfe && d3 == 0xff) return encoding_utf32_be;
+		if (d0 == 0xff && d1 == 0xfe && d2 == 0 && d3 == 0) return encoding_utf32_le;
+		if (d0 == 0xfe && d1 == 0xff) return encoding_utf16_be;
+		if (d0 == 0xff && d1 == 0xfe) return encoding_utf16_le;
+		if (d0 == 0xef && d1 == 0xbb && d2 == 0xbf) return encoding_utf8;
+
+		// look for <, <? or <?xm in various encodings
+		if (d0 == 0 && d1 == 0 && d2 == 0 && d3 == 0x3c) return encoding_utf32_be;
+		if (d0 == 0x3c && d1 == 0 && d2 == 0 && d3 == 0) return encoding_utf32_le;
+		if (d0 == 0 && d1 == 0x3c && d2 == 0 && d3 == 0x3f) return encoding_utf16_be;
+		if (d0 == 0x3c && d1 == 0 && d2 == 0x3f && d3 == 0) return encoding_utf16_le;
+		if (d0 == 0x3c && d1 == 0x3f && d2 == 0x78 && d3 == 0x6d) return encoding_utf8;
+
+		// look for utf16 < followed by node name (this may fail, but is better than utf8 since it's zero terminated so early)
+		if (d0 == 0 && d1 == 0x3c) return encoding_utf16_be;
+		if (d0 == 0x3c && d1 == 0) return encoding_utf16_le;
+
+		// no known BOM detected, assume utf8
+		return encoding_utf8;
+	}
+
+	PUGI__FN xml_encoding get_buffer_encoding(xml_encoding encoding, const void* contents, size_t size)
+	{
+		// replace wchar encoding with utf implementation
+		if (encoding == encoding_wchar) return get_wchar_encoding();
+
+		// replace utf16 encoding with utf16 with specific endianness
+		if (encoding == encoding_utf16) return is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+
+		// replace utf32 encoding with utf32 with specific endianness
+		if (encoding == encoding_utf32) return is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+
+		// only do autodetection if no explicit encoding is requested
+		if (encoding != encoding_auto) return encoding;
+
+		// skip encoding autodetection if input buffer is too small
+		if (size < 4) return encoding_utf8;
+
+		// try to guess encoding (based on XML specification, Appendix F.1)
+		const uint8_t* data = static_cast<const uint8_t*>(contents);
+
+		PUGI__DMC_VOLATILE uint8_t d0 = data[0], d1 = data[1], d2 = data[2], d3 = data[3];
+
+		return guess_buffer_encoding(d0, d1, d2, d3);
+	}
+
+	PUGI__FN bool get_mutable_buffer(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable)
+	{
+		if (is_mutable)
+		{
+			out_buffer = static_cast<char_t*>(const_cast<void*>(contents));
+		}
+		else
+		{
+			void* buffer = xml_memory::allocate(size > 0 ? size : 1);
+			if (!buffer) return false;
+
+			memcpy(buffer, contents, size);
+
+			out_buffer = static_cast<char_t*>(buffer);
+		}
+
+		out_length = size / sizeof(char_t);
+
+		return true;
+	}
+
+#ifdef PUGIXML_WCHAR_MODE
+	PUGI__FN bool need_endian_swap_utf(xml_encoding le, xml_encoding re)
+	{
+		return (le == encoding_utf16_be && re == encoding_utf16_le) || (le == encoding_utf16_le && re == encoding_utf16_be) ||
+			   (le == encoding_utf32_be && re == encoding_utf32_le) || (le == encoding_utf32_le && re == encoding_utf32_be);
+	}
+
+	PUGI__FN bool convert_buffer_endian_swap(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable)
+	{
+		const char_t* data = static_cast<const char_t*>(contents);
+	
+		if (is_mutable)
+		{
+			out_buffer = const_cast<char_t*>(data);
+		}
+		else
+		{
+			out_buffer = static_cast<char_t*>(xml_memory::allocate(size > 0 ? size : 1));
+			if (!out_buffer) return false;
+		}
+
+		out_length = size / sizeof(char_t);
+
+		convert_wchar_endian_swap(out_buffer, data, out_length);
+
+		return true;
+	}
+
+	PUGI__FN bool convert_buffer_utf8(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size)
+	{
+		const uint8_t* data = static_cast<const uint8_t*>(contents);
+
+		// first pass: get length in wchar_t units
+		out_length = utf_decoder<wchar_counter>::decode_utf8_block(data, size, 0);
+
+		// allocate buffer of suitable length
+		out_buffer = static_cast<char_t*>(xml_memory::allocate((out_length > 0 ? out_length : 1) * sizeof(char_t)));
+		if (!out_buffer) return false;
+
+		// second pass: convert utf8 input to wchar_t
+		wchar_writer::value_type out_begin = reinterpret_cast<wchar_writer::value_type>(out_buffer);
+		wchar_writer::value_type out_end = utf_decoder<wchar_writer>::decode_utf8_block(data, size, out_begin);
+
+		assert(out_end == out_begin + out_length);
+		(void)!out_end;
+
+		return true;
+	}
+
+	template <typename opt_swap> PUGI__FN bool convert_buffer_utf16(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap)
+	{
+		const uint16_t* data = static_cast<const uint16_t*>(contents);
+		size_t length = size / sizeof(uint16_t);
+
+		// first pass: get length in wchar_t units
+		out_length = utf_decoder<wchar_counter, opt_swap>::decode_utf16_block(data, length, 0);
+
+		// allocate buffer of suitable length
+		out_buffer = static_cast<char_t*>(xml_memory::allocate((out_length > 0 ? out_length : 1) * sizeof(char_t)));
+		if (!out_buffer) return false;
+
+		// second pass: convert utf16 input to wchar_t
+		wchar_writer::value_type out_begin = reinterpret_cast<wchar_writer::value_type>(out_buffer);
+		wchar_writer::value_type out_end = utf_decoder<wchar_writer, opt_swap>::decode_utf16_block(data, length, out_begin);
+
+		assert(out_end == out_begin + out_length);
+		(void)!out_end;
+
+		return true;
+	}
+
+	template <typename opt_swap> PUGI__FN bool convert_buffer_utf32(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap)
+	{
+		const uint32_t* data = static_cast<const uint32_t*>(contents);
+		size_t length = size / sizeof(uint32_t);
+
+		// first pass: get length in wchar_t units
+		out_length = utf_decoder<wchar_counter, opt_swap>::decode_utf32_block(data, length, 0);
+
+		// allocate buffer of suitable length
+		out_buffer = static_cast<char_t*>(xml_memory::allocate((out_length > 0 ? out_length : 1) * sizeof(char_t)));
+		if (!out_buffer) return false;
+
+		// second pass: convert utf32 input to wchar_t
+		wchar_writer::value_type out_begin = reinterpret_cast<wchar_writer::value_type>(out_buffer);
+		wchar_writer::value_type out_end = utf_decoder<wchar_writer, opt_swap>::decode_utf32_block(data, length, out_begin);
+
+		assert(out_end == out_begin + out_length);
+		(void)!out_end;
+
+		return true;
+	}
+
+	PUGI__FN bool convert_buffer_latin1(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size)
+	{
+		const uint8_t* data = static_cast<const uint8_t*>(contents);
+
+		// get length in wchar_t units
+		out_length = size;
+
+		// allocate buffer of suitable length
+		out_buffer = static_cast<char_t*>(xml_memory::allocate((out_length > 0 ? out_length : 1) * sizeof(char_t)));
+		if (!out_buffer) return false;
+
+		// convert latin1 input to wchar_t
+		wchar_writer::value_type out_begin = reinterpret_cast<wchar_writer::value_type>(out_buffer);
+		wchar_writer::value_type out_end = utf_decoder<wchar_writer>::decode_latin1_block(data, size, out_begin);
+
+		assert(out_end == out_begin + out_length);
+		(void)!out_end;
+
+		return true;
+	}
+
+	PUGI__FN bool convert_buffer(char_t*& out_buffer, size_t& out_length, xml_encoding encoding, const void* contents, size_t size, bool is_mutable)
+	{
+		// get native encoding
+		xml_encoding wchar_encoding = get_wchar_encoding();
+
+		// fast path: no conversion required
+		if (encoding == wchar_encoding) return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
+
+		// only endian-swapping is required
+		if (need_endian_swap_utf(encoding, wchar_encoding)) return convert_buffer_endian_swap(out_buffer, out_length, contents, size, is_mutable);
+
+		// source encoding is utf8
+		if (encoding == encoding_utf8) return convert_buffer_utf8(out_buffer, out_length, contents, size);
+
+		// source encoding is utf16
+		if (encoding == encoding_utf16_be || encoding == encoding_utf16_le)
+		{
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+
+			return (native_encoding == encoding) ?
+				convert_buffer_utf16(out_buffer, out_length, contents, size, opt_false()) :
+				convert_buffer_utf16(out_buffer, out_length, contents, size, opt_true());
+		}
+
+		// source encoding is utf32
+		if (encoding == encoding_utf32_be || encoding == encoding_utf32_le)
+		{
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+
+			return (native_encoding == encoding) ?
+				convert_buffer_utf32(out_buffer, out_length, contents, size, opt_false()) :
+				convert_buffer_utf32(out_buffer, out_length, contents, size, opt_true());
+		}
+
+		// source encoding is latin1
+		if (encoding == encoding_latin1) return convert_buffer_latin1(out_buffer, out_length, contents, size);
+
+		assert(!"Invalid encoding");
+		return false;
+	}
+#else
+	template <typename opt_swap> PUGI__FN bool convert_buffer_utf16(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap)
+	{
+		const uint16_t* data = static_cast<const uint16_t*>(contents);
+		size_t length = size / sizeof(uint16_t);
+
+		// first pass: get length in utf8 units
+		out_length = utf_decoder<utf8_counter, opt_swap>::decode_utf16_block(data, length, 0);
+
+		// allocate buffer of suitable length
+		out_buffer = static_cast<char_t*>(xml_memory::allocate((out_length > 0 ? out_length : 1) * sizeof(char_t)));
+		if (!out_buffer) return false;
+
+		// second pass: convert utf16 input to utf8
+		uint8_t* out_begin = reinterpret_cast<uint8_t*>(out_buffer);
+		uint8_t* out_end = utf_decoder<utf8_writer, opt_swap>::decode_utf16_block(data, length, out_begin);
+
+		assert(out_end == out_begin + out_length);
+		(void)!out_end;
+
+		return true;
+	}
+
+	template <typename opt_swap> PUGI__FN bool convert_buffer_utf32(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, opt_swap)
+	{
+		const uint32_t* data = static_cast<const uint32_t*>(contents);
+		size_t length = size / sizeof(uint32_t);
+
+		// first pass: get length in utf8 units
+		out_length = utf_decoder<utf8_counter, opt_swap>::decode_utf32_block(data, length, 0);
+
+		// allocate buffer of suitable length
+		out_buffer = static_cast<char_t*>(xml_memory::allocate((out_length > 0 ? out_length : 1) * sizeof(char_t)));
+		if (!out_buffer) return false;
+
+		// second pass: convert utf32 input to utf8
+		uint8_t* out_begin = reinterpret_cast<uint8_t*>(out_buffer);
+		uint8_t* out_end = utf_decoder<utf8_writer, opt_swap>::decode_utf32_block(data, length, out_begin);
+
+		assert(out_end == out_begin + out_length);
+		(void)!out_end;
+
+		return true;
+	}
+
+	PUGI__FN size_t get_latin1_7bit_prefix_length(const uint8_t* data, size_t size)
+	{
+		for (size_t i = 0; i < size; ++i)
+			if (data[i] > 127)
+				return i;
+
+		return size;
+	}
+
+	PUGI__FN bool convert_buffer_latin1(char_t*& out_buffer, size_t& out_length, const void* contents, size_t size, bool is_mutable)
+	{
+		const uint8_t* data = static_cast<const uint8_t*>(contents);
+
+		// get size of prefix that does not need utf8 conversion
+		size_t prefix_length = get_latin1_7bit_prefix_length(data, size);
+		assert(prefix_length <= size);
+
+		const uint8_t* postfix = data + prefix_length;
+		size_t postfix_length = size - prefix_length;
+
+		// if no conversion is needed, just return the original buffer
+		if (postfix_length == 0) return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
+
+		// first pass: get length in utf8 units
+		out_length = prefix_length + utf_decoder<utf8_counter>::decode_latin1_block(postfix, postfix_length, 0);
+
+		// allocate buffer of suitable length
+		out_buffer = static_cast<char_t*>(xml_memory::allocate((out_length > 0 ? out_length : 1) * sizeof(char_t)));
+		if (!out_buffer) return false;
+
+		// second pass: convert latin1 input to utf8
+		memcpy(out_buffer, data, prefix_length);
+
+		uint8_t* out_begin = reinterpret_cast<uint8_t*>(out_buffer);
+		uint8_t* out_end = utf_decoder<utf8_writer>::decode_latin1_block(postfix, postfix_length, out_begin + prefix_length);
+
+		assert(out_end == out_begin + out_length);
+		(void)!out_end;
+
+		return true;
+	}
+
+	PUGI__FN bool convert_buffer(char_t*& out_buffer, size_t& out_length, xml_encoding encoding, const void* contents, size_t size, bool is_mutable)
+	{
+		// fast path: no conversion required
+		if (encoding == encoding_utf8) return get_mutable_buffer(out_buffer, out_length, contents, size, is_mutable);
+
+		// source encoding is utf16
+		if (encoding == encoding_utf16_be || encoding == encoding_utf16_le)
+		{
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+
+			return (native_encoding == encoding) ?
+				convert_buffer_utf16(out_buffer, out_length, contents, size, opt_false()) :
+				convert_buffer_utf16(out_buffer, out_length, contents, size, opt_true());
+		}
+
+		// source encoding is utf32
+		if (encoding == encoding_utf32_be || encoding == encoding_utf32_le)
+		{
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+
+			return (native_encoding == encoding) ?
+				convert_buffer_utf32(out_buffer, out_length, contents, size, opt_false()) :
+				convert_buffer_utf32(out_buffer, out_length, contents, size, opt_true());
+		}
+
+		// source encoding is latin1
+		if (encoding == encoding_latin1) return convert_buffer_latin1(out_buffer, out_length, contents, size, is_mutable);
+
+		assert(!"Invalid encoding");
+		return false;
+	}
+#endif
+
+	PUGI__FN size_t as_utf8_begin(const wchar_t* str, size_t length)
+	{
+		// get length in utf8 characters
+		return utf_decoder<utf8_counter>::decode_wchar_block(str, length, 0);
+	}
+
+	PUGI__FN void as_utf8_end(char* buffer, size_t size, const wchar_t* str, size_t length)
+	{
+		// convert to utf8
+		uint8_t* begin = reinterpret_cast<uint8_t*>(buffer);
+		uint8_t* end = utf_decoder<utf8_writer>::decode_wchar_block(str, length, begin);
+	
+		assert(begin + size == end);
+		(void)!end;
+
+		// zero-terminate
+		buffer[size] = 0;
+	}
+	
+#ifndef PUGIXML_NO_STL
+	PUGI__FN std::string as_utf8_impl(const wchar_t* str, size_t length)
+	{
+		// first pass: get length in utf8 characters
+		size_t size = as_utf8_begin(str, length);
+
+		// allocate resulting string
+		std::string result;
+		result.resize(size);
+
+		// second pass: convert to utf8
+		if (size > 0) as_utf8_end(&result[0], size, str, length);
+
+		return result;
+	}
+
+	PUGI__FN std::basic_string<wchar_t> as_wide_impl(const char* str, size_t size)
+	{
+		const uint8_t* data = reinterpret_cast<const uint8_t*>(str);
+
+		// first pass: get length in wchar_t units
+		size_t length = utf_decoder<wchar_counter>::decode_utf8_block(data, size, 0);
+
+		// allocate resulting string
+		std::basic_string<wchar_t> result;
+		result.resize(length);
+
+		// second pass: convert to wchar_t
+		if (length > 0)
+		{
+			wchar_writer::value_type begin = reinterpret_cast<wchar_writer::value_type>(&result[0]);
+			wchar_writer::value_type end = utf_decoder<wchar_writer>::decode_utf8_block(data, size, begin);
+
+			assert(begin + length == end);
+			(void)!end;
+		}
+
+		return result;
+	}
+#endif
+
+	inline bool strcpy_insitu_allow(size_t length, uintptr_t allocated, char_t* target)
+	{
+		assert(target);
+		size_t target_length = strlength(target);
+
+		// always reuse document buffer memory if possible
+		if (!allocated) return target_length >= length;
+
+		// reuse heap memory if waste is not too great
+		const size_t reuse_threshold = 32;
+
+		return target_length >= length && (target_length < reuse_threshold || target_length - length < target_length / 2);
+	}
+
+	PUGI__FN bool strcpy_insitu(char_t*& dest, uintptr_t& header, uintptr_t header_mask, const char_t* source)
+	{
+		size_t source_length = strlength(source);
+
+		if (source_length == 0)
+		{
+			// empty string and null pointer are equivalent, so just deallocate old memory
+			xml_allocator* alloc = reinterpret_cast<xml_memory_page*>(header & xml_memory_page_pointer_mask)->allocator;
+
+			if (header & header_mask) alloc->deallocate_string(dest);
+			
+			// mark the string as not allocated
+			dest = 0;
+			header &= ~header_mask;
+
+			return true;
+		}
+		else if (dest && strcpy_insitu_allow(source_length, header & header_mask, dest))
+		{
+			// we can reuse old buffer, so just copy the new data (including zero terminator)
+			memcpy(dest, source, (source_length + 1) * sizeof(char_t));
+			
+			return true;
+		}
+		else
+		{
+			xml_allocator* alloc = reinterpret_cast<xml_memory_page*>(header & xml_memory_page_pointer_mask)->allocator;
+
+			// allocate new buffer
+			char_t* buf = alloc->allocate_string(source_length + 1);
+			if (!buf) return false;
+
+			// copy the string (including zero terminator)
+			memcpy(buf, source, (source_length + 1) * sizeof(char_t));
+
+			// deallocate old buffer (*after* the above to protect against overlapping memory and/or allocation failures)
+			if (header & header_mask) alloc->deallocate_string(dest);
+			
+			// the string is now allocated, so set the flag
+			dest = buf;
+			header |= header_mask;
+
+			return true;
+		}
+	}
+
+	struct gap
+	{
+		char_t* 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_t*& s, size_t count)
+		{
+			if (end) // there was a gap already; collapse it
+			{
+				// Move [old_gap_end, new_gap_start) to [old_gap_start, ...)
+				assert(s >= end);
+				memmove(end - size, end, reinterpret_cast<char*>(s) - reinterpret_cast<char*>(end));
+			}
+				
+			s += count; // end of current gap
+				
+			// "merge" two gaps
+			end = s;
+			size += count;
+		}
+			
+		// Collapse all gaps, return past-the-end pointer
+		char_t* flush(char_t* s)
+		{
+			if (end)
+			{
+				// Move [old_gap_end, current_pos) to [old_gap_start, ...)
+				assert(s >= end);
+				memmove(end - size, end, reinterpret_cast<char*>(s) - reinterpret_cast<char*>(end));
+
+				return s - size;
+			}
+			else return s;
+		}
+	};
+	
+	PUGI__FN char_t* strconv_escape(char_t* s, gap& g)
+	{
+		char_t* stre = s + 1;
+
+		switch (*stre)
+		{
+			case '#':	// &#...
+			{
+				unsigned int ucsc = 0;
+
+				if (stre[1] == 'x') // &#x... (hex code)
+				{
+					stre += 2;
+
+					char_t ch = *stre;
+
+					if (ch == ';') return stre;
+
+					for (;;)
+					{
+						if (static_cast<unsigned int>(ch - '0') <= 9)
+							ucsc = 16 * ucsc + (ch - '0');
+						else if (static_cast<unsigned int>((ch | ' ') - 'a') <= 5)
+							ucsc = 16 * ucsc + ((ch | ' ') - 'a' + 10);
+						else if (ch == ';')
+							break;
+						else // cancel
+							return stre;
+
+						ch = *++stre;
+					}
+					
+					++stre;
+				}
+				else	// &#... (dec code)
+				{
+					char_t ch = *++stre;
+
+					if (ch == ';') return stre;
+
+					for (;;)
+					{
+						if (static_cast<unsigned int>(ch - '0') <= 9)
+							ucsc = 10 * ucsc + (ch - '0');
+						else if (ch == ';')
+							break;
+						else // cancel
+							return stre;
+
+						ch = *++stre;
+					}
+					
+					++stre;
+				}
+
+			#ifdef PUGIXML_WCHAR_MODE
+				s = reinterpret_cast<char_t*>(wchar_writer::any(reinterpret_cast<wchar_writer::value_type>(s), ucsc));
+			#else
+				s = reinterpret_cast<char_t*>(utf8_writer::any(reinterpret_cast<uint8_t*>(s), ucsc));
+			#endif
+					
+				g.push(s, stre - s);
+				return stre;
+			}
+
+			case 'a':	// &a
+			{
+				++stre;
+
+				if (*stre == 'm') // &am
+				{
+					if (*++stre == 'p' && *++stre == ';') // &amp;
+					{
+						*s++ = '&';
+						++stre;
+							
+						g.push(s, stre - s);
+						return stre;
+					}
+				}
+				else if (*stre == 'p') // &ap
+				{
+					if (*++stre == 'o' && *++stre == 's' && *++stre == ';') // &apos;
+					{
+						*s++ = '\'';
+						++stre;
+
+						g.push(s, stre - s);
+						return stre;
+					}
+				}
+				break;
+			}
+
+			case 'g': // &g
+			{
+				if (*++stre == 't' && *++stre == ';') // &gt;
+				{
+					*s++ = '>';
+					++stre;
+					
+					g.push(s, stre - s);
+					return stre;
+				}
+				break;
+			}
+
+			case 'l': // &l
+			{
+				if (*++stre == 't' && *++stre == ';') // &lt;
+				{
+					*s++ = '<';
+					++stre;
+						
+					g.push(s, stre - s);
+					return stre;
+				}
+				break;
+			}
+
+			case 'q': // &q
+			{
+				if (*++stre == 'u' && *++stre == 'o' && *++stre == 't' && *++stre == ';') // &quot;
+				{
+					*s++ = '"';
+					++stre;
+					
+					g.push(s, stre - s);
+					return stre;
+				}
+				break;
+			}
+
+			default:
+				break;
+		}
+		
+		return stre;
+	}
+
+	// Utility macro for last character handling
+	#define ENDSWITH(c, e) ((c) == (e) || ((c) == 0 && endch == (e)))
+
+	PUGI__FN char_t* strconv_comment(char_t* s, char_t endch)
+	{
+		gap g;
+		
+		while (true)
+		{
+			while (!PUGI__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[0] == '-' && s[1] == '-' && ENDSWITH(s[2], '>')) // comment ends here
+			{
+				*g.flush(s) = 0;
+				
+				return s + (s[2] == '>' ? 3 : 2);
+			}
+			else if (*s == 0)
+			{
+				return 0;
+			}
+			else ++s;
+		}
+	}
+
+	PUGI__FN char_t* strconv_cdata(char_t* s, char_t endch)
+	{
+		gap g;
+			
+		while (true)
+		{
+			while (!PUGI__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[0] == ']' && s[1] == ']' && ENDSWITH(s[2], '>')) // CDATA ends here
+			{
+				*g.flush(s) = 0;
+				
+				return s + 1;
+			}
+			else if (*s == 0)
+			{
+				return 0;
+			}
+			else ++s;
+		}
+	}
+	
+	typedef char_t* (*strconv_pcdata_t)(char_t*);
+		
+	template <typename opt_eol, typename opt_escape> struct strconv_pcdata_impl
+	{
+		static char_t* parse(char_t* s)
+		{
+			gap g;
+			
+			while (true)
+			{
+				while (!PUGI__IS_CHARTYPE(*s, ct_parse_pcdata)) ++s;
+					
+				if (*s == '<') // PCDATA ends here
+				{
+					*g.flush(s) = 0;
+					
+					return s + 1;
+				}
+				else if (opt_eol::value && *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::value && *s == '&')
+				{
+					s = strconv_escape(s, g);
+				}
+				else if (*s == 0)
+				{
+					return s;
+				}
+				else ++s;
+			}
+		}
+	};
+	
+	PUGI__FN strconv_pcdata_t get_strconv_pcdata(unsigned int optmask)
+	{
+		PUGI__STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20);
+
+		switch ((optmask >> 4) & 3) // get bitmask for flags (eol escapes)
+		{
+		case 0: return strconv_pcdata_impl<opt_false, opt_false>::parse;
+		case 1: return strconv_pcdata_impl<opt_false, opt_true>::parse;
+		case 2: return strconv_pcdata_impl<opt_true, opt_false>::parse;
+		case 3: return strconv_pcdata_impl<opt_true, opt_true>::parse;
+		default: return 0; // should not get here
+		}
+	}
+
+	typedef char_t* (*strconv_attribute_t)(char_t*, char_t);
+	
+	template <typename opt_escape> struct strconv_attribute_impl
+	{
+		static char_t* parse_wnorm(char_t* s, char_t end_quote)
+		{
+			gap g;
+
+			// trim leading whitespaces
+			if (PUGI__IS_CHARTYPE(*s, ct_space))
+			{
+				char_t* str = s;
+				
+				do ++str;
+				while (PUGI__IS_CHARTYPE(*str, ct_space));
+				
+				g.push(s, str - s);
+			}
+
+			while (true)
+			{
+				while (!PUGI__IS_CHARTYPE(*s, ct_parse_attr_ws | ct_space)) ++s;
+				
+				if (*s == end_quote)
+				{
+					char_t* str = g.flush(s);
+					
+					do *str-- = 0;
+					while (PUGI__IS_CHARTYPE(*str, ct_space));
+				
+					return s + 1;
+				}
+				else if (PUGI__IS_CHARTYPE(*s, ct_space))
+				{
+					*s++ = ' ';
+		
+					if (PUGI__IS_CHARTYPE(*s, ct_space))
+					{
+						char_t* str = s + 1;
+						while (PUGI__IS_CHARTYPE(*str, ct_space)) ++str;
+						
+						g.push(s, str - s);
+					}
+				}
+				else if (opt_escape::value && *s == '&')
+				{
+					s = strconv_escape(s, g);
+				}
+				else if (!*s)
+				{
+					return 0;
+				}
+				else ++s;
+			}
+		}
+
+		static char_t* parse_wconv(char_t* s, char_t end_quote)
+		{
+			gap g;
+
+			while (true)
+			{
+				while (!PUGI__IS_CHARTYPE(*s, ct_parse_attr_ws)) ++s;
+				
+				if (*s == end_quote)
+				{
+					*g.flush(s) = 0;
+				
+					return s + 1;
+				}
+				else if (PUGI__IS_CHARTYPE(*s, ct_space))
+				{
+					if (*s == '\r')
+					{
+						*s++ = ' ';
+				
+						if (*s == '\n') g.push(s, 1);
+					}
+					else *s++ = ' ';
+				}
+				else if (opt_escape::value && *s == '&')
+				{
+					s = strconv_escape(s, g);
+				}
+				else if (!*s)
+				{
+					return 0;
+				}
+				else ++s;
+			}
+		}
+
+		static char_t* parse_eol(char_t* s, char_t end_quote)
+		{
+			gap g;
+
+			while (true)
+			{
+				while (!PUGI__IS_CHARTYPE(*s, ct_parse_attr)) ++s;
+				
+				if (*s == end_quote)
+				{
+					*g.flush(s) = 0;
+				
+					return s + 1;
+				}
+				else if (*s == '\r')
+				{
+					*s++ = '\n';
+					
+					if (*s == '\n') g.push(s, 1);
+				}
+				else if (opt_escape::value && *s == '&')
+				{
+					s = strconv_escape(s, g);
+				}
+				else if (!*s)
+				{
+					return 0;
+				}
+				else ++s;
+			}
+		}
+
+		static char_t* parse_simple(char_t* s, char_t end_quote)
+		{
+			gap g;
+
+			while (true)
+			{
+				while (!PUGI__IS_CHARTYPE(*s, ct_parse_attr)) ++s;
+				
+				if (*s == end_quote)
+				{
+					*g.flush(s) = 0;
+				
+					return s + 1;
+				}
+				else if (opt_escape::value && *s == '&')
+				{
+					s = strconv_escape(s, g);
+				}
+				else if (!*s)
+				{
+					return 0;
+				}
+				else ++s;
+			}
+		}
+	};
+
+	PUGI__FN strconv_attribute_t get_strconv_attribute(unsigned int optmask)
+	{
+		PUGI__STATIC_ASSERT(parse_escapes == 0x10 && parse_eol == 0x20 && parse_wconv_attribute == 0x40 && parse_wnorm_attribute == 0x80);
+		
+		switch ((optmask >> 4) & 15) // get bitmask for flags (wconv wnorm eol escapes)
+		{
+		case 0:  return strconv_attribute_impl<opt_false>::parse_simple;
+		case 1:  return strconv_attribute_impl<opt_true>::parse_simple;
+		case 2:  return strconv_attribute_impl<opt_false>::parse_eol;
+		case 3:  return strconv_attribute_impl<opt_true>::parse_eol;
+		case 4:  return strconv_attribute_impl<opt_false>::parse_wconv;
+		case 5:  return strconv_attribute_impl<opt_true>::parse_wconv;
+		case 6:  return strconv_attribute_impl<opt_false>::parse_wconv;
+		case 7:  return strconv_attribute_impl<opt_true>::parse_wconv;
+		case 8:  return strconv_attribute_impl<opt_false>::parse_wnorm;
+		case 9:  return strconv_attribute_impl<opt_true>::parse_wnorm;
+		case 10: return strconv_attribute_impl<opt_false>::parse_wnorm;
+		case 11: return strconv_attribute_impl<opt_true>::parse_wnorm;
+		case 12: return strconv_attribute_impl<opt_false>::parse_wnorm;
+		case 13: return strconv_attribute_impl<opt_true>::parse_wnorm;
+		case 14: return strconv_attribute_impl<opt_false>::parse_wnorm;
+		case 15: return strconv_attribute_impl<opt_true>::parse_wnorm;
+		default: return 0; // should not get here
+		}
+	}
+
+	inline xml_parse_result make_parse_result(xml_parse_status status, ptrdiff_t offset = 0)
+	{
+		xml_parse_result result;
+		result.status = status;
+		result.offset = offset;
+
+		return result;
+	}
+
+	struct xml_parser
+	{
+		xml_allocator alloc;
+		char_t* error_offset;
+		xml_parse_status error_status;
+		
+		// Parser utilities.
+		#define PUGI__SKIPWS()			{ while (PUGI__IS_CHARTYPE(*s, ct_space)) ++s; }
+		#define PUGI__OPTSET(OPT)			( optmsk & (OPT) )
+		#define PUGI__PUSHNODE(TYPE)		{ cursor = append_node(cursor, alloc, TYPE); if (!cursor) PUGI__THROW_ERROR(status_out_of_memory, s); }
+		#define PUGI__POPNODE()			{ cursor = cursor->parent; }
+		#define PUGI__SCANFOR(X)			{ while (*s != 0 && !(X)) ++s; }
+		#define PUGI__SCANWHILE(X)		{ while ((X)) ++s; }
+		#define PUGI__ENDSEG()			{ ch = *s; *s = 0; ++s; }
+		#define PUGI__THROW_ERROR(err, m)	return error_offset = m, error_status = err, static_cast<char_t*>(0)
+		#define PUGI__CHECK_ERROR(err, m)	{ if (*s == 0) PUGI__THROW_ERROR(err, m); }
+		
+		xml_parser(const xml_allocator& alloc_): alloc(alloc_), error_offset(0), error_status(status_ok)
+		{
+		}
+
+		// DOCTYPE consists of nested sections of the following possible types:
+		// <!-- ... -->, <? ... ?>, "...", '...'
+		// <![...]]>
+		// <!...>
+		// First group can not contain nested groups
+		// Second group can contain nested groups of the same type
+		// Third group can contain all other groups
+		char_t* parse_doctype_primitive(char_t* s)
+		{
+			if (*s == '"' || *s == '\'')
+			{
+				// quoted string
+				char_t ch = *s++;
+				PUGI__SCANFOR(*s == ch);
+				if (!*s) PUGI__THROW_ERROR(status_bad_doctype, s);
+
+				s++;
+			}
+			else if (s[0] == '<' && s[1] == '?')
+			{
+				// <? ... ?>
+				s += 2;
+				PUGI__SCANFOR(s[0] == '?' && s[1] == '>'); // no need for ENDSWITH because ?> can't terminate proper doctype
+				if (!*s) PUGI__THROW_ERROR(status_bad_doctype, s);
+
+				s += 2;
+			}
+			else if (s[0] == '<' && s[1] == '!' && s[2] == '-' && s[3] == '-')
+			{
+				s += 4;
+				PUGI__SCANFOR(s[0] == '-' && s[1] == '-' && s[2] == '>'); // no need for ENDSWITH because --> can't terminate proper doctype
+				if (!*s) PUGI__THROW_ERROR(status_bad_doctype, s);
+
+				s += 4;
+			}
+			else PUGI__THROW_ERROR(status_bad_doctype, s);
+
+			return s;
+		}
+
+		char_t* parse_doctype_ignore(char_t* s)
+		{
+			assert(s[0] == '<' && s[1] == '!' && s[2] == '[');
+			s++;
+
+			while (*s)
+			{
+				if (s[0] == '<' && s[1] == '!' && s[2] == '[')
+				{
+					// nested ignore section
+					s = parse_doctype_ignore(s);
+					if (!s) return s;
+				}
+				else if (s[0] == ']' && s[1] == ']' && s[2] == '>')
+				{
+					// ignore section end
+					s += 3;
+
+					return s;
+				}
+				else s++;
+			}
+
+			PUGI__THROW_ERROR(status_bad_doctype, s);
+		}
+
+		char_t* parse_doctype_group(char_t* s, char_t endch, bool toplevel)
+		{
+			assert(s[0] == '<' && s[1] == '!');
+			s++;
+
+			while (*s)
+			{
+				if (s[0] == '<' && s[1] == '!' && s[2] != '-')
+				{
+					if (s[2] == '[')
+					{
+						// ignore
+						s = parse_doctype_ignore(s);
+						if (!s) return s;
+					}
+					else
+					{
+						// some control group
+						s = parse_doctype_group(s, endch, false);
+						if (!s) return s;
+					}
+				}
+				else if (s[0] == '<' || s[0] == '"' || s[0] == '\'')
+				{
+					// unknown tag (forbidden), or some primitive group
+					s = parse_doctype_primitive(s);
+					if (!s) return s;
+				}
+				else if (*s == '>')
+				{
+					s++;
+
+					return s;
+				}
+				else s++;
+			}
+
+			if (!toplevel || endch != '>') PUGI__THROW_ERROR(status_bad_doctype, s);
+
+			return s;
+		}
+
+		char_t* parse_exclamation(char_t* s, xml_node_struct* cursor, unsigned int optmsk, char_t endch)
+		{
+			// parse node contents, starting with exclamation mark
+			++s;
+
+			if (*s == '-') // '<!-...'
+			{
+				++s;
+
+				if (*s == '-') // '<!--...'
+				{
+					++s;
+
+					if (PUGI__OPTSET(parse_comments))
+					{
+						PUGI__PUSHNODE(node_comment); // Append a new node on the tree.
+						cursor->value = s; // Save the offset.
+					}
+
+					if (PUGI__OPTSET(parse_eol) && PUGI__OPTSET(parse_comments))
+					{
+						s = strconv_comment(s, endch);
+
+						if (!s) PUGI__THROW_ERROR(status_bad_comment, cursor->value);
+					}
+					else
+					{
+						// Scan for terminating '-->'.
+						PUGI__SCANFOR(s[0] == '-' && s[1] == '-' && ENDSWITH(s[2], '>'));
+						PUGI__CHECK_ERROR(status_bad_comment, s);
+
+						if (PUGI__OPTSET(parse_comments))
+							*s = 0; // Zero-terminate this segment at the first terminating '-'.
+
+						s += (s[2] == '>' ? 3 : 2); // Step over the '\0->'.
+					}
+				}
+				else PUGI__THROW_ERROR(status_bad_comment, s);
+			}
+			else if (*s == '[')
+			{
+				// '<![CDATA[...'
+				if (*++s=='C' && *++s=='D' && *++s=='A' && *++s=='T' && *++s=='A' && *++s == '[')
+				{
+					++s;
+
+					if (PUGI__OPTSET(parse_cdata))
+					{
+						PUGI__PUSHNODE(node_cdata); // Append a new node on the tree.
+						cursor->value = s; // Save the offset.
+
+						if (PUGI__OPTSET(parse_eol))
+						{
+							s = strconv_cdata(s, endch);
+
+							if (!s) PUGI__THROW_ERROR(status_bad_cdata, cursor->value);
+						}
+						else
+						{
+							// Scan for terminating ']]>'.
+							PUGI__SCANFOR(s[0] == ']' && s[1] == ']' && ENDSWITH(s[2], '>'));
+							PUGI__CHECK_ERROR(status_bad_cdata, s);
+
+							*s++ = 0; // Zero-terminate this segment.
+						}
+					}
+					else // Flagged for discard, but we still have to scan for the terminator.
+					{
+						// Scan for terminating ']]>'.
+						PUGI__SCANFOR(s[0] == ']' && s[1] == ']' && ENDSWITH(s[2], '>'));
+						PUGI__CHECK_ERROR(status_bad_cdata, s);
+
+						++s;
+					}
+
+					s += (s[1] == '>' ? 2 : 1); // Step over the last ']>'.
+				}
+				else PUGI__THROW_ERROR(status_bad_cdata, s);
+			}
+			else if (s[0] == 'D' && s[1] == 'O' && s[2] == 'C' && s[3] == 'T' && s[4] == 'Y' && s[5] == 'P' && ENDSWITH(s[6], 'E'))
+			{
+				s -= 2;
+
+				if (cursor->parent) PUGI__THROW_ERROR(status_bad_doctype, s);
+
+				char_t* mark = s + 9;
+
+				s = parse_doctype_group(s, endch, true);
+				if (!s) return s;
+
+				if (PUGI__OPTSET(parse_doctype))
+				{
+					while (PUGI__IS_CHARTYPE(*mark, ct_space)) ++mark;
+
+					PUGI__PUSHNODE(node_doctype);
+
+					cursor->value = mark;
+
+					assert((s[0] == 0 && endch == '>') || s[-1] == '>');
+					s[*s == 0 ? 0 : -1] = 0;
+
+					PUGI__POPNODE();
+				}
+			}
+			else if (*s == 0 && endch == '-') PUGI__THROW_ERROR(status_bad_comment, s);
+			else if (*s == 0 && endch == '[') PUGI__THROW_ERROR(status_bad_cdata, s);
+			else PUGI__THROW_ERROR(status_unrecognized_tag, s);
+
+			return s;
+		}
+
+		char_t* parse_question(char_t* s, xml_node_struct*& ref_cursor, unsigned int optmsk, char_t endch)
+		{
+			// load into registers
+			xml_node_struct* cursor = ref_cursor;
+			char_t ch = 0;
+
+			// parse node contents, starting with question mark
+			++s;
+
+			// read PI target
+			char_t* target = s;
+
+			if (!PUGI__IS_CHARTYPE(*s, ct_start_symbol)) PUGI__THROW_ERROR(status_bad_pi, s);
+
+			PUGI__SCANWHILE(PUGI__IS_CHARTYPE(*s, ct_symbol));
+			PUGI__CHECK_ERROR(status_bad_pi, s);
+
+			// determine node type; stricmp / strcasecmp is not portable
+			bool declaration = (target[0] | ' ') == 'x' && (target[1] | ' ') == 'm' && (target[2] | ' ') == 'l' && target + 3 == s;
+
+			if (declaration ? PUGI__OPTSET(parse_declaration) : PUGI__OPTSET(parse_pi))
+			{
+				if (declaration)
+				{
+					// disallow non top-level declarations
+					if (cursor->parent) PUGI__THROW_ERROR(status_bad_pi, s);
+
+					PUGI__PUSHNODE(node_declaration);
+				}
+				else
+				{
+					PUGI__PUSHNODE(node_pi);
+				}
+
+				cursor->name = target;
+
+				PUGI__ENDSEG();
+
+				// parse value/attributes
+				if (ch == '?')
+				{
+					// empty node
+					if (!ENDSWITH(*s, '>')) PUGI__THROW_ERROR(status_bad_pi, s);
+					s += (*s == '>');
+
+					PUGI__POPNODE();
+				}
+				else if (PUGI__IS_CHARTYPE(ch, ct_space))
+				{
+					PUGI__SKIPWS();
+
+					// scan for tag end
+					char_t* value = s;
+
+					PUGI__SCANFOR(s[0] == '?' && ENDSWITH(s[1], '>'));
+					PUGI__CHECK_ERROR(status_bad_pi, s);
+
+					if (declaration)
+					{
+						// replace ending ? with / so that 'element' terminates properly
+						*s = '/';
+
+						// we exit from this function with cursor at node_declaration, which is a signal to parse() to go to LOC_ATTRIBUTES
+						s = value;
+					}
+					else
+					{
+						// store value and step over >
+						cursor->value = value;
+						PUGI__POPNODE();
+
+						PUGI__ENDSEG();
+
+						s += (*s == '>');
+					}
+				}
+				else PUGI__THROW_ERROR(status_bad_pi, s);
+			}
+			else
+			{
+				// scan for tag end
+				PUGI__SCANFOR(s[0] == '?' && ENDSWITH(s[1], '>'));
+				PUGI__CHECK_ERROR(status_bad_pi, s);
+
+				s += (s[1] == '>' ? 2 : 1);
+			}
+
+			// store from registers
+			ref_cursor = cursor;
+
+			return s;
+		}
+
+		char_t* parse(char_t* s, xml_node_struct* xmldoc, unsigned int optmsk, char_t endch)
+		{
+			strconv_attribute_t strconv_attribute = get_strconv_attribute(optmsk);
+			strconv_pcdata_t strconv_pcdata = get_strconv_pcdata(optmsk);
+			
+			char_t ch = 0;
+			xml_node_struct* cursor = xmldoc;
+			char_t* mark = s;
+
+			while (*s != 0)
+			{
+				if (*s == '<')
+				{
+					++s;
+
+				LOC_TAG:
+					if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) // '<#...'
+					{
+						PUGI__PUSHNODE(node_element); // Append a new node to the tree.
+
+						cursor->name = s;
+
+						PUGI__SCANWHILE(PUGI__IS_CHARTYPE(*s, ct_symbol)); // Scan for a terminator.
+						PUGI__ENDSEG(); // Save char in 'ch', terminate & step over.
+
+						if (ch == '>')
+						{
+							// end of tag
+						}
+						else if (PUGI__IS_CHARTYPE(ch, ct_space))
+						{
+						LOC_ATTRIBUTES:
+							while (true)
+							{
+								PUGI__SKIPWS(); // Eat any whitespace.
+						
+								if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) // <... #...
+								{
+									xml_attribute_struct* a = append_attribute_ll(cursor, alloc); // Make space for this attribute.
+									if (!a) PUGI__THROW_ERROR(status_out_of_memory, s);
+
+									a->name = s; // Save the offset.
+
+									PUGI__SCANWHILE(PUGI__IS_CHARTYPE(*s, ct_symbol)); // Scan for a terminator.
+									PUGI__CHECK_ERROR(status_bad_attribute, s); //$ redundant, left for performance
+
+									PUGI__ENDSEG(); // Save char in 'ch', terminate & step over.
+									PUGI__CHECK_ERROR(status_bad_attribute, s); //$ redundant, left for performance
+
+									if (PUGI__IS_CHARTYPE(ch, ct_space))
+									{
+										PUGI__SKIPWS(); // Eat any whitespace.
+										PUGI__CHECK_ERROR(status_bad_attribute, s); //$ redundant, left for performance
+
+										ch = *s;
+										++s;
+									}
+									
+									if (ch == '=') // '<... #=...'
+									{
+										PUGI__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) PUGI__THROW_ERROR(status_bad_attribute, a->value);
+
+											// After this line the loop continues from the start;
+											// Whitespaces, / and > are ok, symbols and EOF are wrong,
+											// everything else will be detected
+											if (PUGI__IS_CHARTYPE(*s, ct_start_symbol)) PUGI__THROW_ERROR(status_bad_attribute, s);
+										}
+										else PUGI__THROW_ERROR(status_bad_attribute, s);
+									}
+									else PUGI__THROW_ERROR(status_bad_attribute, s);
+								}
+								else if (*s == '/')
+								{
+									++s;
+									
+									if (*s == '>')
+									{
+										PUGI__POPNODE();
+										s++;
+										break;
+									}
+									else if (*s == 0 && endch == '>')
+									{
+										PUGI__POPNODE();
+										break;
+									}
+									else PUGI__THROW_ERROR(status_bad_start_element, s);
+								}
+								else if (*s == '>')
+								{
+									++s;
+
+									break;
+								}
+								else if (*s == 0 && endch == '>')
+								{
+									break;
+								}
+								else PUGI__THROW_ERROR(status_bad_start_element, s);
+							}
+
+							// !!!
+						}
+						else if (ch == '/') // '<#.../'
+						{
+							if (!ENDSWITH(*s, '>')) PUGI__THROW_ERROR(status_bad_start_element, s);
+
+							PUGI__POPNODE(); // Pop.
+
+							s += (*s == '>');
+						}
+						else if (ch == 0)
+						{
+							// we stepped over null terminator, backtrack & handle closing tag
+							--s;
+							
+							if (endch != '>') PUGI__THROW_ERROR(status_bad_start_element, s);
+						}
+						else PUGI__THROW_ERROR(status_bad_start_element, s);
+					}
+					else if (*s == '/')
+					{
+						++s;
+
+						char_t* name = cursor->name;
+						if (!name) PUGI__THROW_ERROR(status_end_element_mismatch, s);
+						
+						while (PUGI__IS_CHARTYPE(*s, ct_symbol))
+						{
+							if (*s++ != *name++) PUGI__THROW_ERROR(status_end_element_mismatch, s);
+						}
+
+						if (*name)
+						{
+							if (*s == 0 && name[0] == endch && name[1] == 0) PUGI__THROW_ERROR(status_bad_end_element, s);
+							else PUGI__THROW_ERROR(status_end_element_mismatch, s);
+						}
+							
+						PUGI__POPNODE(); // Pop.
+
+						PUGI__SKIPWS();
+
+						if (*s == 0)
+						{
+							if (endch != '>') PUGI__THROW_ERROR(status_bad_end_element, s);
+						}
+						else
+						{
+							if (*s != '>') PUGI__THROW_ERROR(status_bad_end_element, s);
+							++s;
+						}
+					}
+					else if (*s == '?') // '<?...'
+					{
+						s = parse_question(s, cursor, optmsk, endch);
+						if (!s) return s;
+
+						assert(cursor);
+						if ((cursor->header & xml_memory_page_type_mask) + 1 == node_declaration) goto LOC_ATTRIBUTES;
+					}
+					else if (*s == '!') // '<!...'
+					{
+						s = parse_exclamation(s, cursor, optmsk, endch);
+						if (!s) return s;
+					}
+					else if (*s == 0 && endch == '?') PUGI__THROW_ERROR(status_bad_pi, s);
+					else PUGI__THROW_ERROR(status_unrecognized_tag, s);
+				}
+				else
+				{
+					mark = s; // Save this offset while searching for a terminator.
+
+					PUGI__SKIPWS(); // Eat whitespace if no genuine PCDATA here.
+
+					if (*s == '<')
+					{
+						// We skipped some whitespace characters because otherwise we would take the tag branch instead of PCDATA one
+						assert(mark != s);
+
+						if (!PUGI__OPTSET(parse_ws_pcdata | parse_ws_pcdata_single))
+						{
+							continue;
+						}
+						else if (PUGI__OPTSET(parse_ws_pcdata_single))
+						{
+							if (s[1] != '/' || cursor->first_child) continue;
+						}
+					}
+
+					s = mark;
+							
+					if (cursor->parent)
+					{
+						PUGI__PUSHNODE(node_pcdata); // Append a new node on the tree.
+						cursor->value = s; // Save the offset.
+
+						s = strconv_pcdata(s);
+								
+						PUGI__POPNODE(); // Pop since this is a standalone.
+						
+						if (!*s) break;
+					}
+					else
+					{
+						PUGI__SCANFOR(*s == '<'); // '...<'
+						if (!*s) break;
+						
+						++s;
+					}
+
+					// We're after '<'
+					goto LOC_TAG;
+				}
+			}
+
+			// check that last tag is closed
+			if (cursor != xmldoc) PUGI__THROW_ERROR(status_end_element_mismatch, s);
+
+			return s;
+		}
+
+		static xml_parse_result parse(char_t* buffer, size_t length, xml_node_struct* root, unsigned int optmsk)
+		{
+			xml_document_struct* xmldoc = static_cast<xml_document_struct*>(root);
+
+			// store buffer for offset_debug
+			xmldoc->buffer = buffer;
+
+			// early-out for empty documents
+			if (length == 0) return make_parse_result(status_ok);
+
+			// create parser on stack
+			xml_parser parser(*xmldoc);
+
+			// save last character and make buffer zero-terminated (speeds up parsing)
+			char_t endch = buffer[length - 1];
+			buffer[length - 1] = 0;
+			
+			// perform actual parsing
+			parser.parse(buffer, xmldoc, optmsk, endch);
+
+			xml_parse_result result = make_parse_result(parser.error_status, parser.error_offset ? parser.error_offset - buffer : 0);
+			assert(result.offset >= 0 && static_cast<size_t>(result.offset) <= length);
+
+			// update allocator state
+			*static_cast<xml_allocator*>(xmldoc) = parser.alloc;
+
+			// since we removed last character, we have to handle the only possible false positive
+			if (result && endch == '<')
+			{
+				// there's no possible well-formed document with < at the end
+				return make_parse_result(status_unrecognized_tag, length);
+			}
+
+			return result;
+		}
+	};
+
+	// Output facilities
+	PUGI__FN xml_encoding get_write_native_encoding()
+	{
+	#ifdef PUGIXML_WCHAR_MODE
+		return get_wchar_encoding();
+	#else
+		return encoding_utf8;
+	#endif
+	}
+
+	PUGI__FN xml_encoding get_write_encoding(xml_encoding encoding)
+	{
+		// replace wchar encoding with utf implementation
+		if (encoding == encoding_wchar) return get_wchar_encoding();
+
+		// replace utf16 encoding with utf16 with specific endianness
+		if (encoding == encoding_utf16) return is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+
+		// replace utf32 encoding with utf32 with specific endianness
+		if (encoding == encoding_utf32) return is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+
+		// only do autodetection if no explicit encoding is requested
+		if (encoding != encoding_auto) return encoding;
+
+		// assume utf8 encoding
+		return encoding_utf8;
+	}
+
+#ifdef PUGIXML_WCHAR_MODE
+	PUGI__FN size_t get_valid_length(const char_t* data, size_t length)
+	{
+		assert(length > 0);
+
+		// discard last character if it's the lead of a surrogate pair 
+		return (sizeof(wchar_t) == 2 && static_cast<unsigned int>(static_cast<uint16_t>(data[length - 1]) - 0xD800) < 0x400) ? length - 1 : length;
+	}
+
+	PUGI__FN size_t convert_buffer(char_t* r_char, uint8_t* r_u8, uint16_t* r_u16, uint32_t* r_u32, const char_t* data, size_t length, xml_encoding encoding)
+	{
+		// only endian-swapping is required
+		if (need_endian_swap_utf(encoding, get_wchar_encoding()))
+		{
+			convert_wchar_endian_swap(r_char, data, length);
+
+			return length * sizeof(char_t);
+		}
+	
+		// convert to utf8
+		if (encoding == encoding_utf8)
+		{
+			uint8_t* dest = r_u8;
+			uint8_t* end = utf_decoder<utf8_writer>::decode_wchar_block(data, length, dest);
+
+			return static_cast<size_t>(end - dest);
+		}
+
+		// convert to utf16
+		if (encoding == encoding_utf16_be || encoding == encoding_utf16_le)
+		{
+			uint16_t* dest = r_u16;
+
+			// convert to native utf16
+			uint16_t* end = utf_decoder<utf16_writer>::decode_wchar_block(data, length, dest);
+
+			// swap if necessary
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+
+			if (native_encoding != encoding) convert_utf_endian_swap(dest, dest, static_cast<size_t>(end - dest));
+
+			return static_cast<size_t>(end - dest) * sizeof(uint16_t);
+		}
+
+		// convert to utf32
+		if (encoding == encoding_utf32_be || encoding == encoding_utf32_le)
+		{
+			uint32_t* dest = r_u32;
+
+			// convert to native utf32
+			uint32_t* end = utf_decoder<utf32_writer>::decode_wchar_block(data, length, dest);
+
+			// swap if necessary
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+
+			if (native_encoding != encoding) convert_utf_endian_swap(dest, dest, static_cast<size_t>(end - dest));
+
+			return static_cast<size_t>(end - dest) * sizeof(uint32_t);
+		}
+
+		// convert to latin1
+		if (encoding == encoding_latin1)
+		{
+			uint8_t* dest = r_u8;
+			uint8_t* end = utf_decoder<latin1_writer>::decode_wchar_block(data, length, dest);
+
+			return static_cast<size_t>(end - dest);
+		}
+
+		assert(!"Invalid encoding");
+		return 0;
+	}
+#else
+	PUGI__FN size_t get_valid_length(const char_t* data, size_t length)
+	{
+		assert(length > 4);
+
+		for (size_t i = 1; i <= 4; ++i)
+		{
+			uint8_t ch = static_cast<uint8_t>(data[length - i]);
+
+			// either a standalone character or a leading one
+			if ((ch & 0xc0) != 0x80) return length - i;
+		}
+
+		// there are four non-leading characters at the end, sequence tail is broken so might as well process the whole chunk
+		return length;
+	}
+
+	PUGI__FN size_t convert_buffer(char_t* /* r_char */, uint8_t* r_u8, uint16_t* r_u16, uint32_t* r_u32, const char_t* data, size_t length, xml_encoding encoding)
+	{
+		if (encoding == encoding_utf16_be || encoding == encoding_utf16_le)
+		{
+			uint16_t* dest = r_u16;
+
+			// convert to native utf16
+			uint16_t* end = utf_decoder<utf16_writer>::decode_utf8_block(reinterpret_cast<const uint8_t*>(data), length, dest);
+
+			// swap if necessary
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf16_le : encoding_utf16_be;
+
+			if (native_encoding != encoding) convert_utf_endian_swap(dest, dest, static_cast<size_t>(end - dest));
+
+			return static_cast<size_t>(end - dest) * sizeof(uint16_t);
+		}
+
+		if (encoding == encoding_utf32_be || encoding == encoding_utf32_le)
+		{
+			uint32_t* dest = r_u32;
+
+			// convert to native utf32
+			uint32_t* end = utf_decoder<utf32_writer>::decode_utf8_block(reinterpret_cast<const uint8_t*>(data), length, dest);
+
+			// swap if necessary
+			xml_encoding native_encoding = is_little_endian() ? encoding_utf32_le : encoding_utf32_be;
+
+			if (native_encoding != encoding) convert_utf_endian_swap(dest, dest, static_cast<size_t>(end - dest));
+
+			return static_cast<size_t>(end - dest) * sizeof(uint32_t);
+		}
+
+		if (encoding == encoding_latin1)
+		{
+			uint8_t* dest = r_u8;
+			uint8_t* end = utf_decoder<latin1_writer>::decode_utf8_block(reinterpret_cast<const uint8_t*>(data), length, dest);
+
+			return static_cast<size_t>(end - dest);
+		}
+
+		assert(!"Invalid encoding");
+		return 0;
+	}
+#endif
+
+	class xml_buffered_writer
+	{
+		xml_buffered_writer(const xml_buffered_writer&);
+		xml_buffered_writer& operator=(const xml_buffered_writer&);
+
+	public:
+		xml_buffered_writer(xml_writer& writer_, xml_encoding user_encoding): writer(writer_), bufsize(0), encoding(get_write_encoding(user_encoding))
+		{
+			PUGI__STATIC_ASSERT(bufcapacity >= 8);
+		}
+
+		~xml_buffered_writer()
+		{
+			flush();
+		}
+
+		void flush()
+		{
+			flush(buffer, bufsize);
+			bufsize = 0;
+		}
+
+		void flush(const char_t* data, size_t size)
+		{
+			if (size == 0) return;
+
+			// fast path, just write data
+			if (encoding == get_write_native_encoding())
+				writer.write(data, size * sizeof(char_t));
+			else
+			{
+				// convert chunk
+				size_t result = convert_buffer(scratch.data_char, scratch.data_u8, scratch.data_u16, scratch.data_u32, data, size, encoding);
+				assert(result <= sizeof(scratch));
+
+				// write data
+				writer.write(scratch.data_u8, result);
+			}
+		}
+
+		void write(const char_t* data, size_t length)
+		{
+			if (bufsize + length > bufcapacity)
+			{
+				// flush the remaining buffer contents
+				flush();
+
+				// handle large chunks
+				if (length > bufcapacity)
+				{
+					if (encoding == get_write_native_encoding())
+					{
+						// fast path, can just write data chunk
+						writer.write(data, length * sizeof(char_t));
+						return;
+					}
+
+					// need to convert in suitable chunks
+					while (length > bufcapacity)
+					{
+						// get chunk size by selecting such number of characters that are guaranteed to fit into scratch buffer
+						// and form a complete codepoint sequence (i.e. discard start of last codepoint if necessary)
+						size_t chunk_size = get_valid_length(data, bufcapacity);
+
+						// convert chunk and write
+						flush(data, chunk_size);
+
+						// iterate
+						data += chunk_size;
+						length -= chunk_size;
+					}
+
+					// small tail is copied below
+					bufsize = 0;
+				}
+			}
+
+			memcpy(buffer + bufsize, data, length * sizeof(char_t));
+			bufsize += length;
+		}
+
+		void write(const char_t* data)
+		{
+			write(data, strlength(data));
+		}
+
+		void write(char_t d0)
+		{
+			if (bufsize + 1 > bufcapacity) flush();
+
+			buffer[bufsize + 0] = d0;
+			bufsize += 1;
+		}
+
+		void write(char_t d0, char_t d1)
+		{
+			if (bufsize + 2 > bufcapacity) flush();
+
+			buffer[bufsize + 0] = d0;
+			buffer[bufsize + 1] = d1;
+			bufsize += 2;
+		}
+
+		void write(char_t d0, char_t d1, char_t d2)
+		{
+			if (bufsize + 3 > bufcapacity) flush();
+
+			buffer[bufsize + 0] = d0;
+			buffer[bufsize + 1] = d1;
+			buffer[bufsize + 2] = d2;
+			bufsize += 3;
+		}
+
+		void write(char_t d0, char_t d1, char_t d2, char_t d3)
+		{
+			if (bufsize + 4 > bufcapacity) flush();
+
+			buffer[bufsize + 0] = d0;
+			buffer[bufsize + 1] = d1;
+			buffer[bufsize + 2] = d2;
+			buffer[bufsize + 3] = d3;
+			bufsize += 4;
+		}
+
+		void write(char_t d0, char_t d1, char_t d2, char_t d3, char_t d4)
+		{
+			if (bufsize + 5 > bufcapacity) flush();
+
+			buffer[bufsize + 0] = d0;
+			buffer[bufsize + 1] = d1;
+			buffer[bufsize + 2] = d2;
+			buffer[bufsize + 3] = d3;
+			buffer[bufsize + 4] = d4;
+			bufsize += 5;
+		}
+
+		void write(char_t d0, char_t d1, char_t d2, char_t d3, char_t d4, char_t d5)
+		{
+			if (bufsize + 6 > bufcapacity) flush();
+
+			buffer[bufsize + 0] = d0;
+			buffer[bufsize + 1] = d1;
+			buffer[bufsize + 2] = d2;
+			buffer[bufsize + 3] = d3;
+			buffer[bufsize + 4] = d4;
+			buffer[bufsize + 5] = d5;
+			bufsize += 6;
+		}
+
+		// utf8 maximum expansion: x4 (-> utf32)
+		// utf16 maximum expansion: x2 (-> utf32)
+		// utf32 maximum expansion: x1
+		enum
+		{
+			bufcapacitybytes =
+			#ifdef PUGIXML_MEMORY_OUTPUT_STACK
+				PUGIXML_MEMORY_OUTPUT_STACK
+			#else
+				10240
+			#endif
+			,
+			bufcapacity = bufcapacitybytes / (sizeof(char_t) + 4)
+		};
+
+		char_t buffer[bufcapacity];
+
+		union
+		{
+			uint8_t data_u8[4 * bufcapacity];
+			uint16_t data_u16[2 * bufcapacity];
+			uint32_t data_u32[bufcapacity];
+			char_t data_char[bufcapacity];
+		} scratch;
+
+		xml_writer& writer;
+		size_t bufsize;
+		xml_encoding encoding;
+	};
+
+	PUGI__FN void text_output_escaped(xml_buffered_writer& writer, const char_t* s, chartypex_t type)
+	{
+		while (*s)
+		{
+			const char_t* prev = s;
+			
+			// While *s is a usual symbol
+			while (!PUGI__IS_CHARTYPEX(*s, type)) ++s;
+		
+			writer.write(prev, static_cast<size_t>(s - prev));
+
+			switch (*s)
+			{
+				case 0: break;
+				case '&':
+					writer.write('&', 'a', 'm', 'p', ';');
+					++s;
+					break;
+				case '<':
+					writer.write('&', 'l', 't', ';');
+					++s;
+					break;
+				case '>':
+					writer.write('&', 'g', 't', ';');
+					++s;
+					break;
+				case '"':
+					writer.write('&', 'q', 'u', 'o', 't', ';');
+					++s;
+					break;
+				default: // s is not a usual symbol
+				{
+					unsigned int ch = static_cast<unsigned int>(*s++);
+					assert(ch < 32);
+
+					writer.write('&', '#', static_cast<char_t>((ch / 10) + '0'), static_cast<char_t>((ch % 10) + '0'), ';');
+				}
+			}
+		}
+	}
+
+	PUGI__FN void text_output(xml_buffered_writer& writer, const char_t* s, chartypex_t type, unsigned int flags)
+	{
+		if (flags & format_no_escapes)
+			writer.write(s);
+		else
+			text_output_escaped(writer, s, type);
+	}
+
+	PUGI__FN void text_output_cdata(xml_buffered_writer& writer, const char_t* s)
+	{
+		do
+		{
+			writer.write('<', '!', '[', 'C', 'D');
+			writer.write('A', 'T', 'A', '[');
+
+			const char_t* prev = s;
+
+			// look for ]]> sequence - we can't output it as is since it terminates CDATA
+			while (*s && !(s[0] == ']' && s[1] == ']' && s[2] == '>')) ++s;
+
+			// skip ]] if we stopped at ]]>, > will go to the next CDATA section
+			if (*s) s += 2;
+
+			writer.write(prev, static_cast<size_t>(s - prev));
+
+			writer.write(']', ']', '>');
+		}
+		while (*s);
+	}
+
+	PUGI__FN void node_output_attributes(xml_buffered_writer& writer, const xml_node& node, unsigned int flags)
+	{
+		const char_t* default_name = PUGIXML_TEXT(":anonymous");
+
+		for (xml_attribute a = node.first_attribute(); a; a = a.next_attribute())
+		{
+			writer.write(' ');
+			writer.write(a.name()[0] ? a.name() : default_name);
+			writer.write('=', '"');
+
+			text_output(writer, a.value(), ctx_special_attr, flags);
+
+			writer.write('"');
+		}
+	}
+
+	PUGI__FN void node_output(xml_buffered_writer& writer, const xml_node& node, const char_t* indent, unsigned int flags, unsigned int depth)
+	{
+		const char_t* default_name = PUGIXML_TEXT(":anonymous");
+
+		if ((flags & format_indent) != 0 && (flags & format_raw) == 0)
+			for (unsigned int i = 0; i < depth; ++i) writer.write(indent);
+
+		switch (node.type())
+		{
+		case node_document:
+		{
+			for (xml_node n = node.first_child(); n; n = n.next_sibling())
+				node_output(writer, n, indent, flags, depth);
+			break;
+		}
+			
+		case node_element:
+		{
+			const char_t* name = node.name()[0] ? node.name() : default_name;
+
+			writer.write('<');
+			writer.write(name);
+
+			node_output_attributes(writer, node, flags);
+
+			if (flags & format_raw)
+			{
+				if (!node.first_child())
+					writer.write(' ', '/', '>');
+				else
+				{
+					writer.write('>');
+
+					for (xml_node n = node.first_child(); n; n = n.next_sibling())
+						node_output(writer, n, indent, flags, depth + 1);
+
+					writer.write('<', '/');
+					writer.write(name);
+					writer.write('>');
+				}
+			}
+			else if (!node.first_child())
+				writer.write(' ', '/', '>', '\n');
+			else if (node.first_child() == node.last_child() && (node.first_child().type() == node_pcdata || node.first_child().type() == node_cdata))
+			{
+				writer.write('>');
+
+				if (node.first_child().type() == node_pcdata)
+					text_output(writer, node.first_child().value(), ctx_special_pcdata, flags);
+				else
+					text_output_cdata(writer, node.first_child().value());
+
+				writer.write('<', '/');
+				writer.write(name);
+				writer.write('>', '\n');
+			}
+			else
+			{
+				writer.write('>', '\n');
+				
+				for (xml_node n = node.first_child(); n; n = n.next_sibling())
+					node_output(writer, n, indent, flags, depth + 1);
+
+				if ((flags & format_indent) != 0 && (flags & format_raw) == 0)
+					for (unsigned int i = 0; i < depth; ++i) writer.write(indent);
+				
+				writer.write('<', '/');
+				writer.write(name);
+				writer.write('>', '\n');
+			}
+
+			break;
+		}
+		
+		case node_pcdata:
+			text_output(writer, node.value(), ctx_special_pcdata, flags);
+			if ((flags & format_raw) == 0) writer.write('\n');
+			break;
+
+		case node_cdata:
+			text_output_cdata(writer, node.value());
+			if ((flags & format_raw) == 0) writer.write('\n');
+			break;
+
+		case node_comment:
+			writer.write('<', '!', '-', '-');
+			writer.write(node.value());
+			writer.write('-', '-', '>');
+			if ((flags & format_raw) == 0) writer.write('\n');
+			break;
+
+		case node_pi:
+		case node_declaration:
+			writer.write('<', '?');
+			writer.write(node.name()[0] ? node.name() : default_name);
+
+			if (node.type() == node_declaration)
+			{
+				node_output_attributes(writer, node, flags);
+			}
+			else if (node.value()[0])
+			{
+				writer.write(' ');
+				writer.write(node.value());
+			}
+
+			writer.write('?', '>');
+			if ((flags & format_raw) == 0) writer.write('\n');
+			break;
+
+		case node_doctype:
+			writer.write('<', '!', 'D', 'O', 'C');
+			writer.write('T', 'Y', 'P', 'E');
+
+			if (node.value()[0])
+			{
+				writer.write(' ');
+				writer.write(node.value());
+			}
+
+			writer.write('>');
+			if ((flags & format_raw) == 0) writer.write('\n');
+			break;
+
+		default:
+			assert(!"Invalid node type");
+		}
+	}
+
+	inline bool has_declaration(const xml_node& node)
+	{
+		for (xml_node child = node.first_child(); child; child = child.next_sibling())
+		{
+			xml_node_type type = child.type();
+
+			if (type == node_declaration) return true;
+			if (type == node_element) return false;
+		}
+
+		return false;
+	}
+
+	inline bool allow_insert_child(xml_node_type parent, xml_node_type child)
+	{
+		if (parent != node_document && parent != node_element) return false;
+		if (child == node_document || child == node_null) return false;
+		if (parent != node_document && (child == node_declaration || child == node_doctype)) return false;
+
+		return true;
+	}
+
+	PUGI__FN void recursive_copy_skip(xml_node& dest, const xml_node& source, const xml_node& skip)
+	{
+		assert(dest.type() == source.type());
+
+		switch (source.type())
+		{
+		case node_element:
+		{
+			dest.set_name(source.name());
+
+			for (xml_attribute a = source.first_attribute(); a; a = a.next_attribute())
+				dest.append_attribute(a.name()).set_value(a.value());
+
+			for (xml_node c = source.first_child(); c; c = c.next_sibling())
+			{
+				if (c == skip) continue;
+
+				xml_node cc = dest.append_child(c.type());
+				assert(cc);
+
+				recursive_copy_skip(cc, c, skip);
+			}
+
+			break;
+		}
+
+		case node_pcdata:
+		case node_cdata:
+		case node_comment:
+		case node_doctype:
+			dest.set_value(source.value());
+			break;
+
+		case node_pi:
+			dest.set_name(source.name());
+			dest.set_value(source.value());
+			break;
+
+		case node_declaration:
+		{
+			dest.set_name(source.name());
+
+			for (xml_attribute a = source.first_attribute(); a; a = a.next_attribute())
+				dest.append_attribute(a.name()).set_value(a.value());
+
+			break;
+		}
+
+		default:
+			assert(!"Invalid node type");
+		}
+	}
+
+	inline bool is_text_node(xml_node_struct* node)
+	{
+		xml_node_type type = static_cast<xml_node_type>((node->header & impl::xml_memory_page_type_mask) + 1);
+
+		return type == node_pcdata || type == node_cdata;
+	}
+
+	// get value with conversion functions
+	PUGI__FN int get_value_int(const char_t* value, int def)
+	{
+		if (!value) return def;
+
+	#ifdef PUGIXML_WCHAR_MODE
+		return static_cast<int>(wcstol(value, 0, 10));
+	#else
+		return static_cast<int>(strtol(value, 0, 10));
+	#endif
+	}
+
+	PUGI__FN unsigned int get_value_uint(const char_t* value, unsigned int def)
+	{
+		if (!value) return def;
+
+	#ifdef PUGIXML_WCHAR_MODE
+		return static_cast<unsigned int>(wcstoul(value, 0, 10));
+	#else
+		return static_cast<unsigned int>(strtoul(value, 0, 10));
+	#endif
+	}
+
+	PUGI__FN double get_value_double(const char_t* value, double def)
+	{
+		if (!value) return def;
+
+	#ifdef PUGIXML_WCHAR_MODE
+		return wcstod(value, 0);
+	#else
+		return strtod(value, 0);
+	#endif
+	}
+
+	PUGI__FN float get_value_float(const char_t* value, float def)
+	{
+		if (!value) return def;
+
+	#ifdef PUGIXML_WCHAR_MODE
+		return static_cast<float>(wcstod(value, 0));
+	#else
+		return static_cast<float>(strtod(value, 0));
+	#endif
+	}
+
+	PUGI__FN bool get_value_bool(const char_t* value, bool def)
+	{
+		if (!value) return def;
+
+		// only look at first char
+		char_t first = *value;
+
+		// 1*, t* (true), T* (True), y* (yes), Y* (YES)
+		return (first == '1' || first == 't' || first == 'T' || first == 'y' || first == 'Y');
+	}
+
+	// set value with conversion functions
+	PUGI__FN bool set_value_buffer(char_t*& dest, uintptr_t& header, uintptr_t header_mask, char (&buf)[128])
+	{
+	#ifdef PUGIXML_WCHAR_MODE
+		char_t wbuf[128];
+		impl::widen_ascii(wbuf, buf);
+
+		return strcpy_insitu(dest, header, header_mask, wbuf);
+	#else
+		return strcpy_insitu(dest, header, header_mask, buf);
+	#endif
+	}
+
+	PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, int value)
+	{
+		char buf[128];
+		sprintf(buf, "%d", value);
+	
+		return set_value_buffer(dest, header, header_mask, buf);
+	}
+
+	PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, unsigned int value)
+	{
+		char buf[128];
+		sprintf(buf, "%u", value);
+
+		return set_value_buffer(dest, header, header_mask, buf);
+	}
+
+	PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, double value)
+	{
+		char buf[128];
+		sprintf(buf, "%g", value);
+
+		return set_value_buffer(dest, header, header_mask, buf);
+	}
+	
+	PUGI__FN bool set_value_convert(char_t*& dest, uintptr_t& header, uintptr_t header_mask, bool value)
+	{
+		return strcpy_insitu(dest, header, header_mask, value ? PUGIXML_TEXT("true") : PUGIXML_TEXT("false"));
+	}
+
+	// we need to get length of entire file to load it in memory; the only (relatively) sane way to do it is via seek/tell trick
+	PUGI__FN xml_parse_status get_file_size(FILE* file, size_t& out_result)
+	{
+	#if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400 && !defined(_WIN32_WCE)
+		// there are 64-bit versions of fseek/ftell, let's use them
+		typedef __int64 length_type;
+
+		_fseeki64(file, 0, SEEK_END);
+		length_type length = _ftelli64(file);
+		_fseeki64(file, 0, SEEK_SET);
+	#elif defined(__MINGW32__) && !defined(__NO_MINGW_LFS) && !defined(__STRICT_ANSI__)
+		// there are 64-bit versions of fseek/ftell, let's use them
+		typedef off64_t length_type;
+
+		fseeko64(file, 0, SEEK_END);
+		length_type length = ftello64(file);
+		fseeko64(file, 0, SEEK_SET);
+	#else
+		// if this is a 32-bit OS, long is enough; if this is a unix system, long is 64-bit, which is enough; otherwise we can't do anything anyway.
+		typedef long length_type;
+
+		fseek(file, 0, SEEK_END);
+		length_type length = ftell(file);
+		fseek(file, 0, SEEK_SET);
+	#endif
+
+		// check for I/O errors
+		if (length < 0) return status_io_error;
+		
+		// check for overflow
+		size_t result = static_cast<size_t>(length);
+
+		if (static_cast<length_type>(result) != length) return status_out_of_memory;
+
+		// finalize
+		out_result = result;
+
+		return status_ok;
+	}
+
+	PUGI__FN xml_parse_result load_file_impl(xml_document& doc, FILE* file, unsigned int options, xml_encoding encoding)
+	{
+		if (!file) return make_parse_result(status_file_not_found);
+
+		// get file size (can result in I/O errors)
+		size_t size = 0;
+		xml_parse_status size_status = get_file_size(file, size);
+
+		if (size_status != status_ok)
+		{
+			fclose(file);
+			return make_parse_result(size_status);
+		}
+		
+		// allocate buffer for the whole file
+		char* contents = static_cast<char*>(xml_memory::allocate(size > 0 ? size : 1));
+
+		if (!contents)
+		{
+			fclose(file);
+			return make_parse_result(status_out_of_memory);
+		}
+
+		// read file in memory
+		size_t read_size = fread(contents, 1, size, file);
+		fclose(file);
+
+		if (read_size != size)
+		{
+			xml_memory::deallocate(contents);
+			return make_parse_result(status_io_error);
+		}
+		
+		return doc.load_buffer_inplace_own(contents, size, options, encoding);
+	}
+
+#ifndef PUGIXML_NO_STL
+	template <typename T> struct xml_stream_chunk
+	{
+		static xml_stream_chunk* create()
+		{
+			void* memory = xml_memory::allocate(sizeof(xml_stream_chunk));
+			
+			return new (memory) xml_stream_chunk();
+		}
+
+		static void destroy(void* ptr)
+		{
+			xml_stream_chunk* chunk = static_cast<xml_stream_chunk*>(ptr);
+
+			// free chunk chain
+			while (chunk)
+			{
+				xml_stream_chunk* next = chunk->next;
+				xml_memory::deallocate(chunk);
+				chunk = next;
+			}
+		}
+
+		xml_stream_chunk(): next(0), size(0)
+		{
+		}
+
+		xml_stream_chunk* next;
+		size_t size;
+
+		T data[xml_memory_page_size / sizeof(T)];
+	};
+
+	template <typename T> PUGI__FN xml_parse_status load_stream_data_noseek(std::basic_istream<T>& stream, void** out_buffer, size_t* out_size)
+	{
+		buffer_holder chunks(0, xml_stream_chunk<T>::destroy);
+
+		// read file to a chunk list
+		size_t total = 0;
+		xml_stream_chunk<T>* last = 0;
+
+		while (!stream.eof())
+		{
+			// allocate new chunk
+			xml_stream_chunk<T>* chunk = xml_stream_chunk<T>::create();
+			if (!chunk) return status_out_of_memory;
+
+			// append chunk to list
+			if (last) last = last->next = chunk;
+			else chunks.data = last = chunk;
+
+			// read data to chunk
+			stream.read(chunk->data, static_cast<std::streamsize>(sizeof(chunk->data) / sizeof(T)));
+			chunk->size = static_cast<size_t>(stream.gcount()) * sizeof(T);
+
+			// read may set failbit | eofbit in case gcount() is less than read length, so check for other I/O errors
+			if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
+
+			// guard against huge files (chunk size is small enough to make this overflow check work)
+			if (total + chunk->size < total) return status_out_of_memory;
+			total += chunk->size;
+		}
+
+		// copy chunk list to a contiguous buffer
+		char* buffer = static_cast<char*>(xml_memory::allocate(total));
+		if (!buffer) return status_out_of_memory;
+
+		char* write = buffer;
+
+		for (xml_stream_chunk<T>* chunk = static_cast<xml_stream_chunk<T>*>(chunks.data); chunk; chunk = chunk->next)
+		{
+			assert(write + chunk->size <= buffer + total);
+			memcpy(write, chunk->data, chunk->size);
+			write += chunk->size;
+		}
+
+		assert(write == buffer + total);
+
+		// return buffer
+		*out_buffer = buffer;
+		*out_size = total;
+
+		return status_ok;
+	}
+
+	template <typename T> PUGI__FN xml_parse_status load_stream_data_seek(std::basic_istream<T>& stream, void** out_buffer, size_t* out_size)
+	{
+		// get length of remaining data in stream
+		typename std::basic_istream<T>::pos_type pos = stream.tellg();
+		stream.seekg(0, std::ios::end);
+		std::streamoff length = stream.tellg() - pos;
+		stream.seekg(pos);
+
+		if (stream.fail() || pos < 0) return status_io_error;
+
+		// guard against huge files
+		size_t read_length = static_cast<size_t>(length);
+
+		if (static_cast<std::streamsize>(read_length) != length || length < 0) return status_out_of_memory;
+
+		// read stream data into memory (guard against stream exceptions with buffer holder)
+		buffer_holder buffer(xml_memory::allocate((read_length > 0 ? read_length : 1) * sizeof(T)), xml_memory::deallocate);
+		if (!buffer.data) return status_out_of_memory;
+
+		stream.read(static_cast<T*>(buffer.data), static_cast<std::streamsize>(read_length));
+
+		// read may set failbit | eofbit in case gcount() is less than read_length (i.e. line ending conversion), so check for other I/O errors
+		if (stream.bad() || (!stream.eof() && stream.fail())) return status_io_error;
+
+		// return buffer
+		size_t actual_length = static_cast<size_t>(stream.gcount());
+		assert(actual_length <= read_length);
+
+		*out_buffer = buffer.release();
+		*out_size = actual_length * sizeof(T);
+
+		return status_ok;
+	}
+
+	template <typename T> PUGI__FN xml_parse_result load_stream_impl(xml_document& doc, std::basic_istream<T>& stream, unsigned int options, xml_encoding encoding)
+	{
+		void* buffer = 0;
+		size_t size = 0;
+
+		// load stream to memory (using seek-based implementation if possible, since it's faster and takes less memory)
+		xml_parse_status status = (stream.tellg() < 0) ? load_stream_data_noseek(stream, &buffer, &size) : load_stream_data_seek(stream, &buffer, &size);
+		if (status != status_ok) return make_parse_result(status);
+
+		return doc.load_buffer_inplace_own(buffer, size, options, encoding);
+	}
+#endif
+
+#if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__) || (defined(__MINGW32__) && !defined(__STRICT_ANSI__))
+	PUGI__FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode)
+	{
+		return _wfopen(path, mode);
+	}
+#else
+	PUGI__FN char* convert_path_heap(const wchar_t* str)
+	{
+		assert(str);
+
+		// first pass: get length in utf8 characters
+		size_t length = wcslen(str);
+		size_t size = as_utf8_begin(str, length);
+
+		// allocate resulting string
+		char* result = static_cast<char*>(xml_memory::allocate(size + 1));
+		if (!result) return 0;
+
+		// second pass: convert to utf8
+		as_utf8_end(result, size, str, length);
+
+		return result;
+	}
+
+	PUGI__FN FILE* open_file_wide(const wchar_t* path, const wchar_t* mode)
+	{
+		// there is no standard function to open wide paths, so our best bet is to try utf8 path
+		char* path_utf8 = convert_path_heap(path);
+		if (!path_utf8) return 0;
+
+		// convert mode to ASCII (we mirror _wfopen interface)
+		char mode_ascii[4] = {0};
+		for (size_t i = 0; mode[i]; ++i) mode_ascii[i] = static_cast<char>(mode[i]);
+
+		// try to open the utf8 path
+		FILE* result = fopen(path_utf8, mode_ascii);
+
+		// free dummy buffer
+		xml_memory::deallocate(path_utf8);
+
+		return result;
+	}
+#endif
+
+	PUGI__FN bool save_file_impl(const xml_document& doc, FILE* file, const char_t* indent, unsigned int flags, xml_encoding encoding)
+	{
+		if (!file) return false;
+
+		xml_writer_file writer(file);
+		doc.save(writer, indent, flags, encoding);
+
+		int result = ferror(file);
+
+		fclose(file);
+
+		return result == 0;
+	}
+PUGI__NS_END
+
+namespace pugi
+{
+	PUGI__FN xml_writer_file::xml_writer_file(void* file_): file(file_)
+	{
+	}
+
+	PUGI__FN void xml_writer_file::write(const void* data, size_t size)
+	{
+		size_t result = fwrite(data, 1, size, static_cast<FILE*>(file));
+		(void)!result; // unfortunately we can't do proper error handling here
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN xml_writer_stream::xml_writer_stream(std::basic_ostream<char, std::char_traits<char> >& stream): narrow_stream(&stream), wide_stream(0)
+	{
+	}
+
+	PUGI__FN xml_writer_stream::xml_writer_stream(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream): narrow_stream(0), wide_stream(&stream)
+	{
+	}
+
+	PUGI__FN void xml_writer_stream::write(const void* data, size_t size)
+	{
+		if (narrow_stream)
+		{
+			assert(!wide_stream);
+			narrow_stream->write(reinterpret_cast<const char*>(data), static_cast<std::streamsize>(size));
+		}
+		else
+		{
+			assert(wide_stream);
+			assert(size % sizeof(wchar_t) == 0);
+
+			wide_stream->write(reinterpret_cast<const wchar_t*>(data), static_cast<std::streamsize>(size / sizeof(wchar_t)));
+		}
+	}
+#endif
+
+	PUGI__FN xml_tree_walker::xml_tree_walker(): _depth(0)
+	{
+	}
+	
+	PUGI__FN xml_tree_walker::~xml_tree_walker()
+	{
+	}
+
+	PUGI__FN int xml_tree_walker::depth() const
+	{
+		return _depth;
+	}
+
+	PUGI__FN bool xml_tree_walker::begin(xml_node&)
+	{
+		return true;
+	}
+
+	PUGI__FN bool xml_tree_walker::end(xml_node&)
+	{
+		return true;
+	}
+
+	PUGI__FN xml_attribute::xml_attribute(): _attr(0)
+	{
+	}
+
+	PUGI__FN xml_attribute::xml_attribute(xml_attribute_struct* attr): _attr(attr)
+	{
+	}
+
+	PUGI__FN static void unspecified_bool_xml_attribute(xml_attribute***)
+	{
+	}
+
+	PUGI__FN xml_attribute::operator xml_attribute::unspecified_bool_type() const
+	{
+		return _attr ? unspecified_bool_xml_attribute : 0;
+	}
+
+	PUGI__FN bool xml_attribute::operator!() const
+	{
+		return !_attr;
+	}
+
+	PUGI__FN bool xml_attribute::operator==(const xml_attribute& r) const
+	{
+		return (_attr == r._attr);
+	}
+	
+	PUGI__FN bool xml_attribute::operator!=(const xml_attribute& r) const
+	{
+		return (_attr != r._attr);
+	}
+
+	PUGI__FN bool xml_attribute::operator<(const xml_attribute& r) const
+	{
+		return (_attr < r._attr);
+	}
+	
+	PUGI__FN bool xml_attribute::operator>(const xml_attribute& r) const
+	{
+		return (_attr > r._attr);
+	}
+	
+	PUGI__FN bool xml_attribute::operator<=(const xml_attribute& r) const
+	{
+		return (_attr <= r._attr);
+	}
+	
+	PUGI__FN bool xml_attribute::operator>=(const xml_attribute& r) const
+	{
+		return (_attr >= r._attr);
+	}
+
+	PUGI__FN xml_attribute xml_attribute::next_attribute() const
+	{
+		return _attr ? xml_attribute(_attr->next_attribute) : xml_attribute();
+	}
+
+	PUGI__FN xml_attribute xml_attribute::previous_attribute() const
+	{
+		return _attr && _attr->prev_attribute_c->next_attribute ? xml_attribute(_attr->prev_attribute_c) : xml_attribute();
+	}
+
+	PUGI__FN const char_t* xml_attribute::as_string(const char_t* def) const
+	{
+		return (_attr && _attr->value) ? _attr->value : def;
+	}
+
+	PUGI__FN int xml_attribute::as_int(int def) const
+	{
+		return impl::get_value_int(_attr ? _attr->value : 0, def);
+	}
+
+	PUGI__FN unsigned int xml_attribute::as_uint(unsigned int def) const
+	{
+		return impl::get_value_uint(_attr ? _attr->value : 0, def);
+	}
+
+	PUGI__FN double xml_attribute::as_double(double def) const
+	{
+		return impl::get_value_double(_attr ? _attr->value : 0, def);
+	}
+
+	PUGI__FN float xml_attribute::as_float(float def) const
+	{
+		return impl::get_value_float(_attr ? _attr->value : 0, def);
+	}
+
+	PUGI__FN bool xml_attribute::as_bool(bool def) const
+	{
+		return impl::get_value_bool(_attr ? _attr->value : 0, def);
+	}
+
+	PUGI__FN bool xml_attribute::empty() const
+	{
+		return !_attr;
+	}
+
+	PUGI__FN const char_t* xml_attribute::name() const
+	{
+		return (_attr && _attr->name) ? _attr->name : PUGIXML_TEXT("");
+	}
+
+	PUGI__FN const char_t* xml_attribute::value() const
+	{
+		return (_attr && _attr->value) ? _attr->value : PUGIXML_TEXT("");
+	}
+
+	PUGI__FN size_t xml_attribute::hash_value() const
+	{
+		return static_cast<size_t>(reinterpret_cast<uintptr_t>(_attr) / sizeof(xml_attribute_struct));
+	}
+
+	PUGI__FN xml_attribute_struct* xml_attribute::internal_object() const
+	{
+		return _attr;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute::operator=(const char_t* rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+	
+	PUGI__FN xml_attribute& xml_attribute::operator=(int rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute::operator=(unsigned int rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute::operator=(double rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+	
+	PUGI__FN xml_attribute& xml_attribute::operator=(bool rhs)
+	{
+		set_value(rhs);
+		return *this;
+	}
+
+	PUGI__FN bool xml_attribute::set_name(const char_t* rhs)
+	{
+		if (!_attr) return false;
+		
+		return impl::strcpy_insitu(_attr->name, _attr->header, impl::xml_memory_page_name_allocated_mask, rhs);
+	}
+		
+	PUGI__FN bool xml_attribute::set_value(const char_t* rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::strcpy_insitu(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+	}
+
+	PUGI__FN bool xml_attribute::set_value(int rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+	}
+
+	PUGI__FN bool xml_attribute::set_value(unsigned int rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+	}
+
+	PUGI__FN bool xml_attribute::set_value(double rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+	}
+	
+	PUGI__FN bool xml_attribute::set_value(bool rhs)
+	{
+		if (!_attr) return false;
+
+		return impl::set_value_convert(_attr->value, _attr->header, impl::xml_memory_page_value_allocated_mask, rhs);
+	}
+
+#ifdef __BORLANDC__
+	PUGI__FN bool operator&&(const xml_attribute& lhs, bool rhs)
+	{
+		return (bool)lhs && rhs;
+	}
+
+	PUGI__FN bool operator||(const xml_attribute& lhs, bool rhs)
+	{
+		return (bool)lhs || rhs;
+	}
+#endif
+
+	PUGI__FN xml_node::xml_node(): _root(0)
+	{
+	}
+
+	PUGI__FN xml_node::xml_node(xml_node_struct* p): _root(p)
+	{
+	}
+	
+	PUGI__FN static void unspecified_bool_xml_node(xml_node***)
+	{
+	}
+
+	PUGI__FN xml_node::operator xml_node::unspecified_bool_type() const
+	{
+		return _root ? unspecified_bool_xml_node : 0;
+	}
+
+	PUGI__FN bool xml_node::operator!() const
+	{
+		return !_root;
+	}
+
+	PUGI__FN xml_node::iterator xml_node::begin() const
+	{
+		return iterator(_root ? _root->first_child : 0, _root);
+	}
+
+	PUGI__FN xml_node::iterator xml_node::end() const
+	{
+		return iterator(0, _root);
+	}
+	
+	PUGI__FN xml_node::attribute_iterator xml_node::attributes_begin() const
+	{
+		return attribute_iterator(_root ? _root->first_attribute : 0, _root);
+	}
+
+	PUGI__FN xml_node::attribute_iterator xml_node::attributes_end() const
+	{
+		return attribute_iterator(0, _root);
+	}
+	
+	PUGI__FN xml_object_range<xml_node_iterator> xml_node::children() const
+	{
+		return xml_object_range<xml_node_iterator>(begin(), end());
+	}
+
+	PUGI__FN xml_object_range<xml_named_node_iterator> xml_node::children(const char_t* name_) const
+	{
+		return xml_object_range<xml_named_node_iterator>(xml_named_node_iterator(child(name_), name_), xml_named_node_iterator());
+	}
+
+	PUGI__FN xml_object_range<xml_attribute_iterator> xml_node::attributes() const
+	{
+		return xml_object_range<xml_attribute_iterator>(attributes_begin(), attributes_end());
+	}
+
+	PUGI__FN bool xml_node::operator==(const xml_node& r) const
+	{
+		return (_root == r._root);
+	}
+
+	PUGI__FN bool xml_node::operator!=(const xml_node& r) const
+	{
+		return (_root != r._root);
+	}
+
+	PUGI__FN bool xml_node::operator<(const xml_node& r) const
+	{
+		return (_root < r._root);
+	}
+	
+	PUGI__FN bool xml_node::operator>(const xml_node& r) const
+	{
+		return (_root > r._root);
+	}
+	
+	PUGI__FN bool xml_node::operator<=(const xml_node& r) const
+	{
+		return (_root <= r._root);
+	}
+	
+	PUGI__FN bool xml_node::operator>=(const xml_node& r) const
+	{
+		return (_root >= r._root);
+	}
+
+	PUGI__FN bool xml_node::empty() const
+	{
+		return !_root;
+	}
+	
+	PUGI__FN const char_t* xml_node::name() const
+	{
+		return (_root && _root->name) ? _root->name : PUGIXML_TEXT("");
+	}
+
+	PUGI__FN xml_node_type xml_node::type() const
+	{
+		return _root ? static_cast<xml_node_type>((_root->header & impl::xml_memory_page_type_mask) + 1) : node_null;
+	}
+	
+	PUGI__FN const char_t* xml_node::value() const
+	{
+		return (_root && _root->value) ? _root->value : PUGIXML_TEXT("");
+	}
+	
+	PUGI__FN xml_node xml_node::child(const char_t* name_) const
+	{
+		if (!_root) return xml_node();
+
+		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+			if (i->name && impl::strequal(name_, i->name)) return xml_node(i);
+
+		return xml_node();
+	}
+
+	PUGI__FN xml_attribute xml_node::attribute(const char_t* name_) const
+	{
+		if (!_root) return xml_attribute();
+
+		for (xml_attribute_struct* i = _root->first_attribute; i; i = i->next_attribute)
+			if (i->name && impl::strequal(name_, i->name))
+				return xml_attribute(i);
+		
+		return xml_attribute();
+	}
+	
+	PUGI__FN xml_node xml_node::next_sibling(const char_t* name_) const
+	{
+		if (!_root) return xml_node();
+		
+		for (xml_node_struct* i = _root->next_sibling; i; i = i->next_sibling)
+			if (i->name && impl::strequal(name_, i->name)) return xml_node(i);
+
+		return xml_node();
+	}
+
+	PUGI__FN xml_node xml_node::next_sibling() const
+	{
+		if (!_root) return xml_node();
+		
+		if (_root->next_sibling) return xml_node(_root->next_sibling);
+		else return xml_node();
+	}
+
+	PUGI__FN xml_node xml_node::previous_sibling(const char_t* name_) const
+	{
+		if (!_root) return xml_node();
+		
+		for (xml_node_struct* i = _root->prev_sibling_c; i->next_sibling; i = i->prev_sibling_c)
+			if (i->name && impl::strequal(name_, i->name)) return xml_node(i);
+
+		return xml_node();
+	}
+
+	PUGI__FN xml_node xml_node::previous_sibling() const
+	{
+		if (!_root) return xml_node();
+		
+		if (_root->prev_sibling_c->next_sibling) return xml_node(_root->prev_sibling_c);
+		else return xml_node();
+	}
+
+	PUGI__FN xml_node xml_node::parent() const
+	{
+		return _root ? xml_node(_root->parent) : xml_node();
+	}
+
+	PUGI__FN xml_node xml_node::root() const
+	{
+		if (!_root) return xml_node();
+
+		impl::xml_memory_page* page = reinterpret_cast<impl::xml_memory_page*>(_root->header & impl::xml_memory_page_pointer_mask);
+
+		return xml_node(static_cast<impl::xml_document_struct*>(page->allocator));
+	}
+
+	PUGI__FN xml_text xml_node::text() const
+	{
+		return xml_text(_root);
+	}
+
+	PUGI__FN const char_t* xml_node::child_value() const
+	{
+		if (!_root) return PUGIXML_TEXT("");
+		
+		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+			if (i->value && impl::is_text_node(i))
+				return i->value;
+
+		return PUGIXML_TEXT("");
+	}
+
+	PUGI__FN const char_t* xml_node::child_value(const char_t* name_) const
+	{
+		return child(name_).child_value();
+	}
+
+	PUGI__FN xml_attribute xml_node::first_attribute() const
+	{
+		return _root ? xml_attribute(_root->first_attribute) : xml_attribute();
+	}
+
+	PUGI__FN xml_attribute xml_node::last_attribute() const
+	{
+		return _root && _root->first_attribute ? xml_attribute(_root->first_attribute->prev_attribute_c) : xml_attribute();
+	}
+
+	PUGI__FN xml_node xml_node::first_child() const
+	{
+		return _root ? xml_node(_root->first_child) : xml_node();
+	}
+
+	PUGI__FN xml_node xml_node::last_child() const
+	{
+		return _root && _root->first_child ? xml_node(_root->first_child->prev_sibling_c) : xml_node();
+	}
+
+	PUGI__FN bool xml_node::set_name(const char_t* rhs)
+	{
+		switch (type())
+		{
+		case node_pi:
+		case node_declaration:
+		case node_element:
+			return impl::strcpy_insitu(_root->name, _root->header, impl::xml_memory_page_name_allocated_mask, rhs);
+
+		default:
+			return false;
+		}
+	}
+		
+	PUGI__FN bool xml_node::set_value(const char_t* rhs)
+	{
+		switch (type())
+		{
+		case node_pi:
+		case node_cdata:
+		case node_pcdata:
+		case node_comment:
+		case node_doctype:
+			return impl::strcpy_insitu(_root->value, _root->header, impl::xml_memory_page_value_allocated_mask, rhs);
+
+		default:
+			return false;
+		}
+	}
+
+	PUGI__FN xml_attribute xml_node::append_attribute(const char_t* name_)
+	{
+		if (type() != node_element && type() != node_declaration) return xml_attribute();
+		
+		xml_attribute a(impl::append_attribute_ll(_root, impl::get_allocator(_root)));
+		a.set_name(name_);
+		
+		return a;
+	}
+
+	PUGI__FN xml_attribute xml_node::prepend_attribute(const char_t* name_)
+	{
+		if (type() != node_element && type() != node_declaration) return xml_attribute();
+		
+		xml_attribute a(impl::allocate_attribute(impl::get_allocator(_root)));
+		if (!a) return xml_attribute();
+
+		a.set_name(name_);
+		
+		xml_attribute_struct* head = _root->first_attribute;
+
+		if (head)
+		{
+			a._attr->prev_attribute_c = head->prev_attribute_c;
+			head->prev_attribute_c = a._attr;
+		}
+		else
+			a._attr->prev_attribute_c = a._attr;
+		
+		a._attr->next_attribute = head;
+		_root->first_attribute = a._attr;
+				
+		return a;
+	}
+
+	PUGI__FN xml_attribute xml_node::insert_attribute_before(const char_t* name_, const xml_attribute& attr)
+	{
+		if ((type() != node_element && type() != node_declaration) || attr.empty()) return xml_attribute();
+		
+		// check that attribute belongs to *this
+		xml_attribute_struct* cur = attr._attr;
+
+		while (cur->prev_attribute_c->next_attribute) cur = cur->prev_attribute_c;
+
+		if (cur != _root->first_attribute) return xml_attribute();
+
+		xml_attribute a(impl::allocate_attribute(impl::get_allocator(_root)));
+		if (!a) return xml_attribute();
+
+		a.set_name(name_);
+
+		if (attr._attr->prev_attribute_c->next_attribute)
+			attr._attr->prev_attribute_c->next_attribute = a._attr;
+		else
+			_root->first_attribute = a._attr;
+		
+		a._attr->prev_attribute_c = attr._attr->prev_attribute_c;
+		a._attr->next_attribute = attr._attr;
+		attr._attr->prev_attribute_c = a._attr;
+				
+		return a;
+	}
+
+	PUGI__FN xml_attribute xml_node::insert_attribute_after(const char_t* name_, const xml_attribute& attr)
+	{
+		if ((type() != node_element && type() != node_declaration) || attr.empty()) return xml_attribute();
+		
+		// check that attribute belongs to *this
+		xml_attribute_struct* cur = attr._attr;
+
+		while (cur->prev_attribute_c->next_attribute) cur = cur->prev_attribute_c;
+
+		if (cur != _root->first_attribute) return xml_attribute();
+
+		xml_attribute a(impl::allocate_attribute(impl::get_allocator(_root)));
+		if (!a) return xml_attribute();
+
+		a.set_name(name_);
+
+		if (attr._attr->next_attribute)
+			attr._attr->next_attribute->prev_attribute_c = a._attr;
+		else
+			_root->first_attribute->prev_attribute_c = a._attr;
+		
+		a._attr->next_attribute = attr._attr->next_attribute;
+		a._attr->prev_attribute_c = attr._attr;
+		attr._attr->next_attribute = a._attr;
+
+		return a;
+	}
+
+	PUGI__FN xml_attribute xml_node::append_copy(const xml_attribute& proto)
+	{
+		if (!proto) return xml_attribute();
+
+		xml_attribute result = append_attribute(proto.name());
+		result.set_value(proto.value());
+
+		return result;
+	}
+
+	PUGI__FN xml_attribute xml_node::prepend_copy(const xml_attribute& proto)
+	{
+		if (!proto) return xml_attribute();
+
+		xml_attribute result = prepend_attribute(proto.name());
+		result.set_value(proto.value());
+
+		return result;
+	}
+
+	PUGI__FN xml_attribute xml_node::insert_copy_after(const xml_attribute& proto, const xml_attribute& attr)
+	{
+		if (!proto) return xml_attribute();
+
+		xml_attribute result = insert_attribute_after(proto.name(), attr);
+		result.set_value(proto.value());
+
+		return result;
+	}
+
+	PUGI__FN xml_attribute xml_node::insert_copy_before(const xml_attribute& proto, const xml_attribute& attr)
+	{
+		if (!proto) return xml_attribute();
+
+		xml_attribute result = insert_attribute_before(proto.name(), attr);
+		result.set_value(proto.value());
+
+		return result;
+	}
+
+	PUGI__FN xml_node xml_node::append_child(xml_node_type type_)
+	{
+		if (!impl::allow_insert_child(this->type(), type_)) return xml_node();
+		
+		xml_node n(impl::append_node(_root, impl::get_allocator(_root), type_));
+
+		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
+
+		return n;
+	}
+
+	PUGI__FN xml_node xml_node::prepend_child(xml_node_type type_)
+	{
+		if (!impl::allow_insert_child(this->type(), type_)) return xml_node();
+		
+		xml_node n(impl::allocate_node(impl::get_allocator(_root), type_));
+		if (!n) return xml_node();
+
+		n._root->parent = _root;
+
+		xml_node_struct* head = _root->first_child;
+
+		if (head)
+		{
+			n._root->prev_sibling_c = head->prev_sibling_c;
+			head->prev_sibling_c = n._root;
+		}
+		else
+			n._root->prev_sibling_c = n._root;
+		
+		n._root->next_sibling = head;
+		_root->first_child = n._root;
+				
+		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
+
+		return n;
+	}
+
+	PUGI__FN xml_node xml_node::insert_child_before(xml_node_type type_, const xml_node& node)
+	{
+		if (!impl::allow_insert_child(this->type(), type_)) return xml_node();
+		if (!node._root || node._root->parent != _root) return xml_node();
+	
+		xml_node n(impl::allocate_node(impl::get_allocator(_root), type_));
+		if (!n) return xml_node();
+
+		n._root->parent = _root;
+		
+		if (node._root->prev_sibling_c->next_sibling)
+			node._root->prev_sibling_c->next_sibling = n._root;
+		else
+			_root->first_child = n._root;
+		
+		n._root->prev_sibling_c = node._root->prev_sibling_c;
+		n._root->next_sibling = node._root;
+		node._root->prev_sibling_c = n._root;
+
+		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
+
+		return n;
+	}
+
+	PUGI__FN xml_node xml_node::insert_child_after(xml_node_type type_, const xml_node& node)
+	{
+		if (!impl::allow_insert_child(this->type(), type_)) return xml_node();
+		if (!node._root || node._root->parent != _root) return xml_node();
+	
+		xml_node n(impl::allocate_node(impl::get_allocator(_root), type_));
+		if (!n) return xml_node();
+
+		n._root->parent = _root;
+	
+		if (node._root->next_sibling)
+			node._root->next_sibling->prev_sibling_c = n._root;
+		else
+			_root->first_child->prev_sibling_c = n._root;
+		
+		n._root->next_sibling = node._root->next_sibling;
+		n._root->prev_sibling_c = node._root;
+		node._root->next_sibling = n._root;
+
+		if (type_ == node_declaration) n.set_name(PUGIXML_TEXT("xml"));
+
+		return n;
+	}
+
+	PUGI__FN xml_node xml_node::append_child(const char_t* name_)
+	{
+		xml_node result = append_child(node_element);
+
+		result.set_name(name_);
+
+		return result;
+	}
+
+	PUGI__FN xml_node xml_node::prepend_child(const char_t* name_)
+	{
+		xml_node result = prepend_child(node_element);
+
+		result.set_name(name_);
+
+		return result;
+	}
+
+	PUGI__FN xml_node xml_node::insert_child_after(const char_t* name_, const xml_node& node)
+	{
+		xml_node result = insert_child_after(node_element, node);
+
+		result.set_name(name_);
+
+		return result;
+	}
+
+	PUGI__FN xml_node xml_node::insert_child_before(const char_t* name_, const xml_node& node)
+	{
+		xml_node result = insert_child_before(node_element, node);
+
+		result.set_name(name_);
+
+		return result;
+	}
+
+	PUGI__FN xml_node xml_node::append_copy(const xml_node& proto)
+	{
+		xml_node result = append_child(proto.type());
+
+		if (result) impl::recursive_copy_skip(result, proto, result);
+
+		return result;
+	}
+
+	PUGI__FN xml_node xml_node::prepend_copy(const xml_node& proto)
+	{
+		xml_node result = prepend_child(proto.type());
+
+		if (result) impl::recursive_copy_skip(result, proto, result);
+
+		return result;
+	}
+
+	PUGI__FN xml_node xml_node::insert_copy_after(const xml_node& proto, const xml_node& node)
+	{
+		xml_node result = insert_child_after(proto.type(), node);
+
+		if (result) impl::recursive_copy_skip(result, proto, result);
+
+		return result;
+	}
+
+	PUGI__FN xml_node xml_node::insert_copy_before(const xml_node& proto, const xml_node& node)
+	{
+		xml_node result = insert_child_before(proto.type(), node);
+
+		if (result) impl::recursive_copy_skip(result, proto, result);
+
+		return result;
+	}
+
+	PUGI__FN bool xml_node::remove_attribute(const char_t* name_)
+	{
+		return remove_attribute(attribute(name_));
+	}
+
+	PUGI__FN bool xml_node::remove_attribute(const xml_attribute& a)
+	{
+		if (!_root || !a._attr) return false;
+
+		// check that attribute belongs to *this
+		xml_attribute_struct* attr = a._attr;
+
+		while (attr->prev_attribute_c->next_attribute) attr = attr->prev_attribute_c;
+
+		if (attr != _root->first_attribute) return false;
+
+		if (a._attr->next_attribute) a._attr->next_attribute->prev_attribute_c = a._attr->prev_attribute_c;
+		else if (_root->first_attribute) _root->first_attribute->prev_attribute_c = a._attr->prev_attribute_c;
+		
+		if (a._attr->prev_attribute_c->next_attribute) a._attr->prev_attribute_c->next_attribute = a._attr->next_attribute;
+		else _root->first_attribute = a._attr->next_attribute;
+
+		impl::destroy_attribute(a._attr, impl::get_allocator(_root));
+
+		return true;
+	}
+
+	PUGI__FN bool xml_node::remove_child(const char_t* name_)
+	{
+		return remove_child(child(name_));
+	}
+
+	PUGI__FN bool xml_node::remove_child(const xml_node& n)
+	{
+		if (!_root || !n._root || n._root->parent != _root) return false;
+
+		if (n._root->next_sibling) n._root->next_sibling->prev_sibling_c = n._root->prev_sibling_c;
+		else if (_root->first_child) _root->first_child->prev_sibling_c = n._root->prev_sibling_c;
+		
+		if (n._root->prev_sibling_c->next_sibling) n._root->prev_sibling_c->next_sibling = n._root->next_sibling;
+		else _root->first_child = n._root->next_sibling;
+		
+		impl::destroy_node(n._root, impl::get_allocator(_root));
+
+		return true;
+	}
+
+	PUGI__FN xml_node xml_node::find_child_by_attribute(const char_t* name_, const char_t* attr_name, const char_t* attr_value) const
+	{
+		if (!_root) return xml_node();
+		
+		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+			if (i->name && impl::strequal(name_, i->name))
+			{
+				for (xml_attribute_struct* a = i->first_attribute; a; a = a->next_attribute)
+					if (impl::strequal(attr_name, a->name) && impl::strequal(attr_value, a->value))
+						return xml_node(i);
+			}
+
+		return xml_node();
+	}
+
+	PUGI__FN xml_node xml_node::find_child_by_attribute(const char_t* attr_name, const char_t* attr_value) const
+	{
+		if (!_root) return xml_node();
+		
+		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+			for (xml_attribute_struct* a = i->first_attribute; a; a = a->next_attribute)
+				if (impl::strequal(attr_name, a->name) && impl::strequal(attr_value, a->value))
+					return xml_node(i);
+
+		return xml_node();
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN string_t xml_node::path(char_t delimiter) const
+	{
+		xml_node cursor = *this; // Make a copy.
+		
+		string_t result = cursor.name();
+
+		while (cursor.parent())
+		{
+			cursor = cursor.parent();
+			
+			string_t temp = cursor.name();
+			temp += delimiter;
+			temp += result;
+			result.swap(temp);
+		}
+
+		return result;
+	}
+#endif
+
+	PUGI__FN xml_node xml_node::first_element_by_path(const char_t* path_, char_t delimiter) const
+	{
+		xml_node found = *this; // Current search context.
+
+		if (!_root || !path_ || !path_[0]) return found;
+
+		if (path_[0] == delimiter)
+		{
+			// Absolute path; e.g. '/foo/bar'
+			found = found.root();
+			++path_;
+		}
+
+		const char_t* path_segment = path_;
+
+		while (*path_segment == delimiter) ++path_segment;
+
+		const char_t* 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_t* 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 && impl::strequalrange(j->name, path_segment, static_cast<size_t>(path_segment_end - path_segment)))
+				{
+					xml_node subsearch = xml_node(j).first_element_by_path(next_segment, delimiter);
+
+					if (subsearch) return subsearch;
+				}
+			}
+
+			return xml_node();
+		}
+	}
+
+	PUGI__FN bool xml_node::traverse(xml_tree_walker& walker)
+	{
+		walker._depth = -1;
+		
+		xml_node arg_begin = *this;
+		if (!walker.begin(arg_begin)) return false;
+
+		xml_node cur = first_child();
+				
+		if (cur)
+		{
+			++walker._depth;
+
+			do 
+			{
+				xml_node arg_for_each = cur;
+				if (!walker.for_each(arg_for_each))
+					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 && !cur.parent().empty())
+					{
+						--walker._depth;
+						cur = cur.parent();
+					}
+						
+					if (cur != *this)
+						cur = cur.next_sibling();
+				}
+			}
+			while (cur && cur != *this);
+		}
+
+		assert(walker._depth == -1);
+
+		xml_node arg_end = *this;
+		return walker.end(arg_end);
+	}
+
+	PUGI__FN size_t xml_node::hash_value() const
+	{
+		return static_cast<size_t>(reinterpret_cast<uintptr_t>(_root) / sizeof(xml_node_struct));
+	}
+
+	PUGI__FN xml_node_struct* xml_node::internal_object() const
+	{
+		return _root;
+	}
+
+	PUGI__FN void xml_node::print(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const
+	{
+		if (!_root) return;
+
+		impl::xml_buffered_writer buffered_writer(writer, encoding);
+
+		impl::node_output(buffered_writer, *this, indent, flags, depth);
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN void xml_node::print(std::basic_ostream<char, std::char_traits<char> >& stream, const char_t* indent, unsigned int flags, xml_encoding encoding, unsigned int depth) const
+	{
+		xml_writer_stream writer(stream);
+
+		print(writer, indent, flags, encoding, depth);
+	}
+
+	PUGI__FN void xml_node::print(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream, const char_t* indent, unsigned int flags, unsigned int depth) const
+	{
+		xml_writer_stream writer(stream);
+
+		print(writer, indent, flags, encoding_wchar, depth);
+	}
+#endif
+
+	PUGI__FN ptrdiff_t xml_node::offset_debug() const
+	{
+		xml_node_struct* r = root()._root;
+
+		if (!r) return -1;
+
+		const char_t* buffer = static_cast<impl::xml_document_struct*>(r)->buffer;
+
+		if (!buffer) return -1;
+
+		switch (type())
+		{
+		case node_document:
+			return 0;
+
+		case node_element:
+		case node_declaration:
+		case node_pi:
+			return (_root->header & impl::xml_memory_page_name_allocated_mask) ? -1 : _root->name - buffer;
+
+		case node_pcdata:
+		case node_cdata:
+		case node_comment:
+		case node_doctype:
+			return (_root->header & impl::xml_memory_page_value_allocated_mask) ? -1 : _root->value - buffer;
+
+		default:
+			return -1;
+		}
+	}
+
+#ifdef __BORLANDC__
+	PUGI__FN bool operator&&(const xml_node& lhs, bool rhs)
+	{
+		return (bool)lhs && rhs;
+	}
+
+	PUGI__FN bool operator||(const xml_node& lhs, bool rhs)
+	{
+		return (bool)lhs || rhs;
+	}
+#endif
+
+	PUGI__FN xml_text::xml_text(xml_node_struct* root): _root(root)
+	{
+	}
+
+	PUGI__FN xml_node_struct* xml_text::_data() const
+	{
+		if (!_root || impl::is_text_node(_root)) return _root;
+
+		for (xml_node_struct* node = _root->first_child; node; node = node->next_sibling)
+			if (impl::is_text_node(node))
+				return node;
+
+		return 0;
+	}
+
+	PUGI__FN xml_node_struct* xml_text::_data_new()
+	{
+		xml_node_struct* d = _data();
+		if (d) return d;
+
+		return xml_node(_root).append_child(node_pcdata).internal_object();
+	}
+
+	PUGI__FN xml_text::xml_text(): _root(0)
+	{
+	}
+
+	PUGI__FN static void unspecified_bool_xml_text(xml_text***)
+	{
+	}
+
+	PUGI__FN xml_text::operator xml_text::unspecified_bool_type() const
+	{
+		return _data() ? unspecified_bool_xml_text : 0;
+	}
+
+	PUGI__FN bool xml_text::operator!() const
+	{
+		return !_data();
+	}
+
+	PUGI__FN bool xml_text::empty() const
+	{
+		return _data() == 0;
+	}
+
+	PUGI__FN const char_t* xml_text::get() const
+	{
+		xml_node_struct* d = _data();
+
+		return (d && d->value) ? d->value : PUGIXML_TEXT("");
+	}
+
+	PUGI__FN const char_t* xml_text::as_string(const char_t* def) const
+	{
+		xml_node_struct* d = _data();
+
+		return (d && d->value) ? d->value : def;
+	}
+
+	PUGI__FN int xml_text::as_int(int def) const
+	{
+		xml_node_struct* d = _data();
+
+		return impl::get_value_int(d ? d->value : 0, def);
+	}
+
+	PUGI__FN unsigned int xml_text::as_uint(unsigned int def) const
+	{
+		xml_node_struct* d = _data();
+
+		return impl::get_value_uint(d ? d->value : 0, def);
+	}
+
+	PUGI__FN double xml_text::as_double(double def) const
+	{
+		xml_node_struct* d = _data();
+
+		return impl::get_value_double(d ? d->value : 0, def);
+	}
+
+	PUGI__FN float xml_text::as_float(float def) const
+	{
+		xml_node_struct* d = _data();
+
+		return impl::get_value_float(d ? d->value : 0, def);
+	}
+
+	PUGI__FN bool xml_text::as_bool(bool def) const
+	{
+		xml_node_struct* d = _data();
+
+		return impl::get_value_bool(d ? d->value : 0, def);
+	}
+
+	PUGI__FN bool xml_text::set(const char_t* rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::strcpy_insitu(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+	}
+
+	PUGI__FN bool xml_text::set(int rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+	}
+
+	PUGI__FN bool xml_text::set(unsigned int rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+	}
+
+	PUGI__FN bool xml_text::set(double rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+	}
+
+	PUGI__FN bool xml_text::set(bool rhs)
+	{
+		xml_node_struct* dn = _data_new();
+
+		return dn ? impl::set_value_convert(dn->value, dn->header, impl::xml_memory_page_value_allocated_mask, rhs) : false;
+	}
+
+	PUGI__FN xml_text& xml_text::operator=(const char_t* rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_text& xml_text::operator=(int rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_text& xml_text::operator=(unsigned int rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_text& xml_text::operator=(double rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_text& xml_text::operator=(bool rhs)
+	{
+		set(rhs);
+		return *this;
+	}
+
+	PUGI__FN xml_node xml_text::data() const
+	{
+		return xml_node(_data());
+	}
+
+#ifdef __BORLANDC__
+	PUGI__FN bool operator&&(const xml_text& lhs, bool rhs)
+	{
+		return (bool)lhs && rhs;
+	}
+
+	PUGI__FN bool operator||(const xml_text& lhs, bool rhs)
+	{
+		return (bool)lhs || rhs;
+	}
+#endif
+
+	PUGI__FN xml_node_iterator::xml_node_iterator()
+	{
+	}
+
+	PUGI__FN xml_node_iterator::xml_node_iterator(const xml_node& node): _wrap(node), _parent(node.parent())
+	{
+	}
+
+	PUGI__FN xml_node_iterator::xml_node_iterator(xml_node_struct* ref, xml_node_struct* parent): _wrap(ref), _parent(parent)
+	{
+	}
+
+	PUGI__FN bool xml_node_iterator::operator==(const xml_node_iterator& rhs) const
+	{
+		return _wrap._root == rhs._wrap._root && _parent._root == rhs._parent._root;
+	}
+	
+	PUGI__FN bool xml_node_iterator::operator!=(const xml_node_iterator& rhs) const
+	{
+		return _wrap._root != rhs._wrap._root || _parent._root != rhs._parent._root;
+	}
+
+	PUGI__FN xml_node& xml_node_iterator::operator*() const
+	{
+		assert(_wrap._root);
+		return _wrap;
+	}
+
+	PUGI__FN xml_node* xml_node_iterator::operator->() const
+	{
+		assert(_wrap._root);
+		return const_cast<xml_node*>(&_wrap); // BCC32 workaround
+	}
+
+	PUGI__FN const xml_node_iterator& xml_node_iterator::operator++()
+	{
+		assert(_wrap._root);
+		_wrap._root = _wrap._root->next_sibling;
+		return *this;
+	}
+
+	PUGI__FN xml_node_iterator xml_node_iterator::operator++(int)
+	{
+		xml_node_iterator temp = *this;
+		++*this;
+		return temp;
+	}
+
+	PUGI__FN const xml_node_iterator& xml_node_iterator::operator--()
+	{
+		_wrap = _wrap._root ? _wrap.previous_sibling() : _parent.last_child();
+		return *this;
+	}
+
+	PUGI__FN xml_node_iterator xml_node_iterator::operator--(int)
+	{
+		xml_node_iterator temp = *this;
+		--*this;
+		return temp;
+	}
+
+	PUGI__FN xml_attribute_iterator::xml_attribute_iterator()
+	{
+	}
+
+	PUGI__FN xml_attribute_iterator::xml_attribute_iterator(const xml_attribute& attr, const xml_node& parent): _wrap(attr), _parent(parent)
+	{
+	}
+
+	PUGI__FN xml_attribute_iterator::xml_attribute_iterator(xml_attribute_struct* ref, xml_node_struct* parent): _wrap(ref), _parent(parent)
+	{
+	}
+
+	PUGI__FN bool xml_attribute_iterator::operator==(const xml_attribute_iterator& rhs) const
+	{
+		return _wrap._attr == rhs._wrap._attr && _parent._root == rhs._parent._root;
+	}
+	
+	PUGI__FN bool xml_attribute_iterator::operator!=(const xml_attribute_iterator& rhs) const
+	{
+		return _wrap._attr != rhs._wrap._attr || _parent._root != rhs._parent._root;
+	}
+
+	PUGI__FN xml_attribute& xml_attribute_iterator::operator*() const
+	{
+		assert(_wrap._attr);
+		return _wrap;
+	}
+
+	PUGI__FN xml_attribute* xml_attribute_iterator::operator->() const
+	{
+		assert(_wrap._attr);
+		return const_cast<xml_attribute*>(&_wrap); // BCC32 workaround
+	}
+
+	PUGI__FN const xml_attribute_iterator& xml_attribute_iterator::operator++()
+	{
+		assert(_wrap._attr);
+		_wrap._attr = _wrap._attr->next_attribute;
+		return *this;
+	}
+
+	PUGI__FN xml_attribute_iterator xml_attribute_iterator::operator++(int)
+	{
+		xml_attribute_iterator temp = *this;
+		++*this;
+		return temp;
+	}
+
+	PUGI__FN const xml_attribute_iterator& xml_attribute_iterator::operator--()
+	{
+		_wrap = _wrap._attr ? _wrap.previous_attribute() : _parent.last_attribute();
+		return *this;
+	}
+
+	PUGI__FN xml_attribute_iterator xml_attribute_iterator::operator--(int)
+	{
+		xml_attribute_iterator temp = *this;
+		--*this;
+		return temp;
+	}
+
+	PUGI__FN xml_named_node_iterator::xml_named_node_iterator(): _name(0)
+	{
+	}
+
+	PUGI__FN xml_named_node_iterator::xml_named_node_iterator(const xml_node& node, const char_t* name): _node(node), _name(name)
+	{
+	}
+
+	PUGI__FN bool xml_named_node_iterator::operator==(const xml_named_node_iterator& rhs) const
+	{
+		return _node == rhs._node;
+	}
+
+	PUGI__FN bool xml_named_node_iterator::operator!=(const xml_named_node_iterator& rhs) const
+	{
+		return _node != rhs._node;
+	}
+
+	PUGI__FN xml_node& xml_named_node_iterator::operator*() const
+	{
+		assert(_node._root);
+		return _node;
+	}
+
+	PUGI__FN xml_node* xml_named_node_iterator::operator->() const
+	{
+		assert(_node._root);
+		return const_cast<xml_node*>(&_node); // BCC32 workaround
+	}
+
+	PUGI__FN const xml_named_node_iterator& xml_named_node_iterator::operator++()
+	{
+		assert(_node._root);
+		_node = _node.next_sibling(_name);
+		return *this;
+	}
+
+	PUGI__FN xml_named_node_iterator xml_named_node_iterator::operator++(int)
+	{
+		xml_named_node_iterator temp = *this;
+		++*this;
+		return temp;
+	}
+
+	PUGI__FN xml_parse_result::xml_parse_result(): status(status_internal_error), offset(0), encoding(encoding_auto)
+	{
+	}
+
+	PUGI__FN xml_parse_result::operator bool() const
+	{
+		return status == status_ok;
+	}
+
+	PUGI__FN const char* xml_parse_result::description() const
+	{
+		switch (status)
+		{
+		case status_ok: return "No error";
+
+		case status_file_not_found: return "File was not found";
+		case status_io_error: return "Error reading from file/stream";
+		case status_out_of_memory: return "Could not allocate memory";
+		case status_internal_error: return "Internal error occurred";
+
+		case status_unrecognized_tag: return "Could not determine tag type";
+
+		case status_bad_pi: return "Error parsing document declaration/processing instruction";
+		case status_bad_comment: return "Error parsing comment";
+		case status_bad_cdata: return "Error parsing CDATA section";
+		case status_bad_doctype: return "Error parsing document type declaration";
+		case status_bad_pcdata: return "Error parsing PCDATA section";
+		case status_bad_start_element: return "Error parsing start element tag";
+		case status_bad_attribute: return "Error parsing element attribute";
+		case status_bad_end_element: return "Error parsing end element tag";
+		case status_end_element_mismatch: return "Start-end tags mismatch";
+
+		default: return "Unknown error";
+		}
+	}
+
+	PUGI__FN xml_document::xml_document(): _buffer(0)
+	{
+		create();
+	}
+
+	PUGI__FN xml_document::~xml_document()
+	{
+		destroy();
+	}
+
+	PUGI__FN void xml_document::reset()
+	{
+		destroy();
+		create();
+	}
+
+	PUGI__FN void xml_document::reset(const xml_document& proto)
+	{
+		reset();
+
+		for (xml_node cur = proto.first_child(); cur; cur = cur.next_sibling())
+			append_copy(cur);
+	}
+
+	PUGI__FN void xml_document::create()
+	{
+		// initialize sentinel page
+		PUGI__STATIC_ASSERT(offsetof(impl::xml_memory_page, data) + sizeof(impl::xml_document_struct) + impl::xml_memory_page_alignment <= sizeof(_memory));
+
+		// align upwards to page boundary
+		void* page_memory = reinterpret_cast<void*>((reinterpret_cast<uintptr_t>(_memory) + (impl::xml_memory_page_alignment - 1)) & ~(impl::xml_memory_page_alignment - 1));
+
+		// prepare page structure
+		impl::xml_memory_page* page = impl::xml_memory_page::construct(page_memory);
+
+		page->busy_size = impl::xml_memory_page_size;
+
+		// allocate new root
+		_root = new (page->data) impl::xml_document_struct(page);
+		_root->prev_sibling_c = _root;
+
+		// setup sentinel page
+		page->allocator = static_cast<impl::xml_document_struct*>(_root);
+	}
+
+	PUGI__FN void xml_document::destroy()
+	{
+		// destroy static storage
+		if (_buffer)
+		{
+			impl::xml_memory::deallocate(_buffer);
+			_buffer = 0;
+		}
+
+		// destroy dynamic storage, leave sentinel page (it's in static memory)
+		if (_root)
+		{
+			impl::xml_memory_page* root_page = reinterpret_cast<impl::xml_memory_page*>(_root->header & impl::xml_memory_page_pointer_mask);
+			assert(root_page && !root_page->prev && !root_page->memory);
+
+			// destroy all pages
+			for (impl::xml_memory_page* page = root_page->next; page; )
+			{
+				impl::xml_memory_page* next = page->next;
+
+				impl::xml_allocator::deallocate_page(page);
+
+				page = next;
+			}
+
+			// cleanup root page
+			root_page->allocator = 0;
+			root_page->next = 0;
+			root_page->busy_size = root_page->freed_size = 0;
+
+			_root = 0;
+		}
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN xml_parse_result xml_document::load(std::basic_istream<char, std::char_traits<char> >& stream, unsigned int options, xml_encoding encoding)
+	{
+		reset();
+
+		return impl::load_stream_impl(*this, stream, options, encoding);
+	}
+
+	PUGI__FN xml_parse_result xml_document::load(std::basic_istream<wchar_t, std::char_traits<wchar_t> >& stream, unsigned int options)
+	{
+		reset();
+
+		return impl::load_stream_impl(*this, stream, options, encoding_wchar);
+	}
+#endif
+
+	PUGI__FN xml_parse_result xml_document::load(const char_t* contents, unsigned int options)
+	{
+		// Force native encoding (skip autodetection)
+	#ifdef PUGIXML_WCHAR_MODE
+		xml_encoding encoding = encoding_wchar;
+	#else
+		xml_encoding encoding = encoding_utf8;
+	#endif
+
+		return load_buffer(contents, impl::strlength(contents) * sizeof(char_t), options, encoding);
+	}
+
+	PUGI__FN xml_parse_result xml_document::load_file(const char* path_, unsigned int options, xml_encoding encoding)
+	{
+		reset();
+
+		FILE* file = fopen(path_, "rb");
+
+		return impl::load_file_impl(*this, file, options, encoding);
+	}
+
+	PUGI__FN xml_parse_result xml_document::load_file(const wchar_t* path_, unsigned int options, xml_encoding encoding)
+	{
+		reset();
+
+		FILE* file = impl::open_file_wide(path_, L"rb");
+
+		return impl::load_file_impl(*this, file, options, encoding);
+	}
+
+	PUGI__FN xml_parse_result xml_document::load_buffer_impl(void* contents, size_t size, unsigned int options, xml_encoding encoding, bool is_mutable, bool own)
+	{
+		reset();
+
+		// check input buffer
+		assert(contents || size == 0);
+
+		// get actual encoding
+		xml_encoding buffer_encoding = impl::get_buffer_encoding(encoding, contents, size);
+
+		// get private buffer
+		char_t* buffer = 0;
+		size_t length = 0;
+
+		if (!impl::convert_buffer(buffer, length, buffer_encoding, contents, size, is_mutable)) return impl::make_parse_result(status_out_of_memory);
+		
+		// delete original buffer if we performed a conversion
+		if (own && buffer != contents && contents) impl::xml_memory::deallocate(contents);
+
+		// parse
+		xml_parse_result res = impl::xml_parser::parse(buffer, length, _root, options);
+
+		// remember encoding
+		res.encoding = buffer_encoding;
+
+		// grab onto buffer if it's our buffer, user is responsible for deallocating contens himself
+		if (own || buffer != contents) _buffer = buffer;
+
+		return res;
+	}
+
+	PUGI__FN xml_parse_result xml_document::load_buffer(const void* contents, size_t size, unsigned int options, xml_encoding encoding)
+	{
+		return load_buffer_impl(const_cast<void*>(contents), size, options, encoding, false, false);
+	}
+
+	PUGI__FN xml_parse_result xml_document::load_buffer_inplace(void* contents, size_t size, unsigned int options, xml_encoding encoding)
+	{
+		return load_buffer_impl(contents, size, options, encoding, true, false);
+	}
+		
+	PUGI__FN xml_parse_result xml_document::load_buffer_inplace_own(void* contents, size_t size, unsigned int options, xml_encoding encoding)
+	{
+		return load_buffer_impl(contents, size, options, encoding, true, true);
+	}
+
+	PUGI__FN void xml_document::save(xml_writer& writer, const char_t* indent, unsigned int flags, xml_encoding encoding) const
+	{
+		impl::xml_buffered_writer buffered_writer(writer, encoding);
+
+		if ((flags & format_write_bom) && encoding != encoding_latin1)
+		{
+			// BOM always represents the codepoint U+FEFF, so just write it in native encoding
+		#ifdef PUGIXML_WCHAR_MODE
+			unsigned int bom = 0xfeff;
+			buffered_writer.write(static_cast<wchar_t>(bom));
+		#else
+			buffered_writer.write('\xef', '\xbb', '\xbf');
+		#endif
+		}
+
+		if (!(flags & format_no_declaration) && !impl::has_declaration(*this))
+		{
+			buffered_writer.write(PUGIXML_TEXT("<?xml version=\"1.0\""));
+			if (encoding == encoding_latin1) buffered_writer.write(PUGIXML_TEXT(" encoding=\"ISO-8859-1\""));
+			buffered_writer.write('?', '>');
+			if (!(flags & format_raw)) buffered_writer.write('\n');
+		}
+
+		impl::node_output(buffered_writer, *this, indent, flags, 0);
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN void xml_document::save(std::basic_ostream<char, std::char_traits<char> >& stream, const char_t* indent, unsigned int flags, xml_encoding encoding) const
+	{
+		xml_writer_stream writer(stream);
+
+		save(writer, indent, flags, encoding);
+	}
+
+	PUGI__FN void xml_document::save(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream, const char_t* indent, unsigned int flags) const
+	{
+		xml_writer_stream writer(stream);
+
+		save(writer, indent, flags, encoding_wchar);
+	}
+#endif
+
+	PUGI__FN bool xml_document::save_file(const char* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const
+	{
+		FILE* file = fopen(path_, (flags & format_save_file_text) ? "w" : "wb");
+		return impl::save_file_impl(*this, file, indent, flags, encoding);
+	}
+
+	PUGI__FN bool xml_document::save_file(const wchar_t* path_, const char_t* indent, unsigned int flags, xml_encoding encoding) const
+	{
+		FILE* file = impl::open_file_wide(path_, (flags & format_save_file_text) ? L"w" : L"wb");
+		return impl::save_file_impl(*this, file, indent, flags, encoding);
+	}
+
+	PUGI__FN xml_node xml_document::document_element() const
+	{
+		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
+			if ((i->header & impl::xml_memory_page_type_mask) + 1 == node_element)
+				return xml_node(i);
+
+		return xml_node();
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN std::string PUGIXML_FUNCTION as_utf8(const wchar_t* str)
+	{
+		assert(str);
+
+		return impl::as_utf8_impl(str, wcslen(str));
+	}
+
+	PUGI__FN std::string PUGIXML_FUNCTION as_utf8(const std::basic_string<wchar_t>& str)
+	{
+		return impl::as_utf8_impl(str.c_str(), str.size());
+	}
+	
+	PUGI__FN std::basic_string<wchar_t> PUGIXML_FUNCTION as_wide(const char* str)
+	{
+		assert(str);
+
+		return impl::as_wide_impl(str, strlen(str));
+	}
+	
+	PUGI__FN std::basic_string<wchar_t> PUGIXML_FUNCTION as_wide(const std::string& str)
+	{
+		return impl::as_wide_impl(str.c_str(), str.size());
+	}
+#endif
+
+	PUGI__FN void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate)
+	{
+		impl::xml_memory::allocate = allocate;
+		impl::xml_memory::deallocate = deallocate;
+	}
+
+	PUGI__FN allocation_function PUGIXML_FUNCTION get_memory_allocation_function()
+	{
+		return impl::xml_memory::allocate;
+	}
+
+	PUGI__FN deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function()
+	{
+		return impl::xml_memory::deallocate;
+	}
+}
+
+#if !defined(PUGIXML_NO_STL) && (defined(_MSC_VER) || defined(__ICC))
+namespace std
+{
+	// Workarounds for (non-standard) iterator category detection for older versions (MSVC7/IC8 and earlier)
+	PUGI__FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_node_iterator&)
+	{
+		return std::bidirectional_iterator_tag();
+	}
+
+	PUGI__FN std::bidirectional_iterator_tag _Iter_cat(const pugi::xml_attribute_iterator&)
+	{
+		return std::bidirectional_iterator_tag();
+	}
+
+	PUGI__FN std::forward_iterator_tag _Iter_cat(const pugi::xml_named_node_iterator&)
+	{
+		return std::forward_iterator_tag();
+	}
+}
+#endif
+
+#if !defined(PUGIXML_NO_STL) && defined(__SUNPRO_CC)
+namespace std
+{
+	// Workarounds for (non-standard) iterator category detection
+	PUGI__FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_node_iterator&)
+	{
+		return std::bidirectional_iterator_tag();
+	}
+
+	PUGI__FN std::bidirectional_iterator_tag __iterator_category(const pugi::xml_attribute_iterator&)
+	{
+		return std::bidirectional_iterator_tag();
+	}
+
+	PUGI__FN std::forward_iterator_tag __iterator_category(const pugi::xml_named_node_iterator&)
+	{
+		return std::forward_iterator_tag();
+	}
+}
+#endif
+
+#ifndef PUGIXML_NO_XPATH
+
+// STL replacements
+PUGI__NS_BEGIN
+	struct equal_to
+	{
+		template <typename T> bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs == rhs;
+		}
+	};
+
+	struct not_equal_to
+	{
+		template <typename T> bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs != rhs;
+		}
+	};
+
+	struct less
+	{
+		template <typename T> bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs < rhs;
+		}
+	};
+
+	struct less_equal
+	{
+		template <typename T> bool operator()(const T& lhs, const T& rhs) const
+		{
+			return lhs <= rhs;
+		}
+	};
+
+	template <typename T> void swap(T& lhs, T& rhs)
+	{
+		T temp = lhs;
+		lhs = rhs;
+		rhs = temp;
+	}
+
+	template <typename I, typename Pred> I min_element(I begin, I end, const Pred& pred)
+	{
+		I result = begin;
+
+		for (I it = begin + 1; it != end; ++it)
+			if (pred(*it, *result))
+				result = it;
+
+		return result;
+	}
+
+	template <typename I> void reverse(I begin, I end)
+	{
+		while (begin + 1 < end) swap(*begin++, *--end);
+	}
+
+	template <typename I> I unique(I begin, I end)
+	{
+		// fast skip head
+		while (begin + 1 < end && *begin != *(begin + 1)) begin++;
+
+		if (begin == end) return begin;
+
+		// last written element
+		I write = begin++; 
+
+		// merge unique elements
+		while (begin != end)
+		{
+			if (*begin != *write)
+				*++write = *begin++;
+			else
+				begin++;
+		}
+
+		// past-the-end (write points to live element)
+		return write + 1;
+	}
+
+	template <typename I> void copy_backwards(I begin, I end, I target)
+	{
+		while (begin != end) *--target = *--end;
+	}
+
+	template <typename I, typename Pred, typename T> void insertion_sort(I begin, I end, const Pred& pred, T*)
+	{
+		assert(begin != end);
+
+		for (I it = begin + 1; it != end; ++it)
+		{
+			T val = *it;
+
+			if (pred(val, *begin))
+			{
+				// move to front
+				copy_backwards(begin, it, it + 1);
+				*begin = val;
+			}
+			else
+			{
+				I hole = it;
+
+				// move hole backwards
+				while (pred(val, *(hole - 1)))
+				{
+					*hole = *(hole - 1);
+					hole--;
+				}
+
+				// fill hole with element
+				*hole = val;
+			}
+		}
+	}
+
+	// std variant for elements with ==
+	template <typename I, typename Pred> void partition(I begin, I middle, I end, const Pred& pred, I* out_eqbeg, I* out_eqend)
+	{
+		I eqbeg = middle, eqend = middle + 1;
+
+		// expand equal range
+		while (eqbeg != begin && *(eqbeg - 1) == *eqbeg) --eqbeg;
+		while (eqend != end && *eqend == *eqbeg) ++eqend;
+
+		// process outer elements
+		I ltend = eqbeg, gtbeg = eqend;
+
+		for (;;)
+		{
+			// find the element from the right side that belongs to the left one
+			for (; gtbeg != end; ++gtbeg)
+				if (!pred(*eqbeg, *gtbeg))
+				{
+					if (*gtbeg == *eqbeg) swap(*gtbeg, *eqend++);
+					else break;
+				}
+
+			// find the element from the left side that belongs to the right one
+			for (; ltend != begin; --ltend)
+				if (!pred(*(ltend - 1), *eqbeg))
+				{
+					if (*eqbeg == *(ltend - 1)) swap(*(ltend - 1), *--eqbeg);
+					else break;
+				}
+
+			// scanned all elements
+			if (gtbeg == end && ltend == begin)
+			{
+				*out_eqbeg = eqbeg;
+				*out_eqend = eqend;
+				return;
+			}
+
+			// make room for elements by moving equal area
+			if (gtbeg == end)
+			{
+				if (--ltend != --eqbeg) swap(*ltend, *eqbeg);
+				swap(*eqbeg, *--eqend);
+			}
+			else if (ltend == begin)
+			{
+				if (eqend != gtbeg) swap(*eqbeg, *eqend);
+				++eqend;
+				swap(*gtbeg++, *eqbeg++);
+			}
+			else swap(*gtbeg++, *--ltend);
+		}
+	}
+
+	template <typename I, typename Pred> void median3(I first, I middle, I last, const Pred& pred)
+	{
+		if (pred(*middle, *first)) swap(*middle, *first);
+		if (pred(*last, *middle)) swap(*last, *middle);
+		if (pred(*middle, *first)) swap(*middle, *first);
+	}
+
+	template <typename I, typename Pred> void median(I first, I middle, I last, const Pred& pred)
+	{
+		if (last - first <= 40)
+		{
+			// median of three for small chunks
+			median3(first, middle, last, pred);
+		}
+		else
+		{
+			// median of nine
+			size_t step = (last - first + 1) / 8;
+
+			median3(first, first + step, first + 2 * step, pred);
+			median3(middle - step, middle, middle + step, pred);
+			median3(last - 2 * step, last - step, last, pred);
+			median3(first + step, middle, last - step, pred);
+		}
+	}
+
+	template <typename I, typename Pred> void sort(I begin, I end, const Pred& pred)
+	{
+		// sort large chunks
+		while (end - begin > 32)
+		{
+			// find median element
+			I middle = begin + (end - begin) / 2;
+			median(begin, middle, end - 1, pred);
+
+			// partition in three chunks (< = >)
+			I eqbeg, eqend;
+			partition(begin, middle, end, pred, &eqbeg, &eqend);
+
+			// loop on larger half
+			if (eqbeg - begin > end - eqend)
+			{
+				sort(eqend, end, pred);
+				end = eqbeg;
+			}
+			else
+			{
+				sort(begin, eqbeg, pred);
+				begin = eqend;
+			}
+		}
+
+		// insertion sort small chunk
+		if (begin != end) insertion_sort(begin, end, pred, &*begin);
+	}
+PUGI__NS_END
+
+// Allocator used for AST and evaluation stacks
+PUGI__NS_BEGIN
+	struct xpath_memory_block
+	{	
+		xpath_memory_block* next;
+
+		char data[
+	#ifdef PUGIXML_MEMORY_XPATH_PAGE_SIZE
+			PUGIXML_MEMORY_XPATH_PAGE_SIZE
+	#else
+			4096
+	#endif
+		];
+	};
+		
+	class xpath_allocator
+	{
+		xpath_memory_block* _root;
+		size_t _root_size;
+
+	public:
+	#ifdef PUGIXML_NO_EXCEPTIONS
+		jmp_buf* error_handler;
+	#endif
+
+		xpath_allocator(xpath_memory_block* root, size_t root_size = 0): _root(root), _root_size(root_size)
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			error_handler = 0;
+		#endif
+		}
+		
+		void* allocate_nothrow(size_t size)
+		{
+			const size_t block_capacity = sizeof(_root->data);
+
+			// align size so that we're able to store pointers in subsequent blocks
+			size = (size + sizeof(void*) - 1) & ~(sizeof(void*) - 1);
+
+			if (_root_size + size <= block_capacity)
+			{
+				void* buf = _root->data + _root_size;
+				_root_size += size;
+				return buf;
+			}
+			else
+			{
+				size_t block_data_size = (size > block_capacity) ? size : block_capacity;
+				size_t block_size = block_data_size + offsetof(xpath_memory_block, data);
+
+				xpath_memory_block* block = static_cast<xpath_memory_block*>(xml_memory::allocate(block_size));
+				if (!block) return 0;
+				
+				block->next = _root;
+				
+				_root = block;
+				_root_size = size;
+				
+				return block->data;
+			}
+		}
+
+		void* allocate(size_t size)
+		{
+			void* result = allocate_nothrow(size);
+
+			if (!result)
+			{
+			#ifdef PUGIXML_NO_EXCEPTIONS
+				assert(error_handler);
+				longjmp(*error_handler, 1);
+			#else
+				throw std::bad_alloc();
+			#endif
+			}
+
+			return result;
+		}
+
+		void* reallocate(void* ptr, size_t old_size, size_t new_size)
+		{
+			// align size so that we're able to store pointers in subsequent blocks
+			old_size = (old_size + sizeof(void*) - 1) & ~(sizeof(void*) - 1);
+			new_size = (new_size + sizeof(void*) - 1) & ~(sizeof(void*) - 1);
+
+			// we can only reallocate the last object
+			assert(ptr == 0 || static_cast<char*>(ptr) + old_size == _root->data + _root_size);
+
+			// adjust root size so that we have not allocated the object at all
+			bool only_object = (_root_size == old_size);
+
+			if (ptr) _root_size -= old_size;
+
+			// allocate a new version (this will obviously reuse the memory if possible)
+			void* result = allocate(new_size);
+			assert(result);
+
+			// we have a new block
+			if (result != ptr && ptr)
+			{
+				// copy old data
+				assert(new_size > old_size);
+				memcpy(result, ptr, old_size);
+
+				// free the previous page if it had no other objects
+				if (only_object)
+				{
+					assert(_root->data == result);
+					assert(_root->next);
+
+					xpath_memory_block* next = _root->next->next;
+
+					if (next)
+					{
+						// deallocate the whole page, unless it was the first one
+						xml_memory::deallocate(_root->next);
+						_root->next = next;
+					}
+				}
+			}
+
+			return result;
+		}
+
+		void revert(const xpath_allocator& state)
+		{
+			// free all new pages
+			xpath_memory_block* cur = _root;
+
+			while (cur != state._root)
+			{
+				xpath_memory_block* next = cur->next;
+
+				xml_memory::deallocate(cur);
+
+				cur = next;
+			}
+
+			// restore state
+			_root = state._root;
+			_root_size = state._root_size;
+		}
+
+		void release()
+		{
+			xpath_memory_block* cur = _root;
+			assert(cur);
+
+			while (cur->next)
+			{
+				xpath_memory_block* next = cur->next;
+
+				xml_memory::deallocate(cur);
+
+				cur = next;
+			}
+		}
+	};
+
+	struct xpath_allocator_capture
+	{
+		xpath_allocator_capture(xpath_allocator* alloc): _target(alloc), _state(*alloc)
+		{
+		}
+
+		~xpath_allocator_capture()
+		{
+			_target->revert(_state);
+		}
+
+		xpath_allocator* _target;
+		xpath_allocator _state;
+	};
+
+	struct xpath_stack
+	{
+		xpath_allocator* result;
+		xpath_allocator* temp;
+	};
+
+	struct xpath_stack_data
+	{
+		xpath_memory_block blocks[2];
+		xpath_allocator result;
+		xpath_allocator temp;
+		xpath_stack stack;
+
+	#ifdef PUGIXML_NO_EXCEPTIONS
+		jmp_buf error_handler;
+	#endif
+
+		xpath_stack_data(): result(blocks + 0), temp(blocks + 1)
+		{
+			blocks[0].next = blocks[1].next = 0;
+
+			stack.result = &result;
+			stack.temp = &temp;
+
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			result.error_handler = temp.error_handler = &error_handler;
+		#endif
+		}
+
+		~xpath_stack_data()
+		{
+			result.release();
+			temp.release();
+		}
+	};
+PUGI__NS_END
+
+// String class
+PUGI__NS_BEGIN
+	class xpath_string
+	{
+		const char_t* _buffer;
+		bool _uses_heap;
+
+		static char_t* duplicate_string(const char_t* string, size_t length, xpath_allocator* alloc)
+		{
+			char_t* result = static_cast<char_t*>(alloc->allocate((length + 1) * sizeof(char_t)));
+			assert(result);
+
+			memcpy(result, string, length * sizeof(char_t));
+			result[length] = 0;
+
+			return result;
+		}
+
+		static char_t* duplicate_string(const char_t* string, xpath_allocator* alloc)
+		{
+			return duplicate_string(string, strlength(string), alloc);
+		}
+
+	public:
+		xpath_string(): _buffer(PUGIXML_TEXT("")), _uses_heap(false)
+		{
+		}
+
+		explicit xpath_string(const char_t* str, xpath_allocator* alloc)
+		{
+			bool empty_ = (*str == 0);
+
+			_buffer = empty_ ? PUGIXML_TEXT("") : duplicate_string(str, alloc);
+			_uses_heap = !empty_;
+		}
+
+		explicit xpath_string(const char_t* str, bool use_heap): _buffer(str), _uses_heap(use_heap)
+		{
+		}
+
+		xpath_string(const char_t* begin, const char_t* end, xpath_allocator* alloc)
+		{
+			assert(begin <= end);
+
+			bool empty_ = (begin == end);
+
+			_buffer = empty_ ? PUGIXML_TEXT("") : duplicate_string(begin, static_cast<size_t>(end - begin), alloc);
+			_uses_heap = !empty_;
+		}
+
+		void append(const xpath_string& o, xpath_allocator* alloc)
+		{
+			// skip empty sources
+			if (!*o._buffer) return;
+
+			// fast append for constant empty target and constant source
+			if (!*_buffer && !_uses_heap && !o._uses_heap)
+			{
+				_buffer = o._buffer;
+			}
+			else
+			{
+				// need to make heap copy
+				size_t target_length = strlength(_buffer);
+				size_t source_length = strlength(o._buffer);
+				size_t result_length = target_length + source_length;
+
+				// allocate new buffer
+				char_t* result = static_cast<char_t*>(alloc->reallocate(_uses_heap ? const_cast<char_t*>(_buffer) : 0, (target_length + 1) * sizeof(char_t), (result_length + 1) * sizeof(char_t)));
+				assert(result);
+
+				// append first string to the new buffer in case there was no reallocation
+				if (!_uses_heap) memcpy(result, _buffer, target_length * sizeof(char_t));
+
+				// append second string to the new buffer
+				memcpy(result + target_length, o._buffer, source_length * sizeof(char_t));
+				result[result_length] = 0;
+
+				// finalize
+				_buffer = result;
+				_uses_heap = true;
+			}
+		}
+
+		const char_t* c_str() const
+		{
+			return _buffer;
+		}
+
+		size_t length() const
+		{
+			return strlength(_buffer);
+		}
+		
+		char_t* data(xpath_allocator* alloc)
+		{
+			// make private heap copy
+			if (!_uses_heap)
+			{
+				_buffer = duplicate_string(_buffer, alloc);
+				_uses_heap = true;
+			}
+
+			return const_cast<char_t*>(_buffer);
+		}
+
+		bool empty() const
+		{
+			return *_buffer == 0;
+		}
+
+		bool operator==(const xpath_string& o) const
+		{
+			return strequal(_buffer, o._buffer);
+		}
+
+		bool operator!=(const xpath_string& o) const
+		{
+			return !strequal(_buffer, o._buffer);
+		}
+
+		bool uses_heap() const
+		{
+			return _uses_heap;
+		}
+	};
+
+	PUGI__FN xpath_string xpath_string_const(const char_t* str)
+	{
+		return xpath_string(str, false);
+	}
+PUGI__NS_END
+
+PUGI__NS_BEGIN
+	PUGI__FN bool starts_with(const char_t* string, const char_t* pattern)
+	{
+		while (*pattern && *string == *pattern)
+		{
+			string++;
+			pattern++;
+		}
+
+		return *pattern == 0;
+	}
+
+	PUGI__FN const char_t* find_char(const char_t* s, char_t c)
+	{
+	#ifdef PUGIXML_WCHAR_MODE
+		return wcschr(s, c);
+	#else
+		return strchr(s, c);
+	#endif
+	}
+
+	PUGI__FN const char_t* find_substring(const char_t* s, const char_t* p)
+	{
+	#ifdef PUGIXML_WCHAR_MODE
+		// MSVC6 wcsstr bug workaround (if s is empty it always returns 0)
+		return (*p == 0) ? s : wcsstr(s, p);
+	#else
+		return strstr(s, p);
+	#endif
+	}
+
+	// Converts symbol to lower case, if it is an ASCII one
+	PUGI__FN char_t tolower_ascii(char_t ch)
+	{
+		return static_cast<unsigned int>(ch - 'A') < 26 ? static_cast<char_t>(ch | ' ') : ch;
+	}
+
+	PUGI__FN xpath_string string_value(const xpath_node& na, xpath_allocator* alloc)
+	{
+		if (na.attribute())
+			return xpath_string_const(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 xpath_string_const(n.value());
+			
+			case node_document:
+			case node_element:
+			{
+				xpath_string result;
+
+				xml_node cur = n.first_child();
+				
+				while (cur && cur != n)
+				{
+					if (cur.type() == node_pcdata || cur.type() == node_cdata)
+						result.append(xpath_string_const(cur.value()), alloc);
+
+					if (cur.first_child())
+						cur = cur.first_child();
+					else if (cur.next_sibling())
+						cur = cur.next_sibling();
+					else
+					{
+						while (!cur.next_sibling() && cur != n)
+							cur = cur.parent();
+
+						if (cur != n) cur = cur.next_sibling();
+					}
+				}
+				
+				return result;
+			}
+			
+			default:
+				return xpath_string();
+			}
+		}
+	}
+	
+	PUGI__FN unsigned int node_height(xml_node n)
+	{
+		unsigned int result = 0;
+		
+		while (n)
+		{
+			++result;
+			n = n.parent();
+		}
+		
+		return result;
+	}
+	
+	PUGI__FN bool node_is_before(xml_node ln, unsigned int lh, xml_node rn, unsigned int rh)
+	{
+		// normalize heights
+		for (unsigned int i = rh; i < lh; i++) ln = ln.parent();
+		for (unsigned int j = lh; j < rh; j++) rn = rn.parent();
+		
+		// one node is the ancestor of the other
+		if (ln == rn) return lh < rh;
+		
+		// find common ancestor
+		while (ln.parent() != rn.parent())
+		{
+			ln = ln.parent();
+			rn = rn.parent();
+		}
+
+		// there is no common ancestor (the shared parent is null), nodes are from different documents
+		if (!ln.parent()) return ln < rn;
+
+		// determine sibling order
+		for (; ln; ln = ln.next_sibling())
+			if (ln == rn)
+				return true;
+				
+		return false;
+	}
+
+	PUGI__FN bool node_is_ancestor(xml_node parent, xml_node node)
+	{
+		while (node && node != parent) node = node.parent();
+
+		return parent && node == parent;
+	}
+
+	PUGI__FN const void* document_order(const xpath_node& xnode)
+	{
+		xml_node_struct* node = xnode.node().internal_object();
+
+		if (node)
+		{
+			if (node->name && (node->header & xml_memory_page_name_allocated_mask) == 0) return node->name;
+			if (node->value && (node->header & xml_memory_page_value_allocated_mask) == 0) return node->value;
+			return 0;
+		}
+
+		xml_attribute_struct* attr = xnode.attribute().internal_object();
+
+		if (attr)
+		{
+			if ((attr->header & xml_memory_page_name_allocated_mask) == 0) return attr->name;
+			if ((attr->header & xml_memory_page_value_allocated_mask) == 0) return attr->value;
+			return 0;
+		}
+
+		return 0;
+	}
+	
+	struct document_order_comparator
+	{
+		bool operator()(const xpath_node& lhs, const xpath_node& rhs) const
+		{
+			// optimized document order based check
+			const void* lo = document_order(lhs);
+			const void* ro = document_order(rhs);
+
+			if (lo && ro) return lo < ro;
+
+			// slow comparison
+			xml_node ln = lhs.node(), rn = rhs.node();
+
+			// compare attributes
+			if (lhs.attribute() && rhs.attribute())
+			{
+				// shared parent
+				if (lhs.parent() == rhs.parent())
+				{
+					// determine sibling order
+					for (xml_attribute a = lhs.attribute(); a; a = a.next_attribute())
+						if (a == rhs.attribute())
+							return true;
+					
+					return false;
+				}
+				
+				// compare attribute parents
+				ln = lhs.parent();
+				rn = rhs.parent();
+			}
+			else if (lhs.attribute())
+			{
+				// attributes go after the parent element
+				if (lhs.parent() == rhs.node()) return false;
+				
+				ln = lhs.parent();
+			}
+			else if (rhs.attribute())
+			{
+				// attributes go after the parent element
+				if (rhs.parent() == lhs.node()) return true;
+				
+				rn = rhs.parent();
+			}
+
+			if (ln == rn) return false;
+			
+			unsigned int lh = node_height(ln);
+			unsigned int rh = node_height(rn);
+			
+			return node_is_before(ln, lh, rn, rh);
+		}
+	};
+
+	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();
+		}
+	};
+	
+	PUGI__FN double gen_nan()
+	{
+	#if defined(__STDC_IEC_559__) || ((FLT_RADIX - 0 == 2) && (FLT_MAX_EXP - 0 == 128) && (FLT_MANT_DIG - 0 == 24))
+		union { float f; uint32_t i; } u[sizeof(float) == sizeof(uint32_t) ? 1 : -1];
+		u[0].i = 0x7fc00000;
+		return u[0].f;
+	#else
+		// fallback
+		const volatile double zero = 0.0;
+		return zero / zero;
+	#endif
+	}
+	
+	PUGI__FN bool is_nan(double value)
+	{
+	#if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__)
+		return !!_isnan(value);
+	#elif defined(fpclassify) && defined(FP_NAN)
+		return fpclassify(value) == FP_NAN;
+	#else
+		// fallback
+		const volatile double v = value;
+		return v != v;
+	#endif
+	}
+	
+	PUGI__FN const char_t* convert_number_to_string_special(double value)
+	{
+	#if defined(PUGI__MSVC_CRT_VERSION) || defined(__BORLANDC__)
+		if (_finite(value)) return (value == 0) ? PUGIXML_TEXT("0") : 0;
+		if (_isnan(value)) return PUGIXML_TEXT("NaN");
+		return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
+	#elif defined(fpclassify) && defined(FP_NAN) && defined(FP_INFINITE) && defined(FP_ZERO)
+		switch (fpclassify(value))
+		{
+		case FP_NAN:
+			return PUGIXML_TEXT("NaN");
+
+		case FP_INFINITE:
+			return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
+
+		case FP_ZERO:
+			return PUGIXML_TEXT("0");
+
+		default:
+			return 0;
+		}
+	#else
+		// fallback
+		const volatile double v = value;
+
+		if (v == 0) return PUGIXML_TEXT("0");
+		if (v != v) return PUGIXML_TEXT("NaN");
+		if (v * 2 == v) return value > 0 ? PUGIXML_TEXT("Infinity") : PUGIXML_TEXT("-Infinity");
+		return 0;
+	#endif
+	}
+	
+	PUGI__FN bool convert_number_to_boolean(double value)
+	{
+		return (value != 0 && !is_nan(value));
+	}
+	
+	PUGI__FN void truncate_zeros(char* begin, char* end)
+	{
+		while (begin != end && end[-1] == '0') end--;
+
+		*end = 0;
+	}
+
+	// gets mantissa digits in the form of 0.xxxxx with 0. implied and the exponent
+#if defined(PUGI__MSVC_CRT_VERSION) && PUGI__MSVC_CRT_VERSION >= 1400 && !defined(_WIN32_WCE)
+	PUGI__FN void convert_number_to_mantissa_exponent(double value, char* buffer, size_t buffer_size, char** out_mantissa, int* out_exponent)
+	{
+		// get base values
+		int sign, exponent;
+		_ecvt_s(buffer, buffer_size, value, DBL_DIG + 1, &exponent, &sign);
+
+		// truncate redundant zeros
+		truncate_zeros(buffer, buffer + strlen(buffer));
+
+		// fill results
+		*out_mantissa = buffer;
+		*out_exponent = exponent;
+	}
+#else
+	PUGI__FN void convert_number_to_mantissa_exponent(double value, char* buffer, size_t buffer_size, char** out_mantissa, int* out_exponent)
+	{
+		// get a scientific notation value with IEEE DBL_DIG decimals
+		sprintf(buffer, "%.*e", DBL_DIG, value);
+		assert(strlen(buffer) < buffer_size);
+		(void)!buffer_size;
+
+		// get the exponent (possibly negative)
+		char* exponent_string = strchr(buffer, 'e');
+		assert(exponent_string);
+
+		int exponent = atoi(exponent_string + 1);
+
+		// extract mantissa string: skip sign
+		char* mantissa = buffer[0] == '-' ? buffer + 1 : buffer;
+		assert(mantissa[0] != '0' && mantissa[1] == '.');
+
+		// divide mantissa by 10 to eliminate integer part
+		mantissa[1] = mantissa[0];
+		mantissa++;
+		exponent++;
+
+		// remove extra mantissa digits and zero-terminate mantissa
+		truncate_zeros(mantissa, exponent_string);
+
+		// fill results
+		*out_mantissa = mantissa;
+		*out_exponent = exponent;
+	}
+#endif
+
+	PUGI__FN xpath_string convert_number_to_string(double value, xpath_allocator* alloc)
+	{
+		// try special number conversion
+		const char_t* special = convert_number_to_string_special(value);
+		if (special) return xpath_string_const(special);
+
+		// get mantissa + exponent form
+		char mantissa_buffer[64];
+
+		char* mantissa;
+		int exponent;
+		convert_number_to_mantissa_exponent(value, mantissa_buffer, sizeof(mantissa_buffer), &mantissa, &exponent);
+
+		// make the number!
+		char_t result[512];
+		char_t* s = result;
+
+		// sign
+		if (value < 0) *s++ = '-';
+
+		// integer part
+		if (exponent <= 0)
+		{
+			*s++ = '0';
+		}
+		else
+		{
+			while (exponent > 0)
+			{
+				assert(*mantissa == 0 || static_cast<unsigned int>(*mantissa - '0') <= 9);
+				*s++ = *mantissa ? *mantissa++ : '0';
+				exponent--;
+			}
+		}
+
+		// fractional part
+		if (*mantissa)
+		{
+			// decimal point
+			*s++ = '.';
+
+			// extra zeroes from negative exponent
+			while (exponent < 0)
+			{
+				*s++ = '0';
+				exponent++;
+			}
+
+			// extra mantissa digits
+			while (*mantissa)
+			{
+				assert(static_cast<unsigned int>(*mantissa - '0') <= 9);
+				*s++ = *mantissa++;
+			}
+		}
+
+		// zero-terminate
+		assert(s < result + sizeof(result) / sizeof(result[0]));
+		*s = 0;
+
+		return xpath_string(result, alloc);
+	}
+	
+	PUGI__FN bool check_string_to_number_format(const char_t* string)
+	{
+		// parse leading whitespace
+		while (PUGI__IS_CHARTYPE(*string, ct_space)) ++string;
+
+		// parse sign
+		if (*string == '-') ++string;
+
+		if (!*string) return false;
+
+		// if there is no integer part, there should be a decimal part with at least one digit
+		if (!PUGI__IS_CHARTYPEX(string[0], ctx_digit) && (string[0] != '.' || !PUGI__IS_CHARTYPEX(string[1], ctx_digit))) return false;
+
+		// parse integer part
+		while (PUGI__IS_CHARTYPEX(*string, ctx_digit)) ++string;
+
+		// parse decimal part
+		if (*string == '.')
+		{
+			++string;
+
+			while (PUGI__IS_CHARTYPEX(*string, ctx_digit)) ++string;
+		}
+
+		// parse trailing whitespace
+		while (PUGI__IS_CHARTYPE(*string, ct_space)) ++string;
+
+		return *string == 0;
+	}
+
+	PUGI__FN double convert_string_to_number(const char_t* string)
+	{
+		// check string format
+		if (!check_string_to_number_format(string)) return gen_nan();
+
+		// parse string
+	#ifdef PUGIXML_WCHAR_MODE
+		return wcstod(string, 0);
+	#else
+		return atof(string);
+	#endif
+	}
+
+	PUGI__FN bool convert_string_to_number(const char_t* begin, const char_t* end, double* out_result)
+	{
+		char_t buffer[32];
+
+		size_t length = static_cast<size_t>(end - begin);
+		char_t* scratch = buffer;
+
+		if (length >= sizeof(buffer) / sizeof(buffer[0]))
+		{
+			// need to make dummy on-heap copy
+			scratch = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
+			if (!scratch) return false;
+		}
+
+		// copy string to zero-terminated buffer and perform conversion
+		memcpy(scratch, begin, length * sizeof(char_t));
+		scratch[length] = 0;
+
+		*out_result = convert_string_to_number(scratch);
+
+		// free dummy buffer
+		if (scratch != buffer) xml_memory::deallocate(scratch);
+
+		return true;
+	}
+	
+	PUGI__FN double round_nearest(double value)
+	{
+		return floor(value + 0.5);
+	}
+
+	PUGI__FN double round_nearest_nzero(double value)
+	{
+		// same as round_nearest, but returns -0 for [-0.5, -0]
+		// ceil is used to differentiate between +0 and -0 (we return -0 for [-0.5, -0] and +0 for +0)
+		return (value >= -0.5 && value <= 0) ? ceil(value) : floor(value + 0.5);
+	}
+	
+	PUGI__FN const char_t* qualified_name(const xpath_node& node)
+	{
+		return node.attribute() ? node.attribute().name() : node.node().name();
+	}
+	
+	PUGI__FN const char_t* local_name(const xpath_node& node)
+	{
+		const char_t* name = qualified_name(node);
+		const char_t* p = find_char(name, ':');
+		
+		return p ? p + 1 : name;
+	}
+
+	struct namespace_uri_predicate
+	{
+		const char_t* prefix;
+		size_t prefix_length;
+
+		namespace_uri_predicate(const char_t* name)
+		{
+			const char_t* pos = find_char(name, ':');
+
+			prefix = pos ? name : 0;
+			prefix_length = pos ? static_cast<size_t>(pos - name) : 0;
+		}
+
+		bool operator()(const xml_attribute& a) const
+		{
+			const char_t* name = a.name();
+
+			if (!starts_with(name, PUGIXML_TEXT("xmlns"))) return false;
+
+			return prefix ? name[5] == ':' && strequalrange(name + 6, prefix, prefix_length) : name[5] == 0;
+		}
+	};
+
+	PUGI__FN const char_t* namespace_uri(const xml_node& node)
+	{
+		namespace_uri_predicate pred = node.name();
+		
+		xml_node p = node;
+		
+		while (p)
+		{
+			xml_attribute a = p.find_attribute(pred);
+			
+			if (a) return a.value();
+			
+			p = p.parent();
+		}
+		
+		return PUGIXML_TEXT("");
+	}
+
+	PUGI__FN const char_t* namespace_uri(const xml_attribute& attr, const xml_node& parent)
+	{
+		namespace_uri_predicate pred = attr.name();
+		
+		// Default namespace does not apply to attributes
+		if (!pred.prefix) return PUGIXML_TEXT("");
+		
+		xml_node p = parent;
+		
+		while (p)
+		{
+			xml_attribute a = p.find_attribute(pred);
+			
+			if (a) return a.value();
+			
+			p = p.parent();
+		}
+		
+		return PUGIXML_TEXT("");
+	}
+
+	PUGI__FN const char_t* namespace_uri(const xpath_node& node)
+	{
+		return node.attribute() ? namespace_uri(node.attribute(), node.parent()) : namespace_uri(node.node());
+	}
+
+	PUGI__FN void normalize_space(char_t* buffer)
+	{
+		char_t* write = buffer;
+
+		for (char_t* it = buffer; *it; )
+		{
+			char_t ch = *it++;
+
+			if (PUGI__IS_CHARTYPE(ch, ct_space))
+			{
+				// replace whitespace sequence with single space
+				while (PUGI__IS_CHARTYPE(*it, ct_space)) it++;
+
+				// avoid leading spaces
+				if (write != buffer) *write++ = ' ';
+			}
+			else *write++ = ch;
+		}
+
+		// remove trailing space
+		if (write != buffer && PUGI__IS_CHARTYPE(write[-1], ct_space)) write--;
+
+		// zero-terminate
+		*write = 0;
+	}
+
+	PUGI__FN void translate(char_t* buffer, const char_t* from, const char_t* to)
+	{
+		size_t to_length = strlength(to);
+
+		char_t* write = buffer;
+
+		while (*buffer)
+		{
+			PUGI__DMC_VOLATILE char_t ch = *buffer++;
+
+			const char_t* pos = find_char(from, ch);
+
+			if (!pos)
+				*write++ = ch; // do not process
+			else if (static_cast<size_t>(pos - from) < to_length)
+				*write++ = to[pos - from]; // replace
+		}
+
+		// zero-terminate
+		*write = 0;
+	}
+
+	struct xpath_variable_boolean: xpath_variable
+	{
+		xpath_variable_boolean(): value(false)
+		{
+		}
+
+		bool value;
+		char_t name[1];
+	};
+
+	struct xpath_variable_number: xpath_variable
+	{
+		xpath_variable_number(): value(0)
+		{
+		}
+
+		double value;
+		char_t name[1];
+	};
+
+	struct xpath_variable_string: xpath_variable
+	{
+		xpath_variable_string(): value(0)
+		{
+		}
+
+		~xpath_variable_string()
+		{
+			if (value) xml_memory::deallocate(value);
+		}
+
+		char_t* value;
+		char_t name[1];
+	};
+
+	struct xpath_variable_node_set: xpath_variable
+	{
+		xpath_node_set value;
+		char_t name[1];
+	};
+
+	static const xpath_node_set dummy_node_set;
+
+	PUGI__FN unsigned int hash_string(const char_t* str)
+	{
+		// Jenkins one-at-a-time hash (http://en.wikipedia.org/wiki/Jenkins_hash_function#one-at-a-time)
+		unsigned int result = 0;
+
+		while (*str)
+		{
+			result += static_cast<unsigned int>(*str++);
+			result += result << 10;
+			result ^= result >> 6;
+		}
+	
+		result += result << 3;
+		result ^= result >> 11;
+		result += result << 15;
+	
+		return result;
+	}
+
+	template <typename T> PUGI__FN T* new_xpath_variable(const char_t* name)
+	{
+		size_t length = strlength(name);
+		if (length == 0) return 0; // empty variable names are invalid
+
+		// $$ we can't use offsetof(T, name) because T is non-POD, so we just allocate additional length characters
+		void* memory = xml_memory::allocate(sizeof(T) + length * sizeof(char_t));
+		if (!memory) return 0;
+
+		T* result = new (memory) T();
+
+		memcpy(result->name, name, (length + 1) * sizeof(char_t));
+
+		return result;
+	}
+
+	PUGI__FN xpath_variable* new_xpath_variable(xpath_value_type type, const char_t* name)
+	{
+		switch (type)
+		{
+		case xpath_type_node_set:
+			return new_xpath_variable<xpath_variable_node_set>(name);
+
+		case xpath_type_number:
+			return new_xpath_variable<xpath_variable_number>(name);
+
+		case xpath_type_string:
+			return new_xpath_variable<xpath_variable_string>(name);
+
+		case xpath_type_boolean:
+			return new_xpath_variable<xpath_variable_boolean>(name);
+
+		default:
+			return 0;
+		}
+	}
+
+	template <typename T> PUGI__FN void delete_xpath_variable(T* var)
+	{
+		var->~T();
+		xml_memory::deallocate(var);
+	}
+
+	PUGI__FN void delete_xpath_variable(xpath_value_type type, xpath_variable* var)
+	{
+		switch (type)
+		{
+		case xpath_type_node_set:
+			delete_xpath_variable(static_cast<xpath_variable_node_set*>(var));
+			break;
+
+		case xpath_type_number:
+			delete_xpath_variable(static_cast<xpath_variable_number*>(var));
+			break;
+
+		case xpath_type_string:
+			delete_xpath_variable(static_cast<xpath_variable_string*>(var));
+			break;
+
+		case xpath_type_boolean:
+			delete_xpath_variable(static_cast<xpath_variable_boolean*>(var));
+			break;
+
+		default:
+			assert(!"Invalid variable type");
+		}
+	}
+
+	PUGI__FN xpath_variable* get_variable(xpath_variable_set* set, const char_t* begin, const char_t* end)
+	{
+		char_t buffer[32];
+
+		size_t length = static_cast<size_t>(end - begin);
+		char_t* scratch = buffer;
+
+		if (length >= sizeof(buffer) / sizeof(buffer[0]))
+		{
+			// need to make dummy on-heap copy
+			scratch = static_cast<char_t*>(xml_memory::allocate((length + 1) * sizeof(char_t)));
+			if (!scratch) return 0;
+		}
+
+		// copy string to zero-terminated buffer and perform lookup
+		memcpy(scratch, begin, length * sizeof(char_t));
+		scratch[length] = 0;
+
+		xpath_variable* result = set->get(scratch);
+
+		// free dummy buffer
+		if (scratch != buffer) xml_memory::deallocate(scratch);
+
+		return result;
+	}
+PUGI__NS_END
+
+// Internal node set class
+PUGI__NS_BEGIN
+	PUGI__FN xpath_node_set::type_t xpath_sort(xpath_node* begin, xpath_node* end, xpath_node_set::type_t type, bool rev)
+	{
+		xpath_node_set::type_t order = rev ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_sorted;
+
+		if (type == xpath_node_set::type_unsorted)
+		{
+			sort(begin, end, document_order_comparator());
+
+			type = xpath_node_set::type_sorted;
+		}
+		
+		if (type != order) reverse(begin, end);
+			
+		return order;
+	}
+
+	PUGI__FN xpath_node xpath_first(const xpath_node* begin, const xpath_node* end, xpath_node_set::type_t type)
+	{
+		if (begin == end) return xpath_node();
+
+		switch (type)
+		{
+		case xpath_node_set::type_sorted:
+			return *begin;
+
+		case xpath_node_set::type_sorted_reverse:
+			return *(end - 1);
+
+		case xpath_node_set::type_unsorted:
+			return *min_element(begin, end, document_order_comparator());
+
+		default:
+			assert(!"Invalid node set type");
+			return xpath_node();
+		}
+	}
+
+	class xpath_node_set_raw
+	{
+		xpath_node_set::type_t _type;
+
+		xpath_node* _begin;
+		xpath_node* _end;
+		xpath_node* _eos;
+
+	public:
+		xpath_node_set_raw(): _type(xpath_node_set::type_unsorted), _begin(0), _end(0), _eos(0)
+		{
+		}
+
+		xpath_node* begin() const
+		{
+			return _begin;
+		}
+
+		xpath_node* end() const
+		{
+			return _end;
+		}
+
+		bool empty() const
+		{
+			return _begin == _end;
+		}
+
+		size_t size() const
+		{
+			return static_cast<size_t>(_end - _begin);
+		}
+
+		xpath_node first() const
+		{
+			return xpath_first(_begin, _end, _type);
+		}
+
+		void push_back(const xpath_node& node, xpath_allocator* alloc)
+		{
+			if (_end == _eos)
+			{
+				size_t capacity = static_cast<size_t>(_eos - _begin);
+
+				// get new capacity (1.5x rule)
+				size_t new_capacity = capacity + capacity / 2 + 1;
+
+				// reallocate the old array or allocate a new one
+				xpath_node* data = static_cast<xpath_node*>(alloc->reallocate(_begin, capacity * sizeof(xpath_node), new_capacity * sizeof(xpath_node)));
+				assert(data);
+
+				// finalize
+				_begin = data;
+				_end = data + capacity;
+				_eos = data + new_capacity;
+			}
+
+			*_end++ = node;
+		}
+
+		void append(const xpath_node* begin_, const xpath_node* end_, xpath_allocator* alloc)
+		{
+			size_t size_ = static_cast<size_t>(_end - _begin);
+			size_t capacity = static_cast<size_t>(_eos - _begin);
+			size_t count = static_cast<size_t>(end_ - begin_);
+
+			if (size_ + count > capacity)
+			{
+				// reallocate the old array or allocate a new one
+				xpath_node* data = static_cast<xpath_node*>(alloc->reallocate(_begin, capacity * sizeof(xpath_node), (size_ + count) * sizeof(xpath_node)));
+				assert(data);
+
+				// finalize
+				_begin = data;
+				_end = data + size_;
+				_eos = data + size_ + count;
+			}
+
+			memcpy(_end, begin_, count * sizeof(xpath_node));
+			_end += count;
+		}
+
+		void sort_do()
+		{
+			_type = xpath_sort(_begin, _end, _type, false);
+		}
+
+		void truncate(xpath_node* pos)
+		{
+			assert(_begin <= pos && pos <= _end);
+
+			_end = pos;
+		}
+
+		void remove_duplicates()
+		{
+			if (_type == xpath_node_set::type_unsorted)
+				sort(_begin, _end, duplicate_comparator());
+		
+			_end = unique(_begin, _end);
+		}
+
+		xpath_node_set::type_t type() const
+		{
+			return _type;
+		}
+
+		void set_type(xpath_node_set::type_t value)
+		{
+			_type = value;
+		}
+	};
+PUGI__NS_END
+
+PUGI__NS_BEGIN
+	struct xpath_context
+	{
+		xpath_node n;
+		size_t position, size;
+
+		xpath_context(const xpath_node& n_, size_t position_, size_t size_): n(n_), position(position_), size(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,
+		lex_double_colon,
+		lex_eof
+	};
+
+	struct xpath_lexer_string
+	{
+		const char_t* begin;
+		const char_t* end;
+
+		xpath_lexer_string(): begin(0), end(0)
+		{
+		}
+
+		bool operator==(const char_t* other) const
+		{
+			size_t length = static_cast<size_t>(end - begin);
+
+			return strequalrange(other, begin, length);
+		}
+	};
+
+	class xpath_lexer
+	{
+		const char_t* _cur;
+		const char_t* _cur_lexeme_pos;
+		xpath_lexer_string _cur_lexeme_contents;
+
+		lexeme_t _cur_lexeme;
+
+	public:
+		explicit xpath_lexer(const char_t* query): _cur(query)
+		{
+			next();
+		}
+		
+		const char_t* state() const
+		{
+			return _cur;
+		}
+		
+		void next()
+		{
+			const char_t* cur = _cur;
+
+			while (PUGI__IS_CHARTYPE(*cur, ct_space)) ++cur;
+
+			// save lexeme position for error reporting
+			_cur_lexeme_pos = cur;
+
+			switch (*cur)
+			{
+			case 0:
+				_cur_lexeme = lex_eof;
+				break;
+			
+			case '>':
+				if (*(cur+1) == '=')
+				{
+					cur += 2;
+					_cur_lexeme = lex_greater_or_equal;
+				}
+				else
+				{
+					cur += 1;
+					_cur_lexeme = lex_greater;
+				}
+				break;
+
+			case '<':
+				if (*(cur+1) == '=')
+				{
+					cur += 2;
+					_cur_lexeme = lex_less_or_equal;
+				}
+				else
+				{
+					cur += 1;
+					_cur_lexeme = lex_less;
+				}
+				break;
+
+			case '!':
+				if (*(cur+1) == '=')
+				{
+					cur += 2;
+					_cur_lexeme = lex_not_equal;
+				}
+				else
+				{
+					_cur_lexeme = lex_none;
+				}
+				break;
+
+			case '=':
+				cur += 1;
+				_cur_lexeme = lex_equal;
+
+				break;
+			
+			case '+':
+				cur += 1;
+				_cur_lexeme = lex_plus;
+
+				break;
+
+			case '-':
+				cur += 1;
+				_cur_lexeme = lex_minus;
+
+				break;
+
+			case '*':
+				cur += 1;
+				_cur_lexeme = lex_multiply;
+
+				break;
+
+			case '|':
+				cur += 1;
+				_cur_lexeme = lex_union;
+
+				break;
+			
+			case '$':
+				cur += 1;
+
+				if (PUGI__IS_CHARTYPEX(*cur, ctx_start_symbol))
+				{
+					_cur_lexeme_contents.begin = cur;
+
+					while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
+
+					if (cur[0] == ':' && PUGI__IS_CHARTYPEX(cur[1], ctx_symbol)) // qname
+					{
+						cur++; // :
+
+						while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
+					}
+
+					_cur_lexeme_contents.end = cur;
+				
+					_cur_lexeme = lex_var_ref;
+				}
+				else
+				{
+					_cur_lexeme = lex_none;
+				}
+
+				break;
+
+			case '(':
+				cur += 1;
+				_cur_lexeme = lex_open_brace;
+
+				break;
+
+			case ')':
+				cur += 1;
+				_cur_lexeme = lex_close_brace;
+
+				break;
+			
+			case '[':
+				cur += 1;
+				_cur_lexeme = lex_open_square_brace;
+
+				break;
+
+			case ']':
+				cur += 1;
+				_cur_lexeme = lex_close_square_brace;
+
+				break;
+
+			case ',':
+				cur += 1;
+				_cur_lexeme = lex_comma;
+
+				break;
+
+			case '/':
+				if (*(cur+1) == '/')
+				{
+					cur += 2;
+					_cur_lexeme = lex_double_slash;
+				}
+				else
+				{
+					cur += 1;
+					_cur_lexeme = lex_slash;
+				}
+				break;
+		
+			case '.':
+				if (*(cur+1) == '.')
+				{
+					cur += 2;
+					_cur_lexeme = lex_double_dot;
+				}
+				else if (PUGI__IS_CHARTYPEX(*(cur+1), ctx_digit))
+				{
+					_cur_lexeme_contents.begin = cur; // .
+
+					++cur;
+
+					while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++;
+
+					_cur_lexeme_contents.end = cur;
+					
+					_cur_lexeme = lex_number;
+				}
+				else
+				{
+					cur += 1;
+					_cur_lexeme = lex_dot;
+				}
+				break;
+
+			case '@':
+				cur += 1;
+				_cur_lexeme = lex_axis_attribute;
+
+				break;
+
+			case '"':
+			case '\'':
+			{
+				char_t terminator = *cur;
+
+				++cur;
+
+				_cur_lexeme_contents.begin = cur;
+				while (*cur && *cur != terminator) cur++;
+				_cur_lexeme_contents.end = cur;
+				
+				if (!*cur)
+					_cur_lexeme = lex_none;
+				else
+				{
+					cur += 1;
+					_cur_lexeme = lex_quoted_string;
+				}
+
+				break;
+			}
+
+			case ':':
+				if (*(cur+1) == ':')
+				{
+					cur += 2;
+					_cur_lexeme = lex_double_colon;
+				}
+				else
+				{
+					_cur_lexeme = lex_none;
+				}
+				break;
+
+			default:
+				if (PUGI__IS_CHARTYPEX(*cur, ctx_digit))
+				{
+					_cur_lexeme_contents.begin = cur;
+
+					while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++;
+				
+					if (*cur == '.')
+					{
+						cur++;
+
+						while (PUGI__IS_CHARTYPEX(*cur, ctx_digit)) cur++;
+					}
+
+					_cur_lexeme_contents.end = cur;
+
+					_cur_lexeme = lex_number;
+				}
+				else if (PUGI__IS_CHARTYPEX(*cur, ctx_start_symbol))
+				{
+					_cur_lexeme_contents.begin = cur;
+
+					while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
+
+					if (cur[0] == ':')
+					{
+						if (cur[1] == '*') // namespace test ncname:*
+						{
+							cur += 2; // :*
+						}
+						else if (PUGI__IS_CHARTYPEX(cur[1], ctx_symbol)) // namespace test qname
+						{
+							cur++; // :
+
+							while (PUGI__IS_CHARTYPEX(*cur, ctx_symbol)) cur++;
+						}
+					}
+
+					_cur_lexeme_contents.end = cur;
+				
+					_cur_lexeme = lex_string;
+				}
+				else
+				{
+					_cur_lexeme = lex_none;
+				}
+			}
+
+			_cur = cur;
+		}
+
+		lexeme_t current() const
+		{
+			return _cur_lexeme;
+		}
+
+		const char_t* current_pos() const
+		{
+			return _cur_lexeme_pos;
+		}
+
+		const xpath_lexer_string& contents() const
+		{
+			assert(_cur_lexeme == lex_var_ref || _cur_lexeme == lex_number || _cur_lexeme == lex_string || _cur_lexeme == lex_quoted_string);
+
+			return _cur_lexeme_contents;
+		}
+	};
+
+	enum ast_type_t
+	{
+		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_string_constant,			// string constant
+		ast_number_constant,			// number constant
+		ast_variable,					// variable
+		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 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_none,
+		nodetest_name,
+		nodetest_type_node,
+		nodetest_type_comment,
+		nodetest_type_pi,
+		nodetest_type_text,
+		nodetest_pi,
+		nodetest_all,
+		nodetest_all_in_namespace
+	};
+
+	template <axis_t N> struct axis_to_type
+	{
+		static const axis_t axis;
+	};
+
+	template <axis_t N> const axis_t axis_to_type<N>::axis = N;
+		
+	class xpath_ast_node
+	{
+	private:
+		// node type
+		char _type;
+		char _rettype;
+
+		// for ast_step / ast_predicate
+		char _axis;
+		char _test;
+
+		// tree node structure
+		xpath_ast_node* _left;
+		xpath_ast_node* _right;
+		xpath_ast_node* _next;
+
+		union
+		{
+			// value for ast_string_constant
+			const char_t* string;
+			// value for ast_number_constant
+			double number;
+			// variable for ast_variable
+			xpath_variable* variable;
+			// node test for ast_step (node name/namespace/node type/pi target)
+			const char_t* nodetest;
+		} _data;
+
+		xpath_ast_node(const xpath_ast_node&);
+		xpath_ast_node& operator=(const xpath_ast_node&);
+
+		template <class Comp> static bool compare_eq(xpath_ast_node* lhs, xpath_ast_node* rhs, const xpath_context& c, const xpath_stack& stack, const Comp& comp)
+		{
+			xpath_value_type lt = lhs->rettype(), rt = rhs->rettype();
+
+			if (lt != xpath_type_node_set && rt != xpath_type_node_set)
+			{
+				if (lt == xpath_type_boolean || rt == xpath_type_boolean)
+					return comp(lhs->eval_boolean(c, stack), rhs->eval_boolean(c, stack));
+				else if (lt == xpath_type_number || rt == xpath_type_number)
+					return comp(lhs->eval_number(c, stack), rhs->eval_number(c, stack));
+				else if (lt == xpath_type_string || rt == xpath_type_string)
+				{
+					xpath_allocator_capture cr(stack.result);
+
+					xpath_string ls = lhs->eval_string(c, stack);
+					xpath_string rs = rhs->eval_string(c, stack);
+
+					return comp(ls, rs);
+				}
+			}
+			else if (lt == xpath_type_node_set && rt == xpath_type_node_set)
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_node_set_raw ls = lhs->eval_node_set(c, stack);
+				xpath_node_set_raw rs = rhs->eval_node_set(c, stack);
+
+				for (const xpath_node* li = ls.begin(); li != ls.end(); ++li)
+					for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
+					{
+						xpath_allocator_capture cri(stack.result);
+
+						if (comp(string_value(*li, stack.result), string_value(*ri, stack.result)))
+							return true;
+					}
+
+				return false;
+			}
+			else
+			{
+				if (lt == xpath_type_node_set)
+				{
+					swap(lhs, rhs);
+					swap(lt, rt);
+				}
+
+				if (lt == xpath_type_boolean)
+					return comp(lhs->eval_boolean(c, stack), rhs->eval_boolean(c, stack));
+				else if (lt == xpath_type_number)
+				{
+					xpath_allocator_capture cr(stack.result);
+
+					double l = lhs->eval_number(c, stack);
+					xpath_node_set_raw rs = rhs->eval_node_set(c, stack);
+
+					for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
+					{
+						xpath_allocator_capture cri(stack.result);
+
+						if (comp(l, convert_string_to_number(string_value(*ri, stack.result).c_str())))
+							return true;
+					}
+
+					return false;
+				}
+				else if (lt == xpath_type_string)
+				{
+					xpath_allocator_capture cr(stack.result);
+
+					xpath_string l = lhs->eval_string(c, stack);
+					xpath_node_set_raw rs = rhs->eval_node_set(c, stack);
+
+					for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
+					{
+						xpath_allocator_capture cri(stack.result);
+
+						if (comp(l, string_value(*ri, stack.result)))
+							return true;
+					}
+
+					return false;
+				}
+			}
+
+			assert(!"Wrong types");
+			return false;
+		}
+
+		template <class Comp> static bool compare_rel(xpath_ast_node* lhs, xpath_ast_node* rhs, const xpath_context& c, const xpath_stack& stack, const Comp& comp)
+		{
+			xpath_value_type lt = lhs->rettype(), rt = rhs->rettype();
+
+			if (lt != xpath_type_node_set && rt != xpath_type_node_set)
+				return comp(lhs->eval_number(c, stack), rhs->eval_number(c, stack));
+			else if (lt == xpath_type_node_set && rt == xpath_type_node_set)
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_node_set_raw ls = lhs->eval_node_set(c, stack);
+				xpath_node_set_raw rs = rhs->eval_node_set(c, stack);
+
+				for (const xpath_node* li = ls.begin(); li != ls.end(); ++li)
+				{
+					xpath_allocator_capture cri(stack.result);
+
+					double l = convert_string_to_number(string_value(*li, stack.result).c_str());
+
+					for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
+					{
+						xpath_allocator_capture crii(stack.result);
+
+						if (comp(l, convert_string_to_number(string_value(*ri, stack.result).c_str())))
+							return true;
+					}
+				}
+
+				return false;
+			}
+			else if (lt != xpath_type_node_set && rt == xpath_type_node_set)
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				double l = lhs->eval_number(c, stack);
+				xpath_node_set_raw rs = rhs->eval_node_set(c, stack);
+
+				for (const xpath_node* ri = rs.begin(); ri != rs.end(); ++ri)
+				{
+					xpath_allocator_capture cri(stack.result);
+
+					if (comp(l, convert_string_to_number(string_value(*ri, stack.result).c_str())))
+						return true;
+				}
+
+				return false;
+			}
+			else if (lt == xpath_type_node_set && rt != xpath_type_node_set)
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_node_set_raw ls = lhs->eval_node_set(c, stack);
+				double r = rhs->eval_number(c, stack);
+
+				for (const xpath_node* li = ls.begin(); li != ls.end(); ++li)
+				{
+					xpath_allocator_capture cri(stack.result);
+
+					if (comp(convert_string_to_number(string_value(*li, stack.result).c_str()), r))
+						return true;
+				}
+
+				return false;
+			}
+			else
+			{
+				assert(!"Wrong types");
+				return false;
+			}
+		}
+
+		void apply_predicate(xpath_node_set_raw& ns, size_t first, xpath_ast_node* expr, const xpath_stack& stack)
+		{
+			assert(ns.size() >= first);
+
+			size_t i = 1;
+			size_t size = ns.size() - first;
+				
+			xpath_node* last = ns.begin() + first;
+				
+			// remove_if... or well, sort of
+			for (xpath_node* it = last; it != ns.end(); ++it, ++i)
+			{
+				xpath_context c(*it, i, size);
+			
+				if (expr->rettype() == xpath_type_number)
+				{
+					if (expr->eval_number(c, stack) == i)
+						*last++ = *it;
+				}
+				else if (expr->eval_boolean(c, stack))
+					*last++ = *it;
+			}
+			
+			ns.truncate(last);
+		}
+
+		void apply_predicates(xpath_node_set_raw& ns, size_t first, const xpath_stack& stack)
+		{
+			if (ns.size() == first) return;
+			
+			for (xpath_ast_node* pred = _right; pred; pred = pred->_next)
+			{
+				apply_predicate(ns, first, pred->_left, stack);
+			}
+		}
+
+		void step_push(xpath_node_set_raw& ns, const xml_attribute& a, const xml_node& parent, xpath_allocator* alloc)
+		{
+			if (!a) return;
+
+			const char_t* name = a.name();
+
+			// There are no attribute nodes corresponding to attributes that declare namespaces
+			// That is, "xmlns:..." or "xmlns"
+			if (starts_with(name, PUGIXML_TEXT("xmlns")) && (name[5] == 0 || name[5] == ':')) return;
+			
+			switch (_test)
+			{
+			case nodetest_name:
+				if (strequal(name, _data.nodetest)) ns.push_back(xpath_node(a, parent), alloc);
+				break;
+				
+			case nodetest_type_node:
+			case nodetest_all:
+				ns.push_back(xpath_node(a, parent), alloc);
+				break;
+				
+			case nodetest_all_in_namespace:
+				if (starts_with(name, _data.nodetest))
+					ns.push_back(xpath_node(a, parent), alloc);
+				break;
+			
+			default:
+				;
+			}
+		}
+		
+		void step_push(xpath_node_set_raw& ns, const xml_node& n, xpath_allocator* alloc)
+		{
+			if (!n) return;
+
+			switch (_test)
+			{
+			case nodetest_name:
+				if (n.type() == node_element && strequal(n.name(), _data.nodetest)) ns.push_back(n, alloc);
+				break;
+				
+			case nodetest_type_node:
+				ns.push_back(n, alloc);
+				break;
+				
+			case nodetest_type_comment:
+				if (n.type() == node_comment)
+					ns.push_back(n, alloc);
+				break;
+				
+			case nodetest_type_text:
+				if (n.type() == node_pcdata || n.type() == node_cdata)
+					ns.push_back(n, alloc);
+				break;
+				
+			case nodetest_type_pi:
+				if (n.type() == node_pi)
+					ns.push_back(n, alloc);
+				break;
+									
+			case nodetest_pi:
+				if (n.type() == node_pi && strequal(n.name(), _data.nodetest))
+					ns.push_back(n, alloc);
+				break;
+				
+			case nodetest_all:
+				if (n.type() == node_element)
+					ns.push_back(n, alloc);
+				break;
+				
+			case nodetest_all_in_namespace:
+				if (n.type() == node_element && starts_with(n.name(), _data.nodetest))
+					ns.push_back(n, alloc);
+				break;
+
+			default:
+				assert(!"Unknown axis");
+			} 
+		}
+
+		template <class T> void step_fill(xpath_node_set_raw& ns, const xml_node& n, xpath_allocator* alloc, T)
+		{
+			const axis_t axis = T::axis;
+
+			switch (axis)
+			{
+			case axis_attribute:
+			{
+				for (xml_attribute a = n.first_attribute(); a; a = a.next_attribute())
+					step_push(ns, a, n, alloc);
+				
+				break;
+			}
+			
+			case axis_child:
+			{
+				for (xml_node c = n.first_child(); c; c = c.next_sibling())
+					step_push(ns, c, alloc);
+					
+				break;
+			}
+			
+			case axis_descendant:
+			case axis_descendant_or_self:
+			{
+				if (axis == axis_descendant_or_self)
+					step_push(ns, n, alloc);
+					
+				xml_node cur = n.first_child();
+				
+				while (cur && cur != n)
+				{
+					step_push(ns, cur, alloc);
+					
+					if (cur.first_child())
+						cur = cur.first_child();
+					else if (cur.next_sibling())
+						cur = cur.next_sibling();
+					else
+					{
+						while (!cur.next_sibling() && cur != n)
+							cur = cur.parent();
+					
+						if (cur != n) cur = cur.next_sibling();
+					}
+				}
+				
+				break;
+			}
+			
+			case axis_following_sibling:
+			{
+				for (xml_node c = n.next_sibling(); c; c = c.next_sibling())
+					step_push(ns, c, alloc);
+				
+				break;
+			}
+			
+			case axis_preceding_sibling:
+			{
+				for (xml_node c = n.previous_sibling(); c; c = c.previous_sibling())
+					step_push(ns, c, alloc);
+				
+				break;
+			}
+			
+			case axis_following:
+			{
+				xml_node cur = n;
+
+				// exit from this node so that we don't include descendants
+				while (cur && !cur.next_sibling()) cur = cur.parent();
+				cur = cur.next_sibling();
+
+				for (;;)
+				{
+					step_push(ns, cur, alloc);
+
+					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;
+					}
+				}
+
+				break;
+			}
+
+			case axis_preceding:
+			{
+				xml_node cur = n;
+
+				while (cur && !cur.previous_sibling()) cur = cur.parent();
+				cur = cur.previous_sibling();
+
+				for (;;)
+				{
+					if (cur.last_child())
+						cur = cur.last_child();
+					else
+					{
+						// leaf node, can't be ancestor
+						step_push(ns, cur, alloc);
+
+						if (cur.previous_sibling())
+							cur = cur.previous_sibling();
+						else
+						{
+							do 
+							{
+								cur = cur.parent();
+								if (!cur) break;
+
+								if (!node_is_ancestor(cur, n)) step_push(ns, cur, alloc);
+							}
+							while (!cur.previous_sibling());
+
+							cur = cur.previous_sibling();
+
+							if (!cur) break;
+						}
+					}
+				}
+
+				break;
+			}
+			
+			case axis_ancestor:
+			case axis_ancestor_or_self:
+			{
+				if (axis == axis_ancestor_or_self)
+					step_push(ns, n, alloc);
+
+				xml_node cur = n.parent();
+				
+				while (cur)
+				{
+					step_push(ns, cur, alloc);
+					
+					cur = cur.parent();
+				}
+				
+				break;
+			}
+
+			case axis_self:
+			{
+				step_push(ns, n, alloc);
+
+				break;
+			}
+
+			case axis_parent:
+			{
+				if (n.parent()) step_push(ns, n.parent(), alloc);
+
+				break;
+			}
+				
+			default:
+				assert(!"Unimplemented axis");
+			}
+		}
+		
+		template <class T> void step_fill(xpath_node_set_raw& ns, const xml_attribute& a, const xml_node& p, xpath_allocator* alloc, T v)
+		{
+			const axis_t axis = T::axis;
+
+			switch (axis)
+			{
+			case axis_ancestor:
+			case axis_ancestor_or_self:
+			{
+				if (axis == axis_ancestor_or_self && _test == nodetest_type_node) // reject attributes based on principal node type test
+					step_push(ns, a, p, alloc);
+
+				xml_node cur = p;
+				
+				while (cur)
+				{
+					step_push(ns, cur, alloc);
+					
+					cur = cur.parent();
+				}
+				
+				break;
+			}
+
+			case axis_descendant_or_self:
+			case axis_self:
+			{
+				if (_test == nodetest_type_node) // reject attributes based on principal node type test
+					step_push(ns, a, p, alloc);
+
+				break;
+			}
+
+			case axis_following:
+			{
+				xml_node cur = p;
+				
+				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, alloc);
+				}
+
+				break;
+			}
+
+			case axis_parent:
+			{
+				step_push(ns, p, alloc);
+
+				break;
+			}
+
+			case axis_preceding:
+			{
+				// preceding:: axis does not include attribute nodes and attribute ancestors (they are the same as parent's ancestors), so we can reuse node preceding
+				step_fill(ns, p, alloc, v);
+				break;
+			}
+			
+			default:
+				assert(!"Unimplemented axis");
+			}
+		}
+		
+		template <class T> xpath_node_set_raw step_do(const xpath_context& c, const xpath_stack& stack, T v)
+		{
+			const axis_t axis = T::axis;
+			bool attributes = (axis == axis_ancestor || axis == axis_ancestor_or_self || axis == axis_descendant_or_self || axis == axis_following || axis == axis_parent || axis == axis_preceding || axis == axis_self);
+
+			xpath_node_set_raw ns;
+			ns.set_type((axis == axis_ancestor || axis == axis_ancestor_or_self || axis == axis_preceding || axis == axis_preceding_sibling) ? xpath_node_set::type_sorted_reverse : xpath_node_set::type_sorted);
+
+			if (_left)
+			{
+				xpath_node_set_raw s = _left->eval_node_set(c, stack);
+
+				// self axis preserves the original order
+				if (axis == axis_self) ns.set_type(s.type());
+
+				for (const xpath_node* it = s.begin(); it != s.end(); ++it)
+				{
+					size_t size = ns.size();
+
+					// in general, all axes generate elements in a particular order, but there is no order guarantee if axis is applied to two nodes
+					if (axis != axis_self && size != 0) ns.set_type(xpath_node_set::type_unsorted);
+					
+					if (it->node())
+						step_fill(ns, it->node(), stack.result, v);
+					else if (attributes)
+						step_fill(ns, it->attribute(), it->parent(), stack.result, v);
+						
+					apply_predicates(ns, size, stack);
+				}
+			}
+			else
+			{
+				if (c.n.node())
+					step_fill(ns, c.n.node(), stack.result, v);
+				else if (attributes)
+					step_fill(ns, c.n.attribute(), c.n.parent(), stack.result, v);
+				
+				apply_predicates(ns, 0, stack);
+			}
+
+			// child, attribute and self axes always generate unique set of nodes
+			// for other axis, if the set stayed sorted, it stayed unique because the traversal algorithms do not visit the same node twice
+			if (axis != axis_child && axis != axis_attribute && axis != axis_self && ns.type() == xpath_node_set::type_unsorted)
+				ns.remove_duplicates();
+
+			return ns;
+		}
+		
+	public:
+		xpath_ast_node(ast_type_t type, xpath_value_type rettype_, const char_t* value):
+			_type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(0), _right(0), _next(0)
+		{
+			assert(type == ast_string_constant);
+			_data.string = value;
+		}
+
+		xpath_ast_node(ast_type_t type, xpath_value_type rettype_, double value):
+			_type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(0), _right(0), _next(0)
+		{
+			assert(type == ast_number_constant);
+			_data.number = value;
+		}
+		
+		xpath_ast_node(ast_type_t type, xpath_value_type rettype_, xpath_variable* value):
+			_type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(0), _right(0), _next(0)
+		{
+			assert(type == ast_variable);
+			_data.variable = value;
+		}
+		
+		xpath_ast_node(ast_type_t type, xpath_value_type rettype_, xpath_ast_node* left = 0, xpath_ast_node* right = 0):
+			_type(static_cast<char>(type)), _rettype(static_cast<char>(rettype_)), _axis(0), _test(0), _left(left), _right(right), _next(0)
+		{
+		}
+
+		xpath_ast_node(ast_type_t type, xpath_ast_node* left, axis_t axis, nodetest_t test, const char_t* contents):
+			_type(static_cast<char>(type)), _rettype(xpath_type_node_set), _axis(static_cast<char>(axis)), _test(static_cast<char>(test)), _left(left), _right(0), _next(0)
+		{
+			_data.nodetest = contents;
+		}
+
+		void set_next(xpath_ast_node* value)
+		{
+			_next = value;
+		}
+
+		void set_right(xpath_ast_node* value)
+		{
+			_right = value;
+		}
+
+		bool eval_boolean(const xpath_context& c, const xpath_stack& stack)
+		{
+			switch (_type)
+			{
+			case ast_op_or:
+				return _left->eval_boolean(c, stack) || _right->eval_boolean(c, stack);
+				
+			case ast_op_and:
+				return _left->eval_boolean(c, stack) && _right->eval_boolean(c, stack);
+				
+			case ast_op_equal:
+				return compare_eq(_left, _right, c, stack, equal_to());
+
+			case ast_op_not_equal:
+				return compare_eq(_left, _right, c, stack, not_equal_to());
+	
+			case ast_op_less:
+				return compare_rel(_left, _right, c, stack, less());
+			
+			case ast_op_greater:
+				return compare_rel(_right, _left, c, stack, less());
+
+			case ast_op_less_or_equal:
+				return compare_rel(_left, _right, c, stack, less_equal());
+			
+			case ast_op_greater_or_equal:
+				return compare_rel(_right, _left, c, stack, less_equal());
+
+			case ast_func_starts_with:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_string lr = _left->eval_string(c, stack);
+				xpath_string rr = _right->eval_string(c, stack);
+
+				return starts_with(lr.c_str(), rr.c_str());
+			}
+
+			case ast_func_contains:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_string lr = _left->eval_string(c, stack);
+				xpath_string rr = _right->eval_string(c, stack);
+
+				return find_substring(lr.c_str(), rr.c_str()) != 0;
+			}
+
+			case ast_func_boolean:
+				return _left->eval_boolean(c, stack);
+				
+			case ast_func_not:
+				return !_left->eval_boolean(c, stack);
+				
+			case ast_func_true:
+				return true;
+				
+			case ast_func_false:
+				return false;
+
+			case ast_func_lang:
+			{
+				if (c.n.attribute()) return false;
+				
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_string lang = _left->eval_string(c, stack);
+				
+				for (xml_node n = c.n.node(); n; n = n.parent())
+				{
+					xml_attribute a = n.attribute(PUGIXML_TEXT("xml:lang"));
+					
+					if (a)
+					{
+						const char_t* value = a.value();
+						
+						// strnicmp / strncasecmp is not portable
+						for (const char_t* lit = lang.c_str(); *lit; ++lit)
+						{
+							if (tolower_ascii(*lit) != tolower_ascii(*value)) return false;
+							++value;
+						}
+						
+						return *value == 0 || *value == '-';
+					}
+				}
+				
+				return false;
+			}
+
+			case ast_variable:
+			{
+				assert(_rettype == _data.variable->type());
+
+				if (_rettype == xpath_type_boolean)
+					return _data.variable->get_boolean();
+
+				// fallthrough to type conversion
+			}
+
+			default:
+			{
+				switch (_rettype)
+				{
+				case xpath_type_number:
+					return convert_number_to_boolean(eval_number(c, stack));
+					
+				case xpath_type_string:
+				{
+					xpath_allocator_capture cr(stack.result);
+
+					return !eval_string(c, stack).empty();
+				}
+					
+				case xpath_type_node_set:				
+				{
+					xpath_allocator_capture cr(stack.result);
+
+					return !eval_node_set(c, stack).empty();
+				}
+
+				default:
+					assert(!"Wrong expression for return type boolean");
+					return false;
+				}
+			}
+			}
+		}
+
+		double eval_number(const xpath_context& c, const xpath_stack& stack)
+		{
+			switch (_type)
+			{
+			case ast_op_add:
+				return _left->eval_number(c, stack) + _right->eval_number(c, stack);
+				
+			case ast_op_subtract:
+				return _left->eval_number(c, stack) - _right->eval_number(c, stack);
+
+			case ast_op_multiply:
+				return _left->eval_number(c, stack) * _right->eval_number(c, stack);
+
+			case ast_op_divide:
+				return _left->eval_number(c, stack) / _right->eval_number(c, stack);
+
+			case ast_op_mod:
+				return fmod(_left->eval_number(c, stack), _right->eval_number(c, stack));
+
+			case ast_op_negate:
+				return -_left->eval_number(c, stack);
+
+			case ast_number_constant:
+				return _data.number;
+
+			case ast_func_last:
+				return static_cast<double>(c.size);
+			
+			case ast_func_position:
+				return static_cast<double>(c.position);
+
+			case ast_func_count:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				return static_cast<double>(_left->eval_node_set(c, stack).size());
+			}
+			
+			case ast_func_string_length_0:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				return static_cast<double>(string_value(c.n, stack.result).length());
+			}
+			
+			case ast_func_string_length_1:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				return static_cast<double>(_left->eval_string(c, stack).length());
+			}
+			
+			case ast_func_number_0:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				return convert_string_to_number(string_value(c.n, stack.result).c_str());
+			}
+			
+			case ast_func_number_1:
+				return _left->eval_number(c, stack);
+
+			case ast_func_sum:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				double r = 0;
+				
+				xpath_node_set_raw ns = _left->eval_node_set(c, stack);
+				
+				for (const xpath_node* it = ns.begin(); it != ns.end(); ++it)
+				{
+					xpath_allocator_capture cri(stack.result);
+
+					r += convert_string_to_number(string_value(*it, stack.result).c_str());
+				}
+			
+				return r;
+			}
+
+			case ast_func_floor:
+			{
+				double r = _left->eval_number(c, stack);
+				
+				return r == r ? floor(r) : r;
+			}
+
+			case ast_func_ceiling:
+			{
+				double r = _left->eval_number(c, stack);
+				
+				return r == r ? ceil(r) : r;
+			}
+
+			case ast_func_round:
+				return round_nearest_nzero(_left->eval_number(c, stack));
+			
+			case ast_variable:
+			{
+				assert(_rettype == _data.variable->type());
+
+				if (_rettype == xpath_type_number)
+					return _data.variable->get_number();
+
+				// fallthrough to type conversion
+			}
+
+			default:
+			{
+				switch (_rettype)
+				{
+				case xpath_type_boolean:
+					return eval_boolean(c, stack) ? 1 : 0;
+					
+				case xpath_type_string:
+				{
+					xpath_allocator_capture cr(stack.result);
+
+					return convert_string_to_number(eval_string(c, stack).c_str());
+				}
+					
+				case xpath_type_node_set:
+				{
+					xpath_allocator_capture cr(stack.result);
+
+					return convert_string_to_number(eval_string(c, stack).c_str());
+				}
+					
+				default:
+					assert(!"Wrong expression for return type number");
+					return 0;
+				}
+				
+			}
+			}
+		}
+		
+		xpath_string eval_string_concat(const xpath_context& c, const xpath_stack& stack)
+		{
+			assert(_type == ast_func_concat);
+
+			xpath_allocator_capture ct(stack.temp);
+
+			// count the string number
+			size_t count = 1;
+			for (xpath_ast_node* nc = _right; nc; nc = nc->_next) count++;
+
+			// gather all strings
+			xpath_string static_buffer[4];
+			xpath_string* buffer = static_buffer;
+
+			// allocate on-heap for large concats
+			if (count > sizeof(static_buffer) / sizeof(static_buffer[0]))
+			{
+				buffer = static_cast<xpath_string*>(stack.temp->allocate(count * sizeof(xpath_string)));
+				assert(buffer);
+			}
+
+			// evaluate all strings to temporary stack
+			xpath_stack swapped_stack = {stack.temp, stack.result};
+
+			buffer[0] = _left->eval_string(c, swapped_stack);
+
+			size_t pos = 1;
+			for (xpath_ast_node* n = _right; n; n = n->_next, ++pos) buffer[pos] = n->eval_string(c, swapped_stack);
+			assert(pos == count);
+
+			// get total length
+			size_t length = 0;
+			for (size_t i = 0; i < count; ++i) length += buffer[i].length();
+
+			// create final string
+			char_t* result = static_cast<char_t*>(stack.result->allocate((length + 1) * sizeof(char_t)));
+			assert(result);
+
+			char_t* ri = result;
+
+			for (size_t j = 0; j < count; ++j)
+				for (const char_t* bi = buffer[j].c_str(); *bi; ++bi)
+					*ri++ = *bi;
+
+			*ri = 0;
+
+			return xpath_string(result, true);
+		}
+
+		xpath_string eval_string(const xpath_context& c, const xpath_stack& stack)
+		{
+			switch (_type)
+			{
+			case ast_string_constant:
+				return xpath_string_const(_data.string);
+			
+			case ast_func_local_name_0:
+			{
+				xpath_node na = c.n;
+				
+				return xpath_string_const(local_name(na));
+			}
+
+			case ast_func_local_name_1:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_node_set_raw ns = _left->eval_node_set(c, stack);
+				xpath_node na = ns.first();
+				
+				return xpath_string_const(local_name(na));
+			}
+
+			case ast_func_name_0:
+			{
+				xpath_node na = c.n;
+				
+				return xpath_string_const(qualified_name(na));
+			}
+
+			case ast_func_name_1:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_node_set_raw ns = _left->eval_node_set(c, stack);
+				xpath_node na = ns.first();
+				
+				return xpath_string_const(qualified_name(na));
+			}
+
+			case ast_func_namespace_uri_0:
+			{
+				xpath_node na = c.n;
+				
+				return xpath_string_const(namespace_uri(na));
+			}
+
+			case ast_func_namespace_uri_1:
+			{
+				xpath_allocator_capture cr(stack.result);
+
+				xpath_node_set_raw ns = _left->eval_node_set(c, stack);
+				xpath_node na = ns.first();
+				
+				return xpath_string_const(namespace_uri(na));
+			}
+
+			case ast_func_string_0:
+				return string_value(c.n, stack.result);
+
+			case ast_func_string_1:
+				return _left->eval_string(c, stack);
+
+			case ast_func_concat:
+				return eval_string_concat(c, stack);
+
+			case ast_func_substring_before:
+			{
+				xpath_allocator_capture cr(stack.temp);
+
+				xpath_stack swapped_stack = {stack.temp, stack.result};
+
+				xpath_string s = _left->eval_string(c, swapped_stack);
+				xpath_string p = _right->eval_string(c, swapped_stack);
+
+				const char_t* pos = find_substring(s.c_str(), p.c_str());
+				
+				return pos ? xpath_string(s.c_str(), pos, stack.result) : xpath_string();
+			}
+			
+			case ast_func_substring_after:
+			{
+				xpath_allocator_capture cr(stack.temp);
+
+				xpath_stack swapped_stack = {stack.temp, stack.result};
+
+				xpath_string s = _left->eval_string(c, swapped_stack);
+				xpath_string p = _right->eval_string(c, swapped_stack);
+				
+				const char_t* pos = find_substring(s.c_str(), p.c_str());
+				if (!pos) return xpath_string();
+
+				const char_t* result = pos + p.length();
+
+				return s.uses_heap() ? xpath_string(result, stack.result) : xpath_string_const(result);
+			}
+
+			case ast_func_substring_2:
+			{
+				xpath_allocator_capture cr(stack.temp);
+
+				xpath_stack swapped_stack = {stack.temp, stack.result};
+
+				xpath_string s = _left->eval_string(c, swapped_stack);
+				size_t s_length = s.length();
+
+				double first = round_nearest(_right->eval_number(c, stack));
+				
+				if (is_nan(first)) return xpath_string(); // NaN
+				else if (first >= s_length + 1) return xpath_string();
+				
+				size_t pos = first < 1 ? 1 : static_cast<size_t>(first);
+				assert(1 <= pos && pos <= s_length + 1);
+
+				const char_t* rbegin = s.c_str() + (pos - 1);
+				
+				return s.uses_heap() ? xpath_string(rbegin, stack.result) : xpath_string_const(rbegin);
+			}
+			
+			case ast_func_substring_3:
+			{
+				xpath_allocator_capture cr(stack.temp);
+
+				xpath_stack swapped_stack = {stack.temp, stack.result};
+
+				xpath_string s = _left->eval_string(c, swapped_stack);
+				size_t s_length = s.length();
+
+				double first = round_nearest(_right->eval_number(c, stack));
+				double last = first + round_nearest(_right->_next->eval_number(c, stack));
+				
+				if (is_nan(first) || is_nan(last)) return xpath_string();
+				else if (first >= s_length + 1) return xpath_string();
+				else if (first >= last) return xpath_string();
+				else if (last < 1) return xpath_string();
+				
+				size_t pos = first < 1 ? 1 : static_cast<size_t>(first);
+				size_t end = last >= s_length + 1 ? s_length + 1 : static_cast<size_t>(last);
+
+				assert(1 <= pos && pos <= end && end <= s_length + 1);
+				const char_t* rbegin = s.c_str() + (pos - 1);
+				const char_t* rend = s.c_str() + (end - 1);
+
+				return (end == s_length + 1 && !s.uses_heap()) ? xpath_string_const(rbegin) : xpath_string(rbegin, rend, stack.result);
+			}
+
+			case ast_func_normalize_space_0:
+			{
+				xpath_string s = string_value(c.n, stack.result);
+
+				normalize_space(s.data(stack.result));
+
+				return s;
+			}
+
+			case ast_func_normalize_space_1:
+			{
+				xpath_string s = _left->eval_string(c, stack);
+
+				normalize_space(s.data(stack.result));
+			
+				return s;
+			}
+
+			case ast_func_translate:
+			{
+				xpath_allocator_capture cr(stack.temp);
+
+				xpath_stack swapped_stack = {stack.temp, stack.result};
+
+				xpath_string s = _left->eval_string(c, stack);
+				xpath_string from = _right->eval_string(c, swapped_stack);
+				xpath_string to = _right->_next->eval_string(c, swapped_stack);
+
+				translate(s.data(stack.result), from.c_str(), to.c_str());
+
+				return s;
+			}
+
+			case ast_variable:
+			{
+				assert(_rettype == _data.variable->type());
+
+				if (_rettype == xpath_type_string)
+					return xpath_string_const(_data.variable->get_string());
+
+				// fallthrough to type conversion
+			}
+
+			default:
+			{
+				switch (_rettype)
+				{
+				case xpath_type_boolean:
+					return xpath_string_const(eval_boolean(c, stack) ? PUGIXML_TEXT("true") : PUGIXML_TEXT("false"));
+					
+				case xpath_type_number:
+					return convert_number_to_string(eval_number(c, stack), stack.result);
+					
+				case xpath_type_node_set:
+				{
+					xpath_allocator_capture cr(stack.temp);
+
+					xpath_stack swapped_stack = {stack.temp, stack.result};
+
+					xpath_node_set_raw ns = eval_node_set(c, swapped_stack);
+					return ns.empty() ? xpath_string() : string_value(ns.first(), stack.result);
+				}
+				
+				default:
+					assert(!"Wrong expression for return type string");
+					return xpath_string();
+				}
+			}
+			}
+		}
+
+		xpath_node_set_raw eval_node_set(const xpath_context& c, const xpath_stack& stack)
+		{
+			switch (_type)
+			{
+			case ast_op_union:
+			{
+				xpath_allocator_capture cr(stack.temp);
+
+				xpath_stack swapped_stack = {stack.temp, stack.result};
+
+				xpath_node_set_raw ls = _left->eval_node_set(c, swapped_stack);
+				xpath_node_set_raw rs = _right->eval_node_set(c, stack);
+				
+				// we can optimize merging two sorted sets, but this is a very rare operation, so don't bother
+				rs.set_type(xpath_node_set::type_unsorted);
+
+				rs.append(ls.begin(), ls.end(), stack.result);
+				rs.remove_duplicates();
+				
+				return rs;
+			}
+
+			case ast_filter:
+			case ast_filter_posinv:
+			{
+				xpath_node_set_raw set = _left->eval_node_set(c, stack);
+
+				// either expression is a number or it contains position() call; sort by document order
+				if (_type == ast_filter) set.sort_do();
+
+				apply_predicate(set, 0, _right, stack);
+			
+				return set;
+			}
+			
+			case ast_func_id:
+				return xpath_node_set_raw();
+			
+			case ast_step:
+			{
+				switch (_axis)
+				{
+				case axis_ancestor:
+					return step_do(c, stack, axis_to_type<axis_ancestor>());
+					
+				case axis_ancestor_or_self:
+					return step_do(c, stack, axis_to_type<axis_ancestor_or_self>());
+
+				case axis_attribute:
+					return step_do(c, stack, axis_to_type<axis_attribute>());
+
+				case axis_child:
+					return step_do(c, stack, axis_to_type<axis_child>());
+				
+				case axis_descendant:
+					return step_do(c, stack, axis_to_type<axis_descendant>());
+
+				case axis_descendant_or_self:
+					return step_do(c, stack, axis_to_type<axis_descendant_or_self>());
+
+				case axis_following:
+					return step_do(c, stack, axis_to_type<axis_following>());
+				
+				case axis_following_sibling:
+					return step_do(c, stack, axis_to_type<axis_following_sibling>());
+				
+				case axis_namespace:
+					// namespaced axis is not supported
+					return xpath_node_set_raw();
+				
+				case axis_parent:
+					return step_do(c, stack, axis_to_type<axis_parent>());
+				
+				case axis_preceding:
+					return step_do(c, stack, axis_to_type<axis_preceding>());
+
+				case axis_preceding_sibling:
+					return step_do(c, stack, axis_to_type<axis_preceding_sibling>());
+				
+				case axis_self:
+					return step_do(c, stack, axis_to_type<axis_self>());
+
+				default:
+					assert(!"Unknown axis");
+					return xpath_node_set_raw();
+				}
+			}
+
+			case ast_step_root:
+			{
+				assert(!_right); // root step can't have any predicates
+
+				xpath_node_set_raw ns;
+
+				ns.set_type(xpath_node_set::type_sorted);
+
+				if (c.n.node()) ns.push_back(c.n.node().root(), stack.result);
+				else if (c.n.attribute()) ns.push_back(c.n.parent().root(), stack.result);
+
+				return ns;
+			}
+
+			case ast_variable:
+			{
+				assert(_rettype == _data.variable->type());
+
+				if (_rettype == xpath_type_node_set)
+				{
+					const xpath_node_set& s = _data.variable->get_node_set();
+
+					xpath_node_set_raw ns;
+
+					ns.set_type(s.type());
+					ns.append(s.begin(), s.end(), stack.result);
+
+					return ns;
+				}
+
+				// fallthrough to type conversion
+			}
+
+			default:
+				assert(!"Wrong expression for return type node set");
+				return xpath_node_set_raw();
+			}
+		}
+		
+		bool is_posinv()
+		{
+			switch (_type)
+			{
+			case ast_func_position:
+				return false;
+
+			case ast_string_constant:
+			case ast_number_constant:
+			case ast_variable:
+				return true;
+
+			case ast_step:
+			case ast_step_root:
+				return true;
+
+			case ast_predicate:
+			case ast_filter:
+			case ast_filter_posinv:
+				return true;
+
+			default:
+				if (_left && !_left->is_posinv()) return false;
+				
+				for (xpath_ast_node* n = _right; n; n = n->_next)
+					if (!n->is_posinv()) return false;
+					
+				return true;
+			}
+		}
+
+		xpath_value_type rettype() const
+		{
+			return static_cast<xpath_value_type>(_rettype);
+		}
+	};
+
+	struct xpath_parser
+	{
+		xpath_allocator* _alloc;
+		xpath_lexer _lexer;
+
+		const char_t* _query;
+		xpath_variable_set* _variables;
+
+		xpath_parse_result* _result;
+
+	#ifdef PUGIXML_NO_EXCEPTIONS
+		jmp_buf _error_handler;
+	#endif
+
+		void throw_error(const char* message)
+		{
+			_result->error = message;
+			_result->offset = _lexer.current_pos() - _query;
+
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			longjmp(_error_handler, 1);
+		#else
+			throw xpath_exception(*_result);
+		#endif
+		}
+
+		void throw_error_oom()
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			throw_error("Out of memory");
+		#else
+			throw std::bad_alloc();
+		#endif
+		}
+
+		void* alloc_node()
+		{
+			void* result = _alloc->allocate_nothrow(sizeof(xpath_ast_node));
+
+			if (!result) throw_error_oom();
+
+			return result;
+		}
+
+		const char_t* alloc_string(const xpath_lexer_string& value)
+		{
+			if (value.begin)
+			{
+				size_t length = static_cast<size_t>(value.end - value.begin);
+
+				char_t* c = static_cast<char_t*>(_alloc->allocate_nothrow((length + 1) * sizeof(char_t)));
+				if (!c) throw_error_oom();
+
+				memcpy(c, value.begin, length * sizeof(char_t));
+				c[length] = 0;
+
+				return c;
+			}
+			else return 0;
+		}
+
+		xpath_ast_node* parse_function_helper(ast_type_t type0, ast_type_t type1, size_t argc, xpath_ast_node* args[2])
+		{
+			assert(argc <= 1);
+
+			if (argc == 1 && args[0]->rettype() != xpath_type_node_set) throw_error("Function has to be applied to node set");
+
+			return new (alloc_node()) xpath_ast_node(argc == 0 ? type0 : type1, xpath_type_string, args[0]);
+		}
+
+		xpath_ast_node* parse_function(const xpath_lexer_string& name, size_t argc, xpath_ast_node* args[2])
+		{
+			switch (name.begin[0])
+			{
+			case 'b':
+				if (name == PUGIXML_TEXT("boolean") && argc == 1)
+					return new (alloc_node()) xpath_ast_node(ast_func_boolean, xpath_type_boolean, args[0]);
+					
+				break;
+			
+			case 'c':
+				if (name == PUGIXML_TEXT("count") && argc == 1)
+				{
+					if (args[0]->rettype() != xpath_type_node_set) throw_error("Function has to be applied to node set");
+					return new (alloc_node()) xpath_ast_node(ast_func_count, xpath_type_number, args[0]);
+				}
+				else if (name == PUGIXML_TEXT("contains") && argc == 2)
+					return new (alloc_node()) xpath_ast_node(ast_func_contains, xpath_type_string, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("concat") && argc >= 2)
+					return new (alloc_node()) xpath_ast_node(ast_func_concat, xpath_type_string, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("ceiling") && argc == 1)
+					return new (alloc_node()) xpath_ast_node(ast_func_ceiling, xpath_type_number, args[0]);
+					
+				break;
+			
+			case 'f':
+				if (name == PUGIXML_TEXT("false") && argc == 0)
+					return new (alloc_node()) xpath_ast_node(ast_func_false, xpath_type_boolean);
+				else if (name == PUGIXML_TEXT("floor") && argc == 1)
+					return new (alloc_node()) xpath_ast_node(ast_func_floor, xpath_type_number, args[0]);
+					
+				break;
+			
+			case 'i':
+				if (name == PUGIXML_TEXT("id") && argc == 1)
+					return new (alloc_node()) xpath_ast_node(ast_func_id, xpath_type_node_set, args[0]);
+					
+				break;
+			
+			case 'l':
+				if (name == PUGIXML_TEXT("last") && argc == 0)
+					return new (alloc_node()) xpath_ast_node(ast_func_last, xpath_type_number);
+				else if (name == PUGIXML_TEXT("lang") && argc == 1)
+					return new (alloc_node()) xpath_ast_node(ast_func_lang, xpath_type_boolean, args[0]);
+				else if (name == PUGIXML_TEXT("local-name") && argc <= 1)
+					return parse_function_helper(ast_func_local_name_0, ast_func_local_name_1, argc, args);
+			
+				break;
+			
+			case 'n':
+				if (name == PUGIXML_TEXT("name") && argc <= 1)
+					return parse_function_helper(ast_func_name_0, ast_func_name_1, argc, args);
+				else if (name == PUGIXML_TEXT("namespace-uri") && argc <= 1)
+					return parse_function_helper(ast_func_namespace_uri_0, ast_func_namespace_uri_1, argc, args);
+				else if (name == PUGIXML_TEXT("normalize-space") && argc <= 1)
+					return new (alloc_node()) xpath_ast_node(argc == 0 ? ast_func_normalize_space_0 : ast_func_normalize_space_1, xpath_type_string, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("not") && argc == 1)
+					return new (alloc_node()) xpath_ast_node(ast_func_not, xpath_type_boolean, args[0]);
+				else if (name == PUGIXML_TEXT("number") && argc <= 1)
+					return new (alloc_node()) xpath_ast_node(argc == 0 ? ast_func_number_0 : ast_func_number_1, xpath_type_number, args[0]);
+			
+				break;
+			
+			case 'p':
+				if (name == PUGIXML_TEXT("position") && argc == 0)
+					return new (alloc_node()) xpath_ast_node(ast_func_position, xpath_type_number);
+				
+				break;
+			
+			case 'r':
+				if (name == PUGIXML_TEXT("round") && argc == 1)
+					return new (alloc_node()) xpath_ast_node(ast_func_round, xpath_type_number, args[0]);
+
+				break;
+			
+			case 's':
+				if (name == PUGIXML_TEXT("string") && argc <= 1)
+					return new (alloc_node()) xpath_ast_node(argc == 0 ? ast_func_string_0 : ast_func_string_1, xpath_type_string, args[0]);
+				else if (name == PUGIXML_TEXT("string-length") && argc <= 1)
+					return new (alloc_node()) xpath_ast_node(argc == 0 ? ast_func_string_length_0 : ast_func_string_length_1, xpath_type_string, args[0]);
+				else if (name == PUGIXML_TEXT("starts-with") && argc == 2)
+					return new (alloc_node()) xpath_ast_node(ast_func_starts_with, xpath_type_boolean, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("substring-before") && argc == 2)
+					return new (alloc_node()) xpath_ast_node(ast_func_substring_before, xpath_type_string, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("substring-after") && argc == 2)
+					return new (alloc_node()) xpath_ast_node(ast_func_substring_after, xpath_type_string, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("substring") && (argc == 2 || argc == 3))
+					return new (alloc_node()) xpath_ast_node(argc == 2 ? ast_func_substring_2 : ast_func_substring_3, xpath_type_string, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("sum") && argc == 1)
+				{
+					if (args[0]->rettype() != xpath_type_node_set) throw_error("Function has to be applied to node set");
+					return new (alloc_node()) xpath_ast_node(ast_func_sum, xpath_type_number, args[0]);
+				}
+
+				break;
+			
+			case 't':
+				if (name == PUGIXML_TEXT("translate") && argc == 3)
+					return new (alloc_node()) xpath_ast_node(ast_func_translate, xpath_type_string, args[0], args[1]);
+				else if (name == PUGIXML_TEXT("true") && argc == 0)
+					return new (alloc_node()) xpath_ast_node(ast_func_true, xpath_type_boolean);
+					
+				break;
+
+			default:
+				break;
+			}
+
+			throw_error("Unrecognized function or wrong parameter count");
+
+			return 0;
+		}
+
+		axis_t parse_axis_name(const xpath_lexer_string& name, bool& specified)
+		{
+			specified = true;
+
+			switch (name.begin[0])
+			{
+			case 'a':
+				if (name == PUGIXML_TEXT("ancestor"))
+					return axis_ancestor;
+				else if (name == PUGIXML_TEXT("ancestor-or-self"))
+					return axis_ancestor_or_self;
+				else if (name == PUGIXML_TEXT("attribute"))
+					return axis_attribute;
+				
+				break;
+			
+			case 'c':
+				if (name == PUGIXML_TEXT("child"))
+					return axis_child;
+				
+				break;
+			
+			case 'd':
+				if (name == PUGIXML_TEXT("descendant"))
+					return axis_descendant;
+				else if (name == PUGIXML_TEXT("descendant-or-self"))
+					return axis_descendant_or_self;
+				
+				break;
+			
+			case 'f':
+				if (name == PUGIXML_TEXT("following"))
+					return axis_following;
+				else if (name == PUGIXML_TEXT("following-sibling"))
+					return axis_following_sibling;
+				
+				break;
+			
+			case 'n':
+				if (name == PUGIXML_TEXT("namespace"))
+					return axis_namespace;
+				
+				break;
+			
+			case 'p':
+				if (name == PUGIXML_TEXT("parent"))
+					return axis_parent;
+				else if (name == PUGIXML_TEXT("preceding"))
+					return axis_preceding;
+				else if (name == PUGIXML_TEXT("preceding-sibling"))
+					return axis_preceding_sibling;
+				
+				break;
+			
+			case 's':
+				if (name == PUGIXML_TEXT("self"))
+					return axis_self;
+				
+				break;
+
+			default:
+				break;
+			}
+
+			specified = false;
+			return axis_child;
+		}
+
+		nodetest_t parse_node_test_type(const xpath_lexer_string& name)
+		{
+			switch (name.begin[0])
+			{
+			case 'c':
+				if (name == PUGIXML_TEXT("comment"))
+					return nodetest_type_comment;
+
+				break;
+
+			case 'n':
+				if (name == PUGIXML_TEXT("node"))
+					return nodetest_type_node;
+
+				break;
+
+			case 'p':
+				if (name == PUGIXML_TEXT("processing-instruction"))
+					return nodetest_type_pi;
+
+				break;
+
+			case 't':
+				if (name == PUGIXML_TEXT("text"))
+					return nodetest_type_text;
+
+				break;
+			
+			default:
+				break;
+			}
+
+			return nodetest_none;
+		}
+
+		// PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
+		xpath_ast_node* parse_primary_expression()
+		{
+			switch (_lexer.current())
+			{
+			case lex_var_ref:
+			{
+				xpath_lexer_string name = _lexer.contents();
+
+				if (!_variables)
+					throw_error("Unknown variable: variable set is not provided");
+
+				xpath_variable* var = get_variable(_variables, name.begin, name.end);
+
+				if (!var)
+					throw_error("Unknown variable: variable set does not contain the given name");
+
+				_lexer.next();
+
+				return new (alloc_node()) xpath_ast_node(ast_variable, var->type(), var);
+			}
+
+			case lex_open_brace:
+			{
+				_lexer.next();
+
+				xpath_ast_node* n = parse_expression();
+
+				if (_lexer.current() != lex_close_brace)
+					throw_error("Unmatched braces");
+
+				_lexer.next();
+
+				return n;
+			}
+
+			case lex_quoted_string:
+			{
+				const char_t* value = alloc_string(_lexer.contents());
+
+				xpath_ast_node* n = new (alloc_node()) xpath_ast_node(ast_string_constant, xpath_type_string, value);
+				_lexer.next();
+
+				return n;
+			}
+
+			case lex_number:
+			{
+				double value = 0;
+
+				if (!convert_string_to_number(_lexer.contents().begin, _lexer.contents().end, &value))
+					throw_error_oom();
+
+				xpath_ast_node* n = new (alloc_node()) xpath_ast_node(ast_number_constant, xpath_type_number, value);
+				_lexer.next();
+
+				return n;
+			}
+
+			case lex_string:
+			{
+				xpath_ast_node* args[2] = {0};
+				size_t argc = 0;
+				
+				xpath_lexer_string function = _lexer.contents();
+				_lexer.next();
+				
+				xpath_ast_node* last_arg = 0;
+				
+				if (_lexer.current() != lex_open_brace)
+					throw_error("Unrecognized function call");
+				_lexer.next();
+
+				if (_lexer.current() != lex_close_brace)
+					args[argc++] = parse_expression();
+
+				while (_lexer.current() != lex_close_brace)
+				{
+					if (_lexer.current() != lex_comma)
+						throw_error("No comma between function arguments");
+					_lexer.next();
+					
+					xpath_ast_node* n = parse_expression();
+					
+					if (argc < 2) args[argc] = n;
+					else last_arg->set_next(n);
+
+					argc++;
+					last_arg = n;
+				}
+				
+				_lexer.next();
+
+				return parse_function(function, argc, args);
+			}
+
+			default:
+				throw_error("Unrecognizable primary expression");
+
+				return 0;
+			}
+		}
+		
+		// FilterExpr ::= PrimaryExpr | FilterExpr Predicate
+		// Predicate ::= '[' PredicateExpr ']'
+		// PredicateExpr ::= Expr
+		xpath_ast_node* parse_filter_expression()
+		{
+			xpath_ast_node* n = parse_primary_expression();
+
+			while (_lexer.current() == lex_open_square_brace)
+			{
+				_lexer.next();
+
+				xpath_ast_node* expr = parse_expression();
+
+				if (n->rettype() != xpath_type_node_set) throw_error("Predicate has to be applied to node set");
+
+				bool posinv = expr->rettype() != xpath_type_number && expr->is_posinv();
+
+				n = new (alloc_node()) xpath_ast_node(posinv ? ast_filter_posinv : ast_filter, xpath_type_node_set, n, expr);
+
+				if (_lexer.current() != lex_close_square_brace)
+					throw_error("Unmatched square brace");
+			
+				_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)
+		{
+			if (set && set->rettype() != xpath_type_node_set)
+				throw_error("Step has to be applied to node set");
+
+			bool axis_specified = false;
+			axis_t axis = axis_child; // implied child axis
+
+			if (_lexer.current() == lex_axis_attribute)
+			{
+				axis = axis_attribute;
+				axis_specified = true;
+				
+				_lexer.next();
+			}
+			else if (_lexer.current() == lex_dot)
+			{
+				_lexer.next();
+				
+				return new (alloc_node()) xpath_ast_node(ast_step, set, axis_self, nodetest_type_node, 0);
+			}
+			else if (_lexer.current() == lex_double_dot)
+			{
+				_lexer.next();
+				
+				return new (alloc_node()) xpath_ast_node(ast_step, set, axis_parent, nodetest_type_node, 0);
+			}
+		
+			nodetest_t nt_type = nodetest_none;
+			xpath_lexer_string nt_name;
+			
+			if (_lexer.current() == lex_string)
+			{
+				// node name test
+				nt_name = _lexer.contents();
+				_lexer.next();
+
+				// was it an axis name?
+				if (_lexer.current() == lex_double_colon)
+				{
+					// parse axis name
+					if (axis_specified) throw_error("Two axis specifiers in one step");
+
+					axis = parse_axis_name(nt_name, axis_specified);
+
+					if (!axis_specified) throw_error("Unknown axis");
+
+					// read actual node test
+					_lexer.next();
+
+					if (_lexer.current() == lex_multiply)
+					{
+						nt_type = nodetest_all;
+						nt_name = xpath_lexer_string();
+						_lexer.next();
+					}
+					else if (_lexer.current() == lex_string)
+					{
+						nt_name = _lexer.contents();
+						_lexer.next();
+					}
+					else throw_error("Unrecognized node test");
+				}
+				
+				if (nt_type == nodetest_none)
+				{
+					// node type test or processing-instruction
+					if (_lexer.current() == lex_open_brace)
+					{
+						_lexer.next();
+						
+						if (_lexer.current() == lex_close_brace)
+						{
+							_lexer.next();
+
+							nt_type = parse_node_test_type(nt_name);
+
+							if (nt_type == nodetest_none) throw_error("Unrecognized node type");
+							
+							nt_name = xpath_lexer_string();
+						}
+						else if (nt_name == PUGIXML_TEXT("processing-instruction"))
+						{
+							if (_lexer.current() != lex_quoted_string)
+								throw_error("Only literals are allowed as arguments to processing-instruction()");
+						
+							nt_type = nodetest_pi;
+							nt_name = _lexer.contents();
+							_lexer.next();
+							
+							if (_lexer.current() != lex_close_brace)
+								throw_error("Unmatched brace near processing-instruction()");
+							_lexer.next();
+						}
+						else
+							throw_error("Unmatched brace near node type test");
+
+					}
+					// QName or NCName:*
+					else
+					{
+						if (nt_name.end - nt_name.begin > 2 && nt_name.end[-2] == ':' && nt_name.end[-1] == '*') // NCName:*
+						{
+							nt_name.end--; // erase *
+							
+							nt_type = nodetest_all_in_namespace;
+						}
+						else nt_type = nodetest_name;
+					}
+				}
+			}
+			else if (_lexer.current() == lex_multiply)
+			{
+				nt_type = nodetest_all;
+				_lexer.next();
+			}
+			else throw_error("Unrecognized node test");
+			
+			xpath_ast_node* n = new (alloc_node()) xpath_ast_node(ast_step, set, axis, nt_type, alloc_string(nt_name));
+			
+			xpath_ast_node* last = 0;
+			
+			while (_lexer.current() == lex_open_square_brace)
+			{
+				_lexer.next();
+				
+				xpath_ast_node* expr = parse_expression();
+
+				xpath_ast_node* pred = new (alloc_node()) xpath_ast_node(ast_predicate, xpath_type_node_set, expr);
+				
+				if (_lexer.current() != lex_close_square_brace)
+					throw_error("Unmatched square brace");
+				_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 (_lexer.current() == lex_slash || _lexer.current() == lex_double_slash)
+			{
+				lexeme_t l = _lexer.current();
+				_lexer.next();
+
+				if (l == lex_double_slash)
+					n = new (alloc_node()) xpath_ast_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
+				
+				n = parse_step(n);
+			}
+			
+			return n;
+		}
+		
+		// LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
+		// AbsoluteLocationPath ::= '/' RelativeLocationPath? | '//' RelativeLocationPath
+		xpath_ast_node* parse_location_path()
+		{
+			if (_lexer.current() == lex_slash)
+			{
+				_lexer.next();
+				
+				xpath_ast_node* n = new (alloc_node()) xpath_ast_node(ast_step_root, xpath_type_node_set);
+
+				// relative location path can start from axis_attribute, dot, double_dot, multiply and string lexemes; any other lexeme means standalone root path
+				lexeme_t l = _lexer.current();
+
+				if (l == lex_string || l == lex_axis_attribute || l == lex_dot || l == lex_double_dot || l == lex_multiply)
+					return parse_relative_location_path(n);
+				else
+					return n;
+			}
+			else if (_lexer.current() == lex_double_slash)
+			{
+				_lexer.next();
+				
+				xpath_ast_node* n = new (alloc_node()) xpath_ast_node(ast_step_root, xpath_type_node_set);
+				n = new (alloc_node()) xpath_ast_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
+				
+				return parse_relative_location_path(n);
+			}
+
+			// else clause moved outside of if because of bogus warning 'control may reach end of non-void function being inlined' in gcc 4.0.1
+			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 (_lexer.current() == lex_var_ref || _lexer.current() == lex_open_brace || 
+				_lexer.current() == lex_quoted_string || _lexer.current() == lex_number ||
+				_lexer.current() == lex_string)
+			{
+				if (_lexer.current() == lex_string)
+				{
+					// This is either a function call, or not - if not, we shall proceed with location path
+					const char_t* state = _lexer.state();
+					
+					while (PUGI__IS_CHARTYPE(*state, ct_space)) ++state;
+					
+					if (*state != '(') return parse_location_path();
+
+					// This looks like a function call; however this still can be a node-test. Check it.
+					if (parse_node_test_type(_lexer.contents()) != nodetest_none) return parse_location_path();
+				}
+				
+				xpath_ast_node* n = parse_filter_expression();
+
+				if (_lexer.current() == lex_slash || _lexer.current() == lex_double_slash)
+				{
+					lexeme_t l = _lexer.current();
+					_lexer.next();
+					
+					if (l == lex_double_slash)
+					{
+						if (n->rettype() != xpath_type_node_set) throw_error("Step has to be applied to node set");
+
+						n = new (alloc_node()) xpath_ast_node(ast_step, n, axis_descendant_or_self, nodetest_type_node, 0);
+					}
+	
+					// 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 (_lexer.current() == lex_union)
+			{
+				_lexer.next();
+
+				xpath_ast_node* expr = parse_union_expression();
+
+				if (n->rettype() != xpath_type_node_set || expr->rettype() != xpath_type_node_set)
+					throw_error("Union operator has to be applied to node sets");
+
+				n = new (alloc_node()) xpath_ast_node(ast_op_union, xpath_type_node_set, n, expr);
+			}
+
+			return n;
+		}
+
+		// UnaryExpr ::= UnionExpr | '-' UnaryExpr
+		xpath_ast_node* parse_unary_expression()
+		{
+			if (_lexer.current() == lex_minus)
+			{
+				_lexer.next();
+
+				xpath_ast_node* expr = parse_unary_expression();
+
+				return new (alloc_node()) xpath_ast_node(ast_op_negate, xpath_type_number, expr);
+			}
+			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 (_lexer.current() == lex_multiply || (_lexer.current() == lex_string &&
+				   (_lexer.contents() == PUGIXML_TEXT("mod") || _lexer.contents() == PUGIXML_TEXT("div"))))
+			{
+				ast_type_t op = _lexer.current() == lex_multiply ? ast_op_multiply :
+					_lexer.contents().begin[0] == 'd' ? ast_op_divide : ast_op_mod;
+				_lexer.next();
+
+				xpath_ast_node* expr = parse_unary_expression();
+
+				n = new (alloc_node()) xpath_ast_node(op, xpath_type_number, n, expr);
+			}
+
+			return n;
+		}
+
+		// AdditiveExpr ::= MultiplicativeExpr
+		//					| AdditiveExpr '+' MultiplicativeExpr
+		//					| AdditiveExpr '-' MultiplicativeExpr
+		xpath_ast_node* parse_additive_expression()
+		{
+			xpath_ast_node* n = parse_multiplicative_expression();
+
+			while (_lexer.current() == lex_plus || _lexer.current() == lex_minus)
+			{
+				lexeme_t l = _lexer.current();
+
+				_lexer.next();
+
+				xpath_ast_node* expr = parse_multiplicative_expression();
+
+				n = new (alloc_node()) xpath_ast_node(l == lex_plus ? ast_op_add : ast_op_subtract, xpath_type_number, n, expr);
+			}
+
+			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 (_lexer.current() == lex_less || _lexer.current() == lex_less_or_equal || 
+				   _lexer.current() == lex_greater || _lexer.current() == lex_greater_or_equal)
+			{
+				lexeme_t l = _lexer.current();
+				_lexer.next();
+
+				xpath_ast_node* expr = parse_additive_expression();
+
+				n = new (alloc_node()) 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, xpath_type_boolean, n, expr);
+			}
+
+			return n;
+		}
+		
+		// EqualityExpr ::= RelationalExpr
+		//					| EqualityExpr '=' RelationalExpr
+		//					| EqualityExpr '!=' RelationalExpr
+		xpath_ast_node* parse_equality_expression()
+		{
+			xpath_ast_node* n = parse_relational_expression();
+
+			while (_lexer.current() == lex_equal || _lexer.current() == lex_not_equal)
+			{
+				lexeme_t l = _lexer.current();
+
+				_lexer.next();
+
+				xpath_ast_node* expr = parse_relational_expression();
+
+				n = new (alloc_node()) xpath_ast_node(l == lex_equal ? ast_op_equal : ast_op_not_equal, xpath_type_boolean, n, expr);
+			}
+
+			return n;
+		}
+		
+		// AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
+		xpath_ast_node* parse_and_expression()
+		{
+			xpath_ast_node* n = parse_equality_expression();
+
+			while (_lexer.current() == lex_string && _lexer.contents() == PUGIXML_TEXT("and"))
+			{
+				_lexer.next();
+
+				xpath_ast_node* expr = parse_equality_expression();
+
+				n = new (alloc_node()) xpath_ast_node(ast_op_and, xpath_type_boolean, n, expr);
+			}
+
+			return n;
+		}
+
+		// OrExpr ::= AndExpr | OrExpr 'or' AndExpr
+		xpath_ast_node* parse_or_expression()
+		{
+			xpath_ast_node* n = parse_and_expression();
+
+			while (_lexer.current() == lex_string && _lexer.contents() == PUGIXML_TEXT("or"))
+			{
+				_lexer.next();
+
+				xpath_ast_node* expr = parse_and_expression();
+
+				n = new (alloc_node()) xpath_ast_node(ast_op_or, xpath_type_boolean, n, expr);
+			}
+
+			return n;
+		}
+		
+		// Expr ::= OrExpr
+		xpath_ast_node* parse_expression()
+		{
+			return parse_or_expression();
+		}
+
+		xpath_parser(const char_t* query, xpath_variable_set* variables, xpath_allocator* alloc, xpath_parse_result* result): _alloc(alloc), _lexer(query), _query(query), _variables(variables), _result(result)
+		{
+		}
+
+		xpath_ast_node* parse()
+		{
+			xpath_ast_node* result = parse_expression();
+			
+			if (_lexer.current() != lex_eof)
+			{
+				// there are still unparsed tokens left, error
+				throw_error("Incorrect query");
+			}
+			
+			return result;
+		}
+
+		static xpath_ast_node* parse(const char_t* query, xpath_variable_set* variables, xpath_allocator* alloc, xpath_parse_result* result)
+		{
+			xpath_parser parser(query, variables, alloc, result);
+
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			int error = setjmp(parser._error_handler);
+
+			return (error == 0) ? parser.parse() : 0;
+		#else
+			return parser.parse();
+		#endif
+		}
+	};
+
+	struct xpath_query_impl
+	{
+		static xpath_query_impl* create()
+		{
+			void* memory = xml_memory::allocate(sizeof(xpath_query_impl));
+
+			return new (memory) xpath_query_impl();
+		}
+
+		static void destroy(void* ptr)
+		{
+			if (!ptr) return;
+			
+			// free all allocated pages
+			static_cast<xpath_query_impl*>(ptr)->alloc.release();
+
+			// free allocator memory (with the first page)
+			xml_memory::deallocate(ptr);
+		}
+
+		xpath_query_impl(): root(0), alloc(&block)
+		{
+			block.next = 0;
+		}
+
+		xpath_ast_node* root;
+		xpath_allocator alloc;
+		xpath_memory_block block;
+	};
+
+	PUGI__FN xpath_string evaluate_string_impl(xpath_query_impl* impl, const xpath_node& n, xpath_stack_data& sd)
+	{
+		if (!impl) return xpath_string();
+
+	#ifdef PUGIXML_NO_EXCEPTIONS
+		if (setjmp(sd.error_handler)) return xpath_string();
+	#endif
+
+		xpath_context c(n, 1, 1);
+
+		return impl->root->eval_string(c, sd.stack);
+	}
+PUGI__NS_END
+
+namespace pugi
+{
+#ifndef PUGIXML_NO_EXCEPTIONS
+	PUGI__FN xpath_exception::xpath_exception(const xpath_parse_result& result_): _result(result_)
+	{
+		assert(_result.error);
+	}
+	
+	PUGI__FN const char* xpath_exception::what() const throw()
+	{
+		return _result.error;
+	}
+
+	PUGI__FN const xpath_parse_result& xpath_exception::result() const
+	{
+		return _result;
+	}
+#endif
+	
+	PUGI__FN xpath_node::xpath_node()
+	{
+	}
+		
+	PUGI__FN xpath_node::xpath_node(const xml_node& node_): _node(node_)
+	{
+	}
+		
+	PUGI__FN xpath_node::xpath_node(const xml_attribute& attribute_, const xml_node& parent_): _node(attribute_ ? parent_ : xml_node()), _attribute(attribute_)
+	{
+	}
+
+	PUGI__FN xml_node xpath_node::node() const
+	{
+		return _attribute ? xml_node() : _node;
+	}
+		
+	PUGI__FN xml_attribute xpath_node::attribute() const
+	{
+		return _attribute;
+	}
+	
+	PUGI__FN xml_node xpath_node::parent() const
+	{
+		return _attribute ? _node : _node.parent();
+	}
+
+	PUGI__FN static void unspecified_bool_xpath_node(xpath_node***)
+	{
+	}
+
+	PUGI__FN xpath_node::operator xpath_node::unspecified_bool_type() const
+	{
+		return (_node || _attribute) ? unspecified_bool_xpath_node : 0;
+	}
+	
+	PUGI__FN bool xpath_node::operator!() const
+	{
+		return !(_node || _attribute);
+	}
+
+	PUGI__FN bool xpath_node::operator==(const xpath_node& n) const
+	{
+		return _node == n._node && _attribute == n._attribute;
+	}
+	
+	PUGI__FN bool xpath_node::operator!=(const xpath_node& n) const
+	{
+		return _node != n._node || _attribute != n._attribute;
+	}
+
+#ifdef __BORLANDC__
+	PUGI__FN bool operator&&(const xpath_node& lhs, bool rhs)
+	{
+		return (bool)lhs && rhs;
+	}
+
+	PUGI__FN bool operator||(const xpath_node& lhs, bool rhs)
+	{
+		return (bool)lhs || rhs;
+	}
+#endif
+
+	PUGI__FN void xpath_node_set::_assign(const_iterator begin_, const_iterator end_)
+	{
+		assert(begin_ <= end_);
+
+		size_t size_ = static_cast<size_t>(end_ - begin_);
+
+		if (size_ <= 1)
+		{
+			// deallocate old buffer
+			if (_begin != &_storage) impl::xml_memory::deallocate(_begin);
+
+			// use internal buffer
+			if (begin_ != end_) _storage = *begin_;
+
+			_begin = &_storage;
+			_end = &_storage + size_;
+		}
+		else
+		{
+			// make heap copy
+			xpath_node* storage = static_cast<xpath_node*>(impl::xml_memory::allocate(size_ * sizeof(xpath_node)));
+
+			if (!storage)
+			{
+			#ifdef PUGIXML_NO_EXCEPTIONS
+				return;
+			#else
+				throw std::bad_alloc();
+			#endif
+			}
+
+			memcpy(storage, begin_, size_ * sizeof(xpath_node));
+			
+			// deallocate old buffer
+			if (_begin != &_storage) impl::xml_memory::deallocate(_begin);
+
+			// finalize
+			_begin = storage;
+			_end = storage + size_;
+		}
+	}
+
+	PUGI__FN xpath_node_set::xpath_node_set(): _type(type_unsorted), _begin(&_storage), _end(&_storage)
+	{
+	}
+
+	PUGI__FN xpath_node_set::xpath_node_set(const_iterator begin_, const_iterator end_, type_t type_): _type(type_), _begin(&_storage), _end(&_storage)
+	{
+		_assign(begin_, end_);
+	}
+
+	PUGI__FN xpath_node_set::~xpath_node_set()
+	{
+		if (_begin != &_storage) impl::xml_memory::deallocate(_begin);
+	}
+		
+	PUGI__FN xpath_node_set::xpath_node_set(const xpath_node_set& ns): _type(ns._type), _begin(&_storage), _end(&_storage)
+	{
+		_assign(ns._begin, ns._end);
+	}
+	
+	PUGI__FN xpath_node_set& xpath_node_set::operator=(const xpath_node_set& ns)
+	{
+		if (this == &ns) return *this;
+		
+		_type = ns._type;
+		_assign(ns._begin, ns._end);
+
+		return *this;
+	}
+
+	PUGI__FN xpath_node_set::type_t xpath_node_set::type() const
+	{
+		return _type;
+	}
+		
+	PUGI__FN size_t xpath_node_set::size() const
+	{
+		return _end - _begin;
+	}
+		
+	PUGI__FN bool xpath_node_set::empty() const
+	{
+		return _begin == _end;
+	}
+		
+	PUGI__FN const xpath_node& xpath_node_set::operator[](size_t index) const
+	{
+		assert(index < size());
+		return _begin[index];
+	}
+
+	PUGI__FN xpath_node_set::const_iterator xpath_node_set::begin() const
+	{
+		return _begin;
+	}
+		
+	PUGI__FN xpath_node_set::const_iterator xpath_node_set::end() const
+	{
+		return _end;
+	}
+	
+	PUGI__FN void xpath_node_set::sort(bool reverse)
+	{
+		_type = impl::xpath_sort(_begin, _end, _type, reverse);
+	}
+
+	PUGI__FN xpath_node xpath_node_set::first() const
+	{
+		return impl::xpath_first(_begin, _end, _type);
+	}
+
+	PUGI__FN xpath_parse_result::xpath_parse_result(): error("Internal error"), offset(0)
+	{
+	}
+
+	PUGI__FN xpath_parse_result::operator bool() const
+	{
+		return error == 0;
+	}
+
+	PUGI__FN const char* xpath_parse_result::description() const
+	{
+		return error ? error : "No error";
+	}
+
+	PUGI__FN xpath_variable::xpath_variable()
+	{
+	}
+
+	PUGI__FN const char_t* xpath_variable::name() const
+	{
+		switch (_type)
+		{
+		case xpath_type_node_set:
+			return static_cast<const impl::xpath_variable_node_set*>(this)->name;
+
+		case xpath_type_number:
+			return static_cast<const impl::xpath_variable_number*>(this)->name;
+
+		case xpath_type_string:
+			return static_cast<const impl::xpath_variable_string*>(this)->name;
+
+		case xpath_type_boolean:
+			return static_cast<const impl::xpath_variable_boolean*>(this)->name;
+
+		default:
+			assert(!"Invalid variable type");
+			return 0;
+		}
+	}
+
+	PUGI__FN xpath_value_type xpath_variable::type() const
+	{
+		return _type;
+	}
+
+	PUGI__FN bool xpath_variable::get_boolean() const
+	{
+		return (_type == xpath_type_boolean) ? static_cast<const impl::xpath_variable_boolean*>(this)->value : false;
+	}
+
+	PUGI__FN double xpath_variable::get_number() const
+	{
+		return (_type == xpath_type_number) ? static_cast<const impl::xpath_variable_number*>(this)->value : impl::gen_nan();
+	}
+
+	PUGI__FN const char_t* xpath_variable::get_string() const
+	{
+		const char_t* value = (_type == xpath_type_string) ? static_cast<const impl::xpath_variable_string*>(this)->value : 0;
+		return value ? value : PUGIXML_TEXT("");
+	}
+
+	PUGI__FN const xpath_node_set& xpath_variable::get_node_set() const
+	{
+		return (_type == xpath_type_node_set) ? static_cast<const impl::xpath_variable_node_set*>(this)->value : impl::dummy_node_set;
+	}
+
+	PUGI__FN bool xpath_variable::set(bool value)
+	{
+		if (_type != xpath_type_boolean) return false;
+
+		static_cast<impl::xpath_variable_boolean*>(this)->value = value;
+		return true;
+	}
+
+	PUGI__FN bool xpath_variable::set(double value)
+	{
+		if (_type != xpath_type_number) return false;
+
+		static_cast<impl::xpath_variable_number*>(this)->value = value;
+		return true;
+	}
+
+	PUGI__FN bool xpath_variable::set(const char_t* value)
+	{
+		if (_type != xpath_type_string) return false;
+
+		impl::xpath_variable_string* var = static_cast<impl::xpath_variable_string*>(this);
+
+		// duplicate string
+		size_t size = (impl::strlength(value) + 1) * sizeof(char_t);
+
+		char_t* copy = static_cast<char_t*>(impl::xml_memory::allocate(size));
+		if (!copy) return false;
+
+		memcpy(copy, value, size);
+
+		// replace old string
+		if (var->value) impl::xml_memory::deallocate(var->value);
+		var->value = copy;
+
+		return true;
+	}
+
+	PUGI__FN bool xpath_variable::set(const xpath_node_set& value)
+	{
+		if (_type != xpath_type_node_set) return false;
+
+		static_cast<impl::xpath_variable_node_set*>(this)->value = value;
+		return true;
+	}
+
+	PUGI__FN xpath_variable_set::xpath_variable_set()
+	{
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i) _data[i] = 0;
+	}
+
+	PUGI__FN xpath_variable_set::~xpath_variable_set()
+	{
+		for (size_t i = 0; i < sizeof(_data) / sizeof(_data[0]); ++i)
+		{
+			xpath_variable* var = _data[i];
+
+			while (var)
+			{
+				xpath_variable* next = var->_next;
+
+				impl::delete_xpath_variable(var->_type, var);
+
+				var = next;
+			}
+		}
+	}
+
+	PUGI__FN xpath_variable* xpath_variable_set::find(const char_t* name) const
+	{
+		const size_t hash_size = sizeof(_data) / sizeof(_data[0]);
+		size_t hash = impl::hash_string(name) % hash_size;
+
+		// look for existing variable
+		for (xpath_variable* var = _data[hash]; var; var = var->_next)
+			if (impl::strequal(var->name(), name))
+				return var;
+
+		return 0;
+	}
+
+	PUGI__FN xpath_variable* xpath_variable_set::add(const char_t* name, xpath_value_type type)
+	{
+		const size_t hash_size = sizeof(_data) / sizeof(_data[0]);
+		size_t hash = impl::hash_string(name) % hash_size;
+
+		// look for existing variable
+		for (xpath_variable* var = _data[hash]; var; var = var->_next)
+			if (impl::strequal(var->name(), name))
+				return var->type() == type ? var : 0;
+
+		// add new variable
+		xpath_variable* result = impl::new_xpath_variable(type, name);
+
+		if (result)
+		{
+			result->_type = type;
+			result->_next = _data[hash];
+
+			_data[hash] = result;
+		}
+
+		return result;
+	}
+
+	PUGI__FN bool xpath_variable_set::set(const char_t* name, bool value)
+	{
+		xpath_variable* var = add(name, xpath_type_boolean);
+		return var ? var->set(value) : false;
+	}
+
+	PUGI__FN bool xpath_variable_set::set(const char_t* name, double value)
+	{
+		xpath_variable* var = add(name, xpath_type_number);
+		return var ? var->set(value) : false;
+	}
+
+	PUGI__FN bool xpath_variable_set::set(const char_t* name, const char_t* value)
+	{
+		xpath_variable* var = add(name, xpath_type_string);
+		return var ? var->set(value) : false;
+	}
+
+	PUGI__FN bool xpath_variable_set::set(const char_t* name, const xpath_node_set& value)
+	{
+		xpath_variable* var = add(name, xpath_type_node_set);
+		return var ? var->set(value) : false;
+	}
+
+	PUGI__FN xpath_variable* xpath_variable_set::get(const char_t* name)
+	{
+		return find(name);
+	}
+
+	PUGI__FN const xpath_variable* xpath_variable_set::get(const char_t* name) const
+	{
+		return find(name);
+	}
+
+	PUGI__FN xpath_query::xpath_query(const char_t* query, xpath_variable_set* variables): _impl(0)
+	{
+		impl::xpath_query_impl* qimpl = impl::xpath_query_impl::create();
+
+		if (!qimpl)
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			_result.error = "Out of memory";
+		#else
+			throw std::bad_alloc();
+		#endif
+		}
+		else
+		{
+			impl::buffer_holder impl_holder(qimpl, impl::xpath_query_impl::destroy);
+
+			qimpl->root = impl::xpath_parser::parse(query, variables, &qimpl->alloc, &_result);
+
+			if (qimpl->root)
+			{
+				_impl = static_cast<impl::xpath_query_impl*>(impl_holder.release());
+				_result.error = 0;
+			}
+		}
+	}
+
+	PUGI__FN xpath_query::~xpath_query()
+	{
+		impl::xpath_query_impl::destroy(_impl);
+	}
+
+	PUGI__FN xpath_value_type xpath_query::return_type() const
+	{
+		if (!_impl) return xpath_type_none;
+
+		return static_cast<impl::xpath_query_impl*>(_impl)->root->rettype();
+	}
+
+	PUGI__FN bool xpath_query::evaluate_boolean(const xpath_node& n) const
+	{
+		if (!_impl) return false;
+		
+		impl::xpath_context c(n, 1, 1);
+		impl::xpath_stack_data sd;
+
+	#ifdef PUGIXML_NO_EXCEPTIONS
+		if (setjmp(sd.error_handler)) return false;
+	#endif
+		
+		return static_cast<impl::xpath_query_impl*>(_impl)->root->eval_boolean(c, sd.stack);
+	}
+	
+	PUGI__FN double xpath_query::evaluate_number(const xpath_node& n) const
+	{
+		if (!_impl) return impl::gen_nan();
+		
+		impl::xpath_context c(n, 1, 1);
+		impl::xpath_stack_data sd;
+
+	#ifdef PUGIXML_NO_EXCEPTIONS
+		if (setjmp(sd.error_handler)) return impl::gen_nan();
+	#endif
+
+		return static_cast<impl::xpath_query_impl*>(_impl)->root->eval_number(c, sd.stack);
+	}
+
+#ifndef PUGIXML_NO_STL
+	PUGI__FN string_t xpath_query::evaluate_string(const xpath_node& n) const
+	{
+		impl::xpath_stack_data sd;
+
+		return impl::evaluate_string_impl(static_cast<impl::xpath_query_impl*>(_impl), n, sd).c_str();
+	}
+#endif
+
+	PUGI__FN size_t xpath_query::evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const
+	{
+		impl::xpath_stack_data sd;
+
+		impl::xpath_string r = impl::evaluate_string_impl(static_cast<impl::xpath_query_impl*>(_impl), n, sd);
+
+		size_t full_size = r.length() + 1;
+		
+		if (capacity > 0)
+		{
+			size_t size = (full_size < capacity) ? full_size : capacity;
+			assert(size > 0);
+
+			memcpy(buffer, r.c_str(), (size - 1) * sizeof(char_t));
+			buffer[size - 1] = 0;
+		}
+		
+		return full_size;
+	}
+
+	PUGI__FN xpath_node_set xpath_query::evaluate_node_set(const xpath_node& n) const
+	{
+		if (!_impl) return xpath_node_set();
+
+		impl::xpath_ast_node* root = static_cast<impl::xpath_query_impl*>(_impl)->root;
+
+		if (root->rettype() != xpath_type_node_set)
+		{
+		#ifdef PUGIXML_NO_EXCEPTIONS
+			return xpath_node_set();
+		#else
+			xpath_parse_result res;
+			res.error = "Expression does not evaluate to node set";
+
+			throw xpath_exception(res);
+		#endif
+		}
+		
+		impl::xpath_context c(n, 1, 1);
+		impl::xpath_stack_data sd;
+
+	#ifdef PUGIXML_NO_EXCEPTIONS
+		if (setjmp(sd.error_handler)) return xpath_node_set();
+	#endif
+
+		impl::xpath_node_set_raw r = root->eval_node_set(c, sd.stack);
+
+		return xpath_node_set(r.begin(), r.end(), r.type());
+	}
+
+	PUGI__FN const xpath_parse_result& xpath_query::result() const
+	{
+		return _result;
+	}
+
+	PUGI__FN static void unspecified_bool_xpath_query(xpath_query***)
+	{
+	}
+
+	PUGI__FN xpath_query::operator xpath_query::unspecified_bool_type() const
+	{
+		return _impl ? unspecified_bool_xpath_query : 0;
+	}
+
+	PUGI__FN bool xpath_query::operator!() const
+	{
+		return !_impl;
+	}
+
+	PUGI__FN xpath_node xml_node::select_single_node(const char_t* query, xpath_variable_set* variables) const
+	{
+		xpath_query q(query, variables);
+		return select_single_node(q);
+	}
+
+	PUGI__FN xpath_node xml_node::select_single_node(const xpath_query& query) const
+	{
+		xpath_node_set s = query.evaluate_node_set(*this);
+		return s.empty() ? xpath_node() : s.first();
+	}
+
+	PUGI__FN xpath_node_set xml_node::select_nodes(const char_t* query, xpath_variable_set* variables) const
+	{
+		xpath_query q(query, variables);
+		return select_nodes(q);
+	}
+
+	PUGI__FN xpath_node_set xml_node::select_nodes(const xpath_query& query) const
+	{
+		return query.evaluate_node_set(*this);
+	}
+}
+
+#endif
+
+#ifdef __BORLANDC__
+#	pragma option pop
+#endif
+
+// Intel C++ does not properly keep warning state for function templates,
+// so popping warning state at the end of translation unit leads to warnings in the middle.
+#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
+#	pragma warning(pop)
+#endif
+
+// Undefine all local macros (makes sure we're not leaking macros in header-only mode)
+#undef PUGI__NO_INLINE
+#undef PUGI__STATIC_ASSERT
+#undef PUGI__DMC_VOLATILE
+#undef PUGI__MSVC_CRT_VERSION
+#undef PUGI__NS_BEGIN
+#undef PUGI__NS_END
+#undef PUGI__FN
+#undef PUGI__FN_NO_INLINE
+#undef PUGI__IS_CHARTYPE_IMPL
+#undef PUGI__IS_CHARTYPE
+#undef PUGI__IS_CHARTYPEX
+#undef PUGI__SKIPWS
+#undef PUGI__OPTSET
+#undef PUGI__PUSHNODE
+#undef PUGI__POPNODE
+#undef PUGI__SCANFOR
+#undef PUGI__SCANWHILE
+#undef PUGI__ENDSEG
+#undef PUGI__THROW_ERROR
+#undef PUGI__CHECK_ERROR
+
+#endif
+
+/**
+ * Copyright (c) 2006-2012 Arseny Kapoulkine
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
diff --git a/tools/intergen/third_party/pugixml/src/pugixml.hpp b/tools/intergen/third_party/pugixml/src/pugixml.hpp
new file mode 100644
index 0000000000..77b4dcf474
--- /dev/null
+++ b/tools/intergen/third_party/pugixml/src/pugixml.hpp
@@ -0,0 +1,1265 @@
+/**
+ * pugixml parser - version 1.2
+ * --------------------------------------------------------
+ * Copyright (C) 2006-2012, by Arseny Kapoulkine (arseny.kapoulkine@gmail.com)
+ * Report bugs and download new versions at http://pugixml.org/
+ *
+ * This library is distributed under the MIT License. See notice at the end
+ * of this file.
+ *
+ * This work is based on the pugxml parser, which is:
+ * Copyright (C) 2003, by Kristen Wegner (kristen@tima.net)
+ */
+
+#ifndef PUGIXML_VERSION
+// Define version macro; evaluates to major * 100 + minor so that it's safe to use in less-than comparisons
+#	define PUGIXML_VERSION 120
+#endif
+
+// Include user configuration file (this can define various configuration macros)
+#include "pugiconfig.hpp"
+
+#ifndef HEADER_PUGIXML_HPP
+#define HEADER_PUGIXML_HPP
+
+// Include stddef.h for size_t and ptrdiff_t
+#include <stddef.h>
+
+// Include exception header for XPath
+#if !defined(PUGIXML_NO_XPATH) && !defined(PUGIXML_NO_EXCEPTIONS)
+#	include <exception>
+#endif
+
+// Include STL headers
+#ifndef PUGIXML_NO_STL
+#	include <iterator>
+#	include <iosfwd>
+#	include <string>
+#endif
+
+// Macro for deprecated features
+#ifndef PUGIXML_DEPRECATED
+#	if defined(__GNUC__)
+#		define PUGIXML_DEPRECATED __attribute__((deprecated))
+#	elif defined(_MSC_VER) && _MSC_VER >= 1300
+#		define PUGIXML_DEPRECATED __declspec(deprecated)
+#	else
+#		define PUGIXML_DEPRECATED
+#	endif
+#endif
+
+// If no API is defined, assume default
+#ifndef PUGIXML_API
+#	define PUGIXML_API
+#endif
+
+// If no API for classes is defined, assume default
+#ifndef PUGIXML_CLASS
+#	define PUGIXML_CLASS PUGIXML_API
+#endif
+
+// If no API for functions is defined, assume default
+#ifndef PUGIXML_FUNCTION
+#	define PUGIXML_FUNCTION PUGIXML_API
+#endif
+
+// Character interface macros
+#ifdef PUGIXML_WCHAR_MODE
+#	define PUGIXML_TEXT(t) L ## t
+#	define PUGIXML_CHAR wchar_t
+#else
+#	define PUGIXML_TEXT(t) t
+#	define PUGIXML_CHAR char
+#endif
+
+namespace pugi
+{
+	// Character type used for all internal storage and operations; depends on PUGIXML_WCHAR_MODE
+	typedef PUGIXML_CHAR char_t;
+
+#ifndef PUGIXML_NO_STL
+	// String type used for operations that work with STL string; depends on PUGIXML_WCHAR_MODE
+	typedef std::basic_string<PUGIXML_CHAR, std::char_traits<PUGIXML_CHAR>, std::allocator<PUGIXML_CHAR> > string_t;
+#endif
+}
+
+// The PugiXML namespace
+namespace pugi
+{
+	// Tree node types
+	enum xml_node_type
+	{
+		node_null,			// Empty (null) node handle
+		node_document,		// A document tree's absolute root
+		node_element,		// Element tag, i.e. '<node/>'
+		node_pcdata,		// Plain character data, i.e. 'text'
+		node_cdata,			// Character data, i.e. '<![CDATA[text]]>'
+		node_comment,		// Comment tag, i.e. '<!-- text -->'
+		node_pi,			// Processing instruction, i.e. '<?name?>'
+		node_declaration,	// Document declaration, i.e. '<?xml version="1.0"?>'
+		node_doctype		// Document type declaration, i.e. '<!DOCTYPE doc>'
+	};
+
+	// Parsing options
+
+	// Minimal parsing mode (equivalent to turning all other flags off).
+	// Only elements and PCDATA sections are added to the DOM tree, no text conversions are performed.
+	const unsigned int parse_minimal = 0x0000;
+
+	// This flag determines if processing instructions (node_pi) are added to the DOM tree. This flag is off by default.
+	const unsigned int parse_pi = 0x0001;
+
+	// This flag determines if comments (node_comment) are added to the DOM tree. This flag is off by default.
+	const unsigned int parse_comments = 0x0002;
+
+	// This flag determines if CDATA sections (node_cdata) are added to the DOM tree. This flag is on by default.
+	const unsigned int parse_cdata = 0x0004;
+
+	// This flag determines if plain character data (node_pcdata) that consist only of whitespace are added to the DOM tree.
+	// This flag is off by default; turning it on usually results in slower parsing and more memory consumption.
+	const unsigned int parse_ws_pcdata = 0x0008;
+
+	// This flag determines if character and entity references are expanded during parsing. This flag is on by default.
+	const unsigned int parse_escapes = 0x0010;
+
+	// This flag determines if EOL characters are normalized (converted to #xA) during parsing. This flag is on by default.
+	const unsigned int parse_eol = 0x0020;
+	
+	// This flag determines if attribute values are normalized using CDATA normalization rules during parsing. This flag is on by default.
+	const unsigned int parse_wconv_attribute = 0x0040;
+
+	// This flag determines if attribute values are normalized using NMTOKENS normalization rules during parsing. This flag is off by default.
+	const unsigned int parse_wnorm_attribute = 0x0080;
+	
+	// This flag determines if document declaration (node_declaration) is added to the DOM tree. This flag is off by default.
+	const unsigned int parse_declaration = 0x0100;
+
+	// This flag determines if document type declaration (node_doctype) is added to the DOM tree. This flag is off by default.
+	const unsigned int parse_doctype = 0x0200;
+
+	// This flag determines if plain character data (node_pcdata) that is the only child of the parent node and that consists only
+	// of whitespace is added to the DOM tree.
+	// This flag is off by default; turning it on may result in slower parsing and more memory consumption.
+	const unsigned int parse_ws_pcdata_single = 0x0400;
+
+	// The default parsing mode.
+	// Elements, PCDATA and CDATA sections are added to the DOM tree, character/reference entities are expanded,
+	// End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.
+	const unsigned int parse_default = parse_cdata | parse_escapes | parse_wconv_attribute | parse_eol;
+
+	// The full parsing mode.
+	// Nodes of all types are added to the DOM tree, character/reference entities are expanded,
+	// End-of-Line characters are normalized, attribute values are normalized using CDATA normalization rules.
+	const unsigned int parse_full = parse_default | parse_pi | parse_comments | parse_declaration | parse_doctype;
+
+	// These flags determine the encoding of input data for XML document
+	enum xml_encoding
+	{
+		encoding_auto,		// Auto-detect input encoding using BOM or < / <? detection; use UTF8 if BOM is not found
+		encoding_utf8,		// UTF8 encoding
+		encoding_utf16_le,	// Little-endian UTF16
+		encoding_utf16_be,	// Big-endian UTF16
+		encoding_utf16,		// UTF16 with native endianness
+		encoding_utf32_le,	// Little-endian UTF32
+		encoding_utf32_be,	// Big-endian UTF32
+		encoding_utf32,		// UTF32 with native endianness
+		encoding_wchar,		// The same encoding wchar_t has (either UTF16 or UTF32)
+		encoding_latin1
+	};
+
+	// 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;
+	
+	// Write encoding-specific BOM to the output stream. This flag is off by default.
+	const unsigned int format_write_bom = 0x02;
+
+	// Use raw output mode (no indentation and no line breaks are written). This flag is off by default.
+	const unsigned int format_raw = 0x04;
+	
+	// Omit default XML declaration even if there is no declaration in the document. This flag is off by default.
+	const unsigned int format_no_declaration = 0x08;
+
+	// Don't escape attribute values and PCDATA contents. This flag is off by default.
+	const unsigned int format_no_escapes = 0x10;
+
+	// Open file using text mode in xml_document::save_file. This enables special character (i.e. new-line) conversions on some systems. This flag is off by default.
+	const unsigned int format_save_file_text = 0x20;
+
+	// The default set of formatting flags.
+	// Nodes are indented depending on their depth in DOM tree, a default declaration is output if document has none.
+	const unsigned int format_default = format_indent;
+		
+	// Forward declarations
+	struct xml_attribute_struct;
+	struct xml_node_struct;
+
+	class xml_node_iterator;
+	class xml_attribute_iterator;
+	class xml_named_node_iterator;
+
+	class xml_tree_walker;
+
+	class xml_node;
+
+	class xml_text;
+	
+	#ifndef PUGIXML_NO_XPATH
+	class xpath_node;
+	class xpath_node_set;
+	class xpath_query;
+	class xpath_variable_set;
+	#endif
+
+	// Range-based for loop support
+	template <typename It> class xml_object_range
+	{
+	public:
+		typedef It const_iterator;
+
+		xml_object_range(It b, It e): _begin(b), _end(e)
+		{
+		}
+
+		It begin() const { return _begin; }
+		It end() const { return _end; }
+
+	private:
+		It _begin, _end;
+	};
+
+	// Writer interface for node printing (see xml_node::print)
+	class PUGIXML_CLASS xml_writer
+	{
+	public:
+		virtual ~xml_writer() {}
+
+		// Write memory chunk into stream/file/whatever
+		virtual void write(const void* data, size_t size) = 0;
+	};
+
+	// xml_writer implementation for FILE*
+	class PUGIXML_CLASS xml_writer_file: public xml_writer
+	{
+	public:
+		// Construct writer from a FILE* object; void* is used to avoid header dependencies on stdio
+		xml_writer_file(void* file);
+
+		virtual void write(const void* data, size_t size);
+
+	private:
+		void* file;
+	};
+
+	#ifndef PUGIXML_NO_STL
+	// xml_writer implementation for streams
+	class PUGIXML_CLASS xml_writer_stream: public xml_writer
+	{
+	public:
+		// Construct writer from an output stream object
+		xml_writer_stream(std::basic_ostream<char, std::char_traits<char> >& stream);
+		xml_writer_stream(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream);
+
+		virtual void write(const void* data, size_t size);
+
+	private:
+		std::basic_ostream<char, std::char_traits<char> >* narrow_stream;
+		std::basic_ostream<wchar_t, std::char_traits<wchar_t> >* wide_stream;
+	};
+	#endif
+
+	// A light-weight handle for manipulating attributes in DOM tree
+	class PUGIXML_CLASS xml_attribute
+	{
+		friend class xml_attribute_iterator;
+		friend class xml_node;
+
+	private:
+		xml_attribute_struct* _attr;
+	
+		typedef void (*unspecified_bool_type)(xml_attribute***);
+
+	public:
+		// Default constructor. Constructs an empty attribute.
+		xml_attribute();
+		
+		// Constructs attribute from internal pointer
+		explicit xml_attribute(xml_attribute_struct* attr);
+
+		// Safe bool conversion operator
+		operator unspecified_bool_type() const;
+
+		// Borland C++ workaround
+		bool operator!() const;
+
+		// Comparison operators (compares wrapped attribute pointers)
+		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;
+
+		// Check if attribute is empty
+		bool empty() const;
+
+		// Get attribute name/value, or "" if attribute is empty
+		const char_t* name() const;
+		const char_t* value() const;
+
+		// Get attribute value, or the default value if attribute is empty
+		const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;
+
+		// Get attribute value as a number, or the default value if conversion did not succeed or attribute is empty
+		int as_int(int def = 0) const;
+		unsigned int as_uint(unsigned int def = 0) const;
+		double as_double(double def = 0) const;
+		float as_float(float def = 0) const;
+
+		// Get attribute value as bool (returns true if first character is in '1tTyY' set), or the default value if attribute is empty
+		bool as_bool(bool def = false) const;
+
+		// Set attribute name/value (returns false if attribute is empty or there is not enough memory)
+		bool set_name(const char_t* rhs);
+		bool set_value(const char_t* rhs);
+
+		// Set attribute value with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
+		bool set_value(int rhs);
+		bool set_value(unsigned int rhs);
+		bool set_value(double rhs);
+		bool set_value(bool rhs);
+
+		// Set attribute value (equivalent to set_value without error checking)
+		xml_attribute& operator=(const char_t* rhs);
+		xml_attribute& operator=(int rhs);
+		xml_attribute& operator=(unsigned int rhs);
+		xml_attribute& operator=(double rhs);
+		xml_attribute& operator=(bool rhs);
+
+		// Get next/previous attribute in the attribute list of the parent node
+		xml_attribute next_attribute() const;
+		xml_attribute previous_attribute() const;
+
+		// Get hash value (unique for handles to the same object)
+		size_t hash_value() const;
+
+		// Get internal pointer
+		xml_attribute_struct* internal_object() const;
+	};
+
+#ifdef __BORLANDC__
+	// Borland C++ workaround
+	bool PUGIXML_FUNCTION operator&&(const xml_attribute& lhs, bool rhs);
+	bool PUGIXML_FUNCTION operator||(const xml_attribute& lhs, bool rhs);
+#endif
+
+	// A light-weight handle for manipulating nodes in DOM tree
+	class PUGIXML_CLASS xml_node
+	{
+		friend class xml_attribute_iterator;
+		friend class xml_node_iterator;
+		friend class xml_named_node_iterator;
+
+	protected:
+		xml_node_struct* _root;
+
+		typedef void (*unspecified_bool_type)(xml_node***);
+
+	public:
+		// Default constructor. Constructs an empty node.
+		xml_node();
+
+		// Constructs node from internal pointer
+		explicit xml_node(xml_node_struct* p);
+
+		// Safe bool conversion operator
+		operator unspecified_bool_type() const;
+
+		// Borland C++ workaround
+		bool operator!() const;
+	
+		// Comparison operators (compares wrapped node pointers)
+		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;
+
+		// Check if node is empty.
+		bool empty() const;
+
+		// Get node type
+		xml_node_type type() const;
+
+		// Get node name/value, or "" if node is empty or it has no name/value
+		const char_t* name() const;
+		const char_t* value() const;
+	
+		// Get attribute list
+		xml_attribute first_attribute() const;
+		xml_attribute last_attribute() const;
+
+		// Get children list
+		xml_node first_child() const;
+		xml_node last_child() const;
+
+		// Get next/previous sibling in the children list of the parent node
+		xml_node next_sibling() const;
+		xml_node previous_sibling() const;
+		
+		// Get parent node
+		xml_node parent() const;
+
+		// Get root of DOM tree this node belongs to
+		xml_node root() const;
+
+		// Get text object for the current node
+		xml_text text() const;
+
+		// Get child, attribute or next/previous sibling with the specified name
+		xml_node child(const char_t* name) const;
+		xml_attribute attribute(const char_t* name) const;
+		xml_node next_sibling(const char_t* name) const;
+		xml_node previous_sibling(const char_t* name) const;
+
+		// Get child value of current node; that is, value of the first child node of type PCDATA/CDATA
+		const char_t* child_value() const;
+
+		// Get child value of child with specified name. Equivalent to child(name).child_value().
+		const char_t* child_value(const char_t* name) const;
+
+		// Set node name/value (returns false if node is empty, there is not enough memory, or node can not have name/value)
+		bool set_name(const char_t* rhs);
+		bool set_value(const char_t* rhs);
+		
+		// Add attribute with specified name. Returns added attribute, or empty attribute on errors.
+		xml_attribute append_attribute(const char_t* name);
+		xml_attribute prepend_attribute(const char_t* name);
+		xml_attribute insert_attribute_after(const char_t* name, const xml_attribute& attr);
+		xml_attribute insert_attribute_before(const char_t* name, const xml_attribute& attr);
+
+		// Add a copy of the specified attribute. Returns added attribute, or empty attribute on errors.
+		xml_attribute append_copy(const xml_attribute& proto);
+		xml_attribute prepend_copy(const xml_attribute& proto);
+		xml_attribute insert_copy_after(const xml_attribute& proto, const xml_attribute& attr);
+		xml_attribute insert_copy_before(const xml_attribute& proto, const xml_attribute& attr);
+
+		// Add child node with specified type. Returns added node, or empty node on errors.
+		xml_node append_child(xml_node_type type = node_element);
+		xml_node prepend_child(xml_node_type type = node_element);
+		xml_node insert_child_after(xml_node_type type, const xml_node& node);
+		xml_node insert_child_before(xml_node_type type, const xml_node& node);
+
+		// Add child element with specified name. Returns added node, or empty node on errors.
+		xml_node append_child(const char_t* name);
+		xml_node prepend_child(const char_t* name);
+		xml_node insert_child_after(const char_t* name, const xml_node& node);
+		xml_node insert_child_before(const char_t* name, const xml_node& node);
+
+		// Add a copy of the specified node as a child. Returns added node, or empty node on errors.
+		xml_node append_copy(const xml_node& proto);
+		xml_node prepend_copy(const xml_node& proto);
+		xml_node insert_copy_after(const xml_node& proto, const xml_node& node);
+		xml_node insert_copy_before(const xml_node& proto, const xml_node& node);
+
+		// Remove specified attribute
+		bool remove_attribute(const xml_attribute& a);
+		bool remove_attribute(const char_t* name);
+
+		// Remove specified child
+		bool remove_child(const xml_node& n);
+		bool remove_child(const char_t* name);
+
+		// Find attribute using predicate. Returns first attribute for which predicate returned true.
+		template <typename Predicate> xml_attribute find_attribute(Predicate pred) const
+		{
+			if (!_root) return xml_attribute();
+			
+			for (xml_attribute attrib = first_attribute(); attrib; attrib = attrib.next_attribute())
+				if (pred(attrib))
+					return attrib;
+		
+			return xml_attribute();
+		}
+
+		// Find child node using predicate. Returns first child for which predicate returned true.
+		template <typename Predicate> xml_node find_child(Predicate pred) const
+		{
+			if (!_root) return xml_node();
+	
+			for (xml_node node = first_child(); node; node = node.next_sibling())
+				if (pred(node))
+					return node;
+		
+			return xml_node();
+		}
+
+		// Find node from subtree using predicate. Returns first node from subtree (depth-first), for which predicate returned true.
+		template <typename Predicate> xml_node find_node(Predicate pred) const
+		{
+			if (!_root) return xml_node();
+
+			xml_node cur = first_child();
+			
+			while (cur._root && cur._root != _root)
+			{
+				if (pred(cur)) return cur;
+
+				if (cur.first_child()) cur = cur.first_child();
+				else if (cur.next_sibling()) cur = cur.next_sibling();
+				else
+				{
+					while (!cur.next_sibling() && cur._root != _root) cur = cur.parent();
+
+					if (cur._root != _root) cur = cur.next_sibling();
+				}
+			}
+
+			return xml_node();
+		}
+
+		// Find child node by attribute name/value
+		xml_node find_child_by_attribute(const char_t* name, const char_t* attr_name, const char_t* attr_value) const;
+		xml_node find_child_by_attribute(const char_t* attr_name, const char_t* attr_value) const;
+
+	#ifndef PUGIXML_NO_STL
+		// Get the absolute node path from root as a text string.
+		string_t path(char_t delimiter = '/') const;
+	#endif
+
+		// Search for a node by path consisting of node names and . or .. elements.
+		xml_node first_element_by_path(const char_t* path, char_t delimiter = '/') const;
+
+		// Recursively traverse subtree with xml_tree_walker
+		bool traverse(xml_tree_walker& walker);
+	
+	#ifndef PUGIXML_NO_XPATH
+		// Select single node by evaluating XPath query. Returns first node from the resulting node set.
+		xpath_node select_single_node(const char_t* query, xpath_variable_set* variables = 0) const;
+		xpath_node select_single_node(const xpath_query& query) const;
+
+		// Select node set by evaluating XPath query
+		xpath_node_set select_nodes(const char_t* query, xpath_variable_set* variables = 0) const;
+		xpath_node_set select_nodes(const xpath_query& query) const;
+	#endif
+		
+		// Print subtree using a writer object
+		void print(xml_writer& writer, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto, unsigned int depth = 0) const;
+
+	#ifndef PUGIXML_NO_STL
+		// Print subtree to stream
+		void print(std::basic_ostream<char, std::char_traits<char> >& os, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto, unsigned int depth = 0) const;
+		void print(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& os, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, unsigned int depth = 0) const;
+	#endif
+
+		// Child nodes iterators
+		typedef xml_node_iterator iterator;
+
+		iterator begin() const;
+		iterator end() const;
+
+		// Attribute iterators
+		typedef xml_attribute_iterator attribute_iterator;
+
+		attribute_iterator attributes_begin() const;
+		attribute_iterator attributes_end() const;
+
+		// Range-based for support
+		xml_object_range<xml_node_iterator> children() const;
+		xml_object_range<xml_named_node_iterator> children(const char_t* name) const;
+		xml_object_range<xml_attribute_iterator> attributes() const;
+
+		// Get node offset in parsed file/string (in char_t units) for debugging purposes
+		ptrdiff_t offset_debug() const;
+
+		// Get hash value (unique for handles to the same object)
+		size_t hash_value() const;
+
+		// Get internal pointer
+		xml_node_struct* internal_object() const;
+	};
+
+#ifdef __BORLANDC__
+	// Borland C++ workaround
+	bool PUGIXML_FUNCTION operator&&(const xml_node& lhs, bool rhs);
+	bool PUGIXML_FUNCTION operator||(const xml_node& lhs, bool rhs);
+#endif
+
+	// A helper for working with text inside PCDATA nodes
+	class PUGIXML_CLASS xml_text
+	{
+		friend class xml_node;
+
+		xml_node_struct* _root;
+
+		typedef void (*unspecified_bool_type)(xml_text***);
+
+		explicit xml_text(xml_node_struct* root);
+
+		xml_node_struct* _data_new();
+		xml_node_struct* _data() const;
+
+	public:
+		// Default constructor. Constructs an empty object.
+		xml_text();
+
+		// Safe bool conversion operator
+		operator unspecified_bool_type() const;
+
+		// Borland C++ workaround
+		bool operator!() const;
+
+		// Check if text object is empty
+		bool empty() const;
+
+		// Get text, or "" if object is empty
+		const char_t* get() const;
+
+		// Get text, or the default value if object is empty
+		const char_t* as_string(const char_t* def = PUGIXML_TEXT("")) const;
+
+		// Get text as a number, or the default value if conversion did not succeed or object is empty
+		int as_int(int def = 0) const;
+		unsigned int as_uint(unsigned int def = 0) const;
+		double as_double(double def = 0) const;
+		float as_float(float def = 0) const;
+
+		// Get text as bool (returns true if first character is in '1tTyY' set), or the default value if object is empty
+		bool as_bool(bool def = false) const;
+
+		// Set text (returns false if object is empty or there is not enough memory)
+		bool set(const char_t* rhs);
+
+		// Set text with type conversion (numbers are converted to strings, boolean is converted to "true"/"false")
+		bool set(int rhs);
+		bool set(unsigned int rhs);
+		bool set(double rhs);
+		bool set(bool rhs);
+
+		// Set text (equivalent to set without error checking)
+		xml_text& operator=(const char_t* rhs);
+		xml_text& operator=(int rhs);
+		xml_text& operator=(unsigned int rhs);
+		xml_text& operator=(double rhs);
+		xml_text& operator=(bool rhs);
+
+		// Get the data node (node_pcdata or node_cdata) for this object
+		xml_node data() const;
+	};
+
+#ifdef __BORLANDC__
+	// Borland C++ workaround
+	bool PUGIXML_FUNCTION operator&&(const xml_text& lhs, bool rhs);
+	bool PUGIXML_FUNCTION operator||(const xml_text& lhs, bool rhs);
+#endif
+
+	// Child node iterator (a bidirectional iterator over a collection of xml_node)
+	class PUGIXML_CLASS xml_node_iterator
+	{
+		friend class xml_node;
+
+	private:
+		mutable xml_node _wrap;
+		xml_node _parent;
+
+		xml_node_iterator(xml_node_struct* ref, xml_node_struct* parent);
+
+	public:
+		// Iterator traits
+		typedef ptrdiff_t difference_type;
+		typedef xml_node value_type;
+		typedef xml_node* pointer;
+		typedef xml_node& reference;
+
+	#ifndef PUGIXML_NO_STL
+		typedef std::bidirectional_iterator_tag iterator_category;
+	#endif
+
+		// Default constructor
+		xml_node_iterator();
+
+		// Construct an iterator which points to the specified node
+		xml_node_iterator(const xml_node& node);
+
+		// Iterator operators
+		bool operator==(const xml_node_iterator& rhs) const;
+		bool operator!=(const xml_node_iterator& rhs) const;
+
+		xml_node& operator*() 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 (a bidirectional iterator over a collection of xml_attribute)
+	class PUGIXML_CLASS xml_attribute_iterator
+	{
+		friend class xml_node;
+
+	private:
+		mutable xml_attribute _wrap;
+		xml_node _parent;
+
+		xml_attribute_iterator(xml_attribute_struct* ref, xml_node_struct* parent);
+
+	public:
+		// Iterator traits
+		typedef ptrdiff_t difference_type;
+		typedef xml_attribute value_type;
+		typedef xml_attribute* pointer;
+		typedef xml_attribute& reference;
+
+	#ifndef PUGIXML_NO_STL
+		typedef std::bidirectional_iterator_tag iterator_category;
+	#endif
+
+		// Default constructor
+		xml_attribute_iterator();
+
+		// Construct an iterator which points to the specified attribute
+		xml_attribute_iterator(const xml_attribute& attr, const xml_node& parent);
+
+		// Iterator operators
+		bool operator==(const xml_attribute_iterator& rhs) const;
+		bool operator!=(const xml_attribute_iterator& rhs) const;
+
+		xml_attribute& operator*() 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);
+	};
+
+	// Named node range helper
+	class xml_named_node_iterator
+	{
+	public:
+		// Iterator traits
+		typedef ptrdiff_t difference_type;
+		typedef xml_node value_type;
+		typedef xml_node* pointer;
+		typedef xml_node& reference;
+
+	#ifndef PUGIXML_NO_STL
+		typedef std::forward_iterator_tag iterator_category;
+	#endif
+
+		// Default constructor
+		xml_named_node_iterator();
+
+		// Construct an iterator which points to the specified node
+		xml_named_node_iterator(const xml_node& node, const char_t* name);
+
+		// Iterator operators
+		bool operator==(const xml_named_node_iterator& rhs) const;
+		bool operator!=(const xml_named_node_iterator& rhs) const;
+
+		xml_node& operator*() const;
+		xml_node* operator->() const;
+
+		const xml_named_node_iterator& operator++();
+		xml_named_node_iterator operator++(int);
+
+	private:
+		mutable xml_node _node;
+		const char_t* _name;
+	};
+
+	// Abstract tree walker class (see xml_node::traverse)
+	class PUGIXML_CLASS xml_tree_walker
+	{
+		friend class xml_node;
+
+	private:
+		int _depth;
+	
+	protected:
+		// Get current traversal depth
+		int depth() const;
+	
+	public:
+		xml_tree_walker();
+		virtual ~xml_tree_walker();
+
+		// Callback that is called when traversal begins
+		virtual bool begin(xml_node& node);
+
+		// Callback that is called for each node traversed
+		virtual bool for_each(xml_node& node) = 0;
+
+		// Callback that is called when traversal ends
+		virtual bool end(xml_node& node);
+	};
+
+	// Parsing status, returned as part of xml_parse_result object
+	enum xml_parse_status
+	{
+		status_ok = 0,				// No error
+
+		status_file_not_found,		// File was not found during load_file()
+		status_io_error,			// Error reading from file/stream
+		status_out_of_memory,		// Could not allocate memory
+		status_internal_error,		// Internal error occurred
+
+		status_unrecognized_tag,	// Parser could not determine tag type
+
+		status_bad_pi,				// Parsing error occurred while parsing document declaration/processing instruction
+		status_bad_comment,			// Parsing error occurred while parsing comment
+		status_bad_cdata,			// Parsing error occurred while parsing CDATA section
+		status_bad_doctype,			// Parsing error occurred while parsing document type declaration
+		status_bad_pcdata,			// Parsing error occurred while parsing PCDATA section
+		status_bad_start_element,	// Parsing error occurred while parsing start element tag
+		status_bad_attribute,		// Parsing error occurred while parsing element attribute
+		status_bad_end_element,		// Parsing error occurred while parsing end element tag
+		status_end_element_mismatch // There was a mismatch of start-end tags (closing tag had incorrect name, some tag was not closed or there was an excessive closing tag)
+	};
+
+	// Parsing result
+	struct PUGIXML_CLASS xml_parse_result
+	{
+		// Parsing status (see xml_parse_status)
+		xml_parse_status status;
+
+		// Last parsed offset (in char_t units from start of input data)
+		ptrdiff_t offset;
+
+		// Source document encoding
+		xml_encoding encoding;
+
+		// Default constructor, initializes object to failed state
+		xml_parse_result();
+
+		// Cast to bool operator
+		operator bool() const;
+
+		// Get error description
+		const char* description() const;
+	};
+
+	// Document class (DOM tree root)
+	class PUGIXML_CLASS xml_document: public xml_node
+	{
+	private:
+		char_t* _buffer;
+
+		char _memory[192];
+		
+		// Non-copyable semantics
+		xml_document(const xml_document&);
+		const xml_document& operator=(const xml_document&);
+
+		void create();
+		void destroy();
+
+		xml_parse_result load_buffer_impl(void* contents, size_t size, unsigned int options, xml_encoding encoding, bool is_mutable, bool own);
+
+	public:
+		// Default constructor, makes empty document
+		xml_document();
+
+		// Destructor, invalidates all node/attribute handles to this document
+		~xml_document();
+
+		// Removes all nodes, leaving the empty document
+		void reset();
+
+		// Removes all nodes, then copies the entire contents of the specified document
+		void reset(const xml_document& proto);
+
+	#ifndef PUGIXML_NO_STL
+		// Load document from stream.
+		xml_parse_result load(std::basic_istream<char, std::char_traits<char> >& stream, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
+		xml_parse_result load(std::basic_istream<wchar_t, std::char_traits<wchar_t> >& stream, unsigned int options = parse_default);
+	#endif
+
+		// Load document from zero-terminated string. No encoding conversions are applied.
+		xml_parse_result load(const char_t* contents, unsigned int options = parse_default);
+
+		// Load document from file
+		xml_parse_result load_file(const char* path, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
+		xml_parse_result load_file(const wchar_t* path, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
+
+		// Load document from buffer. Copies/converts the buffer, so it may be deleted or changed after the function returns.
+		xml_parse_result load_buffer(const void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
+
+		// Load document from buffer, using the buffer for in-place parsing (the buffer is modified and used for storage of document data).
+		// You should ensure that buffer data will persist throughout the document's lifetime, and free the buffer memory manually once document is destroyed.
+		xml_parse_result load_buffer_inplace(void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
+
+		// Load document from buffer, using the buffer for in-place parsing (the buffer is modified and used for storage of document data).
+		// You should allocate the buffer with pugixml allocation function; document will free the buffer when it is no longer needed (you can't use it anymore).
+		xml_parse_result load_buffer_inplace_own(void* contents, size_t size, unsigned int options = parse_default, xml_encoding encoding = encoding_auto);
+
+		// Save XML document to writer (semantics is slightly different from xml_node::print, see documentation for details).
+		void save(xml_writer& writer, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
+
+	#ifndef PUGIXML_NO_STL
+		// Save XML document to stream (semantics is slightly different from xml_node::print, see documentation for details).
+		void save(std::basic_ostream<char, std::char_traits<char> >& stream, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
+		void save(std::basic_ostream<wchar_t, std::char_traits<wchar_t> >& stream, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default) const;
+	#endif
+
+		// Save XML to file
+		bool save_file(const char* path, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
+		bool save_file(const wchar_t* path, const char_t* indent = PUGIXML_TEXT("\t"), unsigned int flags = format_default, xml_encoding encoding = encoding_auto) const;
+
+		// Get document element
+		xml_node document_element() const;
+	};
+
+#ifndef PUGIXML_NO_XPATH
+	// XPath query return type
+	enum xpath_value_type
+	{
+		xpath_type_none,	  // Unknown type (query failed to compile)
+		xpath_type_node_set,  // Node set (xpath_node_set)
+		xpath_type_number,	  // Number
+		xpath_type_string,	  // String
+		xpath_type_boolean	  // Boolean
+	};
+
+	// XPath parsing result
+	struct PUGIXML_CLASS xpath_parse_result
+	{
+		// Error message (0 if no error)
+		const char* error;
+
+		// Last parsed offset (in char_t units from string start)
+		ptrdiff_t offset;
+
+		// Default constructor, initializes object to failed state
+		xpath_parse_result();
+
+		// Cast to bool operator
+		operator bool() const;
+
+		// Get error description
+		const char* description() const;
+	};
+
+	// A single XPath variable
+	class PUGIXML_CLASS xpath_variable
+	{
+		friend class xpath_variable_set;
+
+	protected:
+		xpath_value_type _type;
+		xpath_variable* _next;
+
+		xpath_variable();
+
+		// Non-copyable semantics
+		xpath_variable(const xpath_variable&);
+		xpath_variable& operator=(const xpath_variable&);
+		
+	public:
+		// Get variable name
+		const char_t* name() const;
+
+		// Get variable type
+		xpath_value_type type() const;
+
+		// Get variable value; no type conversion is performed, default value (false, NaN, empty string, empty node set) is returned on type mismatch error
+		bool get_boolean() const;
+		double get_number() const;
+		const char_t* get_string() const;
+		const xpath_node_set& get_node_set() const;
+
+		// Set variable value; no type conversion is performed, false is returned on type mismatch error
+		bool set(bool value);
+		bool set(double value);
+		bool set(const char_t* value);
+		bool set(const xpath_node_set& value);
+	};
+
+	// A set of XPath variables
+	class PUGIXML_CLASS xpath_variable_set
+	{
+	private:
+		xpath_variable* _data[64];
+
+		// Non-copyable semantics
+		xpath_variable_set(const xpath_variable_set&);
+		xpath_variable_set& operator=(const xpath_variable_set&);
+
+		xpath_variable* find(const char_t* name) const;
+
+	public:
+		// Default constructor/destructor
+		xpath_variable_set();
+		~xpath_variable_set();
+
+		// Add a new variable or get the existing one, if the types match
+		xpath_variable* add(const char_t* name, xpath_value_type type);
+
+		// Set value of an existing variable; no type conversion is performed, false is returned if there is no such variable or if types mismatch
+		bool set(const char_t* name, bool value);
+		bool set(const char_t* name, double value);
+		bool set(const char_t* name, const char_t* value);
+		bool set(const char_t* name, const xpath_node_set& value);
+
+		// Get existing variable by name
+		xpath_variable* get(const char_t* name);
+		const xpath_variable* get(const char_t* name) const;
+	};
+
+	// A compiled XPath query object
+	class PUGIXML_CLASS xpath_query
+	{
+	private:
+		void* _impl;
+		xpath_parse_result _result;
+
+		typedef void (*unspecified_bool_type)(xpath_query***);
+
+		// Non-copyable semantics
+		xpath_query(const xpath_query&);
+		xpath_query& operator=(const xpath_query&);
+
+	public:
+		// Construct a compiled object from XPath expression.
+		// If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on compilation errors.
+		explicit xpath_query(const char_t* query, xpath_variable_set* variables = 0);
+
+		// Destructor
+		~xpath_query();
+
+		// Get query expression return type
+		xpath_value_type return_type() const;
+		
+		// Evaluate expression as boolean value in the specified context; performs type conversion if necessary.
+		// If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
+		bool evaluate_boolean(const xpath_node& n) const;
+		
+		// Evaluate expression as double value in the specified context; performs type conversion if necessary.
+		// If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
+		double evaluate_number(const xpath_node& n) const;
+		
+	#ifndef PUGIXML_NO_STL
+		// Evaluate expression as string value in the specified context; performs type conversion if necessary.
+		// If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
+		string_t evaluate_string(const xpath_node& n) const;
+	#endif
+		
+		// Evaluate expression as string value in the specified context; performs type conversion if necessary.
+		// At most capacity characters are written to the destination buffer, full result size is returned (includes terminating zero).
+		// If PUGIXML_NO_EXCEPTIONS is not defined, throws std::bad_alloc on out of memory errors.
+		// If PUGIXML_NO_EXCEPTIONS is defined, returns empty  set instead.
+		size_t evaluate_string(char_t* buffer, size_t capacity, const xpath_node& n) const;
+
+		// Evaluate expression as node set in the specified context.
+		// If PUGIXML_NO_EXCEPTIONS is not defined, throws xpath_exception on type mismatch and std::bad_alloc on out of memory errors.
+		// If PUGIXML_NO_EXCEPTIONS is defined, returns empty node set instead.
+		xpath_node_set evaluate_node_set(const xpath_node& n) const;
+
+		// Get parsing result (used to get compilation errors in PUGIXML_NO_EXCEPTIONS mode)
+		const xpath_parse_result& result() const;
+
+		// Safe bool conversion operator
+		operator unspecified_bool_type() const;
+
+		// Borland C++ workaround
+		bool operator!() const;
+	};
+	
+	#ifndef PUGIXML_NO_EXCEPTIONS
+	// XPath exception class
+	class PUGIXML_CLASS xpath_exception: public std::exception
+	{
+	private:
+		xpath_parse_result _result;
+
+	public:
+		// Construct exception from parse result
+		explicit xpath_exception(const xpath_parse_result& result);
+
+		// Get error message
+		virtual const char* what() const throw();
+
+		// Get parse result
+		const xpath_parse_result& result() const;
+	};
+	#endif
+	
+	// XPath node class (either xml_node or xml_attribute)
+	class PUGIXML_CLASS xpath_node
+	{
+	private:
+		xml_node _node;
+		xml_attribute _attribute;
+	
+		typedef void (*unspecified_bool_type)(xpath_node***);
+
+	public:
+		// Default constructor; constructs empty XPath node
+		xpath_node();
+		
+		// Construct XPath node from XML node/attribute
+		xpath_node(const xml_node& node);
+		xpath_node(const xml_attribute& attribute, const xml_node& parent);
+
+		// Get node/attribute, if any
+		xml_node node() const;
+		xml_attribute attribute() const;
+		
+		// Get parent of contained node/attribute
+		xml_node parent() const;
+
+		// Safe bool conversion operator
+		operator unspecified_bool_type() const;
+		
+		// Borland C++ workaround
+		bool operator!() const;
+
+		// Comparison operators
+		bool operator==(const xpath_node& n) const;
+		bool operator!=(const xpath_node& n) const;
+	};
+
+#ifdef __BORLANDC__
+	// Borland C++ workaround
+	bool PUGIXML_FUNCTION operator&&(const xpath_node& lhs, bool rhs);
+	bool PUGIXML_FUNCTION operator||(const xpath_node& lhs, bool rhs);
+#endif
+
+	// A fixed-size collection of XPath nodes
+	class PUGIXML_CLASS xpath_node_set
+	{
+	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;
+	
+		// Default constructor. Constructs empty set.
+		xpath_node_set();
+
+		// Constructs a set from iterator range; data is not checked for duplicates and is not sorted according to provided type, so be careful
+		xpath_node_set(const_iterator begin, const_iterator end, type_t type = type_unsorted);
+
+		// Destructor
+		~xpath_node_set();
+		
+		// Copy constructor/assignment operator
+		xpath_node_set(const xpath_node_set& ns);
+		xpath_node_set& operator=(const xpath_node_set& ns);
+
+		// Get collection type
+		type_t type() const;
+		
+		// Get collection size
+		size_t size() const;
+
+		// Indexing operator
+		const xpath_node& operator[](size_t index) const;
+		
+		// Collection iterators
+		const_iterator begin() const;
+		const_iterator end() const;
+
+		// Sort the collection in ascending/descending order by document order
+		void sort(bool reverse = false);
+		
+		// Get first node in the collection by document order
+		xpath_node first() const;
+		
+		// Check if collection is empty
+		bool empty() const;
+	
+	private:
+		type_t _type;
+		
+		xpath_node _storage;
+		
+		xpath_node* _begin;
+		xpath_node* _end;
+
+		void _assign(const_iterator begin, const_iterator end);
+	};
+#endif
+
+#ifndef PUGIXML_NO_STL
+	// Convert wide string to UTF8
+	std::basic_string<char, std::char_traits<char>, std::allocator<char> > PUGIXML_FUNCTION as_utf8(const wchar_t* str);
+	std::basic_string<char, std::char_traits<char>, std::allocator<char> > PUGIXML_FUNCTION as_utf8(const std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >& str);
+	
+	// Convert UTF8 to wide string
+	std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > PUGIXML_FUNCTION as_wide(const char* str);
+	std::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> > PUGIXML_FUNCTION as_wide(const std::basic_string<char, std::char_traits<char>, std::allocator<char> >& str);
+#endif
+
+	// Memory allocation function interface; returns pointer to allocated memory or NULL on failure
+	typedef void* (*allocation_function)(size_t size);
+	
+	// Memory deallocation function interface
+	typedef void (*deallocation_function)(void* ptr);
+
+	// Override default memory management functions. All subsequent allocations/deallocations will be performed via supplied functions.
+	void PUGIXML_FUNCTION set_memory_management_functions(allocation_function allocate, deallocation_function deallocate);
+	
+	// Get current memory management functions
+	allocation_function PUGIXML_FUNCTION get_memory_allocation_function();
+	deallocation_function PUGIXML_FUNCTION get_memory_deallocation_function();
+}
+
+#if !defined(PUGIXML_NO_STL) && (defined(_MSC_VER) || defined(__ICC))
+namespace std
+{
+	// Workarounds for (non-standard) iterator category detection for older versions (MSVC7/IC8 and earlier)
+	std::bidirectional_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_node_iterator&);
+	std::bidirectional_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_attribute_iterator&);
+	std::forward_iterator_tag PUGIXML_FUNCTION _Iter_cat(const pugi::xml_named_node_iterator&);
+}
+#endif
+
+#if !defined(PUGIXML_NO_STL) && defined(__SUNPRO_CC)
+namespace std
+{
+	// Workarounds for (non-standard) iterator category detection
+	std::bidirectional_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_node_iterator&);
+	std::bidirectional_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_attribute_iterator&);
+	std::forward_iterator_tag PUGIXML_FUNCTION __iterator_category(const pugi::xml_named_node_iterator&);
+}
+#endif
+
+#endif
+
+/**
+ * Copyright (c) 2006-2012 Arseny Kapoulkine
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
diff --git a/tools/intergen/tool/CMakeLists.txt b/tools/intergen/tool/CMakeLists.txt
new file mode 100644
index 0000000000..775988a149
--- /dev/null
+++ b/tools/intergen/tool/CMakeLists.txt
@@ -0,0 +1,10 @@
+include_directories(
+  ${pugixml_SOURCE_DIR}/../src
+  ${intergen_SOURCE_DIR}/cppgen/include
+  ${intergen_SOURCE_DIR}/model/include
+  ${intergen_SOURCE_DIR}/utils/include
+)
+
+add_executable(intergen intergen.cc)
+target_link_libraries(intergen intergen_cppgen intergen_model intergen_utils pugixml)
+install(TARGETS intergen RUNTIME DESTINATION bin)
diff --git a/tools/intergen/tool/intergen.cc b/tools/intergen/tool/intergen.cc
new file mode 100644
index 0000000000..bad87b178b
--- /dev/null
+++ b/tools/intergen/tool/intergen.cc
@@ -0,0 +1,186 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include <set>
+#include <sstream>
+
+#include "getopt.h"
+
+#include "cppgen/cpp_api_code_generator.h"
+#include "model/api.h"
+#include "model/model_filter.h"
+#include "pugixml.hpp"
+#include "utils/safeformat.h"
+
+using std::cout;
+using std::cerr;
+
+/*
+ * Parsed command line options
+ */
+struct Options {
+  char* interface_xml;
+  bool  auto_generate_function_ids;
+  bool  generate_json_code;
+  bool  generate_dbus_code;
+  std::set<std::string> requested_interfaces;
+  std::set<std::string> excluded_scopes;
+  bool  avoid_unsigned;
+  int   minimum_word_size;
+  Options()
+      : interface_xml(NULL),
+        auto_generate_function_ids(false),
+        generate_json_code(false),
+        generate_dbus_code(false),
+        avoid_unsigned(false),
+        minimum_word_size(8) {
+  }
+};
+
+void Usage() {
+  cout << "Interface generator\n"
+       << "Usage: intergen -f <xml_file> <options>\n"
+       << "Options are:\n"
+       << "  -f <xml_file>       Specifies interface definition input xml file\n"
+       << "  -i <interface_name> Specifies interface name from given xml file.\n"
+       << "                      Must be given as a lower_case_identifier.\n"
+       << "                      Option can occur multiple times to select\n"
+       << "                      multiple interfaces.\n"
+       << "  -s <scope_name>     Excludes entities marked with given scope from\n"
+       << "                      generated code. Can occur multiple times.\n"
+       << "  -a                  Automatically generates function ID enum.\n"
+       << "  -U                  Avoid unsigned integers in generated types\n"
+       << "  -w <word_bits>      Minimal word size (integer size in bits) in generated types\n"
+       << "  -j                  Generate json serialization code\n"
+       << "  -d                  Generate d-bus serialization code\n";
+}
+
+int main(int argc, char* argv[]) {
+  if (argc == 1) {
+    Usage();
+    return EXIT_FAILURE;
+  }
+  Options options;
+  const char* opts = "ajdUf:i:s:w:";
+  for (int opt = getopt(argc, argv, opts); opt != -1;
+      opt = getopt(argc, argv, opts)) {
+    switch (opt) {
+      case 'i': {
+        options.requested_interfaces.insert(optarg);
+        break;
+      }
+      case 'f': {
+        if (options.interface_xml == NULL) {
+          options.interface_xml = optarg;
+        } else {
+          cerr << "Option 'f' specified multiple times" << '\n';
+        }
+        break;
+      }
+      case 's': {
+        options.excluded_scopes.insert(optarg);
+        break;
+      }
+      case 'a': {
+        options.auto_generate_function_ids = true;
+        break;
+      }
+      case 'U': {
+        options.avoid_unsigned = true;
+        break;
+      }
+      case 'w': {
+        static const int kValidWidths[] = {8, 16, 32, 64};
+        std::set<int> valid_widths(kValidWidths, kValidWidths + 4);
+
+        std::stringstream wordwidth(optarg);
+        if (!(wordwidth>>options.minimum_word_size)
+            || valid_widths.count(options.minimum_word_size) == 0) {
+          cerr << "Invalid word size provided, valid values are "
+                  "8, 16, 32 or 64" << '\n';
+          return EXIT_FAILURE;
+        }
+        break;
+      }
+      case 'j': {
+        options.generate_json_code = true;
+        break;
+      }
+      case 'd': {
+        options.generate_dbus_code = true;
+        break;
+      }
+      default: {
+        cerr << "Invalid option: '" << opt << "'" << '\n';
+        return EXIT_FAILURE;
+      }
+    }
+  }
+
+  if (options.interface_xml == NULL) {
+    cerr << "Interface definition file must be specified" << '\n';
+    return EXIT_FAILURE;
+  }
+  pugi::xml_document doc;
+  pugi::xml_parse_result result = doc.load_file(options.interface_xml);
+  if (result) {
+    codegen::ModelFilter model_filter(options.excluded_scopes);
+    codegen::API api(&model_filter, options.auto_generate_function_ids);
+    if (api.init(doc)) {
+      codegen::CppApiCodeGenerator cpp_code_generator(&api);
+      std::set<std::string> bad =
+          cpp_code_generator.Generate(
+            codegen::Preferences(options.minimum_word_size,
+                                 options.avoid_unsigned,
+                                 options.generate_json_code,
+                                 options.generate_dbus_code,
+                                 options.requested_interfaces));
+      if (bad.empty()) {
+        return EXIT_SUCCESS;
+      } else {
+        cerr << "Failed to generate interfaces: " << '\n';
+        std::copy(bad.begin(), bad.end(),
+                  std::ostream_iterator<std::string>(cerr, "\n"));
+        cerr << '\n';
+      }
+    } else {
+      cerr << "Failed to process xml" << '\n';
+    }
+  } else {
+    std::cerr << "Failed to load xml file " << options.interface_xml << ": "
+              << result.description() << '\n';
+  }
+  return EXIT_FAILURE;
+}
diff --git a/tools/intergen/utils/CMakeLists.txt b/tools/intergen/utils/CMakeLists.txt
new file mode 100644
index 0000000000..8e2ccbd67f
--- /dev/null
+++ b/tools/intergen/utils/CMakeLists.txt
@@ -0,0 +1,22 @@
+include_directories(
+  include
+  ${pugixml_SOURCE_DIR}/../src
+)
+
+set (HEADERS
+  include/utils/common_types.h
+  include/utils/macro.h
+  include/utils/safeformat.h
+  include/utils/stl_utils.h
+  include/utils/string_utils.h
+  include/utils/xml_utils.h
+)
+
+set (SOURCES
+  src/utils/common_types.cc
+  src/utils/safeformat.cc
+  src/utils/xml_utils.cc
+)
+
+add_library(intergen_utils ${HEADERS} ${SOURCES})
+target_link_libraries(intergen_utils pugixml)
diff --git a/tools/intergen/utils/include/utils/common_types.h b/tools/intergen/utils/include/utils/common_types.h
new file mode 100644
index 0000000000..aff817b634
--- /dev/null
+++ b/tools/intergen/utils/include/utils/common_types.h
@@ -0,0 +1,132 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef COMMON_TYPES_H_
+#define COMMON_TYPES_H_
+
+#include <string>
+#include <vector>
+
+#include "utils/string_utils.h"
+
+namespace codegen {
+/*
+ * Entity description, a set of text strings.
+ */
+typedef std::vector<std::string> Description;
+
+/*
+ * Natural fraction class
+ */
+class Fraction {
+ public:
+  // Constructs fraction with value of 0/1
+  Fraction();
+  // Constructs fraction from given values
+  Fraction(int64_t numer, int64_t denumer);
+  // Parses string |literal| containing float point string definition, result is stored in
+  // |fraction| parameter.
+  // If |literal| can not be parsed, returns false.
+  static bool FromFloatPointString(const std::string& literal, Fraction* fraction);
+  // Field accessors
+  int64_t numer() const;
+  int64_t denumer() const;
+
+ private:
+  int64_t numer_;
+  int64_t denumer_;
+
+};
+
+/*
+ * Template class representing generic range with lower
+ * and upper bounds (min and max).
+ * Allows value or another range to be tested for inclusion.
+ * Range boundaries are always included in tests.
+ */
+template<typename T>
+class BasicRange {
+ public:
+  typedef T value_type;
+  // Create a range with specified bounds
+  BasicRange(value_type min, value_type max)
+      : min_(min),
+        max_(max) {
+    Fraction::FromFloatPointString(NumberToString(min_), &min_fract_);
+    Fraction::FromFloatPointString(NumberToString(max_), &max_fract_);
+  }
+  // Constructs the range from given string representations of value.
+  // Used to avoid converting fractional boundaries to floating point
+  // Representation.
+  BasicRange(const std::string& min_str, const std::string& max_str)
+      : min_(0),
+        max_(0) {
+    bool valid_min = StringToNumber(min, &min_)
+        && Fraction::FromFloatPointString(min, &min_fract_);
+    bool valid_max = StringToNumber(max, &max_)
+        && Fraction::FromFloatPointString(max, &max_fract_);
+    assert(valid_min && valid_max);
+  }
+  // Tells if |value| belongs to current range (boundaries are included)
+  bool Includes(value_type value) const {
+    return min_ <= value && value <= max_;
+  }
+
+  // Tells if another range completely belongs to current range
+  // (boundaries are included)
+  bool Includes(const BasicRange& that) {
+    return min() <= that.min() && max() >= that.max();
+  }
+
+  // Field access methods
+  value_type min() const {
+    return min_;
+  }
+  value_type max() const {
+    return max_;
+  }
+  const Fraction& min_fract() const {
+    return min_fract_;
+  }
+  const Fraction& max_fract() const {
+    return max_fract_;
+  }
+ private:
+  value_type min_;
+  value_type max_;
+  Fraction min_fract_;
+  Fraction max_fract_;
+};
+
+} // namespace codegen
+
+#endif /* COMMON_TYPES_H_ */
diff --git a/tools/intergen/utils/include/utils/macro.h b/tools/intergen/utils/include/utils/macro.h
new file mode 100644
index 0000000000..328f249329
--- /dev/null
+++ b/tools/intergen/utils/include/utils/macro.h
@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef MACRO_H_
+#define MACRO_H_
+
+/*
+ * Copy prevention helper macro
+ */
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName&);   \
+  void operator=(const TypeName&)
+
+/*
+ * C++11 optional override support macro
+ */
+#define OVERRIDE
+
+#endif /* MACRO_H_ */
diff --git a/tools/intergen/utils/include/utils/safeformat.h b/tools/intergen/utils/include/utils/safeformat.h
new file mode 100644
index 0000000000..a8f5d09d60
--- /dev/null
+++ b/tools/intergen/utils/include/utils/safeformat.h
@@ -0,0 +1,579 @@
+/*
+* Typesafe printf-like wrapper around std streams
+* by Igor Kozyrenko, 2013
+*/
+
+#include <cstring>
+#include <cwchar>
+#include <ostream>
+#include <sstream>
+
+namespace typesafe_format {
+namespace impl {
+
+// Pointer avoidance magic
+template<class T> struct no_pointers                { enum { allowed = 1 }; };
+template<>        struct no_pointers<char*>         { enum { allowed = 1 }; };
+template<>        struct no_pointers<const char*>   { enum { allowed = 1 }; };
+template<>        struct no_pointers<wchar_t*>      { enum { allowed = 1 }; };
+template<>        struct no_pointers<const wchar_t*>{ enum { allowed = 1 }; };
+template<class T> struct no_pointers<T*>            { enum { allowed = 0 }; };
+
+// Static assert helper
+template<bool b> struct my_static_assert       {};
+template<>       struct my_static_assert<true> { enum { here }; };
+
+template <typename CT>
+struct Streamable {
+  virtual void OutputToStream(std::basic_ostream<CT>& stream) const = 0;
+  virtual ~Streamable() {}
+};
+
+template <typename CT, typename T>
+struct StreamableValue: public Streamable<CT> {
+  StreamableValue(const T& val): val_(val) {
+    // You can wrap pointer with typesafe_format::ptr to pass this check
+    (void)my_static_assert<no_pointers<T>::allowed>::here;
+  }
+  void OutputToStream(std::basic_ostream<CT>& stream) const {
+    stream<<val_;
+  }
+private:
+  const T& val_;
+};
+
+inline size_t len(const char* str)    { return std::strlen(str); }
+inline size_t len(const wchar_t* str) { return std::wcslen(str); }
+
+void format_params(const char* fmt, size_t fmt_length, std::ostream& os,
+                   const Streamable<char>* params[], size_t params_count);
+void format_params(const wchar_t* fmt, size_t fmt_length, std::wostream& os,
+                   const Streamable<wchar_t>* params[], size_t params_count);
+} // namespace impl
+
+// Wrapper class to pass anti-pointer protection
+struct ptr {
+  explicit ptr(void* ptr): ptr_(ptr) {}
+private:
+  void* ptr_;
+  template <typename CT>
+  friend std::basic_ostream<CT>& operator<<(std::basic_ostream<CT>&,
+                                            const ptr&);
+};
+template <typename CT>
+inline std::basic_ostream<CT>& operator<<(std::basic_ostream<CT>& os,
+                                          const ptr& ptr) {
+  return os<<ptr.ptr_;
+}
+
+// stream format overloads
+template <typename CT>
+std::basic_ostream<CT>& strmfmtl(
+    std::basic_ostream<CT>& os, const CT* fmt, size_t fmt_length) {
+  return os.write(fmt, fmt_length);
+}
+
+template <typename CT,
+          typename T0>
+std::basic_ostream<CT>& strmfmtl(
+    std::basic_ostream<CT>& os, const CT* fmt, size_t fmt_length,
+    const T0& p0) {
+  impl::StreamableValue<CT, T0> s0(p0);
+  const impl::Streamable<CT>* params[] =
+      {&s0};
+  impl::format_params(fmt, fmt_length, os,
+      params, sizeof params/sizeof params[0]);
+  return os;
+}
+
+template <typename CT,
+          typename T0, typename T1>
+std::basic_ostream<CT>& strmfmtl(
+    std::basic_ostream<CT>& os, const CT* fmt, size_t fmt_length,
+    const T0& p0, const T1& p1) {
+  impl::StreamableValue<CT, T0> s0(p0);
+  impl::StreamableValue<CT, T1> s1(p1);
+  const impl::Streamable<CT>* params[] =
+      {&s0, &s1};
+  impl::format_params(fmt, fmt_length, os,
+      params, sizeof params/sizeof params[0]);
+  return os;
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2>
+std::basic_ostream<CT>& strmfmtl(
+    std::basic_ostream<CT>& os, const CT* fmt, size_t fmt_length,
+    const T0& p0, const T1& p1, const T2& p2) {
+  impl::StreamableValue<CT, T0> s0(p0);
+  impl::StreamableValue<CT, T1> s1(p1);
+  impl::StreamableValue<CT, T2> s2(p2);
+  const impl::Streamable<CT>* params[] =
+      {&s0, &s1, &s2};
+  impl::format_params(fmt, fmt_length, os,
+      params, sizeof params/sizeof params[0]);
+  return os;
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3>
+std::basic_ostream<CT>& strmfmtl(
+    std::basic_ostream<CT>& os, const CT* fmt, size_t fmt_length,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3) {
+  impl::StreamableValue<CT, T0> s0(p0);
+  impl::StreamableValue<CT, T1> s1(p1);
+  impl::StreamableValue<CT, T2> s2(p2);
+  impl::StreamableValue<CT, T3> s3(p3);
+  const impl::Streamable<CT>* params[] =
+      {&s0, &s1, &s2, &s3};
+  impl::format_params(fmt, fmt_length, os,
+      params, sizeof params/sizeof params[0]);
+  return os;
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4>
+std::basic_ostream<CT>& strmfmtl(
+    std::basic_ostream<CT>& os, const CT* fmt, size_t fmt_length,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4) {
+  impl::StreamableValue<CT, T0> s0(p0);
+  impl::StreamableValue<CT, T1> s1(p1);
+  impl::StreamableValue<CT, T2> s2(p2);
+  impl::StreamableValue<CT, T3> s3(p3);
+  impl::StreamableValue<CT, T4> s4(p4);
+  const impl::Streamable<CT>* params[] =
+      {&s0, &s1, &s2, &s3, &s4};
+  impl::format_params(fmt, fmt_length, os,
+      params, sizeof params/sizeof params[0]);
+  return os;
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5>
+std::basic_ostream<CT>& strmfmtl(
+    std::basic_ostream<CT>& os, const CT* fmt, size_t fmt_length,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5) {
+  impl::StreamableValue<CT, T0> s0(p0);
+  impl::StreamableValue<CT, T1> s1(p1);
+  impl::StreamableValue<CT, T2> s2(p2);
+  impl::StreamableValue<CT, T3> s3(p3);
+  impl::StreamableValue<CT, T4> s4(p4);
+  impl::StreamableValue<CT, T5> s5(p5);
+  const impl::Streamable<CT>* params[] =
+      {&s0, &s1, &s2, &s3, &s4, &s5};
+  impl::format_params(fmt, fmt_length, os,
+      params, sizeof params/sizeof params[0]);
+  return os;
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6>
+std::basic_ostream<CT>& strmfmtl(
+    std::basic_ostream<CT>& os, const CT* fmt, size_t fmt_length,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6) {
+  impl::StreamableValue<CT, T0> s0(p0);
+  impl::StreamableValue<CT, T1> s1(p1);
+  impl::StreamableValue<CT, T2> s2(p2);
+  impl::StreamableValue<CT, T3> s3(p3);
+  impl::StreamableValue<CT, T4> s4(p4);
+  impl::StreamableValue<CT, T5> s5(p5);
+  impl::StreamableValue<CT, T6> s6(p6);
+  const impl::Streamable<CT>* params[] =
+      {&s0, &s1, &s2, &s3, &s4, &s5, &s6};
+  impl::format_params(fmt, fmt_length, os,
+      params, sizeof params/sizeof params[0]);
+  return os;
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7>
+std::basic_ostream<CT>& strmfmtl(
+    std::basic_ostream<CT>& os, const CT* fmt, size_t fmt_length,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6, const T7& p7) {
+  impl::StreamableValue<CT, T0> s0(p0);
+  impl::StreamableValue<CT, T1> s1(p1);
+  impl::StreamableValue<CT, T2> s2(p2);
+  impl::StreamableValue<CT, T3> s3(p3);
+  impl::StreamableValue<CT, T4> s4(p4);
+  impl::StreamableValue<CT, T5> s5(p5);
+  impl::StreamableValue<CT, T6> s6(p6);
+  impl::StreamableValue<CT, T7> s7(p7);
+  const impl::Streamable<CT>* params[] =
+      {&s0, &s1, &s2, &s3, &s4, &s5, &s6, &s7};
+  impl::format_params(fmt, fmt_length, os,
+      params, sizeof params/sizeof params[0]);
+  return os;
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7, typename T8>
+std::basic_ostream<CT>& strmfmtl(
+    std::basic_ostream<CT>& os, const CT* fmt, size_t fmt_length,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6, const T7& p7, const T8& p8) {
+  impl::StreamableValue<CT, T0> s0(p0);
+  impl::StreamableValue<CT, T1> s1(p1);
+  impl::StreamableValue<CT, T2> s2(p2);
+  impl::StreamableValue<CT, T3> s3(p3);
+  impl::StreamableValue<CT, T4> s4(p4);
+  impl::StreamableValue<CT, T5> s5(p5);
+  impl::StreamableValue<CT, T6> s6(p6);
+  impl::StreamableValue<CT, T7> s7(p7);
+  impl::StreamableValue<CT, T8> s8(p8);
+  const impl::Streamable<CT>* params[] =
+      {&s0, &s1, &s2, &s3, &s4, &s5, &s6, &s7, &s8};
+  impl::format_params(fmt, fmt_length, os,
+      params, sizeof params/sizeof params[0]);
+  return os;
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7, typename T8, typename T9>
+std::basic_ostream<CT>& strmfmtl(
+    std::basic_ostream<CT>& os, const CT* fmt, size_t fmt_length,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6, const T7& p7, const T8& p8, const T9& p9) {
+  impl::StreamableValue<CT, T0> s0(p0);
+  impl::StreamableValue<CT, T1> s1(p1);
+  impl::StreamableValue<CT, T2> s2(p2);
+  impl::StreamableValue<CT, T3> s3(p3);
+  impl::StreamableValue<CT, T4> s4(p4);
+  impl::StreamableValue<CT, T5> s5(p5);
+  impl::StreamableValue<CT, T6> s6(p6);
+  impl::StreamableValue<CT, T7> s7(p7);
+  impl::StreamableValue<CT, T8> s8(p8);
+  impl::StreamableValue<CT, T9> s9(p9);
+  const impl::Streamable<CT>* params[] =
+      {&s0, &s1, &s2, &s3, &s4, &s5, &s6, &s7, &s8, &s9};
+  impl::format_params(fmt, fmt_length, os,
+      params, sizeof params/sizeof params[0]);
+  return os;
+}
+
+/*
+ * Stream format overloads
+ * */
+template <typename CT>
+std::basic_ostream<CT>& strmfmt(
+    std::basic_ostream<CT>& os, const CT* fmt) {
+  return strmfmtl(os, fmt, impl::len(fmt));
+}
+
+template <typename CT,
+          typename T0>
+std::basic_ostream<CT>& strmfmt(
+    std::basic_ostream<CT>& os, const CT* fmt, const T0& p0) {
+  return strmfmtl(os, fmt, impl::len(fmt), p0);
+}
+
+template <typename CT,
+          typename T0, typename T1>
+std::basic_ostream<CT>& strmfmt(
+    std::basic_ostream<CT>& os, const CT* fmt,
+    const T0& p0, const T1& p1) {
+  return strmfmtl(os, fmt, impl::len(fmt), p0, p1);
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2>
+std::basic_ostream<CT>& strmfmt(
+    std::basic_ostream<CT>& os, const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2) {
+  return strmfmtl(os, fmt, impl::len(fmt), p0, p1, p2);
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3>
+std::basic_ostream<CT>& strmfmt(
+    std::basic_ostream<CT>& os, const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3) {
+  return strmfmtl(os, fmt, impl::len(fmt), p0, p1, p2, p3);
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4>
+std::basic_ostream<CT>& strmfmt(
+    std::basic_ostream<CT>& os, const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4) {
+  return strmfmtl(os, fmt, impl::len(fmt), p0, p1, p2, p3, p4);
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5>
+std::basic_ostream<CT>& strmfmt(
+    std::basic_ostream<CT>& os, const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5) {
+  return strmfmtl(os, fmt, impl::len(fmt), p0, p1, p2, p3, p4, p5);
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6>
+std::basic_ostream<CT>& strmfmt(
+    std::basic_ostream<CT>& os, const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6) {
+  return strmfmtl(os, fmt, impl::len(fmt), p0, p1, p2, p3, p4, p5, p6);
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7>
+std::basic_ostream<CT>& strmfmt(
+    std::basic_ostream<CT>& os, const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6, const T7& p7) {
+  return strmfmtl(os, fmt, impl::len(fmt), p0, p1, p2, p3, p4, p5, p6, p7);
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7, typename T8>
+std::basic_ostream<CT>& strmfmt(
+    std::basic_ostream<CT>& os, const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6, const T7& p7, const T8& p8) {
+  return strmfmtl(os, fmt, impl::len(fmt), p0, p1, p2, p3, p4, p5, p6, p7, p8);
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7, typename T8, typename T9>
+std::basic_ostream<CT>& strmfmt(
+    std::basic_ostream<CT>& os, const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6, const T7& p7, const T8& p8, const T9& p9) {
+  return strmfmtl(os, fmt, impl::len(fmt), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
+}
+
+/*
+*
+* Char array format overloads
+*
+*/
+template <typename CT,
+          typename T0>
+std::basic_string<CT> format(const CT* fmt,
+    const T0& p0) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt, impl::len(fmt), p0);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1>
+std::basic_string<CT> format(const CT* fmt,
+    const T0& p0, const T1& p1) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt, impl::len(fmt), p0, p1);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2>
+std::basic_string<CT> format(const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt, impl::len(fmt), p0, p1, p2);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3>
+std::basic_string<CT> format(const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt, impl::len(fmt), p0, p1, p2, p3);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4>
+std::basic_string<CT> format(const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt, impl::len(fmt), p0, p1, p2, p3, p4);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5>
+std::basic_string<CT> format(const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt, impl::len(fmt), p0, p1, p2, p3, p4, p5);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6>
+std::basic_string<CT> format(const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt, impl::len(fmt), p0, p1, p2, p3, p4, p5, p6);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7>
+std::basic_string<CT> format(const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6, const T7& p7) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt, impl::len(fmt), p0, p1, p2, p3, p4, p5, p6, p7);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7, typename T8>
+std::basic_string<CT> format(const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6, const T7& p7, const T8& p8) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt, impl::len(fmt), p0, p1, p2, p3, p4, p5, p6, p7, p8);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7, typename T8, typename T9>
+std::basic_string<CT> format(const CT* fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6, const T7& p7, const T8& p8, const T9& p9) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt, impl::len(fmt), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
+  return stream.str();
+}
+
+/*
+*
+* STL string overloads
+*
+*/
+template <typename CT,
+          typename T0>
+std::basic_string<CT> format(const std::basic_string<CT> fmt,
+    const T0& p0) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt.c_str(), fmt.size(),
+      p0);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1>
+std::basic_string<CT> format(const std::basic_string<CT> fmt,
+    const T0& p0, const T1& p1) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt.c_str(), fmt.size(),
+      p0, p1);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2>
+std::basic_string<CT> format(const std::basic_string<CT> fmt,
+    const T0& p0, const T1& p1, const T2& p2) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt.c_str(), fmt.size(),
+      p0, p1, p2);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3>
+std::basic_string<CT> format(const std::basic_string<CT> fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt.c_str(), fmt.size(),
+      p0, p1, p2, p3);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4>
+std::basic_string<CT> format(const std::basic_string<CT> fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt.c_str(), fmt.size(),
+      p0, p1, p2, p3, p4);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5>
+std::basic_string<CT> format(const std::basic_string<CT> fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt.c_str(), fmt.size(),
+      p0, p1, p2, p3, p4, p5);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6>
+std::basic_string<CT> format(const std::basic_string<CT> fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt.c_str(), fmt.size(),
+      p0, p1, p2, p3, p4, p5, p6);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7>
+std::basic_string<CT> format(const std::basic_string<CT> fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6, const T7& p7) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt.c_str(), fmt.size(),
+      p0, p1, p2, p3, p4, p5, p6, p7);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7, typename T8>
+std::basic_string<CT> format(const std::basic_string<CT> fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6, const T7& p7, const T8& p8) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt.c_str(), fmt.size(),
+      p0, p1, p2, p3, p4, p5, p6, p7, p8);
+  return stream.str();
+}
+
+template <typename CT,
+          typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7, typename T8, typename T9>
+std::basic_string<CT> format(const std::basic_string<CT> fmt,
+    const T0& p0, const T1& p1, const T2& p2, const T3& p3, const T4& p4,
+    const T5& p5, const T6& p6, const T7& p7, const T8& p8, const T9& p9) {
+  std::basic_stringstream<CT> stream;
+  strmfmtl(stream, fmt.c_str(), fmt.size(),
+      p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
+  return stream.str();
+}
+
+} // namespace typesafe_format
diff --git a/tools/intergen/utils/include/utils/stl_utils.h b/tools/intergen/utils/include/utils/stl_utils.h
new file mode 100644
index 0000000000..0b3718947e
--- /dev/null
+++ b/tools/intergen/utils/include/utils/stl_utils.h
@@ -0,0 +1,101 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STL_UTILS_H_
+#define STL_UTILS_H_
+
+/*
+ * Common helper functions that work with STL types
+ */
+
+#include <cassert>
+#include <map>
+#include <set>
+
+namespace utils {
+
+/*
+ * Collects all the keys from given map |m|
+ */
+template<typename K, typename V>
+std::set<K> MapKeys(const std::map<K, V> m) {
+  std::set<K> keys;
+  for (typename std::map<K, V>::const_iterator i = m.begin(), end = m.end();
+      i != end; ++i) {
+    keys.insert(i->first);
+  }
+  return keys;
+}
+
+/*
+ * Automatcally deletes all the values |cont| elements are pointing to.
+ */
+template<typename T>
+class StdContainerDeleter {
+ public:
+  explicit StdContainerDeleter(T* cont)
+      : cont_(cont) {
+  }
+  ~StdContainerDeleter() {
+    for (typename T::iterator i = cont_->begin(), end = cont_->end(); i != end;
+        ++i) {
+      delete *i;
+    }
+  }
+ private:
+  T* cont_;
+};
+
+/*
+ * Automatcally deletes all map values |cont| elements are pointing to.
+ */
+template<typename T>
+  class StdMapDeleter {
+public:
+  explicit StdMapDeleter(T* cont)
+      : cont_(cont) {
+  }
+  ~StdMapDeleter() {
+    for (typename T::iterator i = cont_->begin(), end = cont_->end(); i != end;
+         ++i) {
+      delete i->second;
+    }
+  }
+private:
+  T* cont_;
+};
+
+
+
+}
+
+#endif /* STL_UTILS_H_ */
diff --git a/tools/intergen/utils/include/utils/string_utils.h b/tools/intergen/utils/include/utils/string_utils.h
new file mode 100644
index 0000000000..78c1b87aa5
--- /dev/null
+++ b/tools/intergen/utils/include/utils/string_utils.h
@@ -0,0 +1,161 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef STRING_UTILS_H_
+#define STRING_UTILS_H_
+
+#include <stdint.h>
+#include <algorithm>
+#include <cassert>
+#include <cctype>
+#include <functional>
+#include <ostream>
+#include <sstream>
+#include <string>
+
+/*
+ * Commonly used string processing functions
+ */
+
+/*
+ * Stream indentation helper class. Hooks the stream that is
+ * passed to it's constructor processing all the input to that stream
+ * and issuing indentation spaces when newline symbol is put to the stream.
+ * Unhooks from stream on destruction.
+ */
+class Indent: private std::streambuf {
+public:
+  /*
+   *  Constructs indentation 'sentry' object hooking on |dest| stream.
+   *  |ident_size| is the indentation width (spaces).
+   */
+  explicit Indent(std::ostream& dest, size_t ident_size = 2)
+    : dest_buf_(dest.rdbuf()),
+      new_line_started_(true),
+      ident_(ident_size, ' '),
+      owner_(&dest) {
+    owner_->rdbuf(this);
+  }
+  ~Indent() {
+    owner_->rdbuf( dest_buf_ );
+  }
+private:
+  virtual int overflow( int ch ) {
+    if ( new_line_started_ && ch != '\n' ) {
+          dest_buf_->sputn(ident_.data(), ident_.size());
+    }
+    new_line_started_ = ch == '\n';
+    return dest_buf_->sputc(ch);
+  }
+private:
+  std::streambuf*     dest_buf_;
+  bool                new_line_started_;
+  std::string         ident_;
+  std::ostream*       owner_;
+};
+
+/*
+ * String to numerical (int, double) conversion function.
+ * Checks wether |str_val| contains a number and converts
+ * it to |out_val|.
+ * Returns false on failure.
+ */
+template<typename T>
+bool StringToNumber(const std::string& str_val, T* out_val) {
+  assert(out_val);
+  std::stringstream stream(str_val);
+  stream>>(*out_val);
+  return bool(stream);
+}
+
+/*
+ * Number to string conversion function.
+ */
+template<typename T>
+inline std::string NumberToString(T number) {
+  std::stringstream stream;
+  std::string result;
+  stream<<number;
+  stream>>result;
+  return result;
+}
+
+/*
+ * In-place string trimming function, trims spaces at string beginning
+ */
+inline std::string& ltrim(std::string &s) {
+  s.erase(
+      s.begin(),
+      std::find_if(s.begin(), s.end(),
+                   std::not1(std::ptr_fun<int, int>(std::isspace))));
+  return s;
+}
+
+/*
+ * In-place string trimming function, trims spaces at string end
+ */
+inline std::string& rtrim(std::string &s) {
+  s.erase(
+      std::find_if(s.rbegin(), s.rend(),
+                   std::not1(std::ptr_fun<int, int>(std::isspace))).base(),
+      s.end());
+  return s;
+}
+
+/*
+ * In-place string trimming function, trims spaces around text
+ */
+inline std::string& trim(std::string &s) {
+  return ltrim(rtrim(s));
+}
+
+/*
+ * Converts ASCII string to lowercase
+ */
+inline std::string to_lower(std::string str) {
+  for (std::string::iterator i = str.begin(); i != str.end(); ++i) {
+    *i = std::tolower(*i);
+  }
+  return str;
+}
+
+/*
+ * Converts ASCII string to uppercase
+ */
+inline std::string to_upper(std::string str) {
+  for (std::string::iterator i = str.begin(); i != str.end(); ++i) {
+    *i = std::toupper(*i);
+  }
+  return str;
+}
+
+#endif /* STRING_UTILS_H_ */
diff --git a/tools/intergen/utils/include/utils/xml_utils.h b/tools/intergen/utils/include/utils/xml_utils.h
new file mode 100644
index 0000000000..6c5c3ed3b9
--- /dev/null
+++ b/tools/intergen/utils/include/utils/xml_utils.h
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef XML_UTILS_H_
+#define XML_UTILS_H_
+
+/*
+ * This file contains commonly used XML functions
+ */
+
+#include "utils/common_types.h"
+
+namespace pugi {
+class xml_node;
+}
+
+namespace codegen {
+
+// Extract all the non-empty description sub-nodes and collect them in
+// Description object
+Description CollectDescription(const pugi::xml_node& node);
+
+} // namespace codegen
+
+#endif /* XML_UTILS_H_ */
diff --git a/tools/intergen/utils/src/utils/common_types.cc b/tools/intergen/utils/src/utils/common_types.cc
new file mode 100644
index 0000000000..535ce5a745
--- /dev/null
+++ b/tools/intergen/utils/src/utils/common_types.cc
@@ -0,0 +1,77 @@
+/**
+* Copyright (c) 2014, Ford Motor Company
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+* Redistributions of source code must retain the above copyright notice, this
+* list of conditions and the following disclaimer.
+*
+* Redistributions in binary form must reproduce the above copyright notice,
+* this list of conditions and the following
+* disclaimer in the documentation and/or other materials provided with the
+* distribution.
+*
+* Neither the name of the Ford Motor Company nor the names of its contributors
+* may be used to endorse or promote products derived from this software
+* without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+* POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "utils/common_types.h"
+
+#include <cmath>
+
+namespace codegen {
+
+using std::string;
+
+Fraction::Fraction()
+    : numer_(0),
+      denumer_(1) {
+}
+
+Fraction::Fraction(int64_t numer, int64_t denumer)
+: numer_(numer), denumer_(denumer) {
+}
+
+// static
+bool Fraction::FromFloatPointString(const std::string& literal, Fraction* fraction) {
+  size_t dot_position = literal.find('.');
+  string wholes_str = literal.substr(0, dot_position);
+  string decs_str;
+  if (dot_position != literal.npos) {
+    decs_str = literal.substr(dot_position + 1);
+  }
+  int64_t numer_val = 0;
+  if (StringToNumber(wholes_str + decs_str, &numer_val)) {
+    int64_t denumer_val = pow(10, decs_str.size());
+    *fraction = Fraction(numer_val, denumer_val);
+    return true;
+  }
+  return false;
+}
+
+int64_t Fraction::numer() const {
+  return numer_;
+}
+
+int64_t Fraction::denumer() const {
+  return denumer_;
+}
+
+}  // namespace codegen
+
+
diff --git a/tools/intergen/utils/src/utils/safeformat.cc b/tools/intergen/utils/src/utils/safeformat.cc
new file mode 100644
index 0000000000..0db0bebe6c
--- /dev/null
+++ b/tools/intergen/utils/src/utils/safeformat.cc
@@ -0,0 +1,107 @@
+/*
+* Typesafe printf-like wrapper around std streams
+* by Igor Kozyrenko, 2013
+*/
+
+#include "utils/safeformat.h"
+
+#include <sstream>
+#include <algorithm>
+#include <iterator>
+
+namespace typesafe_format {
+namespace impl {
+
+const char kPlaceholderPrefix = '{';
+const char kPlaceholderSuffix = '}';
+
+struct Placeholder {
+  bool   escaped;
+  size_t escaped_prefixes;
+  size_t number;
+  size_t length;
+};
+
+void missing_parameter(std::ostream& os, size_t param_number) {
+  os<<"{Parameter "<<param_number<<" is missing}";
+}
+
+void missing_parameter(std::wostream& os, size_t param_number) {
+  os<<L"{Parameter "<<param_number<<L" is missing}";
+}
+
+template <typename CT>
+const CT* find_placeholder_tmpl(const CT* text, const CT* end,
+                                Placeholder& ph) {
+  const CT* prefix_begin = text;
+  bool done = false;
+  do {
+    prefix_begin = std::find(prefix_begin, end, kPlaceholderPrefix);
+    // there must be at least two symbols after prefix
+    if (std::distance(prefix_begin, end) > 2) {
+      const CT* prefix_end = prefix_begin + 1;
+      // count prefix escapes if any
+      while(*prefix_end == kPlaceholderPrefix &&
+            std::distance(prefix_end, end) > 2)
+        ++prefix_end;
+      size_t prefixes = std::distance(prefix_begin, prefix_end);
+      size_t prefix_number = *prefix_end - '0';
+      const CT* suffix = prefix_end + 1;
+      if (prefix_number < 10 &&  // it is in range of valid placeholders
+          *suffix == kPlaceholderSuffix) {
+        ph.escaped =          prefixes % 2 == 0;
+        ph.escaped_prefixes = prefixes / 2;
+        ph.number = prefix_number;
+        ph.length = (suffix - prefix_begin) + 1;
+        done = true;
+      } else {
+        prefix_begin = suffix; // continue from the symbol after number
+      }
+    } else { // prefix_begin is not at least last but two
+      prefix_begin = end;
+      done = true;
+    }
+  } while (!done);
+  return prefix_begin;
+}
+
+template <typename CT>
+void format_params_tmpl(const CT* fmt, size_t fmt_length,
+                        std::basic_ostream<CT>& os,
+                        const Streamable<CT>* params[], size_t params_count) {
+  const CT* text = fmt;
+  const CT* end = fmt + fmt_length;
+  Placeholder placeholder;
+  for (const CT* ph_pos = find_placeholder_tmpl(text, end, placeholder);
+       ph_pos != end;
+       ph_pos = find_placeholder_tmpl(text, end, placeholder)) {
+    os.write(text, ph_pos - text);
+    for (size_t i = 0; i != placeholder.escaped_prefixes; ++i)
+      os.put(kPlaceholderPrefix);
+    if (placeholder.escaped) {
+      os<<placeholder.number<<kPlaceholderSuffix;
+    } else {
+      if (placeholder.number < params_count)
+        params[placeholder.number]->OutputToStream(os);
+      else {
+        missing_parameter(os, placeholder.number);
+      }
+    }
+    text = ph_pos + placeholder.length;
+  }
+  os.write(text, end - text);
+}
+
+void format_params(const char* fmt, size_t fmt_length, std::ostream& os,
+                   const Streamable<char>* params[], size_t params_count) {
+  format_params_tmpl(fmt, fmt_length, os, params, params_count);
+}
+void format_params(const wchar_t* fmt, size_t fmt_length, std::wostream& os,
+                  const Streamable<wchar_t>* params[], size_t params_count) {
+  format_params_tmpl(fmt, fmt_length, os, params, params_count);
+}
+
+
+
+} // namespace impl
+} // namespace typesafe_format
diff --git a/tools/intergen/utils/src/utils/xml_utils.cc b/tools/intergen/utils/src/utils/xml_utils.cc
new file mode 100644
index 0000000000..a66fbce90d
--- /dev/null
+++ b/tools/intergen/utils/src/utils/xml_utils.cc
@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) 2014, Ford Motor Company
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided with the
+ * distribution.
+ *
+ * Neither the name of the Ford Motor Company nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "utils/xml_utils.h"
+
+#include "pugixml.hpp"
+#include "utils/string_utils.h"
+
+namespace codegen {
+
+Description CollectDescription(const pugi::xml_node& node) {
+  Description description;
+  for (pugi::xml_node i = node.child("description"); i;
+      i = i.next_sibling("description")) {
+    std::string description_string = i.child_value();
+    trim(description_string);
+    if (!description_string.empty()) {
+      description.push_back(description_string);
+    }
+  }
+  return description;
+}
+
+}  // namespace codegen