Initial smartdevicelink commitHEADmaster

226 files changed, 49063 insertions, 0 deletions

diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt
new file mode 100644
index 000000000..557c23f4e
--- /dev/null
+++ b/tools/CMakeLists.txt
@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 2.8.3)
+
+include(ExternalProject)
+
+set(intergen_SOURCES "${CMAKE_CURRENT_LIST_DIR}/intergen")
+set(intergen_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/intergen")
+set(intergen_INSTALL_DIR "${CMAKE_CURRENT_BINARY_DIR}/intergen")
+set(intergen_CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${intergen_INSTALL_DIR})
+
+ExternalProject_Add(intergen
+                    SOURCE_DIR ${intergen_SOURCES}
+                    PREFIX ${intergen_PREFIX}
+                    INSTALL_DIR ${intergen_INSTALL_DIR}
+                    CMAKE_ARGS ${intergen_CMAKE_ARGS})
+
+# This will force intergen make call every time core is built
+# When intergen source didn't change no files are updated
+# It is required to automatically rebuild interfaces if intergen was changed
+ExternalProject_Add_Step(intergen forcebuild
+                         COMMAND ${CMAKE_COMMAND} -E echo "Force intergen build"
+                         DEPENDEES update DEPENDERS build
+                         ALWAYS 1)
+
+if(BUILD_TESTS)
+  add_subdirectory(intergen/test)
+endif()  
+add_subdirectory(policy_table_validator)
diff --git a/tools/InterfaceGenerator/Generator.py b/tools/InterfaceGenerator/Generator.py
new file mode 100755
index 000000000..5b5894bc0
--- /dev/null
+++ b/tools/InterfaceGenerator/Generator.py
@@ -0,0 +1,116 @@
+"""
+Generator application that generates c++ interfaces code from xml description
+
+usage: Generator.py [-h] --parser-type {sdlrpcv2}
+                    source-xml namespace output-dir
+
+SmartSchema interface generator
+
+positional arguments:
+  source-xml
+  namespace
+  output-dir
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --parser-type {sdlrpcv2}
+"""
+
+import os.path
+import argparse
+import errno
+import sys
+
+import generator.parsers.SDLRPCV1
+import generator.parsers.SDLRPCV2
+import generator.parsers.JSONRPC
+import generator.generators.SmartFactorySDLRPC
+import generator.generators.SmartFactoryJSONRPC
+
+from generator.parsers.RPCBase import ParseError
+from generator.generators.SmartFactoryBase import GenerateError
+
+SUPPORTED_FORMATS = {
+    "sdlrpcv1": (generator.parsers.SDLRPCV1.Parser,
+                 generator.generators.SmartFactorySDLRPC.CodeGenerator),
+    "sdlrpcv2": (generator.parsers.SDLRPCV2.Parser,
+                 generator.generators.SmartFactorySDLRPC.CodeGenerator),
+    "jsonrpc": (generator.parsers.JSONRPC.Parser,
+                generator.generators.SmartFactoryJSONRPC.CodeGenerator)
+}
+
+
+def _create_parser():
+    """Create parser for parsing command-line arguments.
+
+    Returns an instance of argparse.ArgumentParser
+
+    """
+
+    parser = argparse.ArgumentParser(
+        description="SmartSchema interface generator"
+    )
+    parser.add_argument("source-xml")
+    parser.add_argument("namespace")
+    parser.add_argument("output-dir")
+    parser.add_argument("--parser-type",
+                        choices=SUPPORTED_FORMATS.keys(),
+                        required=True)
+    return parser
+
+
+def _handle_fatal_error(error):
+    """Handle fatal error during parsing or code generation.
+
+    Keyword arguments:
+    error -- base exception to handle.
+
+    """
+
+    print(error.message)
+    print
+    sys.exit(errno.EINVAL)
+
+
+def main():
+    """Main function of the generator that does actual work."""
+
+    args = vars(_create_parser().parse_args())
+
+    src_xml = args["source-xml"]
+    src_xml_name = os.path.splitext(os.path.basename(src_xml))[0]
+    namespace = args["namespace"]
+    output_dir = args["output-dir"]
+    parser_type = args["parser_type"]
+
+    print("""
+Generating interface source code with following parameters:
+    Source xml      : {0}
+    Namespace       : {1}
+    Output directory: {2}
+    Parser type     : {3}
+""".format(src_xml, namespace, output_dir, parser_type))
+
+    # Select required parser and code generator
+    parser = SUPPORTED_FORMATS[parser_type][0]()
+    code_generator = SUPPORTED_FORMATS[parser_type][1]()
+
+    # Convert incoming xml to internal model
+    try:
+        interface = parser.parse(args["source-xml"])
+    except ParseError as error:
+        _handle_fatal_error(error)
+
+    # Generate SmartFactory source code from internal model
+    try:
+        code_generator.generate(interface,
+                                src_xml_name,
+                                namespace,
+                                output_dir)
+    except GenerateError as error:
+        _handle_fatal_error(error)
+
+    print("Done.")
+
+if __name__ == '__main__':
+    main()
diff --git a/tools/InterfaceGenerator/generator/Model.py b/tools/InterfaceGenerator/generator/Model.py
new file mode 100755
index 000000000..ee458d934
--- /dev/null
+++ b/tools/InterfaceGenerator/generator/Model.py
@@ -0,0 +1,326 @@
+"""Interface model.
+
+Interface model is represented by Interface class.
+Parser must provide an instance of this model as a result of parsing
+interface definition file.
+Generator must take an instance of this model as input for generating
+output files.
+"""
+
+# In this module there are classes that are used as data container
+# pylint: disable=R0903
+
+import collections
+
+
+class Boolean(object):
+
+    """Boolean type.
+
+    default_value -- default value
+
+    """
+
+    def __init__(self, default_value=None):
+        self.default_value = default_value
+
+
+class Integer(object):
+
+    """Integer type.
+
+    Instance variables:
+    min_value -- minimum allowed value
+    max_value -- maximum allowed value
+    default_value -- default value
+
+    """
+
+    def __init__(self, min_value=None, max_value=None, default_value=None):
+        self.min_value = min_value
+        self.max_value = max_value
+        self.default_value = default_value
+
+
+class Double(object):
+
+    """Floating-point type.
+
+    Instance variables:
+    min_value -- minimum allowed value
+    max_value -- maximum allowed value
+    default_value -- default value
+
+    """
+
+    def __init__(self, min_value=None, max_value=None, default_value=None):
+        self.min_value = min_value
+        self.max_value = max_value
+        self.default_value = default_value
+
+class String(object):
+
+    """String type.
+
+    Instance variables:
+    min_length -- minimum string length
+    max_length -- maximum string length
+    default_value -- default value
+
+    """
+
+    def __init__(self, min_length=None, max_length=None, default_value=None):
+        self.min_length = min_length
+        self.max_length = max_length
+        self.default_value = default_value
+
+
+class Array(object):
+
+    """Array type.
+
+    Instance variables:
+    min_size -- minimum array size
+    max_size -- maximum array size
+    element_type -- type of array element
+
+    """
+
+    def __init__(self, min_size=None, max_size=None, element_type=None):
+        self.min_size = min_size
+        self.max_size = max_size
+        self.element_type = element_type
+
+
+class Issue(object):
+
+    """Issue.
+
+    Instance variables:
+    creator -- issue creator
+    value -- issue text
+
+    """
+
+    def __init__(self, creator=None, value=None):
+        self.creator = creator
+        self.value = value
+
+
+class InterfaceItemBase(object):
+
+    """Base class for interface item.
+
+    Instance variables:
+    name -- item name
+    description -- list of string description elements
+    design_description -- list of string design description elements
+    issues -- list of issues
+    todos -- list of string todo elements
+    platform -- optional platform (string or None)
+    default_value -- default value
+    scope -- optional scope: internal, partner or none (none by defaul, means public)
+
+    """
+
+    def __init__(self, name, description=None, design_description=None,
+                 issues=None, todos=None, platform=None, default_value=None, scope=None):
+        self.name = name
+        self.description = description if description is not None else []
+        self.design_description = \
+            design_description if design_description is not None else []
+        self.issues = issues if issues is not None else []
+        self.todos = todos if todos is not None else []
+        self.platform = platform
+        self.default_value = default_value
+        self.scope = scope
+
+
+class EnumElement(InterfaceItemBase):
+
+    """Element of enumeration.
+
+    Instance variables:
+    internal_name -- internal name of an element must be used by a
+                     generator if it is provided (not None)
+    value -- optional element value
+
+    """
+
+    def __init__(self, name, description=None, design_description=None,
+                 issues=None, todos=None, platform=None, internal_name=None,
+                 value=None):
+        super(EnumElement, self).__init__(
+            name, description=description,
+            design_description=design_description, issues=issues, todos=todos,
+            platform=platform)
+        self.internal_name = internal_name
+        self.value = value
+
+    @property
+    def primary_name(self):
+        """Primary name of the EnumElement.
+
+        Return the 'internal_name' property if presented or 'name' property
+        otherwise.
+
+        """
+        return self.name if self.internal_name is None else self.internal_name
+
+
+class Enum(InterfaceItemBase):
+
+    """Enumeration.
+
+    Instance variables:
+    internal_scope -- optional internal scope
+    elements -- enumeration elements
+
+    """
+
+    def __init__(self, name, description=None, design_description=None,
+                 issues=None, todos=None, platform=None, internal_scope=None,
+                 elements=None, scope=None):
+        super(Enum, self).__init__(
+            name, description=description,
+            design_description=design_description, issues=issues, todos=todos,
+            platform=platform, scope=scope)
+
+        self.internal_scope = internal_scope
+        self.elements = \
+            elements if elements is not None else collections.OrderedDict()
+
+
+class EnumSubset(InterfaceItemBase):
+
+    """Enumeration subset.
+
+    Instance variables:
+    enum -- enumeration
+    allowed_elements -- dictionary of elements of enumeration
+                        which are allowed in this subset
+
+    """
+
+    def __init__(self, name, enum, description=None, design_description=None,
+                 issues=None, todos=None, platform=None,
+                 allowed_elements=None):
+        super(EnumSubset, self).__init__(
+            name, description=description,
+            design_description=design_description, issues=issues, todos=todos,
+            platform=platform)
+
+        self.enum = enum
+        self.allowed_elements = \
+            allowed_elements if allowed_elements is not None else {}
+
+
+class Param(InterfaceItemBase):
+
+    """Parameter.
+
+    Instance variables:
+    is_mandatory -- boolean value indicating whether
+                    this parameter is mandatory
+    param_type -- parameter type
+    default_value -- default value
+
+    """
+
+    def __init__(self, name, param_type, description=None,
+                 design_description=None, issues=None, todos=None,
+                 platform=None, is_mandatory=True, default_value=None, scope=None):
+        super(Param, self).__init__(
+            name, description=description,
+            design_description=design_description, issues=issues, todos=todos,
+            platform=platform, default_value=default_value, scope=scope)
+
+        self.is_mandatory = is_mandatory
+        self.param_type = param_type
+        self.default_value = default_value
+
+
+class FunctionParam(Param):
+
+    """Function parameter.
+
+    Instance variables:
+    default_value -- optional default value of this parameter
+
+    """
+
+    def __init__(self, name, param_type, description=None,
+                 design_description=None, issues=None, todos=None,
+                 platform=None, is_mandatory=True, default_value=None, scope=None):
+        super(FunctionParam, self).__init__(
+            name, param_type=param_type, description=description,
+            design_description=design_description, issues=issues, todos=todos,
+            platform=platform, is_mandatory=is_mandatory, default_value=default_value, scope=scope)
+
+        self.default_value = default_value
+
+
+class Struct(InterfaceItemBase):
+
+    """Structure.
+
+    Instance variables:
+    members -- dictionary of structure members (instances of Param class)
+
+    """
+
+    def __init__(self, name, description=None, design_description=None,
+                 issues=None, todos=None, platform=None, members=None, scope=None):
+        super(Struct, self).__init__(
+            name, description=description,
+            design_description=design_description, issues=issues, todos=todos,
+            platform=platform, scope=scope)
+
+        self.members = \
+            members if members is not None else collections.OrderedDict()
+
+
+class Function(InterfaceItemBase):
+
+    """Function.
+
+    Instance variables:
+    function_id -- function identifier (EnumElement from Enum "FunctionID")
+    message_type -- message type (EnumElement from Enum "messageType")
+    params -- function parameters
+
+    """
+
+    def __init__(self, name, function_id, message_type, description=None,
+                 design_description=None, issues=None, todos=None,
+                 platform=None, params=None, scope=None):
+        super(Function, self).__init__(
+            name, description=description,
+            design_description=design_description, issues=issues, todos=todos,
+            platform=platform, scope=scope)
+
+        self.function_id = function_id
+        self.message_type = message_type
+        self.params = \
+            params if params is not None else collections.OrderedDict()
+
+
+class Interface(object):
+
+    """Interface.
+
+    Instance variables:
+    enums -- dictionary of enumerations
+    structs -- dictionary of structures
+    functions -- dictionary of functions
+    params -- dictionary of interface parameters (name, version, etc.)
+
+    """
+
+    def __init__(self, enums=None, structs=None, functions=None, params=None):
+        self.enums = enums if enums is not None else collections.OrderedDict()
+        self.structs = \
+            structs if structs is not None else collections.OrderedDict()
+        self.functions = \
+            functions if functions is not None else collections.OrderedDict()
+        self.params = params if params is not None else {}
diff --git a/tools/InterfaceGenerator/generator/__init__.py b/tools/InterfaceGenerator/generator/__init__.py
new file mode 100755
index 000000000..380e81d9a
--- /dev/null
+++ b/tools/InterfaceGenerator/generator/__init__.py
@@ -0,0 +1,2 @@
+"""Top-level application package.
+"""
diff --git a/tools/InterfaceGenerator/generator/generators/SmartFactoryBase.py b/tools/InterfaceGenerator/generator/generators/SmartFactoryBase.py
new file mode 100755
index 000000000..2b372021c
--- /dev/null
+++ b/tools/InterfaceGenerator/generator/generators/SmartFactoryBase.py
@@ -0,0 +1,1684 @@
+"""SmartFactory code generator base.
+
+Base of code generator for SmartFactory that provides SmartSchema object in
+accordance with given internal model.
+
+"""
+# pylint: disable=W0402
+# pylint: disable=C0302
+import codecs
+import collections
+import os
+import string
+import uuid
+
+from generator import Model
+
+
+class GenerateError(Exception):
+
+    """Generate error.
+
+    This exception is raised when SmartFactory generator is unable to create
+    output from given model.
+
+    """
+
+    pass
+
+
+class CodeGenerator(object):
+
+    """Base SmartFactory generator.
+
+    This class provides service which allows to generate pair of *.h and
+    *.cc files by given interface model.
+
+    """
+
+    def __init__(self):
+        """Construct new object."""
+
+        self._generated_structs = []
+        self._structs_add_code = u""
+
+    def generate(self, interface, filename, namespace, destination_dir):
+        """Generate SmartFactory source files.
+
+        Generates source code files at destination directory in
+        accordance with given model in specified namespace.
+
+        Keyword arguments:
+        interface -- model of the interface to generate source code for.
+        filename -- name of initial XML file.
+        namespace -- name of destination namespace.
+        destination_dir -- directory to create source files.
+
+        """
+
+        namespace = unicode(namespace)
+
+        if interface is None:
+            raise GenerateError("Given interface is None.")
+
+        self._generated_structs = []
+        self._structs_add_code = ""
+
+        if "messageType" in interface.enums:
+            interface.enums["messageType"] = self._preprocess_message_type(
+                interface.enums["messageType"])
+
+        if not os.path.exists(destination_dir):
+            os.makedirs(destination_dir)
+
+        namespace_open = u""
+        namespace_close = u""
+
+        if namespace:
+            parts = namespace.split(u"::")
+            for part in parts:
+                namespace_open = u"".join(
+                    [namespace_open,
+                     self._namespace_open_template.substitute(name=part)])
+                namespace_close = u"".join(
+                    [namespace_close,
+                     "}} // {0}\n".format(part)])
+
+        class_name = unicode(os.path.splitext(filename)[0])
+        guard = u"__CSMARTFACTORY_{0}_{1}_H__".format(
+            class_name.upper(),
+            unicode(uuid.uuid1().hex.capitalize()))
+        header_file_name = u"".join("{0}.h".format(class_name))
+
+        with codecs.open(os.path.join(destination_dir, header_file_name),
+                         encoding="utf-8",
+                         mode="w") as f_h:
+            f_h.write(self._h_file_tempalte.substitute(
+                class_name=class_name,
+                guard=guard,
+                namespace_open=namespace_open,
+                enums_content=self._gen_enums(
+                    interface.enums.values(),
+                    interface.structs.values()),
+                namespace_close=namespace_close))
+
+        self._gen_struct_schema_items(interface.structs.values())
+
+        function_id_items = u""
+        if "FunctionID" in interface.enums:
+            function_id = interface.enums["FunctionID"]
+            function_id_items = u"\n".join(
+                [self._impl_code_loc_decl_enum_insert_template.substitute(
+                    var_name="function_id_items",
+                    enum=function_id.name,
+                    value=x.primary_name)
+                 for x in function_id.elements.values()])
+
+        message_type_items = u""
+        if "messageType" in interface.enums:
+            message_type = interface.enums["messageType"]
+            message_type_items = u"\n".join(
+                [self._impl_code_loc_decl_enum_insert_template.substitute(
+                    var_name="message_type_items",
+                    enum=message_type.name,
+                    value=x.primary_name)
+                 for x in message_type.elements.values()])
+
+        header_file_name = "".join("{0}_schema.h".format(class_name))
+        guard = u"__CSMARTFACTORY_{0}_{1}_HPP__".format(
+            class_name.upper(),
+            unicode(uuid.uuid1().hex.capitalize()))
+        with codecs.open(os.path.join(destination_dir, header_file_name),
+                         encoding="utf-8",
+                         mode="w") as f_h:
+            f_h.write(self._hpp_schema_file_tempalte.substitute(
+                class_name=class_name,
+                guard=guard,
+                header_file_name=unicode("".join("{0}.h".format(class_name))),
+                namespace_open=namespace_open,
+                class_content=self._gen_h_class(
+                    class_name,
+                    interface.params,
+                    interface.functions.values(),
+                    interface.structs.values()),
+                namespace_close=namespace_close))
+
+        with codecs.open(os.path.join(destination_dir,
+                                      u"".join("{0}_schema.cc".format(class_name))),
+                         encoding="utf-8", mode="w") as f_s:
+            f_s.write(self._cc_file_template.substitute(
+                header_file_name=unicode(header_file_name),
+                namespace=namespace,
+                class_name=class_name,
+                function_id_items=self._indent_code(function_id_items, 1),
+                message_type_items=self._indent_code(message_type_items, 1),
+                struct_schema_items=self._structs_add_code,
+                pre_function_schemas=self._gen_pre_function_schemas(
+                    interface.functions.values()),
+                function_schemas=self._gen_function_schemas(
+                    interface.functions.values()),
+                init_function_impls=self._gen_function_impls(
+                    interface.functions.values(),
+                    namespace,
+                    class_name),
+                init_structs_impls=self._gen_sturct_impls(
+                    interface.structs.values(),
+                    namespace,
+                    class_name),
+                enum_string_coversions=self._gen_enum_to_str_converters(
+                    interface.enums.values(),
+                    namespace)))
+
+    def _preprocess_message_type(self, message_type):
+        """Preprocess message_type enum.
+
+        In base class this method is unimplemented and will cause runtime
+        exception. This method must be overridden by the subclasses to
+        return message_type enum after preprocessing.
+
+        Keyword arguments:
+        message_type -- message_type enum to preprocess.
+
+        """
+
+        raise GenerateError("Unexpected call to the unimplemented function.")
+
+    def _gen_enum_to_str_converters(self, enums, namespace):
+        """Generate enum to string converters.
+
+        Generates part of source code with specific enum to string value
+        converting functions.
+
+        Keyword arguments:
+        enums -- list of enums to generate string converting functions.
+        namespace -- namespace to address enums.
+
+        Returns:
+        String value with enum to string converting functions.
+
+        """
+
+        if enums is None:
+            raise GenerateError("Enums is None")
+
+        return u"\n".join([self._enum_to_str_converter_template.substitute(
+            namespace=namespace,
+            enum=x.name,
+            cstringvalues=self._indent_code(self._gen_enum_cstring_values(x), 2),
+            enumvalues=self._indent_code(self._gen_enum_enum_values(x, namespace), 2))
+            for x in enums])
+
+    def _gen_enum_cstring_values(self, enum):
+        """Generate list of c-string representing enum values.
+        Keyword arguments:
+        enum -- enum to generate string mapping.
+        Returns:
+        String value with c-string values.
+        """
+        return u",\n".join(['"' + x.name + '"' for x in enum.elements.values()])
+
+    def _gen_enum_enum_values(self, enum, namespace):
+        """Generate list of all enum values.
+        Keyword arguments:
+        enum -- enum to generate the list.
+        namespace -- namespace to address enum.
+        Returns:
+        String value with enum values.
+        """
+        return u",\n".join([namespace + "::" + enum.name + "::" + x.primary_name for x in enum.elements.values()])
+
+    def _gen_h_class(self, class_name, params, functions, structs):
+        """Generate source code of class for header file.
+
+        Generates source code of class that should be used in the
+        header file.
+
+        Keyword arguments:
+        class_name -- name of the class to generate.
+        params -- class parameters.
+        functions -- list of functions to generate methods for.
+        structs -- structures to generate methods for.
+
+        Returns:
+        String with complete *.h file source code.
+
+        """
+
+        return self._class_h_template.substitute(
+            comment=self._gen_class_comment(class_name, params),
+            class_name=class_name,
+            init_function_decls=self._gen_function_decls(functions),
+            init_struct_decls=self._gen_structs_decls(structs))
+
+    def _gen_structs_decls(self, structs):
+        """Generate method prototypes for structs for header file.
+
+        Generates method prototypes for structs that should be used in the
+        header file.
+
+        Keyword arguments:
+        structs -- list of structs to generate methods for.
+
+        Returns:
+        String with structs init methods declarations source code.
+
+        """
+
+        if structs is None:
+            raise GenerateError("Structs is None")
+
+        return u"\n".join([self._indent_code(
+            self._gen_struct_decl(x), 1) for x in structs])
+
+    def _gen_struct_decl(self, struct):
+        """Generate method prototype for struct for header file.
+
+        Generates method prototype for struct that should be used in the
+        header file.
+
+        Keyword arguments:
+        struct -- struct to generate method for.
+
+        Returns:
+        String with struct inin method declaration source code.
+
+        """
+
+        return self._struct_decl_template.substitute(
+            comment=self._gen_comment(struct),
+            struct_name=struct.name)
+
+    def _gen_function_decls(self, functions):
+        """Generate method prototypes for functions for header file.
+
+        Generates method prototypes for functions that should be used in the
+        header file.
+
+        Keyword arguments:
+        functions -- list of functions to generate methods for.
+
+        Returns:
+        String with function init methods declarations source code.
+
+        """
+
+        if functions is None:
+            raise GenerateError("Functions is None")
+
+        return u"\n".join([self._indent_code(
+            self._gen_function_decl(x), 1) for x in functions])
+
+    def _gen_function_decl(self, function):
+        """Generate method prototype for function for header file.
+
+        Generates method prototype for function that should be used in the
+        header file.
+
+        Keyword arguments:
+        function -- function to generate method for.
+
+        Returns:
+        String with function declaration source code.
+
+        """
+
+        return self._function_decl_template.substitute(
+            comment=self._gen_comment(function),
+            function_id=function.function_id.primary_name,
+            message_type=function.message_type.primary_name)
+
+    def _gen_struct_schema_items(self, structs):
+        """Generate struct schema items initialization code for source file.
+
+        Generates struct schema items initialization code that should be used
+        in the source file.
+
+        Keyword arguments:
+        structs -- list of structs to generate code for.
+
+        Returns:
+        String with struct schema items initialization source code.
+
+        """
+
+        if structs is None:
+            raise GenerateError("Structs is None")
+
+        for struct in structs:
+            self._process_struct(struct)
+
+    def _process_struct(self, struct):
+        """Process struct recursively to provide correct initialization.
+
+        This method create source code for cc file that guarantees that
+        structures are initialized in right order (to resolve all
+        dependencies).
+
+        Keyword arguments:
+        struct -- struct to process.
+
+        """
+
+        if struct.name in self._generated_structs:
+            return
+
+        for member in struct.members.values():
+            self._process_struct_member(member)
+
+        self._structs_add_code = u"\n".join(
+            [self._structs_add_code, self._indent_code(
+                self._gen_struct_schema_item(struct), 1)])
+        self._generated_structs.append(struct.name)
+
+    def _process_struct_member(self, member):
+        """Process struct member recursively to provide correct initialization.
+
+        This method ensures that nested structs (if any) are generated.
+
+        Keyword arguments:
+        member -- struct member to process.
+
+        """
+
+        if type(member.param_type) is Model.Struct:
+            self._ensure_struct_generated(member.param_type)
+
+    def _ensure_struct_generated(self, struct):
+        """Ensure that struct is already generated.
+
+        If struct is already created this method returns otherwise it
+        runs generation of struct to resolve dependency.
+
+        Keyword arguments:
+        struct -- struct to ensure existence.
+
+        """
+
+        if struct.name in self._generated_structs:
+            return
+
+        self._process_struct(struct)
+
+    def _gen_struct_schema_item(self, struct):
+        """Generate struct schema item initialization code for source file.
+
+        Generates struct schema item initialization code that should be used
+        in the source file.
+
+        Keyword arguments:
+        struct -- struct to generate code for.
+
+        Returns:
+        String with struct schema item initialization source code.
+
+        """
+
+        return self._struct_schema_item_template.substitute(name=struct.name)
+
+    def _gen_pre_function_schemas(self, functions):
+        """Generate specific code that goes before schema initialization.
+
+        In base class this function is unimplemented and it will raise an
+        runtime exception. Subclasses must implement this function in order
+        to provide format-specific code that goes before schema initialization.
+
+        Keyword arguments:
+        functions -- list of functions to generate code for.
+
+        """
+
+        raise GenerateError("Unexpected call to the unimplemented function.")
+
+    def _gen_function_schemas(self, functions):
+        """Generate functions initialization code for source file.
+
+        Generates functions schema initialization code that should be used
+        in the source file.
+
+        Keyword arguments:
+        functions -- list of functions to generate code for.
+
+        Returns:
+        String with functions schema initialization source code.
+
+        """
+
+        if functions is None:
+            raise GenerateError("Functions is None")
+
+        return u"".join([self._indent_code(
+            self._gen_function_schema(x), 1)
+            for x in functions])
+
+    def _gen_function_schema(self, function):
+        """Generate function initialization code for source file.
+
+        Generates function schema initialization code that should be used
+        in the source file.
+
+        Keyword arguments:
+        function -- function to generate method for.
+
+        Returns:
+        String with function schema initialization source code.
+
+        """
+
+        return self._function_schema_template.substitute(
+            function_id=function.function_id.primary_name,
+            message_type=function.message_type.primary_name)
+
+    def _gen_sturct_impls(self, structs, namespace, class_name):
+        """Generate structs implementation for source file.
+
+        Generates implementation code of methods that provide schema items for
+        structs. This code should be used in the source file.
+
+        Keyword arguments:
+        structs -- list of structs to generate methods for.
+        namespace -- name of destination namespace.
+        class_name -- name of the parent class.
+
+        Returns:
+        String with structs implementation source code.
+
+        """
+
+        if structs is None:
+            raise GenerateError("Structs is None")
+
+        return u"\n".join([self._gen_struct_impl(
+            x, namespace, class_name) for x in structs])
+
+    def _gen_struct_impl(self, struct, namespace, class_name):
+        """Generate struct implementation for source file.
+
+        Generates implementation code of method that provide schema item for
+        struct. This code should be used in the source file.
+
+        Keyword arguments:
+        struct -- struct to generate method for.
+        namespace -- name of destination namespace.
+        class_name -- name of the parent class.
+
+        Returns:
+        String with structs implementation source code.
+
+        """
+
+        processed_enums = []
+        return self._struct_impl_template.substitute(
+            namespace=namespace,
+            class_name=class_name,
+            struct_name=struct.name,
+            code=self._indent_code(
+                self._struct_impl_code_tempate.substitute(
+                    schema_loc_decl=self._gen_schema_loc_decls(
+                        struct.members.values(), processed_enums),
+                    schema_items_decl=self._gen_schema_items_decls(
+                        struct.members.values()),
+                    schema_item_fill=self._gen_schema_items_fill(
+                        struct.members.values())),
+                1))
+
+    def _gen_schema_loc_decls(self, members, processed_enums):
+        """Generate local declarations of variables for schema.
+
+        This method generates full set of required variables for
+        enums and enum subsets.
+
+        Keyword arguments:
+        members -- struct/function members/params.
+        processed_enums -- list of already processed enums.
+
+        Returns:
+        String with local declarations source code.
+
+        """
+
+        result = u""
+        for member in members:
+            if type(member.param_type) is Model.Enum and \
+               member.param_type.name not in processed_enums:
+                local_var = self._gen_schema_loc_emum_var_name(
+                    member.param_type)
+                result = u"\n".join(
+                    [u"".join(
+                        [result, self._impl_code_loc_decl_enum_template.
+                            substitute(
+                                type=member.param_type.name,
+                                var_name=local_var)]),
+                        u"\n".join(
+                            [self._impl_code_loc_decl_enum_insert_template.
+                                substitute(
+                                    var_name=local_var,
+                                    enum=member.param_type.name,
+                                    value=x.primary_name)
+                             for x in member.param_type.elements.values()])])
+                processed_enums.append(member.param_type.name)
+                result = u"".join([result, u"\n\n"]) if result else u""
+            elif type(member.param_type) is Model.EnumSubset:
+                local_var = self._gen_schema_loc_emum_s_var_name(member.name)
+                result = u"\n".join(
+                    [u"".join(
+                        [result, self._impl_code_loc_decl_enum_template.
+                            substitute(
+                                type=member.param_type.enum.name,
+                                var_name=local_var)]),
+                        u"\n".join(
+                            [self._impl_code_loc_decl_enum_insert_template.
+                                substitute(
+                                    var_name=local_var,
+                                    enum=member.param_type.enum.name,
+                                    value=x.primary_name)
+                             for x in member.param_type.
+                             allowed_elements.values()])])
+                result = u"".join([result, u"\n\n"]) if result else u""
+            elif type(member.param_type) is Model.Array:
+                result = u"".join(
+                    [result, self._gen_schema_loc_decls(
+                        [Model.Param(name=member.param_type.element_type.name
+                         if type(member.param_type.element_type) is
+                         Model.EnumSubset else "",
+                            param_type=member.param_type.element_type)],
+                        processed_enums)])
+
+        return result
+
+    def _gen_schema_items_decls(self, members):
+        """Generate schema items declarations.
+
+        Generates declaration and initialization of schema items
+        which is uses as struct members/function parameters.
+
+        Keyword arguments:
+        members -- list of struct members/function parameters.
+
+        Returns:
+        String with schema items declaration source code.
+
+        """
+
+        result = u"\n\n".join(
+            [self._gen_schema_item_decl(x) for x in members])
+
+        return u"".join([result, u"\n\n"]) if result else u""
+
+    def _gen_schema_item_decl(self, member):
+        """Generate schema item declaration.
+
+        Generates declaration and initialization of schema item
+        which is uses as struct member/function parameter.
+
+        Keyword arguments:
+        member -- struct member/function parameter.
+
+        Returns:
+        String with schema item declaration source code.
+
+        """
+
+        return self._impl_code_item_decl_temlate.substitute(
+            comment=self._gen_comment(member, False),
+            var_name=self._gen_schema_item_var_name(member),
+            item_decl=self._gen_schema_item_decl_code(
+                member.param_type,
+                member.name,
+                member.default_value))
+
+    def _gen_schema_item_decl_code(self, param, member_name, default_value):
+
+        """Generate schema item initialization code.
+
+        Generates type-specific code that initializes schema item
+
+        Keyword arguments:
+        param -- value of parameter type.
+        mamber_name -- name of struct member/function parameter.
+        default_value -- default value (used only for function parameters).
+
+        Returns:
+        String with schema item initialization source code.
+
+        """
+        code = u""
+        if type(param) is Model.Boolean:
+            code = self._impl_code_bool_item_template.substitute(
+                params=self._gen_schema_item_param_values(
+                    [[u"bool", None if param.default_value is None
+                      else u"true" if param.default_value is True else u"false"]]))
+        elif type(param) is Model.Integer:
+            if param.max_value < 2 ** 31:
+                code = self._impl_code_integer_item_template.substitute(
+                    type=u"int32_t",
+                    params=self._gen_schema_item_param_values(
+                        [[u"int32_t", param.min_value],
+                         [u"int32_t", param.max_value],
+                         [u"int32_t", param.default_value]]))
+            elif param.max_value < 2 ** 63:
+                code = self._impl_code_integer_item_template.substitute(
+                    type=u"int64_t",
+                    params=self._gen_schema_item_param_values(
+                        [[u"int64_t", param.min_value],
+                         [u"int64_t", str(param.max_value) + u"LL"],
+                         [u"int64_t", param.default_value]]))
+            else:
+                raise GenerateError("Parameter value too large: " + str(param.max_value))
+        elif type(param) is Model.Double:
+            code = self._impl_code_integer_item_template.substitute(
+                type=u"double",
+                params=self._gen_schema_item_param_values(
+                    [[u"double", param.min_value],
+                     [u"double", param.max_value],
+                     [u"double", param.default_value]]))
+        elif type(param) is Model.String:
+            code = self._impl_code_string_item_template.substitute(
+                params=self._gen_schema_item_param_values(
+                    [[u"size_t", param.min_length],
+                     [u"size_t", param.max_length],
+                     [u"std::string", u"".join(
+                     [u'"', param.default_value, u'"']) if param.default_value
+                         is not None else u""]]))
+        elif type(param) is Model.Array:
+            code = self._impl_code_array_item_template.substitute(
+                params=u"".join(
+                    [u"".join(
+                        [self._gen_schema_item_decl_code(
+                            param.element_type,
+                            param.element_type.name if type(param.element_type)
+                            is Model.EnumSubset else u"",
+                            None),
+                            u", "]),
+                        self._gen_schema_item_param_values(
+                            [[u"size_t", param.min_size],
+                             [u"size_t", param.max_size]])]))
+        elif type(param) is Model.Struct:
+            code = self._impl_code_struct_item_template.substitute(
+                name=param.name)
+        elif type(param) is Model.Enum:
+            code = self._impl_code_enum_item_template.substitute(
+                type=param.name,
+                params=u"".join(
+                    [self._gen_schema_loc_emum_var_name(param),
+                     u", ",
+                     self._gen_schema_item_param_values(
+                         [[u"".join([param.name, u"::eType"]),
+                          u"".join([param.name, u"::",
+                                    default_value.primary_name]) if
+                           default_value is not None else None]])]))
+        elif type(param) is Model.EnumSubset:
+            code = self._impl_code_enum_item_template.substitute(
+                type=param.enum.name,
+                params=u"".join(
+                    [self._gen_schema_loc_emum_s_var_name(member_name),
+                     u", ",
+                     self._gen_schema_item_param_values(
+                         [[u"".join([param.enum.name, u"::eType"]),
+                          default_value.primary_name if default_value
+                          is not None else None]])]))
+        else:
+            raise GenerateError("Unexpected type of parameter: " +
+                                str(type(param)))
+        return code
+
+    def _gen_schema_item_param_values(self, params):
+        """Generate values of schema item initialization parameters.
+
+        Generates part of code which is used as schema item initialization
+        parameters.
+
+        Keyword arguments:
+        params -- list of tuples which maps parameter type to parameter value.
+
+        Returns:
+        String with schema item initialization parameters source code.
+
+        """
+
+        result = u""
+        for param in params:
+            value = self._impl_code_item_param_value_template.substitute(
+                type=param[0],
+                value=str(param[1] if param[1] is not None else ""))
+            result = u"".join([result, u"".join(
+                [u", ", value])
+                if result else value])
+
+        return result
+
+    def _gen_schema_items_fill(self, members):
+        """Generate schema items fill code.
+
+        Generates source code that fills new schema with items.
+
+        Keyword arguments:
+        members -- list of struct members/function parameters to process.
+
+        Returns:
+        String with function schema items fill code.
+
+        """
+
+        result = u"\n".join(
+            [self._gen_schema_item_fill(x) for x in members])
+
+        return u"".join([result, u"\n\n"]) if result else u""
+
+    def _gen_schema_params_fill(self, message_type_name):
+        """Generate schema params fill code.
+
+        In the base class this method is not implemented (raises exception).
+        This method must be implemented by the subclasses to specify format
+        specific PARAMS for the function.
+
+        Keyword arguments:
+        message_type_name -- Name of the messageType enum element.
+
+        Returns:
+        String with function schema params fill code.
+
+        """
+
+        raise GenerateError("Unexpected call to the unimplemented function.")
+
+    def _gen_schema_item_fill(self, member):
+        """Generate schema item fill code.
+
+        Generates source code that fills new schema with item.
+
+        Keyword arguments:
+        member -- struct member/function parameter to process.
+
+        Returns:
+        String with schema item fill code.
+
+        """
+
+        return self._impl_code_item_fill_template.substitute(
+            name=member.name,
+            var_name=self._gen_schema_item_var_name(member),
+            is_mandatory=u"true" if member.is_mandatory is True else u"false")
+
+    @staticmethod
+    def _gen_schema_item_var_name(member):
+        """Generate schema item variable name.
+
+        Generates variable name for local declarations.
+
+        Keyword arguments:
+        member -- struct member/function parameter to process.
+
+        Returns:
+        String with schema item variable name.
+
+        """
+
+        return u"".join([member.name, u"_SchemaItem"])
+
+    @staticmethod
+    def _gen_schema_loc_emum_var_name(param_type):
+        """Generate name of enum local variable.
+
+        Generates name of local variable that defines allowed enum elements.
+
+        Keyword arguments:
+        param_type -- parameter type object.
+
+        Returns:
+        String with name of enum local variable.
+
+        """
+
+        return u"".join([param_type.name, u"_all_enum_values"])
+
+    @staticmethod
+    def _gen_schema_loc_emum_s_var_name(member_name):
+        """Generate name of enum subset local variable.
+
+        Generates name of local variable that defines allowed enum
+        subset elements.
+
+        Keyword arguments:
+        param_type -- parameter type object.
+
+        Returns:
+        String with name of enum subset local variable.
+
+        """
+
+        return u"".join([member_name, "_allowed_enum_subset_values"])
+
+    def _gen_function_impls(self, functions, namespace, class_name):
+        """Generate functions implementation for source file.
+
+        Generates implementation code of methods that provide schema for
+        functions. This code should be used in the source file.
+
+        Keyword arguments:
+        functions -- list of functions to generate methods for.
+        namespace -- name of destination namespace.
+        class_name -- name of the parent class.
+
+        Returns:
+        String with functions implementation source code.
+
+        """
+
+        if functions is None:
+            raise GenerateError("Functions is None")
+
+        return u"\n".join([self._gen_function_impl(
+            x, namespace, class_name) for x in functions])
+
+    def _gen_function_impl(self, function, namespace, class_name):
+        """Generate function implementation for source file.
+
+        Generates implementation code of method that provides schema for
+        function. This code should be used in the source file.
+
+        Keyword arguments:
+        function -- function to generate method for.
+        namespace -- name of destination namespace.
+        class_name -- name of the parent class.
+
+        Returns:
+        String with function implementation source code.
+
+        """
+
+        processed_enums = []
+        return self._function_impl_template.substitute(
+            namespace=namespace,
+            class_name=class_name,
+            function_id=function.function_id.primary_name,
+            message_type=function.message_type.primary_name,
+            code=self._indent_code(
+                self._function_impl_code_tempate.substitute(
+                    schema_loc_decl=self._gen_schema_loc_decls(
+                        function.params.values(), processed_enums),
+                    schema_items_decl=self._gen_schema_items_decls(
+                        function.params.values()),
+                    schema_item_fill=self._gen_schema_items_fill(
+                        function.params.values()),
+                    schema_params_fill=self._gen_schema_params_fill(
+                        function.message_type.name)),
+                1))
+
+    def _gen_enums(self, enums, structs):
+        """Generate enums for header file.
+
+        Generates declaration of enumerations for the header file.
+
+        Keyword arguments:
+        enums -- list of enums to generate.
+
+        Returns:
+        String with enums declaration source code.
+
+        """
+
+        if enums is None:
+            raise GenerateError("Enums is None")
+
+        if structs is None:
+            raise GenerateError("Structs is None")
+
+        if structs:
+            struct_id_enum_elements = collections.OrderedDict()
+            for struct in structs:
+                struct_id_enum_elements[struct.name] = Model.EnumElement(
+                    name=struct.name)
+            return u"\n".join(
+                [self._gen_enum(
+                    Model.Enum(name="StructIdentifiers",
+                               elements=struct_id_enum_elements)),
+                 u"\n".join([self._gen_enum(x) for x in enums])])
+
+        return u"\n".join([self._gen_enum(x) for x in enums])
+
+    def _gen_enum(self, enum):
+        """Generate enum for header file.
+
+        Generates declaration of enumeration for the header file.
+
+        Keyword arguments:
+        enum -- enum to generate.
+
+        Returns:
+        String with enum declaration source code.
+
+        """
+
+        enum_elements = enum.elements.values()
+        enum_elements.insert(0, Model.EnumElement(
+            name=u"INVALID_ENUM",
+            description=None,
+            design_description=None,
+            issues=None,
+            todos=None,
+            platform=None,
+            internal_name=None,
+            value=u"-1"))
+        return self._enum_template.substitute(
+            comment=self._gen_comment(enum),
+            name=enum.name,
+            enum_items=self._indent_code(self._gen_enum_elements(
+                enum_elements), 1))
+
+    def _gen_enum_elements(self, enum_elements):
+        """Generate enum elements for header file.
+
+        Generates declaration of enumeration elements for the header file.
+
+        Keyword arguments:
+        enum_elements -- list of enum elements to generate.
+
+        Returns:
+        String with enum elements declaration source code.
+
+        """
+
+        return u",\n\n".join([self._gen_enum_element(x)
+                              for x in enum_elements])
+
+    def _gen_enum_element(self, enum_element):
+        """Generate enum element for header file.
+
+        Generates declaration of enumeration element for the header file.
+
+        Keyword arguments:
+        enum_element -- enum element to generate.
+
+        Returns:
+        String with enum element declaration source code.
+
+        """
+
+        if enum_element.value is not None:
+            return self._enum_element_with_value_template.substitute(
+                comment=self._gen_comment(enum_element),
+                name=enum_element.primary_name,
+                value=enum_element.value)
+        else:
+            return self._enum_element_with_no_value_template.substitute(
+                comment=self._gen_comment(enum_element),
+                name=enum_element.primary_name)
+
+    def _gen_class_comment(self, class_name, params):
+        """Generate doxygen comment to the class for header file.
+
+        Generates doxygen comment for the class that should be used in
+        the header file.
+
+        Keyword arguments:
+        class_name -- name of the class.
+        params -- class parameters.
+
+        Returns:
+        String with generated doxygen class comment.
+
+        """
+
+        return self._class_comment_template.substitute(
+            class_name=class_name,
+            class_params=u"".join(
+                [u" *     {0} - {1}\n".format(x[0],
+                 x[1]) for x in params.items()])
+            if params else u" *    none\n")
+
+    def _gen_comment(self, interface_item_base, use_doxygen=True):
+        """Generate doxygen comment for iterface_item_base for header file.
+
+        Generates doxygen comment for any iterface_item_base for the header
+        file.
+
+        Keyword arguments:
+        interface_item_base -- object to generate doxygen comment for.
+        use_doxygen -- Flag that indicates does function uses doxygen or not.
+
+        Returns:
+        String with generated doxygen comment.
+
+        """
+
+        brief_type_title = None
+        interface_item_base_classname = interface_item_base.__class__.__name__
+        if interface_item_base_classname in self._model_types_briefs:
+            brief_type_title = \
+                self._model_types_briefs[interface_item_base_classname]
+        else:
+            raise GenerateError("Unable to create comment for unknown type " +
+                                interface_item_base_classname)
+
+        name = interface_item_base.primary_name if \
+            type(interface_item_base) is Model.EnumElement else \
+            interface_item_base.name
+        brief_description = (u" * @brief {0}{1}.\n" if use_doxygen is
+                             True else u"// {0}{1}.\n").format(
+                                 brief_type_title,
+                                 name)
+
+        description = u"".join([(u" * {0}\n" if use_doxygen
+                                is True else u"// {0}\n").format(x)
+                                for x in self._normalize_multiline_comments(
+                                    interface_item_base.description)])
+        if description is not u"":
+            description = u"".join([u" *\n" if use_doxygen
+                                    is True else u"//\n", description])
+
+        design_description = u"".join([(u" * {0}\n" if use_doxygen is
+                                       True else u"// {0}\n").format(x)
+                                       for x in
+                                       self._normalize_multiline_comments(
+                                           interface_item_base.
+                                           design_description)])
+        if design_description is not u"":
+            design_description = u"".join([u" *\n" if use_doxygen is
+                                           True else "//\n",
+                                           design_description])
+
+        issues = u"".join([(u" * @note {0}\n" if use_doxygen is
+                           True else u"// Note: {0}\n").format(x)
+                           for x in self._normalize_multiline_comments(
+                               [x.value for x in interface_item_base.issues])])
+        if issues is not u"":
+            issues = u"".join([u" *\n" if use_doxygen is
+                              True else u"//\n", issues])
+
+        todos = u"".join([(u" * @todo {0}\n" if use_doxygen is
+                          True else u"// ToDo: {0}\n").format(x)
+                          for x in self._normalize_multiline_comments(
+                              interface_item_base.todos)])
+        if todos is not u"":
+            todos = u"".join([u" *\n" if use_doxygen is
+                              True else u"//\n", todos])
+
+        returns = u""
+        if type(interface_item_base) is Model.Function:
+            returns = u"".join([u" *\n", self._function_return_comment])
+
+        template = self._comment_doxygen_template if use_doxygen is \
+            True else self._comment_cc_template
+
+        return template.substitute(
+            brief_description=brief_description,
+            description=description,
+            design_description=design_description,
+            issues=issues,
+            todos=todos,
+            returns=returns)
+
+    def _indent_code(self, code, indent_level):
+        """Indent given source code.
+
+        Indents given source code right by given indentation level.
+
+        Keyword arguments:
+        code -- given source code.
+        indent_level -- desired indentation level.
+
+        Returns:
+        String with processed code.
+
+        """
+
+        code_lines = code.split("\n")
+        return u"".join(
+            [u"{0}{1}\n".format(
+                self._indent_template * indent_level,
+                x) if x is not u"" else u"\n" for x in code_lines])
+
+    @staticmethod
+    def _normalize_multiline_comments(initial_strings):
+        """Normalize multiline comments.
+
+        Makes multiline comment clean of any line breaks creating additional
+        strings for the comment.
+
+        Keyword arguments:
+        initial_strings -- initial list of strings to process.
+
+        Returns:
+        New list of the strings (with contains no strings with line breaks).
+
+        """
+
+        result = []
+        for initial_string in initial_strings:
+            result = result + initial_string.splitlines()
+        return result
+
+    _model_types_briefs = dict(
+        {u"EnumElement": u"",
+         u"Enum": u"Enumeration ",
+         u"Function": u"Method that generates schema for function ",
+         u"Struct": u"Method that generates schema item for structure ",
+         u"Param": u"Struct member ",
+         u"FunctionParam": u"Function parameter "})
+
+    _h_file_tempalte = string.Template(
+        u'''/**\n'''
+        u''' * @file ${class_name}.h\n'''
+        u''' * @brief Generated class ${class_name} header file.\n'''
+        u''' *\n'''
+        u''' * This class is a part of SmartObjects solution. It provides\n'''
+        u''' * factory functionallity which allows client to use '''
+        u'''SmartSchemas\n'''
+        u''' * in accordance with definitions from ${class_name}.xml file\n'''
+        u''' */\n'''
+        u'''// Copyright (c) 2013, Ford Motor Company\n'''
+        u'''// All rights reserved.\n'''
+        u'''//\n'''
+        u'''// Redistribution and use in source and binary forms, '''
+        u'''with or without\n'''
+        u'''// modification, are permitted provided that the following '''
+        u'''conditions are met:\n'''
+        u'''//\n'''
+        u'''// Redistributions of source code must retain the above '''
+        u'''copyright notice, this\n'''
+        u'''// list of conditions and the following disclaimer.\n'''
+        u'''//\n'''
+        u'''// Redistributions in binary form must reproduce '''
+        u'''the above copyright notice,\n'''
+        u'''// this list of conditions and the following\n'''
+        u'''// disclaimer in the documentation and/or other materials '''
+        u'''provided with the\n'''
+        u'''// distribution.\n'''
+        u'''//\n'''
+        u'''// Neither the name of the Ford Motor Company nor the names '''
+        u'''of its contributors\n'''
+        u'''// may be used to endorse or promote products derived '''
+        u'''from this software\n'''
+        u'''// without specific prior written permission.\n'''
+        u'''//\n'''
+        u'''// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND '''
+        u'''CONTRIBUTORS "AS IS"\n'''
+        u'''// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT '''
+        u'''LIMITED TO, THE\n'''
+        u'''// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR '''
+        u'''A PARTICULAR PURPOSE\n'''
+        u'''// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER '''
+        u'''OR CONTRIBUTORS BE\n'''
+        u'''// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, '''
+        u'''EXEMPLARY, OR\n'''
+        u'''// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, '''
+        u'''PROCUREMENT OF\n'''
+        u'''// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; '''
+        u'''OR BUSINESS\n'''
+        u'''// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, '''
+        u'''WHETHER IN\n'''
+        u'''// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE '''
+        u'''OR OTHERWISE)\n'''
+        u'''// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF '''
+        u'''ADVISED OF THE\n'''
+        u'''// POSSIBILITY OF SUCH DAMAGE.\n\n'''
+        u'''#ifndef $guard\n'''
+        u'''#define $guard\n'''
+        u'''\n'''
+        u'''$namespace_open'''
+        u'''$enums_content'''
+        u'''$namespace_close'''
+        u'''#endif //$guard\n'''
+        u'''\n\n''')
+
+    _hpp_schema_file_tempalte = string.Template(
+        u'''/**\n'''
+        u''' * @file ${class_name}.hpp\n'''
+        u''' * @brief Generated class ${class_name} header file.\n'''
+        u''' *\n'''
+        u''' * This class is a part of SmartObjects solution. It provides\n'''
+        u''' * factory functionallity which allows client to use '''
+        u'''SmartSchemas\n'''
+        u''' * in accordance with definitions from ${class_name}.xml file\n'''
+        u''' */\n'''
+        u'''// Copyright (c) 2013, Ford Motor Company\n'''
+        u'''// All rights reserved.\n'''
+        u'''//\n'''
+        u'''// Redistribution and use in source and binary forms, '''
+        u'''with or without\n'''
+        u'''// modification, are permitted provided that the following '''
+        u'''conditions are met:\n'''
+        u'''//\n'''
+        u'''// Redistributions of source code must retain the above '''
+        u'''copyright notice, this\n'''
+        u'''// list of conditions and the following disclaimer.\n'''
+        u'''//\n'''
+        u'''// Redistributions in binary form must reproduce '''
+        u'''the above copyright notice,\n'''
+        u'''// this list of conditions and the following\n'''
+        u'''// disclaimer in the documentation and/or other materials '''
+        u'''provided with the\n'''
+        u'''// distribution.\n'''
+        u'''//\n'''
+        u'''// Neither the name of the Ford Motor Company nor the names '''
+        u'''of its contributors\n'''
+        u'''// may be used to endorse or promote products derived '''
+        u'''from this software\n'''
+        u'''// without specific prior written permission.\n'''
+        u'''//\n'''
+        u'''// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND '''
+        u'''CONTRIBUTORS "AS IS"\n'''
+        u'''// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT '''
+        u'''LIMITED TO, THE\n'''
+        u'''// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR '''
+        u'''A PARTICULAR PURPOSE\n'''
+        u'''// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER '''
+        u'''OR CONTRIBUTORS BE\n'''
+        u'''// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, '''
+        u'''EXEMPLARY, OR\n'''
+        u'''// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, '''
+        u'''PROCUREMENT OF\n'''
+        u'''// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; '''
+        u'''OR BUSINESS\n'''
+        u'''// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, '''
+        u'''WHETHER IN\n'''
+        u'''// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE '''
+        u'''OR OTHERWISE)\n'''
+        u'''// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF '''
+        u'''ADVISED OF THE\n'''
+        u'''// POSSIBILITY OF SUCH DAMAGE.\n\n'''
+        u'''#ifndef $guard\n'''
+        u'''#define $guard\n'''
+        u'''\n'''
+        u'''#include "formatters/CSmartFactory.hpp"\n'''
+        u'''#include "smart_objects/smart_schema.h"\n'''
+        u'''#include "smart_objects/schema_item.h"\n'''
+        u'''#include "utils/shared_ptr.h"\n'''
+        u'''#include "$header_file_name"\n'''
+        u'''\n'''
+        u'''$namespace_open'''
+        u'''\n\n'''
+        u'''$class_content'''
+        u'''\n\n'''
+        u'''$namespace_close'''
+        u'''\n'''
+        u'''#endif //$guard\n'''
+        u'''\n''')
+
+    _namespace_open_template = string.Template(
+        u'''namespace $name {\n''')
+
+    _cc_file_template = string.Template(
+        u'''/**\n'''
+        u''' * @file ${class_name}.cc\n'''
+        u''' * @brief Generated class ${class_name} source file.\n'''
+        u''' *\n'''
+        u''' * This class is a part of SmartObjects solution. It provides\n'''
+        u''' * factory functionallity which allows client to use '''
+        u'''SmartSchemas\n'''
+        u''' * in accordance with definitions from ${class_name}.xml file\n'''
+        u''' */\n'''
+        u'''// Copyright (c) 2013, Ford Motor Company\n'''
+        u'''// All rights reserved.\n'''
+        u'''//\n'''
+        u'''// Redistribution and use in source and binary forms, '''
+        u'''with or without\n'''
+        u'''// modification, are permitted provided that the following '''
+        u'''conditions are met:\n'''
+        u'''//\n'''
+        u'''// Redistributions of source code must retain the above '''
+        u'''copyright notice, this\n'''
+        u'''// list of conditions and the following disclaimer.\n'''
+        u'''//\n'''
+        u'''// Redistributions in binary form must reproduce '''
+        u'''the above copyright notice,\n'''
+        u'''// this list of conditions and the following\n'''
+        u'''// disclaimer in the documentation and/or other materials '''
+        u'''provided with the\n'''
+        u'''// distribution.\n'''
+        u'''//\n'''
+        u'''// Neither the name of the Ford Motor Company nor the names '''
+        u'''of its contributors\n'''
+        u'''// may be used to endorse or promote products derived '''
+        u'''from this software\n'''
+        u'''// without specific prior written permission.\n'''
+        u'''//\n'''
+        u'''// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND '''
+        u'''CONTRIBUTORS "AS IS"\n'''
+        u'''// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT '''
+        u'''LIMITED TO, THE\n'''
+        u'''// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR '''
+        u''''A PARTICULAR PURPOSE\n'''
+        u'''// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER '''
+        u'''OR CONTRIBUTORS BE\n'''
+        u'''// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, '''
+        u'''EXEMPLARY, OR\n'''
+        u'''// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, '''
+        u'''PROCUREMENT OF\n'''
+        u'''// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; '''
+        u'''OR BUSINESS\n'''
+        u'''// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, '''
+        u'''WHETHER IN\n'''
+        u'''// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE '''
+        u'''OR OTHERWISE)\n'''
+        u'''// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF '''
+        u'''ADVISED OF THE\n'''
+        u'''// POSSIBILITY OF SUCH DAMAGE.\n\n'''
+        u'''#include <map>\n'''
+        u'''#include <set>\n'''
+        u'''\n'''
+        u'''#include "$header_file_name"\n'''
+        u'''#include "smart_objects/always_true_schema_item.h"\n'''
+        u'''#include "smart_objects/always_false_schema_item.h"\n'''
+        u'''#include "smart_objects/array_schema_item.h"\n'''
+        u'''#include "smart_objects/bool_schema_item.h"\n'''
+        u'''#include "smart_objects/object_schema_item.h"\n'''
+        u'''#include "smart_objects/string_schema_item.h"\n'''
+        u'''#include "smart_objects/enum_schema_item.h"\n'''
+        u'''#include "smart_objects/number_schema_item.h"\n'''
+        u'''#include "smart_objects/schema_item_parameter.h"\n'''
+        u'''\n'''
+        u'''using namespace NsSmartDeviceLink::NsSmartObjects;\n'''
+        u'''\n'''
+        u'''$namespace::$class_name::$class_name()\n'''
+        u''' : NsSmartDeviceLink::NsJSONHandler::CSmartFactory<FunctionID::eType, '''
+        u'''messageType::eType, StructIdentifiers::eType>() {\n'''
+        u'''  TStructsSchemaItems struct_schema_items;\n'''
+        u'''  InitStructSchemes(struct_schema_items);\n'''
+        u'''\n'''
+        u'''  std::set<FunctionID::eType> function_id_items;\n'''
+        u'''${function_id_items}'''
+        u'''\n'''
+        u'''  std::set<messageType::eType> message_type_items;\n'''
+        u'''${message_type_items}'''
+        u'''\n'''
+        u'''  InitFunctionSchemes(struct_schema_items, function_id_items, '''
+        u'''message_type_items);\n'''
+        u'''}\n'''
+        u'''\n'''
+        u'''utils::SharedPtr<ISchemaItem> $namespace::$class_name::'''
+        u'''ProvideObjectSchemaItemForStruct(\n'''
+        u'''    const TStructsSchemaItems &struct_schema_items,\n'''
+        u'''    const StructIdentifiers::eType struct_id) {\n'''
+        u'''  const TStructsSchemaItems::const_iterator it = '''
+        u'''struct_schema_items.find(struct_id);\n'''
+        u'''  if (it != struct_schema_items.end()) {\n'''
+        u'''    return it->second;\n'''
+        u'''  }\n'''
+        u'''\n'''
+        u'''  return NsSmartDeviceLink::NsSmartObjects::'''
+        u'''CAlwaysFalseSchemaItem::create();\n'''
+        u'''}\n'''
+        u'''\n'''
+        u'''void $namespace::$class_name::InitStructSchemes(\n'''
+        u'''    TStructsSchemaItems &struct_schema_items) {'''
+        u'''$struct_schema_items'''
+        u'''}\n'''
+        u'''\n'''
+        u'''void $namespace::$class_name::InitFunctionSchemes(\n'''
+        u'''    const TStructsSchemaItems &struct_schema_items,\n'''
+        u'''    const std::set<FunctionID::eType> &function_id_items,\n'''
+        u'''    const std::set<messageType::eType> &message_type_items) {\n'''
+        u'''$pre_function_schemas'''
+        u'''$function_schemas'''
+        u'''}\n'''
+        u'''\n'''
+        u'''//------------- Functions schemes initialization -------------\n'''
+        u'''\n'''
+        u'''$init_function_impls'''
+        u'''\n'''
+        u'''//----------- Structs schema items initialization ------------\n'''
+        u'''\n'''
+        u'''$init_structs_impls'''
+        u'''\n'''
+        u'''//-------------- String to value enum mapping ----------------\n'''
+        u'''\n'''
+        u'''namespace NsSmartDeviceLink {\n'''
+        u'''namespace NsSmartObjects {\n'''
+        u'''\n'''
+        u'''$enum_string_coversions'''
+        u'''\n'''
+        u'''} // NsSmartObjects\n'''
+        u'''} // NsSmartDeviceLink\n'''
+        u'''\n''')
+
+    _enum_to_str_converter_template = string.Template(
+        u'''template<>\n'''
+        u'''const EnumConversionHelper<${namespace}::${enum}::eType>::'''
+        u'''EnumToCStringMap\n'''
+        u'''EnumConversionHelper<${namespace}::${enum}::eType>::'''
+        u'''enum_to_cstring_map_ =\n'''
+        u'''  EnumConversionHelper<${namespace}::${enum}::eType>::'''
+        u'''InitEnumToCStringMap();\n'''
+        u'''\n'''
+        u'''template<>\n'''
+        u'''const EnumConversionHelper<${namespace}::${enum}::eType>::'''
+        u'''CStringToEnumMap\n'''
+        u'''EnumConversionHelper<${namespace}::${enum}::eType>::'''
+        u'''cstring_to_enum_map_ =\n'''
+        u'''  EnumConversionHelper<${namespace}::${enum}::eType>::'''
+        u'''InitCStringToEnumMap();\n'''
+        u'''\n'''
+        u'''template<>\n'''
+        u'''const char* const\n'''
+        u'''EnumConversionHelper<${namespace}::${enum}::eType>::'''
+        u'''cstring_values_[] = {\n'''
+        u'''${cstringvalues}'''
+        u'''};\n'''
+        u'''\n'''
+        u'''template<>\n'''
+        u'''const ${namespace}::${enum}::eType\n'''
+        u'''EnumConversionHelper<${namespace}::${enum}::eType>::'''
+        u'''enum_values_[] = {\n'''
+        u'''${enumvalues}'''
+        u'''};\n'''
+        u'''\n''')
+
+    _struct_schema_item_template = string.Template(
+        u'''utils::SharedPtr<ISchemaItem> struct_schema_item_${name} = '''
+        u'''InitStructSchemaItem_${name}(struct_schema_items);\n'''
+        u'''struct_schema_items.insert(std::make_pair('''
+        u'''StructIdentifiers::${name}, struct_schema_item_${name}));\n'''
+        u'''structs_schemes_.insert(std::make_pair('''
+        u'''StructIdentifiers::${name}, CSmartSchema('''
+        u'''struct_schema_item_${name})));''')
+
+    _function_schema_template = string.Template(
+        u'''functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::'''
+        u'''NsJSONHandler::'''
+        u'''SmartSchemaKey<FunctionID::eType, messageType::eType>'''
+        u'''(FunctionID::$function_id, messageType::$message_type), '''
+        u'''InitFunction_${function_id}_${message_type}('''
+        u'''struct_schema_items, function_id_items, message_type_items)));''')
+
+    _struct_impl_template = string.Template(
+        u'''utils::SharedPtr<ISchemaItem> $namespace::$class_name::'''
+        u'''InitStructSchemaItem_${struct_name}(\n'''
+        u'''    const TStructsSchemaItems &struct_schema_items) {\n'''
+        u'''$code'''
+        u'''}\n''')
+
+    _struct_impl_code_tempate = string.Template(
+        u'''${schema_loc_decl}'''
+        u'''${schema_items_decl}'''
+        u'''CObjectSchemaItem::Members '''
+        u'''schema_members;\n\n'''
+        u'''${schema_item_fill}'''
+        u'''return CObjectSchemaItem::create(schema_members);''')
+
+    _impl_code_loc_decl_enum_template = string.Template(
+        u'''std::set<${type}::eType> ${var_name};''')
+
+    _impl_code_loc_decl_enum_insert_template = string.Template(
+        u'''${var_name}.insert(${enum}::${value});''')
+
+    _impl_code_item_decl_temlate = string.Template(
+        u'''${comment}'''
+        u'''utils::SharedPtr<ISchemaItem> ${var_name} = ${item_decl};''')
+
+    _impl_code_integer_item_template = string.Template(
+        u'''TNumberSchemaItem<${type}>::create(${params})''')
+
+    _impl_code_bool_item_template = string.Template(
+        u'''CBoolSchemaItem::create(${params})''')
+
+    _impl_code_string_item_template = string.Template(
+        u'''CStringSchemaItem::create(${params})''')
+
+    _impl_code_array_item_template = string.Template(
+        u'''CArraySchemaItem::create(${params})''')
+
+    _impl_code_struct_item_template = string.Template(
+        u'''ProvideObjectSchemaItemForStruct(struct_schema_items, '''
+        u'''StructIdentifiers::${name})''')
+
+    _impl_code_enum_item_template = string.Template(
+        u'''TEnumSchemaItem<${type}::eType>::create(${params})''')
+
+    _impl_code_item_param_value_template = string.Template(
+        u'''TSchemaItemParameter<$type>($value)''')
+
+    _impl_code_item_fill_template = string.Template(
+        u'''schema_members["${name}"] = CObjectSchemaItem::'''
+        u'''SMember(${var_name}, ${is_mandatory});''')
+
+    _function_impl_template = string.Template(
+        u'''CSmartSchema $namespace::$class_name::'''
+        u'''InitFunction_${function_id}_${message_type}(\n'''
+        u'''    const TStructsSchemaItems &struct_schema_items,\n'''
+        u'''    const std::set<FunctionID::eType> &function_id_items,\n'''
+        u'''    const std::set<messageType::eType> &message_type_items) {\n'''
+        u'''$code'''
+        u'''}\n''')
+
+    _function_impl_code_tempate = string.Template(
+        u'''${schema_loc_decl}'''
+        u'''${schema_items_decl}'''
+        u'''CObjectSchemaItem::Members '''
+        u'''schema_members;\n\n'''
+        u'''${schema_item_fill}'''
+        u'''CObjectSchemaItem::Members '''
+        u'''params_members;\n'''
+        u'''${schema_params_fill}'''
+        u'''\n'''
+        u'''CObjectSchemaItem::Members '''
+        u'''root_members_map;\n'''
+        u'''root_members_map[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::S_MSG_PARAMS] = '''
+        u'''CObjectSchemaItem::SMember(CObjectSchemaItem::'''
+        u'''create(schema_members), true);\n'''
+        u'''root_members_map[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::S_PARAMS] = '''
+        u'''CObjectSchemaItem::SMember(CObjectSchemaItem::'''
+        u'''create(params_members), true);\n\n'''
+        u'''return CSmartSchema(CObjectSchemaItem::'''
+        u'''create(root_members_map));''')
+
+    _class_h_template = string.Template(
+        u'''$comment\n'''
+        u'''class $class_name : public NsSmartDeviceLink::NsJSONHandler::'''
+        u'''CSmartFactory<FunctionID::eType, messageType::eType, '''
+        u'''StructIdentifiers::eType> {\n'''
+        u''' public:\n'''
+        u'''  /**\n'''
+        u'''   * @brief Constructor.\n'''
+        u'''   */\n'''
+        u'''  $class_name();\n'''
+        u'''\n'''
+        u''' protected:\n'''
+        u'''  /**\n'''
+        u'''   * @brief Type that maps of struct IDs to schema items.\n'''
+        u'''   */\n'''
+        u'''  typedef std::map<const StructIdentifiers::eType, '''
+        u'''utils::SharedPtr<NsSmartDeviceLink::NsSmartObjects::'''
+        u'''ISchemaItem> > TStructsSchemaItems;\n'''
+        u'''\n'''
+        u'''  /**\n'''
+        u'''   * @brief Helper that allows to make reference to struct\n'''
+        u'''   *\n'''
+        u'''   * @param struct_schema_items Struct schema items.\n'''
+        u'''   * @param struct_id ID of structure to provide.\n'''
+        u'''   *\n'''
+        u'''   * @return utils::SharedPtr of strucute\n'''
+        u'''   */\n'''
+        u'''  static '''
+        u'''utils::SharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> '''
+        u'''ProvideObjectSchemaItemForStruct(\n'''
+        u'''        const TStructsSchemaItems &struct_schema_items,\n'''
+        u'''        const StructIdentifiers::eType struct_id);\n'''
+        u'''\n'''
+        u'''  /**\n'''
+        u'''   * @brief Initializes all struct schemes.\n'''
+        u'''   */\n'''
+        u'''  void InitStructSchemes('''
+        u'''TStructsSchemaItems &struct_schema_items);\n'''
+        u'''\n'''
+        u'''  /**\n'''
+        u'''   * @brief Initializes all function schemes.\n'''
+        u'''   *\n'''
+        u'''   * @param struct_schema_items Struct schema items.\n'''
+        u'''   * @param function_id_items Set of all elements '''
+        u'''of FunctionID enum.\n'''
+        u'''   * @param message_type_items Set of all elements '''
+        u'''of messageType enum.\n'''
+        u'''   */\n'''
+        u'''  void InitFunctionSchemes(\n'''
+        u'''      const TStructsSchemaItems &struct_schema_items,\n'''
+        u'''      const std::set<FunctionID::eType> &function_id_items,\n'''
+        u'''      const std::set<messageType::eType> '''
+        u'''&message_type_items);\n'''
+        u'''\n'''
+        u'''$init_function_decls'''
+        u'''\n'''
+        u'''$init_struct_decls'''
+        u'''};''')
+
+    _function_return_comment = u''' * @return NsSmartDeviceLink::''' \
+                               u'''NsSmartObjects::CSmartSchema\n'''
+
+    _function_decl_template = string.Template(
+        u'''$comment\n'''
+        u'''static NsSmartDeviceLink::NsSmartObjects::CSmartSchema '''
+        u'''InitFunction_${function_id}_${message_type}(\n'''
+        u'''    const TStructsSchemaItems &struct_schema_items,\n'''
+        u'''    const std::set<FunctionID::eType> &function_id_items,\n'''
+        u'''    const std::set<messageType::eType> &message_type_items);''')
+
+    _struct_decl_template = string.Template(
+        u'''$comment\n'''
+        u'''static '''
+        u'''utils::SharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> '''
+        u'''InitStructSchemaItem_${struct_name}(\n'''
+        u'''    const TStructsSchemaItems &struct_schema_items);''')
+
+    _class_comment_template = string.Template(
+        u'''/**\n'''
+        u''' * @brief Class $class_name.\n'''
+        u''' *\n'''
+        u''' * Params:\n'''
+        u'''$class_params'''
+        u''' */''')
+
+    _comment_doxygen_template = string.Template(
+        u'''/**\n'''
+        u'''$brief_description'''
+        u'''$description'''
+        u'''$design_description'''
+        u'''$issues'''
+        u'''$todos'''
+        u'''$returns */''')
+
+    _comment_cc_template = string.Template(
+        u'''$brief_description'''
+        u'''$description'''
+        u'''$design_description'''
+        u'''$issues'''
+        u'''$todos'''
+        u'''$returns''')
+
+    _enum_template = string.Template(
+        u'''namespace $name {\n'''
+        u'''$comment\n'''
+        u'''enum eType {\n'''
+        u'''$enum_items};\n'''
+        u'''} // $name\n''')
+
+    _enum_element_with_value_template = string.Template(
+        u'''$comment\n'''
+        u'''$name = $value''')
+
+    _enum_element_with_no_value_template = string.Template(
+        u'''$comment\n'''
+        u'''$name''')
+
+    _indent_template = u"  "
diff --git a/tools/InterfaceGenerator/generator/generators/SmartFactoryJSONRPC.py b/tools/InterfaceGenerator/generator/generators/SmartFactoryJSONRPC.py
new file mode 100755
index 000000000..cf9887d39
--- /dev/null
+++ b/tools/InterfaceGenerator/generator/generators/SmartFactoryJSONRPC.py
@@ -0,0 +1,165 @@
+"""SmartFactory code generator for JSONRPC format.
+
+Defines JSONRPC format specific code generation rules.
+
+"""
+import string
+
+from generator.generators import SmartFactoryBase
+from generator import Model
+
+
+class CodeGenerator(SmartFactoryBase.CodeGenerator):
+
+    """JSONRPC SmartFactory generator.
+
+    Defines special cases that affects base code generation to make JSONRPC
+    format-friendly code.
+
+    """
+
+    def __init__(self):
+        """Construct new object."""
+
+        SmartFactoryBase.CodeGenerator.__init__(self)
+
+    def _gen_pre_function_schemas(self, functions):
+        """Generate specific code that goes before schema initialization.
+
+        JSON RPC generator generates code that adds specific schema for the
+        error_response and adds this schema for every available response.
+
+        Keyword arguments:
+        functions -- list of functions to generate code for.
+
+        Returns:
+        Source code with error_response schema initialization and adding to the
+        base SmartFactory..
+
+        """
+
+        code = u""
+        for function in functions:
+            if unicode(function.message_type.primary_name) == u"response":
+                code = u"".join(
+                    [code, self._error_response_insert_template.substitute(
+                        function_id=function.function_id.primary_name)])
+
+        if code:
+            return self._indent_code(
+                u"".join([self._error_response_schema_template, code]), 1)
+
+        return u""
+
+    def _preprocess_message_type(self, message_type):
+        """Preprocess message_type enum.
+
+        JSON RPC generator needs to add new message_type "error_response" in
+        case if at least one response available.
+
+        Keyword arguments:
+        message_type -- message_type enum to preprocess.
+
+        Returns:
+        Preprocessed message_type enum.
+
+        """
+
+        if "response" in message_type.elements:
+            message_type.elements[u"error_response"] = Model.EnumElement(
+                name=u"error_response")
+
+        return message_type
+
+    def _gen_schema_params_fill(self, message_type_name):
+        """Generate schema params fill code.
+
+        Provides constant set of params for the function in accordance to the
+        JSONRPC format.
+
+        Keyword arguments:
+        message_type_name -- Name of the messageType enum element.
+
+        Returns:
+        String with function schema params fill code.
+
+        """
+
+        return u"".join(
+            [self._base_params,
+             self._correlation_id_param
+                if unicode(message_type_name) != u"notification" else u"",
+             self._additional_response_params
+                if unicode(message_type_name) == u"response" else u""])
+
+    _error_response_insert_template = string.Template(
+        u'''functions_schemes_.insert(std::make_pair('''
+        u'''NsSmartDeviceLink::NsJSONHandler::'''
+        u'''SmartSchemaKey<FunctionID::eType, messageType::eType>('''
+        u'''FunctionID::${function_id}, messageType::error_response), '''
+        u'''error_response_schema));\n''')
+
+    _error_response_schema_template = (
+        u'''CObjectSchemaItem::Members '''
+        u'''params_members;\n'''
+        u'''params_members[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember('''
+        u'''TEnumSchemaItem<FunctionID::eType>::create('''
+        u'''function_id_items), true);\n'''
+        u'''params_members[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember('''
+        u'''TEnumSchemaItem<messageType::eType>::create('''
+        u'''message_type_items), true);\n'''
+        u'''params_members[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember('''
+        u'''TNumberSchemaItem<int>::create(), true);\n'''
+        u'''params_members[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember('''
+        u'''TNumberSchemaItem<int>::create(), true);\n'''
+        u'''params_members[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember('''
+        u'''TNumberSchemaItem<int>::create(), true);\n'''
+        u'''params_members[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::kCode] = CObjectSchemaItem::SMember('''
+        u'''TNumberSchemaItem<int>::create(), true);\n'''
+        u'''params_members[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::kMessage] = CObjectSchemaItem::SMember('''
+        u'''CStringSchemaItem::create(), true);\n'''
+        u'''\n'''
+        u'''CObjectSchemaItem::Members root_members_map;\n'''
+        u'''root_members_map[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::S_PARAMS] = CObjectSchemaItem::SMember('''
+        u'''CObjectSchemaItem::create(params_members), true);\n'''
+        u'''\n'''
+        u'''CSmartSchema error_response_schema('''
+        u'''CObjectSchemaItem::create(root_members_map));\n'''
+        u'''\n''')
+
+    _base_params = (
+        u'''params_members[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::S_FUNCTION_ID] = CObjectSchemaItem::'''
+        u'''SMember(TEnumSchemaItem<FunctionID::eType>::'''
+        u'''create(function_id_items), true);\n'''
+        u'''params_members[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::S_MESSAGE_TYPE] = CObjectSchemaItem::'''
+        u'''SMember(TEnumSchemaItem<messageType::eType>::'''
+        u'''create(message_type_items), true);\n'''
+        u'''params_members[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::'''
+        u'''SMember(TNumberSchemaItem<int>::create(), true);\n'''
+        u'''params_members[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::'''
+        u'''SMember(TNumberSchemaItem<int>::create(), true);\n'''
+    )
+
+    _correlation_id_param = (
+        u'''params_members[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::S_CORRELATION_ID] = CObjectSchemaItem::'''
+        u'''SMember(TNumberSchemaItem<int>::create(), true);\n'''
+    )
+
+    _additional_response_params = (
+        u'''params_members[NsSmartDeviceLink::NsJSONHandler::'''
+        u'''strings::kCode] = CObjectSchemaItem::'''
+        u'''SMember(TNumberSchemaItem<int>::create(), true);\n'''
+    )
diff --git a/tools/InterfaceGenerator/generator/generators/SmartFactorySDLRPC.py b/tools/InterfaceGenerator/generator/generators/SmartFactorySDLRPC.py
new file mode 100755
index 000000000..b3fb61f4a
--- /dev/null
+++ b/tools/InterfaceGenerator/generator/generators/SmartFactorySDLRPC.py
@@ -0,0 +1,92 @@
+"""SmartFactory code generator for SDLRPC format.
+
+Defines SDLRPC format specific code generation rules.
+
+"""
+from generator.generators import SmartFactoryBase
+
+
+class CodeGenerator(SmartFactoryBase.CodeGenerator):
+
+    """SDLRPC SmartFactory generator.
+
+    Defines special cases that affects base code generation to make SDLRPC
+    format-friendly code.
+
+    """
+
+    def __init__(self):
+        """Construct new object."""
+
+        SmartFactoryBase.CodeGenerator.__init__(self)
+
+    def _gen_pre_function_schemas(self, functions):
+        """Generate specific code that goes before schema initialization.
+
+        In SDL RPC generator there is no need to generate any code before
+        schemas initialization.
+
+        Keyword arguments:
+        functions -- list of functions to generate code for.
+
+        Returns:
+        Empty string.
+
+        """
+
+        return u""
+
+    def _preprocess_message_type(self, message_type):
+        """Preprocess message_type enum.
+
+        In SDL RPC generator there is no need to preprocess message_type
+        enum values.
+
+        Keyword arguments:
+        message_type -- message_type enum to preprocess.
+
+        Returns:
+        Initial message_type enum without any modifications.
+
+        """
+
+        return message_type
+
+    def _gen_schema_params_fill(self, message_type_name):
+        """Generate schema params fill code.
+
+        Provides constant set of params for the function in accordance to the
+        SDLRPC format (both v1 and v2).
+
+        Keyword arguments:
+        message_type_name -- Name of the messageType enum element.
+
+        Returns:
+        String with function schema params fill code.
+
+        """
+
+        base_params = \
+            u'''params_members[NsSmartDeviceLink::NsJSONHandler::''' \
+            u'''strings::S_FUNCTION_ID] = CObjectSchemaItem::''' \
+            u'''SMember(TEnumSchemaItem<FunctionID::eType>::''' \
+            u'''create(function_id_items), true);\n''' \
+            u'''params_members[NsSmartDeviceLink::NsJSONHandler::''' \
+            u'''strings::S_MESSAGE_TYPE] = CObjectSchemaItem::''' \
+            u'''SMember(TEnumSchemaItem<messageType::eType>::''' \
+            u'''create(message_type_items), true);\n''' \
+            u'''params_members[NsSmartDeviceLink::NsJSONHandler::''' \
+            u'''strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::''' \
+            u'''SMember(TNumberSchemaItem<int>::create(), true);\n''' \
+            u'''params_members[NsSmartDeviceLink::NsJSONHandler::''' \
+            u'''strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::''' \
+            u'''SMember(TNumberSchemaItem<int>::create(), true);\n'''
+
+        correlation_id_param = \
+            u'''params_members[NsSmartDeviceLink::NsJSONHandler::''' \
+            u'''strings::S_CORRELATION_ID] = CObjectSchemaItem::''' \
+            u'''SMember(TNumberSchemaItem<int>::create(), true);\n'''
+
+        return u"".join([base_params, correlation_id_param
+                        if unicode(message_type_name) !=
+                        u"notification" else u""])
diff --git a/tools/InterfaceGenerator/generator/generators/__init__.py b/tools/InterfaceGenerator/generator/generators/__init__.py
new file mode 100755
index 000000000..57e528dc8
--- /dev/null
+++ b/tools/InterfaceGenerator/generator/generators/__init__.py
@@ -0,0 +1,3 @@
+"""Package that contains generators from internal model representation to
+different formats.
+"""
diff --git a/tools/InterfaceGenerator/generator/parsers/JSONRPC.py b/tools/InterfaceGenerator/generator/parsers/JSONRPC.py
new file mode 100755
index 000000000..092f41ec1
--- /dev/null
+++ b/tools/InterfaceGenerator/generator/parsers/JSONRPC.py
@@ -0,0 +1,89 @@
+"""JSON RPC parser.
+
+Contains parser for JSON RPC XML format.
+
+"""
+
+from generator.parsers import RPCBase
+
+
+class Parser(RPCBase.Parser):
+
+    """JSON RPC parser."""
+
+    def __init__(self):
+        """Constructor."""
+        super(Parser, self).__init__()
+        self._interface_name = None
+
+    def _parse_root(self, root):
+        """Parse root XML element.
+
+        This implementation parses root as interfaces element with multiple
+        interfaces in it.
+
+        Keyword arguments:
+        root -- root element.
+
+        """
+
+        self._params = root.attrib
+        self._interface_name = None
+
+        for element in root:
+            if element.tag != "interface":
+                raise RPCBase.ParseError("Subelement '" + element.tag +
+                                         "' is unexpected in interfaces")
+
+            if "name" not in element.attrib:
+                raise RPCBase.ParseError(
+                    "Name is not specified for interface")
+
+            self._interface_name = element.attrib["name"]
+            self._parse_interface(element, self._interface_name + "_")
+
+    def _provide_enum_element_for_function(self, enum_name, element_name):
+        """Provide enum element for functions.
+
+        This implementation replaces the underscore separating interface and
+        function name with dot and sets it as name of enum element leaving
+        the name with underscore as internal_name. For enums other than
+        FunctionID the base implementation is called.
+
+        Returns EnumElement.
+
+        """
+
+        name = element_name
+        internal_name = None
+
+        if "FunctionID" == enum_name:
+            prefix_length = len(self._interface_name) + 1
+            if element_name[:prefix_length] != self._interface_name + '_':
+                raise RPCBase.ParseError(
+                    "Unexpected prefix for function id '" +
+                    element_name + "'")
+            name = self._interface_name + "." + element_name[prefix_length:]
+            internal_name = element_name
+
+        element = super(Parser, self)._provide_enum_element_for_function(
+            enum_name,
+            name)
+
+        if internal_name is not None:
+            element.internal_name = internal_name
+
+        return element
+
+    def _check_function_param_name(self, function_param_name):
+        """Check function param name.
+
+        This method is called to check whether the newly parsed function
+        parameter name conflicts with some predefined name.
+        """
+
+        if function_param_name in ['method', 'code']:
+            raise RPCBase.ParseError(
+                "'" + function_param_name +
+                "' is a predefined name and can't be used" +
+                " as a function parameter name")
diff --git a/tools/InterfaceGenerator/generator/parsers/RPCBase.py b/tools/InterfaceGenerator/generator/parsers/RPCBase.py
new file mode 100755
index 000000000..2b3db62d5
--- /dev/null
+++ b/tools/InterfaceGenerator/generator/parsers/RPCBase.py
@@ -0,0 +1,758 @@
+"""RPC XML base parser.
+
+Contains base parser for SDLRPC v1/v2 and JSON RPC XML format.
+
+"""
+
+import collections
+import xml.etree.ElementTree
+
+from generator import Model
+
+
+class ParseError(Exception):
+
+    """Parse error.
+
+    This exception is raised when XML contains errors and can't be parsed.
+
+    """
+
+    pass
+
+
+class Parser(object):
+
+    """RPC XML Parser base.
+
+    This class must not be used directly. One of its subclasses must be used
+    instead.
+
+    """
+
+    def __init__(self):
+        """Constructor."""
+        self._types = {}
+        self._enums = collections.OrderedDict()
+        self._structs = collections.OrderedDict()
+        self._functions = collections.OrderedDict()
+        self._params = {}
+
+    def parse(self, filename):
+        """Parse XML.
+
+        Returns an instance of generator.Model.Interface containing parsed
+        interface or raises ParseError if input XML contains errors
+        and can't be parsed.
+
+        Keyword arguments:
+        filename -- name of input XML file.
+
+        """
+
+        tree = xml.etree.ElementTree.parse(filename)
+        root = tree.getroot()
+
+        self._enums = self._initialize_enums()
+        self._structs = collections.OrderedDict()
+        self._functions = collections.OrderedDict()
+        self._params = {}
+
+        self._types = dict(self._enums.items())
+
+        self._parse_root(root)
+
+        return Model.Interface(enums=self._enums, structs=self._structs,
+                               functions=self._functions, params=self._params)
+
+    def _initialize_enums(self):
+        """Initialize enums.
+
+        The default implementation returns an OrderedDict with two empty
+        enums: "FunctionID" and "messageType". Required for formats where
+        these enums must be generated automatically according to the declared
+        in the XML functions.
+
+        These enums are filled during the parsing of the functions.
+
+        """
+        return collections.OrderedDict(
+            [("FunctionID", Model.Enum(name="FunctionID")),
+             ("messageType", Model.Enum(name="messageType"))])
+
+    def _check_enum_name(self, enum):
+        """Check enum name.
+
+        This method is called to check whether the newly parsed enum's name
+        conflicts with some predefined enum.
+
+        This implementation raises an error if enum name is one of the
+        predefined enums "FunctionID" or "messageType" which must not be
+        declared explicitly in the XML.
+
+        """
+        if enum.name in ["FunctionID", "messageType"]:
+            raise ParseError(
+                "Enum '" + enum.name +
+                "' is generated automatically in SDLRPCV1 and"
+                " must not be declared in xml file")
+
+    def _check_function_param_name(self, function_param_name):
+        """Check function param name.
+
+        This method is called to check whether the newly parsed function
+        parameter name conflicts with some predefined name.
+
+        This implementation doesn't check anything because there is no
+        predefined names in base RPC XML.
+        """
+
+        pass
+
+    def _parse_root(self, root):
+        """Parse root XML element.
+
+        Default implementation parses root as interface element without a
+        prefix.
+
+        Keyword arguments:
+        root -- root element.
+
+        """
+
+        self._parse_interface(root, "")
+
+    def _parse_interface(self, interface, prefix):
+        """Parse interface element.
+
+        Keyword arguments:
+        interface -- interface element.
+        prefix -- string prefix for all types of the interface.
+
+        """
+        if interface.tag != "interface":
+            raise ParseError("Invalid interface tag: " + interface.tag)
+
+        params, subelements, attrib = self._parse_base_item(interface, "")
+
+        for param in ["description", "design_description", "todos"]:
+            if 0 != len(params[param]):
+                attrib[param] = "\n".join(params[param])
+
+        if 0 != len(params["issues"]):
+            attrib["issues"] = "\n".join(i.value for i in params["issues"])
+
+        self._params = dict(
+            self._params.items() +
+            [(prefix + p[0], p[1]) for p in attrib.items()])
+
+        for element in subelements:
+            if element.tag == "enum":
+                enum = self._parse_enum(element, prefix)
+                self._check_enum_name(enum)
+                self._add_item(self._enums, enum)
+                self._add_type(enum)
+            elif element.tag == "struct":
+                struct = self._parse_struct(element, prefix)
+                self._add_item(self._structs, struct)
+                self._add_type(struct)
+            elif element.tag == "function":
+                function = self._parse_function(element, prefix)
+                self._add_item(self._functions, function,
+                               (function.function_id, function.message_type))
+            else:
+                raise ParseError("Unexpected element: " + element.tag)
+
+    @staticmethod
+    def _add_item(items, item, key=None):
+        """Add new item in the items dictionary with given key.
+
+        Performs additional check for presence in the dictionary and throws
+        ParseError exception if key already exist.
+
+        """
+        if key is None:
+            key = item.name
+
+        if key in items:
+            raise ParseError(type(item).__name__ + " '" + str(key) +
+                             "' is declared more than once")
+        items[key] = item
+
+    def _add_type(self, _type):
+        """Add new type in the internal types dictionary.
+
+        Performs additional check for presence type with same name in the
+        dictionary and throws ParseError exception if key already exist.
+
+        """
+        if _type.name in self._types:
+            raise ParseError("Type '" + _type.name +
+                             "' is declared as both struct and enum")
+
+        self._types[_type.name] = _type
+
+    def _parse_enum(self, element, prefix):
+        """Parse element as enumeration.
+
+        Returns an instance of generator.Model.Enum
+
+        """
+        params, subelements, attributes = \
+            self._parse_base_item(element, prefix)
+
+        internal_scope = None
+        scope = None
+        for attribute in attributes:
+            if attribute == "internal_scope":
+                internal_scope = attributes[attribute]
+            elif attribute == "scope":
+                scope = attributes[attribute]
+            else:
+                raise ParseError("Unexpected attribute '" + attribute +
+                                 "' in enum '" + params["name"] + "'")
+        params["internal_scope"] = internal_scope
+        params["scope"] = scope
+
+        elements = collections.OrderedDict()
+        for subelement in subelements:
+            if subelement.tag == "element":
+                self._add_item(elements, self._parse_enum_element(subelement))
+            else:
+                raise ParseError("Unexpected element '" + subelement.tag +
+                                 "' in enum '" + params["name"] + "'")
+        params["elements"] = elements
+
+        # Magic usage is correct
+        # pylint: disable=W0142
+        return Model.Enum(**params)
+
+    def _parse_struct(self, element, prefix):
+        """Parse element as structure.
+
+        Returns an instance of generator.Model.Struct
+
+        """
+        params, subelements, attrib = self._parse_base_item(element, prefix)
+
+        scope = None
+        for attribute in attrib:
+            if attribute == "scope":
+                scope = attrib[attribute]
+            else:
+                raise ParseError("Unexpected attribute '" + attribute +
+                                 "' in struct '" + params["name"] + "'")
+        params["scope"] = scope
+
+        members = collections.OrderedDict()
+        for subelement in subelements:
+            if subelement.tag == "param":
+                self._add_item(members, self._parse_param(subelement, prefix))
+            else:
+                raise ParseError("Unexpected subelement '" + subelement.name +
+                                 "' in struct '" + params["name"] + "'")
+        params["members"] = members
+
+        # Magic usage is correct
+        # pylint: disable=W0142
+        return Model.Struct(**params)
+
+    def _parse_function(self, element, prefix):
+        """Parse element as function.
+
+        Returns an instance of generator.Model.Function
+
+        """
+        params, subelements, attributes = \
+            self._parse_base_item(element, prefix)
+
+        function_id, message_type = self._parse_function_id_type(
+            params["name"],
+            attributes)
+
+        scope = None
+        for attribute in attributes:
+            if attribute == "scope":
+                scope = attributes[attribute]
+
+        params["function_id"] = function_id
+        params["message_type"] = message_type
+        params["scope"] = scope
+
+        function_params = collections.OrderedDict()
+        for subelement in subelements:
+            if subelement.tag == "param":
+                function_param = self._parse_function_param(subelement,
+                                                            prefix)
+                self._check_function_param_name(function_param.name)
+                if function_param.name in function_params:
+                    raise ParseError("Parameter '" + function_param.name +
+                                     "' is specified more than once" +
+                                     " for function '" + params["name"] + "'")
+                function_params[function_param.name] = function_param
+            else:
+                raise ParseError("Unexpected subelement '" + subelement.tag +
+                                 "' in function '" + params["name"] + "'")
+        params["params"] = function_params
+
+        # Magic usage is correct
+        # pylint: disable=W0142
+        return Model.Function(**params)
+
+    def _parse_function_id_type(self, function_name, attrib):
+        """Parse function id and message type according to XML format.
+
+        This implementation takes function name as function id and extracts
+        attribute "messagetype" as message type and searches them in enums
+        "FunctionID" and "messageType" adding the missing elements if
+        necessary.
+
+        Returns function id and message type as an instances of EnumElement.
+
+        """
+        if "messagetype" not in attrib:
+            raise ParseError("No messagetype specified for function '" +
+                             function_name + "'")
+
+        function_id = self._provide_enum_element_for_function(
+            "FunctionID",
+            function_name)
+
+        message_type = self._provide_enum_element_for_function(
+            "messageType",
+            self._extract_attrib(attrib, "messagetype"))
+
+        return function_id, message_type
+
+    def _provide_enum_element_for_function(self, enum_name, element_name):
+        """Provide enum element for functions.
+
+        Search an element in an enum and add it if it is missing.
+
+        Returns EnumElement.
+
+        """
+        if enum_name not in self._types:
+            raise ParseError("Enum '" + enum_name +
+                             "' is not initialized")
+
+        enum = self._types[enum_name]
+
+        if not isinstance(enum, Model.Enum):
+            raise ParseError("'" + enum_name + "' is not an enum")
+
+        if element_name not in enum.elements:
+            enum.elements[element_name] = Model.EnumElement(name=element_name)
+
+        return enum.elements[element_name]
+
+    def _parse_base_item(self, element, prefix):
+        """Parse element as base item.
+
+        Returns an params, sub-elements and attributes of the element
+
+        """
+        params = {}
+
+        description = []
+        design_description = []
+        issues = []
+        todos = []
+        subelements = []
+
+        if "name" not in element.attrib:
+            raise ParseError("Name is not specified for " + element.tag)
+
+        params["name"] = prefix + element.attrib["name"]
+        attrib = dict(element.attrib.items())
+        del attrib["name"]
+
+        params["platform"] = self._extract_attrib(attrib, "platform")
+
+        for subelement in element:
+            if subelement.tag == "description":
+                description.append(self._parse_simple_element(subelement))
+            elif subelement.tag == "designdescription":
+                design_description.append(
+                    self._parse_simple_element(subelement))
+            elif subelement.tag == "todo":
+                todos.append(self._parse_simple_element(subelement))
+            elif subelement.tag == "issue":
+                issues.append(self._parse_issue(subelement))
+            else:
+                subelements.append(subelement)
+
+        params["description"] = description
+        params["design_description"] = design_description
+        params["issues"] = issues
+        params["todos"] = todos
+
+        return params, subelements, attrib
+
+    @staticmethod
+    def _parse_simple_element(element):
+        """Parse element as simple element and returns it's text.
+
+        Element is simple when it contains no subelements and attributes.
+
+        Returns element text if present or empty string if not
+
+        """
+        if len(element) != 0:
+            raise ParseError("Unexpected subelements in '" +
+                             element.tag + "'")
+        if len(element.attrib) != 0:
+            raise ParseError("Unexpected attributes in '" +
+                             element.tag + "'")
+        return element.text if element.text is not None else ""
+
+    @staticmethod
+    def _parse_issue(element):
+        """Parse element as issue.
+
+        Issue must not contain subelements and attributes.
+
+        Returns an instance of generator.Model.Issue
+
+        """
+        if len(element) != 0:
+            raise ParseError("Unexpected subelements in issue")
+        if "creator" not in element.attrib:
+            raise ParseError("No creator in issue")
+        if len(element.attrib) != 1:
+            raise ParseError("Unexpected attributes in issue")
+
+        return Model.Issue(
+            creator=element.attrib["creator"],
+            value=element.text if element.text is not None else "")
+
+    def _parse_enum_element(self, element):
+        """Parse element as element of enumeration.
+
+        Returns an instance of generator.Model.EnumElement
+
+        """
+        params, subelements, attributes = self._parse_base_item(element, "")
+
+        if len(subelements) != 0:
+            raise ParseError("Unexpected subelements in enum element")
+
+        self._ignore_attribute(attributes, "hexvalue")
+        self._ignore_attribute(attributes, "scope")
+        self._ignore_attribute(attributes, "rootscreen")
+
+        internal_name = None
+        value = None
+        for attribute in attributes:
+            if attribute == "internal_name":
+                internal_name = attributes[attribute]
+            elif attribute == "value":
+                try:
+                    value = int(attributes[attribute])
+                except:
+                    raise ParseError("Invalid value for enum element: '" +
+                                     attributes[attribute] + "'")
+        params["internal_name"] = internal_name
+        params["value"] = value
+
+        # Magic usage is correct
+        # pylint: disable=W0142
+        return Model.EnumElement(**params)
+
+    def _parse_param(self, element, prefix):
+        """Parse element as structure parameter.
+
+        Returns an instance of generator.Model.Param
+
+        """
+        params, subelements, attrib = \
+            self._parse_param_base_item(element, prefix)
+
+        if len(attrib) != 0:
+            raise ParseError("""Unknown attribute(s) {0} in param {1}
+                """.format(attrib, params["name"]))
+
+        if len(subelements) != 0:
+            raise ParseError("Unknown subelements in param '" +
+                             params["name"] + "'")
+
+        # Magic usage is correct
+        # pylint: disable=W0142
+        return Model.Param(**params)
+
+    def _parse_function_param(self, element, prefix):
+        """Parse element as function parameter.
+
+        Returns an instance of generator.Model.FunctionParam
+
+        """
+        params, subelements, attrib = \
+            self._parse_param_base_item(element, prefix)
+
+        default_value = None
+        default_value_string = self._extract_attrib(attrib, "defvalue")
+        if default_value_string is not None:
+            param_type = params["param_type"]
+            if type(param_type) is Model.Boolean:
+                default_value = \
+                    self._get_bool_from_string(default_value_string)
+            elif type(param_type) is Model.Integer:
+                try:
+                    default_value = int(default_value_string)
+                except:
+                    raise ParseError("Invalid value for integer: '" +
+                                     default_value_string + "'")
+            elif type(param_type) is Model.Double:
+                try:
+                    default_value = float(default_value_string)
+                except:
+                    raise ParseError("Invalid value for float: '" +
+                                     default_value_string + "'")
+            elif type(param_type) is Model.String:
+                default_value = default_value_string
+            elif type(param_type) is Model.Enum or \
+                    type(param_type) is Model.EnumSubset:
+                if type(param_type) is Model.EnumSubset:
+                    allowed_elements = param_type.allowed_elements
+                else:
+                    allowed_elements = param_type.elements
+                if default_value_string not in allowed_elements:
+                    raise ParseError("Default value '" + default_value_string +
+                                     "' for parameter '" + params["name"] +
+                                     "' is not a member of " +
+                                     type(param_type).__name__ +
+                                     "'" + params["name"] + "'")
+                default_value = allowed_elements[default_value_string]
+            else:
+                raise ParseError("Default value specified for " +
+                                 type(param_type).__name__)
+        params["default_value"] = default_value
+
+        if len(attrib) != 0:
+            raise ParseError("Unexpected attributes in parameter '" +
+                             params["name"] + "'")
+
+        if len(subelements) != 0:
+            raise ParseError("Unexpected subelements in parameter '" +
+                             params["name"] + "'")
+
+        # Magic usage is correct
+        # pylint: disable=W0142
+        return Model.FunctionParam(**params)
+
+    def _parse_param_base_item(self, element, prefix):
+        """Parse base param items.
+
+        Returns params, other subelements and attributes.
+
+        """
+        params, subelements, attrib = self._parse_base_item(element, "")
+
+        params["is_mandatory"] = self._extract_optional_bool_attrib(
+            attrib, "mandatory", True)
+
+        scope = self._extract_attrib(attrib, "scope")
+        if scope is not None:
+            params["scope"] = scope
+
+        default_value = None;
+        param_type = None
+        type_name = self._extract_attrib(attrib, "type")
+        if type_name is None:
+            raise ParseError("Type is not specified for parameter '" +
+                             params["name"] + "'")
+        if type_name == "Boolean":
+            default_value = self._extract_attrib(
+                attrib, "defvalue")
+            if default_value != None:
+                default_value = self._get_bool_from_string(default_value);
+            param_type = Model.Boolean(default_value=default_value)
+        elif type_name == "Integer" or \
+                type_name == "Float":
+            min_value = self._extract_optional_number_attrib(
+                attrib, "minvalue", int if type_name == "Integer" else float)
+            max_value = self._extract_optional_number_attrib(
+                attrib, "maxvalue", int if type_name == "Integer" else float)
+            default_value = self._extract_optional_number_attrib(
+                attrib, "defvalue", int if type_name == "Integer" else float)
+
+            param_type = \
+                (Model.Integer if type_name == "Integer" else Model.Double)(
+                    min_value=min_value,
+                    max_value=max_value,
+                    default_value=default_value)
+        elif type_name == "String":
+            min_length = self._extract_optional_number_attrib(
+                attrib, "minlength")
+            # if minlength is not defined default value is 1
+            if min_length is None:
+                min_length = 1
+            max_length = self._extract_optional_number_attrib(
+                attrib, "maxlength")
+            default_value = self._extract_attrib(attrib, "defvalue")
+            param_type = Model.String(min_length=min_length, max_length=max_length, default_value=default_value)
+        else:
+            if 1 == type_name.count("."):
+                custom_type_name = type_name.replace(".", "_")
+            else:
+                custom_type_name = prefix + type_name
+
+            if custom_type_name in self._types:
+                param_type = self._types[custom_type_name]
+                default_value = self._extract_attrib(attrib, "defvalue")
+                if default_value != None:
+                    if default_value not in param_type.elements:
+                        raise ParseError("Default value '" + default_value +
+                                     "' for parameter '" + params["name"] +
+                                     "' is not a member of " +
+                                     type(param_type).__name__ +
+                                     "'" + params["name"] + "'")
+                    default_value = param_type.elements[default_value]
+            else:
+                raise ParseError("Unknown type '" + type_name + "'")
+
+        if self._extract_optional_bool_attrib(attrib, "array", False):
+            min_size = self._extract_optional_number_attrib(attrib,
+                                                            "minsize")
+            max_size = self._extract_optional_number_attrib(attrib,
+                                                            "maxsize")
+            param_type = Model.Array(element_type=param_type,
+                                     min_size=min_size,
+                                     max_size=max_size)
+            
+        base_type = \
+            param_type.element_type if isinstance(param_type, Model.Array) \
+            else param_type
+
+        other_subelements = []
+        for subelement in subelements:
+            if subelement.tag == "element":
+                if type(base_type) is not Model.Enum and \
+                   type(base_type) is not Model.EnumSubset:
+                    raise ParseError("Elements specified for parameter '" +
+                                     params["name"] + "' of type " +
+                                     type(base_type).__name__)
+                if type(base_type) is Model.Enum:
+                    base_type = Model.EnumSubset(
+                        name=params["name"],
+                        enum=base_type,
+                        description=params["description"],
+                        design_description=params["design_description"],
+                        issues=params["issues"],
+                        todos=params["todos"],
+                        allowed_elements={})
+                if "name" not in subelement.attrib:
+                    raise ParseError(
+                        "Element name is not specified for parameter '" +
+                        params["name"] + "'")
+                element_name = subelement.attrib["name"]
+                if len(subelement.attrib) != 1:
+                    raise ParseError("Unexpected attributes for element '" +
+                                     element_name + "' of parameter '" +
+                                     params["name"])
+                if len(subelement.getchildren()) != 0:
+                    raise ParseError("Unexpected subelements for element '" +
+                                     element_name + "' of parameter '" +
+                                     params["name"])
+                if element_name in base_type.allowed_elements:
+                    raise ParseError("Element '" + element_name +
+                                     "' is specified more than once for" +
+                                     " parameter '" + params["name"] + "'")
+                if element_name not in base_type.enum.elements:
+                    raise ParseError("Element '" + element_name +
+                                     "' is not a member of enum '" +
+                                     base_type.enum.name + "'")
+                base_type.allowed_elements[element_name] = \
+                    base_type.enum.elements[element_name]
+            else:
+                other_subelements.append(subelement)
+
+        if isinstance(param_type, Model.Array):
+            param_type.element_type = base_type
+        else:
+            param_type = base_type
+
+        params["param_type"] = param_type
+        if default_value is not None:
+            params["default_value"] = default_value
+
+        return params, other_subelements, attrib
+
+    def _extract_optional_bool_attrib(self, attrib, name, default):
+        """Extract boolean attribute with given name.
+
+        Returns value of the attribute.
+
+        """
+        value = self._extract_attrib(attrib, name)
+
+        if value is None:
+            value = default
+        else:
+            value = self._get_bool_from_string(value)
+
+        return value
+
+    def _extract_optional_number_attrib(self, attrib, name, _type=int):
+        """Extract number attribute with given name.
+
+        Returns value of the attribute.
+
+        """
+        value = self._extract_attrib(attrib, name)
+
+        if value is not None:
+            try:
+                value = _type(value)
+            except:
+                raise ParseError("Invlaid value for " + _type.__name__ +
+                                 ": '" + value + "'")
+
+        return value
+
+    @staticmethod
+    def _extract_attrib(attrib, name):
+        """Extract attribute with given name.
+
+        Returns value of the attribute.
+
+        """
+        value = None
+
+        if name in attrib:
+            value = attrib[name]
+            del attrib[name]
+
+        return value
+
+    @staticmethod
+    def _get_bool_from_string(bool_string):
+        """Convert string representation of boolean to real bool value.
+
+        Returns converted value.
+
+        """
+        value = None
+
+        if bool_string in ['0', 'false']:
+            value = False
+        elif bool_string in ['1', 'true']:
+            value = True
+        else:
+            raise ParseError("Invalid value for bool: '" +
+                             bool_string + "'")
+
+        return value
+
+    def _ignore_attribute(self, attrib, name):
+        """To be called when attribute is meaningless in terms
+        of code generation but it's presence is not issue.
+
+        Removes this attribute from attribute list.
+
+        """
+        if name in attrib:
+            del attrib[name]
+            print ("Ignoring attribute '" +
+                   name + "'")
+        return True
diff --git a/tools/InterfaceGenerator/generator/parsers/SDLRPCV1.py b/tools/InterfaceGenerator/generator/parsers/SDLRPCV1.py
new file mode 100755
index 000000000..52158ee93
--- /dev/null
+++ b/tools/InterfaceGenerator/generator/parsers/SDLRPCV1.py
@@ -0,0 +1,14 @@
+"""SDLRPCV1 parser.
+
+Contains parser for SDLRPCV1 XML format.
+
+"""
+
+from generator.parsers import RPCBase
+
+
+class Parser(RPCBase.Parser):
+
+    """SDLRPCV1 parser."""
+
+    pass
diff --git a/tools/InterfaceGenerator/generator/parsers/SDLRPCV2.py b/tools/InterfaceGenerator/generator/parsers/SDLRPCV2.py
new file mode 100755
index 000000000..3d67c6e4c
--- /dev/null
+++ b/tools/InterfaceGenerator/generator/parsers/SDLRPCV2.py
@@ -0,0 +1,88 @@
+"""SDLRPCV2 parser.
+
+Contains parser for SDLRPCV2 XML format.
+
+"""
+
+import collections
+
+from generator import Model
+from generator.parsers import RPCBase
+
+
+class Parser(RPCBase.Parser):
+
+    """SDLRPCV2 parser."""
+
+    def _initialize_enums(self):
+        """Initialize enums.
+
+        This implementation returns empty OrderedDict because in SDLRPCV2
+        all enums must be declared explicitly in the XML file.
+
+        """
+        return collections.OrderedDict()
+
+    def _check_enum_name(self, enum):
+        """Check enum name.
+
+        This method is called to check whether the newly parsed enum's name
+        conflicts with some predefined enum.
+        As SDLRPCV2 has no predefined enums this implementation does nothing.
+
+        """
+        pass
+
+    def _parse_function_id_type(self, function_name, attrib):
+        """Parse function id and message type according to XML format.
+
+        This implementation extracts attribute "FunctionID" as function id
+        and messagetype as message type and searches them in enums
+        "FunctionID" and "messageType". If at least one of them (or the entire
+        enum) is missing it raises an error.
+
+        Returns function id and message type as an instances of EnumElement.
+
+        """
+        if "functionID" not in attrib:
+            raise RPCBase.ParseError(
+                "No functionID specified for function '" +
+                function_name + "'")
+
+        if "messagetype" not in attrib:
+            raise RPCBase.ParseError(
+                "No messagetype specified for function '" +
+                function_name + "'")
+
+        function_id = self._get_enum_element_for_function(
+            "FunctionID",
+            self._extract_attrib(attrib, "functionID"))
+        message_type = self._get_enum_element_for_function(
+            "messageType",
+            self._extract_attrib(attrib, "messagetype"))
+
+        return function_id, message_type
+
+    def _get_enum_element_for_function(self, enum_name, element_name):
+        """Get enum element with given name from given enumeration.
+
+        Returns an instance of generator.Model.EnumElement.
+
+        """
+        if enum_name not in self._types:
+            raise RPCBase.ParseError(
+                "Enumeration '" + enum_name +
+                "' must be declared before any function")
+
+        enum = self._types[enum_name]
+
+        if type(enum) is not Model.Enum:
+            raise RPCBase.ParseError("'" + enum_name +
+                                     "' is not an enumeration")
+
+        if element_name not in enum.elements:
+            raise RPCBase.ParseError(
+                "'" + element_name +
+                "' is not a member of enum '" + enum_name + "'")
+
+        return enum.elements[element_name]
diff --git a/tools/InterfaceGenerator/generator/parsers/__init__.py b/tools/InterfaceGenerator/generator/parsers/__init__.py
new file mode 100755
index 000000000..7005503b0
--- /dev/null
+++ b/tools/InterfaceGenerator/generator/parsers/__init__.py
@@ -0,0 +1,3 @@
+"""Package that contains parsers from different formats to internal model
+representation.
+"""
diff --git a/tools/InterfaceGenerator/pylint.cfg b/tools/InterfaceGenerator/pylint.cfg
new file mode 100644
index 000000000..44e23eb1b
--- /dev/null
+++ b/tools/InterfaceGenerator/pylint.cfg
@@ -0,0 +1,264 @@
+[MASTER]
+
+# Specify a configuration file.
+#rcfile=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+#init-hook=
+
+# Profiled execution.
+profile=no
+
+# Add files or directories to the blacklist. They should be base names, not
+# paths.
+ignore=CVS
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# List of plugins (as comma separated values of python modules names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+
+[MESSAGES CONTROL]
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time. See also the "--disable" option for examples.
+#enable=
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once).You can also use "--disable=all" to
+# disable everything first and then reenable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use"--disable=all --enable=classes
+# --disable=W"
+#disable=
+
+
+[REPORTS]
+
+# Set the output format. Available formats are text, parseable, colorized, msvs
+# (visual studio) and html. You can also give a reporter class, eg
+# mypackage.mymodule.MyReporterClass.
+output-format=colorized
+
+# Include message's id in output
+include-ids=yes
+
+# Include symbolic ids of messages in output
+symbols=no
+
+# Put messages in a separate file for each module / package specified on the
+# command line instead of printing them on stdout. Reports (if any) will be
+# written in a file name "pylint_global.[txt|html]".
+files-output=no
+
+# Tells whether to display a full report or only the messages
+reports=no
+
+# Python expression which should return a note less than 10 (10 is the highest
+# note). You have access to the variables errors warning, statement which
+# respectively contain the number of errors / warnings messages and the total
+# number of statements analyzed. This is used by the global evaluation report
+# (RP0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Add a comment according to your evaluation note. This is used by the global
+# evaluation report (RP0004).
+comment=no
+
+
+[BASIC]
+
+# Required attributes for module, separated by a comma
+required-attributes=
+
+# List of builtins function names that should not be used, separated by a comma
+bad-functions=map,filter,apply,input
+
+# Regular expression which should only match correct module names
+module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Regular expression which should only match correct module level names
+const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+
+# Regular expression which should only match correct class names
+class-rgx=[A-Z_][a-zA-Z0-9]+$
+
+# Regular expression which should only match correct function names
+function-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression which should only match correct method names
+method-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression which should only match correct instance attribute names
+attr-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression which should only match correct argument names
+argument-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression which should only match correct variable names
+variable-rgx=[a-z_][a-z0-9_]{2,30}$
+
+# Regular expression which should only match correct list comprehension /
+# generator expression variable names
+inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
+
+# Good variable names which should always be accepted, separated by a comma
+good-names=i,j,k,ex,Run,_
+
+# Bad variable names which should always be refused, separated by a comma
+bad-names=foo,bar,baz,toto,tutu,tata
+
+# Regular expression which should only match functions or classes name which do
+# not require a docstring
+no-docstring-rgx=__.*__
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,XXX,TODO
+
+
+[SIMILARITIES]
+
+# Minimum lines number of a similarity.
+min-similarity-lines=4
+
+# Ignore comments when computing similarities.
+ignore-comments=no
+
+# Ignore docstrings when computing similarities.
+ignore-docstrings=no
+
+# Ignore imports when computing similarities.
+ignore-imports=no
+
+
+[TYPECHECK]
+
+# Tells whether missing members accessed in mixin class should be ignored. A
+# mixin class is detected if its name ends with "mixin" (case insensitive).
+ignore-mixin-members=yes
+
+# List of classes names for which member attributes should not be checked
+# (useful for classes with attributes dynamically set).
+ignored-classes=SQLObject
+
+# When zope mode is activated, add a predefined set of Zope acquired attributes
+# to generated-members.
+zope=no
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E0201 when accessed. Python regular
+# expressions are accepted.
+generated-members=REQUEST,acl_users,aq_parent
+
+
+[VARIABLES]
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# A regular expression matching the beginning of the name of dummy variables
+# (i.e. not used).
+dummy-variables-rgx=_|dummy
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid to define new builtins when possible.
+additional-builtins=
+
+
+[FORMAT]
+
+# Maximum number of characters on a single line.
+max-line-length=80
+
+# Maximum number of lines in a module
+max-module-lines=1000
+
+# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
+# tab).
+indent-string='    '
+
+
+[IMPORTS]
+
+# Deprecated modules which should not be used, separated by a comma
+deprecated-modules=regsub,string,TERMIOS,Bastion,rexec
+
+# Create a graph of every (i.e. internal and external) dependencies in the
+# given file (report RP0402 must not be disabled)
+import-graph=
+
+# Create a graph of external dependencies in the given file (report RP0402 must
+# not be disabled)
+ext-import-graph=
+
+# Create a graph of internal dependencies in the given file (report RP0402 must
+# not be disabled)
+int-import-graph=
+
+
+[CLASSES]
+
+# List of interface methods to ignore, separated by a comma. This is used for
+# instance to not check methods defines in Zope's Interface base class.
+ignore-iface-methods=isImplementedBy,deferred,extends,names,namesAndDescriptions,queryDescriptionFor,getBases,getDescriptionFor,getDoc,getName,getTaggedValue,getTaggedValueTags,isEqualOrExtendedBy,setTaggedValue,isImplementedByInstancesOf,adaptWith,is_implemented_by
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,__new__,setUp
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=mcs
+
+
+[DESIGN]
+
+# Maximum number of arguments for function / method
+max-args=10
+
+# Argument names that match this expression will be ignored. Default to name
+# with leading underscore
+ignored-argument-names=_.*
+
+# Maximum number of locals for function / method body
+max-locals=15
+
+# Maximum number of return / yield for function / method body
+max-returns=6
+
+# Maximum number of branch for function / method body
+max-branchs=12
+
+# Maximum number of statements in function / method body
+max-statements=50
+
+# Maximum number of parents for a class (see R0901).
+max-parents=7
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=1
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when being caught. Defaults to
+# "Exception"
+overgeneral-exceptions=Exception
diff --git a/tools/InterfaceGenerator/requirements.txt b/tools/InterfaceGenerator/requirements.txt
new file mode 100644
index 000000000..af21f6cb9
--- /dev/null
+++ b/tools/InterfaceGenerator/requirements.txt
@@ -0,0 +1,6 @@
+flake8
+pep8-naming
+pep257
+mccabe
+pylint
+mock
\ No newline at end of file
diff --git a/tools/InterfaceGenerator/runAllTests.sh b/tools/InterfaceGenerator/runAllTests.sh
new file mode 100755
index 000000000..ab5b7c82c
--- /dev/null
+++ b/tools/InterfaceGenerator/runAllTests.sh
@@ -0,0 +1 @@
+python -m unittest discover -b
\ No newline at end of file
diff --git a/tools/InterfaceGenerator/test/__init__.py b/tools/InterfaceGenerator/test/__init__.py
new file mode 100755
index 000000000..e69de29bb
--- /dev/null
+++ b/tools/InterfaceGenerator/test/__init__.py
diff --git a/tools/InterfaceGenerator/test/generator/__init__.py b/tools/InterfaceGenerator/test/generator/__init__.py
new file mode 100755
index 000000000..e69de29bb
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/__init__.py
diff --git a/tools/InterfaceGenerator/test/generator/generators/__init__.py b/tools/InterfaceGenerator/test/generator/generators/__init__.py
new file mode 100755
index 000000000..e69de29bb
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/__init__.py
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryBase.py b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryBase.py
new file mode 100755
index 000000000..aea91f4a4
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryBase.py
@@ -0,0 +1,283 @@
+"""Test for SmartFactory generator base.
+
+Verifies common helper functions and produced source code.
+
+"""
+import collections
+import unittest
+
+from generator.generators import SmartFactoryBase
+from generator import Model
+
+
+EXPECTED_RESULT_FULL_COMMENT = u"""/**
+ * @brief Enumeration Test Name.
+ *
+ * Description Line1
+ * Description Line2
+ *
+ * Design Line1
+ *
+ * @note Issue1
+ * @note Issue2
+ * @note Issue3
+ *
+ * @todo Do1
+ * @todo Do2
+ */"""
+
+EXPECTED_RESULT_ENUM_ELEMENT1 = u"""/**
+ * @brief InternalName.
+ */
+InternalName = 10"""
+
+EXPECTED_RESULT_ENUM_ELEMENT2 = u"""/**
+ * @brief NO_VALUE_ELEMENT.
+ *
+ * Description Line1
+ * Description Line2
+ *
+ * Design Line1
+ */
+NO_VALUE_ELEMENT"""
+
+EXPECTED_RESULT_ENUM_ELEMENTS1 = u"""/**
+ * @brief name1.
+ *
+ * Design Line1
+ *
+ * @todo Do1
+ * @todo Do2
+ */
+name1 = 1,
+
+/**
+ * @brief internal_name2.
+ *
+ * Description Line1
+ * Description Line2
+ *
+ * @note Issue1
+ * @note Issue2
+ * @note Issue3
+ */
+internal_name2"""
+
+EXPECTED_RESULT_ENUM1 = u"""namespace Enum1 {
+/**
+ * @brief Enumeration Enum1.
+ *
+ * @todo Do1
+ * @todo Do2
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief name1.
+   *
+   * Design Line1
+   *
+   * @todo Do1
+   * @todo Do2
+   */
+  name1 = 1,
+
+  /**
+   * @brief internal_name2.
+   *
+   * Description Line1
+   * Description Line2
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  internal_name2
+};
+} // Enum1
+"""
+
+EXPECTED_RESULT_ENUM2 = u"""namespace E2 {
+/**
+ * @brief Enumeration E2.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief val_1.
+   */
+  val_1,
+
+  /**
+   * @brief val_2.
+   */
+  val_2 = 100,
+
+  /**
+   * @brief val_3.
+   */
+  val_3
+};
+} // E2
+"""
+
+DESCRIPTION = [u"Description Line1", u"Description Line2"]
+
+DESIGN_DESCRIPTION = [u"Design Line1"]
+
+ISSUES = [Model.Issue(value=u"Issue1"),
+          Model.Issue(value=u"Issue2"),
+          Model.Issue(value=u"Issue3")]
+
+TODOS = [u"Do1", u"Do2"]
+
+
+class Test(unittest.TestCase):
+
+    """Test for SmartFactory base generator.
+
+    This class holds set of test cases for the SmartFactory base generator.
+
+    """
+
+    def test_gen_comment(self):
+        """Test generation of the source code comments.
+
+        Verifies correct generation of the code comments.
+
+        """
+        generator = SmartFactoryBase.CodeGenerator()
+
+        enum = Model.Enum(name=u"Test Name",
+                          description=DESCRIPTION,
+                          design_description=DESIGN_DESCRIPTION,
+                          issues=ISSUES,
+                          todos=TODOS)
+        self.assertEqual(generator._gen_comment(enum),
+                         EXPECTED_RESULT_FULL_COMMENT,
+                         "Full comment for enum is invalid")
+
+    def test_gen_enum_element(self):
+        """Test generation of the single enum element.
+
+        Verifies correct generation of the single enum element.
+
+        """
+        generator = SmartFactoryBase.CodeGenerator()
+
+        enum_element1 = Model.EnumElement(name=u"Element1",
+                                          internal_name=u"InternalName",
+                                          value=u"10")
+
+        self.assertEqual(
+            generator._gen_enum_element(enum_element1),
+            EXPECTED_RESULT_ENUM_ELEMENT1,
+            "Short commented enum element with internal name is invalid")
+
+        enum_element2 = Model.EnumElement(
+            name=u"NO_VALUE_ELEMENT",
+            description=DESCRIPTION,
+            design_description=DESIGN_DESCRIPTION)
+        self.assertEqual(generator._gen_enum_element(enum_element2),
+                         EXPECTED_RESULT_ENUM_ELEMENT2,
+                         "Enum element with no value is invalid")
+
+    def test_gen_enum_elements(self):
+        """Test generation of the enum elements.
+
+        Verifies correct generation of the enum elements.
+
+        """
+        generator = SmartFactoryBase.CodeGenerator()
+
+        elements = [Model.EnumElement(name=u"name1",
+                                      design_description=DESIGN_DESCRIPTION,
+                                      todos=TODOS,
+                                      value=u"1"),
+                    Model.EnumElement(name=u"name2",
+                                      description=DESCRIPTION,
+                                      issues=ISSUES,
+                                      internal_name=u"internal_name2")]
+        self.assertEqual(generator._gen_enum_elements(elements),
+                         EXPECTED_RESULT_ENUM_ELEMENTS1,
+                         "Simple enum elements are invalid")
+
+    def test_gen_enum(self):
+        """Test generation of the enum.
+
+        Verifies correct generation of the enum.
+
+        """
+        generator = SmartFactoryBase.CodeGenerator()
+
+        elements1 = collections.OrderedDict()
+        elements1[u"name1"] = Model.EnumElement(
+            name=u"name1",
+            design_description=DESIGN_DESCRIPTION,
+            todos=TODOS,
+            value=u"1")
+        elements1[u"name2"] = Model.EnumElement(
+            name=u"name2",
+            description=DESCRIPTION,
+            issues=ISSUES,
+            internal_name=u"internal_name2")
+
+        enum1 = Model.Enum(name=u"Enum1",
+                           todos=TODOS,
+                           elements=elements1)
+
+        self.assertEqual(generator._gen_enum(enum1),
+                         EXPECTED_RESULT_ENUM1,
+                         "Simple enum is invalid")
+
+        elements2 = collections.OrderedDict()
+        elements2[u"xxx"] = Model.EnumElement(name=u"xxx",
+                                              internal_name=u"val_1")
+        elements2[u"yyy"] = Model.EnumElement(name=u"yyy",
+                                              internal_name=u"val_2",
+                                              value=u"100")
+        elements2[u"zzz"] = Model.EnumElement(name=u"val_3")
+
+        enum2 = Model.Enum(name=u"E2",
+                           elements=elements2)
+        self.assertEqual(generator._gen_enum(enum2),
+                         EXPECTED_RESULT_ENUM2,
+                         "Long enum is invalid")
+
+        self.assertEqual(generator._gen_enums([enum1, enum2],
+                                              collections.OrderedDict()),
+                         u"{0}\n{1}".format(EXPECTED_RESULT_ENUM1,
+                                            EXPECTED_RESULT_ENUM2),
+                         "Generated enums are invalid")
+
+    def test_normalize_multiline_comments(self):
+        """Test normalization of the multiline comments.
+
+        Verifies correct normalization of the multiline comments.
+
+        """
+        generator = SmartFactoryBase.CodeGenerator()
+
+        self.assertEqual(generator._normalize_multiline_comments([]), [])
+
+        self.assertEqual(generator._normalize_multiline_comments(["aaa",
+                                                                  "bbb",
+                                                                  "ccc ccc",
+                                                                  "ddd\tddd"]),
+                         ["aaa", "bbb", "ccc ccc", "ddd\tddd"])
+        self.assertEqual(generator._normalize_multiline_comments(["aaa\n1",
+                                                                  "bbb\r\n2",
+                                                                  "ccc\r3",
+                                                                  "aaa aaa"]),
+                         ["aaa", "1", "bbb", "2", "ccc", "3", "aaa aaa"])
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py
new file mode 100755
index 000000000..b21e32003
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py
@@ -0,0 +1,482 @@
+"""Test for JSONRPC SmartFactory generator.
+
+Verifies format specific functions and produced source code.
+
+"""
+import collections
+import codecs
+import os
+import unittest
+import uuid
+
+from mock import MagicMock
+from mock import call
+
+from generator.generators import SmartFactoryJSONRPC
+from generator import Model
+
+
+EXPECTED_RESULT_REQUEST = (
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<FunctionID::eType>::create("""
+    u"""function_id_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<messageType::eType>::create("""
+    u"""message_type_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+)
+
+EXPECTED_RESULT_RESPONSE = (
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<FunctionID::eType>::create("""
+    u"""function_id_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<messageType::eType>::create("""
+    u"""message_type_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::kCode] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+)
+
+EXPECTED_RESULT_NOTIFICATION = (
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<FunctionID::eType>::create("""
+    u"""function_id_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<messageType::eType>::create("""
+    u"""message_type_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+)
+
+EXPECTED_PRE_FUNCTION_CODE = (
+    u"""  std::map<std::string, CObjectSchemaItem::SMember> """
+    u"""params_members;\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<FunctionID::eType>::create("""
+    u"""function_id_items), true);\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<messageType::eType>::create("""
+    u"""message_type_items), true);\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler"""
+    u"""::strings::kCode] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""  params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::kMessage] = CObjectSchemaItem::SMember("""
+    u"""CStringSchemaItem::create(), true);\n"""
+    u"""\n"""
+    u"""  std::map<std::string, CObjectSchemaItem::SMember> """
+    u"""root_members_map;\n"""
+    u"""  root_members_map[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PARAMS] = CObjectSchemaItem::SMember("""
+    u"""CObjectSchemaItem::create(params_members), true);\n"""
+    u"""\n"""
+    u"""  CSmartSchema error_response_schema(CObjectSchemaItem::create("""
+    u"""root_members_map));\n"""
+    u"""\n"""
+    u"""  functions_schemes_.insert(std::make_pair("""
+    u"""NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<"""
+    u"""FunctionID::eType, messageType::eType>("""
+    u"""FunctionID::request, messageType::error_response)"""
+    u""", error_response_schema));\n"""
+    u"""\n"""
+)
+
+DESCRIPTION = [u"Description Line1", u"Description Line2"]
+
+DESIGN_DESCRIPTION = [u"Design Line1"]
+
+ISSUES = [Model.Issue(value=u"Issue1"),
+          Model.Issue(value=u"Issue2"),
+          Model.Issue(value=u"Issue3")]
+
+TODOS = [u"Do1", u"Do2"]
+
+
+class Test(unittest.TestCase):
+
+    """Test for JSONRPC SmartFactory generator.
+
+    This class holds set of test cases for the JSONRPC SmartFactory generator.
+
+    """
+
+    def test_gen_schema_params_fill(self):
+        """Test feature that allows to create format specific PARAMS.
+
+        Verifies JSONRPC implementation of the _gen_schema_params_fill
+        method.
+
+        """
+        generator = SmartFactoryJSONRPC.CodeGenerator()
+
+        self.assertEqual(generator._gen_schema_params_fill("request"),
+                         EXPECTED_RESULT_REQUEST,
+                         "Invalid code generation for request")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"request"),
+                         EXPECTED_RESULT_REQUEST,
+                         "Invalid code generation for request")
+
+        self.assertEqual(generator._gen_schema_params_fill("response"),
+                         EXPECTED_RESULT_RESPONSE,
+                         "Invalid code generation for response")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"response"),
+                         EXPECTED_RESULT_RESPONSE,
+                         "Invalid code generation for response")
+
+        self.assertEqual(generator._gen_schema_params_fill("notification"),
+                         EXPECTED_RESULT_NOTIFICATION,
+                         "Invalid code generation for notification")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"notification"),
+                         EXPECTED_RESULT_NOTIFICATION,
+                         "Invalid code generation for notification")
+
+    def test_preprocess_message_type(self):
+        """Test preprocessing of the message_type enum.
+
+        Verifies JSONPRC implementation of the _preprocess_message_type
+        function.
+
+        """
+
+        generator = SmartFactoryJSONRPC.CodeGenerator()
+
+        message_type_elements = collections.OrderedDict()
+        message_type_elements[u"request"] = Model.EnumElement(name=u"request")
+        message_type_elements[u"response"] = Model.EnumElement(
+            name=u"response")
+        message_type_elements[u"notification"] = Model.EnumElement(
+            name=u"notification")
+
+        message_type = Model.Enum(name=u"messageType",
+                                  elements=message_type_elements)
+
+        result_enum = generator._preprocess_message_type(message_type)
+
+        self.assertIn("error_response", result_enum.elements)
+        self.assertEqual("error_response",
+                         result_enum.elements["error_response"].primary_name)
+
+        message_type_elements = collections.OrderedDict()
+        message_type_elements[u"request"] = Model.EnumElement(name=u"request")
+        message_type_elements[u"notification"] = Model.EnumElement(
+            name=u"notification")
+
+        message_type = Model.Enum(name=u"messageType",
+                                  elements=message_type_elements)
+
+        result_enum = generator._preprocess_message_type(message_type)
+
+        self.assertNotIn("error_response", result_enum.elements)
+
+    def test_gen_pre_function_schemas(self):
+        """Test code that goes before schema initialization.
+
+        Verifies JSONPRC implementation of the _gen_pre_function_schemas
+        function.
+
+        """
+
+        generator = SmartFactoryJSONRPC.CodeGenerator()
+
+        self.assertEqual(u"",
+                         generator._gen_pre_function_schemas([]),
+                         "Invalid code for empty functions list")
+
+        message_type_elements = collections.OrderedDict()
+        message_type_elements[u"request"] = Model.EnumElement(name=u"request")
+        message_type_elements[u"response"] = Model.EnumElement(
+            name=u"response")
+        message_type_elements[u"notification"] = Model.EnumElement(
+            name=u"notification")
+
+        message_type = Model.Enum(name=u"messageType",
+                                  elements=message_type_elements)
+
+        function1 = Model.Function(
+            "func1", function_id=message_type.elements[u"request"],
+            message_type=message_type.elements[u"request"])
+
+        self.assertEqual(u"",
+                         generator._gen_pre_function_schemas([function1]),
+                         "Invalid code for empty functions list")
+
+        function2 = Model.Function(
+            "func2", function_id=message_type.elements[u"request"],
+            message_type=message_type.elements[u"response"])
+
+        self.assertEqual(EXPECTED_PRE_FUNCTION_CODE,
+                         generator._gen_pre_function_schemas([function2]),
+                         "Invalid code for single response function")
+
+        self.assertEqual(EXPECTED_PRE_FUNCTION_CODE,
+                         generator._gen_pre_function_schemas([function1,
+                                                              function2]),
+                         "Invalid code for mixed function list")
+
+    def test_full_generation(self):
+        """Test full generation using JSONRPC SmartSchema generator.
+
+        Creates output files which is captured by the mock and compare them
+        with sample files with correct code. This test requires valid
+        test_expected_jsonrpc.h and test_expected_jsonrpc.cc in the same
+        directory as this module.
+
+        """
+
+        expected_h_file_content = open("test_expected_jsonrpc.h", "r").read()
+        expected_cc_file_content = open("test_expected_jsonrpc.cc", "r").read()
+
+        generator = SmartFactoryJSONRPC.CodeGenerator()
+
+        message_type_elements = collections.OrderedDict()
+        message_type_elements[u"request"] = Model.EnumElement(name=u"request")
+        message_type_elements[u"response"] = Model.EnumElement(
+            name=u"response")
+        message_type_elements[u"notification"] = Model.EnumElement(
+            name=u"notification")
+
+        message_type = Model.Enum(name=u"messageType",
+                                  elements=message_type_elements)
+
+        elements1 = collections.OrderedDict()
+        elements1[u"name1"] = Model.EnumElement(
+            name=u"name1",
+            design_description=DESIGN_DESCRIPTION,
+            todos=TODOS,
+            value=u"1")
+        elements1[u"name2"] = Model.EnumElement(
+            name="name2",
+            description=DESCRIPTION,
+            issues=ISSUES,
+            internal_name=u"internal_name2")
+
+        enum1 = Model.Enum(name=u"Enum1",
+                           todos=TODOS,
+                           elements=elements1)
+
+        elements2 = collections.OrderedDict()
+        elements2[u"xxx"] = Model.EnumElement(name=u"xxx",
+                                              internal_name=u"val_1")
+        elements2[u"yyy"] = Model.EnumElement(name=u"yyy",
+                                              internal_name=u"val_2",
+                                              value=u"100")
+        elements2[u"zzz"] = Model.EnumElement(name=u"val_3")
+
+        enum2 = Model.Enum(name=u"E2",
+                           elements=elements2)
+
+        elements3 = collections.OrderedDict()
+        elements3["1"] = Model.EnumElement(name="xxx",
+                                           internal_name="_1")
+        elements3["2"] = Model.EnumElement(name="xxx",
+                                           internal_name="_2")
+        elements3["3"] = Model.EnumElement(name="xxx",
+                                           internal_name="_3")
+        enum3 = Model.Enum(name="Enum_new2",
+                           elements=elements3)
+
+        elements4 = collections.OrderedDict()
+        elements4["name1"] = Model.EnumElement(name="xxx",
+                                               internal_name="_11")
+        elements4["name2"] = Model.EnumElement(name="xxx",
+                                               internal_name="_22")
+        enum4 = Model.Enum(name="Enum_new4",
+                           elements=elements4)
+
+        enums = collections.OrderedDict()
+        enums["Enum1"] = enum1
+        enums["Enum2"] = enum2
+        enums["Enum3"] = enum3
+        enums["Enum4"] = enum4
+        enums["messageType"] = message_type
+
+        params1 = collections.OrderedDict()
+        params1["1"] = Model.FunctionParam(
+            name="param1",
+            design_description=DESIGN_DESCRIPTION,
+            description=DESCRIPTION,
+            issues=ISSUES,
+            todos=TODOS,
+            param_type=enum4,
+            default_value=elements4["name1"])
+        params1["2"] = Model.FunctionParam(
+            name="param2",
+            param_type=Model.EnumSubset(
+                name="sub1",
+                enum=enum1,
+                allowed_elements={"e1": elements1["name1"]}),
+            default_value=elements1["name1"])
+
+        functions = collections.OrderedDict()
+        functions["Function1"] = Model.Function(
+            name="Function1",
+            function_id=elements1["name1"],
+            message_type=message_type_elements["request"],
+            params=params1)
+        functions["Function2"] = Model.Function(
+            name="Function2",
+            function_id=elements2["xxx"],
+            message_type=message_type_elements["response"])
+        functions["Function3"] = Model.Function(
+            name="Function2",
+            function_id=elements2["yyy"],
+            message_type=message_type_elements["notification"])
+
+        members1 = collections.OrderedDict()
+        members1["m1"] = Model.Param(name="intParam",
+                                     param_type=Model.Integer(max_value=2))
+        members1["m11"] = Model.Param(name="doubleParam",
+                                      param_type=Model.Double(min_value=0.333),
+                                      is_mandatory=False)
+        members1["m222"] = Model.Param(name="boolParam",
+                                       param_type=Model.Boolean())
+        members1["m2"] = Model.Param(name="structParam",
+                                     param_type=Model.Struct(name="Struct2"))
+        members1["aaa"] = Model.Param(name="enumParam",
+                                      param_type=enum1)
+        members1["bbb"] = Model.Param(name="enumParam1",
+                                      param_type=enum1)
+        members1["xxx"] = Model.Param(
+            name="enumSubset1",
+            param_type=Model.EnumSubset(
+                name="sub",
+                enum=enum1,
+                allowed_elements={"e1": elements1["name1"]}),
+            is_mandatory=False)
+        members1["1"] = Model.Param(
+            name="arrayOfInt",
+            param_type=Model.Array(min_size=0,
+                                   max_size=20,
+                                   element_type=Model.Boolean()),
+            is_mandatory=False)
+        members1["2"] = Model.Param(
+            name="arrayOfEnum1",
+            param_type=Model.Array(min_size=0,
+                                   max_size=20,
+                                   element_type=enum1),
+            is_mandatory=False)
+        members1["3"] = Model.Param(
+            name="arrayOfEnum3",
+            param_type=Model.Array(min_size=10,
+                                   max_size=40,
+                                   element_type=enum3),
+            is_mandatory=True)
+        members1["4"] = Model.Param(
+            name="arrayOfEnum4",
+            param_type=Model.Array(
+                min_size=10,
+                max_size=41,
+                element_type=Model.EnumSubset(
+                    name="sub1",
+                    enum=enum1,
+                    allowed_elements={"e1": elements1["name1"]})))
+        members1["5"] = Model.Param(
+            name="arrayOfEnum5",
+            param_type=Model.Array(
+                min_size=10,
+                max_size=42,
+                element_type=Model.EnumSubset(
+                    name="sub2",
+                    enum=enum1,
+                    allowed_elements={"e1": elements1["name2"]})))
+        members1["6"] = Model.Param(
+            name="arrayOfEnum6",
+            param_type=Model.Array(
+                min_size=10,
+                max_size=43,
+                element_type=Model.EnumSubset(
+                    name="sub3",
+                    enum=enum4,
+                    allowed_elements={"e1": elements4["name2"]})))
+
+        structs = collections.OrderedDict()
+        structs["Struct1"] = Model.Struct(
+            name="Struct1",
+            design_description=DESIGN_DESCRIPTION,
+            issues=ISSUES,
+            members=members1)
+        structs["Struct2"] = Model.Struct(name="Struct2",
+                                          issues=ISSUES)
+
+        interface = Model.Interface(enums=enums,
+                                    structs=structs,
+                                    functions=functions,
+                                    params={"param1": "value1",
+                                            "param2": "value2"})
+
+        os.path.exists = MagicMock(return_value=True)
+        uuid.uuid1 = MagicMock(
+            return_value=uuid.UUID("12345678123456781234567812345678"))
+        codecs.open = MagicMock()
+
+        generator.generate(interface=interface,
+                           filename="Test.xml",
+                           namespace="XXX::YYY::ZZZ",
+                           destination_dir="/some/test/dir")
+
+        os.path.exists.assert_has_calls([call('/some/test/dir')])
+
+        open_result = codecs.open
+        mock_calls = open_result.mock_calls
+
+        self.assertEqual(mock_calls[0],
+                         call('/some/test/dir/Test.h',
+                              mode='w',
+                              encoding='utf-8'),
+                         "Invalid header file creation")
+
+        self.assertEqual(mock_calls[4],
+                         call('/some/test/dir/Test.cc',
+                              mode='w',
+                              encoding='utf-8'),
+                         "Invalid source file creation")
+
+        self.assertEqual(str(mock_calls[2])[27:-2].replace("\\n", "\n"),
+                         expected_h_file_content,
+                         "Invalid header file content")
+
+        self.assertEqual(str(mock_calls[6])[27:-2].replace("\\n", "\n"),
+                         expected_cc_file_content,
+                         "Invalid source file content")
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py
new file mode 100755
index 000000000..111ffb3cb
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py
@@ -0,0 +1,325 @@
+"""Test for SDLRPC SmartFactory generator.
+
+Verifies format specific functions and produced source code.
+
+"""
+import collections
+import codecs
+import os
+import unittest
+import uuid
+
+from mock import MagicMock
+from mock import call
+
+from generator.generators import SmartFactorySDLRPC
+from generator import Model
+
+
+EXPECTED_NOTIFICATION_RESULT = (
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<FunctionID::eType>::create("""
+    u"""function_id_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TEnumSchemaItem<messageType::eType>::create("""
+    u"""message_type_items), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n"""
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n""")
+
+EXPECTED_REQ_RESP_RESULT = "".join([EXPECTED_NOTIFICATION_RESULT, (
+    u"""params_members[NsSmartDeviceLink::NsJSONHandler::"""
+    u"""strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember("""
+    u"""TNumberSchemaItem<int>::create(), true);\n""")])
+
+DESCRIPTION = [u"Description Line1", u"Description Line2"]
+
+DESIGN_DESCRIPTION = [u"Design Line1"]
+
+ISSUES = [Model.Issue(value=u"Issue1"),
+          Model.Issue(value=u"Issue2"),
+          Model.Issue(value=u"Issue3")]
+
+TODOS = [u"Do1", u"Do2"]
+
+
+class Test(unittest.TestCase):
+
+    """Test for SLDRPC SmartFactory generator.
+
+    This class holds set of test cases for the SDLRPC SmartFactory generator.
+
+    """
+
+    def test_gen_schema_params_fill(self):
+        """Test feature that allows to create format specific PARAMS.
+
+        Verifies SDLRPC implementation of the _gen_schema_params_fill
+        method.
+
+        """
+
+        generator = SmartFactorySDLRPC.CodeGenerator()
+
+        self.assertEqual(generator._gen_schema_params_fill("request"),
+                         EXPECTED_REQ_RESP_RESULT,
+                         "Invalid code generation for request")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"request"),
+                         EXPECTED_REQ_RESP_RESULT,
+                         "Invalid code generation for request")
+
+        self.assertEqual(generator._gen_schema_params_fill("response"),
+                         EXPECTED_REQ_RESP_RESULT,
+                         "Invalid code generation for response")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"response"),
+                         EXPECTED_REQ_RESP_RESULT,
+                         "Invalid code generation for response")
+
+        self.assertEqual(generator._gen_schema_params_fill("notification"),
+                         EXPECTED_NOTIFICATION_RESULT,
+                         "Invalid code generation for notification")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"notification"),
+                         EXPECTED_NOTIFICATION_RESULT,
+                         "Invalid code generation for notification")
+
+        self.assertEqual(generator._gen_schema_params_fill("some text"),
+                         EXPECTED_REQ_RESP_RESULT,
+                         "Invalid code generation")
+
+        self.assertEqual(generator._gen_schema_params_fill(u"some text"),
+                         EXPECTED_REQ_RESP_RESULT,
+                         "Invalid code generation")
+
+    def test_full_generation(self):
+        """Test full generation using SDLPRC SmartSchema generator.
+
+        Creates output files which is captured by the mock and compare them
+        with sample files with correct code. This test requires valid
+        test_expected_sdlrpc.h and test_expected_sdlrpc.cc in the same as
+        this module.
+
+        """
+
+        expected_h_file_content = open("test_expected_sdlrpc.h", "r").read()
+        expected_cc_file_content = open("test_expected_sdlrpc.cc", "r").read()
+
+        generator = SmartFactorySDLRPC.CodeGenerator()
+
+        message_type_elements = collections.OrderedDict()
+        message_type_elements[u"request"] = Model.EnumElement(name=u"request")
+        message_type_elements[u"response"] = Model.EnumElement(
+            name=u"response")
+        message_type_elements[u"notification"] = Model.EnumElement(
+            name=u"notification")
+
+        message_type = Model.Enum(name=u"messageType",
+                                  elements=message_type_elements)
+
+        elements1 = collections.OrderedDict()
+        elements1[u"name1"] = Model.EnumElement(
+            name=u"name1",
+            design_description=DESIGN_DESCRIPTION,
+            todos=TODOS,
+            value=u"1")
+        elements1[u"name2"] = Model.EnumElement(
+            name="name2",
+            description=DESCRIPTION,
+            issues=ISSUES,
+            internal_name=u"internal_name2")
+
+        enum1 = Model.Enum(name=u"Enum1",
+                           todos=TODOS,
+                           elements=elements1)
+
+        elements2 = collections.OrderedDict()
+        elements2[u"xxx"] = Model.EnumElement(name=u"xxx",
+                                              internal_name=u"val_1")
+        elements2[u"yyy"] = Model.EnumElement(name=u"yyy",
+                                              internal_name=u"val_2",
+                                              value=u"100")
+        elements2[u"zzz"] = Model.EnumElement(name=u"val_3")
+
+        enum2 = Model.Enum(name=u"E2",
+                           elements=elements2)
+
+        elements3 = collections.OrderedDict()
+        elements3["1"] = Model.EnumElement(name="xxx",
+                                           internal_name="_1")
+        elements3["2"] = Model.EnumElement(name="xxx",
+                                           internal_name="_2")
+        elements3["3"] = Model.EnumElement(name="xxx",
+                                           internal_name="_3")
+        enum3 = Model.Enum(name="Enum_new2",
+                           elements=elements3)
+
+        elements4 = collections.OrderedDict()
+        elements4["name1"] = Model.EnumElement(name="xxx",
+                                               internal_name="_11")
+        elements4["name2"] = Model.EnumElement(name="xxx",
+                                               internal_name="_22")
+        enum4 = Model.Enum(name="Enum_new4",
+                           elements=elements4)
+
+        enums = collections.OrderedDict()
+        enums["Enum1"] = enum1
+        enums["Enum2"] = enum2
+        enums["Enum3"] = enum3
+        enums["Enum4"] = enum4
+        enums["messageType"] = message_type
+
+        params1 = collections.OrderedDict()
+        params1["1"] = Model.FunctionParam(
+            name="param1",
+            design_description=DESIGN_DESCRIPTION,
+            description=DESCRIPTION,
+            issues=ISSUES,
+            todos=TODOS,
+            param_type=enum4,
+            default_value=elements4["name1"])
+        params1["2"] = Model.FunctionParam(
+            name="param2",
+            param_type=Model.EnumSubset(
+                name="sub1",
+                enum=enum1,
+                allowed_elements={"e1": elements1["name1"]}),
+            default_value=elements1["name1"])
+
+        functions = collections.OrderedDict()
+        functions["Function1"] = Model.Function(
+            name="Function1",
+            function_id=elements1["name1"],
+            message_type=message_type_elements["request"],
+            params=params1)
+        functions["Function2"] = Model.Function(
+            name="Function2",
+            function_id=elements2["xxx"],
+            message_type=message_type_elements["response"])
+        functions["Function3"] = Model.Function(
+            name="Function2",
+            function_id=elements2["yyy"],
+            message_type=message_type_elements["notification"])
+
+        members1 = collections.OrderedDict()
+        members1["m1"] = Model.Param(name="intParam",
+                                     param_type=Model.Integer(max_value=2))
+        members1["m11"] = Model.Param(name="doubleParam",
+                                      param_type=Model.Double(min_value=0.333),
+                                      is_mandatory=False)
+        members1["m222"] = Model.Param(name="boolParam",
+                                       param_type=Model.Boolean())
+        members1["m2"] = Model.Param(name="structParam",
+                                     param_type=Model.Struct(name="Struct2"))
+        members1["aaa"] = Model.Param(name="enumParam",
+                                      param_type=enum1)
+        members1["bbb"] = Model.Param(name="enumParam1",
+                                      param_type=enum1)
+        members1["xxx"] = Model.Param(
+            name="enumSubset1",
+            param_type=Model.EnumSubset(
+                name="sub",
+                enum=enum1,
+                allowed_elements={"e1": elements1["name1"]}),
+            is_mandatory=False)
+        members1["1"] = Model.Param(
+            name="arrayOfInt",
+            param_type=Model.Array(min_size=0,
+                                   max_size=20,
+                                   element_type=Model.Boolean()),
+            is_mandatory=False)
+        members1["2"] = Model.Param(
+            name="arrayOfEnum1",
+            param_type=Model.Array(min_size=0,
+                                   max_size=20,
+                                   element_type=enum1),
+            is_mandatory=False)
+        members1["3"] = Model.Param(
+            name="arrayOfEnum3",
+            param_type=Model.Array(min_size=10,
+                                   max_size=40,
+                                   element_type=enum3),
+            is_mandatory=True)
+        members1["4"] = Model.Param(
+            name="arrayOfEnum4",
+            param_type=Model.Array(
+                min_size=10,
+                max_size=41,
+                element_type=Model.EnumSubset(
+                    name="sub1",
+                    enum=enum1,
+                    allowed_elements={"e1": elements1["name1"]})))
+        members1["5"] = Model.Param(
+            name="arrayOfEnum5",
+            param_type=Model.Array(
+                min_size=10,
+                max_size=42,
+                element_type=Model.EnumSubset(
+                    name="sub2",
+                    enum=enum1,
+                    allowed_elements={"e1": elements1["name2"]})))
+        members1["6"] = Model.Param(
+            name="arrayOfEnum6",
+            param_type=Model.Array(
+                min_size=10,
+                max_size=43,
+                element_type=Model.EnumSubset(
+                    name="sub3",
+                    enum=enum4,
+                    allowed_elements={"e1": elements4["name2"]})))
+
+        structs = collections.OrderedDict()
+        structs["Struct1"] = Model.Struct(
+            name="Struct1",
+            design_description=DESIGN_DESCRIPTION,
+            issues=ISSUES,
+            members=members1)
+        structs["Struct2"] = Model.Struct(name="Struct2",
+                                          issues=ISSUES)
+
+        interface = Model.Interface(enums=enums,
+                                    structs=structs,
+                                    functions=functions,
+                                    params={"param1": "value1",
+                                            "param2": "value2"})
+
+        os.path.exists = MagicMock(return_value=True)
+        uuid.uuid1 = MagicMock(
+            return_value=uuid.UUID("12345678123456781234567812345678"))
+        codecs.open = MagicMock()
+
+        generator.generate(interface=interface,
+                           filename="Test.xml",
+                           namespace="XXX::YYY::ZZZ",
+                           destination_dir="/some/test/dir")
+
+        os.path.exists.assert_has_calls([call('/some/test/dir')])
+
+        open_result = codecs.open
+        mock_calls = open_result.mock_calls
+
+        self.assertEqual(mock_calls[0],
+                         call('/some/test/dir/Test.h',
+                              mode='w',
+                              encoding='utf-8'),
+                         "Invalid header file creation")
+
+        self.assertEqual(mock_calls[4],
+                         call('/some/test/dir/Test.cc',
+                              mode='w',
+                              encoding='utf-8'),
+                         "Invalid source file creation")
+
+        self.assertEqual(str(mock_calls[2])[27:-2].replace("\\n", "\n"),
+                         expected_h_file_content,
+                         "Invalid header file content")
+
+        self.assertEqual(str(mock_calls[6])[27:-2].replace("\\n", "\n"),
+                         expected_cc_file_content,
+                         "Invalid source file content")
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.cc b/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.cc
new file mode 100644
index 000000000..458c27543
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.cc
@@ -0,0 +1,385 @@
+/**
+ * @file Test.cc
+ * @brief Generated class Test source file.
+ *
+ * This class is a part of SmartObjects solution. It provides
+ * factory functionallity which allows client to use SmartSchemas
+ * in accordance with definitions from Test.xml file
+ */
+// Copyright (c) 2013, 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 <map>
+#include <set>
+
+#include "Test.h"
+#include "SmartObjects/CAlwaysTrueSchemaItem.hpp"
+#include "SmartObjects/CAlwaysFalseSchemaItem.hpp"
+#include "SmartObjects/CArraySchemaItem.hpp"
+#include "SmartObjects/CBoolSchemaItem.hpp"
+#include "SmartObjects/CObjectSchemaItem.hpp"
+#include "SmartObjects/CStringSchemaItem.hpp"
+#include "SmartObjects/TEnumSchemaItem.hpp"
+#include "SmartObjects/TNumberSchemaItem.hpp"
+#include "SmartObjects/TSchemaItemParameter.hpp"
+
+using namespace NsSmartDeviceLink::NsSmartObjects;
+
+XXX::YYY::ZZZ::Test::Test()
+ : CSmartFactory<FunctionID::eType, messageType::eType, StructIdentifiers::eType>() {
+  TStructsSchemaItems struct_schema_items;
+  InitStructSchemes(struct_schema_items);
+
+  std::set<FunctionID::eType> function_id_items;
+
+
+  std::set<messageType::eType> message_type_items;
+  message_type_items.insert(messageType::request);
+  message_type_items.insert(messageType::response);
+  message_type_items.insert(messageType::notification);
+  message_type_items.insert(messageType::error_response);
+
+  InitFunctionSchemes(struct_schema_items, function_id_items, message_type_items);
+}
+
+TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::ProvideObjectSchemaItemForStruct(
+    const TStructsSchemaItems &struct_schema_items,
+    const StructIdentifiers::eType struct_id) {
+  const TStructsSchemaItems::const_iterator it = struct_schema_items.find(struct_id);
+  if (it != struct_schema_items.end()) {
+    return it->second;
+  }
+
+  return NsSmartDeviceLink::NsSmartObjects::CAlwaysFalseSchemaItem::create();
+}
+
+void XXX::YYY::ZZZ::Test::InitStructSchemes(
+    TStructsSchemaItems &struct_schema_items) {
+  TSharedPtr<ISchemaItem> struct_schema_item_Struct2 = InitStructSchemaItem_Struct2(struct_schema_items);
+  struct_schema_items.insert(std::make_pair(StructIdentifiers::Struct2, struct_schema_item_Struct2));
+  structs_schemes_.insert(std::make_pair(StructIdentifiers::Struct2, CSmartSchema(struct_schema_item_Struct2)));
+
+  TSharedPtr<ISchemaItem> struct_schema_item_Struct1 = InitStructSchemaItem_Struct1(struct_schema_items);
+  struct_schema_items.insert(std::make_pair(StructIdentifiers::Struct1, struct_schema_item_Struct1));
+  structs_schemes_.insert(std::make_pair(StructIdentifiers::Struct1, CSmartSchema(struct_schema_item_Struct1)));
+}
+
+void XXX::YYY::ZZZ::Test::InitFunctionSchemes(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::kCode] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::kMessage] = CObjectSchemaItem::SMember(CStringSchemaItem::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  CSmartSchema error_response_schema(CObjectSchemaItem::create(root_members_map));
+
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::val_1, messageType::error_response), error_response_schema));
+
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::name1, messageType::request), InitFunction_name1_request(struct_schema_items, function_id_items, message_type_items)));
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::val_1, messageType::response), InitFunction_val_1_response(struct_schema_items, function_id_items, message_type_items)));
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::val_2, messageType::notification), InitFunction_val_2_notification(struct_schema_items, function_id_items, message_type_items)));
+}
+
+//------------- Functions schemes initialization -------------
+
+CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_name1_request(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::set<Enum_new4::eType> Enum_new4_all_enum_values;
+  Enum_new4_all_enum_values.insert(Enum_new4::_11);
+  Enum_new4_all_enum_values.insert(Enum_new4::_22);
+
+  std::set<Enum1::eType> param2_allowed_enum_subset_values;
+  param2_allowed_enum_subset_values.insert(Enum1::name1);
+
+  // Function parameter param1.
+  //
+  // Description Line1
+  // Description Line2
+  //
+  // Design Line1
+  //
+  // Note: Issue1
+  // Note: Issue2
+  // Note: Issue3
+  //
+  // ToDo: Do1
+  // ToDo: Do2
+  TSharedPtr<ISchemaItem> param1_SchemaItem = TEnumSchemaItem<Enum_new4::eType>::create(Enum_new4_all_enum_values, TSchemaItemParameter<Enum_new4::eType>(Enum_new4::_11));
+
+  // Function parameter param2.
+  TSharedPtr<ISchemaItem> param2_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(param2_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>(name1));
+
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  schema_members["param1"] = CObjectSchemaItem::SMember(param1_SchemaItem, true);
+  schema_members["param2"] = CObjectSchemaItem::SMember(param2_SchemaItem, true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  return CSmartSchema(CObjectSchemaItem::create(root_members_map));
+}
+
+CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_val_1_response(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::kCode] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  return CSmartSchema(CObjectSchemaItem::create(root_members_map));
+}
+
+CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_val_2_notification(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  return CSmartSchema(CObjectSchemaItem::create(root_members_map));
+}
+
+//----------- Structs schema items initialization ------------
+
+TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::InitStructSchemaItem_Struct1(
+    const TStructsSchemaItems &struct_schema_items) {
+  std::set<Enum1::eType> Enum1_all_enum_values;
+  Enum1_all_enum_values.insert(Enum1::name1);
+  Enum1_all_enum_values.insert(Enum1::internal_name2);
+
+  std::set<Enum1::eType> enumSubset1_allowed_enum_subset_values;
+  enumSubset1_allowed_enum_subset_values.insert(Enum1::name1);
+
+  std::set<Enum_new2::eType> Enum_new2_all_enum_values;
+  Enum_new2_all_enum_values.insert(Enum_new2::_1);
+  Enum_new2_all_enum_values.insert(Enum_new2::_2);
+  Enum_new2_all_enum_values.insert(Enum_new2::_3);
+
+  std::set<Enum1::eType> sub1_allowed_enum_subset_values;
+  sub1_allowed_enum_subset_values.insert(Enum1::name1);
+
+  std::set<Enum1::eType> sub2_allowed_enum_subset_values;
+  sub2_allowed_enum_subset_values.insert(Enum1::internal_name2);
+
+  std::set<Enum_new4::eType> sub3_allowed_enum_subset_values;
+  sub3_allowed_enum_subset_values.insert(Enum_new4::_22);
+
+  // Struct member intParam.
+  TSharedPtr<ISchemaItem> intParam_SchemaItem = TNumberSchemaItem<int>::create(TSchemaItemParameter<int>(), TSchemaItemParameter<int>(2), TSchemaItemParameter<int>());
+
+  // Struct member doubleParam.
+  TSharedPtr<ISchemaItem> doubleParam_SchemaItem = TNumberSchemaItem<double>::create(TSchemaItemParameter<double>(0.333), TSchemaItemParameter<double>(), TSchemaItemParameter<double>());
+
+  // Struct member boolParam.
+  TSharedPtr<ISchemaItem> boolParam_SchemaItem = CBoolSchemaItem::create(TSchemaItemParameter<bool>());
+
+  // Struct member structParam.
+  TSharedPtr<ISchemaItem> structParam_SchemaItem = ProvideObjectSchemaItemForStruct(struct_schema_items, StructIdentifiers::Struct2);
+
+  // Struct member enumParam.
+  TSharedPtr<ISchemaItem> enumParam_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(Enum1_all_enum_values, TSchemaItemParameter<Enum1::eType>());
+
+  // Struct member enumParam1.
+  TSharedPtr<ISchemaItem> enumParam1_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(Enum1_all_enum_values, TSchemaItemParameter<Enum1::eType>());
+
+  // Struct member enumSubset1.
+  TSharedPtr<ISchemaItem> enumSubset1_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(enumSubset1_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>());
+
+  // Struct member arrayOfInt.
+  TSharedPtr<ISchemaItem> arrayOfInt_SchemaItem = CArraySchemaItem::create(CBoolSchemaItem::create(TSchemaItemParameter<bool>()), TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(20));
+
+  // Struct member arrayOfEnum1.
+  TSharedPtr<ISchemaItem> arrayOfEnum1_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum1::eType>::create(Enum1_all_enum_values, TSchemaItemParameter<Enum1::eType>()), TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(20));
+
+  // Struct member arrayOfEnum3.
+  TSharedPtr<ISchemaItem> arrayOfEnum3_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum_new2::eType>::create(Enum_new2_all_enum_values, TSchemaItemParameter<Enum_new2::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(40));
+
+  // Struct member arrayOfEnum4.
+  TSharedPtr<ISchemaItem> arrayOfEnum4_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum1::eType>::create(sub1_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(41));
+
+  // Struct member arrayOfEnum5.
+  TSharedPtr<ISchemaItem> arrayOfEnum5_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum1::eType>::create(sub2_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(42));
+
+  // Struct member arrayOfEnum6.
+  TSharedPtr<ISchemaItem> arrayOfEnum6_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum_new4::eType>::create(sub3_allowed_enum_subset_values, TSchemaItemParameter<Enum_new4::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(43));
+
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  schema_members["intParam"] = CObjectSchemaItem::SMember(intParam_SchemaItem, true);
+  schema_members["doubleParam"] = CObjectSchemaItem::SMember(doubleParam_SchemaItem, false);
+  schema_members["boolParam"] = CObjectSchemaItem::SMember(boolParam_SchemaItem, true);
+  schema_members["structParam"] = CObjectSchemaItem::SMember(structParam_SchemaItem, true);
+  schema_members["enumParam"] = CObjectSchemaItem::SMember(enumParam_SchemaItem, true);
+  schema_members["enumParam1"] = CObjectSchemaItem::SMember(enumParam1_SchemaItem, true);
+  schema_members["enumSubset1"] = CObjectSchemaItem::SMember(enumSubset1_SchemaItem, false);
+  schema_members["arrayOfInt"] = CObjectSchemaItem::SMember(arrayOfInt_SchemaItem, false);
+  schema_members["arrayOfEnum1"] = CObjectSchemaItem::SMember(arrayOfEnum1_SchemaItem, false);
+  schema_members["arrayOfEnum3"] = CObjectSchemaItem::SMember(arrayOfEnum3_SchemaItem, true);
+  schema_members["arrayOfEnum4"] = CObjectSchemaItem::SMember(arrayOfEnum4_SchemaItem, true);
+  schema_members["arrayOfEnum5"] = CObjectSchemaItem::SMember(arrayOfEnum5_SchemaItem, true);
+  schema_members["arrayOfEnum6"] = CObjectSchemaItem::SMember(arrayOfEnum6_SchemaItem, true);
+
+  return CObjectSchemaItem::create(schema_members);
+}
+
+TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::InitStructSchemaItem_Struct2(
+    const TStructsSchemaItems &struct_schema_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  return CObjectSchemaItem::create(schema_members);
+}
+
+//-------------- String to value enum mapping ----------------
+
+namespace NsSmartDeviceLink {
+namespace NsSmartObjects {
+
+template <>
+const std::map<XXX::YYY::ZZZ::Enum1::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::Enum1::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::Enum1::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum1::name1, "name1"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum1::internal_name2, "name2"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::E2::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::E2::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::E2::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::E2::val_1, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::E2::val_2, "yyy"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::E2::val_3, "val_3"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::Enum_new2::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::Enum_new2::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::Enum_new2::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new2::_1, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new2::_2, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new2::_3, "xxx"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::Enum_new4::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::Enum_new4::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::Enum_new4::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new4::_11, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new4::_22, "xxx"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::messageType::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::messageType::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::messageType::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::request, "request"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::response, "response"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::notification, "notification"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::error_response, "error_response"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+} // NsSmartObjects
+} // NsSmartDeviceLink
+
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.h b/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.h
new file mode 100644
index 000000000..b26560348
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.h
@@ -0,0 +1,326 @@
+/**
+ * @file Test.h
+ * @brief Generated class Test header file.
+ *
+ * This class is a part of SmartObjects solution. It provides
+ * factory functionallity which allows client to use SmartSchemas
+ * in accordance with definitions from Test.xml file
+ */
+// Copyright (c) 2013, 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 __CSMARTFACTORY_TEST_12345678123456781234567812345678_H__
+#define __CSMARTFACTORY_TEST_12345678123456781234567812345678_H__
+
+#include "JSONHandler/CSmartFactory.hpp"
+#include "SmartObjects/CSmartSchema.hpp"
+#include "SmartObjects/ISchemaItem.hpp"
+#include "SmartObjects/TSharedPtr.hpp"
+
+namespace XXX {
+namespace YYY {
+namespace ZZZ {
+
+namespace StructIdentifiers {
+/**
+ * @brief Enumeration StructIdentifiers.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief Struct1.
+   */
+  Struct1,
+
+  /**
+   * @brief Struct2.
+   */
+  Struct2
+};
+} // StructIdentifiers
+
+namespace Enum1 {
+/**
+ * @brief Enumeration Enum1.
+ *
+ * @todo Do1
+ * @todo Do2
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief name1.
+   *
+   * Design Line1
+   *
+   * @todo Do1
+   * @todo Do2
+   */
+  name1 = 1,
+
+  /**
+   * @brief internal_name2.
+   *
+   * Description Line1
+   * Description Line2
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  internal_name2
+};
+} // Enum1
+
+namespace E2 {
+/**
+ * @brief Enumeration E2.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief val_1.
+   */
+  val_1,
+
+  /**
+   * @brief val_2.
+   */
+  val_2 = 100,
+
+  /**
+   * @brief val_3.
+   */
+  val_3
+};
+} // E2
+
+namespace Enum_new2 {
+/**
+ * @brief Enumeration Enum_new2.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief _1.
+   */
+  _1,
+
+  /**
+   * @brief _2.
+   */
+  _2,
+
+  /**
+   * @brief _3.
+   */
+  _3
+};
+} // Enum_new2
+
+namespace Enum_new4 {
+/**
+ * @brief Enumeration Enum_new4.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief _11.
+   */
+  _11,
+
+  /**
+   * @brief _22.
+   */
+  _22
+};
+} // Enum_new4
+
+namespace messageType {
+/**
+ * @brief Enumeration messageType.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief request.
+   */
+  request,
+
+  /**
+   * @brief response.
+   */
+  response,
+
+  /**
+   * @brief notification.
+   */
+  notification,
+
+  /**
+   * @brief error_response.
+   */
+  error_response
+};
+} // messageType
+
+
+/**
+ * @brief Class Test.
+ *
+ * Params:
+ *     param2 - value2
+ *     param1 - value1
+ */
+class Test : public NsSmartDeviceLink::NsJSONHandler::CSmartFactory<FunctionID::eType, messageType::eType, StructIdentifiers::eType> {
+ public:
+  /**
+   * @brief Constructor.
+   */
+  Test();
+
+ protected:
+  /**
+   * @brief Type that maps of struct IDs to schema items.
+   */
+  typedef std::map<const StructIdentifiers::eType, NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> > TStructsSchemaItems;
+
+  /**
+   * @brief Helper that allows to make reference to struct
+   *
+   * @param struct_schema_items Struct schema items.
+   * @param struct_id ID of structure to provide.
+   *
+   * @return TSharedPtr of strucute
+   */
+  static NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> ProvideObjectSchemaItemForStruct(
+        const TStructsSchemaItems &struct_schema_items,
+        const StructIdentifiers::eType struct_id);
+
+  /**
+   * @brief Initializes all struct schemes.
+   */
+  void InitStructSchemes(TStructsSchemaItems &struct_schema_items);
+
+  /**
+   * @brief Initializes all function schemes.
+   *
+   * @param struct_schema_items Struct schema items.
+   * @param function_id_items Set of all elements of FunctionID enum.
+   * @param message_type_items Set of all elements of messageType enum.
+   */
+  void InitFunctionSchemes(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema for function Function1.
+   *
+   * @return NsSmartDeviceLink::NsSmartObjects::CSmartSchema
+   */
+  static NsSmartDeviceLink::NsSmartObjects::CSmartSchema InitFunction_name1_request(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema for function Function2.
+   *
+   * @return NsSmartDeviceLink::NsSmartObjects::CSmartSchema
+   */
+  static NsSmartDeviceLink::NsSmartObjects::CSmartSchema InitFunction_val_1_response(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema for function Function2.
+   *
+   * @return NsSmartDeviceLink::NsSmartObjects::CSmartSchema
+   */
+  static NsSmartDeviceLink::NsSmartObjects::CSmartSchema InitFunction_val_2_notification(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema item for structure Struct1.
+   *
+   * Design Line1
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  static NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> InitStructSchemaItem_Struct1(
+      const TStructsSchemaItems &struct_schema_items);
+
+  /**
+   * @brief Method that generates schema item for structure Struct2.
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  static NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> InitStructSchemaItem_Struct2(
+      const TStructsSchemaItems &struct_schema_items);
+};
+
+} // XXX
+} // YYY
+} // ZZZ
+
+#endif //__CSMARTFACTORY_TEST_12345678123456781234567812345678_H__
+
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.cc b/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.cc
new file mode 100644
index 000000000..53e5b7f78
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.cc
@@ -0,0 +1,366 @@
+/**
+ * @file Test.cc
+ * @brief Generated class Test source file.
+ *
+ * This class is a part of SmartObjects solution. It provides
+ * factory functionallity which allows client to use SmartSchemas
+ * in accordance with definitions from Test.xml file
+ */
+// Copyright (c) 2013, 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 <map>
+#include <set>
+
+#include "Test.h"
+#include "SmartObjects/CAlwaysTrueSchemaItem.hpp"
+#include "SmartObjects/CAlwaysFalseSchemaItem.hpp"
+#include "SmartObjects/CArraySchemaItem.hpp"
+#include "SmartObjects/CBoolSchemaItem.hpp"
+#include "SmartObjects/CObjectSchemaItem.hpp"
+#include "SmartObjects/CStringSchemaItem.hpp"
+#include "SmartObjects/TEnumSchemaItem.hpp"
+#include "SmartObjects/TNumberSchemaItem.hpp"
+#include "SmartObjects/TSchemaItemParameter.hpp"
+
+using namespace NsSmartDeviceLink::NsSmartObjects;
+
+XXX::YYY::ZZZ::Test::Test()
+ : CSmartFactory<FunctionID::eType, messageType::eType, StructIdentifiers::eType>() {
+  TStructsSchemaItems struct_schema_items;
+  InitStructSchemes(struct_schema_items);
+
+  std::set<FunctionID::eType> function_id_items;
+
+
+  std::set<messageType::eType> message_type_items;
+  message_type_items.insert(messageType::request);
+  message_type_items.insert(messageType::response);
+  message_type_items.insert(messageType::notification);
+
+  InitFunctionSchemes(struct_schema_items, function_id_items, message_type_items);
+}
+
+TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::ProvideObjectSchemaItemForStruct(
+    const TStructsSchemaItems &struct_schema_items,
+    const StructIdentifiers::eType struct_id) {
+  const TStructsSchemaItems::const_iterator it = struct_schema_items.find(struct_id);
+  if (it != struct_schema_items.end()) {
+    return it->second;
+  }
+
+  return NsSmartDeviceLink::NsSmartObjects::CAlwaysFalseSchemaItem::create();
+}
+
+void XXX::YYY::ZZZ::Test::InitStructSchemes(
+    TStructsSchemaItems &struct_schema_items) {
+  TSharedPtr<ISchemaItem> struct_schema_item_Struct2 = InitStructSchemaItem_Struct2(struct_schema_items);
+  struct_schema_items.insert(std::make_pair(StructIdentifiers::Struct2, struct_schema_item_Struct2));
+  structs_schemes_.insert(std::make_pair(StructIdentifiers::Struct2, CSmartSchema(struct_schema_item_Struct2)));
+
+  TSharedPtr<ISchemaItem> struct_schema_item_Struct1 = InitStructSchemaItem_Struct1(struct_schema_items);
+  struct_schema_items.insert(std::make_pair(StructIdentifiers::Struct1, struct_schema_item_Struct1));
+  structs_schemes_.insert(std::make_pair(StructIdentifiers::Struct1, CSmartSchema(struct_schema_item_Struct1)));
+}
+
+void XXX::YYY::ZZZ::Test::InitFunctionSchemes(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::name1, messageType::request), InitFunction_name1_request(struct_schema_items, function_id_items, message_type_items)));
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::val_1, messageType::response), InitFunction_val_1_response(struct_schema_items, function_id_items, message_type_items)));
+  functions_schemes_.insert(std::make_pair(NsSmartDeviceLink::NsJSONHandler::SmartSchemaKey<FunctionID::eType, messageType::eType>(FunctionID::val_2, messageType::notification), InitFunction_val_2_notification(struct_schema_items, function_id_items, message_type_items)));
+}
+
+//------------- Functions schemes initialization -------------
+
+CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_name1_request(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::set<Enum_new4::eType> Enum_new4_all_enum_values;
+  Enum_new4_all_enum_values.insert(Enum_new4::_11);
+  Enum_new4_all_enum_values.insert(Enum_new4::_22);
+
+  std::set<Enum1::eType> param2_allowed_enum_subset_values;
+  param2_allowed_enum_subset_values.insert(Enum1::name1);
+
+  // Function parameter param1.
+  //
+  // Description Line1
+  // Description Line2
+  //
+  // Design Line1
+  //
+  // Note: Issue1
+  // Note: Issue2
+  // Note: Issue3
+  //
+  // ToDo: Do1
+  // ToDo: Do2
+  TSharedPtr<ISchemaItem> param1_SchemaItem = TEnumSchemaItem<Enum_new4::eType>::create(Enum_new4_all_enum_values, TSchemaItemParameter<Enum_new4::eType>(Enum_new4::_11));
+
+  // Function parameter param2.
+  TSharedPtr<ISchemaItem> param2_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(param2_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>(name1));
+
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  schema_members["param1"] = CObjectSchemaItem::SMember(param1_SchemaItem, true);
+  schema_members["param2"] = CObjectSchemaItem::SMember(param2_SchemaItem, true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  return CSmartSchema(CObjectSchemaItem::create(root_members_map));
+}
+
+CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_val_1_response(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  return CSmartSchema(CObjectSchemaItem::create(root_members_map));
+}
+
+CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_val_2_notification(
+    const TStructsSchemaItems &struct_schema_items,
+    const std::set<FunctionID::eType> &function_id_items,
+    const std::set<messageType::eType> &message_type_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  std::map<std::string, CObjectSchemaItem::SMember> params_members;
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[NsSmartDeviceLink::NsJSONHandler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+
+  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[NsSmartDeviceLink::NsJSONHandler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+
+  return CSmartSchema(CObjectSchemaItem::create(root_members_map));
+}
+
+//----------- Structs schema items initialization ------------
+
+TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::InitStructSchemaItem_Struct1(
+    const TStructsSchemaItems &struct_schema_items) {
+  std::set<Enum1::eType> Enum1_all_enum_values;
+  Enum1_all_enum_values.insert(Enum1::name1);
+  Enum1_all_enum_values.insert(Enum1::internal_name2);
+
+  std::set<Enum1::eType> enumSubset1_allowed_enum_subset_values;
+  enumSubset1_allowed_enum_subset_values.insert(Enum1::name1);
+
+  std::set<Enum_new2::eType> Enum_new2_all_enum_values;
+  Enum_new2_all_enum_values.insert(Enum_new2::_1);
+  Enum_new2_all_enum_values.insert(Enum_new2::_2);
+  Enum_new2_all_enum_values.insert(Enum_new2::_3);
+
+  std::set<Enum1::eType> sub1_allowed_enum_subset_values;
+  sub1_allowed_enum_subset_values.insert(Enum1::name1);
+
+  std::set<Enum1::eType> sub2_allowed_enum_subset_values;
+  sub2_allowed_enum_subset_values.insert(Enum1::internal_name2);
+
+  std::set<Enum_new4::eType> sub3_allowed_enum_subset_values;
+  sub3_allowed_enum_subset_values.insert(Enum_new4::_22);
+
+  // Struct member intParam.
+  TSharedPtr<ISchemaItem> intParam_SchemaItem = TNumberSchemaItem<int>::create(TSchemaItemParameter<int>(), TSchemaItemParameter<int>(2), TSchemaItemParameter<int>());
+
+  // Struct member doubleParam.
+  TSharedPtr<ISchemaItem> doubleParam_SchemaItem = TNumberSchemaItem<double>::create(TSchemaItemParameter<double>(0.333), TSchemaItemParameter<double>(), TSchemaItemParameter<double>());
+
+  // Struct member boolParam.
+  TSharedPtr<ISchemaItem> boolParam_SchemaItem = CBoolSchemaItem::create(TSchemaItemParameter<bool>());
+
+  // Struct member structParam.
+  TSharedPtr<ISchemaItem> structParam_SchemaItem = ProvideObjectSchemaItemForStruct(struct_schema_items, StructIdentifiers::Struct2);
+
+  // Struct member enumParam.
+  TSharedPtr<ISchemaItem> enumParam_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(Enum1_all_enum_values, TSchemaItemParameter<Enum1::eType>());
+
+  // Struct member enumParam1.
+  TSharedPtr<ISchemaItem> enumParam1_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(Enum1_all_enum_values, TSchemaItemParameter<Enum1::eType>());
+
+  // Struct member enumSubset1.
+  TSharedPtr<ISchemaItem> enumSubset1_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(enumSubset1_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>());
+
+  // Struct member arrayOfInt.
+  TSharedPtr<ISchemaItem> arrayOfInt_SchemaItem = CArraySchemaItem::create(CBoolSchemaItem::create(TSchemaItemParameter<bool>()), TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(20));
+
+  // Struct member arrayOfEnum1.
+  TSharedPtr<ISchemaItem> arrayOfEnum1_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum1::eType>::create(Enum1_all_enum_values, TSchemaItemParameter<Enum1::eType>()), TSchemaItemParameter<size_t>(0), TSchemaItemParameter<size_t>(20));
+
+  // Struct member arrayOfEnum3.
+  TSharedPtr<ISchemaItem> arrayOfEnum3_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum_new2::eType>::create(Enum_new2_all_enum_values, TSchemaItemParameter<Enum_new2::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(40));
+
+  // Struct member arrayOfEnum4.
+  TSharedPtr<ISchemaItem> arrayOfEnum4_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum1::eType>::create(sub1_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(41));
+
+  // Struct member arrayOfEnum5.
+  TSharedPtr<ISchemaItem> arrayOfEnum5_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum1::eType>::create(sub2_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(42));
+
+  // Struct member arrayOfEnum6.
+  TSharedPtr<ISchemaItem> arrayOfEnum6_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum_new4::eType>::create(sub3_allowed_enum_subset_values, TSchemaItemParameter<Enum_new4::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(43));
+
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  schema_members["intParam"] = CObjectSchemaItem::SMember(intParam_SchemaItem, true);
+  schema_members["doubleParam"] = CObjectSchemaItem::SMember(doubleParam_SchemaItem, false);
+  schema_members["boolParam"] = CObjectSchemaItem::SMember(boolParam_SchemaItem, true);
+  schema_members["structParam"] = CObjectSchemaItem::SMember(structParam_SchemaItem, true);
+  schema_members["enumParam"] = CObjectSchemaItem::SMember(enumParam_SchemaItem, true);
+  schema_members["enumParam1"] = CObjectSchemaItem::SMember(enumParam1_SchemaItem, true);
+  schema_members["enumSubset1"] = CObjectSchemaItem::SMember(enumSubset1_SchemaItem, false);
+  schema_members["arrayOfInt"] = CObjectSchemaItem::SMember(arrayOfInt_SchemaItem, false);
+  schema_members["arrayOfEnum1"] = CObjectSchemaItem::SMember(arrayOfEnum1_SchemaItem, false);
+  schema_members["arrayOfEnum3"] = CObjectSchemaItem::SMember(arrayOfEnum3_SchemaItem, true);
+  schema_members["arrayOfEnum4"] = CObjectSchemaItem::SMember(arrayOfEnum4_SchemaItem, true);
+  schema_members["arrayOfEnum5"] = CObjectSchemaItem::SMember(arrayOfEnum5_SchemaItem, true);
+  schema_members["arrayOfEnum6"] = CObjectSchemaItem::SMember(arrayOfEnum6_SchemaItem, true);
+
+  return CObjectSchemaItem::create(schema_members);
+}
+
+TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::InitStructSchemaItem_Struct2(
+    const TStructsSchemaItems &struct_schema_items) {
+  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+
+  return CObjectSchemaItem::create(schema_members);
+}
+
+//-------------- String to value enum mapping ----------------
+
+namespace NsSmartDeviceLink {
+namespace NsSmartObjects {
+
+template <>
+const std::map<XXX::YYY::ZZZ::Enum1::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::Enum1::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::Enum1::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum1::name1, "name1"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum1::internal_name2, "name2"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::E2::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::E2::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::E2::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::E2::val_1, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::E2::val_2, "yyy"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::E2::val_3, "val_3"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::Enum_new2::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::Enum_new2::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::Enum_new2::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new2::_1, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new2::_2, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new2::_3, "xxx"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::Enum_new4::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::Enum_new4::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::Enum_new4::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new4::_11, "xxx"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::Enum_new4::_22, "xxx"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+template <>
+const std::map<XXX::YYY::ZZZ::messageType::eType, std::string> &TEnumSchemaItem<XXX::YYY::ZZZ::messageType::eType>::getEnumElementsStringRepresentation() {
+  static bool is_initialized = false;
+  static std::map<XXX::YYY::ZZZ::messageType::eType, std::string> enum_string_representation;
+
+  if (false == is_initialized) {
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::request, "request"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::response, "response"));
+    enum_string_representation.insert(std::make_pair(XXX::YYY::ZZZ::messageType::notification, "notification"));
+
+    is_initialized = true;
+  }
+
+  return enum_string_representation;
+}
+
+} // NsSmartObjects
+} // NsSmartDeviceLink
+
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.h b/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.h
new file mode 100644
index 000000000..826ea55ce
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.h
@@ -0,0 +1,321 @@
+/**
+ * @file Test.h
+ * @brief Generated class Test header file.
+ *
+ * This class is a part of SmartObjects solution. It provides
+ * factory functionallity which allows client to use SmartSchemas
+ * in accordance with definitions from Test.xml file
+ */
+// Copyright (c) 2013, 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 __CSMARTFACTORY_TEST_12345678123456781234567812345678_H__
+#define __CSMARTFACTORY_TEST_12345678123456781234567812345678_H__
+
+#include "JSONHandler/CSmartFactory.hpp"
+#include "SmartObjects/CSmartSchema.hpp"
+#include "SmartObjects/ISchemaItem.hpp"
+#include "SmartObjects/TSharedPtr.hpp"
+
+namespace XXX {
+namespace YYY {
+namespace ZZZ {
+
+namespace StructIdentifiers {
+/**
+ * @brief Enumeration StructIdentifiers.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief Struct1.
+   */
+  Struct1,
+
+  /**
+   * @brief Struct2.
+   */
+  Struct2
+};
+} // StructIdentifiers
+
+namespace Enum1 {
+/**
+ * @brief Enumeration Enum1.
+ *
+ * @todo Do1
+ * @todo Do2
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief name1.
+   *
+   * Design Line1
+   *
+   * @todo Do1
+   * @todo Do2
+   */
+  name1 = 1,
+
+  /**
+   * @brief internal_name2.
+   *
+   * Description Line1
+   * Description Line2
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  internal_name2
+};
+} // Enum1
+
+namespace E2 {
+/**
+ * @brief Enumeration E2.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief val_1.
+   */
+  val_1,
+
+  /**
+   * @brief val_2.
+   */
+  val_2 = 100,
+
+  /**
+   * @brief val_3.
+   */
+  val_3
+};
+} // E2
+
+namespace Enum_new2 {
+/**
+ * @brief Enumeration Enum_new2.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief _1.
+   */
+  _1,
+
+  /**
+   * @brief _2.
+   */
+  _2,
+
+  /**
+   * @brief _3.
+   */
+  _3
+};
+} // Enum_new2
+
+namespace Enum_new4 {
+/**
+ * @brief Enumeration Enum_new4.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief _11.
+   */
+  _11,
+
+  /**
+   * @brief _22.
+   */
+  _22
+};
+} // Enum_new4
+
+namespace messageType {
+/**
+ * @brief Enumeration messageType.
+ */
+enum eType {
+  /**
+   * @brief INVALID_ENUM.
+   */
+  INVALID_ENUM = -1,
+
+  /**
+   * @brief request.
+   */
+  request,
+
+  /**
+   * @brief response.
+   */
+  response,
+
+  /**
+   * @brief notification.
+   */
+  notification
+};
+} // messageType
+
+
+/**
+ * @brief Class Test.
+ *
+ * Params:
+ *     param2 - value2
+ *     param1 - value1
+ */
+class Test : public NsSmartDeviceLink::NsJSONHandler::CSmartFactory<FunctionID::eType, messageType::eType, StructIdentifiers::eType> {
+ public:
+  /**
+   * @brief Constructor.
+   */
+  Test();
+
+ protected:
+  /**
+   * @brief Type that maps of struct IDs to schema items.
+   */
+  typedef std::map<const StructIdentifiers::eType, NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> > TStructsSchemaItems;
+
+  /**
+   * @brief Helper that allows to make reference to struct
+   *
+   * @param struct_schema_items Struct schema items.
+   * @param struct_id ID of structure to provide.
+   *
+   * @return TSharedPtr of strucute
+   */
+  static NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> ProvideObjectSchemaItemForStruct(
+        const TStructsSchemaItems &struct_schema_items,
+        const StructIdentifiers::eType struct_id);
+
+  /**
+   * @brief Initializes all struct schemes.
+   */
+  void InitStructSchemes(TStructsSchemaItems &struct_schema_items);
+
+  /**
+   * @brief Initializes all function schemes.
+   *
+   * @param struct_schema_items Struct schema items.
+   * @param function_id_items Set of all elements of FunctionID enum.
+   * @param message_type_items Set of all elements of messageType enum.
+   */
+  void InitFunctionSchemes(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema for function Function1.
+   *
+   * @return NsSmartDeviceLink::NsSmartObjects::CSmartSchema
+   */
+  static NsSmartDeviceLink::NsSmartObjects::CSmartSchema InitFunction_name1_request(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema for function Function2.
+   *
+   * @return NsSmartDeviceLink::NsSmartObjects::CSmartSchema
+   */
+  static NsSmartDeviceLink::NsSmartObjects::CSmartSchema InitFunction_val_1_response(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema for function Function2.
+   *
+   * @return NsSmartDeviceLink::NsSmartObjects::CSmartSchema
+   */
+  static NsSmartDeviceLink::NsSmartObjects::CSmartSchema InitFunction_val_2_notification(
+      const TStructsSchemaItems &struct_schema_items,
+      const std::set<FunctionID::eType> &function_id_items,
+      const std::set<messageType::eType> &message_type_items);
+
+  /**
+   * @brief Method that generates schema item for structure Struct1.
+   *
+   * Design Line1
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  static NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> InitStructSchemaItem_Struct1(
+      const TStructsSchemaItems &struct_schema_items);
+
+  /**
+   * @brief Method that generates schema item for structure Struct2.
+   *
+   * @note Issue1
+   * @note Issue2
+   * @note Issue3
+   */
+  static NsSmartDeviceLink::NsSmartObjects::TSharedPtr<NsSmartDeviceLink::NsSmartObjects::ISchemaItem> InitStructSchemaItem_Struct2(
+      const TStructsSchemaItems &struct_schema_items);
+};
+
+} // XXX
+} // YYY
+} // ZZZ
+
+#endif //__CSMARTFACTORY_TEST_12345678123456781234567812345678_H__
+
diff --git a/tools/InterfaceGenerator/test/generator/parsers/__init__.py b/tools/InterfaceGenerator/test/generator/parsers/__init__.py
new file mode 100755
index 000000000..e69de29bb
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/__init__.py
diff --git a/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py b/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py
new file mode 100755
index 000000000..f2fecdb90
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/test_JSONRPC.py
@@ -0,0 +1,595 @@
+"""JSONRPC XML parser unit test."""
+import os
+import unittest
+
+import generator.Model
+import generator.parsers.JSONRPC
+
+
+class TestJSONRPCVParser(unittest.TestCase):
+
+    """Test for JSONRPC xml parser."""
+
+    class _Issue:
+        def __init__(self, creator, value):
+            self.creator = creator
+            self.value = value
+
+        def __eq__(self, other):
+            return self.creator == other.creator and self.value == other.value
+
+    def setUp(self):
+        """Test initialization."""
+        self.valid_xml_name = os.path.dirname(os.path.realpath(__file__)) + \
+            "/valid_JSONRPC.xml"
+        self.parser = generator.parsers.JSONRPC.Parser()
+
+    def test_valid_xml(self):
+        """Test parsing of valid xml."""
+        interface = self.parser.parse(self.valid_xml_name)
+
+        self.assertEqual(9, len(interface.params))
+        self.assertDictEqual({"attr1": "v1",
+                              "attr2": "v2",
+                              "interface1_attribute1": "value1",
+                              "interface1_attribute2": "value2",
+                              "interface1_issues": "Issue1\nIssue2",
+                              "interface1_design_description": "dd",
+                              "interface2_attribute": "value",
+                              "interface2_description":
+                              "Description of interface2",
+                              "interface2_todos": "i2 todo"},
+                             interface.params)
+
+        # Enumerations
+
+        self.assertEqual(5, len(interface.enums))
+
+        # Enumeration "FunctionID"
+
+        self.assertIn("FunctionID", interface.enums)
+        enum = interface.enums["FunctionID"]
+        self.verify_base_item(item=enum,
+                              name="FunctionID")
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("interface1.Function1", enum.elements)
+        element = enum.elements["interface1.Function1"]
+        self.verify_base_item(
+            item=element,
+            name="interface1.Function1")
+        self.assertEqual("interface1_Function1", element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("interface1.Function2", enum.elements)
+        element = enum.elements["interface1.Function2"]
+        self.verify_base_item(
+            item=element,
+            name="interface1.Function2")
+        self.assertEqual("interface1_Function2", element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("interface2.Function1", enum.elements)
+        element = enum.elements["interface2.Function1"]
+        self.verify_base_item(
+            item=element,
+            name="interface2.Function1")
+        self.assertEqual("interface2_Function1", element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Enumeration "messageType"
+
+        self.assertIn("messageType", interface.enums)
+        enum = interface.enums["messageType"]
+        self.verify_base_item(
+            item=enum,
+            name="messageType")
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("request", enum.elements)
+        element = enum.elements["request"]
+        self.verify_base_item(item=element,
+                              name="request")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("response", enum.elements)
+        element = enum.elements["response"]
+        self.verify_base_item(item=element, name="response")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("notification", enum.elements)
+        element = enum.elements["notification"]
+        self.verify_base_item(item=element, name="notification")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Enumeration "interface1_enum1"
+
+        self.assertIn("interface1_enum1", interface.enums)
+        enum = interface.enums["interface1_enum1"]
+        self.verify_base_item(item=enum, name="interface1_enum1",
+                              platform="enum1 platform")
+        self.assertEqual("scope", enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("element1", enum.elements)
+        element = enum.elements["element1"]
+        self.verify_base_item(item=element, name="element1")
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(10, element.value)
+
+        self.assertIn("element2", enum.elements)
+        element = enum.elements["element2"]
+        self.verify_base_item(item=element, name="element2")
+        self.assertEqual("element2_internal", element.internal_name)
+        self.assertEqual(11, element.value)
+
+        self.assertIn("element3", enum.elements)
+        element = enum.elements["element3"]
+        self.verify_base_item(
+            item=element,
+            name="element3",
+            design_description=["Element design description"],
+            platform="element3 platform")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Enumeration "interface2_enum1"
+
+        self.assertIn("interface2_enum1", interface.enums)
+        enum = interface.enums["interface2_enum1"]
+        self.verify_base_item(item=enum, name="interface2_enum1",
+                              description=["Interface2 enum1 description"])
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(2, len(enum.elements))
+
+        self.assertIn("e1", enum.elements)
+        element = enum.elements["e1"]
+        self.verify_base_item(item=element, name="e1")
+        self.assertEqual("int_e1", element.internal_name)
+        self.assertEqual(0, element.value)
+
+        self.assertIn("e2", enum.elements)
+        element = enum.elements["e2"]
+        self.verify_base_item(item=element, name="e2")
+        self.assertEqual("int_e2", element.internal_name)
+        self.assertEqual(10, element.value)
+
+        # Enumeration "interface2_enum2"
+
+        self.assertIn("interface2_enum2", interface.enums)
+        enum = interface.enums["interface2_enum2"]
+        self.verify_base_item(item=enum, name="interface2_enum2",
+                              platform="e2 platform")
+        self.assertEqual("e2 scope", enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("element1", enum.elements)
+        element = enum.elements["element1"]
+        self.verify_base_item(item=element, name="element1")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("element2", enum.elements)
+        element = enum.elements["element2"]
+        self.verify_base_item(item=element, name="element2")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("element3", enum.elements)
+        element = enum.elements["element3"]
+        self.verify_base_item(item=element, name="element3")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Structures
+
+        self.assertEqual(3, len(interface.structs))
+
+        # Structure "interface1_struct1"
+
+        self.assertIn("interface1_struct1", interface.structs)
+        struct = interface.structs["interface1_struct1"]
+        self.verify_base_item(
+            item=struct,
+            name="interface1_struct1",
+            description=["Struct description"],
+            issues=[TestJSONRPCVParser._Issue(creator="creator1",
+                                              value="Issue1"),
+                    TestJSONRPCVParser._Issue(creator="creator2",
+                                              value="Issue2")])
+
+        self.assertEqual(4, len(struct.members))
+
+        self.assertIn("member1", struct.members)
+        member = struct.members["member1"]
+        self.verify_base_item(
+            item=member,
+            name="member1",
+            description=["Param1 description"])
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Integer)
+        self.assertIsNone(member.param_type.min_value)
+        self.assertIsNone(member.param_type.max_value)
+
+        self.assertIn("member2", struct.members)
+        member = struct.members["member2"]
+        self.verify_base_item(item=member, name="member2",
+                              platform="member2 platform")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Boolean)
+
+        self.assertIn("member3", struct.members)
+        member = struct.members["member3"]
+        self.verify_base_item(item=member, name="member3")
+        self.assertEqual(False, member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Double)
+        self.assertIsNone(member.param_type.min_value)
+        self.assertAlmostEqual(20.5, member.param_type.max_value)
+
+        self.assertIn("member4", struct.members)
+        member = struct.members["member4"]
+        self.verify_base_item(item=member, name="member4")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsNone(member.param_type.min_size)
+        self.assertIsNone(member.param_type.max_size)
+        self.assertIsInstance(member.param_type.element_type,
+                              generator.Model.Integer)
+        self.assertEqual(11, member.param_type.element_type.min_value)
+        self.assertEqual(100, member.param_type.element_type.max_value)
+
+        # Structure "interface1_struct2"
+
+        self.assertIn("interface1_struct2", interface.structs)
+        struct = interface.structs["interface1_struct2"]
+        self.verify_base_item(item=struct,
+                              name="interface1_struct2",
+                              description=["Description of struct2"],
+                              platform="struct2 platform")
+
+        self.assertEqual(4, len(struct.members))
+
+        self.assertIn("m1", struct.members)
+        member = struct.members["m1"]
+        self.verify_base_item(item=member, name="m1")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.String)
+        self.assertIsNone(member.param_type.max_length)
+
+        self.assertIn("m2", struct.members)
+        member = struct.members["m2"]
+        self.verify_base_item(item=member, name="m2")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertEqual(1, member.param_type.min_size)
+        self.assertEqual(50, member.param_type.max_size)
+        self.assertIsInstance(member.param_type.element_type,
+                              generator.Model.String)
+        self.assertEqual(100, member.param_type.element_type.max_length)
+
+        self.assertIn("m3", struct.members)
+        member = struct.members["m3"]
+        self.verify_base_item(item=member, name="m3")
+        self.assertTrue(member.is_mandatory)
+        self.assertIs(member.param_type, interface.enums["interface1_enum1"])
+
+        self.assertIn("m4", struct.members)
+        member = struct.members["m4"]
+        self.verify_base_item(item=member, name="m4")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsNone(member.param_type.min_size)
+        self.assertEqual(10, member.param_type.max_size)
+        self.assertIs(member.param_type.element_type,
+                      interface.structs["interface1_struct1"])
+
+        # Structure "interface2_struct1"
+
+        self.assertIn("interface2_struct1", interface.structs)
+        struct = interface.structs["interface2_struct1"]
+        self.verify_base_item(item=struct, name="interface2_struct1")
+
+        self.assertEqual(3, len(struct.members))
+
+        self.assertIn("m_1", struct.members)
+        member = struct.members["m_1"]
+        self.verify_base_item(item=member, name="m_1")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertEqual(1, member.param_type.min_size)
+        self.assertEqual(10, member.param_type.max_size)
+        self.assertIs(member.param_type.element_type,
+                      interface.enums["interface2_enum1"])
+
+        self.assertIn("m_2", struct.members)
+        member = struct.members["m_2"]
+        self.verify_base_item(item=member, name="m_2")
+        self.assertTrue(member.is_mandatory)
+        self.assertIs(member.param_type, interface.enums["interface2_enum2"])
+
+        self.assertIn("m_3", struct.members)
+        member = struct.members["m_3"]
+        self.verify_base_item(item=member, name="m_3")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.String)
+        self.assertEqual(20, member.param_type.max_length)
+
+        # Functions
+
+        self.assertEqual(5, len(interface.functions))
+
+        # Function request "interface1_Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["interface1.Function1"],
+             interface.enums["messageType"].elements["request"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["interface1.Function1"],
+             interface.enums["messageType"].elements["request"])]
+        self.verify_base_item(
+            item=function,
+            name="interface1_Function1",
+            description=["Description of request Function1"],
+            todos=["Function1 request todo"])
+        self.assertIs(
+            function.function_id,
+            interface.enums["FunctionID"].elements["interface1.Function1"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["request"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("param1", function.params)
+        param = function.params["param1"]
+        self.verify_base_item(
+            item=param,
+            name="param1",
+            issues=[TestJSONRPCVParser._Issue(creator="", value="")])
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.String)
+        self.assertIsNone(param.param_type.max_length)
+        self.assertEqual("String default value", param.default_value)
+
+        self.assertIn("param2", function.params)
+        param = function.params["param2"]
+        self.verify_base_item(
+            item=param,
+            name="param2",
+            description=["Param2 description", ""],
+            todos=["Param2 todo"],
+            platform="param2 platform")
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Integer)
+        self.assertIsNone(param.param_type.min_value)
+        self.assertIsNone(param.param_type.max_value)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("param3", function.params)
+        param = function.params["param3"]
+        self.verify_base_item(item=param, name="param3")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type,
+                      interface.structs["interface1_struct1"])
+        self.assertIsNone(param.default_value)
+
+        # Function response "interface1_Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["interface1.Function1"],
+             interface.enums["messageType"].elements["response"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["interface1.Function1"],
+             interface.enums["messageType"].elements["response"])]
+        self.verify_base_item(
+            item=function,
+            name="interface1_Function1",
+            issues=[TestJSONRPCVParser._Issue(creator="c1", value=""),
+                    TestJSONRPCVParser._Issue(creator="c2", value="")],
+            platform="")
+        self.assertIs(
+            function.function_id,
+            interface.enums["FunctionID"].elements["interface1.Function1"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["response"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("p1", function.params)
+        param = function.params["p1"]
+        self.verify_base_item(item=param, name="p1")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["interface1_enum1"])
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("p2", function.params)
+        param = function.params["p2"]
+        self.verify_base_item(item=param, name="p2")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["interface1_enum1"])
+        self.assertIs(
+            param.default_value,
+            interface.enums["interface1_enum1"].elements["element2"])
+
+        self.assertIn("p3", function.params)
+        param = function.params["p3"]
+        self.verify_base_item(item=param, name="p3", design_description=[""])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Boolean)
+        self.assertEqual(False, param.default_value)
+
+        # Function notification "interface1_Function2"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["interface1.Function2"],
+             interface.enums["messageType"].elements["notification"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["interface1.Function2"],
+             interface.enums["messageType"].elements["notification"])]
+        self.verify_base_item(item=function,
+                              name="interface1_Function2",
+                              description=["Function2 description"],
+                              platform="function2 platform")
+        self.assertIs(
+            function.function_id,
+            interface.enums["FunctionID"].elements["interface1.Function2"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["notification"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("n1", function.params)
+        param = function.params["n1"]
+        self.verify_base_item(item=param, name="n1", todos=["n1 todo"])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.EnumSubset)
+        self.assertIs(param.param_type.enum,
+                      interface.enums["interface1_enum1"])
+        self.assertDictEqual(
+            {"element2":
+                interface.enums["interface1_enum1"].elements["element2"],
+             "element3":
+                interface.enums["interface1_enum1"].elements["element3"]},
+            param.param_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("n2", function.params)
+        param = function.params["n2"]
+        self.verify_base_item(item=param, name="n2", todos=["n2 todo"])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Array)
+        self.assertEqual(1, param.param_type.min_size)
+        self.assertEqual(100, param.param_type.max_size)
+        self.assertIsInstance(param.param_type.element_type,
+                              generator.Model.EnumSubset)
+        self.assertIs(param.param_type.element_type.enum,
+                      interface.enums["interface1_enum1"])
+        self.assertDictEqual(
+            {"element1":
+                interface.enums["interface1_enum1"].elements["element1"],
+             "element3":
+                interface.enums["interface1_enum1"].elements["element3"]},
+            param.param_type.element_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("n3", function.params)
+        param = function.params["n3"]
+        self.verify_base_item(item=param, name="n3")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type,
+                      interface.structs["interface1_struct2"])
+        self.assertIsNone(param.default_value)
+
+        # Function request "interface2_Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["interface2.Function1"],
+             interface.enums["messageType"].elements["request"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["interface2.Function1"],
+             interface.enums["messageType"].elements["request"])]
+        self.verify_base_item(item=function, name="interface2_Function1")
+        self.assertIs(
+            function.function_id,
+            interface.enums["FunctionID"].elements["interface2.Function1"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["request"])
+
+        self.assertEqual(2, len(function.params))
+
+        self.assertIn("param1", function.params)
+        param = function.params["param1"]
+        self.verify_base_item(item=param, name="param1")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["interface2_enum1"])
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("param2", function.params)
+        param = function.params["param2"]
+        self.verify_base_item(item=param, name="param2")
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Array)
+        self.assertEqual(5, param.param_type.min_size)
+        self.assertEqual(25, param.param_type.max_size)
+        self.assertIs(param.param_type.element_type,
+                      interface.structs["interface2_struct1"])
+        self.assertIsNone(param.default_value)
+
+        # Function notification "interface2_Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["interface2.Function1"],
+             interface.enums["messageType"].elements["notification"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["interface2.Function1"],
+             interface.enums["messageType"].elements["notification"])]
+        self.verify_base_item(
+            item=function,
+            name="interface2_Function1",
+            issues=[
+                TestJSONRPCVParser._Issue(creator="c", value="Issue text")],
+            platform="platform")
+        self.assertIs(
+            function.function_id,
+            interface.enums["FunctionID"].elements["interface2.Function1"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["notification"])
+
+        self.assertEqual(2, len(function.params))
+
+        self.assertIn("param", function.params)
+        param = function.params["param"]
+        self.verify_base_item(item=param, name="param")
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.EnumSubset)
+        self.assertIs(param.param_type.enum,
+                      interface.enums["interface2_enum2"])
+        self.assertDictEqual(
+            {"element2":
+                interface.enums["interface2_enum2"].elements["element2"],
+             "element3":
+                interface.enums["interface2_enum2"].elements["element3"]},
+            param.param_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("i1", function.params)
+        param = function.params["i1"]
+        self.verify_base_item(item=param, name="i1")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type,
+                      interface.structs["interface1_struct2"])
+        self.assertIsNone(param.default_value)
+
+    def verify_base_item(self, item, name, description=None,
+                         design_description=None, issues=None, todos=None,
+                         platform=None):
+        """Verify base interface item variables."""
+        self.assertEqual(name, item.name)
+        self.assertSequenceEqual(self.get_list(description), item.description)
+        self.assertSequenceEqual(self.get_list(design_description),
+                                 item.design_description)
+        self.assertSequenceEqual(self.get_list(issues), item.issues)
+        self.assertSequenceEqual(self.get_list(todos), item.todos)
+        self.assertEqual(platform, item.platform)
+
+    @staticmethod
+    def get_list(list=None):
+        """Return provided list or empty list if None is provided."""
+        return list if list is not None else []
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV1.py b/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV1.py
new file mode 100755
index 000000000..1464658ff
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV1.py
@@ -0,0 +1,404 @@
+"""SDLRPCV1 XML parser unit test."""
+import os
+import unittest
+
+import generator.Model
+import generator.parsers.SDLRPCV1
+
+
+class TestSDLRPCV1Parser(unittest.TestCase):
+
+    """Test for SDLRPCV1 xml parser."""
+
+    class _Issue:
+        def __init__(self, creator, value):
+            self.creator = creator
+            self.value = value
+
+        def __eq__(self, other):
+            return self.creator == other.creator and self.value == other.value
+
+    def setUp(self):
+        """Test initialization."""
+        self.valid_xml_name = os.path.dirname(os.path.realpath(__file__)) + \
+            "/valid_SDLRPCV1.xml"
+        self.parser = generator.parsers.SDLRPCV1.Parser()
+
+    def test_valid_xml(self):
+        """Test parsing of valid xml."""
+        interface = self.parser.parse(self.valid_xml_name)
+
+        self.assertEqual(2, len(interface.params))
+        self.assertDictEqual({"attribute1": "value1", "attribute2": "value2"},
+                             interface.params)
+
+        # Enumerations
+
+        self.assertEqual(3, len(interface.enums))
+
+        # Enumeration "FunctionID"
+
+        self.assertIn("FunctionID", interface.enums)
+        enum = interface.enums["FunctionID"]
+        self.verify_base_item(item=enum,
+                              name="FunctionID")
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(2, len(enum.elements))
+
+        self.assertIn("Function1", enum.elements)
+        element = enum.elements["Function1"]
+        self.verify_base_item(
+            item=element,
+            name="Function1")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("Function2", enum.elements)
+        element = enum.elements["Function2"]
+        self.verify_base_item(
+            item=element,
+            name="Function2")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Enumeration "messageType"
+
+        self.assertIn("messageType", interface.enums)
+        enum = interface.enums["messageType"]
+        self.verify_base_item(
+            item=enum,
+            name="messageType")
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("request", enum.elements)
+        element = enum.elements["request"]
+        self.verify_base_item(item=element,
+                              name="request")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("response", enum.elements)
+        element = enum.elements["response"]
+        self.verify_base_item(item=element, name="response")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        self.assertIn("notification", enum.elements)
+        element = enum.elements["notification"]
+        self.verify_base_item(item=element, name="notification")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Enumeration "enum1"
+
+        self.assertIn("enum1", interface.enums)
+        enum = interface.enums["enum1"]
+        self.verify_base_item(item=enum, name="enum1",
+                              platform="enum1 platform")
+        self.assertEqual("scope", enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("element1", enum.elements)
+        element = enum.elements["element1"]
+        self.verify_base_item(item=element, name="element1")
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(10, element.value)
+
+        self.assertIn("element2", enum.elements)
+        element = enum.elements["element2"]
+        self.verify_base_item(item=element, name="element2")
+        self.assertEqual("element2_internal", element.internal_name)
+        self.assertEqual(11, element.value)
+
+        self.assertIn("element3", enum.elements)
+        element = enum.elements["element3"]
+        self.verify_base_item(
+            item=element,
+            name="element3",
+            design_description=["Element design description"],
+            platform="element3 platform")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Structures
+
+        self.assertEqual(2, len(interface.structs))
+
+        # Structure "struct1"
+
+        self.assertIn("struct1", interface.structs)
+        struct = interface.structs["struct1"]
+        self.verify_base_item(
+            item=struct,
+            name="struct1",
+            description=["Struct description"],
+            issues=[TestSDLRPCV1Parser._Issue(creator="creator1",
+                                              value="Issue1"),
+                    TestSDLRPCV1Parser._Issue(creator="creator2",
+                                              value="Issue2")])
+
+        self.assertEqual(4, len(struct.members))
+
+        self.assertIn("member1", struct.members)
+        member = struct.members["member1"]
+        self.verify_base_item(
+            item=member,
+            name="member1",
+            description=["Param1 description"])
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Integer)
+        self.assertIsNone(member.param_type.min_value)
+        self.assertIsNone(member.param_type.max_value)
+
+        self.assertIn("member2", struct.members)
+        member = struct.members["member2"]
+        self.verify_base_item(item=member, name="member2",
+                              platform="member2 platform")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Boolean)
+
+        self.assertIn("member3", struct.members)
+        member = struct.members["member3"]
+        self.verify_base_item(item=member, name="member3")
+        self.assertEqual(False, member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Double)
+        self.assertIsNone(member.param_type.min_value)
+        self.assertAlmostEqual(20.5, member.param_type.max_value)
+
+        self.assertIn("member4", struct.members)
+        member = struct.members["member4"]
+        self.verify_base_item(item=member, name="member4")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsNone(member.param_type.min_size)
+        self.assertIsNone(member.param_type.max_size)
+        self.assertIsInstance(member.param_type.element_type,
+                              generator.Model.Integer)
+        self.assertEqual(11, member.param_type.element_type.min_value)
+        self.assertEqual(100, member.param_type.element_type.max_value)
+
+        # Structure "struct2"
+
+        self.assertIn("struct2", interface.structs)
+        struct = interface.structs["struct2"]
+        self.verify_base_item(item=struct,
+                              name="struct2",
+                              description=["Description of struct2"],
+                              platform="struct2 platform")
+
+        self.assertEqual(4, len(struct.members))
+
+        self.assertIn("m1", struct.members)
+        member = struct.members["m1"]
+        self.verify_base_item(item=member, name="m1")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.String)
+        self.assertIsNone(member.param_type.max_length)
+
+        self.assertIn("m2", struct.members)
+        member = struct.members["m2"]
+        self.verify_base_item(item=member, name="m2")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertEqual(1, member.param_type.min_size)
+        self.assertEqual(50, member.param_type.max_size)
+        self.assertIsInstance(member.param_type.element_type,
+                              generator.Model.String)
+        self.assertEqual(100, member.param_type.element_type.max_length)
+
+        self.assertIn("m3", struct.members)
+        member = struct.members["m3"]
+        self.verify_base_item(item=member, name="m3")
+        self.assertTrue(member.is_mandatory)
+        self.assertIs(member.param_type, interface.enums["enum1"])
+
+        self.assertIn("m4", struct.members)
+        member = struct.members["m4"]
+        self.verify_base_item(item=member, name="m4")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsNone(member.param_type.min_size)
+        self.assertEqual(10, member.param_type.max_size)
+        self.assertIs(member.param_type.element_type,
+                      interface.structs["struct1"])
+
+        # Functions
+
+        self.assertEqual(3, len(interface.functions))
+
+        # Function request "Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["Function1"],
+             interface.enums["messageType"].elements["request"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["Function1"],
+             interface.enums["messageType"].elements["request"])]
+        self.verify_base_item(
+            item=function,
+            name="Function1",
+            description=["Description of request Function1"],
+            todos=["Function1 request todo"])
+        self.assertIs(function.function_id,
+                      interface.enums["FunctionID"].elements["Function1"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["request"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("param1", function.params)
+        param = function.params["param1"]
+        self.verify_base_item(
+            item=param,
+            name="param1",
+            issues=[TestSDLRPCV1Parser._Issue(creator="", value="")])
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.String)
+        self.assertIsNone(param.param_type.max_length)
+        self.assertEqual("String default value", param.default_value)
+
+        self.assertIn("param2", function.params)
+        param = function.params["param2"]
+        self.verify_base_item(
+            item=param,
+            name="param2",
+            description=["Param2 description", ""],
+            todos=["Param2 todo"],
+            platform="param2 platform")
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Integer)
+        self.assertIsNone(param.param_type.min_value)
+        self.assertIsNone(param.param_type.max_value)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("param3", function.params)
+        param = function.params["param3"]
+        self.verify_base_item(item=param, name="param3")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type, interface.structs["struct1"])
+        self.assertIsNone(param.default_value)
+
+        # Function response "Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["Function1"],
+             interface.enums["messageType"].elements["response"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["Function1"],
+             interface.enums["messageType"].elements["response"])]
+        self.verify_base_item(
+            item=function,
+            name="Function1",
+            issues=[TestSDLRPCV1Parser._Issue(creator="c1", value=""),
+                    TestSDLRPCV1Parser._Issue(creator="c2", value="")],
+            platform="")
+        self.assertIs(function.function_id,
+                      interface.enums["FunctionID"].elements["Function1"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["response"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("p1", function.params)
+        param = function.params["p1"]
+        self.verify_base_item(item=param, name="p1")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["enum1"])
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("p2", function.params)
+        param = function.params["p2"]
+        self.verify_base_item(item=param, name="p2")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["enum1"])
+        self.assertIs(param.default_value,
+                      interface.enums["enum1"].elements["element2"])
+
+        self.assertIn("p3", function.params)
+        param = function.params["p3"]
+        self.verify_base_item(item=param, name="p3", design_description=[""])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Boolean)
+        self.assertEqual(False, param.default_value)
+
+        # Function notification "Function2"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["Function2"],
+             interface.enums["messageType"].elements["notification"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["Function2"],
+             interface.enums["messageType"].elements["notification"])]
+        self.verify_base_item(item=function,
+                              name="Function2",
+                              description=["Function2 description"],
+                              platform="function2 platform")
+        self.assertIs(function.function_id,
+                      interface.enums["FunctionID"].elements["Function2"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["notification"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("n1", function.params)
+        param = function.params["n1"]
+        self.verify_base_item(item=param, name="n1", todos=["n1 todo"])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.EnumSubset)
+        self.assertIs(param.param_type.enum, interface.enums["enum1"])
+        self.assertDictEqual(
+            {"element2": interface.enums["enum1"].elements["element2"],
+             "element3": interface.enums["enum1"].elements["element3"]},
+            param.param_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("n2", function.params)
+        param = function.params["n2"]
+        self.verify_base_item(item=param, name="n2", todos=["n2 todo"])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Array)
+        self.assertEqual(1, param.param_type.min_size)
+        self.assertEqual(100, param.param_type.max_size)
+        self.assertIsInstance(param.param_type.element_type,
+                              generator.Model.EnumSubset)
+        self.assertIs(param.param_type.element_type.enum,
+                      interface.enums["enum1"])
+        self.assertDictEqual(
+            {"element1": interface.enums["enum1"].elements["element1"],
+             "element3": interface.enums["enum1"].elements["element3"]},
+            param.param_type.element_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("n3", function.params)
+        param = function.params["n3"]
+        self.verify_base_item(item=param, name="n3")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type, interface.structs["struct2"])
+        self.assertIsNone(param.default_value)
+
+    def verify_base_item(self, item, name, description=None,
+                         design_description=None, issues=None, todos=None,
+                         platform=None):
+        """Verify base interface item variables."""
+        self.assertEqual(name, item.name)
+        self.assertSequenceEqual(self.get_list(description), item.description)
+        self.assertSequenceEqual(self.get_list(design_description),
+                                 item.design_description)
+        self.assertSequenceEqual(self.get_list(issues), item.issues)
+        self.assertSequenceEqual(self.get_list(todos), item.todos)
+        self.assertEqual(platform, item.platform)
+
+    @staticmethod
+    def get_list(list=None):
+        """Return provided list or empty list if None is provided."""
+        return list if list is not None else []
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV2.py b/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV2.py
new file mode 100755
index 000000000..c37962cfe
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/test_SDLRPCV2.py
@@ -0,0 +1,417 @@
+"""SDLRPCV2 XML parser unit test."""
+import os
+import unittest
+
+import generator.Model
+import generator.parsers.SDLRPCV2
+
+
+class TestSDLRPCV2Parser(unittest.TestCase):
+
+    """Test for SDLRPCV2 xml parser."""
+
+    class _Issue:
+        def __init__(self, creator, value):
+            self.creator = creator
+            self.value = value
+
+        def __eq__(self, other):
+            return self.creator == other.creator and self.value == other.value
+
+    def setUp(self):
+        """Test initialization."""
+        self.valid_xml_name = os.path.dirname(os.path.realpath(__file__)) + \
+            "/valid_SDLRPCV2.xml"
+        self.parser = generator.parsers.SDLRPCV2.Parser()
+
+    def test_valid_xml(self):
+        """Test parsing of valid xml."""
+        interface = self.parser.parse(self.valid_xml_name)
+
+        self.assertEqual(2, len(interface.params))
+        self.assertDictEqual({"attribute1": "value1", "attribute2": "value2"},
+                             interface.params)
+
+        # Enumerations
+
+        self.assertEqual(3, len(interface.enums))
+
+        # Enumeration "FunctionID"
+
+        self.assertIn("FunctionID", interface.enums)
+        enum = interface.enums["FunctionID"]
+        self.verify_base_item(item=enum,
+                              name="FunctionID",
+                              description=["Description string 1",
+                                           "Description string 2"],
+                              todos=['Function id todo'])
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(2, len(enum.elements))
+
+        self.assertIn("Function1_id", enum.elements)
+        element = enum.elements["Function1_id"]
+        self.verify_base_item(
+            item=element,
+            name="Function1_id",
+            design_description=["Function1 element design description"])
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(10, element.value)
+
+        self.assertIn("Function2_id", enum.elements)
+        element = enum.elements["Function2_id"]
+        self.verify_base_item(
+            item=element,
+            name="Function2_id")
+        self.assertEqual("Function2_internal", element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Enumeration "messageType"
+
+        self.assertIn("messageType", interface.enums)
+        enum = interface.enums["messageType"]
+        self.verify_base_item(
+            item=enum,
+            name="messageType",
+            design_description=["messageType design description",
+                                "messageType design description 2"],
+            issues=[TestSDLRPCV2Parser._Issue(
+                creator="messageType issue creator",
+                value="Issue text")])
+        self.assertIsNone(enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("request", enum.elements)
+        element = enum.elements["request"]
+        self.verify_base_item(item=element,
+                              name="request",
+                              todos=["request todo 1", "request todo 2"],
+                              issues=[TestSDLRPCV2Parser._Issue(
+                                  creator="issue creator",
+                                  value="request issue")])
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(0, element.value)
+
+        self.assertIn("response", enum.elements)
+        element = enum.elements["response"]
+        self.verify_base_item(item=element, name="response")
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(1, element.value)
+
+        self.assertIn("notification", enum.elements)
+        element = enum.elements["notification"]
+        self.verify_base_item(item=element, name="notification")
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(2, element.value)
+
+        # Enumeration "enum1"
+
+        self.assertIn("enum1", interface.enums)
+        enum = interface.enums["enum1"]
+        self.verify_base_item(item=enum, name="enum1",
+                              platform="enum1 platform")
+        self.assertEqual("scope", enum.internal_scope)
+
+        self.assertEqual(3, len(enum.elements))
+
+        self.assertIn("element1", enum.elements)
+        element = enum.elements["element1"]
+        self.verify_base_item(item=element, name="element1")
+        self.assertIsNone(element.internal_name)
+        self.assertEqual(10, element.value)
+
+        self.assertIn("element2", enum.elements)
+        element = enum.elements["element2"]
+        self.verify_base_item(item=element, name="element2")
+        self.assertEqual("element2_internal", element.internal_name)
+        self.assertEqual(11, element.value)
+
+        self.assertIn("element3", enum.elements)
+        element = enum.elements["element3"]
+        self.verify_base_item(
+            item=element,
+            name="element3",
+            design_description=["Element design description"],
+            platform="element3 platform")
+        self.assertIsNone(element.internal_name)
+        self.assertIsNone(element.value)
+
+        # Structures
+
+        self.assertEqual(2, len(interface.structs))
+
+        # Structure "struct1"
+
+        self.assertIn("struct1", interface.structs)
+        struct = interface.structs["struct1"]
+        self.verify_base_item(
+            item=struct,
+            name="struct1",
+            description=["Struct description"],
+            issues=[TestSDLRPCV2Parser._Issue(creator="creator1",
+                                              value="Issue1"),
+                    TestSDLRPCV2Parser._Issue(creator="creator2",
+                                              value="Issue2")])
+
+        self.assertEqual(4, len(struct.members))
+
+        self.assertIn("member1", struct.members)
+        member = struct.members["member1"]
+        self.verify_base_item(
+            item=member,
+            name="member1",
+            description=["Param1 description"])
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Integer)
+        self.assertIsNone(member.param_type.min_value)
+        self.assertIsNone(member.param_type.max_value)
+
+        self.assertIn("member2", struct.members)
+        member = struct.members["member2"]
+        self.verify_base_item(item=member, name="member2",
+                              platform="member2 platform")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Boolean)
+
+        self.assertIn("member3", struct.members)
+        member = struct.members["member3"]
+        self.verify_base_item(item=member, name="member3")
+        self.assertEqual(False, member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Double)
+        self.assertIsNone(member.param_type.min_value)
+        self.assertAlmostEqual(20.5, member.param_type.max_value)
+
+        self.assertIn("member4", struct.members)
+        member = struct.members["member4"]
+        self.verify_base_item(item=member, name="member4")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsNone(member.param_type.min_size)
+        self.assertIsNone(member.param_type.max_size)
+        self.assertIsInstance(member.param_type.element_type,
+                              generator.Model.Integer)
+        self.assertEqual(11, member.param_type.element_type.min_value)
+        self.assertEqual(100, member.param_type.element_type.max_value)
+
+        # Structure "struct2"
+
+        self.assertIn("struct2", interface.structs)
+        struct = interface.structs["struct2"]
+        self.verify_base_item(item=struct,
+                              name="struct2",
+                              description=["Description of struct2"],
+                              platform="struct2 platform")
+
+        self.assertEqual(4, len(struct.members))
+
+        self.assertIn("m1", struct.members)
+        member = struct.members["m1"]
+        self.verify_base_item(item=member, name="m1")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.String)
+        self.assertIsNone(member.param_type.max_length)
+
+        self.assertIn("m2", struct.members)
+        member = struct.members["m2"]
+        self.verify_base_item(item=member, name="m2")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertEqual(1, member.param_type.min_size)
+        self.assertEqual(50, member.param_type.max_size)
+        self.assertIsInstance(member.param_type.element_type,
+                              generator.Model.String)
+        self.assertEqual(100, member.param_type.element_type.max_length)
+
+        self.assertIn("m3", struct.members)
+        member = struct.members["m3"]
+        self.verify_base_item(item=member, name="m3")
+        self.assertTrue(member.is_mandatory)
+        self.assertIs(member.param_type, interface.enums["enum1"])
+
+        self.assertIn("m4", struct.members)
+        member = struct.members["m4"]
+        self.verify_base_item(item=member, name="m4")
+        self.assertTrue(member.is_mandatory)
+        self.assertIsInstance(member.param_type, generator.Model.Array)
+        self.assertIsNone(member.param_type.min_size)
+        self.assertEqual(10, member.param_type.max_size)
+        self.assertIs(member.param_type.element_type,
+                      interface.structs["struct1"])
+
+        # Functions
+
+        self.assertEqual(3, len(interface.functions))
+
+        # Function request "Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["Function1_id"],
+             interface.enums["messageType"].elements["request"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["Function1_id"],
+             interface.enums["messageType"].elements["request"])]
+        self.verify_base_item(
+            item=function,
+            name="Function1",
+            description=["Description of request Function1"],
+            todos=["Function1 request todo"])
+        self.assertIs(function.function_id,
+                      interface.enums["FunctionID"].elements["Function1_id"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["request"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("param1", function.params)
+        param = function.params["param1"]
+        self.verify_base_item(
+            item=param,
+            name="param1",
+            issues=[TestSDLRPCV2Parser._Issue(creator="", value="")])
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.String)
+        self.assertIsNone(param.param_type.max_length)
+        self.assertEqual("String default value", param.default_value)
+
+        self.assertIn("param2", function.params)
+        param = function.params["param2"]
+        self.verify_base_item(
+            item=param,
+            name="param2",
+            description=["Param2 description", ""],
+            todos=["Param2 todo"],
+            platform="param2 platform")
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Integer)
+        self.assertIsNone(param.param_type.min_value)
+        self.assertIsNone(param.param_type.max_value)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("param3", function.params)
+        param = function.params["param3"]
+        self.verify_base_item(item=param, name="param3")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type, interface.structs["struct1"])
+        self.assertIsNone(param.default_value)
+
+        # Function response "Function1"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["Function1_id"],
+             interface.enums["messageType"].elements["response"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["Function1_id"],
+             interface.enums["messageType"].elements["response"])]
+        self.verify_base_item(
+            item=function,
+            name="Function1",
+            issues=[TestSDLRPCV2Parser._Issue(creator="c1", value=""),
+                    TestSDLRPCV2Parser._Issue(creator="c2", value="")],
+            platform="")
+        self.assertIs(function.function_id,
+                      interface.enums["FunctionID"].elements["Function1_id"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["response"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("p1", function.params)
+        param = function.params["p1"]
+        self.verify_base_item(item=param, name="p1")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["enum1"])
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("p2", function.params)
+        param = function.params["p2"]
+        self.verify_base_item(item=param, name="p2")
+        self.assertTrue(param.is_mandatory)
+        self.assertIs(param.param_type, interface.enums["enum1"])
+        self.assertIs(param.default_value,
+                      interface.enums["enum1"].elements["element2"])
+
+        self.assertIn("p3", function.params)
+        param = function.params["p3"]
+        self.verify_base_item(item=param, name="p3", design_description=[""])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Boolean)
+        self.assertEqual(False, param.default_value)
+
+        # Function notification "Function2"
+
+        self.assertIn(
+            (interface.enums["FunctionID"].elements["Function2_id"],
+             interface.enums["messageType"].elements["notification"]),
+            interface.functions)
+        function = interface.functions[
+            (interface.enums["FunctionID"].elements["Function2_id"],
+             interface.enums["messageType"].elements["notification"])]
+        self.verify_base_item(item=function,
+                              name="Function2",
+                              description=["Function2 description"],
+                              platform="function2 platform")
+        self.assertIs(function.function_id,
+                      interface.enums["FunctionID"].elements["Function2_id"])
+        self.assertIs(function.message_type,
+                      interface.enums["messageType"].elements["notification"])
+
+        self.assertEqual(3, len(function.params))
+
+        self.assertIn("n1", function.params)
+        param = function.params["n1"]
+        self.verify_base_item(item=param, name="n1", todos=["n1 todo"])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.EnumSubset)
+        self.assertIs(param.param_type.enum, interface.enums["enum1"])
+        self.assertDictEqual(
+            {"element2": interface.enums["enum1"].elements["element2"],
+             "element3": interface.enums["enum1"].elements["element3"]},
+            param.param_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("n2", function.params)
+        param = function.params["n2"]
+        self.verify_base_item(item=param, name="n2", todos=["n2 todo"])
+        self.assertTrue(param.is_mandatory)
+        self.assertIsInstance(param.param_type, generator.Model.Array)
+        self.assertEqual(1, param.param_type.min_size)
+        self.assertEqual(100, param.param_type.max_size)
+        self.assertIsInstance(param.param_type.element_type,
+                              generator.Model.EnumSubset)
+        self.assertIs(param.param_type.element_type.enum,
+                      interface.enums["enum1"])
+        self.assertDictEqual(
+            {"element1": interface.enums["enum1"].elements["element1"],
+             "element3": interface.enums["enum1"].elements["element3"]},
+            param.param_type.element_type.allowed_elements)
+        self.assertIsNone(param.default_value)
+
+        self.assertIn("n3", function.params)
+        param = function.params["n3"]
+        self.verify_base_item(item=param, name="n3")
+        self.assertEqual(False, param.is_mandatory)
+        self.assertIs(param.param_type, interface.structs["struct2"])
+        self.assertIsNone(param.default_value)
+
+    def verify_base_item(self, item, name, description=None,
+                         design_description=None, issues=None, todos=None,
+                         platform=None):
+        """Verify base interface item variables."""
+        self.assertEqual(name, item.name)
+        self.assertSequenceEqual(self.get_list(description), item.description)
+        self.assertSequenceEqual(self.get_list(design_description),
+                                 item.design_description)
+        self.assertSequenceEqual(self.get_list(issues), item.issues)
+        self.assertSequenceEqual(self.get_list(todos), item.todos)
+        self.assertEqual(platform, item.platform)
+
+    @staticmethod
+    def get_list(list=None):
+        """Return provided list or empty list if None is provided."""
+        return list if list is not None else []
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/InterfaceGenerator/test/generator/parsers/valid_JSONRPC.xml b/tools/InterfaceGenerator/test/generator/parsers/valid_JSONRPC.xml
new file mode 100644
index 000000000..a754e5714
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/valid_JSONRPC.xml
@@ -0,0 +1,100 @@
+<?xml version="1.0"?>
+<interfaces attr1="v1" attr2="v2">
+    <interface name="interface1" attribute1="value1" attribute2="value2">
+        <struct name="struct1">
+            <param name="member1" type="Integer">
+                <description>Param1 description</description>
+            </param>
+            <issue creator="creator1">Issue1</issue>
+            <param name="member2" type="Boolean" mandatory="true" platform="member2 platform"/>
+            <param name="member3" type="Float" maxvalue="20.5" mandatory="false"/>
+            <description>Struct description</description>
+            <issue creator="creator2">Issue2</issue>
+            <param name="member4" type="Integer" minvalue="11" maxvalue="100" array="true"/>
+        </struct>
+        <issue creator="c">Issue1</issue>
+        <function name="Function1" messagetype="request">
+            <description>Description of request Function1</description>
+            <param name="param1" type="String" mandatory="false" defvalue="String default value">
+                <issue creator=""/>
+            </param>
+            <param name="param2" type="Integer" platform="param2 platform">
+                <description>Param2 description</description>
+                <todo>Param2 todo</todo>
+                <description/>
+            </param>
+            <todo>Function1 request todo</todo>
+            <param name="param3" type="struct1" mandatory="false"/>
+        </function>
+        <enum name="enum1" internal_scope="scope" platform="enum1 platform">
+            <element name="element1" value="10"/>
+            <element name="element2" internal_name="element2_internal" value="11"/>
+            <element name="element3" platform="element3 platform">
+                <designdescription>Element design description</designdescription>
+            </element>
+        </enum>
+        <designdescription>dd</designdescription>
+        <issue creator="c">Issue2</issue>
+        <function name="Function1" messagetype="response" platform="">
+            <param name="p1" type="enum1"/>
+            <issue creator="c1"/>
+            <issue creator="c2"></issue>
+            <param name="p2" type="enum1" defvalue="element2"/>
+            <param name="p3" type="Boolean" defvalue="false">
+                <designdescription/>
+            </param>
+        </function>
+        <struct name="struct2" platform="struct2 platform">
+            <description>Description of struct2</description>
+            <param name="m1" type="String"/>
+            <param name="m2" type="String" maxlength="100" array="true" minsize="1" maxsize="50"/>
+            <param name="m3" type="enum1"/>
+            <param name="m4" type="struct1" array="true" maxsize="10"/>
+        </struct>
+        <function name="Function2" messagetype="notification" platform="function2 platform">
+            <description>Function2 description</description>
+            <param name="n1" type="enum1">
+                <element name="element2"/>
+                <element name="element3"/>
+                <todo>n1 todo</todo>
+            </param>
+            <param name="n2" type="enum1" array="true" minsize="1" maxsize="100">
+                <element name="element3"/>
+                <todo>n2 todo</todo>
+                <element name="element1"/>
+            </param>
+            <param name="n3" type="struct2" mandatory="false"/>
+        </function>
+    </interface>
+    <interface name="interface2" attribute="value">
+        <description>Description of interface2</description>
+        <enum name="enum1">
+            <description>Interface2 enum1 description</description>
+            <element name="e1" internal_name="int_e1" value="0"/>
+            <element name="e2" internal_name="int_e2" value="10"/>
+        </enum>
+        <enum name="enum2" internal_scope="e2 scope" platform="e2 platform">
+            <element name="element1"/>
+            <element name="element2"/>
+            <element name="element3"/>
+        </enum>
+        <struct name="struct1">
+            <param name="m_1" type="enum1" minsize="1" maxsize="10" array="true"/>
+            <param name="m_2" type="enum2"/>
+            <param name="m_3" type="String" maxlength="20"/>
+        </struct>
+        <function name="Function1" messagetype="request">
+            <param name="param1" type="enum1" mandatory="false"/>
+            <param name="param2" type="struct1" array="true" minsize="5" maxsize="25"/>
+        </function>
+        <todo>i2 todo</todo>
+        <function name="Function1" messagetype="notification" platform="platform">
+            <issue creator="c">Issue text</issue>
+            <param name="param" type="enum2">
+                <element name="element2"/>
+                <element name="element3"/>
+            </param>
+            <param name="i1" type="interface1.struct2"/>
+        </function>
+    </interface>
+</interfaces>
\ No newline at end of file
diff --git a/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV1.xml b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV1.xml
new file mode 100644
index 000000000..37ebf39d3
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV1.xml
@@ -0,0 +1,64 @@
+<?xml version="1.0"?>
+<interface name="test_interface" attribute1="value1" attribute2="value2">
+    <struct name="struct1">
+        <param name="member1" type="Integer">
+            <description>Param1 description</description>
+        </param>
+        <issue creator="creator1">Issue1</issue>
+        <param name="member2" type="Boolean" mandatory="true" platform="member2 platform"/>
+        <param name="member3" type="Float" maxvalue="20.5" mandatory="false"/>
+        <description>Struct description</description>
+        <issue creator="creator2">Issue2</issue>
+        <param name="member4" type="Integer" minvalue="11" maxvalue="100" array="true"/>
+    </struct>
+    <function name="Function1" messagetype="request">
+        <description>Description of request Function1</description>
+        <param name="param1" type="String" mandatory="false" defvalue="String default value">
+            <issue creator=""/>
+        </param>
+        <param name="param2" type="Integer" platform="param2 platform">
+            <description>Param2 description</description>
+            <todo>Param2 todo</todo>
+            <description/>
+        </param>
+        <todo>Function1 request todo</todo>
+        <param name="param3" type="struct1" mandatory="false"/>
+    </function>
+    <enum name="enum1" internal_scope="scope" platform="enum1 platform">
+        <element name="element1" value="10"/>
+        <element name="element2" internal_name="element2_internal" value="11"/>
+        <element name="element3" platform="element3 platform">
+            <designdescription>Element design description</designdescription>
+        </element>
+    </enum>
+    <function name="Function1" messagetype="response" platform="">
+        <param name="p1" type="enum1"/>
+        <issue creator="c1"/>
+        <issue creator="c2"></issue>
+        <param name="p2" type="enum1" defvalue="element2"/>
+        <param name="p3" type="Boolean" defvalue="false">
+            <designdescription/>
+        </param>
+    </function>
+    <struct name="struct2" platform="struct2 platform">
+        <description>Description of struct2</description>
+        <param name="m1" type="String"/>
+        <param name="m2" type="String" maxlength="100" array="true" minsize="1" maxsize="50"/>
+        <param name="m3" type="enum1"/>
+        <param name="m4" type="struct1" array="true" maxsize="10"/>
+    </struct>
+    <function name="Function2" messagetype="notification" platform="function2 platform">
+        <description>Function2 description</description>
+        <param name="n1" type="enum1">
+            <element name="element2"/>
+            <element name="element3"/>
+            <todo>n1 todo</todo>
+        </param>
+        <param name="n2" type="enum1" array="true" minsize="1" maxsize="100">
+            <element name="element3"/>
+            <todo>n2 todo</todo>
+            <element name="element1"/>
+        </param>
+        <param name="n3" type="struct2" mandatory="false"/>
+    </function>
+</interface>
diff --git a/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV2.xml b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV2.xml
new file mode 100644
index 000000000..cdc5f1ae8
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/parsers/valid_SDLRPCV2.xml
@@ -0,0 +1,85 @@
+<?xml version="1.0"?>
+<interface name="test_interface" attribute1="value1" attribute2="value2">
+    <enum name="FunctionID">
+        <description>Description string 1</description>
+        <element name="Function1_id" value="10">
+            <designdescription>Function1 element design description</designdescription>
+        </element>
+        <description>Description string 2</description>
+        <todo>Function id todo</todo>
+        <element name="Function2_id" internal_name="Function2_internal"/>
+    </enum>
+    <enum name="messageType">
+        <element name="request" value="0">
+            <todo>request todo 1</todo>
+            <issue creator="issue creator">request issue</issue>
+            <todo>request todo 2</todo>
+        </element>
+        <designdescription>messageType design description</designdescription>
+        <issue creator="messageType issue creator">Issue text</issue>
+        <element name="response" value="1"/>
+        <element name="notification" value="2"/>
+        <designdescription>messageType design description 2</designdescription>
+    </enum>
+    <struct name="struct1">
+        <param name="member1" type="Integer">
+            <description>Param1 description</description>
+        </param>
+        <issue creator="creator1">Issue1</issue>
+        <param name="member2" type="Boolean" mandatory="true" platform="member2 platform"/>
+        <param name="member3" type="Float" maxvalue="20.5" mandatory="false"/>
+        <description>Struct description</description>
+        <issue creator="creator2">Issue2</issue>
+        <param name="member4" type="Integer" minvalue="11" maxvalue="100" array="true"/>
+    </struct>
+    <function name="Function1" functionID="Function1_id" messagetype="request">
+        <description>Description of request Function1</description>
+        <param name="param1" type="String" mandatory="false" defvalue="String default value">
+            <issue creator=""/>
+        </param>
+        <param name="param2" type="Integer" platform="param2 platform">
+            <description>Param2 description</description>
+            <todo>Param2 todo</todo>
+            <description/>
+        </param>
+        <todo>Function1 request todo</todo>
+        <param name="param3" type="struct1" mandatory="false"/>
+    </function>
+    <enum name="enum1" internal_scope="scope" platform="enum1 platform">
+        <element name="element1" value="10"/>
+        <element name="element2" internal_name="element2_internal" value="11"/>
+        <element name="element3" platform="element3 platform">
+            <designdescription>Element design description</designdescription>
+        </element>
+    </enum>
+    <function name="Function1" functionID="Function1_id" messagetype="response" platform="">
+        <param name="p1" type="enum1"/>
+        <issue creator="c1"/>
+        <issue creator="c2"></issue>
+        <param name="p2" type="enum1" defvalue="element2"/>
+        <param name="p3" type="Boolean" defvalue="false">
+            <designdescription/>
+        </param>
+    </function>
+    <struct name="struct2" platform="struct2 platform">
+        <description>Description of struct2</description>
+        <param name="m1" type="String"/>
+        <param name="m2" type="String" maxlength="100" array="true" minsize="1" maxsize="50"/>
+        <param name="m3" type="enum1"/>
+        <param name="m4" type="struct1" array="true" maxsize="10"/>
+    </struct>
+    <function name="Function2" functionID="Function2_id" messagetype="notification" platform="function2 platform">
+        <description>Function2 description</description>
+        <param name="n1" type="enum1">
+            <element name="element2"/>
+            <element name="element3"/>
+            <todo>n1 todo</todo>
+        </param>
+        <param name="n2" type="enum1" array="true" minsize="1" maxsize="100">
+            <element name="element3"/>
+            <todo>n2 todo</todo>
+            <element name="element1"/>
+        </param>
+        <param name="n3" type="struct2" mandatory="false"/>
+    </function>
+</interface>
diff --git a/tools/InterfaceGenerator/test/generator/test_Model.py b/tools/InterfaceGenerator/test/generator/test_Model.py
new file mode 100755
index 000000000..55f6a5470
--- /dev/null
+++ b/tools/InterfaceGenerator/test/generator/test_Model.py
@@ -0,0 +1,27 @@
+"""Interface model unit test"""
+import unittest
+
+import generator.Model
+
+
+class TestInterfaceModel(unittest.TestCase):
+
+    """Test for interface model."""
+
+    def test_enum_element_primary_name(self):
+        """Test property primary_name of EnumElement."""
+        element = generator.Model.EnumElement(name="name1")
+        self.assertEqual("name1", element.primary_name)
+
+        element = generator.Model.EnumElement(name="name2",
+                                              internal_name="internal_name1")
+        self.assertEqual("internal_name1", element.primary_name)
+
+        element.internal_name = None
+        self.assertEqual("name2", element.primary_name)
+
+        element.internal_name = "internal_name2"
+        self.assertEqual("internal_name2", element.primary_name)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tools/InterfaceGenerator/test/test_CodeFormatAndQuality.py b/tools/InterfaceGenerator/test/test_CodeFormatAndQuality.py
new file mode 100755
index 000000000..3ce56e0fa
--- /dev/null
+++ b/tools/InterfaceGenerator/test/test_CodeFormatAndQuality.py
@@ -0,0 +1,59 @@
+import subprocess
+import unittest
+import flake8.main
+import pep257
+import os.path
+import fnmatch
+import os
+import pylint.lint
+import sys
+
+class TestCodeFormatAndQuality(unittest.TestCase):
+
+    def setUp(self):
+        self.projectRootDir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+        projectTestsDir = os.path.join(self.projectRootDir, "test")
+        self.filesToAnalyze = []
+        for root, dirnames, filenames in os.walk(self.projectRootDir):
+            if root.startswith(projectTestsDir):
+                continue # Currently we skipping test files
+            for filename in fnmatch.filter(filenames, '*.py'):
+                fullFileName = os.path.join(root, filename)
+                relativeFileName = os.path.relpath(fullFileName, self.projectRootDir)
+                self.filesToAnalyze.append(relativeFileName)
+
+    def test_pep8_conformance(self):
+        maxCyclomaticComplexity = 10
+        errors = 0
+        for file in self.filesToAnalyze:
+            errors = errors + flake8.main.check_file(file, None, maxCyclomaticComplexity)
+
+        self.assertEqual(errors, 0, "Found code style errors or warnings.")
+
+    def test_pep257_conformance(self):
+        errors = []
+
+        for filePath in self.filesToAnalyze:
+            print("Processing file: {0}".format(filePath))
+            result = pep257.check_files([filePath])
+            if result:
+                errors.extend(result)
+                for error in result:
+                    print(error)
+                print
+        self.assertEqual(len(errors), 0, "Found Docstring Conventions violations.")
+
+    def test_pylint_conformance(self):
+        print
+        self.assertEqual(0,
+                         subprocess.call(
+                             ["pylint",
+                              '--rcfile=pylint.cfg',
+                              'generator',
+                              'Generator.py']
+                         ), "Found Pylint violations")
+        return
+
+if __name__ == '__main__':
+    unittest.main()
+
diff --git a/tools/intergen/CMakeLists.txt b/tools/intergen/CMakeLists.txt
new file mode 100644
index 000000000..b7fc7ed02
--- /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 000000000..8482a8206
--- /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 000000000..c6e052a2a
--- /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 000000000..f4fdfb45e
--- /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 000000000..c7ecf267b
--- /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 000000000..5f2ff4193
--- /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 000000000..07857ccf4
--- /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 000000000..4aaecd75c
--- /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 000000000..52937fb11
--- /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 000000000..6858d6f02
--- /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 000000000..21c379f8e
--- /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 000000000..6195d4d24
--- /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 000000000..ce8e39be5
--- /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 000000000..109d46791
--- /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 000000000..5278a2441
--- /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 000000000..a7b5a7c92
--- /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 000000000..b62332e1e
--- /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 000000000..c0818f1b1
--- /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 000000000..da63b4453
--- /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 000000000..6546a38ce
--- /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 000000000..8cc2d10b3
--- /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 000000000..6ec13c914
--- /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 000000000..29207313a
--- /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 000000000..3aef239ea
--- /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 000000000..a9f5ffec1
--- /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 000000000..64872f326
--- /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 000000000..270fe3024
--- /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 000000000..48e2d761f
--- /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 000000000..284f7ba45
--- /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 000000000..3dd851ccc
--- /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 000000000..5fd75760a
--- /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 000000000..f6bf2ef93
--- /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 000000000..d8c277fa7
--- /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 000000000..d2fd9fa4f
--- /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 000000000..b346e16df
--- /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 000000000..67364a257
--- /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 000000000..49bd758b6
--- /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 000000000..46e459198
--- /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 000000000..e2ad0ded0
--- /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 000000000..1b663c081
--- /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 000000000..ac88b5b96
--- /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 000000000..2ada8b723
--- /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 000000000..ca5b12e2d
--- /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 000000000..57b41523f
--- /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 000000000..3ebb9d3bc
--- /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 000000000..71c542ac6
--- /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 000000000..2cfc3ea0c
--- /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 000000000..897356439
--- /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 000000000..cd683801b
--- /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 000000000..494e279e5
--- /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 000000000..f02657358
--- /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 000000000..668577ec2
--- /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 000000000..33256c7e2
--- /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 000000000..5040652e4
--- /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 000000000..1cdb35478
--- /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 000000000..d51aa7b7e
--- /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 000000000..001f9a047
--- /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 000000000..5b509e96a
--- /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 000000000..08eedbca0
--- /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 000000000..e69c12921
--- /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 000000000..6deb18d1d
--- /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 000000000..a9951a253
--- /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 000000000..1730984cc
--- /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 000000000..ae60a53a7
--- /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 000000000..b3659905c
--- /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 000000000..963598418
--- /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 000000000..bbe32a076
--- /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 000000000..dc9398eb3
--- /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 000000000..e0e4f1f6c
--- /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 000000000..92dbbd5d5
--- /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 000000000..25aa55b65
--- /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 000000000..6263d28fe
--- /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 000000000..8fa3987fa
--- /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 000000000..b551bb76f
--- /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 000000000..2c5460352
--- /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 000000000..57e89cce5
--- /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 000000000..8320718ad
--- /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 000000000..9c9765ead
--- /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 000000000..af1bae2c5
--- /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 000000000..b6674c1e2
--- /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 000000000..a57b9a0db
--- /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 000000000..849168054
--- /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 000000000..fa173eb06
--- /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/test/CMakeLists.txt b/tools/intergen/test/CMakeLists.txt
new file mode 100644
index 000000000..f8af75c3b
--- /dev/null
+++ b/tools/intergen/test/CMakeLists.txt
@@ -0,0 +1,85 @@
+# Copyright (c) 2015, 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.
+if(BUILD_TESTS)
+include(${CMAKE_SOURCE_DIR}/tools/intergen/GenerateInterfaceLibrary.cmake)
+
+if (${HMI_DBUS_API})
+  GenerateInterfaceLibrary("test_interface.xml" test_rpc_interface DBUS_SUPPORT)
+else()
+  GenerateInterfaceLibrary("test_interface.xml" test_rpc_interface)
+endif()
+
+set (TEST_HMI_INTERFACES
+  common
+  buttons
+  navigation
+  basic_communication
+  tts
+  ui
+)
+
+if (${HMI_DBUS_API})
+  GenerateInterfaceLibrary("test_hmi_interface.xml" "${TEST_HMI_INTERFACES}" AUTO_FUNC_IDS DBUS_SUPPORT)
+else()
+  GenerateInterfaceLibrary("test_hmi_interface.xml" "${TEST_HMI_INTERFACES}" AUTO_FUNC_IDS)
+endif()
+
+include_directories (
+  ${CMAKE_SOURCE_DIR}/src/components/rpc_base/include
+  ${GMOCK_INCLUDE_DIRECTORY}
+  ${JSONCPP_INCLUDE_DIRECTORY}
+  ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+set (LIBRARIES
+    gtest
+    gtest_main
+    gmock
+    gmock_main
+    test_rpc_interface
+)
+
+set (SOURCES
+  generated_interface_json_tests.cc
+)
+
+if (${HMI_DBUS_API})
+  # Build dbus tests
+  include_directories(
+      ${CMAKE_SOURCE_DIR}/src/components/dbus/include
+      ${DBUS_INCLUDE_DIRS}
+  )
+  set (LIBRARIES ${LIBRARIES} DBus)
+  set (SOURCES ${SOURCES} generated_interface_dbus_tests.cc)
+endif ()
+
+
+create_test(test_generated_interface "${SOURCES}" "${LIBRARIES}")
+endif()  
\ No newline at end of file
diff --git a/tools/intergen/test/generated_interface_dbus_tests.cc b/tools/intergen/test/generated_interface_dbus_tests.cc
new file mode 100644
index 000000000..a510ccd77
--- /dev/null
+++ b/tools/intergen/test/generated_interface_dbus_tests.cc
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2015, 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 "gmock/gmock.h"
+
+#include <test_rpc_interface/interface.h>
+#include <test_rpc_interface/functions.h>
+
+#include "dbus/dbus_message.h"
+
+namespace test {
+using namespace rpc::test_rpc_interface;
+
+TEST(GeneratedInterfaceDbusTests, TestFailedDbusDeserialization) {
+  dbus::MessageRef msg(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL));
+  {
+    dbus::MessageWriter writer(msg);
+  }
+  {
+    dbus::MessageReader reader(msg);
+    request::DiagnosticMessage dm(&reader);
+    ASSERT_TRUE(reader.has_failed());
+    ASSERT_TRUE(dm.is_initialized());
+    ASSERT_FALSE(dm.is_valid());
+  }
+}
+
+TEST(GeneratedInterfaceDbusTests, TestDbusDeserialization) {
+  dbus::MessageRef msg(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL));
+  {
+    dbus::MessageWriter writer(msg);
+    writer.PutUint16(22);
+    writer.PutUint16(42);
+    dbus::MessageWriter array_writer(&writer, dbus::kArray, DBUS_TYPE_BYTE_AS_STRING);
+    array_writer.PutByte(11);
+  }
+  {
+    dbus::MessageReader reader(msg);
+    request::DiagnosticMessage dm(&reader);
+    ASSERT_FALSE(reader.has_failed());
+    ASSERT_FALSE(reader.HasNext());
+    ASSERT_TRUE(dm.is_initialized());
+    ASSERT_TRUE(dm.is_valid());
+    ASSERT_EQ(dm.targetID, 22);
+    ASSERT_EQ(dm.messageLength, 42);
+    ASSERT_EQ(dm.messageData.size(), 1u);
+  }
+}
+
+TEST(GeneratedInterfaceDbusTests, TestDbusSerializationDeserialization) {
+  dbus::MessageRef msg(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL));
+  {
+    dbus::MessageWriter writer(msg);
+    request::DiagnosticMessage dm;
+    dm.targetID = 70;
+    dm.messageLength = 1;
+    dm.messageData.push_back(42);
+    dm.ToDbusWriter(&writer);
+  }
+  {
+    dbus::MessageReader reader(msg);
+    request::DiagnosticMessage dm(&reader);
+    ASSERT_FALSE(reader.has_failed());
+    ASSERT_FALSE(reader.HasNext());
+    ASSERT_TRUE(dm.is_initialized());
+    ASSERT_TRUE(dm.is_valid());
+    ASSERT_EQ(dm.targetID, 70);
+    ASSERT_EQ(dm.messageLength, 1);
+    ASSERT_EQ(dm.messageData.size(), 1u);
+    ASSERT_EQ(dm.messageData[0], 42u);
+  }
+}
+
+TEST(GeneratedInterfaceDbusTests, TestDbusAddSubMenuSerializatioDeserialization) {
+  dbus::MessageRef msg(dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL));
+  {
+    dbus::MessageWriter writer(msg);
+    notification::DummyNotification dn;
+    TdStruct tds;
+    tds.resArrMap["Hello"].push_back(R_SUCCESS);
+    (*tds.optionalResArrMap)["World"].push_back(R_INVALID_DATA);
+    dn.tds.push_back(tds);
+    ASSERT_TRUE(dn.is_valid());
+    dn.ToDbusWriter(&writer);
+  }
+  {
+    dbus::MessageReader reader(msg);
+    notification::DummyNotification dn(&reader);
+    ASSERT_TRUE(dn.is_initialized());
+    ASSERT_TRUE(dn.is_valid());
+    ASSERT_FALSE(reader.has_failed());
+    ASSERT_FALSE(reader.HasNext());
+    ASSERT_EQ(dn.tds[0].resArrMap["Hello"][0], R_SUCCESS);
+    ASSERT_EQ((*dn.tds[0].optionalResArrMap)["World"][0], R_INVALID_DATA);
+  }
+}
+
+}  // namespace test
diff --git a/tools/intergen/test/generated_interface_json_tests.cc b/tools/intergen/test/generated_interface_json_tests.cc
new file mode 100644
index 000000000..995ff17e8
--- /dev/null
+++ b/tools/intergen/test/generated_interface_json_tests.cc
@@ -0,0 +1,627 @@
+/*
+ * Copyright (c) 2015, 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 "gmock/gmock.h"
+
+#include <test_rpc_interface/interface.h>
+#include <test_rpc_interface/functions.h>
+
+#include "json/reader.h"
+#include "json/writer.h"
+#include "rpc_base/gtest_support.h"
+
+namespace test {
+using namespace rpc::test_rpc_interface;
+using Json::Value;
+
+class TestRequestHandlerMock: public request::Handler {
+public:
+  MOCK_METHOD1(HandleAddSubMenu, void(const request::AddSubMenu& params));
+  MOCK_METHOD1(HandleDiagnosticMessage, void(const request::DiagnosticMessage& params));
+  ~TestRequestHandlerMock() {}
+};
+
+class GeneratedInterfaceTests: public ::testing::Test {
+ public:
+  Json::Value JsonValue(const char* json) {
+    Json::Value value;
+    reader.parse(json, value);
+    return value;
+  }
+  Json::Reader reader;
+  Json::FastWriter writer;
+};
+
+TEST_F(GeneratedInterfaceTests, ScrollableMessageTest) {
+  const char* org_json = "{\"reason\":\"MASTER_RESET\"}\n";
+  Value json_value = JsonValue(org_json);
+  notification::OnAppInterfaceUnregistered oaiu(&json_value);
+  ASSERT_TRUE(oaiu.is_initialized());
+  ASSERT_RPCTYPE_VALID(oaiu);
+
+  std::string serialized = writer.write(oaiu.ToJsonValue());
+  ASSERT_EQ(org_json, serialized);
+}
+
+TEST_F(GeneratedInterfaceTests, FunctionWithoutParams) {
+  notification::OnAudioPassThru oapt;
+  ASSERT_FALSE(oapt.is_initialized());
+  ASSERT_FALSE(oapt.is_valid());
+  oapt.mark_initialized();
+  ASSERT_TRUE(oapt.is_initialized());
+  ASSERT_RPCTYPE_VALID(oapt);
+  std::string serialized = writer.write(oapt.ToJsonValue());
+  ASSERT_EQ("{}\n", serialized);
+}
+
+TEST_F(GeneratedInterfaceTests, DefValueTest) {
+  const char* org_json = "{\"menuID\":2,\"menuName\":\"Hello\"}";
+  const char* awaited_json = "{\"menuID\":2,\"menuName\":\"Hello\",\"position\":1000}\n";
+  Value json_value = JsonValue(org_json);
+  request::AddSubMenu aasm(&json_value);
+  ASSERT_TRUE(aasm.is_initialized());
+  ASSERT_RPCTYPE_VALID(aasm);
+  ASSERT_EQ(aasm.position, 1000);
+
+  std::string serialized = writer.write(aasm.ToJsonValue());
+  ASSERT_EQ(awaited_json, serialized);
+}
+
+TEST_F(GeneratedInterfaceTests, MapTest) {
+  const char* expected_json =
+  "{\"choiceID\":1,\"menuName\":\"Menu name\",\"vrCommands\":{\"one\":\"First value\",\"two\":\"Second value\"}}\n";
+
+  Choice choice;
+  ASSERT_FALSE(choice.is_initialized());
+  ASSERT_FALSE(choice.is_valid());
+  std::map<std::string, std::string> init_map;
+  init_map.insert(std::make_pair("one", "First value"));
+  init_map.insert(std::make_pair("two", "Second value"));
+  choice = Choice(1, "Menu name", init_map);
+  ASSERT_TRUE(choice.is_initialized());
+  ASSERT_RPCTYPE_VALID(choice);
+
+  std::string serialized = writer.write(choice.ToJsonValue());
+  ASSERT_EQ(expected_json, serialized);
+}
+
+TEST_F(GeneratedInterfaceTests, TypedefTest) {
+  const char* expected_json =
+  "{\"optionalResArrMap\":{\"World\":[\"INVALID_DATA\"]},\"resArrMap\":{\"Hello\":[\"SUCCESS\"]}}\n";
+
+  TdStruct ts;
+  ts.resArrMap["Hello"].push_back(R_SUCCESS);
+  (*ts.optionalResArrMap)["World"].push_back(R_INVALID_DATA);
+  ASSERT_TRUE(ts.is_initialized());
+  ASSERT_RPCTYPE_VALID(ts);
+  std::string serialized = writer.write(ts.ToJsonValue());
+  ASSERT_EQ(expected_json, serialized);
+}
+
+//TODO(VVeremjova) APPLINK-12831 Fix constructors' work in case invalid values
+TEST_F(GeneratedInterfaceTests, DISABLED_OverflowedDiagnosticMessageTest) {
+  const char* input_json =
+      "{\"messageData\":[300, 20],\"messageLength\":2,\"targetID\":5}";
+  Value json_value = JsonValue(input_json);
+  request::DiagnosticMessage dm(&json_value);
+  ASSERT_TRUE(dm.is_initialized());
+  ASSERT_FALSE(dm.is_valid());
+}
+
+//TODO(VVeremjova) APPLINK-12831 Fix constructors' work in case invalid values
+TEST_F(GeneratedInterfaceTests, DISABLED_OverflowedDiagnosticMessageTest64) {
+  const char* input_json =
+      "{\"messageData\":[10, 123456789123],\"messageLength\":2,\"targetID\":5}";
+  Value json_value = JsonValue(input_json);
+  request::DiagnosticMessage dm(&json_value);
+  ASSERT_TRUE(dm.is_initialized());
+  ASSERT_FALSE(dm.is_valid());
+}
+
+TEST_F(GeneratedInterfaceTests, TestHandlerCalled) {
+  testing::StrictMock<TestRequestHandlerMock> mock;
+  request::AddSubMenu add_submenu;
+  EXPECT_CALL(mock, HandleAddSubMenu(testing::Ref(add_submenu)))
+      .Times(1);
+  add_submenu.HandleWith(&mock);
+}
+
+TEST_F(GeneratedInterfaceTests, TestFactory) {
+  testing::StrictMock<TestRequestHandlerMock> mock;
+  Json::Value json_value;
+  request::Request* req = request::NewFromJson(&json_value, kAddSubMenuID);
+  request::AddSubMenu& add_sub_menu_ref =
+      static_cast<request::AddSubMenu&>(*req);
+  EXPECT_CALL(mock, HandleAddSubMenu(testing::Ref(add_sub_menu_ref)))
+      .Times(1);
+  req->HandleWith(&mock);
+}
+
+TEST_F(GeneratedInterfaceTests, TestNullableStructMember) {
+  TestStructWithNullableParam with_nullable;
+  ASSERT_FALSE(with_nullable.is_initialized());
+  ASSERT_FALSE(with_nullable.is_valid());
+  ASSERT_FALSE(with_nullable.nullableInt.is_valid());
+  ASSERT_FALSE(with_nullable.nullableInt.is_null());
+  with_nullable.nullableInt.set_to_null();
+  ASSERT_RPCTYPE_VALID(with_nullable);
+  ASSERT_TRUE(with_nullable.is_initialized());
+  ASSERT_TRUE(with_nullable.nullableInt.is_null());
+  ASSERT_RPCTYPE_VALID(with_nullable.nullableInt);
+  ASSERT_TRUE(with_nullable.nullableInt.is_initialized());
+}
+
+TEST_F(GeneratedInterfaceTests, TestNullableStructMemberNullInitializationFromJson) {
+  const char* input_json =
+      "{\"nullableInt\":null}\n";
+  Value json_value = JsonValue(input_json);
+  TestStructWithNullableParam with_nullable(&json_value);
+  ASSERT_TRUE(with_nullable.is_initialized());
+  ASSERT_RPCTYPE_VALID(with_nullable);
+  ASSERT_TRUE(with_nullable.nullableInt.is_null());
+  std::string result = writer.write(with_nullable.ToJsonValue());
+  ASSERT_EQ(input_json, result);
+}
+
+TEST_F(GeneratedInterfaceTests, TestNullableStructMemberInitializationFromJson) {
+  const char* input_json =
+      "{\"nullableInt\":3}\n";
+  Value json_value = JsonValue(input_json);
+  TestStructWithNullableParam with_nullable(&json_value);
+  ASSERT_TRUE(with_nullable.is_initialized());
+  ASSERT_RPCTYPE_VALID(with_nullable);
+  ASSERT_FALSE(with_nullable.nullableInt.is_null());
+  ASSERT_EQ(3, with_nullable.nullableInt);
+  std::string result = writer.write(with_nullable.ToJsonValue());
+  ASSERT_EQ(input_json, result);
+}
+
+TEST_F(GeneratedInterfaceTests, TestNullableEnumInitialization) {
+  TestStructWithNullableStructParam strct_with_nullable;
+  strct_with_nullable.nullableEnum = IT_DYNAMIC;
+  strct_with_nullable.nonNullableEnum = IT_STATIC;
+  ASSERT_TRUE(strct_with_nullable.is_initialized());
+  ASSERT_RPCTYPE_VALID(strct_with_nullable);
+  std::string result = writer.write(strct_with_nullable.ToJsonValue());
+  const char* awaited_json1 = "{\"nonNullableEnum\":\"STATIC\",\"nullableEnum\":\"DYNAMIC\"}\n";
+  ASSERT_EQ(awaited_json1, result);
+
+  strct_with_nullable.nullableEnum.set_to_null();
+  ASSERT_TRUE(strct_with_nullable.is_initialized());
+  ASSERT_RPCTYPE_VALID(strct_with_nullable);
+  result = writer.write(strct_with_nullable.ToJsonValue());
+  const char* awaited_json2 = "{\"nonNullableEnum\":\"STATIC\",\"nullableEnum\":null}\n";
+  ASSERT_EQ(awaited_json2, result);
+}
+
+TEST_F(GeneratedInterfaceTests, TestStructWithNullableTypedef) {
+  StructWithNullableTypedef swntd;
+  ASSERT_FALSE(swntd.is_initialized());
+  ASSERT_FALSE(swntd.is_valid());
+  swntd.nullableTdResult = R_SUCCESS;
+  ASSERT_TRUE(swntd.is_initialized());
+  ASSERT_RPCTYPE_VALID(swntd);
+  ASSERT_EQ(R_SUCCESS, swntd.nullableTdResult);
+
+  swntd.nullableTdResult.set_to_null();
+  const char* awaited_json = "{\"nullableTdResult\":null}\n";
+  std::string result = writer.write(swntd.ToJsonValue());
+  ASSERT_EQ(awaited_json, result);
+}
+
+TEST_F(GeneratedInterfaceTests, TestNullingStructWithNullableMapOfNullableInts) {
+  StructWithNullableMapOfNullableInts nmoni;
+  ASSERT_FALSE(nmoni.is_initialized());
+  ASSERT_FALSE(nmoni.is_valid());
+  ASSERT_FALSE(nmoni.nullableMap.is_null());
+  nmoni.nullableMap.set_to_null();
+  ASSERT_TRUE(nmoni.is_initialized());
+  ASSERT_RPCTYPE_VALID(nmoni);
+  ASSERT_TRUE(nmoni.nullableMap.is_null());
+  const char* awaited_json = "{\"nullableMap\":null}\n";
+  std::string result = writer.write(nmoni.ToJsonValue());
+  ASSERT_EQ(awaited_json, result);
+}
+
+TEST_F(GeneratedInterfaceTests, TestNullingValueInStructWithNullableMapOfNullableInts) {
+  StructWithNullableMapOfNullableInts nmoni;
+  ASSERT_FALSE(nmoni.is_initialized());
+  ASSERT_FALSE(nmoni.is_valid());
+  ASSERT_FALSE(nmoni.nullableMap.is_null());
+  nmoni.nullableMap["Hello"].set_to_null();
+
+  ASSERT_TRUE(nmoni.is_initialized());
+  ASSERT_RPCTYPE_VALID(nmoni);
+  ASSERT_FALSE(nmoni.nullableMap.is_null());
+  ASSERT_TRUE(nmoni.nullableMap["Hello"].is_null());
+  const char* awaited_json = "{\"nullableMap\":{\"Hello\":null}}\n";
+  std::string result = writer.write(nmoni.ToJsonValue());
+  ASSERT_EQ(awaited_json, result);
+}
+
+TEST_F(GeneratedInterfaceTests, EmptyStructTests) {
+  EmptyStruct e;
+  ASSERT_TRUE(e.struct_empty());
+  ASSERT_FALSE(e.is_valid());
+  ASSERT_FALSE(e.is_initialized());
+  e.mark_initialized();
+  ASSERT_TRUE(e.struct_empty());
+  ASSERT_RPCTYPE_VALID(e);
+  ASSERT_TRUE(e.is_initialized());
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithOptionalEmptyStructFieldTest) {
+  StructWithOptionalEmptyStructField oe;
+  ASSERT_FALSE(oe.is_valid());
+  ASSERT_FALSE(oe.is_initialized());
+  oe.emptyOne->mark_initialized();
+  ASSERT_RPCTYPE_VALID(oe);
+  ASSERT_TRUE(oe.is_initialized());
+  ASSERT_FALSE(oe.struct_empty());
+  ASSERT_TRUE(oe.emptyOne->struct_empty());
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithMandatoryEmptyStructFieldTest) {
+  StructWithMandatoryEmptyStructField me;
+  ASSERT_FALSE(me.is_valid());
+  ASSERT_FALSE(me.is_initialized());
+}
+
+TEST_F(GeneratedInterfaceTests, EmptyStructJsonTests) {
+  EmptyStruct e;
+  ASSERT_FALSE(e.is_valid());
+  ASSERT_FALSE(e.is_initialized());
+  e.mark_initialized();
+  ASSERT_RPCTYPE_VALID(e);
+  ASSERT_TRUE(e.is_initialized());
+  const char* expected_json = "{}\n";
+  ASSERT_EQ(expected_json, writer.write(e.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithOptionalEmptyStructFieldJsonTest) {
+  StructWithOptionalEmptyStructField oe;
+  ASSERT_FALSE(oe.is_valid());
+  ASSERT_FALSE(oe.is_initialized());
+  oe.mark_initialized();
+  ASSERT_RPCTYPE_VALID(oe);
+  ASSERT_TRUE(oe.is_initialized());
+  const char* expected_json = "{}\n";
+  ASSERT_EQ(expected_json, writer.write(oe.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithMandatoryEmptyStructFieldJsonTest) {
+  StructWithMandatoryEmptyStructField me;
+  ASSERT_FALSE(me.is_valid());
+  ASSERT_FALSE(me.is_initialized());
+  me.emptyOne.mark_initialized();
+  ASSERT_RPCTYPE_VALID(me);
+  ASSERT_TRUE(me.is_initialized());
+  const char* expected_json = "{\"emptyOne\":{}}\n";
+  ASSERT_EQ(expected_json, writer.write(me.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithOneOptionalIntFieldTest) {
+  StructWithOneOptionalIntField soo;
+  ASSERT_FALSE(soo.is_valid());
+  ASSERT_FALSE(soo.is_initialized());
+  soo.mark_initialized();
+  ASSERT_TRUE(soo.is_initialized());
+  ASSERT_RPCTYPE_VALID(soo);
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithOneOptionalInitializedIntFieldTest) {
+  StructWithOneOptionalIntField soo;
+  *soo.optionalInt = 13;
+  ASSERT_RPCTYPE_VALID(soo);
+  ASSERT_TRUE(soo.is_initialized());
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithOneOptionalIntFieldJsonTest) {
+  StructWithOneOptionalIntField soo;
+  ASSERT_FALSE(soo.is_valid());
+  ASSERT_FALSE(soo.is_initialized());
+  soo.mark_initialized();
+  const char* expected_json = "{}\n";
+  ASSERT_EQ(expected_json, writer.write(soo.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithOneInitializedOptionalIntFieldJsonTest) {
+  const char* input_json = "{\"optionalInt\":11}\n";
+  Json::Value json_value = JsonValue(input_json);
+  StructWithOneOptionalIntField soo(&json_value);
+  ASSERT_RPCTYPE_VALID(soo);
+  ASSERT_TRUE(soo.is_initialized());
+  ASSERT_EQ(11, *soo.optionalInt);
+  ASSERT_EQ(input_json, writer.write(soo.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithFieldOfStructThatMightBeEmptyTest) {
+  StructWithFieldOfStructThatMightBeEmpty sfme;
+  ASSERT_FALSE(sfme.is_valid());
+  ASSERT_FALSE(sfme.is_initialized());
+  ASSERT_TRUE(sfme.struct_empty());
+  *sfme.fieldThatMightBeEmpty.optionalInt = 5;
+  ASSERT_FALSE(sfme.struct_empty());
+  ASSERT_RPCTYPE_VALID(sfme);
+  ASSERT_TRUE(sfme.is_initialized());
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithFieldOfStructThatMightBeEmptyJsonNoValueTest) {
+  StructWithFieldOfStructThatMightBeEmpty sfme;
+  ASSERT_TRUE(sfme.struct_empty());
+  ASSERT_FALSE(sfme.is_valid());
+  ASSERT_FALSE(sfme.is_initialized());
+  sfme.fieldThatMightBeEmpty.mark_initialized();
+  ASSERT_FALSE(sfme.struct_empty());
+  ASSERT_RPCTYPE_VALID(sfme);
+  ASSERT_TRUE(sfme.is_initialized());
+  const char* expcected_json = "{\"fieldThatMightBeEmpty\":{}}\n";
+  ASSERT_EQ(expcected_json, writer.write(sfme.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithFieldOfStructThatMightBeEmptyJsonHasValueTest) {
+  const char* input_json = "{\"fieldThatMightBeEmpty\":{\"optionalInt\":12}}\n";
+  Json::Value json_value = JsonValue(input_json);
+  StructWithFieldOfStructThatMightBeEmpty sfme(&json_value);
+  ASSERT_RPCTYPE_VALID(sfme);
+  ASSERT_TRUE(sfme.is_initialized());
+  ASSERT_EQ(12, *sfme.fieldThatMightBeEmpty.optionalInt);
+  ASSERT_EQ(input_json, writer.write(sfme.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithFieldOfOptionalMapTest) {
+  StructWithNullableOptionalMap snom;
+  ASSERT_TRUE(snom.struct_empty());
+  ASSERT_FALSE(snom.is_valid());
+  ASSERT_FALSE(snom.is_initialized());
+  (*snom.nullableOptionalIntMap)["a"] = 5;
+  ASSERT_FALSE(snom.struct_empty());
+  ASSERT_RPCTYPE_VALID(snom);
+  ASSERT_TRUE(snom.is_initialized());
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithFieldOfOptionalMapToJsonTest) {
+  StructWithNullableOptionalMap snom;
+  ASSERT_TRUE(snom.struct_empty());
+  ASSERT_FALSE(snom.is_valid());
+  ASSERT_FALSE(snom.is_initialized());
+  snom.mark_initialized();
+  ASSERT_TRUE(snom.struct_empty());
+  ASSERT_RPCTYPE_VALID(snom);
+  ASSERT_TRUE(snom.is_initialized());
+  const char* expected_json = "{}\n";
+  ASSERT_EQ(expected_json, writer.write(snom.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithFieldOfOptionalMapNulledToJsonTest) {
+  StructWithNullableOptionalMap snom;
+  ASSERT_TRUE(snom.struct_empty());
+  ASSERT_FALSE(snom.is_valid());
+  ASSERT_FALSE(snom.is_initialized());
+  snom.nullableOptionalIntMap->set_to_null();
+  ASSERT_FALSE(snom.struct_empty());
+  ASSERT_RPCTYPE_VALID(snom);
+  ASSERT_TRUE(snom.is_initialized());
+  const char* expected_json = "{\"nullableOptionalIntMap\":null}\n";
+  ASSERT_EQ(expected_json, writer.write(snom.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithFieldOfOptionalMapNulledInJsonTest) {
+  const char* input_json = "{\"nullableOptionalIntMap\":null}\n";
+  Json::Value json_value = JsonValue(input_json);
+  StructWithNullableOptionalMap snom(&json_value);
+  ASSERT_RPCTYPE_VALID(snom);
+  ASSERT_TRUE(snom.is_initialized());
+  ASSERT_TRUE(snom.nullableOptionalIntMap->is_null());
+  ASSERT_EQ(input_json, writer.write(snom.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithFieldOfOptionalMapInitializedInJsonTest) {
+  const char* input_json = "{\"nullableOptionalIntMap\":{\"Hello\":2}}\n";
+  Json::Value json_value = JsonValue(input_json);
+  StructWithNullableOptionalMap snom(&json_value);
+  ASSERT_RPCTYPE_VALID(snom);
+  ASSERT_TRUE(snom.is_initialized());
+  ASSERT_FALSE(snom.nullableOptionalIntMap->is_null());
+  ASSERT_EQ(input_json, writer.write(snom.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithOptionalArrayTest) {
+  const char* expected_json = "{}\n";
+  StructWithOptionalIntArray soia;
+  ASSERT_TRUE(soia.struct_empty());
+  ASSERT_FALSE(soia.is_valid());
+  ASSERT_FALSE(soia.is_initialized());
+  soia.mark_initialized();
+  ASSERT_EQ(expected_json, writer.write(soia.ToJsonValue()));
+  (*soia.optionalIntArray).push_back(2);
+  ASSERT_RPCTYPE_VALID(soia);
+  ASSERT_TRUE(soia.is_initialized());
+  const char* expected_json2 = "{\"optionalIntArray\":[2]}\n";
+  ASSERT_EQ(expected_json2, writer.write(soia.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithMandatoryArrayTest) {
+  const char* expected_json = "{\"mandatoryIntArray\":[]}\n";
+  StructWithMandatoryIntArray smia;
+  ASSERT_FALSE(smia.is_valid());
+  ASSERT_FALSE(smia.is_initialized());
+  smia.mandatoryIntArray.mark_initialized();
+  ASSERT_RPCTYPE_VALID(smia);
+  ASSERT_TRUE(smia.is_initialized());
+  ASSERT_EQ(expected_json, writer.write(smia.ToJsonValue()));
+
+  smia.mandatoryIntArray.push_back(3);
+  ASSERT_RPCTYPE_VALID(smia);
+  ASSERT_TRUE(smia.is_initialized());
+  const char* expected_json2 = "{\"mandatoryIntArray\":[3]}\n";
+  ASSERT_EQ(expected_json2, writer.write(smia.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithOptionalMapTest) {
+  const char* expected_json = "{}\n";
+  StructWithOptionalIntMap soim;
+  ASSERT_TRUE(soim.struct_empty());
+  ASSERT_FALSE(soim.is_valid());
+  ASSERT_FALSE(soim.is_initialized());
+  soim.mark_initialized();
+  ASSERT_TRUE(soim.struct_empty());
+  ASSERT_RPCTYPE_VALID(soim);
+  ASSERT_TRUE(soim.is_initialized());
+  ASSERT_EQ(expected_json, writer.write(soim.ToJsonValue()));
+  (*soim.optionalIntMap)["Yay"] = 2;
+  ASSERT_RPCTYPE_VALID(soim);
+  ASSERT_TRUE(soim.is_initialized());
+  const char* expected_json2 = "{\"optionalIntMap\":{\"Yay\":2}}\n";
+  ASSERT_EQ(expected_json2, writer.write(soim.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithMandatoryMapTest) {
+  const char* expected_json = "{\"mandatoryIntMap\":{}}\n";
+  StructWithMandatoryIntMap smim;
+  ASSERT_FALSE(smim.is_valid());
+  ASSERT_FALSE(smim.is_initialized());
+  smim.mandatoryIntMap.mark_initialized();
+  ASSERT_RPCTYPE_VALID(smim);
+  ASSERT_TRUE(smim.is_initialized());
+  ASSERT_EQ(expected_json, writer.write(smim.ToJsonValue()));
+  smim.mandatoryIntMap["Yay"] = 2;
+  ASSERT_RPCTYPE_VALID(smim);
+  ASSERT_TRUE(smim.is_initialized());
+  const char* expected_json2 = "{\"mandatoryIntMap\":{\"Yay\":2}}\n";
+  ASSERT_EQ(expected_json2, writer.write(smim.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, StructWithMandatoryMapInitFromWrongJsonTest) {
+  const char* empty_json = "{}\n";
+  Json::Value json_value = JsonValue(empty_json);
+
+  StructWithMandatoryIntMap smim(&json_value);
+
+  ASSERT_TRUE(smim.struct_empty());
+  ASSERT_FALSE(smim.is_valid());
+  ASSERT_TRUE(smim.is_initialized());
+
+  smim.mandatoryIntMap["Yay"] = 2;
+  ASSERT_FALSE(smim.struct_empty());
+  ASSERT_RPCTYPE_VALID(smim);
+  ASSERT_TRUE(smim.is_initialized());
+  const char* expected_json = "{\"mandatoryIntMap\":{\"Yay\":2}}\n";
+  ASSERT_EQ(expected_json, writer.write(smim.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, ReportIncorrectlyInitializedMap1) {
+  StructWithMandatoryIntMap smim;
+  smim.mark_initialized();
+  ASSERT_FALSE(smim.is_valid());
+  rpc::ValidationReport report("smim");
+  smim.ReportErrors(&report);
+  ASSERT_EQ("smim.mandatoryIntMap: object is not initialized\n", PrettyFormat(report));
+}
+
+TEST_F(GeneratedInterfaceTests, ReportIncorrectlyInitializedMap2) {
+  Choice c;
+  ASSERT_FALSE(c.is_valid());
+  rpc::ValidationReport report("c");
+  c.ReportErrors(&report);
+  ASSERT_EQ("c: object is not initialized\n"
+            "c.choiceID: value is not initialized\n"
+            "c.menuName: value is not initialized\n"
+            "c.vrCommands: object is not initialized\n", PrettyFormat(report));
+}
+
+TEST_F(GeneratedInterfaceTests, TestFrankenstructCreation) {
+  FrankenstructOfEmptyStringWithMandatoryInt fbmi;
+  ASSERT_FALSE(fbmi.is_valid());
+  ASSERT_FALSE(fbmi.is_initialized());
+  ASSERT_TRUE(fbmi.empty());
+  ASSERT_TRUE(fbmi.struct_empty());
+  fbmi.mandatoryInt = 5;
+  ASSERT_FALSE(fbmi.struct_empty());
+  ASSERT_TRUE(fbmi.empty());
+  ASSERT_TRUE(fbmi.is_initialized());
+
+  // Ok known bug: frankenstructs must be explicitly marked initialized
+  // or has values in map
+  ASSERT_FALSE(fbmi.is_valid());
+  fbmi.mark_initialized();
+  ASSERT_RPCTYPE_VALID(fbmi);
+
+  ASSERT_TRUE(fbmi.is_initialized());
+
+  rpc::ValidationReport report("fbmi");
+  fbmi.ReportErrors(&report);
+  ASSERT_EQ("", PrettyFormat(report));
+}
+
+TEST_F(GeneratedInterfaceTests, FrankenstructToJson) {
+  const char* expected_json = "{\"hello\":\"str\",\"mandatoryInt\":2}\n";
+  FrankenstructOfEmptyStringWithMandatoryInt fbmi;
+  fbmi.mandatoryInt = 2;
+  fbmi["hello"] = "str";
+  ASSERT_TRUE(fbmi.is_initialized());
+  ASSERT_RPCTYPE_VALID(fbmi);
+  ASSERT_FALSE(fbmi.empty());
+  ASSERT_FALSE(fbmi.struct_empty());
+  ASSERT_EQ(expected_json,
+            writer.write(fbmi.ToJsonValue()));
+}
+
+TEST_F(GeneratedInterfaceTests, FrankenstructFromJson) {
+  const char* input_json = "{\"hello\":\"str\",\"mandatoryInt\":2}\n";
+  Json::Value json_value = JsonValue(input_json);
+  FrankenstructOfEmptyStringWithMandatoryInt fbmi(&json_value);
+  ASSERT_TRUE(fbmi.is_initialized());
+  ASSERT_RPCTYPE_VALID(fbmi);
+  ASSERT_FALSE(fbmi.empty());
+  ASSERT_FALSE(fbmi.struct_empty());
+  ASSERT_EQ(1u, fbmi.size());
+  ASSERT_EQ(2, fbmi.mandatoryInt);
+  ASSERT_EQ("str", std::string(fbmi["hello"]));
+}
+
+TEST_F(GeneratedInterfaceTests, FrankenstructFromInvalidJson) {
+  const char* input_json = "{\"hello\":true,\"mandatoryInt\":2}\n";
+  Json::Value json_value = JsonValue(input_json);
+  FrankenstructOfEmptyStringWithMandatoryInt fbmi(&json_value);
+  ASSERT_TRUE(fbmi.is_initialized());
+  ASSERT_FALSE(fbmi.is_valid());
+  ASSERT_FALSE(fbmi.empty());
+  ASSERT_FALSE(fbmi.struct_empty());
+  ASSERT_EQ(1u, fbmi.size());
+  ASSERT_EQ(2, fbmi.mandatoryInt);
+  rpc::ValidationReport report("fbmi");
+  fbmi.ReportErrors(&report);
+  ASSERT_EQ("fbmi[\"hello\"]: value initialized incorrectly\n", PrettyFormat(report));
+}
+
+}  // namespace test
diff --git a/tools/intergen/test/test_hmi_interface.xml b/tools/intergen/test/test_hmi_interface.xml
new file mode 100644
index 000000000..e09190983
--- /dev/null
+++ b/tools/intergen/test/test_hmi_interface.xml
@@ -0,0 +1,3669 @@
+<?xml version="1.0" standalone="yes"?>
+
+<!--
+* Copyright (c) 2015, 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. -->
+
+
+<interfaces name="SmartDeviceLink HMI API">
+
+<interface name="Common" version="1.1" date="2013-10-02">
+
+<enum name="Result">
+	<element name="SUCCESS" value="0"/>
+    <element name="UNSUPPORTED_REQUEST" value="1"/>
+    <element name="UNSUPPORTED_RESOURCE" value="2"/>
+    <element name="DISALLOWED" value="3"/>
+    <element name="REJECTED" value="4"/>
+    <element name="ABORTED" value="5"/>
+    <element name="IGNORED" value="6"/>
+    <element name="RETRY" value="7"/>
+    <element name="IN_USE"  value="8"/>
+    <element name="DATA_NOT_AVAILABLE" value="9"/>
+    <element name="TIMED_OUT" value="10"/>
+    <element name="INVALID_DATA" value="11"/>
+    <element name="CHAR_LIMIT_EXCEEDED" value="12"/>
+    <element name="INVALID_ID" value="13"/>
+    <element name="DUPLICATE_NAME" value="14"/>
+    <element name="APPLICATION_NOT_REGISTERED" value="15"/>
+    <element name="WRONG_LANGUAGE" value="16"/>
+    <element name="OUT_OF_MEMORY" value="17"/>
+    <element name="TOO_MANY_PENDING_REQUESTS" value="18"/>
+    <element name="NO_APPS_REGISTERED" value="19"/>
+    <element name="NO_DEVICES_CONNECTED" value="20"/>
+    <element name="WARNINGS" value="21"/>
+    <element name="GENERIC_ERROR" value="22"/>
+    <element name="USER_DISALLOWED" value="23"/>
+</enum>
+
+<enum name="ButtonName">
+    <description>Defines the hard (physical) and soft (touchscreen) buttons available from SYNC</description>
+    <element name="OK"/>
+    <element name="SEEKLEFT"/>
+    <element name="SEEKRIGHT"/>
+    <element name="TUNEUP"/>
+    <element name="TUNEDOWN"/>
+    <element name="PRESET_0"/>
+    <element name="PRESET_1"/>
+    <element name="PRESET_2"/>
+    <element name="PRESET_3"/>
+    <element name="PRESET_4"/>
+    <element name="PRESET_5"/>
+    <element name="PRESET_6"/>
+    <element name="PRESET_7"/>
+    <element name="PRESET_8"/>
+    <element name="PRESET_9"/>
+    <element name="CUSTOM_BUTTON"/>
+	<element name="SEARCH"/>
+</enum>
+
+<enum name="ButtonEventMode">
+    <element name="BUTTONUP">
+        <description>A button has been released up</description>
+    </element>
+    <element name="BUTTONDOWN">
+        <description>A button has been pressed down</description>
+    </element>
+</enum>
+
+<enum name="ButtonPressMode">
+    <element name="LONG">
+        <description>A button was released, after it was pressed for a long time. Actual timing is defined by head unit and may vary</description>
+    </element>
+    <element name="SHORT">
+        <description>A button was released, after it was pressed for a short time. Actual timing is defined by head unit and may vary</description>
+    </element>
+</enum>
+
+ <enum name="Language">
+     <element name="EN-US" internal_name="EN_US">
+      <description>English - US</description>
+    </element>
+    <element name="ES-MX" internal_name="ES_MX">
+      <description>Spanish - Mexico</description>
+    </element>
+    <element name="FR-CA" internal_name="FR_CA">
+      <description>French - Canada</description>
+    </element>
+    <element name="DE-DE" internal_name="DE_DE">
+      <description>German - Germany</description>
+    </element>
+     <element name="ES-ES" internal_name="ES_ES">
+      <description>Spanish - Spain</description>
+    </element>
+    <element name="EN-GB" internal_name="EN_GB">
+      <description>English - GB</description>
+    </element>
+     <element name="RU-RU" internal_name="RU_RU">
+      <description>Russian - Russia</description>
+    </element>
+     <element name="TR-TR" internal_name="TR_TR">
+      <description>Turkish - Turkey</description>
+    </element>
+     <element name="PL-PL" internal_name="PL_PL">
+      <description>Polish - Poland</description>
+    </element>
+     <element name="FR-FR" internal_name="FR_FR">
+      <description>French - France</description>
+    </element>
+     <element name="IT-IT" internal_name="IT_IT">
+      <description>Italian - Italy</description>
+    </element>
+     <element name="SV-SE" internal_name="SV_SE">
+      <description>Swedish - Sweden</description>
+    </element>
+     <element name="PT-PT" internal_name="PT_PT">
+      <description>Portuguese - Portugal</description>
+    </element>
+     <element name="NL-NL" internal_name="NL_NL">
+      <description>Dutch (Standard) - Netherlands</description>
+    </element>
+     <element name="EN-AU" internal_name="EN_AU">
+      <description>English - Australia</description>
+    </element>
+     <element name="ZH-CN" internal_name="ZH_CN">
+      <description>Mandarin - China</description>
+    </element>
+     <element name="ZH-TW" internal_name="ZH_TW">
+      <description>Mandarin - Taiwan</description>
+    </element>
+     <element name="JA-JP" internal_name="JA_JP">
+      <description>Japanese - Japan</description>
+    </element>
+     <element name="AR-SA" internal_name="AR_SA">
+      <description>Arabic - Saudi Arabia</description>
+    </element>
+     <element name="KO-KR" internal_name="KO_KR">
+      <description>Korean - South Korea</description>
+    </element>
+     <element name="PT-BR" internal_name="PT_BR">
+      <description>Portuguese - Brazil</description>
+    </element>
+     <element name="CS-CZ" internal_name="CS_CZ">
+      <description>Czech - Czech Republic</description>
+    </element>
+     <element name="DA-DK" internal_name="DA_DK">
+      <description>Danish - Denmark</description>
+    </element>
+     <element name="NO-NO" internal_name="NO_NO">
+      <description>Norwegian - Norway</description>
+    </element>
+</enum>
+
+<enum name="SoftButtonType">
+  <description>Contains information about the SoftButton capabilities.</description>
+  <element name="TEXT" internal_name="SBT_TEXT"/>
+  <element name="IMAGE" internal_name="SBT_IMAGE"/>
+  <element name="BOTH" internal_name="SBT_BOTH"/>
+</enum>
+
+<enum name="SystemAction">
+  <description>Enumeration that describes system actions that can be triggered.</description>
+  <element name="DEFAULT_ACTION">
+    <description>Default action occurs.  Standard behavior (e.g. SoftButton clears overlay).</description>
+  </element>
+  <element name="STEAL_FOCUS">
+    <description>The calling app's dialog or related event should clear and the app should be brought into HMI_FULL.</description>
+  </element>
+  <element name="KEEP_CONTEXT">
+    <description>Current system context is maintained.  An overlay is persisted even though a SoftButton has been pressed and the notification sent.</description>
+  </element>
+</enum>
+
+<enum name="AppHMIType">
+  <description>Enumeration listing possible app types.</description>
+  <element name="DEFAULT" />
+  <element name="COMMUNICATION" />
+  <element name="MEDIA" />
+  <element name="MESSAGING" />
+  <element name="NAVIGATION" />
+  <element name="INFORMATION" />
+  <element name="SOCIAL" />
+  <element name="BACKGROUND_PROCESS" />
+  <element name="TESTING" />
+  <element name="SYSTEM" />
+</enum>
+
+<enum name="LayoutMode">
+  <description>For touchscreen interactions, the mode of how the choices are presented.</description>
+  <element name="ICON_ONLY" />
+    <description>This mode causes the interaction to display the previous set of choices as icons.</description>
+  <element name="ICON_WITH_SEARCH" />
+    <description>This mode causes the interaction to display the previous set of choices as icons along with a search field in the HMI.</description>
+  <element name="LIST_ONLY" />
+    <description>This mode causes the interaction to display the previous set of choices as a list.</description>
+  <element name="LIST_WITH_SEARCH" />
+    <description>This mode causes the interaction to display the previous set of choices as a list along with a search field in the HMI.</description>
+  <element name="KEYBOARD" />
+    <description>This mode causes the interaction to immediately display a keyboard entry through the HMI.</description>
+</enum>
+
+<enum name="DeactivateReason">
+  <description>Specifies the functionality the User has switched to.</description>
+  <element name="AUDIO">
+      <description>Navigated to audio(radio, etc)</description>
+  </element>
+  <element name="PHONECALL">
+      <description>Navigated to make a call.</description>
+  </element>
+  <element name="NAVIGATIONMAP">
+      <description>Navigated to navigation screen.</description>
+  </element>
+  <element name="PHONEMENU">
+      <description>Navigated to phone menu.</description>
+  </element>
+  <element name="SYNCSETTINGS">
+      <description>Navigated to settings menu.</description>
+  </element>
+  <element name="GENERAL">
+      <description>Other screens navigation apart from other mobile app.</description>
+  </element>
+</enum>
+
+<enum name="ClockUpdateMode">
+  <description>Describes how the media clock timer should behave on the platform</description>
+  <element name="COUNTUP" />
+  <description>Starts the media clock timer counting upwards, as in time elapsed.</description>
+  <element name="COUNTDOWN" />
+  <description>Starts the media clock timer counting downwards, as in time remaining.</description>
+  <element name="PAUSE" />
+  <description>Pauses the media clock timer</description>
+  <element name="RESUME" />
+  <description>Resume the media clock timer</description>
+  <element name="CLEAR" />
+  <description>Clears the media clock timer (previously done through Show->mediaClock)</description>
+</enum>
+
+<enum name="SystemContext">
+  <description>Enumeration that describes possible contexts the application might be in on HU.</description>
+  <description>Communicated to whichever app is in HMI FULL, except Alert.</description>
+  <element name="MAIN" internal_name="SYSCTXT_MAIN">
+    <description>The app's persistent display (whether media/non-media/navigation) is fully visible onscreen.</description>
+    <description> There is currently no user interaction (user-initiated or app-initiated) with the head-unit</description>
+  </element>
+  <element name="VRSESSION" internal_name="SYSCTXT_VRSESSION">
+    <description>The system is currently in a VR session (with whatever dedicated VR screen being overlaid onscreen).</description>
+  </element>
+  <element name="MENU" internal_name="SYSCTXT_MENU">
+    <description>The system is currently displaying a system or in-App menu onscreen.</description>
+  </element>
+  <element name="HMI_OBSCURED" internal_name="SYSCTXT_HMI_OBSCURED">
+    <description>The app's display HMI is currently obscuring with either a system or other app's overlay (except of Alert element).</description>
+  </element>
+  <element name="ALERT" internal_name="SYSCTXT_ALERT">
+    <description>Broadcast only to whichever app has an alert currently being displayed.</description>
+  </element>
+</enum>
+
+<enum name="HmiZoneCapabilities">
+  <description>Contains information about the HMI zone capabilities.</description>
+  <description>For future use.</description>
+  <element name="FRONT" />
+  <element name="BACK" />
+</enum>
+
+<enum name="SpeechCapabilities">
+  <description>Contains information about the TTS capabilities.</description>
+  <element name="TEXT" internal_name="SC_TEXT" />
+  <element name="SAPI_PHONEMES" />
+  <element name="LHPLUS_PHONEMES" />
+  <element name="PRE_RECORDED" />
+  <element name="SILENCE" />
+</enum>
+
+<enum name="VrCapabilities">
+  <description>Contains information about the VR capabilities.</description>
+  <element name="TEXT" internal_name="VR_TEXT" />
+</enum>
+
+<enum name="TBTState">
+  <description>Enumeration that describes possible states of turn-by-turn client or SmartDeviceLink app.</description>
+  <element name="ROUTE_UPDATE_REQUEST" />
+  <element name="ROUTE_ACCEPTED" />
+  <element name="ROUTE_REFUSED" />
+  <element name="ROUTE_CANCELLED" />
+  <element name="ETA_REQUEST" />
+  <element name="NEXT_TURN_REQUEST" />
+  <element name="ROUTE_STATUS_REQUEST" />
+  <element name="ROUTE_SUMMARY_REQUEST" />
+  <element name="TRIP_STATUS_REQUEST" />
+  <element name="ROUTE_UPDATE_REQUEST_TIMEOUT" />
+</enum>
+
+<enum name="ApplicationsCloseReason">
+  <description>Describes the reasons for exiting all of applications.</description>
+  <element name="IGNITION_OFF" />
+  <element name="MASTER_RESET" />
+  <element name="FACTORY_DEFAULTS" />
+</enum>
+
+<enum name="DisplayType">
+    <description>The possible types of HU display.</description>
+    <element name="CID">
+    <description> A 2-line x 20 character "dot matrix" display </description>
+    </element>
+    <element name="TYPE2">
+    <description> 1 line older radio head unit.</description>
+    </element>
+    <element name="TYPE5">
+    <description> Old radio head unit.</description>
+    </element>
+    <element name="NGN">
+    <description> Next Generation Navigation display.</description>
+    </element>
+    <element name="GEN2_8_DMA">
+    <description> GEN-2, 8 inch display.</description>
+    </element>
+    <element name="GEN2_6_DMA">
+    <description> GEN-2, 6 inch display.</description>
+    </element>
+    <element name="MFD3">
+    <description> 3 inch GEN1.1 display </description>
+    </element>
+    <element name="MFD4">
+    <description> 4 inch GEN1.1 display </description>
+    </element>
+    <element name="MFD5">
+    <description> 5 inch GEN1.1 display </description>
+    </element>
+  </enum>
+
+<enum name="ImageType">
+  <description>Contains information about the type of image.</description>
+  <element name="STATIC" />
+  <element name="DYNAMIC" />
+</enum>
+
+<enum name="TextFieldName">
+  <element name="mainField1">
+    <description>The first line of first set of main fields of the persistent display; applies to "Show"</description>
+  </element>
+  <element name="mainField2">
+    <description>The second line of first set of main fields of the persistent display; applies to "Show"</description>
+  </element>
+  <element name="mainField3">
+    <description>The first line of second set of main fields of persistent display; applies to "Show"</description>
+  </element>
+  <element name="mainField4">
+    <description>The second line of second set of main fields of the persistent display; applies to "Show"</description>
+  </element>
+  <element name="statusBar">
+    <description>The status bar on NGN; applies to "Show"</description>
+  </element>
+  <element name="mediaClock">
+    <description>Text value for MediaClock field; applies to "Show"</description>
+  </element>
+  <element name="mediaTrack">
+    <description>The track field of NGN and GEN1.1 MFD displays. This field is only available for media applications; applies to "Show"</description>
+  </element>
+  <element name="alertText1">
+    <description>The first line of the alert text field; applies to "Alert"</description>
+  </element>
+  <element name="alertText2">
+    <description>The second line of the alert text field; applies to "Alert"</description>
+  </element>
+  <element name="alertText3">
+    <description>The third line of the alert text field; applies to "Alert"</description>
+  </element>
+  <element name="scrollableMessageBody">
+    <description>Long form body of text that can include newlines and tabs; applies to "ScrollableMessage"</description>
+  </element>
+  <element name="initialInteractionText">
+    <description> First line suggestion for a user response (in the case of VR enabled interaction</description>
+  </element>
+  <element name="navigationText1">
+    <description> First line of navigation text</description>
+  </element>
+  <element name="navigationText2">
+    <description> Second line of navigation text</description>
+  </element>
+  <element name="ETA">
+    <description> Estimated Time of Arrival time for navigation</description>
+  </element>
+  <element name="totalDistance">
+    <description> Total distance to destination for navigation</description>
+  </element>
+  <element name="navigationText">
+    <description>Navigation text for UpdateTurnList.</description>
+  </element>
+  <element name="audioPassThruDisplayText1">
+    <description> First line of text for audio pass thru</description>
+  </element>
+  <element name="audioPassThruDisplayText2">
+    <description> Second line of text for audio pass thru</description>
+  </element>
+  <element name="sliderHeader">
+    <description> Header text for slider</description>
+  </element>
+  <element name="sliderFooter">
+    <description> Footer text for slider</description>
+  </element>
+  <element name="notificationText">
+    <description>Text of notification to be displayed on screen.</description>
+  </element>
+  <element name="menuName">
+    <description> Primary text for Choice</description>
+  </element>
+  <element name="secondaryText">
+    <description> Secondary text for Choice</description>
+  </element>
+  <element name="tertiaryText">
+    <description> Tertiary text for Choice</description>
+  </element>
+  <element name="timeToDestination"/>
+  <element name="turnText"/>
+</enum>
+
+<enum name="ImageFieldName">
+  <element name="softButtonImage">
+    <description>The image field for SoftButton</description>
+  </element>
+  <element name="choiceImage">
+    <description>The first image field for Choice</description>
+  </element>
+  <element name="choiceSecondaryImage">
+    <description>The secondary image field for Choice</description>
+  </element>
+  <element name="vrHelpItem">
+    <description>The image field for vrHelpItem</description>
+  </element>
+  <element name="turnIcon">
+    <description>The image field for Turn</description>
+  </element>
+  <element name="menuIcon">
+    <description>The image field for the menu icon in SetGlobalProperties</description>
+  </element>
+  <element name="cmdIcon">
+    <description>The image field for AddCommand</description>
+  </element>
+  <element name="graphic">
+    <description>The image field for Show</description>
+  </element>
+  <element name="showConstantTBTIcon">
+    <description>The primary image field for ShowConstantTBT</description>
+  </element>
+  <element name="showConstantTBTNextTurnIcon">
+    <description>The secondary image field for ShowConstantTBT</description>
+  </element>
+  <element name="nextTurnIcon"/>
+</enum>
+
+<enum name="TextAlignment">
+  <description>The list of possible alignments, left, right, or centered</description>
+  <element name="LEFT_ALIGNED" />
+  <element name="RIGHT_ALIGNED" />
+  <element name="CENTERED" />
+</enum>
+
+<enum name="DriverDistractionState">
+  <description>Enumeration that describes possible states of driver distraction.</description>
+  <element name="DD_ON" />
+  <element name="DD_OFF" />
+</enum>
+
+<enum name="MediaClockFormat">
+  <element name="CLOCK1">
+    <description>
+      minutesFieldWidth = 2;minutesFieldMax = 19;secondsFieldWidth = 2;secondsFieldMax = 99;maxHours = 19;maxMinutes = 59;maxSeconds = 59;
+      Is used for Type II, NGN and CID head units.
+    </description>
+  </element>
+  <element name="CLOCK2">
+    <description>
+      minutesFieldWidth = 3;minutesFieldMax = 199;secondsFieldWidth = 2;secondsFieldMax = 99;maxHours = 59;maxMinutes = 59;maxSeconds = 59;
+    Is used for Type V head units.
+	</description>
+  </element>
+  <element name="CLOCK3">
+    <description>
+      minutesFieldWidth = 2;minutesFieldMax = 59;secondsFieldWidth = 2;secondsFieldMax = 59;maxHours = 9;maxMinutes = 59;maxSeconds = 59;
+    Is used for GEN1.1 (i.e. MFD3/4/5) head units.
+	</description>
+  </element>
+  <element name="CLOCKTEXT1">
+    <description>
+      5 characters possible
+      Format:      1|sp   c   :|sp   c   c
+      1|sp : digit "1" or space
+      c    : character out of following character set: sp|0-9|[letters
+      :|sp : colon or space
+    Is used for Type II head unit
+	</description>
+  </element>
+  <element name="CLOCKTEXT2">
+    <description>
+      5 chars possible
+      Format:      1|sp   c   :|sp   c   c
+      1|sp : digit "1" or space
+      c    : character out of following character set: sp|0-9|[letters
+      :|sp : colon or space
+	Is used for CID and NGN head unit
+	</description>
+  </element>
+  <element name="CLOCKTEXT3">
+    <description>
+      6 chars possible
+      Format:      1|sp   c   c   :|sp   c   c
+      1|sp : digit "1" or space
+      c    : character out of following character set: sp|0-9|[letters
+      :|sp : colon or space
+    Is used for Type V head unit
+  </description>
+  </element>
+  <element name="CLOCKTEXT4">
+    <description>
+      6 chars possible
+      Format:      c   :|sp   c   c   :   c   c
+      :|sp : colon or space
+      c    : character out of following character set: sp|0-9|[letters].
+    Is used for GEN1.1 (i.e. MFD3/4/5) head units
+  </description>
+  </element>
+</enum>
+
+<!--IVI part-->
+<enum name="ComponentVolumeStatus">
+  <description>The volume status of a vehicle component.</description>
+  <element name="UNKNOWN" internal_name="CVS_UNKNOWN">
+  <description> The data is unknown.</description>
+  </element>
+  <element name="NORMAL" internal_name="CVS_NORMAL">
+  <description> The volume is normal.</description>
+  </element>
+  <element name="LOW" internal_name="CVS_LOW">
+  <description> The volume is low.</description>
+  </element>
+  <element name="FAULT" internal_name="CVS_FAULT">
+  <description> The module/sensor is currently faulted. </description>
+  </element>
+  <element name="ALERT"  internal_name="CVS_ALERT">
+  <description> The component`s volume is in critical level.</description>
+  </element>
+  <element name="NOT_SUPPORTED" internal_name="CVS_NOT_SUPPORTED">
+  <description> The data is not supported.</description>
+  </element>
+</enum>
+
+<enum name="PRNDL">
+  <description>The selected gear.</description>
+  <element name="PARK">
+    <description>Parking</description>
+  </element>
+  <element name="REVERSE">
+    <description>Reverse gear</description>
+  </element>
+  <element name="NEUTRAL">
+    <description>No gear</description>
+  </element>
+  <element name="DRIVE">
+  </element>
+  <element name="SPORT">
+    <description>Drive Sport mode</description>
+  </element>
+  <element name="LOWGEAR">
+    <description>1st gear hold</description>
+  </element>
+  <element name="FIRST">
+  </element>
+  <element name="SECOND">
+  </element>
+  <element name="THIRD">
+  </element>
+  <element name="FOURTH">
+  </element>
+  <element name="FIFTH">
+  </element>
+  <element name="SIXTH">
+  </element>
+  <element name="SEVENTH">
+  </element>
+  <element name="EIGHTH">
+  </element>
+</enum>
+
+<enum name="VehicleDataEventStatus">
+  <description>Reflects the status of a vehicle data event; e.g. a seat belt event status.</description>
+  <element name="NO_EVENT" internal_name="VDES_NO_EVENT">
+  <description> The system does not have the adequate information to send valid YES or NO states.</description>
+  </element>
+  <element name="NO" internal_name="VDES_NO">
+  <description> The requested event is in NO state.</description>
+  </element>
+  <element name="YES" internal_name="VDES_YES">
+  <description> The requested event is in YES state.</description>
+  </element>
+  <element name="NOT_SUPPORTED" internal_name="VDES_NOT_SUPPORTED">
+  <description> The requested data is not supported </description>
+  </element>
+  <element name="FAULT" internal_name="VDES_FAULT">
+  <description> The module/sensor is currently faulted.</description>
+  </element>
+</enum>
+
+<enum name="VehicleDataStatus">
+  <description>Reflects the status of a binary vehicle data item.</description>
+  <element name="NO_DATA_EXISTS" internal_name="VDS_NO_DATA_EXISTS">
+  </element>
+  <element name="OFF" internal_name="VDS_OFF">
+  </element>
+  <element name="ON" internal_name="VDS_ON">
+  </element>
+</enum>
+
+<enum name="IgnitionStableStatus">
+  <description>Reflects the ignition switch stability.</description>
+  <element name="IGNITION_SWITCH_NOT_STABLE">
+  </element>
+  <element name="IGNITION_SWITCH_STABLE">
+  </element>
+  <element name="MISSING_FROM_TRANSMITTER">
+  <description> Either the data is not accessible or the sensor is broken.</description>
+  </element>
+</enum>
+
+<enum name="IgnitionStatus">
+  <description>Reflects the status of ignition.</description>
+  <element name="UNKNOWN" internal_name="IS_UNKNOWN">
+  <description> The information is not acceptable. </description>
+  </element>
+  <element name="OFF" internal_name="IS_OFF">
+  <description> The ignition is off.</description>
+  </element>
+  <element name="ACCESSORY" internal_name="IS_ACCESSORY">
+  <description> The accessories are active (power windows, audio, display, etc.).</description>
+  </element>
+  <element name="RUN" internal_name="IS_RUN">
+   <description> Ignition is active.</description>
+  </element>
+  <element name="START" internal_name="IS_START">
+  <description> Starter is switched.</description>
+  </element>
+  <element name="INVALID" internal_name="IS_INVALID">
+  <description> The data is provided, but there is some sort of fault or problem.</description>
+  </element>
+</enum>
+
+<enum name="DeviceLevelStatus">
+  <description>Reflects the reported component status of the connected device, if reported.</description>
+  <element name="ZERO_LEVEL_BARS">
+  </element>
+  <element name="ONE_LEVEL_BARS">
+  </element>
+  <element name="TWO_LEVEL_BARS">
+  </element>
+  <element name="THREE_LEVEL_BARS">
+  </element>
+  <element name="FOUR_LEVEL_BARS">
+  </element>
+  <element name="NOT_PROVIDED">
+  </element>
+</enum>
+
+<enum name="PrimaryAudioSource">
+  <description>Reflects the current primary audio source (if selected).</description>
+  <element name="NO_SOURCE_SELECTED">
+  </element>
+  <element name="USB">
+  </element>
+  <element name="USB2">
+  </element>
+  <element name="BLUETOOTH_STEREO_BTST">
+  </element>
+  <element name="LINE_IN">
+  </element>
+  <element name="IPOD">
+  </element>
+  <element name="MOBILE_APP">
+  </element>
+</enum>
+
+<enum name="CompassDirection">
+  <description>The list of potential compass directions</description>
+  <element name="NORTH">
+  </element>
+  <element name="NORTHWEST">
+  </element>
+  <element name="WEST">
+  </element>
+  <element name="SOUTHWEST">
+  </element>
+  <element name="SOUTH">
+  </element>
+  <element name="SOUTHEAST">
+  </element>
+  <element name="EAST">
+  </element>
+  <element name="NORTHEAST">
+  </element>
+</enum>
+
+<enum name="Dimension">
+  <description>The supported dimensions of the GPS</description>
+  <element name="NO_FIX" internal_name="Dimension_NO_FIX">
+    <description>No GPS at all</description>
+  </element>
+  <element name="2D" internal_name="Dimension_2D">
+    <description>Longitude and lattitude</description>
+  </element>
+  <element name="3D" internal_name="Dimension_3D">
+    <description>Longitude and lattitude and altitude</description>
+  </element>
+</enum>
+
+<enum name="TouchType">
+  <element name="BEGIN"/>
+  <element name="MOVE"/>
+  <element name="END"/>
+</enum>
+
+<enum name="WarningLightStatus">
+  <description>Reflects the status of a cluster instrument warning light.</description>
+  <element name="OFF" internal_name="WLS_OFF">
+  </element>
+  <element name="ON" internal_name="WLS_ON">
+  </element>
+  <element name="FLASH" internal_name="WLS_FLASH">
+  </element>
+</enum>
+
+<enum name="VehicleDataResultCode">
+  <description>Enumeration that describes possible result codes of a vehicle data entry request.</description>
+  <element name="SUCCESS" internal_name="VDRC_SUCCESS"/>
+  <element name="TRUNCATED_DATA" internal_name="VDRC_TRUNCATED_DATA"/>
+  <element name="DISALLOWED" internal_name="VDRC_DISALLOWED"/>
+  <element name="USER_DISALLOWED" internal_name="VDRC_USER_DISALLOWED"/>
+  <element name="INVALID_ID" internal_name="VDRC_INVALID_ID"/>
+  <element name="VEHICLE_DATA_NOT_AVAILABLE" internal_name="VDRC_DATA_NOT_AVAILABLE"/>
+  <element name="DATA_ALREADY_SUBSCRIBED" internal_name="VDRC_DATA_ALREADY_SUBSCRIBED"/>
+  <element name="DATA_NOT_SUBSCRIBED" internal_name="VDRC_DATA_NOT_SUBSCRIBED"/>
+  <element name="IGNORED" internal_name="VDRC_IGNORED"/>
+</enum>
+
+<enum name="VehicleDataType">
+  <description>Defines the data types that can be published and subscribed to.</description>
+  <element name="VEHICLEDATA_GPS">
+    <description>Notifies GPSData may be subscribed</description>
+  </element>
+  <element name="VEHICLEDATA_SPEED" />
+  <element name="VEHICLEDATA_RPM" />
+  <element name="VEHICLEDATA_FUELLEVEL" />
+  <element name="VEHICLEDATA_FUELLEVEL_STATE" />
+  <element name="VEHICLEDATA_FUELCONSUMPTION" />
+  <element name="VEHICLEDATA_EXTERNTEMP" />
+  <element name="VEHICLEDATA_VIN" />
+  <element name="VEHICLEDATA_PRNDL" />
+  <element name="VEHICLEDATA_TIREPRESSURE" />
+  <element name="VEHICLEDATA_ODOMETER" />
+  <element name="VEHICLEDATA_BELTSTATUS" />
+  <element name="VEHICLEDATA_BODYINFO" />
+  <element name="VEHICLEDATA_DEVICESTATUS" />
+  <element name="VEHICLEDATA_ECALLINFO" />
+  <element name="VEHICLEDATA_AIRBAGSTATUS" />
+  <element name="VEHICLEDATA_EMERGENCYEVENT" />
+  <element name="VEHICLEDATA_CLUSTERMODESTATUS" />
+  <element name="VEHICLEDATA_MYKEY" />
+  <element name="VEHICLEDATA_BRAKING" />
+  <element name="VEHICLEDATA_WIPERSTATUS" />
+  <element name="VEHICLEDATA_HEADLAMPSTATUS" />
+  <element name="VEHICLEDATA_BATTVOLTAGE" />
+  <element name="VEHICLEDATA_ENGINETORQUE" />
+  <element name="VEHICLEDATA_ACCPEDAL" />
+  <element name="VEHICLEDATA_STEERINGWHEEL" />
+</enum>
+
+<enum name="WiperStatus">
+  <description>Reflects the status of the wipers.</description>
+  <element name="OFF">
+    <description> The wipers are off.</description>
+  </element>
+  <element name="AUTO_OFF">
+     <description> The wipers are automatically off </description>
+  </element>
+  <element name="OFF_MOVING">
+	<description> Means that though set to off, somehow the wipers have been engaged (physically moved enough to engage a wiping motion).</description>
+  </element>
+  <element name="MAN_INT_OFF">
+    <description> The wipers are manually off after having been working.</description>
+  </element>
+  <element name="MAN_INT_ON">
+    <description> The wipers are manually on.</description>
+  </element>
+  <element name="MAN_LOW">
+    <description> The wipers are manually set to low speed.</description>
+  </element>
+  <element name="MAN_HIGH">
+    <description> The wipers are manually set to high speed.</description>
+  </element>
+  <element name="MAN_FLICK">
+    <description> The wipers are manually set for doing a flick.</description>
+  </element>
+  <element name="WASH">
+	<description> The wipers are set to use the water from vehicle washer bottle for cleaning the windscreen.</description>
+  </element>
+  <element name="AUTO_LOW">
+	<description> The wipers are automatically set to low speed.</description>
+  </element>
+  <element name="AUTO_HIGH">
+    <description> The wipers are automatically set to high speed.</description>
+  </element>
+  <element name="COURTESYWIPE">
+    <description> This is for when a user has just initiated a WASH and several seconds later a secondary wipe is automatically initiated to clear remaining fluid.</description>
+  </element>
+  <element name="AUTO_ADJUST">
+    <description> This is set as the user moves between possible automatic wiper speeds.</description>
+  </element>
+  <element name="STALLED">
+    <description> The wiper is stalled to its place. </description>
+  </element>
+  <element name="NO_DATA_EXISTS">
+    <description> The sensor / module cannot provide any information for wiper.</description>
+  </element>
+</enum>
+
+<enum name="SamplingRate">
+  <description>Describes different sampling options for PerformAudioPassThru.</description>
+  <element name="8KHZ" internal_name="RATE_8KHZ"/>
+  <element name="16KHZ" internal_name="RATE_16KHZ"/>
+  <element name="22KHZ" internal_name="RATE_22KHZ"/>
+  <element name="44KHZ" internal_name="RATE_44KHZ"/>
+</enum>
+
+<enum name="BitsPerSample">
+  <description>Describes different quality options for PerformAudioPassThru.</description>
+  <element name="8_BIT" internal_name="RATE_8_BIT"/>
+  <element name="16_BIT" internal_name="RATE_16_BIT"/>
+</enum>
+
+<enum name="AudioType">
+  <description>Describes different audio type options for PerformAudioPassThru.</description>
+  <element name="PCM" />
+</enum>
+
+<enum name="KeyboardLayout">
+  <description>Enumeration listing possible keyboard layouts.</description>
+  <element name="QWERTY" />
+  <element name="QWERTZ" />
+  <element name="AZERTY" />
+</enum>
+
+<enum name="KeyboardEvent">
+  <description>Enumeration listing possible keyboard events.</description>
+  <element name="KEYPRESS" />
+  <element name="ENTRY_SUBMITTED" />
+  <element name="ENTRY_CANCELLED" />
+  <element name="ENTRY_ABORTED" />
+</enum>
+
+<enum name="KeypressMode">
+  <description>Enumeration listing possible keyboard events.</description>
+  <element name="SINGLE_KEYPRESS">
+    <description>Each keypress is individually sent as the user presses the keyboard keys.</description>
+  </element>
+  <element name="QUEUE_KEYPRESSES">
+    <description>The keypresses are queued and a string is eventually sent once the user chooses to submit their entry.</description>
+  </element>
+  <element name="RESEND_CURRENT_ENTRY">
+    <description>The keypresses are queue and a string is sent each time the user presses a keyboard key; the string contains the entire current entry.</description>
+  </element>
+</enum>
+
+<enum name="AmbientLightStatus">
+  <description>Reflects the status of the ambient light sensor.</description>
+  <element name="NIGHT" />
+  <element name="TWILIGHT_1" />
+  <element name="TWILIGHT_2" />
+  <element name="TWILIGHT_3" />
+  <element name="TWILIGHT_4" />
+  <element name="DAY" />
+  <element name="UNKNOWN" />
+  <element name="INVALID" />
+</enum>
+
+<enum name="FileType">
+  <description>Enumeration listing possible file types.</description>
+  <element name="GRAPHIC_BMP" />
+  <element name="GRAPHIC_JPEG" />
+  <element name="GRAPHIC_PNG" />
+  <element name="AUDIO_WAVE" />
+  <element name="AUDIO_MP3" />
+</enum>
+
+<enum name="RequestType">
+    <description>Enumeration listing possible asynchronous requests.</description>
+    <element name="HTTP" />
+    <element name="FILE_RESUME" />
+    <element name="AUTH_REQUEST" />
+    <element name="AUTH_CHALLENGE" />
+    <element name="AUTH_ACK" />
+  </enum>
+
+<enum name="ECallConfirmationStatus">
+  <description>Reflects the status of the eCall Notification.</description>
+  <element name="NORMAL" internal_name="ECCS_NORMAL">
+  </element>
+  <element name="CALL_IN_PROGRESS" internal_name="ECCS_CALL_IN_PROGRESS">
+  </element>
+  <element name="CALL_CANCELLED" internal_name="ECCS_CALL_CANCELLED">
+  </element>
+  <element name="CALL_COMPLETED">
+  </element>
+  <element name="CALL_UNSUCCESSFUL" internal_name="ECCS_CALL_UNSUCCESSFUL">
+  </element>
+  <element name="ECALL_CONFIGURED_OFF" internal_name="ECCS_ECALL_CONFIGURED_OFF">
+  </element>
+  <element name="CALL_COMPLETE_DTMF_TIMEOUT" internal_name="ECCS_CALL_COMPLETE_DTMF_TIMEOUT">
+  </element>
+</enum>
+
+<enum name="VehicleDataNotificationStatus">
+  <description>Reflects the status of a vehicle data notification.</description>
+  <element name="NOT_SUPPORTED" internal_name="VDNS_NOT_SUPPORTED">
+  </element>
+  <element name="NORMAL" internal_name="VDNS_NORMAL">
+  </element>
+  <element name="ACTIVE" internal_name="VDNS_ACTIVE">
+  </element>
+</enum>
+
+<enum name="EmergencyEventType">
+  <description>Reflects the emergency event status of the vehicle.</description>
+  <element name="NO_EVENT" internal_name="EET_NO_EVENT">
+  </element>
+  <element name="FRONTAL" internal_name="EET_FRONTAL">
+  </element>
+  <element name="SIDE" internal_name="EET_SIDE">
+  </element>
+  <element name="REAR" internal_name="EET_REAR">
+  </element>
+  <element name="ROLLOVER" internal_name="EET_ROLLOVER">
+  </element>
+  <element name="NOT_SUPPORTED" internal_name="EET_NOT_SUPPORTED">
+  </element>
+  <element name="FAULT" internal_name="EET_FAULT">
+  </element>
+</enum>
+
+<enum name="FuelCutoffStatus">
+  <description>Reflects the status of the RCM fuel cutoff.</description>
+  <element name="TERMINATE_FUEL" internal_name="FCS_TERMINATE_FUEL">
+  </element>
+  <element name="NORMAL_OPERATION" internal_name="FCS_NORMAL_OPERATION">
+  </element>
+  <element name="FAULT" internal_name="FCS_FAULT">
+  </element>
+</enum>
+
+<enum name="PowerModeQualificationStatus">
+  <description>Reflects the status of the current power mode qualification.</description>
+  <element name="POWER_MODE_UNDEFINED">
+  </element>
+  <element name="POWER_MODE_EVALUATION_IN_PROGRESS">
+  </element>
+  <element name="NOT_DEFINED">
+  </element>
+  <element name="POWER_MODE_OK">
+  </element>
+</enum>
+
+<enum name="CarModeStatus">
+  <description>Reflects the status of the current car mode.</description>
+  <element name="NORMAL" internal_name="CMS_NORMAL">
+  </element>
+  <element name="FACTORY" internal_name="CMS_FACTORY">
+  </element>
+  <element name="TRANSPORT" internal_name="CMS_TRANSPORT">
+  </element>
+  <element name="CRASH" internal_name="CMS_CRASH">
+  </element>
+</enum>
+
+<enum name="PowerModeStatus">
+  <description>Reflects the status of the current power mode.</description>
+  <element name="KEY_OUT">
+  </element>
+  <element name="KEY_RECENTLY_OUT">
+  </element>
+  <element name="KEY_APPROVED_0">
+  </element>
+  <element name="POST_ACCESORY_0">
+  </element>
+  <element name="ACCESORY_1">
+  </element>
+  <element name="POST_IGNITION_1">
+  </element>
+  <element name="IGNITION_ON_2">
+  </element>
+  <element name="RUNNING_2">
+  </element>
+  <element name="CRANK_3">
+  </element>
+</enum>
+
+<!-- End of IVI part-->
+
+<struct name="ButtonCapabilities">
+    <description>Contains the information about capabilities of a button.</description>
+    <param name="name" type="Common.ButtonName" mandatory="true">
+        <description>The name of the Button from the ButtonName enum</description>
+    </param>
+    <param name="shortPressAvailable" type="Boolean" mandatory="true">
+        <description>The button supports a short press. Whenever the button is pressed short, onButtonPressed(SHORT) should be invoked.</description>
+    </param>
+    <param name="longPressAvailable" type="Boolean" mandatory="true">
+        <description>The button supports a LONG press. Whenever the button is pressed long, onButtonPressed(LONG) should be invoked.</description>
+    </param>
+    <param name="upDownAvailable" type="Boolean" mandatory="true">
+        <description>The button supports "button down" and "button up". Whenever the button is pressed, onButtonEvent(DOWN) should be invoked. Whenever the button is released, onButtonEvent(UP) should be invoked.</description>
+    </param>
+</struct>
+
+<struct name="VehicleDataResult">
+  <description>Individual published data request result</description>
+  <param name="dataType" type="Common.VehicleDataType">
+    <description>Defined published data element type.</description>
+  </param>
+  <param name="resultCode" type="Common.VehicleDataResultCode">
+    <description>Published data result code.</description>
+  </param>
+</struct>
+
+<struct name="TouchCoord">
+  <param name="x" type="Integer" mandatory="true" minvalue="0" maxvalue="10000">
+    <description>The x coordinate of the touch.</description>
+  </param>
+  <param name="y" type="Integer" mandatory="true" minvalue="0" maxvalue="10000">
+    <description>The y coordinate of the touch.</description>
+  </param>
+</struct>
+
+<struct name="TouchEvent">
+  <param name="id" type="Integer" mandatory="true" minvalue="0" maxvalue="9">
+    <description>
+      A touch's unique identifier.  The application can track the current touch events by id.
+      If a touch event has type begin, the id should be added to the set of touches.
+      If a touch event has type end, the id should be removed from the set of touches.
+    </description>
+  </param>
+  <param name="ts" type="Integer" mandatory="true" array="true" minvalue="0" maxvalue="2147483647" minsize="1" maxsize="1000">
+    <description>
+      The time that the touch was recorded.  This number can the time since the beginning of the session or something else as long as the units are in milliseconds.
+      The timestamp is used to determined the rate of change of position of a touch.
+      The application also uses the time to verify whether two touches, with different ids, are part of a single action by the user.
+      If there is only a single timestamp in this array, it is the same for every coordinate in the coordinates array.
+    </description>
+  </param>
+  <param name="c" type="Common.TouchCoord" mandatory="true" array="true" minsize="1" maxsize="1000">
+  </param>
+</struct>
+
+<struct name="PresetBankCapabilities">
+    <description>Contains information about on-screen preset capabilities (whether the HW preset buttons could be duplicated with onscreen buttons).</description>
+    <param name="onScreenPresetsAvailable" type="Boolean" mandatory="true">
+        <description>Must be true if onscreen custom presets are available.</description>
+    </param>
+</struct>
+
+<struct name="Image">
+  <param name="value" maxlength="65535" type="String" mandatory="true">
+    <description>The path to the dynamic image stored on HU or the static binary image itself.</description>
+  </param>
+  <param name="imageType" type="Common.ImageType" mandatory="true">
+    <description>Describes, whether it is a static or dynamic image.</description>
+  </param>
+</struct>
+
+<struct name="SoftButton">
+    <param name="type" type="Common.SoftButtonType" mandatory="true">
+      <description>Describes, whether text, icon or both text and image should be displayed on the soft button. See softButtonType</description>
+    </param>
+    <param name="text" maxlength="500" type="String" mandatory="false">
+      <description>Optional text to be displayed (if defined as TEXT or BOTH)</description>
+    </param>
+    <param name="image" type="Common.Image" mandatory="false">
+      <description>Optional image struct for SoftButton (if defined as IMAGE or BOTH)</description>
+    </param>
+    <param name="isHighlighted" type="Boolean" mandatory="false">
+      <description>If true, must be highlighted</description>
+      <description>If false, must be not</description>
+    </param>
+    <param name="softButtonID" type="Integer" minvalue="0" maxvalue="65535" mandatory="true">
+      <description>Value which must be returned via OnButtonPress / OnButtonEvent</description>
+    </param>
+    <param name="systemAction" type="Common.SystemAction" mandatory="false">
+      <description>Parameter indicates whether clicking a SoftButton must call a specific system action.  See SystemAction</description>
+    </param>
+ </struct>
+
+<struct name="TTSChunk">
+    <description>A TTS chunk, that consists of the text/phonemes to be spoken</description>
+    <param name="text" type="String" mandatory="true" maxlength="500">
+        <description>The text or phonemes to be spoken.</description>
+    </param>
+    <param name="type" type="Common.SpeechCapabilities" mandatory="true">
+      <description>Describes, whether it is text or a specific phoneme set. See SpeechCapabilities.</description>
+    </param>
+</struct>
+
+<struct name="HMIApplication">
+    <description>Data type containing information about application needed by HMI.</description>
+    <param name="appName" type="String" maxlength="100" mandatory="true">
+      <description>The mobile application name, e.g. "Ford Drive Green".</description>
+    </param>
+    <param name="ngnMediaScreenAppName" type="String" maxlength="100" mandatory="false">
+      <description>Provides an abbreviated version of the app name (if needed), that may be displayed on the NGN media screen.</description>
+      <description>If not provided, the appName should be used instead (and may be truncated if too long)</description>
+    </param>
+    <param name="icon" type="String" mandatory="false">
+      <description>Path to application icon stored on HU.</description>
+    </param>
+    <param name="deviceName" type="String" mandatory="true">
+      <description>The name of device which the provided application is running on.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>Unique (during ignition cycle) id of the application. To be used in all RPCs sent by both HU system and SDL</description>
+    </param>
+    <param name="hmiDisplayLanguageDesired" type="Common.Language" mandatory="true">
+      <description>The language the application intends to use on HU  </description>
+    </param>
+    <param name="isMediaApplication" type="Boolean" mandatory="true">
+      <description>Indicates whether it is a media or a non-media application.</description>
+    </param>
+    <param name="appType" type="Common.AppHMIType" minsize="1" maxsize="100" array="true" mandatory="false">
+      <description>List of all applicable app types stating which classifications to be given to the app.</description>
+      <description>e.g. for platforms like GEN2, this determines which "corner(s)" the app can populate.</description>
+    </param>
+</struct>
+
+<struct name="MenuParams">
+  <param name="parentID" type="Integer" minvalue="0" maxvalue="2000000000" mandatory="false">
+    <description>unique ID of the sub menu, the command must be added to.</description>
+    <description>If not provided, the command must be added to the top level of the in application menu.</description>
+  </param>
+  <param name="position" type="Integer" minvalue="0" maxvalue="1000" mandatory="false">
+    <description>Position within the items that are at the top level of the in application menu.</description>
+    <description>0 should insert at the front.</description>
+    <description>1 should insert at the second position.</description>
+    <description>if position is greater than or equal to the number of items on the top level, the the sub menu/command should be appended to the end.</description>
+    <description>If this param is omitted the entry should be added at the end.</description>
+  </param>
+  <param name="menuName" type="String" maxlength="500" mandatory="true">
+    <description>The name of the sub menu/command.</description>
+  </param>
+</struct>
+
+<struct name="Choice">
+  <description>A choice is an option given to the user which can be selected either by menu, or through voice recognition system.</description>
+  <param name="choiceID" type="Integer" minvalue="0" maxvalue="65535" mandatory="true">
+	<description> The unique within the concerned application identifier for this choice </description>
+  </param>
+  <param name="menuName" type="String" maxlength="500" mandatory="false">
+    <description> The name of the choice </description>
+  </param>
+  <param name="image" type="Common.Image" mandatory="false">
+	<description> The image for representing the choice </description>
+  </param>
+  <param name="secondaryText" maxlength="500" type="String" mandatory="false">
+    <description>Optional secondary text to display; e.g. address of POI in a search result entry</description>
+  </param>
+  <param name="tertiaryText" maxlength="500" type="String" mandatory="false">
+    <description>Optional tertiary text to display; e.g. distance to POI for a search result entry</description>
+  </param>
+  <param name="secondaryImage" type="Image" mandatory="false">
+    <description>Optional secondary image struct for choice</description>
+  </param>
+</struct>
+
+<struct name="VrHelpItem">
+  <param name="text" maxlength="500" type="String" mandatory="true">
+    <description>Text to display for VR Help item</description>
+  </param>
+  <param name="image" type="Common.Image" mandatory="false">
+    <description>Image struct for VR Help item</description>
+  </param>
+  <param name="position" type="Integer" minvalue="1" maxvalue="8" mandatory="true">
+    <description>Position to display item in VR Help list</description>
+  </param>
+</struct>
+
+<struct name="TimeFormat">
+  <param name="hours" type="Integer" minvalue="0" maxvalue="59" mandatory="true">
+    <description>The hour of the media clock.</description>
+    <description>Some units only support a max of 19 hours. If out of range, it should be rejected.</description>
+  </param>
+  <param name="minutes" type="Integer" minvalue="0" maxvalue="59" mandatory="true"/>
+  <param name="seconds" type="Integer" minvalue="0" maxvalue="59" mandatory="true"/>
+</struct>
+
+<struct name="TouchEventCapabilities">
+  <param name="pressAvailable" type="Boolean" mandatory="true">
+  </param>
+  <param name="multiTouchAvailable" type="Boolean" mandatory="true">
+  </param>
+  <param name="doublePressAvailable" type="Boolean" mandatory="true">
+  </param>
+</struct>
+
+<struct name="ImageResolution">
+  <param name="resolutionWidth" type="Integer" minvalue="1" maxvalue="10000" mandatory="true">
+    <description>The image resolution width.</description>
+  </param>
+  <param name="resolutionHeight" type="Integer" minvalue="1" maxvalue="10000" mandatory="true">
+    <description>The image resolution height.</description>
+  </param>
+</struct>
+
+<struct name="ScreenParams">
+  <param name="resolution" type="Common.ImageResolution" mandatory="true">
+    <description>The resolution of the prescribed screen area.</description>
+  </param>
+  <param name="touchEventAvailable" type="Common.TouchEventCapabilities" mandatory="false">
+    <description>Types of screen touch events available in screen area.</description>
+  </param>
+</struct>
+
+<struct name="ImageField">
+  <param name="name" type="Common.ImageFieldName" mandatory="true">
+    <description>The name that identifies the field. See ImageFieldName.</description>
+  </param>
+  <param name="imageTypeSupported" type="Common.FileType" maxsize="100" array="true" mandatory="false" minsize="1">
+    <description>The image types that are supported in this field. See FileType.</description>
+  </param>
+  <param name="imageResolution" type="Common.ImageResolution" mandatory="false">
+    <description>The image resolution of this field.</description>
+  </param>
+</struct>
+
+<struct name="DisplayCapabilities">
+  <description>Contains information about the display capabilities.</description>
+  <param name="displayType" type="Common.DisplayType" mandatory="true">
+    <description>The type of the display. See DisplayType</description>
+  </param>
+  <param name="textFields" type="Common.TextFieldName" minsize="0" maxsize="100" array="true" mandatory="true">
+    <description>A set of all fields for text displaying supported by HU. See TextFieldName.</description>
+    <description>If there are no textfields supported, the empty array must be returned</description>
+  </param>
+  <param name="imageFields" type="Common.ImageField" minsize="1" maxsize="100" array="true">
+    <description>A set of all fields that support images. See ImageField</description>
+  </param>
+  <param name="mediaClockFormats" type="Common.MediaClockFormat" minsize="1" maxsize="100" array="true" mandatory="true">
+    <description>A set of all supported formats of the media clock. See MediaClockFormat</description>
+  </param>
+  <param name="imageCapabilities" type="Common.ImageType" array="true" minsize="0" maxsize="2" mandatory="false">
+  </param>
+  <param name="graphicSupported" type="Boolean" mandatory="true">
+    <description>The display's persistent screen supports referencing a static or dynamic image.</description>
+  </param>
+</struct>
+
+<struct name="SoftButtonCapabilities">
+  <description>Contains information about a SoftButton's capabilities.</description>
+  <param name="shortPressAvailable" type="Boolean" mandatory="true">
+    <description>The button supports a short press.</description>
+    <description>Whenever the button is pressed short, onButtonPressed( SHORT) must be invoked.</description>
+  </param>
+  <param name="longPressAvailable" type="Boolean" mandatory="true">
+    <description>The button supports a LONG press.</description>
+    <description>Whenever the button is pressed long, onButtonPressed( LONG) must be invoked.</description>
+  </param>
+  <param name="upDownAvailable" type="Boolean" mandatory="true">
+    <description>The button supports "button down" and "button up".</description>
+    <description>Whenever the button is pressed, onButtonEvent( DOWN) must be invoked.</description>
+    <description>Whenever the button is released, onButtonEvent( UP) must be invoked.</description>
+  </param>
+  <param name="imageSupported" type="Boolean" mandatory="true">
+    <description>Must be true if the button supports referencing a static or dynamic image.</description>
+  </param>
+</struct>
+
+<struct name="AudioPassThruCapabilities">
+  <description>
+    Describes different audio type configurations for PerformAudioPassThru.
+    e.g. 8kHz,8-bit,PCM
+  </description>
+  <param name="samplingRate" type="Common.SamplingRate" mandatory="true"/>
+  <param name="bitsPerSample" type="Common.BitsPerSample" mandatory="true"/>
+  <param name="audioType" type="Common.AudioType" mandatory="true"/>
+</struct>
+
+<struct name="Coordinate">
+  <param name="xCoord" type="Integer" mandatory="true">
+  </param>
+  <param name="yCoord" type="Integer" mandatory="true">
+  </param>
+</struct>
+
+<struct name="TouchArea">
+  <param name="rotationAngle" type="Float" mandatory="false" minvalue="0" maxvalue="360">
+  </param>
+  <param name="radiusCoord" type="Common.Coordinate" mandatory="true">
+  </param>
+</struct>
+
+<struct name="TextFieldStruct">
+  <param name="fieldName" type="Common.TextFieldName" mandatory="true">
+	<description>The name of the field for displaying the text.</description>
+  </param>
+  <param name="fieldText" type="String" maxlength="500" mandatory="true">
+    <description>The  text itself.</description>
+  </param>
+</struct>
+
+<struct name="KeyboardProperties">
+  <description>Configuration of on-screen keyboard (if available).</description>
+  <param name="language" type="Common.Language" mandatory="false">
+    <description>The keyboard language.</description>
+  </param>
+  <param name="keyboardLayout" type="Common.KeyboardLayout" mandatory="false" >
+    <description>Desired keyboard layout.</description>
+  </param>
+  <param name="sendDynamicEntry" type="Boolean" mandatory="false">
+    <description>In this mode, all keypresses will be sent as they occur.</description>
+    <description>If disabled, entire string of text will be returned only once submitted by user.</description>
+    <description>If omitted, this value will be set to FALSE.</description>
+  </param>
+  <param name="keypressMode" type="Common.KeypressMode" mandatory="false" >
+    <description>
+    	Desired keypress mode.
+    	If omitted, this value will be set to RESEND_CURRENT_ENTRY.
+    </description>
+  </param>
+  <param name="limitedCharacterList" type="String" maxlength="1" minsize="1" maxsize="100" array="true" mandatory="false">
+    <description>Array of keyboard characters to enable.</description>
+    <description>All omitted characters will be greyed out (disabled) on the keyboard.</description>
+    <description>If omitted, the entire keyboard will be enabled.</description>
+  </param>
+  <param name="autoCompleteText" type="String" maxlength="1000" mandatory="false">
+    <description>Allows an app to prepopulate the text field with a suggested or completed entry as the user types</description>
+  </param>
+</struct>
+
+<struct name="Turn">
+  <param name="navigationText" type="Common.TextFieldStruct" mandatory="false">
+    <description>Uses navigationText from TextFieldStruct.</description>
+  </param>
+  <param name="turnIcon" type="Common.Image" mandatory="false">
+  </param>
+</struct>
+
+<struct name="VehicleType">
+  <param name="make" type="String" maxlength="500" mandatory="false">
+    <description>Make of the vehicle</description>
+    <description>e.g. Ford</description>
+  </param>
+  <param name="model" type="String" maxlength="500" mandatory="false">
+    <description>Model of the vehicle</description>
+    <description>e.g. Fiesta</description>
+  </param>
+  <param name="modelYear" type="String" maxlength="500" mandatory="false">
+    <description>Model Year of the vehicle</description>
+    <description>e.g. 2013</description>
+  </param>
+  <param name="trim" type="String" maxlength="500" mandatory="false">
+    <description>Trim of the vehicle</description>
+    <description>e.g. SE</description>
+  </param>
+</struct>
+
+<struct name="DeviceInfo">
+  <param name="name" type="String" mandatory="true">
+    <description>The name of the device connected.</description>
+  </param>
+  <param name="id" type="Integer" mandatory="true">
+    <description>The ID of the device connected</description>
+  </param>
+</struct>
+
+<!--IVI part-->
+<struct name="GPSData">
+  <description>Struct with the GPS data.</description>
+  <param name="longitudeDegrees" type="Float" minvalue="-180" maxvalue="180" mandatory="false">
+  </param>
+  <param name="latitudeDegrees" type="Float" minvalue="-90" maxvalue="90" mandatory="false">
+  </param>
+  <param name="utcYear" type="Integer" minvalue="2010" maxvalue="2100" mandatory="false">
+    <description>The current UTC year.</description>
+  </param>
+  <param name="utcMonth" type="Integer" minvalue="1" maxvalue="12" mandatory="false">
+    <description>The current UTC month.</description>
+  </param>
+  <param name="utcDay" type="Integer" minvalue="1" maxvalue="31" mandatory="false">
+    <description>The current UTC day.</description>
+  </param>
+  <param name="utcHours" type="Integer" minvalue="0" maxvalue="23" mandatory="false">
+    <description>The current UTC hour.</description>
+  </param>
+  <param name="utcMinutes" type="Integer" minvalue="0" maxvalue="59" mandatory="false">
+    <description>The current UTC minute.</description>
+  </param>
+  <param name="utcSeconds" type="Integer" minvalue="0" maxvalue="59" mandatory="false">
+    <description>The current UTC second.</description>
+  </param>
+  <param name="compassDirection" type="Common.CompassDirection" mandatory="false">
+    <description>See CompassDirection.</description>
+  </param>
+  <param name="pdop" type="Float" minvalue="0" maxvalue="10" mandatory="false">
+    <description>PDOP.</description>
+  </param>
+  <param name="hdop" type="Float" minvalue="0" maxvalue="10" mandatory="false">
+    <description>HDOP.</description>
+  </param>
+  <param name="vdop" type="Float" minvalue="0" maxvalue="10" mandatory="false">
+    <description>VDOP.</description>
+  </param>
+  <param name="actual" type="Boolean" mandatory="false">
+    <description>
+      True, if actual.
+      False, if infered.
+    </description>
+  </param>
+  <param name="satellites" type="Integer" minvalue="0" maxvalue="31" mandatory="false">
+    <description>Number of satellites in view</description>
+  </param>
+  <param name="dimension" type="Common.Dimension" mandatory="false">
+    <description>See Dimension</description>
+  </param>
+  <param name="altitude" type="Float" minvalue="-10000" maxvalue="10000" mandatory="false">
+    <description>Altitude in meters</description>
+  </param>
+  <param name="heading" type="Float" minvalue="0" maxvalue="359.99" mandatory="false">
+    <description>The heading. North is 0. Resolution is 0.01</description>
+  </param>
+  <param name="speed" type="Float" minvalue="0" maxvalue="500" mandatory="false">
+    <description>The speed in KPH</description>
+  </param>
+</struct>
+
+<struct name="SingleTireStatus">
+  <param name="status" type="Common.ComponentVolumeStatus" mandatory="true">
+    <description>The status of component volume. See ComponentVolumeStatus.</description>
+</param>
+</struct>
+
+<struct name="DIDResult">
+  <description>Individual requested DID result and data</description>
+  <param name="resultCode" type="Common.VehicleDataResultCode" mandatory="true">
+    <description>Individual DID result code.</description>
+  </param>
+  <param name="didLocation" type="Integer" minvalue="0" maxvalue="65535" mandatory="true">
+    <description>Location of raw data (the address from ReadDID request)</description>
+  </param>
+  <param name="data" type="String" maxlength="5000" mandatory="false">
+    <description>Raw DID-based data returned for requested element.</description>
+  </param>
+</struct>
+
+<struct name="HeadLampStatus">
+  <param name="lowBeamsOn" type="Boolean" mandatory="true">
+    <description>Status of the low beam lamps.</description>
+  </param>
+  <param name="highBeamsOn" type="Boolean" mandatory="true">
+    <description>Status of the high beam lamps.</description>
+  </param>
+  <param name="ambientLightSensorStatus" type="Common.AmbientLightStatus" mandatory="true">
+    <description>Status of the ambient light sensor.</description>
+  </param>
+</struct>
+
+<struct name="TireStatus">
+<description>The status and pressure of the tires.</description>
+<param name="pressureTelltale" type="Common.WarningLightStatus" mandatory="false">
+  <description>Status of the Tire Pressure Telltale. See WarningLightStatus.</description>
+</param>
+  <param name="leftFront" type="Common.SingleTireStatus" mandatory="false">
+    <description>The status of the left front tire.</description>
+</param>
+  <param name="rightFront" type="Common.SingleTireStatus" mandatory="false">
+    <description>The status of the right front tire.</description>
+</param>
+  <param name="leftRear" type="Common.SingleTireStatus" mandatory="false">
+    <description>The status of the left rear tire.</description>
+</param>
+  <param name="rightRear" type="Common.SingleTireStatus" mandatory="false">
+    <description>The status of the right rear tire.</description>
+</param>
+  <param name="innerLeftRear" type="Common.SingleTireStatus" mandatory="false">
+    <description>The status of the inner left rear.</description>
+</param>
+  <param name="innerRightRear" type="Common.SingleTireStatus" mandatory="false">
+    <description>The status of the inner right rear.</description>
+</param>
+</struct>
+
+<struct name="BeltStatus">
+  <param name="driverBeltDeployed" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="passengerBeltDeployed" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="passengerBuckleBelted" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="driverBuckleBelted" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="leftRow2BuckleBelted" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="passengerChildDetected" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="rightRow2BuckleBelted" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="middleRow2BuckleBelted" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="middleRow3BuckleBelted" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="leftRow3BuckleBelted" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="rightRow3BuckleBelted" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="leftRearInflatableBelted" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="rightRearInflatableBelted" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="middleRow1BeltDeployed" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+  <param name="middleRow1BuckleBelted" type="Common.VehicleDataEventStatus" mandatory="false">
+    <description>See VehicleDataEventStatus.</description>
+</param>
+</struct>
+
+<struct name="BodyInformation">
+  <param name="parkBrakeActive" type="Boolean" mandatory="true">
+    <description>Must be true if the park brake is active</description>
+  </param>
+  <param name="ignitionStableStatus" type="Common.IgnitionStableStatus" mandatory="true">
+    <description>Information about the ignition switch. See IgnitionStableStatus.</description>
+  </param>
+  <param name="ignitionStatus" type="Common.IgnitionStatus" mandatory="true">
+    <description>The status of the ignition. See IgnitionStatus.</description>
+  </param>
+</struct>
+
+<struct name="DeviceStatus">
+  <param name="voiceRecOn" type="Boolean" mandatory="false">
+    <description>Must be true if the voice recording is on.</description>
+  </param>
+  <param name="btIconOn" type="Boolean" mandatory="false">
+    <description>Must be true if Bluetooth icon is displayed.</description>
+  </param>
+  <param name="callActive" type="Boolean" mandatory="false">
+    <description>Must be true if there is an active call..</description>
+  </param>
+  <param name="phoneRoaming" type="Boolean" mandatory="false">
+    <description>Must be true if ther is a phone roaming.</description>
+  </param>
+  <param name="textMsgAvailable" type="Boolean" mandatory="false">
+    <description>Must be true if the text message is available.</description>
+  </param>
+  <param name="battLevelStatus" type="Common.DeviceLevelStatus" mandatory="false">
+    <description>Device battery level status. See DeviceLevelStatus.</description>
+  </param>
+  <param name="stereoAudioOutputMuted" type="Boolean" mandatory="false">
+    <description>Must be true if stereo audio output is muted.</description>
+  </param>
+  <param name="monoAudioOutputMuted" type="Boolean" mandatory="false">
+    <description>Must be true if mono audio output is muted.</description>
+  </param>
+  <param name="signalLevelStatus" type="Common.DeviceLevelStatus" mandatory="false">
+    <description>Device signal level status. See DeviceLevelStatus.</description>
+  </param>
+  <param name="primaryAudioSource" type="Common.PrimaryAudioSource" mandatory="false">
+    <description>See PrimaryAudioSource.</description>
+  </param>
+  <param name="eCallEventActive" type="Boolean" mandatory="false">
+    <description>Must be true if emergency call event is active.</description>
+  </param>
+</struct>
+
+<struct name="ECallInfo">
+  <param name="eCallNotificationStatus" type="Common.VehicleDataNotificationStatus">
+    <description>References signal "eCallNotification_4A". See VehicleDataNotificationStatus.</description>
+  </param>
+  <param name="auxECallNotificationStatus" type="Common.VehicleDataNotificationStatus">
+    <description>References signal "eCallNotification". See VehicleDataNotificationStatus.</description>
+  </param>
+  <param name="eCallConfirmationStatus" type="Common.ECallConfirmationStatus">
+    <description>References signal "eCallConfirmation". See ECallConfirmationStatus.</description>
+  </param>
+</struct>
+
+<struct name="AirbagStatus">
+  <param name="driverAirbagDeployed" type="Common.VehicleDataEventStatus">
+    <description>References signal "VedsDrvBag_D_Ltchd". See VehicleDataEventStatus.</description>
+  </param>
+  <param name="driverSideAirbagDeployed" type="Common.VehicleDataEventStatus">
+    <description>References signal "VedsDrvSideBag_D_Ltchd". See VehicleDataEventStatus.</description>
+  </param>
+  <param name="driverCurtainAirbagDeployed" type="Common.VehicleDataEventStatus">
+    <description>References signal "VedsDrvCrtnBag_D_Ltchd". See VehicleDataEventStatus.</description>
+  </param>
+  <param name="passengerAirbagDeployed" type="Common.VehicleDataEventStatus">
+    <description>References signal "VedsPasBag_D_Ltchd". See VehicleDataEventStatus.</description>
+  </param>
+  <param name="passengerCurtainAirbagDeployed" type="Common.VehicleDataEventStatus">
+    <description>References signal "VedsPasCrtnBag_D_Ltchd". See VehicleDataEventStatus.</description>
+  </param>
+  <param name="driverKneeAirbagDeployed" type="Common.VehicleDataEventStatus">
+    <description>References signal "VedsKneeDrvBag_D_Ltchd". See VehicleDataEventStatus.</description>
+  </param>
+  <param name="passengerSideAirbagDeployed" type="Common.VehicleDataEventStatus">
+    <description>References signal "VedsPasSideBag_D_Ltchd". See VehicleDataEventStatus.</description>
+  </param>
+  <param name="passengerKneeAirbagDeployed" type="Common.VehicleDataEventStatus">
+    <description>References signal "VedsKneePasBag_D_Ltchd". See VehicleDataEventStatus.</description>
+  </param>
+</struct>
+
+<struct name="EmergencyEvent">
+  <param name="emergencyEventType" type="Common.EmergencyEventType">
+    <description>References signal "VedsEvntType_D_Ltchd". See EmergencyEventType.</description>
+  </param>
+  <param name="fuelCutoffStatus" type="Common.FuelCutoffStatus">
+    <description>References signal "RCM_FuelCutoff". See FuelCutoffStatus.</description>
+  </param>
+  <param name="rolloverEvent" type="Common.VehicleDataEventStatus">
+    <description>References signal "VedsEvntRoll_D_Ltchd". See VehicleDataEventStatus.</description>
+  </param>
+  <param name="maximumChangeVelocity" type="Common.VehicleDataEventStatus">
+    <description>References signal "VedsMaxDeltaV_D_Ltchd". See VehicleDataEventStatus.</description>
+  </param>
+  <param name="multipleEvents" type="Common.VehicleDataEventStatus">
+    <description>References signal "VedsMultiEvnt_D_Ltchd". See VehicleDataEventStatus.</description>
+  </param>
+</struct>
+
+<struct name="ClusterModeStatus">
+  <param name="powerModeActive" type="Boolean">
+    <description>References signal "PowerMode_UB".</description>
+  </param>
+  <param name="powerModeQualificationStatus" type="Common.PowerModeQualificationStatus">
+    <description>References signal "PowerModeQF". See PowerModeQualificationStatus.</description>
+  </param>
+  <param name="carModeStatus" type="Common.CarModeStatus">
+    <description>References signal "CarMode". See CarMode.</description>
+  </param>
+  <param name="powerModeStatus" type="Common.PowerModeStatus">
+    <description>References signal "PowerMode". See PowerMode.</description>
+  </param>
+</struct>
+
+<struct name="MyKey">
+  <param name="e911Override" type="Common.VehicleDataStatus" mandatory="true">
+    <description>Indicates whether e911 override is on. See VehicleDataStatus.</description>
+  </param>
+</struct>
+<!--end of IVI part-->
+
+</interface>
+
+<interface name="Buttons" version="1.0" date="2013-04-12">
+	<function name="GetCapabilities" messagetype="request">
+		<description>Method is invoked at system start-up. SDL requests the information about all supported hardware buttons and their capabilities</description>
+    </function>
+    <function name="GetCapabilities" messagetype="response">
+        <param name="capabilities" type="Common.ButtonCapabilities" array="true" minsize="1" maxsize="100" mandatory="true">
+        	<description>Response must provide the names of available buttons and their capabilities.See ButtonCapabilities</description>
+        </param>
+        <param name="presetBankCapabilities" type="Common.PresetBankCapabilities" mandatory="false">
+        	<description>Must be returned if the platform supports custom on-screen Presets</description>
+    	</param>
+    </function>
+    <function name="OnButtonEvent" messagetype="notification">
+    	<description>HU system must notify about every UP/DOWN event for buttons</description>
+    	<param name="name" type="Common.ButtonName" mandatory="true"/>
+    	<param name="mode" type="Common.ButtonEventMode" mandatory="true">
+            <description>Indicates whether this is an UP or DOWN event.</description>
+    	</param>
+    	<param name="customButtonID" type="Integer" mandatory="false" minvalue="0" maxvalue="65536">
+    		<description>Must be provided if ButtonName is CUSTOM_BUTTON, this references the integer ID passed by a custom button. (e.g. softButtonName)</description>
+    	</param>
+    </function>
+    <function name="OnButtonPress" messagetype="notification">
+        <param name="name" type="Common.ButtonName" mandatory="true"/>
+        <param name="mode" type="Common.ButtonPressMode" mandatory="true">
+            <description>Indicates whether this is a LONG or SHORT button press event.</description>
+        </param>
+        <param name="customButtonID" type="Integer" mandatory="false" minvalue="0" maxvalue="65536">
+            <description>Must be returned if ButtonName is CUSTOM_BUTTON, this references the string passed by a custom button. (e.g. softButtonName)</description>
+        </param>
+    </function>
+</interface>
+
+<interface name="BasicCommunication" version="1.0" date="2013-04-12">
+    <function name="OnReady" messagetype="notification">
+      <description>HMI must notify SDL about its readiness to start communication. In fact, this has to be the first message between SDL and HMI.</description>
+    </function>
+    <function name="OnStartDeviceDiscovery" messagetype="notification">
+      <description>Initiated by HMI user for getting the list of connected devices.</description>
+    </function>
+    <function name="UpdateDeviceList" messagetype="request">
+      <description>Request from SmartDeviceLink to HMI to change device list.</description>
+      <param name="deviceList" type="Common.DeviceInfo" mandatory="true" array="true" minsize="0" maxsize="100">
+        <description>The array of names/IDs of connected devices</description>
+      </param>
+    </function>
+    <function name="UpdateDeviceList" messagetype="response">
+    </function>
+    <function name="OnUpdateDeviceList" messagetype="notification">
+      <description>Notification from HMI to SDL sent when HMI requires update of device list (i.e. when user clicks 'Change Device' button)</description>
+    </function>
+    <function name="AllowDeviceToConnect" messagetype="request">
+        <description>Request from SmartDeviceLink to HMI to get the permissions of new device connection.</description>
+        <param name="device" type="Common.DeviceInfo" mandatory="true"/>
+    </function>
+    <function name="AllowDeviceToConnect" messagetype="response">
+      <param name="allow" type="Boolean" mandatory="true"/>
+    </function>
+    <function name="OnDeviceChosen" messagetype="notification">
+      <description>Notification must be initiated by HMI on user selecting device in the list of devices.</description>
+      <param name="deviceInfo" type="Common.DeviceInfo" mandatory="true">
+        <description>The name and ID of the device chosen</description>
+      </param>
+    </function>
+    <function name="OnFindApplications" messagetype="notification">
+      <description>This method must be invoked by HMI to get list of registered apps.</description>
+      <param name="deviceInfo" type="Common.DeviceInfo" mandatory="false">
+        <description>The name and ID of the device the list of registered applications is required for.</description>
+      </param>
+    </function>
+    <function name="UpdateAppList" messagetype="request">
+      <description>Issued by SDL to notify HMI about new applications registered.</description>
+      <param name="applications" type="Common.HMIApplication" mandatory="true" array="true" minsize="1" maxsize="100"/>
+    </function>
+    <function name="UpdateAppList" messagetype="response">
+    </function>
+    <function name="ActivateApp" messagetype="request">
+      <description>Request from SDL to HMI to bring specified application to front on UI e.g make it HMI status 'FULL'.</description>
+      <param name="appID" type="Integer" mandatory="true">
+        <description>ID of deactivated application.</description>
+      </param>
+    </function>
+    <function name="ActivateApp" messagetype="response">
+    </function>
+    <function name="OnAppActivated" messagetype="notification">
+      <description>Must be sent by HU system when the user clicks on app in the list of registered apps or on soft button with 'STEAL_FOCUS' action.</description>
+      <param name="appID" type="Integer" mandatory="true">
+        <description>ID of selected application.</description>
+      </param>
+    </function>
+    <function name="OnAppDeactivated" messagetype="notification">
+      <description>Must be sent by HU system when the user switches to any functionality which is not other mobile application.</description>
+      <param name="appID" type="Integer" mandatory="true">
+        <description>ID of deactivated application.</description>
+      </param>
+      <param name="reason" type="Common.DeactivateReason" mandatory="true">
+        <description>Specifies the functionality the user has switched to.</description>
+      </param>
+    </function>
+    <function name="OnAppRegistered" messagetype="notification">
+      <description>Issued by SDL to notify HMI about new application registered.</description>
+      <param name="application" type="Common.HMIApplication" mandatory="true">
+        <description>The information about application registered. See HMIApplication. </description>
+      </param>
+      <param name="resume" type="Boolean" mandatory="false">
+        <description>Flag to indicate if application may be resumed in future</description>
+      </param>
+    </function>
+    <function name="OnAppUnregistered" messagetype="notification">
+      <description>Issued by SDL to notify HMI about application unregistered. Application then to be removed from application list; all data connected with application has to be cleared up.</description>
+      <param name="appID" type="Integer" mandatory="true">
+        <description>ID of the application unregistered</description>
+      </param>
+      <param name="resume" type="Boolean" mandatory="false">
+        <description>Flag to indicate if application may be resumed in future</description>
+      </param>
+    </function>
+    <function name="GetResumeResult" messagetype="request">
+      <description>Issued by SDL to request HMI resumption check.</description>
+      <param name="appID" type="Integer" mandatory="true">
+        <description>ID of the registered application that will be resumed</description>
+      </param>
+    </function>
+    <function name="GetResumeResult" messagetype="response">
+      <description>Issued by HMI to notify SDL about application resumption check.</description>
+      <param name="result" type="Boolean" mandatory="true">
+        <description>Flag to indicate if applications data check was successfull</description>
+      </param>
+    </function>
+    <function name="OnExitApplication" messagetype="notification">
+      <description>Must be sent by HMI when the User chooses to exit the application..</description>
+      <param name="appID" type="Integer" mandatory="true">
+        <description>ID of the application to be exited.</description>
+      </param>
+    </function>
+    <function name="OnExitAllApplications" messagetype="notification">
+      <description>Sent by HMI to SDL to close all registered applications.</description>
+      <param name="reason" type="Common.ApplicationsCloseReason" mandatory="true">
+        <description>Specifies reason for exiting all apllications.</description>
+      </param>
+    </function>
+    <function name="MixingAudioSupported" messagetype="request">
+      <description>Request from SDL to HMI to find out if the last one supports mixing audio (i.e. recording TTS command and playing audio).</description>
+    </function>
+    <function name="MixingAudioSupported" messagetype="response">
+      <description>If no response received SDL supposes that mixing audio is not supported</description>
+      <param name="attenuatedSupported" type="Boolean" mandatory="true">
+        <description>Must be true if supported</description>
+      </param>
+    </function>
+    <function name="PlayTone" messagetype="notification">
+      <description>Sent by SDL to HMI to notify that the tone should be played.</description>
+    </function>
+    <!-- Policies -->
+    <function name="AllowAllApps" messagetype="request">
+      <description>Initiated by SDL. Results by user/HMI allowing SDL functionality or disallowing access to all mobile apps.</description>
+    </function>
+    <function name="AllowAllApps" messagetype="response">
+      <param name="allowed" type="Boolean" mandatory="true">
+        <description>Must be true if allowed</description>
+      </param>
+    </function>
+    <function name="AllowApp" messagetype="request">
+      <description>Initiated by SDL for requesting the allowance for the application</description>
+      <param name="app" type="Common.HMIApplication" mandatory="true">
+        <description>Information about the application. See HMIApplication. </description>
+      </param>
+      <param name="appPermissions" type="String" array="true" minsize="1" maxsize="100" mandatory="false">
+        <description>List of permissions required by application.</description>
+      </param>
+    </function>
+    <function name="AllowApp" messagetype="response">
+      <param name="allowed" type="Boolean" mandatory="true">
+        <description>Must be true if allowed</description>
+      </param>
+    </function>
+
+    <function name="OnSystemRequest" messagetype="notification" >
+	<description>
+        An asynchronous request from the system for specific data from the device or the cloud or response to a request from the device or cloud
+	Binary data can be included in hybrid part of message for some requests (such as Authentication request responses)
+	</description>
+      <param name="requestType" type="Common.RequestType" mandatory="true">
+        <description>The type of system request.</description>
+      </param>
+      <param name="url" type="String" maxlength="1000" minsize="1" maxsize="100" array="true" mandatory="false">
+        <description>Optional array of URL(s) for HTTP requests.</description>
+      </param>
+      <param name="fileType" type="Common.FileType" mandatory="false">
+        <description>Optional file type (meant for HTTP file requests).</description>
+      </param>
+      <param name="offset" type="Integer" minvalue="0" maxvalue="100000000000" mandatory="false">
+        <description>Optional offset in bytes for resuming partial data chunks</description>
+      </param>
+      <param name="length" type="Integer" minvalue="0" maxvalue="100000000000" mandatory="false">
+        <description>Optional length in bytes for resuming partial data chunks</description>
+      </param>
+    </function>
+
+</interface>
+
+<interface name="VR" version="1.0" date="2013-04-17">
+  <function name="IsReady" messagetype="request">
+    <description>Method is invoked at system startup. Response provides information about presence of VR module and its readiness to cooperate with SDL.</description>
+  </function>
+  <function name="IsReady" messagetype="response">
+    <param name="available" type="Boolean" mandatory="true">
+      <description>Must be true if VR is present and ready to communicate with SDL.</description>
+    </param>
+  </function>
+  <function name="Started" messagetype="notification">
+    <description>Must be initiated  by VR module to let SDL know that VR session has started.</description>
+  </function>
+  <function name="Stopped" messagetype="notification">
+    <description>Must be initiated by VR module to let SDL know that VR session has stopped.</description>
+  </function>
+  <function name="AddCommand" messagetype="request">
+    <description>Request from SDL to add a command(string with associated id) to VR.</description>
+    <param name="cmdID" type="Integer" mandatory="true" minvalue="0">
+      <description>ID of a command (further to be used in OnCommand notification).</description>
+    </param>
+    <param name="vrCommands" type="String" mandatory="true" maxlength="99" minsize="1" maxsize="100" array="true">
+      <description>List of strings to be used as VR commands.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="false">
+      <description>ID of application that requested this RPC.</description>
+    </param>
+  </function>
+  <function name="AddCommand" messagetype="response">
+  </function>
+  <function name="DeleteCommand" messagetype="request">
+    <description>Request from SDL to delete a command from VR.</description>
+    <param name="cmdID" type="Integer" mandatory="true">
+      <description>Id of a command (list of strings), previously sent by AddCommand.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that requested this RPC.</description>
+    </param>
+  </function>
+  <function name="DeleteCommand" messagetype="response">
+  </function>
+  <function name="OnCommand" messagetype="notification">
+    <description>Notifies SDL about command trigerred via VR</description>
+    <param name="cmdID" type="Integer" mandatory="true">
+      <description>ID of of the command (list of strings)</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="false">
+      <description>ID of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="ChangeRegistration" messagetype="request">
+    <description>Request from SmartDeviceLink to HMI to change language of VR.</description>
+    <param name="language" type="Common.Language" mandatory="true">
+      <description>The language application wants to switch to.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that concerns this RPC.</description>
+    </param>
+  </function>
+  <function name="ChangeRegistration" messagetype="response">
+  </function>
+  <function name="OnLanguageChange" messagetype="notification">
+    <description>Notification from HMI to SmartDeviceLink about change of  language.</description>
+    <param name="language" type="Common.Language" mandatory="true">
+      <description>Language VR has switched to.</description>
+    </param>
+  </function>
+  <function name="GetSupportedLanguages" messagetype="request">
+    <description>Method is invoked at system start-up. Response must provide the information about VR supported languages.</description>
+  </function>
+  <function name="GetSupportedLanguages" messagetype="response">
+    <param name="languages" type="Common.Language" mandatory="true" array="true" minsize="1" maxsize="100">
+      <description>List of languages supported in VR.</description>
+    </param>
+  </function>
+  <function name="GetLanguage" messagetype="request">
+    <description>Request from SmartDeviceLink to HMI to get currently active  VR language</description>
+  </function>
+  <function name="GetLanguage" messagetype="response">
+    <param name="language" type="Common.Language" mandatory="true"/>
+  </function>
+  <function name="GetCapabilities" messagetype="request">
+    <description>Method is invoked at system startup by SDL to request information about VR capabilities of HMI.</description>
+  </function>
+  <function name="GetCapabilities" messagetype="response">
+    <param name="vrCapabilities" type="Common.VrCapabilities" minsize="1" maxsize="100" array="true" mandatory="false">
+      <description>Types of input recognized by VR module.</description>
+    </param>
+  </function>
+</interface>
+
+<interface name="TTS" version="1.0" date="2013-04-18">
+  <description>RPCs for communication between TTS and SDL.</description>
+  <function name="GetCapabilities" messagetype="request">
+    <description>Method is invoked at system start-up. SDL requests the information about all supported hardware and their capabilities</description>
+  </function>
+  <function name="GetCapabilities" messagetype="response">
+    <param name="capabilities" type="Common.SpeechCapabilities" mandatory="true">
+    </param>
+  </function>
+  <function name="Started" messagetype="notification">
+    <description>Must be initiated  by TTS module to let SDL know that TTS session has started.</description>
+  </function>
+  <function name="Stopped" messagetype="notification">
+    <description>Must be initiated by TTS module to let SDL know that TTS session has stopped.</description>
+  </function>
+  <function name="IsReady" messagetype="request">
+    <description>Method is invoked at system start-up. Response must provide the information about presence of TTS module and its readiness to cooperate with SDL.</description>
+  </function>
+  <function name="IsReady" messagetype="response">
+    <param name="available" type="Boolean" mandatory="true">
+      <description>Must be true if TTS is present and ready to communicate with SDL.</description>
+    </param>
+  </function>
+  <function name="PerformInteraction" messagetype="request">
+    <description>Sets some properties for the application initiated request.</description>
+    <param name="helpPrompt" type="Common.TTSChunk" minsize="1" maxsize="100" array="true" mandatory="false">
+      <description>The help prompt. An array of text chunks of type TTSChunk. See TTSChunk. The array must have at least one item.</description>
+    </param>
+    <param name="initialPrompt" type="Common.TTSChunk" minsize="1" maxsize="100" array="true">
+      <description>
+      	This is the intial prompt spoken to the user at the start of an interaction.
+      	An array of text chunks of type TTSChunk. See TTSChunk.
+      	The array must have at least one item.
+      </description>
+    </param>
+    <param name="timeoutPrompt" type="Common.TTSChunk" minsize="1" maxsize="100" array="true" mandatory="false">
+      <description>Help text for a wait timeout. An array of text chunks of type TTSChunk. See TTSChunk. The array must have at least one item.</description>
+    </param>
+    <param name="timeout" type="Integer" mandatory="true">
+      <description>Timeout initiate timeoutPrompt</description>
+    </param>
+  </function>
+  <function name="PerformInteraction" messagetype="response">
+  </function>
+  <function name="Speak" messagetype="request">
+    <description>RPC from SDL to TTS for speaking the text.</description>
+    <param name="ttsChunks" type="Common.TTSChunk" mandatory="true" array="true" minsize="1" maxsize="100">
+      <description>List of strings to be spoken.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that requested this RPC.</description>
+    </param>
+  </function>
+  <function name="Speak" messagetype="response">
+    <description>Provides information about success of operation.</description>
+  </function>
+  <function name="StopSpeaking" messagetype="request">
+    <description>Initiated by SDL to stop speaking the text.</description>
+  </function>
+  <function name="StopSpeaking" messagetype="response">
+  </function>
+  <function name="ChangeRegistration" messagetype="request">
+    <description>Request from SmartDeviceLink to HMI to change language of TTS.</description>
+    <param name="language" type="Common.Language" mandatory="true">
+      <description>The language application wants to switch to.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="ChangeRegistration" messagetype="response">
+  </function>
+  <function name="OnLanguageChange" messagetype="notification">
+    <description>Notification from HMI to SmartDeviceLink about change of  language.</description>
+    <param name="language" type="Common.Language" mandatory="true">
+      <description>Language TTS has switched to.</description>
+    </param>
+  </function>
+  <function name="GetSupportedLanguages" messagetype="request">
+    <description>Method is invoked at system start-up by SDL. Response must provide the information about TTS supported languages.</description>
+  </function>
+  <function name="GetSupportedLanguages" messagetype="response">
+    <param name="languages" type="Common.Language" mandatory="true" array="true" minsize="1" maxsize="100">
+      <description>List of languages supported in TTS.</description>
+    </param>
+  </function>
+  <function name="GetLanguage" messagetype="request">
+    <description>Request from SmartDeviceLink to HMI to get currently active  TTS language</description>
+  </function>
+  <function name="GetLanguage" messagetype="response">
+    <param name="language" type="Common.Language" mandatory="true"/>
+  </function>
+  <function name="SetGlobalProperties" messagetype="request">
+    <description>Sets some properties for the application initiated request.</description>
+    <param name="helpPrompt" type="Common.TTSChunk" minsize="1" maxsize="100" array="true" mandatory="false" >
+      <description>
+          The help prompt.
+          An array of text chunks of type TTSChunk. See TTSChunk.
+          The array must have at least one item.
+      </description>
+    </param>
+    <param name="timeoutPrompt" type="Common.TTSChunk" minsize="1" maxsize="100" array="true" mandatory="false" >
+      <description>
+          Help text for a wait timeout.
+          An array of text chunks of type TTSChunk. See TTSChunk.
+          The array must have at least one item.
+      </description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="SetGlobalProperties" messagetype="response">
+  </function>
+</interface>
+
+<interface name="UI" version="1.0" date="2013-04-16">
+  <function name="Alert" messagetype="request">
+    <description>Request from SDL to show an alert message on the display.</description>
+    <param name="alertStrings" type="Common.TextFieldStruct" mandatory="true" array="true" minsize="0" maxsize="3">
+      <description>Array of lines of alert text fields. See TextFieldStruct. Uses alertText1, alertText2, alertText3.</description>
+    </param>
+    <param name="duration" type="Integer" mandatory="true" minvalue="3000" maxvalue="10000" defvalue="5000">
+      <description>Timeout in milliseconds.</description>
+    </param>
+    <param name="softButtons" type="Common.SoftButton" mandatory="false" minsize="0" maxsize="4" array="true">
+      <description>App defined SoftButtons</description>
+    </param>
+    <param name="progressIndicator" type="Boolean" mandatory="false">
+      <description>If supported on the given platform, the alert GUI will include some sort of animation indicating that loading of a feature is progressing.  e.g. a spinning wheel or hourglass, etc.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="Alert" messagetype="response">
+    <param name="tryAgainTime" type="Integer" mandatory="false" minvalue="0" maxvalue="360000">
+      <description>Amount of time (in milliseconds) that SDL must wait before resending an alert. Must be provided if another system event or overlay currently has a higher priority than this alert.</description>
+    </param>
+  </function>
+  <function name="ShowNotification" messagetype="notification">
+    <description>Initiated by SDL in order to notify user about some actions, i.e. while waiting for updates from server etc.</description>
+    <param name="text" type="Common.TextFieldStruct" mandatory="true"/>
+    <param name="icon" type="Common.Image" mandatory="false"/>
+    <param name="timeout" type="Integer" mandatory="true">
+      <description>Pop-up is expected to be shown before time specified with timeout is up and then closed by HMI or closed upon ClosePopUp request from SDL.</description>
+    </param>
+  </function>
+  <function name="Show" messagetype="request">
+    <param name="showStrings" type="Common.TextFieldStruct" mandatory="true" array="true" minsize="0" maxsize="7">
+      <description>Array of lines of show text fields. See TextFieldStruct. Uses mainField1, mainField2, mainField3, mainField4. If some field is not set, the corresponding text should stay unchanged. If field's text is empty "", the field must be cleared.
+          mainField1: The text that should be displayed in a single or upper display line.
+          mainField2: The text that should be displayed on the second display line.
+          mainField3: The text that should be displayed on the second "page" first display line.
+          mainField4: The text that should be displayed on the second "page" second display line.
+          statusBar: statusBar.
+          mediaClock: Text value for MediaClock field.
+          mediaTrack: The text that should be displayed in the track field. This field is only valid for media applications on NGN type ACMs.
+      </description>
+    </param>
+    <param name="alignment" type="Common.TextAlignment" mandatory="false">
+      <description>Specifies how mainField1 and mainField2 texts should be aligned on the display.</description>
+      <description>If omitted, texts must be centered</description>
+    </param>
+    <param name="graphic" type="Common.Image" mandatory="false">
+      <description>Path to optional dynamic image or the static binary image itself.  See Image. If omitted, the displayed graphic should not change.</description>
+    </param>
+    <param name="secondaryGraphic" type="Common.Image" mandatory="false">
+      <description>
+        Image struct determining whether static or dynamic secondary image to display in app.
+        If omitted on supported displays, the displayed secondary graphic shall not change.
+      </description>
+    </param>
+    <param name="softButtons" type="Common.SoftButton" minsize="0" maxsize="8" array="true" mandatory="false">
+      <description>App defined SoftButtons.</description>
+      <description>If omitted, the currently displayed SoftButton values should not change.</description>
+    </param>
+    <param name="customPresets" type="String" maxlength="500" minsize="0" maxsize="6" array="true" mandatory="false">
+      <description>App labeled on-screen presets (i.e. GEN3 media presets or dynamic search suggestions).</description>
+      <description>If omitted on supported displays, the presets will be shown as not defined.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>Id of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="Show" messagetype="response">
+  </function>
+  <function name="AddCommand" messagetype="request">
+    <description>Request from SDL to add a command to the application menu.</description>
+    <param name="cmdID" type="Integer" minvalue="0" mandatory="true">
+      <description>ID of the command to be added.</description>
+    </param>
+    <param name="menuParams" type="Common.MenuParams" mandatory="false">
+      <description>Optional sub value containing parameters of the command (position, name, etc.). See MenuParams. If omitted the command should be added to the end of the list of commands.</description>
+    </param>
+    <param name="cmdIcon" type="Common.Image" mandatory="false">
+      <description>Image to be displayed for representing the command. See Image.</description>
+      <description>If omitted, no (or the default if applicable) icon should be displayed.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that concerns this RPC.</description>
+    </param>
+  </function>
+  <function name="AddCommand" messagetype="response">
+    </function>
+  <function name="DeleteCommand" messagetype="request">
+    <description>Request from SDL to delete a command from the in-application menu with the specified command id.</description>
+    <param name="cmdID" type="Integer" mandatory="true" minvalue="0" maxvalue="2000000000">
+      <description>cmdId previously sent via AddCommand request - id of the command to be deleted.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that concerns this RPC.</description>
+    </param>
+  </function>
+  <function name="DeleteCommand" messagetype="response">
+  </function>
+  <function name="AddSubMenu" messagetype="request">
+    <description>Request from SDL to add a sub menu to the in-application menu.</description>
+    <param name="menuID" type="Integer" minvalue="0" maxvalue="2000000000" mandatory="true">
+      <description>ID of the sub menu to be added. Unique for the application.</description>
+    </param>
+    <param name="menuParams" type="Common.MenuParams" mandatory="true">
+      <description>Position and name of menu to be added. 'parent' field is omitted for this RPC.  </description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that requested this RPC.</description>
+    </param>
+  </function>
+  <function name="AddSubMenu" messagetype="response">
+  </function>
+  <function name="DeleteSubMenu" messagetype="request">
+    <description>Request from SDL to delete a submenu from the in-application menu.</description>
+    <param name="menuID" type="Integer" minvalue="0" maxvalue="2000000000" mandatory="true" >
+      <description>The "menuID" of the sub-menu to be deleted. (See addSubMenu.menuID)</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that concerns this RPC.</description>
+    </param>
+  </function>
+  <function name="DeleteSubMenu" messagetype="response">
+  </function>
+  <function name="PerformInteraction" messagetype="request">
+    <description>Request from SDL for triggering an interaction (e.g. "Permit GPS?" - Yes, no, Always Allow).</description>
+    <param name="initialText" type="Common.TextFieldStruct" mandatory="true">
+      <description>Uses initialInteractionText. See TextFieldStruct.</description>
+    </param>
+    <param name="choiceSet" type="Common.Choice" minsize="1" maxsize="100" array="true" mandatory="false">
+      <description>The list of choices to be used for the interaction with the user</description>
+    </param>
+    <param name="vrHelpTitle" type="String" maxlength="500" mandatory="false">
+      <description>VR Help Title text.</description>
+      <description>If omitted on supported displays, the default HU system help title should be used.</description>
+    </param>
+    <param name="vrHelp" type="Common.VrHelpItem" minsize="1" maxsize="100" array="true" mandatory="false">
+      <description>VR Help Items. If omitted on supported displays, the default HU system generated help items should be used.</description>
+    </param>
+    <param name="timeout" type="Integer" minvalue="5000" maxvalue="100000" defvalue="10000" mandatory="true">
+      <description>Timeout in milliseconds.</description>
+    </param>
+    <param name="interactionLayout" type="Common.LayoutMode" mandatory="false">
+      <description>See LayoutMode.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that concerns this RPC.</description>
+    </param>
+  </function>
+  <function name="PerformInteraction" messagetype="response">
+    <param name="choiceID" type="Integer" minvalue="0" maxvalue="2000000000" mandatory="false">
+      <description>ID of the choice that was selected in response to PerformInteraction.</description>
+    </param>
+    <param name="manualTextEntry" type="String" maxlength="500" mandatory="false">
+      <description>
+	       	Manually entered text selection, e.g. through keyboard
+        	Can be returned in lieu of choiceID, depending on trigger source
+      </description>
+    </param>
+  </function>
+  <function name="SetMediaClockTimer" messagetype="request">
+    <description>Sets the initial media clock value and automatic update method.</description>
+    <param name="startTime" type="Common.TimeFormat" mandatory="false">
+      <description>startTime should be ignored for "PAUSE", "RESUME", and "CLEAR"</description>
+    </param>
+    <param name="endTime" type="Common.TimeFormat" mandatory="false">
+      <description>
+          See TimeFormat.
+      	  endTime can be provided for "COUNTUP" and "COUNTDOWN"; to be used to calculate any visual progress bar (if not provided, this feature is ignored)
+      	  If endTime is greater then startTime for COUNTDOWN or less than startTime for COUNTUP, then the request will return an INVALID_DATA.
+      	  endTime will be ignored for "PAUSE", "RESUME", and "CLEAR"
+      </description>
+    </param>
+    <param name="updateMode" type="Common.ClockUpdateMode" mandatory="true">
+      <description>The update method of the media clock.</description>
+      <description>In case of pause, resume, or clear, the start time value is ignored and shall be left out.  For resume, the time continues with the same value as it was when paused.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SetMediaClockTimer" messagetype="response">
+  </function>
+  <function name="SetGlobalProperties" messagetype="request">
+    <description>Request from SDL to set some properties for VR help.</description>
+    <param name="vrHelpTitle" type="String" maxlength="500" mandatory="false">
+      <description>VR Help Title text.</description>
+      <description>If omitted on supported displays, the default HU system help title should be used.</description>
+    </param>
+    <param name="vrHelp" type="Common.VrHelpItem" minsize="1" maxsize="100" array="true" mandatory="false">
+      <description>VR Help Items. If omitted on supported displays, the default HU system generated help items should be used.</description>
+    </param>
+    <param name="menuTitle" maxlength="500" type="String" mandatory="false">
+      <description>Optional text to label an app menu button (for certain touchscreen platforms).</description>
+    </param>
+    <param name="menuIcon" type="Common.Image" mandatory="false">
+      <description>>Optional icon to draw on an app menu button (for certain touchscreen platforms).</description>
+    </param>
+    <param name="keyboardProperties" type="Common.KeyboardProperties" mandatory="false">
+      <description>On-screen keybaord configuration (if available).</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that concerns this RPC.</description>
+    </param>
+  </function>
+  <function name="SetGlobalProperties" messagetype="response">
+  </function>
+  <function name="OnCommand" messagetype="notification">
+    <description>Notification must be initiated by HMI on user choosing menu item.</description>
+    <param name="cmdID" type="Integer" minvalue="0" maxvalue="2000000000" mandatory="true">
+      <description>Command ID, which is related to a specific menu entry (previously sent with AddCommand).</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that is related to this RPC.</description>
+    </param>
+  </function>
+  <function name="OnSystemContext" messagetype="notification">
+    <description>Notification must be initiated by HMI when the user changes the context of application: goes to menu (in-application menu or system menu); switches to VR; pop-up appears on screen etc.</description>
+    <param name="systemContext" type="Common.SystemContext" mandatory="true">
+      <description>The context the application is brought into.</description>
+    </param>
+  </function>
+  <function name="GetCapabilities" messagetype="request">
+    <description>Method is invoked at system startup by SDL to request information about UI capabilities of HMI.</description>
+  </function>
+  <function name="GetCapabilities" messagetype="response">
+    <param name="displayCapabilities" type="Common.DisplayCapabilities" mandatory="true">
+      <description>Information about the capabilities of the display: its type, text field supported, etc. See DisplayCapabilities. </description>
+    </param>
+    <param name="audioPassThruCapabilities" type="Common.AudioPassThruCapabilities" mandatory="true"/>
+    <param name="hmiZoneCapabilities" type="Common.HmiZoneCapabilities" mandatory="true"/>
+    <param name="softButtonCapabilities" type="Common.SoftButtonCapabilities" mandatory="false">
+      <description>Must be returned if the platform supports on-screen SoftButtons.</description>
+    </param>
+  </function>
+  <function name="ChangeRegistration" messagetype="request">
+    <description>Request from SmartDeviceLink to HMI to change language for app.</description>
+    <param name="language" type="Common.Language" mandatory="true">
+      <description>The language application wants to switch to.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that concerns this RPC.</description>
+    </param>
+  </function>
+  <function name="ChangeRegistration" messagetype="response">
+  </function>
+  <function name="OnLanguageChange" messagetype="notification">
+    <description>Notification from HMI to SmartDeviceLink about change of  language.</description>
+    <param name="language" type="Common.Language" mandatory="true">
+      <description>Language UI has switched to.</description>
+    </param>
+  </function>
+  <function name="GetSupportedLanguages" messagetype="request">
+    <description>Method should be invoked at system startup. Response provides information about UI supported languages.</description>
+  </function>
+  <function name="GetSupportedLanguages" messagetype="response">
+    <param name="languages" type="Common.Language" mandatory="true" array="true" minsize="1" maxsize="100">
+      <description>List of languages supported in UI.</description>
+    </param>
+  </function>
+  <function name="GetLanguage" messagetype="request">
+    <description>Request from SmartDeviceLink to HMI to get currently active  UI language</description>
+  </function>
+  <function name="GetLanguage" messagetype="response">
+    <param name="language" type="Common.Language" mandatory="true"/>
+  </function>
+  <function name="OnDriverDistraction" messagetype="notification">
+    <description>Notification must be sent from HMI to SDL when driver distraction state is changed. Driver distraction rules are defined by the platform.</description>
+    <param name="state" type="Common.DriverDistractionState" mandatory="true">
+      <description>See DriverDistractionState. </description>
+    </param>
+  </function>
+  <function name="SetAppIcon" messagetype="request">
+    <description>Used to set existing local file on SYNC as the app's icon.</description>
+    <param name="syncFileName" type="Common.Image" mandatory="true">
+      <description>Either the path to the dynamic image stored on HY or the static binary image itself. See Image</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="SetAppIcon" messagetype="response">
+  </function>
+  <function name="ShowCustomForm" messagetype="request">
+    <description>Used to show a custom form; it can be a parent or child screen. If no parent screen is designated, it is set as a parent screen.</description>
+    <param name="customFormID" type="String" maxlength="500" mandatory="true">
+      <description>
+			Predefined or dynamically created screen layout.
+			Currently only predefined forms are defined.
+			Predefined layouts include:
+				"DEFAULT" - Default media / non-media screen
+				"ONSCREEN_PRESETS" - Custom root media screen containing app-defined onscreen presets.
+				"KEYBOARD_SEARCH" - Custom template containing app-configured on-screen keyboard with active search updating; user also can trigger voice search.
+				"NAV_FULLSCREEN_MAP" - Custom root template screen containing full screen map with navigation controls.
+				"NAV_POI_MENU" - Custom template containing app-defined POI options.
+				"NAV_SEARCH_RESULTS" - Custom template containing a list of app-defined search results
+				"NAV_POI_INFO" - Custom template containing app-defined POI information (and potentially map data).
+      </description>
+    </param>
+    <param name="parentFormID" type="String" maxlength="500" mandatory="false">
+      <description>
+			Parent screen of predefined form to display.
+			Currently only predefined forms are defined.
+			If not provided, then set to "DEFAULT".
+			Predefined layouts include:
+				"DEFAULT" - Default media / non-media screen
+				"ONSCREEN_PRESETS" - Custom root media screen containing app-defined onscreen presets.
+				"NAV_FULLSCREEN_MAP" - Custom template containing full screen map with navigation controls.
+      </description>
+    </param>
+  </function>
+  <function name="ShowCustomForm" messagetype="response">
+    <param name="info" type="String" maxlength="1000" mandatory="false" platform="documentation">
+      <description>Provides additional human readable info regarding the result.</description>
+    </param>
+  </function>
+  <function name="ShowKeyboard" messagetype="request">
+    <description>Configures and populates on-screen keyboard.</description>
+    <param name="language" type="Common.Language" mandatory="true">
+      <description>The keyboard language.</description>
+    </param>
+    <param name="keyboardLayout" type="Common.KeyboardLayout" mandatory="true" >
+      <description>Desired keyboard layout.</description>
+    </param>
+    <param name="sendDynamicEntry" type="Boolean" mandatory="false">
+      <description>In this mode, all keypresses will be sent as they occur.</description>
+      <description>If disabled, entire string of text will be returned only once submitted by user.</description>
+      <description>If omitted, this value will be set to FALSE.</description>
+    </param>
+    <param name="limitedCharacterList" type="String" maxlength="1" minsize="1" maxsize="100" array="true" mandatory="false">
+      <description>Array of keyboard characters to enable.</description>
+      <description>All omitted characters will be greyed out (disabled) on the keyboard.</description>
+      <description>If omitted, the entire keyboard will be enabled.</description>
+    </param>
+    <param name="autoCompleteText" type="String" maxlength="1000" mandatory="false">
+      <description>Allows an app to prepopulate the text field with a suggested or completed entry as the user types</description>
+    </param>
+  </function>
+  <function name="ShowKeyboard" messagetype="response">
+    <param name="info" type="String" maxlength="1000" mandatory="false" platform="documentation">
+      <description>Provides additional human readable info regarding the result.</description>
+    </param>
+  </function>
+  <function name="OnKeyboardInput" messagetype="notification">
+    <description>On-screen keyboard event.</description>
+    <description>Can be full string or individual keypresses depending on keyboard mode.</description>
+    <param name="event" type="Common.KeyboardEvent" mandatory="true">
+      <description>On-screen keyboard input data.</description>
+    </param>
+    <param name="data" type="String" maxlength="500" mandatory="false">
+      <description>On-screen keyboard input data.</description>
+      <description>For dynamic keypress events, this will be the current compounded string of entry text.</description>
+      <description>For entry submission events, this will be the full text entry (this will always return regardless of the mode).</description>
+      <description>For entry cancelled and entry aborted events, this data param will be omitted.</description>
+    </param>
+  </function>
+  <function name="OnTouchEvent" messagetype="notification">
+    <description>Notifies about touch events on the screen's prescribed area</description>
+    <param name="type" type="Common.TouchType" mandatory="true">
+      <description>The type of touch event.</description>
+    </param>
+    <param name="event" type="Common.TouchEvent" mandatory="true" minsize="1" maxsize="10" array="true">
+      <description>List of all individual touches involved in this event.</description>
+    </param>
+  </function>
+  <function name="Slider" messagetype="request">
+    <description>Creates a full screen or pop-up overlay (depending on platform) with a single user controlled slider.</description>
+    <param name="numTicks" type="Integer" minvalue="2" maxvalue="26" mandatory="true">
+      <description>Number of selectable items on a horizontal axis</description>
+    </param>
+    <param name="position" type="Integer" minvalue="1" maxvalue="26" mandatory="true">
+      <description>Initial position of slider control (cannot exceed numTicks)</description>
+    </param>
+    <param name="sliderHeader" type="String" maxlength="500" mandatory="true">
+      <description>Text header to be displayed.</description>
+    </param>
+    <param name="sliderFooter" type="String" maxlength="500"  minsize="1" maxsize="26" array="true" mandatory="false">
+      <description>Text footer to be displayed (meant to display min/max threshold descriptors).</description>
+      <description>For a static text footer, only one footer string shall be provided in the array.</description>
+      <description>For a dynamic text footer, the number of footer text string in the array must match the numTicks value.</description>
+      <description>For a dynamic text footer, text array string should correlate with potential slider position index.</description>
+      <description>If omitted on supported displays, no footer text shall be displayed.</description>
+    </param>
+    <param name="timeout" type="Integer" minvalue="1000" maxvalue="65535" mandatory="true">
+      <description>Timeout. The slider should be displayed until the defined amount of time has elapsed. </description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that concerns this RPC.</description>
+    </param>
+  </function>
+  <function name="Slider" messagetype="response">
+    <param name="sliderPosition" type="Integer" minvalue="1" maxvalue="26" mandatory="false">
+      <description>Current slider position. Must be returned when the user has clicked the ‘Save’ or ‘Canceled’ button or by the timeout </description>
+    </param>
+  </function>
+  <function name="ScrollableMessage" messagetype="request">
+    <description>Creates a full screen overlay containing a large block of formatted text that can be scrolled with up to 8 SoftButtons defined</description>
+    <param name="messageText" type="Common.TextFieldStruct" mandatory="true">
+      <description>Body of text that can include newlines and tabs. Uses scrollableMessageBody.</description>
+    </param>
+    <param name="timeout" type="Integer" minvalue="0" maxvalue="65535" defvalue="30000" mandatory="true">
+      <description>Timeout in milliseconds. The message should be displayed until the time defined is up.</description>
+    </param>
+    <param name="softButtons" type="Common.SoftButton" minsize="0" maxsize="8" array="true" mandatory="false">
+      <description>App defined SoftButtons.</description>
+      <description>If omitted on supported displays, only the system defined "Close" SoftButton should be displayed.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="ScrollableMessage" messagetype="response">
+  </function>
+  <function name="PerformAudioPassThru" messagetype="request">
+    <param name="audioPassThruDisplayTexts" type="Common.TextFieldStruct" mandatory="true" minsize="0" maxsize="2" array="true">
+      <description>Uses
+            audioPassThruDisplayText1: First line of text displayed during audio capture.
+            audioPassThruDisplayText2: Second line of text displayed during audio capture.</description>
+    </param>
+    <param name="maxDuration" type="Integer" minvalue="1" maxvalue="1000000" mandatory="true">
+      <description>The maximum duration of audio recording in milliseconds. If not provided, the recording should be performed until EndAudioPassThru arrives.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+        <description>ID of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="PerformAudioPassThru" messagetype="response">
+  </function>
+  <function name="EndAudioPassThru" messagetype="request">
+    <description>Request is sent by SDL to stop the audio capturing.</description>
+  </function>
+  <function name="EndAudioPassThru" messagetype="response">
+  </function>
+  <function name="IsReady" messagetype="request">
+    <description>Method is invoked at system startup. Response provides information about presence of UI module and its readiness to cooperate with SDL.</description>
+  </function>
+  <function name="IsReady" messagetype="response">
+    <param name="available" type="Boolean" mandatory="true">
+      <description>Must be true if UI is present and ready to communicate with SDL.</description>
+    </param>
+  </function>
+  <function name="ClosePopUp" messagetype="request">
+    <description>Initiated by SDL to close currently active pop-up on HMI.</description>
+    <param name="methodName" type="String" mandatory="false">
+      <description>Method to be closed</description>
+    </param>
+  </function>
+  <function name="ClosePopUp" messagetype="response">
+    <description>Provides the result of operation.</description>
+  </function>
+  <function name="OnResetTimeout" messagetype="notification">
+    <description>HMI must provide SDL with notifications specific to the current Turn-By-Turn client status on the module</description>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>Id of application that invoked notifcation.</description>
+    </param>
+    <param name="methodName" type="String" mandatory="true">
+      <description>Currently used method name on which was triggered action</description>
+    </param>
+  </function>
+</interface>
+
+<interface name="Navigation" version="1.0" date="2013-05-22">
+  <function name="IsReady" messagetype="request">
+    <description>Method is invoked at system startup. Response must provide the information about presence of UI Navigation module and its readiness to cooperate with SDL.</description>
+  </function>
+  <function name="IsReady" messagetype="response">
+    <param name="available" type="Boolean" mandatory="true">
+      <description>Must be true if Navigation is present and ready to communicate with SDL.</description>
+    </param>
+  </function>
+  <function name="ShowConstantTBT" messagetype="request">
+    <description>Request from SmartDeviceLinkCore to HMI to show info about navigation.</description>
+    <param name="navigationTexts" type="Common.TextFieldStruct" mandatory="true" array="true" minsize="0" maxsize="5">
+      <description>See TextFieldStruct. Uses:
+          navigationText1
+          navigationText2
+          ETA
+          totalDistance.
+      </description>
+    </param>
+    <param name="turnIcon" type="Common.Image" mandatory="false">
+    </param>
+    <param name="nextTurnIcon" type="Common.Image" mandatory="false">
+    </param>
+    <param name="distanceToManeuver" type="Float" minvalue="0" maxvalue="1000000000" mandatory="true">
+      <description>Fraction of distance till next maneuver (from previous maneuver).</description>
+      <description>May be used to calculate progress bar.</description>
+    </param>
+    <param name="distanceToManeuverScale" type="Float" minvalue="0" maxvalue="1000000000" mandatory="true">
+      <description>Fraction of distance till next maneuver (starting from when AlertManeuver is triggered).</description>
+      <description>May be used to calculate progress bar.</description>
+    </param>
+    <param name="maneuverComplete" type="Boolean" mandatory="false">
+      <description>If and when a maneuver has completed while an AlertManeuver is active, SDL will send this value set to TRUE in order to clear the AlertManeuver overlay.</description>
+      <description>If omitted the value should be assumed as FALSE.</description>
+    </param>
+    <param name="softButtons" type="Common.SoftButton" minsize="0" maxsize="3" array="true" mandatory="false">
+      <description>Three dynamic SoftButtons available</description>
+      <description>If omitted on supported displays, the currently displayed SoftButton values will not change.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="ShowConstantTBT" messagetype="response">
+  </function>
+  <function name="AlertManeuver" messagetype="request">
+    <description>Request from SmartDeviceLinkCore to HMI to announce navigation maneuver</description>
+    <param name="softButtons" type="Common.SoftButton" minsize="0" maxsize="3" array="true" mandatory="false">
+      <description>If omitted, only the system defined "Close" SoftButton should be displayed.</description>
+    </param>
+  </function>
+  <function name="AlertManeuver" messagetype="response">
+  </function>
+  <function name="UpdateTurnList" messagetype="request">
+    <description>Request from SmartDeviceLinkCore to HMI to update turn list.</description>
+    <param name="turnList" type="Common.Turn" minsize="1" maxsize="100" array="true" mandatory="true">
+    </param>
+    <param name="softButtons" type="Common.SoftButton" minsize="0" maxsize="1" array="true" mandatory="false">
+      <description>If omitted, app-defined SoftButton should be left blank.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="UpdateTurnList" messagetype="response">
+  </function>
+  <function name="OnTBTClientState" messagetype="notification">
+    <description>HMI must provide SDL with notifications specific to the current Turn-By-Turn client status on the module</description>
+    <param name="state" type="Common.TBTState" mandatory="true">
+      <description>Current State of TBT client</description>
+    </param>
+  </function>
+  <function name="StartStream" messagetype="request">
+    <description>Notification from SmartDeviceLinkCore to HMI to start playing video streaming.</description>
+    <param name="url" type="String" minlength="21" maxlength="500" mandatory="true">
+      <description>URL that HMI start playing.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="StartStream" messagetype="response">
+  </function>
+  <function name="StopStream" messagetype="request">
+    <description>Notification from SmartDeviceLinkCore to HMI to start playing video streaming.</description>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="StopStream" messagetype="response">
+  </function>
+
+    <function name="StartAudioStream" messagetype="request">
+    <description>Notification from SmartDeviceLinkCore to HMI to start playing audio streaming.</description>
+    <param name="url" type="String" minlength="21" maxlength="500" mandatory="true">
+      <description>URL that HMI start playing.</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="StartAudioStream" messagetype="response">
+  </function>
+  <function name="StopAudioStream" messagetype="request">
+    <description>Notification from SmartDeviceLinkCore to HMI to start playing audio streaming.</description>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="StopAudioStream" messagetype="response">
+  </function>
+
+</interface>
+
+<interface name="VehicleInfo" version="1.0" date="2013-04-21">
+  <function name="IsReady" messagetype="request">
+    <description>Method is invoked at system startup. Response should provide information about presence of any of vehicle information modules (ECU, GPS, etc) and their readiness to cooperate with SDL.</description>
+  </function>
+  <function name="IsReady" messagetype="response">
+    <param name="available" type="Boolean" mandatory="true">
+      <description>Must be true if vehicle data modules are present and ready to communicate with SDL.</description>
+    </param>
+  </function>
+  <function name="GetVehicleType" messagetype="request">
+    <description>Request from SmartDeviceLinkCore to HMI to get info about the vehicle (type, model, etc.).</description>
+  </function>
+  <function name="GetVehicleType" messagetype="response">
+    <param name="vehicleType" type="Common.VehicleType" mandatory="true"/>
+  </function>
+  <function name="ReadDID" messagetype="request">
+    <description>Request from SDL for vehicle data reading.</description>
+    <param name="ecuName" type="Integer" minvalue="0" maxvalue="65535" mandatory="true">
+      <description>Name of ECU.</description>
+    </param>
+    <param name="didLocation" type="Integer" minvalue="0" maxvalue="65535" minsize="1" maxsize="1000" array="true" mandatory="true">
+      <description>Get raw data from vehicle data DID location(s).</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application related to this RPC.</description>
+    </param>
+  </function>
+  <function name="ReadDID" messagetype="response">
+    <param name="didResult" type="Common.DIDResult" minsize="0" maxsize="1000" array="true" mandatory="false">
+      <description>Array of requested DID results (with data if available).</description>
+    </param>
+  </function>
+  <function name="GetDTCs" messagetype="request">
+    <description>Vehicle module diagnostic trouble code request.</description>
+    <param name="ecuName" type="Integer" minvalue="0" maxvalue="65535" mandatory="true">
+      <description>Name of ECU.</description>
+    </param>
+    <param name="dtcMask" type="Integer" minvalue="0" maxvalue="255" mandatory="false">
+      <description>DTC Mask Byte to be sent in diagnostic request to module .</description>
+    </param>
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application that requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetDTCs" messagetype="response">
+    <param name="ecuHeader" type="Integer" minvalue="0" maxvalue="65535" mandatory="true">
+      <description>2 byte ECU Header for DTC response (as defined in VHR_Layout_Specification_DTCs.pdf)</description>
+    </param>
+    <param name="dtc" type="String" mandatory="false" minsize="1" maxsize="15" maxlength="10" array="true">
+      <description>
+        Array of all reported DTCs on module. Each DTC is represented with 4 bytes:
+        3 bytes for data
+        1 byte for status
+      </description>
+    </param>
+  </function>
+
+<!--Qt HMI version of GetVehicleData-->
+  <function name="GetGpsData" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetGpsData" messagetype="response">
+    <param name="gps" type="Common.GPSData" mandatory="true">
+      <description>See GPSData</description>
+    </param>
+  </function>
+
+  <function name="GetSpeed" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetSpeed" messagetype="response">
+    <param name="speed" type="Float" minvalue="0" maxvalue="700" mandatory="true">
+      <description>The vehicle speed in kilometers per hour</description>
+    </param>
+  </function>
+
+  <function name="GetRpm" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetRpm" messagetype="response">
+    <param name="rpm" type="Integer" minvalue="0" maxvalue="20000" mandatory="true">
+      <description>The number of revolutions per minute of the engine</description>
+    </param>
+  </function>
+
+  <function name="GetFuelLevel" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetFuelLevel" messagetype="response">
+    <param name="fuelLevel" type="Float" minvalue="-6" maxvalue="106" mandatory="true">
+      <description>The fuel level in the tank (percentage)</description>
+    </param>
+  </function>
+
+  <function name="GetFuelLevelState" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetFuelLevelState" messagetype="response">
+    <param name="fuelLevel_State" type="Common.ComponentVolumeStatus" mandatory="true">
+      <description>The fuel level state</description>
+    </param>
+  </function>
+
+  <function name="GetInstantFuelConsumption" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetInstantFuelConsumption" messagetype="response">
+    <param name="instantFuelConsumption" type="Float" minvalue="0" maxvalue="25575" mandatory="true">
+      <description>The instantaneous fuel consumption in microlitres</description>
+    </param>
+  </function>
+
+  <function name="GetExternalTemperature" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetExternalTemperature" messagetype="response">
+    <param name="externalTemperature" type="Float" minvalue="-40" maxvalue="100" mandatory="true">
+      <description>The external temperature in degrees celsius</description>
+    </param>
+  </function>
+
+  <function name="GetVin" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetVin" messagetype="response">
+    <param name="vin" type="String" maxlength="17" mandatory="true">
+      <description>Vehicle identification number</description>
+    </param>
+  </function>
+
+  <function name="GetPrndl" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetPrndl" messagetype="response">
+    <param name="prndl" type="Common.PRNDL" mandatory="true">
+      <description>See PRNDL</description>
+    </param>
+  </function>
+
+  <function name="GetTirePressure" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetTirePressure" messagetype="response">
+    <param name="tirePressure" type="Common.TireStatus" mandatory="true">
+      <description>See TireStatus</description>
+    </param>
+  </function>
+
+  <function name="GetOdometer" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetOdometer" messagetype="response">
+    <param name="odometer" type="Integer" minvalue="0" maxvalue="17000000" mandatory="true">
+      <description>Odometer in km</description>
+    </param>
+  </function>
+
+  <function name="GetBeltStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetBeltStatus" messagetype="response">
+    <param name="beltStatus" type="Common.BeltStatus" mandatory="true">
+      <description>The status of the seat belts</description>
+    </param>
+  </function>
+
+  <function name="GetBodyInformation" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetBodyInformation" messagetype="response">
+    <param name="bodyInformation" type="Common.BodyInformation" mandatory="true">
+      <description>The body information including power modes</description>
+    </param>
+  </function>
+
+  <function name="GetDeviceStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetDeviceStatus" messagetype="response">
+    <param name="deviceStatus" type="Common.DeviceStatus" mandatory="true">
+      <description>The device status including signal and battery strength</description>
+    </param>
+  </function>
+
+  <function name="GetDriverBraking" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetDriverBraking" messagetype="response">
+    <param name="driverBraking" type="Common.VehicleDataEventStatus" mandatory="true">
+      <description>The status of the brake pedal</description>
+    </param>
+  </function>
+
+  <function name="GetWiperStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetWiperStatus" messagetype="response">
+    <param name="wiperStatus" type="Common.WiperStatus" mandatory="true">
+      <description>The status of the wipers</description>
+    </param>
+  </function>
+
+  <function name="GetHeadLampStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetHeadLampStatus" messagetype="response">
+    <param name="headLampStatus" type="Common.HeadLampStatus" mandatory="true">
+      <description>Status of the head lamps</description>
+    </param>
+  </function>
+
+  <function name="GetEngineTorque" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetEngineTorque" messagetype="response">
+    <param name="engineTorque" type="Float" minvalue="-1000" maxvalue="2000" mandatory="true">
+      <description>Torque value for engine (in Nm) on non-diesel variants</description>
+    </param>
+  </function>
+
+  <function name="GetAccPedalPosition" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetAccPedalPosition" messagetype="response">
+    <param name="accPedalPosition" type="Float" minvalue="0" maxvalue="100" mandatory="true">
+      <description>Accelerator pedal position (percentage depressed)</description>
+    </param>
+  </function>
+
+  <function name="GetSteeringWheelAngle" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetSteeringWheelAngle" messagetype="response">
+    <param name="steeringWheelAngle" type="Float" minvalue="-2000" maxvalue="2000" mandatory="true">
+      <description>Current angle of the steering wheel (in deg)</description>
+    </param>
+  </function>
+
+  <function name="GetECallInfo" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetECallInfo" messagetype="response">
+    <param name="eCallInfo" type="Common.ECallInfo" mandatory="true">
+      <description>Emergency Call notification and confirmation data</description>
+    </param>
+  </function>
+
+  <function name="GetAirbagStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetAirbagStatus" messagetype="response">
+    <param name="airbagStatus" type="Common.AirbagStatus" mandatory="true">
+      <description>The status of the air bags</description>
+    </param>
+  </function>
+
+  <function name="GetEmergencyEvent" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetEmergencyEvent" messagetype="response">
+    <param name="emergencyEvent" type="Common.EmergencyEvent" mandatory="true">
+      <description>Information related to an emergency event (and if it occurred)</description>
+    </param>
+  </function>
+
+  <function name="GetClusterModeStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetClusterModeStatus" messagetype="response">
+    <param name="clusterModeStatus" type="Common.ClusterModeStatus" mandatory="true">
+      <description>The status modes of the cluster</description>
+    </param>
+  </function>
+
+  <function name="GetMyKey" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="GetMyKey" messagetype="response">
+    <param name="myKey" type="Common.MyKey" mandatory="true">
+      <description>Information related to the MyKey feature</description>
+    </param>
+  </function>
+<!--end Qt HMI version of GetVehicleData-->
+
+<!--Qt HMI version of OnVehicleData-->
+  <function name="OnGpsData" messagetype="notification">
+    <param name="gps" type="Common.GPSData" mandatory="true">
+      <description>See GPSData</description>
+    </param>
+  </function>
+
+  <function name="OnSpeed" messagetype="notification">
+    <param name="speed" type="Float" minvalue="0" maxvalue="700" mandatory="true">
+      <description>The vehicle speed in kilometers per hour</description>
+    </param>
+  </function>
+
+  <function name="OnRpm" messagetype="notification">
+    <param name="rpm" type="Integer" minvalue="0" maxvalue="20000" mandatory="true">
+      <description>The number of revolutions per minute of the engine</description>
+    </param>
+  </function>
+
+  <function name="OnFuelLevel" messagetype="notification">
+    <param name="fuelLevel" type="Float" minvalue="-6" maxvalue="106" mandatory="true">
+      <description>The fuel level in the tank (percentage)</description>
+    </param>
+  </function>
+
+  <function name="OnFuelLevelState" messagetype="notification">
+    <param name="fuelLevel_State" type="Common.ComponentVolumeStatus" mandatory="true">
+      <description>The fuel level state</description>
+    </param>
+  </function>
+
+  <function name="OnInstantFuelConsumption" messagetype="notification">
+    <param name="instantFuelConsumption" type="Float" minvalue="0" maxvalue="25575" mandatory="true">
+      <description>The instantaneous fuel consumption in microlitres</description>
+    </param>
+  </function>
+
+  <function name="OnExternalTemperature" messagetype="notification">
+    <param name="externalTemperature" type="Float" minvalue="-40" maxvalue="100" mandatory="true">
+      <description>The external temperature in degrees celsius</description>
+    </param>
+  </function>
+
+  <function name="OnVin" messagetype="notification">
+    <param name="vin" type="String" maxlength="17" mandatory="true">
+      <description>Vehicle identification number.</description>
+    </param>
+  </function>
+
+  <function name="OnPrndl" messagetype="notification">
+    <param name="prndl" type="Common.PRNDL" mandatory="true">
+      <description>See PRNDL</description>
+    </param>
+  </function>
+
+  <function name="OnTirePressure" messagetype="notification">
+    <param name="tirePressure" type="Common.TireStatus" mandatory="true">
+      <description>See TireStatus</description>
+    </param>
+  </function>
+
+  <function name="OnOdometer" messagetype="notification">
+    <param name="odometer" type="Integer" minvalue="0" maxvalue="2000000" mandatory="true">
+      <description>Odometer in km</description>
+    </param>
+  </function>
+
+  <function name="OnBeltStatus" messagetype="notification">
+    <param name="beltStatus" type="Common.BeltStatus" mandatory="true">
+      <description>The status of the seat belts</description>
+    </param>
+  </function>
+
+  <function name="OnBodyInformation" messagetype="notification">
+    <param name="bodyInformation" type="Common.BodyInformation" mandatory="true">
+      <description>The body information including power modes</description>
+    </param>
+  </function>
+
+  <function name="OnDeviceStatus" messagetype="notification">
+    <param name="deviceStatus" type="Common.DeviceStatus" mandatory="true">
+      <description>The device status including signal and battery strength</description>
+    </param>
+  </function>
+
+  <function name="OnDriverBraking" messagetype="notification">
+    <param name="driverBraking" type="Common.VehicleDataEventStatus" mandatory="true">
+      <description>The status of the brake pedal</description>
+    </param>
+  </function>
+
+  <function name="OnWiperStatus" messagetype="notification">
+    <param name="wiperStatus" type="Common.WiperStatus" mandatory="true">
+      <description>The status of the wipers</description>
+    </param>
+  </function>
+
+  <function name="OnHeadLampStatus" messagetype="notification">
+    <param name="headLampStatus" type="Common.HeadLampStatus" mandatory="true">
+      <description>Status of the head lamps</description>
+    </param>
+  </function>
+
+  <function name="OnEngineTorque" messagetype="notification">
+    <param name="engineTorque" type="Float" minvalue="-1000" maxvalue="2000" mandatory="true">
+      <description>Torque value for engine (in Nm) on non-diesel variants</description>
+    </param>
+  </function>
+
+  <function name="OnAccPedalPosition" messagetype="notification">
+    <param name="accPedalPosition" type="Float" minvalue="0" maxvalue="100" mandatory="true">
+      <description>Accelerator pedal position (percentage depressed)</description>
+    </param>
+  </function>
+
+  <function name="OnSteeringWheelAngle" messagetype="notification">
+    <param name="steeringWheelAngle" type="Float" minvalue="-2000" maxvalue="2000" mandatory="true">
+      <description>Current angle of the steering wheel (in deg)</description>
+    </param>
+  </function>
+
+  <function name="OnMyKey" messagetype="notification">
+    <param name="myKey" type="Common.MyKey" mandatory="true">
+      <description>Information related to the MyKey feature</description>
+    </param>
+  </function>
+<!--end Qt HMI version of OnVehicleData-->
+
+<!--Qt HMI version of SubscribeVehicleData/UnsubscribeVehicleData-->
+  <function name="SubscribeGps" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeGps" messagetype="response">
+    <param name="gps" type="Common.VehicleDataResult" mandatory="true">
+      <description>See GPSData</description>
+    </param>
+  </function>
+  <function name="UnsubscribeGps" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeGps" messagetype="response">
+    <param name="gps" type="Common.VehicleDataResult" mandatory="true">
+      <description>See GPSData</description>
+    </param>
+  </function>
+
+  <function name="SubscribeSpeed" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeSpeed" messagetype="response">
+    <param name="speed" type="Common.VehicleDataResult" mandatory="true">
+      <description>The vehicle speed in kilometers per hour</description>
+    </param>
+  </function>
+  <function name="UnsubscribeSpeed" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeSpeed" messagetype="response">
+    <param name="speed" type="Common.VehicleDataResult" mandatory="true">
+      <description>The vehicle speed in kilometers per hour</description>
+    </param>
+  </function>
+
+  <function name="SubscribeRpm" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeRpm" messagetype="response">
+    <param name="rpm" type="Common.VehicleDataResult" mandatory="true">
+      <description>The number of revolutions per minute of the engine</description>
+    </param>
+  </function>
+  <function name="UnsubscribeRpm" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeRpm" messagetype="response">
+    <param name="rpm" type="Common.VehicleDataResult" mandatory="true">
+      <description>The number of revolutions per minute of the engine</description>
+    </param>
+  </function>
+
+  <function name="SubscribeFuelLevel" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeFuelLevel" messagetype="response">
+    <param name="fuelLevel" type="Common.VehicleDataResult" mandatory="true">
+      <description>The fuel level in the tank (percentage)</description>
+    </param>
+  </function>
+  <function name="UnsubscribeFuelLevel" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeFuelLevel" messagetype="response">
+    <param name="fuelLevel" type="Common.VehicleDataResult" mandatory="true">
+      <description>The fuel level in the tank (percentage)</description>
+    </param>
+  </function>
+
+  <function name="SubscribeFuelLevel_State" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeFuelLevel_State" messagetype="response">
+    <param name="fuelLevel_State" type="Common.VehicleDataResult" mandatory="true">
+      <description>The fuel level state</description>
+    </param>
+  </function>
+  <function name="UnsubscribeFuelLevel_State" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeFuelLevel_State" messagetype="response">
+    <param name="fuelLevel_State" type="Common.VehicleDataResult" mandatory="true">
+      <description>The fuel level state</description>
+    </param>
+  </function>
+
+  <function name="SubscribeInstantFuelConsumption" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeInstantFuelConsumption" messagetype="response">
+    <param name="instantFuelConsumption" type="Common.VehicleDataResult" mandatory="true">
+      <description>The instantaneous fuel consumption in microlitres</description>
+    </param>
+  </function>
+  <function name="UnsubscribeInstantFuelConsumption" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeInstantFuelConsumption" messagetype="response">
+    <param name="instantFuelConsumption" type="Common.VehicleDataResult" mandatory="true">
+      <description>The instantaneous fuel consumption in microlitres</description>
+    </param>
+  </function>
+
+  <function name="SubscribeExternalTemperature" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeExternalTemperature" messagetype="response">
+    <param name="externalTemperature" type="Common.VehicleDataResult" mandatory="true">
+      <description>The external temperature in degrees celsius</description>
+    </param>
+  </function>
+  <function name="UnsubscribeExternalTemperature" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeExternalTemperature" messagetype="response">
+    <param name="externalTemperature" type="Common.VehicleDataResult" mandatory="true">
+      <description>The external temperature in degrees celsius</description>
+    </param>
+  </function>
+
+  <function name="SubscribePrndl" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribePrndl" messagetype="response">
+    <param name="prndl" type="Common.VehicleDataResult" mandatory="true">
+      <description>See PRNDL</description>
+    </param>
+  </function>
+  <function name="UnsubscribePrndl" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribePrndl" messagetype="response">
+    <param name="prndl" type="Common.VehicleDataResult" mandatory="true">
+      <description>See PRNDL</description>
+    </param>
+  </function>
+
+  <function name="SubscribeVin" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeVin" messagetype="response">
+    <param name="vin" type="String" maxlength="17" mandatory="true">
+      <description>Vehicle identification number</description>
+    </param>
+  </function>
+  <function name="UnsubscribeVin" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeVin" messagetype="response">
+    <param name="vin" type="String" maxlength="17" mandatory="true">
+      <description>Vehicle identification number</description>
+    </param>
+  </function>
+
+  <function name="SubscribeTirePressure" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeTirePressure" messagetype="response">
+    <param name="tirePressure" type="Common.VehicleDataResult" mandatory="true">
+      <description>See TireStatus</description>
+    </param>
+  </function>
+  <function name="UnsubscribeTirePressure" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeTirePressure" messagetype="response">
+    <param name="tirePressure" type="Common.VehicleDataResult" mandatory="true">
+      <description>See TireStatus</description>
+    </param>
+  </function>
+
+  <function name="SubscribeOdometer" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeOdometer" messagetype="response">
+    <param name="odometer" type="Common.VehicleDataResult" mandatory="true">
+      <description>Odometer in km</description>
+    </param>
+  </function>
+  <function name="UnsubscribeOdometer" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeOdometer" messagetype="response">
+    <param name="odometer" type="Common.VehicleDataResult" mandatory="true">
+      <description>Odometer in km</description>
+    </param>
+  </function>
+
+  <function name="SubscribeBeltStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeBeltStatus" messagetype="response">
+    <param name="beltStatus" type="Common.VehicleDataResult" mandatory="true">
+      <description>The status of the seat belts</description>
+    </param>
+  </function>
+  <function name="UnsubscribeBeltStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeBeltStatus" messagetype="response">
+    <param name="beltStatus" type="Common.VehicleDataResult" mandatory="true">
+      <description>The status of the seat belts</description>
+    </param>
+  </function>
+
+  <function name="SubscribeBodyInformation" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeBodyInformation" messagetype="response">
+    <param name="bodyInformation" type="Common.VehicleDataResult" mandatory="true">
+      <description>The body information including power modes</description>
+    </param>
+  </function>
+  <function name="UnsubscribeBodyInformation" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeBodyInformation" messagetype="response">
+    <param name="bodyInformation" type="Common.VehicleDataResult" mandatory="true">
+      <description>The body information including power modes</description>
+    </param>
+  </function>
+
+  <function name="SubscribeDeviceStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeDeviceStatus" messagetype="response">
+    <param name="deviceStatus" type="Common.VehicleDataResult" mandatory="true">
+      <description>The device status including signal and battery strength</description>
+    </param>
+  </function>
+  <function name="UnsubscribeDeviceStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeDeviceStatus" messagetype="response">
+    <param name="deviceStatus" type="Common.VehicleDataResult" mandatory="true">
+      <description>The device status including signal and battery strength</description>
+    </param>
+  </function>
+
+  <function name="SubscribeDriverBraking" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeDriverBraking" messagetype="response">
+    <param name="driverBraking" type="Common.VehicleDataResult" mandatory="true">
+      <description>The status of the brake pedal</description>
+    </param>
+  </function>
+  <function name="UnsubscribeDriverBraking" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeDriverBraking" messagetype="response">
+    <param name="driverBraking" type="Common.VehicleDataResult" mandatory="true">
+      <description>The status of the brake pedal</description>
+    </param>
+  </function>
+
+  <function name="SubscribeWiperStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeWiperStatus" messagetype="response">
+    <param name="wiperStatus" type="Common.VehicleDataResult" mandatory="true">
+      <description>The status of the wipers</description>
+    </param>
+  </function>
+  <function name="UnsubscribeWiperStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeWiperStatus" messagetype="response">
+    <param name="wiperStatus" type="Common.VehicleDataResult" mandatory="true">
+      <description>The status of the wipers</description>
+    </param>
+  </function>
+
+  <function name="SubscribeHeadLampStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeHeadLampStatus" messagetype="response">
+    <param name="headLampStatus" type="Common.VehicleDataResult" mandatory="true">
+      <description>Status of the head lamps</description>
+    </param>
+  </function>
+  <function name="UnsubscribeHeadLampStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeHeadLampStatus" messagetype="response">
+    <param name="headLampStatus" type="Common.VehicleDataResult" mandatory="true">
+      <description>Status of the head lamps</description>
+    </param>
+  </function>
+
+  <function name="SubscribeEngineTorque" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeEngineTorque" messagetype="response">
+    <param name="engineTorque" type="Common.VehicleDataResult" mandatory="true">
+      <description>Torque value for engine (in Nm) on non-diesel variants</description>
+    </param>
+  </function>
+  <function name="UnsubscribeEngineTorque" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeEngineTorque" messagetype="response">
+    <param name="engineTorque" type="Common.VehicleDataResult" mandatory="true">
+      <description>Torque value for engine (in Nm) on non-diesel variants</description>
+    </param>
+  </function>
+
+  <function name="SubscribeAccPedalPosition" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeAccPedalPosition" messagetype="response">
+    <param name="accPedalPosition" type="Common.VehicleDataResult" mandatory="true">
+      <description>Accelerator pedal position (percentage depressed)</description>
+    </param>
+  </function>
+  <function name="UnsubscribeAccPedalPosition" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeAccPedalPosition" messagetype="response">
+    <param name="accPedalPosition" type="Common.VehicleDataResult" mandatory="true">
+      <description>Accelerator pedal position (percentage depressed)</description>
+    </param>
+  </function>
+
+  <function name="SubscribeSteeringWheelAngle" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeSteeringWheelAngle" messagetype="response">
+    <param name="steeringWheelAngle" type="Common.VehicleDataResult" mandatory="true">
+      <description>Current angle of the steering wheel (in deg)</description>
+    </param>
+  </function>
+  <function name="UnsubscribeSteeringWheelAngle" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeSteeringWheelAngle" messagetype="response">
+    <param name="steeringWheelAngle" type="Common.VehicleDataResult" mandatory="true">
+      <description>Current angle of the steering wheel (in deg)</description>
+    </param>
+  </function>
+
+  <function name="SubscribeECallInfo" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeECallInfo" messagetype="response">
+    <param name="eCallInfo" type="Common.VehicleDataResult" mandatory="true">
+      <description>Emergency Call notification and confirmation data</description>
+    </param>
+  </function>
+  <function name="UnsubscribeECallInfo" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeECallInfo" messagetype="response">
+    <param name="eCallInfo" type="Common.VehicleDataResult" mandatory="true">
+      <description>Emergency Call notification and confirmation data</description>
+    </param>
+  </function>
+
+  <function name="SubscribeAirbagStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeAirbagStatus" messagetype="response">
+    <param name="airbagStatus" type="Common.VehicleDataResult" mandatory="true">
+      <description>The status of the air bags</description>
+    </param>
+  </function>
+  <function name="UnsubscribeAirbagStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeAirbagStatus" messagetype="response">
+    <param name="airbagStatus" type="Common.VehicleDataResult" mandatory="true">
+      <description>The status of the air bags</description>
+    </param>
+  </function>
+
+  <function name="SubscribeEmergencyEvent" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeEmergencyEvent" messagetype="response">
+    <param name="emergencyEvent" type="Common.VehicleDataResult" mandatory="true">
+      <description>Information related to an emergency event (and if it occurred)</description>
+    </param>
+  </function>
+  <function name="UnsubscribeEmergencyEvent" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeEmergencyEvent" messagetype="response">
+    <param name="emergencyEvent" type="Common.VehicleDataResult" mandatory="true">
+      <description>Information related to an emergency event (and if it occurred)</description>
+    </param>
+  </function>
+
+  <function name="SubscribeClusterModeStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeClusterModeStatus" messagetype="response">
+    <param name="clusterModeStatus" type="Common.VehicleDataResult" mandatory="true">
+      <description>The status modes of the cluster</description>
+    </param>
+  </function>
+  <function name="UnsubscribeClusterModeStatus" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeClusterModeStatus" messagetype="response">
+    <param name="clusterModeStatus" type="Common.VehicleDataResult" mandatory="true">
+      <description>The status modes of the cluster</description>
+    </param>
+  </function>
+
+  <function name="SubscribeMyKey" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="SubscribeMyKey" messagetype="response">
+    <param name="myKey" type="Common.VehicleDataResult" mandatory="true">
+      <description>Information related to the MyKey feature</description>
+    </param>
+  </function>
+  <function name="UnsubscribeMyKey" messagetype="request">
+    <param name="appID" type="Integer" mandatory="true">
+      <description>ID of application requested this RPC.</description>
+    </param>
+  </function>
+  <function name="UnsubscribeMyKey" messagetype="response">
+    <param name="myKey" type="Common.VehicleDataResult" mandatory="true">
+      <description>Information related to the MyKey feature</description>
+    </param>
+  </function>
+<!--end Qt HMI version of SubscribeVehicleData/UnsubscribeVehicleData-->
+
+</interface>
+</interfaces>
diff --git a/tools/intergen/test/test_interface.xml b/tools/intergen/test/test_interface.xml
new file mode 100644
index 000000000..08c77fcd0
--- /dev/null
+++ b/tools/intergen/test/test_interface.xml
@@ -0,0 +1,457 @@
+<?xml version="1.0" standalone="no"?>
+
+<!--
+* Copyright (c) 2015, 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. -->
+<?xml-stylesheet type="text/xml" href="protocol2html.xsl"?>
+
+<interface name="test rpc interface" version="42" >
+
+  <enum name="Result" internal_scope="base">
+    <element name="SUCCESS">
+      <description>The request succeeded</description>
+    </element>
+    <element name="INVALID_DATA">
+      <description>
+      	The data sent is invalid. For example:
+		Invalid Json syntax
+      	Parameters out of bounds (number or enum range)
+      	Mandatory parameters not provided
+      	Parameter provided with wrong type
+      	Invalid characters
+      	Empty string
+      </description>
+    </element>
+    <element name="UNSUPPORTED_REQUEST">
+      <description>The request is not supported by Sync</description>
+    </element>
+    <element name="OUT_OF_MEMORY">
+      <description>The system could not process the request because the necessary memory couldn't be allocated</description>
+    </element>
+    <element name="TOO_MANY_PENDING_REQUESTS">
+      <description>There are too many requests pending (means, that the response has not been delivered, yet).</description>
+      <designdescription>There may be a maximum of 1000 pending requests at a time.</designdescription>
+    </element>
+    <element name="INVALID_ID">
+      <description>
+      	One of the provided IDs is not valid. For example
+      	This applies to CorrelationID, SubscriptionID, CommandID, MenuID, etc.
+      </description>
+    </element>
+    <element name="DUPLICATE_NAME">
+      <description>There was a conflict with an registered name (application or menu item) or vr command</description>
+    </element>
+    <element name="TOO_MANY_APPLICATIONS">
+      <description>There are already too many registered applications</description>
+    </element>
+    <element name="APPLICATION_REGISTERED_ALREADY">
+      <description>RegisterApplication has been called again, after a RegisterApplication was successful before.</description>
+    </element>
+    <element name="UNSUPPORTED_VERSION">
+      <description>Sync doesn't support the protocol that is requested by the mobile application</description>
+    </element>
+    <element name="WRONG_LANGUAGE">
+      <description>
+      	The requested language is currently not supported.
+      	Might be because of a mismatch of the currently active language on Sync and the requested language
+      </description>
+    </element>
+    <element name="APPLICATION_NOT_REGISTERED">
+      <description>An command can not be executed because no application has been registered with RegisterApplication.</description>
+    </element>
+    <element name="IN_USE">
+      <description>
+      	The data may not be changed, because it is currently in use.
+      	For example when trying to delete a command set that is currently involved in an interaction.
+      </description>
+    </element>
+    <element name="VEHICLE_DATA_NOT_ALLOWED">
+      <description>The user has turned off access to vehicle data, and it is globally unavailable to mobile applications.</description>
+    </element>
+    <element name="VEHICLE_DATA_NOT_AVAILABLE">
+      <description>The requested vehicle data is not available on this vehicle or is not published.</description>
+    </element>
+    <element name="REJECTED">
+      <description>
+      	The requested command was rejected, e.g. because mobile app is in background and cannot perform any HMI commands.
+      	Or an HMI command (e.g. Speak) is rejected because a higher priority HMI command (e.g. Alert) is playing.
+      </description>
+    </element>
+    <element name="ABORTED">
+      <description>
+      	A command was aborted, for example due to user interaction (e.g. user pressed button).
+      	Or an HMI command (e.g. Speak) is aborted because a higher priority HMI command (e.g. Alert) was requested.
+      </description>
+    </element>
+    <element name="IGNORED">
+      <description>
+      	A command was ignored, because the intended result is already in effect.
+      	For example, SetMediaClockTimer was used to pause the media clock although the clock is paused already.
+      	NOTE: potentially replaces SUBSCRIBED_ALREADY
+      </description>
+    </element>
+    <element name="UNSUPPORTED_RESOURCE">
+      <description>
+      	A button that was requested for subscription is not supported under the current system.
+      	NOTE: could become a more generic UNSUPPORTED_RESOURCE by merging with VEHICLE_DATA_NOT_AVAILABLE.
+      </description>
+    </element>
+    <element name="FILE_NOT_FOUND">
+      <description>A specified file could not be found on Sync.</description>
+    </element>
+    <element name="GENERIC_ERROR">
+      <description>Provided data is valid but something went wrong in the lower layers.</description>
+    </element>
+    <element name="DISALLOWED">
+      <description>RPC is not authorized in local policy table.</description>
+    </element>
+    <element name="USER_DISALLOWED">
+      <description>RPC is included in a functional group explicitly blocked by the user.</description>
+    </element>
+    <element name="TIMED_OUT">
+      <description>Overlay reached the maximum timeout and closed.</description>
+    </element>
+    <element name="CANCEL_ROUTE">
+      <description>User selected to Cancel Route.</description>
+    </element>
+    <element name="TRUNCATED_DATA">
+      <description>The RPC (e.g. ReadDID) executed successfully but the data exceeded the platform maximum threshold and thus, only part of the data is available.</description>
+    </element>
+    <element name="RETRY">
+      <description>The user interrupted the RPC (e.g. PerformAudioPassThru) and indicated to start over.  Note, the app must issue the new RPC.</description>
+    </element>
+    <element name="WARNINGS">
+      <description>The RPC (e.g. SubscribeVehicleData) executed successfully but one or more items have a warning or failure.</description>
+    </element>
+  </enum>
+
+  <enum name="AppInterfaceUnregisteredReason">
+    <description>Error code, which comes from sync side.</description>
+<!-- Deprecate
+    <element name="USER_EXIT" />
+-->
+    <element name="IGNITION_OFF" />
+    <element name="BLUETOOTH_OFF" />
+    <element name="USB_DISCONNECTED" />
+    <element name="REQUEST_WHILE_IN_NONE_HMI_LEVEL" />
+    <element name="TOO_MANY_REQUESTS" />
+    <element name="DRIVER_DISTRACTION_VIOLATION" />
+    <element name="LANGUAGE_CHANGE" />
+    <element name="MASTER_RESET" />
+    <element name="FACTORY_DEFAULTS" />
+    <element name="APP_UNAUTHORIZED" />
+  </enum>
+
+  <enum name="TBTState">
+    <description>Enumeration that describes possible states of turn-by-turn client or AppLink app.</description>
+    <element name="ROUTE_UPDATE_REQUEST" />
+    <element name="ROUTE_ACCEPTED" />
+    <element name="ROUTE_REFUSED" />
+    <element name="ROUTE_CANCELLED" />
+    <element name="ETA_REQUEST" />
+    <element name="NEXT_TURN_REQUEST" />
+    <element name="ROUTE_STATUS_REQUEST" />
+    <element name="ROUTE_SUMMARY_REQUEST" />
+    <element name="TRIP_STATUS_REQUEST" />
+    <element name="ROUTE_UPDATE_REQUEST_TIMEOUT" />
+  </enum>
+
+  <enum name="ImageType">
+    <description>Contains information about the type of image.</description>
+    <element name="STATIC" />
+    <element name="DYNAMIC" />
+  </enum>
+
+  <struct name="Image">
+    <param name="value" maxlength="65535" type="String">
+      <description>Either the static hex icon value or the binary image file name identifier (sent by PutFile).</description>
+    </param>
+    <param name="imageType" type="ImageType">
+      <description>Describes, whether it is a static or dynamic image.</description>
+    </param>
+  </struct>
+
+  <struct name="Choice">
+    <description>A choice is an option given to the user, which can be selected either by menu, or through voice recognition system.</description>
+    <param name="choiceID" type="Integer" minvalue="0" maxvalue="65535" />
+    <param name="menuName" type="String" maxlength="500" />
+    <param name="vrCommands" type="String" minsize="1" maxsize="100" maxlength="99" map="true" />
+    <param name="image" type="Image" mandatory="false"/>
+    <param name="secondaryText" maxlength="500" type="String" mandatory="false" scope="partner">
+      <description>Optional secondary text to display; e.g. address of POI in a search result entry</description>
+    </param>
+    <param name="tertiaryText" maxlength="500" type="String" mandatory="false" scope="partner">
+      <description>Optional tertiary text to display; e.g. distance to POI for a search result entry</description>
+    </param>
+    <param name="secondaryImage" type="Image" mandatory="false" scope="partner">
+      <description>Optional secondary image struct for choice</description>
+    </param>
+  </struct>
+
+  <struct name="TestStructWithNullableParam">
+    <param name="nullableInt" nullable="true" type="Integer" minavlue="0" maxvalue="42" />
+  </struct>
+
+  <struct name="TestStructWithNullableStructParam">
+    <param name="nullableEnum" nullable="true" type="ImageType"/>
+    <param name="nonNullableEnum" nullable="true" type="ImageType"/>
+  </struct>
+
+  <enum name="FunctionID" internal_scope="base">
+    <description>Enumeration linking function names with function IDs in AppLink protocol.</description>
+    <description>Assumes enumeration starts at value 0.</description>
+    <element name="RESERVED" value="0" />
+    <element name="AddSubMenuID" value="7" hexvalue="7" />
+    <element name="DiagnosticMessageID" value="37" hexvalue="25" />
+    <element name="OnAppInterfaceUnregisteredID" value="32769" hexvalue="8001" />
+    <element name="OnTBTClientStateID" value="32774" hexvalue="8006" />
+    <element name="OnAudioPassThruID" value="32777" hexvalue="8009" />
+    <element name="DummyNotificationID" value="42" />
+  </enum>
+
+  <enum name="messageType">
+    <description>
+    	Enumeration linking message types with function types in WiPro protocol.
+    	Assumes enumeration starts at value 0.
+    </description>
+    <element name="request" value="0" />
+    <element name="response" value="1" />
+    <element name="notification" value="2" />
+  </enum>
+
+  <!-- Requests/Responses -->
+
+  <function name="AddSubMenu" functionID="AddSubMenuID" messagetype="request">
+    <description>Adds a sub menu to the in-application menu.</description>
+
+    <param name="menuID" type="Integer" minvalue="1" maxvalue="2000000000">
+      <description>unique ID of the sub menu to add.</description>
+    </param>
+
+    <param name="position" type="Integer" minvalue="0" maxvalue="1000" defvalue="1000" mandatory="false">
+      <description>
+      	Position within the items that are are at top level of the in application menu.
+      	0 will insert at the front.
+      	1 will insert at the second position.
+      	If position is greater or equal than the number of items on top level, the sub menu will be appended to the end.
+      	Position of any submenu will always be located before the return and exit options
+      	If this param was omitted the entry will be added at the end.
+      </description>
+    </param>
+
+    <param name="menuName" maxlength="500" type="String">
+      <description>Text to show in the menu for this sub menu.</description>
+    </param>
+  </function>
+
+  <function name="AddSubMenu" functionID="AddSubMenuID" messagetype="response">
+    <param name="success" type="Boolean" platform="documentation">
+		<description> true if successful; false, if failed </description>
+	  </param>
+
+    <param name="resultCode" type="Result" platform="documentation">
+      <description>See Result</description>
+      <element name="SUCCESS"/>
+      <element name="INVALID_DATA"/>
+      <element name="OUT_OF_MEMORY"/>
+      <element name="TOO_MANY_PENDING_REQUESTS"/>
+      <element name="APPLICATION_NOT_REGISTERED"/>
+      <element name="GENERIC_ERROR"/>
+      <element name="REJECTED"/>
+      <element name="INVALID_ID"/>
+      <element name="DUPLICATE_NAME"/>
+    </param>
+
+    <param name="info" type="String" maxlength="1000" mandatory="false" platform="documentation">
+      <description>Provides additional human readable info regarding the result.</description>
+    </param>
+  </function>
+
+
+  <function name="DiagnosticMessage" functionID="DiagnosticMessageID" messagetype="request" scope="internal">
+    <description>Non periodic vehicle diagnostic request</description>
+
+    <param name="targetID" type="Integer" minvalue="0" maxvalue="65535" mandatory="true">
+      <description>Name of target ECU.</description>
+    </param>
+
+    <param name="messageLength" type="Integer" minvalue="0" maxvalue="65535" mandatory="true">
+      <description>Length of message (in bytes).</description>
+    </param>
+
+    <param name="messageData" type="Integer" minvalue="0" maxvalue="255" minsize="1" maxsize="65535" array="true" mandatory="true">
+      <description>
+      	Array of bytes comprising CAN message.
+      </description>
+    </param>
+  </function>
+
+  <function name="DiagnosticMessage" functionID="DiagnosticMessageID" messagetype="response" scope="internal">
+
+    <param name="success" type="Boolean" platform="documentation">
+      <description> true, if successful; false, if failed </description>
+    </param>
+
+    <param name="resultCode" type="Result" array="true" platform="documentation">
+      <description>See Result</description>
+      <element name="SUCCESS"/>
+      <element name="INVALID_DATA"/>
+      <element name="OUT_OF_MEMORY"/>
+      <element name="TOO_MANY_PENDING_REQUESTS"/>
+      <element name="APPLICATION_NOT_REGISTERED"/>
+      <element name="GENERIC_ERROR"/>
+      <element name="REJECTED"/>
+      <element name="DISALLOWED"/>
+      <element name="USER_DISALLOWED"/>
+      <element name="TRUNCATED_DATA"/>
+    </param>
+
+    <param name="info" type="String" maxlength="1000" mandatory="false" platform="documentation">
+      <description>Provides additional human readable info regarding the result.</description>
+    </param>
+
+    <param name="messageDataResult" type="Integer" minvalue="0" maxvalue="255" minsize="1" maxsize="65535" array="true" mandatory="true">
+      <description>
+      	Array of bytes comprising CAN message result.
+      </description>
+    </param>
+
+  </function>
+
+  <function name="OnAppInterfaceUnregistered" functionID="OnAppInterfaceUnregisteredID" messagetype="notification">
+    <param name="reason" type="AppInterfaceUnregisteredReason">
+      <description>See AppInterfaceUnregisteredReason</description>
+    </param>
+  </function>
+
+  <function name="OnTBTClientState" functionID="OnTBTClientStateID" messagetype="notification" >
+    <description>Provides applications with notifications specific to the current TBT client status on the module</description>
+    <param name="state" type="TBTState">
+      <description>Current State of TBT client</description>
+    </param>
+  </function>
+
+  <function name="OnAudioPassThru" functionID="OnAudioPassThruID" messagetype="notification">
+      <description>Binary data is in binary part of hybrid msg</description>
+  </function>
+
+  <typedef name="TdResult" type="Result">
+    <description>
+      Test typedef over enum
+    </description>
+  </typedef>
+
+  <struct name="EmptyStruct">
+    <description>
+      Completely empty structure
+    </description>
+  </struct>
+
+  <struct name="StructWithOptionalEmptyStructField">
+    <param name="emptyOne" type="EmptyStruct" mandatory="false" />
+  </struct>
+
+  <struct name="StructWithMandatoryEmptyStructField">
+    <param name="emptyOne" type="EmptyStruct" />
+  </struct>
+
+  <struct name="StructWithNullableTypedef">
+    <description>
+      Test struct having nullable typedef as a param
+    </description>
+    <param name="nullableTdResult" type="TdResult" nullable="true"/>
+  </struct>
+
+  <struct name="StructWithOneOptionalIntField" nullable="true" >
+    <param name="optionalInt" type="Integer" minvalue="1" maxvalue="42" mandatory="false" />
+  </struct>
+
+  <struct name="StructWithFieldOfStructThatMightBeEmpty">
+    <param name="fieldThatMightBeEmpty" type="StructWithOneOptionalIntField" mandatory="true" />
+  </struct>
+
+  <struct name="StructWithNullableOptionalMap">
+    <param name="nullableOptionalIntMap" type="Integer" map="true" nullable="true" mandatory="false" minsize="0" maxsize="5" minvalue="2" maxvalue="10" />
+  </struct>
+
+  <struct name="StructWithNullableMapOfNullableInts">
+    <param name="nullableMap" type="Integer" minvalue="0" maxvalue="42" map="true" minsize="1" maxsize="5" nullable="true" null_values_allowed="true" />
+  </struct>
+
+  <struct name="StructWithOptionalIntArray">
+    <param name="optionalIntArray" type="Integer" minvalue="0" maxvalue="42" array="true" minsize="0" maxsize="5" mandatory="false" />
+  </struct>
+
+  <struct name="StructWithMandatoryIntArray">
+    <param name="mandatoryIntArray" type="Integer" minvalue="0" maxvalue="42" array="true" minsize="0" maxsize="5" />
+  </struct>
+
+  <struct name="StructWithOptionalIntMap">
+    <param name="optionalIntMap" type="Integer" minvalue="0" maxvalue="42" map="true" minsize="0" maxsize="5" mandatory="false" />
+  </struct>
+
+  <struct name="StructWithMandatoryIntMap">
+    <param name="mandatoryIntMap" type="Integer" minvalue="0" maxvalue="42" map="true" minsize="0" maxsize="5" />
+  </struct>
+
+  <struct name="FrankenstructOfEmptyStringWithMandatoryInt" type="String" maxlength="15" minsize="0" maxsize="3">
+    <param name="mandatoryInt" type="Integer" minvalue="0" maxvalue="42" />
+  </struct>
+
+  <typedef name="TdResultArray" type="TdResult" array="true" minsize="1" maxsize="10">
+    <description>
+      Test typedef over array
+    </description>
+  </typedef>
+  <typedef name="TdResultArrayMap" type="TdResultArray" map="true" minsize="1" maxsize="5">
+    <description>
+      Test typedef over map of arrays
+    </description>
+  </typedef>
+
+  <struct name="TdStruct" >
+    <description>
+      Test struct containing typedef field
+    </description>
+    <param name="resArrMap" type="TdResultArrayMap" mandatory="true" />
+    <param name="optionalResArrMap" type="TdResultArrayMap" mandatory="false" />
+  </struct>
+
+  <typedef name="TdStructBasedTdef" type="TdStruct" array="true" minsize="1" maxsize="10">
+    <description>
+      Test typedef over struct
+    </description>
+  </typedef>
+
+  <function name="DummyNotification" functionID="DummyNotificationID" messagetype="notification">
+    <param name="tds" type="TdStructBasedTdef" />
+  </function>
+
+  </interface>
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 000000000..319807771
--- /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 000000000..5adc3779c
--- /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 000000000..2e28ce8d0
--- /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 000000000..8b0ba85b0
--- /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 000000000..124a56b79
--- /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 000000000..fbb2fdc5b
--- /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 000000000..e960b3956
--- /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 000000000..ceadadaa8
--- /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 000000000..23e4aec4f
--- /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 000000000..6da6366af
--- /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 000000000..86882e010
--- /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 000000000..9f75a4f77
--- /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 000000000..64954d556
--- /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 000000000..ddbb93cb7
--- /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 000000000..96df958c9
--- /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 000000000..7f15ebc18
--- /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 000000000..9d443b1dc
--- /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 000000000..3bb450cf7
--- /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 000000000..60fa8f80d
--- /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 000000000..c9fe63da7
--- /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 000000000..3b6e53c0b
--- /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 000000000..5d32bf643
--- /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 000000000..223b429b7
--- /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 000000000..b6446a29a
--- /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 000000000..34d9dd951
--- /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 000000000..8f3089bb2
--- /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 000000000..c6abd052d
--- /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 000000000..cf1a13743
--- /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 000000000..d119532b3
--- /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 000000000..22d8d835a
--- /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 000000000..df7b322c8
--- /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 000000000..a26b62c1b
--- /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 000000000..f2f778520
--- /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 000000000..d0b2e02f7
--- /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 000000000..d9fe5f876
--- /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 000000000..bb37f6470
--- /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 000000000..0a72f7814
--- /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 000000000..6afd25dd9
--- /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 000000000..078e0bf80
--- /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 000000000..92ccb7112
--- /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 000000000..fa615a451
--- /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 000000000..18dd331d4
--- /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 000000000..f7b06c95d
--- /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 000000000..365fb64c3
--- /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 000000000..04b4b4655
--- /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 000000000..05cfb7f8d
--- /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 000000000..04ab4450a
--- /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 000000000..7d0959a0a
--- /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 000000000..28c2f6bc9
--- /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 000000000..defcb33ff
--- /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 000000000..aaed9b57b
--- /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 000000000..30c1aa17c
--- /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 000000000..6a49f6668
--- /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 000000000..d01965d2b
--- /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 000000000..0091b3d8a
--- /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 000000000..7e0370945
--- /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 000000000..a195ef8e5
--- /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 000000000..d59c8b0cf
--- /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 000000000..90e0dc62c
--- /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 000000000..9d8ded07b
--- /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 000000000..a284b9ef8
--- /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 000000000..cb999027b
--- /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 000000000..b33267afa
--- /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 000000000..097e37421
--- /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 000000000..6c8622aa4
--- /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 000000000..d55474e5e
--- /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 000000000..b2bf5a2de
--- /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 000000000..6cb6f4fe1
--- /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 000000000..c622a9c08
--- /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 000000000..c098bd17b
--- /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 000000000..c6e9c510a
--- /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 000000000..aa3353d46
--- /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 000000000..c17596703
--- /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 000000000..f1b89a0a2
--- /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 000000000..7d56bafd2
--- /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 000000000..477f54a9d
--- /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 000000000..e18ccfca5
--- /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 000000000..637a81da5
--- /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 000000000..b60f5af8f
--- /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 000000000..065e0eb4f
--- /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 000000000..72186182d
--- /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 000000000..a00e9d1f6
--- /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 000000000..c29b4c576
--- /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 000000000..c1e133ce9
--- /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 000000000..c2196715c
--- /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 000000000..4035ab1cf
--- /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 000000000..77b4dcf47
--- /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/tmp/intergen-cfgcmd.txt b/tools/intergen/tmp/intergen-cfgcmd.txt
new file mode 100644
index 000000000..cf97a5dd0
--- /dev/null
+++ b/tools/intergen/tmp/intergen-cfgcmd.txt
@@ -0,0 +1 @@
+cmd='/usr/bin/cmake;-DCMAKE_INSTALL_PREFIX=/media/akutsan/Media/development/applink/tools/intergen;-GUnix Makefiles;/media/akutsan/Media/development/applink/tools/intergen'
diff --git a/tools/intergen/tmp/intergen-cfgcmd.txt.in b/tools/intergen/tmp/intergen-cfgcmd.txt.in
new file mode 100644
index 000000000..b3f09efc8
--- /dev/null
+++ b/tools/intergen/tmp/intergen-cfgcmd.txt.in
@@ -0,0 +1 @@
+cmd='@cmd@'
diff --git a/tools/intergen/tool/CMakeLists.txt b/tools/intergen/tool/CMakeLists.txt
new file mode 100644
index 000000000..775988a14
--- /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 000000000..bad87b178
--- /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 000000000..8e2ccbd67
--- /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 000000000..aff817b63
--- /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 000000000..328f24932
--- /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 000000000..a8f5d09d6
--- /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 000000000..0b3718947
--- /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 000000000..78c1b87aa
--- /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 000000000..6c5c3ed3b
--- /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 000000000..535ce5a74
--- /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 000000000..0db0bebe6
--- /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 000000000..a66fbce90
--- /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
diff --git a/tools/policy_table_validator/CMakeLists.txt b/tools/policy_table_validator/CMakeLists.txt
new file mode 100644
index 000000000..2a372d7ff
--- /dev/null
+++ b/tools/policy_table_validator/CMakeLists.txt
@@ -0,0 +1,27 @@
+#set( CMAKE_VERBOSE_MAKEFILE on )
+
+include_directories(
+	${CMAKE_SOURCE_DIR}/src/components/policy/src/policy/
+        ${CMAKE_SOURCE_DIR}/src/components/rpc_base/include/
+        ${CMAKE_SOURCE_DIR}/src/components/utils/include/
+	${JSONCPP_INCLUDE_DIRECTORY}
+)
+
+
+link_directories (
+    ${CMAKE_BINARY_DIR}/src/components/policy/src/policy/policy_table/table_struct/
+    ${CMAKE_BINARY_DIR}/src/components/rpc_base/
+)
+
+
+set(LIBRARIES
+  policy_struct
+  rpc_base
+)
+
+set (SOURCES
+  main.cpp 
+)
+
+add_executable(policyValidator ${SOURCES})
+target_link_libraries(policyValidator ${LIBRARIES})
diff --git a/tools/policy_table_validator/main.cpp b/tools/policy_table_validator/main.cpp
new file mode 100644
index 000000000..16454ca12
--- /dev/null
+++ b/tools/policy_table_validator/main.cpp
@@ -0,0 +1,83 @@
+#include <iostream>
+#include <cstdlib>
+#include "policy_table/table_struct/types.h"
+
+#include "json/reader.h"
+#include "utils/file_system.h"
+
+namespace policy_table = rpc::policy_table_interface_base;
+
+enum ResultCode {
+  SUCCES = 0,
+  MISSED_FILE_NAME,
+  READ_ERROR,
+  PARSE_ERROR,
+  PT_TYPE_ERROR
+};
+
+rpc::policy_table_interface_base::PolicyTableType StringToPolicyTableType(const std::string& str_pt_type) {
+  if (str_pt_type == "PT_PRELOADED") {
+    return rpc::policy_table_interface_base::PT_PRELOADED;
+  }
+  if (str_pt_type == "PT_SNAPSHOT") {
+    return rpc::policy_table_interface_base::PT_SNAPSHOT;
+  }
+  if (str_pt_type == "PT_UPDATE") {
+    return rpc::policy_table_interface_base::PT_UPDATE;
+  }
+  return rpc::policy_table_interface_base::INVALID_PT_TYPE;
+}
+
+void help() {
+  std::cout << "Usage:" << std::endl <<
+               "./policy_validator {Policy table type} {file_name}" << std::endl;
+  std::cout << "Policy table types:"
+               "\t PT_PRELOADED , PT_UPDATE , PT_SNAPSHOT" <<std::endl;
+}
+
+int main(int argc, char** argv) {
+  if (argc != 3) {
+    // TODO(AKutsan): No filename
+    help();
+    exit(MISSED_FILE_NAME);
+  }
+  std::string pt_type_str = argv[1];
+  std::string file_name = argv[2];
+  std::string json_string;
+  rpc::policy_table_interface_base::PolicyTableType pt_type;
+  pt_type = StringToPolicyTableType(pt_type_str);
+  if (rpc::policy_table_interface_base::PolicyTableType::INVALID_PT_TYPE
+      == pt_type) {
+    std::cout << "Invalid policy table type: " << pt_type_str << std::endl;
+    exit(PT_TYPE_ERROR);
+  }
+  bool read_result = file_system::ReadFile(file_name, json_string);
+  if (false == read_result) {
+    std::cout << "Read file error: " << file_name << std::endl;
+    exit(READ_ERROR);
+  }
+
+  Json::Reader reader;
+  Json::Value value;
+
+  bool parce_result = reader.parse(json_string, value);
+  if (false == parce_result) {
+    std::cout << "Json parce fails" << std::endl;
+    exit(PARSE_ERROR);
+  }
+  std::cout << "DEFAULT_POLICY" << std::endl;
+  policy_table::Table table(&value);
+  table.SetPolicyTableType(pt_type);
+  bool is_valid = table.is_valid();
+  if (true == is_valid ) {
+    std::cout << "Table is valid" << std::endl;
+    exit(SUCCES);
+  }
+
+  std::cout << "Table is not valid" << std::endl;
+  rpc::ValidationReport report("policy_table");
+  table.ReportErrors(&report);
+  std::cout << "Errors: " << std::endl << rpc::PrettyFormat(report) << std::endl;
+
+  return SUCCES;
+}