Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
Rhino JavaScript Java Library Source Code
Rhino JavaScript Java Library is an open-source implementation of JavaScript written entirely in Java.
Rhino JavaScript Java Library Source Code files are provided in binary package (rhino-1.7.14.zip).
You can also browse the source code below:
✍: FYIcenter.com
⏎ org/mozilla/javascript/ImporterTopLevel.java
/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ // API class package org.mozilla.javascript; /** * Class ImporterTopLevel * * <p>This class defines a ScriptableObject that can be instantiated as a top-level ("global") * object to provide functionality similar to Java's "import" statement. * * <p>This class can be used to create a top-level scope using the following code: * * <pre> * Scriptable scope = new ImporterTopLevel(cx); * </pre> * * Then JavaScript code will have access to the following methods: * * <ul> * <li>importClass - will "import" a class by making its unqualified name available as a property * of the top-level scope * <li>importPackage - will "import" all the classes of the package by searching for unqualified * names as classes qualified by the given package. * </ul> * * The following code from the shell illustrates this use: * * <pre> * js> importClass(java.io.File) * js> f = new File('help.txt') * help.txt * js> importPackage(java.util) * js> v = new Vector() * [] * </pre> * * @author Norris Boyd */ public class ImporterTopLevel extends TopLevel { private static final long serialVersionUID = -9095380847465315412L; private static final Object IMPORTER_TAG = "Importer"; public ImporterTopLevel() {} public ImporterTopLevel(Context cx) { this(cx, false); } public ImporterTopLevel(Context cx, boolean sealed) { initStandardObjects(cx, sealed); } @Override public String getClassName() { return (topScopeFlag) ? "global" : "JavaImporter"; } public static void init(Context cx, Scriptable scope, boolean sealed) { ImporterTopLevel obj = new ImporterTopLevel(); obj.exportAsJSClass(MAX_PROTOTYPE_ID, scope, sealed); } public void initStandardObjects(Context cx, boolean sealed) { // Assume that Context.initStandardObjects initialize JavaImporter // property lazily so the above init call is not yet called cx.initStandardObjects(this, sealed); topScopeFlag = true; // If seal is true then exportAsJSClass(cx, seal) would seal // this obj. Since this is scope as well, it would not allow // to add variables. IdFunctionObject ctor = exportAsJSClass(MAX_PROTOTYPE_ID, this, false); if (sealed) { ctor.sealObject(); } // delete "constructor" defined by exportAsJSClass so "constructor" // name would refer to Object.constructor // and not to JavaImporter.prototype.constructor. delete("constructor"); } @Override public boolean has(String name, Scriptable start) { return super.has(name, start) || getPackageProperty(name, start) != NOT_FOUND; } @Override public Object get(String name, Scriptable start) { Object result = super.get(name, start); if (result != NOT_FOUND) return result; result = getPackageProperty(name, start); return result; } private Object getPackageProperty(String name, Scriptable start) { Object result = NOT_FOUND; Scriptable scope = start; if (topScopeFlag) { scope = ScriptableObject.getTopLevelScope(scope); } Object[] elements = getNativeJavaPackages(scope); if (elements == null) { return result; } for (int i = 0; i < elements.length; i++) { NativeJavaPackage p = (NativeJavaPackage) elements[i]; Object v = p.getPkgProperty(name, start, false); if (v != null && !(v instanceof NativeJavaPackage)) { if (result == NOT_FOUND) { result = v; } else { throw Context.reportRuntimeErrorById( "msg.ambig.import", result.toString(), v.toString()); } } } return result; } private static Object[] getNativeJavaPackages(Scriptable scope) { // retrive the native java packages stored in top scope. synchronized (scope) { if (scope instanceof ScriptableObject) { ScriptableObject so = (ScriptableObject) scope; ObjArray importedPackages = (ObjArray) so.getAssociatedValue(AKEY); if (importedPackages != null) { return importedPackages.toArray(); } } } return null; } /** @deprecated Kept only for compatibility. */ @Deprecated public void importPackage(Context cx, Scriptable thisObj, Object[] args, Function funObj) { js_importPackage(this, args); } private Object js_construct(Scriptable scope, Object[] args) { ImporterTopLevel result = new ImporterTopLevel(); for (int i = 0; i != args.length; ++i) { Object arg = args[i]; if (arg instanceof NativeJavaClass) { ImporterTopLevel.importClass(result, (NativeJavaClass) arg); } else if (arg instanceof NativeJavaPackage) { ImporterTopLevel.importPackage(result, (NativeJavaPackage) arg); } else { throw Context.reportRuntimeErrorById( "msg.not.class.not.pkg", Context.toString(arg)); } } // set explicitly prototype and scope // as otherwise in top scope mode BaseFunction.construct // would keep them set to null. It also allow to use // JavaImporter without new and still get properly // initialized object. result.setParentScope(scope); result.setPrototype(this); return result; } private static Object js_importClass(Scriptable scope, Object[] args) { for (int i = 0; i != args.length; i++) { Object arg = args[i]; if (!(arg instanceof NativeJavaClass)) { throw Context.reportRuntimeErrorById("msg.not.class", Context.toString(arg)); } importClass(scope, (NativeJavaClass) arg); } return Undefined.instance; } private static Object js_importPackage(ScriptableObject scope, Object[] args) { for (int i = 0; i != args.length; i++) { Object arg = args[i]; if (!(arg instanceof NativeJavaPackage)) { throw Context.reportRuntimeErrorById("msg.not.pkg", Context.toString(arg)); } importPackage(scope, (NativeJavaPackage) arg); } return Undefined.instance; } private static void importPackage(ScriptableObject scope, NativeJavaPackage pkg) { if (pkg == null) { return; } synchronized (scope) { ObjArray importedPackages = (ObjArray) scope.getAssociatedValue(AKEY); if (importedPackages == null) { importedPackages = new ObjArray(); scope.associateValue(AKEY, importedPackages); } for (int j = 0; j != importedPackages.size(); j++) { if (pkg.equals(importedPackages.get(j))) { return; } } importedPackages.add(pkg); } } private static void importClass(Scriptable scope, NativeJavaClass cl) { String s = cl.getClassObject().getName(); String n = s.substring(s.lastIndexOf('.') + 1); Object val = scope.get(n, scope); if (val != NOT_FOUND && val != cl) { throw Context.reportRuntimeErrorById("msg.prop.defined", n); } // defineProperty(n, cl, DONTENUM); scope.put(n, scope, cl); } @Override protected void initPrototypeId(int id) { String s; int arity; switch (id) { case Id_constructor: arity = 0; s = "constructor"; break; case Id_importClass: arity = 1; s = "importClass"; break; case Id_importPackage: arity = 1; s = "importPackage"; break; default: throw new IllegalArgumentException(String.valueOf(id)); } initPrototypeMethod(IMPORTER_TAG, id, s, arity); } @Override public Object execIdCall( IdFunctionObject f, Context cx, Scriptable scope, Scriptable thisObj, Object[] args) { if (!f.hasTag(IMPORTER_TAG)) { return super.execIdCall(f, cx, scope, thisObj, args); } int id = f.methodId(); switch (id) { case Id_constructor: return js_construct(scope, args); case Id_importClass: return js_importClass(realScope(scope, thisObj, f), args); case Id_importPackage: return js_importPackage(realScope(scope, thisObj, f), args); } throw new IllegalArgumentException(String.valueOf(id)); } private ScriptableObject realScope(Scriptable scope, Scriptable thisObj, IdFunctionObject f) { if (topScopeFlag) { // when used as top scope importPackage and importClass are global // function that ignore thisObj. We use the the top level scope // which might not be the same as 'this' when used shared scopes thisObj = ScriptableObject.getTopLevelScope(scope); } return ensureType(thisObj, ScriptableObject.class, f); } @Override protected int findPrototypeId(String s) { int id; switch (s) { case "constructor": id = Id_constructor; break; case "importClass": id = Id_importClass; break; case "importPackage": id = Id_importPackage; break; default: id = 0; break; } return id; } private static final int Id_constructor = 1, Id_importClass = 2, Id_importPackage = 3, MAX_PROTOTYPE_ID = 3; private static final String AKEY = "importedPackages"; private boolean topScopeFlag; }
⏎ org/mozilla/javascript/ImporterTopLevel.java
Or download all of them as a single archive file:
File name: rhino-1.7.14-sources.jar File size: 1029165 bytes Release date: 2022-01-06 Download
⇒ Example code to Test rhino-runtime-1.7.14.jar
⇐ Download Rhino JavaScript Binary Package
2022-05-03, 35376👍, 1💬
Popular Posts:
JDK 11 jdk.charsets.jmod is the JMOD file for JDK 11 Charsets module. JDK 11 Charsets module compile...
Where to find answers to frequently asked questions on Download and Installing of Older Versions? He...
JRE 5 sunjce_provider.jar is the JAR file for JRE 5 Sun JCE Provider, which provides implementations...
What Is in Xerces-J-bin.2.12.2.zip? Xerces-J-bin.2.12.2.zip file is the distribution package ZIP fil...
iText is an ideal library for developers looking to enhance web- and other applications with dynamic...