parser3/src/classes/xdoc.C - diff

Return to xdoc.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/xdoc.C between versions 1.108.2.17 and 1.136

version 1.108.2.17, 2003/03/07 14:56:59	version 1.136, 2004/02/17 15:08:14
Line 1	Line 1
/** @file	/** @file
Parser: @b xdoc parser class.	Parser: @b xdoc parser class.

Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001-2004 ArtLebedev Group (http://www.artlebedev.com)
Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
*/	*/

#include "classes.h"	#include "pa_config_includes.h"

#ifdef XML	#ifdef XML

static const char* IDENT_XDOC_C="$Date$";	static const char * const IDENT_XDOC_C="$Date$";

	#include "gdome.h"
	#include "libxml/tree.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_vmethod_frame.h"	#include "pa_vmethod_frame.h"

#include "pa_stylesheet_connection.h"	#include "pa_stylesheet_manager.h"
#include "pa_request.h"	#include "pa_request.h"
#include "pa_vxdoc.h"	#include "pa_vxdoc.h"
#include "pa_charset.h"	#include "pa_charset.h"
#include "pa_vfile.h"	#include "pa_vfile.h"
	#include "pa_xml_exception.h"
#include "xnode.h"	#include "xnode.h"

#include "gdome.h"
#include "libxml/tree.h"
extern "C" {
#include "gdomecore/gdome-xml-node.h"
#include "gdomecore/gdome-xml-document.h"
};
#include "libxslt/xsltInternals.h"
#include "libxslt/transform.h"
#include "libxslt/xsltutils.h"
#include "libxslt/variables.h"

// defines	// defines

#define XDOC_CLASS_NAME "xdoc"	#define XDOC_CLASS_NAME "xdoc"
Line 43 extern "C" {	Line 43 extern "C" {

class MXdoc: public MXnode {	class MXdoc: public MXnode {
public: // VStateless_class	public: // VStateless_class
ValuePtr create_new_value() { return ValuePtr(new VXdoc(0, 0, 0)); }	Value* create_new_value(Pool&) { return new VXdoc(0, 0); }

public:	public:
MXdoc();	MXdoc();

public: // Methoded
void configure_admin(Request& r);
};	};

// global variable	// global variable
Line 159 private:	Line 157 private:

// methods	// methods

static void writeNode(Request& r, StringPtr method_name, GdomeNode *node,	static void writeNode(Request& r, GdomeNode *node,
GdomeException exc) {	GdomeException exc) {
if(!node \|\| exc)	if(!node \|\| exc)
throw Exception(	throw XmlException(0, exc);
method_name,
exc);

Pool& pool=r.pool();

// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&pool, &r.charsets, node)));	r.write_no_lang(*new VXnode(&r.charsets, node));
}	}

// Element createElement(in DOMString tagName) raises(DOMException);	// Element createElement(in DOMString tagName) raises(DOMException);
static void _createElement(Request& r, StringPtr method_name, MethodParams* params) {	static void _createElement(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

StringPtr tagName=params->as_string(0, "tagName must be string");	const String& tagName=params.as_string(0, "tagName must be string");

GdomeException exc;	GdomeException exc;
GdomeNode *node=	GdomeNode *node=
(GdomeNode *)gdome_doc_createElement(vdoc.get_document(method_name),	(GdomeNode *)gdome_doc_createElement(vdoc.get_document(),
r.transcode(tagName).get(),	r.transcode(tagName).use(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, node, exc);
	}

	// Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
	static void _createElementNS(Request& r, MethodParams& params) {
	VXdoc& vdoc=GET_SELF(r, VXdoc);

	// namespaceURI;localName
	const String& namespaceURI=params.as_string(0, "namespaceURI must be string");
	const String& qualifiedName=params.as_string(1, "qualifiedName must be string");

	GdomeException exc;
	GdomeNode *node=
	(GdomeNode *)gdome_doc_createElementNS(vdoc.get_document(),
	r.transcode(namespaceURI).use(),
	r.transcode(qualifiedName).use(),
	&exc);
	writeNode(r, node, exc);
}	}

// DocumentFragment createDocumentFragment()	// DocumentFragment createDocumentFragment()
static void _createDocumentFragment(Request& r, StringPtr method_name, MethodParams* ) {	static void _createDocumentFragment(Request& r, MethodParams&) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

GdomeException exc;	GdomeException exc;
GdomeNode *node=	GdomeNode *node=
(GdomeNode *)gdome_doc_createDocumentFragment(	(GdomeNode *)gdome_doc_createDocumentFragment(
vdoc.get_document(method_name),	vdoc.get_document(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, node, exc);
}	}

// Text createTextNode(in DOMString data);	// Text createTextNode(in DOMString data);
static void _createTextNode(Request& r, StringPtr method_name, MethodParams* params) {	static void _createTextNode(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

StringPtr data=params->as_string(0, "data must be string");	const String& data=params.as_string(0, "data must be string");

GdomeException exc;	GdomeException exc;
GdomeNode node=(GdomeNode )gdome_doc_createTextNode(	GdomeNode node=(GdomeNode )gdome_doc_createTextNode(
vdoc.get_document(method_name),	vdoc.get_document(),
r.transcode(data).get(),	r.transcode(data).use(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, node, exc);
}	}

// Comment createComment(in DOMString data)	// Comment createComment(in DOMString data)
static void _createComment(Request& r, StringPtr method_name, MethodParams* params) {	static void _createComment(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

StringPtr data=params->as_string(0, "data must be string");	const String& data=params.as_string(0, "data must be string");

GdomeException exc;	GdomeException exc;
GdomeNode node=(GdomeNode )gdome_doc_createComment(	GdomeNode node=(GdomeNode )gdome_doc_createComment(
vdoc.get_document(method_name),	vdoc.get_document(),
r.transcode(data).get(),	r.transcode(data).use(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, node, exc);
}	}

// CDATASection createCDATASection(in DOMString data) raises(DOMException);	// CDATASection createCDATASection(in DOMString data) raises(DOMException);
static void _createCDATASection(Request& r, StringPtr method_name, MethodParams* params) {	static void _createCDATASection(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

StringPtr data=params->as_string(0, "data must be string");	const String& data=params.as_string(0, "data must be string");

GdomeException exc;	GdomeException exc;
GdomeNode node=(GdomeNode )gdome_doc_createCDATASection(	GdomeNode node=(GdomeNode )gdome_doc_createCDATASection(
vdoc.get_document(method_name),	vdoc.get_document(),
r.transcode(data).get(),	r.transcode(data).use(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, node, exc);
}	}

// ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) raises(DOMException);	// ProcessingInstruction createProcessingInstruction(in DOMString target,in DOMString data) raises(DOMException);
static void _createProcessingInstruction(Request& r, StringPtr method_name, MethodParams* params) {	static void _createProcessingInstruction(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

StringPtr target=params->as_string(0, "data must be string");	const String& target=params.as_string(0, "data must be string");
StringPtr data=params->as_string(1, "data must be string");	const String& data=params.as_string(1, "data must be string");

GdomeException exc;	GdomeException exc;
GdomeNode node=(GdomeNode )gdome_doc_createProcessingInstruction(	GdomeNode node=(GdomeNode )gdome_doc_createProcessingInstruction(
vdoc.get_document(method_name),	vdoc.get_document(),
r.transcode(target).get(),	r.transcode(target).use(),
r.transcode(data).get(),	r.transcode(data).use(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, node, exc);
}	}

// Attr createAttribute(in DOMString name) raises(DOMException);	// Attr createAttribute(in DOMString name) raises(DOMException);
static void _createAttribute(Request& r, StringPtr method_name, MethodParams* params) {	static void _createAttribute(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

StringPtr name=params->as_string(0, "name must be string");	const String& name=params.as_string(0, "name must be string");

GdomeException exc;	GdomeException exc;
GdomeNode node=(GdomeNode )gdome_doc_createAttribute(	GdomeNode node=(GdomeNode )gdome_doc_createAttribute(
vdoc.get_document(method_name),	vdoc.get_document(),
r.transcode(name).get(),	r.transcode(name).use(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, node, exc);
}	}

	// Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
	static void _createAttributeNS(Request& r, MethodParams& params) {
	VXdoc& vdoc=GET_SELF(r, VXdoc);

	// namespaceURI;qualifiedName
	const String& namespaceURI=params.as_string(0, "namespaceURI must be string");
	const String& qualifiedName=params.as_string(1, "name must be string");

	GdomeException exc;
	GdomeNode node=(GdomeNode )gdome_doc_createAttributeNS(
	vdoc.get_document(),
	r.transcode(namespaceURI).use(),
	r.transcode(qualifiedName).use(),
	&exc);
	writeNode(r, node, exc);
	}

// EntityReference createEntityReference(in DOMString name) raises(DOMException);	// EntityReference createEntityReference(in DOMString name) raises(DOMException);
static void _createEntityReference(Request& r, StringPtr method_name, MethodParams* params) {	static void _createEntityReference(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

StringPtr name=params->as_string(0, "name must be string");	const String& name=params.as_string(0, "name must be string");

GdomeException exc;	GdomeException exc;
GdomeNode node=(GdomeNode )gdome_doc_createEntityReference(	GdomeNode node=(GdomeNode )gdome_doc_createEntityReference(
vdoc.get_document(method_name),	vdoc.get_document(),
r.transcode(name).get(),	r.transcode(name).use(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, node, exc);
}	}

// NodeList getElementsByTagName(in DOMString name);	// NodeList getElementsByTagName(in DOMString name);
static void _getElementsByTagName(Request& r, StringPtr method_name, MethodParams* params) {	static void _getElementsByTagName(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

StringPtr name=params->as_string(0, "name must be string");	const String& name=params.as_string(0, "name must be string");

VHashPtr result(new VHash);	VHash& result=*new VHash;
GdomeException exc;	GdomeException exc;
if(GdomeNodeList *nodes=	if(GdomeNodeList *nodes=
gdome_doc_getElementsByTagName(	gdome_doc_getElementsByTagName(
vdoc.get_document(method_name),	vdoc.get_document(),
r.transcode(name).get(),	r.transcode(name).use(),
&exc)) {	&exc)) {
gulong length=gdome_nl_length(nodes, &exc);	gulong length=gdome_nl_length(nodes, &exc);
for(gulong i=0; i<length; i++) {	for(gulong i=0; i<length; i++)
StringPtr skey(new String);	result.hash().put(
*skey << pool.format_integer(i);	String::Body::Format(i),
	new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));
result->hash(Exception::undefined_source).put(
skey,
ValuePtr(new VXnode(&pool, &r.charsets, gdome_nl_item(nodes, i, &exc))));
}
} else if(exc)	} else if(exc)
throw Exception(	throw XmlException(0, exc);
method_name,
exc);

// write out result	// write out result
r.write_no_lang(result);	r.write_no_lang(result);
}	}

static void _getElementsByTagNameNS(Request& r, StringPtr method_name, MethodParams* params) {	static void _getElementsByTagNameNS(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

// namespaceURI;localName	// namespaceURI;localName
StringPtr namespaceURI=params->as_string(0, "namespaceURI must be string");	const String& namespaceURI=params.as_string(0, "namespaceURI must be string");
StringPtr localName=params->as_string(1, "localName must be string");	const String& localName=params.as_string(1, "localName must be string");

GdomeException exc;	GdomeException exc;
VHashPtr result(new VHash);	VHash& result=*new VHash;
if(GdomeNodeList *nodes=	if(GdomeNodeList *nodes=
gdome_doc_getElementsByTagNameNS(	gdome_doc_getElementsByTagNameNS(
vdoc.get_document(method_name),	vdoc.get_document(),
r.transcode(namespaceURI).get(),	r.transcode(namespaceURI).use(),
r.transcode(localName).get(),	r.transcode(localName).use(),
&exc)) {	&exc)) {
gulong length=gdome_nl_length(nodes, &exc);	gulong length=gdome_nl_length(nodes, &exc);
for(gulong i=0; i<length; i++) {	for(gulong i=0; i<length; i++)
StringPtr skey(new String);	result.hash().put(
*skey << pool.format_integer(i);	String::Body::Format(i),
	new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));
result->hash(Exception::undefined_source).put(
skey,
ValuePtr(new VXnode(&pool, &r.charsets, gdome_nl_item(nodes, i, &exc))));
}
}	}

// write out result	// write out result
r.write_no_lang(result);	r.write_no_lang(result);
}	}

static void _getElementById(Request& r, StringPtr method_name, MethodParams* params) {	static void _getElementById(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

// elementId	// elementId
StringPtr elementId=params->as_string(0, "elementID must be string");	const String& elementId=params.as_string(0, "elementID must be string");

GdomeException exc;	GdomeException exc;
if(GdomeNode node=(GdomeNode )gdome_doc_getElementById(	if(GdomeNode node=(GdomeNode )gdome_doc_getElementById(
vdoc.get_document(method_name),	vdoc.get_document(),
r.transcode(elementId).get(),	r.transcode(elementId).use(),
&exc)) {	&exc)) {
// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&pool, &r.charsets, node)));	r.write_no_lang(*new VXnode(&r.charsets, node));
} else if(exc \|\| xmlHaveGenericErrors())	} else if(exc \|\| xmlHaveGenericErrors())
throw Exception(	throw XmlException(&elementId, exc);
method_name,
exc);
}	}

static void _importNode(Request& r, StringPtr method_name, MethodParams* params) {	static void _importNode(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

GdomeNode *importedNode=	GdomeNode *importedNode=
as_node(method_name, params, 0, "importedNode must be node");	as_node(params, 0, "importedNode must be node");
bool deep=	bool deep=
params->as_bool(1, "deep must be bool", r);	params.as_bool(1, "deep must be bool", r);

GdomeException exc;	GdomeException exc;
GdomeNode *outputNode=gdome_doc_importNode(vdoc.get_document(method_name),	GdomeNode *outputNode=gdome_doc_importNode(vdoc.get_document(),
importedNode,	importedNode,
deep, &exc);	deep, &exc);
if(exc)	if(exc)
throw Exception(	throw XmlException(0, exc);
method_name,
exc);

// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&pool, &r.charsets, outputNode)));	r.write_no_lang(*new VXnode(&r.charsets, outputNode));
}	}
/*	/*
GdomeElement gdome_doc_createElementNS (GdomeDocument self, GdomeDOMString namespaceURI, GdomeDOMString qualifiedName, 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);	GdomeAttr gdome_doc_createAttributeNS (GdomeDocument self, GdomeDOMString namespaceURI, GdomeDOMString qualifiedName, GdomeException *exc);
*/	*/

static void _create(Request& r, StringPtr method_name, MethodParams* params) {	static void _create(Request& r, MethodParams& params) {
Pool& pool=r.pool();
Charset& source_charset=r.charsets.source();	Charset& source_charset=r.charsets.source();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

ValuePtr param=(*params)[params->count()-1];	Value& param=params[params.count()-1];
GdomeDocument *document;	GdomeDocument *document;
if(param->get_junction()) { // {<?xml?>...}	bool set_encoding=false;
Temp_lang temp_lang(r, String::UL_XML);	if(param.get_junction()) { // {<?xml?>...}
StringPtr xml=r.process_to_string(param);	Temp_lang temp_lang(r, String::L_XML);
	const String& xml=r.process_to_string(param);

CharPtr cstr=xml->cstr(String::UL_UNSPECIFIED);	const char* cstr=xml.cstr(String::L_UNSPECIFIED, 0, &r.charsets);
document=(GdomeDocument *)	document=(GdomeDocument *)
gdome_xml_n_mkref((xmlNode *)xmlParseMemory(	gdome_xml_n_mkref((xmlNode *)xmlParseMemory(
cstr, strlen(cstr)	cstr, strlen(cstr)
));	));
	//printf("document=0x%p\n", document);
if(!document \|\| xmlHaveGenericErrors()) {	if(!document \|\| xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(	throw XmlException(0, exc);
method_name,
exc);
}	}

	// must be last action in if, see after if}
} else { // [name]	} else { // [name]
StringPtr qualifiedName=param->as_string(&pool);	const String& qualifiedName=param.as_string();

GdomeException exc;	GdomeException exc;
/*	#if 0
GdomeDocumentType *documentType=gdome_di_createDocumentType (	GdomeDocumentType *documentType=gdome_di_createDocumentType (
docimpl,	docimpl,
r.transcode(qualifiedName),	r.transcode(qualifiedName),
0/publicId /,	0/publicId/,
0/systemId /,	0/systemId/,
&exc);	&exc);
if(!documentType \|\| exc \|\| xmlHaveGenericErrors())	if(!documentType \|\| exc \|\| xmlHaveGenericErrors())
throw Exception(	throw Exception(
method_name,	method_name,
exc);	exc);
*/	/// +xalan createXMLDecl ?
document=gdome_di_createDocument (domimpl,	#endif
	document=gdome_di_createDocument(domimpl,
0/namespaceURI/,	0/namespaceURI/,
r.transcode(qualifiedName).get(),	r.transcode(qualifiedName).use(),
0/doctype/,	0/doctype/,
&exc);	&exc);
if(!document \|\| exc \|\| xmlHaveGenericErrors())	if(!document \|\| exc \|\| xmlHaveGenericErrors())
throw Exception(	throw XmlException(0, exc);
method_name,
exc);

xmlDoc *doc=gdome_xml_doc_get_xmlDoc(document);
CharPtr source_charset_name=source_charset.name()->cstr();
doc->encoding=source_charset.transcode_buf2xchar(source_charset_name, strlen(source_charset_name));

/// +xalan createXMLDecl ?	set_encoding=true;
	// must be last action in if, see after if}
	}
	// must be first action after if}
	// replace any previous parsed source
	{
	vdoc.set_document(&r.charsets, document);
	GdomeException exc;
	gdome_doc_unref(document, &exc);
}	}

// URI	// URI
const char* URI_cstr;	const char* URI_cstr;
CharPtr URI_cstr_ptr;	const char* URI_cstr_ptr;
if(params->count()>1) { // absolute(param)	if(params.count()>1) { // absolute(param)
StringPtr URI=params->as_string(0, "URI must be string");	const String& URI=params.as_string(0, "URI must be string");
URI_cstr=URI_cstr_ptr=r.absolute(URI)->cstr();	URI_cstr=URI_cstr_ptr=r.absolute(URI).cstr();
} else // default = disk path to requested document	} else // default = disk path to requested document
URI_cstr=r.request_info.path_translated;	URI_cstr=r.request_info.path_translated;
xmlDoc *doc=gdome_xml_doc_get_xmlDoc(document);	xmlDoc *doc=gdome_xml_doc_get_xmlDoc(document);
if(URI_cstr)	if(URI_cstr)
doc->URL=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));	doc->URL=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));

// replace any previous parsed source	if(set_encoding) {
vdoc.set_document(&pool, &r.charsets, document);	const char* source_charset_name=source_charset.NAME().cstr();
	doc->encoding=source_charset.transcode_buf2xchar(source_charset_name, strlen(source_charset_name));
	}
}	}

static void _load(Request& r, StringPtr method_name, MethodParams* params) {	static void _load(Request& r, MethodParams& params) {
Pool& pool=r.pool();
Charset& source_charset=r.charsets.source();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

// filespec	// filespec
StringPtr file_name=params->as_string(0, "uri must be string");	const String* uri=&params.as_string(0, "uri must be string");
StringPtr uri=r.absolute(file_name);	const char* uri_cstr;
	if(uri->pos("://")==STRING_NOT_FOUND) // disk path
void *data; size_t size;	uri_cstr=r.absolute(*uri).cstr(String::L_FILE_SPEC);
File_read_result file=file_read(pool, source_charset, uri, false/not text/,	else // xxx://
params->count()>1?params->as_no_junction(1, "additional params must be hash")	uri_cstr=uri->cstr(String::L_AS_IS); // leave as-is for xmlParseFile to handle
->get_hash(method_name)
:0);

	/// todo!! add SAFE MODE!!
GdomeDocument document=(GdomeDocument )	GdomeDocument document=(GdomeDocument )
gdome_xml_n_mkref((xmlNode *)xmlParseMemory(file.data, file.size));	gdome_xml_n_mkref((xmlNode *)xmlParseFile(uri_cstr));
if(!document \|\| xmlHaveGenericErrors()) {	if(!document \|\| xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(uri, exc);	throw XmlException(uri, exc);
}	}
CharPtr URI_cstr=uri->cstr();	// must be first action after if}
	// replace any previous parsed source
	{
	vdoc.set_document(&r.charsets, document);
	GdomeException exc;
	gdome_doc_unref(document, &exc);
	}
	/* xmlParseFile does that itself. old peace for xmlParseMemory
	const char* URI_cstr=uri->cstr();
xmlDoc *doc=gdome_xml_doc_get_xmlDoc(document);	xmlDoc *doc=gdome_xml_doc_get_xmlDoc(document);
if(URI_cstr)	if(URI_cstr)
doc->URL=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));	doc->URL=r.charsets.source().transcode_buf2xchar(URI_cstr, strlen(URI_cstr));
	*/
// replace any previous parsed source
vdoc.set_document(&pool, &r.charsets, document);
}	}

static void param_option_over_output_option(Pool& pool,	static void param_option_over_output_option(
HashStringValue& param_options, const char* option_name,	HashStringValue& param_options, const char* option_name,
StringPtr& output_option) {	const String*& output_option) {
if(ValuePtr value=param_options.get(StringPtr(new String(option_name))))	if(Value* value=param_options.get(String::Body(option_name)))
output_option=value->as_string(&pool);	output_option=&value->as_string();
}	}
static void param_option_over_output_option(Pool& pool,	static void param_option_over_output_option(
HashStringValue& param_options, const char* option_name,	HashStringValue& param_options, const char* option_name,
bool& output_option) {	bool& output_option) {
if(ValuePtr value=param_options.get(StringPtr(new String(option_name)))) {	if(Value* value=param_options.get(String::Body(option_name))) {
StringPtr s=value->as_string(&pool);	const String& s=value->as_string();
if(*s=="yes")	if(s=="yes")
output_option=true;	output_option=true;
else if(*s=="no")	else if(s=="no")
output_option=false;	output_option=false;
else	else
throw Exception("parser.runtime",	throw Exception("parser.runtime",
s,	&s,
"%s must be either 'yes' or 'no'", option_name);	"%s must be either 'yes' or 'no'", option_name);
}	}
}	}

/// @test valid_options check	/// @test valid_options check
static void prepare_output_options(Request& r,	static void prepare_output_options(Request& r,
StringPtr method_name, MethodParams* params, int index,	MethodParams& params, size_t index,
VXdoc::Output_options& oo) {	VXdoc::Output_options& oo) {
Pool& pool=r.pool();
/*	/*
<xsl:output	<xsl:output
!method = "xml" \| "html" \| "text" \| qname-but-not-ncname	!method = "xml" \| "html" \| "text" \| qname-but-not-ncname
Line 543 static void prepare_output_options(Reque	Line 554 static void prepare_output_options(Reque
*/	*/

// configuring with options from parameter...	// configuring with options from parameter...
if(params->count()>index) {	if(params.count()>index) {
ValuePtr voptions=params->as_no_junction(index, "options must be string");	Value& voptions=params.as_no_junction(index, "options must be string");
if(voptions->is_defined()) {	if(voptions.is_defined()) {
if(HashStringValue *options=voptions->get_hash(method_name)) {	if(HashStringValue *options=voptions.get_hash()) {
// $.method[xml\|html\|text]	// $.method[xml\|html\|text]
if(ValuePtr vmethod=options->get(StringPtr(new String(XDOC_OUTPUT_METHOD_OPTION_NAME))))	if(Value* vmethod=options->get(String::Body(XDOC_OUTPUT_METHOD_OPTION_NAME)))
oo.method=vmethod->as_string(&pool);	oo.method=&vmethod->as_string();

// $.version[1.0]	// $.version[1.0]
param_option_over_output_option(pool, *options, "version", oo.version);	param_option_over_output_option(*options, "version", oo.version);
// $.encoding[windows-1251\|...]	// $.encoding[windows-1251\|...]
param_option_over_output_option(pool, *options, "encoding", oo.encoding);	param_option_over_output_option(*options, "encoding", oo.encoding);
// $.omit-xml-declaration[yes\|no]	// $.omit-xml-declaration[yes\|no]
param_option_over_output_option(pool, *options, "omit-xml-declaration", oo.omitXmlDeclaration);	param_option_over_output_option(*options, "omit-xml-declaration", oo.omitXmlDeclaration);
// $.standalone[yes\|no]	// $.standalone[yes\|no]
param_option_over_output_option(pool, *options, "standalone", oo.standalone);	param_option_over_output_option(*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]	// $.indent[yes\|no]
param_option_over_output_option(pool, *options, "indent", oo.indent);	param_option_over_output_option(*options, "indent", oo.indent);
// $.media-type[text/{html\|xml\|plain}]	// $.media-type[text/{html\|xml\|plain}]
param_option_over_output_option(pool, *options, "media-type", oo.mediaType);	param_option_over_output_option(*options, "media-type", oo.mediaType);
}	}
}	}
}	}

// default encoding from pool	// default encoding from pool
if(!oo.encoding)	if(!oo.encoding)
oo.encoding=r.charsets.source().name();	oo.encoding=new String(r.charsets.source().NAME(), String::L_TAINTED);
// default method=xml	// default method=xml
if(!oo.method)	if(!oo.method)
oo.method=StringPtr(new String(XDOC_OUTPUT_METHOD_OPTION_VALUE_XML));	oo.method=new String(XDOC_OUTPUT_METHOD_OPTION_VALUE_XML);
// default mediaType = depending on method	// default mediaType = depending on method
if(!oo.mediaType) {	if(!oo.mediaType) {
if(*oo.method==XDOC_OUTPUT_METHOD_OPTION_VALUE_XML)	if(*oo.method==XDOC_OUTPUT_METHOD_OPTION_VALUE_XML)
oo.mediaType=StringPtr(new String("text/xml"));	oo.mediaType=new String("text/xml");
else if(*oo.method==XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML)	else if(*oo.method==XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML)
oo.mediaType=StringPtr(new String("text/html"));	oo.mediaType=new String("text/html");
else // XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT & all others	else // XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT & all others
oo.mediaType=StringPtr(new String("text/plain"));	oo.mediaType=new String("text/plain");
	}
	}

	/// patching piece from libxslt not to set meta encoding
	static void
	pa_xsltSaveResultToMem(
	xmlChar*& doc_txt_ptr, int& doc_txt_len,
	xmlDocPtr result,
	xsltStylesheetPtr style,
	xmlCharEncodingHandler* encoder)
	{
	const xmlChar *encoding;
	int base;
	const xmlChar *method;
	int indent;
	xmlOutputBufferPtr buf = 0;

	if ((result == NULL) \|\| (style == NULL))
	return;
	if ((result->children == NULL) \|\|
	((result->children->type == XML_DTD_NODE) &&
	(result->children->next == NULL)))
	return;

	if ((style->methodURI != NULL) &&
	((style->method == NULL) \|\|
	(!xmlStrEqual(style->method, (const xmlChar *) "xhtml")))) {
	xsltGenericError(xsltGenericErrorContext,
	"xsltSaveResultTo : unknown ouput method\n");
	return;
	}

	XSLT_GET_IMPORT_PTR(method, style, method)
	XSLT_GET_IMPORT_PTR(encoding, style, encoding)
	XSLT_GET_IMPORT_INT(indent, style, indent);

	if ((method == NULL) && (result->type == XML_HTML_DOCUMENT_NODE))
	method = (const xmlChar *) "html";

	if ((method != NULL) &&
	(xmlStrEqual(method, (const xmlChar *) "html")
	\|\|xmlStrEqual(method, (const xmlChar *) "xhtml"))) {
	if (indent == -1)
	indent = 1;
	//
	// * xmlDocDumpFormatMemoryEnc:
	// Note it is up to the caller of this function to free the
	// allocated memory with xmlFree()
	//
	// we wont free anything, and wont copy that data anymore [already done inside and zeroterminated]
	xmlDocDumpFormatMemoryEnc(result, &doc_txt_ptr, &doc_txt_len, (const char *) encoding,
	indent);
	} else if ((method != NULL) &&
	(xmlStrEqual(method, (const xmlChar *) "text"))) {
	xmlNodePtr cur;
	buf = xmlAllocOutputBuffer(encoder);

	cur = result->children;
	while (cur != NULL) {
	if (cur->type == XML_TEXT_NODE)
	xmlOutputBufferWriteString(buf, (const char *) cur->content);

	/*
	* Skip to next node
	*/
	if (cur->children != NULL) {
	if ((cur->children->type != XML_ENTITY_DECL) &&
	(cur->children->type != XML_ENTITY_REF_NODE) &&
	(cur->children->type != XML_ENTITY_NODE)) {
	cur = cur->children;
	continue;
	}
	}
	if (cur->next != NULL) {
	cur = cur->next;
	continue;
	}

	do {
	cur = cur->parent;
	if (cur == NULL)
	break;
	if (cur == (xmlNodePtr) style->doc) {
	cur = NULL;
	break;
	}
	if (cur->next != NULL) {
	cur = cur->next;
	break;
	}
	} while (cur != NULL);
	}
	} else {
	int omitXmlDecl;
	int standalone;
	buf = xmlAllocOutputBuffer(encoder);

	XSLT_GET_IMPORT_INT(omitXmlDecl, style, omitXmlDeclaration);
	XSLT_GET_IMPORT_INT(standalone, style, standalone);

	if (omitXmlDecl != 1) {
	xmlOutputBufferWriteString(buf, "<?xml version=");
	if (result->version != NULL)
	xmlBufferWriteQuotedString(buf->buffer, result->version);
	else
	xmlOutputBufferWriteString(buf, "\"1.0\"");
	if (encoding == NULL) {
	if (result->encoding != NULL)
	encoding = result->encoding;
	else if (result->charset != XML_CHAR_ENCODING_UTF8)
	encoding = (const xmlChar *)
	xmlGetCharEncodingName((xmlCharEncoding)
	result->charset);
	}
	if (encoding != NULL) {
	xmlOutputBufferWriteString(buf, " encoding=");
	xmlBufferWriteQuotedString(buf->buffer, (xmlChar *) encoding);
	}
	switch (standalone) {
	case 0:
	xmlOutputBufferWriteString(buf, " standalone=\"no\"");
	break;
	case 1:
	xmlOutputBufferWriteString(buf, " standalone=\"yes\"");
	break;
	default:
	break;
	}
	xmlOutputBufferWriteString(buf, "?>\n");
	}
	if (result->children != NULL) {
	xmlNodePtr child = result->children;

	while (child != NULL) {
	xmlNodeDumpOutput(buf, result, child, 0, (indent == 1),
	(const char *) encoding);
	if (child->type == XML_DTD_NODE)
	xmlOutputBufferWriteString(buf, "\n");
	child = child->next;
	}
	xmlOutputBufferWriteString(buf, "\n");
	}
	}

	if(buf) {
	xmlOutputBufferFlush(buf);
	if(buf->conv) {
	doc_txt_len=buf->conv->use;
	doc_txt_ptr=buf->conv->content;
	} else {
	doc_txt_len=buf->buffer->use;
	doc_txt_ptr=buf->buffer->content;
	}

	if(doc_txt_ptr && doc_txt_len)
	doc_txt_ptr=BAD_CAST pa_strdup((const char*)doc_txt_ptr, doc_txt_len);

	xmlOutputBufferClose(buf);
}	}
}	}

struct Xdoc2buf_result {	struct Xdoc2buf_result {
char* ptr;	char* str;
size_t size;	size_t length;
};	};
static Xdoc2buf_result xdoc2buf(Request& r, VXdoc& vdoc,	static Xdoc2buf_result xdoc2buf(Request& r, VXdoc& vdoc,
StringPtr method_name, MethodParams* params, int index,	MethodParams& params, int index,
VXdoc::Output_options& oo,	VXdoc::Output_options& oo,
StringPtr file_spec) {	const String* file_spec) {
Xdoc2buf_result result;	Xdoc2buf_result result;
Pool& pool=r.pool();	prepare_output_options(r, params, index,
prepare_output_options(r, method_name, params, index,
oo);	oo);

CharPtr encoding_cstr=oo.encoding->cstr();	const char* encoding_cstr=oo.encoding->cstr();
xmlCharEncodingHandler *encoder=xmlFindCharEncodingHandler(encoding_cstr);	xmlCharEncodingHandler *encoder=xmlFindCharEncodingHandler(encoding_cstr);
if(!encoder)	if(!encoder)
throw Exception("parser.runtime",	throw Exception("parser.runtime",
method_name,	0,
"encoding '%s' not supported", encoding_cstr.get());	"encoding '%s' not supported", encoding_cstr);
// UTF-8 encoder contains empty input/output converters,	// UTF-8 encoder contains empty input/output converters,
// which is wrong for xmlOutputBufferCreateIO	// which is wrong for xmlOutputBufferCreateIO
// while zero encoder goes perfectly	// while zero encoder goes perfectly
if(encoder && strcmp(encoder->name, "UTF-8")==0)	const char* encoder_name=encoder->name;
	if(strcmp(encoder_name, "UTF-8")==0)
encoder=0;	encoder=0;

xmlOutputBuffer_auto_ptr outputBuffer(xmlAllocOutputBuffer(encoder));

xsltStylesheet_auto_ptr stylesheet(xsltNewStylesheet());	xsltStylesheet_auto_ptr stylesheet(xsltNewStylesheet());
if(!stylesheet.get())	if(!stylesheet.get())
throw Exception(0,	throw Exception(0,
method_name,	0,
"xsltNewStylesheet failed");	"xsltNewStylesheet failed");

#define OOS2STYLE(name) \	#define OOS2STYLE(name) \
stylesheet->name=oo.name?BAD_CAST g_strdup(r.transcode(oo.name)->str):0	stylesheet->name=oo.name?BAD_CAST xmlMemStrdup(r.transcode(*oo.name)->str):0
#define OOE2STYLE(name) \	#define OOE2STYLE(name) \
stylesheet->name=oo.name	stylesheet->name=oo.name

OOS2STYLE(method);	OOS2STYLE(method);
OOS2STYLE(encoding);	OOS2STYLE(encoding);
OOS2STYLE(mediaType);	OOS2STYLE(mediaType);
OOS2STYLE(doctypeSystem);	// OOS2STYLE(doctypeSystem);
OOS2STYLE(doctypePublic);	// OOS2STYLE(doctypePublic);
OOE2STYLE(indent);	OOE2STYLE(indent);
OOS2STYLE(version);	OOS2STYLE(version);
OOE2STYLE(standalone);	OOE2STYLE(standalone);
OOE2STYLE(omitXmlDeclaration);	OOE2STYLE(omitXmlDeclaration);

xmlDoc *document=gdome_xml_doc_get_xmlDoc(vdoc.get_document(method_name));	xmlDoc *document=gdome_xml_doc_get_xmlDoc(vdoc.get_document());
if(xsltSaveResultTo(outputBuffer.get(), document, stylesheet.get())<0) {	document->encoding=BAD_CAST xmlMemStrdup(encoder_name);

	xmlChar* doc_txt_ptr=0;
	int doc_txt_len=0;
	pa_xsltSaveResultToMem(doc_txt_ptr, doc_txt_len, document, stylesheet.get(), encoder);
	if(xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(	throw XmlException(0, exc);
method_name,
exc);
}	}

// write out result	result.length=doc_txt_len;
char *gnome_buf; size_t gnome_size;	result.str=(char*)doc_txt_ptr;
if(outputBuffer->conv) {
gnome_size=outputBuffer->conv->use;
gnome_buf=(char *)outputBuffer->conv->content;
} else {
gnome_size=outputBuffer->buffer->use;
gnome_buf=(char *)outputBuffer->buffer->content;
}
if(file_spec)	if(file_spec)
file_write(file_spec,	file_write(*file_spec,
gnome_buf, gnome_size,	result.str, result.length,
true/as_text/);	true/as_text/);
else if(result.size=gnome_size) {
result.ptr=pool.copy(gnome_buf, gnome_size);
} else
result.ptr=0;

return result;	return result;
}	}

static void _file(Request& r, StringPtr method_name, MethodParams* params) {	static void _file(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);
VXdoc::Output_options oo(vdoc.output_options);	VXdoc::Output_options oo(vdoc.output_options);
Xdoc2buf_result buf=xdoc2buf(r, vdoc, method_name, params, 0,	Xdoc2buf_result buf=xdoc2buf(r, vdoc, params, 0,
oo,	oo,
StringPtr(0)/not to file, to memory/);	0/not to file, to memory/);
// write out result	// write out result
r.write_no_lang(String(buf.ptr, buf.size));	r.write_no_lang(String(buf.str, buf.length));

// write out result	// write out result
VFilePtr vfile(new VFile);	VFile& vfile=*new VFile;
ValuePtr vcontent_type;	VHash& vhcontent_type=*new VHash;
VHashPtr vhcontent_type(new VHash);	vhcontent_type.hash().put(
vhcontent_type->hash(method_name).put(
value_name,	value_name,
ValuePtr(new VString(oo.mediaType)));	new VString(*oo.mediaType));
vhcontent_type->hash(method_name).put(	vhcontent_type.hash().put(
StringPtr(new String("charset")),	String::Body("charset"),
ValuePtr(new VString(oo.encoding)));	new VString(*oo.encoding));
vcontent_type=vhcontent_type;

vfile->set(pool, false/tainted/, buf.ptr?buf.ptr:""/to distinguish from stat-ed file/, buf.size,	vfile.set(false/tainted/, buf.str?buf.str:""/to distinguish from stat-ed file/, buf.length,
0/file_name/, vcontent_type);	0/file_name/, &vhcontent_type);
r.write_no_lang(vfile);	r.write_no_lang(vfile);
}	}

static void _save(Request& r, StringPtr method_name, MethodParams* params) {	static void _save(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

StringPtr 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);	VXdoc::Output_options oo(vdoc.output_options);
xdoc2buf(r, vdoc, method_name, params, 1,	xdoc2buf(r, vdoc, params, 1,
oo,	oo,
file_spec);	&file_spec);
}	}

static void _string(Request& r, StringPtr method_name, MethodParams* params) {	static void _string(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);
VXdoc::Output_options oo(vdoc.output_options);	VXdoc::Output_options oo(vdoc.output_options);
Xdoc2buf_result buf=xdoc2buf(r, vdoc, method_name, params, 0,	Xdoc2buf_result buf=xdoc2buf(r, vdoc, params, 0,
oo,	oo,
StringPtr(0)/not to file, to memory/);	0/not to file, to memory/);
// write out result	// write out result
r.write_no_lang(String(buf.ptr, buf.size));	r.write_no_lang(String(buf.str, buf.length));
}	}

#ifndef DOXYGEN	#ifndef DOXYGEN
struct Add_xslt_param_info {	struct Add_xslt_param_info {
Request* r;	Request* r;
	Array<GdomeDOMString_auto_ptr>* strings;
const char** current_transform_param;	const char** current_transform_param;
};	};
#endif	#endif
static void add_xslt_param(	static void add_xslt_param(
HashStringValue::key_type attribute,	HashStringValue::key_type attribute,
HashStringValue::value_type meaning,	HashStringValue::value_type meaning,
Add_xslt_param_info* info) {	Add_xslt_param_info* info) {
*info->current_transform_param++=info->r->transcode(attribute)->str;	GdomeDOMString_auto_ptr s;
*info->current_transform_param++=info->r->transcode(meaning->as_string(&info->r->pool()))->str;	info->current_transform_param++=(s=info->r->transcode(attribute))->str; info->strings+=s;
}	info->current_transform_param++=(s=info->r->transcode(meaning->as_string()))->str; info->strings+=s;
static VXdocPtr _transform(Request& r, StringPtr doc_source, StringPtr stylesheet_source,	}
VXdoc& vdoc, xsltStylesheetPtr stylesheet, const char** transform_params) {
Pool& pool=r.pool();	static VXdoc& _transform(Request& r, const String* stylesheet_source,
xmlDoc *document=gdome_xml_doc_get_xmlDoc(vdoc.get_document(doc_source));	VXdoc& vdoc, xsltStylesheetPtr stylesheet, const char** transform_params)
	{
	xmlDoc *document=gdome_xml_doc_get_xmlDoc(vdoc.get_document());
xsltTransformContext_auto_ptr transformContext(	xsltTransformContext_auto_ptr transformContext(
xsltNewTransformContext(stylesheet, document));	xsltNewTransformContext(stylesheet, document));
// make params literal	// make params literal
if (transformContext->globalVars == NULL) // strangly not initialized by xsltNewTransformContext	if (transformContext->globalVars == NULL) // strangly not initialized by xsltNewTransformContext
transformContext->globalVars = xmlHashCreate(20);	transformContext->globalVars = xmlHashCreate(20);
xsltQuoteUserParams(transformContext.get(), transform_params);	xsltQuoteUserParams(transformContext.get(), transform_params);
// do transform	// do transform
Line 748 static VXdocPtr _transform(Request& r, S	Line 902 static VXdocPtr _transform(Request& r, S
transformContext.get());	transformContext.get());
if(!transformed \|\| xmlHaveGenericErrors()) {	if(!transformed \|\| xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(	throw XmlException(stylesheet_source, exc);
stylesheet_source,
exc);
}	}

//gdome_xml_doc_mkref dislikes XML_HTML_DOCUMENT_NODE type, fixing	//gdome_xml_doc_mkref dislikes XML_HTML_DOCUMENT_NODE type, fixing
Line 759 static VXdocPtr _transform(Request& r, S	Line 911 static VXdocPtr _transform(Request& r, S
GdomeDocument *gdomeDocument=gdome_xml_doc_mkref(transformed);	GdomeDocument *gdomeDocument=gdome_xml_doc_mkref(transformed);
if(!gdomeDocument)	if(!gdomeDocument)
throw Exception(0,	throw Exception(0,
doc_source,	0,
"gdome_xml_doc_mkref failed");	"gdome_xml_doc_mkref failed");
VXdocPtr result(new VXdoc(&pool, &r.charsets, gdomeDocument));	VXdoc& result=*new VXdoc(&r.charsets, gdomeDocument);
/* grabbing options	/* grabbing options

<xsl:output	<xsl:output
Line 777 static VXdocPtr _transform(Request& r, S	Line 929 static VXdocPtr _transform(Request& r, S
!indent = "yes" \| "no"	!indent = "yes" \| "no"
!media-type = string />	!media-type = string />
*/	*/
VXdoc::Output_options& oo=result->output_options;	VXdoc::Output_options& oo=result.output_options;

oo.method=stylesheet->method?r.transcode(stylesheet->method, stylesheet_source):StringPtr(0);	oo.method=stylesheet->method?&r.transcode(stylesheet->method):0;
oo.encoding=stylesheet->encoding?r.transcode(stylesheet->encoding, stylesheet_source):StringPtr(0);	oo.encoding=stylesheet->encoding?&r.transcode(stylesheet->encoding):0;
oo.mediaType=stylesheet->mediaType?r.transcode(stylesheet->mediaType, stylesheet_source):StringPtr(0);	oo.mediaType=stylesheet->mediaType?&r.transcode(stylesheet->mediaType):0;
oo.doctypeSystem=stylesheet->doctypeSystem?r.transcode(stylesheet->doctypeSystem, stylesheet_source):StringPtr(0);
oo.doctypePublic=stylesheet->doctypePublic?r.transcode(stylesheet->doctypePublic, stylesheet_source):StringPtr(0);
oo.indent=stylesheet->indent!=0;	oo.indent=stylesheet->indent!=0;
oo.version=stylesheet->version?r.transcode(stylesheet->version, stylesheet_source):StringPtr(0);	oo.version=stylesheet->version?&r.transcode(stylesheet->version):0;
oo.standalone=stylesheet->standalone!=0;	oo.standalone=stylesheet->standalone!=0;
oo.omitXmlDeclaration=stylesheet->omitXmlDeclaration!=0;	oo.omitXmlDeclaration=stylesheet->omitXmlDeclaration!=0;

// return	// return
return result;	return result;
}	}
static void _transform(Request& r, StringPtr method_name, MethodParams* params) {	static void _transform(Request& r, MethodParams& params) {
Pool& pool=r.pool();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

// params	// params
smart_ptr<const char*> transform_params;	Array<GdomeDOMString_auto_ptr> transform_strings;
if(params->count()>1) {	const char** transform_params=0;
ValuePtr vparams=params->as_no_junction(1, "transform parameters must be hash");	if(params.count()>1) {
if(!vparams->is_string())	Value& vparams=params.as_no_junction(1, "transform parameters must be hash");
if(HashStringValue* params=vparams->get_hash(method_name)) {	if(!vparams.is_string())
transform_params=smart_ptr<const char>(new const char[params->count()*2+1]);	if(HashStringValue* hash=vparams.get_hash()) {
	transform_params=new(UseGC) const char[hash->count()2+1];
Add_xslt_param_info info={	Add_xslt_param_info info={
&r,	&r,
	&transform_strings,
transform_params	transform_params
};	};
params->for_each(add_xslt_param, &info);	hash->for_each(add_xslt_param, &info);
transform_params[params->count()*2]=0;	transform_params[hash->count()*2]=0;
} else	} else
throw Exception("parser.runtime",	throw Exception("parser.runtime",
method_name,	0,
"transform parameters parameter must be hash");	"transform parameters parameter must be hash");
}	}

VXdocPtr result;	VXdoc* result;
ValuePtr vmaybe_xdoc=(*params)[0];	if(Value *vxdoc=params[0].as(VXDOC_TYPE, false)) { // stylesheet (xdoc)
if(Value *vxdoc=vmaybe_xdoc->as(VXDOC_TYPE, false)) { // stylesheet (xdoc)
xmlDoc *document=gdome_xml_doc_get_xmlDoc(	xmlDoc *document=gdome_xml_doc_get_xmlDoc(
static_cast<VXdoc *>(vxdoc)->get_document(method_name));	static_cast<VXdoc *>(vxdoc)->get_document());
// compile xdoc stylesheet	// compile xdoc stylesheet
xsltStylesheet_auto_ptr stylesheet_ptr(xsltParseStylesheetDoc(document));	xsltStylesheet_auto_ptr stylesheet_ptr(xsltParseStylesheetDoc(document));
// strange thing - xsltParseStylesheetDoc records document and destroys it in stylesheet destructor
// we don't need that
stylesheet_ptr->doc=0;
if(xmlHaveGenericErrors()) {	if(xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(method_name, exc);	throw XmlException(0, exc);
}	}
if(!stylesheet_ptr.get())	if(!stylesheet_ptr.get())
throw Exception("xml",	throw Exception("xml",
method_name,	0,
"stylesheet failed to compile");	"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!	// transform!
result=_transform(r, method_name, method_name,	result=&_transform(r, 0,
vdoc, stylesheet_ptr.get(),	vdoc, stylesheet_ptr.get(),
transform_params);	transform_params);
} else { // stylesheet (file name)	} else { // stylesheet (file name)
// extablish stylesheet connection	// extablish stylesheet connection
StringPtr stylesheet_filespec=	const String& stylesheet_filespec=
r.absolute(params->as_string(0, "stylesheet must be file name (string) or DOM document (xdoc)"));	r.absolute(params.as_string(0, "stylesheet must be file name (string) or DOM document (xdoc)"));
Stylesheet_connectionPtr connection=stylesheet_manager.get_connection(stylesheet_filespec);	Stylesheet_connection_ptr connection=stylesheet_manager->get_connection(stylesheet_filespec);

// load and compile file to stylesheet [or get cached if any]	// load and compile file to stylesheet [or get cached if any]
// transform!	// transform!
result=_transform(r, method_name, stylesheet_filespec,	result=&_transform(r, &stylesheet_filespec, vdoc, connection->stylesheet(),
vdoc, connection->stylesheet(false/nocache/),
transform_params);	transform_params);
}	}

// write out result	// write out result
r.write_no_lang(result);	r.write_no_lang(*result);
}	}

// constructor	// constructor

/// @test how to create empty type html?	/// @test how to create empty type html?
MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME, xnode_class.get()) {	MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME, xnode_class) {
/// DOM1	/// DOM1

// Element createElement(in DOMString tagName) raises(DOMException);	// Element createElement(in DOMString tagName) raises(DOMException);
Line 888 MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME,	Line 1037 MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME,
// Node (in Node importedNode, in boolean deep) raises(DOMException)	// Node (in Node importedNode, in boolean deep) raises(DOMException)
add_native_method("importNode", Method::CT_DYNAMIC, _importNode, 2, 2);	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);

// NodeList getElementsByTagNameNS(in DOMString namespaceURI, in DOMString localName);	// NodeList getElementsByTagNameNS(in DOMString namespaceURI, in DOMString localName);
add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2);	add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2);

Line 901 MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME,	Line 1056 MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME,
add_native_method("set", Method::CT_DYNAMIC, _create, 1, 1);	add_native_method("set", Method::CT_DYNAMIC, _create, 1, 1);

// ^xdoc::load[some.xml]	// ^xdoc::load[some.xml]
add_native_method("load", Method::CT_DYNAMIC, _load, 1, 2);	add_native_method("load", Method::CT_DYNAMIC, _load, 1, 1);

// ^xdoc.save[some.xml]	// ^xdoc.save[some.xml]
// ^xdoc.save[some.xml;options hash]	// ^xdoc.save[some.xml;options hash]
Line 921 MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME,	Line 1076 MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME,

}	}

void MXdoc::configure_admin(Request& r) {
}

# else	# else

#endif	#include "classes.h"

	// global variable

	DECLARE_CLASS_VAR(xdoc, 0, 0); // fictive

	#endif

E-mail:

Removed from v.1.108.2.17
changed lines
	Added in v.1.136