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 bool Delete(Context cx)
 {
     if (type == Types.None) {
         return ScriptRuntime.deleteObjectElem (target, name, cx);
     }
     return false;
 }

 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);
 }

 // neg:
 // implement the '-' operator inline in the caller
 // as "-ScriptConvert.ToNumber(val)"
 // not:
 // implement the '!' operator inline in the caller
 // as "!toBoolean(val)"
 // bitnot:
 // implement the '~' operator inline in the caller
 // as "~toInt32(val)"
 public static object Add(object val1, object val2, Context cx)
 {
     if (CliHelper.IsNumber (val1) && CliHelper.IsNumber (val2)) {
         return (double)val1 + (double)val2;
     }
     if (val1 is XMLObject) {
         object test = ((XMLObject)val1).AddValues (cx, true, val2);
         if (test != UniqueTag.NotFound) {
             return test;
         }
     }
     if (val2 is XMLObject) {
         object test = ((XMLObject)val2).AddValues (cx, false, val1);
         if (test != UniqueTag.NotFound) {
             return test;
         }
     }
     if (val1 is EcmaScript.NET.Types.Cli.CliEventInfo) {
         return ((EcmaScript.NET.Types.Cli.CliEventInfo)val1).Add (val2, cx);
     }
     if (val1 is IScriptable)
         val1 = ((IScriptable)val1).GetDefaultValue (null);
     if (val2 is IScriptable)
         val2 = ((IScriptable)val2).GetDefaultValue (null);
     if (!(val1 is string) && !(val2 is string))
         if ((CliHelper.IsNumber (val1)) && (CliHelper.IsNumber (val2)))
             return (double)val1 + (double)val2;
         else
             return ScriptConvert.ToNumber (val1) + ScriptConvert.ToNumber (val2);
     return string.Concat (ScriptConvert.ToString (val1), ScriptConvert.ToString (val2));
 }

        internal static IRef createSpecial (Context cx, object obj, string name)
        {
            IScriptable target = ScriptConvert.ToObjectOrNull (cx, obj);
            if (target == null) {
                throw ScriptRuntime.UndefReadError (obj, name);
            }

            Types type;
            if (name.Equals ("__proto__")) {
                type = Types.Proto;
            }
            else if (name.Equals ("__parent__")) {
                type = Types.Parent;
            }
            else {
                throw new ArgumentException (name);
            }

            if (!cx.HasFeature (Context.Features.ParentProtoProperties)) {
                // Clear special after checking for valid name!
                type = Types.None;
            }

            return new SpecialRef (target, type, name);
        }

 public bool Has(Context cx)
 {
     if (type == Types.None) {
         return ScriptRuntime.hasObjectElem (target, name, cx);
     }
     return true;
 }

        internal InterpreterData(Context.Versions languageVersion, string sourceFile, string encodedSource)
        {
            this.languageVersion = languageVersion;
            this.itsSourceFile = sourceFile;
            this.encodedSource = encodedSource;

            Init ();
        }

        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 static IScriptable ToObjectOrNull (Context cx, object obj)
 {
     if (obj is IScriptable) {
         return (IScriptable)obj;
     }
     else if (obj != null && obj != Undefined.Value) {
         return ToObject (cx, ScriptRuntime.getTopCallScope (cx), obj);
     }
     return null;
 }

        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;
        }

        public IdEnumeration (object value, Context cx, bool enumValues)
        {
            obj = ScriptConvert.ToObjectOrNull (cx, value);
            if (obj != null) {
                // null or undefined do not cause errors but rather lead to empty
                // "for in" loop
                this.enumValues = enumValues;

                // enumInit should read all initial ids before returning
                // or "for (a.i in a)" would wrongly enumerate i in a as well
                ChangeObject ();
            }
        }

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

                case Id_constructor:
                    throw Context.ReportRuntimeError ("Direct call is not supported");
            }
            throw new ArgumentException (Convert.ToString (id));
        }

        public virtual void initFromContext (Context cx)
        {
            setErrorReporter (cx.ErrorReporter);
            this.languageVersion = cx.Version;
            useDynamicScope = cx.compileFunctionsWithDynamicScopeFlag;
            generateDebugInfo = (!cx.GeneratingDebugChanged || cx.GeneratingDebug);
            reservedKeywordAsIdentifier = cx.HasFeature (Context.Features.ReservedKeywordAsIdentifier);
            allowMemberExprAsFunctionName = cx.HasFeature (Context.Features.MemberExprAsFunctionName);
            xmlAvailable = cx.HasFeature (Context.Features.E4x);
            getterAndSetterSupport = cx.HasFeature (Context.Features.GetterAndSetter);

            optimizationLevel = cx.OptimizationLevel;

            generatingSource = cx.GeneratingSource;
            activationNames = cx.activationNames;
        }

        public object Get (Context cx)
        {
            switch (type) {

                case Types.None:
                    return ScriptRuntime.getObjectProp (target, name, cx);

                case Types.Proto:
                    return target.GetPrototype ();

                case Types.Parent:
                    return target.ParentScope;

                default:
                    throw Context.CodeBug ();

            }
        }

        public virtual object Current(Context cx)
        {
            if (!enumValues)
                return currentId;

            object result;

            string s = ScriptRuntime.ToStringIdOrIndex (cx, currentId);
            if (s == null) {
                int index = ScriptRuntime.lastIndexResult (cx);
                result = obj.Get (index, obj);
            }
            else {
                result = obj.Get (s, obj);
            }

            return result;
        }

        public object Set (Context cx, object value)
        {
            switch (type) {

                case Types.None:
                    return ScriptRuntime.setObjectProp (target, name, value, cx);

                case Types.Proto:
                case Types.Parent: {
                        IScriptable obj = ScriptConvert.ToObjectOrNull (cx, value);
                        if (obj != null) {
                            // Check that obj does not contain on its prototype/scope
                            // chain to prevent cycles
                            IScriptable search = obj;
                            do {
                                if (search == target) {
                                    throw Context.ReportRuntimeErrorById ("msg.cyclic.value", name);
                                }
                                if (type == Types.Proto) {
                                    search = search.GetPrototype ();
                                }
                                else {
                                    search = search.ParentScope;
                                }
                            }
                            while (search != null);
                        }
                        if (type == Types.Proto) {
                            target.SetPrototype (obj);
                        }
                        else {
                            target.ParentScope = obj;
                        }
                        return obj;
                    }

                default:
                    throw Context.CodeBug ();

            }
        }

        public static Namespace Parse (XMLLib lib, Context cx, Object prefixValue,
            Object uriValue)
        {
            String prefix;
            String uri;

            if (uriValue is QName) {
                QName qname = (QName)uriValue;
                uri = qname.Uri;
                if (uri == null) {
                    uri = qname.ToString ();
                }
            }
            else {
                uri = ScriptConvert.ToString (uriValue);
            }

            if (uri.Length == 0) {
                if (prefixValue == Undefined.Value) {
                    prefix = "";
                }
                else {
                    prefix = ScriptConvert.ToString (prefixValue);
                    if (prefix.Length != 0) {
                        throw ScriptRuntime.TypeError (
                            "Illegal prefix '" + prefix + "' for 'no namespace'.");
                    }
                }
            }
            else if (prefixValue == Undefined.Value) {
                prefix = "";
            }
            else if (!lib.IsXMLName (cx, prefixValue)) {
                prefix = "";
            }
            else {
                prefix = ScriptConvert.ToString (prefixValue);
            }

            return new Namespace (lib, prefix, uri);
        }

        private object jsConstructor (Context cx, bool inNewExpr, object [] args)
        {
            if (!inNewExpr && args.Length == 1) {
                return Namespace.Parse (lib, cx, args [0]);
            }

            if (args.Length == 0) {
                return Namespace.Parse (lib, cx);
            }
            else if (args.Length == 1) {
                return Namespace.Parse (lib, cx, args [0]);
            }
            else {
                return Namespace.Parse (lib, cx, args [0], args [1]);
            }
        }

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

                case Id_constructor:
                    return jsConstructor (cx, (thisObj == null), args);

                case Id_toString:
                    return realThis (thisObj, f).ToString ();

                case Id_toSource:
                    return realThis (thisObj, f).js_toSource ();
            }
            throw new System.ArgumentException (System.Convert.ToString (id));
        }

 /// <summary> Call a method of an object.</summary>
 /// <param name="cx">the Context object associated with the current thread.
 /// </param>
 /// <param name="obj">the JavaScript object
 /// </param>
 /// <param name="methodName">the name of the function property
 /// </param>
 /// <param name="args">the arguments for the call
 /// </param>
 public static object CallMethod (Context cx, IScriptable obj, string methodName, object [] args)
 {
     object funObj = GetProperty (obj, methodName);
     if (!(funObj is IFunction)) {
         throw ScriptRuntime.NotFunctionError (obj, methodName);
     }
     IFunction fun = (IFunction)funObj;
     // TODO: What should be the scope when calling funObj?
     // The following favor scope stored in the object on the assumption
     // that is more useful especially under dynamic scope setup.
     // An alternative is to check for dynamic scope flag
     // and use ScriptableObject.getTopLevelScope(fun) if the flag is not
     // set. But that require access to Context and messy code
     // so for now it is not checked.
     IScriptable scope = ScriptableObject.GetTopLevelScope (obj);
     if (cx != null) {
         return fun.Call (cx, scope, obj, args);
     }
     else {
         return Context.Call (null, fun, scope, obj, args);
     }
 }