Return to xnode.C CVS log

Up to [parser3project] / parser3 / src / classes

Annotation of parser3/src/classes/xnode.C, revision 1.4

1.1       parser      1: /** @file
                      2:        Parser: @b dom parser class.
                      3: 
                      4:        Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
                      5:        Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
                      6: 
1.4     ! parser      7:        $Id: xnode.C,v 1.3 2001/09/28 09:37:09 parser Exp $
1.1       parser      8: */
                      9: #include "classes.h"
                     10: #ifdef XML
                     11: 
                     12: #include "pa_request.h"
                     13: #include "pa_vxnode.h"
                     14: 
                     15: #include "xnode.h"
                     16: 
                     17: #include <util/XMLString.hpp>
                     18: #include <XalanSourceTree/XalanSourceTreeDOMSupport.hpp>
                     19: #include <XPath/XPathEvaluator.hpp>
                     20: #include <XPath/NodeRefList.hpp>
                     21: 
                     22: // defines
                     23: 
                     24: #define XNODE_CLASS_NAME "xnode"
                     25: 
                     26: // class
                     27: 
                     28: // methods
                     29: 
                     30: static void _select(Request& r, const String& method_name, MethodParams *params) {
                     31: //     _asm int 3;
                     32:        Pool& pool=r.pool();
                     33:        VXnode& vnode=*static_cast<VXnode *>(r.self);
                     34: 
                     35:        // expression
                     36:        const String& expression=params->as_string(0, "expression must not be code");
                     37:        const char *expression_cstr=expression.cstr(String::UL_AS_IS);
                     38:        XalanDOMString dstring(expression_cstr);
                     39:        const XalanDOMChar *expression_dcstr=dstring.c_str();
                     40: 
                     41:        XPathEvaluator evaluator;
                     42:        // We'll use these to parse the XML file.
                     43:        XalanSourceTreeDOMSupport dom_support;
                     44: 
                     45:        try {
                     46:                NodeRefList list=evaluator.selectNodeList(dom_support, 
                     47:                        &vnode.get_node(pool, &method_name), 
                     48:                        expression_dcstr);
                     49: 
                     50:                VHash& result=*new(pool) VHash(pool);
                     51:                for(int i=0; i<list.getLength(); i++) {
                     52:                        String& skey=*new(pool) String(pool);
                     53:                        {
                     54:                                char *buf=(char *)pool.malloc(MAX_NUMBER);
                     55:                                snprintf(buf, MAX_NUMBER, "%d", i);
                     56:                                skey << buf;
                     57:                        }
                     58: 
                     59:                        result.hash().put(skey, new(pool) VXnode(pool, list.item(i)));
                     60:                }
                     61:                result.set_name(method_name);
                     62:                r.write_no_lang(result);
                     63:        } catch(const XSLException& e) {
1.4     ! parser     64:                pool.exception()._throw(pool, &expression, e);
1.1       parser     65:        }
                     66: }
                     67: 
                     68: static void _select_single(Request& r, const String& method_name, MethodParams *params) {
                     69: //     _asm int 3;
                     70:        Pool& pool=r.pool();
                     71:        VXnode& vnode=*static_cast<VXnode *>(r.self);
                     72: 
                     73:        // expression
                     74:        const String& expression=params->as_string(0, "expression must not be code");
                     75:        const char *expression_cstr=expression.cstr(String::UL_AS_IS);
                     76:        XalanDOMString dstring(expression_cstr);
                     77:        const XalanDOMChar *expression_dcstr=dstring.c_str();
                     78: 
                     79:        XPathEvaluator evaluator;
                     80:        // Initialize the XalanSourceTree subsystem...
                     81: //     XalanSourceTreeInit             theSourceTreeInit;
                     82:        // We'll use these to parse the XML file.
                     83:        XalanSourceTreeDOMSupport dom_support;
                     84: 
                     85:        try {
                     86:                 if(XalanNode *node=evaluator.selectSingleNode(dom_support, 
                     87:                        &vnode.get_node(pool, &method_name), 
                     88:                        expression_dcstr)) {
                     89: 
                     90:                        VXnode& result=*new(pool) VXnode(pool, node);
                     91:                        result.set_name(method_name);
                     92:                        r.write_no_lang(result);
                     93:                }
                     94:        } catch(const XSLException& e) {
1.4     ! parser     95:                pool.exception()._throw(pool, &expression, e);
1.1       parser     96:        }
                     97: }
                     98: 
                     99: // constructor
                    100: 
1.2       parser    101: MXnode::MXnode(Pool& apool) : Methoded(apool), 
                    102:        consts(apool) {
1.1       parser    103:        set_name(*NEW String(pool(), XNODE_CLASS_NAME));
                    104: 
                    105:        // ^node.select[/some/xpath/query] = hash $.#[dnode]
                    106:        add_native_method("select", Method::CT_DYNAMIC, _select, 1, 1);
                    107: 
                    108:        // ^node.select-single[/some/xpath/query] = first dnode
                    109:        add_native_method("select-single", Method::CT_DYNAMIC, _select_single, 1, 1);
1.2       parser    110: 
                    111:        // consts
                    112: 
                    113: #define CONST(name, value) \
                    114:        consts.put(*new(pool()) String(pool(), #name), new(pool()) VInt(pool(), value))
                    115: 
                    116:        CONST(ELEMENT_NODE, 1);
                    117:     CONST(ATTRIBUTE_NODE,  2);
                    118:     CONST(TEXT_NODE,  3);
                    119:     CONST(CDATA_SECTION_NODE,  4);
                    120:     CONST(ENTITY_REFERENCE_NODE,  5);
                    121:     CONST(ENTITY_NODE,  6);
                    122:     CONST(PROCESSING_INSTRUCTION_NODE,  7);
                    123:     CONST(COMMENT_NODE,  8);
                    124:     CONST(DOCUMENT_NODE,  9);
                    125:     CONST(DOCUMENT_TYPE_NODE,  10);
                    126:     CONST(DOCUMENT_FRAGMENT_NODE,  11);
                    127:     CONST(NOTATION_NODE,  12);
1.1       parser    128: 
                    129: }
1.3       parser    130: 
1.1       parser    131: // global variable
                    132: 
                    133: Methoded *Xnode_class;
                    134: 
                    135: #endif
                    136: 
                    137: // creator
                    138: Methoded *MXnode_create(Pool& pool) {
                    139:        return 
                    140: #ifdef XML
                    141:                Xnode_class=new(pool) MXnode(pool)
                    142: #else
                    143:                0
                    144: #endif
                    145:                ;
                    146: }