aboutsummaryrefslogtreecommitdiffstats
path: root/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla
diff options
context:
space:
mode:
authorAlexander Sulfrian <alexander@sulfrian.net>2010-06-08 08:22:05 +0200
committerAlexander Sulfrian <alexander@sulfrian.net>2010-06-08 08:22:05 +0200
commitd7c5ad7d6263fd1baf9bfdbaa4c50b70ef2fbdb2 (patch)
treeae0b65da6432f4c26c8d5a7319efbda5d172846c /trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla
parentfa61221dcd89fcd72cba2c97971626f456c86e5d (diff)
downloadetherpad-d7c5ad7d6263fd1baf9bfdbaa4c50b70ef2fbdb2.tar.gz
etherpad-d7c5ad7d6263fd1baf9bfdbaa4c50b70ef2fbdb2.tar.xz
etherpad-d7c5ad7d6263fd1baf9bfdbaa4c50b70ef2fbdb2.zip
reverted folder structure change for better mergeing with upstream
Diffstat (limited to 'trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla')
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/ClassDefinitionException.java53
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/NotAFunctionException.java52
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/PropertyException.java54
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/LogicalEquality.java367
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/Namespace.java335
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/NamespaceHelper.java350
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/QName.java321
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XML.java3092
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLCtor.java269
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLLibImpl.java754
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLList.java1617
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLName.java171
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLObjectImpl.java724
-rw-r--r--trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLWithScope.java125
14 files changed, 8284 insertions, 0 deletions
diff --git a/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/ClassDefinitionException.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/ClassDefinitionException.java
new file mode 100644
index 0000000..2197063
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/ClassDefinitionException.java
@@ -0,0 +1,53 @@
+
+/* -*- 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):
+ *
+ * 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 ***** */
+// API class
+
+package org.mozilla.javascript;
+
+/**
+ * @deprecated The exception is no longer thrown by Rhino runtime as
+ * {@link EvaluatorException} is used instead.
+ */
+public class ClassDefinitionException extends RuntimeException
+{
+ static final long serialVersionUID = -5637830967241712746L;
+
+ public ClassDefinitionException(String detail) {
+ super(detail);
+ }
+}
diff --git a/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/NotAFunctionException.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/NotAFunctionException.java
new file mode 100644
index 0000000..3de53a8
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/NotAFunctionException.java
@@ -0,0 +1,52 @@
+
+/* -*- 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):
+ * Igor Bukanov
+ *
+ * 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 ***** */
+// API class
+
+package org.mozilla.javascript;
+
+/**
+ * @deprecated The exception is no longer thrown by Rhino runtime as
+ * {@link EvaluatorException} is used instead.
+ */
+public class NotAFunctionException extends RuntimeException
+{
+ static final long serialVersionUID = 6461524852170711724L;
+
+ public NotAFunctionException() { }
+}
diff --git a/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/PropertyException.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/PropertyException.java
new file mode 100644
index 0000000..8d786c7
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/PropertyException.java
@@ -0,0 +1,54 @@
+/* -*- 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
+ *
+ * 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 ***** */
+
+// API class
+
+package org.mozilla.javascript;
+
+/**
+ * @deprecated This exception is no longer thrown by Rhino runtime.
+ */
+public class PropertyException extends RuntimeException
+{
+ static final long serialVersionUID = -8221564865490676219L;
+
+ public PropertyException(String detail) {
+ super(detail);
+ }
+
+}
diff --git a/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/LogicalEquality.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/LogicalEquality.java
new file mode 100644
index 0000000..b525aff
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/LogicalEquality.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
+ *
+ * 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.xml.impl.xmlbeans;
+
+import org.apache.xmlbeans.XmlCursor;
+
+import java.util.*;
+
+
+public class LogicalEquality
+{
+ public static boolean nodesEqual(XmlCursor xmlOne, XmlCursor xmlTwo)
+ {
+ boolean result = false;
+
+ if (xmlOne.isStartdoc())
+ {
+ xmlOne.toFirstContentToken();
+ }
+
+ if (xmlTwo.isStartdoc())
+ {
+ xmlTwo.toFirstContentToken();
+ }
+
+ if (xmlOne.currentTokenType() == xmlTwo.currentTokenType())
+ {
+ if (xmlOne.isEnddoc())
+ {
+ // Both empty
+ result = true;
+ }
+ else if (xmlOne.isAttr())
+ {
+ result = attributesEqual(xmlOne, xmlTwo);
+ }
+ else if (xmlOne.isText())
+ {
+ result = textNodesEqual(xmlOne, xmlTwo);
+ }
+ else if (xmlOne.isComment())
+ {
+ result = commentsEqual(xmlOne, xmlTwo);
+ }
+ else if (xmlOne.isProcinst())
+ {
+ result = processingInstructionsEqual(xmlOne, xmlTwo);
+ }
+ else if (xmlOne.isStart())
+ {
+ // Compare root elements
+ result = elementsEqual(xmlOne, xmlTwo);
+ }
+ }
+
+ return result;
+ }
+
+ private static boolean elementsEqual(XmlCursor xmlOne, XmlCursor xmlTwo)
+ {
+ boolean result = true;
+
+ if (!qnamesEqual(xmlOne.getName(), xmlTwo.getName()))
+ {
+ result = false;
+ }
+ else
+ {
+ // These filter out empty text nodes.
+ nextToken(xmlOne);
+ nextToken(xmlTwo);
+
+ do
+ {
+ if (xmlOne.currentTokenType() != xmlTwo.currentTokenType())
+ {
+ // Not same token
+ result = false;
+ break;
+ }
+ else if (xmlOne.isEnd())
+ {
+ // Done with this element, step over end
+ break;
+ }
+ else if (xmlOne.isEnddoc())
+ {
+ // Shouldn't get here
+ break;
+ }
+ else if (xmlOne.isAttr())
+ {
+ // This one will move us to the first non-attr token.
+ result = attributeListsEqual(xmlOne, xmlTwo);
+ }
+ else
+ {
+ if (xmlOne.isText())
+ {
+ result = textNodesEqual(xmlOne, xmlTwo);
+ }
+ else if (xmlOne.isComment())
+ {
+ result = commentsEqual(xmlOne, xmlTwo);
+ }
+ else if (xmlOne.isProcinst())
+ {
+ result = processingInstructionsEqual(xmlOne, xmlTwo);
+ }
+ else if (xmlOne.isStart())
+ {
+ result = elementsEqual(xmlOne, xmlTwo);
+ }
+ else
+ {
+ //XML.log("Unknown token type" + xmlOne.currentTokenType());
+ }
+
+ // These filter out empty text nodes.
+ nextToken(xmlOne);
+ nextToken(xmlTwo);
+ }
+ }
+ while(result);
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @param xmlOne
+ * @param xmlTwo
+ * @return
+ */
+ private static boolean attributeListsEqual(XmlCursor xmlOne, XmlCursor xmlTwo)
+ {
+ boolean result = true;
+ TreeMap mapOne = loadAttributeMap(xmlOne);
+ TreeMap mapTwo = loadAttributeMap(xmlTwo);
+
+ if (mapOne.size() != mapTwo.size())
+ {
+ result = false;
+ }
+ else
+ {
+ Set keysOne = mapOne.keySet();
+ Set keysTwo = mapTwo.keySet();
+ Iterator itOne = keysOne.iterator();
+ Iterator itTwo = keysTwo.iterator();
+
+ while (result && itOne.hasNext())
+ {
+ String valueOne = (String) itOne.next();
+ String valueTwo = (String) itTwo.next();
+
+ if (!valueOne.equals(valueTwo))
+ {
+ result = false;
+ }
+ else
+ {
+ javax.xml.namespace.QName qnameOne = (javax.xml.namespace.QName) mapOne.get(valueOne);
+ javax.xml.namespace.QName qnameTwo = (javax.xml.namespace.QName) mapTwo.get(valueTwo);
+
+ if (!qnamesEqual(qnameOne, qnameTwo))
+ {
+ result = false;
+ }
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @param xml
+ * @return
+ */
+ private static TreeMap loadAttributeMap(XmlCursor xml)
+ {
+ TreeMap result = new TreeMap();
+
+ while (xml.isAttr())
+ {
+ result.put(xml.getTextValue(), xml.getName());
+ nextToken(xml);
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @param xmlOne
+ * @param xmlTwo
+ * @return
+ */
+ private static boolean attributesEqual(XmlCursor xmlOne, XmlCursor xmlTwo)
+ {
+ boolean result = false;
+
+ if (xmlOne.isAttr() && xmlTwo.isAttr())
+ {
+ if (qnamesEqual(xmlOne.getName(), xmlTwo.getName()))
+ {
+ if (xmlOne.getTextValue().equals(xmlTwo.getTextValue()))
+ {
+ result = true;
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @param xmlOne
+ * @param xmlTwo
+ * @return
+ */
+ private static boolean textNodesEqual(XmlCursor xmlOne, XmlCursor xmlTwo)
+ {
+ boolean result = false;
+
+ if (xmlOne.isText() && xmlTwo.isText())
+ {
+ if (xmlOne.getChars().equals(xmlTwo.getChars()))
+ {
+ result = true;
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @param xmlOne
+ * @param xmlTwo
+ * @return
+ */
+ private static boolean commentsEqual(XmlCursor xmlOne, XmlCursor xmlTwo)
+ {
+ boolean result = false;
+
+ if (xmlOne.isComment() && xmlTwo.isComment())
+ {
+ if (xmlOne.getTextValue().equals(xmlTwo.getTextValue()))
+ {
+ result = true;
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @param xmlOne
+ * @param xmlTwo
+ * @return
+ */
+ private static boolean processingInstructionsEqual(XmlCursor xmlOne, XmlCursor xmlTwo)
+ {
+ boolean result = false;
+
+ if (xmlOne.isProcinst() && xmlTwo.isProcinst())
+ {
+ if (qnamesEqual(xmlOne.getName(), xmlTwo.getName()))
+ {
+ if (xmlOne.getTextValue().equals(xmlTwo.getTextValue()))
+ {
+ result = true;
+ }
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @param qnameOne
+ * @param qnameTwo
+ * @return
+ */
+ private static boolean qnamesEqual(javax.xml.namespace.QName qnameOne, javax.xml.namespace.QName qnameTwo)
+ {
+ boolean result = false;
+
+ if (qnameOne.getNamespaceURI().equals(qnameTwo.getNamespaceURI()))
+ {
+ if (qnameOne.getLocalPart().equals(qnameTwo.getLocalPart()))
+ {
+ return true;
+ }
+ }
+
+ return result;
+ }
+
+ /**
+ * filter out empty textNodes here
+ *
+ * @param xml
+ */
+ private static void nextToken(XmlCursor xml)
+ {
+ do
+ {
+ xml.toNextToken();
+
+ if (!xml.isText())
+ {
+ // Not a text node
+ break;
+ }
+ else if (xml.getChars().trim().length() > 0)
+ {
+ // Text node is not empty
+ break;
+ }
+ }
+ while (true);
+ }
+}
diff --git a/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/Namespace.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/Namespace.java
new file mode 100644
index 0000000..3a16320
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/Namespace.java
@@ -0,0 +1,335 @@
+/* -*- 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.xml.impl.xmlbeans;
+
+import org.mozilla.javascript.*;
+
+/**
+ * Class Namespace
+ *
+ */
+class Namespace extends IdScriptableObject
+{
+ static final long serialVersionUID = -5765755238131301744L;
+
+ private static final Object NAMESPACE_TAG = new Object();
+
+ private XMLLibImpl lib;
+ private String prefix;
+ private String uri;
+
+ public Namespace(XMLLibImpl lib, String uri)
+ {
+ super(lib.globalScope(), lib.namespacePrototype);
+
+ if (uri == null)
+ throw new IllegalArgumentException();
+
+ this.lib = lib;
+ this.prefix = (uri.length() == 0) ? "" : null;
+ this.uri = uri;
+ }
+
+
+ public Namespace(XMLLibImpl lib, String prefix, String uri)
+ {
+ super(lib.globalScope(), lib.namespacePrototype);
+
+ if (uri == null)
+ throw new IllegalArgumentException();
+ if (uri.length() == 0) {
+ // prefix should be "" for empty uri
+ if (prefix == null)
+ throw new IllegalArgumentException();
+ if (prefix.length() != 0)
+ throw new IllegalArgumentException();
+ }
+
+ this.lib = lib;
+ this.prefix = prefix;
+ this.uri = uri;
+ }
+
+ public void exportAsJSClass(boolean sealed)
+ {
+ exportAsJSClass(MAX_PROTOTYPE_ID, lib.globalScope(), sealed);
+ }
+
+ /**
+ *
+ * @return
+ */
+ public String uri()
+ {
+ return uri;
+ }
+
+ /**
+ *
+ * @return
+ */
+ public String prefix()
+ {
+ return prefix;
+ }
+
+ /**
+ *
+ * @return
+ */
+ public String toString ()
+ {
+ return uri();
+ }
+
+ /**
+ *
+ * @return
+ */
+ public String toLocaleString ()
+ {
+ return toString();
+ }
+
+ 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;
+ }
+
+ private boolean equals(Namespace n)
+ {
+ return uri().equals(n.uri());
+ }
+
+ /**
+ *
+ * @return
+ */
+ public String getClassName ()
+ {
+ return "Namespace";
+ }
+
+ /**
+ *
+ * @param hint
+ * @return
+ */
+ 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: 2004-07-20 19:50:50 CEST
+ 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;
+ }
+// #/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 (prefix == null) return Undefined.instance;
+ return prefix;
+ 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: 2004-08-21 12:07:01 CEST
+ 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;
+ }
+// #/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;
+ }
+
+ private Object jsConstructor(Context cx, boolean inNewExpr, Object[] args)
+ {
+ if (!inNewExpr && args.length == 1) {
+ return lib.castToNamespace(cx, args[0]);
+ }
+
+ if (args.length == 0) {
+ return lib.constructNamespace(cx);
+ } else if (args.length == 1) {
+ return lib.constructNamespace(cx, args[0]);
+ } else {
+ return lib.constructNamespace(cx, args[0], args[1]);
+ }
+ }
+
+ private String js_toSource()
+ {
+ StringBuffer sb = new StringBuffer();
+ sb.append('(');
+ toSourceImpl(prefix, uri, 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/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/NamespaceHelper.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/NamespaceHelper.java
new file mode 100644
index 0000000..fc99c7e
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/NamespaceHelper.java
@@ -0,0 +1,350 @@
+/* -*- 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):
+ * 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.xml.impl.xmlbeans;
+
+import java.util.*;
+import org.apache.xmlbeans.XmlCursor;
+
+import org.mozilla.javascript.*;
+
+class NamespaceHelper
+{
+ private XMLLibImpl lib;
+ private final Map prefixToURI = new HashMap();
+ private final Map uriToPrefix = new HashMap();
+ // A set of URIs that are used without explicit namespace declaration in scope.
+ private final Set undeclared = new HashSet();
+
+ private NamespaceHelper(XMLLibImpl lib)
+ {
+ this.lib = lib;
+ // Insert the default namespace
+ prefixToURI.put("", "");
+ Set prefixes = new HashSet();
+ prefixes.add("");
+ uriToPrefix.put("", prefixes);
+ }
+
+ /**
+ * Declared a new namespace
+ *
+ * @param prefix
+ * @param uri
+ * @param declarations
+ */
+ private void declareNamespace(String prefix, String uri, ObjArray declarations)
+ {
+ Set prefixes = (Set)uriToPrefix.get(uri);
+ if(prefixes == null)
+ {
+ prefixes = new HashSet();
+ uriToPrefix.put(uri, prefixes);
+ }
+
+ if(!prefixes.contains(prefix))
+ {
+ String oldURI = (String)prefixToURI.get(prefix);
+
+ // Add the new mapping
+ prefixes.add(prefix);
+ prefixToURI.put(prefix, uri);
+ if(declarations != null)
+ declarations.add(new Namespace(lib, prefix, uri));
+
+ if(oldURI != null)
+ {
+ // Update the existing mapping
+ prefixes = (Set)uriToPrefix.get(oldURI);
+ prefixes.remove(prefix);
+ }
+ }
+ }
+
+ /**
+ * Updates the internal state of this NamespaceHelper to reflect the
+ * existance of the XML token pointed to by the cursor.
+ */
+ private void processName(XmlCursor cursor, ObjArray declarations)
+ {
+ javax.xml.namespace.QName qname = cursor.getName();
+ String uri = qname.getNamespaceURI();
+ Set prefixes = (Set)uriToPrefix.get(uri);
+ if(prefixes == null || prefixes.size() == 0)
+ {
+ undeclared.add(uri);
+ if(declarations != null)
+ declarations.add(new Namespace(lib, uri));
+ }
+ }
+
+ /**
+ * Updates the internal state of this NamespaceHelper with the
+ * namespace information of the element pointed to by the cursor.
+ */
+ private void update(XmlCursor cursor, ObjArray declarations)
+ {
+ // Process the Namespace declarations
+ cursor.push();
+ while(cursor.toNextToken().isAnyAttr())
+ {
+ if(cursor.isNamespace())
+ {
+ javax.xml.namespace.QName name = cursor.getName();
+ String prefix = name.getLocalPart();
+ String uri = name.getNamespaceURI();
+
+ declareNamespace(prefix, uri, declarations);
+ }
+ }
+ cursor.pop();
+
+ // Process the element
+ processName(cursor, declarations);
+
+ // Process the attributes
+ cursor.push();
+ boolean hasNext = cursor.toFirstAttribute();
+ while(hasNext)
+ {
+ processName(cursor, declarations);
+ hasNext = cursor.toNextAttribute();
+ }
+ cursor.pop();
+ }
+
+ /**
+ * @return Object[] array of Namespace objects in scope at the cursor.
+ */
+ public static Object[] inScopeNamespaces(XMLLibImpl lib, XmlCursor cursor)
+ {
+ ObjArray namespaces = new ObjArray();
+ NamespaceHelper helper = new NamespaceHelper(lib);
+
+ cursor.push();
+
+ int depth = 0;
+ while(cursor.hasPrevToken())
+ {
+ if(cursor.isContainer())
+ {
+ cursor.push();
+ depth++;
+ }
+
+ cursor.toParent();
+ }
+
+ for(int i = 0; i < depth; i++)
+ {
+ cursor.pop();
+ helper.update(cursor, null);
+ }
+
+ Iterator i = helper.prefixToURI.entrySet().iterator();
+ while(i.hasNext())
+ {
+ Map.Entry entry = (Map.Entry)i.next();
+ Namespace ns = new Namespace(lib, (String)entry.getKey(),
+ (String)entry.getValue());
+ namespaces.add(ns);
+ }
+
+ i = helper.undeclared.iterator();
+ while(i.hasNext())
+ {
+ Namespace ns = new Namespace(lib, (String)i.next());
+ namespaces.add(ns);
+ }
+
+ cursor.pop();
+
+ return namespaces.toArray();
+ }
+
+ static Namespace getNamespace(XMLLibImpl lib, XmlCursor cursor,
+ Object[] inScopeNamespaces)
+ {
+ String uri;
+ String prefix;
+
+ if (cursor.isProcinst()) {
+ uri = "";
+ prefix = "";
+ } else {
+ javax.xml.namespace.QName qname = cursor.getName();
+ uri = qname.getNamespaceURI();
+ prefix = qname.getPrefix();
+ }
+
+ if (inScopeNamespaces == null)
+ return new Namespace(lib, prefix, uri);
+
+ Namespace result = null;
+ for (int i = 0; i != inScopeNamespaces.length; ++i) {
+ Namespace ns = (Namespace)inScopeNamespaces[i];
+ if(ns == null) continue;
+
+ String nsURI = ns.uri();
+ if(nsURI.equals(uri))
+ {
+ if(prefix.equals(ns.prefix()))
+ {
+ result = ns;
+ break;
+ }
+
+ if(result == null ||
+ (result.prefix() == null &&
+ ns.prefix() != null))
+ result = ns;
+ }
+ }
+
+ if(result == null)
+ result = new Namespace(lib, prefix, uri);
+
+ return result;
+ }
+
+ /**
+ * @return List of Namespace objects that are declared in the container pointed to by the cursor.
+ */
+ public static Object[] namespaceDeclarations(XMLLibImpl lib, XmlCursor cursor)
+ {
+ ObjArray declarations = new ObjArray();
+ NamespaceHelper helper = new NamespaceHelper(lib);
+
+ cursor.push();
+
+ int depth = 0;
+ while(cursor.hasPrevToken())
+ {
+ if(cursor.isContainer())
+ {
+ cursor.push();
+ depth++;
+ }
+
+ cursor.toParent();
+ }
+
+ for(int i = 0; i < depth - 1; i++)
+ {
+ cursor.pop();
+ helper.update(cursor, null);
+ }
+
+ if(depth > 0)
+ {
+ cursor.pop();
+ helper.update(cursor, declarations);
+ }
+
+ cursor.pop();
+
+ return declarations.toArray();
+ }
+
+ /**
+ * @return Prefix to URI map of all namespaces in scope at the cursor.
+ */
+ public static Map getAllNamespaces(XMLLibImpl lib, XmlCursor cursor)
+ {
+ NamespaceHelper helper = new NamespaceHelper(lib);
+
+ cursor.push();
+
+ int depth = 0;
+ while(cursor.hasPrevToken())
+ {
+ if(cursor.isContainer())
+ {
+ cursor.push();
+ depth++;
+ }
+
+ cursor.toParent();
+ }
+
+ for(int i = 0; i < depth; i++)
+ {
+ cursor.pop();
+ helper.update(cursor, null);
+ }
+
+ cursor.pop();
+
+ return helper.prefixToURI;
+ }
+
+ public static void getNamespaces(XmlCursor cursor, Map prefixToURI)
+ {
+ cursor.push();
+ while(cursor.toNextToken().isAnyAttr())
+ {
+ if(cursor.isNamespace())
+ {
+ javax.xml.namespace.QName name = cursor.getName();
+ String prefix = name.getLocalPart();
+ String uri = name.getNamespaceURI();
+
+ prefixToURI.put(prefix, uri);
+ }
+ }
+ cursor.pop();
+ }
+
+ public static void removeNamespace(XmlCursor cursor, String prefix)
+ {
+ cursor.push();
+ while(cursor.toNextToken().isAnyAttr())
+ {
+ if(cursor.isNamespace())
+ {
+ javax.xml.namespace.QName name = cursor.getName();
+ if(name.getLocalPart().equals(prefix))
+ {
+ cursor.removeXml();
+ break;
+ }
+ }
+ }
+ cursor.pop();
+ }
+} \ No newline at end of file
diff --git a/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/QName.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/QName.java
new file mode 100644
index 0000000..247da19
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/QName.java
@@ -0,0 +1,321 @@
+/* -*- 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.xml.impl.xmlbeans;
+
+import org.mozilla.javascript.*;
+
+/**
+ * Class QName
+ *
+ */
+final class QName extends IdScriptableObject
+{
+ static final long serialVersionUID = 416745167693026750L;
+
+ private static final Object QNAME_TAG = new Object();
+
+ XMLLibImpl lib;
+ private String prefix;
+ private String localName;
+ private String uri;
+
+ QName(XMLLibImpl lib, String uri, String localName, String prefix)
+ {
+ super(lib.globalScope(), lib.qnamePrototype);
+ if (localName == null) throw new IllegalArgumentException();
+ this.lib = lib;
+ this.uri = uri;
+ this.prefix = prefix;
+ this.localName = localName;
+ }
+
+ void exportAsJSClass(boolean sealed)
+ {
+ exportAsJSClass(MAX_PROTOTYPE_ID, lib.globalScope(), sealed);
+ }
+
+ /**
+ *
+ * @return
+ */
+ public String toString()
+ {
+ String result;
+
+ if (uri == null)
+ {
+ result = "*::".concat(localName);
+ }
+ else if(uri.length() == 0)
+ {
+ result = localName;
+ }
+ else
+ {
+ result = uri + "::" + localName;
+ }
+
+ return result;
+ }
+
+ public String localName()
+ {
+ return localName;
+ }
+
+ String prefix()
+ {
+ return (prefix == null) ? prefix : "";
+ }
+
+ String uri()
+ {
+ return uri;
+ }
+
+ 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)
+ {
+ boolean result;
+
+ if (uri == null) {
+ result = q.uri == null && localName.equals(q.localName);
+ } else {
+ result = uri.equals(q.uri) && localName.equals(q.localName);
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @return
+ */
+ public String getClassName ()
+ {
+ return "QName";
+ }
+
+ /**
+ *
+ * @param hint
+ * @return
+ */
+ 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: 2004-07-18 12:32:51 CEST
+ 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;
+ }
+// #/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: 2004-08-21 12:45:13 CEST
+ 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;
+ }
+// #/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;
+ }
+
+ private Object jsConstructor(Context cx, boolean inNewExpr, Object[] args)
+ {
+ if (!inNewExpr && args.length == 1) {
+ return lib.castToQName(cx, args[0]);
+ }
+ if (args.length == 0) {
+ return lib.constructQName(cx, Undefined.instance);
+ } else if (args.length == 1) {
+ return lib.constructQName(cx, args[0]);
+ } else {
+ return lib.constructQName(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/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XML.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XML.java
new file mode 100644
index 0000000..c8818a5
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XML.java
@@ -0,0 +1,3092 @@
+/* -*- 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.xml.impl.xmlbeans;
+
+import java.io.Serializable;
+import java.util.*;
+
+import org.mozilla.javascript.*;
+
+import org.apache.xmlbeans.XmlCursor;
+import org.apache.xmlbeans.XmlCursor.XmlBookmark;
+import org.apache.xmlbeans.XmlCursor.TokenType;
+import org.apache.xmlbeans.XmlException;
+import org.apache.xmlbeans.XmlObject;
+import org.apache.xmlbeans.XmlOptions;
+
+class XML extends XMLObjectImpl
+{
+ static final long serialVersionUID = -630969919086449092L;
+
+ final static class XScriptAnnotation extends XmlBookmark implements Serializable
+ {
+ private static final long serialVersionUID = 1L;
+
+ javax.xml.namespace.QName _name;
+ XML _xScriptXML;
+
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Constructurs
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ XScriptAnnotation (XmlCursor curs)
+ {
+ _name = curs.getName();
+ }
+
+ }
+
+ /**
+ *
+ */
+ final static class NamespaceDeclarations
+ {
+ private int _prefixIdx;
+ private StringBuffer _namespaceDecls;
+ private String _defaultNSURI;
+
+
+ NamespaceDeclarations (XmlCursor curs)
+ {
+ _prefixIdx = 0;
+ _namespaceDecls = new StringBuffer();
+
+ skipNonElements(curs);
+ _defaultNSURI = curs.namespaceForPrefix("");
+
+ if (isAnyDefaultNamespace())
+ {
+ addDecl("", _defaultNSURI);
+ }
+ }
+
+
+ private void addDecl (String prefix, String ns)
+ {
+ _namespaceDecls.append((prefix.length() > 0 ?
+ "declare namespace " + prefix :
+ "default element namespace") +
+ " = \"" + ns + "\"" + "\n");
+ }
+
+
+ String getNextPrefix (String ns)
+ {
+ String prefix = "NS" + _prefixIdx++;
+
+ _namespaceDecls.append("declare namespace " + prefix + " = " + "\"" + ns + "\"" + "\n");
+
+ return prefix;
+ }
+
+
+ boolean isAnyDefaultNamespace ()
+ {
+ return _defaultNSURI != null ?_defaultNSURI.length() > 0 : false;
+ }
+
+
+ String getDeclarations()
+ {
+ return _namespaceDecls.toString();
+ }
+ }
+
+ // Fields
+ //static final XML prototype = new XML();
+ private XScriptAnnotation _anno;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Constructors
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ /**
+ *
+ * @param anno
+ */
+ private XML(XMLLibImpl lib, XScriptAnnotation anno)
+ {
+ super(lib, lib.xmlPrototype);
+ _anno = anno;
+ _anno._xScriptXML = this;
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Public factories for creating a XScript XML object given an XBean cursor.
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+ static XML createEmptyXML(XMLLibImpl lib)
+ {
+ XScriptAnnotation anno;
+
+ XmlObject xo = XmlObject.Factory.newInstance();
+ XmlCursor curs = xo.newCursor();
+ try {
+ anno = new XScriptAnnotation(curs);
+ curs.setBookmark(anno);
+ } finally {
+ curs.dispose();
+ }
+
+ return new XML(lib, anno);
+ }
+
+ private static XML createXML (XMLLibImpl lib, XmlCursor curs)
+ {
+ if (curs.currentTokenType().isStartdoc())
+ {
+ curs.toFirstContentToken();
+ }
+
+ XScriptAnnotation anno = findAnnotation(curs);
+
+ return new XML(lib, anno);
+ }
+
+ /**
+ * Special constructor for making an attribute
+ *
+ */
+ private static XML createAttributeXML(XMLLibImpl lib, XmlCursor cursor)
+ {
+ if (!cursor.isAttr())
+ throw new IllegalArgumentException();
+
+ XScriptAnnotation anno = new XScriptAnnotation(cursor);
+ cursor.setBookmark(anno);
+
+ return new XML(lib, anno);
+ }
+
+
+ /**
+ *
+ * @param qname
+ * @param value
+ * @return
+ */
+ static XML createTextElement(XMLLibImpl lib, javax.xml.namespace.QName qname, String value)
+ {
+ XScriptAnnotation anno;
+
+ XmlObject xo = XmlObject.Factory.newInstance();
+ XmlCursor cursor = xo.newCursor();
+ try {
+ cursor.toNextToken();
+
+ cursor.beginElement(qname.getLocalPart(), qname.getNamespaceURI());
+ //if(namespace.length() > 0)
+ // cursor.insertNamespace("", namespace);
+ cursor.insertChars(value);
+
+ cursor.toStartDoc();
+ cursor.toNextToken();
+ anno = new XScriptAnnotation(cursor);
+ cursor.setBookmark(anno);
+ } finally {
+ cursor.dispose();
+ }
+
+ return new XML(lib, anno);
+ }
+
+ static XML createFromXmlObject(XMLLibImpl lib, XmlObject xo)
+ {
+ XScriptAnnotation anno;
+ XmlCursor curs = xo.newCursor();
+ if (curs.currentTokenType().isStartdoc())
+ {
+ curs.toFirstContentToken();
+ }
+ try {
+ anno = new XScriptAnnotation(curs);
+ curs.setBookmark(anno);
+ } finally {
+ curs.dispose();
+ }
+ return new XML(lib, anno);
+ }
+
+ static XML createFromJS(XMLLibImpl lib, Object inputObject)
+ {
+ XmlObject xo;
+ boolean isText = false;
+ String frag;
+
+ if (inputObject == null || inputObject == Undefined.instance) {
+ frag = "";
+ } else if (inputObject instanceof XMLObjectImpl) {
+ // todo: faster way for XMLObjects?
+ frag = ((XMLObjectImpl) inputObject).toXMLString(0);
+ } else {
+ if (inputObject instanceof Wrapper) {
+ Object wrapped = ((Wrapper)inputObject).unwrap();
+ if (wrapped instanceof XmlObject) {
+ return createFromXmlObject(lib, (XmlObject)wrapped);
+ }
+ }
+ frag = ScriptRuntime.toString(inputObject);
+ }
+
+ if (frag.trim().startsWith("<>"))
+ {
+ throw ScriptRuntime.typeError("Invalid use of XML object anonymous tags <></>.");
+ }
+
+ if (frag.indexOf("<") == -1)
+ {
+ // Must be solo text node, wrap in XML fragment
+ isText = true;
+ frag = "<textFragment>" + frag + "</textFragment>";
+ }
+
+ XmlOptions options = new XmlOptions();
+
+ if (lib.ignoreComments)
+ {
+ options.put(XmlOptions.LOAD_STRIP_COMMENTS);
+ }
+
+ if (lib.ignoreProcessingInstructions)
+ {
+ options.put(XmlOptions.LOAD_STRIP_PROCINSTS);
+ }
+
+ if (lib.ignoreWhitespace)
+ {
+ options.put(XmlOptions.LOAD_STRIP_WHITESPACE);
+ }
+
+ try
+ {
+ xo = XmlObject.Factory.parse(frag, options);
+
+ // Apply the default namespace
+ Context cx = Context.getCurrentContext();
+ String defaultURI = lib.getDefaultNamespaceURI(cx);
+
+ if(defaultURI.length() > 0)
+ {
+ XmlCursor cursor = xo.newCursor();
+ boolean isRoot = true;
+ while(!cursor.toNextToken().isEnddoc())
+ {
+ if(!cursor.isStart()) continue;
+
+ // Check if this element explicitly sets the
+ // default namespace
+ boolean defaultNSDeclared = false;
+ cursor.push();
+ while(cursor.toNextToken().isAnyAttr())
+ {
+ if(cursor.isNamespace())
+ {
+ if(cursor.getName().getLocalPart().length() == 0)
+ {
+ defaultNSDeclared = true;
+ break;
+ }
+ }
+ }
+ cursor.pop();
+ if(defaultNSDeclared)
+ {
+ cursor.toEndToken();
+ continue;
+ }
+
+ // Check if this element's name is in no namespace
+ javax.xml.namespace.QName qname = cursor.getName();
+ if(qname.getNamespaceURI().length() == 0)
+ {
+ // Change the namespace
+ qname = new javax.xml.namespace.QName(defaultURI,
+ qname.getLocalPart());
+ cursor.setName(qname);
+ }
+
+ if(isRoot)
+ {
+ // Declare the default namespace
+ cursor.push();
+ cursor.toNextToken();
+ cursor.insertNamespace("", defaultURI);
+ cursor.pop();
+
+ isRoot = false;
+ }
+ }
+ cursor.dispose();
+ }
+ }
+ catch (XmlException xe)
+ {
+/*
+todo need to handle namespace prefix not found in XML look for namespace type in the scope change.
+
+ String errorMsg = "Use of undefined namespace prefix: ";
+ String msg = xe.getError().getMessage();
+ if (msg.startsWith(errorMsg))
+ {
+ String prefix = msg.substring(errorMsg.length());
+ }
+*/
+ String errMsg = xe.getMessage();
+ if (errMsg.equals("error: Unexpected end of file after null"))
+ {
+ // Create an empty document.
+ xo = XmlObject.Factory.newInstance();
+ }
+ else
+ {
+ throw ScriptRuntime.typeError(xe.getMessage());
+ }
+ }
+ catch (Throwable e)
+ {
+ // todo: TLL Catch specific exceptions during parse.
+ throw ScriptRuntime.typeError("Not Parsable as XML");
+ }
+
+ XmlCursor curs = xo.newCursor();
+ if (curs.currentTokenType().isStartdoc())
+ {
+ curs.toFirstContentToken();
+ }
+
+ if (isText)
+ {
+ // Move it to point to the text node
+ curs.toFirstContentToken();
+ }
+
+ XScriptAnnotation anno;
+ try
+ {
+ anno = new XScriptAnnotation(curs);
+ curs.setBookmark(anno);
+ }
+ finally
+ {
+ curs.dispose();
+ }
+
+ return new XML(lib, anno);
+ }
+
+ static XML getFromAnnotation(XMLLibImpl lib, XScriptAnnotation anno)
+ {
+ if (anno._xScriptXML == null)
+ {
+ anno._xScriptXML = new XML(lib, anno);
+ }
+
+ return anno._xScriptXML;
+ }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Private functions:
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ /**
+ *
+ * @param curs
+ * @return
+ */
+ private static TokenType skipNonElements (XmlCursor curs)
+ {
+ TokenType tt = curs.currentTokenType();
+ while (tt.isComment() || tt.isProcinst())
+ {
+ tt = curs.toNextToken();
+ }
+
+ return tt;
+ }
+
+ /**
+ *
+ * @param curs
+ * @return
+ */
+ protected static XScriptAnnotation findAnnotation(XmlCursor curs)
+ {
+ XmlBookmark anno = curs.getBookmark(XScriptAnnotation.class);
+ if (anno == null)
+ {
+ anno = new XScriptAnnotation(curs);
+ curs.setBookmark(anno);
+ }
+
+ return (XScriptAnnotation)anno;
+ }
+
+ /**
+ *
+ * @return
+ */
+ private XmlOptions getOptions()
+ {
+ XmlOptions options = new XmlOptions();
+
+ if (lib.ignoreComments)
+ {
+ options.put(XmlOptions.LOAD_STRIP_COMMENTS);
+ }
+
+ if (lib.ignoreProcessingInstructions)
+ {
+ options.put(XmlOptions.LOAD_STRIP_PROCINSTS);
+ }
+
+ if (lib.ignoreWhitespace)
+ {
+ options.put(XmlOptions.LOAD_STRIP_WHITESPACE);
+ }
+
+ if (lib.prettyPrinting)
+ {
+ options.put(XmlOptions.SAVE_PRETTY_PRINT, null);
+ options.put(XmlOptions.SAVE_PRETTY_PRINT_INDENT, new Integer(lib.prettyIndent));
+ }
+
+ return options;
+ }
+
+
+ /**
+ *
+ * @param cursor
+ * @param opts
+ * @return
+ */
+ private static String dumpNode(XmlCursor cursor, XmlOptions opts)
+ {
+ if (cursor.isText())
+ return cursor.getChars();
+
+ if (cursor.isFinish())
+ return "";
+
+ cursor.push();
+ boolean wanRawText = cursor.isStartdoc() && !cursor.toFirstChild();
+ cursor.pop();
+
+ return wanRawText ? cursor.getTextValue() : cursor.xmlText( opts );
+ }
+
+ /**
+ *
+ * @return
+ */
+ private XmlCursor newCursor ()
+ {
+ XmlCursor curs;
+
+ if (_anno != null)
+ {
+ curs = _anno.createCursor();
+ if (curs == null)
+ {
+ // Orphaned case.
+ XmlObject doc = XmlObject.Factory.newInstance();
+ curs = doc.newCursor();
+
+ if (_anno._name != null)
+ {
+ curs.toNextToken();
+ curs.insertElement(_anno._name);
+ curs.toPrevSibling();
+ }
+
+ curs.setBookmark(_anno);
+ }
+ }
+ else
+ {
+ XmlObject doc = XmlObject.Factory.newInstance();
+ curs = doc.newCursor();
+ }
+
+ return curs;
+ }
+
+ /*
+ * fUseStartDoc used by child(int index) the index is at startDoc is the element at the top-level
+ * otherwise we always want to drill in.
+ */
+ private boolean moveToChild(XmlCursor curs, long index, boolean fFirstChild, boolean fUseStartDoc)
+ {
+ if (index < 0)
+ throw new IllegalArgumentException();
+
+ long idxChild = 0;
+
+ if (!fUseStartDoc && curs.currentTokenType().isStartdoc())
+ {
+ // We always move to the children of the top node.
+ // todo: This assumes that we want have multiple top-level nodes. Which we should be able tohave.
+ curs.toFirstContentToken();
+ }
+
+ TokenType tt = curs.toFirstContentToken();
+ if (!tt.isNone() && !tt.isEnd())
+ {
+ while (true)
+ {
+ if (index == idxChild)
+ {
+ return true;
+ }
+
+ tt = curs.currentTokenType();
+ if (tt.isText())
+ {
+ curs.toNextToken();
+ }
+ else if (tt.isStart())
+ {
+ // Need to do this we want to be pointing at the text if that after the end token.
+ curs.toEndToken();
+ curs.toNextToken();
+ }
+ else if (tt.isComment() || tt.isProcinst())
+ {
+ continue;
+ }
+ else
+ {
+ break;
+ }
+
+ idxChild++;
+ }
+ }
+ else if (fFirstChild && index == 0)
+ {
+ // Drill into where first child would be.
+// curs.toFirstContentToken();
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ *
+ * @return
+ */
+ XmlCursor.TokenType tokenType()
+ {
+ XmlCursor.TokenType result;
+
+ XmlCursor curs = newCursor();
+
+ if (curs.isStartdoc())
+ {
+ curs.toFirstContentToken();
+ }
+
+ result = curs.currentTokenType();
+
+ curs.dispose();
+
+ return result;
+ }
+ /**
+ *
+ * @param srcCurs
+ * @param destCurs
+ * @param fDontMoveIfSame
+ * @return
+ */
+ private boolean moveSrcToDest (XmlCursor srcCurs, XmlCursor destCurs, boolean fDontMoveIfSame)
+ {
+ boolean fMovedSomething = true;
+ TokenType tt;
+ do
+ {
+ if (fDontMoveIfSame && srcCurs.isInSameDocument(destCurs) && (srcCurs.comparePosition(destCurs) == 0))
+ {
+ // If the source and destination are pointing at the same place then there's nothing to move.
+ fMovedSomething = false;
+ break;
+ }
+
+ // todo ***TLL*** Use replaceContents (when added) and eliminate children removes (see above todo).
+ if (destCurs.currentTokenType().isStartdoc())
+ {
+ destCurs.toNextToken();
+ }
+
+ // todo ***TLL*** Can Eric support notion of copy instead of me copying then moving???
+ XmlCursor copyCurs = copy(srcCurs);
+
+ copyCurs.moveXml(destCurs);
+
+ copyCurs.dispose();
+
+ tt = srcCurs.currentTokenType();
+ } while (!tt.isStart() && !tt.isEnd() && !tt.isEnddoc());
+
+ return fMovedSomething;
+ }
+
+ /**
+ *
+ * @param cursToCopy
+ * @return
+ */
+ private XmlCursor copy (XmlCursor cursToCopy)
+ {
+ XmlObject xo = XmlObject.Factory.newInstance();
+
+ XmlCursor copyCurs = null;
+
+ if (cursToCopy.currentTokenType().isText())
+ {
+ try
+ {
+ // Try just as a textnode, to do that we need to wrap the text in a special fragment tag
+ // that is not visible from the XmlCursor.
+ copyCurs = XmlObject.Factory.parse("<x:fragment xmlns:x=\"http://www.openuri.org/fragment\">" +
+ cursToCopy.getChars() +
+ "</x:fragment>").newCursor();
+ if (!cursToCopy.toNextSibling())
+ {
+ if (cursToCopy.currentTokenType().isText())
+ {
+ cursToCopy.toNextToken(); // It's not an element it's text so skip it.
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ throw ScriptRuntime.typeError(ex.getMessage());
+ }
+ }
+ else
+ {
+ copyCurs = xo.newCursor();
+ copyCurs.toFirstContentToken();
+ if (cursToCopy.currentTokenType() == XmlCursor.TokenType.STARTDOC)
+ {
+ cursToCopy.toNextToken();
+ }
+
+ cursToCopy.copyXml(copyCurs);
+ if (!cursToCopy.toNextSibling()) // If element skip element.
+ {
+ if (cursToCopy.currentTokenType().isText())
+ {
+ cursToCopy.toNextToken(); // It's not an element it's text so skip it.
+ }
+ }
+
+ }
+
+ copyCurs.toStartDoc();
+ copyCurs.toFirstContentToken();
+
+ return copyCurs;
+ }
+
+ private static final int APPEND_CHILD = 1;
+ private static final int PREPEND_CHILD = 2;
+
+ /**
+ *
+ * @param curs
+ * @param xmlToInsert
+ */
+ private void insertChild(XmlCursor curs, Object xmlToInsert)
+ {
+ if (xmlToInsert == null || xmlToInsert instanceof Undefined)
+ {
+ // Do nothing
+ }
+ else if (xmlToInsert instanceof XmlCursor)
+ {
+ moveSrcToDest((XmlCursor)xmlToInsert, curs, true);
+ }
+ else if (xmlToInsert instanceof XML)
+ {
+ XML xmlValue = (XML) xmlToInsert;
+
+ // If it's an attribute, then change to text node
+ if (xmlValue.tokenType() == XmlCursor.TokenType.ATTR)
+ {
+ insertChild(curs, xmlValue.toString());
+ }
+ else
+ {
+ XmlCursor cursToInsert = ((XML) xmlToInsert).newCursor();
+
+ moveSrcToDest(cursToInsert, curs, true);
+
+ cursToInsert.dispose();
+ }
+ }
+ else if (xmlToInsert instanceof XMLList)
+ {
+ XMLList list = (XMLList) xmlToInsert;
+
+ for (int i = 0; i < list.length(); i++)
+ {
+ insertChild(curs, list.item(i));
+ }
+ }
+ else
+ {
+ // Convert to string and make XML out of it
+ String xmlStr = ScriptRuntime.toString(xmlToInsert);
+ XmlObject xo = XmlObject.Factory.newInstance(); // Create an empty document.
+
+ XmlCursor sourceCurs = xo.newCursor();
+ sourceCurs.toNextToken();
+
+ // To hold the text.
+ sourceCurs.insertChars(xmlStr);
+
+ sourceCurs.toPrevToken();
+
+ // Call us again with the cursor.
+ moveSrcToDest(sourceCurs, curs, true);
+ }
+ }
+
+ /**
+ *
+ * @param childToMatch
+ * @param xmlToInsert
+ * @param addToType
+ */
+ private void insertChild(XML childToMatch, Object xmlToInsert, int addToType)
+ {
+ XmlCursor curs = newCursor();
+ TokenType tt = curs.currentTokenType();
+ XmlCursor xmlChildCursor = childToMatch.newCursor();
+
+ if (tt.isStartdoc())
+ {
+ tt = curs.toFirstContentToken();
+ }
+
+ if (tt.isContainer())
+ {
+ tt = curs.toNextToken();
+
+ while (!tt.isEnd())
+ {
+ if (tt.isStart())
+ {
+ // See if this child is the same as the one thep passed in
+ if (curs.comparePosition(xmlChildCursor) == 0)
+ {
+ // Found it
+ if (addToType == APPEND_CHILD)
+ {
+ // Move the cursor to just past the end of this element
+ curs.toEndToken();
+ curs.toNextToken();
+ }
+
+ insertChild(curs, xmlToInsert);
+ break;
+ }
+ }
+
+ // Skip over child elements
+ if (tt.isStart())
+ {
+ tt = curs.toEndToken();
+ }
+
+ tt = curs.toNextToken();
+ }
+
+ }
+
+ xmlChildCursor.dispose();
+ curs.dispose();
+ }
+
+ /**
+ *
+ * @param curs
+ */
+ protected void removeToken (XmlCursor curs)
+ {
+ XmlObject xo = XmlObject.Factory.newInstance();
+
+ // Don't delete anything move to another document so it gets orphaned nicely.
+ XmlCursor tmpCurs = xo.newCursor();
+ tmpCurs.toFirstContentToken();
+
+
+ curs.moveXml(tmpCurs);
+
+ tmpCurs.dispose();
+ }
+
+ /**
+ *
+ * @param index
+ */
+ protected void removeChild(long index)
+ {
+ XmlCursor curs = newCursor();
+
+ if (moveToChild(curs, index, false, false))
+ {
+ removeToken(curs);
+ }
+
+ curs.dispose();
+ }
+
+ /**
+ *
+ * @param name
+ * @return
+ */
+ protected static javax.xml.namespace.QName computeQName (Object name)
+ {
+ if (name instanceof String)
+ {
+ String ns = null;
+ String localName = null;
+
+ String fullName = (String)name;
+ localName = fullName;
+ if (fullName.startsWith("\""))
+ {
+ int idx = fullName.indexOf(":");
+ if (idx != -1)
+ {
+ ns = fullName.substring(1, idx - 1); // Don't include the "" around the namespace
+ localName = fullName.substring(idx + 1);
+ }
+ }
+
+ if (ns == null)
+ {
+ return new javax.xml.namespace.QName(localName);
+ }
+ else
+ {
+ return new javax.xml.namespace.QName(ns, localName);
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ *
+ * @param destCurs
+ * @param newValue
+ */
+ private void replace(XmlCursor destCurs, XML newValue)
+ {
+ if (destCurs.isStartdoc())
+ {
+ // Can't overwrite a whole document (user really wants to overwrite the contents of).
+ destCurs.toFirstContentToken();
+ }
+
+ // Orphan the token -- don't delete it outright on the XmlCursor.
+ removeToken(destCurs);
+
+ XmlCursor srcCurs = newValue.newCursor();
+ if (srcCurs.currentTokenType().isStartdoc())
+ {
+ // Cann't append a whole document (user really wants to append the contents of).
+ srcCurs.toFirstContentToken();
+ }
+
+ moveSrcToDest(srcCurs, destCurs, false);
+
+ // Re-link a new annotation to this cursor -- we just deleted the previous annotation on entrance to replace.
+ if (!destCurs.toPrevSibling())
+ {
+ destCurs.toPrevToken();
+ }
+ destCurs.setBookmark(new XScriptAnnotation(destCurs));
+
+ // todo would be nice if destCurs.toNextSibling went to where the next token if the cursor was pointing at the last token in the stream.
+ destCurs.toEndToken();
+ destCurs.toNextToken();
+
+ srcCurs.dispose();
+ }
+
+ /**
+ *
+ * @param currXMLNode
+ * @param xmlValue
+ * @return
+ */
+ private boolean doPut(XMLName name, XML currXMLNode, XMLObjectImpl xmlValue)
+ {
+ boolean result = false;
+ XmlCursor curs = currXMLNode.newCursor();
+
+ try
+ {
+ // Replace the node with this new xml value.
+ XML xml;
+
+ int toAssignLen = xmlValue.length();
+
+ for (int i = 0; i < toAssignLen; i++)
+ {
+ if (xmlValue instanceof XMLList)
+ {
+ xml = ((XMLList) xmlValue).item(i);
+ }
+ else
+ {
+ xml = (XML) xmlValue;
+ }
+
+ // If it's an attribute or text node, make text node.
+ XmlCursor.TokenType tt = xml.tokenType();
+ if (tt == XmlCursor.TokenType.ATTR || tt == XmlCursor.TokenType.TEXT)
+ {
+ xml = makeXmlFromString(lib, name, xml.toString());
+ }
+
+ if (i == 0)
+ {
+ // 1st assignment is replaceChild all others are appendChild
+ replace(curs, xml);
+ }
+ else
+ {
+ insertChild(curs, xml);
+ }
+ }
+
+ // We're done we've blown away the node because the rvalue was XML...
+ result = true;
+ }
+ catch (Exception ex)
+ {
+ ex.printStackTrace();
+ throw ScriptRuntime.typeError(ex.getMessage());
+ }
+ finally
+ {
+ curs.dispose();
+ }
+
+ return result;
+ }
+
+ /**
+ * Make a text node element with this element name and text value.
+ *
+ * @param name
+ * @param value
+ * @return
+ */
+ private XML makeXmlFromString(XMLLibImpl lib, XMLName name,
+ String value)
+ {
+ XML result;
+
+ javax.xml.namespace.QName qname;
+
+ try
+ {
+ qname = new javax.xml.namespace.QName(name.uri(), name.localName());
+ }
+ catch(Exception e)
+ {
+ throw ScriptRuntime.typeError(e.getMessage());
+ }
+
+ result = createTextElement(lib, qname, value);
+
+ return result;
+ }
+
+ /**
+ *
+ * @param name
+ * @return
+ */
+ private XMLList matchAttributes(XMLName xmlName)
+ {
+ XMLList result = new XMLList(lib);
+ XmlCursor curs = newCursor();
+
+ if (curs.currentTokenType().isStartdoc())
+ {
+ curs.toFirstContentToken();
+ }
+
+ if (curs.isStart())
+ {
+ if (curs.toFirstAttribute())
+ {
+ do
+ {
+ if (qnameMatches(xmlName, curs.getName()))
+ {
+ result.addToList(createAttributeObject(curs));
+ }
+ } while (curs.toNextAttribute());
+ }
+ }
+
+ curs.dispose();
+
+ return result;
+ }
+
+ /**
+ *
+ * @param attrCurs
+ * @return
+ */
+ private XML createAttributeObject (XmlCursor attrCurs)
+ {
+ XML result = null;
+
+ if (attrCurs.currentTokenType().isAttr())
+ {
+ result = createAttributeXML(lib, attrCurs);
+ }
+
+ return result;
+ }
+
+ //
+ //
+ // methods overriding ScriptableObject
+ //
+ //
+
+ public String getClassName ()
+ {
+ return "XML";
+ }
+
+ //
+ //
+ // methods overriding IdScriptableObject
+ //
+ //
+
+ /**
+ * XML[0] should return this, all other indexes are Undefined
+ *
+ * @param index
+ * @param start
+ * @return
+ */
+ public Object get(int index, Scriptable start)
+ {
+ //Log("get index: " + index);
+
+ if (index == 0)
+ {
+ return this;
+ }
+ else
+ {
+ return Scriptable.NOT_FOUND;
+ }
+ }
+
+ /**
+ * Does the named property exist
+ *
+ * @param name
+ * @param start
+ * @return
+ */
+ boolean hasXMLProperty(XMLName xmlName)
+ {
+ boolean result = false;
+
+ if (prototypeFlag)
+ {
+ String name = xmlName.localName();
+
+ if (getMethod(name) != NOT_FOUND)
+ {
+ result = true;
+ }
+ }
+ else
+ {
+ // 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;
+ }
+
+
+ /**
+ *
+ * @param index
+ * @param start
+ * @return
+ */
+ public boolean has(int index, Scriptable start)
+ {
+ return (index == 0);
+ }
+
+ /**
+ *
+ * @return
+ */
+ public Object[] getIds()
+ {
+ Object[] enumObjs;
+
+ if (prototypeFlag)
+ {
+ enumObjs = new Object[0];
+ }
+ else
+ {
+ enumObjs = new Object[1];
+
+ enumObjs[0] = new Integer(0);
+ }
+
+ return enumObjs;
+ }
+
+
+ /**
+ *
+ * @return
+ */
+ public Object [] getIdsForDebug()
+ {
+ return getIds();
+ }
+
+ /**
+ *
+ * @param name
+ * @param start
+ * @return
+ */
+ Object getXMLProperty(XMLName xmlName)
+ {
+ Object result = NOT_FOUND;
+
+ if (prototypeFlag)
+ {
+ String name = xmlName.localName();
+
+ result = getMethod(name);
+ }
+ else
+ {
+ result = getPropertyList(xmlName);
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @param name
+ * @param start
+ * @param value
+ */
+ void putXMLProperty(XMLName xmlName, Object value)
+ {
+ //Log("put property: " + name + " value: " + value.getClass());
+
+ if (prototypeFlag)
+ {
+ }
+ else
+ {
+ // Special-case checks for undefined and null
+ if (value == null)
+ {
+ value = "null";
+ }
+ else if (value instanceof Undefined)
+ {
+ value = "undefined";
+ }
+
+ // Get the named property
+ if (xmlName.isAttributeName())
+ {
+ setAttribute(xmlName, value);
+ }
+ else if (xmlName.uri() == null &&
+ xmlName.localName().equals("*"))
+ {
+ 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).tokenType() == XmlCursor.TokenType.ATTR)
+ {
+ xmlValue = makeXmlFromString(lib, xmlName, xmlValue.toString());
+ }
+ }
+
+ if (xmlValue instanceof XMLList)
+ {
+ for (int i = 0; i < xmlValue.length(); i++)
+ {
+ XML xml = ((XMLList) xmlValue).item(i);
+
+ if (xml.tokenType() == XmlCursor.TokenType.ATTR)
+ {
+ ((XMLList) xmlValue).replace(i, makeXmlFromString(lib, xmlName, xml.toString()));
+ }
+ }
+ }
+ }
+ else
+ {
+ xmlValue = makeXmlFromString(lib, xmlName, ScriptRuntime.toString(value));
+ }
+
+ XMLList matches = getPropertyList(xmlName);
+
+ if (matches.length() == 0)
+ {
+ appendChild(xmlValue);
+ }
+ else
+ {
+ // Remove all other matches
+ for (int i = 1; i < matches.length(); i++)
+ {
+ removeChild(matches.item(i).childIndex());
+ }
+
+ // Replace first match with new value.
+ doPut(xmlName, matches.item(0), xmlValue);
+ }
+ }
+ }
+ }
+
+
+ /**
+ *
+ * @param index
+ * @param start
+ * @param value
+ */
+ public void put(int index, Scriptable start, Object value)
+ {
+ // Spec says assignment to indexed XML object should return type error
+ throw ScriptRuntime.typeError("Assignment to indexed XML is not allowed");
+ }
+
+
+ /**
+ *
+ * @param name
+ */
+ void deleteXMLProperty(XMLName name)
+ {
+ if (!name.isDescendants() && name.isAttributeName())
+ {
+ XmlCursor curs = newCursor();
+
+ // TODO: Cover the case *::name
+ if (name.localName().equals("*"))
+ {
+ // Delete all attributes.
+ if (curs.toFirstAttribute())
+ {
+ while (curs.currentTokenType().isAttr())
+ {
+ curs.removeXml();
+ }
+ }
+ }
+ else
+ {
+ // Delete an attribute.
+ javax.xml.namespace.QName qname = new javax.xml.namespace.QName(
+ name.uri(), name.localName());
+ curs.removeAttribute(qname);
+ }
+
+ curs.dispose();
+ }
+ else
+ {
+ XMLList matches = getPropertyList(name);
+
+ matches.remove();
+ }
+ }
+
+
+ /**
+ *
+ * @param index
+ */
+ public void delete(int index)
+ {
+ if (index == 0)
+ {
+ remove();
+ }
+ }
+
+ //
+ //
+ // package utility functions:
+ //
+ //
+
+ protected XScriptAnnotation getAnnotation ()
+ { return _anno; }
+
+
+ protected void changeNS (String oldURI, String newURI)
+ {
+ XmlCursor curs = newCursor();
+ while (curs.toParent()) {
+ /* Goto the top of the document */
+ }
+
+ TokenType tt = curs.currentTokenType();
+ if (tt.isStartdoc())
+ {
+ tt = curs.toFirstContentToken();
+ }
+
+ if (tt.isStart())
+ {
+ do
+ {
+ if (tt.isStart() || tt.isAttr() || tt.isNamespace())
+ {
+ javax.xml.namespace.QName currQName = curs.getName();
+ if (oldURI.equals(currQName.getNamespaceURI()))
+ {
+ curs.setName(new javax.xml.namespace.QName(newURI, currQName.getLocalPart()));
+ }
+ }
+
+ tt = curs.toNextToken();
+ } while (!tt.isEnddoc() && !tt.isNone());
+ }
+
+ curs.dispose();
+ }
+
+
+ /**
+ *
+ */
+ void remove ()
+ {
+ XmlCursor childCurs = newCursor();
+
+ if (childCurs.currentTokenType().isStartdoc())
+ {
+ // Remove on the document removes all children.
+ TokenType tt = childCurs.toFirstContentToken();
+ while (!tt.isEnd() && !tt.isEnddoc())
+ {
+ removeToken(childCurs);
+ tt = childCurs.currentTokenType(); // Now see where we're pointing after the delete -- next token.
+ }
+ }
+ else
+ {
+ removeToken(childCurs);
+ }
+
+ childCurs.dispose();
+ }
+
+
+ /**
+ *
+ * @param value
+ */
+ void replaceAll(XML value)
+ {
+ XmlCursor curs = newCursor();
+
+ replace(curs, value);
+ _anno = value._anno;
+
+ curs.dispose();
+ }
+
+
+ /**
+ *
+ * @param attrName
+ * @param value
+ */
+ void setAttribute(XMLName xmlName, Object value)
+ {
+ if (xmlName.uri() == null &&
+ xmlName.localName().equals("*"))
+ {
+ throw ScriptRuntime.typeError("@* assignment not supported.");
+ }
+
+ XmlCursor curs = newCursor();
+
+ String strValue = ScriptRuntime.toString(value);
+ if (curs.currentTokenType().isStartdoc())
+ {
+ curs.toFirstContentToken();
+ }
+
+ javax.xml.namespace.QName qName;
+
+ try
+ {
+ qName = new javax.xml.namespace.QName(xmlName.uri(), xmlName.localName());
+ }
+ catch(Exception e)
+ {
+ throw ScriptRuntime.typeError(e.getMessage());
+ }
+
+ if (!curs.setAttributeText(qName, strValue))
+ {
+ if (curs.currentTokenType().isStart())
+ {
+ // Can only add attributes inside of a start.
+ curs.toNextToken();
+ }
+ curs.insertAttributeWithValue(qName, strValue);
+ }
+
+ curs.dispose();
+ }
+
+ /**
+ *
+ * @param namespace
+ * @return
+ */
+ private XMLList allChildNodes(String namespace)
+ {
+ XMLList result = new XMLList(lib);
+ XmlCursor curs = newCursor();
+ TokenType tt = curs.currentTokenType();
+ javax.xml.namespace.QName targetProperty = new javax.xml.namespace.QName(namespace, "*");
+
+ if (tt.isStartdoc())
+ {
+ tt = curs.toFirstContentToken();
+ }
+
+ if (tt.isContainer())
+ {
+ tt = curs.toFirstContentToken();
+
+ while (!tt.isEnd())
+ {
+ if (!tt.isStart())
+ {
+ // Not an element
+ result.addToList(findAnnotation(curs));
+
+ // Reset target property to null in this case
+ targetProperty = null;
+ }
+ else
+ {
+ // Match namespace as well if specified
+ if (namespace == null ||
+ namespace.length() == 0 ||
+ namespace.equals("*") ||
+ curs.getName().getNamespaceURI().equals(namespace))
+ {
+ // Add it to the list
+ result.addToList(findAnnotation(curs));
+
+ // Set target property if target name is "*",
+ // Otherwise if target property does not match current, then
+ // set to null
+ if (targetProperty != null)
+ {
+ if (targetProperty.getLocalPart().equals("*"))
+ {
+ targetProperty = curs.getName();
+ }
+ else if (!targetProperty.getLocalPart().equals(curs.getName().getLocalPart()))
+ {
+ // Not a match, unset target property
+ targetProperty = null;
+ }
+ }
+ }
+ }
+
+ // Skip over child elements
+ if (tt.isStart())
+ {
+ tt = curs.toEndToken();
+ }
+
+ tt = curs.toNextToken();
+ }
+ }
+
+ curs.dispose();
+
+ // Set the targets for this XMLList.
+ result.setTargets(this, targetProperty);
+
+ return result;
+ }
+
+ /**
+ *
+ * @return
+ */
+ private XMLList matchDescendantAttributes(XMLName xmlName)
+ {
+ XMLList result = new XMLList(lib);
+ XmlCursor curs = newCursor();
+ TokenType tt = curs.currentTokenType();
+
+ // Set the targets for this XMLList.
+ result.setTargets(this, null);
+
+ if (tt.isStartdoc())
+ {
+ tt = curs.toFirstContentToken();
+ }
+
+ if (tt.isContainer())
+ {
+ int nestLevel = 1;
+
+ while (nestLevel > 0)
+ {
+ tt = curs.toNextToken();
+
+ // Only try to match names for attributes
+ if (tt.isAttr())
+ {
+ if (qnameMatches(xmlName, curs.getName()))
+ {
+ result.addToList(findAnnotation(curs));
+ }
+ }
+
+ if (tt.isStart())
+ {
+ nestLevel++;
+ }
+ else if (tt.isEnd())
+ {
+ nestLevel--;
+ }
+ else if (tt.isEnddoc())
+ {
+ // Shouldn't get here, but just in case.
+ break;
+ }
+ }
+ }
+
+ curs.dispose();
+
+ return result;
+ }
+
+ /**
+ *
+ * @return
+ */
+ private XMLList matchDescendantChildren(XMLName xmlName)
+ {
+ XMLList result = new XMLList(lib);
+ XmlCursor curs = newCursor();
+ TokenType tt = curs.currentTokenType();
+
+ // Set the targets for this XMLList.
+ result.setTargets(this, null);
+
+ if (tt.isStartdoc())
+ {
+ tt = curs.toFirstContentToken();
+ }
+
+ if (tt.isContainer())
+ {
+ int nestLevel = 1;
+
+ while (nestLevel > 0)
+ {
+ tt = curs.toNextToken();
+
+ if (!tt.isAttr() && !tt.isEnd() && !tt.isEnddoc())
+ {
+ // Only try to match names for elements or processing instructions.
+ if (!tt.isStart() && !tt.isProcinst())
+ {
+ // Not an element or procinst, only add if qname is all
+ if (xmlName.localName().equals("*"))
+ {
+ result.addToList(findAnnotation(curs));
+ }
+ }
+ else
+ {
+ if (qnameMatches(xmlName, curs.getName()))
+ {
+ result.addToList(findAnnotation(curs));
+ }
+ }
+ }
+
+ if (tt.isStart())
+ {
+ nestLevel++;
+ }
+ else if (tt.isEnd())
+ {
+ nestLevel--;
+ }
+ else if (tt.isEnddoc())
+ {
+ // Shouldn't get here, but just in case.
+ break;
+ }
+ }
+ }
+
+ curs.dispose();
+
+ return result;
+ }
+
+ /**
+ *
+ * @param tokenType
+ * @return
+ */
+ private XMLList matchChildren(XmlCursor.TokenType tokenType)
+ {
+ return matchChildren(tokenType, XMLName.formStar());
+ }
+
+ /**
+ *
+ * @return
+ */
+ private XMLList matchChildren(XmlCursor.TokenType tokenType, XMLName name)
+ {
+ XMLList result = new XMLList(lib);
+ XmlCursor curs = newCursor();
+ TokenType tt = curs.currentTokenType();
+ javax.xml.namespace.QName qname = new javax.xml.namespace.QName(name.uri(), name.localName());
+ javax.xml.namespace.QName targetProperty = qname;
+
+ if (tt.isStartdoc())
+ {
+ tt = curs.toFirstContentToken();
+ }
+
+ if (tt.isContainer())
+ {
+ tt = curs.toFirstContentToken();
+
+ while (!tt.isEnd())
+ {
+ if (tt == tokenType)
+ {
+ // Only try to match names for elements or processing instructions.
+ if (!tt.isStart() && !tt.isProcinst())
+ {
+ // Not an element or no name specified.
+ result.addToList(findAnnotation(curs));
+
+ // Reset target property to null in this case
+ targetProperty = null;
+ }
+ else
+ {
+ // Match names as well
+ if (qnameMatches(name, curs.getName()))
+ {
+ // Add it to the list
+ result.addToList(findAnnotation(curs));
+
+ // Set target property if target name is "*",
+ // Otherwise if target property does not match current, then
+ // set to null
+ if (targetProperty != null)
+ {
+ if (targetProperty.getLocalPart().equals("*"))
+ {
+ targetProperty = curs.getName();
+ }
+ else if (!targetProperty.getLocalPart().equals(curs.getName().getLocalPart()))
+ {
+ // Not a match, unset target property
+ targetProperty = null;
+ }
+ }
+ }
+ }
+ }
+
+ // Skip over child elements
+ if (tt.isStart())
+ {
+ tt = curs.toEndToken();
+ }
+
+ tt = curs.toNextToken();
+ }
+ }
+
+ curs.dispose();
+
+ if (tokenType == XmlCursor.TokenType.START)
+ {
+ // Set the targets for this XMLList.
+ result.setTargets(this, targetProperty);
+ }
+
+ return result;
+
+ }
+
+ /**
+ *
+ * @param template
+ * @param match
+ * @return
+ */
+ private boolean qnameMatches(XMLName template, javax.xml.namespace.QName match)
+ {
+ boolean matches = false;
+
+ if (template.uri() == null ||
+ template.uri().equals(match.getNamespaceURI()))
+ {
+ // URI OK, test name
+ if (template.localName().equals("*") ||
+ template.localName().equals(match.getLocalPart()))
+ {
+ matches = true;
+ }
+ }
+
+ return matches;
+ }
+
+ //
+ //
+ // Methods from section 12.4.4 in the spec
+ //
+ //
+
+ /**
+ * The addNamespace method adds a namespace declaration to the in scope
+ * namespaces for this XML object and returns this XML object.
+ *
+ * @param toAdd
+ */
+ XML addNamespace(Namespace ns)
+ {
+ // When a namespace is used it will be added automatically
+ // to the inScopeNamespaces set. There is no need to add
+ // Namespaces with undefined prefixes.
+ String nsPrefix = ns.prefix();
+ if (nsPrefix == null) return this;
+
+ XmlCursor cursor = newCursor();
+
+ try
+ {
+ if(!cursor.isContainer()) return this;
+
+ javax.xml.namespace.QName qname = cursor.getName();
+ // Don't add a default namespace declarations to containers
+ // with QNames in no namespace.
+ if(qname.getNamespaceURI().equals("") &&
+ nsPrefix.equals("")) return this;
+
+ // Get all declared namespaces that are in scope
+ Map prefixToURI = NamespaceHelper.getAllNamespaces(lib, cursor);
+
+ String uri = (String)prefixToURI.get(nsPrefix);
+ if(uri != null)
+ {
+ // Check if the Namespace is not already in scope
+ if(uri.equals(ns.uri())) return this;
+
+ cursor.push();
+
+ // Let's see if we have to delete a namespace declaration
+ while(cursor.toNextToken().isAnyAttr())
+ {
+ if(cursor.isNamespace())
+ {
+ qname = cursor.getName();
+ String prefix = qname.getLocalPart();
+ if(prefix.equals(nsPrefix))
+ {
+ // Delete the current Namespace declaration
+ cursor.removeXml();
+ break;
+ }
+ }
+ }
+
+ cursor.pop();
+ }
+
+ cursor.toNextToken();
+ cursor.insertNamespace(nsPrefix, ns.uri());
+ }
+ finally
+ {
+ cursor.dispose();
+ }
+
+ return this;
+ }
+
+ /**
+ *
+ * @param xml
+ * @return
+ */
+ XML appendChild(Object xml)
+ {
+ XmlCursor curs = newCursor();
+
+ if (curs.isStartdoc())
+ {
+ curs.toFirstContentToken();
+ }
+
+ // Move the cursor to the end of this element
+ if (curs.isStart())
+ {
+ curs.toEndToken();
+ }
+
+ insertChild(curs, xml);
+
+ curs.dispose();
+
+ return this;
+ }
+
+ /**
+ *
+ * @param name
+ * @return
+ */
+ XMLList attribute(XMLName xmlName)
+ {
+ return matchAttributes(xmlName);
+ }
+
+ /**
+ *
+ * @return
+ */
+ XMLList attributes()
+ {
+ XMLName xmlName = XMLName.formStar();
+ return matchAttributes(xmlName);
+ }
+
+ XMLList child(long index)
+ {
+ XMLList result = new XMLList(lib);
+ result.setTargets(this, null);
+ result.addToList(getXmlChild(index));
+ return result;
+ }
+
+ XMLList child(XMLName xmlName)
+ {
+ if (xmlName == null)
+ return new XMLList(lib);
+
+ XMLList result;
+ if (xmlName.localName().equals("*"))
+ {
+ result = allChildNodes(xmlName.uri());
+ }
+ else
+ {
+ result = matchChildren(XmlCursor.TokenType.START, xmlName);
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @param index
+ * @return
+ */
+ XML getXmlChild(long index)
+ {
+ XML result = null;
+ XmlCursor curs = newCursor();
+
+ if (moveToChild(curs, index, false, true))
+ {
+ result = createXML(lib, curs);
+ }
+
+ curs.dispose();
+
+ return result;
+ }
+
+ /**
+ *
+ * @return
+ */
+ int childIndex()
+ {
+ int index = 0;
+
+ XmlCursor curs = newCursor();
+
+ TokenType tt = curs.currentTokenType();
+ while (true)
+ {
+ if (tt.isText())
+ {
+ index++;
+ if (!curs.toPrevSibling())
+ {
+ break;
+ }
+ }
+ else if (tt.isStart())
+ {
+ tt = curs.toPrevToken();
+ if (tt.isEnd())
+ {
+ curs.toNextToken();
+ if (!curs.toPrevSibling())
+ {
+ break;
+ }
+
+ index++;
+ }
+ else
+ {
+ // Hit the parent start tag so get out we're down counting children.
+ break;
+ }
+ }
+ else if (tt.isComment() || tt.isProcinst())
+ {
+ curs.toPrevToken();
+ }
+ else
+ {
+ break;
+ }
+
+ tt = curs.currentTokenType();
+ }
+
+ index = curs.currentTokenType().isStartdoc() ? -1 : index;
+
+ curs.dispose();
+
+ return index;
+ }
+
+ /**
+ *
+ * @return
+ */
+ XMLList children()
+ {
+ return allChildNodes(null);
+ }
+
+ /**
+ *
+ * @return
+ */
+ XMLList comments()
+ {
+ return matchChildren(XmlCursor.TokenType.COMMENT);
+ }
+
+ /**
+ *
+ * @param xml
+ * @return
+ */
+ boolean contains(Object xml)
+ {
+ boolean result = false;
+
+ if (xml instanceof XML)
+ {
+ result = equivalentXml(xml);
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @return
+ */
+ Object copy()
+ {
+ XmlCursor srcCurs = newCursor();
+
+ if (srcCurs.isStartdoc())
+ {
+ srcCurs.toFirstContentToken();
+ }
+
+ XML xml = createEmptyXML(lib);
+
+ XmlCursor destCurs = xml.newCursor();
+ destCurs.toFirstContentToken();
+
+ srcCurs.copyXml(destCurs);
+
+ destCurs.dispose();
+ srcCurs.dispose();
+
+ return xml;
+ }
+
+ /**
+ *
+ * @param name
+ * @return
+ */
+ XMLList descendants(XMLName xmlName)
+ {
+ XMLList result;
+ if (xmlName.isAttributeName())
+ {
+ result = matchDescendantAttributes(xmlName);
+ }
+ else
+ {
+ result = matchDescendantChildren(xmlName);
+ }
+
+ return result;
+ }
+
+ /**
+ * The inScopeNamespaces method returns an Array of Namespace objects
+ * representing the namespaces in scope for this XML object in the
+ * context of its parent.
+ *
+ * @return Array of all Namespaces in scope for this XML Object.
+ */
+ Object[] inScopeNamespaces()
+ {
+ XmlCursor cursor = newCursor();
+ Object[] namespaces = NamespaceHelper.inScopeNamespaces(lib, cursor);
+ cursor.dispose();
+ return namespaces;
+ }
+
+ /**
+ *
+ * @param child
+ * @param xml
+ */
+ XML insertChildAfter(Object child, Object xml)
+ {
+ if (child == null)
+ {
+ // Spec says inserting after nothing is the same as prepending
+ prependChild(xml);
+ }
+ else if (child instanceof XML)
+ {
+ insertChild((XML) child, xml, APPEND_CHILD);
+ }
+
+ return this;
+ }
+
+ /**
+ *
+ * @param child
+ * @param xml
+ */
+ XML insertChildBefore(Object child, Object xml)
+ {
+ if (child == null)
+ {
+ // Spec says inserting before nothing is the same as appending
+ appendChild(xml);
+ }
+ else if (child instanceof XML)
+ {
+ insertChild((XML) child, xml, PREPEND_CHILD);
+ }
+
+ return this;
+ }
+
+ /**
+ *
+ * @return
+ */
+ boolean hasOwnProperty(XMLName xmlName)
+ {
+ boolean hasProperty = false;
+
+ if (prototypeFlag)
+ {
+ String property = xmlName.localName();
+ hasProperty = (0 != findPrototypeId(property));
+ }
+ else
+ {
+ hasProperty = (getPropertyList(xmlName).length() > 0);
+ }
+
+ return hasProperty;
+ }
+
+ /**
+ *
+ * @return
+ */
+ boolean hasComplexContent()
+ {
+ return !hasSimpleContent();
+ }
+
+ /**
+ *
+ * @return
+ */
+ boolean hasSimpleContent()
+ {
+ boolean simpleContent = false;
+
+ XmlCursor curs = newCursor();
+
+ if (curs.isAttr() || curs.isText()) {
+ return true;
+ }
+
+ if (curs.isStartdoc())
+ {
+ curs.toFirstContentToken();
+ }
+
+ simpleContent = !(curs.toFirstChild());
+
+ curs.dispose();
+
+ return simpleContent;
+ }
+
+ /**
+ * Length of an XML object is always 1, it's a list of XML objects of size 1.
+ *
+ * @return
+ */
+ int length()
+ {
+ return 1;
+ }
+
+ /**
+ *
+ * @return
+ */
+ String localName()
+ {
+ XmlCursor cursor = newCursor();
+ if (cursor.isStartdoc())
+ cursor.toFirstContentToken();
+
+ String name = null;
+
+ if(cursor.isStart() ||
+ cursor.isAttr() ||
+ cursor.isProcinst())
+ {
+ javax.xml.namespace.QName qname = cursor.getName();
+ name = qname.getLocalPart();
+ }
+ cursor.dispose();
+
+ return name;
+ }
+
+ /**
+ * The name method returns the qualified name associated with this XML object.
+ *
+ * @return The qualified name associated with this XML object.
+ */
+ QName name()
+ {
+ XmlCursor cursor = newCursor();
+ if (cursor.isStartdoc())
+ cursor.toFirstContentToken();
+
+ QName name = null;
+
+ if(cursor.isStart() ||
+ cursor.isAttr() ||
+ cursor.isProcinst())
+ {
+ javax.xml.namespace.QName qname = cursor.getName();
+ if(cursor.isProcinst())
+ {
+ name = new QName(lib, "", qname.getLocalPart(), "");
+ }
+ else
+ {
+ String uri = qname.getNamespaceURI();
+ String prefix = qname.getPrefix();
+ name = new QName(lib, uri, qname.getLocalPart(), prefix);
+ }
+ }
+
+ cursor.dispose();
+
+ return name;
+ }
+
+ /**
+ *
+ * @param prefix
+ * @return
+ */
+ Object namespace(String prefix)
+ {
+ XmlCursor cursor = newCursor();
+ if (cursor.isStartdoc())
+ {
+ cursor.toFirstContentToken();
+ }
+
+ Object result = null;
+
+ if (prefix == null)
+ {
+ if(cursor.isStart() ||
+ cursor.isAttr())
+ {
+ Object[] inScopeNS = NamespaceHelper.inScopeNamespaces(lib, cursor);
+ // XXX Is it reaaly necessary to create the second cursor?
+ XmlCursor cursor2 = newCursor();
+ if (cursor2.isStartdoc())
+ cursor2.toFirstContentToken();
+
+ result = NamespaceHelper.getNamespace(lib, cursor2, inScopeNS);
+
+ cursor2.dispose();
+ }
+ }
+ else
+ {
+ Map prefixToURI = NamespaceHelper.getAllNamespaces(lib, cursor);
+ String uri = (String)prefixToURI.get(prefix);
+ result = (uri == null) ? Undefined.instance : new Namespace(lib, prefix, uri);
+ }
+
+ cursor.dispose();
+
+ return result;
+ }
+
+ /**
+ *
+ * @return
+ */
+ Object[] namespaceDeclarations()
+ {
+ XmlCursor cursor = newCursor();
+ Object[] namespaces = NamespaceHelper.namespaceDeclarations(lib, cursor);
+ cursor.dispose();
+ return namespaces;
+ }
+
+ /**
+ *
+ * @return
+ */
+ Object nodeKind()
+ {
+ String result;
+ XmlCursor.TokenType tt = tokenType();
+
+ if (tt == XmlCursor.TokenType.ATTR)
+ {
+ result = "attribute";
+ }
+ else if (tt == XmlCursor.TokenType.TEXT)
+ {
+ result = "text";
+ }
+ else if (tt == XmlCursor.TokenType.COMMENT)
+ {
+ result = "comment";
+ }
+ else if (tt == XmlCursor.TokenType.PROCINST)
+ {
+ result = "processing-instruction";
+ }
+ else if (tt == XmlCursor.TokenType.START)
+ {
+ result = "element";
+ }
+ else
+ {
+ // A non-existant node has the nodeKind() of text
+ result = "text";
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ */
+ void normalize()
+ {
+ XmlCursor curs = newCursor();
+ TokenType tt = curs.currentTokenType();
+
+ // Walk through the tokens removing empty text nodes and merging adjacent text nodes.
+ if (tt.isStartdoc())
+ {
+ tt = curs.toFirstContentToken();
+ }
+
+ if (tt.isContainer())
+ {
+ int nestLevel = 1;
+ String previousText = null;
+
+ while (nestLevel > 0)
+ {
+ tt = curs.toNextToken();
+
+ if (tt == XmlCursor.TokenType.TEXT)
+ {
+ String currentText = curs.getChars().trim();
+
+ if (currentText.trim().length() == 0)
+ {
+ // Empty text node, remove.
+ removeToken(curs);
+ curs.toPrevToken();
+ }
+ else if (previousText == null)
+ {
+ // No previous text node, reset to trimmed version
+ previousText = currentText;
+ }
+ else
+ {
+ // It appears that this case never happens with XBeans.
+ // Previous text node exists, concatenate
+ String newText = previousText + currentText;
+
+ curs.toPrevToken();
+ removeToken(curs);
+ removeToken(curs);
+ curs.insertChars(newText);
+ }
+ }
+ else
+ {
+ previousText = null;
+ }
+
+ if (tt.isStart())
+ {
+ nestLevel++;
+ }
+ else if (tt.isEnd())
+ {
+ nestLevel--;
+ }
+ else if (tt.isEnddoc())
+ {
+ // Shouldn't get here, but just in case.
+ break;
+ }
+ }
+ }
+
+
+ curs.dispose();
+ }
+
+ /**
+ *
+ * @return
+ */
+ Object parent()
+ {
+ Object parent;
+
+ XmlCursor curs = newCursor();
+
+ if (curs.isStartdoc())
+ {
+ // At doc level - no parent
+ parent = Undefined.instance;
+ }
+ else
+ {
+ if (curs.toParent())
+ {
+ if (curs.isStartdoc())
+ {
+ // Was top-level - no parent
+ parent = Undefined.instance;
+ }
+ else
+ {
+ parent = getFromAnnotation(lib, findAnnotation(curs));
+ }
+ }
+ else
+ {
+ // No parent
+ parent = Undefined.instance;
+ }
+ }
+
+ curs.dispose();
+
+ return parent;
+ }
+
+ /**
+ *
+ * @param xml
+ * @return
+ */
+ XML prependChild (Object xml)
+ {
+ XmlCursor curs = newCursor();
+
+ if (curs.isStartdoc())
+ {
+ curs.toFirstContentToken();
+ }
+
+ // Move the cursor to the first content token
+ curs.toFirstContentToken();
+
+ insertChild(curs, xml);
+
+ curs.dispose();
+
+ return this;
+ }
+
+ /**
+ *
+ * @return
+ */
+ Object processingInstructions(XMLName xmlName)
+ {
+ return matchChildren(XmlCursor.TokenType.PROCINST, xmlName);
+ }
+
+ /**
+ *
+ * @param name
+ * @return
+ */
+ 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 posotive 0
+ result = (x == 0.0 && 1.0 / x > 0);
+ } else {
+ result = ScriptRuntime.toString(name).equals("0");
+ }
+ return result;
+ }
+
+ /**
+ *
+ * @param namespace
+ */
+ XML removeNamespace(Namespace ns)
+ {
+ XmlCursor cursor = newCursor();
+
+ try
+ {
+ if(cursor.isStartdoc())
+ cursor.toFirstContentToken();
+ if(!cursor.isStart()) return this;
+
+ String nsPrefix = ns.prefix();
+ String nsURI = ns.uri();
+ Map prefixToURI = new HashMap();
+ int depth = 1;
+
+ while(!(cursor.isEnd() && depth == 0))
+ {
+ if(cursor.isStart())
+ {
+ // Get the namespaces declared in this element.
+ // The ones with undefined prefixes are not candidates
+ // for removal because they are used.
+ prefixToURI.clear();
+ NamespaceHelper.getNamespaces(cursor, prefixToURI);
+ ObjArray inScopeNSBag = new ObjArray();
+ Iterator i = prefixToURI.entrySet().iterator();
+ while(i.hasNext())
+ {
+ Map.Entry entry = (Map.Entry)i.next();
+ ns = new Namespace(lib, (String)entry.getKey(), (String)entry.getValue());
+ inScopeNSBag.add(ns);
+ }
+
+ // Add the URI we are looking for to avoid matching
+ // non-existing Namespaces.
+ ns = new Namespace(lib, nsURI);
+ inScopeNSBag.add(ns);
+
+ Object[] inScopeNS = inScopeNSBag.toArray();
+
+ // Check the element name
+ Namespace n = NamespaceHelper.getNamespace(lib, cursor,
+ inScopeNS);
+ if(nsURI.equals(n.uri()) &&
+ (nsPrefix == null ||
+ nsPrefix.equals(n.prefix())))
+ {
+ // This namespace is used
+ return this;
+ }
+
+ // Check the attributes
+ cursor.push();
+ boolean hasNext = cursor.toFirstAttribute();
+ while(hasNext)
+ {
+ n = NamespaceHelper.getNamespace(lib, cursor, inScopeNS);
+ if(nsURI.equals(n.uri()) &&
+ (nsPrefix == null ||
+ nsPrefix.equals(n.prefix())))
+ {
+ // This namespace is used
+ return this;
+ }
+
+ hasNext = cursor.toNextAttribute();
+ }
+ cursor.pop();
+
+ if(nsPrefix == null)
+ {
+ // Remove all namespaces declarations that match nsURI
+ i = prefixToURI.entrySet().iterator();
+ while(i.hasNext())
+ {
+ Map.Entry entry = (Map.Entry)i.next();
+ if(entry.getValue().equals(nsURI))
+ NamespaceHelper.removeNamespace(cursor, (String)entry.getKey());
+ }
+ }
+ else if(nsURI.equals(prefixToURI.get(nsPrefix)))
+ {
+ // Remove the namespace declaration that matches nsPrefix
+ NamespaceHelper.removeNamespace(cursor, String.valueOf(nsPrefix));
+ }
+ }
+
+ switch(cursor.toNextToken().intValue())
+ {
+ case XmlCursor.TokenType.INT_START:
+ depth++;
+ break;
+ case XmlCursor.TokenType.INT_END:
+ depth--;
+ break;
+ }
+ }
+ }
+ finally
+ {
+ cursor.dispose();
+ }
+
+ return this;
+ }
+
+ XML replace(long 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;
+ }
+
+ /**
+ *
+ * @param propertyName
+ * @param xml
+ * @return
+ */
+ XML replace(XMLName xmlName, Object xml)
+ {
+ putXMLProperty(xmlName, xml);
+ return this;
+ }
+
+ /**
+ *
+ * @param xml
+ */
+ XML setChildren(Object xml)
+ {
+ // remove all children
+ XMLName xmlName = XMLName.formStar();
+ XMLList matches = getPropertyList(xmlName);
+ matches.remove();
+
+ // append new children
+ appendChild(xml);
+
+ return this;
+ }
+
+ /**
+ *
+ * @param name
+ */
+ void setLocalName(String localName)
+ {
+ XmlCursor cursor = newCursor();
+
+ try
+ {
+ if(cursor.isStartdoc())
+ cursor.toFirstContentToken();
+
+ if(cursor.isText() || cursor.isComment()) return;
+
+
+ javax.xml.namespace.QName qname = cursor.getName();
+ cursor.setName(new javax.xml.namespace.QName(
+ qname.getNamespaceURI(), localName, qname.getPrefix()));
+ }
+ finally
+ {
+ cursor.dispose();
+ }
+ }
+
+ /**
+ *
+ * @param name
+ */
+ void setName(QName qname)
+ {
+ XmlCursor cursor = newCursor();
+
+ try
+ {
+ if(cursor.isStartdoc())
+ cursor.toFirstContentToken();
+
+ if(cursor.isText() || cursor.isComment()) return;
+
+ if(cursor.isProcinst())
+ {
+ String localName = qname.localName();
+ cursor.setName(new javax.xml.namespace.QName(localName));
+ }
+ else
+ {
+ String prefix = qname.prefix();
+ if (prefix == null) { prefix = ""; }
+ cursor.setName(new javax.xml.namespace.QName(
+ qname.uri(), qname.localName(), prefix));
+ }
+ }
+ finally
+ {
+ cursor.dispose();
+ }
+ }
+
+ /**
+ *
+ * @param ns
+ */
+ void setNamespace(Namespace ns)
+ {
+ XmlCursor cursor = newCursor();
+
+ try
+ {
+ if(cursor.isStartdoc())
+ cursor.toFirstContentToken();
+
+ if(cursor.isText() ||
+ cursor.isComment() ||
+ cursor.isProcinst()) return;
+
+ String prefix = ns.prefix();
+ if (prefix == null) {
+ prefix = "";
+ }
+ cursor.setName(new javax.xml.namespace.QName(
+ ns.uri(), localName(), prefix));
+ }
+ finally
+ {
+ cursor.dispose();
+ }
+ }
+
+ /**
+ *
+ * @return
+ */
+ XMLList text()
+ {
+ return matchChildren(XmlCursor.TokenType.TEXT);
+ }
+
+ /**
+ *
+ * @return
+ */
+ public String toString()
+ {
+ String result;
+ XmlCursor curs = newCursor();
+
+ if (curs.isStartdoc())
+ {
+ curs.toFirstContentToken();
+ }
+
+ if (curs.isText())
+ {
+ result = curs.getChars();
+ }
+ else if (curs.isStart() && hasSimpleContent())
+ {
+ result = curs.getTextValue();
+ }
+ else
+ {
+ result = toXMLString(0);
+ }
+
+ return result;
+ }
+
+ String toSource(int indent)
+ {
+ // XXX Does toXMLString always return valid XML literal?
+ return toXMLString(indent);
+ }
+
+ /**
+ *
+ * @return
+ */
+ String toXMLString(int indent)
+ {
+ // XXX indent is ignored
+
+ String result;
+
+ XmlCursor curs = newCursor();
+
+ if (curs.isStartdoc())
+ {
+ curs.toFirstContentToken();
+ }
+
+ try
+ {
+ if (curs.isText())
+ {
+ result = curs.getChars();
+ }
+ else if (curs.isAttr())
+ {
+ result = curs.getTextValue();
+ }
+ else if (curs.isComment() || curs.isProcinst())
+ {
+ result = XML.dumpNode(curs, getOptions());
+
+ // todo: XBeans-dependent hack here
+ // If it's a comment or PI, take off the xml-frament stuff
+ String start = "<xml-fragment>";
+ String end = "</xml-fragment>";
+
+ if (result.startsWith(start))
+ {
+ result = result.substring(start.length());
+ }
+
+ if (result.endsWith(end))
+ {
+ result = result.substring(0, result.length() - end.length());
+ }
+ }
+ else
+ {
+ result = XML.dumpNode(curs, getOptions());
+ }
+ }
+ finally
+ {
+ curs.dispose();
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @return
+ */
+ Object valueOf()
+ {
+ return this;
+ }
+
+ //
+ // Other public Functions from XMLObject
+ //
+
+ /**
+ *
+ * @param target
+ * @return
+ */
+ boolean equivalentXml(Object target)
+ {
+ boolean result = false;
+
+ if (target instanceof XML)
+ {
+ XML otherXml = (XML) target;
+
+ // Compare with toString() if either side is text node or attribute
+ // otherwise compare as XML
+ XmlCursor.TokenType thisTT = tokenType();
+ XmlCursor.TokenType otherTT = otherXml.tokenType();
+ if (thisTT == XmlCursor.TokenType.ATTR || otherTT == XmlCursor.TokenType.ATTR ||
+ thisTT == XmlCursor.TokenType.TEXT || otherTT == XmlCursor.TokenType.TEXT)
+ {
+ result = toString().equals(otherXml.toString());
+ }
+ else
+ {
+ XmlCursor cursOne = newCursor();
+ XmlCursor cursTwo = otherXml.newCursor();
+
+ result = LogicalEquality.nodesEqual(cursOne, cursTwo);
+
+ cursOne.dispose();
+ cursTwo.dispose();
+
+// Old way of comparing by string.
+// boolean orgPrettyPrinting = prototype.prettyPrinting;
+// prototype.prettyPrinting = true;
+// result = toXMLString(0).equals(otherXml.toXMLString(0));
+// prototype.prettyPrinting = orgPrettyPrinting;
+ }
+ }
+ else if (target instanceof XMLList)
+ {
+ XMLList otherList = (XMLList) target;
+
+ if (otherList.length() == 1)
+ {
+ result = equivalentXml(otherList.getXmlFromAnnotation(0));
+ }
+ }
+ else if (hasSimpleContent())
+ {
+ String otherStr = ScriptRuntime.toString(target);
+
+ result = toString().equals(otherStr);
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @param name
+ * @param start
+ * @return
+ */
+ XMLList getPropertyList(XMLName name)
+ {
+ XMLList result;
+
+ // Get the named property
+ if (name.isDescendants())
+ {
+ result = descendants(name);
+ }
+ else if (name.isAttributeName())
+ {
+ result = attribute(name);
+ }
+ else
+ {
+ result = child(name);
+ }
+
+ return result;
+ }
+
+ protected Object jsConstructor(Context cx, boolean inNewExpr,
+ Object[] args)
+ {
+ if (args.length == 0) {
+ return createFromJS(lib, "");
+ } else {
+ Object arg0 = args[0];
+ if (!inNewExpr && arg0 instanceof XML) {
+ // XML(XML) returns the same object.
+ return arg0;
+ }
+ return createFromJS(lib, arg0);
+ }
+ }
+
+ /**
+ * 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;
+ }
+
+ XmlObject getXmlObject()
+ {
+ XmlObject xo;
+ XmlCursor cursor = newCursor();
+ try {
+ xo = cursor.getObject();
+ } finally {
+ cursor.dispose();
+ }
+ return xo;
+ }
+}
diff --git a/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLCtor.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLCtor.java
new file mode 100644
index 0000000..987c8ed
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLCtor.java
@@ -0,0 +1,269 @@
+/* -*- 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
+ *
+ * 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.xml.impl.xmlbeans;
+
+import org.mozilla.javascript.*;
+
+class XMLCtor extends IdFunctionObject
+{
+ static final long serialVersionUID = -8708195078359817341L;
+
+ private static final Object XMLCTOR_TAG = new Object();
+
+ private XMLLibImpl lib;
+
+ XMLCtor(XML xml, Object tag, int id, int arity)
+ {
+ super(xml, tag, id, arity);
+ this.lib = xml.lib;
+ 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: 2004-07-19 13:03:52 CEST
+ 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;
+ }
+// #/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(lib.ignoreComments);
+ case Id_ignoreProcessingInstructions:
+ return ScriptRuntime.wrapBoolean(lib.ignoreProcessingInstructions);
+ case Id_ignoreWhitespace:
+ return ScriptRuntime.wrapBoolean(lib.ignoreWhitespace);
+ case Id_prettyIndent:
+ return ScriptRuntime.wrapInt(lib.prettyIndent);
+ case Id_prettyPrinting:
+ return ScriptRuntime.wrapBoolean(lib.prettyPrinting);
+ }
+ return super.getInstanceIdValue(id);
+ }
+
+ protected void setInstanceIdValue(int id, Object value)
+ {
+ switch (id - super.getMaxInstanceId()) {
+ case Id_ignoreComments:
+ lib.ignoreComments = ScriptRuntime.toBoolean(value);
+ return;
+ case Id_ignoreProcessingInstructions:
+ lib.ignoreProcessingInstructions = ScriptRuntime.toBoolean(value);
+ return;
+ case Id_ignoreWhitespace:
+ lib.ignoreWhitespace = ScriptRuntime.toBoolean(value);
+ return;
+ case Id_prettyIndent:
+ lib.prettyIndent = ScriptRuntime.toInt32(value);
+ return;
+ case Id_prettyPrinting:
+ lib.prettyPrinting = 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: 2004-07-19 13:03:52 CEST
+ 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;
+ }
+// #/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: {
+ lib.defaultSettings();
+ 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)
+ {
+ lib.defaultSettings();
+ } else if (args[0] instanceof Scriptable) {
+ readSettings((Scriptable)args[0]);
+ }
+ return Undefined.instance;
+ }
+ }
+ throw new IllegalArgumentException(String.valueOf(id));
+ }
+}
diff --git a/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLLibImpl.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLLibImpl.java
new file mode 100644
index 0000000..90da7d4
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLLibImpl.java
@@ -0,0 +1,754 @@
+/* -*- 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
+ *
+ * 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.xml.impl.xmlbeans;
+
+import java.io.Serializable;
+
+import org.mozilla.javascript.*;
+import org.mozilla.javascript.xml.*;
+
+import org.apache.xmlbeans.XmlCursor;
+import org.apache.xmlbeans.XmlObject;
+
+public final class XMLLibImpl extends XMLLib implements Serializable
+{
+ private static final long serialVersionUID = 1L;
+
+ private Scriptable globalScope;
+
+ XML xmlPrototype;
+ XMLList xmlListPrototype;
+ Namespace namespacePrototype;
+ QName qnamePrototype;
+
+
+ // Environment settings...
+ boolean ignoreComments;
+ boolean ignoreProcessingInstructions;
+ boolean ignoreWhitespace;
+ boolean prettyPrinting;
+ int prettyIndent;
+
+ Scriptable globalScope()
+ {
+ return globalScope;
+ }
+
+ private XMLLibImpl(Scriptable globalScope)
+ {
+ this.globalScope = globalScope;
+ defaultSettings();
+ }
+
+ public static void init(Context cx, Scriptable scope, boolean sealed)
+ {
+ // To force LinkageError if XmlObject is not available
+ XmlObject.class.getName();
+
+ XMLLibImpl lib = new XMLLibImpl(scope);
+ XMLLib bound = lib.bindToScope(scope);
+ if (bound == lib) {
+ lib.exportToScope(sealed);
+ }
+ }
+
+ private void exportToScope(boolean sealed)
+ {
+ xmlPrototype = XML.createEmptyXML(this);
+ xmlListPrototype = new XMLList(this);
+ namespacePrototype = new Namespace(this, "", "");
+ qnamePrototype = new QName(this, "", "", "");
+
+ xmlPrototype.exportAsJSClass(sealed);
+ xmlListPrototype.exportAsJSClass(sealed);
+ namespacePrototype.exportAsJSClass(sealed);
+ qnamePrototype.exportAsJSClass(sealed);
+ }
+
+ void defaultSettings()
+ {
+ ignoreComments = true;
+ ignoreProcessingInstructions = true;
+ ignoreWhitespace = true;
+ prettyPrinting = true;
+ prettyIndent = 2;
+ }
+
+ XMLName toAttributeName(Context cx, Object nameValue)
+ {
+ String uri;
+ String localName;
+
+ if (nameValue instanceof String) {
+ uri = "";
+ localName = (String)nameValue;
+ } else if (nameValue instanceof XMLName) {
+ XMLName xmlName = (XMLName)nameValue;
+ if (!xmlName.isAttributeName()) {
+ xmlName.setAttributeName();
+ }
+ return xmlName;
+ } else if (nameValue instanceof QName) {
+ QName qname = (QName)nameValue;
+ uri = qname.uri();
+ localName = qname.localName();
+ } else if (nameValue instanceof Boolean
+ || nameValue instanceof Number
+ || nameValue == Undefined.instance
+ || nameValue == null)
+ {
+ throw badXMLName(nameValue);
+ } else {
+ uri = "";
+ localName = ScriptRuntime.toString(nameValue);
+ }
+ XMLName xmlName = XMLName.formProperty(uri, localName);
+ xmlName.setAttributeName();
+ return xmlName;
+ }
+
+ 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 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;
+ }
+
+ XMLName toXMLNameFromString(Context cx, 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;
+ }
+ }
+
+ String uri = getDefaultNamespaceURI(cx);
+
+ return XMLName.formProperty(uri, name);
+ }
+
+ Namespace constructNamespace(Context cx, 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) {
+ prefix = qname.prefix();
+ } else {
+ uri = qname.toString();
+ prefix = null;
+ }
+ } else {
+ uri = ScriptRuntime.toString(uriValue);
+ prefix = (uri.length() == 0) ? "" : null;
+ }
+
+ return new Namespace(this, prefix, uri);
+ }
+
+ Namespace castToNamespace(Context cx, Object namescapeObj)
+ {
+ if (namescapeObj instanceof Namespace) {
+ return (Namespace)namescapeObj;
+ }
+ return constructNamespace(cx, namescapeObj);
+ }
+
+ Namespace constructNamespace(Context cx)
+ {
+ return new Namespace(this, "", "");
+ }
+
+ public Namespace constructNamespace(Context cx, 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 (!isXMLName(cx, prefixValue)) {
+ prefix = "";
+ } else {
+ prefix = ScriptRuntime.toString(prefixValue);
+ }
+
+ return new Namespace(this, prefix, uri);
+ }
+
+ String getDefaultNamespaceURI(Context cx)
+ {
+ String uri = "";
+ if (cx == null) {
+ cx = Context.getCurrentContext();
+ }
+ if (cx != null) {
+ Object ns = ScriptRuntime.searchDefaultNamespace(cx);
+ if (ns != null) {
+ if (ns instanceof Namespace) {
+ uri = ((Namespace)ns).uri();
+ } else {
+ // Should not happen but for now it could
+ // due to bad searchDefaultNamespace implementation.
+ }
+ }
+ }
+ return uri;
+ }
+
+ Namespace getDefaultNamespace(Context cx)
+ {
+ if (cx == null) {
+ cx = Context.getCurrentContext();
+ if (cx == null) {
+ return namespacePrototype;
+ }
+ }
+
+ Namespace result;
+ Object ns = ScriptRuntime.searchDefaultNamespace(cx);
+ if (ns == null) {
+ result = namespacePrototype;
+ } else {
+ if (ns instanceof Namespace) {
+ result = (Namespace)ns;
+ } else {
+ // Should not happen but for now it could
+ // due to bad searchDefaultNamespace implementation.
+ result = namespacePrototype;
+ }
+ }
+ return result;
+ }
+
+ QName castToQName(Context cx, Object qnameValue)
+ {
+ if (qnameValue instanceof QName) {
+ return (QName)qnameValue;
+ }
+ return constructQName(cx, qnameValue);
+ }
+
+ QName constructQName(Context cx, Object nameValue)
+ {
+ QName result;
+
+ if (nameValue instanceof QName) {
+ QName qname = (QName)nameValue;
+ result = new QName(this, qname.uri(), qname.localName(),
+ qname.prefix());
+ } else {
+ String localName = ScriptRuntime.toString(nameValue);
+ result = constructQNameFromString(cx, localName);
+ }
+
+ return result;
+ }
+
+ /**
+ * Optimized version of constructQName for String type
+ */
+ QName constructQNameFromString(Context cx, String localName)
+ {
+ if (localName == null)
+ throw new IllegalArgumentException();
+
+ String uri;
+ String prefix;
+
+ if ("*".equals(localName)) {
+ uri = null;
+ prefix = null;
+ } else {
+ Namespace ns = getDefaultNamespace(cx);
+ uri = ns.uri();
+ prefix = ns.prefix();
+ }
+
+ return new QName(this, uri, localName, prefix);
+ }
+
+ QName constructQName(Context cx, Object namespaceValue, Object nameValue)
+ {
+ String uri;
+ String localName;
+ String prefix;
+
+ if (nameValue instanceof QName) {
+ QName qname = (QName)nameValue;
+ localName = qname.localName();
+ } else {
+ localName = ScriptRuntime.toString(nameValue);
+ }
+
+ Namespace ns;
+ if (namespaceValue == Undefined.instance) {
+ if ("*".equals(localName)) {
+ ns = null;
+ } else {
+ ns = getDefaultNamespace(cx);
+ }
+ } else if (namespaceValue == null) {
+ ns = null;
+ } else if (namespaceValue instanceof Namespace) {
+ ns = (Namespace)namespaceValue;
+ } else {
+ ns = constructNamespace(cx, namespaceValue);
+ }
+
+ if (ns == null) {
+ uri = null;
+ prefix = null;
+ } else {
+ uri = ns.uri();
+ prefix = ns.prefix();
+ }
+
+ return new QName(this, uri, localName, prefix);
+ }
+
+ Object addXMLObjects(Context cx, XMLObject obj1, XMLObject obj2)
+ {
+ XMLList listToAdd = new XMLList(this);
+
+ 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 = new XMLList(this, 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;
+ }
+
+ //
+ //
+ // Overriding XMLLib methods
+ //
+ //
+
+ /**
+ * See E4X 13.1.2.1.
+ */
+ public boolean isXMLName(Context cx, 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 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);
+ }
+
+ XMLName toQualifiedName(Context cx, Object namespaceValue,
+ Object nameValue)
+ {
+ // This is duplication of constructQName(cx, namespaceValue, nameValue)
+ // but for XMLName
+
+ String uri;
+ String localName;
+
+ if (nameValue instanceof QName) {
+ QName qname = (QName)nameValue;
+ localName = qname.localName();
+ } else {
+ localName = ScriptRuntime.toString(nameValue);
+ }
+
+ Namespace ns;
+ if (namespaceValue == Undefined.instance) {
+ if ("*".equals(localName)) {
+ ns = null;
+ } else {
+ ns = getDefaultNamespace(cx);
+ }
+ } else if (namespaceValue == null) {
+ ns = null;
+ } else if (namespaceValue instanceof Namespace) {
+ ns = (Namespace)namespaceValue;
+ } else {
+ ns = constructNamespace(cx, namespaceValue);
+ }
+
+ if (ns == null) {
+ uri = null;
+ } else {
+ uri = ns.uri();
+ }
+
+ return XMLName.formProperty(uri, localName);
+ }
+
+ 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 = toQualifiedName(cx, namespace, name);
+ if ((memberTypeFlags & Node.ATTRIBUTE_FLAG) != 0) {
+ if (!xmlName.isAttributeName()) {
+ xmlName.setAttributeName();
+ }
+ }
+ return xmlPrimaryReference(cx, xmlName, scope);
+ }
+
+ private Ref xmlPrimaryReference(Context cx, XMLName xmlName,
+ Scriptable scope)
+ {
+ XMLObjectImpl xmlObj;
+ XMLObjectImpl firstXmlObject = 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 (firstXmlObject == null) {
+ firstXmlObject = xmlObj;
+ }
+ }
+ scope = scope.getParentScope();
+ if (scope == null) {
+ xmlObj = firstXmlObject;
+ break;
+ }
+ }
+
+ // xmlObj == null corresponds to undefined as the target of
+ // the reference
+ if (xmlObj != null) {
+ xmlName.initXMLObject(xmlObj);
+ }
+ return xmlName;
+ }
+
+ /**
+ * Escapes the reserved characters in a value of an attribute
+ *
+ * @param value Unescaped text
+ * @return The escaped text
+ */
+ public String escapeAttributeValue(Object value)
+ {
+ String text = ScriptRuntime.toString(value);
+
+ if (text.length() == 0) return "";
+
+ XmlObject xo = XmlObject.Factory.newInstance();
+
+ XmlCursor cursor = xo.newCursor();
+ cursor.toNextToken();
+ cursor.beginElement("a");
+ cursor.insertAttributeWithValue("a", text);
+ cursor.dispose();
+
+ String elementText = xo.toString();
+ int begin = elementText.indexOf('"');
+ int end = elementText.lastIndexOf('"');
+ return elementText.substring(begin + 1, end);
+ }
+
+ /**
+ * Escapes the reserved characters in a value of a text node
+ *
+ * @param value Unescaped text
+ * @return The escaped text
+ */
+ public String escapeTextValue(Object value)
+ {
+ if (value instanceof XMLObjectImpl) {
+ return ((XMLObjectImpl)value).toXMLString(0);
+ }
+
+ String text = ScriptRuntime.toString(value);
+
+ if (text.length() == 0) return text;
+
+ XmlObject xo = XmlObject.Factory.newInstance();
+
+ XmlCursor cursor = xo.newCursor();
+ cursor.toNextToken();
+ cursor.beginElement("a");
+ cursor.insertChars(text);
+ cursor.dispose();
+
+ String elementText = xo.toString();
+ int begin = elementText.indexOf('>') + 1;
+ int end = elementText.lastIndexOf('<');
+ return (begin < end) ? elementText.substring(begin, end) : "";
+ }
+
+ public Object toDefaultXmlNamespace(Context cx, Object uriValue)
+ {
+ return constructNamespace(cx, uriValue);
+ }
+}
diff --git a/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLList.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLList.java
new file mode 100644
index 0000000..b66ec96
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLList.java
@@ -0,0 +1,1617 @@
+/* -*- 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.xml.impl.xmlbeans;
+
+import java.util.Vector;
+
+import org.mozilla.javascript.*;
+import org.mozilla.javascript.xml.*;
+
+import org.apache.xmlbeans.XmlCursor;
+
+class XMLList extends XMLObjectImpl implements Function
+{
+ static final long serialVersionUID = -4543618751670781135L;
+
+ static class AnnotationList
+ {
+ private Vector v;
+
+
+ AnnotationList ()
+ {
+ v = new Vector();
+ }
+
+
+ void add (XML.XScriptAnnotation n)
+ {
+ v.add(n);
+ }
+
+
+ XML.XScriptAnnotation item(int index)
+ {
+ return (XML.XScriptAnnotation)(v.get(index));
+ }
+
+
+ void remove (int index)
+ {
+ v.remove(index);
+ }
+
+
+ int length()
+ {
+ return v.size();
+ }
+ };
+
+
+ // Fields
+ private AnnotationList _annos;
+
+ private XMLObjectImpl targetObject = null;
+ private javax.xml.namespace.QName targetProperty = null;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Constructors
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ /**
+ *
+ */
+ XMLList(XMLLibImpl lib)
+ {
+ super(lib, lib.xmlListPrototype);
+ _annos = new AnnotationList();
+ }
+
+ /**
+ *
+ * @param inputObject
+ */
+ XMLList(XMLLibImpl lib, Object inputObject)
+ {
+ super(lib, lib.xmlListPrototype);
+ String frag;
+
+ if (inputObject == null || inputObject instanceof Undefined)
+ {
+ frag = "";
+ }
+ else if (inputObject instanceof XML)
+ {
+ XML xml = (XML) inputObject;
+
+ _annos = new AnnotationList();
+ _annos.add(xml.getAnnotation());
+ }
+ else if (inputObject instanceof XMLList)
+ {
+ XMLList xmll = (XMLList) inputObject;
+
+ _annos = new AnnotationList();
+
+ for (int i = 0; i < xmll._annos.length(); i++)
+ {
+ _annos.add(xmll._annos.item(i));
+ }
+ }
+ else
+ {
+ 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 = XML.createFromJS(lib, frag);
+
+ // Now orphan the children and add them to our XMLList.
+ XMLList children = orgXML.children();
+
+ _annos = new AnnotationList();
+
+ for (int i = 0; i < children._annos.length(); i++)
+ {
+ // Copy here is so that they'll be orphaned (parent() will be undefined)
+ _annos.add(((XML) children.item(i).copy()).getAnnotation());
+ }
+ }
+ }
+
+ //
+ //
+ // TargetObject/Property accessors
+ //
+ //
+
+ /**
+ *
+ * @param object
+ * @param property
+ */
+ void setTargets(XMLObjectImpl object, javax.xml.namespace.QName property)
+ {
+ targetObject = object;
+ targetProperty = property;
+ }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Private functions
+ //
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ /**
+ *
+ * @param index
+ * @return
+ */
+ XML getXmlFromAnnotation(int index)
+ {
+ XML retVal;
+
+ if (index >= 0 && index < length())
+ {
+ XML.XScriptAnnotation anno = _annos.item(index);
+ retVal = XML.getFromAnnotation(lib, anno);
+ }
+ else
+ {
+ retVal = null;
+ }
+
+ return retVal;
+ }
+
+ /**
+ *
+ * @param index
+ */
+ private void internalRemoveFromList (int index)
+ {
+ _annos.remove(index);
+ }
+
+ /**
+ *
+ * @param index
+ * @param xml
+ */
+ void replace(int index, XML xml)
+ {
+ if (index < length())
+ {
+ AnnotationList newAnnoList = new AnnotationList();
+
+ // Copy upto item to replace.
+ for (int i = 0; i < index; i++)
+ {
+ newAnnoList.add(_annos.item(i));
+ }
+
+ newAnnoList.add(xml.getAnnotation());
+
+ // Skip over old item we're going to replace we've already add new item on above line.
+ for (int i = index + 1; i < length(); i++)
+ {
+ newAnnoList.add(_annos.item(i));
+ }
+
+ _annos = newAnnoList;
+ }
+ }
+
+ /**
+ *
+ * @param index
+ * @param xml
+ */
+ private void insert(int index, XML xml)
+ {
+ if (index < length())
+ {
+ AnnotationList newAnnoList = new AnnotationList();
+
+ // Copy upto item to insert.
+ for (int i = 0; i < index; i++)
+ {
+ newAnnoList.add(_annos.item(i));
+ }
+
+ newAnnoList.add(xml.getAnnotation());
+
+ for (int i = index; i < length(); i++)
+ {
+ newAnnoList.add(_annos.item(i));
+ }
+
+ _annos = newAnnoList;
+ }
+ }
+
+ //
+ //
+ // methods overriding ScriptableObject
+ //
+ //
+
+ public String getClassName ()
+ {
+ return "XMLList";
+ }
+
+ //
+ //
+ // methods overriding IdScriptableObject
+ //
+ //
+
+ /**
+ *
+ * @param index
+ * @param start
+ * @return
+ */
+ public Object get(int index, Scriptable start)
+ {
+ //Log("get index: " + index);
+
+ if (index >= 0 && index < length())
+ {
+ return getXmlFromAnnotation(index);
+ }
+ else
+ {
+ return Scriptable.NOT_FOUND;
+ }
+ }
+
+ /**
+ *
+ * @param name
+ * @param start
+ * @return
+ */
+ 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;
+ }
+
+
+ /**
+ *
+ * @param index
+ * @param start
+ * @return
+ */
+ public boolean has(int index, Scriptable start)
+ {
+ return 0 <= index && index < length();
+ }
+
+ /**
+ *
+ * @param name
+ * @param value
+ */
+ 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 that 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.getLocalPart().equals("*"))
+ {
+ // Add an empty element with our targetProperty name and then set it.
+ XML xmlValue = XML.createTextElement(lib, targetProperty, "");
+ 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.getNamespaceURI(), targetProperty.getLocalPart());
+ 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));
+ }
+ }
+
+ /**
+ *
+ * @param name
+ * @return
+ */
+ Object getXMLProperty(XMLName name)
+ {
+ return getPropertyList(name);
+ }
+
+ /**
+ *
+ * @param index
+ * @param value
+ */
+ 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 = XML.createFromJS(lib, value.toString());
+ }
+ else
+ {
+ xmlValue = XML.createTextElement(lib, targetProperty, value.toString());
+ }
+ }
+
+ // 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)
+ {
+ xmlNode.replaceAll((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();
+ xmlNode.replaceAll(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 = XML.getFromAnnotation(lib, _annos.item(index));
+
+ if (xmlValue instanceof XML)
+ {
+ xmlNode.replaceAll((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)
+ {
+ xmlNode.replaceAll(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);
+ }
+ }
+ }
+
+
+ /**
+ *
+ * @param name
+ */
+ void deleteXMLProperty(XMLName name)
+ {
+ for (int i = 0; i < length(); i++)
+ {
+ XML xml = getXmlFromAnnotation(i);
+
+ if (xml.tokenType() == XmlCursor.TokenType.START)
+ {
+ xml.deleteXMLProperty(name);
+ }
+ }
+ }
+
+ /**
+ *
+ * @param index
+ */
+ public void delete(int index)
+ {
+ if (index >= 0 && index < length())
+ {
+ XML xml = getXmlFromAnnotation(index);
+
+ xml.remove();
+
+ internalRemoveFromList(index);
+ }
+ }
+
+
+ /**
+ *
+ * @return
+ */
+ public Object[] getIds()
+ {
+ Object enumObjs[];
+
+ if (prototypeFlag)
+ {
+ enumObjs = new Object[0];
+ }
+ else
+ {
+ enumObjs = new Object[length()];
+
+ for (int i = 0; i < enumObjs.length; i++)
+ {
+ enumObjs[i] = new Integer(i);
+ }
+ }
+
+ return enumObjs;
+ }
+
+ /**
+ *
+ * @return
+ */
+ 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);
+ }
+ }
+ }
+
+ /**
+ *
+ * @param index
+ * @return
+ */
+ XML item (int index)
+ {
+ return _annos != null
+ ? getXmlFromAnnotation(index) : XML.createEmptyXML(lib);
+ }
+
+
+ /**
+ *
+ * @param name
+ * @param value
+ */
+ private void setAttribute (XMLName xmlName, Object value)
+ {
+ for (int i = 0; i < length(); i++)
+ {
+ XML xml = getXmlFromAnnotation(i);
+ xml.setAttribute(xmlName, value);
+ }
+ }
+
+
+ /**
+ *
+ * @param toAdd
+ */
+ 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++)
+ {
+ _annos.add((xmlSrc.item(i)).getAnnotation());
+ }
+ }
+ else if (toAdd instanceof XML)
+ {
+ _annos.add(((XML)(toAdd)).getAnnotation());
+ }
+ else if (toAdd instanceof XML.XScriptAnnotation)
+ {
+ _annos.add((XML.XScriptAnnotation)toAdd);
+ }
+ }
+
+ //
+ //
+ // Methods from section 12.4.4 in the spec
+ //
+ //
+
+ /**
+ *
+ * @param toAdd
+ */
+ XML addNamespace(Namespace ns)
+ {
+ if(length() == 1)
+ {
+ return getXmlFromAnnotation(0).addNamespace(ns);
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The addNamespace method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @param xml
+ * @return
+ */
+ XML appendChild(Object xml)
+ {
+ if (length() == 1)
+ {
+ return getXmlFromAnnotation(0).appendChild(xml);
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The appendChild method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @param attr
+ * @return
+ */
+ XMLList attribute(XMLName xmlName)
+ {
+ XMLList result = new XMLList(lib);
+
+ for (int i = 0; i < length(); i++)
+ {
+ XML xml = getXmlFromAnnotation(i);
+ result.addToList(xml.attribute(xmlName));
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @return
+ */
+ XMLList attributes()
+ {
+ XMLList result = new XMLList(lib);
+
+ for (int i = 0; i < length(); i++)
+ {
+ XML xml = getXmlFromAnnotation(i);
+ result.addToList(xml.attributes());
+ }
+
+ return result;
+ }
+
+ XMLList child(long index)
+ {
+ XMLList result = new XMLList(lib);
+
+ for (int i = 0; i < length(); i++)
+ {
+ result.addToList(getXmlFromAnnotation(i).child(index));
+ }
+
+ return result;
+ }
+
+ XMLList child(XMLName xmlName)
+ {
+ XMLList result = new XMLList(lib);
+
+ for (int i = 0; i < length(); i++)
+ {
+ result.addToList(getXmlFromAnnotation(i).child(xmlName));
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @return
+ */
+ int childIndex()
+ {
+ if (length() == 1)
+ {
+ return getXmlFromAnnotation(0).childIndex();
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The childIndex method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @return
+ */
+ XMLList children()
+ {
+ Vector v = new 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 = new XMLList(lib);
+ int sz = v.size();
+
+ for (int i = 0; i < sz; i++)
+ {
+ allChildren.addToList(v.get(i));
+ }
+
+ return allChildren;
+ }
+
+ /**
+ *
+ * @return
+ */
+ XMLList comments()
+ {
+ XMLList result = new XMLList(lib);
+
+ for (int i = 0; i < length(); i++)
+ {
+ XML xml = getXmlFromAnnotation(i);
+
+ result.addToList(xml.comments());
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @param xml
+ * @return
+ */
+ 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;
+ }
+
+ /**
+ *
+ * @return
+ */
+ Object copy()
+ {
+ XMLList result = new XMLList(lib);
+
+ for (int i = 0; i < length(); i++)
+ {
+ XML xml = getXmlFromAnnotation(i);
+ result.addToList(xml.copy());
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @return
+ */
+ XMLList descendants(XMLName xmlName)
+ {
+ XMLList result = new XMLList(lib);
+
+ for (int i = 0; i < length(); i++)
+ {
+ XML xml = getXmlFromAnnotation(i);
+ result.addToList(xml.descendants(xmlName));
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @return
+ */
+ Object[] inScopeNamespaces()
+ {
+ if(length() == 1)
+ {
+ return getXmlFromAnnotation(0).inScopeNamespaces();
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The inScopeNamespaces method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @param child
+ * @param xml
+ */
+ XML insertChildAfter(Object child, Object xml)
+ {
+ if (length() == 1)
+ {
+ return getXmlFromAnnotation(0).insertChildAfter(child, xml);
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The insertChildAfter method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @param child
+ * @param xml
+ */
+ XML insertChildBefore(Object child, Object xml)
+ {
+ if (length() == 1)
+ {
+ return getXmlFromAnnotation(0).insertChildAfter(child, xml);
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The insertChildBefore method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @return
+ */
+ boolean hasOwnProperty(XMLName xmlName)
+ {
+ boolean hasProperty = false;
+
+ if (prototypeFlag)
+ {
+ String property = xmlName.localName();
+ hasProperty = (0 != findPrototypeId(property));
+ }
+ else
+ {
+ hasProperty = (getPropertyList(xmlName).length() > 0);
+ }
+
+ return hasProperty;
+ }
+
+ /**
+ *
+ * @return
+ */
+ 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.tokenType() == XmlCursor.TokenType.START)
+ {
+ complexContent = true;
+ break;
+ }
+ }
+ }
+
+ return complexContent;
+ }
+
+ /**
+ *
+ * @return
+ */
+ boolean hasSimpleContent()
+ {
+ boolean simpleContent;
+ int length = length();
+
+ if (length == 0)
+ {
+ simpleContent = true;
+ }
+ else if (length == 1)
+ {
+ simpleContent = getXmlFromAnnotation(0).hasSimpleContent();
+ }
+ else
+ {
+ simpleContent = true;
+
+ for (int i = 0; i < length; i++)
+ {
+ XML nextElement = getXmlFromAnnotation(i);
+ if (nextElement.tokenType() == XmlCursor.TokenType.START)
+ {
+ simpleContent = false;
+ break;
+ }
+ }
+ }
+
+ return simpleContent;
+ }
+
+ /**
+ *
+ * @return
+ */
+ int length()
+ {
+ int result = 0;
+
+ if (_annos != null)
+ {
+ result = _annos.length();
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @return
+ */
+ String localName()
+ {
+ if (length() == 1)
+ {
+ return name().localName();
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The localName method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @return
+ */
+ QName name()
+ {
+ if (length() == 1)
+ {
+ return getXmlFromAnnotation(0).name();
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The name method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @param prefix
+ * @return
+ */
+ Object namespace(String prefix)
+ {
+ if (length() == 1)
+ {
+ return getXmlFromAnnotation(0).namespace(prefix);
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The namespace method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @return
+ */
+ Object[] namespaceDeclarations()
+ {
+ if (length() == 1)
+ {
+ return getXmlFromAnnotation(0).namespaceDeclarations();
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The namespaceDeclarations method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @return
+ */
+ Object nodeKind()
+ {
+ if (length() == 1)
+ {
+ return getXmlFromAnnotation(0).nodeKind();
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The nodeKind method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ */
+ 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.
+ *
+ * @return
+ */
+ Object parent()
+ {
+ Object sameParent = Undefined.instance;
+
+ if ((length() == 0) && (targetObject != null) && (targetObject instanceof XML))
+ {
+ sameParent = targetObject;
+ }
+ else
+ {
+ for (int i = 0; i < length(); i++)
+ {
+ Object currParent = getXmlFromAnnotation(i).parent();
+
+ if (i == 0)
+ {
+ // Set the first for the rest to compare to.
+ sameParent = currParent;
+ }
+ else if (sameParent != currParent)
+ {
+ sameParent = Undefined.instance;
+ break;
+ }
+ }
+ }
+
+ // If everything in the list is the sameParent then return that as the parent.
+ return sameParent;
+ }
+
+ /**
+ *
+ * @param xml
+ * @return
+ */
+ XML prependChild(Object xml)
+ {
+ if (length() == 1)
+ {
+ return getXmlFromAnnotation(0).prependChild(xml);
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The prependChild method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @return
+ */
+ Object processingInstructions(XMLName xmlName)
+ {
+ XMLList result = new XMLList(lib);
+
+ for (int i = 0; i < length(); i++)
+ {
+ XML xml = getXmlFromAnnotation(i);
+
+ result.addToList(xml.processingInstructions(xmlName));
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @param name
+ * @return
+ */
+ 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());
+ }
+
+ /**
+ *
+ * @param ns
+ */
+ XML removeNamespace(Namespace ns)
+ {
+ if(length() == 1)
+ {
+ return getXmlFromAnnotation(0).removeNamespace(ns);
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The removeNamespace method works only on lists containing one item");
+ }
+ }
+
+ XML replace(long index, Object xml)
+ {
+ if (length() == 1)
+ {
+ return getXmlFromAnnotation(0).replace(index, xml);
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The replace method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @param propertyName
+ * @param xml
+ * @return
+ */
+ XML replace(XMLName xmlName, Object xml)
+ {
+ if (length() == 1)
+ {
+ return getXmlFromAnnotation(0).replace(xmlName, xml);
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The replace method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @param xml
+ */
+ XML setChildren(Object xml)
+ {
+ if (length() == 1)
+ {
+ return getXmlFromAnnotation(0).setChildren(xml);
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The setChildren method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @param name
+ */
+ void setLocalName(String localName)
+ {
+ if (length() == 1)
+ {
+ getXmlFromAnnotation(0).setLocalName(localName);
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The setLocalName method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @param name
+ */
+ void setName(QName qname)
+ {
+ if (length() == 1)
+ {
+ getXmlFromAnnotation(0).setName(qname);
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The setName method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * @param ns
+ */
+ void setNamespace(Namespace ns)
+ {
+ if (length() == 1)
+ {
+ getXmlFromAnnotation(0).setNamespace(ns);
+ }
+ else
+ {
+ throw ScriptRuntime.typeError("The setNamespace method works only on lists containing one item");
+ }
+ }
+
+ /**
+ *
+ * * @return
+ */
+ XMLList text()
+ {
+ XMLList result = new XMLList(lib);
+
+ for (int i = 0; i < length(); i++)
+ {
+ result.addToList(getXmlFromAnnotation(i).text());
+ }
+
+ return result;
+ }
+
+ /**
+ *
+ * @return
+ */
+ public String toString()
+ {
+ if (hasSimpleContent())
+ {
+ StringBuffer sb = new StringBuffer();
+
+ for(int i = 0; i < length(); i++)
+ {
+ XML next = getXmlFromAnnotation(i);
+ sb.append(next.toString());
+ }
+
+ return sb.toString();
+ }
+ else
+ {
+ return toXMLString(0);
+ }
+ }
+
+ String toSource(int indent)
+ {
+ // XXX indent is ignored
+ return "<>"+toXMLString(0)+"</>";
+ }
+
+ /**
+ *
+ * @return
+ */
+ String toXMLString(int indent)
+ {
+ StringBuffer sb = new StringBuffer();
+
+ for(int i = 0; i < length(); i++)
+ {
+ if (i > 0)
+ {
+ sb.append('\n');
+ }
+
+ sb.append(getXmlFromAnnotation(i).toXMLString(indent));
+ }
+
+ return sb.toString();
+ }
+
+ /**
+ *
+ * @return
+ */
+ Object valueOf()
+ {
+ return this;
+ }
+
+ //
+ // Other public Functions from XMLObject
+ //
+
+ /**
+ *
+ * @param target
+ * @return
+ */
+ 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;
+ }
+
+ /**
+ *
+ * @param name
+ * @param start
+ * @return
+ */
+ private XMLList getPropertyList(XMLName name)
+ {
+ XMLList propertyList = new XMLList(lib);
+ javax.xml.namespace.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 = new javax.xml.namespace.QName(name.uri(), name.localName());
+ }
+
+ 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 new XMLList(lib);
+ } else {
+ Object arg0 = args[0];
+ if (!inNewExpr && arg0 instanceof XMLList) {
+ // XMLList(XMLList) returns the same object.
+ return arg0;
+ }
+ return new XMLList(lib, arg0);
+ }
+ }
+
+ org.apache.xmlbeans.XmlObject getXmlObject()
+ {
+ if (length() == 1) {
+ return getXmlFromAnnotation(0).getXmlObject();
+ } else {
+ throw ScriptRuntime.typeError("getXmlObject method works only on lists containing one item");
+ }
+ }
+
+ /**
+ * 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.getLocalPart();
+
+ 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/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLName.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLName.java
new file mode 100644
index 0000000..8ff972e
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLName.java
@@ -0,0 +1,171 @@
+/* -*- 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
+ *
+ * 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.xml.impl.xmlbeans;
+
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.Kit;
+import org.mozilla.javascript.Ref;
+import org.mozilla.javascript.ScriptRuntime;
+import org.mozilla.javascript.Undefined;
+
+class XMLName extends Ref
+{
+ static final long serialVersionUID = 3832176310755686977L;
+
+ private String uri;
+ private String localName;
+ private boolean isAttributeName;
+ private boolean isDescendants;
+ private XMLObjectImpl xmlObject;
+
+ private XMLName(String uri, String localName)
+ {
+ this.uri = uri;
+ this.localName = localName;
+ }
+
+ static XMLName formStar()
+ {
+ return new XMLName(null, "*");
+ }
+
+ static XMLName formProperty(String uri, String localName)
+ {
+ return new XMLName(uri, localName);
+ }
+
+ void initXMLObject(XMLObjectImpl xmlObject)
+ {
+ if (xmlObject == null) throw new IllegalArgumentException();
+ if (this.xmlObject != null) throw new IllegalStateException();
+ this.xmlObject = xmlObject;
+ }
+
+ String uri()
+ {
+ return uri;
+ }
+
+ String localName()
+ {
+ return localName;
+ }
+
+ boolean isAttributeName()
+ {
+ return isAttributeName;
+ }
+
+ void setAttributeName()
+ {
+ if (isAttributeName) throw new IllegalStateException();
+ isAttributeName = true;
+ }
+
+ boolean isDescendants()
+ {
+ return isDescendants;
+ }
+
+ void setIsDescendants()
+ {
+ if (isDescendants) throw new IllegalStateException();
+ isDescendants = true;
+ }
+
+ 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();
+ }
+
+}
diff --git a/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLObjectImpl.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLObjectImpl.java
new file mode 100644
index 0000000..a6d47d5
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLObjectImpl.java
@@ -0,0 +1,724 @@
+/* -*- 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
+ *
+ * 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.xml.impl.xmlbeans;
+
+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();
+
+ protected final XMLLibImpl lib;
+ protected boolean prototypeFlag;
+
+ protected XMLObjectImpl(XMLLibImpl lib, XMLObject prototype)
+ {
+ super(lib.globalScope(), prototype);
+ this.lib = lib;
+ }
+
+ /**
+ * 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);
+
+ // Methods from section 12.4.4 in the spec
+ abstract XML addNamespace(Namespace ns);
+ abstract XML appendChild(Object xml);
+ abstract XMLList attribute(XMLName xmlName);
+ abstract XMLList attributes();
+ abstract XMLList child(long index);
+ abstract XMLList child(XMLName xmlName);
+ abstract int childIndex();
+ abstract XMLList children();
+ abstract XMLList comments();
+ abstract boolean contains(Object xml);
+ abstract Object copy();
+ abstract XMLList descendants(XMLName xmlName);
+ abstract Object[] inScopeNamespaces();
+ abstract XML insertChildAfter(Object child, Object xml);
+ abstract XML insertChildBefore(Object child, Object xml);
+ abstract boolean hasOwnProperty(XMLName xmlName);
+ abstract boolean hasComplexContent();
+ abstract boolean hasSimpleContent();
+ abstract int length();
+ abstract String localName();
+ abstract QName name();
+ abstract Object namespace(String prefix);
+ abstract Object[] namespaceDeclarations();
+ abstract Object nodeKind();
+ abstract void normalize();
+ abstract Object parent();
+ abstract XML prependChild(Object xml);
+ abstract Object processingInstructions(XMLName xmlName);
+ abstract boolean propertyIsEnumerable(Object member);
+ abstract XML removeNamespace(Namespace ns);
+ abstract XML replace(long index, Object xml);
+ abstract XML replace(XMLName name, Object xml);
+ abstract XML setChildren(Object xml);
+ abstract void setLocalName(String name);
+ abstract void setName(QName xmlName);
+ abstract void setNamespace(Namespace ns);
+ abstract XMLList text();
+ public abstract String toString();
+ abstract String toSource(int indent);
+ abstract String toXMLString(int indent);
+ abstract Object valueOf();
+
+ /**
+ * Extension to access native implementation from scripts
+ */
+ abstract org.apache.xmlbeans.XmlObject getXmlObject();
+
+ protected abstract Object jsConstructor(Context cx, boolean inNewExpr,
+ Object[] args);
+
+
+ final Object getMethod(String id)
+ {
+ return super.get(id, this);
+ }
+
+ //
+ //
+ // Methods overriding ScriptableObject
+ //
+ //
+
+ public final Object getDefaultValue(Class hint)
+ {
+ return toString();
+ }
+
+ public void delete(String name)
+ {
+ throw new IllegalArgumentException("String: [" + name + "]");
+ }
+
+ /**
+ * 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
+ //
+ //
+
+ public final XMLLib lib()
+ {
+ return lib;
+ }
+
+ /**
+ * 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;
+ }
+
+ public Ref memberRef(Context cx, Object elem, int memberTypeFlags)
+ {
+ XMLName xmlName;
+ if ((memberTypeFlags & Node.ATTRIBUTE_FLAG) != 0) {
+ xmlName = lib.toAttributeName(cx, elem);
+ } else {
+ if ((memberTypeFlags & Node.DESCENDANTS_FLAG) == 0) {
+ // Code generation would use ecma(Get|Has|Delete|Set) for
+ // normal name idenrifiers so one ATTRIBUTE_FLAG
+ // or DESCENDANTS_FLAG has to be set
+ throw Kit.codeBug();
+ }
+ xmlName = lib.toXMLName(cx, elem);
+ }
+ if ((memberTypeFlags & Node.DESCENDANTS_FLAG) != 0) {
+ xmlName.setIsDescendants();
+ }
+ xmlName.initXMLObject(this);
+ return xmlName;
+ }
+
+ /**
+ * Generic reference to implement x::ns, x.@ns::y, x..@ns::y etc.
+ */
+ public Ref memberRef(Context cx, Object namespace, Object elem,
+ int memberTypeFlags)
+ {
+ XMLName xmlName = lib.toQualifiedName(cx, namespace, elem);
+ if ((memberTypeFlags & Node.ATTRIBUTE_FLAG) != 0) {
+ if (!xmlName.isAttributeName()) {
+ xmlName.setAttributeName();
+ }
+ }
+ if ((memberTypeFlags & Node.DESCENDANTS_FLAG) != 0) {
+ xmlName.setIsDescendants();
+ }
+ xmlName.initXMLObject(this);
+ return xmlName;
+ }
+
+ 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, lib.globalScope(), 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_inScopeNamespaces = 13,
+ Id_insertChildAfter = 14,
+ Id_insertChildBefore = 15,
+ Id_hasOwnProperty = 16,
+ Id_hasComplexContent = 17,
+ Id_hasSimpleContent = 18,
+ Id_length = 19,
+ Id_localName = 20,
+ Id_name = 21,
+ Id_namespace = 22,
+ Id_namespaceDeclarations = 23,
+ Id_nodeKind = 24,
+ Id_normalize = 25,
+ Id_parent = 26,
+ Id_prependChild = 27,
+ Id_processingInstructions = 28,
+ Id_propertyIsEnumerable = 29,
+ Id_removeNamespace = 30,
+ Id_replace = 31,
+ Id_setChildren = 32,
+ Id_setLocalName = 33,
+ Id_setName = 34,
+ Id_setNamespace = 35,
+ Id_text = 36,
+ Id_toString = 37,
+ Id_toSource = 38,
+ Id_toXMLString = 39,
+ Id_valueOf = 40,
+
+ Id_getXmlObject = 41,
+
+ MAX_PROTOTYPE_ID = 41;
+
+ protected int findPrototypeId(String s)
+ {
+ int id;
+// #generated# Last update: 2004-11-10 15:38:11 CET
+ 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(4)) {
+ case 'K': X="nodeKind";id=Id_nodeKind; break L;
+ case 'a': X="contains";id=Id_contains; break L;
+ case 'd': X="children";id=Id_children; break L;
+ case 'e': X="comments";id=Id_comments; break L;
+ case 'r': X="toString";id=Id_toString; break L;
+ case 'u': X="toSource";id=Id_toSource; 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: switch (s.charAt(0)) {
+ case 'a': X="addNamespace";id=Id_addNamespace; break L;
+ case 'g': X="getXmlObject";id=Id_getXmlObject; break L;
+ case 'p': X="prependChild";id=Id_prependChild; break L;
+ case 's': c=s.charAt(3);
+ if (c=='L') { X="setLocalName";id=Id_setLocalName; }
+ else if (c=='N') { X="setNamespace";id=Id_setNamespace; }
+ break L;
+ } 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;
+ }
+// #/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_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_toSource: arity=1; s="toSource"; break;
+ case Id_toXMLString: arity=1; s="toXMLString"; break;
+ case Id_valueOf: arity=0; s="valueOf"; break;
+
+ case Id_getXmlObject: arity=0; s="getXmlObject"; break;
+ default: throw new IllegalArgumentException(String.valueOf(id));
+ }
+ initPrototypeMethod(XMLOBJECT_TAG, id, s, arity);
+ }
+
+ /**
+ *
+ * @param f
+ * @param cx
+ * @param scope
+ * @param thisObj
+ * @param args
+ * @return
+ */
+ 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;
+
+ switch (id) {
+ case Id_addNamespace: {
+ Namespace ns = lib.castToNamespace(cx, arg(args, 0));
+ return realThis.addNamespace(ns);
+ }
+ case Id_appendChild:
+ return realThis.appendChild(arg(args, 0));
+ case Id_attribute: {
+ XMLName xmlName = lib.toAttributeName(cx, arg(args, 0));
+ return realThis.attribute(xmlName);
+ }
+ case Id_attributes:
+ return realThis.attributes();
+ case Id_child: {
+ XMLName xmlName = lib.toXMLNameOrIndex(cx, arg(args, 0));
+ if (xmlName == null) {
+ long index = ScriptRuntime.lastUint32Result(cx);
+ return realThis.child(index);
+ } else {
+ return realThis.child(xmlName);
+ }
+ }
+ case Id_childIndex:
+ return ScriptRuntime.wrapInt(realThis.childIndex());
+ 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: {
+ XMLName xmlName = (args.length == 0)
+ ? XMLName.formStar()
+ : lib.toXMLName(cx, args[0]);
+ return realThis.descendants(xmlName);
+ }
+ case Id_inScopeNamespaces: {
+ Object[] array = realThis.inScopeNamespaces();
+ return cx.newArray(scope, array);
+ }
+ case Id_insertChildAfter:
+ return realThis.insertChildAfter(arg(args, 0), arg(args, 1));
+ case Id_insertChildBefore:
+ return realThis.insertChildBefore(arg(args, 0), arg(args, 1));
+ 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_localName:
+ return realThis.localName();
+ case Id_name:
+ return realThis.name();
+ case Id_namespace: {
+ String prefix = (args.length > 0)
+ ? ScriptRuntime.toString(args[0]) : null;
+ return realThis.namespace(prefix);
+ }
+ case Id_namespaceDeclarations: {
+ Object[] array = realThis.namespaceDeclarations();
+ return cx.newArray(scope, array);
+ }
+ case Id_nodeKind:
+ return realThis.nodeKind();
+ case Id_normalize:
+ realThis.normalize();
+ return Undefined.instance;
+ case Id_parent:
+ return realThis.parent();
+ case Id_prependChild:
+ return realThis.prependChild(arg(args, 0));
+ 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_removeNamespace: {
+ Namespace ns = lib.castToNamespace(cx, arg(args, 0));
+ return realThis.removeNamespace(ns);
+ }
+ case Id_replace: {
+ XMLName xmlName = lib.toXMLNameOrIndex(cx, arg(args, 0));
+ Object arg1 = arg(args, 1);
+ if (xmlName == null) {
+ long index = ScriptRuntime.lastUint32Result(cx);
+ return realThis.replace(index, arg1);
+ } else {
+ return realThis.replace(xmlName, arg1);
+ }
+ }
+ case Id_setChildren:
+ return realThis.setChildren(arg(args, 0));
+ case Id_setLocalName: {
+ String localName;
+ Object arg = arg(args, 0);
+ if (arg instanceof QName) {
+ localName = ((QName)arg).localName();
+ } else {
+ localName = ScriptRuntime.toString(arg);
+ }
+ realThis.setLocalName(localName);
+ return Undefined.instance;
+ }
+ case Id_setName: {
+ Object arg = (args.length != 0) ? args[0] : Undefined.instance;
+ QName qname;
+ if (arg instanceof QName) {
+ qname = (QName)arg;
+ if (qname.uri() == null) {
+ qname = lib.constructQNameFromString(cx, qname.localName());
+ } else {
+ // E4X 13.4.4.35 requires to always construct QName
+ qname = lib.constructQName(cx, qname);
+ }
+ } else {
+ qname = lib.constructQName(cx, arg);
+ }
+ realThis.setName(qname);
+ return Undefined.instance;
+ }
+ case Id_setNamespace: {
+ Namespace ns = lib.castToNamespace(cx, arg(args, 0));
+ realThis.setNamespace(ns);
+ return Undefined.instance;
+ }
+ case Id_text:
+ return realThis.text();
+ case Id_toString:
+ return realThis.toString();
+ case Id_toSource: {
+ int indent = ScriptRuntime.toInt32(args, 0);
+ return realThis.toSource(indent);
+ }
+ case Id_toXMLString: {
+ int indent = ScriptRuntime.toInt32(args, 0);
+ return realThis.toXMLString(indent);
+ }
+ case Id_valueOf:
+ return realThis.valueOf();
+
+ case Id_getXmlObject: {
+ org.apache.xmlbeans.XmlObject xmlObject = realThis.getXmlObject();
+ return Context.javaToJS(xmlObject, scope);
+ }
+ }
+ throw new IllegalArgumentException(String.valueOf(id));
+ }
+
+ private static Object arg(Object[] args, int i)
+ {
+ return (i < args.length) ? args[i] : Undefined.instance;
+ }
+
+} \ No newline at end of file
diff --git a/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLWithScope.java b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/XMLWithScope.java
new file mode 100644
index 0000000..67a778d
--- /dev/null
+++ b/trunk/infrastructure/rhino1_7R1/deprecatedsrc/org/mozilla/javascript/xml/impl/xmlbeans/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.xml.impl.xmlbeans;
+
+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 = new XMLList(lib);
+ }
+
+ 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;
+ }
+}