Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.xml.DomParser"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.xml.DomParser"] = true;
dojo.provide("dojox.xml.DomParser");

dojox.xml.DomParser=new (function(){
        /**********************************************************
         *      The DomParser is a close-to (but not entirely)
         *      conforming XML parser based on regular
         *      expressions.  It will take any XML fragment
         *      and return a lightweight JS structure that is
         *      similar to (but not exactly) the DOM specification.
         *
         *      Getter and setter methods are NOT available; the goal
         *      was to keep the resulting object model entirely JS-like.
         *
         *      All node types but document fragments are supported;
         *      all nodes support getElementsByTagName and 
         *      getElementsByTagNameNS (with short names byName and 
         *      byNameNS).  The document node supports getElementById
         *      (byId), and all nodes support a supplimental
         *      childrenByName/childrenByNameNS method as well.
         *
         *      The object model is intended to be a READONLY format;
         *      mutation events are NOT supported, and though you
         *      can change properties on a node-by-node basis, certain
         *      operations are not supported (such as changing the ID 
         *      of an element).
         **********************************************************/

        //      internal use only.
        var nodeTypes={ ELEMENT:1, ATTRIBUTE:2, TEXT:3, CDATA_SECTION:4, PROCESSING_INSTRUCTION:7, COMMENT:8, DOCUMENT:9 };

        //      compile the regular expressions once.
        var reTags=/<([^>\/\s+]*)([^>]*)>([^<]*)/g;
        var reAttr=/([^=]*)="([^"]*)"/g;
        var reEntity=/<!ENTITY\s+([^"]*)\s+"([^"]*)">/g;
        var reCData=/<!\[CDATA\[([\u0001-\uFFFF]*?)\]\]>/g;
        var reComments=/<!--([\u0001-\uFFFF]*?)-->/g;
        var trim=/^\s+|\s+$/g;
        var normalize=/\s+/g;
        var egt=/\&gt;/g;
        var elt=/\&lt;/g;
        var equot=/\&quot;/g;
        var eapos=/\&apos;/g;
        var eamp=/\&amp;/g;
        var dNs="_def_";

        //      create a root node.
        function _doc(){
                return new (function(){
                        var all={};
                        this.nodeType=nodeTypes.DOCUMENT;
                        this.nodeName="#document";
                        this.namespaces={};
                        this._nsPaths={};
                        this.childNodes=[];
                        this.documentElement=null;

                        //      any element with an ID attribute will be added to the internal hashtable.
                        this._add=function(obj){
                                if(typeof(obj.id)!="undefined"){ all[obj.id]=obj; }
                        };
                        this._remove=function(id){
                                if(all[id]){ delete all[id]; }
                        };

                        this.byId=this.getElementById=function(id){ return keys[id]; };
                        this.byName=this.getElementsByTagName=byName;
                        this.byNameNS=this.getElementsByTagNameNS=byNameNS;
                        this.childrenByName=childrenByName;
                })();
        }

        //      functions attached to element nodes
        function byName(name){
                //      return all descendants with name.  Fully qualified (i.e. svg:svg)
                function __(node, name, arr){
                        dojo.forEach(node.childNodes, function(c){
                                if(c.nodeType==nodeTypes.ELEMENT){
                                        if(name=="*"){ arr.push(c); }
                                        else if(c.nodeName==name){ arr.push(c); }
                                        __(c, name, arr);
                                }
                        });
                }
                var a=[];
                __(this, name, a);
                return a;
        }
        function byNameNS(name, ns){
                //      return all descendants with name by namespace.  If no namespace passed, the default is used.
                function __(node, name, ns, arr){
                        dojo.forEach(node.childNodes, function(c){
                                if(c.nodeType==nodeTypes.ELEMENT){
                                        if(name=="*"&&c.ownerDocument._nsPaths[ns]==c.namespace){ arr.push(c); }
                                        else if(c.localName==name&&c.ownerDocument._nsPaths[ns]==c.namespace){ arr.push(c); }
                                        __(c, name, ns, arr);
                                }
                        });
                }
                if(!ns){ ns=dNs; }
                var a=[];
                __(this, name, ns, a);
                return a;
        }
        //      Only child nodes with name.
        function childrenByName(name){
                var a=[];
                dojo.forEach(this.childNodes, function(c){
                        if(c.nodeType==nodeTypes.ELEMENT){
                                if(name=="*"){ a.push(c); }
                                else if(c.nodeName==name){ a.push(c); }
                        }
                });
                return a;
        }

        //      attribute functions
        function getAttr(name){
                for(var i=0; i<this.attributes.length; i++){
                        if(this.attributes[i].nodeName==name){
                                return this.attributes[i].nodeValue;
                        }
                }
                return null;
        }
        function getAttrNS(name, ns){
                for(var i=0; i<this.attributes.length; i++){
                        if(this.ownerDocument._nsPaths[ns]==this.attributes[i].namespace
                                &&this.attributes[i].localName==name
                        ){
                                return this.attributes[i].nodeValue;
                        }
                }
                return null;
        }
        //      note that you can only swap IDs using setAttribute, NOT with setAttributeNS.
        function setAttr(name, val){
                var old=null;
                for(var i=0; i<this.attributes.length; i++){
                        if(this.attributes[i].nodeName==name){
                                old=this.attributes[i].nodeValue;
                                this.attributes[i].nodeValue=val;
                                break;
                        }
                }
                if(name=="id"){
                        if(old!=null){ this.ownerDocument._remove(old); }
                        this.ownerDocument._add(this);
                }
        }
        function setAttrNS(name, val, ns){
                for(var i=0; i<this.attributes.length; i++){
                        if(this.ownerDocument._nsPaths[ns]==this.attributes[i].namespace
                                &&this.attributes[i].localName==name
                        ){
                                this.attributes[i].nodeValue=val;
                                return;
                        }
                }
        }

        //      navigation
        function prev(){
                var p=this.parentNode;
                if(p){
                        for(var i=0;i<p.childNodes.length;i++){
                                if(p.childNodes[i]==this&&i>0){
                                        return p.childNodes[i-1];
                                }
                        }
                }
                return null;
        }
        function next(){
                var p=this.parentNode;
                if(p){
                        for(var i=0;i<p.childNodes.length;i++){
                                if(p.childNodes[i]==this&&(i+1)<p.childNodes.length){
                                        return p.childNodes[i+1];
                                }
                        }
                }
                return null;
        }

        //      the main method.
        this.parse=function(/* String */str){
                var root=_doc();
                if(str==null){ return root; }
                if(str.length==0){ return root; }

                //      preprocess custom entities
                if(str.indexOf("<!ENTITY")>0){
                        var entity, eRe=[];
                        if(reEntity.test(str)){
                                reEntity.lastIndex=0;
                                //      match entities
                                while((entity=reEntity.exec(str))!=null){
                                        eRe.push({ 
                                                entity:"&"+entity[1].replace(trim,"")+";", 
                                                expression:entity[2] 
                                        });
                                }
                                //      replace instances in the document.
                                for(var i=0; i<eRe.length; i++){
                                        str=str.replace(new RegExp(eRe[i].entity, "g"), eRe[i].expression);
                                }
                        }
                }

                //      pre-parse for CData, and tokenize.
                var cdSections=[], cdata;
                while((cdata=reCData.exec(str))!=null){ cdSections.push(cdata[1]); }
                for(var i=0; i<cdSections.length; i++){ str=str.replace(cdSections[i], i); }
                
                //      pre-parse for comments, and tokenize.
                var comments=[], comment;
                while((comment=reComments.exec(str))!=null){ comments.push(comment[1]); }
                for(i=0; i<comments.length; i++){ str=str.replace(comments[i], i); }

                //      parse the document
                var res, obj=root;
                while((res=reTags.exec(str))!=null){
                        //      closing tags.
                        if(res[2].charAt(0)=="/"){
                                if(obj.parentNode){
                                        obj=obj.parentNode;
                                }
                                continue;
                        }

                        //      open tags.
                        if(res[1].length>0){
                                //      figure out the type of node.
                                if(res[1].charAt(0)=="?"){
                                        //      processing instruction
                                        var name=res[1].substr(1);
                                        var target=res[2].substr(0,res[2].length-2);
                                        obj.childNodes.push({ 
                                                nodeType:nodeTypes.PROCESSING_INSTRUCTION, 
                                                nodeName:name, 
                                                nodeValue:target 
                                        });
                                }
                                else if(res[1].charAt(0)=="!"){
                                        //      CDATA; skip over any declaration elements.
                                        if(res[1].indexOf("![CDATA[")==0){
                                                var val=parseInt(res[1].replace("![CDATA[","").replace("]]",""));
                                                obj.childNodes.push({ 
                                                        nodeType:nodeTypes.CDATA_SECTION, 
                                                        nodeName:"#cdata-section", 
                                                        nodeValue:cdSections[val] 
                                                });
                                        }
                                        //      Comments.
                                        else if(res[1].substr(0,3)=="!--"){
                                                var val=parseInt(res[1].replace("!--","").replace("--",""));
                                                obj.childNodes.push({ 
                                                        nodeType:nodeTypes.COMMENT, 
                                                        nodeName:"#comment", 
                                                        nodeValue:comments[val] 
                                                });
                                        }
                                }
                                else {
                                        //      Elements (with attribute and text)
                                        var name=res[1].replace(trim,"");
                                        var o={ 
                                                nodeType:nodeTypes.ELEMENT, 
                                                nodeName:name, 
                                                localName:name, 
                                                namespace:dNs, 
                                                ownerDocument:root, 
                                                attributes:[], 
                                                parentNode:null, 
                                                childNodes:[] 
                                        };

                                        //      check to see if it's namespaced.
                                        if(name.indexOf(":")>-1){
                                                var t=name.split(":");
                                                o.namespace=t[0];
                                                o.localName=t[1];
                                        }

                                        //      set the function references.
                                        o.byName=o.getElementsByTagName=byName;
                                        o.byNameNS=o.getElementsByTagNameNS=byNameNS;
                                        o.childrenByName=childrenByName;
                                        o.getAttribute=getAttr;
                                        o.getAttributeNS=getAttrNS;
                                        o.setAttribute=setAttr;
                                        o.setAttributeNS=setAttrNS;
                                        o.previous=o.previousSibling=prev;
                                        o.next=o.nextSibling=next;

                                        //      parse the attribute string.
                                        var attr;
                                        while((attr=reAttr.exec(res[2]))!=null){
                                                if(attr.length>0){
                                                        var name=attr[1].replace(trim,"");
                                                        var val=attr[2].replace(normalize," ")
                                                                .replace(egt,">")
                                                                .replace(elt,"<")
                                                                .replace(eapos,"'")
                                                                .replace(equot,'"')
                                                                .replace(eamp,"&");
                                                        if(name.indexOf("xmlns")==0){
                                                                if(name.indexOf(":")>0){
                                                                        var ns=name.split(":");
                                                                        root.namespaces[ns[1]]=val;
                                                                        root._nsPaths[val]=ns[1];
                                                                } else {
                                                                        root.namespaces[dNs]=val;
                                                                        root._nsPaths[val]=dNs;
                                                                }
                                                        } else {
                                                                var ln=name;
                                                                var ns=dNs;
                                                                if(name.indexOf(":")>0){
                                                                        var t=name.split(":");
                                                                        ln=t[1];
                                                                        ns=t[0];
                                                                }
                                                                o.attributes.push({
                                                                        nodeType:nodeTypes.ATTRIBUTE, 
                                                                        nodeName:name, 
                                                                        localName:ln, 
                                                                        namespace:ns, 
                                                                        nodeValue:val 
                                                                });

                                                                //      only add id as a property.
                                                                if(ln=="id"){ o.id=val; }
                                                        }
                                                }
                                        }
                                        root._add(o);

                                        var text=res[3].replace(trim,"");
                                        if(text.length>0)
                                                o.childNodes.push({ 
                                                        nodeType:nodeTypes.TEXT, 
                                                        nodeName:"#text", 
                                                        nodeValue:text.replace(normalize," ").replace(egt,">").replace(elt,"<").replace(eapos,"'").replace(equot,'"').replace(eamp,"&") 
                                                });

                                        if(obj){
                                                obj.childNodes.push(o);
                                                o.parentNode=obj;
                                                //      if it's not a self-closing node.
                                                if(res[2].charAt(res[2].length-1)!="/"){
                                                        obj=o;
                                                }
                                        }
                                }
                        }
                }

                //      set the document element
                for(var i=0; i<root.childNodes.length; i++){
                        var e=root.childNodes[i];
                        if(e.nodeType==nodeTypes.ELEMENT){
                                root.documentElement=e;
                                break;
                        }
                }
                return root;
        };
})();

}