--- parser3/src/classes/xdoc.C	2011/05/18 01:25:06	1.166
+++ parser3/src/classes/xdoc.C	2015/04/06 22:27:25	1.181
@@ -1,7 +1,7 @@
 /** @file
 	Parser: @b xdoc parser class.
 
-	Copyright (c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)
+	Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)
 	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
 */
 
@@ -9,8 +9,6 @@
 
 #ifdef XML
 
-static const char * const IDENT_XDOC_C="$Date: 2011/05/18 01:25:06 $";
-
 #include "libxml/tree.h"
 #include "libxml/HTMLtree.h"
 #include "libxslt/xsltInternals.h"
@@ -28,6 +26,9 @@ static const char * const IDENT_XDOC_C="
 #include "pa_vfile.h"
 #include "pa_xml_exception.h"
 #include "xnode.h"
+#include "pa_charsets.h"
+
+volatile const char * IDENT_XDOC_C="$Id: xdoc.C,v 1.181 2015/04/06 22:27:25 moko Exp $";
 
 // defines
 
@@ -217,24 +218,23 @@ pa_importNode (xmlDoc& xmldoc, xmlNode&
 
 // Element createElement(in DOMString tagName) raises(DOMException);
 static void _createElement(Request& r, MethodParams& params) {
+	xmlChar* tagName=as_xmlname(r, params, 0, "tagName must be string");
+
 	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) {
+	xmlChar* namespaceURI=as_xmlnsuri(r, params, 0);
+	xmlChar* qualifiedName=as_xmlqname(r, params, 1);
+
 	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);
 
@@ -258,20 +258,20 @@ static void _createDocumentFragment(Requ
 
 // Text createTextNode(in DOMString data);
 static void _createTextNode(Request& r, MethodParams& params) {
+	xmlChar* data=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
+
 	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, MethodParams& params) {
-	VXdoc& vdoc=GET_SELF(r, VXdoc);
+	xmlChar* data=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
 
-	xmlChar* data=as_xmlchar(r, params, 0, DATA_MUST_BE_STRING);
+	VXdoc& vdoc=GET_SELF(r, VXdoc);
 
 	xmlNode *node=xmlNewComment(data);
 	writeNode(r, vdoc, node);
@@ -279,46 +279,46 @@ static void _createComment(Request& r, M
 
 // CDATASection createCDATASection(in DOMString data) raises(DOMException);
 static void _createCDATASection(Request& r, MethodParams& params) {
+	xmlChar* data=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
+
 	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, MethodParams& params) {
+	xmlChar* target=as_xmlchar(r, params, 0, XML_DATA_MUST_BE_STRING);
+	xmlChar* data=as_xmlchar(r, params, 1, XML_DATA_MUST_BE_STRING);
+
 	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, MethodParams& params) {
+	xmlChar* name=as_xmlname(r, params, 0);
+
 	VXdoc& vdoc=GET_SELF(r, VXdoc);
 	xmlDoc& xmldoc=vdoc.get_xmldoc();
 
-	xmlChar* name=as_xmlchar(r, params, 0, NAME_MUST_BE_STRING);
-
 	xmlNode *node=(xmlNode*)xmlNewDocProp(&xmldoc, name, 0);
 	writeNode(r, vdoc, node);
 }
 
 // Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
 static void _createAttributeNS(Request& r, MethodParams& params) {
+	xmlChar* namespaceURI=as_xmlnsuri(r, params, 0);
+	xmlChar* qualifiedName=as_xmlqname(r, params, 1);
+
 	VXdoc& vdoc=GET_SELF(r, VXdoc);
 	xmlDoc& xmldoc=vdoc.get_xmldoc();
 
-	xmlChar* namespaceURI=as_xmlchar(r, params, 0, NAMESPACEURI_MUST_BE_STRING);
-	xmlChar* qualifiedName=as_xmlchar(r, params, 1, NAME_MUST_BE_STRING);
-
 	xmlChar* prefix=0;
 	xmlChar* localName=xmlSplitQName2(qualifiedName, &prefix);
 
@@ -334,42 +334,37 @@ static void _createAttributeNS(Request&
 
 // EntityReference createEntityReference(in DOMString name) raises(DOMException);
 static void _createEntityReference(Request& r, MethodParams& params) {
+	xmlChar* name=as_xmlname(r, params, 0);
+
 	VXdoc& vdoc=GET_SELF(r, VXdoc);
 	xmlDoc& xmldoc=vdoc.get_xmldoc();
 
-	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, MethodParams& params) {
+	xmlChar* elementId=as_xmlname(r, params, 0, "elementID must be string");
+
 	VXdoc& vdoc=GET_SELF(r, VXdoc);
 	xmlDoc& xmldoc=vdoc.get_xmldoc();
 
-	// elementId
-	xmlChar* elementId=as_xmlchar(r, params, 0, "elementID must be string");
-
-	if(xmlNode *node=pa_getElementById(xmldoc, elementId)) {
-		// write out result
+	if(xmlNode *node=pa_getElementById(xmldoc, elementId))
 		writeNode(r, vdoc, node);
-	}
 }
 
 static void _importNode(Request& r, MethodParams& params) {
+	xmlNode& importedNode=as_node(params, 0, "importedNode must be node");
+	bool deep=params.as_bool(1, "deep must be bool", r);
+
 	VXdoc& vdoc=GET_SELF(r, VXdoc);
 	xmlDoc& xmldoc=vdoc.get_xmldoc();
 
-	xmlNode& importedNode=
-		as_node(params, 0, "importedNode must be node");
-	bool deep=
-		params.as_bool(1, "deep must be bool", r);
-
 	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);
@@ -386,17 +381,20 @@ static void _create(Request& r, MethodPa
 		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);
+		String::Body sbody=xml.cstr_to_string_body_untaint(r.flang, r.connection(false), &r.charsets);
 		xmldoc=xmlParseMemory(sbody.cstr(), sbody.length());
 
 		//printf("document=0x%p\n", document);
 		if(!xmldoc || xmlHaveGenericErrors())
-			throw XmlException(0);
+			throw XmlException(0, r);
 
 		// must be last action in if, see after if}
 	} else { // [localName]
 		if(const String* value = param.get_string()){
 			xmlChar* localName=r.transcode(*value);
+			if(xmlValidateNCName(localName, 0) != 0)
+				throw XmlException(0, XML_INVALID_LOCAL_NAME, localName);
+
 #if 0
 			GdomeDocumentType *documentType=gdome_di_createDocumentType (
 				docimpl, 
@@ -412,10 +410,11 @@ static void _create(Request& r, MethodPa
 #endif
 			xmldoc=xmlNewDoc(0);
 			if(!xmldoc || xmlHaveGenericErrors())
-				throw XmlException(0);
+				throw XmlException(0, r);
+
 			xmlNode* node=xmlNewChild((xmlNode*)xmldoc, NULL, localName, NULL);
 			if(!node || xmlHaveGenericErrors())
-				throw XmlException(0);
+				throw XmlException(0, r);
 
 			set_encoding=true;
 			// must be last action in if, see after if}
@@ -423,7 +422,7 @@ static void _create(Request& r, MethodPa
 			VFile* vfile=param.as_vfile(String::L_AS_IS);
 			xmldoc=xmlParseMemory(vfile->value_ptr(), vfile->value_size());
 			if(!xmldoc || xmlHaveGenericErrors())
-				throw XmlException(0);
+				throw XmlException(0, r);
 		}
 	}
 	// must be first action after if}
@@ -460,7 +459,7 @@ static void _load(Request& r, MethodPara
 	/// @todo!! add SAFE MODE!!
 	xmlDoc* xmldoc=xmlParseFile(uri_cstr);
 	if(!xmldoc || xmlHaveGenericErrors())
-		throw XmlException(uri);
+		throw XmlException(uri, r);
 	
 	// must be first action after if}
 	// replace any previous parsed source
@@ -471,24 +470,22 @@ String::C xdoc2buf(Request& r, VXdoc& vd
 					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;
+	Charset* render=0;
+	Charset* header=0;
 	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();
+		render=&r.charsets.source();
+		header=&r.charsets.client();
 	} else {
-		header_encoding=render_encoding=oo.encoding->cstr();
+		header=render=&charsets.get(oo.encoding->change_case(r.charsets.source(), String::CC_UPPER));
 	}
+	const char* render_encoding=render->NAME_CSTR();
+	const char* header_encoding=header->NAME_CSTR();
 
 	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 renderer goes perfectly 
-	if(strcmp(render_encoding, "UTF-8")==0)
+	if(render->isUTF8())
 		renderer=0;
 
 	xmlOutputBuffer_auto_ptr outputBuffer(xmlAllocOutputBuffer(renderer));
@@ -520,11 +517,20 @@ String::C xdoc2buf(Request& r, VXdoc& vd
 		stylesheet->encoding=BAD_CAST xmlMemStrdup(header_encoding);
 	if(xsltSaveResultTo(outputBuffer.get(), &xmldoc, stylesheet.get())<0
 		|| xmlHaveGenericErrors())
-		throw XmlException(0);
+		throw XmlException(0, r);
 
 	// write out result
 	char *gnome_str;
 	size_t gnome_length;
+#ifdef LIBXML2_NEW_BUFFER
+	if(outputBuffer->conv) {
+		gnome_length=xmlBufUse(outputBuffer->conv);
+		gnome_str=(char *)xmlBufContent(outputBuffer->conv);
+	} else {
+		gnome_length=xmlOutputBufferGetSize(&(*outputBuffer));
+		gnome_str=(char *)xmlOutputBufferGetContent(&(*outputBuffer));
+	}
+#else
 	if(outputBuffer->conv) {
 		gnome_length=outputBuffer->conv->use;
 		gnome_str=(char *)outputBuffer->conv->content;
@@ -532,6 +538,7 @@ String::C xdoc2buf(Request& r, VXdoc& vd
 		gnome_length=outputBuffer->buffer->use;
 		gnome_str=(char *)outputBuffer->buffer->content;
 	}
+#endif
 
 	if(file_spec){
 		file_write(r.charsets,
@@ -551,7 +558,8 @@ inline HashStringValue* get_options(Meth
 static void _file(Request& r, MethodParams& params) {
 	VXdoc& vdoc=GET_SELF(r, VXdoc);
 
-	XDocOutputOptions oo(r, get_options(params, 0));
+	XDocOutputOptions oo(vdoc.output_options);
+	oo.append(r, get_options(params, 0), true/* $.name[filename] could be specified by user */);
 	String::C buf=xdoc2buf(r, vdoc, oo, 0/*file_name. not to file, to memory*/);
 
 	VFile& vfile=*new VFile;
@@ -563,8 +571,7 @@ static void _file(Request& r, MethodPara
 		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);
+	vfile.set_binary(false/*not tainted*/, buf.str?buf.str:""/*to distinguish from stat-ed file*/, buf.length, oo.filename, &vhcontent_type);
 
 	// write out result
 	r.write_no_lang(vfile);
@@ -575,14 +582,16 @@ static void _save(Request& r, MethodPara
 
 	const String& file_spec=r.absolute(params.as_string(0, FILE_NAME_MUST_BE_STRING));
 	
-	XDocOutputOptions oo(r, get_options(params, 1));
+	XDocOutputOptions oo(vdoc.output_options);
+	oo.append(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));
+	XDocOutputOptions oo(vdoc.output_options);
+	oo.append(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*/);
@@ -627,7 +636,7 @@ static VXdoc& _transform(Request& r, con
 		0/*FILE *profile*/,
 		transformContext.get());
 	if(!transformed || xmlHaveGenericErrors())
-		throw XmlException(stylesheet_source);
+		throw XmlException(stylesheet_source, r);
 
 	//gdome_xml_doc_mkref dislikes XML_HTML_DOCUMENT_NODE  type, fixing
 	transformed->type=XML_DOCUMENT_NODE;
@@ -668,8 +677,8 @@ static void _transform(Request& r, Metho
 	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];
+		if(HashStringValue* hash=params.as_hash(1, "transform options")) {
+			transform_params=new const xmlChar*[hash->count()*2+1];
 			Add_xslt_param_info info={
 				&r, 
 				&transform_strings,
@@ -685,7 +694,7 @@ static void _transform(Request& r, Metho
 		// compile xdoc stylesheet
 		xsltStylesheet_auto_ptr stylesheet_ptr(xsltParseStylesheetDoc(&stylesheetdoc)); 
 		if(xmlHaveGenericErrors())
-			throw XmlException(0);
+			throw XmlException(0, r);
 		if(!stylesheet_ptr.get())
 			throw Exception("xml",
 				0,