parser3/src/classes/xnode.C - diff

Return to xnode.C CVS log

Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/xnode.C between versions 1.54.2.10.2.1 and 1.64

version 1.54.2.10.2.1, 2003/03/18 15:14:15	version 1.64, 2004/02/03 16:27:54
Line 7	Line 7
#include "classes.h"	#include "classes.h"
#ifdef XML	#ifdef XML

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

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

Line 16 static const char* IDENT_XNODE_C="$Date$	Line 16 static const char* IDENT_XNODE_C="$Date$
#include "pa_vxnode.h"	#include "pa_vxnode.h"
#include "pa_vxdoc.h"	#include "pa_vxdoc.h"
#include "pa_vvoid.h"	#include "pa_vvoid.h"
	#include "pa_xml_exception.h"

#include "xnode.h"	#include "xnode.h"

Line 100 private:	Line 101 private:

// helpers	// helpers

GdomeNode as_node(const String& method_name, MethodParams params,	GdomeNode* as_node(MethodParams& params,
int index, const char* msg) {	int index, const char* msg) {
ValuePtr value=params->as_no_junction(index, msg);	GdomeNode* result;
if(Value* vxnode=value->as(VXNODE_TYPE, false))	Value& value=params.as_no_junction(index, msg);
return static_cast<VXnode*>(vxnode)->get_node(method_name);	if(Value* vxnode=value.as(VXNODE_TYPE, false))
else	result=static_cast<VXnode*>(vxnode)->get_node();
	else {
throw Exception("parser.runtime",	throw Exception("parser.runtime",
method_name,	0,
msg);	msg);
	}

	return result;
}	}

// helpers	// helpers

GdomeAttr * as_attrconst String& method_name, MethodParams* params,	GdomeAttr* as_attr(MethodParams& params,
int index, const char* msg) {	int index, const char* msg) {
GdomeNode *node=as_node(method_name, params, index, msg);	GdomeNode* node=as_node(params, index, msg);
GdomeException exc;	GdomeException exc;
if(gdome_n_nodeType(node, &exc)!=GDOME_ATTRIBUTE_NODE)	if(gdome_n_nodeType(node, &exc)!=GDOME_ATTRIBUTE_NODE)
throw Exception("parser.runtime",	throw Exception("parser.runtime",
method_name,	0,
msg);	msg);

return GDOME_A(node);	return GDOME_A(node);
Line 130 GdomeAttr * as_attrconst String& method_	Line 135 GdomeAttr * as_attrconst String& method_
// DOM1 node	// DOM1 node

// Node insertBefore(in Node newChild,in Node refChild) raises(DOMException);	// Node insertBefore(in Node newChild,in Node refChild) raises(DOMException);
static void _insertBefore(Request& r, const String& method_name, MethodParams* params) {	static void _insertBefore(Request& r, MethodParams& params) {
=r.pool();
VXnode& vnode=GET_SELF(r, VXnode);	VXnode& vnode=GET_SELF(r, VXnode);
GdomeNode *selfNode=vnode.get_node(method_name);	GdomeNode* selfNode=vnode.get_node();
GdomeNode *newChild=as_node(method_name, params, 0, "newChild must be node");	GdomeNode* newChild=as_node(params, 0, "newChild must be node");
GdomeNode *refChild=as_node(method_name, params, 1, "refChild must be node");	GdomeNode* refChild=as_node(params, 1, "refChild must be node");

GdomeException exc;	GdomeException exc;
if(GdomeNode *retNode=gdome_n_insertBefore(selfNode, newChild, refChild, &exc)) {	if(GdomeNode* retNode=gdome_n_insertBefore(selfNode, newChild, refChild, &exc)) {
// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&pool, &r.charsets, retNode)));	r.write_no_lang(*new VXnode(&r.charsets, retNode));
} else	} else
throw Exception(	throw XmlException(0, exc);
method_name,
exc);
}	}

// Node replaceChild(in Node newChild,in Node oldChild) raises(DOMException);	// Node replaceChild(in Node newChild,in Node oldChild) raises(DOMException);
static void _replaceChild(Request& r, const String& method_name, MethodParams* params) {	static void _replaceChild(Request& r, MethodParams& params) {
=r.pool();
VXnode& vnode=GET_SELF(r, VXnode);	VXnode& vnode=GET_SELF(r, VXnode);
GdomeNode *selfNode=vnode.get_node(method_name);	GdomeNode* selfNode=vnode.get_node();
GdomeNode *newChild=as_node(method_name, params, 0, "newChild must be node");	GdomeNode* newChild=as_node(params, 0, "newChild must be node");
GdomeNode *refChild=as_node(method_name, params, 1, "refChild must be node");	GdomeNode* oldChild=as_node(params, 1, "oldChild must be node");

GdomeException exc;	GdomeException exc;
if(GdomeNode *retNode=gdome_n_replaceChild(selfNode, newChild, refChild, &exc)) {	if(GdomeNode* retNode=gdome_n_replaceChild(selfNode, newChild, oldChild, &exc)) {
// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&pool, &r.charsets, retNode)));	r.write_no_lang(*new VXnode(&r.charsets, retNode));
} else	} else
throw Exception(	throw XmlException(0, exc);
method_name,
exc);
}	}

// Node removeChild(in Node oldChild) raises(DOMException);	// Node removeChild(in Node oldChild) raises(DOMException);
static void _removeChild(Request& r, const String& method_name, MethodParams* params) {	static void _removeChild(Request& r, MethodParams& params) {
=r.pool();
VXnode& vnode=GET_SELF(r, VXnode);	VXnode& vnode=GET_SELF(r, VXnode);
GdomeNode *selfNode=vnode.get_node(method_name);	GdomeNode* selfNode=vnode.get_node();
GdomeNode *oldChild=as_node(method_name, params, 0, "oldChild must be node");	GdomeNode* oldChild=as_node(params, 0, "oldChild must be node");

GdomeException exc;	GdomeException exc;
if(GdomeNode *retNode=gdome_n_removeChild(selfNode, oldChild, &exc)) {	if(GdomeNode* retNode=gdome_n_removeChild(selfNode, oldChild, &exc)) {
// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&pool, &r.charsets, retNode)));	r.write_no_lang(*new VXnode(&r.charsets, retNode));
} else	} else
throw Exception(	throw XmlException(0, exc);
method_name,
exc);
}	}

// Node appendChild(in Node newChild) raises(DOMException);	// Node appendChild(in Node newChild) raises(DOMException);
static void _appendChild(Request& r, const String& method_name, MethodParams* params) {	static void _appendChild(Request& r, MethodParams& params) {
=r.pool();
VXnode& vnode=GET_SELF(r, VXnode);	VXnode& vnode=GET_SELF(r, VXnode);
GdomeNode *selfNode=vnode.get_node(method_name);	GdomeNode* selfNode=vnode.get_node();
GdomeNode *newChild=as_node(method_name, params, 0, "newChild must be node");	GdomeNode* newChild=as_node(params, 0, "newChild must be node");

GdomeException exc;	GdomeException exc;
if(GdomeNode *retNode=gdome_n_appendChild(selfNode, newChild, &exc)) {	if(GdomeNode* retNode=gdome_n_appendChild(selfNode, newChild, &exc)) {
// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&pool, &r.charsets, retNode)));	r.write_no_lang(*new VXnode(&r.charsets, retNode));
} else	} else
throw Exception(	throw XmlException(0, exc);
method_name,
exc);
}	}

// boolean hasChildNodes();	// boolean hasChildNodes();
static void _hasChildNodes(Request& r, const String& method_name, MethodParams* ) {	static void _hasChildNodes(Request& r, MethodParams&) {
=r.pool();
VXnode& vnode=GET_SELF(r, VXnode);	VXnode& vnode=GET_SELF(r, VXnode);
GdomeNode *node=vnode.get_node(method_name);	GdomeNode* node=vnode.get_node();

GdomeException exc;	GdomeException exc;
// write out result	// write out result
bool result=gdome_n_hasChildNodes(node, &exc)!=0;	bool result=gdome_n_hasChildNodes(node, &exc)!=0;
r.write_no_lang(ValuePtr(new VBool(result)));	r.write_no_lang(*new VBool(result));
}	}

// Node cloneNode(in boolean deep);	// Node cloneNode(in boolean deep);
static void _cloneNode(Request& r, const String& method_name, MethodParams* params) {	static void _cloneNode(Request& r, MethodParams& params) {
=r.pool();
VXnode& vnode=GET_SELF(r, VXnode);	VXnode& vnode=GET_SELF(r, VXnode);
GdomeNode *node=vnode.get_node(method_name);	GdomeNode* node=vnode.get_node();

bool deep=params->as_bool(0, "deep must be bool", r);	bool deep=params.as_bool(0, "deep must be bool", r);

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

// DOM1 element	// DOM1 element

GdomeElement *get_self_element(Request& r, const String& method_name) {	GdomeElement* get_self_element(Request& r) {
=r.pool();
VXnode& vnode=GET_SELF(r, VXnode);	VXnode& vnode=GET_SELF(r, VXnode);
GdomeNode *node=vnode.get_node(method_name);	GdomeNode* node=vnode.get_node();

GdomeException exc;	GdomeException exc;
if(gdome_n_nodeType(node, &exc)!=GDOME_ELEMENT_NODE)	if(gdome_n_nodeType(node, &exc)!=GDOME_ELEMENT_NODE)
throw Exception("parser.runtime",	throw Exception("parser.runtime",
method_name,	0,
"method can only be called on nodes of ELEMENT type");	"method can only be called on nodes of ELEMENT type");

return GDOME_EL(node);	return GDOME_EL(node);
Line 242 GdomeElement *get_self_element(Request&	Line 232 GdomeElement *get_self_element(Request&



// DOMString getAttribute(in DOMString name);	/// @bug attribute_value must be freed! [// DOMString getAttribute(in DOMString name);
static void _getAttribute(Request& r, const String& method_name, MethodParams* params) {	static void _getAttribute(Request& r, MethodParams& params) {
=r.pool();	GdomeElement* element=get_self_element(r);
GdomeElement *element=get_self_element(r, method_name);	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;
GdomeDOMString *attribute_value=	GdomeDOMString *attribute_value=
gdome_el_getAttribute(element, r.transcode(name).get(), &exc);	gdome_el_getAttribute(element, r.transcode(name).use(), &exc);
// write out result	// write out result
r.write_no_lang(*r.transcode(attribute_value, name));	r.write_no_lang(r.transcode(attribute_value));
}	}

// void setAttribute(in DOMString name, in DOMString value) raises(DOMException);	// void setAttribute(in DOMString name, in DOMString value) raises(DOMException);
static void _setAttribute(Request& r, const String& method_name, MethodParams* params) {	static void _setAttribute(Request& r, MethodParams& params) {
=r.pool();	GdomeElement* element=get_self_element(r);
GdomeElement *element=get_self_element(r, method_name);	const String& name=params.as_string(0, "name must be string");
const String& name=params->as_string(0, "name must be string");	const String& attribute_value=params.as_string(1, "value must be string");
const String& attribute_value=params->as_string(1, "value must be string");

GdomeException exc;	GdomeException exc;
gdome_el_setAttribute(element,	gdome_el_setAttribute(element,
r.transcode(name).get(),	r.transcode(name).use(),
r.transcode(attribute_value).get(),	r.transcode(attribute_value).use(),
&exc);	&exc);
if(exc)	if(exc)
throw Exception(	throw XmlException(0, exc);
method_name,
exc);
}	}

// void removeAttribute(in DOMString name) raises(DOMException);	// void removeAttribute(in DOMString name) raises(DOMException);
static void _removeAttribute(Request& r, const String& method_name, MethodParams* params) {	static void _removeAttribute(Request& r, MethodParams& params) {
=r.pool();	GdomeElement* element=get_self_element(r);
GdomeElement *element=get_self_element(r, method_name);	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;
gdome_el_removeAttribute(element, r.transcode(name).get(), &exc);	gdome_el_removeAttribute(element, r.transcode(name).use(), &exc);
if(exc)	if(exc)
throw Exception(	throw XmlException(0, exc);
method_name,
exc);
}	}

// Attr getAttributeNode(in DOMString name);	// Attr getAttributeNode(in DOMString name);
static void _getAttributeNode(Request& r, const String& method_name, MethodParams* params) {	static void _getAttributeNode(Request& r, MethodParams& params) {
=r.pool();	GdomeElement* element=get_self_element(r);
GdomeElement *element=get_self_element(r, method_name);	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;
if(GdomeAttr *attr=gdome_el_getAttributeNode(element, r.transcode(name).get(), &exc)) {	if(GdomeAttr *attr=gdome_el_getAttributeNode(element,
	r.transcode(name).use(), &exc)) {
// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&pool, &r.charsets, (GdomeNode *)attr)));	r.write_no_lang(new VXnode(&r.charsets, (GdomeNode )attr));
} else if(exc)	} else if(exc)
throw Exception(	throw XmlException(0, exc);
method_name,
exc);
}	}

// Attr setAttributeNode(in Attr newAttr) raises(DOMException);	// Attr setAttributeNode(in Attr newAttr) raises(DOMException);
static void _setAttributeNode(Request& r, const String& method_name, MethodParams* params) {	static void _setAttributeNode(Request& r, MethodParams& params) {
=r.pool();	GdomeElement* element=get_self_element(r);
GdomeElement *element=get_self_element(r, method_name);	GdomeAttr * newAttr=as_attr(params, 0, "newAttr must be ATTRIBUTE node");
GdomeAttr * newAttr=as_attr(pool, method_name, params, 0, "newAttr must be ATTRIBUTE node");

GdomeException exc;	GdomeException exc;
if(GdomeAttr *returnAttr=gdome_el_setAttributeNode(element, newAttr, &exc)) {	if(GdomeAttr *returnAttr=gdome_el_setAttributeNode(element, newAttr, &exc)) {
// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&pool, &r.charsets, (GdomeNode *)returnAttr)));	r.write_no_lang(new VXnode(&r.charsets, (GdomeNode )returnAttr));
} else	} else
throw Exception(	throw XmlException(0, exc);
method_name,
exc);
}	}

// Attr removeAttributeNode(in Attr oldAttr) raises(DOMException);	// Attr removeAttributeNode(in Attr oldAttr) raises(DOMException);
static void _removeAttributeNode(Request& r, const String& method_name, MethodParams* params) {	static void _removeAttributeNode(Request& r, MethodParams& params) {
=r.pool();	GdomeElement* element=get_self_element(r);
GdomeElement *element=get_self_element(r, method_name);	GdomeAttr * oldAttr=as_attr(params, 0, "oldAttr must be ATTRIBUTE node");
GdomeAttr * oldAttr=as_attr(pool, method_name, params, 0, "oldAttr must be ATTRIBUTE node");

GdomeException exc;	GdomeException exc;
gdome_el_removeAttributeNode(element, oldAttr, &exc);	gdome_el_removeAttributeNode(element, oldAttr, &exc);
if(exc)	if(exc)
throw Exception(	throw XmlException(0, exc);
method_name,
exc);
}	}

// NodeList getElementsByTagName(in DOMString name);	// NodeList getElementsByTagName(in DOMString name);
static void _getElementsByTagName(Request& r, const String& method_name, MethodParams* params) {	static void _getElementsByTagName(Request& r, MethodParams& params) {
=r.pool();	GdomeElement* element=get_self_element(r);
GdomeElement *element=get_self_element(r, method_name);

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

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

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

static void _getElementsByTagNameNS(Request& r, const String& method_name, MethodParams* params) {	// DOM 2
=r.pool();
GdomeElement *element=get_self_element(r, method_name);	// DOMString getAttributeNS(in DOMString namespaceURI, in DOMString localName);
	static void _getAttributeNS(Request& r, MethodParams& params) {
	GdomeElement* element=get_self_element(r);

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

	GdomeException exc;
	GdomeDOMString *attribute_value=
	gdome_el_getAttributeNS(element,
	r.transcode(namespaceURI).use(),
	r.transcode(localName).use(), &exc);
	// write out result
	r.write_no_lang(r.transcode(attribute_value));
	}

	// void setAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName, in DOMString value) raises(DOMException);
	static void _setAttributeNS(Request& r, MethodParams& params) {
	GdomeElement* element=get_self_element(r);
	const String& namespaceURI=params.as_string(0, "namespaceURI must be string");
	const String& qualifiedName=params.as_string(1, "qualifiedName must be string");
	const String& attribute_value=params.as_string(2, "value must be string");

	GdomeException exc;
	gdome_el_setAttributeNS(element,
	r.transcode(namespaceURI).use(),
	r.transcode(qualifiedName).use(),
	r.transcode(attribute_value).use(),
	&exc);
	if(exc)
	throw XmlException(0, exc);
	}

	// void removeAttributeNS(in DOMString namespaceURI, in DOMString localName) raises(DOMException);
	static void _removeAttributeNS(Request& r, MethodParams& params) {
	GdomeElement* element=get_self_element(r);
	const String& namespaceURI=params.as_string(0, "namespaceURI must be string");
	const String& localName=params.as_string(1, "localName must be string");

	GdomeException exc;
	gdome_el_removeAttributeNS(element,
	r.transcode(namespaceURI).use(),
	r.transcode(localName).use(),
	&exc);
	if(exc)
	throw XmlException(0, exc);
	}

	// Attr getAttributeNodeNS(in DOMString namespaceURI, in DOMString localName);
	static void _getAttributeNodeNS(Request& r, MethodParams& params) {
	GdomeElement* element=get_self_element(r);
	const String& namespaceURI=params.as_string(0, "namespaceURI must be string");
	const String& name=params.as_string(1, "name must be string");

	GdomeException exc;
	if(GdomeAttr *attr=gdome_el_getAttributeNodeNS(element,
	r.transcode(namespaceURI).use(), r.transcode(name).use(), &exc)) {
	// write out result
	r.write_no_lang(new VXnode(&r.charsets, (GdomeNode )attr));
	} else if(exc)
	throw XmlException(0, exc);
	}

	// Attr setAttributeNodeNS(in Attr newAttr) raises(DOMException);
	static void _setAttributeNodeNS(Request& r, MethodParams& params) {
	GdomeElement* element=get_self_element(r);
	GdomeAttr * newAttr=as_attr(params, 0, "newAttr must be ATTRIBUTE node");

	GdomeException exc;
	if(GdomeAttr *returnAttr=gdome_el_setAttributeNodeNS(element, newAttr, &exc)) {
	// write out result
	r.write_no_lang(new VXnode(&r.charsets, (GdomeNode )returnAttr));
	} else
	throw XmlException(0, exc);
	}

	// boolean hasAttribute(in DOMString name) raises(DOMException);
	static void _hasAttribute(Request& r, MethodParams& params) {
	GdomeElement* element=get_self_element(r);

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

	GdomeException exc;
	// write out result
	bool result=gdome_el_hasAttribute(element,
	r.transcode(name).use(),
	&exc)!=0;
	r.write_no_lang(*new VBool(result));
	}

	// boolean hasAttributeNS(n DOMString namespaceURI, in DOMString localName) raises(DOMException);
	static void _hasAttributeNS(Request& r, MethodParams& params) {
	GdomeElement* element=get_self_element(r);

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

	GdomeException exc;
	// write out result
	bool result=gdome_el_hasAttributeNS(element,
	r.transcode(namespaceURI).use(),
	r.transcode(localName).use(),
	&exc)!=0;
	r.write_no_lang(*new VBool(result));
	}

	static void _getElementsByTagNameNS(Request& r, MethodParams& params) {
	GdomeElement* element=get_self_element(r);

// 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;
VHashPtr result(new VHash);	VHash& result=*new VHash;
if(GdomeNodeList *nodes=	if(GdomeNodeList *nodes=
gdome_el_getElementsByTagNameNS(	gdome_el_getElementsByTagNameNS(
element,	element,
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++)
const String& skey(new String);	result.hash().put(
*skey << pool.format_integer(i);	String::Body::Format(i),
	new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));
result->hash(Exception::undefined_source).put(skey,
ValuePtr(new VXnode(&pool, &r.charsets, gdome_nl_item(nodes, i, &exc))));
}
}	}

// write out result	// write out result
Line 392 static void _getElementsByTagNameNS(Requ	Line 465 static void _getElementsByTagNameNS(Requ
}	}

// void normalize();	// void normalize();
static void _normalize(Request& r, const String& method_name, MethodParams* ) {	static void _normalize(Request& r, MethodParams&) {
=r.pool();
VXnode& vnode=GET_SELF(r, VXnode);	VXnode& vnode=GET_SELF(r, VXnode);
GdomeNode *selfNode=vnode.get_node(method_name);	GdomeNode* selfNode=vnode.get_node();

GdomeException exc;	GdomeException exc;
gdome_n_normalize(selfNode, &exc);	gdome_n_normalize(selfNode, &exc);
if(exc)	if(exc)
throw Exception(	throw XmlException(0, exc);
method_name,
exc);
}	}

static void _selectX(Request& r, const String& method_name, MethodParams* params,	static void _selectX(Request& r, MethodParams& params,
void (*handler)(Request& r,	void (*handler)(Request& r,
const String& expression,	const String& expression,
xmlXPathObject_auto_ptr res,	xmlXPathObject_auto_ptr res,
ValuePtr& result)) {	Value*& result)) {
// _asm int 3;
=r.pool();
VXnode& vnode=GET_SELF(r, VXnode);	VXnode& vnode=GET_SELF(r, VXnode);

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

GdomeException exc;	GdomeException exc;
GdomeNode *dome_node=vnode.get_node(method_name);	GdomeNode* dome_node=vnode.get_node();
GdomeDocument *dome_document=gdome_n_ownerDocument(dome_node, &exc);	GdomeDocument *dome_document=gdome_n_ownerDocument(dome_node, &exc);
if(!dome_document) // document does not own itself, so ownerDocument = 0	if(!dome_document) // document does not own itself, so ownerDocument = 0
dome_document=GDOME_DOC(dome_node); // and we need downcast	dome_document=GDOME_DOC(dome_node); // and we need downcast
xmlDoc *xml_document=gdome_xml_doc_get_xmlDoc(dome_document);	xmlDoc *xml_document=gdome_xml_doc_get_xmlDoc(dome_document);
xmlXPathContext_auto_ptr ctxt(xmlXPathNewContext(xml_document));	xmlXPathContext_auto_ptr ctxt(xmlXPathNewContext(xml_document));
ctxt->node=gdome_xml_n_get_xmlNode(dome_node);	ctxt->node=gdome_xml_n_get_xmlNode(dome_node);
/error to stderr for now/	/error to stderr for now/
xmlXPathObject_auto_ptr res(	xmlXPathObject_auto_ptr res(
Line 431 static void _selectX(Request& r, const S	Line 499 static void _selectX(Request& r, const S

if(xmlHaveGenericErrors()) {	if(xmlHaveGenericErrors()) {
GdomeException exc=0;	GdomeException exc=0;
throw Exception(expression, exc);	throw XmlException(&expression, exc);
}	}

ValuePtr result;	Value* result=0;
if(res.get())	if(res.get())
handler(r, expression, res, result);	handler(r, expression, res, result);
if(result)	if(result)
r.write_no_lang(result);	r.write_no_lang(*result);
}	}

static void selectNodesHandler(Request& r,	static void selectNodesHandler(Request& r,
const String& expression,	const String& expression,
xmlXPathObject_auto_ptr res,	xmlXPathObject_auto_ptr res,
ValuePtr& result) {	Value*& result) {
=r.pool();	VHash& vhash=*new VHash; result=&vhash;
VHashPtr vhash(new VHash); result=vhash;
switch(res->type) {	switch(res->type) {
case XPATH_UNDEFINED:	case XPATH_UNDEFINED:
break;	break;
case XPATH_NODESET:	case XPATH_NODESET:
if(res->nodesetval)	if(res->nodesetval)
if(int size=res->nodesetval->nodeNr) {	if(int size=res->nodesetval->nodeNr) {
HashStringValue& hash=vhash->hash(Exception::undefined_source);	HashStringValue& hash=vhash.hash();
for(int i=0; i<size; i++) {	for(int i=0; i<size; i++)
const String& skey(new String);	hash.put(
*skey << pool.format_integer(i);	String::Body::Format(i),
	new VXnode(
hash.put(skey,	&r.charsets,
ValuePtr(new VXnode(&pool, &r.charsets, gdome_xml_n_mkref(res->nodesetval->nodeTab[i]))));	gdome_xml_n_mkref(res->nodesetval->nodeTab[i])));
}
}	}
break;	break;
default:	default:
throw Exception(Exception::undefined_type,	throw Exception(0,
expression,	&expression,
"wrong xmlXPathEvalExpression result type (%d)", res->type);	"wrong xmlXPathEvalExpression result type (%d)", res->type);
break; // never	break; // never
}	}
}	}

static void selectNodeHandler(Request& r,	static void selectNodeHandler(Request& r,
const String& expression,	const String& expression,
xmlXPathObject_auto_ptr res,	xmlXPathObject_auto_ptr res,
ValuePtr& result) {	Value*& result) {
=r.pool();

switch(res->type) {	switch(res->type) {
case XPATH_UNDEFINED:	case XPATH_UNDEFINED:
break;	break;
Line 484 static void selectNodeHandler(Request& r	Line 548 static void selectNodeHandler(Request& r
if(res->nodesetval && res->nodesetval->nodeNr) { // empty result strangly has NODESET res->type	if(res->nodesetval && res->nodesetval->nodeNr) { // empty result strangly has NODESET res->type
if(res->nodesetval->nodeNr>1)	if(res->nodesetval->nodeNr>1)
throw Exception("parser.runtime",	throw Exception("parser.runtime",
expression,	&expression,
"resulted not in a single node (%d)", res->nodesetval->nodeNr);	"resulted not in a single node (%d)", res->nodesetval->nodeNr);

result=ValuePtr(new VXnode(&pool, &r.charsets, gdome_xml_n_mkref(res->nodesetval->nodeTab[0])));	result=new VXnode(
	&r.charsets,
	gdome_xml_n_mkref(res->nodesetval->nodeTab[0]));
}	}
break;	break;
case XPATH_BOOLEAN:	case XPATH_BOOLEAN:
result=ValuePtr(new VBool(res->boolval!=0));	result=new VBool(res->boolval!=0);
break;	break;
case XPATH_NUMBER:	case XPATH_NUMBER:
result=ValuePtr(new VDouble(res->floatval));	result=new VDouble(res->floatval);
break;	break;
case XPATH_STRING:	case XPATH_STRING:
result=ValuePtr(new VString(	result=new VString(r.transcode((xmlChar*)res->stringval));
r.transcode(
GdomeDOMString_auto_ptr(
gdome_str_mkref_dup((const gchar *)res->stringval)).get(), expression)));
break;	break;
default:	default:
throw Exception("parser.runtime",	throw Exception("parser.runtime",
expression,	&expression,
"wrong xmlXPathEvalExpression result type (%d)", res->type);	"wrong xmlXPathEvalExpression result type (%d)", res->type);
	// result=0;
break; // never	break; // never
}	}
}	}

static void selectBoolHandler(Request& r,	static void selectBoolHandler(Request&,
const String& expression,	const String& expression,
xmlXPathObject_auto_ptr res,	xmlXPathObject_auto_ptr res,
ValuePtr& result) {	Value*& result) {
=r.pool();
switch(res->type) {	switch(res->type) {
case XPATH_BOOLEAN:	case XPATH_BOOLEAN:
result=ValuePtr(new VBool(res->boolval!=0));	result=new VBool(res->boolval!=0);
break;	break;
case XPATH_NODESET:	case XPATH_NODESET:
if(!(res->nodesetval && res->nodesetval->nodeNr))	if(!(res->nodesetval && res->nodesetval->nodeNr))
Line 525 static void selectBoolHandler(Request& r	Line 588 static void selectBoolHandler(Request& r
// else[nodeset] fall down to default	// else[nodeset] fall down to default
default:	default:
throw Exception("parser.runtime",	throw Exception("parser.runtime",
expression,	&expression,
"wrong xmlXPathEvalExpression result type (%d)", res->type);	"wrong xmlXPathEvalExpression result type (%d)", res->type);
break; // never	break; // never
}	}
}	}

static void selectNumberHandler(Request& r,	static void selectNumberHandler(Request&,
const String& expression,	const String& expression,
xmlXPathObject_auto_ptr res,	xmlXPathObject_auto_ptr res,
ValuePtr& result) {	Value*& result) {
=r.pool();
switch(res->type) {	switch(res->type) {
case XPATH_NUMBER:	case XPATH_NUMBER:
result=ValuePtr(new VDouble(res->floatval));	result=new VDouble(res->floatval);
break;	break;
case XPATH_NODESET:	case XPATH_NODESET:
if(!(res->nodesetval && res->nodesetval->nodeNr))	if(!(res->nodesetval && res->nodesetval->nodeNr))
Line 546 static void selectNumberHandler(Request&	Line 608 static void selectNumberHandler(Request&
// else[nodeset] fall down to default	// else[nodeset] fall down to default
default:	default:
throw Exception("parser.runtime",	throw Exception("parser.runtime",
expression,	&expression,
"wrong xmlXPathEvalExpression result type (%d)", res->type);	"wrong xmlXPathEvalExpression result type (%d)", res->type);
break; // never	break; // never
}	}
Line 555 static void selectNumberHandler(Request&	Line 617 static void selectNumberHandler(Request&
static void selectStringHandler(Request& r,	static void selectStringHandler(Request& r,
const String& expression,	const String& expression,
xmlXPathObject_auto_ptr res,	xmlXPathObject_auto_ptr res,
ValuePtr& result) {	Value*& result) {
=r.pool();
switch(res->type) {	switch(res->type) {
case XPATH_UNDEFINED:	case XPATH_UNDEFINED:
break;	break;
case XPATH_STRING:	case XPATH_STRING:
result=ValuePtr(new VString(	result=new VString(r.transcode((xmlChar*)res->stringval));
r.transcode(
GdomeDOMString_auto_ptr(
gdome_str_mkref_dup((const gchar *)res->stringval)).get(), expression)));
break;	break;
case XPATH_NODESET:	case XPATH_NODESET:
if(!(res->nodesetval && res->nodesetval->nodeNr))	if(!(res->nodesetval && res->nodesetval->nodeNr))
Line 572 static void selectStringHandler(Request&	Line 630 static void selectStringHandler(Request&
// else[nodeset] fall down to default	// else[nodeset] fall down to default
default:	default:
throw Exception("parser.runtime",	throw Exception("parser.runtime",
expression,	&expression,
"wrong xmlXPathEvalExpression result type (%d)", res->type);	"wrong xmlXPathEvalExpression result type (%d)", res->type);
break; // never	break; // never
}	}
}	}

static void _select(Request& r, const String& method_name, MethodParams* params) {	static void _select(Request& r, MethodParams& params) {
_selectX(r, method_name, params,	_selectX(r, params,
selectNodesHandler);	selectNodesHandler);
}	}

static void _selectSingle(Request& r, const String& method_name, MethodParams* params) {	static void _selectSingle(Request& r, MethodParams& params) {
_selectX(r, method_name, params,	_selectX(r, params,
selectNodeHandler);	selectNodeHandler);
}	}

static void _selectBool(Request& r, const String& method_name, MethodParams* params) {	static void _selectBool(Request& r, MethodParams& params) {
_selectX(r, method_name, params,	_selectX(r, params,
selectBoolHandler);	selectBoolHandler);
}	}

static void _selectNumber(Request& r, const String& method_name, MethodParams* params) {	static void _selectNumber(Request& r, MethodParams& params) {
_selectX(r, method_name, params,	_selectX(r, params,
selectNumberHandler);	selectNumberHandler);
}	}

static void _selectString(Request& r, const String& method_name, MethodParams* params) {	static void _selectString(Request& r, MethodParams& params) {
_selectX(r, method_name, params,	_selectX(r, params,
selectStringHandler);	selectStringHandler);
}	}

// constructor	// constructor

	/// @bug one can change const and ruin other's work, we need unchangable VIntConst class
MXnode::MXnode(const char* aname, VStateless_class *abase):	MXnode::MXnode(const char* aname, VStateless_class *abase):
Methoded(aname?aname:"xnode", abase)	Methoded(aname?aname:"xnode", abase)
{	{
Line 644 MXnode::MXnode(const char* aname, VState	Line 703 MXnode::MXnode(const char* aname, VState
// void normalize();	// void normalize();
add_native_method("normalize", Method::CT_DYNAMIC, _normalize, 0, 0);	add_native_method("normalize", Method::CT_DYNAMIC, _normalize, 0, 0);

	/// DOM2 element

	// DOMString getAttributeNS(in DOMString namespaceURI, in DOMString localName);
	add_native_method("getAttributeNS", Method::CT_DYNAMIC, _getAttributeNS, 2, 2);
	// void setAttributeNS(in DOMString namespaceURI, in DOMString qualifiedName, in DOMString value) raises(DOMException);
	add_native_method("setAttributeNS", Method::CT_DYNAMIC, _setAttributeNS, 3, 3);
	// void removeAttributeNS(in DOMString namespaceURI, in DOMString localName) raises(DOMException);
	add_native_method("removeAttributeNS", Method::CT_DYNAMIC, _removeAttributeNS, 2, 2);
	// Attr getAttributeNodeNS(in DOMString namespaceURI, in DOMString localName);
	add_native_method("getAttributeNodeNS", Method::CT_DYNAMIC, _getAttributeNodeNS, 2, 2);
	// Attr setAttributeNodeNS(in Attr newAttr) raises(DOMException);
	add_native_method("setAttributeNodeNS", Method::CT_DYNAMIC, _setAttributeNodeNS, 1, 1);
	// boolean hasAttribute(in DOMString name) raises(DOMException);
	add_native_method("hasAttribute", Method::CT_DYNAMIC, _hasAttribute, 1, 1);
	// boolean hasAttributeNS(in DOMString namespaceURI, in DOMString localName) raises(DOMException);
	add_native_method("hasAttributeNS", Method::CT_DYNAMIC, _hasAttributeNS, 2, 2);

/// parser	/// parser
// ^node.select[/some/xpath/query] = hash $.#[dnode]	// ^node.select[/some/xpath/query] = hash $.#[dnode]
add_native_method("select", Method::CT_DYNAMIC, _select, 1, 1);	add_native_method("select", Method::CT_DYNAMIC, _select, 1, 1);
Line 660 MXnode::MXnode(const char* aname, VState	Line 736 MXnode::MXnode(const char* aname, VState
// consts	// consts

#define CONST(name) \	#define CONST(name) \
consts.put(String* (new String(#name)), ValuePtr(new VInt(GDOME_##name)))	consts.put(String::Body(#name), new VInt(GDOME_##name))

CONST(ELEMENT_NODE);	CONST(ELEMENT_NODE);
CONST(ATTRIBUTE_NODE);	CONST(ATTRIBUTE_NODE);
CONST(TEXT_NODE);	CONST(TEXT_NODE);
CONST(CDATA_SECTION_NODE);	CONST(CDATA_SECTION_NODE);
CONST(ENTITY_REFERENCE_NODE);	CONST(ENTITY_REFERENCE_NODE);
CONST(ENTITY_NODE);	CONST(ENTITY_NODE);
CONST(PROCESSING_INSTRUCTION_NODE);	CONST(PROCESSING_INSTRUCTION_NODE);
CONST(COMMENT_NODE);	CONST(COMMENT_NODE);
CONST(DOCUMENT_NODE);	CONST(DOCUMENT_NODE);
CONST(DOCUMENT_TYPE_NODE);	CONST(DOCUMENT_TYPE_NODE);
CONST(DOCUMENT_FRAGMENT_NODE);	CONST(DOCUMENT_FRAGMENT_NODE);
CONST(NOTATION_NODE);	CONST(NOTATION_NODE);

}	}

#else	#else

E-mail:

Removed from v.1.54.2.10.2.1
changed lines
	Added in v.1.64