org.mozilla.javascript.ImporterTopLevel Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of js Show documentation
Show all versions of js Show documentation
Rhino is an open-source implementation of JavaScript written entirely in Java. It is typically embedded into Java applications to provide scripting to end users.
The newest version!
/* -*- 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) 1999
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Norris Boyd
* Igor Bukanov
* Matthias Radestock
*
* 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;
/**
* Class ImporterTopLevel
*
* This class defines a ScriptableObject that can be instantiated
* as a top-level ("global") object to provide functionality similar
* to Java's "import" statement.
*
* This class can be used to create a top-level scope using the following code:
*
* Scriptable scope = new ImporterTopLevel(cx);
*
* Then JavaScript code will have access to the following methods:
*
* - importClass - will "import" a class by making its unqualified name
* available as a property of the top-level scope
*
- importPackage - will "import" all the classes of the package by
* searching for unqualified names as classes qualified
* by the given package.
*
* The following code from the shell illustrates this use:
*
* js> importClass(java.io.File)
* js> f = new File('help.txt')
* help.txt
* js> importPackage(java.util)
* js> v = new Vector()
* []
*
* @author Norris Boyd
*/
public class ImporterTopLevel extends IdScriptableObject
{
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;
Object[] elements;
synchronized (importedPackages) {
elements = importedPackages.toArray();
}
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.reportRuntimeError2(
"msg.ambig.import", result.toString(), v.toString());
}
}
}
return result;
}
/**
* @deprecated Kept only for compatibility.
*/
public void importPackage(Context cx, Scriptable thisObj, Object[] args,
Function funObj)
{
js_importPackage(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) {
result.importClass((NativeJavaClass)arg);
} else if (arg instanceof NativeJavaPackage) {
result.importPackage((NativeJavaPackage)arg);
} else {
throw Context.reportRuntimeError1(
"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 Object js_importClass(Object[] args)
{
for (int i = 0; i != args.length; i++) {
Object arg = args[i];
if (!(arg instanceof NativeJavaClass)) {
throw Context.reportRuntimeError1(
"msg.not.class", Context.toString(arg));
}
importClass((NativeJavaClass)arg);
}
return Undefined.instance;
}
private Object js_importPackage(Object[] args)
{
for (int i = 0; i != args.length; i++) {
Object arg = args[i];
if (!(arg instanceof NativeJavaPackage)) {
throw Context.reportRuntimeError1(
"msg.not.pkg", Context.toString(arg));
}
importPackage((NativeJavaPackage)arg);
}
return Undefined.instance;
}
private void importPackage(NativeJavaPackage pkg)
{
if(pkg == null) {
return;
}
synchronized (importedPackages) {
for (int j = 0; j != importedPackages.size(); j++) {
if (pkg.equals(importedPackages.get(j))) {
return;
}
}
importedPackages.add(pkg);
}
}
private void importClass(NativeJavaClass cl)
{
String s = cl.getClassObject().getName();
String n = s.substring(s.lastIndexOf('.')+1);
Object val = get(n, this);
if (val != NOT_FOUND && val != cl) {
throw Context.reportRuntimeError1("msg.prop.defined", n);
}
//defineProperty(n, cl, DONTENUM);
put(n, this, 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 realThis(thisObj, f).js_importClass(args);
case Id_importPackage:
return realThis(thisObj, f).js_importPackage(args);
}
throw new IllegalArgumentException(String.valueOf(id));
}
private ImporterTopLevel realThis(Scriptable thisObj, IdFunctionObject f)
{
if (topScopeFlag) {
// when used as top scope importPackage and importClass are global
// function that ignore thisObj
return this;
}
if (!(thisObj instanceof ImporterTopLevel))
throw incompatibleCallError(f);
return (ImporterTopLevel)thisObj;
}
// #string_id_map#
@Override
protected int findPrototypeId(String s)
{
int id;
// #generated# Last update: 2007-05-09 08:15:24 EDT
L0: { id = 0; String X = null; int c;
int s_length = s.length();
if (s_length==11) {
c=s.charAt(0);
if (c=='c') { X="constructor";id=Id_constructor; }
else if (c=='i') { X="importClass";id=Id_importClass; }
}
else if (s_length==13) { X="importPackage";id=Id_importPackage; }
if (X!=null && X!=s && !X.equals(s)) id = 0;
break L0;
}
// #/generated#
return id;
}
private static final int
Id_constructor = 1,
Id_importClass = 2,
Id_importPackage = 3,
MAX_PROTOTYPE_ID = 3;
// #/string_id_map#
private ObjArray importedPackages = new ObjArray();
private boolean topScopeFlag;
}