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.78 and 1.108.2.19

version 1.78, 2002/01/28 08:20:33	version 1.108.2.19, 2003/03/08 15:55:34
Line 1	Line 1
/** @file	/** @file
Parser: @b xdoc parser class.	Parser: @b xdoc parser class.

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

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

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

	#include "pa_vmethod_frame.h"

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

#include "gdome.h"	#include "gdome.h"
#include "libxml/tree.h"	#include "libxml/tree.h"
extern "C" {	extern "C" {
Line 18 extern "C" {	Line 28 extern "C" {
#include "libxslt/xsltInternals.h"	#include "libxslt/xsltInternals.h"
#include "libxslt/transform.h"	#include "libxslt/transform.h"
#include "libxslt/xsltutils.h"	#include "libxslt/xsltutils.h"
	#include "libxslt/variables.h"
#include "pa_stylesheet_connection.h"
#include "classes.h"
#include "pa_request.h"
#include "pa_vxdoc.h"
#include "pa_charset.h"
#include "pa_vfile.h"
#include "xnode.h"


// defines	// defines

Line 39 extern "C" {	Line 41 extern "C" {

// 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, 0); }	ValuePtr create_new_value() { return ValuePtr(new VXdoc(0, 0, 0)); }

public:	public:
MXdoc(Pool& pool);	MXdoc();

public: // Methoded	public: // Methoded
bool used_directly() { return true; }
void configure_admin(Request& r);	void configure_admin(Request& r);
};	};

	// global variable

	DECLARE_CLASS_VAR(xdoc, new MXdoc, 0);

// helper classes	// helper classes

class xmlOutputBuffer_auto_ptr {	class xmlOutputBuffer_auto_ptr {
Line 154 private:	Line 159 private:

// methods	// methods

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

Pool& pool=r.pool();	Pool& pool=r.pool();

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

// 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, StringPtr method_name, MethodParams* params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& tagName=params->as_string(0, "tagName must be string");	StringPtr 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(method_name),
pool.transcode(tagName).get(),	r.transcode(tagName).get(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, method_name, node, exc);
}	}

// DocumentFragment createDocumentFragment()	// DocumentFragment createDocumentFragment()
static void _createDocumentFragment(Request& r, const String& method_name, MethodParams *) {	static void _createDocumentFragment(Request& r, StringPtr method_name, MethodParams* ) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	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(method_name),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, method_name, 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, StringPtr method_name, MethodParams* params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& data=params->as_string(0, "data must be string");	StringPtr 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(method_name),
pool.transcode(data).get(),	r.transcode(data).get(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, method_name, 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, StringPtr method_name, MethodParams* params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& data=params->as_string(0, "data must be string");	StringPtr 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(method_name),
pool.transcode(data).get(),	r.transcode(data).get(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, method_name, 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, StringPtr method_name, MethodParams* params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& data=params->as_string(0, "data must be string");	StringPtr 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(method_name),
pool.transcode(data).get(),	r.transcode(data).get(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, method_name, 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, StringPtr method_name, MethodParams* params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& target=params->as_string(0, "data must be string");	StringPtr target=params->as_string(0, "data must be string");
const String& data=params->as_string(1, "data must be string");	StringPtr 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(method_name),
pool.transcode(target).get(),	r.transcode(target).get(),
pool.transcode(data).get(),	r.transcode(data).get(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, method_name, 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, StringPtr method_name, MethodParams* params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& name=params->as_string(0, "name must be string");	StringPtr 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(method_name),
pool.transcode(name).get(),	r.transcode(name).get(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, method_name, 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, StringPtr method_name, MethodParams* params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& name=params->as_string(0, "name must be string");	StringPtr 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(method_name),
pool.transcode(name).get(),	r.transcode(name).get(),
&exc);	&exc);
writeNode(r, method_name, node, exc);	writeNode(r, method_name, node, exc);
}	}

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

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

	VHashPtr result(new VHash);
GdomeException exc;	GdomeException exc;
VHash& result=*new(pool) VHash(pool);
if(GdomeNodeList *nodes=	if(GdomeNodeList *nodes=
gdome_doc_getElementsByTagName(	gdome_doc_getElementsByTagName(
vdoc.get_document(&method_name),	vdoc.get_document(method_name),
pool.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++) {
String& skey=*new(pool) String(pool);	StringPtr skey(new String);
{	*skey << pool.format_integer(i);
char buf=(char )pool.malloc(MAX_NUMBER);
snprintf(buf, MAX_NUMBER, "%d", i);
skey << buf;
}

result.hash(0).put(skey, new(pool) VXnode(pool, 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)
	throw Exception(
	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, StringPtr method_name, MethodParams* params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=GET_SELF(r, VXdoc);

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

GdomeException exc;	GdomeException exc;
VHash& result=*new(pool) VHash(pool);	VHashPtr result(new VHash);
if(GdomeNodeList *nodes=	if(GdomeNodeList *nodes=
gdome_doc_getElementsByTagNameNS(	gdome_doc_getElementsByTagNameNS(
vdoc.get_document(&method_name),	vdoc.get_document(method_name),
pool.transcode(namespaceURI).get(),	r.transcode(namespaceURI).get(),
pool.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++) {
String& skey=*new(pool) String(pool);	StringPtr skey(new String);
{	*skey << pool.format_integer(i);
char buf=(char )pool.malloc(MAX_NUMBER);
snprintf(buf, MAX_NUMBER, "%d", i);
skey << buf;
}

result.hash(0).put(skey, new(pool) VXnode(pool, 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, const String& method_name, MethodParams *params) {	static void _getElementById(Request& r, StringPtr method_name, MethodParams* params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=GET_SELF(r, VXdoc);

// elementId	// elementId
const String& elementId=params->as_string(0, "elementID must be string");	StringPtr 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(method_name),
pool.transcode(elementId).get(),	r.transcode(elementId).get(),
&exc)) {	&exc)) {
// write out result	// write out result
VXnode& result=*new(pool) VXnode(pool, node);	r.write_no_lang(ValuePtr(new VXnode(&pool, &r.charsets, node)));
r.write_no_lang(result);
} else if(exc \|\| xmlHaveGenericErrors())	} else if(exc \|\| xmlHaveGenericErrors())
throw Exception(0, 0,	throw Exception(
&method_name,	method_name,
exc);	exc);
}	}
/*
GdomeNode gdome_doc_importNode (GdomeDocument self, GdomeNode importedNode, GdomeBoolean deep, GdomeException exc);
GdomeElement gdome_doc_createElementNS (GdomeDocument self, GdomeDOMString namespaceURI, GdomeDOMString qualifiedName, GdomeException *exc);
GdomeAttr gdome_doc_createAttributeNS (GdomeDocument self, GdomeDOMString namespaceURI, GdomeDOMString qualifiedName, GdomeException *exc);
*/


static void _create(Request& r, const String& method_name, MethodParams *params) {	static void _importNode(Request& r, StringPtr method_name, MethodParams* params) {
//_asm int 3;
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=GET_SELF(r, VXdoc);

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

GdomeException exc;	GdomeNode *importedNode=
/*	as_node(method_name, params, 0, "importedNode must be node");
GdomeDocumentType *documentType=gdome_di_createDocumentType (	bool deep=
docimpl,	params->as_bool(1, "deep must be bool", r);
pool.transcode(qualifiedName),
0/publicId /,	GdomeException exc;
0/systemId /,	GdomeNode *outputNode=gdome_doc_importNode(vdoc.get_document(method_name),
&exc);	importedNode,
if(!documentType \|\| exc \|\| xmlHaveGenericErrors())	deep, &exc);
throw Exception(0, 0,	if(exc)
&method_name,	throw Exception(
exc);	method_name,
*/
GdomeDocument *document=gdome_di_createDocument (domimpl,
0/namespaceURI/,
pool.transcode(qualifiedName).get(),
0/doctype/,
&exc);
if(!document \|\| exc \|\| xmlHaveGenericErrors())
throw Exception(0, 0,
&method_name,
exc);	exc);

/// +xalan createXMLDecl ?	// write out result
	r.write_no_lang(ValuePtr(new VXnode(&pool, &r.charsets, outputNode)));
// replace any previous parsed source
vdoc.set_document(document);
}	}
	/*
	GdomeElement gdome_doc_createElementNS (GdomeDocument self, GdomeDOMString namespaceURI, GdomeDOMString qualifiedName, GdomeException *exc);
	GdomeAttr gdome_doc_createAttributeNS (GdomeDocument self, GdomeDOMString namespaceURI, GdomeDOMString qualifiedName, GdomeException *exc);
	*/

static void _set(Request& r, const String& method_name, MethodParams *params) {	static void _create(Request& r, StringPtr method_name, MethodParams* params) {
// _asm int 3;
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	Charset& source_charset=r.charsets.source();
	VXdoc& vdoc=GET_SELF(r, VXdoc);

Value& vxml=params->as_junction(0, "xml must be code");	ValuePtr param=(*params)[params->count()-1];
Temp_lang temp_lang(r, String::UL_XML);	GdomeDocument *document;
const String& xml=r.process(vxml).as_string();	if(param->get_junction()) { // {<?xml?>...}
	Temp_lang temp_lang(r, String::UL_XML);
	StringPtr xml=r.process_to_string(param);

	CharPtr cstr=xml->cstr(String::UL_UNSPECIFIED);
	document=(GdomeDocument *)
	gdome_xml_n_mkref((xmlNode *)xmlParseMemory(
	cstr, strlen(cstr)
	));
	if(!document \|\| xmlHaveGenericErrors()) {
	GdomeException exc=0;
	throw Exception(
	method_name,
	exc);
	}
	} else { // [name]
	StringPtr qualifiedName=param->as_string(&pool);

const char *cstr=xml.cstr(String::UL_UNSPECIFIED);	GdomeException exc;
GdomeDocument document=(GdomeDocument )	/*
gdome_xml_n_mkref((xmlNode *)xmlParseMemory(	GdomeDocumentType *documentType=gdome_di_createDocumentType (
cstr, strlen(cstr)	docimpl,
));	r.transcode(qualifiedName),
if(!document \|\| xmlHaveGenericErrors()) {	0/publicId /,
GdomeException exc=0;	0/systemId /,
throw Exception(0, 0,	&exc);
&method_name,	if(!documentType \|\| exc \|\| xmlHaveGenericErrors())
exc);	throw Exception(
	method_name,
	exc);
	*/
	document=gdome_di_createDocument (domimpl,
	0/namespaceURI/,
	r.transcode(qualifiedName).get(),
	0/doctype/,
	&exc);
	if(!document \|\| exc \|\| xmlHaveGenericErrors())
	throw Exception(
	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 ?
}	}

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

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

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

// filespec	// filespec
const String& file_name=params->as_string(0, "uri must be string");	StringPtr file_name=params->as_string(0, "uri must be string");
const String& uri=r.absolute(file_name);	StringPtr uri=r.absolute(file_name);

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

GdomeDocument document=(GdomeDocument )	GdomeDocument document=(GdomeDocument )
gdome_xml_n_mkref((xmlNode *)xmlParseFile(uri.cstr()));	gdome_xml_n_mkref((xmlNode *)xmlParseMemory(file.data, file.size));
if(!document \|\| xmlHaveGenericErrors()) {	if(!document \|\| xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(0, 0,	throw Exception(uri, exc);
&uri,
exc);
}	}
	CharPtr URI_cstr=uri->cstr();
	xmlDoc *doc=gdome_xml_doc_get_xmlDoc(document);
	if(URI_cstr)
	doc->URL=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));

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

static void param_option_over_output_option(Pool& pool,	static void param_option_over_output_option(Pool& pool,
Hash param_options, const char option_name,	HashStringValue& param_options, const char* option_name,
const String *& output_option) {	StringPtr& output_option) {
if(Value value=static_cast<Value >(param_options->get(*new(pool) String(pool,	if(ValuePtr value=param_options.get(StringPtr(new String(option_name))))
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(Pool& pool,
Hash param_options, const char option_name,	HashStringValue& param_options, const char* option_name,
bool& output_option) {	bool& output_option) {
if(Value value=static_cast<Value >(param_options->get(*new(pool)	if(ValuePtr value=param_options.get(StringPtr(new String(option_name)))) {
String(pool, 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(0, 0,	throw Exception("parser.runtime",
&s,	s,
"%s must be either 'yes' or 'no'", option_name);	"%s must be either 'yes' or 'no'", option_name);
}	}
}	}

static void prepare_output_options(	/// @test valid_options check
Pool& pool, const String& method_name, MethodParams *params, int index,	static void prepare_output_options(Request& r,
	StringPtr method_name, MethodParams* params, int 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 502 static void prepare_output_options(	Line 543 static void prepare_output_options(
*/	*/

// configuring with options from parameter...	// configuring with options from parameter...
if(params->size()>index) {	if(params->count()>index) {
Value& voptions=params->as_no_junction(index, "options must be string");	ValuePtr voptions=params->as_no_junction(index, "options must be string");
if(voptions.is_defined()) {	if(voptions->is_defined()) {
if(Hash *options=voptions.get_hash(&method_name)) {	if(HashStringValue *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(ValuePtr vmethod=options->get(StringPtr(new String(XDOC_OUTPUT_METHOD_OPTION_NAME))))
String(pool, 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(pool, *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(pool, *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(pool, *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(pool, *options, "standalone", oo.standalone);
// $.doctype-public[?]	// $.doctype-public[?]
param_option_over_output_option(pool, options, "doctype-public", oo.doctypePublic);	param_option_over_output_option(pool, *options, "doctype-public", oo.doctypePublic);
// $.doctype-system[?]	// $.doctype-system[?]
param_option_over_output_option(pool, options, "doctype-system", oo.doctypeSystem);	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(pool, *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(pool, *options, "media-type", oo.mediaType);
}	}
}	}
}	}

// default encoding from pool	// default encoding from pool
if(!oo.encoding)	if(!oo.encoding)
oo.encoding=&pool.get_source_charset().name();	oo.encoding=r.charsets.source().name();
// default method=xml	// default method=xml
if(!oo.method)	if(!oo.method)
oo.method=new(pool) String(pool, XDOC_OUTPUT_METHOD_OPTION_VALUE_XML);	oo.method=StringPtr(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=new(pool) String(pool, "text/xml");	oo.mediaType=StringPtr(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=new(pool) String(pool, "text/html");	oo.mediaType=StringPtr(new String("text/html"));
else // XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT & all others	else // XDOC_OUTPUT_METHOD_OPTION_VALUE_TEXT & all others
oo.mediaType=new(pool) String(pool, "text/plain");	oo.mediaType=StringPtr(new String("text/plain"));
}	}
}	}

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

const char *encoding_cstr=oo.encoding->cstr();	CharPtr encoding_cstr=oo.encoding->cstr();
xmlCharEncodingHandler *encoder=xmlFindCharEncodingHandler(encoding_cstr);	xmlCharEncodingHandler *encoder=xmlFindCharEncodingHandler(encoding_cstr);
if(!encoder)	if(!encoder)
throw Exception(0, 0,	throw Exception("parser.runtime",
&method_name,	method_name,
"encoding '%s' not supported", encoding_cstr);	"encoding '%s' not supported", encoding_cstr.get());
// 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 572 static void xdoc2buf(Pool& pool, VXdoc&	Line 617 static void xdoc2buf(Pool& pool, VXdoc&

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

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

Line 591 static void xdoc2buf(Pool& pool, VXdoc&	Line 636 static void xdoc2buf(Pool& pool, VXdoc&
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(method_name));
if(xsltSaveResultTo(outputBuffer.get(), document, stylesheet.get())<0) {	if(xsltSaveResultTo(outputBuffer.get(), document, stylesheet.get())<0) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(0, 0,	throw Exception(
&method_name,	method_name,
exc);	exc);
}	}

Line 609 static void xdoc2buf(Pool& pool, VXdoc&	Line 654 static void xdoc2buf(Pool& pool, VXdoc&
gnome_buf=(char *)outputBuffer->buffer->content;	gnome_buf=(char *)outputBuffer->buffer->content;
}	}
if(file_spec)	if(file_spec)
file_write(	file_write(file_spec,
*file_spec,
gnome_buf, gnome_size,	gnome_buf, gnome_size,
true/as_text/);	true/as_text/);
else if(*parser_size=gnome_size) {	else if(result.size=gnome_size) {
parser_buf=(char )pool.malloc(gnome_size);	result.ptr=pool.copy(gnome_buf, gnome_size);
memcpy(*parser_buf, gnome_buf, gnome_size);
} else	} else
*parser_buf=0;	result.ptr=0;

	return result;
}	}

static void _file(Request& r, const String& method_name, MethodParams *params) {	static void _file(Request& r, StringPtr method_name, MethodParams* params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=GET_SELF(r, VXdoc);
VXdoc::Output_options oo(vdoc.output_options);	VXdoc::Output_options oo(vdoc.output_options);
char *buf; size_t buf_size;	Xdoc2buf_result buf=xdoc2buf(r, vdoc, method_name, params, 0,
xdoc2buf(pool, vdoc, method_name, params, 0,
oo,	oo,
0/not to file, to memory/,	StringPtr(0)/not to file, to memory/);
&buf, &buf_size);
// write out result	// write out result
r.write_no_lang(*new(pool) String(pool, buf, buf_size));	r.write_no_lang(String(buf.ptr, buf.size));

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

vfile.set(false/tainted/, buf, buf_size, 0/file_name/, vcontent_type);	vfile->set(pool, false/tainted/, buf.ptr?buf.ptr:""/to distinguish from stat-ed file/, buf.size,
	0/file_name/, vcontent_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, StringPtr method_name, MethodParams* params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	VXdoc& vdoc=GET_SELF(r, VXdoc);

const String& file_spec=r.absolute(params->as_string(0, "file name must be string"));	StringPtr 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(pool, vdoc, method_name, params, 1,	xdoc2buf(r, vdoc, method_name, params, 1,
oo,	oo,
&file_spec,	file_spec);
0, 0);
}	}

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

static void add_xslt_param(const Hash::Key& aattribute, Hash::Val *ameaning,	#ifndef DOXYGEN
void *info) {	struct Add_xslt_param_info {
Value meaning=static_cast<Value >(ameaning);	Request* r;
Pool& pool=meaning->pool();	Array<GdomeDOMString_auto_ptr>* strings;
const char transform_params=(const char )info;	const char** current_transform_param;
*transform_params++=pool.transcode(aattribute)->str;	};
*transform_params++=pool.transcode(meaning->as_string())->str;	#endif
	static void add_xslt_param(
	HashStringValue::key_type attribute,
	HashStringValue::value_type meaning,
	Add_xslt_param_info* info) {
	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(meaning->as_string(&info->r->pool())))->str; info->strings+=s;
}	}
static void _transform(Request& r, const String& method_name, MethodParams *params) {	static VXdocPtr _transform(Request& r, StringPtr doc_source, StringPtr stylesheet_source,
//_asm int 3;	VXdoc& vdoc, xsltStylesheetPtr stylesheet, const char** transform_params) {
Pool& pool=r.pool();	Pool& pool=r.pool();
VXdoc& vdoc=static_cast<VXdoc >(r.self);	xmlDoc *document=gdome_xml_doc_get_xmlDoc(vdoc.get_document(doc_source));

// params
const char **transform_params=0;
if(params->size()>1) {
Value& vparams=params->as_no_junction(1, "transform parameters must be hash");
if(vparams.is_defined())
if(Hash *params=vparams.get_hash(&method_name)) {
transform_params=
(const char *)pool.malloc(sizeof(const char )params->size()2+1);
params->for_each(add_xslt_param, transform_params);
transform_params[params->size()*2]=0;
} else
throw Exception(0, 0,
&method_name,
"transform parameters parameter must be hash");
}

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

// transform
xsltStylesheet stylesheet=connection->stylesheet(false/nocache*/);
xmlDoc *document=gdome_xml_doc_get_xmlDoc(vdoc.get_document(&method_name));
xsltTransformContext_auto_ptr transformContext(	xsltTransformContext_auto_ptr transformContext(
xsltNewTransformContext(stylesheet, document));	xsltNewTransformContext(stylesheet, document));
	// make params literal
	if (transformContext->globalVars == NULL) // strangly not initialized by xsltNewTransformContext
	transformContext->globalVars = xmlHashCreate(20);
	xsltQuoteUserParams(transformContext.get(), transform_params);
	// do transform
xmlDoc *transformed=xsltApplyStylesheetUser(	xmlDoc *transformed=xsltApplyStylesheetUser(
stylesheet,	stylesheet,
document,	document,
transform_params,	0/already quoted-inserted transform_params/,
0/const char output*/,	0/const char output*/,
0/FILE profile*/,	0/FILE profile*/,
transformContext.get());	transformContext.get());
if(!transformed \|\| xmlHaveGenericErrors()) {	if(!transformed \|\| xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(0, 0,	throw Exception(
&stylesheet_filespec,	stylesheet_source,
exc);	exc);
}	}

Line 731 static void _transform(Request& r, const	Line 760 static void _transform(Request& r, const
// constructing result	// constructing result
GdomeDocument *gdomeDocument=gdome_xml_doc_mkref(transformed);	GdomeDocument *gdomeDocument=gdome_xml_doc_mkref(transformed);
if(!gdomeDocument)	if(!gdomeDocument)
throw Exception(0, 0,	throw Exception(0,
&method_name,	doc_source,
"gdome_xml_doc_mkref failed");	"gdome_xml_doc_mkref failed");
VXdoc& result=*new(pool) VXdoc(pool, gdomeDocument);	VXdocPtr result(new VXdoc(&pool, &r.charsets, gdomeDocument));
/* grabbing options	/* grabbing options

<xsl:output	<xsl:output
Line 750 static void _transform(Request& r, const	Line 779 static void _transform(Request& r, const
!indent = "yes" \| "no"	!indent = "yes" \| "no"
!media-type = string />	!media-type = string />
*/	*/
memset(&result.output_options, 0, sizeof(result.output_options));	VXdoc::Output_options& oo=result->output_options;
VXdoc::Output_options& oo=result.output_options;

oo.method=stylesheet->method?&pool.transcode(stylesheet->method):0;	oo.method=stylesheet->method?r.transcode(stylesheet->method, stylesheet_source):StringPtr(0);
oo.encoding=stylesheet->encoding?&pool.transcode(stylesheet->encoding):0;	oo.encoding=stylesheet->encoding?r.transcode(stylesheet->encoding, stylesheet_source):StringPtr(0);
oo.mediaType=stylesheet->mediaType?&pool.transcode(stylesheet->mediaType):0;	oo.mediaType=stylesheet->mediaType?r.transcode(stylesheet->mediaType, stylesheet_source):StringPtr(0);
oo.doctypeSystem=stylesheet->doctypeSystem?&pool.transcode(stylesheet->doctypeSystem):0;	oo.doctypeSystem=stylesheet->doctypeSystem?r.transcode(stylesheet->doctypeSystem, stylesheet_source):StringPtr(0);
oo.doctypePublic=stylesheet->doctypePublic?&pool.transcode(stylesheet->doctypePublic):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?&pool.transcode(stylesheet->version):0;	oo.version=stylesheet->version?r.transcode(stylesheet->version, stylesheet_source):StringPtr(0);
oo.standalone=stylesheet->standalone!=0;	oo.standalone=stylesheet->standalone!=0;
oo.omitXmlDeclaration=stylesheet->omitXmlDeclaration!=0;	oo.omitXmlDeclaration=stylesheet->omitXmlDeclaration!=0;

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

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

	VXdocPtr result;
	ValuePtr vmaybe_xdoc=(*params)[0];
	if(Value *vxdoc=vmaybe_xdoc->as(VXDOC_TYPE, false)) { // stylesheet (xdoc)
	xmlDoc *document=gdome_xml_doc_get_xmlDoc(
	static_cast<VXdoc *>(vxdoc)->get_document(method_name));
	// compile xdoc stylesheet
	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()) {
	GdomeException exc=0;
	throw Exception(method_name, exc);
	}
	if(!stylesheet_ptr.get())
	throw Exception("xml",
	method_name,
	"stylesheet failed to compile");

	// transform!
	result=_transform(r, method_name, method_name,
	vdoc, stylesheet_ptr.get(),
	transform_params);
	} else { // stylesheet (file name)
	// extablish stylesheet connection
	StringPtr stylesheet_filespec=
	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);

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

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

// constructor	// constructor

MXdoc::MXdoc(Pool& apool) : MXnode(apool) {	/// @test how to create empty type html?
set_name(*NEW String(pool(), XDOC_CLASS_NAME));	MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME, xnode_class.get()) {

/// @test how to create empty type html?

/// DOM1	/// DOM1

// Element createElement(in DOMString tagName) raises(DOMException);	// Element createElement(in DOMString tagName) raises(DOMException);
Line 792 MXdoc::MXdoc(Pool& apool) : MXnode(apool	Line 881 MXdoc::MXdoc(Pool& apool) : MXnode(apool
add_native_method("createAttribute", Method::CT_DYNAMIC, _createAttribute, 1, 1);	add_native_method("createAttribute", Method::CT_DYNAMIC, _createAttribute, 1, 1);
// EntityReference createEntityReference(in DOMString name) raises(DOMException);	// EntityReference createEntityReference(in DOMString name) raises(DOMException);
add_native_method("createEntityReference", Method::CT_DYNAMIC, _createEntityReference, 1, 1);	add_native_method("createEntityReference", Method::CT_DYNAMIC, _createEntityReference, 1, 1);
// NodeList getElementsByTagName(in DOMString tagname);	// NodeList getElementsByTagName(in DOMString name);
add_native_method("getElementsByTagName", Method::CT_DYNAMIC, _getElementsByTagName, 1, 1);	add_native_method("getElementsByTagName", Method::CT_DYNAMIC, _getElementsByTagName, 1, 1);
// ^xdoc.getElementsByTagNameNS[namespaceURI;localName] = array of nodes
add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2);

/// DOM2(?)	/// DOM2

// ^xdoc.getElementById[elementId]	// ^xdoc.getElementById[elementId]
add_native_method("getElementById", Method::CT_DYNAMIC, _getElementById, 1, 1);	add_native_method("getElementById", Method::CT_DYNAMIC, _getElementById, 1, 1);

	// Node (in Node importedNode, in boolean deep) raises(DOMException)
	add_native_method("importNode", Method::CT_DYNAMIC, _importNode, 2, 2);

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

/// parser	/// parser

// ^xdoc::create{qualifiedName}	// ^xdoc::create{qualifiedName}
add_native_method("create", Method::CT_DYNAMIC, _create, 1, 1);	// ^xdoc::create[<some>xml</some>]
// ^xdoc::set[<some>xml</some>]	// ^xdoc::create[URI][<some>xml</some>]
add_native_method("set", Method::CT_DYNAMIC, _set, 1, 1);	add_native_method("create", Method::CT_DYNAMIC, _create, 1, 2);
	// for backward compatibility with <=v 1.82 2002/01/31 11:51:46 paf
	add_native_method("set", Method::CT_DYNAMIC, _create, 1, 1);

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

// ^xdoc.save[some.xml]	// ^xdoc.save[some.xml]
// ^xdoc.save[some.xml;options hash]	// ^xdoc.save[some.xml;options hash]
Line 824 MXdoc::MXdoc(Pool& apool) : MXnode(apool	Line 919 MXdoc::MXdoc(Pool& apool) : MXnode(apool
// ^xdoc.file[options hash] file with "<doc/>"	// ^xdoc.file[options hash] file with "<doc/>"
add_native_method("file", Method::CT_DYNAMIC, _file, 0, 1);	add_native_method("file", Method::CT_DYNAMIC, _file, 0, 1);

// ^xdoc.transform[stylesheet file_name]	// ^xdoc.transform[stylesheet file_name/xdoc]
// ^xdoc.transform[stylesheet file_name;params hash]	// ^xdoc.transform[stylesheet file_name/xdoc;params hash]
add_native_method("transform", Method::CT_DYNAMIC, _transform, 1, 2);	add_native_method("transform", Method::CT_DYNAMIC, _transform, 1, 2);

}	}
Line 833 MXdoc::MXdoc(Pool& apool) : MXnode(apool	Line 928 MXdoc::MXdoc(Pool& apool) : MXnode(apool
void MXdoc::configure_admin(Request& r) {	void MXdoc::configure_admin(Request& r) {
}	}

// global variable	# else

Methoded *Xdoc_class;	// global variable

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

#endif	#endif

Methoded *MXdoc_create(Pool& pool) {
return
#ifdef XML
Xdoc_class=new(pool) MXdoc(pool)
#else
0
#endif
;
}

E-mail:

Removed from v.1.78
changed lines
	Added in v.1.108.2.19