Initial Import

1 files changed, 2139 insertions, 0 deletions

diff --git a/src/sablo.h b/src/sablo.h
new file mode 100644
index 0000000..99cfc40
--- /dev/null
+++ b/src/sablo.h
@@ -0,0 +1,2139 @@
+//
+// AUTHOR
+// N. Nielsen
+//
+// LICENSE
+// This software is in the public domain.
+//
+// The software is provided "as is", without warranty of any kind,
+// express or implied, including but not limited to the warranties
+// of merchantability, fitness for a particular purpose, and
+// noninfringement. In no event shall the author(s) be liable for any
+// claim, damages, or other liability, whether in an action of
+// contract, tort, or otherwise, arising from, out of, or in connection
+// with the software or the use or other dealings in the software.
+//
+// SUPPORT
+// Send bug reports to: <nielsen@memberwebs.com>
+//
+// SITE
+// http://memberwebs.com/nielsen/
+//
+
+// SABLOTRON C++ WRAPPER
+//
+//   This wrapper tries to emulate the W3C DOM as much as possible.
+// Objects returned can be copied liberally. When copied they still
+// refer to the original Sablotron classes.
+//   Almost all classes are "light" wrappers, and shouldn't be more
+// than 4 to 8 bytes a piece, with no additional memory allocation.
+//   Certain objects (NodeList, NamedNodeMap implementations) are
+// heavier, and are reference counted.
+//
+//   Salbotron uses UTF8 exclusively internally. This wrapper
+// supports on the fly conversions from UTF16. Define the following
+// constants to enable conversions:
+//
+// USE_UTF16
+//   Convert all data values from UTF16 to UTF8.
+//
+// DOM_UTF16
+//   Convert all DOM names from UTF16 to UTF8.
+//
+//   If either of the above two constants are enabled you must include
+// salbotr.cpp in your build.
+//
+//   Everything is in the DOM namespace.
+//
+//   Objects of type Document and DOMImplementation must be manually
+// freed with their 'release' member function.
+//
+//
+
+#ifndef __SABLO_H__
+#define __SABLO_H__
+
+#define USE_UTF16
+// #define DOM_UTF16
+
+#include <stdio.h>
+#include <wchar.h>
+#include <exception>
+#include <string>
+
+namespace DOM
+{
+	namespace S
+	{
+		extern "C"
+		{
+			#include <sablot.h>
+			#include <sdom.h>
+		}
+	};
+
+	bool transcode16to8(const std::basic_string<wchar_t>& data,
+						std::basic_string<char>& ret);
+	bool transcode8to16(const std::basic_string<char>& data,
+					    std::basic_string<wchar_t>& ret);
+
+	namespace INT
+	{
+		typedef std::basic_string<char> _8str;
+		typedef std::basic_string<wchar_t> _16str;
+	}
+
+#ifdef ASSERT
+	#define DOM_ASSERT ASSERT
+#else
+	#include "assert.h"
+	#define ASSERT assert
+#endif
+
+#ifdef USE_UTF16
+	#ifdef DOM_UTF16
+		typedef INT::_16str data_str;
+		typedef INT::_16str dom_str;
+		#define FROM_V(v) _16to8(v)
+		#define FROM_D(v) _16to8(v)
+		#define TO_V(v) _8to16(v)
+		#define TO_D(v) _8to16(v)
+	#else
+		typedef INT::_16str data_str;
+		typedef INT::_8str dom_str;
+		#define FROM_V(v) _16to8(v)
+		#define FROM_D(v) v
+		#define TO_V(v) _8to16(v)
+		#define TO_D(v) v
+	#endif
+#else
+	typedef INT::_8str data_str;
+	typedef INT::_8str dom_str;
+		#define FROM_V(v) v
+		#define FROM_D(v) v
+		#define TO_V(v) v
+		#define TO_D(v) v
+#endif
+
+	namespace INT
+	{
+		template<typename C>
+		class Ref
+		{
+		public:
+			Ref()
+				{ m_ptr = NULL; }
+
+			Ref(C* ptr)
+			{
+				m_ptr = ptr;
+				addref();
+			}
+
+			Ref(C* ptr, bool addref)
+			{
+				m_ptr = ptr;
+				if(addref)
+					addref();
+			}
+
+			~Ref()
+			{
+				release();
+			}
+
+			Ref(const Ref& orig)
+			{
+				m_ptr = orig.m_ptr;
+				addref();
+			}
+
+			Ref& operator=(const C* ptr)
+			{
+				C* old = m_ptr;
+				m_ptr = (C*)ptr;
+				addref();
+				if(old)
+					old->release();
+				return *this;
+			}
+
+			Ref& operator=(const Ref& orig)
+				{ return operator=(orig.m_ptr); }
+
+#ifdef COMPARE_REF
+			bool operator==(const C* ptr)
+			{
+				if(m_ptr == NULL && ptr == NULL)
+					return true;
+				else if(m_ptr == NULL || ptr == NULL)
+					return false;
+
+				return *ptr == *m_ptr;
+			}
+
+			bool operator==(const Ref& orig)
+				{ return operator==(orig.m_ptr); }
+#else
+			bool operator==(const C* ptr)
+			{
+				ASSERT(ptr == NULL);
+				return m_ptr == NULL;
+			}
+#endif
+			operator C*() const
+				{ return m_ptr; }
+
+			operator C&() const
+				{ return &m_ptr; }
+
+			C* operator->() const
+				{ return m_ptr; }
+
+		protected:
+			void release()
+			{
+				if(m_ptr)
+					m_ptr->release();
+				m_ptr = NULL;
+			}
+
+			void addref()
+			{
+				if(m_ptr)
+					m_ptr->addref();
+			}
+
+		private:
+			C* m_ptr;
+		};
+
+		class Inst
+		{
+		public:
+			Inst()
+				{ m_x = 0; }
+			virtual ~Inst()
+				{ }
+			void addref()
+				{ m_x++; }
+			void release()
+			{
+				if((--m_x) <= 0)
+					delete this;
+			}
+
+		private:
+			int m_x;
+		};
+
+		class Base;
+	};
+
+	#define ASSERT_VALID() \
+		ASSERT(isValid());
+	#define ASSERT_VALID_NODE(node) \
+		ASSERT(node.isValid());
+	#define ASSERT_TYPE(t) \
+		ASSERT(getNodeType() == t)
+	#define ASSERT_NODE_TYPE(n, t) \
+		ASSERT(n.getNodeType() == t)
+
+	class DOMException
+	{
+	public:
+		typedef enum
+		{
+			INDEX_SIZE_ERR = S::SDOM_INDEX_SIZE_ERR,
+			DOMSTRING_SIZE_ERR = S::SDOM_DOMSTRING_SIZE_ERR,
+			HIERARCHY_REQUEST_ERR = S::SDOM_HIERARCHY_REQUEST_ERR,
+			WRONG_DOCUMENT_ERR = S::SDOM_WRONG_DOCUMENT_ERR,
+			INVALID_CHARACTER_ERR = S::SDOM_INVALID_CHARACTER_ERR,
+			NO_DATA_ALLOWED_ERR = S::SDOM_NO_DATA_ALLOWED_ERR,
+			NO_MODIFICATION_ALLOWED_ERR = S::SDOM_NO_MODIFICATION_ALLOWED_ERR,
+			NOT_FOUND_ERR = S::SDOM_NOT_FOUND_ERR,
+			NOT_SUPPORTED_ERR = S::SDOM_NOT_SUPPORTED_ERR,
+			INUSE_ATTRIBUTE_ERR = S::SDOM_INUSE_ATTRIBUTE_ERR,
+			INVALID_STATE_ERR = S::SDOM_INVALID_STATE_ERR,
+			SYNTAX_ERR = S::SDOM_SYNTAX_ERR,
+			INVALID_MODIFICATION_ERR = S::SDOM_INVALID_MODIFICATION_ERR,
+			NAMESPACE_ERR = S::SDOM_NAMESPACE_ERR,
+			INVALID_ACCESS_ERR = S::SDOM_INVALID_ACCESS_ERR,
+			/* not in spec below this point: */
+			INVALID_NODE_TYPE = S::SDOM_INVALID_NODE_TYPE,
+			QUERY_PARSE_ERR = S::SDOM_QUERY_PARSE_ERR,
+			QUERY_EXECUTION_ERR = S::SDOM_QUERY_EXECUTION_ERR,
+			NOT_OK = S::SDOM_NOT_OK
+		} CODES;
+
+		int getCode()
+			{ return code; }
+		char* getMessage()
+			{ return S::SDOM_getExceptionMessage(m_sit); }
+		void getDetails(int* code, char** message,
+			            char** documentUri, int* fileLine)
+			{ S::SDOM_getExceptionDetails(m_sit, code, message, documentUri, fileLine); }
+
+		short code;
+
+	protected:
+		DOMException(S::SDOM_Exception e, S::SablotSituation s)
+		{
+			code = e;
+			m_sit = s;
+		}
+
+		S::SablotSituation m_sit;
+
+		friend class INT::Base;
+	};
+
+	namespace INT
+	{
+		/**
+		 * The base class that keeps references to sablo
+		 */
+		class Base
+		{
+		public:
+			bool operator==(const Base& other) const
+				{ return m_sit == other.m_sit; }
+			bool operator==(const void* null) const
+				{ ASSERT(null == NULL); return m_sit == NULL; };
+			bool operator!=(const Base& other) const
+				{ return !operator==(other); }
+			bool operator!=(const void* null) const
+				{ return !operator==(null); }
+
+		protected:
+			Base(S::SablotSituation sit)
+				{ m_sit = sit; }
+			Base(const Base& base)
+				{ m_sit = base.m_sit; }
+			Base& operator=(const Base& other)
+				{ m_sit = other.m_sit; return *this; }
+			Base& operator=(const void* null)
+				{ ASSERT(null == NULL); m_sit = NULL; return *this; }
+			inline bool isValid() const
+				{ return m_sit != NULL; }
+
+			inline S::SDOM_Exception _try_(S::SDOM_Exception e) const
+				throw(DOMException)
+			{
+				if(e != S::SDOM_OK)
+					throw DOMException(e, m_sit);
+				return e;
+			}
+
+#ifdef USE_UTF16
+			inline _16str _8to16(const _8str& d) const
+				throw(DOMException)
+			{
+				_16str s;
+				if(!transcode8to16(d, s))
+					throw DOMException(S::SDOM_INVALID_CHARACTER_ERR, m_sit);
+				return s;
+			}
+
+			inline _8str _16to8(const _16str& d) const
+				throw(DOMException)
+			{
+				_8str s;
+				if(!transcode16to8(d, s))
+					throw DOMException(S::SDOM_INVALID_CHARACTER_ERR, m_sit);
+				return s;
+			}
+#endif
+
+			S::SablotSituation m_sit;
+		};
+
+		class NamedNodeMap;
+		class NodeList;
+		class ChildNodeList;
+		class AttrNodeList;
+		class DOMNodeList;
+		class AttrNamedNodeMap;
+	}
+
+	class Element;
+	class Document;
+	class DOMImplementation;
+
+	typedef INT::Ref<INT::NamedNodeMap> NamedNodeMap;
+	typedef INT::Ref<INT::NodeList> NodeList;
+
+	/**
+	 * Thin wrapper class for a DOM Node
+	 */
+	class Node :
+		public INT::Base
+	{
+	public:
+		enum TYPES
+		{
+			 ELEMENT_NODE = S::SDOM_ELEMENT_NODE,
+			 ATTRIBUTE_NODE = S::SDOM_ATTRIBUTE_NODE,
+			 TEXT_NODE = S::SDOM_TEXT_NODE,
+			 CDATA_SECTION_NODE = S::SDOM_CDATA_SECTION_NODE,
+			 ENTITY_REFERENCE_NODE = S::SDOM_ENTITY_REFERENCE_NODE,
+			 ENTITY_NODE = S::SDOM_ENTITY_NODE,
+			 PROCESSING_INSTRUCTION_NODE = S::SDOM_PROCESSING_INSTRUCTION_NODE,
+			 COMMENT_NODE = S::SDOM_COMMENT_NODE,
+			 DOCUMENT_NODE = S::SDOM_DOCUMENT_NODE,
+			 DOCUMENT_TYPE_NODE = S::SDOM_DOCUMENT_TYPE_NODE,
+			 DOCUMENT_FRAGMENT_NODE = S::SDOM_DOCUMENT_FRAGMENT_NODE,
+			 NOTATION_NODE = S::SDOM_NOTATION_NODE
+		};
+
+		Node() : INT::Base(NULL)
+		{
+			m_node = NULL;
+		}
+
+		Node(const Node& node)
+			: INT::Base(node)
+		{
+			m_node = node.m_node;
+		}
+
+	    Node& operator=(const Node& other)
+		{
+			Base::operator=(other);
+			m_node = other.m_node;
+			return *this;
+		}
+
+		Node& operator=(const void* null)
+		{
+			ASSERT(null == NULL);
+			Base::operator=(null);
+			m_node = NULL;
+			return *this;
+		}
+
+		bool operator==(const Node& other) const
+		{
+			return Base::operator==(other) &&
+				m_node == other.m_node;
+		}
+
+		bool operator==(const void* null) const
+		{
+			ASSERT(null == NULL);
+			return Base::operator==(null) ||
+				m_node == NULL;
+		}
+
+		bool operator!=(const Node& other) const
+			{ return !operator==(other); }
+
+		bool operator!=(const void* null) const
+			{ return !operator==(null); }
+
+		const Node* operator->() const
+			{ return (const Node*)this; }
+		Node* operator->()
+			{ return this; }
+
+		dom_str getNodeName() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_char* name;
+			_try_(S::SDOM_getNodeName(m_sit, m_node, &name));
+			return TO_D(INT::_8str(name));
+		}
+
+		data_str getNodeValue() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_char* value;
+			_try_(S::SDOM_getNodeValue(m_sit, m_node, &value));
+			return TO_V(INT::_8str(value));
+		}
+
+		void setNodeValue(const data_str& value)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			_try_(S::SDOM_setNodeValue(m_sit, m_node, FROM_V(value).c_str()));
+		}
+
+		short getNodeType() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_NodeType type;
+			_try_(S::SDOM_getNodeType(m_sit, m_node, &type));
+			return (short)type;
+		}
+
+		Node getParentNode() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_Node parent;
+			_try_(S::SDOM_getParentNode(m_sit, m_node, &parent));
+			return Node(m_sit, parent);
+		}
+
+		NodeList getChildNodes() const
+			throw(DOMException);
+
+		Node getFirstChild() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_Node child;
+			_try_(S::SDOM_getFirstChild(m_sit, m_node, &child));
+			return Node(m_sit, child);
+		}
+
+		Node getLastChild() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_Node child;
+			_try_(S::SDOM_getLastChild(m_sit, m_node, &child));
+			return Node(m_sit, child);
+		}
+
+		Node getPreviousSibling() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_Node sib;
+			_try_(S::SDOM_getPreviousSibling(m_sit, m_node, &sib));
+			return Node(m_sit, sib);
+		}
+
+		Node getNextSibling() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_Node sib;
+			_try_(S::SDOM_getNextSibling(m_sit, m_node, &sib));
+			return Node(m_sit, sib);
+		}
+
+		NamedNodeMap getAttributes() const
+			throw(DOMException);
+
+		Document getOwnerDocument() const
+			throw(DOMException);
+
+		Node insertBefore(const Node& newChild, const Node& refChild)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(newChild);
+			ASSERT_VALID_NODE(refChild);
+			_try_(S::SDOM_insertBefore(m_sit, m_node, newChild.m_node, refChild.m_node));
+			return newChild;
+		}
+
+		Node replaceChild(const Node& newChild, const Node& refChild)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(newChild);
+			ASSERT_VALID_NODE(refChild);
+			_try_(S::SDOM_replaceChild(m_sit, m_node, newChild.m_node, refChild.m_node));
+			return newChild;
+		}
+
+		Node removeChild(const Node& oldChild)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(oldChild);
+			_try_(S::SDOM_removeChild(m_sit, m_node, oldChild.m_node));
+			return oldChild;
+		}
+
+		Node appendChild(const Node& newChild)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(newChild);
+			_try_(S::SDOM_appendChild(m_sit, m_node, newChild.m_node));
+			return newChild;
+		}
+
+		bool hasChildNodes() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			int count = 0;
+			_try_(S::SDOM_getChildNodeCount(m_sit, m_node, &count));
+			return count != 0;
+		}
+
+		Node cloneNode(bool deep) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_Node node;
+			_try_(S::SDOM_cloneNode(m_sit, m_node, deep ? 1 : 0, &node));
+			return Node(m_sit, node);
+		}
+
+		void normalize()
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+		}
+
+		bool isSupported(const dom_str& feature,
+						 const dom_str& version) const
+		{
+			ASSERT_VALID();
+			return false;
+		}
+
+		dom_str getNamespaceURI() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_char* uri;
+			_try_(S::SDOM_getNodeNSUri(m_sit, m_node, &uri));
+			return TO_D(INT::_8str(uri));
+		}
+
+		dom_str getPrefix() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_char* prefix;
+			_try_(S::SDOM_getNodePrefix(m_sit, m_node, &prefix));
+			return TO_D(INT::_8str(prefix));
+		}
+
+		void setPrefix(const dom_str& prefix)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+		}
+
+		dom_str getLocalName() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_char* name;
+			_try_(S::SDOM_getNodeLocalName(m_sit, m_node, &name));
+			return TO_D(INT::_8str(name));
+		}
+
+		bool hasAttributes() const
+			throw (DOMException)
+		{
+			ASSERT_VALID();
+
+			if(getNodeType() != ELEMENT_NODE)
+				return false;
+
+			int count = 0;
+			_try_(S::SDOM_getAttributeNodeCount(m_sit, m_node, &count));
+			return count != 0;
+		}
+
+		void* setUserData(void* data)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			void* old = S::SDOM_getNodeInstanceData(m_node);
+			S::SDOM_setNodeInstanceData(m_node, data);
+			return old;
+		}
+
+		void* getUserData() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			return S::SDOM_getNodeInstanceData(m_node);
+		}
+
+		std::string serialize() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_Document doc;
+			_try_(S::SDOM_getOwnerDocument(m_sit, m_node, &doc));
+			S::SDOM_char* serialized;
+			_try_(S::SDOM_nodeToString(m_sit, doc, m_node, &serialized));
+			std::string ret(serialized);
+			S::SablotFree(serialized);
+			return ret;
+		}
+
+		bool isValid() const
+		{
+			return Base::isValid() &&
+				m_node != NULL;
+		}
+
+	protected:
+		Node(S::SablotSituation sit, S::SDOM_Node node) :
+				INT::Base(sit) { m_node = node; }
+
+	protected:
+		S::SDOM_Node m_node;
+
+		friend class Document;
+		friend class INT::ChildNodeList;
+		friend class INT::AttrNodeList;
+		friend class INT::DOMNodeList;
+		friend class INT::AttrNamedNodeMap;
+	};
+
+	class Attr :
+		public Node
+	{
+	public:
+		Attr() { }
+		Attr(const Attr& node) :
+			Node(node) { }
+
+	    Attr& operator=(const Attr& other)
+			{ Node::operator=(other); return *this; }
+		Attr& operator=(const void* null)
+			{ Node::operator=(null); return *this; }
+		const Attr* operator->() const
+			{ return (const Attr*)this; }
+		Attr* operator->()
+			{ return this; }
+
+		dom_str getName() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ATTRIBUTE_NODE);
+			return getNodeName();
+		}
+
+		Element getOwnerElement() const
+			throw(DOMException);
+
+		bool getSpecified() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ATTRIBUTE_NODE);
+			return true;
+		}
+
+		data_str getValue() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ATTRIBUTE_NODE);
+			return getNodeValue();
+		}
+
+		void setValue(const data_str& value)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ATTRIBUTE_NODE);
+			setNodeValue(value);
+		}
+
+	protected:
+		Attr(S::SablotSituation sit, S::SDOM_Node node) :
+			 Node(sit, node) { }
+
+		friend class Element;
+		friend class Document;
+	};
+
+	/**
+	 * This wrapper class for an element
+	 */
+	class Element :
+		public Node
+	{
+	public:
+		Element() { }
+		Element(const Element& node) :
+			Node(node) {}
+
+	    Element& operator=(const Element& other)
+			{ Node::operator=(other); return *this; }
+		Element& operator=(const void* null)
+			{ Node::operator=(null); return *this; }
+		const Element* operator->() const
+			{ return (const Element*)this; }
+		Element* operator->()
+			{ return this; }
+
+		dom_str getTagName() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+			return getNodeName();
+		}
+
+		data_str getAttribute(const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+			S::SDOM_char* value;
+			_try_(S::SDOM_getAttribute(m_sit, m_node, FROM_D(name).c_str(), &value));
+			return TO_V(INT::_8str(value));
+		}
+
+		void setAttribute(const dom_str& name, const data_str& value)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+			_try_(S::SDOM_setAttribute(m_sit, m_node, FROM_D(name).c_str(),
+									   FROM_V(value).c_str()));
+		}
+
+		void removeAttribute(const dom_str& name)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+			_try_(S::SDOM_removeAttribute(m_sit, m_node, FROM_D(name).c_str()));
+		}
+
+		Attr getAttributeNode(const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+			S::SDOM_Node attr;
+			_try_(S::SDOM_getAttributeNode(m_sit, m_node, FROM_D(name).c_str(), &attr));
+			return Attr(m_sit, attr);
+		}
+
+		Attr setAttributeNode(const Attr& attr)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(attr);
+			ASSERT_TYPE(ELEMENT_NODE);
+			S::SDOM_Node repl;
+			_try_(S::SDOM_setAttributeNode(m_sit, m_node, attr.m_node, &repl));
+			return Attr(m_sit, repl);
+		}
+
+		Attr removeAttributeNode(const Attr& attr)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(attr);
+			ASSERT_TYPE(ELEMENT_NODE);
+			S::SDOM_Node rem;
+			_try_(S::SDOM_removeAttributeNode(m_sit, m_node, attr.m_node, &rem));
+			return Attr(m_sit, rem);
+		}
+
+		NodeList getElementsByTagName(const dom_str& name) const
+			throw(DOMException);
+
+		data_str getAttributeNS(const dom_str& uri, const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+			S::SDOM_char* value;
+			_try_(S::SDOM_getAttributeNS(m_sit, m_node, (char*)FROM_D(uri).c_str(),
+										 (char*)FROM_D(name).c_str(), &value));
+			return TO_V(INT::_8str(value));
+		}
+
+		void setAttributeNS(const dom_str& uri, const dom_str& name,
+							const data_str& value)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+			_try_(S::SDOM_setAttributeNS(m_sit, m_node, FROM_D(uri).c_str(),
+									     FROM_D(name).c_str(), FROM_V(value).c_str()));
+		}
+
+		void removeAttributeNS(const dom_str& uri, const dom_str& name)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+			DOM::Attr attr = getAttributeNodeNS(uri, name);
+			if(attr != NULL)
+				removeAttributeNode(attr);
+		}
+
+		Attr getAttributeNodeNS(const dom_str& uri, const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+			S::SDOM_Node attr;
+			_try_(S::SDOM_getAttributeNodeNS(m_sit, m_node, (char*)FROM_D(uri).c_str(),
+											 (char*)FROM_D(name).c_str(), &attr));
+			return Attr(m_sit, attr);
+		}
+
+		Attr setAttributeNodeNS(const Attr& attr)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_VALID_NODE(attr);
+			ASSERT_TYPE(ELEMENT_NODE);
+			S::SDOM_Node repl;
+			_try_(S::SDOM_setAttributeNodeNS(m_sit, m_node, attr.m_node, &repl));
+			return Attr(m_sit, repl);
+		}
+
+		NodeList getElementsByTagNameNS(const dom_str& uri,
+										const dom_str& name) const
+			throw(DOMException);
+
+		bool hasAttribute(const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+			return getAttributeNode(name) != NULL;
+		}
+
+		bool hasAttributeNS(const dom_str& uri, const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ELEMENT_NODE);
+			return getAttributeNodeNS(uri, name) != NULL;
+		}
+
+	protected:
+		Element(S::SablotSituation sit, S::SDOM_Node node) :
+			 Node(sit, node) { }
+
+		friend class Attr;
+		friend class Document;
+	};
+
+
+	class CharacterData :
+		public Node
+	{
+	public:
+		CharacterData() { }
+		CharacterData(const Node& node) :
+			Node(node) { }
+
+	    CharacterData& operator=(const CharacterData& other)
+			{ Node::operator=(other); return *this; }
+		CharacterData& operator=(const void* null)
+			{ Node::operator=(null); return *this; }
+		const CharacterData* operator->() const
+			{ return (const CharacterData*)this; }
+		CharacterData* operator->()
+			{ return this; }
+
+		void appendData(const data_str& data)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+			data_str val = getNodeValue();
+			val.append(data);
+			setNodeValue(val);
+		}
+
+		void deleteData(int offset, int count)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+			data_str val = getNodeValue();
+			val.erase(offset, count);
+			setNodeValue(val);
+		}
+
+		data_str getData() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+			return getNodeValue();
+		}
+
+		int getLength() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+			return getNodeValue().size();
+		}
+
+		void insertData(int offset, const data_str& data)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+			data_str val = getNodeValue();
+			val.insert(offset, data);
+			setNodeValue(val);
+		}
+
+		void replaceData(int offset, int count, const data_str& arg)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+			data_str val = getNodeValue();
+			val.erase(offset, count);
+			val.insert(offset, arg);
+			setNodeValue(val);
+		}
+
+		void setData(const data_str& data)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+			setNodeValue(data);
+		}
+
+		data_str substringData(int offset, int count) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT(getNodeType() == TEXT_NODE ||
+				   getNodeType() == CDATA_SECTION_NODE ||
+				   getNodeType() == COMMENT_NODE);
+			data_str val = getNodeValue();
+			return val.substr(offset, count);
+		}
+
+	protected:
+		CharacterData(S::SablotSituation sit, S::SDOM_Node node) :
+			 Node(sit, node) { }
+	};
+
+	class Text :
+		public CharacterData
+	{
+	public:
+		Text() { }
+		Text(const Node& node) :
+			CharacterData(node) { }
+
+		Text& operator=(const Text& other)
+			{ CharacterData::operator=(other); return *this; }
+		Text& operator=(const void* null)
+			{ CharacterData::operator=(null); return *this; }
+		const Text* operator->() const
+			{ return (const Text*)this; }
+		Text* operator->()
+			{ return this; }
+
+		Text splitText(int offset)
+			throw(DOMException);
+
+	protected:
+		Text(S::SablotSituation sit, S::SDOM_Node node) :
+			 CharacterData(sit, node) { }
+
+		friend class Document;
+	};
+
+	class CDATASection :
+		public Text
+	{
+	public:
+		CDATASection() { }
+		CDATASection(const CDATASection& node) :
+			Text(node) { }
+
+		CDATASection& operator=(const CDATASection& other)
+			{ Text::operator=(other); return *this; }
+		CDATASection& operator=(void* null)
+			{ Text::operator=(null); return *this; }
+		const CDATASection* operator->() const
+			{ return (const CDATASection*)this; }
+		CDATASection* operator->()
+			{ return this; }
+
+	protected:
+		CDATASection(S::SablotSituation sit, S::SDOM_Node node) :
+			 Text(sit, node) { }
+
+		friend class Document;
+	};
+
+	class Comment :
+		public CharacterData
+	{
+	public:
+		Comment() { }
+		Comment(const Comment& node) :
+			CharacterData(node) { }
+
+		Comment& operator=(const Comment& other)
+			{ CharacterData::operator=(other); return *this; }
+		Comment& operator=(void* null)
+			{ CharacterData::operator=(null); return *this; }
+		const Comment* operator->() const
+			{ return (const Comment*)this; }
+		Comment* operator->()
+			{ return this; }
+
+	protected:
+		Comment(S::SablotSituation sit, S::SDOM_Node node) :
+			 CharacterData(sit, node) { }
+
+		friend class Document;
+	};
+
+	class ProcessingInstruction :
+		public Node
+	{
+	public:
+		ProcessingInstruction() { }
+		ProcessingInstruction(const ProcessingInstruction& node) :
+			Node(node) { }
+
+		ProcessingInstruction& operator=(const ProcessingInstruction& other)
+			{ Node::operator=(other); return *this; }
+		ProcessingInstruction& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const ProcessingInstruction* operator->() const
+			{ return (const ProcessingInstruction*)this; }
+		ProcessingInstruction* operator->()
+			{ return this; }
+
+		data_str getData() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(PROCESSING_INSTRUCTION_NODE);
+			return getNodeValue();
+		}
+
+		dom_str getTarget() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(PROCESSING_INSTRUCTION_NODE);
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+			return dom_str();
+		}
+
+		void setData(const data_str& data)
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(PROCESSING_INSTRUCTION_NODE);
+			setNodeValue(data);
+		}
+
+	protected:
+		ProcessingInstruction(S::SablotSituation sit, S::SDOM_Node node) :
+			 Node(sit, node) { }
+
+		friend class Document;
+	};
+
+	class DocumentFragment :
+		public Node
+	{
+	public:
+		DocumentFragment() { }
+		DocumentFragment(const DocumentFragment& node) :
+			Node(node) { }
+
+		DocumentFragment& operator=(const DocumentFragment& other)
+			{ Node::operator=(other); return *this; }
+		DocumentFragment& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const DocumentFragment* operator->() const
+			{ return (const DocumentFragment*)this; }
+		DocumentFragment* operator->()
+			{ return this; }
+	};
+
+	class Entity :
+		public Node
+	{
+	public:
+		Entity() { }
+		Entity(const Entity& node) :
+			Node(node) { }
+
+		Entity& operator=(const Entity& other)
+			{ Node::operator=(other); return *this; }
+		Entity& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const Entity* operator->() const
+			{ return (const Entity*)this; }
+		Entity* operator->()
+			{ return this; }
+
+		dom_str getNotationName() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ENTITY_NODE);
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+			return dom_str();
+		}
+
+		dom_str getPublicId() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ENTITY_NODE);
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+			return dom_str();
+		}
+
+		dom_str getSystemId() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(ENTITY_NODE);
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+			return dom_str();
+		}
+	};
+
+	class EntityReference :
+		public Node
+	{
+	public:
+		EntityReference() { }
+		EntityReference(const EntityReference& node) :
+			Node(node) { }
+
+		EntityReference& operator=(const EntityReference& other)
+			{ Node::operator=(other); return *this; }
+		EntityReference& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const EntityReference* operator->() const
+			{ return (const EntityReference*)this; }
+		EntityReference* operator->()
+			{ return this; }
+	};
+
+	class Notation :
+		public Node
+	{
+	public:
+		Notation() { }
+		Notation(const Notation& node) :
+			Node(node) { }
+
+		Notation& operator=(const Notation& other)
+			{ Node::operator=(other); return *this; }
+		Notation& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const Notation* operator->() const
+			{ return (const Notation*)this; }
+		Notation* operator->()
+			{ return this; }
+
+		dom_str getPublicId() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(NOTATION_NODE);
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+			return dom_str();
+		}
+
+		dom_str getSystemId() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(NOTATION_NODE);
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+			return dom_str();
+		}
+	};
+
+	class DocumentType :
+		public Node
+	{
+	public:
+		DocumentType() { }
+		DocumentType(const DocumentType& node) :
+			Node(node) { }
+
+		DocumentType& operator=(const DocumentType& other)
+			{ Node::operator=(other); return *this; }
+		DocumentType& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const DocumentType* operator->() const
+			{ return (const DocumentType*)this; }
+		DocumentType* operator->()
+			{ return this; }
+
+		NamedNodeMap getEntities() const
+			throw(DOMException);
+
+		dom_str getInternalSubset() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+			return dom_str();
+		}
+
+		dom_str getName() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+			return dom_str();
+		}
+
+		NamedNodeMap getNotations() const
+			throw(DOMException);
+	};
+
+
+	class Document :
+		public Node
+	{
+	public:
+		Document() { }
+		Document(const Document& doc) :
+			Node(doc) { }
+		Document(S::SablotSituation sit, S::SDOM_Document doc) :
+			Node(sit, NULL) { m_node = doc; }
+
+		Document& operator=(const Document& other)
+			{ Node::operator=(other); return *this; }
+		Document& operator=(void* null)
+			{ Node::operator=(null); return *this; }
+		const Document* operator->() const
+			{ return (const Document*)this; }
+		Document* operator->()
+			{ return this; }
+
+		DocumentType getDocType() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			return DocumentType();
+		}
+
+		DOMImplementation getImplementation() const
+			throw(DOMException);
+
+		Element getDocumentElement() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			S::SDOM_Node child;
+			_try_(S::SDOM_getFirstChild(m_sit, m_node, &child));
+			return Element(m_sit, child);
+		}
+
+		Element createElement(const dom_str& tag) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			S::SDOM_Node el;
+			_try_(S::SDOM_createElement(m_sit, (S::SDOM_Document)m_node,
+									 &el, FROM_D(tag).c_str()));
+			return Element(m_sit, el);
+		}
+
+		DocumentFragment createDocumentFragment() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+			return DocumentFragment();
+		}
+
+		Text createTextNode(const data_str& data) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			S::SDOM_Node text;
+			_try_(S::SDOM_createTextNode(m_sit, (S::SDOM_Document)m_node,
+									  &text, FROM_V(data).c_str()));
+			return Text(m_sit, text);
+		}
+
+		Comment createComment(const data_str& data) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			S::SDOM_Node comment;
+			_try_(S::SDOM_createComment(m_sit, (S::SDOM_Document)m_node,
+									 &comment, FROM_V(data).c_str()));
+			return Comment(m_sit, comment);
+		}
+
+		CDATASection createCDATASection(const data_str& data) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			S::SDOM_Node cdata;
+			_try_(S::SDOM_createCDATASection(m_sit, (S::SDOM_Document)m_node,
+										  &cdata, FROM_V(data).c_str()));
+			return CDATASection(m_sit, cdata);
+		}
+
+		ProcessingInstruction createProcessingInstruction(const dom_str& targ,
+														  const data_str& data) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			S::SDOM_Node pi;
+			_try_(S::SDOM_createProcessingInstruction(m_sit,
+												   (S::SDOM_Document)m_node,
+													&pi, FROM_D(targ).c_str(),
+													FROM_V(data).c_str()));
+			return ProcessingInstruction(m_sit, pi);
+		}
+
+		Attr createAttribute(const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			S::SDOM_Node attr;
+			_try_(S::SDOM_createAttribute(m_sit, (S::SDOM_Document)m_node,
+									   &attr, FROM_D(name).c_str()));
+			return Attr(m_sit, attr);
+		}
+
+		EntityReference createEntityReference()
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+			return EntityReference();
+		}
+
+		NodeList getElementsByTagName(const dom_str& name) const
+			throw(DOMException);
+
+		Node importNode(const Node& import, bool deep) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			ASSERT_VALID_NODE(import);
+			S::SDOM_Node imported;
+			_try_(S::SDOM_cloneForeignNode(m_sit, (S::SDOM_Document)m_node,
+										   import.m_node, deep ? 1 : 0, &imported));
+			return Node(m_sit, imported);
+		}
+
+		Element createElementNS(const dom_str& uri, const dom_str& tag) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			S::SDOM_Node el;
+			_try_(S::SDOM_createElementNS(m_sit, (S::SDOM_Document)m_node,
+										  &el, FROM_D(uri).c_str(), FROM_D(tag).c_str()));
+			return Element(m_sit, el);
+		}
+
+		Attr createAttributeNS(const dom_str& uri, const dom_str& name) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			S::SDOM_Node attr;
+			_try_(S::SDOM_createAttributeNS(m_sit, (S::SDOM_Document)m_node,
+											&attr, FROM_D(uri).c_str(), FROM_D(name).c_str()));
+			return Attr(m_sit, attr);
+		}
+
+		NodeList getElementsByTagNameNS(const dom_str& uri,
+										const dom_str& name) const
+			throw(DOMException);
+
+		Element getElementById(const dom_str& id) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			dom_str query = "//*[id('" + id + "')]";
+			S::SDOM_NodeList result;
+			_try_(S::SDOM_xql(m_sit, FROM_D(query).c_str(), m_node, &result));
+
+			int length;
+			_try_(S::SDOM_getNodeListLength(m_sit, result, &length));
+
+			Element ret;
+			if(length != 1)
+			{
+				ret = Element();
+			}
+			else
+			{
+				S::SDOM_Node el;
+				_try_(S::SDOM_getNodeListItem(m_sit, result, 0, &el));
+				ret = Element(m_sit, el);
+			}
+
+			S::SDOM_disposeNodeList(m_sit, result);
+			return ret;
+		}
+
+		std::string serialize() const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			S::SDOM_char* serialized;
+			_try_(S::SDOM_docToString(m_sit, (S::SDOM_Document)m_node, &serialized));
+			std::string ret(serialized);
+			S::SablotFree(serialized);
+			return ret;
+		}
+
+		void release()
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			ASSERT_TYPE(DOCUMENT_NODE);
+			S::SDOM_tmpListDump((S::SDOM_Document)m_node, 0);
+			if(S::SablotDestroyDocument(m_sit, (S::SDOM_Document)m_node))
+				_try_(S::SDOM_NOT_OK);
+			*this = NULL;
+		}
+
+	protected:
+
+		friend class Node;
+		friend class DOMImplementation;
+	};
+
+
+	class DOMImplementation :
+		public INT::Base
+	{
+	public:
+		DOMImplementation()
+			throw(DOMException) : INT::Base(NULL)
+		{
+			if(S::SablotCreateSituation(&m_sit))
+				_try_(S::SDOM_NOT_OK);
+		}
+		DOMImplementation(S::SablotSituation sit)
+			throw(DOMException) : INT::Base(sit) { }
+		DOMImplementation(const DOMImplementation& impl) :
+			INT::Base(impl) { }
+
+		DOMImplementation& operator=(const DOMImplementation& other)
+			{ Base::operator=(other); return *this; }
+		DOMImplementation& operator=(void* null)
+			{ Base::operator=(null); return *this; }
+		const DOMImplementation* operator->() const
+			{ return (const DOMImplementation*)this; }
+		DOMImplementation* operator->()
+			{ return this; }
+
+		Document createDocument(const dom_str& uri, const dom_str& qname,
+								const DocumentType& type) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			S::SDOM_Document doc;
+			if(S::SablotCreateDocument(m_sit, &doc))
+				_try_(S::SDOM_NOT_OK);
+
+			Document document(m_sit, doc);
+
+			if(!qname.empty())
+			{
+				if(!uri.empty())
+					document.appendChild(document.createElementNS(uri, qname));
+				else
+					document.appendChild(document.createElement(qname));
+			}
+
+			return document;
+		}
+
+		DocumentType createDocumentType(const dom_str& qname,
+									    const dom_str& publicId,
+										const dom_str& systemId) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			_try_(S::SDOM_NOT_SUPPORTED_ERR);
+			return DocumentType();
+		}
+
+		bool hasFeature(const dom_str& feature, const dom_str& version) const
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			return false;
+		}
+
+		void release()
+			throw(DOMException)
+		{
+			ASSERT_VALID();
+			if(S::SablotDestroySituation(m_sit))
+				_try_(S::SDOM_NOT_OK);
+		}
+	};
+
+	namespace INT
+	{
+		class NodeList :
+			public INT::Base,
+			public INT::Inst
+		{
+		public:
+#ifdef COMPARE_REF
+			virtual bool operator==(const NodeList& other) const
+				{ return Base::operator==(other); }
+#endif
+			virtual int getLength() const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				_try_(S::SDOM_NOT_SUPPORTED_ERR);
+				return 0;
+			}
+
+			virtual Node item(int index) const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				_try_(S::SDOM_NOT_SUPPORTED_ERR);
+				return Node();
+			}
+
+		protected:
+			NodeList(S::SablotSituation sit) :
+				 INT::Base(sit) { }
+
+			virtual bool isValid() const
+			{
+				return false;
+			}
+
+		private:
+			NodeList(const NodeList& list) : INT::Base(list) { }
+		};
+
+		class ChildNodeList :
+			public NodeList
+		{
+		public:
+#ifdef COMPARE_REF
+			virtual bool operator==(const NodeList& other) const
+				{ return m_el == ((ChildNodeList)other).m_el; }
+#endif
+			virtual int getLength() const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				int length;
+				_try_(S::SDOM_getChildNodeCount(m_sit, m_el, &length));
+				return length;
+			}
+
+			virtual Node item(int index) const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				S::SDOM_Node attr;
+				_try_(S::SDOM_getChildNodeIndex(m_sit, m_el, index, &attr));
+				return Node(m_sit, attr);
+			}
+
+		protected:
+			ChildNodeList(S::SablotSituation sit, S::SDOM_Node node) :
+				 NodeList(sit) { m_el = node; }
+
+			virtual bool isValid() const
+			{
+				return m_el != NULL;
+			}
+
+		protected:
+			S::SDOM_Node m_el;
+
+			friend class Node;
+		};
+
+		class AttrNodeList :
+			public NodeList
+		{
+		public:
+#ifdef COMPARE_REF
+			virtual bool operator==(const NodeList& other) const
+				{ return m_el == ((AttrNodeList)other).m_el; }
+#endif
+			virtual int getLength() const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				int length;
+				_try_(S::SDOM_getAttributeNodeCount(m_sit, m_el, &length));
+				return length;
+			}
+
+			virtual Node item(int index) const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				S::SDOM_Node attr;
+				_try_(S::SDOM_getAttributeNodeIndex(m_sit, m_el, index, &attr));
+				return Node(m_sit, attr);
+			}
+
+		protected:
+			AttrNodeList(S::SablotSituation sit, S::SDOM_Node el) :
+				 NodeList(sit) { m_el = el; }
+
+			virtual bool isValid() const
+			{
+				return m_el != NULL;
+			}
+
+		protected:
+			S::SDOM_Node m_el;
+		};
+
+
+		class DOMNodeList :
+			public NodeList
+		{
+		public:
+#ifdef COMPARE_REF
+			virtual bool operator==(const NodeList& other) const
+				{ return m_list == ((DOMNodeList&)other).m_list; }
+#endif
+			virtual int getLength() const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				int length;
+				_try_(S::SDOM_getNodeListLength(m_sit, m_list, &length));
+				return length;
+			}
+
+			virtual Node item(int index) const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				S::SDOM_Node it;
+				_try_(S::SDOM_getNodeListItem(m_sit, m_list, index, &it));
+				return Node(m_sit, it);
+			}
+
+		protected:
+			DOMNodeList(S::SablotSituation sit, S::SDOM_NodeList list) :
+				 NodeList(sit)
+			{
+				m_list = list;
+			}
+
+			~DOMNodeList()
+			{
+				if(m_list != NULL)
+					S::SDOM_disposeNodeList(m_sit, m_list);
+				m_list = NULL;
+			}
+
+			virtual bool isValid() const
+			{
+				return m_list != NULL;
+			}
+
+		protected:
+			S::SDOM_NodeList m_list;
+
+			friend class Element;
+			friend class Document;
+		};
+
+
+		class NamedNodeMap :
+			public INT::Base,
+			public INT::Inst
+		{
+		public:
+#ifdef COMPARE_REF
+			virtual bool operator==(const NamedNodeMap& other) const
+				{ Base::operator==(other); }
+#endif
+			virtual int getLength() const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				_try_(S::SDOM_NOT_SUPPORTED_ERR);
+				return 0;
+			}
+
+			virtual Node getNamedItem(const dom_str& name) const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				_try_(S::SDOM_NOT_SUPPORTED_ERR);
+				return Node();
+			}
+
+			virtual Node getNamedItemNS(const dom_str& uri, const dom_str& name) const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				_try_(S::SDOM_NOT_SUPPORTED_ERR);
+				return Node();
+			}
+
+			virtual Node item(int index) const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				_try_(S::SDOM_NOT_SUPPORTED_ERR);
+				return Node();
+			}
+
+			virtual Node removeNamedItem(const dom_str& name)
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				_try_(S::SDOM_NOT_SUPPORTED_ERR);
+				return Node();
+			}
+
+			virtual Node removeNamedItemNS(const dom_str& uri, const dom_str& name)
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				_try_(S::SDOM_NOT_SUPPORTED_ERR);
+				return Node();
+			}
+
+			virtual Node setNamedItem(const Node& arg)
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				ASSERT_VALID_NODE(arg);
+				_try_(S::SDOM_NOT_SUPPORTED_ERR);
+				return Node();
+			}
+
+			virtual Node setNamedItemNS(const Node& arg)
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				ASSERT_VALID_NODE(arg);
+				_try_(S::SDOM_NOT_SUPPORTED_ERR);
+				return Node();
+			}
+
+		protected:
+			NamedNodeMap(S::SablotSituation sit) :
+				 INT::Base(sit) { }
+
+			virtual bool isValid() const
+			{
+				return false;
+			}
+
+		private:
+			NamedNodeMap(const NamedNodeMap& map) : INT::Base(map) { }
+		};
+
+		class AttrNamedNodeMap :
+			public NamedNodeMap
+		{
+		public:
+#ifdef COMPARE_REF
+			virtual bool operator==(const NamedNodeMap& other) const
+				{ return m_el == ((AttrNamedNodeMap)other).m_el; }
+#endif
+			virtual int getLength() const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				ASSERT_VALID_NODE(m_el);
+				int length;
+				_try_(S::SDOM_getAttributeNodeCount(m_sit, m_el.m_node, &length));
+				return length;
+			}
+
+			virtual Node getNamedItem(const dom_str& name) const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				ASSERT_VALID_NODE(m_el);
+				return m_el.getAttributeNode(name);
+			}
+
+			virtual Node getNamedItemNS(const dom_str& uri, const dom_str& name) const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				ASSERT_VALID_NODE(m_el);
+				return m_el.getAttributeNodeNS(uri, name);
+			}
+
+			virtual Node item(int index) const
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				S::SDOM_Node attr;
+				_try_(S::SDOM_getAttributeNodeIndex(m_sit, m_el.m_node, index, &attr));
+				return Node(m_sit, attr);
+			}
+
+			virtual Node removeNamedItem(const dom_str& name)
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				ASSERT_VALID_NODE(m_el);
+				Node node = getNamedItem(name);
+				if(node != NULL)
+					m_el.removeAttributeNode((Attr&)node);
+				return node;
+			}
+
+			virtual Node removeNamedItemNS(const dom_str& uri, const dom_str& name)
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				ASSERT_VALID_NODE(m_el);
+				Node node = getNamedItemNS(uri, name);
+				if(node != NULL)
+					m_el.removeAttributeNode((Attr&)node);
+				return node;
+			}
+
+			virtual Node setNamedItem(const Node& arg)
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				ASSERT_VALID_NODE(m_el);
+				return m_el.setAttributeNode((Attr&)arg);
+			}
+
+			virtual Node setNamedItemNS(const Node& arg)
+				throw(DOMException)
+			{
+				ASSERT_VALID();
+				ASSERT_VALID_NODE(m_el);
+				return m_el.setAttributeNodeNS((Attr&)arg);
+			}
+
+		protected:
+			AttrNamedNodeMap(S::SablotSituation sit, const Node& el) :
+				 NamedNodeMap(sit)
+			{
+				ASSERT_VALID_NODE(el);
+				ASSERT_NODE_TYPE(el, Node::ELEMENT_NODE);
+				m_el = (Element&)el;
+			}
+
+			virtual bool isValid() const
+			{
+				return m_el.isValid();
+			}
+
+
+		protected:
+			Element m_el;
+
+			friend class Node;
+		};
+	};
+
+
+	inline NodeList Node::getChildNodes() const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		return NodeList(new INT::ChildNodeList(m_sit, m_node));
+	}
+
+	inline NamedNodeMap Node::getAttributes() const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		if(getNodeType() != ELEMENT_NODE)
+			return NamedNodeMap(NULL);
+
+		return NamedNodeMap(new INT::AttrNamedNodeMap(m_sit, *this));
+	}
+
+	inline Document Node::getOwnerDocument() const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		S::SDOM_Document doc;
+		_try_(S::SDOM_getOwnerDocument(m_sit, m_node, &doc));
+		return Document(m_sit, doc);
+	}
+
+	inline Element Attr::getOwnerElement() const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		ASSERT_TYPE(ATTRIBUTE_NODE);
+		S::SDOM_Node el;
+		_try_(S::SDOM_getAttributeElement(m_sit, m_node, &el));
+		return Element(m_sit, el);
+	}
+
+	inline NodeList Element::getElementsByTagName(const dom_str& name) const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		ASSERT_TYPE(ELEMENT_NODE);
+		dom_str query = "descendant::" + name;
+		S::SDOM_NodeList result;
+		_try_(S::SDOM_xql(m_sit, FROM_D(query).c_str(), m_node, &result));
+		return NodeList(new INT::DOMNodeList(m_sit, result));
+	}
+
+	inline NodeList Element::getElementsByTagNameNS(const dom_str& uri,
+										     const dom_str& name) const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		ASSERT_TYPE(ELEMENT_NODE);
+		dom_str query = "descendant::*[namespace-uri()='" + uri + "'";
+		if(name != "*")
+			query += " and local-name()='" + name + "']";
+		S::SDOM_NodeList result;
+		_try_(S::SDOM_xql(m_sit, FROM_D(query).c_str(), m_node, &result));
+		return NodeList(new INT::DOMNodeList(m_sit, result));
+	}
+
+	inline NodeList Document::getElementsByTagName(const dom_str& name) const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		ASSERT_TYPE(DOCUMENT_NODE);
+		dom_str query = "descendant::" + name;
+		S::SDOM_NodeList result;
+		_try_(S::SDOM_xql(m_sit, FROM_D(query).c_str(), m_node, &result));
+		return NodeList(new INT::DOMNodeList(m_sit, result));
+	}
+
+	inline NodeList Document::getElementsByTagNameNS(const dom_str& uri,
+											  const dom_str& name) const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		ASSERT_TYPE(DOCUMENT_NODE);
+		dom_str query = "descendant::*[namespace-uri()='" + uri + "'";
+		if(name != "*")
+			query += " and local-name()='" + name + "']";
+		S::SDOM_NodeList result;
+		_try_(S::SDOM_xql(m_sit, FROM_D(query).c_str(), m_node, &result));
+		return NodeList(new INT::DOMNodeList(m_sit, result));
+	}
+
+	inline DOMImplementation Document::getImplementation() const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		ASSERT_TYPE(DOCUMENT_NODE);
+		return DOMImplementation(m_sit);
+	}
+
+	inline Text Text::splitText(int offset)
+			throw(DOMException)
+	{
+		ASSERT_VALID();
+		ASSERT(getNodeType() == TEXT_NODE ||
+			   getNodeType() == CDATA_SECTION_NODE);
+
+		data_str val = getNodeValue();
+		setNodeValue(val.substr(0, offset));
+
+		Document doc = getOwnerDocument();
+		ASSERT(doc != NULL);
+
+		Text split(m_sit, NULL);
+		val = val.substr(0, offset);
+
+		switch(getNodeType())
+		{
+		case TEXT_NODE:
+			split = doc.createTextNode(val);
+			break;
+
+		case CDATA_SECTION_NODE:
+			split = doc.createCDATASection(val);
+			break;
+
+		default:
+			ASSERT(false);
+		};
+
+		Node parent = getParentNode();
+		if(parent != NULL)
+		{
+			Node next = getNextSibling();
+			if(next != NULL)
+				parent.insertBefore(split, next);
+			else
+				parent.appendChild(split);
+		}
+
+		return split;
+	}
+
+	inline NamedNodeMap DocumentType::getEntities() const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		_try_(S::SDOM_NOT_SUPPORTED_ERR);
+		return NamedNodeMap(NULL);
+	}
+
+	inline NamedNodeMap DocumentType::getNotations() const
+		throw(DOMException)
+	{
+		ASSERT_VALID();
+		_try_(S::SDOM_NOT_SUPPORTED_ERR);
+		return NamedNodeMap(NULL);
+	}
+
+}; // namespace DOM
+
+
+#endif //__SABLO_H__
\ No newline at end of file