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.24 and 1.46

version 1.24, 2001/10/18 11:49:02	version 1.46, 2001/11/21 14:00:27
Line 2	Line 2
Parser: @b xdoc parser class.	Parser: @b xdoc parser class.

Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)	Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)	Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)

$Id$	$Id$
*/	*/
	#include "pa_types.h"
#include "classes.h"	#include "classes.h"
#ifdef XML	#ifdef XML

#include "pa_request.h"	#include "pa_request.h"
#include "pa_vxdoc.h"	#include "pa_vxdoc.h"
#include "pa_xslt_stylesheet_manager.h"	#include "pa_stylesheet_manager.h"
#include "pa_stylesheet_connection.h"	#include "pa_stylesheet_connection.h"
#include "pa_vfile.h"	#include "pa_vfile.h"
#include "xnode.h"	#include "xnode.h"
Line 38	Line 39
#include <XalanDOM/XalanDocumentFragment.hpp>	#include <XalanDOM/XalanDocumentFragment.hpp>
#include <XalanDOM/XalanCDATASection.hpp>	#include <XalanDOM/XalanCDATASection.hpp>
#include <XalanDOM/XalanEntityReference.hpp>	#include <XalanDOM/XalanEntityReference.hpp>
#include <DOM/DOM_Document.hpp>	#include <dom/DOM_Document.hpp>
#include <XercesParserLiaison/XercesDocumentBridge.hpp>	#include <XercesParserLiaison/XercesDocumentBridge.hpp>
#include <XalanTransformer/XercesDOMParsedSource.hpp>	#include <XalanTransformer/XercesDOMParsedSource.hpp>
	#include <XSLT/StylesheetRoot.hpp>
	#include <XalanTransformer/XalanCompiledStylesheet.hpp>

// defines	// defines

Line 50	Line 53
#define XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "xml"	#define XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "xml"
#define XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "html"	#define XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "html"
#define XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT "text"	#define XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT "text"

#define XDOC_OUTPUT_ENCODING_OPTION_NAME "encoding"

#define XDOC_OUTPUT_DEFAULT_INDENT 4	#define XDOC_OUTPUT_DEFAULT_INDENT 4

// class	// class

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

public:	public:
MXdoc(Pool& pool);	MXdoc(Pool& pool);
Line 76 static void _createElement(Request& r, c	Line 76 static void _createElement(Request& r, c
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=static_cast<VXdoc >(r.self);

const char *tagName=params->as_string(0, "tagName must be string").cstr(String::UL_XML);	const String& tagName=params->as_string(0, "tagName must be string");

try {	try {
XalanNode *node=	XalanNode *node=
vdoc.get_document(pool, &method_name).	vdoc.get_document(pool, &method_name).
createElement(XalanDOMString(tagName));	createElement(*pool.transcode(tagName));
// write out result	// write out result
VXnode& result=*new(pool) VXnode(pool, node);	VXnode& result=*new(pool) VXnode(pool, node, false);
r.write_no_lang(result);	r.write_no_lang(result);
} catch(const XalanDOMException& e) {	} catch(const XalanDOMException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
}	}

// DocumentFragment createDocumentFragment()	// DocumentFragment createDocumentFragment()
static void _createDocumentFragment(Request& r, const String& method_name, MethodParams *params) {	static void _createDocumentFragment(Request& r, const String& method_name, MethodParams *) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=static_cast<VXdoc >(r.self);

Line 99 static void _createDocumentFragment(Requ	Line 99 static void _createDocumentFragment(Requ
vdoc.get_document(pool, &method_name).	vdoc.get_document(pool, &method_name).
createDocumentFragment();	createDocumentFragment();
// write out result	// write out result
VXnode& result=*new(pool) VXnode(pool, node);	VXnode& result=*new(pool) VXnode(pool, node, false);
r.write_no_lang(result);	r.write_no_lang(result);
}	}

Line 108 static void _createTextNode(Request& r,	Line 108 static void _createTextNode(Request& r,
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=static_cast<VXdoc >(r.self);

const char *data=params->as_string(0, "data must be string").cstr(String::UL_XML);	const String& data=params->as_string(0, "data must be string");

XalanNode *node=	XalanNode *node=
vdoc.get_document(pool, &method_name).	vdoc.get_document(pool, &method_name).
createTextNode(XalanDOMString(data));	createTextNode(*pool.transcode(data));
// write out result	// write out result
VXnode& result=*new(pool) VXnode(pool, node);	VXnode& result=*new(pool) VXnode(pool, node, false);
r.write_no_lang(result);	r.write_no_lang(result);
}	}

Line 123 static void _createComment(Request& r, c	Line 123 static void _createComment(Request& r, c
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=static_cast<VXdoc >(r.self);

const char *data=params->as_string(0, "data must be string").cstr(String::UL_XML);	const String& data=params->as_string(0, "data must be string");

XalanNode *node=	XalanNode *node=
vdoc.get_document(pool, &method_name).	vdoc.get_document(pool, &method_name).
createComment(XalanDOMString(data));	createComment(*pool.transcode(data));
// write out result	// write out result
VXnode& result=*new(pool) VXnode(pool, node);	VXnode& result=*new(pool) VXnode(pool, node, false);
r.write_no_lang(result);	r.write_no_lang(result);
}	}

Line 138 static void _createCDATASection(Request&	Line 138 static void _createCDATASection(Request&
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=static_cast<VXdoc >(r.self);

const char *data=params->as_string(0, "data must be string").cstr(String::UL_XML);	const String& data=params->as_string(0, "data must be string");

try {	try {
XalanNode *node=	XalanNode *node=
vdoc.get_document(pool, &method_name).	vdoc.get_document(pool, &method_name).
createCDATASection(XalanDOMString(data));	createCDATASection(*pool.transcode(data));
// write out result	// write out result
VXnode& result=*new(pool) VXnode(pool, node);	VXnode& result=*new(pool) VXnode(pool, node, false);
r.write_no_lang(result);	r.write_no_lang(result);
} catch(const XalanDOMException& e) {	} catch(const XalanDOMException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
}	}

Line 157 static void _createProcessingInstruction	Line 157 static void _createProcessingInstruction
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=static_cast<VXdoc >(r.self);

const char *target=params->as_string(0, "target must be string").cstr(String::UL_XML);	const String& target=params->as_string(0, "data must be string");
const char *data=params->as_string(1, "data must be string").cstr(String::UL_XML);	const String& data=params->as_string(1, "data must be string");

try {	try {
XalanNode *node=	XalanNode *node=
vdoc.get_document(pool, &method_name).	vdoc.get_document(pool, &method_name).
createProcessingInstruction(XalanDOMString(target), XalanDOMString(data));	createProcessingInstruction(pool.transcode(target), pool.transcode(data));
// write out result	// write out result
VXnode& result=*new(pool) VXnode(pool, node);	VXnode& result=*new(pool) VXnode(pool, node, false);
r.write_no_lang(result);	r.write_no_lang(result);
} catch(const XalanDOMException& e) {	} catch(const XalanDOMException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
}	}

Line 177 static void _createAttribute(Request& r,	Line 177 static void _createAttribute(Request& r,
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=static_cast<VXdoc >(r.self);

const char *name=params->as_string(0, "name must be string").cstr(String::UL_XML);	const String& name=params->as_string(0, "name must be string");

try {	try {
XalanNode *node=	XalanNode *node=
vdoc.get_document(pool, &method_name).	vdoc.get_document(pool, &method_name).
createAttribute(XalanDOMString(name));	createAttribute(*pool.transcode(name));
// write out result	// write out result
VXnode& result=*new(pool) VXnode(pool, node);	VXnode& result=*new(pool) VXnode(pool, node, false);
r.write_no_lang(result);	r.write_no_lang(result);
} catch(const XalanDOMException& e) {	} catch(const XalanDOMException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
}	}
// EntityReference createEntityReference(in DOMString name) raises(DOMException);	// EntityReference createEntityReference(in DOMString name) raises(DOMException);
Line 195 static void _createEntityReference(Reque	Line 195 static void _createEntityReference(Reque
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=static_cast<VXdoc >(r.self);

const char *name=params->as_string(0, "name must be string").cstr(String::UL_XML);	const String& name=params->as_string(0, "name must be string");

try {	try {
XalanNode *node=	XalanNode *node=
vdoc.get_document(pool, &method_name).	vdoc.get_document(pool, &method_name).
createEntityReference(XalanDOMString(name));	createEntityReference(*pool.transcode(name));
// write out result	// write out result
VXnode& result=*new(pool) VXnode(pool, node);	VXnode& result=*new(pool) VXnode(pool, node, false);
r.write_no_lang(result);	r.write_no_lang(result);
} catch(const XalanDOMException& e) {	} catch(const XalanDOMException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
}	}

Line 366 XalanDefaultParsedSource2::createHelper(	Line 366 XalanDefaultParsedSource2::createHelper(
}	}


	static void param_option_over_output_option(Pool& pool,
	Hash param_options, const char option_name,
	XalanDOMString& output_option) {
	if(Value value=static_cast<Value >(param_options->get(*new(pool)
	String(pool, option_name)))) {
	output_option.clear();
	output_option.append(value->as_string().cstr());
	}
	}
	static void param_option_over_output_option(Pool& pool,
	Hash param_options, const char option_name,
	bool& output_option) {
	if(Value value=static_cast<Value >(param_options->get(*new(pool)
	String(pool, option_name)))) {
	const String& s=value->as_string();
	if(s=="yes")
	output_option=true;
	else if(s=="no")
	output_option=false;
	else
	throw Exception(0, 0,
	&s,
	"%s must be either 'yes' or 'no'", option_name);
	}
	}

static void create_optioned_listener(	static void create_optioned_listener(
const char & content_type, const char & charset, FormatterListener *& listener,	Pool& pool, const String& method_name, MethodParams *params, int index,
Pool& pool,	VXdoc::Output_options& oo, Writer& writer,
const String& method_name, MethodParams *params, int index, Writer& writer) {	FormatterListener *& listener) {
// default encoding from pool	/*
const String *scharset=&pool.get_charset();	XalanDOMString encoding;
const String *method=0;	XalanDOMString mediaType;
XalanDOMString xalan_encoding;	XalanDOMString doctypeSystem;
	XalanDOMString doctypePublic;
	bool doIndent;
	XalanDOMString version;
	XalanDOMString standalone;
	bool xmlDecl;
	*/

	/*
	<xsl:output
	!method = "xml" \| "html" \| "text" \| qname-but-not-ncname
	!version = nmtoken
	!encoding = string
	!omit-xml-declaration = "yes" \| "no"
	!standalone = "yes" \| "no"
	!doctype-public = string
	!doctype-system = string
	cdata-section-elements = qnames
	!indent = "yes" \| "no"
	!media-type = string />
	*/

	/*
	fToXML->setStripCData(stripCData);
	fToXML->setEscapeCData(escapeCData);
	*/

	// configuring with options from parameter...
if(params->size()>index) {	if(params->size()>index) {
Value& 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(Hash *options=voptions.get_hash()) {	if(Hash *options=voptions.get_hash(&method_name)) {
// $.method[xml\|html\|text]	// $.method[xml\|html\|text]
if(Value vmethod=static_cast<Value >(options->get(*new(pool)	if(Value vmethod=static_cast<Value >(options->get(*new(pool)
String(pool, XDOC_OUTPUT_METHOD_OPTION_NAME))))	String(pool, XDOC_OUTPUT_METHOD_OPTION_NAME))))
method=&vmethod->as_string();	oo.method=vmethod->as_string().cstr();

	// $.version[1.0]
	param_option_over_output_option(pool, options, "version", oo.version);
// $.encoding[windows-1251\|...]	// $.encoding[windows-1251\|...]
if(Value vencoding=static_cast<Value >(options->get(*new(pool)	param_option_over_output_option(pool, options, "encoding", oo.encoding);
String(pool, XDOC_OUTPUT_ENCODING_OPTION_NAME)))) {	// $.omit-xml-declaration[yes\|no]
scharset=&vencoding->as_string();	bool omit_xml_declaration=!oo.xmlDecl;
}	param_option_over_output_option(pool, options, "omit-xml-declaration", omit_xml_declaration);
	oo.xmlDecl=!omit_xml_declaration;
	// $.standalone[yes\|no]
	param_option_over_output_option(pool, options, "standalone", oo.standalone);
	// $.doctype-public[?]
	param_option_over_output_option(pool, options, "doctype-public", oo.doctypePublic);
	// $.doctype-system[?]
	param_option_over_output_option(pool, options, "doctype-system", oo.doctypeSystem);
	// $.indent[yes\|no]
	param_option_over_output_option(pool, options, "indent", oo.doIndent);
	// $.media-type[text/{html\|xml\|plain}]
	param_option_over_output_option(pool, options, "media-type", oo.mediaType);
}	}
}	}
}	}

xalan_encoding.append(charset=scharset->cstr());	// default encoding from pool
if(!method/default='xml'/ \|\| *method == XDOC_OUTPUT_METHOD_OPTION_VALUE_XML) {	if(oo.encoding.empty())
content_type="text/xml";	oo.encoding.append(pool.get_charset().cstr());
	// default method=xml
	if(!oo.method)
	oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_XML;

	if(strcmp(oo.method, XDOC_OUTPUT_METHOD_OPTION_VALUE_XML)==0) {
	if(oo.mediaType.empty())
	oo.mediaType.append("text/xml");
listener=new FormatterToXML(writer,	listener=new FormatterToXML(writer,
XalanDOMString(), // version	oo.version,
true, // doIndent	oo.doIndent,
XDOC_OUTPUT_DEFAULT_INDENT, // indent	XDOC_OUTPUT_DEFAULT_INDENT, // indent
xalan_encoding // encoding	oo.encoding,
	oo.mediaType,
	oo.doctypeSystem,
	oo.doctypePublic,
	oo.xmlDecl,
	oo.standalone
);	);
} else if(*method == XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML) {	} else if(strcmp(oo.method, XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML)==0) {
content_type="text/html";	if(oo.mediaType.empty())
	oo.mediaType.append("text/html");
listener=new FormatterToHTML(writer,	listener=new FormatterToHTML(writer,
xalan_encoding, // encoding	oo.encoding,
XalanDOMString(), // mediaType	oo.mediaType,
XalanDOMString(), // doctypeSystem; String to be printed at the top of the document	oo.doctypeSystem,
XalanDOMString(), // doctypePublic	oo.doctypePublic,
true, // doIndent	oo.doIndent,
XDOC_OUTPUT_DEFAULT_INDENT // indent	XDOC_OUTPUT_DEFAULT_INDENT, // indent
	oo.version,
	oo.standalone,
	oo.xmlDecl
);	);
} else if(*method == XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT) {	} else if(strcmp(oo.method, XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT)==0) {
content_type="text/plain";	if(oo.mediaType.empty())
	oo.mediaType.append("text/plain");
listener=new FormatterToText(writer,	listener=new FormatterToText(writer,
xalan_encoding // encoding	oo.encoding
);	);
} else	} else
PTHROW(0, 0,	throw Exception(0, 0,
method,	&method_name,
XDOC_OUTPUT_METHOD_OPTION_NAME " option is invalid; valid methods are: "	XDOC_OUTPUT_METHOD_OPTION_NAME " option is invalid; valid methods are: "
"'" XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "', "	"'" XDOC_OUTPUT_METHOD_OPTION_VALUE_XML "', "
"'" XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "', "	"'" XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML "', "
Line 432 static void create_optioned_listener(	Line 512 static void create_optioned_listener(

static void _save(Request& r, const String& method_name, MethodParams *params) {	static void _save(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
	VXdoc& vdoc=static_cast<VXdoc >(r.self);
VXnode& vnode=static_cast<VXnode >(r.self);	VXnode& vnode=static_cast<VXnode >(r.self);

// filespec	// filespec
Line 442 static void _save(Request& r, const Stri	Line 523 static void _save(Request& r, const Stri
XalanNode& node=vnode.get_node(pool, &method_name);	XalanNode& node=vnode.get_node(pool, &method_name);

try {	try {
	VXdoc::Output_options oo(vdoc.output_options);
XalanFileOutputStream stream(XalanDOMString(filespec, strlen(filespec)));	XalanFileOutputStream stream(XalanDOMString(filespec, strlen(filespec)));
XalanOutputStreamPrintWriter writer(stream);	XalanOutputStreamPrintWriter writer(stream);
const char content_type, charset;
FormatterListener *formatterListener;	FormatterListener *formatterListener;
create_optioned_listener(content_type, charset, formatterListener,	create_optioned_listener(pool, method_name, params, 1,
pool, method_name, params, 1, writer);	oo, writer, formatterListener);
FormatterTreeWalker treeWalker(*formatterListener);	FormatterTreeWalker treeWalker(*formatterListener);
treeWalker.traverse(&node); // Walk that node and produce the XML...	treeWalker.traverse(&node); // Walk that node and produce the XML...
} catch(const XSLException& e) {	} catch(const XSLException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
}	}

Line 462 static void _string(Request& r, const St	Line 543 static void _string(Request& r, const St
// node	// node
XalanNode *node=&vdoc.get_document(pool, &method_name);//.getDocumentElement();	XalanNode *node=&vdoc.get_document(pool, &method_name);//.getDocumentElement();
if(!node)	if(!node)
PTHROW(0, 0,	throw Exception(0, 0,
&method_name,	&method_name,
"no documentElement");	"no documentElement");

try {	try {
	VXdoc::Output_options oo(vdoc.output_options);
String parserString=*new(pool) String(pool);	String parserString=*new(pool) String(pool);
ParserStringXalanOutputStream stream(parserString);	ParserStringXalanOutputStream stream(parserString);
XalanOutputStreamPrintWriter writer(stream);	XalanOutputStreamPrintWriter writer(stream);
const char content_type, charset;
FormatterListener *formatterListener;	FormatterListener *formatterListener;
create_optioned_listener(content_type, charset, formatterListener,	create_optioned_listener(pool, method_name, params, 0,
pool, method_name, params, 0, writer);	oo, writer, formatterListener);
FormatterTreeWalker treeWalker(*formatterListener);	FormatterTreeWalker treeWalker(*formatterListener);
treeWalker.traverse(node); // Walk that node and produce the XML...	treeWalker.traverse(node); // Walk that node and produce the XML...

// write out result	// write out result
r.write_no_lang(parserString);	r.write_no_lang(parserString);
} catch(const XSLException& e) {	} catch(const XSLException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
}	}


static void _file(Request& r, const String& method_name, MethodParams *params) {	static void _file(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
	VXdoc& vdoc=static_cast<VXdoc >(r.self);
VXnode& vnode=static_cast<VXnode >(r.self);	VXnode& vnode=static_cast<VXnode >(r.self);

// node	// node
XalanNode& node=vnode.get_node(pool, &method_name);	XalanNode& node=vnode.get_node(pool, &method_name);

try {	try {
	VXdoc::Output_options oo(vdoc.output_options);
String& parserString=*new(pool) String(pool);	String& parserString=*new(pool) String(pool);
ParserStringXalanOutputStream stream(parserString);	ParserStringXalanOutputStream stream(parserString);
XalanOutputStreamPrintWriter writer(stream);	XalanOutputStreamPrintWriter writer(stream);
const char content_type, charset;
FormatterListener *formatterListener;	FormatterListener *formatterListener;
create_optioned_listener(content_type, charset, formatterListener,	create_optioned_listener(pool, method_name, params, 0,
pool, method_name, params, 0, writer);	oo, writer, formatterListener);
FormatterTreeWalker treeWalker(*formatterListener);	FormatterTreeWalker treeWalker(*formatterListener);
treeWalker.traverse(&node); // Walk that node and produce the XML...	treeWalker.traverse(&node); // Walk that node and produce the XML...

// write out result	// write out result
VFile& vfile=*new(pool) VFile(pool);	VFile& vfile=*new(pool) VFile(pool);
const char *cstr=parserString.cstr();	const char *cstr=parserString.cstr();
String *scontent_type=new(pool) String(pool, content_type);	const String& scontent_type=pool.transcode(oo.mediaType);
Value *vcontent_type;	Value *vcontent_type;
if(charset) {	if(oo.encoding.empty())
	vcontent_type=new(pool) VString(scontent_type);
	else {
VHash *vhcontent_type=new(pool) VHash(pool);	VHash *vhcontent_type=new(pool) VHash(pool);
vhcontent_type->hash().put(value_name, new(pool) VString(scontent_type));	vhcontent_type->hash(&method_name).put(*value_name, new(pool) VString(scontent_type));
String *scharset=new(pool) String(pool, charset);	const String& scharset=pool.transcode(oo.encoding);
vhcontent_type->hash().put(new(pool) String(pool, "charset"), new(pool) VString(scharset));	vhcontent_type->hash(&method_name).put(*new(pool) String(pool, "charset"), new(pool) VString(scharset));
vcontent_type=vhcontent_type;	vcontent_type=vhcontent_type;
} else	}
vcontent_type=new(pool) VString(*scontent_type);
vfile.set(false/tainted/, cstr, strlen(cstr), 0/file_name/, vcontent_type);	vfile.set(false/tainted/, cstr, strlen(cstr), 0/file_name/, vcontent_type);
r.write_no_lang(vfile);	r.write_no_lang(vfile);
} catch(const XSLException& e) {	} catch(const XSLException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
}	}

Line 532 static void _set(Request& r, const Strin	Line 616 static void _set(Request& r, const Strin
Temp_lang temp_lang(r, String::UL_XML);	Temp_lang temp_lang(r, String::UL_XML);
const String& xml=r.process(vxml).as_string();	const String& xml=r.process(vxml).as_string();

std::istrstream stream(xml.cstr());	std::istrstream stream(
	xml.cstr(String::UL_UNSPECIFIED, r.connection));
const XalanParsedSource* parsedSource;	const XalanParsedSource* parsedSource;

try {	try {
parsedSource = new XalanDefaultParsedSource2(&stream);	parsedSource = new XalanDefaultParsedSource2(&stream);
}	}
catch (XSLException& e) {	catch (XSLException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
catch (SAXParseException& e) {	catch (SAXParseException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
catch (SAXException& e) {	catch (SAXException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
catch (XMLException& e) {	catch (XMLException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
catch(const XalanDOMException& e) {	catch(const XalanDOMException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}

// replace any previous parsed source	// replace any previous parsed source
vdoc.set_parsed_source(*parsedSource);	vdoc.set_parsed_source(*parsedSource);
}	}

/// @test free dom_document, xalan_document
static void _create(Request& r, const String& method_name, MethodParams *params) {	static void _create(Request& r, const String& method_name, MethodParams *params) {
	//_asm int 3;
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=static_cast<VXdoc >(r.self);

DOM_Document *dom_document=new DOM_Document();	const String& qualifiedName=params->as_string(0, "qualifiedName must be string");
*dom_document=DOM_Document::createDocument();
/*
const String& squalifiedName=params->as_string(0, "qualifiedName must be string");

/// +createXMLDecl ?
String xml(pool, "<?xml version=\"1.0\"?>\n");
xml << "<" << squalifiedName.cstr(String::UL_XML) << " />";
*/

XalanDocument& xalan_document=*new XercesDocumentBridge(	XalanDocument& document=*new XercesDocumentBridge(
*dom_document,	DOM_Document::createDocument(),
0,	0,
false /threadSafe/,	false /threadSafe/,
false /don' buildBridge -- too early, empty document/);	false /don' buildBridge -- too early, empty document/);

	/// +createXMLDecl ?
	document.appendChild(document.createElement(*pool.transcode(qualifiedName)));

// replace any previous document	// replace any previous document
vdoc.set_document(xalan_document);	vdoc.set_document(document, true/owns/);
}	}

static void _load(Request& r, const String& method_name, MethodParams *params) {	static void _load(Request& r, const String& method_name, MethodParams *params) {
Line 596 static void _load(Request& r, const Stri	Line 676 static void _load(Request& r, const Stri
parsedSource = new XalanDefaultParsedSource2(filespec);	parsedSource = new XalanDefaultParsedSource2(filespec);
}	}
catch (XSLException& e) {	catch (XSLException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
catch (SAXParseException& e) {	catch (SAXParseException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
catch (SAXException& e) {	catch (SAXException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
catch (XMLException& e) {	catch (XMLException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}
catch(const XalanDOMException& e) {	catch(const XalanDOMException& e) {
pool.exception()._throw(pool, &method_name, e);	Exception::provide_source(pool, &method_name, e);
}	}

// replace any previous parsed source	// replace any previous parsed source
vdoc.set_parsed_source(*parsedSource);	vdoc.set_parsed_source(*parsedSource);
}	}

	/// @test lang=String::UL_UNSPECIFIED?
static void add_xslt_param(const Hash::Key& aattribute, Hash::Val *ameaning,	static void add_xslt_param(const Hash::Key& aattribute, Hash::Val *ameaning,
void *info) {	void *info) {
XalanTransformer2& transformer=static_cast<XalanTransformer2 >(info);	XalanTransformer2& transformer=static_cast<XalanTransformer2 >(info);
const char *attribute_cstr=aattribute.cstr();	const char *attribute_cstr=aattribute.cstr(String::UL_UNSPECIFIED);
const char meaning_cstr=static_cast<Value >(ameaning)->as_string().cstr();	const char meaning_cstr=static_cast<Value >(ameaning)->as_string().cstr(String::UL_UNSPECIFIED);

transformer.setStylesheetParam(	transformer.setStylesheetParam(
XalanDOMString(attribute_cstr),	XalanDOMString(attribute_cstr),
XalanDOMString(meaning_cstr));	XalanDOMString(meaning_cstr));
}	}
/*
static void _transform(Request& r, const String& method_name, MethodParams *params) {	static void _transform(Request& r, const String& method_name, MethodParams *params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=static_cast<VXdoc >(r.self);
Line 634 static void _transform(Request& r, const	Line 714 static void _transform(Request& r, const
if(params->size()>1) {	if(params->size()>1) {
Value& vparams=params->as_no_junction(1, "transform parameters parameter must be string");	Value& vparams=params->as_no_junction(1, "transform parameters parameter must be string");
if(vparams.is_defined())	if(vparams.is_defined())
if(Hash *params=vparams.get_hash())	if(Hash *params=vparams.get_hash(&method_name))
params->for_each(add_xslt_param, &vdoc.transformer());	params->for_each(add_xslt_param, &vdoc.transformer());
else	else
PTHROW(0, 0,	throw Exception(0, 0,
&method_name,	&method_name,
"transform parameters parameter must be hash");	"transform parameters parameter must be hash");
}	}

// source
const XalanParsedSource &parsed_source=vdoc.get_parsed_source(pool, &method_name);

// stylesheet	// stylesheet
const String& stylesheet_file_name=params->as_string(0, "file name must be string");	const String& stylesheet_file_name=params->as_string(0, "file name must be string");
const String& stylesheet_filespec=r.absolute(stylesheet_file_name);	const String& stylesheet_filespec=r.absolute(stylesheet_file_name);
//_asm int 3;	//_asm int 3;
Stylesheet_connection& connection=XSLT_stylesheet_manager->get_connection(stylesheet_filespec);	Stylesheet_connection& connection=stylesheet_manager->get_connection(stylesheet_filespec);

// target	// target
XalanDocument* target=vdoc.parser_liaison().createDocument();	XalanDocument* target=vdoc.parser_xerces_liaison().createDocument();

// transform	// transform
try {	try {
vdoc.transformer().transform2(	// note:
parsed_source,	// actually, never found any difference between the two
&connection.stylesheet(true/nocache /),	// but still there some extra "xerces" words at start of transform body
target);	// wich were originally "xalan"
}	// not daring to change that
catch (XSLException& e) {
connection.close();	const XalanCompiledStylesheet& stylesheet=connection.stylesheet(true/nocache/);
pool.exception()._throw(pool, &stylesheet_file_name, e);	if(vdoc.has_parsed_source()) { // set\|load, not create?
}	vdoc.transformer().transform2(
catch (SAXParseException& e) {	vdoc.get_parsed_source(pool, &method_name),
connection.close();	&stylesheet,
pool.exception()._throw(pool, &stylesheet_file_name, e);	target);
}	} else {
catch (SAXException& e) {	target=vdoc.parser_xerces_liaison().createDocument();
connection.close();	vdoc.transformer().transform2(
pool.exception()._throw(pool, &stylesheet_file_name, e);	vdoc.get_document(pool, &method_name),
}	&stylesheet,
catch (XMLException& e) {	target);
connection.close();	}
pool.exception()._throw(pool, &stylesheet_file_name, e);	VXdoc& result=new(pool) VXdoc(pool, target, false/owns not*/);
}	// write out result
catch(const XalanDOMException& e) {	r.write_no_lang(result);
connection.close();	//
pool.exception()._throw(pool, &stylesheet_file_name, e);	if(const StylesheetRoot *stylesheetRoot=stylesheet.getStylesheetRoot()) {
}	/*
	<xsl:output
// write out result	!method = "xml" \| "html" \| "text"
VXdoc& result=*new(pool) VXdoc(pool);	X\| qname-but-not-ncname
result.set_document(*target);	!version = nmtoken
r.write_no_lang(result);	!encoding = string
}	!omit-xml-declaration = "yes" \| "no"
*/	!standalone = "yes" \| "no"
static void _transform(Request& r, const String& method_name, MethodParams *params) {	!doctype-public = string
Pool& pool=r.pool();	!doctype-system = string
VXdoc& vdoc=static_cast<VXdoc >(r.self);	cdata-section-elements = qnames
	!indent = "yes" \| "no"
// params	!media-type = string />
if(params->size()>1) {	*/
Value& vparams=params->as_no_junction(1, "transform parameters parameter must be string");
if(vparams.is_defined())	VXdoc::Output_options& oo=result.output_options;
if(Hash *params=vparams.get_hash())	oo.encoding=stylesheetRoot->m_encoding;
params->for_each(add_xslt_param, &vdoc.transformer());	oo.mediaType=stylesheetRoot->m_mediatype;
else	oo.doctypeSystem=stylesheetRoot->m_doctypeSystem;
PTHROW(0, 0,	oo.doctypePublic=stylesheetRoot->m_doctypePublic;
	oo.doIndent=stylesheetRoot->m_indentResult;
	oo.version=stylesheetRoot->m_version;
	oo.standalone=stylesheetRoot->m_standalone;
	oo.xmlDecl=!stylesheetRoot->m_omitxmlDecl;

	switch(stylesheetRoot->getOutputMethod()) {
	case FormatterListener::OUTPUT_METHOD_HTML:
	oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_HTML; break;
	case FormatterListener::OUTPUT_METHOD_TEXT:
	oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT; break;
	case FormatterListener::OUTPUT_METHOD_NONE:
	case FormatterListener::OUTPUT_METHOD_XML:
	oo.method=XDOC_OUTPUT_METHOD_OPTION_VALUE_XML; break;
	default:
	throw Exception(0, 0,
&method_name,	&method_name,
"transform parameters parameter must be hash");	"unsupported output method specified");
}	break; // never
	}
// source	}
XalanDocument &xalan_document=vdoc.get_document(pool, &method_name);

// stylesheet
const String& stylesheet_file_name=params->as_string(0, "file name must be string");
const String& stylesheet_filespec=r.absolute(stylesheet_file_name);
//_asm int 3;
Stylesheet_connection& connection=XSLT_stylesheet_manager->get_connection(stylesheet_filespec);

// target
XalanDocument* target=vdoc.parser_liaison().createDocument();

// transform
try {
vdoc.transformer().transform2(
&xalan_document,
&connection.stylesheet(true/nocache/),
target);
}	}
catch (XSLException& e) {	catch (XSLException& e) {
connection.close();	connection.close();
pool.exception()._throw(pool, &stylesheet_file_name, e);	Exception::provide_source(pool, &stylesheet_file_name, e);
}	}
catch (SAXParseException& e) {	catch (SAXParseException& e) {
connection.close();	connection.close();
pool.exception()._throw(pool, &stylesheet_file_name, e);	Exception::provide_source(pool, &stylesheet_file_name, e);
}	}
catch (SAXException& e) {	catch (SAXException& e) {
connection.close();	connection.close();
pool.exception()._throw(pool, &stylesheet_file_name, e);	Exception::provide_source(pool, &stylesheet_file_name, e);
}	}
catch (XMLException& e) {	catch (XMLException& e) {
connection.close();	connection.close();
pool.exception()._throw(pool, &stylesheet_file_name, e);	Exception::provide_source(pool, &stylesheet_file_name, e);
}	}
catch(const XalanDOMException& e) {	catch(const XalanDOMException& e) {
connection.close();	connection.close();
pool.exception()._throw(pool, &stylesheet_file_name, e);	Exception::provide_source(pool, &stylesheet_file_name, e);
}	}

// write out result	// close
VXdoc& result=*new(pool) VXdoc(pool);	connection.close();
result.set_document(*target);
r.write_no_lang(result);
}	}

static void _getElementById(Request& r, const String& method_name, MethodParams *params) {	static void _getElementById(Request& r, const String& method_name, MethodParams *params) {
Line 755 static void _getElementById(Request& r,	Line 828 static void _getElementById(Request& r,
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=static_cast<VXdoc >(r.self);

// elementId	// elementId
const char *elementId=params->as_string(0, "elementID must be string").cstr(String::UL_XML);	const String& elementId=params->as_string(0, "elementID must be string");

if(XalanNode *node=	if(XalanNode *node=
vdoc.get_document(pool, &method_name).getElementById(XalanDOMString(elementId))) {	vdoc.get_document(pool, &method_name).getElementById(*pool.transcode(elementId))) {
// write out result	// write out result
VXnode& result=*new(pool) VXnode(pool, node);	VXnode& result=*new(pool) VXnode(pool, node, false);
r.write_no_lang(result);	r.write_no_lang(result);
}	}
}	}
Line 845 Methoded *Xdoc_class;	Line 918 Methoded *Xdoc_class;
Methoded *MXdoc_create(Pool& pool) {	Methoded *MXdoc_create(Pool& pool) {
return	return
#ifdef XML	#ifdef XML
Xdoc_class=new(pool) MXdoc(pool);	Xdoc_class=new(pool) MXdoc(pool)
#else	#else
0	0
#endif	#endif

E-mail:

Removed from v.1.24
changed lines
	Added in v.1.46