Annotation of parser3/src/classes/xnode.C, revision 1.31
1.1 parser 1: /** @file
2: Parser: @b dom parser class.
3:
4: Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
1.18 paf 5: Author: Alexander Petrosyan <paf@design.ru> (http://paf.design.ru)
1.1 parser 6:
1.31 ! paf 7: $Id: xnode.C,v 1.30 2002/01/24 13:26:01 paf Exp $
1.1 parser 8: */
9: #include "classes.h"
10: #ifdef XML
11:
1.21 paf 12: #include "pa_charset.h"
1.1 parser 13: #include "pa_request.h"
14: #include "pa_vxnode.h"
1.23 paf 15: #include "pa_vvoid.h"
1.1 parser 16:
17: #include "xnode.h"
18:
1.21 paf 19: extern "C" {
20: #include "gdomecore/gdome-xml-node.h"
1.27 paf 21: #include "gdomecore/gdome-xml-document.h"
1.21 paf 22: };
1.19 paf 23: #include "gdome.h"
1.21 paf 24: #include "libxml/xpath.h"
25:
26: // classes
27:
28: class xmlXPathObject_auto_ptr {
29: public:
1.29 paf 30: explicit xmlXPathObject_auto_ptr(xmlXPathObject *_APtr = 0)
31: : _Owns(_APtr != 0), _Ptr(_APtr) {}
1.21 paf 32: xmlXPathObject_auto_ptr(const xmlXPathObject_auto_ptr& _Y)
33: : _Owns(_Y._Owns), _Ptr(_Y.release()) {}
34: xmlXPathObject_auto_ptr& operator=(const xmlXPathObject_auto_ptr& _Y)
35: {if (this != &_Y)
36: {if (_Ptr != _Y.get())
37: {if (_Owns && _Ptr)
38: xmlXPathFreeObject(_Ptr);
39: _Owns = _Y._Owns; }
40: else if (_Y._Owns)
41: _Owns = true;
42: _Ptr = _Y.release(); }
43: return (*this); }
44: ~xmlXPathObject_auto_ptr()
45: {if (_Owns && _Ptr)
46: xmlXPathFreeObject(_Ptr); }
47: xmlXPathObject& operator*() const
48: {return (*get()); }
49: xmlXPathObject *operator->() const
50: {return (get()); }
51: xmlXPathObject *get() const
52: {return (_Ptr); }
53: xmlXPathObject *release() const
54: {((xmlXPathObject_auto_ptr *)this)->_Owns = false;
55: return (_Ptr); }
56: private:
57: bool _Owns;
58: xmlXPathObject *_Ptr;
59: };
60:
61: class xmlXPathContext_auto_ptr {
62: public:
1.29 paf 63: explicit xmlXPathContext_auto_ptr(xmlXPathContext *_APtr = 0)
64: : _Owns(_APtr != 0), _Ptr(_APtr) {}
1.21 paf 65: xmlXPathContext_auto_ptr(const xmlXPathContext_auto_ptr& _Y)
66: : _Owns(_Y._Owns), _Ptr(_Y.release()) {}
67: xmlXPathContext_auto_ptr& operator=(const xmlXPathContext_auto_ptr& _Y)
68: {if (this != &_Y)
69: {if (_Ptr != _Y.get())
70: {if (_Owns && _Ptr)
71: xmlXPathFreeContext(_Ptr);
72: _Owns = _Y._Owns; }
73: else if (_Y._Owns)
74: _Owns = true;
75: _Ptr = _Y.release(); }
76: return (*this); }
77: ~xmlXPathContext_auto_ptr()
78: {if (_Owns && _Ptr)
79: xmlXPathFreeContext(_Ptr); }
80: xmlXPathContext& operator*() const
81: {return (*get()); }
82: xmlXPathContext *operator->() const
83: {return (get()); }
84: xmlXPathContext *get() const
85: {return (_Ptr); }
86: xmlXPathContext *release() const
87: {((xmlXPathContext_auto_ptr *)this)->_Owns = false;
88: return (_Ptr); }
89: private:
90: bool _Owns;
91: xmlXPathContext *_Ptr;
92: };
1.1 parser 93:
94: // defines
95:
96: #define XNODE_CLASS_NAME "xnode"
97:
1.6 parser 98: // helpers
99:
1.19 paf 100: GdomeNode *as_node(Pool& pool, const String& method_name, MethodParams *params,
1.6 parser 101: int index, const char *msg) {
102: Value& value=params->as_no_junction(index, msg);
103: if(strcmp(value.type(), VXNODE_TYPE)!=0)
1.12 parser 104: throw Exception(0, 0,
1.6 parser 105: &method_name,
106: msg);
107:
108: VXnode& vnode=*static_cast<VXnode *>(&value);
1.19 paf 109: return vnode.get_node(&method_name);
1.6 parser 110: }
111:
112: // helpers
113:
1.19 paf 114: GdomeAttr * as_attr(Pool& pool, const String& method_name, MethodParams *params,
1.6 parser 115: int index, const char *msg) {
1.19 paf 116: GdomeNode *node=as_node(pool, method_name, params, index, msg);
117: GdomeException exc;
118: if(gdome_n_nodeType(node, &exc)!=GDOME_ATTRIBUTE_NODE)
1.12 parser 119: throw Exception(0, 0,
1.6 parser 120: &method_name,
121: msg);
122:
1.19 paf 123: return GDOME_A(node);
1.6 parser 124: }
1.1 parser 125:
126: // methods
127:
1.6 parser 128: // DOM1 node
129:
130: // Node insertBefore(in Node newChild,in Node refChild) raises(DOMException);
131: static void _insertBefore(Request& r, const String& method_name, MethodParams *params) {
132: Pool& pool=r.pool();
133: VXnode& vnode=*static_cast<VXnode *>(r.self);
1.19 paf 134: GdomeNode *selfNode=vnode.get_node(&method_name);
135: GdomeNode *newChild=as_node(pool, method_name, params, 0, "newChild must be node");
136: GdomeNode *refChild=as_node(pool, method_name, params, 1, "refChild must be node");
1.6 parser 137:
1.19 paf 138: GdomeException exc;
139: if(GdomeNode *retNode=gdome_n_insertBefore(selfNode, newChild, refChild, &exc)) {
140: // write out result
141: VXnode& result=*new(pool) VXnode(pool, retNode);
142: r.write_no_lang(result);
143: } else
144: throw Exception(0, 0,
145: &method_name,
146: exc);
1.6 parser 147: }
148:
149: // Node replaceChild(in Node newChild,in Node oldChild) raises(DOMException);
150: static void _replaceChild(Request& r, const String& method_name, MethodParams *params) {
151: Pool& pool=r.pool();
152: VXnode& vnode=*static_cast<VXnode *>(r.self);
1.19 paf 153: GdomeNode *selfNode=vnode.get_node(&method_name);
154: GdomeNode *newChild=as_node(pool, method_name, params, 0, "newChild must be node");
155: GdomeNode *refChild=as_node(pool, method_name, params, 1, "refChild must be node");
1.6 parser 156:
1.19 paf 157: GdomeException exc;
158: if(GdomeNode *retNode=gdome_n_replaceChild(selfNode, newChild, refChild, &exc)) {
159: // write out result
160: r.write_no_lang(*new(pool) VXnode(pool, retNode));
161: } else
162: throw Exception(0, 0,
163: &method_name,
164: exc);
1.6 parser 165: }
166:
167: // Node removeChild(in Node oldChild) raises(DOMException);
168: static void _removeChild(Request& r, const String& method_name, MethodParams *params) {
169: Pool& pool=r.pool();
170: VXnode& vnode=*static_cast<VXnode *>(r.self);
1.19 paf 171: GdomeNode *selfNode=vnode.get_node(&method_name);
172: GdomeNode *oldChild=as_node(pool, method_name, params, 0, "oldChild must be node");
1.6 parser 173:
1.19 paf 174: GdomeException exc;
175: if(GdomeNode *retNode=gdome_n_removeChild(selfNode, oldChild, &exc)) {
176: // write out result
177: r.write_no_lang(*new(pool) VXnode(pool, retNode));
178: } else
179: throw Exception(0, 0,
180: &method_name,
181: exc);
1.6 parser 182: }
183:
184: // Node appendChild(in Node newChild) raises(DOMException);
185: static void _appendChild(Request& r, const String& method_name, MethodParams *params) {
186: Pool& pool=r.pool();
187: VXnode& vnode=*static_cast<VXnode *>(r.self);
1.19 paf 188: GdomeNode *selfNode=vnode.get_node(&method_name);
189: GdomeNode *newChild=as_node(pool, method_name, params, 0, "newChild must be node");
1.6 parser 190:
1.19 paf 191: GdomeException exc;
192: if(GdomeNode *retNode=gdome_n_appendChild(selfNode, newChild, &exc)) {
193: // write out result
194: r.write_no_lang(*new(pool) VXnode(pool, retNode));
195: } else
196: throw Exception(0, 0,
197: &method_name,
198: exc);
1.6 parser 199: }
200:
201: // boolean hasChildNodes();
202: static void _hasChildNodes(Request& r, const String& method_name, MethodParams *) {
203: Pool& pool=r.pool();
204: VXnode& vnode=*static_cast<VXnode *>(r.self);
1.19 paf 205: GdomeNode *node=vnode.get_node(&method_name);
1.6 parser 206:
1.19 paf 207: GdomeException exc;
1.6 parser 208: // write out result
1.19 paf 209: VBool& result=*new(pool) VBool(pool, gdome_n_hasChildNodes(node, &exc)!=0);
1.6 parser 210: result.set_name(method_name);
211: r.write_no_lang(result);
212: }
213:
214: // Node cloneNode(in boolean deep);
1.14 parser 215: /// @test ownerDocument=?
1.6 parser 216: static void _cloneNode(Request& r, const String& method_name, MethodParams *params) {
217: Pool& pool=r.pool();
218: VXnode& vnode=*static_cast<VXnode *>(r.self);
1.19 paf 219: GdomeNode *node=vnode.get_node(&method_name);
1.6 parser 220:
221: bool deep=params->as_bool(0, "deep must be bool", r);
222:
1.19 paf 223: GdomeException exc;
1.6 parser 224: // write out result
1.19 paf 225: VXnode& result=*new(pool) VXnode(pool, gdome_n_cloneNode(node, deep, &exc));
1.6 parser 226: result.set_name(method_name);
227: r.write_no_lang(result);
228: }
229:
230: // DOM1 element
231:
1.19 paf 232: GdomeElement *get_self_element(Request& r, const String& method_name) {
1.6 parser 233: Pool& pool=r.pool();
234: VXnode& vnode=*static_cast<VXnode *>(r.self);
1.19 paf 235: GdomeNode *node=vnode.get_node(&method_name);
1.6 parser 236:
1.19 paf 237: GdomeException exc;
238: if(gdome_n_nodeType(node, &exc)!=GDOME_ELEMENT_NODE)
1.12 parser 239: throw Exception(0, 0,
1.6 parser 240: &method_name,
241: "method can be called on node of ELEMENT type");
242:
1.19 paf 243: return GDOME_EL(node);
1.6 parser 244: }
245:
246: // DOMString getAttribute(in DOMString name);
247: static void _getAttribute(Request& r, const String& method_name, MethodParams *params) {
248: Pool& pool=r.pool();
1.19 paf 249: GdomeElement *element=get_self_element(r, method_name);
1.11 parser 250: const String& name=params->as_string(0, "name must be string");
1.6 parser 251:
1.19 paf 252: GdomeException exc;
253: GdomeDOMString *attribute_value=
1.21 paf 254: gdome_el_getAttribute(element, pool.transcode(name).get(), &exc);
1.6 parser 255: // write out result
256: r.write_no_lang(*new(pool) VString(pool.transcode(attribute_value)));
257: }
258:
259: // void setAttribute(in DOMString name, in DOMString value) raises(DOMException);
260: static void _setAttribute(Request& r, const String& method_name, MethodParams *params) {
261: Pool& pool=r.pool();
1.19 paf 262: GdomeElement *element=get_self_element(r, method_name);
1.11 parser 263: const String& name=params->as_string(0, "name must be string");
264: const String& attribute_value=params->as_string(1, "value must be string");
1.6 parser 265:
1.19 paf 266: GdomeException exc;
267: gdome_el_setAttribute(element,
1.21 paf 268: pool.transcode(name).get(),
269: pool.transcode(attribute_value).get(),
1.19 paf 270: &exc);
271: if(exc)
272: throw Exception(0, 0,
273: &method_name,
274: exc);
1.6 parser 275: }
276:
277: // void removeAttribute(in DOMString name) raises(DOMException);
278: static void _removeAttribute(Request& r, const String& method_name, MethodParams *params) {
279: Pool& pool=r.pool();
1.19 paf 280: GdomeElement *element=get_self_element(r, method_name);
1.11 parser 281: const String& name=params->as_string(0, "name must be string");
1.6 parser 282:
1.19 paf 283: GdomeException exc;
1.21 paf 284: gdome_el_removeAttribute(element, pool.transcode(name).get(), &exc);
1.19 paf 285: if(exc)
286: throw Exception(0, 0,
287: &method_name,
288: exc);
1.6 parser 289: }
290:
291: // Attr getAttributeNode(in DOMString name);
292: static void _getAttributeNode(Request& r, const String& method_name, MethodParams *params) {
293: Pool& pool=r.pool();
1.19 paf 294: GdomeElement *element=get_self_element(r, method_name);
1.11 parser 295: const String& name=params->as_string(0, "name must be string");
1.6 parser 296:
1.19 paf 297: GdomeException exc;
1.21 paf 298: if(GdomeAttr *attr=gdome_el_getAttributeNode(element, pool.transcode(name).get(), &exc)) {
1.6 parser 299: // write out result
1.19 paf 300: VXnode& result=*new(pool) VXnode(pool, (GdomeNode *)attr);
1.6 parser 301: r.write_no_lang(result);
1.19 paf 302: } else if(exc)
303: throw Exception(0, 0,
304: &method_name,
305: exc);
1.6 parser 306: }
307:
308: // Attr setAttributeNode(in Attr newAttr) raises(DOMException);
309: static void _setAttributeNode(Request& r, const String& method_name, MethodParams *params) {
310: Pool& pool=r.pool();
1.19 paf 311: GdomeElement *element=get_self_element(r, method_name);
312: GdomeAttr * newAttr=as_attr(pool, method_name, params, 0, "newAttr must be ATTRIBUTE node");
1.6 parser 313:
1.19 paf 314: GdomeException exc;
315: if(GdomeAttr *returnAttr=gdome_el_setAttributeNode(element, newAttr, &exc)) {
316: // write out result
317: VXnode& result=*new(pool) VXnode(pool, (GdomeNode *)returnAttr);
318: r.write_no_lang(result);
319: } else
320: throw Exception(0, 0,
321: &method_name,
322: exc);
1.6 parser 323: }
324:
325: // Attr removeAttributeNode(in Attr oldAttr) raises(DOMException);
326: static void _removeAttributeNode(Request& r, const String& method_name, MethodParams *params) {
327: Pool& pool=r.pool();
1.19 paf 328: GdomeElement *element=get_self_element(r, method_name);
329: GdomeAttr * oldAttr=as_attr(pool, method_name, params, 0, "oldAttr must be ATTRIBUTE node");
1.6 parser 330:
1.19 paf 331: GdomeException exc;
332: gdome_el_removeAttributeNode(element, oldAttr, &exc);
333: if(exc)
334: throw Exception(0, 0,
1.26 paf 335: &method_name,
336: exc);
1.6 parser 337: }
338:
339: // NodeList getElementsByTagName(in DOMString name);
340: static void _getElementsByTagName(Request& r, const String& method_name, MethodParams *params) {
341: Pool& pool=r.pool();
1.19 paf 342: GdomeElement *element=get_self_element(r, method_name);
1.6 parser 343:
1.11 parser 344: const String& name=params->as_string(0, "name must be string");
1.6 parser 345:
346: VHash& result=*new(pool) VHash(pool);
1.19 paf 347: GdomeException exc;
348: if(GdomeNodeList *nodes=
1.21 paf 349: gdome_el_getElementsByTagName(element, pool.transcode(name).get(), &exc)) {
1.19 paf 350: gulong length=gdome_nl_length(nodes, &exc);
351: for(gulong i=0; i<length; i++) {
1.6 parser 352: String& skey=*new(pool) String(pool);
353: {
354: char *buf=(char *)pool.malloc(MAX_NUMBER);
355: snprintf(buf, MAX_NUMBER, "%d", i);
356: skey << buf;
357: }
358:
1.19 paf 359: result.hash(0).put(skey, new(pool) VXnode(pool, gdome_nl_item(nodes, i, &exc)));
1.6 parser 360: }
1.19 paf 361: } else if(exc)
362: throw Exception(0, 0,
1.26 paf 363: &method_name,
364: exc);
1.6 parser 365:
366: // write out result
367: r.write_no_lang(result);
368: }
369:
370: // void normalize();
371: static void _normalize(Request& r, const String& method_name, MethodParams *) {
1.19 paf 372: Pool& pool=r.pool();
373: VXnode& vnode=*static_cast<VXnode *>(r.self);
374: GdomeNode *selfNode=vnode.get_node(&method_name);
1.6 parser 375:
1.19 paf 376: GdomeException exc;
377: gdome_n_normalize(selfNode, &exc);
378: if(exc)
379: throw Exception(0, 0,
1.26 paf 380: &method_name,
381: exc);
1.6 parser 382: }
1.25 paf 383:
1.26 paf 384: static void _selectX(Request& r, const String& method_name, MethodParams *params,
385: void (*handler)(Pool& pool,
386: const String& expression,
387: xmlXPathObject_auto_ptr res,
388: Value *& result)) {
1.1 parser 389: // _asm int 3;
390: Pool& pool=r.pool();
391: VXnode& vnode=*static_cast<VXnode *>(r.self);
392:
393: // expression
1.9 parser 394: const String& expression=params->as_string(0, "expression must be string");
1.1 parser 395:
1.25 paf 396: GdomeException exc;
397: GdomeNode *dome_node=vnode.get_node(&method_name);
398: GdomeDocument *dome_document=gdome_n_ownerDocument(dome_node, &exc);
399: if(!dome_document)
400: dome_document=GDOME_DOC(dome_node);
401: xmlDoc *xml_document=((_Gdome_xml_Document *)dome_document)->n;
402: xmlXPathContext_auto_ptr ctxt(xmlXPathNewContext(xml_document));
403: ctxt->node=xmlDocGetRootElement(xml_document);
404: /*error to stderr for now*/
405: xmlXPathObject_auto_ptr res(
406: xmlXPathEvalExpression(BAD_CAST pool.transcode(expression)->str, ctxt.get()));
1.28 paf 407:
408: if(xmlHaveGenericErrors()) {
409: GdomeException exc=0;
410: throw Exception(0, 0,
411: &expression,
412: exc);
413: }
1.25 paf 414:
415: Value *result=0;
416: if(res.get())
1.26 paf 417: handler(pool, expression, res, result);
418: if(result) {
419: result->set_name(method_name);
420: r.write_no_lang(*result);
421: }
422: }
1.25 paf 423:
1.26 paf 424: static void selectNodesHandler(Pool& pool,
425: const String& expression,
426: xmlXPathObject_auto_ptr res,
427: Value *& result) {
1.31 ! paf 428: VHash *vhash=new(pool) VHash(pool); result=vhash;
1.26 paf 429: switch(res->type) {
430: case XPATH_UNDEFINED:
431: break;
432: case XPATH_NODESET:
433: if(int size=res->nodesetval->nodeNr) {
434: Hash& hash=vhash->hash(0);
435: for(int i=0; i<size; i++) {
436: String& skey=*new(pool) String(pool);
437: {
438: char *buf=(char *)pool.malloc(MAX_NUMBER);
439: snprintf(buf, MAX_NUMBER, "%d", i);
440: skey << buf;
1.25 paf 441: }
1.26 paf 442:
443: hash.put(skey, new(pool) VXnode(pool,
1.30 paf 444: gdome_xml_n_mkref(res->nodesetval->nodeTab[i])));
1.1 parser 445: }
1.26 paf 446: }
447: break;
448: default:
449: throw Exception(0, 0,
450: &expression,
451: "wrong xmlXPathEvalExpression result type (%d)", res->type);
452: break; // never
453: }
454: }
455:
456: static void selectNodeHandler(Pool& pool,
457: const String& expression,
458: xmlXPathObject_auto_ptr res,
459: Value *& result) {
460: switch(res->type) {
461: case XPATH_UNDEFINED:
462: break;
463: case XPATH_NODESET:
464: if(res->nodesetval->nodeNr) { // empty result strangly has NODESET res->type
465: if(res->nodesetval->nodeNr>1)
466: throw Exception(0, 0,
1.25 paf 467: &expression,
1.26 paf 468: "resulted not in a single node (%d)", res->nodesetval->nodeNr);
469:
470: result=new(pool) VXnode(pool, gdome_xml_n_mkref(res->nodesetval->nodeTab[0]));
1.25 paf 471: }
1.26 paf 472: break;
473: case XPATH_BOOLEAN:
474: result=new(pool) VBool(pool, res->boolval!=0);
475: break;
476: case XPATH_NUMBER:
477: result=new(pool) VDouble(pool, res->floatval);
478: break;
479: case XPATH_STRING:
480: result=new(pool) VString(
481: pool.transcode(
482: GdomeDOMString_auto_ptr(
483: gdome_str_mkref_dup((const gchar *)res->stringval)).get()));
484: break;
485: default:
486: throw Exception(0, 0,
487: &expression,
488: "wrong xmlXPathEvalExpression result type (%d)", res->type);
489: break; // never
490: }
491: }
492:
493: static void selectBoolHandler(Pool& pool,
494: const String& expression,
495: xmlXPathObject_auto_ptr res,
496: Value *& result) {
497: switch(res->type) {
498: case XPATH_BOOLEAN:
499: result=new(pool) VBool(pool, res->boolval!=0);
500: break;
501: case XPATH_NODESET:
502: if(!res->nodesetval->nodeNr)
503: break;
504: // else[nodeset] fall down to default
505: default:
506: throw Exception(0, 0,
507: &expression,
508: "wrong xmlXPathEvalExpression result type (%d)", res->type);
509: break; // never
510: }
511: }
1.1 parser 512:
1.26 paf 513: static void selectNumberHandler(Pool& pool,
514: const String& expression,
515: xmlXPathObject_auto_ptr res,
516: Value *& result) {
517: switch(res->type) {
518: case XPATH_NUMBER:
519: result=new(pool) VDouble(pool, res->floatval);
520: break;
521: case XPATH_NODESET:
522: if(!res->nodesetval->nodeNr)
523: break;
524: // else[nodeset] fall down to default
525: default:
526: throw Exception(0, 0,
527: &expression,
528: "wrong xmlXPathEvalExpression result type (%d)", res->type);
529: break; // never
530: }
531: }
532:
533: static void selectStringHandler(Pool& pool,
534: const String& expression,
535: xmlXPathObject_auto_ptr res,
536: Value *& result) {
537: switch(res->type) {
538: case XPATH_UNDEFINED:
539: break;
540: case XPATH_STRING:
541: result=new(pool) VString(
542: pool.transcode(
543: GdomeDOMString_auto_ptr(
544: gdome_str_mkref_dup((const gchar *)res->stringval)).get()));
545: break;
546: case XPATH_NODESET:
547: if(!res->nodesetval->nodeNr)
548: break;
549: // else[nodeset] fall down to default
550: default:
551: throw Exception(0, 0,
552: &expression,
553: "wrong xmlXPathEvalExpression result type (%d)", res->type);
554: break; // never
1.1 parser 555: }
556: }
1.25 paf 557:
1.26 paf 558: static void _select(Request& r, const String& method_name, MethodParams *params) {
559: _selectX(r, method_name, params,
560: selectNodesHandler);
561: }
562:
1.9 parser 563: static void _selectSingle(Request& r, const String& method_name, MethodParams *params) {
1.26 paf 564: _selectX(r, method_name, params,
565: selectNodeHandler);
566: }
1.1 parser 567:
1.26 paf 568: static void _selectBool(Request& r, const String& method_name, MethodParams *params) {
569: _selectX(r, method_name, params,
570: selectBoolHandler);
571: }
1.20 paf 572:
1.26 paf 573: static void _selectNumber(Request& r, const String& method_name, MethodParams *params) {
574: _selectX(r, method_name, params,
575: selectNumberHandler);
576: }
1.24 paf 577:
1.26 paf 578: static void _selectString(Request& r, const String& method_name, MethodParams *params) {
579: _selectX(r, method_name, params,
580: selectStringHandler);
1.1 parser 581: }
1.20 paf 582:
1.1 parser 583: // constructor
584:
1.2 parser 585: MXnode::MXnode(Pool& apool) : Methoded(apool),
586: consts(apool) {
1.1 parser 587: set_name(*NEW String(pool(), XNODE_CLASS_NAME));
1.6 parser 588:
589: /// DOM1 node
590:
591: // Node insertBefore(in Node newChild,in Node refChild) raises(DOMException);
592: add_native_method("insertBefore", Method::CT_DYNAMIC, _insertBefore, 2, 2);
593: // Node replaceChild(in Node newChild,in Node oldChild) raises(DOMException);
594: add_native_method("replaceChild", Method::CT_DYNAMIC, _replaceChild, 2, 2);
595: // Node removeChild(in Node oldChild) raises(DOMException);
596: add_native_method("removeChild", Method::CT_DYNAMIC, _removeChild, 1, 1);
597: // Node appendChild(in Node newChild) raises(DOMException);
598: add_native_method("appendChild", Method::CT_DYNAMIC, _appendChild, 1, 1);
599: // boolean hasChildNodes();
600: add_native_method("hasChildNodes", Method::CT_DYNAMIC, _hasChildNodes, 0, 0);
601: // Node cloneNode(in boolean deep);
602: add_native_method("cloneNode", Method::CT_DYNAMIC, _cloneNode, 1, 1);
603:
604: /// DOM1 element
605:
606: // DOMString getAttribute(in DOMString name);
607: add_native_method("getAttribute", Method::CT_DYNAMIC, _getAttribute, 1, 1);
608: // void setAttribute(in DOMString name, in DOMString value) raises(DOMException);
609: add_native_method("setAttribute", Method::CT_DYNAMIC, _setAttribute, 2, 2);
610: // void removeAttribute(in DOMString name) raises(DOMException);
611: add_native_method("removeAttribute", Method::CT_DYNAMIC, _removeAttribute, 1, 1);
612: // Attr getAttributeNode(in DOMString name);
613: add_native_method("getAttributeNode", Method::CT_DYNAMIC, _getAttributeNode, 1, 1);
614: // Attr setAttributeNode(in Attr newAttr) raises(DOMException);
615: add_native_method("setAttributeNode", Method::CT_DYNAMIC, _setAttributeNode, 1, 1);
616: // Attr removeAttributeNode(in Attr oldAttr) raises(DOMException);
617: add_native_method("removeAttributeNode", Method::CT_DYNAMIC, _removeAttributeNode, 1, 1);
618: // NodeList getElementsByTagName(in DOMString name);
619: add_native_method("getElementsByTagName", Method::CT_DYNAMIC, _getElementsByTagName, 1, 1);
620: // void normalize();
621: add_native_method("normalize", Method::CT_DYNAMIC, _normalize, 0, 0);
622:
623: /// parser
1.1 parser 624: // ^node.select[/some/xpath/query] = hash $.#[dnode]
1.25 paf 625: add_native_method("select", Method::CT_DYNAMIC, _select, 1, 1);
1.1 parser 626:
1.26 paf 627: // ^node.selectSingle[/some/xpath/query] = first node [if any]
1.9 parser 628: add_native_method("selectSingle", Method::CT_DYNAMIC, _selectSingle, 1, 1);
1.26 paf 629: // ^node.selectBool[/some/xpath/query] = bool value [if any]
630: add_native_method("selectBool", Method::CT_DYNAMIC, _selectBool, 1, 1);
631: // ^node.selectNumber[/some/xpath/query] = double value [if any]
632: add_native_method("selectNumber", Method::CT_DYNAMIC, _selectNumber, 1, 1);
633: // ^node.selectString[/some/xpath/query] = strinv value [if any]
634: add_native_method("selectString", Method::CT_DYNAMIC, _selectString, 1, 1);
1.20 paf 635:
1.2 parser 636: // consts
637:
1.19 paf 638: #define CONST(name) \
639: consts.put(*new(pool()) String(pool(), #name), new(pool()) VInt(pool(), GDOME_##name))
1.2 parser 640:
1.19 paf 641: CONST(ELEMENT_NODE);
642: CONST(ATTRIBUTE_NODE);
643: CONST(TEXT_NODE);
644: CONST(CDATA_SECTION_NODE);
645: CONST(ENTITY_REFERENCE_NODE);
646: CONST(ENTITY_NODE);
647: CONST(PROCESSING_INSTRUCTION_NODE);
648: CONST(COMMENT_NODE);
649: CONST(DOCUMENT_NODE);
650: CONST(DOCUMENT_TYPE_NODE);
651: CONST(DOCUMENT_FRAGMENT_NODE);
652: CONST(NOTATION_NODE);
1.1 parser 653:
654: }
1.3 parser 655:
1.1 parser 656: // global variable
657:
658: Methoded *Xnode_class;
659:
660: #endif
661:
662: // creator
663: Methoded *MXnode_create(Pool& pool) {
664: return
665: #ifdef XML
666: Xnode_class=new(pool) MXnode(pool)
667: #else
668: 0
669: #endif
670: ;
671: }
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xnode.C CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / classes