public static ScriptableObject InitStandardObjects (Context cx, ScriptableObject scope, bool zealed)
{
if (scope == null) {
scope = new BuiltinObject ();
}
scope.AssociateValue (LIBRARY_SCOPE_KEY, scope);
BaseFunction.Init (scope, zealed);
BuiltinObject.Init (scope, zealed);
IScriptable objectProto = ScriptableObject.GetObjectPrototype (scope);
// Function.prototype.__proto__ should be Object.prototype
IScriptable functionProto = ScriptableObject.GetFunctionPrototype (scope);
functionProto.SetPrototype (objectProto);
// Set the prototype of the object passed in if need be
if (scope.GetPrototype () == null)
scope.SetPrototype (objectProto);
// must precede NativeGlobal since it's needed therein
BuiltinError.Init (scope, zealed);
BuiltinGlobal.Init (cx, scope, zealed);
if (scope is BuiltinGlobalObject) {
((BuiltinGlobalObject)scope).Init (scope, zealed);
}
BuiltinArray.Init (scope, zealed);
BuiltinString.Init (scope, zealed);
BuiltinBoolean.Init (scope, zealed);
BuiltinNumber.Init (scope, zealed);
BuiltinDate.Init (scope, zealed);
BuiltinMath.Init (scope, zealed);
BuiltinWith.Init (scope, zealed);
BuiltinCall.Init (scope, zealed);
BuiltinScript.Init (scope, zealed);
BuiltinRegExp.Init (scope, zealed);
if (cx.HasFeature (Context.Features.E4x)) {
Types.E4X.XMLLib.Init (scope, zealed);
}
Continuation.Init (scope, zealed);
if (cx.HasFeature (Context.Features.NonEcmaItObject)) {
InitItObject (cx, scope);
}
return scope;
}
/// <summary> Initialize the standard objects.
///
/// Creates instances of the standard objects and their constructors
/// (Object, String, Number, Date, etc.), setting up 'scope' to act
/// as a global object as in ECMA 15.1.<p>
///
/// This method must be called to initialize a scope before scripts
/// can be evaluated in that scope.<p>
///
/// This method does not affect the Context it is called upon.<p>
///
/// This form of the method also allows for creating "sealed" standard
/// objects. An object that is sealed cannot have properties added, changed,
/// or removed. This is useful to create a "superglobal" that can be shared
/// among several top-level objects. Note that sealing is not allowed in
/// the current ECMA/ISO language specification, but is likely for
/// the next version.
///
/// </summary>
/// <param name="scope">the scope to initialize, or null, in which case a new
/// object will be created to serve as the scope
/// </param>
/// <param name="sealed">whether or not to create sealed standard objects that
/// cannot be modified.
/// </param>
/// <returns> the initialized scope. The method returns the value of the scope
/// argument if it is not null or newly allocated scope object.
/// </returns>
public ScriptableObject InitStandardObjects(ScriptableObject scope, bool zealed)
{
return ScriptRuntime.InitStandardObjects (this, scope, zealed);
}
/// <summary> Initialize the standard objects.
///
/// Creates instances of the standard objects and their constructors
/// (Object, String, Number, Date, etc.), setting up 'scope' to act
/// as a global object as in ECMA 15.1.<p>
///
/// This method must be called to initialize a scope before scripts
/// can be evaluated in that scope.<p>
///
/// This method does not affect the Context it is called upon.
///
/// </summary>
/// <param name="scope">the scope to initialize, or null, in which case a new
/// object will be created to serve as the scope
/// </param>
/// <returns> the initialized scope. The method returns the value of the scope
/// argument if it is not null or newly allocated scope object which
/// is an instance {@link ScriptableObject}.
/// </returns>
public IScriptable InitStandardObjects(ScriptableObject scope)
{
return InitStandardObjects (scope, false);
}
static void InitItObject(Context cx, ScriptableObject scope)
{
BuiltinObject itObj = new BuiltinObject ();
itObj.SetPrototype (scope);
itObj.DefineProperty ("color", Undefined.Value, ScriptableObject.PERMANENT);
itObj.DefineProperty ("height", Undefined.Value, ScriptableObject.PERMANENT);
itObj.DefineProperty ("width", Undefined.Value, ScriptableObject.PERMANENT);
itObj.DefineProperty ("funny", Undefined.Value, ScriptableObject.PERMANENT);
itObj.DefineProperty ("array", Undefined.Value, ScriptableObject.PERMANENT);
itObj.DefineProperty ("rdonly", Undefined.Value, ScriptableObject.READONLY);
scope.DefineProperty ("it", itObj, ScriptableObject.PERMANENT);
}
public static void setObjectProtoAndParent(ScriptableObject obj, IScriptable scope)
{
// Compared with function it always sets the scope to top scope
scope = ScriptableObject.GetTopLevelScope (scope);
obj.ParentScope = scope;
IScriptable proto = ScriptableObject.getClassPrototype (scope, obj.ClassName);
obj.SetPrototype (proto);
}