internal VsaItem(VsaEngine engine, string name, VsaItemType type, VsaItemFlag flag)
 {
     this.engine = engine;
     this.name = name;
     this.type = type;
     this.flag = flag;
 }

	// Perform a late binding call, with reversed arguments.
	public static Object CallValue2(Object val, Object thisob,
								    Object[] arguments, bool construct,
								    bool brackets, VsaEngine engine)
			{
				// TODO
				return null;
			}

 internal FunctionObject(Type t, string name, string method_name, string[] formal_parameters, JSLocalField[] fields, bool must_save_stack_locals, bool hasArgumentsObject, string text, VsaEngine engine) : base(engine.Globals.globalObject.originalFunction.originalPrototype, name, formal_parameters.Length)
 {
     base.engine = engine;
     this.formal_parameters = formal_parameters;
     this.argumentsSlotNumber = 0;
     this.body = null;
     this.method = TypeReflector.GetTypeReflectorFor(Globals.TypeRefs.ToReferenceContext(t)).GetMethod(method_name, BindingFlags.Public | BindingFlags.Static);
     this.parameterInfos = this.method.GetParameters();
     if (!Microsoft.JScript.CustomAttribute.IsDefined(this.method, typeof(JSFunctionAttribute), false))
     {
         this.isMethod = true;
     }
     else
     {
         JSFunctionAttributeEnum attributeValue = ((JSFunctionAttribute) Microsoft.JScript.CustomAttribute.GetCustomAttributes(this.method, typeof(JSFunctionAttribute), false)[0]).attributeValue;
         this.isExpandoMethod = (attributeValue & JSFunctionAttributeEnum.IsExpandoMethod) != JSFunctionAttributeEnum.None;
     }
     this.funcContext = null;
     this.own_scope = null;
     this.fields = fields;
     this.must_save_stack_locals = must_save_stack_locals;
     this.hasArgumentsObject = hasArgumentsObject;
     this.text = text;
     this.attributes = MethodAttributes.Public;
     this.globals = engine.Globals;
     this.superConstructor = null;
     this.superConstructorCall = null;
     this.enclosing_scope = this.globals.ScopeStack.Peek();
     base.noExpando = false;
     this.clsCompliance = CLSComplianceSpec.NotAttributed;
 }

 public static ArrayObject concat(object thisob, VsaEngine engine, params object[] args)
 {
     ArrayObject obj2 = engine.GetOriginalArrayConstructor().Construct();
     if (thisob is ArrayObject)
     {
         obj2.Concat((ArrayObject) thisob);
     }
     else
     {
         obj2.Concat(thisob);
     }
     for (int i = 0; i < args.Length; i++)
     {
         object obj3 = args[i];
         if (obj3 is ArrayObject)
         {
             obj2.Concat((ArrayObject) obj3);
         }
         else
         {
             obj2.Concat(obj3);
         }
     }
     return obj2;
 }

 		public void OnEngineClosed ()
		{
			VsaEngine engine = new VsaEngine ();
			IVsaItems items;
			IVsaItem item;

			engine = new VsaEngine ();
			engine.RootMoniker = "com.foo://path/to/nowhere";
			engine.Site = new Site ();

			engine.InitNew ();
			items = engine.Items;
			engine.Close ();
		
			int size;

			try {
				size = items.Count;
			} catch (VsaException e) {
				Assert.AreEqual (VsaError.EngineClosed, e.ErrorCode, "#1");
			}

			try {
				item = items.CreateItem ("itemx", VsaItemType.Code, 
							 VsaItemFlag.Class);
			} catch (VsaException e) {
				Assert.AreEqual (VsaError.EngineClosed, e.ErrorCode, "#2");
			}
		}

        public static object CallValue(object thisObj, object val, object [] arguments,
            bool construct, bool brackets, VsaEngine engine)
        {
            if (construct) {
                if (brackets) {
                }

                if (val is Closure)
                    return ((Closure) val).func.CreateInstance (arguments);
                else if (val is FunctionObject)
                    return ((FunctionObject) val).CreateInstance (arguments);
            } else if (brackets) {
                object first_arg = arguments.Length > 0 ? arguments [0] : null;
                return GetObjectProperty ((ScriptObject) Convert.ToObject (val, engine), Convert.ToString (first_arg));
            } else {
                if (val is Closure)
                    return ((Closure) val).func.Invoke (thisObj, arguments);
                else if (val is FunctionObject)
                    return ((FunctionObject) val).Invoke (thisObj, arguments);
                else if (val is RegExpObject) {
                    object first_arg = arguments.Length > 0 ? arguments [0] : null;
                    return RegExpPrototype.exec (val, first_arg);
                } else
                    return null;
            }

            Console.WriteLine ("CallValue: construct = {0}, brackets = {1}, this = {2}, val = {3} ({4}), arg[0] = {5}",
                construct, brackets, thisObj.GetType (), val, val.GetType (), arguments [0]);
            throw new NotImplementedException ();
        }

 private void AddDefinition(string def, Hashtable definitions, VsaEngine engine){
   int equalsIndex = def.IndexOf("=");
   string key;
   string strValue;
   object value = null;
   if (equalsIndex == -1){
     key = def.Trim();
     value = true;
   }else{
     key = def.Substring(0, equalsIndex).Trim();
     strValue = def.Substring(equalsIndex + 1).Trim();
     if (String.Compare(strValue, "true", StringComparison.OrdinalIgnoreCase) == 0)
       value = true;
     else if (String.Compare(strValue, "false", StringComparison.OrdinalIgnoreCase) == 0)
       value = false;
     else{
       try{
         value = Int32.Parse(strValue, CultureInfo.InvariantCulture);
       }catch{
         throw new CmdLineException(CmdLineError.InvalidDefinition, key, engine.ErrorCultureInfo);
       }
     }
   }
   if (key.Length == 0)
     throw new CmdLineException(CmdLineError.MissingDefineArgument, engine.ErrorCultureInfo);
   definitions[key] = value;
 }

 internal ScriptFunction Construct(object[] args, VsaEngine engine)
 {
     ScriptFunction function;
     StringBuilder builder = new StringBuilder("function anonymous(");
     int index = 0;
     int num2 = args.Length - 2;
     while (index < num2)
     {
         builder.Append(Microsoft.JScript.Convert.ToString(args[index]));
         builder.Append(", ");
         index++;
     }
     if (args.Length > 1)
     {
         builder.Append(Microsoft.JScript.Convert.ToString(args[args.Length - 2]));
     }
     builder.Append(") {\n");
     if (args.Length > 0)
     {
         builder.Append(Microsoft.JScript.Convert.ToString(args[args.Length - 1]));
     }
     builder.Append("\n}");
     Context context = new Context(new DocumentContext("anonymous", engine), builder.ToString());
     JSParser parser = new JSParser(context);
     engine.PushScriptObject(((IActivationObject) engine.ScriptObjectStackTop()).GetGlobalScope());
     try
     {
         function = (ScriptFunction) parser.ParseFunctionExpression().PartiallyEvaluate().Evaluate();
     }
     finally
     {
         engine.PopScriptObject();
     }
     return function;
 }

 internal GlobalScope(GlobalScope parent, VsaEngine engine, bool isComponentScope) : base(parent)
 {
     this.componentScopes = null;
     this.recursive = false;
     this.isComponentScope = isComponentScope;
     if (parent == null)
     {
         this.globalObject = engine.Globals.globalObject;
         this.globalObjectTR = TypeReflector.GetTypeReflectorFor(Globals.TypeRefs.ToReferenceContext(this.globalObject.GetType()));
         base.fast = !(this.globalObject is LenientGlobalObject);
     }
     else
     {
         this.globalObject = null;
         this.globalObjectTR = null;
         base.fast = parent.fast;
         if (isComponentScope)
         {
             ((GlobalScope) base.parent).AddComponentScope(this);
         }
     }
     base.engine = engine;
     base.isKnownAtCompileTime = base.fast;
     this.evilScript = true;
     this.thisObject = this;
     this.typeReflector = TypeReflector.GetTypeReflectorFor(Globals.TypeRefs.ToReferenceContext(base.GetType()));
     if (isComponentScope)
     {
         engine.Scopes.Add(this);
     }
 }

 private void AddSourceFile(VsaEngine engine, string filename)
 {
     string name = "$SourceFile_" + this.codeItemCounter++;
     IJSVsaCodeItem item = (IJSVsaCodeItem) engine.Items.CreateItem(name, JSVsaItemType.Code, JSVsaItemFlag.None);
     item.SetOption("codebase", filename);
     item.SourceText = this.ReadFile(filename, engine);
 }

        public static ArrayObject concat(object thisObj, VsaEngine engine,
            params object [] args)
        {
            uint i = 0;
            ArrayObject result = new ArrayObject ();
            int arg_idx = -1;
            int arg_count = args.Length;

            // TODO: Shouldn't this be generic!?
            SemanticAnalyser.assert_type (thisObj, typeof (ArrayObject));
            object cur_obj = thisObj;

            ArrayObject cur_ary;
            while (cur_obj != null) {
                if (cur_obj is ArrayObject) {
                    cur_ary = (ArrayObject) cur_obj;

                    uint n = (uint) cur_ary.length;
                    for (uint j = 0; j < n; j++, i++)
                        result.elems [i] = cur_ary.elems [j];
                } else
                    result.elems [i++] = cur_obj;

                arg_idx++;
                cur_obj = arg_idx < arg_count ? args [arg_idx] : null;
            }

            result.length = i;

            return result;
        }

	// Constructor.
	public EngineInstance(VsaEngine engine)
			{
				// Initialize the local state.
				this.engine = engine;
				this.outStream = null;
				this.errorStream = null;
			}

 internal VsaScriptScope(VsaEngine engine, string itemName, VsaScriptScope parent) 
   : base(engine, itemName, (VsaItemType)(int)VSAITEMTYPE2.SCRIPTSCOPE, VsaItemFlag.None){ 
   this.parent = parent;
   this.scope = null;
   this.items = new ArrayList(8);
   this.isCompiled = false;
   this.isClosed = false;
 }

 internal VsaScriptScope(VsaEngine engine, string itemName, VsaScriptScope parent) : base(engine, itemName, (JSVsaItemType) 0x13, JSVsaItemFlag.None)
 {
     this.parent = parent;
     this.scope = null;
     this.items = new ArrayList(8);
     this.isCompiled = false;
     this.isClosed = false;
 }

 internal VsaItem(VsaEngine engine, string itemName, VsaItemType type, VsaItemFlag flag){ 
   this.engine = engine;
   this.type = type;
   this.name = itemName;
   this.flag = flag;
   this.codebase = null;
   this.isDirty = true;
 }

 VsaEngine INeedEngine.GetEngine()
 {
     if (this.vsaEngine == null)
     {
         this.vsaEngine = VsaEngine.CreateEngineWithType(typeof(Playground.JSEvaluator.Evaluator).TypeHandle);
     }
     return this.vsaEngine;
 }

 public static Object JScriptWith(Object withOb, VsaEngine engine){
   Object ob = Convert.ToObject(withOb, engine);
   if (ob == null)
     throw new JScriptException(JSError.ObjectExpected);
   Globals glob = engine.Globals;
   glob.ScopeStack.GuardedPush(new WithObject(glob.ScopeStack.Peek(), ob));
   return ob;
 }

      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 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 WrappedNamespace(String name, VsaEngine engine, bool AddReferences)
   : base(null) {
   this.name = name;
   this.engine = engine;
   this.isKnownAtCompileTime = true;
   if (name.Length > 0 && AddReferences)
     engine.TryToAddImplicitAssemblyReference(name);
 }