internal BuiltinCall(BuiltinFunction function, IScriptable scope, object [] args)
        {
            this.function = function;

            ParentScope = scope;
            // leave prototype null

            this.originalArgs = (args == null) ? ScriptRuntime.EmptyArgs : args;

            // initialize values of arguments
            int paramAndVarCount = function.ParamAndVarCount;
            int paramCount = function.ParamCount;
            if (paramAndVarCount != 0) {
                for (int i = 0; i != paramCount; ++i) {
                    string name = function.getParamOrVarName (i);
                    object val = i < args.Length ? args [i] : Undefined.Value;
                    DefineProperty (name, val, PERMANENT);
                }
            }

            // initialize "arguments" property but only if it was not overriden by
            // the parameter with the same name
            if (!base.Has ("arguments", this)) {
                DefineProperty ("arguments", new Arguments (this), PERMANENT);
            }

            if (paramAndVarCount != 0) {
                for (int i = paramCount; i != paramAndVarCount; ++i) {
                    string name = function.getParamOrVarName (i);
                    if (!base.Has (name, this)) {
                        DefineProperty (name, Undefined.Value, PERMANENT);
                    }
                }
            }
        }

 public override object Call (Context cx, IScriptable scope, IScriptable thisObj, object [] args)
 {
     if (script != null) {
         return script.Exec (cx, scope);
     }
     return Undefined.Value;
 }

 public static IScriptable ToObject (IScriptable scope, object val)
 {
     if (val is IScriptable) {
         return (IScriptable)val;
     }
     return ToObject (null, scope, val);
 }

        public override object ExecIdCall(IdFunctionObject f, Context cx, IScriptable scope, IScriptable thisObj, object [] args)
        {
            if (!f.HasTag (BOOLEAN_TAG)) {
                return base.ExecIdCall (f, cx, scope, thisObj, args);
            }
            int id = f.MethodId;

            if (id == Id_constructor) {
                bool b = ScriptConvert.ToBoolean (args, 0);
                if (thisObj == null) {
                    return new BuiltinBoolean (b);
                }
                return b;
            }

            // The rest of Boolean.prototype methods require thisObj to be Boolean

            if (!(thisObj is BuiltinBoolean))
                throw IncompatibleCallError (f);
            bool value = ((BuiltinBoolean)thisObj).booleanValue;

            switch (id) {

                case Id_toString:
                    return value ? "true" : "false";

                case Id_toSource:
                    return value ? "(new Boolean(true))" : "(new Boolean(false))";

                case Id_valueOf:
                    return value;
            }
            throw new ArgumentException (Convert.ToString (id));
        }

 public static void ImportTypes(IScriptable scope, string startsWith)
 {
     foreach (Assembly ass in Context.CurrentContext.AppDomain.GetAssemblies())
     {
         ImportAssembly(scope, ass, startsWith);
     }
 }

 public static void ImportAssembly(IScriptable scope, Assembly ass, string startsWith)
 {
     foreach (Type type in ass.GetTypes ()) {
         if (startsWith == null || type.FullName.StartsWith (startsWith))
             ImportType (scope, type);
     }
 }

 public override object Put (string id, IScriptable start, object value)
 {
     // Ignore assignments to "length"--it's readonly.
     if (!id.Equals ("length"))
         return base.Put (id, start, value);
     return Undefined.Value;
 }

 internal static void Init
     (IScriptable scope, bool zealed)
 {
     BuiltinString obj = new BuiltinString ("");
     obj.ExportAsJSClass (MAX_PROTOTYPE_ID, scope, zealed, 
         ScriptableObject.DONTENUM | ScriptableObject.READONLY | ScriptableObject.PERMANENT);
 }

 public override object Call (Context cx, IScriptable scope, IScriptable thisObj, object [] args)
 {
     if (args.Length > 0 && args [0] is BuiltinRegExp && (args.Length == 1 || args [1] == Undefined.Value)) {
         return args [0];
     }
     return Construct (cx, scope, args);
 }

 public override IScriptable Construct (Context cx, IScriptable scope, object [] args)
 {
     BuiltinRegExp re = new BuiltinRegExp ();
     re.compile (cx, scope, args);
     ScriptRuntime.setObjectProtoAndParent (re, scope);
     return re;
 }

        public override System.Object ExecIdCall(IdFunctionObject f, Context cx, IScriptable scope, IScriptable thisObj, System.Object [] args)
        {
            if (!f.HasTag (XMLCTOR_TAG)) {
                return base.ExecIdCall (f, cx, scope, thisObj, args);
            }
            int id = f.MethodId;
            switch (id) {

                case Id_defaultSettings: {
                        lib.SetDefaultSettings ();
                        IScriptable obj = cx.NewObject (scope);
                        WriteSetting (obj);
                        return obj;
                    }

                case Id_settings: {
                        IScriptable obj = cx.NewObject (scope);
                        WriteSetting (obj);
                        return obj;
                    }

                case Id_setSettings: {
                        if (args.Length == 0 || args [0] == null || args [0] == Undefined.Value) {
                            lib.SetDefaultSettings ();
                        }
                        else if (args [0] is IScriptable) {
                            ReadSettings ((IScriptable)args [0]);
                        }
                        return Undefined.Value;
                    }
            }
            throw new System.ArgumentException (System.Convert.ToString (id));
        }

        public PythonEngine(IScriptable callback)
        {
            _callback = callback;
            _scriptHandler = new ScriptHandler(_callback);

            _engines.Add(callback, this);
        }

        public override object ExecIdCall(IdFunctionObject f, Context cx, IScriptable scope, IScriptable thisObj, object [] args)
        {
            int id = f.MethodId;
            switch (id) {
                case Id_print:
                    for (int i = 0; i < args.Length; i++) {
                        if (i > 0)
                            Console.Out.Write (" ");
                        Console.Out.Write (ScriptConvert.ToString (args [i]));
                    }
                    Console.Out.WriteLine ();
                    return Undefined.Value;

                case Id_version:
                    if (args.Length > 0) {
                        if (CliHelper.IsNumber (args [0])) {
                            int newVer = (int)ScriptConvert.ToNumber (args [0]);
                            if (Context.IsValidLanguageVersion (newVer)) {
                                cx.Version = Context.ToValidLanguageVersion (newVer);
                            }
                        }
                    }
                    return (int)cx.Version;
                case Id_options:
                    StringBuilder sb = new StringBuilder ();
                    if (cx.HasFeature (Context.Features.Strict))
                        sb.Append ("strict");
                    return sb.ToString ();
                case Id_gc:
                    GC.Collect ();
                    return Undefined.Value;
            }
            throw f.Unknown ();
        }

 public override object Put (int index, IScriptable start, object value)
 {
     if (0 <= index && index < length) {
         ((System.Array)array).SetValue (Context.JsToCli (value, cls), index);
         return value;
     }
     return base.Put (index, start, value);
 }

 public override object Get (int index, IScriptable start)
 {
     if (0 <= index && index < length) {
         object obj = ((System.Array)array).GetValue (index);
         return Context.CurrentContext.Wrap (this, obj, cls);
     }
     return Undefined.Value;
 }

 internal static void Init (IScriptable scope, bool zealed)
 {
     BuiltinDate obj = new BuiltinDate ();
     // Set the value of the prototype Date to NaN ('invalid date');
     obj.date = double.NaN;
     obj.ExportAsJSClass (MAX_PROTOTYPE_ID, scope, zealed
         , ScriptableObject.DONTENUM | ScriptableObject.READONLY | ScriptableObject.PERMANENT);
 }

        public virtual object Perform (Context cx, IScriptable scope, IScriptable thisObj, object [] args, RegExpActions actionType)
        {
            GlobData data = new GlobData ();
            data.mode = actionType;

            switch ( (RegExpActions)actionType) {

                case EcmaScript.NET.RegExpActions.Match: {
                        object rval;
                        data.optarg = 1;
                        rval = matchOrReplace (cx, scope, thisObj, args, this, data, false);
                        return data.arrayobj == null ? rval : data.arrayobj;
                    }


                case EcmaScript.NET.RegExpActions.Search:
                    data.optarg = 1;
                    return matchOrReplace (cx, scope, thisObj, args, this, data, false);


                case EcmaScript.NET.RegExpActions.Replace: {
                        object arg1 = args.Length < 2 ? Undefined.Value : args [1];
                        string repstr = null;
                        IFunction lambda = null;
                        if (arg1 is IFunction) {
                            lambda = (IFunction)arg1;
                        }
                        else {
                            repstr = ScriptConvert.ToString (arg1);
                        }

                        data.optarg = 2;
                        data.lambda = lambda;
                        data.repstr = repstr;
                        data.dollar = repstr == null ? -1 : repstr.IndexOf ((char)'$');
                        data.charBuf = null;
                        data.leftIndex = 0;
                        object val = matchOrReplace (cx, scope, thisObj, args, this, data, true);
                        SubString rc = this.rightContext;

                        if (data.charBuf == null) {
                            if (data.global || val == null || !val.Equals (true)) {
                                /* Didn't match even once. */
                                return data.str;
                            }
                            SubString lc = this.leftContext;
                            replace_glob (data, cx, scope, this, lc.index, lc.length);
                        }
                        data.charBuf.Append (rc.charArray, rc.index, rc.length);
                        return data.charBuf.ToString ();
                    }


                default:
                    throw Context.CodeBug ();

            }
        }

 public override bool Has (int index, IScriptable start)
 {
     if (0 <= index && index < args.Length) {
         if (args [index] != UniqueTag.NotFound) {
             return true;
         }
     }
     return base.Has (index, start);
 }

 public virtual void InitFunction (string name, IScriptable scope)
 {
     if (name == null)
         throw new ArgumentException ();
     if (scope == null)
         throw new ArgumentException ();
     this.functionName = name;
     ParentScope = scope;
 }

        public static void Init (IScriptable scope)
        {
            CliPackage obj = new CliPackage ();

            ScriptableObject.DefineProperty (scope,
                "cli", obj, ScriptableObject.DONTENUM);

            obj.ParentScope = scope;
        }