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.9 and 1.54.2.10.2.12

version 1.54.2.9, 2003/03/06 16:15:25	version 1.54.2.10.2.12, 2003/04/03 10:48:25
Line 100 private:	Line 100 private:

// helpers	// helpers

GdomeNode as_node(StringPtr 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);
	result=0; // calm, compiler
	}

	return result;
}	}

// helpers	// helpers

GdomeAttr * as_attr(Pool& pool, StringPtr 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_attr(Pool& pool, StringPt	Line 135 GdomeAttr * as_attr(Pool& pool, StringPt
// 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, StringPtr method_name, MethodParams* params) {	static void _insertBefore(Request& r, MethodParams& params) {
Pool& pool=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, retNode)));	r.write_no_lang(*new VXnode(&r.charsets, retNode));
} else	} else
throw Exception(	throw Exception(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, StringPtr method_name, MethodParams* params) {	static void _replaceChild(Request& r, MethodParams& params) {
Pool& pool=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_replaceChild(selfNode, newChild, refChild, &exc)) {	if(GdomeNode* retNode=gdome_n_replaceChild(selfNode, newChild, refChild, &exc)) {
// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&pool, retNode)));	r.write_no_lang(*new VXnode(&r.charsets, retNode));
} else	} else
throw Exception(	throw Exception(0, exc);
method_name,
exc);
}	}

// Node removeChild(in Node oldChild) raises(DOMException);	// Node removeChild(in Node oldChild) raises(DOMException);
static void _removeChild(Request& r, StringPtr method_name, MethodParams* params) {	static void _removeChild(Request& r, MethodParams& params) {
Pool& pool=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, retNode)));	r.write_no_lang(*new VXnode(&r.charsets, retNode));
} else	} else
throw Exception(	throw Exception(0, exc);
method_name,
exc);
}	}

// Node appendChild(in Node newChild) raises(DOMException);	// Node appendChild(in Node newChild) raises(DOMException);
static void _appendChild(Request& r, StringPtr method_name, MethodParams* params) {	static void _appendChild(Request& r, MethodParams& params) {
Pool& pool=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, retNode)));	r.write_no_lang(*new VXnode(&r.charsets, retNode));
} else	} else
throw Exception(	throw Exception(0, exc);
method_name,
exc);
}	}

// boolean hasChildNodes();	// boolean hasChildNodes();
static void _hasChildNodes(Request& r, StringPtr method_name, MethodParams* ) {	static void _hasChildNodes(Request& r, MethodParams&) {
Pool& pool=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, StringPtr method_name, MethodParams* params) {	static void _cloneNode(Request& r, MethodParams& params) {
Pool& pool=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, 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, StringPtr method_name) {	GdomeElement* get_self_element(Request& r) {
Pool& pool=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 243 GdomeElement *get_self_element(Request&	Line 233 GdomeElement *get_self_element(Request&


// DOMString getAttribute(in DOMString name);	// DOMString getAttribute(in DOMString name);
static void _getAttribute(Request& r, StringPtr method_name, MethodParams* params) {	static void _getAttribute(Request& r, MethodParams& params) {
Pool& pool=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");
StringPtr 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).get(), &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, StringPtr method_name, MethodParams* params) {	static void _setAttribute(Request& r, MethodParams& params) {
Pool& pool=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");
StringPtr name=params->as_string(0, "name must be string");	const String& attribute_value=params.as_string(1, "value must be string");
StringPtr attribute_value=params->as_string(1, "value must be string");

GdomeException exc;	GdomeException exc;
gdome_el_setAttribute(element,	gdome_el_setAttribute(element,
Line 268 static void _setAttribute(Request& r, St	Line 256 static void _setAttribute(Request& r, St
r.transcode(attribute_value).get(),	r.transcode(attribute_value).get(),
&exc);	&exc);
if(exc)	if(exc)
throw Exception(	throw Exception(0, exc);
method_name,
exc);
}	}

// void removeAttribute(in DOMString name) raises(DOMException);	// void removeAttribute(in DOMString name) raises(DOMException);
static void _removeAttribute(Request& r, StringPtr method_name, MethodParams* params) {	static void _removeAttribute(Request& r, MethodParams& params) {
Pool& pool=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");
StringPtr 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).get(), &exc);
if(exc)	if(exc)
throw Exception(	throw Exception(0, exc);
method_name,
exc);
}	}

// Attr getAttributeNode(in DOMString name);	// Attr getAttributeNode(in DOMString name);
static void _getAttributeNode(Request& r, StringPtr method_name, MethodParams* params) {	static void _getAttributeNode(Request& r, MethodParams& params) {
Pool& pool=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");
StringPtr 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).get(), &exc)) {
// write out result	// write out result
r.write_no_lang(ValuePtr(new VXnode(&pool, (GdomeNode *)attr)));	r.write_no_lang(new VXnode(&r.charsets, (GdomeNode )attr));
} else if(exc)	} else if(exc)
throw Exception(	throw Exception(
method_name,	0,
exc);	exc);
}	}

// Attr setAttributeNode(in Attr newAttr) raises(DOMException);	// Attr setAttributeNode(in Attr newAttr) raises(DOMException);
static void _setAttributeNode(Request& r, StringPtr method_name, MethodParams* params) {	static void _setAttributeNode(Request& r, MethodParams& params) {
Pool& pool=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, (GdomeNode *)returnAttr)));	r.write_no_lang(new VXnode(&r.charsets, (GdomeNode )returnAttr));
} else	} else
throw Exception(	throw Exception(
method_name,	0,
exc);	exc);
}	}

// Attr removeAttributeNode(in Attr oldAttr) raises(DOMException);	// Attr removeAttributeNode(in Attr oldAttr) raises(DOMException);
static void _removeAttributeNode(Request& r, StringPtr method_name, MethodParams* params) {	static void _removeAttributeNode(Request& r, MethodParams& params) {
Pool& pool=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 Exception(
method_name,	0,
exc);	exc);
}	}

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

StringPtr 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).get(), &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++)
StringPtr skey(new String);	result.hash().put(
*skey << pool.format_integer(i);	StringBody::Format(i),
result->hash(Exception::undefined_source).put(	new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));
skey,
ValuePtr(new VXnode(&pool, gdome_nl_item(nodes, i, &exc))));
}
} else if(exc)	} else if(exc)
throw Exception(	throw Exception(
method_name,	0,
exc);	exc);

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

static void _getElementsByTagNameNS(Request& r, StringPtr method_name, MethodParams* params) {	static void _getElementsByTagNameNS(Request& r, MethodParams& params) {
Pool& pool=r.pool();	GdomeElement* element=get_self_element(r);
GdomeElement *element=get_self_element(r, method_name);

// namespaceURI;localName	// namespaceURI;localName
StringPtr namespaceURI=params->as_string(0, "namespaceURI must be string");	const String& namespaceURI=params.as_string(0, "namespaceURI must be string");
StringPtr 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,
Line 378 static void _getElementsByTagNameNS(Requ	Line 353 static void _getElementsByTagNameNS(Requ
r.transcode(localName).get(),	r.transcode(localName).get(),
&exc)) {	&exc)) {
gulong length=gdome_nl_length(nodes, &exc);	gulong length=gdome_nl_length(nodes, &exc);
for(gulong i=0; i<length; i++) {	for(gulong i=0; i<length; i++)
StringPtr skey(new String);	result.hash().put(
*skey << pool.format_integer(i);	StringBody::Format(i),
	new VXnode(&r.charsets, gdome_nl_item(nodes, i, &exc)));
result->hash(Exception::undefined_source).put(skey,
ValuePtr(new VXnode(&pool, gdome_nl_item(nodes, i, &exc))));
}
}	}

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

// void normalize();	// void normalize();
static void _normalize(Request& r, StringPtr method_name, MethodParams* ) {	static void _normalize(Request& r, MethodParams&) {
Pool& pool=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 Exception(
method_name,	0,
exc);	exc);
}	}

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

// expression	// expression
StringPtr 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
Line 431 static void _selectX(Request& r, StringP	Line 400 static void _selectX(Request& r, StringP

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

ValuePtr result;	Value* result;
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,
StringPtr expression,	const String& expression,
xmlXPathObject_auto_ptr res,	xmlXPathObject_auto_ptr res,
ValuePtr& result) {	Value*& result) {
Pool& pool=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++)
StringPtr skey(new String);	hash.put(
*skey << pool.format_integer(i);	StringBody::Format(i),
	new VXnode(
hash.put(skey,	&r.charsets,
ValuePtr(new VXnode(&pool, 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,
StringPtr expression,	const String& expression,
xmlXPathObject_auto_ptr res,	xmlXPathObject_auto_ptr res,
ValuePtr& result) {	Value*& result) {
Pool& pool=r.pool();

switch(res->type) {	switch(res->type) {
case XPATH_UNDEFINED:	case XPATH_UNDEFINED:
break;	break;
Line 484 static void selectNodeHandler(Request& r	Line 449 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, 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(	r.transcode(GdomeDOMString_auto_ptr(
GdomeDOMString_auto_ptr(	gdome_str_mkref_dup((const gchar *)res->stringval)).get()));
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& r,
StringPtr expression,	const String& expression,
xmlXPathObject_auto_ptr res,	xmlXPathObject_auto_ptr res,
ValuePtr& result) {	Value*& result) {
Pool& pool=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 491 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& r,
StringPtr expression,	const String& expression,
xmlXPathObject_auto_ptr res,	xmlXPathObject_auto_ptr res,
ValuePtr& result) {	Value*& result) {
Pool& pool=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 511 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
}	}
}	}

static void selectStringHandler(Request& r,	static void selectStringHandler(Request& r,
StringPtr expression,	const String& expression,
xmlXPathObject_auto_ptr res,	xmlXPathObject_auto_ptr res,
ValuePtr& result) {	Value*& result) {
Pool& pool=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(	r.transcode(GdomeDOMString_auto_ptr(
GdomeDOMString_auto_ptr(	gdome_str_mkref_dup((const gchar *)res->stringval)).get()));
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 535 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, StringPtr 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, StringPtr 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, StringPtr 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, StringPtr 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, StringPtr method_name, MethodParams* params) {	static void _selectString(Request& r, MethodParams& params) {
_selectX(r, method_name, params,	_selectX(r, params,
selectStringHandler);	selectStringHandler);
}	}

Line 660 MXnode::MXnode(const char* aname, VState	Line 623 MXnode::MXnode(const char* aname, VState
// consts	// consts

#define CONST(name) \	#define CONST(name) \
consts.put(StringPtr(new String(#name)), ValuePtr(new VInt(GDOME_##name)))	consts.put(StringBody(#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.9
changed lines
	Added in v.1.54.2.10.2.12