Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   *
   * This Source Code Form is subject to the terms of the Mozilla Public
   * License, v. 2.0. If a copy of the MPL was not distributed with this
   * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
  
  package org.mozilla.javascript.xmlimpl;
  
 
 
 public final class XMLLibImpl extends XMLLib implements Serializable {
     private static final long serialVersionUID = 1L;
 
     //
     //    EXPERIMENTAL Java interface
     //
 
    
This experimental interface is undocumented.
 
     public static org.w3c.dom.Node toDomNode(Object xmlObject) {
         //    Could return DocumentFragment for XMLList
         //    Probably a single node for XMLList with one element
         if (xmlObject instanceof XML) {
             return ((XML)xmlObject).toDomNode();
         } else {
             throw new IllegalArgumentException(
                     "xmlObject is not an XML object in JavaScript.");
         }
     }
 
     public static void init(Context cxScriptable scopeboolean sealed) {
         XMLLibImpl lib = new XMLLibImpl(scope);
         XMLLib bound = lib.bindToScope(scope);
         if (bound == lib) {
             lib.exportToScope(sealed);
         }
     }
 
     public void setIgnoreComments(boolean b) {
         .setIgnoreComments(b);
     }
 
     public void setIgnoreWhitespace(boolean b) {
         .setIgnoreWhitespace(b);
     }
 
     public void setIgnoreProcessingInstructions(boolean b) {
     }
 
     public void setPrettyPrinting(boolean b) {
         .setPrettyPrinting(b);
     }
 
     public void setPrettyIndent(int i) {
         .setPrettyIndent(i);
     }
 
     public boolean isIgnoreComments() {
         return .isIgnoreComments();
     }
 
     public boolean isIgnoreProcessingInstructions() {
         return .isIgnoreProcessingInstructions();
     }
 
     public boolean isIgnoreWhitespace() {
         return .isIgnoreWhitespace();
     }
 
     public  boolean isPrettyPrinting() {
         return .isPrettyPrinting();
     }
 
     public int getPrettyIndent() {
         return .getPrettyIndent();
     }
 
 
     private Scriptable globalScope;
 
     private XML xmlPrototype;
     private XMLList xmlListPrototype;
     private Namespace namespacePrototype;
     private QName qnamePrototype;
 
     private XmlProcessor options = new XmlProcessor();
 
     private XMLLibImpl(Scriptable globalScope) {
         this. = globalScope;
     }

    

Deprecated:
 
     QName qnamePrototype() {
        return ;
    }

    

Deprecated:
        return ;
    }
        return ;
    }
    private void exportToScope(boolean sealed) {
         = newXML(XmlNode.createText(""));
         = newXMLList();
         = Namespace.create(this.null,
                ..);
         = QName.create(thisthis.null,
                XmlNode.QName.create(XmlNode.Namespace.create(""), ""));
        .exportAsJSClass(sealed);
        .exportAsJSClass(sealed);
        .exportAsJSClass(sealed);
        .exportAsJSClass(sealed);
    }

    

Deprecated:
    XMLName toAttributeName(Context cxObject nameValue) {
        if (nameValue instanceof XMLName) {
            //    TODO    Will this always be an XMLName of type attribute name?
            return (XMLName)nameValue;
        } else if (nameValue instanceof QName) {
            return XMLName.create( ((QName)nameValue).getDelegate(), truefalse );
        } else if (nameValue instanceof Boolean
            || nameValue instanceof Number
            || nameValue == .
            || nameValue == null) {
            throw badXMLName(nameValue);
        } else {
            //    TODO    Not 100% sure that putting these in global namespace is the right thing to do
            String localName = null;
            if (nameValue instanceof String) {
                localName = (String)nameValue;
            } else {
                localName = ScriptRuntime.toString(nameValue);
            }
            if (localName != null && localName.equals("*")) localName = null;
            return XMLName.create(XmlNode.QName.create(
                    XmlNode.Namespace.create(""), localName), truefalse);
        }
    }
    private static RuntimeException badXMLName(Object value)
    {
        String msg;
        if (value instanceof Number) {
            msg = "Can not construct XML name from number: ";
        } else if (value instanceof Boolean) {
            msg = "Can not construct XML name from boolean: ";
        } else if (value == . || value == null) {
            msg = "Can not construct XML name from ";
        } else {
            throw new IllegalArgumentException(value.toString());
        }
        return ScriptRuntime.typeError(msg+ScriptRuntime.toString(value));
    }
    XMLName toXMLNameFromString(Context cxString name) {
        return XMLName.create(getDefaultNamespaceURI(cx), name);
    }
    /* TODO: Marked deprecated by original author */
    XMLName toXMLName(Context cxObject nameValue) {
        XMLName result;
        if (nameValue instanceof XMLName) {
            result = (XMLName)nameValue;
        } else if (nameValue instanceof QName) {
            QName qname = (QName)nameValue;
            result = XMLName.formProperty(qname.uri(), qname.localName());
        } else if (nameValue instanceof String) {
            result = toXMLNameFromString(cx, (String)nameValue);
        } else if (nameValue instanceof Boolean
            || nameValue instanceof Number
            || nameValue == .
            || nameValue == null) {
            throw badXMLName(nameValue);
        } else {
            String name = ScriptRuntime.toString(nameValue);
            result = toXMLNameFromString(cxname);
        }
        return result;
    }

    
If value represents Uint32 index, make it available through ScriptRuntime.lastUint32Result(cx) and return null. Otherwise return the same value as toXMLName(cx, value).
    XMLName toXMLNameOrIndex(Context cxObject value)
    {
        XMLName result;
        if (value instanceof XMLName) {
            result = (XMLName)value;
        } else if (value instanceof String) {
            String str = (String)value;
            long test = ScriptRuntime.testUint32String(str);
            if (test >= 0) {
                ScriptRuntime.storeUint32Result(cxtest);
                result = null;
            } else {
                result = toXMLNameFromString(cxstr);
            }
        } else if (value instanceof Number) {
            double d = ((Number)value).doubleValue();
            long l = (long)d;
            if (l == d && 0 <= l && l <= 0xFFFFFFFFL) {
                ScriptRuntime.storeUint32Result(cxl);
                result = null;
            } else {
                throw badXMLName(value);
            }
        } else if (value instanceof QName) {
            QName qname = (QName)value;
            String uri = qname.uri();
            boolean number = false;
            result = null;
            if (uri != null && uri.length() == 0) {
                // Only in this case qname.toString() can resemble uint32
                long test = ScriptRuntime.testUint32String(uri);
                if (test >= 0) {
                    ScriptRuntime.storeUint32Result(cxtest);
                    number = true;
                }
            }
            if (!number) {
                result = XMLName.formProperty(uriqname.localName());
            }
        } else if (value instanceof Boolean
                   || value == .
                   || value == null)
        {
            throw badXMLName(value);
        } else {
            String str = ScriptRuntime.toString(value);
            long test = ScriptRuntime.testUint32String(str);
            if (test >= 0) {
                ScriptRuntime.storeUint32Result(cxtest);
                result = null;
            } else {
                result = toXMLNameFromString(cxstr);
            }
        }
        return result;
    }
    Object addXMLObjects(Context cxXMLObject obj1XMLObject obj2)
    {
        XMLList listToAdd = newXMLList();
        if (obj1 instanceof XMLList) {
            XMLList list1 = (XMLList)obj1;
            if (list1.length() == 1) {
                listToAdd.addToList(list1.item(0));
            } else {
                // Might be xmlFragment + xmlFragment + xmlFragment + ...;
                // then the result will be an XMLList which we want to be an
                // rValue and allow it to be assigned to an lvalue.
                listToAdd = newXMLListFrom(obj1);
            }
        } else {
            listToAdd.addToList(obj1);
        }
        if (obj2 instanceof XMLList) {
            XMLList list2 = (XMLList)obj2;
            for (int i = 0; i < list2.length(); i++) {
                listToAdd.addToList(list2.item(i));
            }
        } else if (obj2 instanceof XML) {
            listToAdd.addToList(obj2);
        }
        return listToAdd;
    }
    private Ref xmlPrimaryReference(Context cxXMLName xmlNameScriptable scope) {
        XMLObjectImpl xmlObj;
        XMLObjectImpl firstXml = null;
        for (;;) {
            // XML object can only present on scope chain as a wrapper
            // of XMLWithScope
            if (scope instanceof XMLWithScope) {
                xmlObj = (XMLObjectImpl)scope.getPrototype();
                if (xmlObj.hasXMLProperty(xmlName)) {
                    break;
                }
                if (firstXml == null) {
                    firstXml = xmlObj;
                }
            }
            scope = scope.getParentScope();
            if (scope == null) {
                xmlObj = firstXml;
                break;
            }
        }
        // xmlObj == null corresponds to undefined as the target of
        // the reference
        if (xmlObj != null) {
            xmlName.initXMLObject(xmlObj);
        }
        return xmlName;
    }
    Namespace castToNamespace(Context cxObject namespaceObj) {
        return this..castToNamespace(namespaceObj);
    }
    private String getDefaultNamespaceURI(Context cx) {
        return getDefaultNamespace(cx).uri();
    }
    Namespace newNamespace(String uri) {
        return this..newNamespace(uri);
    }
        if (cx == null) {
            cx = Context.getCurrentContext();
            if (cx == null) {
                return ;
            }
        }
        Object ns = ScriptRuntime.searchDefaultNamespace(cx);
        if (ns == null) {
            return ;
        } else {
            if (ns instanceof Namespace) {
                return (Namespace)ns;
            } else {
                //    TODO    Clarify or remove the following comment
                // Should not happen but for now it could
                // due to bad searchDefaultNamespace implementation.
                return ;
            }
        }
    }
    Namespace[] createNamespaces(XmlNode.Namespace[] declarations) {
        Namespace[] rv = new Namespace[declarations.length];
        for (int i=0; i<declarations.lengthi++) {
            rv[i] = this..newNamespace(
                    declarations[i].getPrefix(), declarations[i].getUri());
        }
        return rv;
    }
    //    See ECMA357 13.3.2
    QName constructQName(Context cxObject namespaceObject name) {
        return this..constructQName(thiscxnamespacename);
    }
    QName newQName(String uriString localNameString prefix) {
        return this..newQName(thisurilocalNameprefix);
    }
    QName constructQName(Context cxObject nameValue) {
//        return constructQName(cx, Undefined.instance, nameValue);
        return this..constructQName(thiscxnameValue);
    }
    QName castToQName(Context cxObject qnameValue) {
        return this..castToQName(thiscxqnameValue);
    }
    QName newQName(XmlNode.QName qname) {
        return QName.create(thisthis.this.qname);
    }
    XML newXML(XmlNode node) {
        return new XML(thisthis.this.node);
    }
    /* TODO: Can this can be replaced by ecmaToXml below?
     */
    final XML newXMLFromJs(Object inputObject) {
        String frag;
        if (inputObject == null || inputObject == .) {
            frag = "";
        } else if (inputObject instanceof XMLObjectImpl) {
            // todo: faster way for XMLObjects?
            frag = ((XMLObjectImplinputObject).toXMLString();
        } else {
            frag = ScriptRuntime.toString(inputObject);
        }
        if (frag.trim().startsWith("<>")) {
            throw ScriptRuntime.typeError("Invalid use of XML object anonymous tags <></>.");
        }
        if (frag.indexOf("<") == -1) {
            //    Solo text node
            return newXML(XmlNode.createText(frag));
        }
        return parse(frag);
    }
    private XML parse(String frag) {
        try {
            return newXML(XmlNode.createElement(,
                    getDefaultNamespaceURI(Context.getCurrentContext()), frag));
        } catch (SAXException e) {
            throw ScriptRuntime.typeError("Cannot parse XML: " + e.getMessage());
        }
    }
    final XML ecmaToXml(Object object) {
        //    See ECMA357 10.3
        if (object == null || object == .) {
            throw ScriptRuntime.typeError("Cannot convert " + object + " to XML");
        }
        if (object instanceof XMLreturn (XML)object;
        if (object instanceof XMLList) {
            XMLList list = (XMLList)object;
            if (list.getXML() != null) {
                return list.getXML();
            } else {
                throw ScriptRuntime.typeError("Cannot convert list of >1 element to XML");
            }
        }
        //    TODO    Technically we should fail on anything except a String, Number or Boolean
        //            See ECMA357 10.3
        // Extension: if object is a DOM node, use that to construct the XML
        // object.
        if (object instanceof Wrapper) {
            object = ((Wrapperobject).unwrap();
        }
        if (object instanceof org.w3c.dom.Node) {
            org.w3c.dom.Node node = (org.w3c.dom.Nodeobject;
            return newXML(XmlNode.createElementFromNode(node));
        }
        //    Instead we just blindly cast to a String and let them convert anything.
        String s = ScriptRuntime.toString(object);
        //    TODO    Could this get any uglier?
        if (s.length() > 0 && s.charAt(0) == '<') {
            return parse(s);
        } else {
            return newXML(XmlNode.createText(s));
        }
    }
    final XML newTextElementXML(XmlNode referenceXmlNode.QName qnameString value) {
        return newXML(XmlNode.newElementWithText(referenceqnamevalue));
    }
    XMLList newXMLList() {
        return new XMLList(thisthis.this.);
    }
    final XMLList newXMLListFrom(Object inputObject) {
        XMLList rv = newXMLList();
        if (inputObject == null || inputObject instanceof Undefined) {
            return rv;
        } else if (inputObject instanceof XML) {
            XML xml = (XMLinputObject;
            rv.getNodeList().add(xml);
            return rv;
        } else if (inputObject instanceof XMLList) {
            XMLList xmll = (XMLListinputObject;
            rv.getNodeList().add(xmll.getNodeList());
            return rv;
        } else {
            String frag = ScriptRuntime.toString(inputObject).trim();
            if (!frag.startsWith("<>")) {
                frag = "<>" + frag + "</>";
            }
            frag = "<fragment>" + frag.substring(2);
            if (!frag.endsWith("</>")) {
                throw ScriptRuntime.typeError("XML with anonymous tag missing end anonymous tag");
            }
            frag = frag.substring(0, frag.length() - 3) + "</fragment>";
            XML orgXML = newXMLFromJs(frag);
            // Now orphan the children and add them to our XMLList.
            XMLList children = orgXML.children();
            for (int i = 0; i < children.getNodeList().length(); i++) {
                // Copy here is so that they'll be orphaned (parent() will be undefined)
                rv.getNodeList().add(((XMLchildren.item(i).copy()));
            }
            return rv;
        }
    }
    XmlNode.QName toNodeQName(Context cxObject namespaceValueObject nameValue) {
        // This is duplication of constructQName(cx, namespaceValue, nameValue)
        // but for XMLName
        String localName;
        if (nameValue instanceof QName) {
            QName qname = (QName)nameValue;
            localName = qname.localName();
        } else {
            localName = ScriptRuntime.toString(nameValue);
        }
        XmlNode.Namespace ns;
        if (namespaceValue == .) {
            if ("*".equals(localName)) {
                ns = null;
            } else {
                ns = getDefaultNamespace(cx).getDelegate();
            }
        } else if (namespaceValue == null) {
            ns = null;
        } else if (namespaceValue instanceof Namespace) {
            ns = ((Namespace)namespaceValue).getDelegate();
        } else {
            ns = this..constructNamespace(namespaceValue).getDelegate();
        }
        if (localName != null && localName.equals("*")) localName = null;
        return XmlNode.QName.create(nslocalName);
    }
    XmlNode.QName toNodeQName(Context cxString nameboolean attribute) {
        XmlNode.Namespace defaultNamespace = getDefaultNamespace(cx).getDelegate();
        if (name != null && name.equals("*")) {
            return XmlNode.QName.create(nullnull);
        } else {
            if (attribute) {
                return XmlNode.QName.create(..name);
            } else {
                return XmlNode.QName.create(defaultNamespacename);
            }
        }
    }
    /*
        TODO: Too general; this should be split into overloaded methods.
        Is that possible?
     */
    XmlNode.QName toNodeQName(Context cxObject nameValueboolean attribute) {
        if (nameValue instanceof XMLName) {
            return ((XMLName)nameValue).toQname();
        } else if (nameValue instanceof QName) {
            QName qname = (QName)nameValue;
            return qname.getDelegate();
        } else if (
            nameValue instanceof Boolean
            || nameValue instanceof Number
            || nameValue == .
            || nameValue == null
        ) {
            throw badXMLName(nameValue);
        } else {
            String local = null;
            if (nameValue instanceof String) {
                local = (String)nameValue;
            } else {
                local = ScriptRuntime.toString(nameValue);
            }
            return toNodeQName(cxlocalattribute);
        }
    }
    //
    //    Override methods from XMLLib
    //
    @Override
    public boolean isXMLName(Context _cxObject nameObj) {
        return XMLName.accept(nameObj);
    }
    @Override
    public Object toDefaultXmlNamespace(Context cxObject uriValue) {
        return this..constructNamespace(uriValue);
    }
    @Override
    public String escapeTextValue(Object o) {
        return .escapeTextValue(o);
    }
    @Override
    public String escapeAttributeValue(Object o) {
        return .escapeAttributeValue(o);
    }
    @Override
    public Ref nameRef(Context cxObject nameScriptable scopeint memberTypeFlags) {
        if ((memberTypeFlags & .) == 0) {
            // should only be called for cases like @name or @[expr]
            throw Kit.codeBug();
        }
        XMLName xmlName = toAttributeName(cxname);
        return xmlPrimaryReference(cxxmlNamescope);
    }
    @Override
    public Ref nameRef(Context cxObject namespaceObject nameScriptable scopeint memberTypeFlags) {
        XMLName xmlName = XMLName.create(toNodeQName(cxnamespacename), falsefalse);
        //    No idea what is coming in from the parser in this case; is it detecting the "@"?
        if ((memberTypeFlags & .) != 0) {
            if (!xmlName.isAttributeName()) {
                xmlName.setAttributeName();
            }
        }
        return xmlPrimaryReference(cxxmlNamescope);
    }
New to GrepCode? Check out our FAQ X