Merge lp:~adrianboguszewski/inkscape/sax-parser into lp:~inkscape.dev/inkscape/trunk

[Adrian Boguszewski]

Added new file loading and saving, new sax parser and libxml++.

Unmerged revisions

15065. By Adrian Boguszewski on 2016-11-06

Merged trunk

15064. By Adrian Boguszewski on 2016-10-18

Fixed Windows file loading

15063. By Adrian Boguszewski on 2016-10-18

Merged trunk

15062. By Adrian Boguszewski on 2016-10-04

Fixed libxml++ compilation on Windows

15061. By Adrian Boguszewski on 2016-10-02

Merged trunk

15060. By Adrian Boguszewski on 2016-09-28

Fixed memory management in sax parser

15059. By Adrian Boguszewski on 2016-09-28

Renamed some variables

15058. By Adrian Boguszewski on 2016-09-26

Added empty entity to sax parser

15057. By Adrian Boguszewski on 2016-09-25

Improved compressed file reading

15056. By Adrian Boguszewski on 2016-09-22

Fixed too many text nodes

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-10-01 06:05:10 +0000
+++ CMakeLists.txt	2016-11-06 17:18:04 +0000
@@ -86,6 +86,7 @@
     message("No gmock/gtest found! Perhaps you wish to run 'bash download-gtest.sh' to download it.")
 endif()
 
+include(CMakeScripts/ConfigCompileFlags.cmake)
 include(CMakeScripts/DefineDependsandFlags.cmake) # Includes, Compiler Flags, and Link Libraries
 include(CMakeScripts/HelperMacros.cmake) # Misc Utility Macros
 

=== modified file 'CMakeScripts/ConfigCompileFlags.cmake'
--- CMakeScripts/ConfigCompileFlags.cmake	2016-08-09 09:33:34 +0000
+++ CMakeScripts/ConfigCompileFlags.cmake	2016-11-06 17:18:04 +0000
@@ -14,6 +14,6 @@
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2 ${COMPILE_PROFILING_FLAGS} ")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O2 ${COMPILE_PROFILING_FLAGS} ")
 
-set(CMAKE_MAKE_PROGRAM "${CMAKE_MAKE_PROGRAM} ")
+set(CMAKE_MAKE_PROGRAM ${CMAKE_MAKE_PROGRAM})
 
 message(STATUS "${CMAKE_CXX_FLAGS}")

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2016-10-22 22:11:58 +0000
+++ src/CMakeLists.txt	2016-11-06 17:18:04 +0000
@@ -458,6 +458,7 @@
 add_subdirectory(inkgc)
 add_subdirectory(libuemf)
 add_subdirectory(libvpsc)
+add_subdirectory(libxml++)
 add_subdirectory(livarot)
 add_subdirectory(libnrtype)
 add_subdirectory(libdepixelize)
@@ -515,6 +516,7 @@
         avoid_LIB
         cola_LIB
         vpsc_LIB
+        xmlpp_LIB
         livarot_LIB
         uemf_LIB
         2geom_LIB

=== modified file 'src/document.cpp'
--- src/document.cpp	2016-10-02 22:44:54 +0000
+++ src/document.cpp	2016-11-06 17:18:04 +0000
@@ -42,6 +42,7 @@
 #include <string>
 #include <cstring>
 #include <2geom/transforms.h>
+#include <xml/repr-io.h>
 
 #include "widgets/desktop-widget.h"
 #include "desktop.h"
@@ -496,7 +497,7 @@
         Inkscape::XML::Node *rroot;
         gchar *s, *p;
         /* Try to fetch repr from file */
-        rdoc = sp_repr_read_file(uri, SP_SVG_NS_URI);
+        rdoc = Inkscape::XML::read_svg_file(uri, false, SP_SVG_NS_URI);
         /* If file cannot be loaded, return NULL without warning */
         if (rdoc == NULL) return NULL;
         rroot = rdoc->root();
@@ -542,7 +543,7 @@
 {
     SPDocument *doc = NULL;
 
-    Inkscape::XML::Document *rdoc = sp_repr_read_mem(buffer, length, SP_SVG_NS_URI);
+    Inkscape::XML::Document *rdoc = Inkscape::XML::read_svg_buffer(buffer, false, SP_SVG_NS_URI);
     if ( rdoc ) {
         // Only continue to create a non-null doc if it could be loaded
         Inkscape::XML::Node *rroot = rdoc->root();

=== modified file 'src/extension/implementation/xslt.cpp'
--- src/extension/implementation/xslt.cpp	2016-08-03 13:29:38 +0000
+++ src/extension/implementation/xslt.cpp	2016-11-06 17:18:04 +0000
@@ -29,8 +29,7 @@
 
 #include <libxslt/transform.h>
 #include <libxslt/xsltutils.h>
-
-Inkscape::XML::Document * sp_repr_do_read (xmlDocPtr doc, const gchar * default_ns);
+#include <xml/repr-io.h>
 
 /* Namespaces */
 namespace Inkscape {
@@ -146,9 +145,14 @@
     xmlDocPtr result = xsltApplyStylesheet(_stylesheet, filein, params);
     xmlFreeDoc(filein);
 
-    Inkscape::XML::Document * rdoc = sp_repr_do_read( result, SP_SVG_NS_URI);
+    xmlChar *str;
+    int size;
+    xmlDocDumpMemory(result, &str, &size);
     xmlFreeDoc(result);
 
+    Inkscape::XML::Document * rdoc = Inkscape::XML::read_svg_buffer((char*) str, false, SP_SVG_NS_URI);
+    xmlFree(str);
+
     if (rdoc == NULL) {
         return NULL;
     }
@@ -197,8 +201,7 @@
         return;
     }
 
-    if (!sp_repr_save_rebased_file(repr->document(), tempfilename_out.c_str(), SP_SVG_NS_URI,
-                                   doc->getBase(), filename)) {
+    if (!Inkscape::XML::save_svg_file(repr->document(), tempfilename_out.c_str(), SP_SVG_NS_URI, doc->getBase(), filename)) {
         throw Inkscape::Extension::Output::save_failed();
     }
 

=== modified file 'src/extension/internal/filter/filter-file.cpp'
--- src/extension/internal/filter/filter-file.cpp	2014-06-26 19:40:39 +0000
+++ src/extension/internal/filter/filter-file.cpp	2016-11-06 17:18:04 +0000
@@ -21,6 +21,7 @@
 /* System includes */
 #include <glibmm/i18n.h>
 #include <glibmm/fileutils.h>
+#include <xml/repr-io.h>
 
 namespace Inkscape {
 namespace Extension {
@@ -84,7 +85,7 @@
 void
 Filter::filters_load_file (gchar * filename, gchar * menuname)
 {
-    Inkscape::XML::Document *doc = sp_repr_read_file(filename, INKSCAPE_EXTENSION_URI);
+	Inkscape::XML::Document *doc = Inkscape::XML::read_svg_file(filename, true, INKSCAPE_EXTENSION_URI);
 	if (doc == NULL) {
 		g_warning("File (%s) is not parseable as XML.  Ignored.", filename);
 		return;
@@ -162,7 +163,7 @@
 	node->setAttribute("xmlns:inkscape", SP_INKSCAPE_NS_URI);
 
 	mywriter writer;
-	sp_repr_write_stream(node, writer, 0, FALSE, g_quark_from_static_string("svg"), 0, 0);
+	node->serialize(writer, "svg", 0, 0, false, false);
 
     Inkscape::Extension::build_from_mem(xml_str, new Filter(g_strdup(writer.c_str())));
 	g_free(xml_str);

=== modified file 'src/extension/internal/filter/filter.cpp'
--- src/extension/internal/filter/filter.cpp	2016-07-03 18:53:39 +0000
+++ src/extension/internal/filter/filter.cpp	2016-11-06 17:18:04 +0000
@@ -7,6 +7,7 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
+#include <xml/repr-io.h>
 #include "desktop.h"
 #include "selection.h"
 #include "document-private.h"
@@ -64,7 +65,7 @@
 Inkscape::XML::Document *
 Filter::get_filter (Inkscape::Extension::Extension * ext) {
 	gchar const * filter = get_filter_text(ext);
-	return sp_repr_read_mem(filter, strlen(filter), NULL);
+	return Inkscape::XML::read_svg_buffer(filter, true);
 }
 
 void

=== modified file 'src/extension/internal/svg.cpp'
--- src/extension/internal/svg.cpp	2016-10-01 21:30:34 +0000
+++ src/extension/internal/svg.cpp	2016-11-06 17:18:04 +0000
@@ -15,7 +15,7 @@
  */
 
 #ifdef HAVE_CONFIG_H
-# include <config.h>
+#include <config.h>
 #endif
 #include "sp-object.h"
 #include "svg.h"
@@ -25,11 +25,12 @@
 #include <vector>
 #include "xml/attribute-record.h"
 #include "xml/simple-document.h"
+#include "xml/repr-io.h"
 #include "sp-root.h"
 #include "document.h"
 
 #ifdef WITH_GNOME_VFS
-# include <libgnomevfs/gnome-vfs.h>
+#include <libgnomevfs/gnome-vfs.h>
 #endif
 
 namespace Inkscape {
@@ -293,8 +294,7 @@
         rdoc = new_rdoc;
     }
 
-    if (!sp_repr_save_rebased_file(rdoc, filename, SP_SVG_NS_URI,
-                                   doc->getBase(), filename)) {
+    if (!Inkscape::XML::save_svg_file(rdoc, filename, SP_SVG_NS_URI, doc->getBase(), filename)) {
         throw Inkscape::Extension::Output::save_failed();
     }
 

=== modified file 'src/extension/loader.h'
--- src/extension/loader.h	2016-08-03 15:12:14 +0000
+++ src/extension/loader.h	2016-11-06 17:18:04 +0000
@@ -1,4 +1,5 @@
-/** @file
+/** @file#include <config.h>
+
  * Loader for external plug-ins.
  *//*
  *

=== modified file 'src/extension/prefdialog.cpp'
--- src/extension/prefdialog.cpp	2016-07-28 10:22:07 +0000
+++ src/extension/prefdialog.cpp	2016-11-06 17:18:04 +0000
@@ -12,6 +12,7 @@
 #include <gtkmm/checkbutton.h>
 #include <gtkmm/separator.h>
 #include <glibmm/i18n.h>
+#include <xml/repr-io.h>
 
 #include "ui/dialog-events.h"
 #include "xml/repr.h"
@@ -81,7 +82,7 @@
 
     if (_effect != NULL && !_effect->no_live_preview) {
         if (_param_preview == NULL) {
-            XML::Document * doc = sp_repr_read_mem(live_param_xml, strlen(live_param_xml), NULL);
+            XML::Document * doc = Inkscape::XML::read_svg_buffer(live_param_xml, true);
             if (doc == NULL) {
                 std::cout << "Error encountered loading live parameter XML !!!" << std::endl;
                 return;

=== modified file 'src/extension/system.cpp'
--- src/extension/system.cpp	2016-08-03 13:29:38 +0000
+++ src/extension/system.cpp	2016-11-06 17:18:04 +0000
@@ -40,6 +40,7 @@
 #include "loader.h"
 
 #include <glibmm/miscutils.h>
+#include <xml/repr-io.h>
 
 namespace Inkscape {
 namespace Extension {
@@ -546,7 +547,7 @@
 Extension *
 build_from_file(gchar const *filename)
 {
-    Inkscape::XML::Document *doc = sp_repr_read_file(filename, INKSCAPE_EXTENSION_URI);
+    Inkscape::XML::Document *doc = Inkscape::XML::read_svg_file(filename, true, INKSCAPE_EXTENSION_URI);
     std::string dir = Glib::path_get_dirname(filename);
     Extension *ext = build_from_reprdoc(doc, NULL, &dir);
     if (ext != NULL)
@@ -568,7 +569,7 @@
 Extension *
 build_from_mem(gchar const *buffer, Implementation::Implementation *in_imp)
 {
-    Inkscape::XML::Document *doc = sp_repr_read_mem(buffer, strlen(buffer), INKSCAPE_EXTENSION_URI);
+    Inkscape::XML::Document *doc = Inkscape::XML::read_svg_buffer(buffer, true, INKSCAPE_EXTENSION_URI);
     g_return_val_if_fail(doc != NULL, NULL);
     Extension *ext = build_from_reprdoc(doc, in_imp, NULL);
     Inkscape::GC::release(doc);

=== modified file 'src/inkscape.cpp'
--- src/inkscape.cpp	2016-09-02 22:45:03 +0000
+++ src/inkscape.cpp	2016-11-06 17:18:04 +0000
@@ -48,6 +48,7 @@
 #include <glibmm/i18n.h>
 #include <glibmm/miscutils.h>
 #include <glibmm/convert.h>
+#include <xml/repr-io.h>
 
 #include "desktop.h"
 
@@ -322,21 +323,17 @@
             baseName = 0;
 
             // Try to save the file
-            FILE *file = Inkscape::IO::fopen_utf8name(full_path, "w");
             gchar *errortext = 0;
-            if (file) {
-                try{
-                    sp_repr_save_stream(repr->document(), file, SP_SVG_NS_URI);
-                } catch (Inkscape::Extension::Output::no_extension_found &e) {
-                    errortext = g_strdup(_("Autosave failed! Could not find inkscape extension to save document."));
-                } catch (Inkscape::Extension::Output::save_failed &e) {
+            try {
+                if (!Inkscape::XML::save_svg_file(repr->document(), full_path, SP_SVG_NS_URI)) {
                     gchar *safeUri = Inkscape::IO::sanitizeString(full_path);
                     errortext = g_strdup_printf(_("Autosave failed! File %s could not be saved."), safeUri);
                     g_free(safeUri);
                 }
-                fclose(file);
-            }
-            else {
+
+            } catch (Inkscape::Extension::Output::no_extension_found &e) {
+                errortext = g_strdup(_("Autosave failed! Could not find inkscape extension to save document."));
+            } catch (Inkscape::Extension::Output::save_failed &e) {
                 gchar *safeUri = Inkscape::IO::sanitizeString(full_path);
                 errortext = g_strdup_printf(_("Autosave failed! File %s could not be saved."), safeUri);
                 g_free(safeUri);
@@ -701,15 +698,14 @@
                 file = Inkscape::IO::fopen_utf8name(filename, "w");
                 if (file) {
                     g_snprintf (c, 1024, "%s", filename); // we want the complete path to be stored in c (for reporting purposes)
+                    fclose (file);
                     break;
                 }
             }
 
             // Save
-            if (file) {
-                sp_repr_save_stream (repr->document(), file, SP_SVG_NS_URI);
+            if (Inkscape::XML::save_svg_file(repr->document(), c, SP_SVG_NS_URI)) {
                 savednames = g_slist_prepend (savednames, g_strdup (c));
-                fclose (file);
             } else {
                 failednames = g_slist_prepend (failednames, (doc->getName()) ? g_strdup(doc->getName()) : g_strdup (_("Untitled document")));
             }
@@ -819,7 +815,7 @@
 
     if ( g_file_get_contents(fn, &menus_xml, &len, NULL) ) {
         // load the menus_xml file
-        _menus = sp_repr_read_mem(menus_xml, len, NULL);
+        _menus = Inkscape::XML::read_svg_buffer(menus_xml, true);
 
         g_free(menus_xml);
         menus_xml = 0;
@@ -828,7 +824,7 @@
     fn = 0;
 
     if ( !_menus ) {
-        _menus = sp_repr_read_mem(menus_skeleton, MENUS_SKELETON_SIZE, NULL);
+        _menus = Inkscape::XML::read_svg_buffer(menus_skeleton, true);
     }
 
     return (_menus != 0);

=== added directory 'src/libxml++'
=== added file 'src/libxml++/CMakeLists.txt'
--- src/libxml++/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/libxml++/CMakeLists.txt	2016-11-06 17:18:04 +0000
@@ -0,0 +1,34 @@
+set(libxmlpp_SRC
+        document.cc
+        dtd.cc
+        keepblanks.cc
+        noncopyable.cc
+        exceptions/exception.cc
+        exceptions/internal_error.cc
+        exceptions/parse_error.cc
+        exceptions/validity_error.cc
+        exceptions/wrapped_exception.cc
+        io/istreamparserinputbuffer.cc
+        io/parserinputbuffer.cc
+        parsers/parser.cc
+        parsers/saxparser.cc
+
+        # -------
+        # Headers
+        document.h
+        dtd.h
+        keepblanks.h
+        libxml++config.h
+        noncopyable.h
+        exceptions/exception.h
+        exceptions/internal_error.h
+        exceptions/parse_error.h
+        exceptions/validity_error.h
+        exceptions/wrapped_exception.h
+        io/istreamparserinputbuffer.h
+        io/parserinputbuffer.h
+        parsers/parser.h
+        parsers/saxparser.h
+        )
+
+add_inkscape_lib(xmlpp_LIB "${libxmlpp_SRC}")

=== added file 'src/libxml++/README'
--- src/libxml++/README	1970-01-01 00:00:00 +0000
+++ src/libxml++/README	2016-11-06 17:18:04 +0000
@@ -0,0 +1,8 @@
+This code is a part of libxml++ library (ver 3.0) with local modifications
+inter alia:
+* DOM parser and node classes are removed
+* Enabled SAX2 interface
+* Added new SAX parser methods to handle Processing Instructions
+  and namespace information from nodes
+
+Full library is available here: http://libxmlplusplus.sourceforge.net/
\ No newline at end of file

=== added file 'src/libxml++/document.cc'
--- src/libxml++/document.cc	1970-01-01 00:00:00 +0000
+++ src/libxml++/document.cc	2016-11-06 17:18:04 +0000
@@ -0,0 +1,126 @@
+/* document.cc
+ * this file is part of libxml++
+ *
+ * copyright (C) 2003 by the libxml++ development team
+ *
+ * this file is covered by the GNU Lesser General Public License,
+ * which should be included with libxml++ as the file COPYING.
+ */
+
+#include <libxml++/document.h>
+#include <libxml++/exceptions/internal_error.h>
+
+#include <libxml/tree.h>
+
+namespace xmlpp
+{
+
+static const char* get_encoding_or_utf8(const Glib::ustring& encoding)
+{
+  if(encoding.empty())
+  {
+    //If we don't specify this to the xmlDocDump* functions (using nullptr instead),
+    //then some other encoding is used, causing them to fail on non-ASCII characters.
+    return "UTF-8";
+  }
+  else
+    return encoding.c_str();
+}
+
+
+Document::Init::Init()
+{
+  xmlInitParser(); //Not always necessary, but necessary for thread safety.
+}
+
+Document::Init::~Init() noexcept
+{
+  //We don't call this because it breaks libxml generally and should only be
+  //called at the very end of a process, such as at the end of a main().
+  //libxml might still be used by the application, so we don't want to break
+  //that.
+  //This is important even here, which usually happens only when the library
+  //is unloaded, because that might happen during normal application use,
+  //if the application does dynamic library loading, for instance to load
+  //plugins.
+  //See http://xmlsoft.org/html/libxml-parser.html#xmlCleanupParser
+  //xmlCleanupParser(); //As per xmlInitParser(), or memory leak will happen.
+}
+
+Document::Init Document::init_;
+
+Document::Document(const Glib::ustring& version)
+  : impl_(xmlNewDoc((const xmlChar*)version.c_str()))
+{
+  if (!impl_)
+    throw internal_error("Could not create Document.");
+  impl_->_private = this;
+}
+
+Document::Document(xmlDoc* doc)
+  : impl_(doc)
+{
+  if (!impl_)
+    throw internal_error("xmlDoc pointer cannot be nullptr");
+
+  impl_->_private = this;
+}
+
+Document::~Document()
+{
+  xmlFreeDoc(impl_);
+}
+
+Glib::ustring Document::get_encoding() const
+{
+  Glib::ustring encoding;
+  if(impl_->encoding)
+    encoding = (const char*)impl_->encoding;
+
+  return encoding;
+}
+
+Dtd* Document::get_internal_subset() const
+{
+  auto dtd = xmlGetIntSubset(impl_);
+  if(!dtd)
+    return nullptr;
+
+  if(!dtd->_private)
+    dtd->_private = new Dtd(dtd);
+
+  return reinterpret_cast<Dtd*>(dtd->_private);
+}
+
+void Document::set_internal_subset(const Glib::ustring& name,
+                                   const Glib::ustring& external_id,
+                                   const Glib::ustring& system_id)
+{
+  auto dtd = xmlCreateIntSubset(impl_,
+				   (const xmlChar*)name.c_str(),
+				   external_id.empty() ? nullptr : (const xmlChar*)external_id.c_str(),
+				   system_id.empty() ? nullptr : (const xmlChar*)system_id.c_str());
+
+  if (dtd && !dtd->_private)
+    dtd->_private = new Dtd(dtd);
+}
+
+void Document::set_entity_declaration(const Glib::ustring& name, XmlEntityType type,
+                              const Glib::ustring& publicId, const Glib::ustring& systemId,
+                              const Glib::ustring& content)
+{
+  auto entity = xmlAddDocEntity(impl_, (const xmlChar*)name.c_str(),
+    static_cast<int>(type),
+    publicId.empty() ? nullptr : (const xmlChar*)publicId.c_str(),
+    systemId.empty() ? nullptr : (const xmlChar*)systemId.c_str(),
+    (const xmlChar*)content.c_str());
+  if (!entity)
+    throw internal_error("Could not add entity declaration " + name);
+}
+
+_xmlEntity* Document::get_entity(const Glib::ustring& name)
+{
+  return xmlGetDocEntity(impl_, (const xmlChar*) name.c_str());
+}
+
+} //namespace xmlpp

=== added file 'src/libxml++/document.h'
--- src/libxml++/document.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/document.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,139 @@
+/* document.h
+ * this file is part of libxml++
+ *
+ * parts of the code copyright (C) 2003 by Stefan Seefeld
+ * others copyright (C) 2003 by libxml++ developer's team
+ *
+ * this file is covered by the GNU Lesser General Public License,
+ * which should be included with libxml++ as the file COPYING.
+ */
+
+#ifndef __LIBXMLPP_DOCUMENT_H
+#define __LIBXMLPP_DOCUMENT_H
+
+#include <libxml++/dtd.h>
+
+#include <string>
+#include <ostream>
+
+/* std::string or Glib::ustring in function prototypes in libxml++?
+ *
+ * If it's propagated to a libxml2 function that takes a xmlChar*, it's
+ * UTF-8 encoded, and Glib::ustring is the right choice.
+ *
+ * If it's propagated to a libxml2 function that takes a char*, it's not
+ * necessarily UTF-8 encoded, and std::string is usually the right choice.
+ * Most of these strings are filenames or URLs.
+ */
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" {
+  struct _xmlDoc;
+  struct _xmlEntity;
+}
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+namespace xmlpp
+{
+
+// xmlpp::XmlEntityType is similar to xmlEntityType in libxml2.
+/** The valid entity types.
+ */
+enum class XmlEntityType
+{
+  INTERNAL_GENERAL = 1,
+  EXTERNAL_GENERAL_PARSED = 2,
+  EXTERNAL_GENERAL_UNPARSED = 3,
+  INTERNAL_PARAMETER = 4,
+  EXTERNAL_PARAMETER = 5,
+  INTERNAL_PREDEFINED = 6
+};
+
+//TODO: Make Document inherit from Node, when we can break ABI one day?
+//
+//libxml might intend xmlDoc to derive (theoretically) from xmlNode.
+//This is suggested because the xmlNodeSet returned by xmlXPathEval (see the
+//Node::find() implementation) can contain either xmlNode or xmlDocument elements.
+// See https://bugzilla.gnome.org/show_bug.cgi?id=754673#c8 for an explanation
+// why it has not been done in libxml++ 3.0.
+/**
+ * Represents an XML document in the DOM model.
+ */
+class Document : public NonCopyable
+{
+  //Ensure that libxml is properly initialised:
+  class Init
+  {
+  public:
+    Init();
+    ~Init() noexcept;
+  };
+
+  friend class SaxParser;
+
+public:
+  /** Create a new document.
+   * @param version XML version.
+   * @throws xmlpp::internal_error If memory allocation fails.
+   */
+  explicit Document(const Glib::ustring& version = "1.0");
+
+  /** Create a new C++ wrapper for an xmlDoc struct.
+   * The created xmlpp::Document takes ownership of the xmlDoc.
+   * When the Document is deleted, so is the xmlDoc and all its nodes.
+   * @param doc A pointer to an xmlDoc struct. Must not be <tt>nullptr</tt>.
+   * @throws xmlpp::internal_error If @a doc is <tt>nullptr</tt>.
+   */
+  explicit Document(_xmlDoc* doc);
+
+  ~Document() override;
+
+  /** @return The encoding used in the source from which the document has been loaded.
+   */
+  Glib::ustring get_encoding() const;
+
+  /** Get the internal subset of this document.
+   * @returns A pointer to the DTD, or <tt>nullptr</tt> if not found.
+   */
+  Dtd* get_internal_subset() const;
+
+  /** Create the internal subset of this document.
+   * If the document already has an internal subset, a new one is not created.
+   * @param name The DTD name.
+   * @param external_id The external (PUBLIC) ID, or an empty string.
+   * @param system_id The system ID, or an empty string.
+   */
+  void set_internal_subset(const Glib::ustring& name,
+                           const Glib::ustring& external_id,
+                           const Glib::ustring& system_id);
+
+  /** Add an Entity declaration to the document.
+   * @param name The name of the entity that will be used in an entity reference.
+   * @param type The type of entity.
+   * @param publicId The public ID of the subset.
+   * @param systemId The system ID of the subset.
+   * @param content The value of the Entity. In entity reference substitutions, this
+   * is the replacement value.
+   * @throws xmlpp::internal_error
+   */
+  virtual void set_entity_declaration(const Glib::ustring& name, XmlEntityType type,
+                                      const Glib::ustring& publicId, const Glib::ustring& systemId,
+                                      const Glib::ustring& content);
+
+protected:
+  /** Retrieve an Entity.
+   * The entity can be from an external subset or internally declared.
+   * @param name The name of the entity to get.
+   * @returns A pointer to the libxml2 entity structure, or <tt>nullptr</tt> if not found.
+   */
+  _xmlEntity* get_entity(const Glib::ustring& name);
+
+private:
+  static Init init_;
+
+  _xmlDoc* impl_;
+};
+
+} //namespace xmlpp
+
+#endif //__LIBXMLPP_DOCUMENT_H

=== added file 'src/libxml++/dtd.cc'
--- src/libxml++/dtd.cc	1970-01-01 00:00:00 +0000
+++ src/libxml++/dtd.cc	2016-11-06 17:18:04 +0000
@@ -0,0 +1,147 @@
+/* dtd.cc
+ * libxml++ and this file are copyright (C) 2000 by Ari Johnson, and
+ * are covered by the GNU Lesser General Public License, which should be
+ * included with libxml++ as the file COPYING.
+ */
+
+#include <libxml++/dtd.h>
+#include <libxml++/exceptions/parse_error.h>
+#include <libxml++/io/istreamparserinputbuffer.h>
+
+#include <libxml/tree.h>
+
+namespace xmlpp
+{
+
+struct Dtd::Impl
+{
+  Impl() noexcept : dtd(nullptr), is_dtd_owner(false) {}
+
+  _xmlDtd* dtd;
+  bool is_dtd_owner;
+};
+
+Dtd::Dtd()
+: pimpl_(new Impl)
+{
+}
+
+Dtd::Dtd(_xmlDtd* dtd, bool take_ownership)
+: pimpl_(new Impl)
+{
+  pimpl_->dtd = dtd;
+  if (dtd)
+  {
+    pimpl_->dtd->_private = this;
+    pimpl_->is_dtd_owner = take_ownership;
+  }
+}
+
+Dtd::Dtd(const std::string& filename)
+: pimpl_(new Impl)
+{
+  parse_subset("", filename);
+}
+
+Dtd::Dtd(const Glib::ustring& external, const Glib::ustring& system)
+: pimpl_(new Impl)
+{
+  parse_subset(external, system);
+}
+
+Dtd::~Dtd()
+{
+  release_underlying();
+}
+
+void Dtd::parse_file(const std::string& filename)
+{
+  parse_subset("", filename);
+}
+
+void Dtd::parse_subset(const Glib::ustring& external, const Glib::ustring& system)
+{
+  release_underlying(); // Free any existing dtd.
+  xmlResetLastError();
+
+  auto dtd = xmlParseDTD(
+    external.empty() ? nullptr : (const xmlChar*)external.c_str(),
+    system.empty() ? nullptr : (const xmlChar*)system.c_str());
+
+  if (!dtd)
+  {
+    throw parse_error("Dtd could not be parsed.\n" + format_xml_error());
+  }
+
+  pimpl_->dtd = dtd;
+  pimpl_->dtd->_private = this;
+  pimpl_->is_dtd_owner = true;
+}
+
+void Dtd::parse_memory(const Glib::ustring& contents)
+{
+  // Prepare an istream with buffer
+  std::istringstream is(contents);
+
+  parse_stream(is);
+}
+
+void Dtd::parse_stream(std::istream& in)
+{
+  release_underlying(); // Free any existing dtd.
+  xmlResetLastError();
+
+  IStreamParserInputBuffer ibuff(in);
+
+  auto dtd = xmlIOParseDTD(nullptr, ibuff.cobj(), XML_CHAR_ENCODING_UTF8);
+
+  if (!dtd)
+  {
+    throw parse_error("Dtd could not be parsed.\n" + format_xml_error());
+  }
+
+  pimpl_->dtd = dtd;
+  pimpl_->dtd->_private = this;
+  pimpl_->is_dtd_owner = true;
+}
+
+Glib::ustring Dtd::get_name() const
+{
+  return (pimpl_->dtd && pimpl_->dtd->name) ? (const char*)pimpl_->dtd->name : "";
+}
+
+Glib::ustring Dtd::get_external_id() const
+{
+  return (pimpl_->dtd && pimpl_->dtd->ExternalID) ? (const char*)pimpl_->dtd->ExternalID : "";
+}
+
+Glib::ustring Dtd::get_system_id() const
+{
+  return (pimpl_->dtd && pimpl_->dtd->SystemID) ? (const char*)pimpl_->dtd->SystemID : "";
+}
+
+_xmlDtd* Dtd::cobj() noexcept
+{
+  return pimpl_->dtd;
+}
+
+const _xmlDtd* Dtd::cobj() const noexcept
+{
+  return pimpl_->dtd;
+}
+
+void Dtd::release_underlying()
+{
+  if (pimpl_->dtd)
+  {
+    pimpl_->dtd->_private = nullptr;
+    if (pimpl_->is_dtd_owner)
+    {
+      xmlFreeDtd(pimpl_->dtd);
+      pimpl_->is_dtd_owner = false;
+    }
+    pimpl_->dtd = nullptr;
+  }
+}
+
+} //namespace xmlpp

=== added file 'src/libxml++/dtd.h'
--- src/libxml++/dtd.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/dtd.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,136 @@
+/* dtd.h
+ * libxml++ and this file are copyright (C) 2000 by Ari Johnson, and
+ * are covered by the GNU Lesser General Public License, which should be
+ * included with libxml++ as the file COPYING.
+ */
+
+#ifndef __LIBXMLPP_DTD_H
+#define __LIBXMLPP_DTD_H
+
+#include <libxml++/noncopyable.h>
+#include <glibmm/ustring.h>
+#include <string>
+#include <memory> // std::unique_ptr
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" {
+  struct _xmlDtd;
+}
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+namespace xmlpp
+{
+
+//TODO: Derive from Node?
+// See https://bugzilla.gnome.org/show_bug.cgi?id=754673#c8 for an explanation
+// why it has not been done in libxml++ 3.0.
+/** Represents an XML DTD for validating XML files.
+ * DTD = Document Type Definition
+ */
+class Dtd : public NonCopyable
+{
+public:
+  Dtd();
+
+  /** Create a Dtd from the underlying libxml DTD element.
+   * @param dtd A pointer to the libxml DTD element.
+   * @param take_ownership If <tt>true</tt>, this Dtd instance takes ownership of
+   *        the libxml DTD element. The caller must not delete it.<br>
+   *        If <tt>false</tt>, this Dtd does not take ownership of the libxml
+   *        DTD element. The caller must guarantee that the libxml DTD element
+   *        exists as long as this Dtd keeps a pointer to it. The caller is
+   *        responsible for deleting the libxml DTD element when it's no longer
+   *        needed, unless it belongs to a Document, in which case it's deleted
+   *        when the Document is deleted.
+   */
+  explicit Dtd(_xmlDtd* dtd, bool take_ownership = false);
+
+  /** Create a Dtd and parse an external subset (DTD file) immediately.
+   *
+   * @newin{3,0}
+   *
+   * @param filename The URL of the DTD.
+   * @throws xmlpp::parse_error
+   */
+  explicit Dtd(const std::string& filename);
+
+  /** Create a Dtd and parse an external subset (DTD file) immediately.
+   *
+   * @newin{3,0}
+   *
+   * @param external The external ID of the DTD.
+   * @param system The URL of the DTD.
+   * @throws xmlpp::parse_error
+   */
+  Dtd(const Glib::ustring& external, const Glib::ustring& system);
+
+  ~Dtd() override;
+
+  /** Parse an external subset (DTD file).
+   * If another DTD has been parsed before, that DTD is replaced by the new one
+   * (deleted if this Dtd owns it).
+   *
+   * @newin{3,0}
+   *
+   * @param filename The URL of the DTD.
+   * @throws xmlpp::parse_error
+   */
+  void parse_file(const std::string& filename);
+
+  /** Parse an external subset (DTD file).
+   * If another DTD has been parsed before, that DTD is replaced by the new one
+   * (deleted if this Dtd owns it).
+   *
+   * @newin{3,0}
+   *
+   * @param external The external ID of the DTD.
+   * @param system The URL of the DTD.
+   * @throws xmlpp::parse_error
+   */
+  void parse_subset(const Glib::ustring& external, const Glib::ustring& system);
+
+  /** Parse a DTD from a string.
+   * If another DTD has been parsed before, that DTD is replaced by the new one
+   * (deleted if this Dtd owns it).
+   *
+   * @newin{3,0}
+   *
+   * @param contents The DTD as a string.
+   * @throws xmlpp::parse_error
+   */
+  void parse_memory(const Glib::ustring& contents);
+
+  /** Parse a DTD from a stream.
+   * If another DTD has been parsed before, that DTD is replaced by the new one
+   * (deleted if this Dtd owns it).
+   *
+   * @newin{3,0}
+   *
+   * @param in The stream.
+   * @throws xmlpp::parse_error
+   */
+  void parse_stream(std::istream& in);
+
+  Glib::ustring get_name() const;
+  Glib::ustring get_external_id() const;
+  Glib::ustring get_system_id() const;
+
+  /** Access the underlying libxml implementation.
+   */
+  _xmlDtd* cobj() noexcept;
+
+  /** Access the underlying libxml implementation.
+   */
+  const _xmlDtd* cobj() const noexcept;
+
+protected:
+  void release_underlying();
+
+private:
+  struct Impl;
+  std::unique_ptr<Impl> pimpl_;
+};
+
+} // namespace xmlpp
+
+#endif //__LIBXMLPP_DTD_H

=== added directory 'src/libxml++/exceptions'
=== added file 'src/libxml++/exceptions/exception.cc'
--- src/libxml++/exceptions/exception.cc	1970-01-01 00:00:00 +0000
+++ src/libxml++/exceptions/exception.cc	2016-11-06 17:18:04 +0000
@@ -0,0 +1,125 @@
+#include "exception.h"
+#include <libxml/xmlerror.h>
+#include <libxml/parser.h>
+#include <cstdio>
+#include <vector>
+
+namespace xmlpp {
+
+exception::exception(const Glib::ustring& message)
+: message_(message)
+{
+}
+
+exception::~exception() noexcept
+{}
+
+const char* exception::what() const noexcept
+{
+  return message_.c_str();
+}
+
+void exception::raise() const
+{
+  throw *this;
+}
+
+exception* exception::clone() const
+{
+  return new exception(*this);
+}
+
+Glib::ustring format_xml_error(const _xmlError* error)
+{
+  if (!error)
+    error = xmlGetLastError();
+
+  if (!error || error->code == XML_ERR_OK)
+    return ""; // No error
+
+  Glib::ustring str;
+
+  if (error->file && *error->file != '\0')
+  {
+    str += "File ";
+    str += error->file;
+  }
+
+  if (error->line > 0)
+  {
+    str += (str.empty() ? "Line " : ", line ") + Glib::ustring::format(error->line);
+    if (error->int2 > 0)
+      str += ", column " + Glib::ustring::format(error->int2);
+  }
+
+  const bool two_lines = !str.empty();
+  if (two_lines)
+    str += ' ';
+
+  switch (error->level)
+  {
+    case XML_ERR_WARNING:
+      str += "(warning):";
+      break;
+    case XML_ERR_ERROR:
+      str += "(error):";
+      break;
+    case XML_ERR_FATAL:
+      str += "(fatal):";
+      break;
+    default:
+      str += "():";
+      break;
+  }
+
+  str += two_lines ? '\n' : ' ';
+
+  if (error->message && *error->message != '\0')
+    str += error->message;
+  else
+    str += "Error code " + Glib::ustring::format(error->code);
+
+  // If the string does not end with end-of-line, append an end-of-line.
+  if (*str.rbegin() != '\n')
+    str += '\n';
+
+  return str;
+}
+
+Glib::ustring format_xml_parser_error(const _xmlParserCtxt* parser_context)
+{
+  if (!parser_context)
+    return "Error. xmlpp::format_xml_parser_error() called with parser_context == nullptr\n";
+
+  const auto error = xmlCtxtGetLastError(const_cast<_xmlParserCtxt*>(parser_context));
+
+  if (!error)
+    return ""; // No error
+
+  Glib::ustring str;
+
+  if (!parser_context->wellFormed)
+    str += "Document not well-formed.\n";
+
+  return str + format_xml_error(error);
+}
+
+Glib::ustring format_printf_message(const char* fmt, va_list args)
+{
+  // This code was inspired by the example at
+  // http://en.cppreference.com/w/cpp/io/c/vfprintf
+  va_list args2;
+  va_copy(args2, args);
+  // Number of characters (bytes) in the resulting string;
+  // error, if < 0.
+  const int nchar = std::vsnprintf(nullptr, 0, fmt, args2);
+  va_end(args2);
+  if (nchar < 0)
+   return Glib::ustring::format("Error code from std::vsnprintf = ", nchar);
+
+  std::vector<char> buf(nchar+1);
+  std::vsnprintf(buf.data(), buf.size(), fmt, args);
+  return Glib::ustring(buf.data());
+}
+
+} //namespace xmlpp

=== added file 'src/libxml++/exceptions/exception.h'
--- src/libxml++/exceptions/exception.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/exceptions/exception.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,99 @@
+/* exception.h
+ *
+ * Copyright (C) 2002 The libxml++ development team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __LIBXMLPP_EXCEPTION_H
+#define __LIBXMLPP_EXCEPTION_H
+
+#include <exception>
+#include <cstdarg> // va_list
+#include <glibmm/ustring.h>
+
+#include <libxml++/libxml++config.h>
+
+extern "C" {
+  struct _xmlError;
+  struct _xmlParserCtxt;
+}
+
+namespace xmlpp
+{
+
+/** Base class for all xmlpp exceptions.
+ */
+class LIBXMLPP_API exception : public std::exception
+{
+public:
+  explicit exception(const Glib::ustring& message);
+  ~exception() noexcept override;
+
+  const char* what() const noexcept override;
+
+  virtual void raise() const;
+  virtual exception* clone() const;
+
+private:
+  Glib::ustring message_;
+};
+
+/** Format an _xmlError struct into a text string, suitable for printing.
+ *
+ * @newin{2,36}
+ *
+ * @param error Pointer to an _xmlError struct or <tt>nullptr</tt>.
+ *              If <tt>nullptr</tt>, the error returned by xmlGetLastError() is used.
+ * @returns A formatted text string. If the error struct does not contain an
+ *          error (error->code == XML_ERR_OK), an empty string is returned.
+ */
+Glib::ustring format_xml_error(const _xmlError* error = nullptr);
+
+/** Format a parser error into a text string, suitable for printing.
+ *
+ * @newin{2,36}
+ *
+ * @param parser_context Pointer to an _xmlParserCtxt struct.
+ * @returns A formatted text string. If the parser context does not contain an
+ *          error (parser_context->lastError.code == XML_ERR_OK), an empty
+ *          string is returned.
+ */
+Glib::ustring format_xml_parser_error(const _xmlParserCtxt* parser_context);
+
+/** Format a message from a function with C-style variadic parameters.
+ *
+ * Helper function that formats a message supplied in the form of a printf-style
+ * format specification and zero or more ... parameters.
+ *
+ * @code
+ * // Typical call:
+ * void f(const char* fmt, ...)
+ * {
+ *   va_list args;
+ *   va_start(args, fmt);
+ *   Glib::ustring msg = xmlpp::format_printf_message(fmt, args);
+ *   va_end(args);
+ *   // ...
+ * }
+ * @endcode
+ *
+ * @newin{3,0}
+ */
+Glib::ustring format_printf_message(const char* fmt, va_list args);
+
+} // namespace xmlpp
+
+#endif // __LIBXMLPP_EXCEPTION_H

=== added file 'src/libxml++/exceptions/internal_error.cc'
--- src/libxml++/exceptions/internal_error.cc	1970-01-01 00:00:00 +0000
+++ src/libxml++/exceptions/internal_error.cc	2016-11-06 17:18:04 +0000
@@ -0,0 +1,23 @@
+#include "internal_error.h"
+
+namespace xmlpp {
+
+internal_error::internal_error(const Glib::ustring& message)
+: exception(message)
+{
+}
+
+internal_error::~internal_error() noexcept
+{}
+
+void internal_error::raise() const
+{
+  throw *this;
+}
+
+exception* internal_error::clone() const
+{
+  return new internal_error(*this);
+}
+
+} //namespace xmlpp

=== added file 'src/libxml++/exceptions/internal_error.h'
--- src/libxml++/exceptions/internal_error.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/exceptions/internal_error.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,39 @@
+/* internal_error.h
+ *
+ * Copyright (C) 2002 The libxml++ development team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __LIBXMLPP_INTERNAL_ERROR_H
+#define __LIBXMLPP_INTERNAL_ERROR_H
+
+#include <libxml++/exceptions/exception.h>
+
+namespace xmlpp {
+
+class internal_error : public exception
+{
+public:
+  explicit internal_error(const Glib::ustring& message);
+  ~internal_error() noexcept override;
+
+  void raise() const override;
+  exception* clone() const override;
+};
+
+} // namespace xmlpp
+
+#endif // __LIBXMLPP_INTERNAL_ERROR_H

=== added file 'src/libxml++/exceptions/parse_error.cc'
--- src/libxml++/exceptions/parse_error.cc	1970-01-01 00:00:00 +0000
+++ src/libxml++/exceptions/parse_error.cc	2016-11-06 17:18:04 +0000
@@ -0,0 +1,23 @@
+#include "parse_error.h"
+
+namespace xmlpp {
+
+parse_error::parse_error(const Glib::ustring& message)
+: exception(message)
+{
+}
+
+parse_error::~parse_error() noexcept
+{}
+
+void parse_error::raise() const
+{
+  throw *this;
+}
+
+exception* parse_error::clone() const
+{
+  return new parse_error(*this);
+}
+
+} //namespace xmlpp

=== added file 'src/libxml++/exceptions/parse_error.h'
--- src/libxml++/exceptions/parse_error.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/exceptions/parse_error.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,42 @@
+/* parse_error.h
+ *
+ * Copyright (C) 2002 The libxml++ development team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __LIBXMLPP_PARSE_ERROR_H
+#define __LIBXMLPP_PARSE_ERROR_H
+
+#include <libxml++/exceptions/exception.h>
+
+namespace xmlpp
+{
+
+/** This exception will be thrown when the parser encounters an error in the XML document.
+ */
+class parse_error : public exception
+{
+public:
+  explicit parse_error(const Glib::ustring& message);
+  ~parse_error() noexcept override;
+
+  void raise() const override;
+  exception* clone() const override;
+};
+
+} // namespace xmlpp
+
+#endif // __LIBXMLPP_PARSE_ERROR_H

=== added file 'src/libxml++/exceptions/validity_error.cc'
--- src/libxml++/exceptions/validity_error.cc	1970-01-01 00:00:00 +0000
+++ src/libxml++/exceptions/validity_error.cc	2016-11-06 17:18:04 +0000
@@ -0,0 +1,23 @@
+#include "validity_error.h"
+
+namespace xmlpp {
+
+validity_error::validity_error(const Glib::ustring& message)
+: parse_error(message)
+{
+}
+
+validity_error::~validity_error() noexcept
+{}
+
+void validity_error::raise() const
+{
+  throw *this;
+}
+
+exception* validity_error::clone() const
+{
+  return new validity_error(*this);
+}
+
+} //namespace xmlpp

=== added file 'src/libxml++/exceptions/validity_error.h'
--- src/libxml++/exceptions/validity_error.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/exceptions/validity_error.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,42 @@
+/* validity_error.h
+ *
+ * Copyright (C) 2002 The libxml++ development team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __LIBXMLPP_VALIDITY_ERROR_H
+#define __LIBXMLPP_VALIDITY_ERROR_H
+
+#include <libxml++/exceptions/parse_error.h>
+
+namespace xmlpp
+{
+
+/** This exception will be thrown when the parser encounters a validity error in the XML document.
+ */
+class validity_error : public parse_error
+{
+public:
+  explicit validity_error(const Glib::ustring& message);
+  ~validity_error() noexcept override;
+
+  void raise() const override;
+  exception* clone() const override;
+};
+
+} // namespace xmlpp
+
+#endif // __LIBXMLPP_VALIDITY_ERROR_H

=== added file 'src/libxml++/exceptions/wrapped_exception.cc'
--- src/libxml++/exceptions/wrapped_exception.cc	1970-01-01 00:00:00 +0000
+++ src/libxml++/exceptions/wrapped_exception.cc	2016-11-06 17:18:04 +0000
@@ -0,0 +1,46 @@
+/* Copyright (C) 2015  The libxml++ development team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "wrapped_exception.h"
+
+namespace xmlpp
+{
+
+#ifdef LIBXMLXX_HAVE_EXCEPTION_PTR
+
+wrapped_exception::wrapped_exception(std::exception_ptr exception_ptr)
+  : exception("Wrapped exception"), exception_ptr_(exception_ptr)
+{
+}
+
+wrapped_exception::~wrapped_exception() noexcept
+{
+}
+
+void wrapped_exception::raise() const
+{
+  std::rethrow_exception(exception_ptr_);
+}
+
+exception* wrapped_exception::clone() const
+{
+  return new wrapped_exception(exception_ptr_);
+}
+
+#endif // LIBXMLXX_HAVE_EXCEPTION_PTR
+
+} // namespace xmlpp

=== added file 'src/libxml++/exceptions/wrapped_exception.h'
--- src/libxml++/exceptions/wrapped_exception.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/exceptions/wrapped_exception.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,56 @@
+/* Copyright (C) 2015  The libxml++ development team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __LIBXMLPP_WRAPPED_EXCEPTION_H
+#define __LIBXMLPP_WRAPPED_EXCEPTION_H
+
+#include <exception>
+
+#include <libxml++/exceptions/exception.h>
+#include <libxml++config.h>
+
+namespace xmlpp
+{
+
+#ifdef LIBXMLXX_HAVE_EXCEPTION_PTR
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+/** Helper class for propagating an exception through C code.
+ * Should not be used by applications.
+ * Does not exist in systems that don't support std::exception_ptr.
+ *
+ * @newin{2,40}
+ */
+class wrapped_exception : public exception
+{
+public:
+  explicit wrapped_exception(std::exception_ptr exception_ptr);
+  ~wrapped_exception() noexcept override;
+
+  void raise() const override;
+  exception* clone() const override;
+
+private:
+  std::exception_ptr exception_ptr_;
+};
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+#endif // LIBXMLXX_HAVE_EXCEPTION_PTR
+
+} // namespace xmlpp
+
+#endif // __LIBXMLPP_WRAPPED_EXCEPTION_H

=== added directory 'src/libxml++/io'
=== added file 'src/libxml++/io/istreamparserinputbuffer.cc'
--- src/libxml++/io/istreamparserinputbuffer.cc	1970-01-01 00:00:00 +0000
+++ src/libxml++/io/istreamparserinputbuffer.cc	2016-11-06 17:18:04 +0000
@@ -0,0 +1,44 @@
+/* istreamparserinputbuffer
+ * this file is part of libxml++
+ *
+ * copyright (C) 2003 by libxml++ developer's team
+ *
+ * this file is covered by the GNU Lesser General Public License,
+ * which should be included with libxml++ as the file COPYING.
+ */
+
+#include <libxml++/io/istreamparserinputbuffer.h>
+
+namespace xmlpp
+{
+  IStreamParserInputBuffer::IStreamParserInputBuffer(
+      std::istream & input)
+    : ParserInputBuffer(), input_(input)
+  {
+  }
+
+  IStreamParserInputBuffer::~IStreamParserInputBuffer()
+  {
+  }
+
+  int IStreamParserInputBuffer::do_read(
+      char * buffer,
+      int len)
+  {
+    int l=0;
+    if(input_)
+    {
+      // This is the correct statement - but gcc 2.95.3 lacks this method
+      //l = input_.readsome(buffer, len);
+      input_.read(buffer, len);
+      l = input_.gcount();
+    }
+
+    return l;
+  }
+
+  bool IStreamParserInputBuffer::do_close()
+  {
+    return input_.good();
+  }
+}

=== added file 'src/libxml++/io/istreamparserinputbuffer.h'
--- src/libxml++/io/istreamparserinputbuffer.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/io/istreamparserinputbuffer.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,36 @@
+/* inputstreamparserinputbuffer.h
+ * this file is part of libxml++
+ *
+ * copyright (C) 2003 by libxml++ developer's team
+ *
+ * this file is covered by the GNU Lesser General Public License,
+ * which should be included with libxml++ as the file COPYING.
+ */
+
+#ifndef __LIBXMLPP_ISTREAMPARSEROUTPUTBUFFER_H
+#define __LIBXMLPP_ISTREAMPARSEROUTPUTBUFFER_H
+
+#include <libxml++/io/parserinputbuffer.h>
+
+#include <istream>
+
+namespace xmlpp
+{
+  class IStreamParserInputBuffer: public ParserInputBuffer
+  {
+    public:
+      /**
+       * @param input The istream datas will be read from
+       */
+      IStreamParserInputBuffer(std::istream& input);
+      ~IStreamParserInputBuffer() override;
+
+    private:
+      int  do_read(char * buffer, int len) override;
+      bool do_close() override;
+
+      std::istream& input_;
+  };
+}
+
+#endif

=== added file 'src/libxml++/io/parserinputbuffer.cc'
--- src/libxml++/io/parserinputbuffer.cc	1970-01-01 00:00:00 +0000
+++ src/libxml++/io/parserinputbuffer.cc	2016-11-06 17:18:04 +0000
@@ -0,0 +1,84 @@
+/* parserinputbuffer.cc
+ * this file is part of libxml++
+ *
+ * copyright (C) 2003 by libxml++ developer's team
+ *
+ * this file is covered by the GNU Lesser General Public License,
+ * which should be included with libxml++ as the file COPYING.
+ */
+
+#include <libxml++/io/parserinputbuffer.h>
+#include <libxml++/exceptions/internal_error.h>
+
+#include <libxml/globals.h> //Needed by libxml/xmlIO.h
+#include <libxml/xmlIO.h>
+
+namespace xmlpp
+{
+
+  struct ParserInputBufferCallback
+  {
+    static int on_read(void * context, char * buffer, int len)
+    {
+      auto tmp = static_cast<ParserInputBuffer*>(context);
+      return tmp->do_read(buffer, len);
+    }
+
+    static int on_close(void * context)
+    {
+      auto tmp = static_cast<ParserInputBuffer*>(context);
+      return tmp->do_close();
+    }
+  };
+
+
+  ParserInputBuffer::ParserInputBuffer()
+  {
+    impl_ = xmlParserInputBufferCreateIO(
+        &ParserInputBufferCallback::on_read,
+        &ParserInputBufferCallback::on_close,
+        static_cast<void*>(this),
+        XML_CHAR_ENCODING_NONE);
+    if (!impl_)
+    {
+      throw internal_error("Cannot initialise underlying xmlParserInputBuffer");
+    }
+  }
+
+  ParserInputBuffer::~ParserInputBuffer()
+  {
+  }
+
+  bool ParserInputBuffer::on_close()
+  {
+    bool result = do_close();
+    // the underlying structure is being freed by libxml, the pointer will soon be
+    // invalid.
+    impl_ = nullptr;
+
+    return result;
+  }
+
+  int ParserInputBuffer::on_read(
+      char * buffer,
+      int len)
+  {
+    return do_read(buffer, len);
+  }
+
+  bool ParserInputBuffer::do_close()
+  {
+    return true;
+  }
+
+  _xmlParserInputBuffer* ParserInputBuffer::cobj() noexcept
+  {
+    return impl_;
+  }
+
+  const _xmlParserInputBuffer* ParserInputBuffer::cobj() const noexcept
+  {
+    return impl_;
+  }
+
+}

=== added file 'src/libxml++/io/parserinputbuffer.h'
--- src/libxml++/io/parserinputbuffer.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/io/parserinputbuffer.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,75 @@
+/* parserinputbuffer.h
+ * this file is part of libxml++
+ *
+ * copyright (C) 2003 by libxml++ developer's team
+ *
+ * this file is covered by the GNU Lesser General Public License,
+ * which should be included with libxml++ as the file COPYING.
+ */
+
+#ifndef __LIBXMLPP_PARSERINPUTBUFFER_H
+#define __LIBXMLPP_PARSERINPUTBUFFER_H
+
+#include <string>
+#include <libxml++/noncopyable.h>
+
+extern "C"
+{
+  struct _xmlParserInputBuffer;
+}
+
+namespace xmlpp
+{
+  struct ParserInputBufferCallback;
+
+  /** Base class for xmlParserInputBuffer wrapper
+   *
+   * It can be derived from to create a new output buffer.
+   * A child class has to override do_write(), and possibly
+   * do_close() if some actions are required before buffer closing.
+   */
+  class ParserInputBuffer: public NonCopyable
+  {
+    public:
+      ParserInputBuffer();
+      ~ParserInputBuffer() override;
+
+    public:
+      /** gives an access to the underlying libxml structure to the children
+       */
+      _xmlParserInputBuffer* cobj() noexcept;
+
+      /** gives an access to the underlying libxml structure to the children
+       */
+      const _xmlParserInputBuffer* cobj() const noexcept;
+
+    private:
+      int on_read(char * buffer, int len);
+      bool on_close();
+
+      /** Function called when some data are read from the buffer.
+       * @param buffer The datas encoded in the charset given to the constructor
+       * @param len bytes to read
+       * @return Number of bytes read
+       *
+       * This function MUST be overriden in derived classes.
+       */
+      virtual int do_read(char * buffer, int len) = 0;
+
+      /** Function called before closing the buffer.
+       * Derived classes should override it if some actions are required before
+       * closing the buffer, instead of doing them in the destructor.
+       */
+      virtual bool do_close();
+
+      /**
+       * Underlying libxml2 structure.
+       */
+      _xmlParserInputBuffer* impl_;
+
+      friend struct ParserInputBufferCallback;
+  };
+
+}
+
+#endif

=== added file 'src/libxml++/keepblanks.cc'
--- src/libxml++/keepblanks.cc	1970-01-01 00:00:00 +0000
+++ src/libxml++/keepblanks.cc	2016-11-06 17:18:04 +0000
@@ -0,0 +1,29 @@
+/* keepblanks.cc
+ * libxml++ and this file are
+ * copyright (C) 2003 by The libxml++ Development Team, and
+ * are covered by the GNU Lesser General Public License, which should be
+ * included with libxml++ as the file COPYING.
+ */
+
+#include <libxml++/keepblanks.h>
+
+#include <libxml/globals.h>
+
+namespace xmlpp
+{
+#if _MSC_VER == 1200 // detect MSVC 6.0
+      const bool KeepBlanks::Default = true;
+#endif
+
+  KeepBlanks::KeepBlanks(bool value) noexcept
+  {
+    oldIndentTreeOutput_ = xmlIndentTreeOutput;
+    oldKeepBlanksDefault_ = xmlKeepBlanksDefault( value?1:0 );
+  }
+
+  KeepBlanks::~KeepBlanks() noexcept
+  {
+    xmlKeepBlanksDefault(oldKeepBlanksDefault_);
+    xmlIndentTreeOutput = oldIndentTreeOutput_;
+  }
+}

=== added file 'src/libxml++/keepblanks.h'
--- src/libxml++/keepblanks.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/keepblanks.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,35 @@
+/* keepblanks.h
+ * libxml++ and this file are
+ * copyright (C) 2003 by The libxml++ Development Team, and
+ * are covered by the GNU Lesser General Public License, which should be
+ * included with libxml++ as the file COPYING.
+ */
+
+#ifndef __LIBXMLPP_KEEPBLANKS_H
+#define __LIBXMLPP_KEEPBLANKS_H
+
+namespace xmlpp
+{
+  /** This class sets KeepBlanksDefault and IndentTreeOutput of libxmlpp
+   * and restores their initial values in its destructor. As a consequence
+   * the wanted setting is kept during instance lifetime.
+   */
+  class KeepBlanks {
+    public:
+#if _MSC_VER == 1200 // detect MSVC 6.0
+      static const bool Default;
+#else
+      static const bool Default = true;
+#endif
+
+    public:
+      KeepBlanks(bool value) noexcept;
+      ~KeepBlanks() noexcept;
+
+    private:
+      int oldKeepBlanksDefault_;
+      int oldIndentTreeOutput_;
+  };
+}
+
+#endif // __LIBXMLPP_KEEPBLANKS_H

=== added file 'src/libxml++/libxml++config.h'
--- src/libxml++/libxml++config.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/libxml++config.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,26 @@
+/* libxml++config.h.  Generated from libxml++config.h.in by configure.  */
+#ifndef _LIBXMLPP_CONFIG_H
+#define _LIBXMLPP_CONFIG_H
+
+#include <glibmmconfig.h>
+
+/* Define to omit deprecated API from the library. */
+/* #undef LIBXMLXX_DISABLE_DEPRECATED */
+
+/* Defined if the C++ library supports std::exception_ptr. */
+#define LIBXMLXX_HAVE_EXCEPTION_PTR 1
+
+/* Major version number of libxml++. */
+#define LIBXMLXX_MAJOR_VERSION 3
+
+/* Minor version number of libxml++. */
+#define LIBXMLXX_MINOR_VERSION 0
+
+/* Micro version number of libxml++. */
+#define LIBXMLXX_MICRO_VERSION 0
+
+/* Create static library */
+#define LIBXMLPP_API
+
+#endif /* _LIBXMLPP_CONFIG_H */
+

=== added file 'src/libxml++/noncopyable.cc'
--- src/libxml++/noncopyable.cc	1970-01-01 00:00:00 +0000
+++ src/libxml++/noncopyable.cc	2016-11-06 17:18:04 +0000
@@ -0,0 +1,21 @@
+/* noncopyable.cc
+ * libxml++ and this file are
+ * copyright (C) 2000 by The libxml++ Development Team, and
+ * are covered by the GNU Lesser General Public License, which should be
+ * included with libxml++ as the file COPYING.
+ */
+
+#include <libxml++/noncopyable.h>
+
+namespace xmlpp
+{
+
+NonCopyable::NonCopyable() noexcept
+{
+}
+
+NonCopyable::~NonCopyable()
+{
+}
+
+} //namespace xmlpp

=== added file 'src/libxml++/noncopyable.h'
--- src/libxml++/noncopyable.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/noncopyable.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,31 @@
+/* noncopyable.h
+ * libxml++ and this file are
+ * copyright (C) 2000 by The libxml++ Development Team, and
+ * are covered by the GNU Lesser General Public License, which should be
+ * included with libxml++ as the file COPYING.
+ */
+
+#ifndef __LIBXMLPP_NONCOPYABLE_H
+#define __LIBXMLPP_NONCOPYABLE_H
+
+namespace xmlpp
+{
+
+/** A base for classes which cannot be copied or moved.
+ */
+class NonCopyable
+{
+protected:
+  NonCopyable() noexcept;
+  virtual ~NonCopyable();
+
+  NonCopyable(const NonCopyable&) = delete;
+  NonCopyable& operator=(const NonCopyable&) = delete;
+  NonCopyable(NonCopyable&&) = delete;
+  NonCopyable& operator=(NonCopyable&&) = delete;
+};
+
+} // namespace xmlpp
+
+#endif //__LIBXMLPP_NONCOPYABLE_H
+

=== added directory 'src/libxml++/parsers'
=== added file 'src/libxml++/parsers/parser.cc'
--- src/libxml++/parsers/parser.cc	1970-01-01 00:00:00 +0000
+++ src/libxml++/parsers/parser.cc	2016-11-06 17:18:04 +0000
@@ -0,0 +1,365 @@
+/* parser.cc
+ * libxml++ and this file are copyright (C) 2000 by Ari Johnson, and
+ * are covered by the GNU Lesser General Public License, which should be
+ * included with libxml++ as the file COPYING.
+ */
+
+#include "libxml++/exceptions/wrapped_exception.h"
+#include "libxml++/parsers/parser.h"
+
+#include <libxml/parser.h>
+
+namespace xmlpp
+{
+
+struct Parser::Impl
+{
+  Impl()
+  :
+  throw_messages_(true), validate_(false), substitute_entities_(false),
+  include_default_attributes_(false), set_options_(0), clear_options_(0)
+  {}
+
+  // Built gradually - used in an exception at the end of parsing.
+  Glib::ustring parser_error_;
+  Glib::ustring parser_warning_;
+  Glib::ustring validate_error_;
+  Glib::ustring validate_warning_;
+
+  bool throw_messages_;
+  bool validate_;
+  bool substitute_entities_;
+  bool include_default_attributes_;
+  int set_options_;
+  int clear_options_;
+};
+
+Parser::Parser()
+: context_(nullptr), exception_(nullptr), pimpl_(new Impl)
+{
+}
+
+Parser::~Parser()
+{
+  release_underlying();
+}
+
+void Parser::set_validate(bool val) noexcept
+{
+  pimpl_->validate_ = val;
+}
+
+bool Parser::get_validate() const noexcept
+{
+  return pimpl_->validate_;
+}
+
+void Parser::set_substitute_entities(bool val) noexcept
+{
+  pimpl_->substitute_entities_ = val;
+}
+
+bool Parser::get_substitute_entities() const noexcept
+{
+  return pimpl_->substitute_entities_;
+}
+
+void Parser::set_throw_messages(bool val) noexcept
+{
+  pimpl_->throw_messages_ = val;
+}
+
+bool Parser::get_throw_messages() const noexcept
+{
+  return pimpl_->throw_messages_;
+}
+
+void Parser::set_include_default_attributes(bool val) noexcept
+{
+  pimpl_->include_default_attributes_ = val;
+}
+
+bool Parser::get_include_default_attributes() noexcept
+{
+  return pimpl_->include_default_attributes_;
+}
+
+void Parser::set_parser_options(int set_options, int clear_options) noexcept
+{
+  pimpl_->set_options_ = set_options;
+  pimpl_->clear_options_ = clear_options;
+}
+
+void Parser::get_parser_options(int& set_options, int& clear_options) noexcept
+{
+  set_options = pimpl_->set_options_;
+  clear_options = pimpl_->clear_options_;
+}
+
+void Parser::initialize_context()
+{
+  //Clear these temporary buffers:
+  pimpl_->parser_error_.erase();
+  pimpl_->parser_warning_.erase();
+  pimpl_->validate_error_.erase();
+  pimpl_->validate_warning_.erase();
+
+  //Disactivate any non-standards-compliant libxml1 features.
+  //These are disactivated by default, but if we don't deactivate them for each context
+  //then some other code which uses a global function, such as xmlKeepBlanksDefault(),
+  // could cause this to use the wrong settings:
+  context_->linenumbers = 1; // TRUE - This is the default anyway.
+
+  //Turn on/off validation, entity substitution and default attribute inclusion.
+  int options = context_->options;
+  if (pimpl_->validate_)
+    options |= XML_PARSE_DTDVALID;
+  else
+    options &= ~XML_PARSE_DTDVALID;
+
+  if (pimpl_->substitute_entities_)
+    options |= XML_PARSE_NOENT;
+  else
+    options &= ~XML_PARSE_NOENT;
+
+  if (pimpl_->include_default_attributes_)
+    options |= XML_PARSE_DTDATTR;
+  else
+    options &= ~XML_PARSE_DTDATTR;
+
+  //Turn on/off any parser options.
+  options |= pimpl_->set_options_;
+  options &= ~pimpl_->clear_options_;
+
+  xmlCtxtUseOptions(context_, options);
+
+  if (context_->sax && pimpl_->throw_messages_)
+  {
+    //Tell the parser context about the callbacks.
+    context_->sax->fatalError = &callback_parser_error;
+    context_->sax->error = &callback_parser_error;
+    context_->sax->warning = &callback_parser_warning;
+  }
+
+  if (pimpl_->throw_messages_)
+  {
+    //Tell the validity context about the callbacks:
+    //(These are only called if validation is on - see above)
+    context_->vctxt.error = &callback_validity_error;
+    context_->vctxt.warning = &callback_validity_warning;
+  }
+
+  //Allow callback_error_or_warning() to retrieve the C++ instance:
+  context_->_private = this;
+}
+
+void Parser::release_underlying()
+{
+  if(context_)
+  {
+    context_->_private = nullptr; //Not really necessary.
+
+    if( context_->myDoc != nullptr )
+    {
+      xmlFreeDoc(context_->myDoc);
+    }
+
+    xmlFreeParserCtxt(context_);
+    context_ = nullptr;
+  }
+}
+
+void Parser::on_parser_error(const Glib::ustring& message)
+{
+  //Throw an exception later when the whole message has been received:
+  pimpl_->parser_error_ += message;
+}
+
+void Parser::on_parser_warning(const Glib::ustring& message)
+{
+  //Throw an exception later when the whole message has been received:
+  pimpl_->parser_warning_ += message;
+}
+void Parser::on_validity_error(const Glib::ustring& message)
+{
+  //Throw an exception later when the whole message has been received:
+  pimpl_->validate_error_ += message;
+}
+
+void Parser::on_validity_warning(const Glib::ustring& message)
+{
+  //Throw an exception later when the whole message has been received:
+  pimpl_->validate_warning_ += message;
+}
+
+void Parser::check_for_error_and_warning_messages()
+{
+  Glib::ustring msg(exception_ ? exception_->what() : "");
+  bool parser_msg = false;
+  bool validity_msg = false;
+
+  if (!pimpl_->parser_error_.empty())
+  {
+    parser_msg = true;
+    msg += "\nParser error:\n" + pimpl_->parser_error_;
+    pimpl_->parser_error_.erase();
+  }
+
+  if (!pimpl_->parser_warning_.empty())
+  {
+    parser_msg = true;
+    msg += "\nParser warning:\n" + pimpl_->parser_warning_;
+    pimpl_->parser_warning_.erase();
+  }
+
+  if (!pimpl_->validate_error_.empty())
+  {
+    validity_msg = true;
+    msg += "\nValidity error:\n" + pimpl_->validate_error_;
+    pimpl_->validate_error_.erase();
+  }
+
+  if (!pimpl_->validate_warning_.empty())
+  {
+    validity_msg = true;
+    msg += "\nValidity warning:\n" + pimpl_->validate_warning_;
+    pimpl_->validate_warning_.erase();
+  }
+
+  if (validity_msg)
+    exception_.reset(new validity_error(msg));
+  else if (parser_msg)
+    exception_.reset(new parse_error(msg));
+}
+
+//static
+void Parser::callback_parser_error(void* ctx, const char* msg, ...)
+{
+  va_list var_args;
+  va_start(var_args, msg);
+  callback_error_or_warning(MsgType::ParserError, ctx, msg, var_args);
+  va_end(var_args);
+}
+
+//static
+void Parser::callback_parser_warning(void* ctx, const char* msg, ...)
+{
+  va_list var_args;
+  va_start(var_args, msg);
+  callback_error_or_warning(MsgType::ParserWarning, ctx, msg, var_args);
+  va_end(var_args);
+}
+
+//static
+void Parser::callback_validity_error(void* ctx, const char* msg, ...)
+{
+  va_list var_args;
+  va_start(var_args, msg);
+  callback_error_or_warning(MsgType::ValidityError, ctx, msg, var_args);
+  va_end(var_args);
+}
+
+//static
+void Parser::callback_validity_warning(void* ctx, const char* msg, ...)
+{
+  va_list var_args;
+  va_start(var_args, msg);
+  callback_error_or_warning(MsgType::ValidityWarning, ctx, msg, var_args);
+  va_end(var_args);
+}
+
+//static
+void Parser::callback_error_or_warning(MsgType msg_type, void* ctx,
+                                       const char* msg, va_list var_args)
+{
+  //See xmlHTMLValidityError() in xmllint.c in libxml for more about this:
+
+  auto context = (xmlParserCtxtPtr)ctx;
+  if(context)
+  {
+    auto parser = static_cast<Parser*>(context->_private);
+    if(parser)
+    {
+      auto ubuff = format_xml_error(&context->lastError);
+      if (ubuff.empty())
+      {
+        // Usually the result of formatting var_args with the format string msg
+        // is the same string as is stored in context->lastError.message.
+        // It's unnecessary to use msg and var_args, if format_xml_error()
+        // returns an error message (as it usually does).
+
+        //Convert the ... to a string:
+        ubuff = format_printf_message(msg, var_args);
+      }
+
+      try
+      {
+        switch (msg_type)
+        {
+          case MsgType::ParserError:
+            parser->on_parser_error(ubuff);
+            break;
+          case MsgType::ParserWarning:
+            parser->on_parser_warning(ubuff);
+            break;
+          case MsgType::ValidityError:
+            parser->on_validity_error(ubuff);
+            break;
+          case MsgType::ValidityWarning:
+            parser->on_validity_warning(ubuff);
+            break;
+        }
+      }
+      catch (...)
+      {
+        parser->handle_exception();
+      }
+    }
+  }
+}
+
+void Parser::handle_exception()
+{
+  try
+  {
+    throw; // Re-throw current exception
+  }
+  catch (const exception& e)
+  {
+    exception_.reset(e.clone());
+  }
+#ifdef LIBXMLXX_HAVE_EXCEPTION_PTR
+  catch (...)
+  {
+    exception_.reset(new wrapped_exception(std::current_exception()));
+  }
+#else
+  catch (const std::exception& e)
+  {
+    exception_.reset(new exception(e.what()));
+  }
+  catch (...)
+  {
+    exception_.reset(new exception("An exception was thrown that is not derived from std::exception or xmlpp::exception.\n"
+      "It could not be caught and rethrown because this platform does not support std::exception_ptr."));
+  }
+#endif
+
+  if (context_)
+    xmlStopParser(context_);
+
+  //release_underlying();
+}
+
+void Parser::check_for_exception()
+{
+  check_for_error_and_warning_messages();
+
+  if (exception_)
+  {
+    std::unique_ptr<exception> tmp(std::move(exception_));
+    tmp->raise();
+  }
+}
+
+} // namespace xmlpp

=== added file 'src/libxml++/parsers/parser.h'
--- src/libxml++/parsers/parser.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/parsers/parser.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,220 @@
+/* parser.h
+ * libxml++ and this file are copyright (C) 2000 by Ari Johnson, and
+ * are covered by the GNU Lesser General Public License, which should be
+ * included with libxml++ as the file COPYING.
+ */
+
+#ifndef __LIBXMLPP_PARSER_H
+#define __LIBXMLPP_PARSER_H
+
+#ifdef _MSC_VER //Ignore warnings about the Visual C++ Bug, where we can not do anything
+#pragma warning (disable : 4786)
+#endif
+
+#include <libxml++/noncopyable.h>
+#include <libxml++/exceptions/validity_error.h>
+#include <libxml++/exceptions/internal_error.h>
+
+#include <string>
+#include <istream>
+#include <cstdarg> // va_list
+#include <memory> // std::unique_ptr
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" {
+  struct _xmlParserCtxt;
+}
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+namespace xmlpp {
+
+/** XML parser.
+ *
+ * Abstract base class for DOM parser and SAX parser.
+ */
+class Parser : public NonCopyable
+{
+public:
+  Parser();
+  ~Parser() override;
+
+  using size_type = unsigned int;
+
+  /** By default, the parser will not validate the XML file.
+   * @param val Whether the document should be validated.
+   */
+  void set_validate(bool val = true) noexcept;
+
+  /** See set_validate().
+   * @returns Whether the parser will validate the XML file.
+   */
+  bool get_validate() const noexcept;
+
+  /** Set whether the parser will automatically substitute entity references with the text of the entities' definitions.
+   * For instance, this affects the text returned by ContentNode::get_content().
+   * By default, the parser will not substitute entities, so that you do not lose the entity reference information.
+   * @param val Whether entities will be substitued.
+   */
+  void set_substitute_entities(bool val = true) noexcept;
+
+  /** See set_substitute_entities().
+   * @returns Whether entities will be substituted during parsing.
+   */
+  bool get_substitute_entities() const noexcept;
+
+  /** Set whether the parser will collect and throw error and warning messages.
+   *
+   * If messages are collected, they are included in an exception thrown at the
+   * end of parsing.
+   *
+   * - DOM parser
+   *
+   *   If the messages are not collected, they are written on stderr.
+   *   The messages written on stderr are slightly different, and may be
+   *   preferred in a program started from the command-line. The default, if
+   *   set_throw_messages() is not called, is to collect and throw messages.
+   *
+   * - SAX parser
+   *
+   *   If the messages are not collected, the error handling on_*() methods in
+   *   the user's SAX parser subclass are called. This is the default, if
+   *   set_throw_messages() is not called.
+   *
+   * @newin{2,36}
+   *
+   * @param val Whether messages will be collected and thrown in an exception.
+   */
+  void set_throw_messages(bool val = true) noexcept;
+
+  /** See set_throw_messages().
+   *
+   * @newin{2,36}
+   *
+   * @returns Whether messages will be collected and thrown in an exception.
+   */
+  bool get_throw_messages() const noexcept;
+
+  /** Set whether default attribute values from the DTD shall be included in the node tree.
+   * If set, attributes not assigned a value in the XML file, but with a default value
+   * in the DTD file, will be included in the node tree that the parser creates.
+   * These attributes will be represented by AttributeNode instances (not AttributeDeclaration
+   * instances), just like attributes which are assigned a value in the XML file.
+   *
+   * @newin{2,38}
+   *
+   * @param val Whether attributes with default values will be included in the node tree.
+   */
+  void set_include_default_attributes(bool val = true) noexcept;
+
+  /** See set_include_default_attributes().
+   *
+   * @newin{2,38}
+   *
+   * @returns Whether attributes with default values will be included in the node tree.
+   */
+  bool get_include_default_attributes() noexcept;
+
+  /** Set and/or clear parser option flags.
+   * See the libxml2 documentation, enum xmlParserOption, for a list of parser options.
+   * This method overrides other methods that set parser options, such as set_validate(),
+   * set_substitute_entities() and set_include_default_attributes(). Use set_parser_options()
+   * only if no other method can set the parser options you want.
+   *
+   * @newin{2,38}
+   *
+   * @param set_options Set bits correspond to flags that shall be set during parsing.
+   * @param clear_options Set bits correspond to flags that shall be cleared during parsing.
+   *        Bits that are set in neither @a set_options nor @a clear_options are not affected.
+   */
+  void set_parser_options(int set_options = 0, int clear_options = 0) noexcept;
+
+  /** See set_parser_options().
+   *
+   * @newin{2,38}
+   *
+   * @param [out] set_options Set bits correspond to flags that shall be set during parsing.
+   * @param [out] clear_options Set bits correspond to flags that shall be cleared during parsing.
+   *        Bits that are set in neither @a set_options nor @a clear_options are not affected.
+   */
+  void get_parser_options(int& set_options, int& clear_options) noexcept;
+
+  /** Parse an XML document from a file.
+   * @throw exception
+   * @param filename The path to the file.
+   */
+  virtual void parse_file(const std::string& filename) = 0;
+
+  /** Parse an XML document from raw memory.
+   * @throw exception
+   * @param contents The XML document as an array of bytes.
+   * @param bytes_count The number of bytes in the @a contents array.
+   */
+  virtual void parse_memory_raw(const unsigned char* contents, size_type bytes_count) = 0;
+
+  /** Parse an XML document from a string.
+   * @throw exception
+   * @param contents The XML document as a string.
+   */
+  virtual void parse_memory(const Glib::ustring& contents) = 0;
+
+  /** Parse an XML document from a stream.
+   * @throw exception
+   * @param in The stream.
+   */
+  virtual void parse_stream(std::istream& in) = 0;
+
+  //TODO: Add stop_parser()/stop_parsing(), wrapping xmlStopParser()?
+
+protected:
+  virtual void initialize_context();
+  virtual void release_underlying();
+
+  virtual void on_parser_error(const Glib::ustring& message);
+  virtual void on_parser_warning(const Glib::ustring& message);
+  virtual void on_validity_error(const Glib::ustring& message);
+  virtual void on_validity_warning(const Glib::ustring& message);
+
+  /// To be called in an exception handler.
+  virtual void handle_exception();
+  virtual void check_for_exception();
+
+  virtual void check_for_error_and_warning_messages();
+
+  static void callback_parser_error(void* ctx, const char* msg, ...);
+  static void callback_parser_warning(void* ctx, const char* msg, ...);
+  static void callback_validity_error(void* ctx, const char* msg, ...);
+  static void callback_validity_warning(void* ctx, const char* msg, ...);
+
+  enum class MsgType
+  {
+    ParserError,
+    ParserWarning,
+    ValidityError,
+    ValidityWarning
+  };
+
+  static void callback_error_or_warning(MsgType msg_type, void* ctx,
+                                        const char* msg, va_list var_args);
+
+  _xmlParserCtxt* context_;
+  std::unique_ptr<exception> exception_;
+
+private:
+  struct Impl;
+  std::unique_ptr<Impl> pimpl_;
+};
+
+/** Equivalent to Parser::parse_stream().
+ *
+ * @newin{2,38}
+ */
+inline std::istream& operator>>(std::istream& in, Parser& parser)
+{
+  parser.parse_stream(in);
+  return in;
+}
+
+} // namespace xmlpp
+
+#endif //__LIBXMLPP_PARSER_H
+

=== added file 'src/libxml++/parsers/saxparser.cc'
--- src/libxml++/parsers/saxparser.cc	1970-01-01 00:00:00 +0000
+++ src/libxml++/parsers/saxparser.cc	2016-11-06 17:18:04 +0000
@@ -0,0 +1,711 @@
+/* saxparser.cc
+ * libxml++ and this file are copyright (C) 2000 by Ari Johnson, and
+ * are covered by the GNU Lesser General Public License, which should be
+ * included with libxml++ as the file COPYING.
+ *
+ * 2002/01/05 Valentin Rusu - fixed some potential buffer overruns
+ * 2002/01/21 Valentin Rusu - added CDATA handlers
+ */
+
+#include "libxml++/parsers/saxparser.h"
+#include "libxml++/keepblanks.h"
+
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h> // for xmlCreateFileParserCtxt
+
+#include <cstdarg> //For va_list.
+#include <iostream>
+
+namespace xmlpp {
+
+struct SaxParserCallback
+{
+  static xmlEntityPtr get_entity(void* context, const xmlChar* name);
+  static void entity_decl(void* context, const xmlChar* name, int type, const xmlChar* publicId, const xmlChar* systemId, xmlChar* content);
+  static void start_document(void* context);
+  static void end_document(void* context);
+  static void start_element(void* context, const xmlChar* name, const xmlChar** p);
+  static void end_element(void* context, const xmlChar* name);
+  static void start_element_ns(void *context, const xmlChar *name, const xmlChar *prefix, const xmlChar *URI, int nb_namespaces,
+                               const xmlChar **namespaces, int nb_attributes, int nb_defaulted, const xmlChar **attributes);
+  static void end_element_ns(void *context, const xmlChar *name, const xmlChar *prefix, const xmlChar *URI);
+  static void characters(void* context, const xmlChar* ch, int len);
+  static void comment(void* context, const xmlChar* value);
+  static void processing_instruction(void* context, const xmlChar* target, const xmlChar* data);
+  static void warning(void* context, const char* fmt, ...);
+  static void error(void* context, const char* fmt, ...);
+  static void fatal_error(void* context, const char* fmt, ...);
+  static void cdata_block(void* context, const xmlChar* value, int len);
+  static void internal_subset(void* context, const xmlChar* name, const xmlChar*publicId, const xmlChar*systemId);
+};
+
+
+
+SaxParser::SaxParser(bool use_get_entity)
+  : sax_handler_(new _xmlSAXHandler), entity_resolver_doc_(new Document)
+{
+  xmlSAXHandler temp = {
+    SaxParserCallback::internal_subset,
+    nullptr, // isStandalone
+    nullptr, // hasInternalSubset
+    nullptr, // hasExternalSubset
+    nullptr, // resolveEntity
+    use_get_entity ? SaxParserCallback::get_entity : nullptr, // getEntity
+    SaxParserCallback::entity_decl, // entityDecl
+    nullptr, // notationDecl
+    nullptr, // attributeDecl
+    nullptr, // elementDecl
+    nullptr, // unparsedEntityDecl
+    nullptr, // setDocumentLocator
+    SaxParserCallback::start_document, // startDocument
+    SaxParserCallback::end_document, // endDocument
+    SaxParserCallback::start_element, // startElement
+    SaxParserCallback::end_element, // endElement
+    nullptr, // reference
+    SaxParserCallback::characters, // characters
+    nullptr, // ignorableWhitespace
+    SaxParserCallback::processing_instruction, // processingInstruction
+    SaxParserCallback::comment,  // comment
+    SaxParserCallback::warning,  // warning
+    SaxParserCallback::error,  // error
+    SaxParserCallback::fatal_error, // fatalError
+    nullptr, // getParameterEntity
+    SaxParserCallback::cdata_block, // cdataBlock
+    nullptr, // externalSubset
+    XML_SAX2_MAGIC,       // initialized
+    nullptr, // private
+    SaxParserCallback::start_element_ns, // startElementNs
+    SaxParserCallback::end_element_ns, // endElementNs
+    nullptr, // serror
+  };
+  *sax_handler_ = temp;
+
+  // The default action is to call on_warning(), on_error(), on_fatal_error().
+  set_throw_messages(false);
+}
+
+SaxParser::~SaxParser()
+{
+  release_underlying();
+}
+
+xmlEntityPtr SaxParser::on_get_entity(const Glib::ustring& name)
+{
+  return entity_resolver_doc_->get_entity(name);
+}
+
+void SaxParser::on_entity_declaration(const Glib::ustring& name, XmlEntityType type, const Glib::ustring& publicId, const Glib::ustring& systemId, const Glib::ustring& content)
+{
+  entity_resolver_doc_->set_entity_declaration(name, type, publicId, systemId, content);
+}
+
+void SaxParser::on_start_document()
+{
+}
+
+void SaxParser::on_end_document()
+{
+}
+
+void SaxParser::on_start_element(const Glib::ustring& /* name */, const AttributeList& /* attributes */)
+{
+}
+
+void SaxParser::on_end_element(const Glib::ustring& /* name */)
+{
+}
+
+void SaxParser::on_start_element_ns(const Glib::ustring& /* name */, const Glib::ustring& /* prefix */, const Glib::ustring& /* uri */, const NamespaceList& /* namespaces */, const AttributeList& /* attributes */)
+{
+}
+
+void SaxParser::on_end_element_ns(const Glib::ustring& /* name */, const Glib::ustring& /* prefix */, const Glib::ustring& /* uri */)
+{
+}
+
+void SaxParser::on_characters(const Glib::ustring& /* text */)
+{
+}
+
+void SaxParser::on_comment(const Glib::ustring& /* text */)
+{
+}
+
+void SaxParser::on_processing_instruction(const Glib::ustring &target, const Glib::ustring &data)
+{
+}
+
+void SaxParser::on_warning(const Glib::ustring& /* text */)
+{
+}
+
+void SaxParser::on_error(const Glib::ustring& /* text */)
+{
+}
+
+void SaxParser::on_fatal_error(const Glib::ustring& text)
+{
+  throw parse_error("Fatal error: " + text);
+}
+
+void SaxParser::on_cdata_block(const Glib::ustring& /* text */)
+{
+}
+
+void SaxParser::on_internal_subset(const Glib::ustring& name,
+                         const Glib::ustring& publicId,
+                         const Glib::ustring& systemId)
+{
+  entity_resolver_doc_->set_internal_subset(name, publicId, systemId);
+}
+
+// implementation of this function is inspired by the SAX documentation by James Henstridge.
+// (http://www.daa.com.au/~james/gnome/xml-sax/implementing.html)
+void SaxParser::parse()
+{
+  if(!context_)
+  {
+    throw internal_error("Parser context not created.");
+  }
+
+  auto old_sax = context_->sax;
+  context_->sax = sax_handler_.get();
+
+  xmlResetLastError();
+  initialize_context();
+
+  const int parseError = xmlParseDocument(context_);
+
+  context_->sax = old_sax;
+
+  auto error_str = format_xml_parser_error(context_);
+  if (error_str.empty() && parseError == -1)
+    error_str = "xmlParseDocument() failed.";
+
+  release_underlying(); // Free context_
+
+  check_for_exception();
+
+  if(!error_str.empty())
+  {
+    throw parse_error(error_str);
+  }
+}
+
+void SaxParser::parse_file(const std::string& filename)
+{
+  if(context_)
+  {
+    throw parse_error("Attempt to start a second parse while a parse is in progress.");
+  }
+
+  KeepBlanks k(KeepBlanks::Default);
+
+  context_ = xmlCreateFileParserCtxt(filename.c_str());
+  parse();
+}
+
+void SaxParser::parse_memory_raw(const unsigned char* contents, size_type bytes_count)
+{
+  if(context_)
+  {
+    throw parse_error("Attempt to start a second parse while a parse is in progress.");
+  }
+
+  KeepBlanks k(KeepBlanks::Default);
+
+  context_ = xmlCreateMemoryParserCtxt((const char*)contents, bytes_count);
+  parse();
+}
+
+void SaxParser::parse_memory(const Glib::ustring& contents)
+{
+  parse_memory_raw((const unsigned char*)contents.c_str(), contents.bytes());
+}
+
+void SaxParser::parse_stream(std::istream& in)
+{
+  if(context_)
+  {
+    throw parse_error("Attempt to start a second parse while a parse is in progress.");
+  }
+
+  KeepBlanks k(KeepBlanks::Default);
+  xmlResetLastError();
+
+  context_ = xmlCreatePushParserCtxt(
+      sax_handler_.get(),
+      nullptr,  // user_data
+      nullptr,  // chunk
+      0,        // size
+      nullptr); // no filename for fetching external entities
+
+  if(!context_)
+  {
+    throw internal_error("Could not create parser context\n" + format_xml_error());
+  }
+
+  initialize_context();
+
+  // std::string or Glib::ustring?
+  // Output from the XML parser is UTF-8 encoded.
+  // But the istream "in" is input, i.e. an XML file. It can use any encoding.
+  // If it's not UTF-8, the file itself must contain information about which
+  // encoding it uses. See the XML specification. Thus use std::string.
+  int firstParseError = XML_ERR_OK;
+  std::string line;
+  while (!exception_ && std::getline(in, line))
+  {
+    // since getline does not get the line separator, we have to add it since the parser care
+    // about layout in certain cases.
+    line += '\n';
+
+    const int parseError = xmlParseChunk(context_, line.c_str(),
+      line.size() /* This is a std::string, not a ustring, so this is the number of bytes. */,
+      0 /* don't terminate */);
+
+    // Save the first error code if any, but read on.
+    // More errors might be reported and then thrown by check_for_exception().
+    if (parseError != XML_ERR_OK && firstParseError == XML_ERR_OK)
+      firstParseError = parseError;
+  }
+
+  if (!exception_)
+  {
+     //This is called just to terminate parsing.
+    const int parseError = xmlParseChunk(context_, nullptr /* chunk */, 0 /* size */, 1 /* terminate (1 or 0) */);
+
+    if (parseError != XML_ERR_OK && firstParseError == XML_ERR_OK)
+      firstParseError = parseError;
+  }
+
+  auto error_str = format_xml_parser_error(context_);
+  if (error_str.empty() && firstParseError != XML_ERR_OK)
+    error_str = "Error code from xmlParseChunk(): " + Glib::ustring::format(firstParseError);
+
+  release_underlying(); // Free context_
+
+  check_for_exception();
+
+  if(!error_str.empty())
+  {
+    throw parse_error(error_str);
+  }
+}
+
+void SaxParser::parse_chunk(const Glib::ustring& chunk)
+{
+  parse_chunk_raw((const unsigned char*)chunk.c_str(), chunk.bytes());
+}
+
+void SaxParser::parse_chunk_raw(const unsigned char* contents, size_type bytes_count)
+{
+  KeepBlanks k(KeepBlanks::Default);
+  xmlResetLastError();
+
+  if(!context_)
+  {
+    context_ = xmlCreatePushParserCtxt(
+      sax_handler_.get(),
+      nullptr,  // user_data
+      nullptr,  // chunk
+      0,        // size
+      nullptr); // no filename for fetching external entities
+
+    if(!context_)
+    {
+      throw internal_error("Could not create parser context\n" + format_xml_error());
+    }
+    initialize_context();
+  }
+  else
+    xmlCtxtResetLastError(context_);
+
+  int parseError = XML_ERR_OK;
+  if (!exception_)
+    parseError = xmlParseChunk(context_, (const char*)contents, bytes_count, 0 /* don't terminate */);
+
+  check_for_exception();
+
+  auto error_str = format_xml_parser_error(context_);
+  if (error_str.empty() && parseError != XML_ERR_OK)
+    error_str = "Error code from xmlParseChunk(): " + Glib::ustring::format(parseError);
+  if(!error_str.empty())
+  {
+    throw parse_error(error_str);
+  }
+}
+
+void SaxParser::finish_chunk_parsing()
+{
+  xmlResetLastError();
+  if(!context_)
+  {
+    context_ = xmlCreatePushParserCtxt(
+      sax_handler_.get(),
+      nullptr,  // user_data
+      nullptr,  // chunk
+      0,        // size
+      nullptr); // no filename for fetching external entities
+
+    if(!context_)
+    {
+      throw internal_error("Could not create parser context\n" + format_xml_error());
+    }
+    initialize_context();
+  }
+  else
+    xmlCtxtResetLastError(context_);
+
+  int parseError = XML_ERR_OK;
+  if (!exception_)
+    //This is called just to terminate parsing.
+    parseError = xmlParseChunk(context_, nullptr /* chunk */, 0 /* size */, 1 /* terminate (1 or 0) */);
+
+  auto error_str = format_xml_parser_error(context_);
+  if (error_str.empty() && parseError != XML_ERR_OK)
+    error_str = "Error code from xmlParseChunk(): " + Glib::ustring::format(parseError);
+
+  release_underlying(); // Free context_
+
+  check_for_exception();
+
+  if(!error_str.empty())
+  {
+    throw parse_error(error_str);
+  }
+}
+
+void SaxParser::release_underlying()
+{
+  Parser::release_underlying();
+}
+
+void SaxParser::initialize_context()
+{
+  Parser::initialize_context();
+  // Start with an empty Document for entity resolution.
+  entity_resolver_doc_.reset(new Document);
+}
+
+xmlEntityPtr SaxParserCallback::get_entity(void* context, const xmlChar* name)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+  xmlEntityPtr result = nullptr;
+
+  try
+  {
+    result = parser->on_get_entity((const char*)name);
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+
+  return result;
+}
+
+void SaxParserCallback::entity_decl(void* context, const xmlChar* name, int type, const xmlChar* publicId, const xmlChar* systemId, xmlChar* content)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  try
+  {
+    parser->on_entity_declaration(
+      ( name ? Glib::ustring((const char*)name) : ""),
+      static_cast<XmlEntityType>(type),
+      ( publicId ? Glib::ustring((const char*)publicId) : ""),
+      ( systemId ? Glib::ustring((const char*)systemId) : ""),
+      ( content ? Glib::ustring((const char*)content) : "") );
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::start_document(void* context)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  try
+  {
+    parser->on_start_document();
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::end_document(void* context)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  if (parser->exception_)
+    return;
+
+  try
+  {
+    parser->on_end_document();
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::start_element(void* context,
+                                        const xmlChar* name,
+                                        const xmlChar** p)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  SaxParser::AttributeList attributes;
+
+  if(p)
+    for(const xmlChar** cur = p; cur && *cur; cur += 2)
+      attributes.push_back(
+			  SaxParser::Attribute( (char*)*cur, (char*)*(cur + 1) ));
+
+  try
+  {
+    parser->on_start_element(Glib::ustring((const char*) name), attributes);
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::end_element(void* context, const xmlChar* name)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  try
+  {
+    parser->on_end_element(Glib::ustring((const char*) name));
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::start_element_ns(void *context, const xmlChar *name, const xmlChar *prefix, const xmlChar *URI,
+                                         int nb_namespaces, const xmlChar **namespaces, int nb_attributes,
+                                         int nb_defaulted, const xmlChar **attributes)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  SaxParser::AttributeList attrs;
+  SaxParser::NamespaceList nss;
+  try
+  {
+    const auto pref = prefix ? Glib::ustring((const char*) prefix) : "";
+    const auto uri = URI ? Glib::ustring((const char*) URI) : "";
+    for (int i = 0; i < nb_namespaces; ++i)
+    {
+      const auto p = namespaces[i * 2] ? Glib::ustring((const char*) namespaces[i * 2]) : "";
+      const auto u = namespaces[i * 2 + 1] ? Glib::ustring((const char*) namespaces[i * 2 + 1]) : "";
+      nss.push_back(SaxParser::Namespace(p, u));
+    }
+
+    unsigned int index = 0;
+    for (int ia = 0; ia < nb_attributes; ++ia, index += 5 )
+    {
+      const auto attrName = attributes[index] ? Glib::ustring((const char*) attributes[index]) : "";
+      const auto attrPrefix = attributes[index + 1] ? Glib::ustring((const char*) attributes[index + 1]) : "";
+      const auto attrUri = attributes[index + 2] ? Glib::ustring((const char*) attributes[index + 2]) : "";
+      const auto attrValueBegin = attributes[index + 3];
+      const auto attrValueEnd = attributes[index + 4];
+      Glib::ustring value((const char *)attrValueBegin, (const char *)attrValueEnd);
+      attrs.push_back(SaxParser::Attribute(attrName, value, attrPrefix, attrUri));
+    }
+    parser->on_start_element_ns(Glib::ustring((const char *) name), pref, uri, nss, attrs);
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::end_element_ns(void *context, const xmlChar *name, const xmlChar *prefix, const xmlChar *URI)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  try
+  {
+    const auto pref = prefix ? Glib::ustring((const char*) prefix) : "";
+    const auto uri = URI ? Glib::ustring((const char*) URI) : "";
+
+    parser->on_end_element_ns(Glib::ustring((const char*) name), pref, uri);
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::characters(void * context, const xmlChar* ch, int len)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  try
+  {
+    // Here we force the use of Glib::ustring::ustring( InputIterator begin, InputIterator end )
+    // instead of Glib::ustring::ustring( const char*, size_type ) because it
+    // expects the length of the string in characters, not in bytes.
+    parser->on_characters(
+        Glib::ustring(
+          reinterpret_cast<const char *>(ch),
+          reinterpret_cast<const char *>(ch + len) ) );
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::comment(void* context, const xmlChar* value)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  try
+  {
+    parser->on_comment(Glib::ustring((const char*) value));
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::warning(void* context, const char* fmt, ...)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  va_list arg;
+  va_start(arg, fmt);
+  const Glib::ustring buff = format_printf_message(fmt, arg);
+  va_end(arg);
+
+  try
+  {
+    parser->on_warning(buff);
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::error(void* context, const char* fmt, ...)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  if (parser->exception_)
+    return;
+
+  va_list arg;
+  va_start(arg, fmt);
+  const Glib::ustring buff = format_printf_message(fmt, arg);
+  va_end(arg);
+
+  try
+  {
+    parser->on_error(buff);
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::fatal_error(void* context, const char* fmt, ...)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  va_list arg;
+  va_start(arg, fmt);
+  const Glib::ustring buff = format_printf_message(fmt, arg);
+  va_end(arg);
+
+  try
+  {
+    parser->on_fatal_error(buff);
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::cdata_block(void* context, const xmlChar* value, int len)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  try
+  {
+    // Here we force the use of Glib::ustring::ustring( InputIterator begin, InputIterator end )
+    // see comments in SaxParserCallback::characters
+    parser->on_cdata_block(
+        Glib::ustring(
+          reinterpret_cast<const char *>(value),
+          reinterpret_cast<const char *>(value + len) ) );
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::internal_subset(void* context, const xmlChar* name,
+  const xmlChar* publicId, const xmlChar* systemId)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  try
+  {
+    const auto pid = publicId ? Glib::ustring((const char*) publicId) : "";
+    const auto sid = systemId ? Glib::ustring((const char*) systemId) : "";
+
+    parser->on_internal_subset( Glib::ustring((const char*) name), pid, sid);
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+void SaxParserCallback::processing_instruction(void *context, const xmlChar *target, const xmlChar *data)
+{
+  auto the_context = static_cast<_xmlParserCtxt*>(context);
+  auto parser = static_cast<SaxParser*>(the_context->_private);
+
+  try
+  {
+    parser->on_processing_instruction(Glib::ustring((const char*) target), Glib::ustring((const char*) data));
+  }
+  catch (...)
+  {
+    parser->handle_exception();
+  }
+}
+
+} // namespace xmlpp

=== added file 'src/libxml++/parsers/saxparser.h'
--- src/libxml++/parsers/saxparser.h	1970-01-01 00:00:00 +0000
+++ src/libxml++/parsers/saxparser.h	2016-11-06 17:18:04 +0000
@@ -0,0 +1,261 @@
+/* saxparser.h
+ * libxml++ and this file are copyright (C) 2000 by Ari Johnson, and
+ * are covered by the GNU Lesser General Public License, which should be
+ * included with libxml++ as the file COPYING.
+ */
+
+#ifndef __LIBXMLPP_PARSERS_SAXPARSER_H
+#define __LIBXMLPP_PARSERS_SAXPARSER_H
+
+#include <libxml++/parsers/parser.h>
+
+#include <deque>
+#include <memory>
+#include "libxml++/document.h"
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+extern "C" {
+  struct _xmlSAXHandler;
+  struct _xmlEntity;
+}
+#endif //DOXYGEN_SHOULD_SKIP_THIS
+
+namespace xmlpp {
+
+/** SAX XML parser.
+ * Derive your own class and override the on_*() methods.
+ * SAX = Simple API for XML
+ *
+ * In a system that does not support std::exception_ptr: If an overridden on_*()
+ * method throws an exception which is not derived from xmlpp::exception,
+ * that exception is replaced by a xmlpp::exception before it is propagated
+ * out of the parse method, such as parse_file().
+ */
+class SaxParser : public Parser
+{
+public:
+  /**
+   * Simple structure used in the start_element callbacks, in which
+   * the namespaces are a list of prefix/uri pairs.
+   */
+  struct Namespace
+  {
+      Glib::ustring prefix;
+      Glib::ustring uri;
+
+      Namespace()
+      {
+      }
+
+      Namespace(Glib::ustring const & p, Glib::ustring const & u)
+        : prefix(p), uri(u)
+      {
+      }
+  };
+  /**
+   * Simple structure used in the start_element callbacks, in which
+   * the attributes are a list of name/value/namespace tuples.
+   */
+  struct Attribute
+  {
+    Glib::ustring name;
+    Glib::ustring value;
+    Namespace ns;
+
+    Attribute(Glib::ustring const & n, Glib::ustring const & v)
+      : name(n), value(v)
+    {
+    }
+
+    Attribute(Glib::ustring const & n, Glib::ustring const & v, Glib::ustring const & p, Glib::ustring const & u)
+      : name(n), value(v), ns(Namespace(p, u))
+      {
+      }
+  };
+
+  using AttributeList = std::deque<Attribute>;
+  using NamespaceList = std::deque<Namespace>;
+
+  /** This functor is a helper to find an attribute by name in an
+   * AttributeList using the standard algorithm std::find_if
+   *
+   * Example:@n
+   * <code>
+   *   Glib::ustring name = "foo";@n
+   *   AttributeList::const_iterator attribute = std::find_if(attributes.begin(), attributes.end(), AttributeHasName(name));
+   * </code>
+   */
+  struct AttributeHasName
+  {
+    Glib::ustring const & name;
+
+    AttributeHasName(Glib::ustring const & n)
+      : name(n)
+      {
+      }
+
+    bool operator()(Attribute const & attribute)
+    {
+      return attribute.name == name;
+    }
+  };
+
+  /**
+   * @param use_get_entity Set this to true if you will override on_get_entity().
+   * In theory, if you do not override on_get_entity() the parser should behave exactly the same
+   * whether you use true or false here. But the default implementation of on_get_entity(), needed
+   * if you override on_get_entity() might not have the same behaviour as the underlying default
+   * behaviour of libxml, so the libxml implementation is the default here.
+   */
+  SaxParser(bool use_get_entity = false);
+  ~SaxParser() override;
+
+  /** Parse an XML document from a file.
+   * @param filename The path to the file.
+   * @throws xmlpp::internal_error
+   * @throws xmlpp::parse_error
+   * @throws xmlpp::validity_error
+   */
+  void parse_file(const std::string& filename) override;
+
+  /** Parse an XML document from a string.
+   * @param contents The XML document as a string.
+   * @throws xmlpp::internal_error
+   * @throws xmlpp::parse_error
+   * @throws xmlpp::validity_error
+   */
+  void parse_memory(const Glib::ustring& contents) override;
+
+  /** Parse an XML document from raw memory.
+   * @param contents The XML document as an array of bytes.
+   * @param bytes_count The number of bytes in the @a contents array.
+   * @throws xmlpp::internal_error
+   * @throws xmlpp::parse_error
+   * @throws xmlpp::validity_error
+   */
+  void parse_memory_raw(const unsigned char* contents, size_type bytes_count) override;
+
+  /** Parse an XML document from a stream.
+   * @param in The stream.
+   * @throws xmlpp::internal_error
+   * @throws xmlpp::parse_error
+   * @throws xmlpp::validity_error
+   */
+  void parse_stream(std::istream& in) override;
+
+  /** Parse a chunk of data.
+   *
+   * This lets you pass a document in small chunks, e.g. from a network
+   * connection. The on_* virtual functions are called each time the chunks
+   * provide enough information to advance the parser.
+   *
+   * The first call to parse_chunk() will setup the parser. When the last chunk
+   * has been parsed, call finish_chunk_parsing() to finish the parse.
+   *
+   * @param chunk The next piece of the XML document.
+   * @throws xmlpp::internal_error
+   * @throws xmlpp::parse_error
+   * @throws xmlpp::validity_error
+   */
+  void parse_chunk(const Glib::ustring& chunk);
+
+  /** Parse a chunk of data.
+   *
+   * @newin{2,24}
+   *
+   * This lets you pass a document in small chunks, e.g. from a network
+   * connection. The on_* virtual functions are called each time the chunks
+   * provide enough information to advance the parser.
+   *
+   * The first call to parse_chunk_raw() will setup the parser. When the last chunk
+   * has been parsed, call finish_chunk_parsing() to finish the parse.
+   *
+   * @param contents The next piece of the XML document as an array of bytes.
+   * @param bytes_count The number of bytes in the @a contents array.
+   * @throws xmlpp::internal_error
+   * @throws xmlpp::parse_error
+   * @throws xmlpp::validity_error
+   */
+  void parse_chunk_raw(const unsigned char* contents, size_type bytes_count);
+
+  /** Finish a chunk-wise parse.
+   *
+   * Call this after the last call to parse_chunk() or parse_chunk_raw().
+   * Don't use this function with the other parsing methods.
+   * @throws xmlpp::internal_error
+   * @throws xmlpp::parse_error
+   * @throws xmlpp::validity_error
+   */
+  void finish_chunk_parsing();
+
+protected:
+
+  virtual void on_start_document();
+  virtual void on_end_document();
+  virtual void on_start_element(const Glib::ustring& name, const AttributeList& attributes);
+  virtual void on_end_element(const Glib::ustring& name);
+  virtual void on_start_element_ns(const Glib::ustring& name, const Glib::ustring& prefix, const Glib::ustring& uri, const NamespaceList& namespaces, const AttributeList& attributes);
+  virtual void on_end_element_ns(const Glib::ustring& name, const Glib::ustring& prefix, const Glib::ustring& uri);
+  virtual void on_characters(const Glib::ustring& characters);
+  virtual void on_comment(const Glib::ustring& text);
+  virtual void on_processing_instruction(const Glib::ustring& target, const Glib::ustring& data);
+  virtual void on_warning(const Glib::ustring& text);
+  virtual void on_error(const Glib::ustring& text);
+
+  /** @throws xmlpp::parse_error
+   */
+  virtual void on_fatal_error(const Glib::ustring& text);
+  virtual void on_cdata_block(const Glib::ustring& text);
+
+  /** Override this to receive information about the document's DTD and any entity declarations.
+   */
+  virtual void on_internal_subset(const Glib::ustring& name, const Glib::ustring& publicId, const Glib::ustring& systemId);
+
+  /** Override this method to resolve entities references in your derived parser, instead of using the default entity resolution,
+   * or to be informed when entity references are encountered.
+   *
+   * If you override this function then you must also specify true for use_get_entity constructor parameter.
+   * You will probably need to override on_entity_declaration() as well so that you can use that information when
+   * resolving the entity reference.
+   *
+   * This is known to be difficult, because it requires both an understanding of the W3C specifications and knowledge of the
+   * libxml internals. Entity resolution is easier with the DomParser.
+   *
+   * Call this method in this base class for default processing. For instance, if you just want to know about the existence of
+   * an entity reference, without affecting the normal substitution, just override and call the base class.
+   *
+   * Unlike the DomParser, the SaxParser will also tell you about entity references for the 5 predefined entities.
+   *
+   * @param name The entity reference name.
+   * @returns The resolved xmlEntity for the entity reference, or <tt>nullptr</tt> if not found.
+   *          You must include libxml/parser.h in order to use this C struct.
+   * This instance will not be freed by the caller.
+   */
+  virtual _xmlEntity* on_get_entity(const Glib::ustring& name);
+
+  /** Override this to receive information about every entity declaration.
+   * If you override this function, and you want normal entity substitution to work, then you must call the base class in your override.
+   *
+   * This would be useful when overriding on_get_entity().
+   * @throws xmlpp::internal_error
+   */
+  virtual void on_entity_declaration(const Glib::ustring& name, XmlEntityType type, const Glib::ustring& publicId, const Glib::ustring& systemId, const Glib::ustring& content);
+
+  void release_underlying() override;
+  void initialize_context() override;
+
+private:
+  void parse();
+
+  std::unique_ptr<_xmlSAXHandler> sax_handler_;
+
+  // A separate xmlpp::Document that is just used for entity resolution,
+  // and never seen in the API:
+  std::unique_ptr<Document> entity_resolver_doc_;
+
+  friend struct SaxParserCallback;
+};
+
+} // namespace xmlpp
+
+#endif //__LIBXMLPP_PARSERS_SAXPARSER_H

=== modified file 'src/preferences.cpp'
--- src/preferences.cpp	2016-09-20 11:19:44 +0000
+++ src/preferences.cpp	2016-11-06 17:18:04 +0000
@@ -17,6 +17,7 @@
 #include <glibmm/i18n.h>
 #include <glib/gstdio.h>
 #include <gtk/gtk.h>
+#include <xml/repr-io.h>
 #include "preferences.h"
 #include "preferences-skeleton.h"
 #include "inkscape.h"
@@ -123,7 +124,7 @@
  */
 void Preferences::_loadDefaults()
 {
-    _prefs_doc = sp_repr_read_mem(preferences_skeleton, PREFERENCES_SKELETON_SIZE, NULL);
+    _prefs_doc = Inkscape::XML::read_svg_buffer(preferences_skeleton, true);
 }
 
 /**
@@ -231,7 +232,8 @@
     }
 
     // 4. Is it valid XML?
-    Inkscape::XML::Document *prefs_read = sp_repr_read_mem(prefs_xml, len, NULL);
+    Inkscape::XML::Document *prefs_read = Inkscape::XML::read_svg_buffer(prefs_xml, true);
+
     g_free(prefs_xml);
     if (!prefs_read) {
         gchar *msg = g_strdup_printf(_("The preferences file %s is not a valid XML document."),
@@ -281,7 +283,7 @@
         // There are many other factors, so ask if you would like to learn them. - JAC
         Glib::ustring utf8name = Glib::filename_to_utf8(_prefs_filename);
         if (!utf8name.empty()) {
-            sp_repr_save_file(_prefs_doc, utf8name.c_str());
+            Inkscape::XML::save_svg_file(_prefs_doc, utf8name);
         }
     }
 }

=== modified file 'src/shortcuts.cpp'
--- src/shortcuts.cpp	2016-08-03 13:29:38 +0000
+++ src/shortcuts.cpp	2016-11-06 17:18:04 +0000
@@ -32,6 +32,7 @@
 #include <glibmm/i18n.h>
 #include <glibmm/convert.h>
 #include <glibmm/miscutils.h>
+#include <xml/repr-io.h>
 
 #include "helper/action.h"
 #include "io/sys.h"
@@ -160,7 +161,7 @@
 
     char const *filename = get_path(USER, KEYS, "default.xml");
 
-    XML::Document *doc=sp_repr_read_file(filename, NULL);
+    XML::Document *doc = Inkscape::XML::read_svg_file(filename, true);
     if (!doc) {
         g_warning("Unable to read keys file %s", filename);
         return;
@@ -183,8 +184,7 @@
         iter=root->firstChild();
     }
 
-
-    sp_repr_save_file(doc, filename, NULL);
+    Inkscape::XML::save_svg_file(doc, filename);
 
     GC::release(doc);
 }
@@ -196,10 +196,10 @@
             "<keys name=\"My custom shortcuts\">"
             "</keys>";
 
-    Inkscape::XML::Document *doc = sp_repr_read_mem(buffer, strlen(buffer), NULL);
-    sp_repr_save_file(doc, filename, NULL);
+    Inkscape::XML::Document *doc = Inkscape::XML::read_svg_buffer(buffer, true);
+    Inkscape::XML::save_svg_file(doc, filename);
 
-    return sp_repr_read_file(filename, NULL);
+    return Inkscape::XML::read_svg_file(filename, true);
 }
 
 /*
@@ -242,7 +242,7 @@
                         if (!Inkscape::IO::file_test(full, G_FILE_TEST_IS_DIR)) {
 
                         	// Get the "key name" from the root element of each file
-                            XML::Document *doc=sp_repr_read_file(full, NULL);
+                            XML::Document *doc = Inkscape::XML::read_svg_file(full, true);
                             if (!doc) {
                                 g_warning("Unable to read keyboard shortcut file %s", full);
                                 continue;
@@ -385,15 +385,15 @@
 }
 
 void sp_shortcut_file_import_do(char const *importname) {
+    XML::Document *doc = Inkscape::XML::read_svg_file(importname, true);
 
-    XML::Document *doc=sp_repr_read_file(importname, NULL);
     if (!doc) {
         g_warning("Unable to read keyboard shortcut file %s", importname);
         return;
     }
 
     char const *filename = get_path(USER, KEYS, "default.xml");
-    sp_repr_save_file(doc, filename, NULL);
+    Inkscape::XML::save_svg_file(doc, filename);
 
     GC::release(doc);
 
@@ -404,13 +404,13 @@
 
     char const *filename = get_path(USER, KEYS, "default.xml");
 
-    XML::Document *doc=sp_repr_read_file(filename, NULL);
+    XML::Document *doc = Inkscape::XML::read_svg_file(filename, true);
     if (!doc) {
         g_warning("Unable to read keyboard shortcut file %s", filename);
         return;
     }
 
-    sp_repr_save_file(doc, exportname, NULL);
+    Inkscape::XML::save_svg_file(doc, exportname);
 
     GC::release(doc);
 }
@@ -428,7 +428,7 @@
 
     char const *filename = get_path(USER, KEYS, "default.xml");
 
-    XML::Document *doc=sp_repr_read_file(filename, NULL);
+    XML::Document *doc = Inkscape::XML::read_svg_file(filename, true);
     if (!doc) {
         g_warning("Unable to read keyboard shortcut file %s", filename);
         return;
@@ -486,7 +486,7 @@
         iter = iter->next();
     }
 
-    sp_repr_save_file(doc, filename, NULL);
+    Inkscape::XML::save_svg_file(doc, filename);
 
     GC::release(doc);
 
@@ -496,7 +496,7 @@
 
     char const *filename = get_path(USER, KEYS, "default.xml");
 
-    XML::Document *doc=sp_repr_read_file(filename, NULL);
+    XML::Document *doc = Inkscape::XML::read_svg_file(filename, true);
     if (!doc) {
         g_warning("Unable to read keyboard shortcut file %s, creating ....", filename);
         doc = sp_shortcut_create_template_file(filename);
@@ -541,13 +541,13 @@
         doc->root()->appendChild(newnode);
     }
 
-    sp_repr_save_file(doc, filename, NULL);
+    Inkscape::XML::save_svg_file(doc, filename);
 
     GC::release(doc);
 
 }
 static void read_shortcuts_file(char const *filename, bool const is_user_set) {
-    XML::Document *doc=sp_repr_read_file(filename, NULL);
+    XML::Document *doc = Inkscape::XML::read_svg_file(filename, true);
     if (!doc) {
         g_warning("Unable to read keys file %s", filename);
         return;

=== modified file 'src/ui/dialog/template-load-tab.cpp'
--- src/ui/dialog/template-load-tab.cpp	2016-08-03 13:29:38 +0000
+++ src/ui/dialog/template-load-tab.cpp	2016-11-06 17:18:04 +0000
@@ -17,6 +17,7 @@
 #include <gtkmm/messagedialog.h>
 #include <gtkmm/scrolledwindow.h>
 #include <iostream>
+#include <xml/repr-io.h>
 
 #include "extension/db.h"
 #include "inkscape.h"
@@ -234,7 +235,7 @@
     n =  result.display_name.rfind(".svg");
     result.display_name.replace(n, 4, 1, ' ');
     
-    Inkscape::XML::Document *rdoc = sp_repr_read_file(path.data(), SP_SVG_NS_URI);
+    Inkscape::XML::Document *rdoc = Inkscape::XML::read_svg_file(path.data(), false, SP_SVG_NS_URI);
     if (rdoc){
         Inkscape::XML::Node *myRoot = rdoc->root();
         if (strcmp(myRoot->name(), "svg:svg") != 0){     // Wrong file format

=== modified file 'src/ui/interface.cpp'
--- src/ui/interface.cpp	2016-10-24 22:58:43 +0000
+++ src/ui/interface.cpp	2016-11-06 17:18:04 +0000
@@ -29,6 +29,7 @@
 #include <glibmm/miscutils.h>
 #include <gtkmm/imagemenuitem.h>
 #include <gtkmm/separatormenuitem.h>
+#include <xml/repr-io.h>
 
 #include "inkscape.h"
 #include "extension/db.h"
@@ -1174,7 +1175,7 @@
         case SVG_XML_DATA: {
             gchar *svgdata = (gchar *)gtk_selection_data_get_data (data);
 
-            Inkscape::XML::Document *rnewdoc = sp_repr_read_mem(svgdata, gtk_selection_data_get_length (data), SP_SVG_NS_URI);
+            Inkscape::XML::Document *rnewdoc = Inkscape::XML::read_svg_buffer(svgdata, false, SP_SVG_NS_URI);
 
             if (rnewdoc == NULL) {
                 sp_ui_error_dialog(_("Could not parse SVG data"));

=== modified file 'src/xml/CMakeLists.txt'
--- src/xml/CMakeLists.txt	2011-10-08 06:34:23 +0000
+++ src/xml/CMakeLists.txt	2016-11-06 17:18:04 +0000
@@ -16,7 +16,7 @@
 	subtree.cpp
 	helper-observer.cpp
 	rebase-hrefs.cpp
-
+	svg-parser.cpp
 
 	# -------
 	# Headers
@@ -42,12 +42,14 @@
 	rebase-hrefs-test.h
 	rebase-hrefs.h
 	repr-action-test.h
+	repr-io.h
 	repr-sorting.h
 	repr.h
 	simple-document.h
 	simple-node.h
 	sp-css-attr.h
 	subtree.h
+	svg-parser.h
 	text-node.h
 )
 

=== modified file 'src/xml/comment-node.h'
--- src/xml/comment-node.h	2011-12-08 11:53:54 +0000
+++ src/xml/comment-node.h	2016-11-06 17:18:04 +0000
@@ -17,6 +17,7 @@
 
 #include <glib.h>
 #include "xml/simple-node.h"
+#include "io/inkscapestream.h"
 
 namespace Inkscape {
 
@@ -37,6 +38,14 @@
 
     Inkscape::XML::NodeType type() const { return Inkscape::XML::COMMENT_NODE; }
 
+    void serialize(Inkscape::IO::Writer& out, const Glib::ustring& defaultPrefix, int indent, int indent_level, bool inline_attributes, bool preserve_spaces) override {
+        Glib::ustring real_indentation((unsigned long) (indent * indent_level), ' ');
+        out.writeUString(real_indentation);
+        out.writeString("<!--");
+        out.writeString(content());
+        out.writeString("-->\n");
+    }
+
 protected:
     SimpleNode *_duplicate(Document* doc) const { return new CommentNode(*this, doc); }
 };

=== modified file 'src/xml/node.h'
--- src/xml/node.h	2014-12-16 14:05:47 +0000
+++ src/xml/node.h	2016-11-06 17:18:04 +0000
@@ -23,6 +23,11 @@
 #include "util/list.h"
 
 namespace Inkscape {
+
+namespace IO {
+class Writer;
+}
+
 namespace XML {
 
 struct AttributeRecord;
@@ -193,8 +198,17 @@
      * @param value The node's new content
      */
     virtual void setContent(char const *value)=0;
-    
-    //@{
+
+    /**
+     * @brief Change a namespace of this node
+     *
+     * The strings passed to this method are copied, so you can free them after use.
+     *
+     * @param prefix namespace prefix
+     * @param uri namespace uri
+     */
+    virtual void setNamespace(Glib::ustring const &prefix, Glib::ustring const &uri) = 0;
+
     /**
      * @brief Change an attribute of this node
      *
@@ -470,9 +484,18 @@
      */
     virtual void synthesizeEvents(NodeEventVector const *vector, void *data)=0;
 
+    /**
+     * @brief serialize node and all descendants into given stream
+     * @param out output writer
+     * @param indent size of indent in characters
+     * @param indent_level level of indent, every child should have indent_level of parent plus 1
+     * @param inline_attributes whether attributes should be printed in one line
+     * @param preserve_spaces whether xml:space is set to 'preserve'
+     * @param defaultPrefix prefix for default namespace
+     */
+    virtual void serialize(Inkscape::IO::Writer& out, const Glib::ustring& defaultPrefix, int indent, int indent_level, bool inline_attributes, bool preserve_spaces) = 0;
+
     virtual void recursivePrintTree(unsigned level)=0;
-    
-    /*@}*/
 
 protected:
     Node(Node const &) : Anchored() {}

=== modified file 'src/xml/pi-node.h'
--- src/xml/pi-node.h	2014-10-08 02:22:03 +0000
+++ src/xml/pi-node.h	2016-11-06 17:18:04 +0000
@@ -15,6 +15,7 @@
 #define SEEN_INKSCAPE_XML_PI_NODE_H
 
 #include "xml/simple-node.h"
+#include "io/inkscapestream.h"
 
 namespace Inkscape {
 
@@ -34,6 +35,11 @@
 
     Inkscape::XML::NodeType type() const { return Inkscape::XML::PI_NODE; }
 
+    void serialize(Inkscape::IO::Writer& out, const Glib::ustring& defaultPrefix, int indent, int indent_level, bool inline_attributes, bool preserve_spaces) override {
+        out.printf("<?%s %s?>\n", name(), content());
+    }
+
+
 protected:
     SimpleNode *_duplicate(Document* doc) const { return new PINode(*this, doc); }
 };

=== modified file 'src/xml/repr-io.cpp'
--- src/xml/repr-io.cpp	2016-08-03 13:29:38 +0000
+++ src/xml/repr-io.cpp	2016-11-06 17:18:04 +0000
@@ -1,1091 +1,200 @@
 /*
- * Dirty DOM-like  tree
+ * IO functions for svg files.
  *
  * Authors:
- *   Lauris Kaplinski <[e-mail]>
- *   bulia byak <[e-mail]>
+ *   Adrian Boguszewski
  *
- * Copyright (C) 1999-2002 Lauris Kaplinski
+ * Copyright (C) 2016 Adrian Boguszewski
  *
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <cstring>
-#include <string>
-#include <stdexcept>
-
-#include <libxml/parser.h>
-
-#include "xml/repr.h"
-#include "xml/attribute-record.h"
-#include "xml/rebase-hrefs.h"
-#include "xml/simple-document.h"
-#include "xml/text-node.h"
-
-#include "io/sys.h"
 #include "io/uristream.h"
 #include "io/stringstream.h"
 #include "io/gzipstream.h"
-
-#include "extension/extension.h"
-
 #include "attribute-rel-util.h"
 #include "attribute-sort-util.h"
-
 #include "preferences.h"
-
+#include "repr-io.h"
+#include "rebase-hrefs.h"
+#include "simple-node.h"
+#include "util/list.h"
+#include "svg-parser.h"
+#include "xml/attribute-record.h"
+#include <boost/algorithm/string.hpp>
+#include <io/sys.h>
 #include <glibmm/miscutils.h>
-
-using Inkscape::IO::Writer;
-using Inkscape::Util::List;
-using Inkscape::Util::cons;
-using Inkscape::XML::Document;
-using Inkscape::XML::SimpleDocument;
-using Inkscape::XML::Node;
-using Inkscape::XML::AttributeRecord;
-using Inkscape::XML::calc_abs_doc_base;
-using Inkscape::XML::rebase_href_attrs;
-
-Document *sp_repr_do_read (xmlDocPtr doc, const gchar *default_ns);
-static Node *sp_repr_svg_read_node (Document *xml_doc, xmlNodePtr node, const gchar *default_ns, std::map<std::string, std::string> &prefix_map);
-static gint sp_repr_qualified_name (gchar *p, gint len, xmlNsPtr ns, const xmlChar *name, const gchar *default_ns, std::map<std::string, std::string> &prefix_map);
-static void sp_repr_write_stream_root_element(Node *repr, Writer &out,
-                                              bool add_whitespace, gchar const *default_ns,
-                                              int inlineattrs, int indent,
-                                              gchar const *old_href_abs_base,
-                                              gchar const *new_href_abs_base);
-
-static void sp_repr_write_stream_element(Node *repr, Writer &out,
-                                         gint indent_level, bool add_whitespace,
-                                         Glib::QueryQuark elide_prefix,
-                                         List<AttributeRecord const> attributes,
-                                         int inlineattrs, int indent,
-                                         gchar const *old_href_abs_base,
-                                         gchar const *new_href_abs_base);
-
-#ifdef HAVE_LIBWMF
-static xmlDocPtr sp_wmf_convert (const char * file_name);
-static char * sp_wmf_image_name (void * context);
-#endif /* HAVE_LIBWMF */
-
-
-class XmlSource
-{
-public:
-    XmlSource()
-        : filename(0),
-          encoding(0),
-          fp(NULL),
-          firstFewLen(0),
-          LoadEntities(false),
-          cachedData(),
-          cachedPos(0),
-          dummy("x"),
-          instr(NULL),
-          gzin(NULL)
-    {
-        for (int k=0;k<4;k++)
-        {
-            firstFew[k]=0;
-        }
-    }
-    virtual ~XmlSource()
-    {
-        close();
-        if ( encoding ) {
-            g_free(encoding);
-            encoding = 0;
-        }
-    }
-
-    int setFile( char const * filename, bool load_entities );
-
-    xmlDocPtr readXml();
-
-    static int readCb( void * context, char * buffer, int len );
-    static int closeCb( void * context );
-
-    char const* getEncoding() const { return encoding; }
-    int read( char * buffer, int len );
-    int close();
-private:
-    const char* filename;
-    char* encoding;
-    FILE* fp;
-    unsigned char firstFew[4];
-    int firstFewLen;
-    bool LoadEntities; // Checks for SYSTEM Entities (requires cached data)
-    std::string cachedData;
-    unsigned int cachedPos;
-    Inkscape::URI dummy;
-    Inkscape::IO::UriInputStream* instr;
-    Inkscape::IO::GzipInputStream* gzin;
-};
-
-int XmlSource::setFile(char const *filename, bool load_entities=false)
-{
-    int retVal = -1;
-
-    this->filename = filename;
-
-    fp = Inkscape::IO::fopen_utf8name(filename, "r");
-    if ( fp ) {
-        // First peek in the file to see what it is
-        memset( firstFew, 0, sizeof(firstFew) );
-
-        size_t some = fread( firstFew, 1, 4, fp );
-        if ( fp ) {
-            // first check for compression
-            if ( (some >= 2) && (firstFew[0] == 0x1f) && (firstFew[1] == 0x8b) ) {
-                //g_message(" the file being read is gzip'd. extract it");
-                fclose(fp);
-                fp = 0;
-                fp = Inkscape::IO::fopen_utf8name(filename, "r");
-                instr = new Inkscape::IO::UriInputStream(fp, dummy);
-                gzin = new Inkscape::IO::GzipInputStream(*instr);
-
-                memset( firstFew, 0, sizeof(firstFew) );
-                some = 0;
-                int single = 0;
-                while ( some < 4 && single >= 0 )
-                {
-                    single = gzin->get();
-                    if ( single >= 0 ) {
-                        firstFew[some++] = 0x0ff & single;
-                    } else {
-                        break;
-                    }
-                }
-            }
-
-            int encSkip = 0;
-            if ( (some >= 2) &&(firstFew[0] == 0xfe) && (firstFew[1] == 0xff) ) {
-                encoding = g_strdup("UTF-16BE");
-                encSkip = 2;
-            } else if ( (some >= 2) && (firstFew[0] == 0xff) && (firstFew[1] == 0xfe) ) {
-                encoding = g_strdup("UTF-16LE");
-                encSkip = 2;
-            } else if ( (some >= 3) && (firstFew[0] == 0xef) && (firstFew[1] == 0xbb) && (firstFew[2] == 0xbf) ) {
-                encoding = g_strdup("UTF-8");
-                encSkip = 3;
-            }
-
-            if ( encSkip ) {
-                memmove( firstFew, firstFew + encSkip, (some - encSkip) );
-                some -= encSkip;
-            }
-
-            firstFewLen = some;
-            retVal = 0; // no error
-        }
-    }
-    if(load_entities) {
-        this->cachedData = std::string("");
-        this->cachedPos = 0;
-
-        // First get data from file in typical way (cache it all)
-        char *buffer = new char [4096];
-        while(true) {
-            int len = this->read(buffer, 4096);
-            if(len <= 0) break;
-            buffer[len] = 0;
-            this->cachedData += buffer;
-        }
-        delete[] buffer;
-
-        // Check for SYSTEM or PUBLIC entities and remove them from the cache
-        GMatchInfo *info;
-        gint start, end;
-
-        GRegex *regex = g_regex_new(
-            "<!ENTITY\\s+[^>\\s]+\\s+(SYSTEM|PUBLIC\\s+\"[^>\"]+\")\\s+\"[^>\"]+\"\\s*>",
-            G_REGEX_CASELESS, G_REGEX_MATCH_NEWLINE_ANY, NULL);
-
-        g_regex_match (regex, this->cachedData.c_str(), G_REGEX_MATCH_NEWLINE_ANY, &info);
-
-        while (g_match_info_matches (info)) {
-            if (g_match_info_fetch_pos (info, 1, &start, &end))
-                this->cachedData.erase(start, end - start);
-            g_match_info_next (info, NULL);
-        }
-        g_match_info_free(info);
-        g_regex_unref(regex);
-    }
-    // Do this after loading cache, so reads don't return cache to fill cache.
-    this->LoadEntities = load_entities;
-    return retVal;
-}
-
-xmlDocPtr XmlSource::readXml()
-{
-    int parse_options = XML_PARSE_HUGE | XML_PARSE_RECOVER;
-
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    bool allowNetAccess = prefs->getBool("/options/externalresources/xml/allow_net_access", false);
-    if (!allowNetAccess) parse_options |= XML_PARSE_NONET;
-
-    // Allow NOENT only if we're filtering out SYSTEM and PUBLIC entities
-    if (LoadEntities)     parse_options |= XML_PARSE_NOENT;
-
-    return xmlReadIO( readCb, closeCb, this,
-                      filename, getEncoding(), parse_options);
-}
-
-int XmlSource::readCb( void * context, char * buffer, int len )
-{
-    int retVal = -1;
-
-    if ( context ) {
-        XmlSource* self = static_cast<XmlSource*>(context);
-        retVal = self->read( buffer, len );
-    }
-    return retVal;
-}
-
-int XmlSource::closeCb(void * context)
-{
-    if ( context ) {
-        XmlSource* self = static_cast<XmlSource*>(context);
-        self->close();
-    }
-    return 0;
-}
-
-int XmlSource::read( char *buffer, int len )
-{
-    int retVal = 0;
-    size_t got = 0;
-
-    if ( LoadEntities ) {
-        if (cachedPos >= cachedData.length()) {
-            return -1;
-        } else {
-            retVal = cachedData.copy(buffer, len, cachedPos);
-            cachedPos += retVal;
-            return retVal; // Do NOT continue.
-        }
-    } else if ( firstFewLen > 0 ) {
-        int some = (len < firstFewLen) ? len : firstFewLen;
-        memcpy( buffer, firstFew, some );
-        if ( len < firstFewLen ) {
-            memmove( firstFew, firstFew + some, (firstFewLen - some) );
-        }
-        firstFewLen -= some;
-        got = some;
-    } else if ( gzin ) {
-        int single = 0;
-        while ( (static_cast<int>(got) < len) && (single >= 0) )
-        {
-            single = gzin->get();
-            if ( single >= 0 ) {
-                buffer[got++] = 0x0ff & single;
-            } else {
-                break;
-            }
-        }
-    } else {
-        got = fread( buffer, 1, len, fp );
-    }
-
-    if ( feof(fp) ) {
-        retVal = got;
-    } else if ( ferror(fp) ) {
-        retVal = -1;
-    } else {
-        retVal = got;
-    }
-
-    return retVal;
-}
-
-int XmlSource::close()
-{
-    if ( gzin ) {
-        gzin->close();
-        delete gzin;
-        gzin = 0;
-    }
-    if ( instr ) {
-        instr->close();
-        fp = 0;
-        delete instr;
-        instr = 0;
-    }
-    if ( fp ) {
-        fclose(fp);
-        fp = 0;
-    }
-    return 0;
-}
-
-/**
- * Reads XML from a file, including WMF files, and returns the Document.
- * The default namespace can also be specified, if desired.
- */
-Document *sp_repr_read_file (const gchar * filename, const gchar *default_ns)
-{
-    // g_warning( "Reading file: %s", filename );
-    xmlDocPtr doc = 0;
-    Document * rdoc = 0;
-
-    xmlSubstituteEntitiesDefault(1);
-
-    g_return_val_if_fail (filename != NULL, NULL);
-    if (!Inkscape::IO::file_test( filename, G_FILE_TEST_EXISTS )) {
-        g_warning("Can't open file: %s (doesn't exist)", filename);
-        return NULL;
-    }
-    /* fixme: A file can disappear at any time, including between now and when we actually try to
-     * open it.  Get rid of the above test once we're sure that we correctly handle
-     * non-existence. */
-
-    // TODO: bulia, please look over
-    gsize bytesRead = 0;
-    gsize bytesWritten = 0;
-    GError* error = NULL;
-    // TODO: need to replace with our own fopen and reading
-    gchar* localFilename = g_filename_from_utf8 ( filename,
-                                 -1,  &bytesRead,  &bytesWritten, &error);
-    g_return_val_if_fail( localFilename != NULL, NULL );
-
-    Inkscape::IO::dump_fopen_call( filename, "N" );
-
-#ifdef HAVE_LIBWMF
-    if (strlen (localFilename) > 4) {
-        if ( (strcmp (localFilename + strlen (localFilename) - 4,".wmf") == 0)
-             || (strcmp (localFilename + strlen (localFilename) - 4,".WMF") == 0)) {
-            doc = sp_wmf_convert (localFilename);
-        }
-    }
-#endif // !HAVE_LIBWMF
-
-    if ( !doc ) {
-        XmlSource src;
-
-        if ( (src.setFile(filename) == 0) ) {
-            doc = src.readXml();
-            rdoc = sp_repr_do_read( doc, default_ns );
-            // For some reason, failed ns loading results in this
-            // We try a system check version of load with NOENT for adobe
-            if(rdoc && strcmp(rdoc->root()->name(), "ns:svg") == 0) {
-                xmlFreeDoc( doc );
-                src.setFile(filename, true);
-                doc = src.readXml();
-                rdoc = sp_repr_do_read( doc, default_ns );
-            }
-        }
-    }
-
-
-    if ( doc ) {
-        xmlFreeDoc( doc );
-    }
-
-    if ( localFilename ) {
-        g_free( localFilename );
-    }
-
-    return rdoc;
-}
-
-/**
- * Reads and parses XML from a buffer, returning it as an Document
- */
-Document *sp_repr_read_mem (const gchar * buffer, gint length, const gchar *default_ns)
-{
-    xmlDocPtr doc;
-    Document * rdoc;
-
-    xmlSubstituteEntitiesDefault(1);
-
-    g_return_val_if_fail (buffer != NULL, NULL);
-
-    doc = xmlParseMemory (const_cast<gchar *>(buffer), length);
-
-    rdoc = sp_repr_do_read (doc, default_ns);
-    if (doc) {
-        xmlFreeDoc (doc);
-    }
-    return rdoc;
-}
-
-/**
- * Reads and parses XML from a buffer, returning it as an Document
- */
-Document *sp_repr_read_buf (const Glib::ustring &buf, const gchar *default_ns)
-{
-    return sp_repr_read_mem(buf.c_str(), buf.size(), default_ns);
-}
-
+#include <giomm/file.h>
+
+using namespace Inkscape::Util;
 
 namespace Inkscape {
 
-struct compare_quark_ids {
-    bool operator()(Glib::QueryQuark const &a, Glib::QueryQuark const &b) const {
-        return a.id() < b.id();
-    }
-};
-
-}
-
-namespace {
-
-typedef std::map<Glib::QueryQuark, Glib::QueryQuark, Inkscape::compare_quark_ids> PrefixMap;
-
-Glib::QueryQuark qname_prefix(Glib::QueryQuark qname) {
-    static PrefixMap prefix_map;
-    PrefixMap::iterator iter = prefix_map.find(qname);
-    if ( iter != prefix_map.end() ) {
-        return (*iter).second;
-    } else {
-        gchar const *name_string=g_quark_to_string(qname);
-        gchar const *prefix_end=strchr(name_string, ':');
-        if (prefix_end) {
-            Glib::Quark prefix=Glib::ustring(name_string, prefix_end);
-            prefix_map.insert(PrefixMap::value_type(qname, prefix));
-            return prefix;
-        } else {
-            return GQuark(0);
-        }
-    }
-}
-
-}
-
-namespace {
-
-void promote_to_namespace(Node *repr, const gchar *prefix) {
-    if ( repr->type() == Inkscape::XML::ELEMENT_NODE ) {
-        GQuark code = repr->code();
-        if (!qname_prefix(code).id()) {
-            gchar *svg_name = g_strconcat(prefix, ":", g_quark_to_string(code), NULL);
-            repr->setCodeUnsafe(g_quark_from_string(svg_name));
-            g_free(svg_name);
-        }
-        for ( Node *child = repr->firstChild() ; child ; child = child->next() ) {
-            promote_to_namespace(child, prefix);
-        }
-    }
-}
-
-}
-
-/**
- * Reads in a XML file to create a Document
- */
-Document *sp_repr_do_read (xmlDocPtr doc, const gchar *default_ns)
-{
-    if (doc == NULL) {
-        return NULL;
-    }
-    xmlNodePtr node=xmlDocGetRootElement (doc);
-    if (node == NULL) {
-        return NULL;
-    }
-
-    std::map<std::string, std::string> prefix_map;
-
-    Document *rdoc = new Inkscape::XML::SimpleDocument();
-
-    Node *root=NULL;
-    for ( node = doc->children ; node != NULL ; node = node->next ) {
-        if (node->type == XML_ELEMENT_NODE) {
-            Node *repr=sp_repr_svg_read_node(rdoc, node, default_ns, prefix_map);
-            rdoc->appendChild(repr);
-            Inkscape::GC::release(repr);
-
-            if (!root) {
-                root = repr;
-            } else {
-                root = NULL;
-                break;
-            }
-        } else if ( node->type == XML_COMMENT_NODE || node->type == XML_PI_NODE ) {
-            Node *repr=sp_repr_svg_read_node(rdoc, node, default_ns, prefix_map);
-            rdoc->appendChild(repr);
-            Inkscape::GC::release(repr);
-        }
-    }
-
-    if (root != NULL) {
-        /* promote elements of some XML documents that don't use namespaces
-         * into their default namespace */
-        if ( default_ns && !strchr(root->name(), ':') ) {
-            if ( !strcmp(default_ns, SP_SVG_NS_URI) ) {
-                promote_to_namespace(root, "svg");
-            }
-            if ( !strcmp(default_ns, INKSCAPE_EXTENSION_URI) ) {
-                promote_to_namespace(root, INKSCAPE_EXTENSION_NS_NC);
-            }
-        }
-
-
-        // Clean unnecessary attributes and style properties from SVG documents. (Controlled by
-        // preferences.)  Note: internal Inkscape svg files will also be cleaned (filters.svg,
-        // icons.svg). How can one tell if a file is internal?
-        if ( !strcmp(root->name(), "svg:svg" ) ) {
-            Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-            bool clean = prefs->getBool("/options/svgoutput/check_on_reading");
-            if( clean ) {
-                sp_attribute_clean_tree( root );
-            }
-        }
-    }
-
-    return rdoc;
-}
-
-gint sp_repr_qualified_name (gchar *p, gint len, xmlNsPtr ns, const xmlChar *name, const gchar */*default_ns*/, std::map<std::string, std::string> &prefix_map)
-{
-    const xmlChar *prefix;
-    if (ns){
-        if (ns->href ) {
-            prefix = reinterpret_cast<const xmlChar*>( sp_xml_ns_uri_prefix(reinterpret_cast<const gchar*>(ns->href),
-                                                                            reinterpret_cast<const char*>(ns->prefix)) );
-            prefix_map[reinterpret_cast<const char*>(prefix)] = reinterpret_cast<const char*>(ns->href);
-        }
-        else {
-            prefix = NULL;
-        }
-    }
-    else {
-        prefix = NULL;
-    }
-
-    if (prefix) {
-        return g_snprintf (p, len, "%s:%s", reinterpret_cast<const gchar*>(prefix), name);
-    } else {
-        return g_snprintf (p, len, "%s", name);
-    }
-}
-
-static Node *sp_repr_svg_read_node (Document *xml_doc, xmlNodePtr node, const gchar *default_ns, std::map<std::string, std::string> &prefix_map)
-{
-    xmlAttrPtr prop;
-    xmlNodePtr child;
-    gchar c[256];
-
-    if (node->type == XML_TEXT_NODE || node->type == XML_CDATA_SECTION_NODE) {
-
-        if (node->content == NULL || *(node->content) == '\0') {
-            return NULL; // empty text node
-        }
-
-        bool preserve = (xmlNodeGetSpacePreserve (node) == 1);
-
-        xmlChar *p;
-        for (p = node->content; *p && g_ascii_isspace (*p) && !preserve; p++)
-            ; // skip all whitespace
-
-        if (!(*p)) { // this is an all-whitespace node, and preserve == default
-            return NULL; // we do not preserve all-whitespace nodes unless we are asked to
-        }
-
-        // We keep track of original node type so that CDATA sections are preserved on output.
-        return xml_doc->createTextNode(reinterpret_cast<gchar *>(node->content),
-                                       node->type == XML_CDATA_SECTION_NODE );
-    }
-
-    if (node->type == XML_COMMENT_NODE) {
-        return xml_doc->createComment(reinterpret_cast<gchar *>(node->content));
-    }
-
-    if (node->type == XML_PI_NODE) {
-        return xml_doc->createPI(reinterpret_cast<const gchar *>(node->name),
-                                 reinterpret_cast<const gchar *>(node->content));
-    }
-
-    if (node->type == XML_ENTITY_DECL) {
-        return NULL;
-    }
-
-    sp_repr_qualified_name (c, 256, node->ns, node->name, default_ns, prefix_map);
-    Node *repr = xml_doc->createElement(c);
-    /* TODO remember node->ns->prefix if node->ns != NULL */
-
-    for (prop = node->properties; prop != NULL; prop = prop->next) {
-        if (prop->children) {
-            sp_repr_qualified_name (c, 256, prop->ns, prop->name, default_ns, prefix_map);
-            repr->setAttribute(c, reinterpret_cast<gchar*>(prop->children->content));
-            /* TODO remember prop->ns->prefix if prop->ns != NULL */
-        }
-    }
-
-    if (node->content) {
-        repr->setContent(reinterpret_cast<gchar*>(node->content));
-    }
-
-    for (child = node->xmlChildrenNode; child != NULL; child = child->next) {
-        Node *crepr = sp_repr_svg_read_node (xml_doc, child, default_ns, prefix_map);
-        if (crepr) {
-            repr->appendChild(crepr);
-            Inkscape::GC::release(crepr);
-        }
-    }
-
-    return repr;
-}
-
-
-static void sp_repr_save_writer(Document *doc, Inkscape::IO::Writer *out,
-                    gchar const *default_ns,
-                    gchar const *old_href_abs_base,
-                    gchar const *new_href_abs_base)
-{
+namespace XML {
+
+using namespace Inkscape::IO;
+
+static SVGParser _parser;
+
+static void clean_attributes(Document *doc) {
+    // Clean unnecessary attributes and style properties from SVG documents (controlled by preferences)
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
-    bool inlineattrs = prefs->getBool("/options/svgoutput/inlineattrs");
-    int indent = prefs->getInt("/options/svgoutput/indent", 2);
-
-    /* fixme: do this The Right Way */
-    out->writeString( "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n" );
-
-    const gchar *str = static_cast<Node *>(doc)->attribute("doctype");
-    if (str) {
-        out->writeString( str );
-    }
-
-    for (Node *repr = sp_repr_document_first_child(doc);
-         repr; repr = repr->next())
-    {
-        Inkscape::XML::NodeType const node_type = repr->type();
-        if ( node_type == Inkscape::XML::ELEMENT_NODE ) {
-            sp_repr_write_stream_root_element(repr, *out, TRUE, default_ns, inlineattrs, indent,
-                                              old_href_abs_base, new_href_abs_base);
-        } else {
-            sp_repr_write_stream(repr, *out, 0, TRUE, GQuark(0), inlineattrs, indent,
-                                 old_href_abs_base, new_href_abs_base);
-            if ( node_type == Inkscape::XML::COMMENT_NODE ) {
-                out->writeChar('\n');
-            }
-        }
-    }
-}
-
-
-Glib::ustring sp_repr_save_buf(Document *doc)
-{   
-    Inkscape::IO::StringOutputStream souts;
-    Inkscape::IO::OutputStreamWriter outs(souts);
-
-    sp_repr_save_writer(doc, &outs, SP_INKSCAPE_NS_URI, 0, 0);
-
-    outs.close();
-    Glib::ustring buf = souts.getString();
-
-    return buf;
-}
-
-
-void sp_repr_save_stream(Document *doc, FILE *fp, gchar const *default_ns, bool compress,
-                    gchar const *const old_href_abs_base,
-                    gchar const *const new_href_abs_base)
-{
-    Inkscape::URI dummy("x");
-    Inkscape::IO::UriOutputStream bout(fp, dummy);
-    Inkscape::IO::GzipOutputStream *gout = compress ? new Inkscape::IO::GzipOutputStream(bout) : NULL;
-    Inkscape::IO::OutputStreamWriter *out  = compress ? new Inkscape::IO::OutputStreamWriter( *gout ) : new Inkscape::IO::OutputStreamWriter( bout );
-
-    sp_repr_save_writer(doc, out, default_ns, old_href_abs_base, new_href_abs_base);
-
-    delete out;
-    delete gout;
-}
-
-
-
-/**
- * Returns true if file successfully saved.
- *
- * \param filename The actual file to do I/O to, which might be a temp file.
- *
- * \param for_filename The base URI [actually filename] to assume for purposes of rewriting
- *              xlink:href attributes.
- */
-bool sp_repr_save_rebased_file(Document *doc, gchar const *const filename, gchar const *default_ns,
-                          gchar const *old_base, gchar const *for_filename)
-{
-    if (!filename) {
-        return false;
-    }
-
-    bool compress;
-    {
-        size_t const filename_len = strlen(filename);
-        compress = ( filename_len > 5
-                     && strcasecmp(".svgz", filename + filename_len - 5) == 0 );
-    }
-
-    Inkscape::IO::dump_fopen_call( filename, "B" );
-    FILE *file = Inkscape::IO::fopen_utf8name(filename, "w");
-    if (file == NULL) {
-        return false;
-    }
-
-    Glib::ustring old_href_abs_base;
-    Glib::ustring new_href_abs_base;
-    if (for_filename) {
-        old_href_abs_base = calc_abs_doc_base(old_base);
-        if (Glib::path_is_absolute(for_filename)) {
-            new_href_abs_base = Glib::path_get_dirname(for_filename);
+    bool clean = prefs->getBool("/options/svgoutput/check_on_reading");
+    if(clean) {
+        sp_attribute_clean_tree(doc->root());
+    }
+}
+
+Document* read_svg_file(const Glib::ustring& filename, const bool& is_internal, const Glib::ustring& default_ns) {
+    if (!Inkscape::IO::file_test(filename.c_str(), G_FILE_TEST_EXISTS)) {
+        g_warning("Can't open file: %s (doesn't exist)", filename.c_str());
+        return nullptr;
+    }
+
+    Glib::RefPtr<Gio::File> file = Gio::File::create_for_path(filename);
+    Glib::RefPtr<Gio::FileInfo> info = file->query_info();
+    std::string content_type = info->get_content_type();
+
+    Document *doc;
+    if(content_type == "image/svg+xml" || content_type == "application/xml" || content_type == "text/html"
+            // Windows doesn't support mime type
+            || content_type == ".svg" || content_type == ".xml" || content_type == ".inx" || content_type == ".htm" || content_type == ".html") {
+        doc = _parser.parseFile(filename, default_ns);
+    } else if (content_type == "image/svg+xml-compressed" || content_type == "application/x-gzip"
+                // the same as above
+                || content_type == ".svgz") {
+        doc = _parser.parseCompressedFile(filename, default_ns);
+    } else {
+        g_warning("Unrecognized content type: %s.", content_type.c_str());
+        return nullptr;
+    }
+
+    if(!is_internal) {
+        clean_attributes(doc);
+    }
+    return doc;
+}
+
+Document* read_svg_buffer(const Glib::ustring& source, const bool& is_internal, const Glib::ustring& default_ns) {
+    Document *doc = _parser.parseBuffer(source, default_ns);
+    if(!is_internal) {
+        clean_attributes(doc);
+    }
+    return doc;
+}
+
+static void rebase_attributes(Node* node, const Glib::ustring& old_href_base, const Glib::ustring& new_href_base) {
+    for(auto iter = rebase_href_attrs(old_href_base.c_str(), new_href_base.c_str(), node->attributeList()); iter; ++iter) {
+        node->setAttribute(g_quark_to_string(iter->key), iter->value);
+    }
+
+    for (Node *child = node->firstChild(); child != nullptr; child = child->next()) {
+        if (child->type() == ELEMENT_NODE) {
+            rebase_attributes(child, old_href_base, new_href_base);
+        }
+    }
+}
+
+static void add_namespace_to_doc(Document* doc, const Glib::ustring& node_name) {
+    if (node_name.find(":") != Glib::ustring::npos) {
+        Glib::ustring prefix = node_name.substr(0, node_name.find(":"));
+        Glib::ustring extendedPrefix = "xmlns:" + prefix;
+        SimpleNode* root = dynamic_cast<SimpleNode*>(doc->root());
+        if (root->namespaces().find(g_quark_from_string(extendedPrefix.c_str())) == root->namespaces().end()
+                && prefix != "xml") {
+            root->setNamespace(extendedPrefix, sp_xml_ns_prefix_uri(prefix.c_str()));
+        }
+    }
+}
+
+static void find_all_prefixes(Document* doc, Node* node) {
+    add_namespace_to_doc(doc, node->name());
+    for (List<AttributeRecord const> iter = node->attributeList(); iter; ++iter) {
+        add_namespace_to_doc(doc, g_quark_to_string(iter->key));
+    }
+    for (Node *child = node->firstChild(); child != nullptr; child = child->next()) {
+        if (child->type() == ELEMENT_NODE) {
+            find_all_prefixes(doc, child);
+        }
+    }
+}
+
+static void serialize(Writer& writer, Document* doc, const Glib::ustring& default_ns, const Glib::ustring& old_base, const Glib::ustring& new_base) {
+    if (old_base != "") {
+        Glib::ustring old_href_abs_base = calc_abs_doc_base(old_base.c_str());
+        Glib::ustring new_href_abs_base;
+        if (Glib::path_is_absolute(new_base)) {
+            new_href_abs_base = Glib::path_get_dirname(new_base);
         } else {
             Glib::ustring const cwd = Glib::get_current_dir();
-            Glib::ustring const for_abs_filename = Glib::build_filename(cwd, for_filename);
+            Glib::ustring const for_abs_filename = Glib::build_filename(cwd, new_base);
             new_href_abs_base = Glib::path_get_dirname(for_abs_filename);
         }
-
-        /* effic: Once we're confident that we never need (or never want) to resort
-         * to using sodipodi:absref instead of the xlink:href value,
-         * then we should do `if streq() { free them and set both to NULL; }'. */
-    }
-    sp_repr_save_stream(doc, file, default_ns, compress, old_href_abs_base.c_str(), new_href_abs_base.c_str());
-
-    if (fclose (file) != 0) {
-        return false;
-    }
-
-    return true;
-}
-
-/**
- * Returns true iff file successfully saved.
- */
-bool sp_repr_save_file(Document *doc, gchar const *const filename, gchar const *default_ns)
-{
-    return sp_repr_save_rebased_file(doc, filename, default_ns, NULL, NULL);
-}
-
-
-/* (No doubt this function already exists elsewhere.) */
-static void repr_quote_write (Writer &out, const gchar * val)
-{
-    if (val) {
-        for (; *val != '\0'; val++) {
-            switch (*val) {
-                case '"': out.writeString( "&quot;" ); break;
-                case '&': out.writeString( "&amp;" ); break;
-                case '<': out.writeString( "&lt;" ); break;
-                case '>': out.writeString( "&gt;" ); break;
-                default: out.writeChar( *val ); break;
-            }
-        }
-    }
-}
-
-static void repr_write_comment( Writer &out, const gchar * val, bool addWhitespace, gint indentLevel, int indent )
-{
-    if ( indentLevel > 16 ) {
-        indentLevel = 16;
-    }
-    if (addWhitespace && indent) {
-        for (gint i = 0; i < indentLevel; i++) {
-            for (gint j = 0; j < indent; j++) {
-                out.writeString(" ");
-            }
-        }
-    }
-
-    out.writeString("<!--");
-    // WARNING out.printf() and out.writeString() are *NOT* non-ASCII friendly.
-    if (val) {
-        for (const gchar* cur = val; *cur; cur++ ) {
-            out.writeChar(*cur);
-        }
-    } else {
-        out.writeString(" ");
-    }
-    out.writeString("-->");
-
-    if (addWhitespace) {
-        out.writeString("\n");
-    }
-}
-
-namespace {
-
-typedef std::map<Glib::QueryQuark, gchar const *, Inkscape::compare_quark_ids> LocalNameMap;
-typedef std::map<Glib::QueryQuark, Inkscape::Util::ptr_shared<char>, Inkscape::compare_quark_ids> NSMap;
-
-gchar const *qname_local_name(Glib::QueryQuark qname) {
-    static LocalNameMap local_name_map;
-    LocalNameMap::iterator iter = local_name_map.find(qname);
-    if ( iter != local_name_map.end() ) {
-        return (*iter).second;
-    } else {
-        gchar const *name_string=g_quark_to_string(qname);
-        gchar const *prefix_end=strchr(name_string, ':');
-        if (prefix_end) {
-            return prefix_end + 1;
-        } else {
-            return name_string;
-        }
-    }
-}
-
-void add_ns_map_entry(NSMap &ns_map, Glib::QueryQuark prefix) {
-    using Inkscape::Util::ptr_shared;
-    using Inkscape::Util::share_unsafe;
-
-    static const Glib::QueryQuark xml_prefix("xml");
-
-    NSMap::iterator iter=ns_map.find(prefix);
-    if ( iter == ns_map.end() ) {
-        if (prefix.id()) {
-            gchar const *uri=sp_xml_ns_prefix_uri(g_quark_to_string(prefix));
-            if (uri) {
-                ns_map.insert(NSMap::value_type(prefix, share_unsafe(uri)));
-            } else if ( prefix != xml_prefix ) {
-                g_warning("No namespace known for normalized prefix %s", g_quark_to_string(prefix));
-            }
-        } else {
-            ns_map.insert(NSMap::value_type(prefix, ptr_shared<char>()));
-        }
-    }
-}
-
-void populate_ns_map(NSMap &ns_map, Node &repr) {
-    if ( repr.type() == Inkscape::XML::ELEMENT_NODE ) {
-        add_ns_map_entry(ns_map, qname_prefix(repr.code()));
-        for ( List<AttributeRecord const> iter=repr.attributeList() ;
-              iter ; ++iter )
-        {
-            Glib::QueryQuark prefix=qname_prefix(iter->key);
-            if (prefix.id()) {
-                add_ns_map_entry(ns_map, prefix);
-            }
-        }
-        for ( Node *child=repr.firstChild() ;
-              child ; child = child->next() )
-        {
-            populate_ns_map(ns_map, *child);
-        }
-    }
-}
-
-}
-
-static void sp_repr_write_stream_root_element(Node *repr, Writer &out,
-                                  bool add_whitespace, gchar const *default_ns,
-                                  int inlineattrs, int indent,
-                                  gchar const *const old_href_base,
-                                  gchar const *const new_href_base)
-{
-    using Inkscape::Util::ptr_shared;
-
-    g_assert(repr != NULL);
-
+        rebase_attributes(doc->root(), old_href_abs_base, new_href_abs_base);
+    }
+
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     // Clean unnecessary attributes and stype properties. (Controlled by preferences.)
-    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     bool clean = prefs->getBool("/options/svgoutput/check_on_writing");
-    if (clean) sp_attribute_clean_tree( repr );
+    if (clean) {
+        sp_attribute_clean_tree(doc->root());
+    }
+
+    // find all used prefixes
+    find_all_prefixes(doc, doc->root());
+    if (default_ns != "") {
+        doc->root()->setNamespace("xmlns", default_ns);
+    }
+    Glib::ustring defaultPrefix = sp_xml_ns_uri_prefix(default_ns.c_str(), "");
+
+    bool inlineAttributes = prefs->getBool("/options/svgoutput/inlineattrs");
+    int indent = prefs->getInt("/options/svgoutput/indent", 2);
 
     // Sort attributes in a canonical order (helps with "diffing" SVG files).
     bool sort = prefs->getBool("/options/svgoutput/sort_attributes");
-    if (sort) sp_attribute_sort_tree( repr );
-
-    Glib::QueryQuark xml_prefix=g_quark_from_static_string("xml");
-
-    NSMap ns_map;
-    populate_ns_map(ns_map, *repr);
-
-    Glib::QueryQuark elide_prefix=GQuark(0);
-    if ( default_ns && ns_map.find(GQuark(0)) == ns_map.end() ) {
-        elide_prefix = g_quark_from_string(sp_xml_ns_uri_prefix(default_ns, NULL));
-    }
-
-    List<AttributeRecord const> attributes=repr->attributeList();
-    for ( NSMap::iterator iter=ns_map.begin() ; iter != ns_map.end() ; ++iter ) 
-    {
-        Glib::QueryQuark prefix=(*iter).first;
-        ptr_shared<char> ns_uri=(*iter).second;
-
-        if (prefix.id()) {
-            if ( prefix != xml_prefix ) {
-                if ( elide_prefix == prefix ) {
-                    attributes = cons(AttributeRecord(g_quark_from_static_string("xmlns"), ns_uri), attributes);
-                }
-
-                Glib::ustring attr_name="xmlns:";
-                attr_name.append(g_quark_to_string(prefix));
-                GQuark key = g_quark_from_string(attr_name.c_str());
-                attributes = cons(AttributeRecord(key, ns_uri), attributes);
-            }
-        } else {
-            // if there are non-namespaced elements, we can't globally
-            // use a default namespace
-            elide_prefix = GQuark(0);
-        }
-    }
-
-    return sp_repr_write_stream_element(repr, out, 0, add_whitespace, elide_prefix, attributes,
-                                        inlineattrs, indent, old_href_base, new_href_base);
-}
-
-void sp_repr_write_stream( Node *repr, Writer &out, gint indent_level,
-                           bool add_whitespace, Glib::QueryQuark elide_prefix,
-                           int inlineattrs, int indent,
-                           gchar const *const old_href_base,
-                           gchar const *const new_href_base)
-{
-    switch (repr->type()) {
-        case Inkscape::XML::TEXT_NODE: {
-            if( dynamic_cast<const Inkscape::XML::TextNode *>(repr)->is_CData() ) {
-                // Preserve CDATA sections, not converting '&' to &amp;, etc.
-                out.printf( "<![CDATA[%s]]>", repr->content() );
-            } else {
-                repr_quote_write( out, repr->content() );
-            }
-            break;
-        }
-        case Inkscape::XML::COMMENT_NODE: {
-            repr_write_comment( out, repr->content(), add_whitespace, indent_level, indent );
-            break;
-        }
-        case Inkscape::XML::PI_NODE: {
-            out.printf( "<?%s %s?>", repr->name(), repr->content() );
-            break;
-        }
-        case Inkscape::XML::ELEMENT_NODE: {
-            sp_repr_write_stream_element( repr, out, indent_level,
-                                          add_whitespace, elide_prefix,
-                                          repr->attributeList(),
-                                          inlineattrs, indent,
-                                          old_href_base, new_href_base);
-            break;
-        }
-        case Inkscape::XML::DOCUMENT_NODE: {
-            g_assert_not_reached();
-            break;
-        }
-        default: {
-            g_assert_not_reached();
-        }
-    }
-}
-
-
-void sp_repr_write_stream_element( Node * repr, Writer & out,
-                                   gint indent_level, bool add_whitespace,
-                                   Glib::QueryQuark elide_prefix,
-                                   List<AttributeRecord const> attributes, 
-                                   int inlineattrs, int indent,
-                                   gchar const *old_href_base,
-                                   gchar const *new_href_base )
-{
-    Node *child = 0;
-    bool loose = false;
-
-    g_return_if_fail (repr != NULL);
-
-    if ( indent_level > 16 ) {
-        indent_level = 16;
-    }