reorganizing the first level of folders (trunk/branch folders are not the git way :)

11 files changed, 5853 insertions, 0 deletions

diff --git a/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/Namespace.java b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/Namespace.java
new file mode 100644
index 0000000..a4cf585
--- /dev/null
+++ b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/Namespace.java
@@ -0,0 +1,367 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Ethan Hugg
+ *   Terry Lucas
+ *   Milen Nankov
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.xmlimpl;
+
+import org.mozilla.javascript.*;
+
+/**
+ * Class Namespace
+ *
+ */
+class Namespace extends IdScriptableObject
+{
+    static final long serialVersionUID = -5765755238131301744L;
+
+    private static final Object NAMESPACE_TAG = new Object();
+
+    private Namespace prototype;
+    private XmlNode.Namespace ns;
+
+    private Namespace() {
+    }
+
+    static Namespace create(Scriptable scope, Namespace prototype, XmlNode.Namespace namespace) {
+        Namespace rv = new Namespace();
+        rv.setParentScope(scope);
+        rv.prototype = prototype;
+        rv.setPrototype(prototype);
+        rv.ns = namespace;
+        return rv;
+    }
+
+    final XmlNode.Namespace getDelegate() {
+        return ns;
+    }
+
+    public void exportAsJSClass(boolean sealed) {
+        exportAsJSClass(MAX_PROTOTYPE_ID, this.getParentScope(), sealed);
+    }
+
+    public String uri() {
+        return ns.getUri();
+    }
+
+    public String prefix() {
+        return ns.getPrefix();
+    }
+
+    public String toString() {
+        return uri();
+    }
+
+    public String toLocaleString() {
+        return toString();
+    }
+
+    private boolean equals(Namespace n) {
+        return uri().equals(n.uri());
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof Namespace)) return false;
+        return equals((Namespace)obj);
+    }
+
+    protected Object equivalentValues(Object value) {
+        if (!(value instanceof Namespace)) return Scriptable.NOT_FOUND;
+        boolean result = equals((Namespace)value);
+        return result ? Boolean.TRUE : Boolean.FALSE;
+    }
+
+    public String getClassName() {
+        return "Namespace";
+    }
+
+    public Object getDefaultValue(Class hint) {
+        return uri();
+    }
+
+// #string_id_map#
+    private static final int
+        Id_prefix               = 1,
+        Id_uri                  = 2,
+        MAX_INSTANCE_ID         = 2;
+
+    protected int getMaxInstanceId()
+    {
+        return super.getMaxInstanceId() + MAX_INSTANCE_ID;
+    }
+
+    protected int findInstanceIdInfo(String s)
+    {
+        int id;
+// #generated# Last update: 2007-08-20 08:23:22 EDT
+        L0: { id = 0; String X = null;
+            int s_length = s.length();
+            if (s_length==3) { X="uri";id=Id_uri; }
+            else if (s_length==6) { X="prefix";id=Id_prefix; }
+            if (X!=null && X!=s && !X.equals(s)) id = 0;
+            break L0;
+        }
+// #/generated#
+
+        if (id == 0) return super.findInstanceIdInfo(s);
+
+        int attr;
+        switch (id) {
+          case Id_prefix:
+          case Id_uri:
+            attr = PERMANENT | READONLY;
+            break;
+          default: throw new IllegalStateException();
+        }
+        return instanceIdInfo(attr, super.getMaxInstanceId() + id);
+    }
+// #/string_id_map#
+
+    protected String getInstanceIdName(int id)
+    {
+        switch (id - super.getMaxInstanceId()) {
+          case Id_prefix: return "prefix";
+          case Id_uri: return "uri";
+        }
+        return super.getInstanceIdName(id);
+    }
+
+    protected Object getInstanceIdValue(int id)
+    {
+        switch (id - super.getMaxInstanceId()) {
+          case Id_prefix:
+            if (ns.getPrefix() == null) return Undefined.instance;
+            return ns.getPrefix();
+          case Id_uri:
+            return ns.getUri();
+        }
+        return super.getInstanceIdValue(id);
+    }
+
+
+// #string_id_map#
+    private static final int
+        Id_constructor          = 1,
+        Id_toString             = 2,
+        Id_toSource             = 3,
+        MAX_PROTOTYPE_ID        = 3;
+
+    protected int findPrototypeId(String s)
+    {
+        int id;
+// #generated# Last update: 2007-08-20 08:23:22 EDT
+        L0: { id = 0; String X = null; int c;
+            int s_length = s.length();
+            if (s_length==8) {
+                c=s.charAt(3);
+                if (c=='o') { X="toSource";id=Id_toSource; }
+                else if (c=='t') { X="toString";id=Id_toString; }
+            }
+            else if (s_length==11) { X="constructor";id=Id_constructor; }
+            if (X!=null && X!=s && !X.equals(s)) id = 0;
+            break L0;
+        }
+// #/generated#
+        return id;
+    }
+// #/string_id_map#
+
+    protected void initPrototypeId(int id)
+    {
+        String s;
+        int arity;
+        switch (id) {
+          case Id_constructor: arity=2; s="constructor"; break;
+          case Id_toString:    arity=0; s="toString";    break;
+          case Id_toSource:    arity=0; s="toSource";    break;
+          default: throw new IllegalArgumentException(String.valueOf(id));
+        }
+        initPrototypeMethod(NAMESPACE_TAG, id, s, arity);
+    }
+
+    public Object execIdCall(IdFunctionObject f,
+                             Context cx,
+                             Scriptable scope,
+                             Scriptable thisObj,
+                             Object[] args)
+    {
+        if (!f.hasTag(NAMESPACE_TAG)) {
+            return super.execIdCall(f, cx, scope, thisObj, args);
+        }
+        int id = f.methodId();
+        switch (id) {
+          case Id_constructor:
+            return jsConstructor(cx, (thisObj == null), args);
+          case Id_toString:
+            return realThis(thisObj, f).toString();
+          case Id_toSource:
+            return realThis(thisObj, f).js_toSource();
+        }
+        throw new IllegalArgumentException(String.valueOf(id));
+    }
+
+    private Namespace realThis(Scriptable thisObj, IdFunctionObject f) {
+        if(!(thisObj instanceof Namespace))
+            throw incompatibleCallError(f);
+        return (Namespace)thisObj;
+    }
+
+    Namespace newNamespace(String uri) {
+        Namespace prototype = (this.prototype == null) ? this : this.prototype;
+        return create( this.getParentScope(), prototype, XmlNode.Namespace.create(uri) );
+    }
+
+    Namespace newNamespace(String prefix, String uri) {
+        if (prefix == null) return newNamespace(uri);
+        Namespace prototype = (this.prototype == null) ? this : this.prototype;
+        return create( this.getParentScope(), prototype, XmlNode.Namespace.create(prefix, uri) );
+    }
+
+    Namespace constructNamespace(Object uriValue) {
+        String prefix;
+        String uri;
+
+        if (uriValue instanceof Namespace) {
+            Namespace ns = (Namespace)uriValue;
+            prefix = ns.prefix();
+            uri = ns.uri();
+        } else if (uriValue instanceof QName) {
+            QName qname = (QName)uriValue;
+            uri = qname.uri();
+            if (uri != null) {
+                //    TODO    Is there a way to push this back into QName so that we can make prefix() private?
+                prefix = qname.prefix();
+            } else {
+                uri = qname.toString();
+                prefix = null;
+            }
+        } else {
+            uri = ScriptRuntime.toString(uriValue);
+            prefix = (uri.length() == 0) ? "" : null;
+        }
+
+        return newNamespace(prefix, uri);
+    }
+
+    Namespace castToNamespace(Object namespaceObj) {
+        if (namespaceObj instanceof Namespace) {
+            return (Namespace)namespaceObj;
+        }
+        return constructNamespace(namespaceObj);
+    }
+
+    private Namespace constructNamespace(Object prefixValue, Object uriValue) {
+        String prefix;
+        String uri;
+
+        if (uriValue instanceof QName) {
+            QName qname = (QName)uriValue;
+            uri = qname.uri();
+            if (uri == null) {
+                uri = qname.toString();
+            }
+        } else {
+            uri = ScriptRuntime.toString(uriValue);
+        }
+
+        if (uri.length() == 0) {
+            if (prefixValue == Undefined.instance) {
+                prefix = "";
+            } else {
+                prefix = ScriptRuntime.toString(prefixValue);
+                if (prefix.length() != 0) {
+                    throw ScriptRuntime.typeError(
+                        "Illegal prefix '"+prefix+"' for 'no namespace'.");
+                }
+            }
+        } else if (prefixValue == Undefined.instance) {
+            prefix = "";
+        } else if (!XMLName.accept(prefixValue)) {
+            prefix = "";
+        } else {
+            prefix = ScriptRuntime.toString(prefixValue);
+        }
+
+        return newNamespace(prefix, uri);
+    }
+
+    private Namespace constructNamespace() {
+        return newNamespace("", "");
+    }
+
+    private Object jsConstructor(Context cx, boolean inNewExpr, Object[] args)
+    {
+        if (!inNewExpr && args.length == 1) {
+            return castToNamespace(args[0]);
+        }
+
+        if (args.length == 0) {
+            return constructNamespace();
+        } else if (args.length == 1) {
+            return constructNamespace(args[0]);
+        } else {
+            return constructNamespace(args[0], args[1]);
+        }
+    }
+
+    private String js_toSource()
+    {
+        StringBuffer sb = new StringBuffer();
+        sb.append('(');
+        toSourceImpl(ns.getPrefix(), ns.getUri(), sb);
+        sb.append(')');
+        return sb.toString();
+    }
+
+    static void toSourceImpl(String prefix, String uri, StringBuffer sb)
+    {
+        sb.append("new Namespace(");
+        if (uri.length() == 0) {
+            if (!"".equals(prefix)) throw new IllegalArgumentException(prefix);
+        } else {
+            sb.append('\'');
+            if (prefix != null) {
+                sb.append(ScriptRuntime.escapeString(prefix, '\''));
+                sb.append("', '");
+            }
+            sb.append(ScriptRuntime.escapeString(uri, '\''));
+            sb.append('\'');
+        }
+        sb.append(')');
+    }
+}
diff --git a/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/QName.java b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/QName.java
new file mode 100644
index 0000000..90a18cb
--- /dev/null
+++ b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/QName.java
@@ -0,0 +1,381 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Ethan Hugg
+ *   Terry Lucas
+ *   Milen Nankov
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.xmlimpl;
+
+import org.mozilla.javascript.*;
+
+/**
+ * Class QName
+ *
+ */
+final class QName extends IdScriptableObject
+{
+    static final long serialVersionUID = 416745167693026750L;
+
+    private static final Object QNAME_TAG = new Object();
+
+    private XMLLibImpl lib;
+
+    private QName prototype;
+
+    private XmlNode.QName delegate;
+
+    private QName() {
+    }
+
+    static QName create(XMLLibImpl lib, Scriptable scope, QName prototype, XmlNode.QName delegate) {
+        QName rv = new QName();
+        rv.lib = lib;
+        rv.setParentScope(scope);
+        rv.prototype = prototype;
+        rv.setPrototype(prototype);
+        rv.delegate = delegate;
+        return rv;
+    }
+
+//    /** @deprecated */
+//    static QName create(XMLLibImpl lib, XmlNode.QName nodeQname) {
+//        return create(lib, lib.globalScope(), lib.qnamePrototype(), nodeQname);
+//    }
+
+    void exportAsJSClass(boolean sealed) {
+        exportAsJSClass(MAX_PROTOTYPE_ID, getParentScope(), sealed);
+    }
+
+    public String toString() {
+        //    ECMA357 13.3.4.2
+        if (delegate.getNamespace() == null) {
+            return "*::" + localName();
+        } else if (delegate.getNamespace().isGlobal()) {
+            //    leave as empty
+            return localName();
+        } else {
+            return uri() + "::" + localName();
+        }
+    }
+
+    public String localName() {
+        if (delegate.getLocalName() == null) return "*";
+        return delegate.getLocalName();
+    }
+
+    /**
+        @deprecated
+
+        This property is supposed to be invisible and I think we can make it private at some point, though Namespace
+        might need it
+    */
+    String prefix() {
+        if (delegate.getNamespace() == null) return null;
+        return delegate.getNamespace().getPrefix();
+    }
+
+    String uri() {
+        if (delegate.getNamespace() == null) return null;
+        return delegate.getNamespace().getUri();
+    }
+
+    /** @deprecated */
+    final XmlNode.QName toNodeQname() {
+        return delegate;
+    }
+
+    final XmlNode.QName getDelegate() {
+        return delegate;
+    }
+
+    public boolean equals(Object obj) {
+        if(!(obj instanceof QName)) return false;
+        return equals((QName)obj);
+    }
+
+    protected Object equivalentValues(Object value)
+    {
+        if(!(value instanceof QName)) return Scriptable.NOT_FOUND;
+        boolean result = equals((QName)value);
+        return result ? Boolean.TRUE : Boolean.FALSE;
+    }
+
+    private boolean equals(QName q) {
+        return this.delegate.isEqualTo(q.delegate);
+    }
+
+    public String getClassName() {
+        return "QName";
+    }
+
+    public Object getDefaultValue(Class hint) {
+        return toString();
+    }
+
+// #string_id_map#
+    private static final int
+        Id_localName            = 1,
+        Id_uri                  = 2,
+        MAX_INSTANCE_ID         = 2;
+
+    protected int getMaxInstanceId()
+    {
+        return super.getMaxInstanceId() + MAX_INSTANCE_ID;
+    }
+
+    protected int findInstanceIdInfo(String s)
+    {
+        int id;
+// #generated# Last update: 2007-08-20 08:21:41 EDT
+        L0: { id = 0; String X = null;
+            int s_length = s.length();
+            if (s_length==3) { X="uri";id=Id_uri; }
+            else if (s_length==9) { X="localName";id=Id_localName; }
+            if (X!=null && X!=s && !X.equals(s)) id = 0;
+            break L0;
+        }
+// #/generated#
+
+        if (id == 0) return super.findInstanceIdInfo(s);
+
+        int attr;
+        switch (id) {
+          case Id_localName:
+          case Id_uri:
+            attr = PERMANENT | READONLY;
+            break;
+          default: throw new IllegalStateException();
+        }
+        return instanceIdInfo(attr, super.getMaxInstanceId() + id);
+    }
+// #/string_id_map#
+
+    protected String getInstanceIdName(int id)
+    {
+        switch (id - super.getMaxInstanceId()) {
+          case Id_localName: return "localName";
+          case Id_uri: return "uri";
+        }
+        return super.getInstanceIdName(id);
+    }
+
+    protected Object getInstanceIdValue(int id)
+    {
+        switch (id - super.getMaxInstanceId()) {
+          case Id_localName: return localName();
+          case Id_uri: return uri();
+        }
+        return super.getInstanceIdValue(id);
+    }
+
+// #string_id_map#
+    private static final int
+        Id_constructor          = 1,
+        Id_toString             = 2,
+        Id_toSource             = 3,
+        MAX_PROTOTYPE_ID        = 3;
+
+    protected int findPrototypeId(String s)
+    {
+        int id;
+// #generated# Last update: 2007-08-20 08:21:41 EDT
+        L0: { id = 0; String X = null; int c;
+            int s_length = s.length();
+            if (s_length==8) {
+                c=s.charAt(3);
+                if (c=='o') { X="toSource";id=Id_toSource; }
+                else if (c=='t') { X="toString";id=Id_toString; }
+            }
+            else if (s_length==11) { X="constructor";id=Id_constructor; }
+            if (X!=null && X!=s && !X.equals(s)) id = 0;
+            break L0;
+        }
+// #/generated#
+        return id;
+    }
+// #/string_id_map#
+
+    protected void initPrototypeId(int id)
+    {
+        String s;
+        int arity;
+        switch (id) {
+          case Id_constructor: arity=2; s="constructor"; break;
+          case Id_toString:    arity=0; s="toString";    break;
+          case Id_toSource:    arity=0; s="toSource";    break;
+          default: throw new IllegalArgumentException(String.valueOf(id));
+        }
+        initPrototypeMethod(QNAME_TAG, id, s, arity);
+    }
+
+    public Object execIdCall(IdFunctionObject f,
+                             Context cx,
+                             Scriptable scope,
+                             Scriptable thisObj,
+                             Object[] args)
+    {
+        if (!f.hasTag(QNAME_TAG)) {
+            return super.execIdCall(f, cx, scope, thisObj, args);
+        }
+        int id = f.methodId();
+        switch (id) {
+          case Id_constructor:
+            return jsConstructor(cx, (thisObj == null), args);
+          case Id_toString:
+            return realThis(thisObj, f).toString();
+          case Id_toSource:
+            return realThis(thisObj, f).js_toSource();
+        }
+        throw new IllegalArgumentException(String.valueOf(id));
+    }
+
+    private QName realThis(Scriptable thisObj, IdFunctionObject f)
+    {
+        if(!(thisObj instanceof QName))
+            throw incompatibleCallError(f);
+        return (QName)thisObj;
+    }
+
+    QName newQName(XMLLibImpl lib, String q_uri, String q_localName, String q_prefix) {
+        QName prototype = this.prototype;
+        if (prototype == null) {
+            prototype = this;
+        }
+        XmlNode.Namespace ns = null;
+        if (q_prefix != null) {
+            ns = XmlNode.Namespace.create(q_uri, q_prefix);
+        } else if (q_uri != null) {
+            ns = XmlNode.Namespace.create(q_uri);
+        } else {
+            ns = null;
+        }
+        if (q_localName != null && q_localName.equals("*")) q_localName = null;
+        return create(lib, this.getParentScope(), prototype, XmlNode.QName.create(ns, q_localName));
+    }
+
+    //    See ECMA357 13.3.2
+    QName constructQName(XMLLibImpl lib, Context cx, Object namespace, Object name) {
+        String nameString = null;
+        if (name instanceof QName) {
+            if (namespace == Undefined.instance) {
+                return (QName)name;
+            } else {
+                nameString = ((QName)name).localName();
+            }
+        }
+        if (name == Undefined.instance) {
+            nameString = "";
+        } else {
+            nameString = ScriptRuntime.toString(name);
+        }
+
+        if (namespace == Undefined.instance) {
+            if ("*".equals(nameString)) {
+                namespace = null;
+            } else {
+                namespace = lib.getDefaultNamespace(cx);
+            }
+        }
+        Namespace namespaceNamespace = null;
+        if (namespace == null) {
+            //    leave as null
+        } else if (namespace instanceof Namespace) {
+            namespaceNamespace = (Namespace)namespace;
+        } else {
+            namespaceNamespace = lib.newNamespace(ScriptRuntime.toString(namespace));
+        }
+        String q_localName = nameString;
+        String q_uri;
+        String q_prefix;
+        if (namespace == null) {
+            q_uri = null;
+            q_prefix = null;    //    corresponds to undefined; see QName class
+        } else {
+            q_uri = namespaceNamespace.uri();
+            q_prefix = namespaceNamespace.prefix();
+        }
+        return newQName(lib, q_uri, q_localName, q_prefix);
+    }
+
+    QName constructQName(XMLLibImpl lib, Context cx, Object nameValue) {
+        return constructQName(lib, cx, Undefined.instance, nameValue);
+    }
+
+    QName castToQName(XMLLibImpl lib, Context cx, Object qnameValue) {
+        if (qnameValue instanceof QName) {
+            return (QName)qnameValue;
+        }
+        return constructQName(lib, cx, qnameValue);
+    }
+
+    private Object jsConstructor(Context cx, boolean inNewExpr, Object[] args) {
+        //    See ECMA357 13.3.2
+        if (!inNewExpr && args.length == 1) {
+            return castToQName(lib, cx, args[0]);
+        }
+        if (args.length == 0) {
+            return constructQName(lib, cx, Undefined.instance);
+        } else if (args.length == 1) {
+            return constructQName(lib, cx, args[0]);
+        } else {
+            return constructQName(lib, cx, args[0], args[1]);
+        }
+    }
+
+    private String js_toSource() {
+        StringBuffer sb = new StringBuffer();
+        sb.append('(');
+        toSourceImpl(uri(), localName(), prefix(), sb);
+        sb.append(')');
+        return sb.toString();
+    }
+
+    private static void toSourceImpl(String uri, String localName, String prefix, StringBuffer sb) {
+        sb.append("new QName(");
+        if (uri == null && prefix == null) {
+            if (!"*".equals(localName)) {
+                sb.append("null, ");
+            }
+        } else {
+            Namespace.toSourceImpl(prefix, uri, sb);
+            sb.append(", ");
+        }
+        sb.append('\'');
+        sb.append(ScriptRuntime.escapeString(localName, '\''));
+        sb.append("')");
+    }
+}
diff --git a/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XML.java b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XML.java
new file mode 100644
index 0000000..090ae1a
--- /dev/null
+++ b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XML.java
@@ -0,0 +1,734 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Ethan Hugg
+ *   Terry Lucas
+ *   Milen Nankov
+ *   David P. Caldwell <inonit@inonit.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.xmlimpl;
+
+import org.mozilla.javascript.*;
+import org.mozilla.javascript.xml.XMLObject;
+
+class XML extends XMLObjectImpl {
+    static final long serialVersionUID = -630969919086449092L;
+
+    private XmlNode node;
+
+    XML(XMLLibImpl lib, Scriptable scope, XMLObject prototype, XmlNode node) {
+      super(lib, scope, prototype);
+      initialize(node);
+    }
+
+    void initialize(XmlNode node) {
+        this.node = node;
+        this.node.setXml(this);
+    }
+
+    final XML getXML() {
+        return this;
+    }
+
+    void replaceWith(XML value) {
+        //    We use the underlying document structure if the node is not
+        //    "standalone," but we need to just replace the XmlNode instance
+        //    otherwise
+        if (this.node.parent() != null || false) {
+            this.node.replaceWith(value.node);
+        } else {
+            this.initialize(value.node);
+        }
+    }
+
+    /** @deprecated I would love to encapsulate this somehow. */
+    XML makeXmlFromString(XMLName name, String value) {
+        try {
+            return newTextElementXML(this.node, name.toQname(), value.toString());
+        } catch(Exception e) {
+            throw ScriptRuntime.typeError(e.getMessage());
+        }
+    }
+
+    /** @deprecated Rename this, at the very least.  But it's not clear it's even necessary */
+    XmlNode getAnnotation() {
+        return node;
+    }
+
+    //
+    //  Methods from ScriptableObject
+    //
+
+    //    TODO Either cross-reference this next comment with the specification or delete it and change the behavior
+    //    The comment: XML[0] should return this, all other indexes are Undefined
+    public Object get(int index, Scriptable start) {
+        if (index == 0) {
+            return this;
+        } else {
+            return Scriptable.NOT_FOUND;
+        }
+    }
+
+    public boolean has(int index, Scriptable start) {
+        return (index == 0);
+    }
+
+    public void put(int index, Scriptable start, Object value) {
+        //    TODO    Clarify the following comment and add a reference to the spec
+        //    The comment: Spec says assignment to indexed XML object should return type error
+        throw ScriptRuntime.typeError("Assignment to indexed XML is not allowed");
+    }
+
+    public Object[] getIds() {
+        if (isPrototype()) {
+            return new Object[0];
+        } else {
+            return new Object[] { new Integer(0) };
+        }
+    }
+
+    //    TODO    This is how I found it but I am not sure it makes sense
+    public void delete(int index) {
+        if (index == 0) {
+            this.remove();
+        }
+    }
+
+    //
+    //    Methods from XMLObjectImpl
+    //
+
+    boolean hasXMLProperty(XMLName xmlName) {
+        if (isPrototype()) {
+            return getMethod(xmlName.localName()) != NOT_FOUND;
+        } else {
+            return (getPropertyList(xmlName).length() > 0) || (getMethod(xmlName.localName()) != NOT_FOUND);
+        }
+    }
+
+    Object getXMLProperty(XMLName xmlName) {
+        if (isPrototype()) {
+            return getMethod(xmlName.localName());
+        } else {
+            return getPropertyList(xmlName);
+        }
+    }
+
+    //
+    //
+    //    Methods that merit further review
+    //
+    //
+
+    XmlNode.QName getNodeQname() {
+        return this.node.getQname();
+    }
+
+    XML[] getChildren() {
+        if (!isElement()) return null;
+        XmlNode[] children = this.node.getMatchingChildren(XmlNode.Filter.TRUE);
+        XML[] rv = new XML[children.length];
+        for (int i=0; i<rv.length; i++) {
+            rv[i] = toXML(children[i]);
+        }
+        return rv;
+    }
+
+    XML[] getAttributes() {
+        XmlNode[] attributes = this.node.getAttributes();
+        XML[] rv = new XML[attributes.length];
+        for (int i=0; i<rv.length; i++) {
+            rv[i] = toXML(attributes[i]);
+        }
+        return rv;
+    }
+
+    //    Used only by XML, XMLList
+    XMLList getPropertyList(XMLName name) {
+        return name.getMyValueOn(this);
+    }
+
+    void deleteXMLProperty(XMLName name) {
+        XMLList list = getPropertyList(name);
+        for (int i=0; i<list.length(); i++) {
+            list.item(i).node.deleteMe();
+        }
+    }
+
+    void putXMLProperty(XMLName xmlName, Object value) {
+        if (isPrototype()) {
+            //    TODO    Is this really a no-op?  Check the spec to be sure
+        } else {
+            xmlName.setMyValueOn(this, value);
+        }
+    }
+
+    boolean hasOwnProperty(XMLName xmlName) {
+        boolean hasProperty = false;
+
+        if (isPrototype()) {
+            String property = xmlName.localName();
+            hasProperty = (0 != findPrototypeId(property));
+        } else {
+            hasProperty = (getPropertyList(xmlName).length() > 0);
+        }
+
+        return hasProperty;
+    }
+
+    protected Object jsConstructor(Context cx, boolean inNewExpr, Object[] args) {
+        if (args.length == 0 || args[0] == null || args[0] == Undefined.instance) {
+            args = new Object[] { "" };
+        }
+        //    ECMA 13.4.2 does not appear to specify what to do if multiple arguments are sent.
+        XML toXml = ecmaToXml(args[0]);
+        if (inNewExpr) {
+            return toXml.copy();
+        } else {
+            return toXml;
+        }
+    }
+
+    //    See ECMA 357, 11_2_2_1, Semantics, 3_f.
+    public Scriptable getExtraMethodSource(Context cx) {
+        if (hasSimpleContent()) {
+            String src = toString();
+            return ScriptRuntime.toObjectOrNull(cx, src);
+        }
+        return null;
+    }
+
+    //
+    //    TODO    Miscellaneous methods not yet grouped
+    //
+
+    void removeChild(int index) {
+        this.node.removeChild(index);
+    }
+
+    void normalize() {
+        this.node.normalize();
+    }
+
+    private XML toXML(XmlNode node) {
+        if (node.getXml() == null) {
+            node.setXml(newXML(node));
+        }
+        return node.getXml();
+    }
+
+    void setAttribute(XMLName xmlName, Object value) {
+        if (!isElement()) throw new IllegalStateException("Can only set attributes on elements.");
+        //    TODO    Is this legal, but just not "supported"?  If so, support it.
+        if (xmlName.uri() == null && xmlName.localName().equals("*")) {
+            throw ScriptRuntime.typeError("@* assignment not supported.");
+        }
+        this.node.setAttribute(xmlName.toQname(), ScriptRuntime.toString(value));
+    }
+
+    void remove() {
+        this.node.deleteMe();
+    }
+
+    void addMatches(XMLList rv, XMLName name) {
+        name.addMatches(rv, this);
+    }
+
+    XMLList elements(XMLName name) {
+        XMLList rv = newXMLList();
+        rv.setTargets(this, name.toQname());
+        //    TODO    Should have an XMLNode.Filter implementation based on XMLName
+        XmlNode[] elements = this.node.getMatchingChildren(XmlNode.Filter.ELEMENT);
+        for (int i=0; i<elements.length; i++) {
+            if (name.matches( toXML(elements[i]) )) {
+                rv.addToList( toXML(elements[i]) );
+            }
+        }
+        return rv;
+    }
+
+    XMLList child(XMLName xmlName) {
+        //    TODO    Right now I think this method would allow child( "@xxx" ) to return the xxx attribute, which is wrong
+
+        XMLList rv = newXMLList();
+
+        //    TODO    Should this also match processing instructions?  If so, we have to change the filter and also the XMLName
+        //            class to add an acceptsProcessingInstruction() method
+
+        XmlNode[] elements = this.node.getMatchingChildren(XmlNode.Filter.ELEMENT);
+        for (int i=0; i<elements.length; i++) {
+            if (xmlName.matchesElement(elements[i].getQname())) {
+                rv.addToList( toXML(elements[i]) );
+            }
+        }
+        rv.setTargets(this, xmlName.toQname());
+        return rv;
+    }
+
+    XML replace(XMLName xmlName, Object xml) {
+        putXMLProperty(xmlName, xml);
+        return this;
+    }
+
+    XMLList children() {
+        XMLList rv = newXMLList();
+        XMLName all = XMLName.formStar();
+        rv.setTargets(this, all.toQname());
+        XmlNode[] children = this.node.getMatchingChildren(XmlNode.Filter.TRUE);
+        for (int i=0; i<children.length; i++) {
+            rv.addToList( toXML(children[i]) );
+        }
+        return rv;
+    }
+
+    XMLList child(int index) {
+        //    ECMA357 13.4.4.6 (numeric case)
+        XMLList result = newXMLList();
+        result.setTargets(this, null);
+        if (index >= 0 && index < this.node.getChildCount()) {
+            result.addToList(getXmlChild(index));
+        }
+        return result;
+    }
+
+    XML getXmlChild(int index) {
+        XmlNode child = this.node.getChild(index);
+        if (child.getXml() == null) {
+            child.setXml(newXML(child));
+        }
+        return child.getXml();
+    }
+
+    int childIndex() {
+        return this.node.getChildIndex();
+    }
+
+    boolean contains(Object xml) {
+        if (xml instanceof XML) {
+            return equivalentXml(xml);
+        } else {
+            return false;
+        }
+    }
+
+    //    Method overriding XMLObjectImpl
+    boolean equivalentXml(Object target) {
+        boolean result = false;
+
+        if (target instanceof XML) {
+            //    TODO    This is a horrifyingly inefficient way to do this so we should make it better.  It may also not work.
+            return this.node.toXmlString(getProcessor()).equals( ((XML)target).node.toXmlString(getProcessor()) );
+        } else if (target instanceof XMLList) {
+            //    TODO    Is this right?  Check the spec ...
+            XMLList otherList = (XMLList) target;
+
+            if (otherList.length() == 1) {
+                result = equivalentXml(otherList.getXML());
+            }
+        } else if (hasSimpleContent()) {
+            String otherStr = ScriptRuntime.toString(target);
+
+            result = toString().equals(otherStr);
+        }
+
+        return result;
+    }
+
+    XMLObjectImpl copy() {
+        return newXML( this.node.copy() );
+    }
+
+    boolean hasSimpleContent() {
+        if (isComment() || isProcessingInstruction()) return false;
+        if (isText() || this.node.isAttributeType()) return true;
+        return !this.node.hasChildElement();
+    }
+
+    boolean hasComplexContent() {
+        return !hasSimpleContent();
+    }
+
+    //    TODO Cross-reference comment below with spec
+    //    Comment is: Length of an XML object is always 1, it's a list of XML objects of size 1.
+    int length() {
+        return 1;
+    }
+
+    //    TODO    it is not clear what this method was for ...
+    boolean is(XML other) {
+        return this.node.isSameNode(other.node);
+    }
+
+    Object nodeKind() {
+        return ecmaClass();
+    }
+
+    Object parent() {
+        XmlNode parent = this.node.parent();
+        if (parent == null) return null;
+        return newXML(this.node.parent());
+    }
+
+    boolean propertyIsEnumerable(Object name)
+    {
+        boolean result;
+        if (name instanceof Integer) {
+            result = (((Integer)name).intValue() == 0);
+        } else if (name instanceof Number) {
+            double x = ((Number)name).doubleValue();
+            // Check that number is positive 0
+            result = (x == 0.0 && 1.0 / x > 0);
+        } else {
+            result = ScriptRuntime.toString(name).equals("0");
+        }
+        return result;
+    }
+
+    Object valueOf() {
+        return this;
+    }
+
+    //
+    //    Selection of children
+    //
+
+    XMLList comments() {
+        XMLList rv = newXMLList();
+        this.node.addMatchingChildren(rv, XmlNode.Filter.COMMENT);
+        return rv;
+    }
+
+    XMLList text() {
+        XMLList rv = newXMLList();
+        this.node.addMatchingChildren(rv, XmlNode.Filter.TEXT);
+        return rv;
+    }
+
+    XMLList processingInstructions(XMLName xmlName) {
+        XMLList rv = newXMLList();
+        this.node.addMatchingChildren(rv, XmlNode.Filter.PROCESSING_INSTRUCTION(xmlName));
+        return rv;
+    }
+
+    //
+    //    Methods relating to modification of child nodes
+    //
+
+    //    We create all the nodes we are inserting before doing the insert to
+    //    avoid nasty cycles caused by mutability of these objects.  For example,
+    //    what if the toString() method of value modifies the XML object we were
+    //    going to insert into?  insertAfter might get confused about where to
+    //    insert.  This actually came up with SpiderMonkey, leading to a (very)
+    //    long discussion.  See bug #354145.
+    private XmlNode[] getNodesForInsert(Object value) {
+        if (value instanceof XML) {
+            return new XmlNode[] { ((XML)value).node };
+        } else if (value instanceof XMLList) {
+            XMLList list = (XMLList)value;
+            XmlNode[] rv = new XmlNode[list.length()];
+            for (int i=0; i<list.length(); i++) {
+                rv[i] = list.item(i).node;
+            }
+            return rv;
+        } else {
+            return new XmlNode[] {
+                XmlNode.createText(getProcessor(), ScriptRuntime.toString(value))
+            };
+        }
+    }
+
+    XML replace(int index, Object xml) {
+        XMLList xlChildToReplace = child(index);
+        if (xlChildToReplace.length() > 0) {
+            // One exists an that index
+            XML childToReplace = xlChildToReplace.item(0);
+            insertChildAfter(childToReplace, xml);
+            removeChild(index);
+        }
+        return this;
+    }
+
+    XML prependChild(Object xml) {
+        if (this.node.isParentType()) {
+            this.node.insertChildrenAt(0, getNodesForInsert(xml));
+        }
+        return this;
+    }
+
+    XML appendChild(Object xml) {
+        if (this.node.isParentType()) {
+            XmlNode[] nodes = getNodesForInsert(xml);
+            this.node.insertChildrenAt(this.node.getChildCount(), nodes);
+        }
+        return this;
+    }
+
+    private int getChildIndexOf(XML child) {
+        for (int i=0; i<this.node.getChildCount(); i++) {
+            if (this.node.getChild(i).isSameNode(child.node)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    XML insertChildBefore(XML child, Object xml) {
+        if (child == null) {
+            // Spec says inserting before nothing is the same as appending
+            appendChild(xml);
+        } else {
+            XmlNode[] toInsert = getNodesForInsert(xml);
+            int index = getChildIndexOf(child);
+            if (index != -1) {
+                this.node.insertChildrenAt(index, toInsert);
+            }
+        }
+
+        return this;
+    }
+
+    XML insertChildAfter(XML child, Object xml) {
+        if (child == null) {
+            // Spec says inserting after nothing is the same as prepending
+            prependChild(xml);
+        } else {
+            XmlNode[] toInsert = getNodesForInsert(xml);
+            int index = getChildIndexOf(child);
+            if (index != -1) {
+                this.node.insertChildrenAt(index+1, toInsert);
+            }
+        }
+
+        return this;
+    }
+
+    XML setChildren(Object xml) {
+        //    TODO    Have not carefully considered the spec but it seems to call for this
+        if (!isElement()) return this;
+
+        while(this.node.getChildCount() > 0) {
+            this.node.removeChild(0);
+        }
+        XmlNode[] toInsert = getNodesForInsert(xml);
+        // append new children
+        this.node.insertChildrenAt(0, toInsert);
+
+        return this;
+    }
+
+    //
+    //    Name and namespace-related methods
+    //
+
+    private void addInScopeNamespace(Namespace ns) {
+        if (!isElement()) {
+            return;
+        }
+        //    See ECMA357 9.1.1.13
+        //    in this implementation null prefix means ECMA undefined
+        if (ns.prefix() != null) {
+            if (ns.prefix().length() == 0 && ns.uri().length() == 0) {
+                return;
+            }
+            if (node.getQname().getNamespace().getPrefix().equals(ns.prefix())) {
+                node.invalidateNamespacePrefix();
+            }
+            node.declareNamespace(ns.prefix(), ns.uri());
+        } else {
+            return;
+        }
+    }
+
+    Namespace[] inScopeNamespaces() {
+        XmlNode.Namespace[] inScope = this.node.getInScopeNamespaces();
+        return createNamespaces(inScope);
+    }
+
+    private XmlNode.Namespace adapt(Namespace ns) {
+        if (ns.prefix() == null) {
+            return XmlNode.Namespace.create(ns.uri());
+        } else {
+            return XmlNode.Namespace.create(ns.prefix(), ns.uri());
+        }
+    }
+
+    XML removeNamespace(Namespace ns) {
+        if (!isElement()) return this;
+        this.node.removeNamespace(adapt(ns));
+        return this;
+    }
+
+    XML addNamespace(Namespace ns) {
+        addInScopeNamespace(ns);
+        return this;
+    }
+
+    QName name() {
+        if (isText() || isComment()) return null;
+        if (isProcessingInstruction()) return newQName("", this.node.getQname().getLocalName(), null);
+        return newQName(node.getQname());
+    }
+
+    Namespace[] namespaceDeclarations() {
+        XmlNode.Namespace[] declarations = node.getNamespaceDeclarations();
+        return createNamespaces(declarations);
+    }
+
+    Namespace namespace(String prefix) {
+        if (prefix == null) {
+            return createNamespace( this.node.getNamespaceDeclaration() );
+        } else {
+            return createNamespace( this.node.getNamespaceDeclaration(prefix) );
+        }
+    }
+
+    String localName() {
+        if (name() == null) return null;
+        return name().localName();
+    }
+
+    void setLocalName(String localName) {
+        //    ECMA357 13.4.4.34
+        if (isText() || isComment()) return;
+        this.node.setLocalName(localName);
+    }
+
+    void setName(QName name) {
+        //    See ECMA357 13.4.4.35
+        if (isText() || isComment()) return;
+        if (isProcessingInstruction()) {
+            //    Spec says set the name URI to empty string and then set the [[Name]] property, but I understand this to do the same
+            //    thing, unless we allow colons in processing instruction targets, which I think we do not.
+            this.node.setLocalName(name.localName());
+            return;
+        }
+        node.renameNode(name.getDelegate());
+    }
+
+    void setNamespace(Namespace ns) {
+        //    See ECMA357 13.4.4.36
+        if (isText() || isComment() || isProcessingInstruction()) return;
+        setName(newQName(ns.uri(), localName(), ns.prefix()));
+    }
+
+    final String ecmaClass() {
+        //    See ECMA357 9.1
+
+        //    TODO    See ECMA357 9.1.1 last paragraph for what defaults should be
+
+        if (node.isTextType()) {
+            return "text";
+        } else if (node.isAttributeType()) {
+            return "attribute";
+        } else if (node.isCommentType()) {
+            return "comment";
+        } else if (node.isProcessingInstructionType()) {
+            return "processing-instruction";
+        } else if (node.isElementType()) {
+            return "element";
+        } else {
+            throw new RuntimeException("Unrecognized type: " + node);
+        }
+    }
+
+    public String getClassName() {
+        //    TODO:    This appears to confuse the interpreter if we use the "real" class property from ECMA.  Otherwise this code
+        //    would be:
+        //    return ecmaClass();
+        return "XML";
+    }
+
+    private String ecmaValue() {
+        return node.ecmaValue();
+    }
+
+    private String ecmaToString() {
+        //    See ECMA357 10.1.1
+        if (isAttribute() || isText()) {
+            return ecmaValue();
+        }
+        if (this.hasSimpleContent()) {
+            StringBuffer rv = new StringBuffer();
+            for (int i=0; i < this.node.getChildCount(); i++) {
+                XmlNode child = this.node.getChild(i);
+                if (!child.isProcessingInstructionType() &&
+                    !child.isCommentType())
+                {
+                    // TODO: Probably inefficient; taking clean non-optimized
+                    // solution for now
+                    XML x = new XML(getLib(), getParentScope(),
+                                    (XMLObject)getPrototype(), child);
+                    rv.append(x.toString());
+                }
+            }
+            return rv.toString();
+        }
+        return toXMLString();
+    }
+
+    public String toString() {
+        return ecmaToString();
+    }
+
+    String toXMLString() {
+        return this.node.ecmaToXMLString(getProcessor());
+    }
+
+    final boolean isAttribute() {
+        return node.isAttributeType();
+    }
+
+    final boolean isComment() {
+        return node.isCommentType();
+    }
+
+    final boolean isText() {
+        return node.isTextType();
+    }
+
+    final boolean isElement() {
+        return node.isElementType();
+    }
+
+    final boolean isProcessingInstruction() {
+        return node.isProcessingInstructionType();
+    }
+
+    //    Support experimental Java interface
+    org.w3c.dom.Node toDomNode() {
+        return node.toDomNode();
+    }
+}
diff --git a/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLCtor.java b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLCtor.java
new file mode 100644
index 0000000..fac8773
--- /dev/null
+++ b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLCtor.java
@@ -0,0 +1,280 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *   David P. Caldwell <inonit@inonit.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.xmlimpl;
+
+import org.mozilla.javascript.*;
+
+class XMLCtor extends IdFunctionObject
+{
+    static final long serialVersionUID = -8708195078359817341L;
+
+    private static final Object XMLCTOR_TAG = new Object();
+
+    private XmlProcessor options;
+//    private XMLLibImpl lib;
+
+    XMLCtor(XML xml, Object tag, int id, int arity)
+    {
+        super(xml, tag, id, arity);
+//        this.lib = xml.lib;
+        this.options = xml.getProcessor();
+        activatePrototypeMap(MAX_FUNCTION_ID);
+    }
+
+    private void writeSetting(Scriptable target)
+    {
+        for (int i = 1; i <= MAX_INSTANCE_ID; ++i) {
+            int id = super.getMaxInstanceId() + i;
+            String name = getInstanceIdName(id);
+            Object value = getInstanceIdValue(id);
+            ScriptableObject.putProperty(target, name, value);
+        }
+    }
+
+    private void readSettings(Scriptable source)
+    {
+        for (int i = 1; i <= MAX_INSTANCE_ID; ++i) {
+            int id = super.getMaxInstanceId() + i;
+            String name = getInstanceIdName(id);
+            Object value = ScriptableObject.getProperty(source, name);
+            if (value == Scriptable.NOT_FOUND) {
+                continue;
+            }
+            switch (i) {
+              case Id_ignoreComments:
+              case Id_ignoreProcessingInstructions:
+              case Id_ignoreWhitespace:
+              case Id_prettyPrinting:
+                if (!(value instanceof Boolean)) {
+                    continue;
+                }
+                break;
+              case Id_prettyIndent:
+                if (!(value instanceof Number)) {
+                    continue;
+                }
+                break;
+              default:
+                throw new IllegalStateException();
+            }
+            setInstanceIdValue(id, value);
+        }
+    }
+
+// #string_id_map#
+
+    private static final int
+        Id_ignoreComments               = 1,
+        Id_ignoreProcessingInstructions = 2,
+        Id_ignoreWhitespace             = 3,
+        Id_prettyIndent                 = 4,
+        Id_prettyPrinting               = 5,
+
+        MAX_INSTANCE_ID                 = 5;
+
+    protected int getMaxInstanceId()
+    {
+        return super.getMaxInstanceId() + MAX_INSTANCE_ID;
+    }
+
+    protected int findInstanceIdInfo(String s) {
+        int id;
+// #generated# Last update: 2007-08-20 09:01:10 EDT
+        L0: { id = 0; String X = null; int c;
+            L: switch (s.length()) {
+            case 12: X="prettyIndent";id=Id_prettyIndent; break L;
+            case 14: c=s.charAt(0);
+                if (c=='i') { X="ignoreComments";id=Id_ignoreComments; }
+                else if (c=='p') { X="prettyPrinting";id=Id_prettyPrinting; }
+                break L;
+            case 16: X="ignoreWhitespace";id=Id_ignoreWhitespace; break L;
+            case 28: X="ignoreProcessingInstructions";id=Id_ignoreProcessingInstructions; break L;
+            }
+            if (X!=null && X!=s && !X.equals(s)) id = 0;
+            break L0;
+        }
+// #/generated#
+
+        if (id == 0) return super.findInstanceIdInfo(s);
+
+        int attr;
+        switch (id) {
+          case Id_ignoreComments:
+          case Id_ignoreProcessingInstructions:
+          case Id_ignoreWhitespace:
+          case Id_prettyIndent:
+          case Id_prettyPrinting:
+            attr = PERMANENT | DONTENUM;
+            break;
+          default: throw new IllegalStateException();
+        }
+        return instanceIdInfo(attr, super.getMaxInstanceId() + id);
+    }
+
+// #/string_id_map#
+
+    protected String getInstanceIdName(int id)
+    {
+        switch (id - super.getMaxInstanceId()) {
+          case Id_ignoreComments:               return "ignoreComments";
+          case Id_ignoreProcessingInstructions: return "ignoreProcessingInstructions";
+          case Id_ignoreWhitespace:             return "ignoreWhitespace";
+          case Id_prettyIndent:                 return "prettyIndent";
+          case Id_prettyPrinting:               return "prettyPrinting";
+        }
+        return super.getInstanceIdName(id);
+    }
+
+    protected Object getInstanceIdValue(int id)
+    {
+        switch (id - super.getMaxInstanceId()) {
+          case Id_ignoreComments:
+            return ScriptRuntime.wrapBoolean(options.isIgnoreComments());
+          case Id_ignoreProcessingInstructions:
+            return ScriptRuntime.wrapBoolean(options.isIgnoreProcessingInstructions());
+          case Id_ignoreWhitespace:
+            return ScriptRuntime.wrapBoolean(options.isIgnoreWhitespace());
+          case Id_prettyIndent:
+            return ScriptRuntime.wrapInt(options.getPrettyIndent());
+          case Id_prettyPrinting:
+            return ScriptRuntime.wrapBoolean(options.isPrettyPrinting());
+        }
+        return super.getInstanceIdValue(id);
+    }
+
+    protected void setInstanceIdValue(int id, Object value) {
+        switch (id - super.getMaxInstanceId()) {
+            case Id_ignoreComments:
+                options.setIgnoreComments(ScriptRuntime.toBoolean(value));
+                return;
+            case Id_ignoreProcessingInstructions:
+                options.setIgnoreProcessingInstructions(ScriptRuntime.toBoolean(value));
+                return;
+            case Id_ignoreWhitespace:
+                options.setIgnoreWhitespace(ScriptRuntime.toBoolean(value));
+                return;
+            case Id_prettyIndent:
+                options.setPrettyIndent(ScriptRuntime.toInt32(value));
+                return;
+            case Id_prettyPrinting:
+                options.setPrettyPrinting(ScriptRuntime.toBoolean(value));
+                return;
+        }
+        super.setInstanceIdValue(id, value);
+    }
+
+// #string_id_map#
+    private static final int
+        Id_defaultSettings              = 1,
+        Id_settings                     = 2,
+        Id_setSettings                  = 3,
+        MAX_FUNCTION_ID                 = 3;
+
+    protected int findPrototypeId(String s)
+    {
+        int id;
+// #generated# Last update: 2007-08-20 09:01:10 EDT
+        L0: { id = 0; String X = null;
+            int s_length = s.length();
+            if (s_length==8) { X="settings";id=Id_settings; }
+            else if (s_length==11) { X="setSettings";id=Id_setSettings; }
+            else if (s_length==15) { X="defaultSettings";id=Id_defaultSettings; }
+            if (X!=null && X!=s && !X.equals(s)) id = 0;
+            break L0;
+        }
+// #/generated#
+        return id;
+    }
+// #/string_id_map#
+
+    protected void initPrototypeId(int id)
+    {
+        String s;
+        int arity;
+        switch (id) {
+          case Id_defaultSettings:  arity=0; s="defaultSettings";  break;
+          case Id_settings:         arity=0; s="settings";         break;
+          case Id_setSettings:      arity=1; s="setSettings";      break;
+          default: throw new IllegalArgumentException(String.valueOf(id));
+        }
+        initPrototypeMethod(XMLCTOR_TAG, id, s, arity);
+    }
+
+    public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope,
+                             Scriptable thisObj, Object[] args)
+    {
+        if (!f.hasTag(XMLCTOR_TAG)) {
+            return super.execIdCall(f, cx, scope, thisObj, args);
+        }
+        int id = f.methodId();
+        switch (id) {
+          case Id_defaultSettings: {
+            options.setDefault();
+            Scriptable obj = cx.newObject(scope);
+            writeSetting(obj);
+            return obj;
+          }
+          case Id_settings: {
+            Scriptable obj = cx.newObject(scope);
+            writeSetting(obj);
+            return obj;
+          }
+          case Id_setSettings: {
+            if (args.length == 0
+                || args[0] == null
+                || args[0] == Undefined.instance)
+            {
+                options.setDefault();
+            } else if (args[0] instanceof Scriptable) {
+                readSettings((Scriptable)args[0]);
+            }
+            return Undefined.instance;
+          }
+        }
+        throw new IllegalArgumentException(String.valueOf(id));
+    }
+
+    /**
+        hasInstance for XML objects works differently than other objects; see ECMA357 13.4.3.10.
+     */
+    public boolean hasInstance(Scriptable instance) {
+        return (instance instanceof XML || instance instanceof XMLList);
+    }
+}
diff --git a/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLLibImpl.java b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLLibImpl.java
new file mode 100644
index 0000000..6d45240
--- /dev/null
+++ b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLLibImpl.java
@@ -0,0 +1,606 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *   David P. Caldwell <inonit@inonit.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.xmlimpl;
+
+import java.io.Serializable;
+
+import org.mozilla.javascript.*;
+import org.mozilla.javascript.xml.*;
+
+public final class XMLLibImpl extends XMLLib implements Serializable {
+    //    TODO    Document that this only works with JDK 1.5 or backport its
+    //    features to earlier versions
+    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 cx, Scriptable scope, boolean sealed) {
+        XMLLibImpl lib = new XMLLibImpl(scope);
+        XMLLib bound = lib.bindToScope(scope);
+        if (bound == lib) {
+            lib.exportToScope(sealed);
+        }
+    }
+
+    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 = globalScope;
+    }
+
+    /** @deprecated */
+    QName qnamePrototype() {
+        return qnamePrototype;
+    }
+
+    /** @deprecated */
+    Scriptable globalScope() {
+        return globalScope;
+    }
+
+    XmlProcessor getProcessor() {
+        return options;
+    }
+
+    private void exportToScope(boolean sealed) {
+        xmlPrototype = newXML(XmlNode.createText(options, ""));
+        xmlListPrototype = newXMLList();
+        namespacePrototype = Namespace.create(this.globalScope, null, XmlNode.Namespace.GLOBAL);
+        qnamePrototype = QName.create(this, this.globalScope, null, XmlNode.QName.create(XmlNode.Namespace.create(""), ""));
+
+        xmlPrototype.exportAsJSClass(sealed);
+        xmlListPrototype.exportAsJSClass(sealed);
+        namespacePrototype.exportAsJSClass(sealed);
+        qnamePrototype.exportAsJSClass(sealed);
+    }
+
+    /** @deprecated */
+    XMLName toAttributeName(Context cx, Object 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(), true, false );
+        } else if (nameValue instanceof Boolean
+            || nameValue instanceof Number
+            || nameValue == Undefined.instance
+            || 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), true, false);
+        }
+    }
+
+    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 == Undefined.instance || 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 cx, String name) {
+        return XMLName.create( getDefaultNamespaceURI(cx), name );
+    }
+
+    /** @deprecated */
+    XMLName toXMLName(Context cx, Object 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 == Undefined.instance
+            || nameValue == null) {
+            throw badXMLName(nameValue);
+        } else {
+            String name = ScriptRuntime.toString(nameValue);
+            result = toXMLNameFromString(cx, name);
+        }
+
+        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 cx, Object 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(cx, test);
+                result = null;
+            } else {
+                result = toXMLNameFromString(cx, str);
+            }
+        } else if (value instanceof Number) {
+            double d = ((Number)value).doubleValue();
+            long l = (long)d;
+            if (l == d && 0 <= l && l <= 0xFFFFFFFFL) {
+                ScriptRuntime.storeUint32Result(cx, l);
+                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(cx, test);
+                    number = true;
+                }
+            }
+            if (!number) {
+                result = XMLName.formProperty(uri, qname.localName());
+            }
+        } else if (value instanceof Boolean
+                   || value == Undefined.instance
+                   || value == null)
+        {
+            throw badXMLName(value);
+        } else {
+            String str = ScriptRuntime.toString(value);
+            long test = ScriptRuntime.testUint32String(str);
+            if (test >= 0) {
+                ScriptRuntime.storeUint32Result(cx, test);
+                result = null;
+            } else {
+                result = toXMLNameFromString(cx, str);
+            }
+        }
+
+        return result;
+    }
+
+    Object addXMLObjects(Context cx, XMLObject obj1, XMLObject 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 cx, XMLName xmlName, Scriptable 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 cx, Object namespaceObj) {
+        return this.namespacePrototype.castToNamespace(namespaceObj);
+    }
+
+    private String getDefaultNamespaceURI(Context cx) {
+        return getDefaultNamespace(cx).uri();
+    }
+
+    Namespace newNamespace(String uri) {
+        return this.namespacePrototype.newNamespace(uri);
+    }
+
+    Namespace getDefaultNamespace(Context cx) {
+        if (cx == null) {
+            cx = Context.getCurrentContext();
+            if (cx == null) {
+                return namespacePrototype;
+            }
+        }
+
+        Object ns = ScriptRuntime.searchDefaultNamespace(cx);
+        if (ns == null) {
+            return namespacePrototype;
+        } 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 namespacePrototype;
+            }
+        }
+    }
+
+    Namespace[] createNamespaces(XmlNode.Namespace[] declarations) {
+        Namespace[] rv = new Namespace[declarations.length];
+        for (int i=0; i<declarations.length; i++) {
+            rv[i] = this.namespacePrototype.newNamespace(declarations[i].getPrefix(), declarations[i].getUri());
+        }
+        return rv;
+    }
+
+    //    See ECMA357 13.3.2
+    QName constructQName(Context cx, Object namespace, Object name) {
+        return this.qnamePrototype.constructQName(this, cx, namespace, name);
+    }
+
+    QName newQName(String uri, String localName, String prefix) {
+        return this.qnamePrototype.newQName(this, uri, localName, prefix);
+    }
+
+    QName constructQName(Context cx, Object nameValue) {
+//        return constructQName(cx, Undefined.instance, nameValue);
+        return this.qnamePrototype.constructQName(this, cx, nameValue);
+    }
+
+    QName castToQName(Context cx, Object qnameValue) {
+        return this.qnamePrototype.castToQName(this, cx, qnameValue);
+    }
+
+    QName newQName(XmlNode.QName qname) {
+        return QName.create(this, this.globalScope, this.qnamePrototype, qname);
+    }
+
+    XML newXML(XmlNode node) {
+        return new XML(this, this.globalScope, this.xmlPrototype, node);
+    }
+
+    /**
+        @deprecated I believe this can be replaced by ecmaToXml below.
+     */
+    final XML newXMLFromJs(Object inputObject) {
+        String frag;
+
+        if (inputObject == null || inputObject == Undefined.instance) {
+            frag = "";
+        } else if (inputObject instanceof XMLObjectImpl) {
+            // todo: faster way for XMLObjects?
+            frag = ((XMLObjectImpl) inputObject).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(options, frag));
+        }
+        return parse(frag);
+    }
+
+    private XML parse(String frag) {
+        try {
+            return newXML(XmlNode.createElement(options, getDefaultNamespaceURI(Context.getCurrentContext()), frag));
+        } catch (org.xml.sax.SAXException e) {
+            throw ScriptRuntime.typeError("Cannot parse XML: " + e.getMessage());
+        }
+    }
+
+    final XML ecmaToXml(Object object) {
+        //    See ECMA357 10.3
+        if (object == null || object == Undefined.instance) throw ScriptRuntime.typeError("Cannot convert " + object + " to XML");
+        if (object instanceof XML) return (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 = ((Wrapper) object).unwrap();
+        }
+        if (object instanceof org.w3c.dom.Node) {
+            org.w3c.dom.Node node = (org.w3c.dom.Node) object;
+            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(options, s));
+        }
+    }
+
+    final XML newTextElementXML(XmlNode reference, XmlNode.QName qname, String value) {
+        return newXML(XmlNode.newElementWithText(options, reference, qname, value));
+    }
+
+    XMLList newXMLList() {
+        return new XMLList(this, this.globalScope, this.xmlListPrototype);
+    }
+
+    final XMLList newXMLListFrom(Object inputObject) {
+        XMLList rv = newXMLList();
+
+        if (inputObject == null || inputObject instanceof Undefined) {
+            return rv;
+        } else if (inputObject instanceof XML) {
+            XML xml = (XML) inputObject;
+            rv.getNodeList().add(xml);
+            return rv;
+        } else if (inputObject instanceof XMLList) {
+            XMLList xmll = (XMLList) inputObject;
+            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(((XML) children.item(i).copy()));
+            }
+            return rv;
+        }
+    }
+
+    XmlNode.QName toNodeQName(Context cx, Object namespaceValue, Object 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 == Undefined.instance) {
+            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.namespacePrototype.constructNamespace(namespaceValue).getDelegate();
+        }
+
+        if (localName != null && localName.equals("*")) localName = null;
+        return XmlNode.QName.create(ns, localName);
+    }
+
+    XmlNode.QName toNodeQName(Context cx, String name, boolean attribute) {
+        XmlNode.Namespace defaultNamespace = getDefaultNamespace(cx).getDelegate();
+        if (name != null && name.equals("*")) {
+            return XmlNode.QName.create(null, null);
+        } else {
+            if (attribute) {
+                return XmlNode.QName.create(XmlNode.Namespace.GLOBAL, name);
+            } else {
+                return XmlNode.QName.create(defaultNamespace, name);
+            }
+        }
+    }
+
+    /**
+        @deprecated Too general; this should be split into overloaded methods.
+        Is that possible?
+     */
+    XmlNode.QName toNodeQName(Context cx, Object nameValue, boolean 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 == Undefined.instance
+            || nameValue == null
+        ) {
+            throw badXMLName(nameValue);
+        } else {
+            String local = null;
+            if (nameValue instanceof String) {
+                local = (String)nameValue;
+            } else {
+                local = ScriptRuntime.toString(nameValue);
+            }
+            return toNodeQName(cx, local, attribute);
+        }
+    }
+
+    //
+    //    Override methods from XMLLib
+    //
+
+    public boolean isXMLName(Context _cx, Object nameObj) {
+        return XMLName.accept(nameObj);
+    }
+
+    public Object toDefaultXmlNamespace(Context cx, Object uriValue) {
+        return this.namespacePrototype.constructNamespace(uriValue);
+    }
+
+    public String escapeTextValue(Object o) {
+        return options.escapeTextValue(o);
+    }
+
+    public String escapeAttributeValue(Object o) {
+        return options.escapeAttributeValue(o);
+    }
+
+    public Ref nameRef(Context cx, Object name, Scriptable scope, int memberTypeFlags) {
+        if ((memberTypeFlags & Node.ATTRIBUTE_FLAG) == 0) {
+            // should only be called foir cases like @name or @[expr]
+            throw Kit.codeBug();
+        }
+        XMLName xmlName = toAttributeName(cx, name);
+        return xmlPrimaryReference(cx, xmlName, scope);
+    }
+
+    public Ref nameRef(Context cx, Object namespace, Object name, Scriptable scope, int memberTypeFlags) {
+        XMLName xmlName = XMLName.create(toNodeQName(cx, namespace, name), false, false);
+
+        //    No idea what is coming in from the parser in this case; is it detecting the "@"?
+        if ((memberTypeFlags & Node.ATTRIBUTE_FLAG) != 0) {
+            if (!xmlName.isAttributeName()) {
+                xmlName.setAttributeName();
+            }
+        }
+
+        return xmlPrimaryReference(cx, xmlName, scope);
+    }
+}
diff --git a/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLList.java b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLList.java
new file mode 100644
index 0000000..59dcca3
--- /dev/null
+++ b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLList.java
@@ -0,0 +1,765 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Ethan Hugg
+ *   Terry Lucas
+ *   Milen Nankov
+ *   David P. Caldwell <inonit@inonit.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.xmlimpl;
+
+import org.mozilla.javascript.*;
+import org.mozilla.javascript.xml.*;
+
+class XMLList extends XMLObjectImpl implements Function {
+    static final long serialVersionUID = -4543618751670781135L;
+
+    private XmlNode.List _annos;
+    private XMLObjectImpl targetObject = null;
+    private XmlNode.QName targetProperty = null;
+
+    XMLList(XMLLibImpl lib, Scriptable scope, XMLObject prototype) {
+        super(lib, scope, prototype);
+        _annos = new XmlNode.List();
+    }
+
+    /** @deprecated Will probably end up unnecessary as we move things around */
+    XmlNode.List getNodeList() {
+        return _annos;
+    }
+
+    //    TODO    Should be XMLObjectImpl, XMLName?
+    void setTargets(XMLObjectImpl object, XmlNode.QName property) {
+        targetObject = object;
+        targetProperty = property;
+    }
+
+    /** @deprecated */
+    private XML getXmlFromAnnotation(int index) {
+        return getXML(_annos, index);
+    }
+
+    XML getXML() {
+        if (length() == 1) return getXmlFromAnnotation(0);
+        return null;
+    }
+
+    private void internalRemoveFromList(int index) {
+        _annos.remove(index);
+    }
+
+    void replace(int index, XML xml) {
+        if (index < length()) {
+            XmlNode.List newAnnoList = new XmlNode.List();
+            newAnnoList.add(_annos, 0, index);
+            newAnnoList.add(xml);
+            newAnnoList.add(_annos, index+1, length());
+            _annos = newAnnoList;
+        }
+    }
+
+    private void insert(int index, XML xml) {
+        if (index < length()) {
+            XmlNode.List newAnnoList = new XmlNode.List();
+            newAnnoList.add(_annos, 0, index);
+            newAnnoList.add(xml);
+            newAnnoList.add(_annos, index, length());
+            _annos = newAnnoList;
+        }
+    }
+
+    //
+    //
+    //  methods overriding ScriptableObject
+    //
+    //
+
+    public String getClassName() {
+        return "XMLList";
+    }
+
+    //
+    //
+    //  methods overriding IdScriptableObject
+    //
+    //
+
+    public Object get(int index, Scriptable start) {
+        //Log("get index: " + index);
+
+        if (index >= 0 && index < length()) {
+            return getXmlFromAnnotation(index);
+        } else {
+            return Scriptable.NOT_FOUND;
+        }
+    }
+
+    boolean hasXMLProperty(XMLName xmlName) {
+        boolean result = false;
+
+        // Has now should return true if the property would have results > 0 or
+        // if it's a method name
+        String name = xmlName.localName();
+        if ((getPropertyList(xmlName).length() > 0) ||
+            (getMethod(name) != NOT_FOUND)) {
+            result = true;
+        }
+
+        return result;
+    }
+
+    public boolean has(int index, Scriptable start) {
+        return 0 <= index && index < length();
+    }
+
+    void putXMLProperty(XMLName xmlName, Object value) {
+        //Log("put property: " + name);
+
+        // Special-case checks for undefined and null
+        if (value == null) {
+            value = "null";
+        } else if (value instanceof Undefined) {
+            value = "undefined";
+        }
+
+        if (length() > 1) {
+            throw ScriptRuntime.typeError("Assignment to lists with more than one item is not supported");
+        } else if (length() == 0) {
+            // Secret sauce for super-expandos.
+            // We set an element here, and then add ourselves to our target.
+            if (targetObject != null && targetProperty != null && targetProperty.getLocalName() != null) {
+                // Add an empty element with our targetProperty name and then set it.
+                XML xmlValue = newTextElementXML(null, targetProperty, null);
+                addToList(xmlValue);
+
+                if(xmlName.isAttributeName()) {
+                    setAttribute(xmlName, value);
+                } else {
+                    XML xml = item(0);
+                    xml.putXMLProperty(xmlName, value);
+
+                    // Update the list with the new item at location 0.
+                    replace(0, item(0));
+                }
+
+                // Now add us to our parent
+                XMLName name2 = XMLName.formProperty(targetProperty.getUri(), targetProperty.getLocalName());
+                targetObject.putXMLProperty(name2, this);
+            } else {
+                throw ScriptRuntime.typeError("Assignment to empty XMLList without targets not supported");
+            }
+        } else if(xmlName.isAttributeName()) {
+            setAttribute(xmlName, value);
+        } else {
+            XML xml = item(0);
+            xml.putXMLProperty(xmlName, value);
+
+            // Update the list with the new item at location 0.
+            replace(0, item(0));
+        }
+    }
+
+    Object getXMLProperty(XMLName name) {
+        return getPropertyList(name);
+    }
+
+    private void replaceNode(XML xml, XML with) {
+        xml.replaceWith(with);
+    }
+
+    public void put(int index, Scriptable start, Object value) {
+        Object parent = Undefined.instance;
+        // Convert text into XML if needed.
+        XMLObject xmlValue;
+
+        // Special-case checks for undefined and null
+        if (value == null) {
+            value = "null";
+        } else if (value instanceof Undefined) {
+            value = "undefined";
+        }
+
+        if (value instanceof XMLObject) {
+            xmlValue = (XMLObject) value;
+        } else {
+            if (targetProperty == null) {
+                xmlValue = newXMLFromJs(value.toString());
+            } else {
+                //    Note that later in the code, we will use this as an argument to replace(int,value)
+                //    So we will be "replacing" this element with itself
+                //    There may well be a better way to do this
+                //    TODO    Find a way to refactor this whole method and simplify it
+                xmlValue = item(index);
+                ((XML)xmlValue).setChildren(value);
+            }
+        }
+
+        // Find the parent
+        if (index < length()) {
+            parent = item(index).parent();
+        } else {
+            // Appending
+            parent = parent();
+        }
+
+        if (parent instanceof XML) {
+            // found parent, alter doc
+            XML xmlParent = (XML) parent;
+
+            if (index < length()) {
+                // We're replacing the the node.
+                XML xmlNode = getXmlFromAnnotation(index);
+
+                if (xmlValue instanceof XML) {
+                    replaceNode(xmlNode, (XML) xmlValue);
+                    replace(index, xmlNode);
+                } else if (xmlValue instanceof XMLList) {
+                    // Replace the first one, and add the rest on the list.
+                    XMLList list = (XMLList) xmlValue;
+
+                    if (list.length() > 0) {
+                        int lastIndexAdded = xmlNode.childIndex();
+                        replaceNode(xmlNode, list.item(0));
+                        replace(index, list.item(0));
+
+                        for (int i = 1; i < list.length(); i++) {
+                            xmlParent.insertChildAfter(xmlParent.getXmlChild(lastIndexAdded), list.item(i));
+                            lastIndexAdded++;
+                            insert(index + i, list.item(i));
+                        }
+                    }
+                }
+            } else {
+                // Appending
+                xmlParent.appendChild(xmlValue);
+                addToList(xmlParent.getXmlChild(index));
+            }
+        } else {
+            // Don't all have same parent, no underlying doc to alter
+            if (index < length()) {
+                XML xmlNode = getXML(_annos, index);
+
+                if (xmlValue instanceof XML) {
+                    replaceNode(xmlNode, (XML) xmlValue);
+                    replace(index, xmlNode);
+                } else if (xmlValue instanceof XMLList) {
+                    // Replace the first one, and add the rest on the list.
+                    XMLList list = (XMLList) xmlValue;
+
+                    if (list.length() > 0) {
+                        replaceNode(xmlNode, list.item(0));
+                        replace(index, list.item(0));
+
+                        for (int i = 1; i < list.length(); i++) {
+                            insert(index + i, list.item(i));
+                        }
+                    }
+                }
+            } else {
+                addToList(xmlValue);
+            }
+        }
+    }
+
+    private XML getXML(XmlNode.List _annos, int index) {
+        if (index >= 0 && index < length()) {
+            return xmlFromNode(_annos.item(index));
+        } else {
+            return null;
+        }
+    }
+
+    void deleteXMLProperty(XMLName name) {
+        for (int i = 0; i < length(); i++) {
+            XML xml = getXmlFromAnnotation(i);
+
+            if (xml.isElement()) {
+                xml.deleteXMLProperty(name);
+            }
+        }
+    }
+
+    public void delete(int index) {
+        if (index >= 0 && index < length()) {
+            XML xml = getXmlFromAnnotation(index);
+
+            xml.remove();
+
+            internalRemoveFromList(index);
+        }
+    }
+
+    public Object[] getIds() {
+        Object enumObjs[];
+
+        if (isPrototype()) {
+            enumObjs = new Object[0];
+        } else {
+            enumObjs = new Object[length()];
+
+            for (int i = 0; i < enumObjs.length; i++) {
+                enumObjs[i] = new Integer(i);
+            }
+        }
+
+        return enumObjs;
+    }
+
+    public Object[] getIdsForDebug() {
+        return getIds();
+    }
+
+
+    // XMLList will remove will delete all items in the list (a set delete) this differs from the XMLList delete operator.
+    void remove() {
+        int nLen = length();
+        for (int i = nLen - 1; i >= 0; i--) {
+            XML xml = getXmlFromAnnotation(i);
+            if (xml != null) {
+                xml.remove();
+                internalRemoveFromList(i);
+            }
+        }
+    }
+
+    XML item(int index) {
+        return _annos != null
+            ? getXmlFromAnnotation(index) : createEmptyXML();
+    }
+
+    private void setAttribute(XMLName xmlName, Object value) {
+        for (int i = 0; i < length(); i++) {
+            XML xml = getXmlFromAnnotation(i);
+            xml.setAttribute(xmlName, value);
+        }
+    }
+
+    void addToList(Object toAdd) {
+        _annos.addToList(toAdd);
+    }
+
+    //
+    //
+    // Methods from section 12.4.4 in the spec
+    //
+    //
+
+    XMLList child(int index) {
+        XMLList result = newXMLList();
+
+        for (int i = 0; i < length(); i++) {
+            result.addToList(getXmlFromAnnotation(i).child(index));
+        }
+
+        return result;
+    }
+
+    XMLList child(XMLName xmlName) {
+        XMLList result = newXMLList();
+
+        for (int i = 0; i < length(); i++) {
+            result.addToList(getXmlFromAnnotation(i).child(xmlName));
+        }
+
+        return result;
+    }
+
+    void addMatches(XMLList rv, XMLName name) {
+        for (int i=0; i<length(); i++) {
+            getXmlFromAnnotation(i).addMatches(rv, name);
+        }
+    }
+
+    XMLList children() {
+        java.util.Vector v = new java.util.Vector();
+
+        for (int i = 0; i < length(); i++) {
+            XML xml = getXmlFromAnnotation(i);
+
+            if (xml != null) {
+                Object o = xml.children();
+                if (o instanceof XMLList) {
+                    XMLList childList = (XMLList)o;
+
+                    int cChildren = childList.length();
+                    for (int j = 0; j < cChildren; j++) {
+                        v.addElement(childList.item(j));
+                    }
+                }
+            }
+        }
+
+        XMLList allChildren = newXMLList();
+        int sz = v.size();
+
+        for (int i = 0; i < sz; i++) {
+            allChildren.addToList(v.get(i));
+        }
+
+        return allChildren;
+    }
+
+    XMLList comments() {
+        XMLList result = newXMLList();
+
+        for (int i = 0; i < length(); i++) {
+            XML xml = getXmlFromAnnotation(i);
+            result.addToList(xml.comments());
+        }
+
+        return result;
+    }
+
+    XMLList elements(XMLName name) {
+        XMLList rv = newXMLList();
+        for (int i=0; i<length(); i++) {
+            XML xml = getXmlFromAnnotation(i);
+            rv.addToList(xml.elements(name));
+        }
+        return rv;
+    }
+
+    boolean contains(Object xml) {
+        boolean result = false;
+
+        for (int i = 0; i < length(); i++) {
+            XML member = getXmlFromAnnotation(i);
+
+            if (member.equivalentXml(xml)) {
+                result = true;
+                break;
+            }
+        }
+
+        return result;
+    }
+
+    XMLObjectImpl copy() {
+        XMLList result = newXMLList();
+
+        for (int i = 0; i < length(); i++) {
+            XML xml = getXmlFromAnnotation(i);
+            result.addToList(xml.copy());
+        }
+
+        return result;
+    }
+
+    boolean hasOwnProperty(XMLName xmlName) {
+        if (isPrototype()) {
+            String property = xmlName.localName();
+            return (findPrototypeId(property) != 0);
+        } else {
+            return (getPropertyList(xmlName).length() > 0);
+        }
+    }
+
+    boolean hasComplexContent() {
+        boolean complexContent;
+        int length = length();
+
+        if (length == 0) {
+            complexContent = false;
+        } else if (length == 1) {
+            complexContent = getXmlFromAnnotation(0).hasComplexContent();
+        } else {
+            complexContent = false;
+
+            for (int i = 0; i < length; i++) {
+                XML nextElement = getXmlFromAnnotation(i);
+                if (nextElement.isElement()) {
+                    complexContent = true;
+                    break;
+                }
+            }
+        }
+
+        return complexContent;
+    }
+
+    boolean hasSimpleContent() {
+        if (length() == 0) {
+            return true;
+        } else if (length() == 1) {
+            return getXmlFromAnnotation(0).hasSimpleContent();
+        } else {
+            for (int i=0; i<length(); i++) {
+                XML nextElement = getXmlFromAnnotation(i);
+                if (nextElement.isElement()) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    int length() {
+        int result = 0;
+
+        if (_annos != null) {
+            result = _annos.length();
+        }
+
+        return result;
+    }
+
+    void normalize() {
+        for (int i = 0; i < length(); i++) {
+            getXmlFromAnnotation(i).normalize();
+        }
+    }
+
+    /**
+     * If list is empty, return undefined, if elements have different parents return undefined,
+     * If they all have the same parent, return that parent
+     */
+    Object parent() {
+        if (length() == 0) return Undefined.instance;
+
+        XML candidateParent = null;
+
+        for (int i = 0; i < length(); i++) {
+            Object currParent = getXmlFromAnnotation(i).parent();
+            if (!(currParent instanceof XML)) return Undefined.instance;
+            XML xml = (XML)currParent;
+            if (i == 0) {
+                // Set the first for the rest to compare to.
+                candidateParent = xml;
+            } else {
+                if (candidateParent.is(xml)) {
+                    //    keep looking
+                } else {
+                    return Undefined.instance;
+                }
+            }
+        }
+        return candidateParent;
+    }
+
+    XMLList processingInstructions(XMLName xmlName) {
+        XMLList result = newXMLList();
+
+        for (int i = 0; i < length(); i++) {
+            XML xml = getXmlFromAnnotation(i);
+
+            result.addToList(xml.processingInstructions(xmlName));
+        }
+
+        return result;
+    }
+
+    boolean propertyIsEnumerable(Object name) {
+        long index;
+        if (name instanceof Integer) {
+            index = ((Integer)name).intValue();
+        } else if (name instanceof Number) {
+            double x = ((Number)name).doubleValue();
+            index = (long)x;
+            if (index != x) {
+                return false;
+            }
+            if (index == 0 && 1.0 / x < 0) {
+                // Negative 0
+                return false;
+            }
+        } else {
+            String s = ScriptRuntime.toString(name);
+            index = ScriptRuntime.testUint32String(s);
+        }
+        return (0 <= index && index < length());
+    }
+
+    XMLList text() {
+        XMLList result = newXMLList();
+
+        for (int i = 0; i < length(); i++) {
+            result.addToList(getXmlFromAnnotation(i).text());
+        }
+
+        return result;
+    }
+
+    public String toString() {
+        //    ECMA357 10.1.2
+        if (hasSimpleContent()) {
+            StringBuffer sb = new StringBuffer();
+
+            for(int i = 0; i < length(); i++) {
+                XML next = getXmlFromAnnotation(i);
+                if (next.isComment() || next.isProcessingInstruction()) {
+                    //    do nothing
+                } else {
+                    sb.append(next.toString());
+                }
+            }
+
+            return sb.toString();
+        } else {
+            return toXMLString();
+        }
+    }
+
+    String toXMLString() {
+        //    See ECMA 10.2.1
+        StringBuffer sb = new StringBuffer();
+
+        for (int i=0; i<length(); i++) {
+            if (getProcessor().isPrettyPrinting() && i != 0) {
+                sb.append('\n');
+            }
+            sb.append(getXmlFromAnnotation(i).toXMLString());
+        }
+        return sb.toString();
+    }
+
+    Object valueOf() {
+        return this;
+    }
+
+    //
+    // Other public Functions from XMLObject
+    //
+
+    boolean equivalentXml(Object target) {
+        boolean result = false;
+
+        // Zero length list should equate to undefined
+        if (target instanceof Undefined && length() == 0) {
+            result = true;
+        } else if (length() == 1) {
+            result = getXmlFromAnnotation(0).equivalentXml(target);
+        } else if (target instanceof XMLList) {
+            XMLList otherList = (XMLList) target;
+
+            if (otherList.length() == length()) {
+                result = true;
+
+                for (int i = 0; i < length(); i++) {
+                    if (!getXmlFromAnnotation(i).equivalentXml(otherList.getXmlFromAnnotation(i))) {
+                        result = false;
+                        break;
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
+    private XMLList getPropertyList(XMLName name) {
+        XMLList propertyList = newXMLList();
+        XmlNode.QName qname = null;
+
+        if (!name.isDescendants() && !name.isAttributeName()) {
+            // Only set the targetProperty if this is a regular child get
+            // and not a descendant or attribute get
+            qname = name.toQname();
+        }
+
+        propertyList.setTargets(this, qname);
+
+        for (int i = 0; i < length(); i++) {
+            propertyList.addToList(
+                getXmlFromAnnotation(i).getPropertyList(name));
+        }
+
+        return propertyList;
+    }
+
+    private Object applyOrCall(boolean isApply,
+        Context cx, Scriptable scope,
+        Scriptable thisObj, Object[] args) {
+        String methodName = isApply ? "apply" : "call";
+        if(!(thisObj instanceof XMLList) ||
+            ((XMLList)thisObj).targetProperty == null)
+            throw ScriptRuntime.typeError1("msg.isnt.function",
+                methodName);
+
+        return ScriptRuntime.applyOrCall(isApply, cx, scope, thisObj, args);
+    }
+
+    protected Object jsConstructor(Context cx, boolean inNewExpr,
+        Object[] args) {
+        if (args.length == 0) {
+            return newXMLList();
+        } else {
+            Object arg0 = args[0];
+            if (!inNewExpr && arg0 instanceof XMLList) {
+                // XMLList(XMLList) returns the same object.
+                return arg0;
+            }
+            return newXMLListFrom(arg0);
+        }
+    }
+
+    /**
+     * See ECMA 357, 11_2_2_1, Semantics, 3_e.
+     */
+    public Scriptable getExtraMethodSource(Context cx) {
+        if (length() == 1) {
+            return getXmlFromAnnotation(0);
+        }
+        return null;
+    }
+
+    public Object call(Context cx, Scriptable scope, Scriptable thisObj,
+        Object[] args) {
+        // This XMLList is being called as a Function.
+        // Let's find the real Function object.
+        if(targetProperty == null)
+            throw ScriptRuntime.notFunctionError(this);
+
+        String methodName = targetProperty.getLocalName();
+
+        boolean isApply = methodName.equals("apply");
+        if(isApply || methodName.equals("call"))
+            return applyOrCall(isApply, cx, scope, thisObj, args);
+
+        Callable method = ScriptRuntime.getElemFunctionAndThis(
+            this, methodName, cx);
+        // Call lastStoredScriptable to clear stored thisObj
+        // but ignore the result as the method should use the supplied
+        // thisObj, not one from redirected call
+        ScriptRuntime.lastStoredScriptable(cx);
+        return method.call(cx, scope, thisObj, args);
+    }
+
+    public Scriptable construct(Context cx, Scriptable scope, Object[] args) {
+        throw ScriptRuntime.typeError1("msg.not.ctor", "XMLList");
+    }
+}
+
+
diff --git a/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLName.java b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLName.java
new file mode 100644
index 0000000..edd7525
--- /dev/null
+++ b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLName.java
@@ -0,0 +1,469 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *   Milen Nankov
+ *   David P. Caldwell <inonit@inonit.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.xmlimpl;
+
+import org.mozilla.javascript.*;
+
+class XMLName extends Ref {
+    static final long serialVersionUID = 3832176310755686977L;
+
+    private static boolean isNCNameStartChar(int c) {
+        if ((c & ~0x7F) == 0) {
+            // Optimize for ASCII and use A..Z < _ < a..z
+            if (c >= 'a') {
+                return c <= 'z';
+            } else if (c >= 'A') {
+                if (c <= 'Z') {
+                    return true;
+                }
+                return c == '_';
+            }
+        } else if ((c & ~0x1FFF) == 0) {
+            return (0xC0 <= c && c <= 0xD6)
+            || (0xD8 <= c && c <= 0xF6)
+            || (0xF8 <= c && c <= 0x2FF)
+            || (0x370 <= c && c <= 0x37D)
+            || 0x37F <= c;
+        }
+        return (0x200C <= c && c <= 0x200D)
+        || (0x2070 <= c && c <= 0x218F)
+        || (0x2C00 <= c && c <= 0x2FEF)
+        || (0x3001 <= c && c <= 0xD7FF)
+        || (0xF900 <= c && c <= 0xFDCF)
+        || (0xFDF0 <= c && c <= 0xFFFD)
+        || (0x10000 <= c && c <= 0xEFFFF);
+    }
+
+    private static boolean isNCNameChar(int c) {
+        if ((c & ~0x7F) == 0) {
+            // Optimize for ASCII and use - < . < 0..9 < A..Z < _ < a..z
+            if (c >= 'a') {
+                return c <= 'z';
+            } else if (c >= 'A') {
+                if (c <= 'Z') {
+                    return true;
+                }
+                return c == '_';
+            } else if (c >= '0') {
+                return c <= '9';
+            } else {
+                return c == '-' || c == '.';
+            }
+        } else if ((c & ~0x1FFF) == 0) {
+            return isNCNameStartChar(c) || c == 0xB7
+                || (0x300 <= c && c <= 0x36F);
+        }
+        return isNCNameStartChar(c) || (0x203F <= c && c <= 0x2040);
+    }
+
+    //    This means "accept" in the parsing sense
+    //    See ECMA357 13.1.2.1
+    static boolean accept(Object nameObj) {
+        String name;
+        try {
+            name = ScriptRuntime.toString(nameObj);
+        } catch (EcmaError ee) {
+            if ("TypeError".equals(ee.getName())) {
+                return false;
+            }
+            throw ee;
+        }
+
+        // See http://w3.org/TR/xml-names11/#NT-NCName
+        int length = name.length();
+        if (length != 0) {
+            if (isNCNameStartChar(name.charAt(0))) {
+                for (int i = 1; i != length; ++i) {
+                    if (!isNCNameChar(name.charAt(i))) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private XmlNode.QName qname;
+    private boolean isAttributeName;
+    private boolean isDescendants;
+    private XMLObjectImpl xmlObject;
+
+    private XMLName() {
+    }
+
+    static XMLName formStar() {
+        XMLName rv = new XMLName();
+        rv.qname = XmlNode.QName.create(null, null);
+        return rv;
+    }
+
+    /** @deprecated */
+    static XMLName formProperty(XmlNode.Namespace namespace, String localName) {
+        if (localName != null && localName.equals("*")) localName = null;
+        XMLName rv = new XMLName();
+        rv.qname = XmlNode.QName.create(namespace, localName);
+        return rv;
+    }
+
+    /** @deprecated */
+    static XMLName formProperty(String uri, String localName) {
+        return formProperty(XmlNode.Namespace.create(uri), localName);
+    }
+
+    /** @deprecated */
+    static XMLName create(String defaultNamespaceUri, String name) {
+        if (name == null)
+            throw new IllegalArgumentException();
+
+        int l = name.length();
+        if (l != 0) {
+            char firstChar = name.charAt(0);
+            if (firstChar == '*') {
+                if (l == 1) {
+                    return XMLName.formStar();
+                }
+            } else if (firstChar == '@') {
+                XMLName xmlName = XMLName.formProperty("", name.substring(1));
+                xmlName.setAttributeName();
+                return xmlName;
+            }
+        }
+
+        return XMLName.formProperty(defaultNamespaceUri, name);
+    }
+
+    static XMLName create(XmlNode.QName qname, boolean attribute, boolean descendants) {
+        XMLName rv = new XMLName();
+        rv.qname = qname;
+        rv.isAttributeName = attribute;
+        rv.isDescendants = descendants;
+        return rv;
+    }
+
+    /** @deprecated */
+    static XMLName create(XmlNode.QName qname) {
+        return create(qname, false, false);
+    }
+
+    void initXMLObject(XMLObjectImpl xmlObject) {
+        if (xmlObject == null) throw new IllegalArgumentException();
+        if (this.xmlObject != null) throw new IllegalStateException();
+        this.xmlObject = xmlObject;
+    }
+
+    String uri() {
+        if (qname.getNamespace() == null) return null;
+        return qname.getNamespace().getUri();
+    }
+
+    String localName() {
+        if (qname.getLocalName() == null) return "*";
+        return qname.getLocalName();
+    }
+
+    private void addDescendantChildren(XMLList list, XML target) {
+        XMLName xmlName = this;
+        if (target.isElement()) {
+            XML[] children = target.getChildren();
+            for (int i=0; i<children.length; i++) {
+                if (xmlName.matches( children[i] )) {
+                    list.addToList( children[i] );
+                }
+                addDescendantChildren(list, children[i]);
+            }
+        }
+    }
+
+    void addMatchingAttributes(XMLList list, XML target) {
+        XMLName name = this;
+        if (target.isElement()) {
+            XML[] attributes = target.getAttributes();
+            for (int i=0; i<attributes.length; i++) {
+                if (name.matches( attributes[i]) ) {
+                    list.addToList( attributes[i] );
+                }
+            }
+        }
+    }
+
+    private void addDescendantAttributes(XMLList list, XML target) {
+        if (target.isElement()) {
+            addMatchingAttributes(list, target);
+            XML[] children = target.getChildren();
+            for (int i=0; i<children.length; i++) {
+                addDescendantAttributes(list, children[i]);
+            }
+        }
+    }
+
+    XMLList matchDescendantAttributes(XMLList rv, XML target) {
+        rv.setTargets(target, null);
+        addDescendantAttributes(rv, target);
+        return rv;
+    }
+
+    XMLList matchDescendantChildren(XMLList rv, XML target) {
+        rv.setTargets(target, null);
+        addDescendantChildren(rv, target);
+        return rv;
+    }
+
+    void addDescendants(XMLList rv, XML target) {
+        XMLName xmlName = this;
+        if (xmlName.isAttributeName()) {
+            matchDescendantAttributes(rv, target);
+        } else {
+            matchDescendantChildren(rv, target);
+        }
+    }
+
+    private void addAttributes(XMLList rv, XML target) {
+        addMatchingAttributes(rv, target);
+    }
+
+    void addMatches(XMLList rv, XML target) {
+        if (isDescendants()) {
+            addDescendants(rv, target);
+        } else if (isAttributeName()) {
+            addAttributes(rv, target);
+        } else {
+            XML[] children = target.getChildren();
+            if (children != null) {
+                for (int i=0; i<children.length; i++) {
+                    if (this.matches(children[i])) {
+                        rv.addToList( children[i] );
+                    }
+                }
+            }
+            rv.setTargets(target, this.toQname());
+        }
+    }
+
+    XMLList getMyValueOn(XML target) {
+        XMLList rv = target.newXMLList();
+        addMatches(rv, target);
+        return rv;
+    }
+
+    void setMyValueOn(XML target, Object value) {
+        // Special-case checks for undefined and null
+        if (value == null) {
+            value = "null";
+        } else if (value instanceof Undefined) {
+            value = "undefined";
+        }
+
+        XMLName xmlName = this;
+        // Get the named property
+        if (xmlName.isAttributeName()) {
+            target.setAttribute(xmlName, value);
+        } else if (xmlName.uri() == null && xmlName.localName().equals("*")) {
+            target.setChildren(value);
+        } else {
+            // Convert text into XML if needed.
+            XMLObjectImpl xmlValue = null;
+
+            if (value instanceof XMLObjectImpl) {
+                xmlValue = (XMLObjectImpl)value;
+
+                // Check for attribute type and convert to textNode
+                if (xmlValue instanceof XML) {
+                    if (((XML)xmlValue).isAttribute()) {
+                        xmlValue = target.makeXmlFromString(xmlName, xmlValue.toString());
+                    }
+                }
+
+                if (xmlValue instanceof XMLList) {
+                    for (int i = 0; i < xmlValue.length(); i++) {
+                        XML xml = ((XMLList) xmlValue).item(i);
+
+                        if (xml.isAttribute()) {
+                            ((XMLList)xmlValue).replace(i, target.makeXmlFromString(xmlName, xml.toString()));
+                        }
+                    }
+                }
+            } else {
+                xmlValue = target.makeXmlFromString(xmlName, ScriptRuntime.toString(value));
+            }
+
+            XMLList matches = target.getPropertyList(xmlName);
+
+            if (matches.length() == 0) {
+                target.appendChild(xmlValue);
+            } else {
+                // Remove all other matches
+                for (int i = 1; i < matches.length(); i++) {
+                    target.removeChild(matches.item(i).childIndex());
+                }
+
+                // Replace first match with new value.
+                XML firstMatch = matches.item(0);
+                target.replace(firstMatch.childIndex(), xmlValue);
+            }
+        }
+    }
+
+    public boolean has(Context cx) {
+        if (xmlObject == null) {
+            return false;
+        }
+        return xmlObject.hasXMLProperty(this);
+    }
+
+    public Object get(Context cx) {
+        if (xmlObject == null) {
+            throw ScriptRuntime.undefReadError(Undefined.instance,
+                toString());
+        }
+        return xmlObject.getXMLProperty(this);
+    }
+
+    public Object set(Context cx, Object value) {
+        if (xmlObject == null) {
+            throw ScriptRuntime.undefWriteError(Undefined.instance,
+                toString(),
+                value);
+        }
+        // Assignment to descendants causes parse error on bad reference
+        // and this should not be called
+        if (isDescendants) throw Kit.codeBug();
+        xmlObject.putXMLProperty(this, value);
+        return value;
+    }
+
+    public boolean delete(Context cx) {
+        if (xmlObject == null) {
+            return true;
+        }
+        xmlObject.deleteXMLProperty(this);
+        return !xmlObject.hasXMLProperty(this);
+    }
+
+    public String toString() {
+        //return qname.localName();
+        StringBuffer buff = new StringBuffer();
+        if (isDescendants) buff.append("..");
+        if (isAttributeName) buff.append('@');
+        if (uri() == null) {
+            buff.append('*');
+            if(localName().equals("*")) {
+                return buff.toString();
+            }
+        } else {
+            buff.append('"').append(uri()).append('"');
+        }
+        buff.append(':').append(localName());
+        return buff.toString();
+    }
+
+    final XmlNode.QName toQname() {
+        return this.qname;
+    }
+
+    final boolean matchesLocalName(String localName) {
+        return localName().equals("*") || localName().equals(localName);
+    }
+
+    final boolean matchesElement(XmlNode.QName qname) {
+        if (this.uri() == null || this.uri().equals(qname.getNamespace().getUri())) {
+            if (this.localName().equals("*") || this.localName().equals(qname.getLocalName())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    final boolean matches(XML node) {
+        XmlNode.QName qname = node.getNodeQname();
+        String nodeUri = null;
+        if (qname.getNamespace() != null) {
+            nodeUri = qname.getNamespace().getUri();
+        }
+        if (isAttributeName) {
+            if (node.isAttribute()) {
+                if (this.uri() == null || this.uri().equals(nodeUri)) {
+                    if (this.localName().equals("*") || this.localName().equals(qname.getLocalName())) {
+                        return true;
+                    }
+                }
+                return false;
+            } else {
+                //    TODO    Could throw exception maybe, should not call this method on attribute name with arbitrary node type
+                //            unless we traverse all attributes and children habitually
+                return false;
+            }
+        } else {
+            if ( this.uri() == null || ((node.isElement()) && this.uri().equals(nodeUri)) ) {
+                if (localName().equals("*")) return true;
+                if (node.isElement()) {
+                    if (localName().equals(qname.getLocalName())) return true;
+                }
+            }
+            return false;
+        }
+    }
+
+    /**    @deprecated */
+    boolean isAttributeName() {
+        return isAttributeName;
+    }
+
+    //    TODO    Fix whether this is an attribute XMLName at construction?
+    /** @deprecated */
+    void setAttributeName() {
+//        if (isAttributeName) throw new IllegalStateException();
+        isAttributeName = true;
+    }
+
+    /**    @deprecated */
+    boolean isDescendants() {
+        return isDescendants;
+    }
+
+    //    TODO    Fix whether this is an descendant XMLName at construction?
+    /** @deprecated */
+    void setIsDescendants() {
+//        if (isDescendants) throw new IllegalStateException();
+        isDescendants = true;
+    }
+}
diff --git a/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLObjectImpl.java b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLObjectImpl.java
new file mode 100644
index 0000000..db918f8
--- /dev/null
+++ b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLObjectImpl.java
@@ -0,0 +1,812 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-2000
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Igor Bukanov
+ *   Ethan Hugg
+ *   Terry Lucas
+ *   Milen Nankov
+ *   David P. Caldwell <inonit@inonit.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.xmlimpl;
+
+import org.mozilla.javascript.*;
+import org.mozilla.javascript.xml.*;
+
+/**
+ *  This abstract class describes what all XML objects (XML, XMLList) should
+ *  have in common.
+ *
+ * @see XML
+ */
+abstract class XMLObjectImpl extends XMLObject {
+    private static final Object XMLOBJECT_TAG = new Object();
+    private XMLLibImpl lib;
+    private boolean prototypeFlag;
+
+    protected XMLObjectImpl(XMLLibImpl lib, Scriptable scope,
+                            XMLObject prototype)
+    {
+        initialize(lib, scope, prototype);
+    }
+
+    final void initialize(XMLLibImpl lib, Scriptable scope,
+                          XMLObject prototype)
+    {
+        setParentScope(scope);
+        setPrototype(prototype);
+        prototypeFlag = (prototype == null);
+        this.lib = lib;
+    }
+
+    final boolean isPrototype() {
+        return prototypeFlag;
+    }
+
+    XMLLibImpl getLib() {
+        return lib;
+    }
+
+    final XML newXML(XmlNode node) {
+        return lib.newXML(node);
+    }
+
+    XML xmlFromNode(XmlNode node) {
+        if (node.getXml() == null) {
+            node.setXml( newXML(node) );
+        }
+        return node.getXml();
+    }
+
+    final XMLList newXMLList() {
+        return lib.newXMLList();
+    }
+
+    final XMLList newXMLListFrom(Object o) {
+        return lib.newXMLListFrom(o);
+    }
+
+    final XmlProcessor getProcessor() {
+        return lib.getProcessor();
+    }
+
+    final QName newQName(String uri, String localName, String prefix) {
+        return lib.newQName(uri, localName, prefix);
+    }
+
+    final QName newQName(XmlNode.QName name) {
+        return lib.newQName(name);
+    }
+
+    final Namespace createNamespace(XmlNode.Namespace declaration) {
+        if (declaration == null) return null;
+        return lib.createNamespaces( new XmlNode.Namespace[] { declaration } )[0];
+    }
+
+    final Namespace[] createNamespaces(XmlNode.Namespace[] declarations) {
+        return lib.createNamespaces(declarations);
+    }
+
+    //
+    //    Scriptable
+    //
+
+    public final Object get(String name, Scriptable start) {
+        return super.get(name, start);
+    }
+
+    public final boolean has(String name, Scriptable start) {
+        return super.has(name, start);
+    }
+
+    public final void put(String name, Scriptable start, Object value) {
+        super.put(name, start, value);
+    }
+
+    public final void delete(String name) {
+        //    TODO    I am not sure about this, but this is how I found it.  DPC
+        throw new IllegalArgumentException("String: [" + name + "]");
+    }
+
+    public final Scriptable getPrototype() {
+        return super.getPrototype();
+    }
+
+    public final void setPrototype(Scriptable prototype) {
+        super.setPrototype(prototype);
+    }
+
+    public final Scriptable getParentScope() {
+        return super.getParentScope();
+    }
+
+    public final void setParentScope(Scriptable parent) {
+        super.setParentScope(parent);
+    }
+
+    public final Object getDefaultValue(Class hint) {
+        return this.toString();
+    }
+
+    public final boolean hasInstance(Scriptable scriptable) {
+        return super.hasInstance(scriptable);
+    }
+
+    /**
+     * ecmaHas(cx, id) calls this after resolving when id to XMLName
+     * and checking it is not Uint32 index.
+     */
+    abstract boolean hasXMLProperty(XMLName name);
+
+    /**
+     * ecmaGet(cx, id) calls this after resolving when id to XMLName
+     * and checking it is not Uint32 index.
+     */
+    abstract Object getXMLProperty(XMLName name);
+
+    /**
+     * ecmaPut(cx, id, value) calls this after resolving when id to XMLName
+     * and checking it is not Uint32 index.
+     */
+    abstract void putXMLProperty(XMLName name, Object value);
+
+    /**
+     * ecmaDelete(cx, id) calls this after resolving when id to XMLName
+     * and checking it is not Uint32 index.
+     */
+    abstract void deleteXMLProperty(XMLName name);
+
+    /**
+     * Test XML equality with target the target.
+     */
+    abstract boolean equivalentXml(Object target);
+
+    abstract void addMatches(XMLList rv, XMLName name);
+
+    private XMLList getMatches(XMLName name) {
+        XMLList rv = newXMLList();
+        addMatches(rv, name);
+        return rv;
+    }
+
+    abstract XML getXML();
+
+    // Methods from section 12.4.4 in the spec
+    abstract XMLList child(int index);
+    abstract XMLList child(XMLName xmlName);
+    abstract XMLList children();
+    abstract XMLList comments();
+    abstract boolean contains(Object xml);
+    abstract XMLObjectImpl copy();
+    abstract XMLList elements(XMLName xmlName);
+    abstract boolean hasOwnProperty(XMLName xmlName);
+    abstract boolean hasComplexContent();
+    abstract boolean hasSimpleContent();
+    abstract int length();
+    abstract void normalize();
+    abstract Object parent();
+    abstract XMLList processingInstructions(XMLName xmlName);
+    abstract boolean propertyIsEnumerable(Object member);
+    abstract XMLList text();
+    public abstract String toString();
+    abstract String toXMLString();
+    abstract Object valueOf();
+
+    protected abstract Object jsConstructor(Context cx, boolean inNewExpr, Object[] args);
+
+    final Object getMethod(String id) {
+        return super.get(id, this);
+    }
+
+    //
+    //
+    // Methods overriding ScriptableObject
+    //
+    //
+
+    /**
+     * XMLObject always compare with any value and equivalentValues
+     * never returns {@link Scriptable#NOT_FOUND} for them but rather
+     * calls equivalentXml(value) and wrap the result as Boolean.
+     */
+    protected final Object equivalentValues(Object value) {
+        boolean result = equivalentXml(value);
+        return result ? Boolean.TRUE : Boolean.FALSE;
+    }
+
+    //
+    //
+    // Methods overriding XMLObject
+    //
+    //
+
+    /**
+     * Implementation of ECMAScript [[Has]]
+     */
+    public final boolean ecmaHas(Context cx, Object id) {
+        if (cx == null) cx = Context.getCurrentContext();
+        XMLName xmlName = lib.toXMLNameOrIndex(cx, id);
+        if (xmlName == null) {
+            long index = ScriptRuntime.lastUint32Result(cx);
+            // XXX Fix this cast
+            return has((int)index, this);
+        }
+        return hasXMLProperty(xmlName);
+    }
+
+    /**
+     * Implementation of ECMAScript [[Get]]
+     */
+    public final Object ecmaGet(Context cx, Object id) {
+        if (cx == null) cx = Context.getCurrentContext();
+        XMLName xmlName = lib.toXMLNameOrIndex(cx, id);
+        if (xmlName == null) {
+            long index = ScriptRuntime.lastUint32Result(cx);
+            // XXX Fix this cast
+            Object result = get((int)index, this);
+            if (result == Scriptable.NOT_FOUND) {
+                result = Undefined.instance;
+            }
+            return result;
+        }
+        return getXMLProperty(xmlName);
+    }
+
+    /**
+     * Implementation of ECMAScript [[Put]]
+     */
+    public final void ecmaPut(Context cx, Object id, Object value) {
+        if (cx == null) cx = Context.getCurrentContext();
+        XMLName xmlName = lib.toXMLNameOrIndex(cx, id);
+        if (xmlName == null) {
+            long index = ScriptRuntime.lastUint32Result(cx);
+            // XXX Fix this cast
+            put((int)index, this, value);
+            return;
+        }
+        putXMLProperty(xmlName, value);
+    }
+
+    /**
+     * Implementation of ECMAScript [[Delete]].
+     */
+    public final boolean ecmaDelete(Context cx, Object id) {
+        if (cx == null) cx = Context.getCurrentContext();
+        XMLName xmlName = lib.toXMLNameOrIndex(cx, id);
+        if (xmlName == null) {
+            long index = ScriptRuntime.lastUint32Result(cx);
+            // XXX Fix this
+            delete((int)index);
+            return true;
+        }
+        deleteXMLProperty(xmlName);
+        return true;
+    }
+
+    //    TODO    Can this be made more strongly typed?
+    public Ref memberRef(Context cx, Object elem, int memberTypeFlags) {
+        boolean attribute = (memberTypeFlags & Node.ATTRIBUTE_FLAG) != 0;
+        boolean descendants = (memberTypeFlags & Node.DESCENDANTS_FLAG) != 0;
+        if (!attribute && !descendants) {
+            // Code generation would use ecma(Get|Has|Delete|Set) for
+            // normal name identifiers so one ATTRIBUTE_FLAG
+            // or DESCENDANTS_FLAG has to be set
+            throw Kit.codeBug();
+        }
+        XmlNode.QName qname = lib.toNodeQName(cx, elem, attribute);
+        XMLName rv = XMLName.create(qname, attribute, descendants);
+        rv.initXMLObject(this);
+        return rv;
+    }
+
+    /**
+     * Generic reference to implement x::ns, x.@ns::y, x..@ns::y etc.
+     */
+    public Ref memberRef(Context cx, Object namespace, Object elem, int memberTypeFlags) {
+        boolean attribute = (memberTypeFlags & Node.ATTRIBUTE_FLAG) != 0;
+        boolean descendants = (memberTypeFlags & Node.DESCENDANTS_FLAG) != 0;
+        XMLName rv = XMLName.create(lib.toNodeQName(cx, namespace, elem), attribute, descendants);
+        rv.initXMLObject(this);
+        return rv;
+    }
+
+    public NativeWith enterWith(Scriptable scope) {
+        return new XMLWithScope(lib, scope, this);
+    }
+
+    public NativeWith enterDotQuery(Scriptable scope) {
+        XMLWithScope xws = new XMLWithScope(lib, scope, this);
+        xws.initAsDotQuery();
+        return xws;
+    }
+
+    public final Object addValues(Context cx, boolean thisIsLeft,
+        Object value) {
+        if (value instanceof XMLObject) {
+            XMLObject v1, v2;
+            if (thisIsLeft) {
+                v1 = this;
+                v2 = (XMLObject)value;
+            } else {
+                v1 = (XMLObject)value;
+                v2 = this;
+            }
+            return lib.addXMLObjects(cx, v1, v2);
+        }
+        if (value == Undefined.instance) {
+            // both "xml + undefined" and "undefined + xml" gives String(xml)
+            return ScriptRuntime.toString(this);
+        }
+
+        return super.addValues(cx, thisIsLeft, value);
+    }
+
+    //
+    //
+    // IdScriptableObject machinery
+    //
+    //
+
+    final void exportAsJSClass(boolean sealed) {
+        prototypeFlag = true;
+        exportAsJSClass(MAX_PROTOTYPE_ID, getParentScope(), sealed);
+    }
+
+// #string_id_map#
+    private final static int
+        Id_constructor             = 1,
+
+        Id_addNamespace            = 2,
+        Id_appendChild             = 3,
+        Id_attribute               = 4,
+        Id_attributes              = 5,
+        Id_child                   = 6,
+        Id_childIndex              = 7,
+        Id_children                = 8,
+        Id_comments                = 9,
+        Id_contains                = 10,
+        Id_copy                    = 11,
+        Id_descendants             = 12,
+        Id_elements                = 13,
+        Id_inScopeNamespaces       = 14,
+        Id_insertChildAfter        = 15,
+        Id_insertChildBefore       = 16,
+        Id_hasOwnProperty          = 17,
+        Id_hasComplexContent       = 18,
+        Id_hasSimpleContent        = 19,
+        Id_length                  = 20,
+        Id_localName               = 21,
+        Id_name                    = 22,
+        Id_namespace               = 23,
+        Id_namespaceDeclarations   = 24,
+        Id_nodeKind                = 25,
+        Id_normalize               = 26,
+        Id_parent                  = 27,
+        Id_prependChild            = 28,
+        Id_processingInstructions  = 29,
+        Id_propertyIsEnumerable    = 30,
+        Id_removeNamespace         = 31,
+        Id_replace                 = 32,
+        Id_setChildren             = 33,
+        Id_setLocalName            = 34,
+        Id_setName                 = 35,
+        Id_setNamespace            = 36,
+        Id_text                    = 37,
+        Id_toString                = 38,
+        Id_toXMLString             = 39,
+        Id_valueOf                 = 40,
+
+        MAX_PROTOTYPE_ID           = 40;
+
+    protected int findPrototypeId(String s) {
+        int id;
+// #generated# Last update: 2007-08-20 09:04:06 EDT
+        L0: { id = 0; String X = null; int c;
+            L: switch (s.length()) {
+            case 4: c=s.charAt(0);
+                if (c=='c') { X="copy";id=Id_copy; }
+                else if (c=='n') { X="name";id=Id_name; }
+                else if (c=='t') { X="text";id=Id_text; }
+                break L;
+            case 5: X="child";id=Id_child; break L;
+            case 6: c=s.charAt(0);
+                if (c=='l') { X="length";id=Id_length; }
+                else if (c=='p') { X="parent";id=Id_parent; }
+                break L;
+            case 7: c=s.charAt(0);
+                if (c=='r') { X="replace";id=Id_replace; }
+                else if (c=='s') { X="setName";id=Id_setName; }
+                else if (c=='v') { X="valueOf";id=Id_valueOf; }
+                break L;
+            case 8: switch (s.charAt(2)) {
+                case 'S': X="toString";id=Id_toString; break L;
+                case 'd': X="nodeKind";id=Id_nodeKind; break L;
+                case 'e': X="elements";id=Id_elements; break L;
+                case 'i': X="children";id=Id_children; break L;
+                case 'm': X="comments";id=Id_comments; break L;
+                case 'n': X="contains";id=Id_contains; break L;
+                } break L;
+            case 9: switch (s.charAt(2)) {
+                case 'c': X="localName";id=Id_localName; break L;
+                case 'm': X="namespace";id=Id_namespace; break L;
+                case 'r': X="normalize";id=Id_normalize; break L;
+                case 't': X="attribute";id=Id_attribute; break L;
+                } break L;
+            case 10: c=s.charAt(0);
+                if (c=='a') { X="attributes";id=Id_attributes; }
+                else if (c=='c') { X="childIndex";id=Id_childIndex; }
+                break L;
+            case 11: switch (s.charAt(0)) {
+                case 'a': X="appendChild";id=Id_appendChild; break L;
+                case 'c': X="constructor";id=Id_constructor; break L;
+                case 'd': X="descendants";id=Id_descendants; break L;
+                case 's': X="setChildren";id=Id_setChildren; break L;
+                case 't': X="toXMLString";id=Id_toXMLString; break L;
+                } break L;
+            case 12: c=s.charAt(0);
+                if (c=='a') { X="addNamespace";id=Id_addNamespace; }
+                else if (c=='p') { X="prependChild";id=Id_prependChild; }
+                else if (c=='s') {
+                    c=s.charAt(3);
+                    if (c=='L') { X="setLocalName";id=Id_setLocalName; }
+                    else if (c=='N') { X="setNamespace";id=Id_setNamespace; }
+                }
+                break L;
+            case 14: X="hasOwnProperty";id=Id_hasOwnProperty; break L;
+            case 15: X="removeNamespace";id=Id_removeNamespace; break L;
+            case 16: c=s.charAt(0);
+                if (c=='h') { X="hasSimpleContent";id=Id_hasSimpleContent; }
+                else if (c=='i') { X="insertChildAfter";id=Id_insertChildAfter; }
+                break L;
+            case 17: c=s.charAt(3);
+                if (c=='C') { X="hasComplexContent";id=Id_hasComplexContent; }
+                else if (c=='c') { X="inScopeNamespaces";id=Id_inScopeNamespaces; }
+                else if (c=='e') { X="insertChildBefore";id=Id_insertChildBefore; }
+                break L;
+            case 20: X="propertyIsEnumerable";id=Id_propertyIsEnumerable; break L;
+            case 21: X="namespaceDeclarations";id=Id_namespaceDeclarations; break L;
+            case 22: X="processingInstructions";id=Id_processingInstructions; break L;
+            }
+            if (X!=null && X!=s && !X.equals(s)) id = 0;
+            break L0;
+        }
+// #/generated#
+        return id;
+    }
+// #/string_id_map#
+
+    protected void initPrototypeId(int id) {
+        String s;
+        int arity;
+        switch (id) {
+            case Id_constructor: {
+                IdFunctionObject ctor;
+                if (this instanceof XML) {
+                    ctor = new XMLCtor((XML)this, XMLOBJECT_TAG, id, 1);
+                } else {
+                    ctor = new IdFunctionObject(this, XMLOBJECT_TAG, id, 1);
+                }
+                initPrototypeConstructor(ctor);
+                return;
+            }
+
+            case Id_addNamespace:      arity=1; s="addNamespace";      break;
+            case Id_appendChild:       arity=1; s="appendChild";       break;
+            case Id_attribute:         arity=1; s="attribute";         break;
+            case Id_attributes:        arity=0; s="attributes";        break;
+            case Id_child:             arity=1; s="child";             break;
+            case Id_childIndex:        arity=0; s="childIndex";        break;
+            case Id_children:          arity=0; s="children";          break;
+            case Id_comments:          arity=0; s="comments";          break;
+            case Id_contains:          arity=1; s="contains";          break;
+            case Id_copy:              arity=0; s="copy";              break;
+            case Id_descendants:       arity=1; s="descendants";       break;
+            case Id_elements:          arity=1; s="elements";          break;
+            case Id_hasComplexContent: arity=0; s="hasComplexContent"; break;
+            case Id_hasOwnProperty:    arity=1; s="hasOwnProperty";    break;
+            case Id_hasSimpleContent:  arity=0; s="hasSimpleContent";  break;
+            case Id_inScopeNamespaces: arity=0; s="inScopeNamespaces"; break;
+            case Id_insertChildAfter:  arity=2; s="insertChildAfter";  break;
+            case Id_insertChildBefore: arity=2; s="insertChildBefore"; break;
+            case Id_length:            arity=0; s="length";            break;
+            case Id_localName:         arity=0; s="localName";         break;
+            case Id_name:              arity=0; s="name";              break;
+            case Id_namespace:         arity=1; s="namespace";         break;
+            case Id_namespaceDeclarations:
+                arity=0; s="namespaceDeclarations"; break;
+            case Id_nodeKind:          arity=0; s="nodeKind";          break;
+            case Id_normalize:         arity=0; s="normalize";         break;
+            case Id_parent:            arity=0; s="parent";            break;
+            case Id_prependChild:      arity=1; s="prependChild";      break;
+            case Id_processingInstructions:
+                arity=1; s="processingInstructions"; break;
+            case Id_propertyIsEnumerable:
+                arity=1; s="propertyIsEnumerable"; break;
+            case Id_removeNamespace:   arity=1; s="removeNamespace";   break;
+            case Id_replace:           arity=2; s="replace";           break;
+            case Id_setChildren:       arity=1; s="setChildren";       break;
+            case Id_setLocalName:      arity=1; s="setLocalName";      break;
+            case Id_setName:           arity=1; s="setName";           break;
+            case Id_setNamespace:      arity=1; s="setNamespace";      break;
+            case Id_text:              arity=0; s="text";              break;
+            case Id_toString:          arity=0; s="toString";          break;
+            case Id_toXMLString:       arity=1; s="toXMLString";       break;
+            case Id_valueOf:           arity=0; s="valueOf";           break;
+
+            default: throw new IllegalArgumentException(String.valueOf(id));
+        }
+        initPrototypeMethod(XMLOBJECT_TAG, id, s, arity);
+    }
+
+    private Object[] toObjectArray(Object[] typed) {
+        Object[] rv = new Object[typed.length];
+        for (int i=0; i<rv.length; i++) {
+            rv[i] = typed[i];
+        }
+        return rv;
+    }
+
+    private void xmlMethodNotFound(Object object, String name) {
+        throw ScriptRuntime.notFunctionError(object, name);
+    }
+
+    public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope, Scriptable thisObj, Object[] args) {
+        if (!f.hasTag(XMLOBJECT_TAG)) {
+            return super.execIdCall(f, cx, scope, thisObj, args);
+        }
+        int id = f.methodId();
+        if (id == Id_constructor) {
+            return jsConstructor(cx, thisObj == null, args);
+        }
+
+        // All (XML|XMLList).prototype methods require thisObj to be XML
+        if (!(thisObj instanceof XMLObjectImpl))
+            throw incompatibleCallError(f);
+        XMLObjectImpl realThis = (XMLObjectImpl)thisObj;
+
+        XML xml = realThis.getXML();
+        switch (id) {
+            case Id_appendChild: {
+                if (xml == null) xmlMethodNotFound(realThis, "appendChild");
+                return xml.appendChild(arg(args, 0));
+            }
+            case Id_addNamespace: {
+                if (xml == null) xmlMethodNotFound(realThis, "addNamespace");
+                Namespace ns = lib.castToNamespace(cx, arg(args, 0));
+                return xml.addNamespace(ns);
+            }
+            case Id_childIndex: {
+                if (xml == null) xmlMethodNotFound(realThis, "childIndex");
+                return ScriptRuntime.wrapInt(xml.childIndex());
+            }
+            case Id_inScopeNamespaces: {
+                if (xml == null) xmlMethodNotFound(realThis, "inScopeNamespaces");
+                return cx.newArray(scope, toObjectArray(xml.inScopeNamespaces()));
+            }
+            case Id_insertChildAfter: {
+                if (xml == null) xmlMethodNotFound(realThis, "insertChildAfter");
+                Object arg0 = arg(args, 0);
+                if (arg0 == null || arg0 instanceof XML) {
+                    return xml.insertChildAfter((XML)arg0, arg(args, 1));
+                }
+                return Undefined.instance;
+            }
+            case Id_insertChildBefore: {
+                if (xml == null) xmlMethodNotFound(realThis, "insertChildBefore");
+                Object arg0 = arg(args, 0);
+                if (arg0 == null || arg0 instanceof XML) {
+                    return xml.insertChildBefore((XML)arg0, arg(args, 1));
+                }
+                return Undefined.instance;
+            }
+            case Id_localName: {
+                if (xml == null) xmlMethodNotFound(realThis, "localName");
+                return xml.localName();
+            }
+            case Id_name: {
+                if (xml == null) xmlMethodNotFound(realThis, "name");
+                return xml.name();
+            }
+            case Id_namespace: {
+                if (xml == null) xmlMethodNotFound(realThis, "namespace");
+                String prefix = (args.length > 0) ? ScriptRuntime.toString(args[0]) : null;
+                Namespace rv = xml.namespace(prefix);
+                if (rv == null) {
+                    return Undefined.instance;
+                } else {
+                    return rv;
+                }
+            }
+            case Id_namespaceDeclarations: {
+                if (xml == null) xmlMethodNotFound(realThis, "namespaceDeclarations");
+                Namespace[] array = xml.namespaceDeclarations();
+                return cx.newArray(scope, toObjectArray(array));
+            }
+            case Id_nodeKind: {
+                if (xml == null) xmlMethodNotFound(realThis, "nodeKind");
+                return xml.nodeKind();
+            }
+            case Id_prependChild: {
+                if (xml == null) xmlMethodNotFound(realThis, "prependChild");
+                return xml.prependChild(arg(args, 0));
+            }
+            case Id_removeNamespace: {
+                if (xml == null) xmlMethodNotFound(realThis, "removeNamespace");
+                Namespace ns = lib.castToNamespace(cx, arg(args, 0));
+                return xml.removeNamespace(ns);
+            }
+            case Id_replace: {
+                if (xml == null) xmlMethodNotFound(realThis, "replace");
+                XMLName xmlName = lib.toXMLNameOrIndex(cx, arg(args, 0));
+                Object arg1 = arg(args, 1);
+                if (xmlName == null) {
+                    //    I refuse to believe that this number will exceed 2^31
+                    int index = (int)ScriptRuntime.lastUint32Result(cx);
+                    return xml.replace(index, arg1);
+                } else {
+                    return xml.replace(xmlName, arg1);
+                }
+            }
+            case Id_setChildren: {
+                if (xml == null) xmlMethodNotFound(realThis, "setChildren");
+                return xml.setChildren(arg(args, 0));
+            }
+            case Id_setLocalName: {
+                if (xml == null) xmlMethodNotFound(realThis, "setLocalName");
+                String localName;
+                Object arg = arg(args, 0);
+                if (arg instanceof QName) {
+                    localName = ((QName)arg).localName();
+                } else {
+                    localName = ScriptRuntime.toString(arg);
+                }
+                xml.setLocalName(localName);
+                return Undefined.instance;
+            }
+            case Id_setName: {
+                if (xml == null) xmlMethodNotFound(realThis, "setName");
+                Object arg = (args.length != 0) ? args[0] : Undefined.instance;
+                QName qname = lib.constructQName(cx, arg);
+                xml.setName(qname);
+                return Undefined.instance;
+            }
+            case Id_setNamespace: {
+                if (xml == null) xmlMethodNotFound(realThis, "setNamespace");
+                Namespace ns = lib.castToNamespace(cx, arg(args, 0));
+                xml.setNamespace(ns);
+                return Undefined.instance;
+            }
+
+            case Id_attribute: {
+                XMLName xmlName = XMLName.create( lib.toNodeQName(cx, arg(args, 0), true), true, false );
+                return realThis.getMatches(xmlName);
+            }
+            case Id_attributes:
+                return realThis.getMatches(XMLName.create(XmlNode.QName.create(null, null), true, false));
+            case Id_child: {
+                XMLName xmlName = lib.toXMLNameOrIndex(cx, arg(args, 0));
+                if (xmlName == null) {
+                    //    Two billion or so is a fine upper limit, so we cast to int
+                    int index = (int)ScriptRuntime.lastUint32Result(cx);
+                    return realThis.child(index);
+                } else {
+                    return realThis.child(xmlName);
+                }
+            }
+            case Id_children:
+                return realThis.children();
+            case Id_comments:
+                return realThis.comments();
+            case Id_contains:
+                return ScriptRuntime.wrapBoolean(
+                    realThis.contains(arg(args, 0)));
+            case Id_copy:
+                return realThis.copy();
+            case Id_descendants: {
+                XmlNode.QName qname = (args.length == 0) ? XmlNode.QName.create(null, null) : lib.toNodeQName(cx, args[0], false);
+                return realThis.getMatches( XMLName.create(qname, false, true) );
+            }
+            case Id_elements: {
+                XMLName xmlName = (args.length == 0)
+                ? XMLName.formStar()
+                : lib.toXMLName(cx, args[0]);
+                return realThis.elements(xmlName);
+            }
+            case Id_hasOwnProperty: {
+                XMLName xmlName = lib.toXMLName(cx, arg(args, 0));
+                return ScriptRuntime.wrapBoolean(
+                    realThis.hasOwnProperty(xmlName));
+            }
+            case Id_hasComplexContent:
+                return ScriptRuntime.wrapBoolean(realThis.hasComplexContent());
+            case Id_hasSimpleContent:
+                return ScriptRuntime.wrapBoolean(realThis.hasSimpleContent());
+            case Id_length:
+                return ScriptRuntime.wrapInt(realThis.length());
+            case Id_normalize:
+                realThis.normalize();
+                return Undefined.instance;
+            case Id_parent:
+                return realThis.parent();
+            case Id_processingInstructions: {
+                XMLName xmlName = (args.length > 0)
+                ? lib.toXMLName(cx, args[0])
+                : XMLName.formStar();
+                return realThis.processingInstructions(xmlName);
+            }
+            case Id_propertyIsEnumerable: {
+                return ScriptRuntime.wrapBoolean(
+                    realThis.propertyIsEnumerable(arg(args, 0)));
+            }
+            case Id_text:
+                return realThis.text();
+            case Id_toString:
+                return realThis.toString();
+            case Id_toXMLString: {
+                return realThis.toXMLString();
+            }
+            case Id_valueOf:
+                return realThis.valueOf();
+        }
+        throw new IllegalArgumentException(String.valueOf(id));
+    }
+
+    private static Object arg(Object[] args, int i) {
+        return (i < args.length) ? args[i] : Undefined.instance;
+    }
+
+    final XML newTextElementXML(XmlNode reference, XmlNode.QName qname, String value) {
+        return lib.newTextElementXML(reference, qname, value);
+    }
+
+    /** @deprecated Hopefully this can be replaced with ecmaToXml below. */
+    final XML newXMLFromJs(Object inputObject) {
+        return lib.newXMLFromJs(inputObject);
+    }
+
+    final XML ecmaToXml(Object object) {
+        return lib.ecmaToXml(object);
+    }
+
+    final String ecmaEscapeAttributeValue(String s) {
+        //    TODO    Check this
+        String quoted = lib.escapeAttributeValue(s);
+        return quoted.substring(1, quoted.length() - 1);
+    }
+
+    final XML createEmptyXML() {
+        return newXML(XmlNode.createEmpty(getProcessor()));
+    }
+}
diff --git a/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLWithScope.java b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLWithScope.java
new file mode 100644
index 0000000..fbeb45e
--- /dev/null
+++ b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XMLWithScope.java
@@ -0,0 +1,125 @@
+/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino code, released
+ * May 6, 1999.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1997-1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Norris Boyd
+ *   Ethan Hugg
+ *   Terry Lucas
+ *   Milen Nankov
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.xmlimpl;
+
+import org.mozilla.javascript.*;
+import org.mozilla.javascript.xml.*;
+
+final class XMLWithScope extends NativeWith
+{
+    private static final long serialVersionUID = -696429282095170887L;
+
+    private XMLLibImpl lib;
+    private int         _currIndex;
+    private XMLList     _xmlList;
+    private XMLObject   _dqPrototype;
+
+    XMLWithScope(XMLLibImpl lib, Scriptable parent, XMLObject prototype)
+    {
+        super(parent, prototype);
+        this.lib = lib;
+    }
+
+    void initAsDotQuery()
+    {
+        XMLObject prototype = (XMLObject)getPrototype();
+        // XMLWithScope also handles the .(xxx) DotQuery for XML
+        // basically DotQuery is a for/in/with statement and in
+        // the following 3 statements we setup to signal it's
+        // DotQuery,
+        // the index and the object being looped over.  The
+        // xws.setPrototype is the scope of the object which is
+        // is a element of the lhs (XMLList).
+        _currIndex = 0;
+        _dqPrototype = prototype;
+        if (prototype instanceof XMLList) {
+            XMLList xl = (XMLList)prototype;
+            if (xl.length() > 0) {
+                setPrototype((Scriptable)(xl.get(0, null)));
+            }
+        }
+        // Always return the outer-most type of XML lValue of
+        // XML to left of dotQuery.
+        _xmlList = lib.newXMLList();
+    }
+
+    protected Object updateDotQuery(boolean value)
+    {
+        // Return null to continue looping
+
+        XMLObject seed = _dqPrototype;
+        XMLList xmlL = _xmlList;
+
+        if (seed instanceof XMLList) {
+            // We're a list so keep testing each element of the list if the
+            // result on the top of stack is true then that element is added
+            // to our result list.  If false, we try the next element.
+            XMLList orgXmlL = (XMLList)seed;
+
+            int idx = _currIndex;
+
+            if (value) {
+                xmlL.addToList(orgXmlL.get(idx, null));
+            }
+
+            // More elements to test?
+            if (++idx < orgXmlL.length()) {
+                // Yes, set our new index, get the next element and
+                // reset the expression to run with this object as
+                // the WITH selector.
+                _currIndex = idx;
+                setPrototype((Scriptable)(orgXmlL.get(idx, null)));
+
+                // continue looping
+                return null;
+            }
+        } else {
+            // If we're not a XMLList then there's no looping
+            // just return DQPrototype if the result is true.
+            if (value) {
+              xmlL.addToList(seed);
+            }
+        }
+
+        return xmlL;
+    }
+}
diff --git a/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XmlNode.java b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XmlNode.java
new file mode 100644
index 0000000..06955d0
--- /dev/null
+++ b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XmlNode.java
@@ -0,0 +1,869 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino DOM-only E4X implementation.
+ *
+ * The Initial Developer of the Original Code is
+ * David P. Caldwell.
+ * Portions created by David P. Caldwell are Copyright (C)
+ * 2007 David P. Caldwell. All Rights Reserved.
+ *
+ *
+ * Contributor(s):
+ *   David P. Caldwell <inonit@inonit.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.xmlimpl;
+
+import java.util.*;
+
+import org.w3c.dom.*;
+
+import org.mozilla.javascript.*;
+
+//    Disambiguate with org.mozilla.javascript
+import org.w3c.dom.Node;
+
+class XmlNode {
+    private static final String XML_NAMESPACES_NAMESPACE_URI = "http://www.w3.org/2000/xmlns/";
+
+    private static final String USER_DATA_XMLNODE_KEY = XmlNode.class.getName();
+
+    private static final boolean DOM_LEVEL_3 = true;
+
+    private static XmlNode getUserData(Node node) {
+        if (DOM_LEVEL_3) {
+            return (XmlNode)node.getUserData(USER_DATA_XMLNODE_KEY);
+        }
+        return null;
+    }
+
+    private static void setUserData(Node node, XmlNode wrap) {
+        if (DOM_LEVEL_3) {
+            node.setUserData(USER_DATA_XMLNODE_KEY, wrap, wrap.events);
+        }
+    }
+
+    private static XmlNode createImpl(Node node) {
+        if (node instanceof Document) throw new IllegalArgumentException();
+        XmlNode rv = null;
+        if (getUserData(node) == null) {
+            rv = new XmlNode();
+            rv.dom = node;
+            setUserData(node, rv);
+        } else {
+            rv = getUserData(node);
+        }
+        return rv;
+    }
+
+    static XmlNode newElementWithText(XmlProcessor processor, XmlNode reference, XmlNode.QName qname, String value) {
+        if (reference instanceof org.w3c.dom.Document) throw new IllegalArgumentException("Cannot use Document node as reference");
+        Document document = null;
+        if (reference != null) {
+            document = reference.dom.getOwnerDocument();
+        } else {
+            document = processor.newDocument();
+        }
+        Node referenceDom = (reference != null) ? reference.dom : null;
+        Element e = document.createElementNS(qname.getUri(), qname.qualify(referenceDom));
+        if (value != null) {
+            e.appendChild(document.createTextNode(value));
+        }
+        return XmlNode.createImpl(e);
+    }
+
+    static XmlNode createText(XmlProcessor processor, String value) {
+        return createImpl( processor.newDocument().createTextNode(value) );
+    }
+
+    static XmlNode createElementFromNode(Node node) {
+        if (node instanceof Document)
+            node = ((Document) node).getDocumentElement();
+        return createImpl(node);
+    }
+
+    static XmlNode createElement(XmlProcessor processor, String namespaceUri, String xml) throws org.xml.sax.SAXException {
+        return createImpl( processor.toXml(namespaceUri, xml) );
+    }
+
+    static XmlNode createEmpty(XmlProcessor processor) {
+        return createText(processor, "");
+    }
+
+    private static XmlNode copy(XmlNode other) {
+        return createImpl( other.dom.cloneNode(true) );
+    }
+
+    private static final long serialVersionUID = 1L;
+
+    private UserDataHandler events = new UserDataHandler() {
+        public void handle(short operation, String key, Object data, Node src, Node dest) {
+        }
+    };
+
+    private Node dom;
+
+    private XML xml;
+
+    private XmlNode() {
+    }
+
+    String debug() {
+        XmlProcessor raw = new XmlProcessor();
+        raw.setIgnoreComments(false);
+        raw.setIgnoreProcessingInstructions(false);
+        raw.setIgnoreWhitespace(false);
+        raw.setPrettyPrinting(false);
+        return raw.ecmaToXmlString(this.dom);
+    }
+
+    public String toString() {
+        return "XmlNode: type=" + dom.getNodeType() + " dom=" + dom.toString();
+    }
+
+    XML getXml() {
+        return xml;
+    }
+
+    void setXml(XML xml) {
+        this.xml = xml;
+    }
+
+    int getChildCount() {
+        return this.dom.getChildNodes().getLength();
+    }
+
+    XmlNode parent() {
+        Node domParent = dom.getParentNode();
+        if (domParent instanceof Document) return null;
+        if (domParent == null) return null;
+        return createImpl(domParent);
+    }
+
+    int getChildIndex() {
+        if (this.isAttributeType()) return -1;
+        if (parent() == null) return -1;
+        org.w3c.dom.NodeList siblings = this.dom.getParentNode().getChildNodes();
+        for (int i=0; i<siblings.getLength(); i++) {
+            if (siblings.item(i) == dom) {
+                return i;
+            }
+        }
+        //    Either the parent is -1 or one of the this node's parent's children is this node.
+        throw new RuntimeException("Unreachable.");
+    }
+
+    void removeChild(int index) {
+        this.dom.removeChild( this.dom.getChildNodes().item(index) );
+    }
+
+    String toXmlString(XmlProcessor processor) {
+        return processor.ecmaToXmlString(this.dom);
+    }
+
+    String ecmaValue() {
+        //    TODO    See ECMA 357 Section 9.1
+        if (isTextType()) {
+            return ((org.w3c.dom.Text)dom).getData();
+        } else if (isAttributeType()) {
+            return ((org.w3c.dom.Attr)dom).getValue();
+        } else if (isProcessingInstructionType()) {
+            return ((org.w3c.dom.ProcessingInstruction)dom).getData();
+        } else if (isCommentType()) {
+            return ((org.w3c.dom.Comment)dom).getNodeValue();
+        } else if (isElementType()) {
+            throw new RuntimeException("Unimplemented ecmaValue() for elements.");
+        } else {
+            throw new RuntimeException("Unimplemented for node " + dom);
+        }
+    }
+
+    void deleteMe() {
+        if (dom instanceof Attr) {
+            Attr attr = (Attr)this.dom;
+            attr.getOwnerElement().getAttributes().removeNamedItemNS(attr.getNamespaceURI(), attr.getLocalName());
+        } else {
+            if (this.dom.getParentNode() != null) {
+                this.dom.getParentNode().removeChild(this.dom);
+            } else {
+                //    This case can be exercised at least when executing the regression
+                //    tests under https://bugzilla.mozilla.org/show_bug.cgi?id=354145
+            }
+        }
+    }
+
+    void normalize() {
+        this.dom.normalize();
+    }
+
+    void insertChildAt(int index, XmlNode node) {
+        Node parent = this.dom;
+        Node child = parent.getOwnerDocument().importNode( node.dom, true );
+        if (parent.getChildNodes().getLength() < index) {
+            //    TODO    Check ECMA for what happens here
+            throw new IllegalArgumentException("index=" + index + " length=" + parent.getChildNodes().getLength());
+        }
+        if (parent.getChildNodes().getLength() == index) {
+            parent.appendChild(child);
+        } else {
+            parent.insertBefore(child, parent.getChildNodes().item(index));
+        }
+    }
+
+    void insertChildrenAt(int index, XmlNode[] nodes) {
+        for (int i=0; i<nodes.length; i++) {
+            insertChildAt(index+i, nodes[i]);
+        }
+    }
+
+    XmlNode getChild(int index) {
+        Node child = dom.getChildNodes().item(index);
+        return createImpl(child);
+    }
+
+    //    Helper method for XML.hasSimpleContent()
+    boolean hasChildElement() {
+        org.w3c.dom.NodeList nodes = this.dom.getChildNodes();
+        for (int i=0; i<nodes.getLength(); i++) {
+            if (nodes.item(i).getNodeType() == org.w3c.dom.Node.ELEMENT_NODE) return true;
+        }
+        return false;
+    }
+
+    boolean isSameNode(XmlNode other) {
+        //    TODO    May need to be changed if we allow XmlNode to refer to several Node objects
+        return this.dom == other.dom;
+    }
+
+    private String toUri(String ns) {
+        return (ns == null) ? "" : ns;
+    }
+
+    private void addNamespaces(Namespaces rv, Element element) {
+        if (element == null) throw new RuntimeException("element must not be null");
+        String myDefaultNamespace = toUri(element.lookupNamespaceURI(null));
+        String parentDefaultNamespace = "";
+        if (element.getParentNode() != null) {
+            parentDefaultNamespace = toUri(element.getParentNode().lookupNamespaceURI(null));
+        }
+        if (!myDefaultNamespace.equals(parentDefaultNamespace) || !(element.getParentNode() instanceof Element) ) {
+            rv.declare(Namespace.create("", myDefaultNamespace));
+        }
+        NamedNodeMap attributes = element.getAttributes();
+        for (int i=0; i<attributes.getLength(); i++) {
+            Attr attr = (Attr)attributes.item(i);
+            if (attr.getPrefix() != null && attr.getPrefix().equals("xmlns")) {
+                rv.declare(Namespace.create(attr.getLocalName(), attr.getValue()));
+            }
+        }
+    }
+
+    private Namespaces getAllNamespaces() {
+        Namespaces rv = new Namespaces();
+
+        Node target = this.dom;
+        if (target instanceof Attr) {
+            target = ((Attr)target).getOwnerElement();
+        }
+        while(target != null) {
+            if (target instanceof Element) {
+                addNamespaces(rv, (Element)target);
+            }
+            target = target.getParentNode();
+        }
+        //    Fallback in case no namespace was declared
+        rv.declare(Namespace.create("", ""));
+        return rv;
+    }
+
+    Namespace[] getInScopeNamespaces() {
+        Namespaces rv = getAllNamespaces();
+        return rv.getNamespaces();
+    }
+
+    Namespace[] getNamespaceDeclarations() {
+        //    ECMA357 13.4.4.24
+        if (this.dom instanceof Element) {
+            Namespaces rv = new Namespaces();
+            addNamespaces( rv, (Element)this.dom );
+            return rv.getNamespaces();
+        } else {
+            return new Namespace[0];
+        }
+    }
+
+    Namespace getNamespaceDeclaration(String prefix) {
+        if (prefix.equals("") && dom instanceof Attr) {
+            //    Default namespaces do not apply to attributes; see XML Namespaces section 5.2
+            return Namespace.create("", "");
+        }
+        Namespaces rv = getAllNamespaces();
+        return rv.getNamespace(prefix);
+    }
+
+    Namespace getNamespaceDeclaration() {
+        if (dom.getPrefix() == null) return getNamespaceDeclaration("");
+        return getNamespaceDeclaration(dom.getPrefix());
+    }
+
+    private static class Namespaces {
+        private HashMap map = new HashMap();
+        private HashMap uriToPrefix = new HashMap();
+
+        Namespaces() {
+        }
+
+        void declare(Namespace n) {
+            if (map.get(n.prefix) == null) {
+                map.put(n.prefix, n.uri);
+            }
+            //    TODO    I think this is analogous to the other way, but have not really thought it through ... should local scope
+            //            matter more than outer scope?
+            if (uriToPrefix.get(n.uri) == null) {
+                uriToPrefix.put(n.uri, n.prefix);
+            }
+        }
+
+        Namespace getNamespaceByUri(String uri) {
+            if (uriToPrefix.get(uri) == null) return null;
+            return Namespace.create(uri, (String)uriToPrefix.get(uri));
+        }
+
+        Namespace getNamespace(String prefix) {
+            if (map.get(prefix) == null) return null;
+            return Namespace.create(prefix, (String)map.get(prefix));
+        }
+
+        Namespace[] getNamespaces() {
+            Iterator i = map.keySet().iterator();
+            ArrayList rv = new ArrayList();
+            while(i.hasNext()) {
+                String prefix = (String)i.next();
+                String uri = (String)map.get(prefix);
+                Namespace n = Namespace.create(prefix, uri);
+                if (!n.isEmpty()) {
+                    rv.add( n );
+                }
+            }
+            return (Namespace[])rv.toArray(new Namespace[0]);
+        }
+    }
+
+    final XmlNode copy() {
+        return copy( this );
+    }
+
+    //    Returns whether this node is capable of being a parent
+    final boolean isParentType() {
+        return isElementType();
+    }
+
+    final boolean isTextType() {
+        return dom.getNodeType() == Node.TEXT_NODE || dom.getNodeType() == Node.CDATA_SECTION_NODE;
+    }
+
+    final boolean isAttributeType() {
+        return dom.getNodeType() == Node.ATTRIBUTE_NODE;
+    }
+
+    final boolean isProcessingInstructionType() {
+        return dom.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE;
+    }
+
+    final boolean isCommentType() {
+        return dom.getNodeType() == Node.COMMENT_NODE;
+    }
+
+    final boolean isElementType() {
+        return dom.getNodeType() == Node.ELEMENT_NODE;
+    }
+
+    final void renameNode(QName qname) {
+        this.dom = dom.getOwnerDocument().renameNode(dom, qname.getUri(), qname.qualify(dom));
+    }
+
+    void invalidateNamespacePrefix() {
+        if (!(dom instanceof Element)) throw new IllegalStateException();
+        String prefix = this.dom.getPrefix();
+        QName after = QName.create(this.dom.getNamespaceURI(), this.dom.getLocalName(), null);
+        renameNode(after);
+        NamedNodeMap attrs = this.dom.getAttributes();
+        for (int i=0; i<attrs.getLength(); i++) {
+            if (attrs.item(i).getPrefix().equals(prefix)) {
+                createImpl( attrs.item(i) ).renameNode( QName.create(attrs.item(i).getNamespaceURI(), attrs.item(i).getLocalName(), null) );
+            }
+        }
+    }
+
+    private void declareNamespace(Element e, String prefix, String uri) {
+        if (prefix.length() > 0) {
+            e.setAttributeNS(XML_NAMESPACES_NAMESPACE_URI, "xmlns:" + prefix, uri);
+        } else {
+            e.setAttribute("xmlns", uri);
+        }
+    }
+
+    void declareNamespace(String prefix, String uri) {
+        if (!(dom instanceof Element)) throw new IllegalStateException();
+        if (dom.lookupNamespaceURI(uri) != null && dom.lookupNamespaceURI(uri).equals(prefix)) {
+            //    do nothing
+        } else {
+            Element e = (Element)dom;
+            declareNamespace(e, prefix, uri);
+        }
+    }
+
+    private Namespace getDefaultNamespace() {
+        String prefix = "";
+        String uri = (dom.lookupNamespaceURI(null) == null) ? "" : dom.lookupNamespaceURI(null);
+        return Namespace.create(prefix, uri);
+    }
+
+    private String getExistingPrefixFor(Namespace namespace) {
+        if (getDefaultNamespace().getUri().equals(namespace.getUri())) {
+            return "";
+        }
+        return dom.lookupPrefix(namespace.getUri());
+    }
+
+    private Namespace getNodeNamespace() {
+        String uri = dom.getNamespaceURI();
+        String prefix = dom.getPrefix();
+        if (uri == null) uri = "";
+        if (prefix == null) prefix = "";
+        return Namespace.create(prefix, uri);
+    }
+
+    Namespace getNamespace() {
+        return getNodeNamespace();
+    }
+
+    void removeNamespace(Namespace namespace) {
+        Namespace current = getNodeNamespace();
+
+        //    Do not remove in-use namespace
+        if (namespace.is(current)) return;
+        NamedNodeMap attrs = this.dom.getAttributes();
+        for (int i=0; i<attrs.getLength(); i++) {
+            XmlNode attr = XmlNode.createImpl(attrs.item(i));
+            if (namespace.is(attr.getNodeNamespace())) return;
+        }
+
+        //    TODO    I must confess I am not sure I understand the spec fully.  See ECMA357 13.4.4.31
+        String existingPrefix = getExistingPrefixFor(namespace);
+        if (existingPrefix != null) {
+            if (namespace.isUnspecifiedPrefix()) {
+                //    we should remove any namespace with this URI from scope; we do this by declaring a namespace with the same
+                //    prefix as the existing prefix and setting its URI to the default namespace
+                declareNamespace(existingPrefix, getDefaultNamespace().getUri());
+            } else {
+                if (existingPrefix.equals(namespace.getPrefix())) {
+                    declareNamespace(existingPrefix, getDefaultNamespace().getUri());
+                }
+            }
+        } else {
+            //    the argument namespace is not declared in this scope, so do nothing.
+        }
+    }
+
+    private void setProcessingInstructionName(String localName) {
+        org.w3c.dom.ProcessingInstruction pi = (ProcessingInstruction)this.dom;
+        //    We cannot set the node name; Document.renameNode() only supports elements and attributes.  So we replace it
+        pi.getParentNode().replaceChild(
+            pi,
+            pi.getOwnerDocument().createProcessingInstruction(localName, pi.getData())
+        );
+    }
+
+    final void setLocalName(String localName) {
+        if (dom instanceof ProcessingInstruction) {
+            setProcessingInstructionName(localName);
+        } else {
+            String prefix = dom.getPrefix();
+            if (prefix == null) prefix = "";
+            this.dom = dom.getOwnerDocument().renameNode(dom, dom.getNamespaceURI(), QName.qualify(prefix, localName));
+        }
+    }
+
+    final QName getQname() {
+        String uri = (dom.getNamespaceURI()) == null ? "" : dom.getNamespaceURI();
+        String prefix = (dom.getPrefix() == null) ? "" : dom.getPrefix();
+        return QName.create( uri, dom.getLocalName(), prefix );
+    }
+
+    void addMatchingChildren(XMLList result, XmlNode.Filter filter) {
+        Node node = this.dom;
+        NodeList children = node.getChildNodes();
+        for(int i=0; i<children.getLength(); i++) {
+            Node childnode = children.item(i);
+            XmlNode child = XmlNode.createImpl(childnode);
+            if (filter.accept(childnode)) {
+                result.addToList(child);
+            }
+        }
+    }
+
+    XmlNode[] getMatchingChildren(Filter filter) {
+        ArrayList rv = new ArrayList();
+        NodeList nodes = this.dom.getChildNodes();
+        for (int i=0; i<nodes.getLength(); i++) {
+            Node node = nodes.item(i);
+            if (filter.accept(node)) {
+                rv.add( createImpl(node) );
+            }
+        }
+        return (XmlNode[])rv.toArray(new XmlNode[0]);
+    }
+
+    XmlNode[] getAttributes() {
+        NamedNodeMap attrs = this.dom.getAttributes();
+        //    TODO    Or could make callers handle null?
+        if (attrs == null) throw new IllegalStateException("Must be element.");
+        XmlNode[] rv = new XmlNode[attrs.getLength()];
+        for (int i=0; i<attrs.getLength(); i++) {
+            rv[i] = createImpl( attrs.item(i) );
+        }
+        return rv;
+    }
+
+    String getAttributeValue() {
+        return ((Attr)dom).getValue();
+    }
+
+    void setAttribute(QName name, String value) {
+        if (!(dom instanceof Element)) throw new IllegalStateException("Can only set attribute on elements.");
+        name.setAttribute( (Element)dom, value );
+    }
+
+    void replaceWith(XmlNode other) {
+        Node replacement = other.dom;
+        if (replacement.getOwnerDocument() != this.dom.getOwnerDocument()) {
+            replacement = this.dom.getOwnerDocument().importNode(replacement, true);
+        }
+        this.dom.getParentNode().replaceChild(replacement, this.dom);
+    }
+
+    String ecmaToXMLString(XmlProcessor processor) {
+        if (this.isElementType()) {
+            Element copy = (Element)this.dom.cloneNode(true);
+            Namespace[] inScope = this.getInScopeNamespaces();
+            for (int i=0; i<inScope.length; i++) {
+                declareNamespace(copy, inScope[i].getPrefix(), inScope[i].getUri());
+            }
+            return processor.ecmaToXmlString(copy);
+        } else {
+            return processor.ecmaToXmlString(dom);
+        }
+    }
+
+    static class Namespace {
+        static Namespace create(String prefix, String uri) {
+            if (prefix == null) throw new IllegalArgumentException("Empty string represents default namespace prefix");
+            if (uri == null) throw new IllegalArgumentException("Namespace may not lack a URI");
+            Namespace rv = new Namespace();
+            rv.prefix = prefix;
+            rv.uri = uri;
+            return rv;
+        }
+
+        static Namespace create(String uri) {
+            Namespace rv = new Namespace();
+            rv.uri = uri;
+            return rv;
+        }
+
+        static final Namespace GLOBAL = create("", "");
+
+        private String prefix;
+        private String uri;
+
+        private Namespace() {
+        }
+
+        public String toString() {
+            if (prefix == null) return "XmlNode.Namespace [" + uri + "]";
+            return "XmlNode.Namespace [" + prefix + "{" + uri + "}]";
+        }
+
+        boolean isUnspecifiedPrefix() {
+            return prefix == null;
+        }
+
+        boolean is(Namespace other) {
+            return this.prefix != null && other.prefix != null && this.prefix.equals(other.prefix) && this.uri.equals(other.uri);
+        }
+
+        boolean isEmpty() {
+            return prefix != null && prefix.equals("") && uri.equals("");
+        }
+
+        boolean isDefault() {
+            return prefix != null && prefix.equals("");
+        }
+
+        boolean isGlobal() {
+            return uri != null && uri.equals("");
+        }
+
+        //    Called by QName
+        //    TODO    Move functionality from QName lookupPrefix to here
+        private void setPrefix(String prefix) {
+            if (prefix == null) throw new IllegalArgumentException();
+            this.prefix = prefix;
+        }
+
+        String getPrefix() {
+            return prefix;
+        }
+
+        String getUri() {
+            return uri;
+        }
+    }
+
+    //    TODO    Where is this class used?  No longer using it in QName implementation
+    static class QName {
+        static QName create(Namespace namespace, String localName) {
+            //    A null namespace indicates a wild-card match for any namespace
+            //    A null localName indicates "*" from the point of view of ECMA357
+            if (localName != null && localName.equals("*")) throw new RuntimeException("* is not valid localName");
+            QName rv = new QName();
+            rv.namespace = namespace;
+            rv.localName = localName;
+            return rv;
+        }
+
+        /** @deprecated */
+        static QName create(String uri, String localName, String prefix) {
+            return create(Namespace.create(prefix, uri), localName);
+        }
+
+        static String qualify(String prefix, String localName) {
+            if (prefix == null) throw new IllegalArgumentException("prefix must not be null");
+            if (prefix.length() > 0) return prefix + ":" + localName;
+            return localName;
+        }
+
+        private Namespace namespace;
+        private String localName;
+
+        private QName() {
+        }
+
+        public String toString() {
+            return "XmlNode.QName [" + localName + "," + namespace + "]";
+        }
+
+        private boolean equals(String one, String two) {
+            if (one == null && two == null) return true;
+            if (one == null || two == null) return false;
+            return one.equals(two);
+        }
+
+        private boolean namespacesEqual(Namespace one, Namespace two) {
+            if (one == null && two == null) return true;
+            if (one == null || two == null) return false;
+            return equals(one.getUri(), two.getUri());
+        }
+
+        final boolean isEqualTo(QName other) {
+            if (!namespacesEqual(this.namespace, other.namespace)) return false;
+            if (!equals(this.localName, other.localName)) return false;
+            return true;
+        }
+
+        void lookupPrefix(org.w3c.dom.Node node) {
+            if (node == null) throw new IllegalArgumentException("node must not be null");
+            String prefix = node.lookupPrefix(namespace.getUri());
+            if (prefix == null) {
+                //    check to see if we match the default namespace
+                String defaultNamespace = node.lookupNamespaceURI(null);
+                if (defaultNamespace == null) defaultNamespace = "";
+                String nodeNamespace = namespace.getUri();
+                if (nodeNamespace.equals(defaultNamespace)) {
+                    prefix = "";
+                }
+            }
+            int i = 0;
+            while(prefix == null) {
+                String generatedPrefix = "e4x_" + i++;
+                String generatedUri = node.lookupNamespaceURI(generatedPrefix);
+                if (generatedUri == null) {
+                    prefix = generatedPrefix;
+                    org.w3c.dom.Node top = node;
+                    while(top.getParentNode() != null && top.getParentNode() instanceof org.w3c.dom.Element) {
+                        top = top.getParentNode();
+                    }
+                    ((org.w3c.dom.Element)top).setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:" + prefix, namespace.getUri());
+                }
+            }
+            namespace.setPrefix(prefix);
+        }
+
+        String qualify(org.w3c.dom.Node node) {
+            if (namespace.getPrefix() == null) {
+                if (node != null) {
+                    lookupPrefix(node);
+                } else {
+                    if (namespace.getUri().equals("")) {
+                        namespace.setPrefix("");
+                    } else {
+                        //    TODO    I am not sure this is right, but if we are creating a standalone node, I think we can set the
+                        //            default namespace on the node itself and not worry about setting a prefix for that namespace.
+                        namespace.setPrefix("");
+                    }
+                }
+            }
+            return qualify(namespace.getPrefix(), localName);
+        }
+
+        void setAttribute(org.w3c.dom.Element element, String value) {
+            if (namespace.getPrefix() == null) lookupPrefix(element);
+            element.setAttributeNS(namespace.getUri(), qualify(namespace.getPrefix(), localName), value);
+        }
+
+        /** @deprecated Use getNamespace() */
+        String getUri() {
+            return namespace.getUri();
+        }
+
+        /** @deprecated Use getNamespace() */
+        String getPrefix() {
+            return namespace.getPrefix();
+        }
+
+        Namespace getNamespace() {
+            return namespace;
+        }
+
+        String getLocalName() {
+            return localName;
+        }
+    }
+
+    static class List {
+        private java.util.Vector v;
+
+        List() {
+            v = new java.util.Vector();
+        }
+
+        private void _add(XmlNode n) {
+            v.add(n);
+        }
+
+        XmlNode item(int index) {
+            return (XmlNode)(v.get(index));
+        }
+
+        void remove(int index) {
+            v.remove(index);
+        }
+
+        void add(List other) {
+            for (int i=0; i<other.length(); i++) {
+                _add(other.item(i));
+            }
+        }
+
+        void add(List from, int startInclusive, int endExclusive) {
+            for (int i=startInclusive; i<endExclusive; i++) {
+                _add(from.item(i));
+            }
+        }
+
+        void add(XmlNode node) {
+            _add(node);
+        }
+
+        /** @deprecated */
+        void add(XML xml) {
+            _add(xml.getAnnotation());
+        }
+
+        /** @deprecated */
+        void addToList(Object toAdd) {
+            if (toAdd instanceof Undefined) {
+                // Missing argument do nothing...
+                return;
+            }
+
+            if (toAdd instanceof XMLList) {
+                XMLList xmlSrc = (XMLList)toAdd;
+                for (int i = 0; i < xmlSrc.length(); i++) {
+                    this._add((xmlSrc.item(i)).getAnnotation());
+                }
+            } else if (toAdd instanceof XML) {
+                this._add(((XML)(toAdd)).getAnnotation());
+            } else if (toAdd instanceof XmlNode) {
+                this._add((XmlNode)toAdd);
+            }
+        }
+
+        int length() {
+            return v.size();
+        }
+    }
+
+    static abstract class Filter {
+        static final Filter COMMENT = new Filter() {
+            boolean accept(Node node) {
+                return node.getNodeType() == Node.COMMENT_NODE;
+            }
+        };
+        static final Filter TEXT = new Filter() {
+            boolean accept(Node node) {
+                return node.getNodeType() == Node.TEXT_NODE;
+            }
+        };
+        static Filter PROCESSING_INSTRUCTION(final XMLName name) {
+            return new Filter() {
+                boolean accept(Node node) {
+                    if (node.getNodeType() == Node.PROCESSING_INSTRUCTION_NODE) {
+                        ProcessingInstruction pi = (ProcessingInstruction)node;
+                        return name.matchesLocalName(pi.getTarget());
+                    }
+                    return false;
+                }
+            };
+        }
+        static Filter ELEMENT = new Filter() {
+            boolean accept(Node node) {
+                return node.getNodeType() == Node.ELEMENT_NODE;
+            }
+        };
+        static Filter TRUE = new Filter() {
+            boolean accept(Node node) {
+                return true;
+            }
+        };
+        abstract boolean accept(Node node);
+    }
+
+    //    Support experimental Java interface
+    org.w3c.dom.Node toDomNode() {
+        return this.dom;
+    }
+}
diff --git a/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XmlProcessor.java b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XmlProcessor.java
new file mode 100644
index 0000000..d8ad495
--- /dev/null
+++ b/infrastructure/rhino1_7R1/xmlimplsrc/org/mozilla/javascript/xmlimpl/XmlProcessor.java
@@ -0,0 +1,445 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Rhino DOM-only E4X implementation.
+ *
+ * The Initial Developer of the Original Code is
+ * David P. Caldwell.
+ * Portions created by David P. Caldwell are Copyright (C)
+ * 2007 David P. Caldwell. All Rights Reserved.
+ *
+ *
+ * Contributor(s):
+ *   David P. Caldwell <inonit@inonit.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * the GNU General Public License Version 2 or later (the "GPL"), in which
+ * case the provisions of the GPL are applicable instead of those above. If
+ * you wish to allow use of your version of this file only under the terms of
+ * the GPL and not to allow others to use your version of this file under the
+ * MPL, indicate your decision by deleting the provisions above and replacing
+ * them with the notice and other provisions required by the GPL. If you do
+ * not delete the provisions above, a recipient may use your version of this
+ * file under either the MPL or the GPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+package org.mozilla.javascript.xmlimpl;
+
+import org.w3c.dom.*;
+
+import javax.xml.parsers.DocumentBuilder;
+
+import org.mozilla.javascript.*;
+
+//    Disambiguate from org.mozilla.javascript.Node
+import org.w3c.dom.Node;
+import org.xml.sax.ErrorHandler;
+import org.xml.sax.SAXParseException;
+
+class XmlProcessor {
+    private boolean ignoreComments;
+    private boolean ignoreProcessingInstructions;
+    private boolean ignoreWhitespace;
+    private boolean prettyPrint;
+    private int prettyIndent;
+
+    private javax.xml.parsers.DocumentBuilderFactory dom;
+    private javax.xml.transform.TransformerFactory xform;
+    private DocumentBuilder documentBuilder;
+    private RhinoSAXErrorHandler errorHandler = new RhinoSAXErrorHandler();
+
+
+    private static class RhinoSAXErrorHandler implements ErrorHandler {
+
+        private void throwError(SAXParseException e) {
+            throw ScriptRuntime.constructError("TypeError", e.getMessage(),
+                e.getLineNumber() - 1);
+        }
+
+        public void error(SAXParseException e) {
+            throwError(e);
+        }
+
+        public void fatalError(SAXParseException e) {
+            throwError(e);
+        }
+
+        public void warning(SAXParseException e) {
+            Context.reportWarning(e.getMessage());
+        }
+    }
+
+    XmlProcessor() {
+        setDefault();
+        this.dom = javax.xml.parsers.DocumentBuilderFactory.newInstance();
+        this.dom.setNamespaceAware(true);
+        this.dom.setIgnoringComments(false);
+        this.xform = javax.xml.transform.TransformerFactory.newInstance();
+    }
+
+    final void setDefault() {
+        this.setIgnoreComments(true);
+        this.setIgnoreProcessingInstructions(true);
+        this.setIgnoreWhitespace(true);
+        this.setPrettyPrinting(true);
+        this.setPrettyIndent(2);
+    }
+
+    final void setIgnoreComments(boolean b) {
+        this.ignoreComments = b;
+    }
+
+    final void setIgnoreWhitespace(boolean b) {
+        this.ignoreWhitespace = b;
+    }
+
+    final void setIgnoreProcessingInstructions(boolean b) {
+        this.ignoreProcessingInstructions = b;
+    }
+
+    final void setPrettyPrinting(boolean b) {
+        this.prettyPrint = b;
+    }
+
+    final void setPrettyIndent(int i) {
+        this.prettyIndent = i;
+    }
+
+    final boolean isIgnoreComments() {
+        return ignoreComments;
+    }
+
+    final boolean isIgnoreProcessingInstructions() {
+        return ignoreProcessingInstructions;
+    }
+
+    final boolean isIgnoreWhitespace() {
+        return ignoreWhitespace;
+    }
+
+    final boolean isPrettyPrinting() {
+        return prettyPrint;
+    }
+
+    final int getPrettyIndent() {
+        return prettyIndent;
+    }
+
+    private String toXmlNewlines(String rv) {
+        StringBuffer nl = new StringBuffer();
+        for (int i=0; i<rv.length(); i++) {
+            if (rv.charAt(i) == '\r') {
+                if (rv.charAt(i+1) == '\n') {
+                    //    DOS, do nothing and skip the \r
+                } else {
+                    //    Macintosh, substitute \n
+                    nl.append('\n');
+                }
+            } else {
+                nl.append(rv.charAt(i));
+            }
+        }
+        return nl.toString();
+    }
+
+    private javax.xml.parsers.DocumentBuilderFactory getDomFactory() {
+        return dom;
+    }
+    
+    private synchronized DocumentBuilder getDocumentBuilderFromPool()
+        throws javax.xml.parsers.ParserConfigurationException
+    {
+        DocumentBuilder result;
+        if (documentBuilder == null) {
+            javax.xml.parsers.DocumentBuilderFactory factory = getDomFactory();
+            result = factory.newDocumentBuilder();
+        } else {
+            result = documentBuilder;
+            documentBuilder = null;
+        }
+        result.setErrorHandler(errorHandler);
+        return result;
+    }
+        
+    private synchronized void returnDocumentBuilderToPool(DocumentBuilder db) {
+        if (documentBuilder == null) {
+            documentBuilder = db;
+            documentBuilder.reset();
+        }
+    }
+
+    private void addProcessingInstructionsTo(java.util.Vector v, Node node) {
+        if (node instanceof ProcessingInstruction) {
+            v.add(node);
+        }
+        if (node.getChildNodes() != null) {
+            for (int i=0; i<node.getChildNodes().getLength(); i++) {
+                addProcessingInstructionsTo(v, node.getChildNodes().item(i));
+            }
+        }
+    }
+
+    private void addCommentsTo(java.util.Vector v, Node node) {
+        if (node instanceof Comment) {
+            v.add(node);
+        }
+        if (node.getChildNodes() != null) {
+            for (int i=0; i<node.getChildNodes().getLength(); i++) {
+                addProcessingInstructionsTo(v, node.getChildNodes().item(i));
+            }
+        }
+    }
+
+    private void addTextNodesToRemoveAndTrim(java.util.Vector toRemove, Node node) {
+        if (node instanceof Text) {
+            Text text = (Text)node;
+            boolean BUG_369394_IS_VALID = false;
+            if (!BUG_369394_IS_VALID) {
+                text.setData(text.getData().trim());
+            } else {
+                if (text.getData().trim().length() == 0) {
+                    text.setData("");
+                }
+            }
+            if (text.getData().length() == 0) {
+                toRemove.add(node);
+            }
+        }
+        if (node.getChildNodes() != null) {
+            for (int i=0; i<node.getChildNodes().getLength(); i++) {
+                addTextNodesToRemoveAndTrim(toRemove, node.getChildNodes().item(i));
+            }
+        }
+    }
+
+    final Node toXml(String defaultNamespaceUri, String xml) throws org.xml.sax.SAXException {
+        //    See ECMA357 10.3.1
+        DocumentBuilder builder = null;
+        try {
+            String syntheticXml = "<parent xmlns=\"" + defaultNamespaceUri +
+                "\">" + xml + "</parent>";
+            builder = getDocumentBuilderFromPool(); 
+            Document document = builder.parse( new org.xml.sax.InputSource(new java.io.StringReader(syntheticXml)) );
+            if (ignoreProcessingInstructions) {
+                java.util.Vector v = new java.util.Vector();
+                addProcessingInstructionsTo(v, document);
+                for (int i=0; i<v.size(); i++) {
+                    Node node = (Node)v.elementAt(i);
+                    node.getParentNode().removeChild(node);
+                }
+            }
+            if (ignoreComments) {
+                java.util.Vector v = new java.util.Vector();
+                addCommentsTo(v, document);
+                for (int i=0; i<v.size(); i++) {
+                    Node node = (Node)v.elementAt(i);
+                    node.getParentNode().removeChild(node);
+                }
+            }
+            if (ignoreWhitespace) {
+                //    Apparently JAXP setIgnoringElementContentWhitespace() has a different meaning, it appears from the Javadoc
+                //    Refers to element-only content models, which means we would need to have a validating parser and DTD or schema
+                //    so that it would know which whitespace to ignore.
+
+                //    Instead we will try to delete it ourselves.
+                java.util.Vector v = new java.util.Vector();
+                addTextNodesToRemoveAndTrim(v, document);
+                for (int i=0; i<v.size(); i++) {
+                    Node node = (Node)v.elementAt(i);
+                    node.getParentNode().removeChild(node);
+                }
+            }
+            NodeList rv = document.getDocumentElement().getChildNodes();
+            if (rv.getLength() > 1) {
+                throw ScriptRuntime.constructError("SyntaxError", "XML objects may contain at most one node.");
+            } else if (rv.getLength() == 0) {
+                Node node = document.createTextNode("");
+                return node;
+            } else {
+                Node node = rv.item(0);
+                document.getDocumentElement().removeChild(node);
+                return node;
+            }
+        } catch (java.io.IOException e) {
+            throw new RuntimeException("Unreachable.");
+        } catch (javax.xml.parsers.ParserConfigurationException e) {
+            throw new RuntimeException(e);
+        } finally {
+            if (builder != null)
+                returnDocumentBuilderToPool(builder);
+        }
+    }
+
+    Document newDocument() {
+        DocumentBuilder builder = null;
+        try {
+            //    TODO    Should this use XML settings?
+            builder = getDocumentBuilderFromPool();
+            return builder.newDocument();
+        } catch (javax.xml.parsers.ParserConfigurationException ex) {
+            //    TODO    How to handle these runtime errors?
+            throw new RuntimeException(ex);
+        } finally {
+            if (builder != null)
+                returnDocumentBuilderToPool(builder);
+        }
+    }
+
+    //    TODO    Cannot remember what this is for, so whether it should use settings or not
+    private String toString(Node node) {
+        javax.xml.transform.dom.DOMSource source = new javax.xml.transform.dom.DOMSource(node);
+        java.io.StringWriter writer = new java.io.StringWriter();
+        javax.xml.transform.stream.StreamResult result = new javax.xml.transform.stream.StreamResult(writer);
+        try {
+            javax.xml.transform.Transformer transformer = xform.newTransformer();
+            transformer.setOutputProperty(javax.xml.transform.OutputKeys.OMIT_XML_DECLARATION, "yes");
+            transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, "no");
+            transformer.setOutputProperty(javax.xml.transform.OutputKeys.METHOD, "xml");
+            transformer.transform(source, result);
+        } catch (javax.xml.transform.TransformerConfigurationException ex) {
+            //    TODO    How to handle these runtime errors?
+            throw new RuntimeException(ex);
+        } catch (javax.xml.transform.TransformerException ex) {
+            //    TODO    How to handle these runtime errors?
+            throw new RuntimeException(ex);
+        }
+        return toXmlNewlines(writer.toString());
+    }
+
+    String escapeAttributeValue(Object value) {
+        String text = ScriptRuntime.toString(value);
+
+        if (text.length() == 0) return "";
+
+        Document dom = newDocument();
+        Element e = dom.createElement("a");
+        e.setAttribute("b", text);
+        String elementText = toString(e);
+        int begin = elementText.indexOf('"');
+        int end = elementText.lastIndexOf('"');
+        return elementText.substring(begin+1,end);
+    }
+
+    String escapeTextValue(Object value) {
+        if (value instanceof XMLObjectImpl) {
+            return ((XMLObjectImpl)value).toXMLString();
+        }
+
+        String text = ScriptRuntime.toString(value);
+
+        if (text.length() == 0) return text;
+
+        Document dom = newDocument();
+        Element e = dom.createElement("a");
+        e.setTextContent(text);
+        String elementText = toString(e);
+
+        int begin = elementText.indexOf('>') + 1;
+        int end = elementText.lastIndexOf('<');
+        return (begin < end) ? elementText.substring(begin, end) : "";
+    }
+
+    private String escapeElementValue(String s) {
+        //    TODO    Check this
+        return escapeTextValue(s);
+    }
+
+    private String elementToXmlString(Element element) {
+        //    TODO    My goodness ECMA is complicated (see 10.2.1).  We'll try this first.
+        Element copy = (Element)element.cloneNode(true);
+        if (prettyPrint) {
+            beautifyElement(copy, 0);
+        }
+        return toString(copy);
+    }
+
+    final String ecmaToXmlString(Node node) {
+        //    See ECMA 357 Section 10.2.1
+        StringBuffer s = new StringBuffer();
+        int indentLevel = 0;
+        if (prettyPrint) {
+            for (int i=0; i<indentLevel; i++) {
+                s.append(' ');
+            }
+        }
+        if (node instanceof Text) {
+            String data = ((Text)node).getData();
+            //    TODO Does Java trim() work same as XMLWhitespace?
+            String v = (prettyPrint) ? data.trim() : data;
+            s.append(escapeElementValue(v));
+            return s.toString();
+        }
+        if (node instanceof Attr) {
+            String value = ((Attr)node).getValue();
+            s.append(escapeAttributeValue(value));
+            return s.toString();
+        }
+        if (node instanceof Comment) {
+            s.append("<!--" + ((Comment)node).getNodeValue() + "-->");
+            return s.toString();
+        }
+        if (node instanceof ProcessingInstruction) {
+            ProcessingInstruction pi = (ProcessingInstruction)node;
+            s.append("<?" + pi.getTarget() + " " + pi.getData() + "?>");
+            return s.toString();
+        }
+        s.append(elementToXmlString((Element)node));
+        return s.toString();
+    }
+
+    private void beautifyElement(Element e, int indent) {
+        StringBuffer s = new StringBuffer();
+        s.append('\n');
+        for (int i=0; i<indent; i++) {
+            s.append(' ');
+        }
+        String afterContent = s.toString();
+        for (int i=0; i<prettyIndent; i++) {
+            s.append(' ');
+        }
+        String beforeContent = s.toString();
+
+        //    We "mark" all the nodes first; if we tried to do this loop otherwise, it would behave unexpectedly (the inserted nodes
+        //    would contribute to the length and it might never terminate).
+        java.util.Vector toIndent = new java.util.Vector();
+        boolean indentChildren = false;
+        for (int i=0; i<e.getChildNodes().getLength(); i++) {
+            if (i == 1) indentChildren = true;
+            if (e.getChildNodes().item(i) instanceof Text) {
+                toIndent.add(e.getChildNodes().item(i));
+            } else {
+                indentChildren = true;
+                toIndent.add(e.getChildNodes().item(i));
+            }
+        }
+        if (indentChildren) {
+            for (int i=0; i<toIndent.size(); i++) {
+                e.insertBefore( e.getOwnerDocument().createTextNode(beforeContent), (Node)toIndent.elementAt(i) );
+            }
+        }
+        NodeList nodes = e.getChildNodes();
+        java.util.Vector v = new java.util.Vector();
+        for (int i=0; i<nodes.getLength(); i++) {
+            if (nodes.item(i) instanceof Element) {
+                v.add( nodes.item(i) );
+            }
+        }
+        for (int i=0; i<v.size(); i++) {
+            beautifyElement( (Element)v.elementAt(i), indent + prettyIndent );
+        }
+        if (indentChildren) {
+            e.appendChild( e.getOwnerDocument().createTextNode(afterContent) );
+        }
+    }
+}