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.21 and 1.139

version 1.108.2.19.2.21, 2003/04/02 10:24:02	version 1.139, 2004/02/18 11:54:08
Line 1	Line 1
/** @file	/** @file
Parser: @b xdoc parser class.	Parser: @b xdoc parser class.

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

Line 9	Line 9

#ifdef XML	#ifdef XML

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

#include "gdome.h"	#include "gdome.h"
#include "libxml/tree.h"	#include "libxml/tree.h"
	#include "libxml/HTMLtree.h"
#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 "libxslt/variables.h"
	#include "libxslt/imports.h"

#include "pa_vmethod_frame.h"	#include "pa_vmethod_frame.h"

Line 26 static const char* IDENT_XDOC_C="$Date$"	Line 27 static const char* IDENT_XDOC_C="$Date$"
#include "pa_vxdoc.h"	#include "pa_vxdoc.h"
#include "pa_charset.h"	#include "pa_charset.h"
#include "pa_vfile.h"	#include "pa_vfile.h"
	#include "pa_xml_exception.h"
#include "xnode.h"	#include "xnode.h"

// defines	// defines
Line 41 static const char* IDENT_XDOC_C="$Date$"	Line 43 static const char* IDENT_XDOC_C="$Date$"

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

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

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

// global variable	// global variable
Line 160 private:	Line 160 private:
static void writeNode(Request& r, GdomeNode *node,	static void writeNode(Request& r, GdomeNode *node,
GdomeException exc) {	GdomeException exc) {
if(!node \|\| exc)	if(!node \|\| exc)
throw Exception(0, exc);	throw XmlException(0, exc);

// write out result	// write out result
r.write_no_lang(*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, 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(),	(GdomeNode *)gdome_doc_createElement(vdoc.get_document(),
r.transcode(tagName).get(),	r.transcode(tagName).use(),
	&exc);
	writeNode(r, node, exc);
	}

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

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

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

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

GdomeException exc;	GdomeException exc;
Line 193 static void _createDocumentFragment(Requ	Line 210 static void _createDocumentFragment(Requ
}	}

// Text createTextNode(in DOMString data);	// Text createTextNode(in DOMString data);
static void _createTextNode(Request& r, 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(),	vdoc.get_document(),
r.transcode(data).get(),	r.transcode(data).use(),
&exc);	&exc);
writeNode(r, node, exc);	writeNode(r, node, exc);
}	}

// Comment createComment(in DOMString data)	// Comment createComment(in DOMString data)
static void _createComment(Request& r, 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(),	vdoc.get_document(),
r.transcode(data).get(),	r.transcode(data).use(),
&exc);	&exc);
writeNode(r, 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, 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(),	vdoc.get_document(),
r.transcode(data).get(),	r.transcode(data).use(),
&exc);	&exc);
writeNode(r, 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, 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");
const String& data=params->as_string(1, "data must be string");	const String& data=params.as_string(1, "data must be string");

GdomeException exc;	GdomeException exc;
GdomeNode node=(GdomeNode )gdome_doc_createProcessingInstruction(	GdomeNode node=(GdomeNode )gdome_doc_createProcessingInstruction(
vdoc.get_document(),	vdoc.get_document(),
r.transcode(target).get(),	r.transcode(target).use(),
r.transcode(data).get(),	r.transcode(data).use(),
&exc);	&exc);
writeNode(r, 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, 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(),	vdoc.get_document(),
r.transcode(name).get(),	r.transcode(name).use(),
&exc);	&exc);
writeNode(r, node, exc);	writeNode(r, node, exc);
}	}

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

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

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

// EntityReference createEntityReference(in DOMString name) raises(DOMException);	// EntityReference createEntityReference(in DOMString name) raises(DOMException);
static void _createEntityReference(Request& r, 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(),	vdoc.get_document(),
r.transcode(name).get(),	r.transcode(name).use(),
&exc);	&exc);
writeNode(r, node, exc);	writeNode(r, node, exc);
}	}

// NodeList getElementsByTagName(in DOMString name);	// NodeList getElementsByTagName(in DOMString name);
static void _getElementsByTagName(Request& r, 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");

VHash& 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(),	vdoc.get_document(),
r.transcode(name).get(),	r.transcode(name).use(),
&exc)) {	&exc)) {
gulong length=gdome_nl_length(nodes, &exc);	gulong length=gdome_nl_length(nodes, &exc);
for(gulong i=0; i<length; i++)	for(gulong i=0; i<length; i++)
result.hash().put(	result.hash().put(
StringBody::Format(i),	String::Body::Format(i),
new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));	new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));
} else if(exc)	} else if(exc)
throw Exception(0, exc);	throw XmlException(0, exc);

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

static void _getElementsByTagNameNS(Request& r, 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
const String& namespaceURI=params->as_string(0, "namespaceURI must be string");	const String& namespaceURI=params.as_string(0, "namespaceURI must be string");
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;
VHash& result=*new VHash;	VHash& result=*new VHash;
if(GdomeNodeList *nodes=	if(GdomeNodeList *nodes=
gdome_doc_getElementsByTagNameNS(	gdome_doc_getElementsByTagNameNS(
vdoc.get_document(),	vdoc.get_document(),
r.transcode(namespaceURI).get(),	r.transcode(namespaceURI).use(),
r.transcode(localName).get(),	r.transcode(localName).use(),
&exc)) {	&exc)) {
gulong length=gdome_nl_length(nodes, &exc);	gulong length=gdome_nl_length(nodes, &exc);
for(gulong i=0; i<length; i++)	for(gulong i=0; i<length; i++)
result.hash().put(	result.hash().put(
StringBody::Format(i),	String::Body::Format(i),
new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));	new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));
}	}

Line 328 static void _getElementsByTagNameNS(Requ	Line 363 static void _getElementsByTagNameNS(Requ
r.write_no_lang(result);	r.write_no_lang(result);
}	}

static void _getElementById(Request& r, MethodParams* params) {	static void _getElementById(Request& r, MethodParams& params) {
VXdoc& vdoc=GET_SELF(r, VXdoc);	VXdoc& vdoc=GET_SELF(r, VXdoc);

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

GdomeException exc;	GdomeException exc;
if(GdomeNode node=(GdomeNode )gdome_doc_getElementById(	if(GdomeNode node=(GdomeNode )gdome_doc_getElementById(
vdoc.get_document(),	vdoc.get_document(),
r.transcode(elementId).get(),	r.transcode(elementId).use(),
&exc)) {	&exc)) {
// write out result	// write out result
r.write_no_lang(*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 XmlException(&elementId, exc);
&elementId,
exc);
}	}

static void _importNode(Request& r, 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(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(),	GdomeNode *outputNode=gdome_doc_importNode(vdoc.get_document(),
importedNode,	importedNode,
deep, &exc);	deep, &exc);
if(exc)	if(exc)
throw Exception(0, exc);	throw XmlException(0, exc);

// write out result	// write out result
r.write_no_lang(*new VXnode(&r.charsets, outputNode));	r.write_no_lang(*new VXnode(&r.charsets, outputNode));
Line 370 GdomeElement *gdome_doc_createElementNS	Line 403 GdomeElement *gdome_doc_createElementNS
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, 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);

Value& param=(params)[params->count()-1];	Value& param=params[params.count()-1];
GdomeDocument *document;	GdomeDocument *document;
bool set_encoding=false;	bool set_encoding=false;
if(param.get_junction()) { // {<?xml?>...}	if(param.get_junction()) { // {<?xml?>...}
Temp_lang temp_lang(r, String::L_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::L_UNSPECIFIED);	const char* cstr=xml.cstr(String::L_UNSPECIFIED, 0, &r.charsets);
document=(GdomeDocument *)	document=(GdomeDocument *)
gdome_xml_n_mkref((xmlNode *)xmlParseMemory(	gdome_xml_n_mkref((xmlNode *)xmlParseMemory(
cstr, strlen(cstr)	cstr, strlen(cstr)
Line 389 static void _create(Request& r, MethodPa	Line 422 static void _create(Request& r, MethodPa
//printf("document=0x%p\n", document);	//printf("document=0x%p\n", document);
if(!document \|\| xmlHaveGenericErrors()) {	if(!document \|\| xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(0, exc);	throw XmlException(0, exc);
}	}

// must be last action in if, see after if}	// must be last action in if, see after if}
Line 397 static void _create(Request& r, MethodPa	Line 430 static void _create(Request& r, MethodPa
const String& qualifiedName=param.as_string();	const String& qualifiedName=param.as_string();

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

set_encoding=true;	set_encoding=true;
// must be last action in if, see after if}	// must be last action in if, see after if}
Line 432 static void _create(Request& r, MethodPa	Line 465 static void _create(Request& r, MethodPa
// URI	// URI
const char* URI_cstr;	const char* URI_cstr;
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;
Line 442 static void _create(Request& r, MethodPa	Line 475 static void _create(Request& r, MethodPa
doc->URL=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));	doc->URL=source_charset.transcode_buf2xchar(URI_cstr, strlen(URI_cstr));

if(set_encoding) {	if(set_encoding) {
const char* source_charset_name=source_charset.name().cstr();	const char* source_charset_name=source_charset.NAME().cstr();
doc->encoding=source_charset.transcode_buf2xchar(source_charset_name, strlen(source_charset_name));	doc->encoding=source_charset.transcode_buf2xchar(source_charset_name, strlen(source_charset_name));
}	}
}	}

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

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

	/// todo!! add SAFE MODE!!
GdomeDocument document=(GdomeDocument )	GdomeDocument document=(GdomeDocument )
gdome_xml_n_mkref((xmlNode *)xmlParseMemory(file.str, file.length));	gdome_xml_n_mkref((xmlNode *)xmlParseFile(uri_cstr));
if(!document \|\| xmlHaveGenericErrors()) {	if(!document \|\| xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(&uri, exc);	throw XmlException(uri, exc);
}	}
// must be first action after if}	// must be first action after if}
// replace any previous parsed source	// replace any previous parsed source
Line 473 static void _load(Request& r, MethodPara	Line 505 static void _load(Request& r, MethodPara
GdomeException exc;	GdomeException exc;
gdome_doc_unref(document, &exc);	gdome_doc_unref(document, &exc);
}	}
	/* xmlParseFile does that itself. old peace for xmlParseMemory
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=r.charsets.source().transcode_buf2xchar(URI_cstr, strlen(URI_cstr));
	*/
}	}

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,
const String*& output_option) {	const String*& output_option) {
if(Value* value=param_options.get(StringBody(option_name)))	if(Value* value=param_options.get(String::Body(option_name)))
output_option=&value->as_string();	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(Value* value=param_options.get(StringBody(option_name))) {	if(Value* value=param_options.get(String::Body(option_name))) {
const String& s=value->as_string();	const String& s=value->as_string();
if(s=="yes")	if(s=="yes")
output_option=true;	output_option=true;
Line 505 static void param_option_over_output_opt	Line 537 static void param_option_over_output_opt

/// @test valid_options check	/// @test valid_options check
static void prepare_output_options(Request& r,	static void prepare_output_options(Request& r,
MethodParams* params, size_t index,	MethodParams& params, size_t index,
VXdoc::Output_options& oo) {	VXdoc::Output_options& oo) {
/*	/*
<xsl:output	<xsl:output
Line 522 static void prepare_output_options(Reque	Line 554 static void prepare_output_options(Reque
*/	*/

// configuring with options from parameter...	// configuring with options from parameter...
if(params->count()>index) {	if(params.count()>index) {
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(HashStringValue *options=voptions.get_hash()) {	if(HashStringValue *options=voptions.get_hash()) {
// $.method[xml\|html\|text]	// $.method[xml\|html\|text]
if(Value* vmethod=options->get(StringBody(XDOC_OUTPUT_METHOD_OPTION_NAME)))	if(Value* vmethod=options->get(String::Body(XDOC_OUTPUT_METHOD_OPTION_NAME)))
oo.method=&vmethod->as_string();	oo.method=&vmethod->as_string();

// $.version[1.0]	// $.version[1.0]
Line 538 static void prepare_output_options(Reque	Line 570 static void prepare_output_options(Reque
param_option_over_output_option(*options, "omit-xml-declaration", oo.omitXmlDeclaration);	param_option_over_output_option(*options, "omit-xml-declaration", oo.omitXmlDeclaration);
// $.standalone[yes\|no]	// $.standalone[yes\|no]
param_option_over_output_option(*options, "standalone", oo.standalone);	param_option_over_output_option(*options, "standalone", oo.standalone);
// $.doctype-public[?]
param_option_over_output_option(*options, "doctype-public", oo.doctypePublic);
// $.doctype-system[?]
param_option_over_output_option(*options, "doctype-system", oo.doctypeSystem);
// $.indent[yes\|no]	// $.indent[yes\|no]
param_option_over_output_option(*options, "indent", oo.indent);	param_option_over_output_option(*options, "indent", oo.indent);
// $.media-type[text/{html\|xml\|plain}]	// $.media-type[text/{html\|xml\|plain}]
Line 552 static void prepare_output_options(Reque	Line 580 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=new String(r.charsets.source().NAME(), String::L_TAINTED);
// default method=xml	// default method=xml
if(!oo.method)	if(!oo.method)
oo.method=new String(XDOC_OUTPUT_METHOD_OPTION_VALUE_XML);	oo.method=new String(XDOC_OUTPUT_METHOD_OPTION_VALUE_XML);
Line 567 static void prepare_output_options(Reque	Line 595 static void prepare_output_options(Reque
}	}
}	}

	/// patching piecees from libxslt and libxml not to set meta encoding
	static int
	pa_xsltSaveResultTo(xmlOutputBufferPtr buf, xmlDocPtr result,
	xsltStylesheetPtr style) {
	const xmlChar *encoding;
	int base;
	const xmlChar *method;
	int indent;

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

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

	base = buf->written;

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

	if ((method == NULL) && (result->type == XML_HTML_DOCUMENT_NODE))
	method = BAD_CAST "html";

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

	if ((method != NULL) &&
	(xmlStrEqual(method, (const xmlChar *) "html"))) {
	if (indent == -1)
	indent = 1;

	int is_xhtml = 0;
	xmlDtdPtr dtd = xmlGetIntSubset(result);
	if (dtd != NULL) {
	is_xhtml = xmlIsXHTML(dtd->SystemID, dtd->ExternalID);
	if (is_xhtml < 0)
	is_xhtml = 0;
	}
	xmlNodePtr cur=result->last;
	if(!cur) {
	is_xhtml=0;
	}

	if(is_xhtml) {
	// xhtmlNodeDumpOutput is static :(
	if((cur->parent == (xmlNodePtr) result) &&
	(cur->type == XML_ELEMENT_NODE) &&
	(xmlStrEqual(cur->name, BAD_CAST "html"))) {
	//cur->name=BAD_CAST "html ";
	}

	method = BAD_CAST "xml";
	omitXmlDecl = 0;
	} else {
	htmlDocContentDumpFormatOutput(buf, result, (const char *) encoding,
	indent);
	xmlOutputBufferFlush(buf);
	goto finish;
	}
	}

	if ((method != NULL) &&
	(xmlStrEqual(method, (const xmlChar *) "text"))) {
	xmlNodePtr cur;

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

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

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

	XSLT_GET_IMPORT_INT(standalone, style, standalone);

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

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


struct Xdoc2buf_result {	struct Xdoc2buf_result {
char* str;	char* str;
size_t length;	size_t length;
};	};
static Xdoc2buf_result xdoc2buf(Request& r, VXdoc& vdoc,	static Xdoc2buf_result xdoc2buf(Request& r, VXdoc& vdoc,
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;
Line 588 static Xdoc2buf_result xdoc2buf(Request&	Line 781 static Xdoc2buf_result xdoc2buf(Request&
// UTF-8 encoder contains empty input/output converters,	// UTF-8 encoder contains empty input/output converters,
// which is wrong for xmlOutputBufferCreateIO	// which is wrong for xmlOutputBufferCreateIO
// while zero encoder goes perfectly	// while zero encoder goes perfectly
if(encoder && strcmp(encoder->name, "UTF-8")==0)	const char* encoder_name=encoder->name;
	if(strcmp(encoder_name, "UTF-8")==0)
encoder=0;	encoder=0;

xmlOutputBuffer_auto_ptr outputBuffer(xmlAllocOutputBuffer(encoder));	xmlOutputBuffer_auto_ptr outputBuffer(xmlAllocOutputBuffer(encoder));
Line 607 static Xdoc2buf_result xdoc2buf(Request&	Line 801 static Xdoc2buf_result xdoc2buf(Request&
OOS2STYLE(method);	OOS2STYLE(method);
OOS2STYLE(encoding);	OOS2STYLE(encoding);
OOS2STYLE(mediaType);	OOS2STYLE(mediaType);
OOS2STYLE(doctypeSystem);	// OOS2STYLE(doctypeSystem);
OOS2STYLE(doctypePublic);	// OOS2STYLE(doctypePublic);
OOE2STYLE(indent);	OOE2STYLE(indent);
OOS2STYLE(version);	OOS2STYLE(version);
OOE2STYLE(standalone);	OOE2STYLE(standalone);
OOE2STYLE(omitXmlDeclaration);	OOE2STYLE(omitXmlDeclaration);

xmlDoc *document=gdome_xml_doc_get_xmlDoc(vdoc.get_document());	xmlDoc *document=gdome_xml_doc_get_xmlDoc(vdoc.get_document());
if(xsltSaveResultTo(outputBuffer.get(), document, stylesheet.get())<0) {	document->encoding=BAD_CAST xmlMemStrdup(encoder_name);
	if(pa_xsltSaveResultTo(outputBuffer.get(), document, stylesheet.get())<0) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(0, exc);	throw XmlException(0, exc);
}	}

// write out result	// write out result
Line 630 static Xdoc2buf_result xdoc2buf(Request&	Line 825 static Xdoc2buf_result xdoc2buf(Request&
gnome_str=(char *)outputBuffer->buffer->content;	gnome_str=(char *)outputBuffer->buffer->content;
}	}

	if((result.length=gnome_length)) {
	result.str=pa_strdup(gnome_str, gnome_length);
	} else
	result.str=0;

if(file_spec)	if(file_spec)
file_write(*file_spec,	file_write(*file_spec,
gnome_str, gnome_length,	gnome_str, gnome_length,
true/as_text/);	true/as_text/);
else if(result.length=gnome_length) {
result.str=pa_strdup(gnome_str, gnome_length);
} else
result.str=0;

return result;	return result;
}	}

static void _file(Request& r, 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, params, 0,	Xdoc2buf_result buf=xdoc2buf(r, vdoc, params, 0,
Line 658 static void _file(Request& r, MethodPara	Line 854 static void _file(Request& r, MethodPara
value_name,	value_name,
new VString(*oo.mediaType));	new VString(*oo.mediaType));
vhcontent_type.hash().put(	vhcontent_type.hash().put(
StringBody("charset"),	String::Body("charset"),
new VString(*oo.encoding));	new VString(*oo.encoding));

vfile.set(false/tainted/, buf.str?buf.str:""/to distinguish from stat-ed file/, buf.length,	vfile.set(false/tainted/, buf.str?buf.str:""/to distinguish from stat-ed file/, buf.length,
Line 666 static void _file(Request& r, MethodPara	Line 862 static void _file(Request& r, MethodPara
r.write_no_lang(vfile);	r.write_no_lang(vfile);
}	}

static void _save(Request& r, 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, params, 1,	xdoc2buf(r, vdoc, params, 1,
Line 677 static void _save(Request& r, MethodPara	Line 873 static void _save(Request& r, MethodPara
&file_spec);	&file_spec);
}	}

static void _string(Request& r, 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, params, 0,	Xdoc2buf_result buf=xdoc2buf(r, vdoc, params, 0,
Line 702 static void add_xslt_param(	Line 898 static void add_xslt_param(
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()))->str; info->strings+=s;	info->current_transform_param++=(s=info->r->transcode(meaning->as_string()))->str; info->strings+=s;
}	}

static VXdoc& _transform(Request& r, 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());	xmlDoc *document=gdome_xml_doc_get_xmlDoc(vdoc.get_document());
xsltTransformContext_auto_ptr transformContext(	xsltTransformContext_auto_ptr transformContext(
xsltNewTransformContext(stylesheet, document));	xsltNewTransformContext(stylesheet, document));
Line 721 static VXdoc& _transform(Request& r, con	Line 919 static VXdoc& _transform(Request& r, con
transformContext.get());	transformContext.get());
if(!transformed \|\| xmlHaveGenericErrors()) {	if(!transformed \|\| xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(stylesheet_source, exc);	throw XmlException(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 753 static VXdoc& _transform(Request& r, con	Line 951 static VXdoc& _transform(Request& r, con
oo.method=stylesheet->method?&r.transcode(stylesheet->method):0;	oo.method=stylesheet->method?&r.transcode(stylesheet->method):0;
oo.encoding=stylesheet->encoding?&r.transcode(stylesheet->encoding):0;	oo.encoding=stylesheet->encoding?&r.transcode(stylesheet->encoding):0;
oo.mediaType=stylesheet->mediaType?&r.transcode(stylesheet->mediaType):0;	oo.mediaType=stylesheet->mediaType?&r.transcode(stylesheet->mediaType):0;
oo.doctypeSystem=stylesheet->doctypeSystem?&r.transcode(stylesheet->doctypeSystem):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):0;	oo.version=stylesheet->version?&r.transcode(stylesheet->version):0;
oo.standalone=stylesheet->standalone!=0;	oo.standalone=stylesheet->standalone!=0;
Line 763 static VXdoc& _transform(Request& r, con	Line 959 static VXdoc& _transform(Request& r, con
// return	// return
return result;	return result;
}	}
static void _transform(Request& r, 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;
const char** transform_params=0;	const char** transform_params=0;
if(params->count()>1) {	if(params.count()>1) {
Value& 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()) {	if(HashStringValue* hash=vparams.get_hash()) {
transform_params=new(UseGC) const char[params->count()2+1];	transform_params=new(UseGC) const char[hash->count()2+1];
Add_xslt_param_info info={	Add_xslt_param_info info={
&r,	&r,
&transform_strings,	&transform_strings,
transform_params	transform_params
};	};
params->for_each(add_xslt_param, &info);	hash->for_each(add_xslt_param, &info);
transform_params[params->count()*2]=0;	transform_params[hash->count()*2]=0;
} else	} else
throw Exception("parser.runtime",	throw Exception("parser.runtime",
0,	0,
Line 788 static void _transform(Request& r, Metho	Line 984 static void _transform(Request& r, Metho
}	}

VXdoc* result;	VXdoc* result;
Value* vmaybe_xdoc=(*params)[0];	if(Value *vxdoc=params[0].as(VXDOC_TYPE, false)) { // stylesheet (xdoc)
if(Value *vxdoc=vmaybe_xdoc->as(VXDOC_TYPE, false)) { // stylesheet (xdoc)
xmlDoc *document=gdome_xml_doc_get_xmlDoc(	xmlDoc *document=gdome_xml_doc_get_xmlDoc(
static_cast<VXdoc *>(vxdoc)->get_document());	static_cast<VXdoc *>(vxdoc)->get_document());
// compile xdoc stylesheet	// compile xdoc stylesheet
xsltStylesheet_auto_ptr stylesheet_ptr(xsltParseStylesheetDoc(document));	xsltStylesheet_auto_ptr stylesheet_ptr(xsltParseStylesheetDoc(document));
// strange thing - xsltParseStylesheetDoc records document and destroys it in stylesheet destructor
// we don't need that
stylesheet_ptr->doc=0;
if(xmlHaveGenericErrors()) {	if(xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(0, exc);	throw XmlException(0, exc);
}	}
if(!stylesheet_ptr.get())	if(!stylesheet_ptr.get())
throw Exception("xml",	throw Exception("xml",
0,	0,
"stylesheet failed to compile");	"stylesheet failed to compile");
	// strange thing - xsltParseStylesheetDoc records document and destroys it in stylesheet destructor
	// we don't need that
	stylesheet_ptr->doc=0;

// transform!	// transform!
result=&_transform(r, 0,	result=&_transform(r, 0,
Line 813 static void _transform(Request& r, Metho	Line 1008 static void _transform(Request& r, Metho
} 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_connection_ptr 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, &stylesheet_filespec,	result=&_transform(r, &stylesheet_filespec, vdoc, connection->stylesheet(),
vdoc, connection->stylesheet(false/nocache/),
transform_params);	transform_params);
}	}

Line 860 MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME,	Line 1054 MXdoc::MXdoc(): MXnode(XDOC_CLASS_NAME,
// Node (in Node importedNode, in boolean deep) raises(DOMException)	// Node (in Node importedNode, in boolean deep) raises(DOMException)
add_native_method("importNode", Method::CT_DYNAMIC, _importNode, 2, 2);	add_native_method("importNode", Method::CT_DYNAMIC, _importNode, 2, 2);

	// Attr createAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
	add_native_method("createAttributeNS", Method::CT_DYNAMIC, _createAttributeNS, 2, 2);

	// Element createElementNS(in DOMString namespaceURI, in DOMString qualifiedName) raises(DOMException);
	add_native_method("createElementNS", Method::CT_DYNAMIC, _createElementNS, 2, 2);

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

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

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

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

}	}

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

# else	# else

#include "classes.h"	#include "classes.h"
Line 905 void MXdoc::configure_admin(Request& r)	Line 1102 void MXdoc::configure_admin(Request& r)
DECLARE_CLASS_VAR(xdoc, 0, 0); // fictive	DECLARE_CLASS_VAR(xdoc, 0, 0); // fictive

#endif	#endif

E-mail:

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