Annotation of parser3/src/types/pa_vxnode.C, revision 1.27

1.1       parser      1: /** @node
                      2:        Parser: @b dnode parser type.
                      3: 
1.16      paf         4:        Copyright(c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)
1.15      paf         5:        Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
1.1       parser      6: */
                      7: #include "pa_config_includes.h"
                      8: #ifdef XML
1.18      paf         9: 
1.27    ! paf        10: static const char* IDENT_VXNODE_C="$Date: 2002/10/08 12:13:37 $";
1.1       parser     11: 
                     12: #include "pa_vxnode.h"
                     13: #include "pa_vxdoc.h"
                     14: #include "pa_vstring.h"
                     15: #include "pa_vbool.h"
                     16: #include "pa_vhash.h"
                     17: 
                     18: void VXnode_cleanup(void *vxnode) {
                     19:        //_asm int 3;
1.12      paf        20:        static_cast<VXnode *>(vxnode)->~VXnode();
1.1       parser     21: }
                     22: 
1.23      paf        23: Value *VXnode::get_element(const String& aname, Value *aself, bool looking_up) { 
1.12      paf        24:        // $CLASS,$method
1.23      paf        25:        if(Value *result=VStateless_object::get_element(aname, aself, looking_up))
1.12      paf        26:                return result;
                     27: 
                     28:        // fields
                     29: 
1.21      paf        30:        GdomeNode *selfNode=get_node(&aname);
1.12      paf        31:        GdomeException exc;
                     32: 
1.21      paf        33:        if(aname=="nodeName") {
1.12      paf        34:                return NEW VString(transcode(gdome_n_nodeName(selfNode, &exc)));
1.21      paf        35:        } else if(aname=="nodeValue") {
1.12      paf        36:                return NEW VString(transcode(gdome_n_nodeValue(selfNode, &exc)));
1.21      paf        37:        } else if(aname=="nodeType") {
1.12      paf        38:                return NEW VInt(pool(), gdome_n_nodeType(selfNode, &exc));
1.21      paf        39:        } else if(aname=="parentNode") {
1.13      paf        40:                if(GdomeNode *result_node=gdome_n_parentNode(selfNode, &exc))
                     41:                        return NEW VXnode(pool(), result_node);
1.25      paf        42:                return 0;
1.21      paf        43:        } else if(aname=="childNodes") {        
1.12      paf        44:                if(GdomeNode *currentNode=gdome_n_firstChild(selfNode, &exc)) {
                     45:                        VHash *result=NEW VHash(pool());
                     46:                        int i=0;
                     47:                        do {
                     48:                                String& skey=*NEW String(pool());
                     49:                                {
                     50:                                        char *buf=(char *)malloc(MAX_NUMBER);
1.20      paf        51:                                        snprintf(buf, MAX_NUMBER, "%d", i++);
1.12      paf        52:                                        skey << buf;
                     53:                                }
1.21      paf        54:                                result->hash(&aname).put(skey, NEW VXnode(pool(), currentNode));
1.12      paf        55:                        } while(currentNode=gdome_n_nextSibling(currentNode, &exc));
1.3       parser     56:                        return result;
1.12      paf        57:                }
1.25      paf        58:                return 0;
1.21      paf        59:        } else if(aname=="firstChild") {
1.13      paf        60:                if(GdomeNode *result_node=gdome_n_firstChild(selfNode, &exc))
                     61:                        return NEW VXnode(pool(), result_node);
1.25      paf        62:                return 0;
1.21      paf        63:        } else if(aname=="lastChild") {
1.13      paf        64:                if(GdomeNode *result_node=gdome_n_lastChild(selfNode, &exc))
                     65:                        return NEW VXnode(pool(), result_node);
1.25      paf        66:                return 0;
1.21      paf        67:        } else if(aname=="previousSibling") {
1.13      paf        68:                if(GdomeNode *result_node=gdome_n_previousSibling(selfNode, &exc))
                     69:                        return NEW VXnode(pool(), result_node);
1.25      paf        70:                return 0;
1.21      paf        71:        } else if(aname=="nextSibling") {
1.13      paf        72:                if(GdomeNode *result_node=gdome_n_nextSibling(selfNode, &exc))
                     73:                        return NEW VXnode(pool(), result_node);
1.25      paf        74:                return 0;
1.21      paf        75:        } else if(aname=="ownerDocument") {
1.12      paf        76:                if(GdomeDocument *document=gdome_n_ownerDocument(selfNode, &exc))
                     77:                        return NEW VXdoc(pool(), document);
1.25      paf        78:                return 0;
1.13      paf        79:        } else switch(gdome_n_nodeType(selfNode, &exc)) {
                     80:                case GDOME_ELEMENT_NODE: 
1.21      paf        81:                        if(aname=="attributes") {
1.13      paf        82:                                if(GdomeNamedNodeMap *attributes=gdome_n_attributes(selfNode, &exc)) {
1.12      paf        83:                                        VHash *result=NEW VHash(pool());
1.13      paf        84:                                        gulong length=gdome_nnm_length(attributes, &exc);
                     85:                                        for(gulong i=0; i<length; i++) {
                     86:                                                GdomeNode *attr_node=gdome_nnm_item(attributes, i, &exc);
1.12      paf        87:                                                result->hash(0).put(
                     88:                                                        transcode(gdome_n_nodeName(attr_node, &exc)), 
1.13      paf        89:                                                        NEW VXnode(pool(), attr_node));
1.3       parser     90:                                        }
1.12      paf        91:                                        return result;
                     92:                                }
1.25      paf        93:                                return 0;
1.21      paf        94:                        } else if(aname=="tagName") {
1.13      paf        95:                                return NEW VString(transcode(gdome_el_tagName(GDOME_EL(selfNode), &exc)));
1.2       parser     96:                        }
1.12      paf        97:                        break;
1.13      paf        98:                case GDOME_ATTRIBUTE_NODE: 
1.21      paf        99:                        if(aname=="specified")
1.13      paf       100:                                return NEW VBool(pool(), gdome_a_specified(GDOME_A(selfNode), &exc)!=0);
1.27    ! paf       101:                        else if(aname=="name")
1.17      paf       102:                                return NEW VString(transcode(gdome_a_name(GDOME_A(selfNode), &exc)));
1.21      paf       103:                        else if(aname=="value")
1.17      paf       104:                                return NEW VString(transcode(gdome_a_value(GDOME_A(selfNode), &exc)));                  
1.12      paf       105:                        break;
                    106: /*
1.13      paf       107:                case GDOME_COMMENT_NODE: 
1.12      paf       108:                        substringData(unsigned int offset, unsigned int count)
                    109: */
1.13      paf       110:                case GDOME_PROCESSING_INSTRUCTION_NODE: 
1.21      paf       111:                        if(aname=="target")
1.13      paf       112:                                return NEW VString(transcode(gdome_pi_target(GDOME_PI(selfNode), &exc)));
1.21      paf       113:                        else if(aname=="data")
1.17      paf       114:                                return NEW VString(transcode(gdome_pi_data(GDOME_PI(selfNode), &exc)));                         
1.12      paf       115:                        break;
1.13      paf       116:                case GDOME_DOCUMENT_TYPE_NODE: 
1.12      paf       117:                        {
1.13      paf       118:                                GdomeDocumentType *doctype=GDOME_DT(selfNode);
1.26      paf       119:                                if(aname=="name") {
1.21      paf       120:                                        // readonly attribute DOMString aname;
                    121:                                        // The aname of DTD; i.e., the aname immediately following 
1.12      paf       122:                                        // the DOCTYPE keyword in an XML source document.
                    123:                                        return NEW VString(transcode(gdome_dt_name(doctype, &exc)));
1.1       parser    124:                                }
1.12      paf       125:                                /*
                    126:                                readonly attribute NamedNodeMap entities;
                    127:                                readonly attribute NamedNodeMap notations;
                    128:                                virtual const XalanNamedNodeMap* getEntities () const = 0 
                    129:                                This function returns a NamedNodeMap containing the general entities, both external and internal, declared in the DTD. More...
                    130:                                virtual const XalanNamedNodeMap* getNotations () const = 0 
                    131:                                This function returns a named selfNode map containing an entry for each notation declared in a document's DTD. More...
                    132:                                */
                    133:                        }
                    134:                        break;
1.13      paf       135:                case GDOME_NOTATION_NODE:
1.12      paf       136:                        {
1.13      paf       137:                                GdomeNotation *notation=GDOME_NOT(selfNode);
1.21      paf       138:                                if(aname=="publicId") {
1.12      paf       139:                                        // readonly attribute DOMString publicId;
                    140:                                        return NEW VString(transcode(gdome_not_publicId(notation, &exc)));
1.21      paf       141:                                } else if(aname=="systemId") {
1.12      paf       142:                                        // readonly attribute DOMString systemId;
                    143:                                        return NEW VString(transcode(gdome_not_systemId(notation, &exc)));
1.4       parser    144:                                }
1.12      paf       145:                        }
                    146:                        break;
                    147:        }
1.3       parser    148:                
1.24      paf       149:        bark("%s field not found", 0, &aname); return 0;
1.1       parser    150: }
                    151: 
                    152: #endif

E-mail: