--- parser3/src/classes/xnode.C 2001/09/26 15:43:59 1.2 +++ parser3/src/classes/xnode.C 2003/03/06 16:15:25 1.54.2.9 @@ -1,145 +1,686 @@ /** @file Parser: @b dom parser class. - Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com) - Author: Alexander Petrosyan (http://design.ru/paf) - - $Id: xnode.C,v 1.2 2001/09/26 15:43:59 parser Exp $ + Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com) + Author: Alexandr Petrosian (http://paf.design.ru) */ #include "classes.h" #ifdef XML +static const char* IDENT_XNODE_C="$Date: 2003/03/06 16:15:25 $"; + +#include "pa_vmethod_frame.h" + +#include "pa_charset.h" #include "pa_request.h" #include "pa_vxnode.h" +#include "pa_vxdoc.h" +#include "pa_vvoid.h" #include "xnode.h" -#include -#include -#include -#include +extern "C" { +#include "gdomecore/gdome-xml-node.h" +#include "gdomecore/gdome-xml-document.h" +}; +#include "gdome.h" +#include "libxml/xpath.h" + +// global variable + +DECLARE_CLASS_VAR(xnode, new MXnode, 0); -// defines +// classes + +class xmlXPathObject_auto_ptr { +public: + explicit xmlXPathObject_auto_ptr(xmlXPathObject *_APtr = 0) + : _Owns(_APtr != 0), _Ptr(_APtr) {} + xmlXPathObject_auto_ptr(const xmlXPathObject_auto_ptr& _Y) + : _Owns(_Y._Owns), _Ptr(_Y.release()) {} + xmlXPathObject_auto_ptr& operator=(const xmlXPathObject_auto_ptr& _Y) + {if (this != &_Y) + {if (_Ptr != _Y.get()) + {if (_Owns && _Ptr) + xmlXPathFreeObject(_Ptr); + _Owns = _Y._Owns; } + else if (_Y._Owns) + _Owns = true; + _Ptr = _Y.release(); } + return (*this); } + ~xmlXPathObject_auto_ptr() + {if (_Owns && _Ptr) + xmlXPathFreeObject(_Ptr); } + xmlXPathObject& operator*() const + {return (*get()); } + xmlXPathObject *operator->() const + {return (get()); } + xmlXPathObject *get() const + {return (_Ptr); } + xmlXPathObject *release() const + {((xmlXPathObject_auto_ptr *)this)->_Owns = false; + return (_Ptr); } +private: + bool _Owns; + xmlXPathObject *_Ptr; +}; + +class xmlXPathContext_auto_ptr { +public: + explicit xmlXPathContext_auto_ptr(xmlXPathContext *_APtr = 0) + : _Owns(_APtr != 0), _Ptr(_APtr) {} + xmlXPathContext_auto_ptr(const xmlXPathContext_auto_ptr& _Y) + : _Owns(_Y._Owns), _Ptr(_Y.release()) {} + xmlXPathContext_auto_ptr& operator=(const xmlXPathContext_auto_ptr& _Y) + {if (this != &_Y) + {if (_Ptr != _Y.get()) + {if (_Owns && _Ptr) + xmlXPathFreeContext(_Ptr); + _Owns = _Y._Owns; } + else if (_Y._Owns) + _Owns = true; + _Ptr = _Y.release(); } + return (*this); } + ~xmlXPathContext_auto_ptr() + {if (_Owns && _Ptr) + xmlXPathFreeContext(_Ptr); } + xmlXPathContext& operator*() const + {return (*get()); } + xmlXPathContext *operator->() const + {return (get()); } + xmlXPathContext *get() const + {return (_Ptr); } + xmlXPathContext *release() const + {((xmlXPathContext_auto_ptr *)this)->_Owns = false; + return (_Ptr); } +private: + bool _Owns; + xmlXPathContext *_Ptr; +}; + +// helpers + +GdomeNode *as_node(StringPtr method_name, MethodParams* params, + int index, const char* msg) { + ValuePtr value=params->as_no_junction(index, msg); + if(Value* vxnode=value->as(VXNODE_TYPE, false)) + return static_cast(vxnode)->get_node(method_name); + else + throw Exception("parser.runtime", + method_name, + msg); +} -#define XNODE_CLASS_NAME "xnode" +// helpers -// class +GdomeAttr * as_attr(Pool& pool, StringPtr method_name, MethodParams* params, + int index, const char* msg) { + GdomeNode *node=as_node(method_name, params, index, msg); + GdomeException exc; + if(gdome_n_nodeType(node, &exc)!=GDOME_ATTRIBUTE_NODE) + throw Exception("parser.runtime", + method_name, + msg); + + return GDOME_A(node); +} // methods -static void _select(Request& r, const String& method_name, MethodParams *params) { -// _asm int 3; +// DOM1 node + +// Node insertBefore(in Node newChild,in Node refChild) raises(DOMException); +static void _insertBefore(Request& r, StringPtr method_name, MethodParams* params) { Pool& pool=r.pool(); - VXnode& vnode=*static_cast(r.self); + VXnode& vnode=GET_SELF(r, VXnode); + GdomeNode *selfNode=vnode.get_node(method_name); + GdomeNode *newChild=as_node(method_name, params, 0, "newChild must be node"); + GdomeNode *refChild=as_node(method_name, params, 1, "refChild must be node"); + + GdomeException exc; + if(GdomeNode *retNode=gdome_n_insertBefore(selfNode, newChild, refChild, &exc)) { + // write out result + r.write_no_lang(ValuePtr(new VXnode(&pool, retNode))); + } else + throw Exception( + method_name, + exc); +} - // expression - const String& expression=params->as_string(0, "expression must not be code"); - const char *expression_cstr=expression.cstr(String::UL_AS_IS); - XalanDOMString dstring(expression_cstr); - const XalanDOMChar *expression_dcstr=dstring.c_str(); - - XPathEvaluator evaluator; - // We'll use these to parse the XML file. - XalanSourceTreeDOMSupport dom_support; - - try { - NodeRefList list=evaluator.selectNodeList(dom_support, - &vnode.get_node(pool, &method_name), - expression_dcstr); - - VHash& result=*new(pool) VHash(pool); - for(int i=0; ias_bool(0, "deep must be bool", r); + + GdomeException exc; + // write out result + r.write_no_lang(ValuePtr(new VXnode(&pool, gdome_n_cloneNode(node, deep, &exc)))); +} + +// DOM1 element + +GdomeElement *get_self_element(Request& r, StringPtr method_name) { + Pool& pool=r.pool(); + VXnode& vnode=GET_SELF(r, VXnode); + GdomeNode *node=vnode.get_node(method_name); + + GdomeException exc; + if(gdome_n_nodeType(node, &exc)!=GDOME_ELEMENT_NODE) + throw Exception("parser.runtime", + method_name, + "method can only be called on nodes of ELEMENT type"); + + return GDOME_EL(node); +} + + + +// DOMString getAttribute(in DOMString name); +static void _getAttribute(Request& r, StringPtr method_name, MethodParams* params) { + Pool& pool=r.pool(); + GdomeElement *element=get_self_element(r, method_name); + StringPtr name=params->as_string(0, "name must be string"); + + GdomeException exc; + GdomeDOMString *attribute_value= + gdome_el_getAttribute(element, r.transcode(name).get(), &exc); + // write out result + r.write_no_lang(*r.transcode(attribute_value, name)); +} + +// void setAttribute(in DOMString name, in DOMString value) raises(DOMException); +static void _setAttribute(Request& r, StringPtr method_name, MethodParams* params) { + Pool& pool=r.pool(); + GdomeElement *element=get_self_element(r, method_name); + StringPtr name=params->as_string(0, "name must be string"); + StringPtr attribute_value=params->as_string(1, "value must be string"); + + GdomeException exc; + gdome_el_setAttribute(element, + r.transcode(name).get(), + r.transcode(attribute_value).get(), + &exc); + if(exc) + throw Exception( + method_name, + exc); +} + +// void removeAttribute(in DOMString name) raises(DOMException); +static void _removeAttribute(Request& r, StringPtr method_name, MethodParams* params) { + Pool& pool=r.pool(); + GdomeElement *element=get_self_element(r, method_name); + StringPtr name=params->as_string(0, "name must be string"); + + GdomeException exc; + gdome_el_removeAttribute(element, r.transcode(name).get(), &exc); + if(exc) + throw Exception( + method_name, + exc); +} + +// Attr getAttributeNode(in DOMString name); +static void _getAttributeNode(Request& r, StringPtr method_name, MethodParams* params) { + Pool& pool=r.pool(); + GdomeElement *element=get_self_element(r, method_name); + StringPtr name=params->as_string(0, "name must be string"); + + GdomeException exc; + if(GdomeAttr *attr=gdome_el_getAttributeNode(element, r.transcode(name).get(), &exc)) { + // write out result + r.write_no_lang(ValuePtr(new VXnode(&pool, (GdomeNode *)attr))); + } else if(exc) + throw Exception( + method_name, + exc); +} + +// Attr setAttributeNode(in Attr newAttr) raises(DOMException); +static void _setAttributeNode(Request& r, StringPtr method_name, MethodParams* params) { + Pool& pool=r.pool(); + GdomeElement *element=get_self_element(r, method_name); + GdomeAttr * newAttr=as_attr(pool, method_name, params, 0, "newAttr must be ATTRIBUTE node"); + + GdomeException exc; + if(GdomeAttr *returnAttr=gdome_el_setAttributeNode(element, newAttr, &exc)) { + // write out result + r.write_no_lang(ValuePtr(new VXnode(&pool, (GdomeNode *)returnAttr))); + } else + throw Exception( + method_name, + exc); +} + +// Attr removeAttributeNode(in Attr oldAttr) raises(DOMException); +static void _removeAttributeNode(Request& r, StringPtr method_name, MethodParams* params) { + Pool& pool=r.pool(); + GdomeElement *element=get_self_element(r, method_name); + GdomeAttr * oldAttr=as_attr(pool, method_name, params, 0, "oldAttr must be ATTRIBUTE node"); + + GdomeException exc; + gdome_el_removeAttributeNode(element, oldAttr, &exc); + if(exc) + throw Exception( + method_name, + exc); +} - result.hash().put(skey, new(pool) VXnode(pool, list.item(i))); +// NodeList getElementsByTagName(in DOMString name); +static void _getElementsByTagName(Request& r, StringPtr method_name, MethodParams* params) { + Pool& pool=r.pool(); + GdomeElement *element=get_self_element(r, method_name); + + StringPtr name=params->as_string(0, "name must be string"); + + VHashPtr result(new VHash); + GdomeException exc; + if(GdomeNodeList *nodes= + gdome_el_getElementsByTagName(element, r.transcode(name).get(), &exc)) { + gulong length=gdome_nl_length(nodes, &exc); + for(gulong i=0; ihash(Exception::undefined_source).put( + skey, + ValuePtr(new VXnode(&pool, gdome_nl_item(nodes, i, &exc)))); + } + } else if(exc) + throw Exception( + method_name, + exc); + + // write out result + r.write_no_lang(result); +} + +static void _getElementsByTagNameNS(Request& r, StringPtr method_name, MethodParams* params) { + Pool& pool=r.pool(); + GdomeElement *element=get_self_element(r, method_name); + + // namespaceURI;localName + StringPtr namespaceURI=params->as_string(0, "namespaceURI must be string"); + StringPtr localName=params->as_string(1, "localName must be string"); + + GdomeException exc; + VHashPtr result(new VHash); + if(GdomeNodeList *nodes= + gdome_el_getElementsByTagNameNS( + element, + r.transcode(namespaceURI).get(), + r.transcode(localName).get(), + &exc)) { + gulong length=gdome_nl_length(nodes, &exc); + for(gulong i=0; ihash(Exception::undefined_source).put(skey, + ValuePtr(new VXnode(&pool, gdome_nl_item(nodes, i, &exc)))); } - result.set_name(method_name); - r.write_no_lang(result); - } catch(const XSLException& e) { - r._throw(&expression, e); } + + // write out result + r.write_no_lang(result); +} + +// void normalize(); +static void _normalize(Request& r, StringPtr method_name, MethodParams* ) { + Pool& pool=r.pool(); + VXnode& vnode=GET_SELF(r, VXnode); + GdomeNode *selfNode=vnode.get_node(method_name); + + GdomeException exc; + gdome_n_normalize(selfNode, &exc); + if(exc) + throw Exception( + method_name, + exc); } -static void _select_single(Request& r, const String& method_name, MethodParams *params) { +static void _selectX(Request& r, StringPtr method_name, MethodParams* params, + void (*handler)(Request& r, + StringPtr expression, + xmlXPathObject_auto_ptr res, + ValuePtr& result)) { // _asm int 3; Pool& pool=r.pool(); - VXnode& vnode=*static_cast(r.self); + VXnode& vnode=GET_SELF(r, VXnode); // expression - const String& expression=params->as_string(0, "expression must not be code"); - const char *expression_cstr=expression.cstr(String::UL_AS_IS); - XalanDOMString dstring(expression_cstr); - const XalanDOMChar *expression_dcstr=dstring.c_str(); - - XPathEvaluator evaluator; - // Initialize the XalanSourceTree subsystem... -// XalanSourceTreeInit theSourceTreeInit; - // We'll use these to parse the XML file. - XalanSourceTreeDOMSupport dom_support; - - try { - if(XalanNode *node=evaluator.selectSingleNode(dom_support, - &vnode.get_node(pool, &method_name), - expression_dcstr)) { - - VXnode& result=*new(pool) VXnode(pool, node); - result.set_name(method_name); - r.write_no_lang(result); + StringPtr expression=params->as_string(0, "expression must be string"); + + GdomeException exc; + GdomeNode *dome_node=vnode.get_node(method_name); + GdomeDocument *dome_document=gdome_n_ownerDocument(dome_node, &exc); + if(!dome_document) // document does not own itself, so ownerDocument = 0 + dome_document=GDOME_DOC(dome_node); // and we need downcast + xmlDoc *xml_document=gdome_xml_doc_get_xmlDoc(dome_document); + xmlXPathContext_auto_ptr ctxt(xmlXPathNewContext(xml_document)); + ctxt->node=gdome_xml_n_get_xmlNode(dome_node); + /*error to stderr for now*/ + xmlXPathObject_auto_ptr res( + xmlXPathEvalExpression(BAD_CAST r.transcode(expression)->str, ctxt.get())); + + if(xmlHaveGenericErrors()) { + GdomeException exc=0; + throw Exception(expression, exc); + } + + ValuePtr result; + if(res.get()) + handler(r, expression, res, result); + if(result) + r.write_no_lang(result); +} + +static void selectNodesHandler(Request& r, + StringPtr expression, + xmlXPathObject_auto_ptr res, + ValuePtr& result) { + Pool& pool=r.pool(); + VHashPtr vhash(new VHash); result=vhash; + switch(res->type) { + case XPATH_UNDEFINED: + break; + case XPATH_NODESET: + if(res->nodesetval) + if(int size=res->nodesetval->nodeNr) { + HashStringValue& hash=vhash->hash(Exception::undefined_source); + for(int i=0; inodesetval->nodeTab[i])))); + } + } + break; + default: + throw Exception(Exception::undefined_type, + expression, + "wrong xmlXPathEvalExpression result type (%d)", res->type); + break; // never + } +} + +static void selectNodeHandler(Request& r, + StringPtr expression, + xmlXPathObject_auto_ptr res, + ValuePtr& result) { + Pool& pool=r.pool(); + + switch(res->type) { + case XPATH_UNDEFINED: + break; + case XPATH_NODESET: + if(res->nodesetval && res->nodesetval->nodeNr) { // empty result strangly has NODESET res->type + if(res->nodesetval->nodeNr>1) + throw Exception("parser.runtime", + expression, + "resulted not in a single node (%d)", res->nodesetval->nodeNr); + + result=ValuePtr(new VXnode(&pool, gdome_xml_n_mkref(res->nodesetval->nodeTab[0]))); } - } catch(const XSLException& e) { - r._throw(&expression, e); + break; + case XPATH_BOOLEAN: + result=ValuePtr(new VBool(res->boolval!=0)); + break; + case XPATH_NUMBER: + result=ValuePtr(new VDouble(res->floatval)); + break; + case XPATH_STRING: + result=ValuePtr(new VString( + r.transcode( + GdomeDOMString_auto_ptr( + gdome_str_mkref_dup((const gchar *)res->stringval)).get(), expression))); + break; + default: + throw Exception("parser.runtime", + expression, + "wrong xmlXPathEvalExpression result type (%d)", res->type); + break; // never } } +static void selectBoolHandler(Request& r, + StringPtr expression, + xmlXPathObject_auto_ptr res, + ValuePtr& result) { + Pool& pool=r.pool(); + switch(res->type) { + case XPATH_BOOLEAN: + result=ValuePtr(new VBool(res->boolval!=0)); + break; + case XPATH_NODESET: + if(!(res->nodesetval && res->nodesetval->nodeNr)) + break; + // else[nodeset] fall down to default + default: + throw Exception("parser.runtime", + expression, + "wrong xmlXPathEvalExpression result type (%d)", res->type); + break; // never + } +} + +static void selectNumberHandler(Request& r, + StringPtr expression, + xmlXPathObject_auto_ptr res, + ValuePtr& result) { + Pool& pool=r.pool(); + switch(res->type) { + case XPATH_NUMBER: + result=ValuePtr(new VDouble(res->floatval)); + break; + case XPATH_NODESET: + if(!(res->nodesetval && res->nodesetval->nodeNr)) + break; + // else[nodeset] fall down to default + default: + throw Exception("parser.runtime", + expression, + "wrong xmlXPathEvalExpression result type (%d)", res->type); + break; // never + } +} + +static void selectStringHandler(Request& r, + StringPtr expression, + xmlXPathObject_auto_ptr res, + ValuePtr& result) { + Pool& pool=r.pool(); + switch(res->type) { + case XPATH_UNDEFINED: + break; + case XPATH_STRING: + result=ValuePtr(new VString( + r.transcode( + GdomeDOMString_auto_ptr( + gdome_str_mkref_dup((const gchar *)res->stringval)).get(), expression))); + break; + case XPATH_NODESET: + if(!(res->nodesetval && res->nodesetval->nodeNr)) + break; + // else[nodeset] fall down to default + default: + throw Exception("parser.runtime", + expression, + "wrong xmlXPathEvalExpression result type (%d)", res->type); + break; // never + } +} + +static void _select(Request& r, StringPtr method_name, MethodParams* params) { + _selectX(r, method_name, params, + selectNodesHandler); +} + +static void _selectSingle(Request& r, StringPtr method_name, MethodParams* params) { + _selectX(r, method_name, params, + selectNodeHandler); +} + +static void _selectBool(Request& r, StringPtr method_name, MethodParams* params) { + _selectX(r, method_name, params, + selectBoolHandler); +} + +static void _selectNumber(Request& r, StringPtr method_name, MethodParams* params) { + _selectX(r, method_name, params, + selectNumberHandler); +} + +static void _selectString(Request& r, StringPtr method_name, MethodParams* params) { + _selectX(r, method_name, params, + selectStringHandler); +} + // constructor -MXnode::MXnode(Pool& apool) : Methoded(apool), - consts(apool) { - set_name(*NEW String(pool(), XNODE_CLASS_NAME)); +MXnode::MXnode(const char* aname, VStateless_class *abase): + Methoded(aname?aname:"xnode", abase) +{ + /// DOM1 node + + // Node insertBefore(in Node newChild,in Node refChild) raises(DOMException); + add_native_method("insertBefore", Method::CT_DYNAMIC, _insertBefore, 2, 2); + // Node replaceChild(in Node newChild,in Node oldChild) raises(DOMException); + add_native_method("replaceChild", Method::CT_DYNAMIC, _replaceChild, 2, 2); + // Node removeChild(in Node oldChild) raises(DOMException); + add_native_method("removeChild", Method::CT_DYNAMIC, _removeChild, 1, 1); + // Node appendChild(in Node newChild) raises(DOMException); + add_native_method("appendChild", Method::CT_DYNAMIC, _appendChild, 1, 1); + // boolean hasChildNodes(); + add_native_method("hasChildNodes", Method::CT_DYNAMIC, _hasChildNodes, 0, 0); + // Node cloneNode(in boolean deep); + add_native_method("cloneNode", Method::CT_DYNAMIC, _cloneNode, 1, 1); + + /// DOM1 element + + // DOMString getAttribute(in DOMString name); + add_native_method("getAttribute", Method::CT_DYNAMIC, _getAttribute, 1, 1); + // void setAttribute(in DOMString name, in DOMString value) raises(DOMException); + add_native_method("setAttribute", Method::CT_DYNAMIC, _setAttribute, 2, 2); + // void removeAttribute(in DOMString name) raises(DOMException); + add_native_method("removeAttribute", Method::CT_DYNAMIC, _removeAttribute, 1, 1); + // Attr getAttributeNode(in DOMString name); + add_native_method("getAttributeNode", Method::CT_DYNAMIC, _getAttributeNode, 1, 1); + // Attr setAttributeNode(in Attr newAttr) raises(DOMException); + add_native_method("setAttributeNode", Method::CT_DYNAMIC, _setAttributeNode, 1, 1); + // Attr removeAttributeNode(in Attr oldAttr) raises(DOMException); + add_native_method("removeAttributeNode", Method::CT_DYNAMIC, _removeAttributeNode, 1, 1); + // NodeList getElementsByTagName(in DOMString name); + add_native_method("getElementsByTagName", Method::CT_DYNAMIC, _getElementsByTagName, 1, 1); + // NodeList getElementsByTagNameNS(in DOMString namespaceURI, in DOMString localName); + add_native_method("getElementsByTagNameNS", Method::CT_DYNAMIC, _getElementsByTagNameNS, 2, 2); + // void normalize(); + add_native_method("normalize", Method::CT_DYNAMIC, _normalize, 0, 0); + /// parser // ^node.select[/some/xpath/query] = hash $.#[dnode] add_native_method("select", Method::CT_DYNAMIC, _select, 1, 1); - // ^node.select-single[/some/xpath/query] = first dnode - add_native_method("select-single", Method::CT_DYNAMIC, _select_single, 1, 1); + // ^node.selectSingle[/some/xpath/query] = first node [if any] + add_native_method("selectSingle", Method::CT_DYNAMIC, _selectSingle, 1, 1); + // ^node.selectBool[/some/xpath/query] = bool value [if any] + add_native_method("selectBool", Method::CT_DYNAMIC, _selectBool, 1, 1); + // ^node.selectNumber[/some/xpath/query] = double value [if any] + add_native_method("selectNumber", Method::CT_DYNAMIC, _selectNumber, 1, 1); + // ^node.selectString[/some/xpath/query] = strinv value [if any] + add_native_method("selectString", Method::CT_DYNAMIC, _selectString, 1, 1); // consts -#define CONST(name, value) \ - consts.put(*new(pool()) String(pool(), #name), new(pool()) VInt(pool(), value)) +#define CONST(name) \ + consts.put(StringPtr(new String(#name)), ValuePtr(new VInt(GDOME_##name))) - CONST(ELEMENT_NODE, 1); - CONST(ATTRIBUTE_NODE, 2); - CONST(TEXT_NODE, 3); - CONST(CDATA_SECTION_NODE, 4); - CONST(ENTITY_REFERENCE_NODE, 5); - CONST(ENTITY_NODE, 6); - CONST(PROCESSING_INSTRUCTION_NODE, 7); - CONST(COMMENT_NODE, 8); - CONST(DOCUMENT_NODE, 9); - CONST(DOCUMENT_TYPE_NODE, 10); - CONST(DOCUMENT_FRAGMENT_NODE, 11); - CONST(NOTATION_NODE, 12); + CONST(ELEMENT_NODE); + CONST(ATTRIBUTE_NODE); + CONST(TEXT_NODE); + CONST(CDATA_SECTION_NODE); + CONST(ENTITY_REFERENCE_NODE); + CONST(ENTITY_NODE); + CONST(PROCESSING_INSTRUCTION_NODE); + CONST(COMMENT_NODE); + CONST(DOCUMENT_NODE); + CONST(DOCUMENT_TYPE_NODE); + CONST(DOCUMENT_FRAGMENT_NODE); + CONST(NOTATION_NODE); } -// global variable -Methoded *Xnode_class; +#else -#endif +// global variable + +DECLARE_CLASS_VAR(xnode, 0, 0); // fictive -// creator -Methoded *MXnode_create(Pool& pool) { - return -#ifdef XML - Xnode_class=new(pool) MXnode(pool) -#else - 0 #endif - ; -}