Annotation of parser3/src/types/pa_vdnode.C, revision 1.4

1.1       parser      1: /** @node
                      2:        Parser: @b dnode parser type.
                      3: 
                      4:        Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)
                      5: 
                      6:        Author: Alexander Petrosyan <paf@design.ru>(http://design.ru/paf)
                      7: 
1.4     ! parser      8:        $Id: pa_vdnode.C,v 1.3 2001/09/20 08:39:41 parser Exp $
1.1       parser      9: */
                     10: 
                     11: #if _MSC_VER
                     12: #      pragma warning(disable:4291)   // disable warning 
                     13: //     "no matching operator delete found; memory will not be freed if initialization throws an exception
                     14: #endif
                     15: 
                     16: #include "pa_vdnode.h"
1.2       parser     17: #include "pa_vdom.h"
1.1       parser     18: #include "pa_vstring.h"
1.3       parser     19: #include "pa_vbool.h"
1.1       parser     20: 
                     21: #include <util/XMLString.hpp>
                     22: #include <util/PlatformUtils.hpp>
                     23: #include <util/TransService.hpp>
1.2       parser     24: #include <XalanDOM/XalanNamedNodeMap.hpp>
1.3       parser     25: #include <XalanDOM/XalanAttr.hpp>
                     26: #include <XalanDOM/XalanProcessingInstruction.hpp>
                     27: 
1.1       parser     28: /*
                     29: void VDnode_cleanup(void *vnode) {
                     30:        //_asm int 3;
                     31:        static_cast<VDDom *>(vnode)->cleanup();
                     32: }
                     33: */
                     34: 
                     35: /// VDnode: $CLASS,$method
                     36: Value *VDnode::get_element(const String& aname) { 
                     37:        // $CLASS,$method
                     38:        if(Value *result=VStateless_object::get_element(aname))
                     39:                return result;
                     40: 
                     41:        // fields
                     42: 
1.3       parser     43:        XalanNode *self=&get_node(pool(), &aname);
1.2       parser     44: 
1.1       parser     45:        if(aname=="name") {
1.4     ! parser     46:                const char *name_cstr=transcode(self->getNodeName());
1.1       parser     47:                String& name=*NEW String(pool(), name_cstr);
                     48:                return NEW VString(name);
1.2       parser     49:        } else if(aname=="value") {
1.4     ! parser     50:                const char *value_cstr=transcode(self->getNodeValue());
1.1       parser     51:                String& value=*NEW String(pool(), value_cstr);
                     52:                return NEW VString(value);
1.2       parser     53:        } else if(aname=="type") {
                     54:                static const char *type_names[]={
1.4     ! parser     55:                        "unknown", "element", "attribute", "text", "cdata", "entityref",    
        !            56:                        "entity", "pi", "comment", "document", "doctype", "docfragment", 
1.2       parser     57:                        "notation"
                     58:                };
1.3       parser     59:                XalanNode::NodeType node_type=self->getNodeType();
1.2       parser     60:                if(node_type > sizeof(type_names)/sizeof(type_names[0]))
                     61:                        node_type=XalanNode::UNKNOWN_NODE;
                     62:                return NEW VString(*NEW String(pool(), type_names[node_type]));
                     63:        } else if(aname=="parent") {
1.3       parser     64:                if(XalanNode *result_node=self->getParentNode())
1.2       parser     65:                        return NEW VDnode(pool(), result_node);
                     66:        } else if(aname=="first-child") {
1.3       parser     67:                if(XalanNode *result_node=self->getFirstChild())
1.2       parser     68:                        return NEW VDnode(pool(), result_node);
                     69:        } else if(aname=="last-child") {
1.3       parser     70:                if(XalanNode *result_node=self->getLastChild())
1.2       parser     71:                        return NEW VDnode(pool(), result_node);
                     72:        } else if(aname=="previous-sibling") {
1.3       parser     73:                if(XalanNode *result_node=self->getPreviousSibling())
1.2       parser     74:                        return NEW VDnode(pool(), result_node);
                     75:        } else if(aname=="next-sibling") {
1.3       parser     76:                if(XalanNode *result_node=self->getNextSibling())
1.2       parser     77:                        return NEW VDnode(pool(), result_node);
                     78:        } else if(aname=="owner") {
1.3       parser     79:                if(XalanDocument *document=self->getOwnerDocument())
1.2       parser     80:                        return NEW VDom(pool(), document);
1.3       parser     81:        } else switch(self->getNodeType()) {
                     82:                case XalanNode::ELEMENT_NODE: 
                     83:                        if(aname=="attributes") {
                     84:                                if(const XalanNamedNodeMap *attributes=self->getAttributes()) {
                     85:                                        VHash *result=NEW VHash(pool());
                     86:                                        for(int i=0; i<attributes->getLength(); i++) {
                     87:                                                XalanNode *attr_node=attributes->item(i);
                     88:                                                result->hash().put(
1.4     ! parser     89:                                                        *NEW String(pool(), transcode(attr_node->getNodeName())), 
1.3       parser     90:                                                        NEW VDnode(pool(), attr_node));
                     91:                                        }
                     92:                                        return result;
                     93:                                }
                     94:                        }
                     95:                        break;
                     96:                case XalanNode::ATTRIBUTE_NODE: 
                     97:                        if(aname=="specified")
                     98:                                return NEW VBool(pool(), static_cast<XalanAttr *>(self)->getSpecified());
                     99:                        break;
                    100: /*
                    101:                case XalanNode::TEXT_NODE: 
                    102:                case XalanNode::CDATA_SECTION_NODE: 
                    103:                case XalanNode::COMMENT_NODE: 
                    104:                        substringData(unsigned int offset, unsigned int count)
                    105: */
                    106:                //case XalanNode::ENTITY_REFERENCE_NODE: 
                    107:                //case XalanNode::ENTITY_NODE: 
                    108:                case XalanNode::PROCESSING_INSTRUCTION_NODE: 
                    109:                        if(aname=="target")
                    110:                                return NEW VString(*NEW String(pool(), 
1.4     ! parser    111:                                        transcode(static_cast<XalanProcessingInstruction *>(self)->getTarget())));
1.3       parser    112:                        break;
                    113: /*
                    114:                case XalanNode::DOCUMENT_NODE: 
                    115: virtual XalanDocumentType* getDoctype () const = 0 
                    116:        Get Document Type Declaration (see DocumentType) associated with this document. More...
                    117: virtual XalanDOMImplementation* getImplementation () const = 0 
                    118:        Return the DOMImplementation object that handles this document.
                    119: virtual XalanElement* getDocumentElement () const = 0 
                    120:        Return a reference to the root element of the document.
                    121: virtual XalanNodeList* getElementsByTagName (const XalanDOMString& tagname) const = 0 
                    122:        Returns a NodeList of all the elements with a given tag name. More...
                    123: */
                    124: /*
                    125:                case XalanNode::DOCUMENT_TYPE_NODE: 
                    126: virtual const XalanDOMString& getName () const = 0 
                    127:        The name of DTD; i.e., the name immediately following the DOCTYPE keyword in an XML source document.
                    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 node map containing an entry for each notation declared in a document's DTD. More...*/
                    132: //             case XalanNode::DOCUMENT_FRAGMENT_NODE: 
                    133: //             case XalanNode::NOTATION_NODE;
                    134:        }
1.1       parser    135:        
1.2       parser    136: 
1.1       parser    137:        return 0;
                    138: }

E-mail: