private IdFunctionObject newIdFunction(
Object tag, int id, String name, int arity, Scriptable scope) {
IdFunctionObject f = new IdFunctionObject(this, tag, id, name, arity, scope);
if (isSealed()) {
f.sealObject();
}
return f;
}
public final void initPrototypeConstructor(IdFunctionObject f) {
int id = prototypeValues.constructorId;
if (id == 0) throw new IllegalStateException();
if (f.methodId() != id) throw new IllegalArgumentException();
if (isSealed()) {
f.sealObject();
}
prototypeValues.initValue(id, "constructor", f, DONTENUM);
}
public static void init(Context cx, Scriptable scope, boolean sealed) {
JavaAdapter obj = new JavaAdapter();
IdFunctionObject ctor =
new IdFunctionObject(obj, FTAG, Id_JavaAdapter, "JavaAdapter", 1, scope);
ctor.markAsConstructor(null);
if (sealed) {
ctor.sealObject();
}
ctor.exportAsScopeProperty();
}
static void init(Scriptable scope, boolean sealed) {
NativeWith obj = new NativeWith();
obj.setParentScope(scope);
obj.setPrototype(ScriptableObject.getObjectPrototype(scope));
IdFunctionObject ctor = new IdFunctionObject(obj, FTAG, Id_constructor, "With", 0, scope);
ctor.markAsConstructor(obj);
if (sealed) {
ctor.sealObject();
}
ctor.exportAsScopeProperty();
}
public final IdFunctionObject exportAsJSClass(
int maxPrototypeId, Scriptable scope, boolean sealed) {
// Set scope and prototype unless this is top level scope itself
if (scope != this && scope != null) {
setParentScope(scope);
setPrototype(getObjectPrototype(scope));
}
activatePrototypeMap(maxPrototypeId);
IdFunctionObject ctor = prototypeValues.createPrecachedConstructor();
if (sealed) {
sealObject();
}
fillConstructorProperties(ctor);
if (sealed) {
ctor.sealObject();
}
ctor.exportAsScopeProperty();
return ctor;
}
public static void init(Context cx, Scriptable scope, boolean sealed) {
ClassLoader loader = cx.getApplicationClassLoader();
final NativeJavaTopPackage top = new NativeJavaTopPackage(loader);
top.setPrototype(getObjectPrototype(scope));
top.setParentScope(scope);
for (int i = 0; i != commonPackages.length; i++) {
NativeJavaPackage parent = top;
for (int j = 0; j != commonPackages[i].length; j++) {
parent = parent.forcePackage(commonPackages[i][j], scope);
}
}
// getClass implementation
IdFunctionObject getClass = new IdFunctionObject(top, FTAG, Id_getClass, "getClass", 1, scope);
// We want to get a real alias, and not a distinct JavaPackage
// with the same packageName, so that we share classes and top
// that are underneath.
String[] topNames = ScriptRuntime.getTopPackageNames();
NativeJavaPackage[] topPackages = new NativeJavaPackage[topNames.length];
for (int i = 0; i < topNames.length; i++) {
topPackages[i] = (NativeJavaPackage) top.get(topNames[i], top);
}
// It's safe to downcast here since initStandardObjects takes
// a ScriptableObject.
ScriptableObject global = (ScriptableObject) scope;
if (sealed) {
getClass.sealObject();
}
getClass.exportAsScopeProperty();
global.defineProperty("Packages", top, ScriptableObject.DONTENUM);
for (int i = 0; i < topNames.length; i++) {
global.defineProperty(topNames[i], topPackages[i], ScriptableObject.DONTENUM);
}
}
public static void init(Context cx, Scriptable scope, boolean sealed) {
NativeGlobal obj = new NativeGlobal();
for (int id = 1; id <= LAST_SCOPE_FUNCTION_ID; ++id) {
String name;
int arity = 1;
switch (id) {
case Id_decodeURI:
name = "decodeURI";
break;
case Id_decodeURIComponent:
name = "decodeURIComponent";
break;
case Id_encodeURI:
name = "encodeURI";
break;
case Id_encodeURIComponent:
name = "encodeURIComponent";
break;
case Id_escape:
name = "escape";
break;
case Id_eval:
name = "eval";
break;
case Id_isFinite:
name = "isFinite";
break;
case Id_isNaN:
name = "isNaN";
break;
case Id_isXMLName:
name = "isXMLName";
break;
case Id_parseFloat:
name = "parseFloat";
break;
case Id_parseInt:
name = "parseInt";
arity = 2;
break;
case Id_unescape:
name = "unescape";
break;
case Id_uneval:
name = "uneval";
break;
default:
throw Kit.codeBug();
}
IdFunctionObject f = new IdFunctionObject(obj, FTAG, id, name, arity, scope);
if (sealed) {
f.sealObject();
}
f.exportAsScopeProperty();
}
ScriptableObject.defineProperty(scope, "NaN", ScriptRuntime.NaNobj, ScriptableObject.DONTENUM);
ScriptableObject.defineProperty(
scope,
"Infinity",
ScriptRuntime.wrapNumber(Double.POSITIVE_INFINITY),
ScriptableObject.DONTENUM);
ScriptableObject.defineProperty(
scope, "undefined", Undefined.instance, ScriptableObject.DONTENUM);
String[] errorMethods =
Kit.semicolonSplit(
""
+ "ConversionError;"
+ "EvalError;"
+ "RangeError;"
+ "ReferenceError;"
+ "SyntaxError;"
+ "TypeError;"
+ "URIError;"
+ "InternalError;"
+ "JavaException;");
/*
Each error constructor gets its own Error object as a prototype,
with the 'name' property set to the name of the error.
*/
for (int i = 0; i < errorMethods.length; i++) {
String name = errorMethods[i];
Scriptable errorProto = ScriptRuntime.newObject(cx, scope, "Error", ScriptRuntime.emptyArgs);
errorProto.put("name", errorProto, name);
if (sealed) {
if (errorProto instanceof ScriptableObject) {
((ScriptableObject) errorProto).sealObject();
}
}
IdFunctionObject ctor = new IdFunctionObject(obj, FTAG, Id_new_CommonError, name, 1, scope);
ctor.markAsConstructor(errorProto);
if (sealed) {
ctor.sealObject();
}
ctor.exportAsScopeProperty();
}
}
