protected NumberObject(ScriptObject parent, Object value)
   : base(parent) {
   this.baseType = value.GetType();
   this.value = value;
   this.noExpando = false;
   this.implicitWrapper = false;
 }

 internal FunctionScope(ScriptObject parent, bool isMethod) : base(parent)
 {
     base.isKnownAtCompileTime = true;
     this.isMethod = isMethod;
     this.mustSaveStackLocals = false;
     if ((parent != null) && (parent is ActivationObject))
     {
         base.fast = ((ActivationObject) parent).fast;
     }
     else
     {
         base.fast = false;
     }
     this.returnVar = null;
     this.owner = null;
     this.isStatic = false;
     this.nested_functions = null;
     this.fields_for_nested_functions = null;
     if (parent is FunctionScope)
     {
         this.ProvidesOuterScopeLocals = new SimpleHashtable(0x10);
     }
     else
     {
         this.ProvidesOuterScopeLocals = null;
     }
     this.closuresMightEscape = false;
 }

	// Constructor.
	public BuiltinFunction(ScriptObject prototype, String name,
						   MethodInfo method)
			: base(prototype, name)
			{
				this.method = method;
				Object[] attrs = method.GetCustomAttributes
						(typeof(JSFunctionAttribute), false);
				if(attrs == null || attrs.Length == 0)
				{
					this.flags = (JSFunctionAttributeEnum)0;
				}
				else
				{
					this.flags = ((JSFunctionAttribute)(attrs[0]))
							.GetAttributeValue();
				}
				requiredParameters = method.GetParameters().Length;
				lengthValue = requiredParameters;
				if((flags & JSFunctionAttributeEnum.HasThisObject) != 0)
				{
					--lengthValue;
				}
				if((flags & JSFunctionAttributeEnum.HasEngine) != 0)
				{
					--lengthValue;
				}
				if((flags & JSFunctionAttributeEnum.HasVarArgs) != 0)
				{
					--lengthValue;
				}
			}

 private void AddNameTo(ScriptObject enclosingScope)
 {
     while (enclosingScope is WithObject)
     {
         enclosingScope = enclosingScope.GetParent();
     }
     if (((IActivationObject) enclosingScope).GetLocalField(this.name) == null)
     {
         FieldInfo info;
         if (enclosingScope is ActivationObject)
         {
             if (enclosingScope is FunctionScope)
             {
                 info = ((ActivationObject) enclosingScope).AddNewField(this.name, null, FieldAttributes.Public);
             }
             else
             {
                 info = ((ActivationObject) enclosingScope).AddNewField(this.name, null, FieldAttributes.Static | FieldAttributes.Public);
             }
         }
         else
         {
             info = ((StackFrame) enclosingScope).AddNewField(this.name, null, FieldAttributes.Public);
         }
         JSLocalField field = info as JSLocalField;
         if (field != null)
         {
             field.debugOn = base.context.document.debugOn;
             field.isDefined = true;
         }
         this.field = (JSVariableField) info;
     }
 }

	// Constructor.
	internal FunctionObject(FunctionPrototype parent, JFunction defn,
							ScriptObject declaringScope)
			: base(parent, defn.name, Support.ExprListLength(defn.fparams))
			{
				this.defn = defn;
				this.declaringScope = declaringScope;
			}

 internal LenientErrorPrototype(LenientFunctionPrototype funcprot, ScriptObject parent, string name) : base(parent, name)
 {
     base.noExpando = false;
     this.name = name;
     Type type = typeof(ErrorPrototype);
     this.toString = new BuiltinFunction("toString", this, type.GetMethod("toString"), funcprot);
 }

 public PackageScope(ScriptObject parent)
   : base(parent) {
   this.fast = true;
   this.name = null;
   this.owner = null;
   this.isKnownAtCompileTime = true;
 }

 public BlockScope(ScriptObject parent, String name, int scopeId)
   : base(parent){
   this.scopeId = scopeId;
   JSField field = (JSField)this.parent.GetField(name+":"+this.scopeId, BindingFlags.Public);
   this.name_table[name] = field;
   this.field_table.Add(field);
 }

 internal ArrayObject(ScriptObject prototype, Type subType)
   : base(prototype, subType) {
   this.len = 0;
   this.denseArray = null;
   this.denseArrayLength = 0;
   this.noExpando = false;
 }

 internal NumberObject(ScriptObject parent, object value, bool implicitWrapper) : base(parent, typeof(NumberObject))
 {
     this.baseType = Globals.TypeRefs.ToReferenceContext(value.GetType());
     this.value = value;
     base.noExpando = implicitWrapper;
     this.implicitWrapper = implicitWrapper;
 }

 internal DateObject(ScriptObject parent, double value)
   : base(parent) {
   this.value = value != value || value > Int64.MaxValue || value < Int64.MinValue
     ? Double.NaN
     : System.Math.Round(value);
   this.noExpando = false;
 }

 internal WithObject(ScriptObject parent, Object contained_object, bool isSuperType)
   : base(parent) {
   this.contained_object = contained_object;
   this.isKnownAtCompileTime = contained_object is Type ||
                              (contained_object is ClassScope && ((ClassScope)contained_object).noExpando) ||
                              (contained_object is JSObject && ((JSObject)contained_object).noExpando);
   this.isSuperType = isSuperType;
 }

 internal LenientErrorPrototype(LenientFunctionPrototype funcprot, ScriptObject parent, String name)
   : base(parent, name) {
   this.noExpando = false;
   //this.constructor is given a value by the constructor class
   this.name = name;
   Type super = typeof(ErrorPrototype);
   this.toString = new BuiltinFunction("toString", this, super.GetMethod("toString"), funcprot);
 }

 internal VsaNamedItemScope(Object hostObject, ScriptObject parent, VsaEngine engine)
   : base(parent){
   this.namedItem = hostObject;
   if ((this.reflectObj = hostObject as IReflect) == null)
     this.reflectObj = hostObject.GetType();
   this.recursive = false;
   this.engine = engine;
 }

 internal LenientFunctionPrototype(ScriptObject parent) : base(parent)
 {
     base.noExpando = false;
     Type type = typeof(FunctionPrototype);
     this.apply = new BuiltinFunction("apply", this, type.GetMethod("apply"), this);
     this.call = new BuiltinFunction("call", this, type.GetMethod("call"), this);
     this.toString = new BuiltinFunction("toString", this, type.GetMethod("toString"), this);
 }

      public VsaEngine engine; //This is only really useful for ScriptFunctions, IActivation objects and prototype objects. It lives here for the sake of simplicity.
      //Prototype objects do not need the scope stack, so in fast mode, all prototype objects can share a common engine.

      internal ScriptObject(ScriptObject parent){
        this.parent = parent;
        this.wrappedMemberCache = null;
        if (this.parent != null)
          this.engine = parent.engine;
        else
          this.engine = null;
      }

 internal LenientFunctionPrototype(ScriptObject parent)
   : base(parent) {
   this.noExpando = false;
   //this.constructor is given a value by ObjectConstructor
   Type super = typeof(FunctionPrototype);
   this.apply = new BuiltinFunction("apply", this, super.GetMethod("apply"), this);
   this.call = new BuiltinFunction("call", this, super.GetMethod("call"), this);
   this.toString = new BuiltinFunction("toString", this, super.GetMethod("toString"), this);
 }

 internal ArgumentsObject(ScriptObject parent, Object[] arguments, FunctionObject function, Closure callee, ScriptObject scope, ArgumentsObject caller)
   : base(parent) {
   this.arguments = arguments;
   this.formal_names = function.formal_parameters;
   this.scope = scope;
   this.callee = callee;
   this.caller = caller;
   this.length = arguments.Length;
   this.noExpando = false;
 }

 internal ArrayWrapper(ScriptObject prototype, Array value, bool implicitWrapper)
   : base(prototype, typeof(ArrayWrapper)) {
   this.value = value;
   this.implicitWrapper = implicitWrapper;
   if (value != null){
     if (value.Rank != 1)
       throw new JScriptException(JSError.TypeMismatch);
     this.len = (uint) value.Length;
   }else
     this.len = 0;
 }

 static internal ClassScope ScopeOfClassMemberInitializer(ScriptObject scope) {
   while (scope != null) {
     if (scope is FunctionScope)
       return null;
     ClassScope cscope = scope as ClassScope;
     if (cscope != null)
       return cscope;
     scope = scope.GetParent();
   }
   return null;
 }