--- parser3/src/classes/xdoc.C	2002/01/24 15:11:59	1.76
+++ parser3/src/classes/xdoc.C	2011/05/18 01:25:06	1.166
@@ -1,56 +1,53 @@
 /** @file
 	Parser: @b xdoc parser class.
 
-	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
-	Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)
-
-	$Id: xdoc.C,v 1.76 2002/01/24 15:11:59 paf Exp $
+	Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)
+	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
-#include "pa_types.h"
+
+#include "pa_config_includes.h"
+
 #ifdef XML
 
-#include "gdome.h"
+static const char * const IDENT_XDOC_C="$Date: 2011/05/18 01:25:06 $";
+
 #include "libxml/tree.h"
-extern "C" {
-#include "gdomecore/gdome-xml-node.h"
-#include "gdomecore/gdome-xml-document.h"
-};
+#include "libxml/HTMLtree.h"
 #include "libxslt/xsltInternals.h"
 #include "libxslt/transform.h"
 #include "libxslt/xsltutils.h"
+#include "libxslt/variables.h"
+#include "libxslt/imports.h"
 
-#include "pa_stylesheet_connection.h"
-#include "classes.h"
+#include "pa_vmethod_frame.h"
+
+#include "pa_stylesheet_manager.h"
 #include "pa_request.h"
 #include "pa_vxdoc.h"
 #include "pa_charset.h"
 #include "pa_vfile.h"
+#include "pa_xml_exception.h"
 #include "xnode.h"
 
-
 // defines
 
 #define XDOC_CLASS_NAME "xdoc"
 
-#define XDOC_OUTPUT_METHOD_OPTION_NAME "method"
-#define XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "xml"
-#define XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "html"
-#define XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT "text"
-
 // class
 
-class MXdoc : public MXnode {
+class MXdoc: public MXnode {
 public: // VStateless_class
-	Value *create_new_value(Pool& pool) { return new(pool) VXdoc(pool, 0); }
+	Value* create_new_value(Pool&) { return new VXdoc(); }
 
 public:
-	MXdoc(Pool& pool);
+	MXdoc();
 
-public: // Methoded
-	bool used_directly() { return true; }
-	void configure_admin(Request& r);
 };
 
+// global variable
+
+DECLARE_CLASS_VAR(xdoc, new MXdoc, 0);
+
 // helper classes
 
 class xmlOutputBuffer_auto_ptr {
@@ -154,586 +151,488 @@ private:
 
 // methods
 
-static void writeNode(Request& r,  const String& method_name, GdomeNode *node, 
-					  GdomeException exc) {
-	if(!node || exc)
-		throw Exception(0, 0, 
-			&method_name, 
-			exc);
-
-	Pool& pool=r.pool();
+static void writeNode(Request& r, VXdoc& xdoc, xmlNode* node) {
+	if(!node)
+		throw Exception(PARSER_RUNTIME,
+			0,
+			"error creating node"); // OOM, bad name, things like that
 
 	// write out result
-	VXnode& result=*new(pool) VXnode(pool, node);
-	r.write_no_lang(result);
+	r.write_no_lang(xdoc.wrap(*node));
+}
+
+struct IdsIteratorInfo {
+	xmlChar *elementId;
+	xmlNode *element;
+};
+
+/* Hash Scanner function for pa_getElementById */
+extern "C" void // switching to calling convetion of libxml
+idsHashScanner (void *payload, void *data, xmlChar *name) {
+	IdsIteratorInfo *priv = (IdsIteratorInfo *)data;
+
+	if (priv->element == NULL && xmlStrEqual (name, priv->elementId))
+	{
+		xmlNode* parent=((xmlID *)payload)->attr->parent;
+		assert(parent);
+		priv->element=parent;
+	}
+}
+
+static xmlNode*
+pa_getElementById(xmlDoc& xmldoc, xmlChar* elementId) {
+	xmlHashTable *ids = (xmlHashTable *)xmldoc.ids;
+	IdsIteratorInfo iter={elementId, NULL};
+	xmlHashScan(ids, idsHashScanner, &iter);
+	return iter.element;
+}
+
+/*
+static xmlNode *
+pa_importNode (xmlDoc& xmldoc, xmlNode& importedNode, bool deep) {
+	xmlNode *result = NULL;
+
+	switch (importedNode.type) {
+	case XML_ATTRIBUTE_NODE:
+		result = (xmlNode *)xmlCopyProp(xmldoc, (xmlAttr *)importedNode);
+		result.parent=0; // no idea
+		break;
+	case XML_DOCUMENT_FRAG_NODE:
+	case XML_ELEMENT_NODE:
+	case XML_ENTITY_REF_NODE:
+	case XML_PI_NODE:
+	case XML_TEXT_NODE:
+	case XML_CDATA_SECTION_NODE:
+	case XML_COMMENT_NODE:
+		result = xmlCopyNode (importedNode->n, deep);
+		xmlSetTreeDoc (result, priv->n);
+		break;
+	default:
+		*exc = GDOME_NOT_SUPPORTED_ERR;
+	}
+
+	return result;
 }
+*/
 
 // Element createElement(in DOMString tagName) raises(DOMException);
-static void _createElement(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
-
-	const String& tagName=params->as_string(0, "tagName must be string");
-
-	GdomeException exc;
-	GdomeNode *node=
-		(GdomeNode *)gdome_doc_createElement(vdoc.get_document(&method_name), 
-		pool.transcode(tagName).get(),
-		&exc);
-	writeNode(r, method_name, node, exc);
+static void _createElement(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+	xmlDoc& xmldoc=vdoc.get_xmldoc();
+
+	xmlChar* tagName=as_xmlchar(r, params, 0, "tagName must be string");
+
+	xmlNode *node=xmlNewDocNode(&xmldoc, NULL, tagName, NULL);
+	writeNode(r, vdoc, node);
+}
+
+// Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
+static void _createElementNS(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+	xmlDoc& xmldoc=vdoc.get_xmldoc();
+
+	// namespaceURI;localName
+	xmlChar* namespaceURI=as_xmlchar(r, params, 0, NAMESPACEURI_MUST_BE_STRING);
+	xmlChar* qualifiedName=as_xmlchar(r, params, 1, "qualifiedName must be string");
+
+	xmlChar* prefix=0;
+	xmlChar* localName=xmlSplitQName2(qualifiedName, &prefix);
+
+	xmlNode *node;
+	if(localName) {
+		xmlNs& ns=pa_xmlMapNs(xmldoc, namespaceURI, prefix);
+		node=xmlNewDocNode(&xmldoc, &ns, localName, NULL);
+	} else
+		node=xmlNewDocNode(&xmldoc, NULL, qualifiedName/*unqualified, actually*/, NULL);
+	writeNode(r, vdoc, node);
 }
 
 // DocumentFragment createDocumentFragment()
-static void _createDocumentFragment(Request& r, const String& method_name, MethodParams *) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
-
-	GdomeException exc;
-	GdomeNode *node=
-		(GdomeNode *)gdome_doc_createDocumentFragment(
-		vdoc.get_document(&method_name),
-		&exc);
-	writeNode(r, method_name, node, exc);
+static void _createDocumentFragment(Request& r, MethodParams&) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+	xmlDoc& xmldoc=vdoc.get_xmldoc();
+
+	xmlNode *node=xmlNewDocFragment(&xmldoc);
+	writeNode(r, vdoc, node);
 }
 
 // Text createTextNode(in DOMString data);
-static void _createTextNode(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
-
-	const String& data=params->as_string(0, "data must be string");
-
-	GdomeException exc;
-	GdomeNode *node=(GdomeNode *)gdome_doc_createTextNode(
-		vdoc.get_document(&method_name),
-		pool.transcode(data).get(),
-		&exc);
-	writeNode(r, method_name, node, exc);
+static void _createTextNode(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+	xmlDoc& xmldoc=vdoc.get_xmldoc();
+
+	xmlChar* data=as_xmlchar(r, params, 0, DATA_MUST_BE_STRING);
+
+	xmlNode *node=xmlNewDocText(&xmldoc, data);
+	writeNode(r, vdoc, node);
 }
 
 // Comment createComment(in DOMString data)
-static void _createComment(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
-
-	const String& data=params->as_string(0, "data must be string");
-
-	GdomeException exc;
-	GdomeNode *node=(GdomeNode *)gdome_doc_createComment(
-		vdoc.get_document(&method_name),
-		pool.transcode(data).get(),
-		&exc);
-	writeNode(r, method_name, node, exc);
+static void _createComment(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+
+	xmlChar* data=as_xmlchar(r, params, 0, DATA_MUST_BE_STRING);
+
+	xmlNode *node=xmlNewComment(data);
+	writeNode(r, vdoc, node);
 }
 
 // CDATASection createCDATASection(in DOMString data) raises(DOMException);
-static void _createCDATASection(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
-
-	const String& data=params->as_string(0, "data must be string");
-
-	GdomeException exc;
-	GdomeNode *node=(GdomeNode *)gdome_doc_createCDATASection(
-		vdoc.get_document(&method_name),
-		pool.transcode(data).get(),
-		&exc);
-	writeNode(r, method_name, node, exc);
+static void _createCDATASection(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+	xmlDoc& xmldoc=vdoc.get_xmldoc();
+
+	xmlChar* data=as_xmlchar(r, params, 0, DATA_MUST_BE_STRING);
+
+	xmlNode *node=xmlNewCDataBlock(&xmldoc, data, strlen((const char*)data));
+	writeNode(r, vdoc, node);
 }
 
 // ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) raises(DOMException);
-static void _createProcessingInstruction(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
-
-	const String& target=params->as_string(0, "data must be string");
-	const String& data=params->as_string(1, "data must be string");
-
-	GdomeException exc;
-	GdomeNode *node=(GdomeNode *)gdome_doc_createProcessingInstruction(
-		vdoc.get_document(&method_name),
-		pool.transcode(target).get(), 
-		pool.transcode(data).get(),
-		&exc);
-	writeNode(r, method_name, node, exc);
+static void _createProcessingInstruction(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+	xmlDoc& xmldoc=vdoc.get_xmldoc();
+
+	xmlChar* target=as_xmlchar(r, params, 0, DATA_MUST_BE_STRING);
+	xmlChar* data=as_xmlchar(r, params, 1, DATA_MUST_BE_STRING);
+
+	xmlNode *node=xmlNewDocPI(&xmldoc, target, data);
+	writeNode(r, vdoc, node);
 }
 
 // Attr createAttribute(in DOMString name) raises(DOMException);
-static void _createAttribute(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
-
-	const String& name=params->as_string(0, "name must be string");
-
-	GdomeException exc;
-	GdomeNode *node=(GdomeNode *)gdome_doc_createAttribute(
-		vdoc.get_document(&method_name),
-		pool.transcode(name).get(),
-		&exc);
-	writeNode(r, method_name, node, exc);
-}
-// EntityReference createEntityReference(in DOMString name) raises(DOMException);
-static void _createEntityReference(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
-
-	const String& name=params->as_string(0, "name must be string");
-
-	GdomeException exc;
-	GdomeNode *node=(GdomeNode *)gdome_doc_createEntityReference(
-		vdoc.get_document(&method_name),
-		pool.transcode(name).get(),
-		&exc);
-	writeNode(r, method_name, node, exc);
-}
-
-static void _getElementsByTagName(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
-
-	const String& name=params->as_string(0, "name must be string");
-
-	GdomeException exc;
-	VHash& result=*new(pool) VHash(pool);
-	if(GdomeNodeList *nodes=
-		gdome_doc_getElementsByTagName(
-			vdoc.get_document(&method_name), 
-			pool.transcode(name).get(),
-			&exc)) {
-		gulong length=gdome_nl_length(nodes, &exc);
-		for(gulong i=0; i<length; i++) {
-			String& skey=*new(pool) String(pool);
-			{
-				char *buf=(char *)pool.malloc(MAX_NUMBER);
-				snprintf(buf, MAX_NUMBER, "%d", i);
-				skey << buf;
-			}
+static void _createAttribute(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+	xmlDoc& xmldoc=vdoc.get_xmldoc();
 
-			result.hash(0).put(skey, new(pool) VXnode(pool, gdome_nl_item(nodes, i, &exc)));
-		}
-	}
+	xmlChar* name=as_xmlchar(r, params, 0, NAME_MUST_BE_STRING);
 
-	// write out result
-	r.write_no_lang(result);
+	xmlNode *node=(xmlNode*)xmlNewDocProp(&xmldoc, name, 0);
+	writeNode(r, vdoc, node);
 }
 
-static void _getElementsByTagNameNS(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
+// Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
+static void _createAttributeNS(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+	xmlDoc& xmldoc=vdoc.get_xmldoc();
 
-	// namespaceURI;localName
-	const String& namespaceURI=params->as_string(0, "namespaceURI must be string");
-	const String& localName=params->as_string(0, "localName must be string");
+	xmlChar* namespaceURI=as_xmlchar(r, params, 0, NAMESPACEURI_MUST_BE_STRING);
+	xmlChar* qualifiedName=as_xmlchar(r, params, 1, NAME_MUST_BE_STRING);
 
-	GdomeException exc;
-	VHash& result=*new(pool) VHash(pool);
-	if(GdomeNodeList *nodes=
-		gdome_doc_getElementsByTagNameNS(
-			vdoc.get_document(&method_name), 
-			pool.transcode(namespaceURI).get(),
-			pool.transcode(localName).get(),
-			&exc)) {
-		gulong length=gdome_nl_length(nodes, &exc);
-		for(gulong i=0; i<length; i++) {
-			String& skey=*new(pool) String(pool);
-			{
-				char *buf=(char *)pool.malloc(MAX_NUMBER);
-				snprintf(buf, MAX_NUMBER, "%d", i);
-				skey << buf;
-			}
+	xmlChar* prefix=0;
+	xmlChar* localName=xmlSplitQName2(qualifiedName, &prefix);
 
-			result.hash(0).put(skey, new(pool) VXnode(pool, gdome_nl_item(nodes, i, &exc)));
-		}
-	}
+	xmlNode *node;
+	if(localName) {
+		xmlNs& ns=pa_xmlMapNs(xmldoc, namespaceURI, prefix);
+		node=(xmlNode*)xmlNewDocProp(&xmldoc, localName, NULL);
+		xmlSetNs(node, &ns);
+	} else
+		node=(xmlNode*)xmlNewDocProp(&xmldoc, qualifiedName/*unqualified, actually*/, NULL);
+	writeNode(r, vdoc, node);
+}
 
+// EntityReference createEntityReference(in DOMString name) raises(DOMException);
+static void _createEntityReference(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+	xmlDoc& xmldoc=vdoc.get_xmldoc();
 
-	// write out result
-	r.write_no_lang(result);
+	xmlChar* name=as_xmlchar(r, params, 0, NAME_MUST_BE_STRING);
+
+	xmlNode *node=xmlNewReference(&xmldoc, name);
+	writeNode(r, vdoc, node);
 }
 
-static void _getElementById(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
+
+static void _getElementById(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+	xmlDoc& xmldoc=vdoc.get_xmldoc();
 
 	// elementId
-	const String& elementId=params->as_string(0, "elementID must be string");
+	xmlChar* elementId=as_xmlchar(r, params, 0, "elementID must be string");
 
-	GdomeException exc;
-	if(GdomeNode *node=(GdomeNode *)gdome_doc_getElementById(
-		vdoc.get_document(&method_name),
-		pool.transcode(elementId).get(),
-		&exc)) {
+	if(xmlNode *node=pa_getElementById(xmldoc, elementId)) {
 		// write out result
-		VXnode& result=*new(pool) VXnode(pool, node);
-		r.write_no_lang(result);
-	} else if(exc || xmlHaveGenericErrors())
-		throw Exception(0, 0, 
-			&method_name, 
-			exc);
+		writeNode(r, vdoc, node);
+	}
 }
-/*
-GdomeNode *gdome_doc_importNode (GdomeDocument *self, GdomeNode *importedNode, GdomeBoolean deep, GdomeException *exc);
-GdomeElement *gdome_doc_createElementNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);
-GdomeAttr *gdome_doc_createAttributeNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);
-*/
-
 
-static void _create(Request& r, const String& method_name, MethodParams *params) {
-	//_asm int 3;
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
-
-	const String& qualifiedName=params->as_string(0, "qualifiedName must be string");
-
-	GdomeException exc;
-	/*
-	GdomeDocumentType *documentType=gdome_di_createDocumentType (
-		docimpl, 
-		pool.transcode(qualifiedName), 
-		0/*publicId* /, 
-		0/*systemId* /, 
-		&exc);
-	if(!documentType || exc || xmlHaveGenericErrors())
-		throw Exception(0, 0, 
-			&method_name, 
-			exc);
-	*/
-	GdomeDocument *document=gdome_di_createDocument (domimpl, 
-		0/*namespaceURI*/, 
-		pool.transcode(qualifiedName).get(), 
-		0/*doctype*/, 
-		&exc);
-	if(!document || exc || xmlHaveGenericErrors())
-		throw Exception(0, 0, 
-			&method_name, 
-			exc);
+static void _importNode(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+	xmlDoc& xmldoc=vdoc.get_xmldoc();
 
-	/// +xalan createXMLDecl ?
+	xmlNode& importedNode=
+		as_node(params, 0, "importedNode must be node");
+	bool deep=
+		params.as_bool(1, "deep must be bool", r);
 
-	// replace any previous parsed source
-	vdoc.set_document(document);
+	xmlNode *node=xmlDocCopyNode(&importedNode, &xmldoc, deep?1: 0);
+	// write out result
+	writeNode(r, vdoc, node);
 }
+/*
+GdomeElement *gdome_doc_createElementNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);
+GdomeAttr *gdome_doc_createAttributeNS (GdomeDocument *self, GdomeDOMString *namespaceURI, GdomeDOMString *qualifiedName, GdomeException *exc);
+*/
 
-static void _set(Request& r, const String& method_name, MethodParams *params) {
-//	_asm int 3;
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
-
-	Value& vxml=params->as_junction(0, "xml must be code");
-	Temp_lang temp_lang(r, String::UL_XML);
-	const String& xml=r.process(vxml).as_string();
-
-	GdomeDocument *document=(GdomeDocument *)
-		gdome_xml_n_mkref((xmlNode *)xmlParseMemory(
-			xml.cstr(String::UL_AS_IS), xml.size()
-		));
-	if(!document || xmlHaveGenericErrors()) {
-		GdomeException exc=0;
-		throw Exception(0, 0, 
-			&method_name, 
-			exc);
+static void _create(Request& r, MethodParams& params) {
+	Charset& source_charset=r.charsets.source();
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+
+	Value& param=params[params.count()-1];
+	xmlDoc* xmldoc;
+	bool set_encoding=false;
+	if(param.get_junction()) { // {<?xml?>...}
+		Temp_lang temp_lang(r, String::L_XML);
+		const String& xml=r.process_to_string(param);
+
+		String::Body sbody=xml.cstr_to_string_body_untaint(r.flang, 0, &r.charsets);
+		xmldoc=xmlParseMemory(sbody.cstr(), sbody.length());
+
+		//printf("document=0x%p\n", document);
+		if(!xmldoc || xmlHaveGenericErrors())
+			throw XmlException(0);
+
+		// must be last action in if, see after if}
+	} else { // [localName]
+		if(const String* value = param.get_string()){
+			xmlChar* localName=r.transcode(*value);
+#if 0
+			GdomeDocumentType *documentType=gdome_di_createDocumentType (
+				docimpl, 
+				r.transcode(qualifiedName), 
+				0/*publicId*/, 
+				0/*systemId*/, 
+				&exc);
+			if(!documentType || exc || xmlHaveGenericErrors())
+				throw Exception(
+					method_name, 
+					exc);
+			/// +xalan createXMLDecl ?
+#endif
+			xmldoc=xmlNewDoc(0);
+			if(!xmldoc || xmlHaveGenericErrors())
+				throw XmlException(0);
+			xmlNode* node=xmlNewChild((xmlNode*)xmldoc, NULL, localName, NULL);
+			if(!node || xmlHaveGenericErrors())
+				throw XmlException(0);
+
+			set_encoding=true;
+			// must be last action in if, see after if}
+		} else {
+			VFile* vfile=param.as_vfile(String::L_AS_IS);
+			xmldoc=xmlParseMemory(vfile->value_ptr(), vfile->value_size());
+			if(!xmldoc || xmlHaveGenericErrors())
+				throw XmlException(0);
+		}
 	}
-
+	// must be first action after if}
 	// replace any previous parsed source
-	vdoc.set_document(document);
+	vdoc.set_xmldoc(r.charsets, *xmldoc); 
+	
+	// URI 
+	const char* URI_cstr;
+	if(params.count()>1) { // absolute(param)
+		const String& URI=params.as_string(0, "URI must be string");
+		URI_cstr=r.absolute(URI).cstr();
+	} else // default = disk path to requested document
+		URI_cstr=r.request_info.path_translated;
+	if(URI_cstr)
+		xmldoc->URL=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));
+
+	if(set_encoding) {
+		const char* source_charset_name=source_charset.NAME().cstr();
+		xmldoc->encoding=source_charset.transcode_buf2xchar(source_charset_name, strlen(source_charset_name));
+	}
 }
 
-static void _load(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
+static void _load(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
 
 	// filespec
-	const String& file_name=params->as_string(0, "uri must be string");
-	const String& uri=r.absolute(file_name);
+	const String* uri=&params.as_string(0, "URI must be string");
+	const char* uri_cstr;
+	if(uri->pos("://")==STRING_NOT_FOUND) // disk path
+		uri_cstr=r.absolute(*uri).taint_cstr(String::L_FILE_SPEC);
+	else // xxx:// 
+		uri_cstr=uri->taint_cstr(String::L_AS_IS); // leave as-is for xmlParseFile to handle
+
+	/// @todo!! add SAFE MODE!!
+	xmlDoc* xmldoc=xmlParseFile(uri_cstr);
+	if(!xmldoc || xmlHaveGenericErrors())
+		throw XmlException(uri);
 	
-	GdomeDocument *document=(GdomeDocument *)
-		gdome_xml_n_mkref((xmlNode *)xmlParseFile(uri.cstr()));
-	if(!document || xmlHaveGenericErrors()) {
-		GdomeException exc=0;
-		throw Exception(0, 0, 
-			&uri, 
-			exc);
-	}
-
+	// must be first action after if}
 	// replace any previous parsed source
-	vdoc.set_document(document);
-}
-
-static void param_option_over_output_option(Pool& pool, 
-											Hash *param_options, const char *option_name,
-											const String *& output_option) {
-	if(Value *value=static_cast<Value *>(param_options->get(*new(pool) String(pool, 
-		option_name))))
-		output_option=&value->as_string();
-}
-static void param_option_over_output_option(Pool& pool, 
-											Hash *param_options, const char *option_name,
-											bool& output_option) {
-	if(Value *value=static_cast<Value *>(param_options->get(*new(pool) 
-		String(pool, option_name)))) {
-		const String& s=value->as_string();
-		if(s=="yes")
-			output_option=true;
-		else if(s=="no")
-			output_option=false;
-		else
-			throw Exception(0, 0,
-				&s,
-				"%s must be either 'yes' or 'no'", option_name);
-	}
+	vdoc.set_xmldoc(r.charsets, *xmldoc); 
 }
 
-static void prepare_output_options(
-								   Pool& pool, const String& method_name, MethodParams *params, int index,
-								   VXdoc::Output_options& oo) {
-/*
-<xsl:output
-  !method = "xml" | "html" | "text" | qname-but-not-ncname 
-  !version = nmtoken 
-  !encoding = string 
-  !omit-xml-declaration = "yes" | "no"
-  !standalone = "yes" | "no"
-  !doctype-public = string 
-  !doctype-system = string 
-  cdata-section-elements = qnames 
-  !indent = "yes" | "no"
-  !media-type = string /> 
-*/
-
-	// configuring with options from parameter...
-	if(params->size()>index) {
-		Value& voptions=params->as_no_junction(index, "options must be string");
-		if(voptions.is_defined()) {
-			if(Hash *options=voptions.get_hash(&method_name)) {
-				// $.method[xml|html|text]
-				if(Value *vmethod=static_cast<Value *>(options->get(*new(pool) 
-					String(pool, XDOC_OUTPUT_METHOD_OPTION_NAME))))
-					oo.method=&vmethod->as_string();
-
-				// $.version[1.0]
-				param_option_over_output_option(pool, options, "version", oo.version);
-				// $.encoding[windows-1251|...]
-				param_option_over_output_option(pool, options, "encoding", oo.encoding);
-				// $.omit-xml-declaration[yes|no]
-				param_option_over_output_option(pool, options, "omit-xml-declaration", oo.omitXmlDeclaration);
-				// $.standalone[yes|no]
-				param_option_over_output_option(pool, options, "standalone", oo.standalone);
-				// $.doctype-public[?]
-				param_option_over_output_option(pool, options, "doctype-public", oo.doctypePublic);
-				// $.doctype-system[?]
-				param_option_over_output_option(pool, options, "doctype-system", oo.doctypeSystem);
-				// $.indent[yes|no]
-				param_option_over_output_option(pool, options, "indent", oo.indent);
-				// $.media-type[text/{html|xml|plain}]
-				param_option_over_output_option(pool, options, "media-type", oo.mediaType);				 
-			}
-		}
-	}
-
-	// default encoding from pool
-	if(!oo.encoding)
-		oo.encoding=&pool.get_source_charset().name();
-	// default method=xml
-	if(!oo.method)
-		oo.method=new(pool) String(pool, XDOC_OUTPUT_METHOD_OPTION_VALUE_XML);
-	// default mediaType = depending on method
-	if(!oo.mediaType) {
-		if(*oo.method==XDOC_OUTPUT_METHOD_OPTION_VALUE_XML)
-			oo.mediaType=new(pool) String(pool, "text/xml");
-		else if(*oo.method==XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML)
-			oo.mediaType=new(pool) String(pool, "text/html");
-		else // XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT & all others
-			oo.mediaType=new(pool) String(pool, "text/plain");
+String::C xdoc2buf(Request& r, VXdoc& vdoc, 
+					XDocOutputOptions& oo,
+					const String* file_spec,
+					bool use_source_charset_to_render_and_client_charset_to_write_to_header=false) {
+	const char* render_encoding;
+	const char* header_encoding;
+	if(use_source_charset_to_render_and_client_charset_to_write_to_header) {
+		render_encoding=r.charsets.source().NAME_CSTR();
+		header_encoding=r.charsets.client().NAME_CSTR();
+	} else {
+		header_encoding=render_encoding=oo.encoding->cstr();
 	}
-}
 
-static void xdoc2buf(Pool& pool, VXdoc& vdoc, 
-					 const String& method_name, MethodParams *params, int index,
-					 VXdoc::Output_options& oo,
-					 const String *file_spec,
-					 char **parser_buf, size_t *parser_size) {
-	prepare_output_options(pool, method_name, params, index,
-		oo);
-
-	const char *encoding_cstr=oo.encoding->cstr();
-	xmlCharEncodingHandler *encoder=xmlFindCharEncodingHandler(encoding_cstr);
-	if(!encoder)
-		throw Exception(0, 0,
-			&method_name,
-			"encoding '%s' not supported", encoding_cstr);
-	// UTF-8 encoder contains empty input/output converters, 
+	xmlCharEncodingHandler *renderer=xmlFindCharEncodingHandler(render_encoding);
+	if(!renderer)
+		throw Exception(PARSER_RUNTIME,
+			0,
+			"encoding '%s' not supported", render_encoding);
+	// UTF-8 renderer contains empty input/output converters, 
 	// which is wrong for xmlOutputBufferCreateIO
-	// while zero encoder goes perfectly 
-	if(encoder && strcmp(encoder->name, "UTF-8")==0)
-		encoder=0;
+	// while zero renderer goes perfectly 
+	if(strcmp(render_encoding, "UTF-8")==0)
+		renderer=0;
 
-	xmlOutputBuffer_auto_ptr outputBuffer(xmlAllocOutputBuffer(encoder));
+	xmlOutputBuffer_auto_ptr outputBuffer(xmlAllocOutputBuffer(renderer));
 
 	xsltStylesheet_auto_ptr stylesheet(xsltNewStylesheet());
 	if(!stylesheet.get())
-		throw Exception(0, 0,
-			&method_name,
+		throw Exception(0,
+			0,
 			"xsltNewStylesheet failed");
 
-	#define OOS2STYLE(name) \
-		stylesheet->name=oo.name?BAD_CAST g_strdup(pool.transcode(*oo.name)->str):0
-	#define OOE2STYLE(name) \
-		stylesheet->name=oo.name
-
-	OOS2STYLE(method);
-	OOS2STYLE(encoding);
-	OOS2STYLE(mediaType);
-	OOS2STYLE(doctypeSystem);
-	OOS2STYLE(doctypePublic);
-	OOE2STYLE(indent);
-	OOS2STYLE(version);
-	OOE2STYLE(standalone);
-	OOE2STYLE(omitXmlDeclaration);
-
-	xmlDoc *document=gdome_xml_doc_get_xmlDoc(vdoc.get_document(&method_name));
-	if(xsltSaveResultTo(outputBuffer.get(), document, stylesheet.get())<0) {
-		GdomeException exc=0;
-		throw Exception(0, 0, 
-			&method_name, 
-			exc);
-	}
+	#define OOSTRING2STYLE(name) \
+		stylesheet->name=oo.name?BAD_CAST xmlMemStrdup((const char*)r.transcode(*oo.name)):0
+	#define OOBOOL2STYLE(name) \
+		if(oo.name>=0) stylesheet->name=oo.name
+
+	OOSTRING2STYLE(method);
+	OOSTRING2STYLE(encoding);
+	OOSTRING2STYLE(mediaType);
+//	OOSTRING2STYLE(doctypeSystem);
+//	OOSTRING2STYLE(doctypePublic);
+	OOBOOL2STYLE(indent);
+	OOSTRING2STYLE(version);
+	OOBOOL2STYLE(standalone);
+	OOBOOL2STYLE(omitXmlDeclaration);
+
+	xmlDoc& xmldoc=vdoc.get_xmldoc();
+	xmldoc.encoding=BAD_CAST xmlMemStrdup(render_encoding);
+	if(header_encoding)
+		stylesheet->encoding=BAD_CAST xmlMemStrdup(header_encoding);
+	if(xsltSaveResultTo(outputBuffer.get(), &xmldoc, stylesheet.get())<0
+		|| xmlHaveGenericErrors())
+		throw XmlException(0);
 
 	// write out result
-	char *gnome_buf;  size_t gnome_size;
+	char *gnome_str;
+	size_t gnome_length;
 	if(outputBuffer->conv) {
-		gnome_size=outputBuffer->conv->use;
-		gnome_buf=(char *)outputBuffer->conv->content;
+		gnome_length=outputBuffer->conv->use;
+		gnome_str=(char *)outputBuffer->conv->content;
 	} else {
-		gnome_size=outputBuffer->buffer->use;
-		gnome_buf=(char *)outputBuffer->buffer->content;
+		gnome_length=outputBuffer->buffer->use;
+		gnome_str=(char *)outputBuffer->buffer->content;
 	}
-	if(file_spec)
-		file_write(pool, 
-					*file_spec,
-					gnome_buf, gnome_size, 
-					true/*as_text*/);
-	else if(*parser_size=gnome_size) {
-		*parser_buf=(char *)pool.malloc(gnome_size);
-		memcpy(*parser_buf, gnome_buf, gnome_size);
+
+	if(file_spec){
+		file_write(r.charsets,
+			*file_spec,
+			gnome_str,
+			gnome_length, 
+			true/*as_text*/);
+		return String::C(); // actually, we don't need this output at all
 	} else
-		*parser_buf=0;
+		return String::C(gnome_length ? pa_strdup(gnome_str, gnome_length) : 0, gnome_length);
 }
 
-static void _file(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
-	VXdoc::Output_options oo(vdoc.output_options);
-	char *buf; size_t buf_size;
-	xdoc2buf(pool, vdoc, method_name, params, 0, 
-		oo,
-		0/*not to file, to memory*/,
-		&buf, &buf_size);
-	// write out result
-	r.write_no_lang(*new(pool) String(pool, buf, buf_size));
+inline HashStringValue* get_options(MethodParams& params, size_t index){
+	return (params.count()>index) ? params.as_hash(index) : 0;
+}
+
+static void _file(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+
+	XDocOutputOptions oo(r, get_options(params, 0));
+	String::C buf=xdoc2buf(r, vdoc, oo, 0/*file_name. not to file, to memory*/);
+
+	VFile& vfile=*new VFile;
+	VHash& vhcontent_type=*new VHash;
+	vhcontent_type.hash().put(
+		value_name, 
+		new VString(*oo.mediaType));
+	vhcontent_type.hash().put(
+		String::Body("charset"), 
+		new VString(*oo.encoding));
+
+	vfile.set(false/*tainted*/, buf.str?buf.str:""/*to distinguish from stat-ed file*/, buf.length, 
+		0/*file_name*/, &vhcontent_type);
 
 	// write out result
-	VFile& vfile=*new(pool) VFile(pool);
-	Value *vcontent_type;
-	VHash *vhcontent_type=new(pool) VHash(pool);
-	vhcontent_type->hash(&method_name).put(
-		*value_name, 
-		new(pool) VString(*oo.mediaType));
-	vhcontent_type->hash(&method_name).put(
-		*new(pool) String(pool, "charset"), 
-		new(pool) VString(*oo.encoding));
-	vcontent_type=vhcontent_type;
-	
-	vfile.set(false/*tainted*/, buf, buf_size, 0/*file_name*/, vcontent_type);
 	r.write_no_lang(vfile);
 }
 
-static void _save(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
+static void _save(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
 
-	const String& file_spec=r.absolute(params->as_string(0, "file name must be string"));
+	const String& file_spec=r.absolute(params.as_string(0, FILE_NAME_MUST_BE_STRING));
 	
-	VXdoc::Output_options oo(vdoc.output_options);
-	xdoc2buf(pool, vdoc, method_name, params, 1, 
-		oo,
-		&file_spec,
-		0, 0);
-}
-
-static void _string(Request& r, const String& method_name, MethodParams *params) {
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
-	VXdoc::Output_options oo(vdoc.output_options);
-	char *buf; size_t buf_size;
-	xdoc2buf(pool, vdoc, method_name, params, 0, 
-		oo,
-		0/*not to file, to memory*/,
-		&buf, &buf_size);
+	XDocOutputOptions oo(r, get_options(params, 1));
+	xdoc2buf(r, vdoc, oo, &file_spec);
+}
+
+static void _string(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
+
+	XDocOutputOptions oo(r, get_options(params, 0));
+	String::C buf=xdoc2buf(r, vdoc, oo,
+		0/*file_name. not to file, to memory*/,
+		true/*use source charset to render, client charset to put to header*/);
+
 	// write out result
-	r.write_no_lang(*new(pool) String(pool, buf, buf_size));
+	r.write_no_lang(String(buf, String::L_AS_IS));
 }
 
-static void add_xslt_param(const Hash::Key& aattribute, Hash::Val *ameaning, 
-						   void *info) {
-	Value *meaning=static_cast<Value *>(ameaning);
-	Pool& pool=meaning->pool();
-	const char **transform_params=(const char **)info;
-	*transform_params++=pool.transcode(aattribute)->str;
-	*transform_params++=pool.transcode(meaning->as_string())->str;
-}
-static void _transform(Request& r, const String& method_name, MethodParams *params) {
-	//_asm int 3;
-	Pool& pool=r.pool();
-	VXdoc& vdoc=*static_cast<VXdoc *>(r.self);
+#ifndef DOXYGEN
+struct Add_xslt_param_info {
+	Request* r;
+	Array<const xmlChar*>* strings;
+	const xmlChar** current_transform_param;
+};
+#endif
+static void add_xslt_param(
+			   HashStringValue::key_type attribute, 
+			   HashStringValue::value_type meaning, 
+			   Add_xslt_param_info* info) {
+	xmlChar* s;
+	*info->current_transform_param++=(s=info->r->transcode(attribute)); *info->strings+=s;
+	*info->current_transform_param++=(s=info->r->transcode(meaning->as_string())); *info->strings+=s;
+}
 
-	// params
-	const char **transform_params=0;
-	if(params->size()>1) {
-		Value& vparams=params->as_no_junction(1, "transform parameters must be hash");
-		if(vparams.is_defined())
-			if(Hash *params=vparams.get_hash(&method_name)) {
-				transform_params=
-					(const char **)pool.malloc(sizeof(const char *)*params->size()*2+1);
-				params->for_each(add_xslt_param, transform_params);
-				transform_params[params->size()*2]=0;				
-			} else
-				throw Exception(0, 0,
-					&method_name,
-					"transform parameters parameter must be hash");
-	}
+static VXdoc& _transform(Request& r, const String* stylesheet_source, 
+						   VXdoc& vdoc, xsltStylesheetPtr stylesheet, const xmlChar** transform_params) 
+{
+	xmlDoc& xmldoc=vdoc.get_xmldoc();
 
-	// stylesheet
-	const String& stylesheet_filespec=r.absolute(params->as_string(0, "file name must be string"));
-	Stylesheet_connection_ptr connection=stylesheet_manager->get_connection(stylesheet_filespec);
-
-	// transform
-	xsltStylesheet *stylesheet=connection->stylesheet(false/*nocache*/);
-	xmlDoc *document=gdome_xml_doc_get_xmlDoc(vdoc.get_document(&method_name));
 	xsltTransformContext_auto_ptr transformContext(
-		xsltNewTransformContext(stylesheet, document));
+		xsltNewTransformContext(stylesheet, &xmldoc));
+	// make params literal
+	if (transformContext->globalVars == NULL) // strangly not initialized by xsltNewTransformContext
+		transformContext->globalVars = xmlHashCreate(20);
+	xsltQuoteUserParams(transformContext.get(), (const char**)transform_params);
+	// do transform
 	xmlDoc *transformed=xsltApplyStylesheetUser(
 		stylesheet,
-		document,
-		transform_params,
-		0/*const char *output*/,
+		&xmldoc,
+		0/*already quoted-inserted  transform_params*/,
+		0/*const char* output*/,
 		0/*FILE *profile*/,
 		transformContext.get());
-	if(!transformed || xmlHaveGenericErrors()) {
-		GdomeException exc=0;
-		throw Exception(0, 0,
-			&stylesheet_filespec, 
-			exc);
-	}
+	if(!transformed || xmlHaveGenericErrors())
+		throw XmlException(stylesheet_source);
 
 	//gdome_xml_doc_mkref dislikes XML_HTML_DOCUMENT_NODE  type, fixing
 	transformed->type=XML_DOCUMENT_NODE;
 	// constructing result
-	GdomeDocument *gdomeDocument=gdome_xml_doc_mkref(transformed);
-	if(!gdomeDocument)
-		throw Exception(0, 0,
-			&method_name,
-			"gdome_xml_doc_mkref failed");
-	VXdoc& result=*new(pool) VXdoc(pool, gdomeDocument);
+	VXdoc& result=*new VXdoc(r.charsets, *transformed);
 	/* grabbing options
 
 		<xsl:output
@@ -749,30 +648,76 @@ static void _transform(Request& r, const
 		!indent = "yes" | "no"
 		!media-type = string /> 
 	*/
-	memset(&result.output_options, 0, sizeof(result.output_options));
-	VXdoc::Output_options& oo=result.output_options;
+	XDocOutputOptions& oo=result.output_options;
 
-	oo.method=stylesheet->method?&pool.transcode(stylesheet->method):0;
-	oo.encoding=stylesheet->encoding?&pool.transcode(stylesheet->encoding):0;
-	oo.mediaType=stylesheet->mediaType?&pool.transcode(stylesheet->mediaType):0;
-	oo.doctypeSystem=stylesheet->doctypeSystem?&pool.transcode(stylesheet->doctypeSystem):0;
-	oo.doctypePublic=stylesheet->doctypePublic?&pool.transcode(stylesheet->doctypePublic):0;
-	oo.indent=stylesheet->indent!=0;
-	oo.version=stylesheet->version?&pool.transcode(stylesheet->version):0;
-	oo.standalone=stylesheet->standalone!=0;
-	oo.omitXmlDeclaration=stylesheet->omitXmlDeclaration!=0;
+	oo.method=stylesheet->method?&r.transcode(stylesheet->method):0;
+	oo.encoding=stylesheet->encoding?&r.transcode(stylesheet->encoding):0;
+	oo.mediaType=stylesheet->mediaType?&r.transcode(stylesheet->mediaType):0;
+	oo.indent=stylesheet->indent;
+	oo.version=stylesheet->version?&r.transcode(stylesheet->version):0;
+	oo.standalone=stylesheet->standalone;
+	oo.omitXmlDeclaration=stylesheet->omitXmlDeclaration;
 
-	// write out result
-	r.write_no_lang(result);
+	// return
+	return result;
 }
+static void _transform(Request& r, MethodParams& params) {
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
 
-// constructor
+	// params
+	Array<const xmlChar*> transform_strings;
+	const xmlChar** transform_params=0;
+	if(params.count()>1)
+		if(HashStringValue* hash=params.as_hash(1)) {
+			transform_params=new(UseGC) const xmlChar*[hash->count()*2+1];
+			Add_xslt_param_info info={
+				&r, 
+				&transform_strings,
+				transform_params
+			};
+			hash->for_each<Add_xslt_param_info*>(add_xslt_param, &info);
+			transform_params[hash->count()*2]=0;
+		}
 
-MXdoc::MXdoc(Pool& apool) : MXnode(apool) {
-	set_name(*NEW String(pool(), XDOC_CLASS_NAME));
+	VXdoc* result;
+	if(Value *vxdoc=params[0].as(VXDOC_TYPE)) { // stylesheet (xdoc)
+		xmlDoc& stylesheetdoc=static_cast<VXdoc *>(vxdoc)->get_xmldoc();
+		// compile xdoc stylesheet
+		xsltStylesheet_auto_ptr stylesheet_ptr(xsltParseStylesheetDoc(&stylesheetdoc)); 
+		if(xmlHaveGenericErrors())
+			throw XmlException(0);
+		if(!stylesheet_ptr.get())
+			throw Exception("xml",
+				0,
+				"stylesheet failed to compile");
+		// strange thing - xsltParseStylesheetDoc records document and destroys it in stylesheet destructor
+		// we don't need that
+		stylesheet_ptr->doc=0;
+
+		// transform!
+		result=&_transform(r, 0,
+			vdoc, stylesheet_ptr.get(),
+			transform_params);
+	} else { // stylesheet (file name)
+		// extablish stylesheet connection
+		const String& stylesheet_filespec=
+			r.absolute(params.as_string(0, "stylesheet must be file name (string) or DOM document (xdoc)"));
+		Stylesheet_connection_ptr connection=stylesheet_manager->get_connection(stylesheet_filespec);
+
+		// load and compile file to stylesheet [or get cached if any]
+		// transform!
+		result=&_transform(r, &stylesheet_filespec, vdoc, connection->stylesheet(),
+			transform_params);
+	}
+
+	// write out result
+	r.write_no_lang(*result);
+}
 
-	/// @test how to create empty type html?
+// constructor
 
+/// @test how to create empty type html?
+MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME, xnode_class) {
 	/// DOM1
 
 	// Element createElement(in DOMString tagName) raises(DOMException);
@@ -791,22 +736,29 @@ MXdoc::MXdoc(Pool& apool) : MXnode(apool
 	add_native_method("createAttribute", Method::CT_DYNAMIC, _createAttribute, 1, 1);
 	// EntityReference createEntityReference(in DOMString name) raises(DOMException);
 	add_native_method("createEntityReference", Method::CT_DYNAMIC, _createEntityReference, 1, 1);
-	// NodeList getElementsByTagName(in DOMString tagname);
-	add_native_method("getElementsByTagName", Method::CT_DYNAMIC, _getElementsByTagName, 1, 1);
-	// ^xdoc.getElementsByTagNameNS[namespaceURI;localName] = array of nodes
-	add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2);
 
-	/// DOM2(?)
+	/// DOM2
 
 	// ^xdoc.getElementById[elementId]
 	add_native_method("getElementById", Method::CT_DYNAMIC, _getElementById, 1, 1);
 
+    // Node (in Node importedNode, in boolean deep) raises(DOMException)
+	add_native_method("importNode", Method::CT_DYNAMIC, _importNode, 2, 2);
+
+	// Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
+	add_native_method("createAttributeNS", Method::CT_DYNAMIC, _createAttributeNS, 2, 2);
+
+	// Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
+	add_native_method("createElementNS", Method::CT_DYNAMIC, _createElementNS, 2, 2);
+
 	/// parser
 	
 	// ^xdoc::create{qualifiedName}
-	add_native_method("create", Method::CT_DYNAMIC, _create, 1, 1);	
-	// ^xdoc::set[<some>xml</some>]
-	add_native_method("set", Method::CT_DYNAMIC, _set, 1, 1);
+	// ^xdoc::create[<some>xml</some>]
+	// ^xdoc::create[URI][<some>xml</some>]
+	add_native_method("create", Method::CT_DYNAMIC, _create, 1, 2);	
+	// for backward compatibility with <=v 1.82 2002/01/31 11:51:46 paf
+	add_native_method("set", Method::CT_DYNAMIC, _create, 1, 1);
 
 	// ^xdoc::load[some.xml]
 	add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);
@@ -823,29 +775,18 @@ MXdoc::MXdoc(Pool& apool) : MXnode(apool
 	// ^xdoc.file[options hash] file with "<doc/>"
 	add_native_method("file", Method::CT_DYNAMIC, _file, 0, 1);
 
-	// ^xdoc.transform[stylesheet file_name]
-	// ^xdoc.transform[stylesheet file_name;params hash]
+	// ^xdoc.transform[stylesheet file_name/xdoc]
+	// ^xdoc.transform[stylesheet file_name/xdoc;params hash]
 	add_native_method("transform", Method::CT_DYNAMIC, _transform, 1, 2);
 
 }
 
-void MXdoc::configure_admin(Request& r) {
-}
-
-// global variable
+# else
 
-Methoded *Xdoc_class;
+#include "classes.h"
 
-// creator
+// global variable
 
-#endif
+DECLARE_CLASS_VAR(xdoc, 0, 0); // fictive
 
-Methoded *MXdoc_create(Pool& pool) {
-	return 
-#ifdef XML
-		Xdoc_class=new(pool) MXdoc(pool)
-#else
-		0
 #endif
-	;
-}