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.19.2.5 and 1.108.2.19.2.21

version 1.108.2.19.2.5, 2003/03/20 14:19:08	version 1.108.2.19.2.21, 2003/04/02 10:24:02
Line 5	Line 5
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* IDENT_XDOC_C="$Date$";

	#include "gdome.h"
	#include "libxml/tree.h"
	#include "libxslt/xsltInternals.h"
	#include "libxslt/transform.h"
	#include "libxslt/xsltutils.h"
	#include "libxslt/variables.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 "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 41 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() { return new VXdoc(0, 0); }

public:	public:
MXdoc();	MXdoc();
Line 159 private:	Line 157 private:

// methods	// methods

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

// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&&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, const String& method_name, MethodParams* params) {	static void _createElement(Request& r, MethodParams* params) {
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& 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).get(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, node, exc);
}	}

// DocumentFragment createDocumentFragment()	// DocumentFragment createDocumentFragment()
static void _createDocumentFragment(Request& r, const String& method_name, MethodParams* ) {	static void _createDocumentFragment(Request& r, MethodParams* ) {
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, const String& method_name, MethodParams* params) {	static void _createTextNode(Request& r, MethodParams* params) {
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& 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).get(),
&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, const String& method_name, MethodParams* params) {	static void _createComment(Request& r, MethodParams* params) {
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& 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).get(),
&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, const String& method_name, MethodParams* params) {	static void _createCDATASection(Request& r, MethodParams* params) {
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& 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).get(),
&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, const String& method_name, MethodParams* params) {	static void _createProcessingInstruction(Request& r, MethodParams* params) {
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& target=params->as_string(0, "data must be string");	const String& target=params->as_string(0, "data must be string");
Line 247 static void _createProcessingInstruction	Line 243 static void _createProcessingInstruction

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).get(),
r.transcode(data).get(),	r.transcode(data).get(),
&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, const String& method_name, MethodParams* params) {	static void _createAttribute(Request& r, MethodParams* params) {
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& 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).get(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, node, exc);
}	}
// EntityReference createEntityReference(in DOMString name) raises(DOMException);	// EntityReference createEntityReference(in DOMString name) raises(DOMException);
static void _createEntityReference(Request& r, const String& method_name, MethodParams* params) {	static void _createEntityReference(Request& r, MethodParams* params) {
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& 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).get(),
&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, const String& method_name, MethodParams* params) {	static void _getElementsByTagName(Request& r, MethodParams* params) {
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& 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).get(),
&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++)
const String& skey(new String);	result.hash().put(
*skey << pool.format_integer(i);	StringBody::Format(i),
	new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));
result->hash(0).put(
skey,
ValuePtr(new VXnode(&&r.charsets, gdome_nl_item(nodes, i, &exc))));
}
} else if(exc)	} else if(exc)
throw Exception(	throw Exception(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, const String& method_name, MethodParams* params) {	static void _getElementsByTagNameNS(Request& r, MethodParams* params) {
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

// namespaceURI;localName	// namespaceURI;localName
Line 320 static void _getElementsByTagNameNS(Requ	Line 310 static void _getElementsByTagNameNS(Requ
const String& 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).get(),
r.transcode(localName).get(),	r.transcode(localName).get(),
&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++)
const String& skey(new String);	result.hash().put(
*skey << pool.format_integer(i);	StringBody::Format(i),
	new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));
result->hash(0).put(
skey,
ValuePtr(new VXnode(&&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, const String& method_name, MethodParams* params) {	static void _getElementById(Request& r, MethodParams* params) {
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

// elementId	// elementId
Line 350 static void _getElementById(Request& r,	Line 336 static void _getElementById(Request& r,

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).get(),
&exc)) {	&exc)) {
// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&&r.charsets, node)));	r.write_no_lang(*new VXnode(&r.charsets, node));
} else if(exc \|\| xmlHaveGenericErrors())	} else if(exc \|\| xmlHaveGenericErrors())
throw Exception(	throw Exception(
method_name,	&elementId,
exc);	exc);
}	}

static void _importNode(Request& r, const String& method_name, MethodParams* params) {	static void _importNode(Request& r, MethodParams* params) {
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 Exception(0, exc);
method_name,
exc);

// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&&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, const String& method_name, MethodParams* params) {	static void _create(Request& r, MethodParams* params) {
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?>...}
	Temp_lang temp_lang(r, String::L_XML);
const String& xml=r.process_to_string(param);	const String& xml=r.process_to_string(param);

const char* cstr=xml->cstr(String::UL_UNSPECIFIED);	const char* cstr=xml.cstr(String::L_UNSPECIFIED);
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 Exception(0, exc);
method_name,
exc);
}	}

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

GdomeException exc;	GdomeException exc;
/*	/*
Line 422 static void _create(Request& r, const St	Line 408 static void _create(Request& r, const St
throw Exception(	throw Exception(
method_name,	method_name,
exc);	exc);
	/// +xalan createXMLDecl ?
*/	*/
document=gdome_di_createDocument (domimpl,	document=gdome_di_createDocument (domimpl,
0/namespaceURI/,	0/namespaceURI/,
Line 429 static void _create(Request& r, const St	Line 416 static void _create(Request& r, const St
0/doctype/,	0/doctype/,
&exc);	&exc);
if(!document \|\| exc \|\| xmlHaveGenericErrors())	if(!document \|\| exc \|\| xmlHaveGenericErrors())
throw Exception(	throw Exception(0, exc);
method_name,
exc);

xmlDoc *doc=gdome_xml_doc_get_xmlDoc(document);
const char* 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
Line 445 static void _create(Request& r, const St	Line 434 static void _create(Request& r, const St
const char* URI_cstr_ptr;	const char* URI_cstr_ptr;
if(params->count()>1) { // absolute(param)	if(params->count()>1) { // absolute(param)
const String& 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(&&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, const String& method_name, MethodParams* params) {	static void _load(Request& r, MethodParams* params) {
Charset& source_charset=r.charsets.source();	Charset& source_charset=r.charsets.source();
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

Line 464 static void _load(Request& r, const Stri	Line 455 static void _load(Request& r, const Stri
const String& file_name=params->as_string(0, "uri must be string");	const String& file_name=params->as_string(0, "uri must be string");
const String& uri=r.absolute(file_name);	const String& uri=r.absolute(file_name);

void *data; size_t size;
File_read_result file=file_read(source_charset, uri, false/not text/,	File_read_result file=file_read(source_charset, uri, false/not text/,
params->count()>1?params->as_no_junction(1, "additional params must be hash")	params->count()>1?params->as_no_junction(1, "additional params must be hash")
->get_hash(method_name)	.get_hash()
:0);	:0);

GdomeDocument document=(GdomeDocument )	GdomeDocument document=(GdomeDocument )
gdome_xml_n_mkref((xmlNode *)xmlParseMemory(file.data, file.length));	gdome_xml_n_mkref((xmlNode *)xmlParseMemory(file.str, file.length));
if(!document \|\| xmlHaveGenericErrors()) {	if(!document \|\| xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(uri, exc);	throw Exception(&uri, exc);
	}
	// must be first action after if}
	// replace any previous parsed source
	{
	vdoc.set_document(&r.charsets, document);
	GdomeException exc;
	gdome_doc_unref(document, &exc);
}	}
const char* URI_cstr=uri->cstr();
	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=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));

// replace any previous parsed source
vdoc.set_document(&&r.charsets, document);
}	}

static void param_option_over_output_option	static void param_option_over_output_option(
HashStringValue& param_options, const char* option_name,	HashStringValue& param_options, const char* option_name,
String* & output_option) {	const String*& output_option) {
if(ValuePtr value=param_options.get(String* (new String(option_name))))	if(Value* value=param_options.get(StringBody(option_name)))
output_option=value->as_string(&pool);	output_option=&value->as_string();
}	}
static void param_option_over_output_option	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(String* (new String(option_name)))) {	if(Value* value=param_options.get(StringBody(option_name))) {
const String& 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,
const String& method_name, MethodParams* params, int index,	MethodParams* params, size_t index,
VXdoc::Output_options& oo) {	VXdoc::Output_options& oo) {
/*	/*
<xsl:output	<xsl:output
!method = "xml" \| "html" \| "text" \| qname-but-not-ncname	!method = "xml" \| "html" \| "text" \| qname-but-not-ncname
Line 527 static void prepare_output_options(Reque	Line 523 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(String* (new String(XDOC_OUTPUT_METHOD_OPTION_NAME))))	if(Value* vmethod=options->get(StringBody(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(*options, "version", oo.version);	param_option_over_output_option(*options, "version", oo.version);
Line 556 static void prepare_output_options(Reque	Line 552 static void prepare_output_options(Reque

// default encoding from pool	// default encoding from pool
if(!oo.encoding)	if(!oo.encoding)
oo.encoding=r.charsets.source().name();	oo.encoding=&r.charsets.source().name();
// default method=xml	// default method=xml
if(!oo.method)	if(!oo.method)
oo.method=String* (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=String* (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=String* (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=String* (new String("text/plain"));	oo.mediaType=new String("text/plain");
}	}
}	}

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,
const String& method_name, MethodParams* params, int index,	MethodParams* params, int index,
VXdoc::Output_options& oo,	VXdoc::Output_options& oo,
const String& file_spec) {	const String* file_spec) {
Xdoc2buf_result result;	Xdoc2buf_result result;
prepare_output_options(r, method_name, params, index,	prepare_output_options(r, params, index,
oo);	oo);

const char* 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
Line 600 static Xdoc2buf_result xdoc2buf(Request&	Line 596 static Xdoc2buf_result xdoc2buf(Request&
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

Line 618 static Xdoc2buf_result xdoc2buf(Request&	Line 614 static Xdoc2buf_result xdoc2buf(Request&
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) {	if(xsltSaveResultTo(outputBuffer.get(), document, stylesheet.get())<0) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(	throw Exception(0, exc);
method_name,
exc);
}	}

// write out result	// write out result
char *gnome_buf; size_t gnome_size;	char *gnome_str; size_t gnome_length;
if(outputBuffer->conv) {	if(outputBuffer->conv) {
gnome_size=outputBuffer->conv->use;	gnome_length=outputBuffer->conv->use;
gnome_buf=(char *)outputBuffer->conv->content;	gnome_str=(char *)outputBuffer->conv->content;
} else {	} else {
gnome_size=outputBuffer->buffer->use;	gnome_length=outputBuffer->buffer->use;
gnome_buf=(char *)outputBuffer->buffer->content;	gnome_str=(char *)outputBuffer->buffer->content;
}	}

if(file_spec)	if(file_spec)
file_write(file_spec,	file_write(*file_spec,
gnome_buf, gnome_size,	gnome_str, gnome_length,
true/as_text/);	true/as_text/);
else if(result.size=gnome_size) {	else if(result.length=gnome_length) {
result.ptr=pool.copy(gnome_buf, gnome_size);	result.str=pa_strdup(gnome_str, gnome_length);
} else	} else
result.ptr=0;	result.str=0;

return result;	return result;
}	}

static void _file(Request& r, const String& method_name, MethodParams* params) {	static void _file(Request& r, MethodParams* params) {
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,
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.length));	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(
String* (new String("charset")),	StringBody("charset"),
ValuePtr(new VString(oo.encoding)));	new VString(*oo.encoding));
vcontent_type=vhcontent_type;

vfile->set(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, const String& method_name, MethodParams* params) {	static void _save(Request& r, MethodParams* params) {
VXdoc& vdoc=GET_SELF(r, VXdoc);	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);	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, const String& method_name, MethodParams* params) {	static void _string(Request& r, MethodParams* params) {
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,
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.length));	r.write_no_lang(String(buf.str, buf.length));
}	}

#ifndef DOXYGEN	#ifndef DOXYGEN
Line 702 struct Add_xslt_param_info {	Line 695 struct Add_xslt_param_info {
};	};
#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) {
GdomeDOMString_auto_ptr s;	GdomeDOMString_auto_ptr s;
info->current_transform_param++=(s=info->r->transcode(attribute))->str; info->strings+=s;	info->current_transform_param++=(s=info->r->transcode(attribute))->str; info->strings+=s;
info->current_transform_param++=(s=info->r->transcode(meaning->as_string(&info->r->pool())))->str; info->strings+=s;	info->current_transform_param++=(s=info->r->transcode(meaning->as_string()))->str; info->strings+=s;
}	}
static VXdocPtr _transform(Request& r, const String& doc_source, const String& stylesheet_source,	static VXdoc& _transform(Request& r, const String* stylesheet_source,
VXdoc& vdoc, xsltStylesheetPtr stylesheet, const char** transform_params) {	VXdoc& vdoc, xsltStylesheetPtr stylesheet, const char** transform_params) {
xmlDoc *document=gdome_xml_doc_get_xmlDoc(vdoc.get_document(doc_source));	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 728 static VXdocPtr _transform(Request& r, c	Line 721 static VXdocPtr _transform(Request& r, c
transformContext.get());	transformContext.get());
if(!transformed \|\| xmlHaveGenericErrors()) {	if(!transformed \|\| xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(	throw Exception(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 739 static VXdocPtr _transform(Request& r, c	Line 730 static VXdocPtr _transform(Request& r, c
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(&&r.charsets, gdomeDocument));	VXdoc& result=*new VXdoc(&r.charsets, gdomeDocument);
/* grabbing options	/* grabbing options

<xsl:output	<xsl:output
Line 757 static VXdocPtr _transform(Request& r, c	Line 748 static VXdocPtr _transform(Request& r, c
!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):0;	oo.method=stylesheet->method?&r.transcode(stylesheet->method):0;
oo.encoding=stylesheet->encoding?r.transcode(stylesheet->encoding, stylesheet_source):0;	oo.encoding=stylesheet->encoding?&r.transcode(stylesheet->encoding):0;
oo.mediaType=stylesheet->mediaType?r.transcode(stylesheet->mediaType, stylesheet_source):0;	oo.mediaType=stylesheet->mediaType?&r.transcode(stylesheet->mediaType):0;
oo.doctypeSystem=stylesheet->doctypeSystem?r.transcode(stylesheet->doctypeSystem, stylesheet_source):0;	oo.doctypeSystem=stylesheet->doctypeSystem?&r.transcode(stylesheet->doctypeSystem):0;
oo.doctypePublic=stylesheet->doctypePublic?r.transcode(stylesheet->doctypePublic, stylesheet_source):0;	oo.doctypePublic=stylesheet->doctypePublic?&r.transcode(stylesheet->doctypePublic):0;
oo.indent=stylesheet->indent!=0;	oo.indent=stylesheet->indent!=0;
oo.version=stylesheet->version?r.transcode(stylesheet->version, stylesheet_source):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, const String& method_name, MethodParams* params) {	static void _transform(Request& r, MethodParams* params) {
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

// params	// params
Array<GdomeDOMString_auto_ptr> transform_strings;	Array<GdomeDOMString_auto_ptr> transform_strings;
smart_ptr<const char*> transform_params;	const char** transform_params=0;
if(params->count()>1) {	if(params->count()>1) {
ValuePtr vparams=params->as_no_junction(1, "transform parameters must be hash");	Value& vparams=params->as_no_junction(1, "transform parameters must be hash");
if(!vparams->is_string())	if(!vparams.is_string())
if(HashStringValue* params=vparams->get_hash(method_name)) {	if(HashStringValue* params=vparams.get_hash()) {
transform_params=smart_ptr<const char>(new const char[params->count()*2+1]);	transform_params=new(UseGC) const char[params->count()2+1];
Add_xslt_param_info info={	Add_xslt_param_info info={
&r,	&r,
&transform_strings,	&transform_strings,
Line 792 static void _transform(Request& r, const	Line 783 static void _transform(Request& r, const
transform_params[params->count()*2]=0;	transform_params[params->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];	Value* vmaybe_xdoc=(*params)[0];
if(Value *vxdoc=vmaybe_xdoc->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	// strange thing - xsltParseStylesheetDoc records document and destroys it in stylesheet destructor
Line 808 static void _transform(Request& r, const	Line 799 static void _transform(Request& r, const
stylesheet_ptr->doc=0;	stylesheet_ptr->doc=0;
if(xmlHaveGenericErrors()) {	if(xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(method_name, exc);	throw Exception(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");

// 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
const String& 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(false/nocache/),	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 907 void MXdoc::configure_admin(Request& r)	Line 898 void MXdoc::configure_admin(Request& r)

# else	# else

	#include "classes.h"

// global variable	// global variable

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

E-mail:

Removed from v.1.108.2.19.2.5
changed lines
	Added in v.1.108.2.19.2.21