netruby/netruby/NETRuby.cs

/*
 Copyright(C) 2001-2002 arton

 Permission is granted for use, copying, modification, distribution,
 and distribution of modified versions of this work as long as the
 above copyright notice is included.
*/

using System;
using System.Diagnostics;
using System.Collections;
using System.IO;
using System.Text;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;
using System.Security;

[assembly: AssemblyTitle("NETRuby")]
[assembly: AssemblyVersion("0.8.*")]
[assembly: AssemblyCopyright("NETRuby - Copyright (C) 2002 arton")]

namespace arton.NETRuby
{
    public class st_table : Hashtable, ICloneable
    {
        public st_table()
        {
        }
        public st_table(Hashtable h) : base(h)
        {
        }
        public bool lookup(string name, out uint id)
        {
            object o = this[name];
            if (o != null)
            {
                id = (uint)o;
                return true;
            }
            id = 0;
            return false;
        }
        public bool lookup(uint id, out string name)
        {
            object o = this[id];
            if (o != null)
            {
                name = (string)o;
                return true;
            }
            name = null;
            return false;
        }
        public bool lookup(uint id, out object o)
        {
            o = this[id];
            return (o != null) ? true : false;
        }
        public bool lookup(object key, out st_table o)
        {
            o = (st_table)this[key];
            return (o != null) ? true : false;
        }
        public bool delete(uint id, out object o)
        {
            lock (SyncRoot)
            {
                bool ret = lookup(id, out o);
                if (ret)
                {
                    Remove(id);
                }
                return ret;
            }
        }
        public override object Clone()
        {
            lock(SyncRoot)
            {
                return new st_table((Hashtable)base.Clone());
            }
        }
    }

    internal class trace_var
    {
        public trace_var()
        {
            removed = false;
            data = null;
            next = null;
        }
        internal bool removed;
        internal delegate void func();
        internal object data;
        internal trace_var next;
    }

    // 
    // hold all global variables in a NetRuby instance
    public class GlobalEntry
    {
        public GlobalEntry(uint i)
        {
            id = i;
            data = null;
            block_trace = false;
            trace = null;
            getMethod = new Getter(undef_getter);
            setMethod = new Setter(undef_setter);
        }
        static private object undef_getter(uint i, GlobalEntry gb, NetRuby rb)
        {
            rb.warning("global variable `" + rb.id2name(i) + "' not initialized");
            return null;
        }
        static private void undef_setter(object val, uint i, GlobalEntry gb, NetRuby rb)
        {
            gb.getMethod = new Getter(val_getter);
            gb.setMethod = new Setter(val_setter);
            gb.data = val;
        }
        static private object val_getter(uint i, GlobalEntry gb, NetRuby rb)
        {
            return gb.data;
        }
        static private void val_setter(object val, uint i, GlobalEntry gb, NetRuby rb)
        {
            gb.data = val;
        }
        static public void ReadonlySetter(object val, uint i, GlobalEntry gb, NetRuby rb)
        {
            throw new eNameError("can't set variable " + rb.id2name(i));
        }
        
        internal uint id;
        internal object data;
        public delegate object Getter(uint id, GlobalEntry gb, NetRuby rb);
        public delegate void Setter(object val, uint id, GlobalEntry gb, NetRuby rb);
        internal void ReplaceGetter(Getter gt)
        {
            if (gt == null)
                getMethod = new Getter(val_getter);
            else
                getMethod = gt;
        }
        internal void ReplaceSetter(Setter st)
        {
            if (st == null)
                setMethod = new Setter(val_setter);
            else
                setMethod = st;
        }
        public object GetValue(NetRuby rb)
        {
            return getMethod(id, this, rb);
        }
        public void SetValue(object val, NetRuby rb)
        {
            setMethod(val, id, this, rb);
        }
        private event Getter getMethod;
        private event Setter setMethod;
        internal bool block_trace;
        internal trace_var trace;
    }

    internal class LocalVars : ICloneable
    {
        internal LocalVars(LocalVars p, int ct, int dl)
        {
            if (ct > 0)
                tbl = new uint[ct + 2];
            else
                tbl = null;
            prev = p;
            dlev = dl;
        }
        internal uint[] tbl;
        internal int dlev;
        internal LocalVars prev;
        internal int Length
        {
            get { return (tbl != null) ? tbl.Length : 0; }
        }
        public object Clone()
        {
            LocalVars o;
            lock (this)
            {
                o = (LocalVars)MemberwiseClone();
                o.tbl = (uint[])o.tbl.Clone();
            }
            if (o.prev != null)
            {
                o.prev = (LocalVars)o.prev.Clone();
            }
            return o;
        }
        internal int Count(uint id)
        {
            if (id == 0) return Length;
            if (tbl != null)
            {
                int cnt = Array.IndexOf(tbl, id);
                if (cnt >= 0) return cnt;
            }
            return Append(id);
        }
        internal int Append(uint id)
        {
            int idx = 2;
            lock (this)
            {
                if (tbl == null) {
                    tbl = new uint[3];
                    tbl[0] = (uint)'_';
                    tbl[1] = (uint)'~';
                    if (id == '_') return 0;
                    if (id == '~') return 1;
                }
                else
                {
                    idx = Length;
                    uint[] t = new uint[idx + 1];
                    Array.Copy(tbl, t, idx);
                    tbl = t;
                }
                tbl[idx] = id;
            }
            return idx;
        }
        internal void Init(int cnt, uint[] local, bool dlv)
        {
            lock (this)
            {
                if (cnt > 0) {
                    tbl = new uint[cnt + 2];
                    Array.Copy(local, tbl, cnt);
                }
                else {
                    tbl = null;
                }
            }
            dlev = (dlv) ? 1 : 0;
        }
    }
    
    public class RVarmap : RBasic
    {
        public RVarmap(NetRuby rb, uint i, object v, RVarmap prev) :
            base(rb, null)
        {
            id = i;
            val = v;
            next = prev;
        }
        internal new uint id;
        internal object val;
        internal RVarmap next;
    }

    struct CacheEntry
    {
        internal uint mid;      // method id
        internal uint mid0;
        internal RMetaObject klass;
        internal RMetaObject origin;
        internal RNode method;
        internal NOEX noex;
        internal const int SIZE = 0x800;
        internal const int MASK = 0x7ff;
        static internal int EXPR1(object o, uint mid)
        {
            return ((int)(((uint)o.GetHashCode()) ^ mid) & MASK);
        }
        internal void SetEmtptyInfo(RMetaObject o, uint id)
        {
            klass = origin = o;
            mid = mid0 = id;
            noex = NOEX.PUBLIC;
            method = null;
        }
        internal void SetInfo(RMetaObject o, uint id, RNode body, RMetaObject org)
        {
            klass = o;
            noex = body.noex;
            body = body.body;
            if (body is RNFBody)
            {
                mid = id;
                origin = body.orig;
                mid0 = body.mid;
                method = body.head;
            }
            else
            {
                origin = org;
                mid = mid0 = id;
                method = body;
            }
        }
    }

    internal enum CALLSTAT
    {
        PUBLIC = 0,
        PRIVATE = 1,
        PROTECTED = 2,
        VCALL = 4,
    }

    public class RBuiltinType
    {
        public readonly Type Type;
        public readonly string Name;
        static public RBuiltinType[] Table
        {
            get { return tbl; }
        }
        private RBuiltinType(Type t, string n)
        {
            Type = t;
            Name = n;
        }
        static RBuiltinType[] tbl = new RBuiltinType[] {
            new RBuiltinType(typeof(RNil), "nil"),
            new RBuiltinType(typeof(RObject), "Object"),
            new RBuiltinType(typeof(RClass), "Class"),
            new RBuiltinType(typeof(RIncClass), "iClass"),
            new RBuiltinType(typeof(RModule), "Module"),
            new RBuiltinType(typeof(RFloat), "Float"),
            new RBuiltinType(typeof(RString), "String"),
            new RBuiltinType(typeof(RRegexp), "Regexp"),
            new RBuiltinType(typeof(RArray), "Array"),
            new RBuiltinType(typeof(RFixnum), "Fixnum"),
            new RBuiltinType(typeof(RBignum), "Bignum"),
            new RBuiltinType(typeof(RTrue), "true"),
            new RBuiltinType(typeof(RFalse), "false"),
            new RBuiltinType(typeof(Symbol), "Symbol"),
            new RBuiltinType(typeof(RData), "Data"),
            new RBuiltinType(typeof(RVarmap), "Varmap"),
            new RBuiltinType(typeof(Scope), "Scope"),
            new RBuiltinType(typeof(RNode), "Node"),
            new RBuiltinType(typeof(QUndef), "undef"),
        };
    }
    
    public class NetRuby : IDisposable
    {
        public NetRuby()
        {
            compiled = disposed = false;
            sym_tbl = new st_table();
            sym_rev_tbl = new st_table();
            class_tbl = new st_table();
            global_tbl = new st_table();
            generic_iv_tbl = null;
            last_id = Token.LAST_TOKEN;
            cache = new CacheEntry[CacheEntry.SIZE];
            threads = new Hashtable();
            threadMain = new RThread(this);
            InitEnvironment(threadMain);
            last_defined_id = last_id;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        bool disposed;
        ~NetRuby()
        {
            Dispose(false);
        }
        protected virtual void Dispose(bool disposing)
        {
            if (!disposed)
            {
                RThread th = GetCurrentContext();
                th.PushTag(Tag.TAG.PROT_NONE);
                if (endProcs != null)
                {
                    while (endProcs.Count > 0)
                    {
                        try
                        {
                            EndProcData ed = (EndProcData)endProcs.Pop();
                            ed.Exec();
                        }
                        catch (Exception ex)
                        {
                            th.errorHandle(ex);
                        }
                    }
                }
                if (ephemeralEndProcs != null)
                {
                    while (ephemeralEndProcs.Count > 0)
                    {
                        try
                        {
                            EndProcData ed = (EndProcData)ephemeralEndProcs.Pop();
                            ed.Exec();
                        }
                        catch (Exception ex)
                        {
                            th.errorHandle(ex);
                        }
                    }
                }
                th.PopTag(false);
                disposed = true;
            }
        }
        internal object[] CallArgs(RNode nd, object self)
        {
            RThread th = GetCurrentContext();
            Block tempBlock = th.block;
            if ((ITER)th.iter.Peek() == ITER.PRE)
            {
                th.block = th.block.prev;
            }
            th.iter.Push(ITER.NOT);
            object[] ret = nd.SetupArgs(this, self, nd.args);
            th.block = tempBlock;
            th.iter.Pop();
            return ret;
        }
        internal object[] CallArgs(RNCall nd, object self, out object receiver)
        {
            RThread th = GetCurrentContext();
            Block tempBlock = th.block;
            if ((ITER)th.iter.Peek() == ITER.PRE)
            {
                th.block = th.block.prev;
            }
            th.iter.Push(ITER.NOT);
            object[] ret = nd.SetupArgs(this, self, out receiver);
            th.block = tempBlock;
            th.iter.Pop();
            return ret;
        }
        internal object CallIter(RNode nd, object self)
        {
            RThread th = GetCurrentContext();
            Block tempBlock = th.block;
            if ((ITER)th.iter.Peek() == ITER.PRE)
            {
                th.block = th.block.prev;
            }
            th.iter.Push(ITER.NOT);
            object ret = Eval(self, nd.iter);
            th.block = tempBlock;
            th.iter.Pop();
            return ret;
        }
        //
        private void InitEnvironment(RThread th)
        {
            Scope.ScopeMode oldvmode = th.PushScope();
            th.PushTag(Tag.TAG.PROT_NONE);
            try
            {
                missing = intern("method_missing");
                idEq = intern("==");
                idEql = intern("eql?");

                cObject = new RClass(this, "Object", null);
                class_tbl[intern("Object")] = cObject;
                cModule = new RModule(this, "Module", cObject);
                cClass = new RClass(this, "Class", cModule);
                class_tbl[intern("Class")] = cClass;
                cObject.klass = new RSingletonClass(cClass);
                cObject.klass.AttachSingleton(cObject);
                cModule.klass = new RSingletonClass(cObject.klass);
                cModule.klass.AttachSingleton(cModule);
                cClass.klass = new RSingletonClass(cModule.klass);
                cClass.klass.AttachSingleton(cClass);
                mKernel = new RKernel(this, "Kernel");
                RMetaObject.IncludeModule(cObject, mKernel);
                mKernel.Init(this);
                REnumerable.Init(this);
                evalInit();
                RString.Init(this);
                RException.Init(this);
                RThreadClass.Init(this);
                RThreadGroupClass.Init(this);
                RNumeric.Init(this);
                RInteger.Init(this);
                RFixnum.Init(this);
                RFloat.Init(this);
                RBignum.Init(this);
                RArray.Init(this);
                RHashClass.Init(this);
                RRegexpClass.Init(this);
                RIOClass.Init(this);
                RProcClass.Init(this);
                RTimeClass.Init(this);
                loader = Loader.Init(this);
                RDotNetClass.Init(this);

                versionInit();
                
                threadMain.Init(this);

                th.rClass = cObject;
                topCRef = new RNCRef(cObject);
                th.cRef = topCRef;
                th.frame.self = topSelf;
                th.frame.cBase = topCRef;

                progInit();
            }
            catch (eTagJump)
            {
                errorPrint(th);
            }
            catch (Exception e)
            {
                errorPrint(th, e);
            }
            th.PopTag(true);
            th.PopScope(oldvmode);
        }

        private void evalInit()
        {
            BindingFlags bf = BindingFlags.InvokeMethod 
                | BindingFlags.Static | BindingFlags.Public 
                | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy 
                | BindingFlags.Instance;
            missing = intern("method_missing");
            initialize = intern("initialize");

            DefineVirtualVariable("$@",
                                  new GlobalEntry.Getter(errAtGetter),
                                  new GlobalEntry.Setter(errAtSetter));
            DefineVariable("$!", null,
                           new GlobalEntry.Getter(errInfoGetter),
                           new GlobalEntry.Setter(errInfoSetter));

            DefineGlobalFunction("eval", new RBasic.RMethod(ruby_eval), -1);
            DefineGlobalFunction("iterator?", new RBasic.RMethod(ruby_block_given_p), 0);
            DefineGlobalFunction("block_given?", new RBasic.RMethod(ruby_block_given_p), 0);
            DefineGlobalFunction("method_missing", new RBasic.RMethod(RBasic.ruby_missing), -1);
            DefineGlobalFunction("loop", new RBasic.RMethod(ruby_loop), 0);

            DefineGlobalFunction("raise", new RBasic.RMethod(ruby_raise), -1);
            DefineGlobalFunction("fail", new RBasic.RMethod(ruby_raise), -1);

            DefineGlobalFunction("caller", new RBasic.RMethod(ruby_caller), -1);
            
            DefineGlobalFunction("exit", new RBasic.RMethod(ruby_exit), -1);
            DefineGlobalFunction("abort", new RBasic.RMethod(ruby_abort), -1);
            DefineGlobalFunction("at_exit", new RBasic.RMethod(ruby_at_exit), 0);
            /*
    rb_define_global_function("catch", rb_f_catch, 1);
    rb_define_global_function("throw", rb_f_throw, -1);
    rb_define_global_function("global_variables", rb_f_global_variables, 0);
    rb_define_global_function("local_variables", rb_f_local_variables, 0);
            */
            mKernel.evalInit();

            Type obj = cModule.GetType();
            cModule.DefinePrivateMethod("append_features", obj.GetMethod("AppendFeatures", bf));
            cModule.DefinePrivateMethod("extend_object", new RBasic.RMethod(RMetaObject.extend_object), 1);
            cModule.DefinePrivateMethod("include", obj.GetMethod("Include", bf));
            cModule.DefinePrivateMethod("public", obj.GetMethod("Public", bf));
            cModule.DefinePrivateMethod("protected", obj.GetMethod("Protected", bf));       
            cModule.DefinePrivateMethod("private", obj.GetMethod("Private", bf));
            cModule.DefinePrivateMethod("module_function", obj.GetMethod("ModuleFunction", bf));
            cClass.UndefMethod("module_function");

            cModule.DefinePrivateMethod("remove_method", new RBasic.RMethod(RMetaObject.remove_method), 1);
            cModule.DefinePrivateMethod("undef_method", new RBasic.RMethod(RMetaObject.undef_method), 1);
            cModule.DefinePrivateMethod("alias_method", new RBasic.RMethod(RMetaObject.alias_method), 2);
            cModule.DefinePrivateMethod("define_method", new RBasic.RMethod(RMetaObject.define_method), -1);
            
            obj = topSelf.GetType();
            topSelf.DefineSingletonMethod("include", obj.GetMethod("Include", bf));
            topSelf.DefineSingletonMethod("public", obj.GetMethod("Public", bf));
            topSelf.DefineSingletonMethod("private", obj.GetMethod("Private", bf));

            mKernel.DefineMethod("extend", new RBasic.RMethod(mKernel.extend), -1);
            
            DefineVariable("$SAFE", null, new GlobalEntry.Getter(safeGetter), new GlobalEntry.Setter(safeSetter));
        }

        private void versionInit()
        {
            Assembly asm = Assembly.GetAssembly(GetType());
            FileVersionInfo finfo = FileVersionInfo.GetVersionInfo(
                                           asm.Location);
            RString s = new RString(this, finfo.FileVersion);
            s.Freeze();
            DefineGlobalConst("RUBY_VERSION", s);
            s = new RString(this, "CommonLanguageRuntime");
            s.Freeze();
            DefineGlobalConst("RUBY_PLATFORM", s);
        }
        private void progInit()
        {
            DefineVirtualVariable("$VERBOSE", new GlobalEntry.Getter(verboseGetter), new GlobalEntry.Setter(verboseSetter));
            DefineVariable("$-v", null, new GlobalEntry.Getter(verboseGetter), new GlobalEntry.Setter(verboseSetter));
            DefineVariable("$-w", null, new GlobalEntry.Getter(verboseGetter), new GlobalEntry.Setter(verboseSetter));
            DefineVariable("$DEBUG", null, new GlobalEntry.Getter(debugGetter), new GlobalEntry.Setter(debugSetter));
            DefineVariable("$-d", null, new GlobalEntry.Getter(debugGetter), new GlobalEntry.Setter(debugSetter));
            DefineReadonlyVariable("$-p", null, new GlobalEntry.Getter(printGetter));
            DefineReadonlyVariable("$-l", null, new GlobalEntry.Getter(lineGetter));

            progName = new RString(this, String.Empty, true);
#if RUBY_ARG0
            DefineVariable("$0", progName, null, new GlobalEntry.Setter(SetArg0));
#else
            DefineVariable("$0", progName);
#endif
            argv = new RArray(this, true);
            DefineReadonlyVariable("$*", argv, new GlobalEntry.Getter(argvGetter));
            DefineGlobalConst("ARGV", argv);
            DefineReadonlyVariable("$-a", argv, new GlobalEntry.Getter(splitGetter));

            DefineVirtualVariable("$_", new GlobalEntry.Getter(lastLineGetter),new GlobalEntry.Setter(lastLineSetter));
        }
                                  
        // returns false if prog termination is required.
        public bool ExecutiveOptions(string[] args)
        {
            bool f = false;
            bool created;
            RThread th = GetCurrentContext(out created);
            
            th.PushTag(Tag.TAG.PROT_NONE);
            try
            {
                f = ProcessOptions(th, args, true);
            }
            catch (eTagJump)
            {
                errorPrint(th);
            }
            catch (Exception e)
            {
                errorPrint(th, e);
            }
            th.PopTag(false);
            // Keep ThreadContext because EvalTree was not yet evaluated.
            return f;
        }
        public bool Options(string[] args)
        {
            bool f = false;
            bool created;
            RThread th = GetCurrentContext(out created);
            
            th.PushTag(Tag.TAG.PROT_NONE);
            try
            {
                f = ProcessOptions(th, args, false);
            }
            catch (eTagJump)
            {
                errorPrint(th);
            }
            catch (Exception e)
            {
                errorPrint(th, e);
            }
            th.PopTag(false);
            // Keep ThreadContext because EvalTree was not yet evaluated.
            return f;
        }
        
        internal bool ProcessOptions(RThread th, string[] args, bool compiled)
        {
            bool result = SetOptions(args, false, compiled);
            if (doCheck && th.CompileFailed == false)
            {
                System.Console.Out.WriteLine("Syntax OK");
                result = false;
            }
            if (doLoop)
            {
            }
            return result;
        }
        
        internal bool SetOptions(string[] args, bool reent, bool compiled)
        {
            if (args.Length <= 0) return true;
            bool vbose = false;
            bool version = false;
            bool copyright = false;
            string e_script = null;
            int idx = 0;
            for (; idx < args.Length; idx++)
            {
                if (args[idx][0] != '-') break;
                for (string s = args[idx].Substring(1); s.Length > 0; s = s.Substring(1))
                {
                    switch (s[0])
                    {
                    case 'a':
                        doSplit = true;
                        break;
                    case 'p':
                        doPrint = true;
                        goto case 'n';
                    case 'n':
                        doLoop = true;
                        break;
                    case 'd':
                        debug = true;
                        verbose = true;
                        break;
                    case 'y':
                        yydebug = true;
                        break;
                    case 'v':
                        if (vbose)
                            break;
                        ShowVersion();
                        vbose = true;
                        goto case 'w';
                    case 'w':
                        verbose = true;
                        break;
                    case 'c':
                        doCheck = true;
                        break;
                    case 's':
                        warn("NETRuby doesn't support -s");
                        // not support sflag
                        break;
                    case 'h':
                        ShowUsage();
                        return false;
                    case 'l':
                        warn("NETRuby doesn't support -l");
                        // doLine = true;
                        break;
                    case 'S':
                        warn("NETRuby doesn't support -S");
                        break;
                    case 'e':
                        if (s.Length == 1)
                        {
                            idx++;
                            if (idx >= args.Length)
                            {
                                s = "";
                            }
                            else
                            {
                                s = args[idx];
                            }
                        }
                        else
                        {
                            s = s.Substring(1);
                        }
                        if (s.Length == 0)
                        {
                            System.Console.Error.WriteLine(args[idx - 1] + ": no code specified for -e");
                            return false;
                        }
                        if (e_script == null)
                        {
                            e_script = s;
                            script = "-e";
                        }
                        else
                        {
                            e_script += s + "\n";
                        }
                        goto next_argv;
                    case 'r':
                        warn("NETRuby doesn't support -r");
                        goto next_argv;
                    case 'i':   // inplace mode
                        warn("NETRRuby doesn't support -i");
                        goto next_argv;
                    case 'C':
                    case 'X':
                        warn("NETRuby doesn't support -C -X");
                        break;
                    case 'F':
                        if (s.Length > 1)
                            fSep = s.Substring(1);
                        goto next_argv;
                    case 'K':
                        if (s.Length > 1)
                        {
                            SetKCode(s[1]);
                            s = s.Substring(1);
                        }
                        break;
                    case 'T':
                    {
                        int v = 1;
                        if (s.Length > 1)
                        {
                            v = Convert.ToInt32(s.Substring(1));
                        }
                        SafeLevel = v;
                        goto next_argv;
                    }
                    case 'I':
                        if (s.Length > 1)
                        {
                            loader.IncPush(s.Substring(1));
                        }
                        goto next_argv;
                    case '0':
                        break;
                    case '-':
                        if (s.Length <= 1)
                        {
                            idx++;
                            goto switch_end;
                        }
                        s = s.Substring(1);
                        if (s == "copyright")
                        {
                            copyright = true;
                        }
                        else if (s == "debug")
                        {
                            debug = true;
                            verbose = true;
                        }
                        else if (s == "version")
                        {
                            version = true;
                        }
                        else if (s == "verbose")
                        {
                            vbose = true;
                            verbose = true;
                        }
                        else if (s == "yydebug")
                        {
                            yydebug = true;
                        }
                        else if (s == "help")
                        {
                            ShowUsage();
                            return false;
                        }
                        else
                        {
                            System.Console.Error.WriteLine(args[idx] + ": invalid option -" + s[0] + "  (-h will show valid options)\n");
                            return false;
                        }
                        goto next_argv;
                    }
                }
            next_argv:
                ;
            }
        switch_end:
            if (reent) return true;
            if (version)
            {
                ShowVersion();
                return false;
            }
            if (copyright)
            {
                ShowCopyright();
            }

            if (compiled == false)
            {
                if (e_script == null && idx >= args.Length)
                {
                    if (vbose) return false;
                    script = "-";
                }
                else
                {
                    if (e_script == null)
                    {
                        script = args[idx];
                    }
                    if (script.Length <= 0)
                    {
                        script = "-";
                    }
                    if (e_script == null)
                    {
                        idx++;
                    }
                }
            }
            RubyScript(script);
            SetArgv(args, idx);
            //processSFlag();
            //initLoadPath();
            if (compiled) return true;
            
            RThread th = GetCurrentContext();
            th.file = AppDomain.CurrentDomain.FriendlyName;
            th.evalTree = null;
            if (e_script != null)
            {
                th.evalTree = CompileFile("-e", new StringReader(e_script), 1, th);
            }
            else
            {
                LoadFile(script, true);
            }
            //processSFlag();
            return true;
        }

        private void ShowVersion()
        {
            Assembly asm = Assembly.GetAssembly(GetType());
            FileVersionInfo finfo = FileVersionInfo.GetVersionInfo(
                                           asm.Location);
            string version = finfo.FileVersion;
            string date = String.Empty;
            string platform = String.Empty;
            System.Console.Out.WriteLine("NETRuby {0} ({1}) [{2}]",
                                           version, date, platform);
        }
        private void ShowCopyright()
        {
            System.Console.Out.WriteLine("ruby - Copyright (C) 1993-2002 Yukihiro Matsumoto");
            System.Console.Out.WriteLine("NETRuby - Copyright (C) 2002 arton");
        }
        private void ShowUsage()
        {
        }
        public void SetKCode(char c)
        {
        }
        public void RubyScript(string name)
        {
            if (name != null)
            {
                progName.SetData(name);
                SourceFile = name;
            }
        }
        public RException ErrorInfo
        {
            get { return GetCurrentContext().errInfo; }
        }
        internal void SetArgv(string[] args, int start)
        {
            argv.Clear();
            for (int i = start; i < args.Length; i++)
            {
                argv.Add(args[i]);
            }
        }
        public bool Require(string path)
        {
            return loader.Require(path);
        }
        public void Load(object fobj, bool wrap)
        {
            RThread th = GetCurrentContext();
            RMetaObject cls = th.rClass;
            RObjectBase self = topSelf;

            if (wrap && th.safeLevel >= 4)
            {
                CheckType(fobj, typeof(RString));
            }
            else
            {
                CheckSafeString(th, fobj);
            }
            string fname = loader.FindFile(fobj.ToString());
            if (fname == null)
                throw new eLoadError("No such file to load -- " + fobj.ToString());
            th.errInfo = null;
            RVarmap old = th.dyna_vars;
            th.dyna_vars = null;
            RModule old_wrapper = th.wrapper;
            RNCRef saved_cRef = th.cRef;
            th.cRef = topCRef;
            if (wrap == false)
            {
                th.Secure(4);
                th.rClass = cObject;
                th.wrapper = null;
            }
            else
            {
                th.wrapper = new RModule(this);
                th.rClass = th.wrapper;
                self = (RObjectBase)topSelf.Clone();
                RMetaObject.ExtendObject(self, th.rClass);
                th.cRef = new RNCRef(th.wrapper, th.cRef);
            }
            Frame frm = th.PushFrame(false);
            frm.lastFunc = 0;
            frm.lastClass = null;
            frm.self = self;
            frm.cBase = new RNCRef(th.rClass);
            Scope.ScopeMode vm = th.PushScope();
            th.ScopeSet(Scope.ScopeMode.Private);
            th.PushTag(Tag.TAG.PROT_NONE);
            Tag.TAG state = Tag.TAG.EMPTY;
            try
            {
                th.EnterEval();
                LoadFile(fname);
                th.LeaveEval();
                RNode node = th.evalTree;
                if (th.CompileFailed == false)
                {
                    EvalNode(self, node, th);
                }
            }
            catch (eTagJump e)
            {
#if EXCEP_TRACE
                Console.WriteLine(e.StackTrace);
#endif          
                state = e.state;
            }
            catch (Exception ex)
            {
#if EXCEP_TRACE
                Console.WriteLine(ex.StackTrace);
#endif          
                th.errInfo = new RException(this, ex);
                state = Tag.TAG.RAISE;
            }
            th.PopTag(true);
            th.cRef = saved_cRef;
            th.PopScope(vm);
            th.PopFrame();
            th.rClass = cls;
            th.dyna_vars = old;
            th.wrapper = old_wrapper;
            if (th.CompileFailed)
            {
                th.ClearCompileError();
                throw new eTagJump(th.errInfo);
            }
            if (state != Tag.TAG.EMPTY)
            {
                JumpTagButLocalJump(state & Tag.TAG.MASK);
            }
            if (th.errInfo != null)
            {
                throw new eTagJump(th.errInfo);
            }
        }
        public void LoadFile(string fname)
        {
            LoadFile(fname, false);
        }
        private void LoadFile(string fname, bool script)
        {
            TextReader tr;
            int line_start = 1;
            if (fname == "-")
            {
                tr = System.Console.In;
            }
            else
            {
                try
                {
                    tr = new StreamReader(fname, Encoding.Default);
                }
                catch (FileNotFoundException)
                {
                    tr = null;
                    ruby_raise(null, eLoadError, "No such file to load -- " + fname);
                }
                catch (Exception e)
                {
                    Exception en = new eTagJump(Tag.TAG.RAISE, e, e.Message + " -- " + fname);
                    throw en;
                }
            }
            if (script)
            {
                int c = tr.Peek();
                if (c == '#')
                {
                    string ln = tr.ReadLine();
                    line_start++;
                    if (ln != null && ln.Length > 2 && ln[1] == '!')
                    {
                        int r = ln.IndexOf("ruby");
                        if (r < 0)
                        {
                            // execute non ruby program
                            Process.GetCurrentProcess().Kill();
                        }

                        ln = ln.Substring(r + 4);
                        if ((r = ln.IndexOf(" -")) >= 0)
                        {
                            ln = ln.Substring(1);
                            string[] argst = ln.Split(null);
                            int n = 0;
                            foreach (string x in argst)
                            {
                                if (x.Length > 1) n++;
                            }
                            string[] args = new string[n];
                            n = 0;
                            foreach (string x in argst)
                            {
                                if (x.Length > 1)
                                {
                                    args[n++] = x;
                                }
                            }
                            SetOptions(args, true, false);
                        }
                    }
                }
            }
            bool thCreated;
            RThread th = GetCurrentContext(out thCreated);
            th.evalTree = CompileFile(fname, tr, line_start, th);
            if (script && __end__seen)
            {
                DefineGlobalConst("DATA", tr);
            }
            else if (fname != "-")
            {
                tr.Close();
            }
        }
        private string MoreSwitches(string p)
        {
            string result = null;
            for (int i = 0; i < p.Length; i++)
            {
                if (Char.IsWhiteSpace(p[i]))
                {
                    p = p.Substring(0, i);
                    result = p.Substring(i);
                }
            }
            SetOptions(new string[] {p}, true, false);
            return (result == null) ? "" : result.TrimStart(null);
        }
        public RNode CompileFile(string fname, TextReader tr, int start, RThread th)
        {
            th.ClearCompileError();
            Parser parser = new Parser(this, th, th.IsInEval);
            try
            {
                yyParser.Scanner scanner =
                    new yyParser.Scanner(parser, tr, fname, start, this, th);
                RNode node = (RNode)parser.Parse(scanner);
                if (doPrint)
                {
                    node = ParserAppendPrint(th, node);
                }
                return node;
            }
            catch (IOException oe)
            {
                Console.Error.WriteLine(oe.Message);
            }
            return null;
        }
        private RNode ParserAppendPrint(RThread th, RNode node)
        {
            uint id = intern("$_");
            node = RNode.block_append(th,
                        node,
                        new RNFCall(null, intern("print"),
                        new RNArray(null, new RNGVar(id, global_entry(id)))));
            return node;

        }
        public void Run()
        {
            bool thCreated;
            RThread th = GetCurrentContext(out thCreated);
            if (th.CompileFailed) return;
            
            Tag.TAG state = Tag.TAG.EMPTY;
            th.PushIter(ITER.NOT);
            th.PushTag(Tag.TAG.PROT_NONE);
            try
            {
                EvalNode(topSelf, th.evalTree, th);
            }
            catch (eTagJump tj)
            {
#if _DEBUG
                System.Console.WriteLine(tj.StackTrace);
#endif          
                state = tj.state;
                if (th.CurrentTag.tag != Tag.TAG.EMPTY)
                    errorPrint(th);
            }
            catch (Exception ex)
            {
#if _DEBUG
                System.Console.WriteLine(ex.StackTrace);
#endif          
                state = Tag.TAG.RAISE;
                if (th.CurrentTag.tag != Tag.TAG.EMPTY)
                    errorPrint(th, ex);
            }
            th.PopIter();
            th.PopTag(false);

            if (thCreated) ClearContext(th);
        }
        public void RunWithMain(RMainObject main)
        {
            bool thCreated;
            compiled = true;
            RThread th = GetCurrentContext(out thCreated);
            if (th.CompileFailed) return;
            
            Tag.TAG state = Tag.TAG.EMPTY;
            th.PushIter(ITER.NOT);
            th.PushTag(Tag.TAG.PROT_NONE);
            try
            {
                topSelf = main;
                main.Run();
            }
            catch (eTagJump tj)
            {
#if _DEBUG
                System.Console.WriteLine(tj.StackTrace);
#endif          
                state = tj.state;
                if (th.CurrentTag.tag != Tag.TAG.EMPTY)
                    errorPrint(th);
            }
            catch (Exception ex)
            {
#if _DEBUG
                System.Console.WriteLine(ex.StackTrace);
#endif          
                state = Tag.TAG.RAISE;
                if (th.CurrentTag.tag != Tag.TAG.EMPTY)
                    errorPrint(th, ex);
            }
            th.PopIter();
            th.PopTag(false);

            if (thCreated) ClearContext(th);
        }

        private void compile(RThread th, bool save)
        {
            if (dynAssembly == null)
            {
                dynName = new AssemblyName();
                int ix = progName.ToString().LastIndexOf('.');
                if (ix > 0)
                    dynName.Name = progName.ToString().Substring(0, ix) + ".exe";
                else
                    dynName.Name = progName + ".exe";
                dynAssembly = Thread.GetDomain().DefineDynamicAssembly(dynName,
                                                                       AssemblyBuilderAccess.RunAndSave);
                dynModule = dynAssembly.DefineDynamicModule(dynName.Name, dynName.Name, true);
            }
            string cname = "RubyMainClass";
            lock (this)
            {
                cname += dynModName.ToString();
                dynModName++;
            }
            TypeBuilder newMain = dynModule.DefineType(cname, TypeAttributes.Public,
                                                       mainType);
            ConstructorBuilder cb = newMain.DefineConstructor(
                                                              MethodAttributes.Assembly,
                                                              CallingConventions.Standard,
                                                              new Type[] {typeof(RObject)});
            ILGenerator cilg = cb.GetILGenerator();
            cilg.Emit(OpCodes.Ldarg_0);
            cilg.Emit(OpCodes.Ldarg_1);
            ConstructorInfo supctr = typeof(RMainObject).GetConstructor(
                                                                        BindingFlags.Instance | BindingFlags.Public, null,
                                                                        new Type[] {typeof(RObject)}, null);
            cilg.Emit(OpCodes.Call, supctr);
            cilg.Emit(OpCodes.Ret);
            MethodBuilder main = newMain.DefineMethod("Run",
                                                      MethodAttributes.Public |
                                                      MethodAttributes.Virtual,
                                                      typeof(object), null);
            ArrayList methodList = null;
            using (ILParam pm = new TopLevelILParam(newMain, main))
            {
                pm.InitLocalTable(this, th.scope.local_tbl);
                CompileNode(pm, th.evalTree, true, th);
                methodList = pm.MethodList;
            }

            MethodBuilder mtb = newMain.DefineMethod("Main",
                                                     MethodAttributes.Public |
                                                     MethodAttributes.Static,
                                                     typeof(void), new Type[] {typeof(string[])});
            ILGenerator il = mtb.GetILGenerator();
            il.BeginScope();
            LocalBuilder r = il.DeclareLocal(typeof(NetRuby));
            r.SetLocalSymInfo("ruby");
            il.Emit(OpCodes.Newobj, typeof(NetRuby).GetConstructor(Type.EmptyTypes));
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Stloc, r);
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Call, typeof(NetRuby).GetMethod("ExecutiveOptions"));
            Label elab = il.DefineLabel();
            il.Emit(OpCodes.Brfalse, elab);
            il.Emit(OpCodes.Ldloc, r);
            foreach (DictionaryEntry de in sym_tbl)
            {
                uint id = (uint)de.Value;
                if ((id >> (int)Parser.ID.SCOPE_SHIFT) <= last_defined_id) continue;
                il.Emit(OpCodes.Dup);
                il.Emit(OpCodes.Ldc_I4, id);
                il.Emit(OpCodes.Ldstr, (string)de.Key);
                il.Emit(OpCodes.Call, typeof(NetRuby).GetMethod("_intern"));
            }
            if (methodList != null)
            {
                foreach (Type typ in methodList)
                {
                    il.Emit(OpCodes.Dup);
                    il.Emit(OpCodes.Ldfld, typeof(NetRuby).GetField("cObject"));
                    il.Emit(OpCodes.Call, typ.GetMethod("Init", BindingFlags.Static | BindingFlags.Public));
                }
            }
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Ldfld, typeof(NetRuby).GetField("topSelf"));
            il.Emit(OpCodes.Newobj, cb);
            il.Emit(OpCodes.Call, typeof(NetRuby).GetMethod("RunWithMain"));
            il.MarkLabel(elab);
            il.Emit(OpCodes.Ldloc, r);
            il.Emit(OpCodes.Ldc_I4_0);
            il.Emit(OpCodes.Call, typeof(NetRuby).GetMethod("Exit"));
            il.EndScope();
            il.Emit(OpCodes.Ret);
                    
            Type tp = newMain.CreateType();
            mainType = tp;

            dynModule.SetUserEntryPoint(mtb);
            dynAssembly.SetEntryPoint(mtb);
            if (save)
            {
                dynAssembly.Save(dynName.Name);
            }
        }
        public void Compile()
        {
            bool thCreated;
            RThread th = GetCurrentContext(out thCreated);
            if (th.CompileFailed) return;

            Tag.TAG state = Tag.TAG.EMPTY;
            th.PushIter(ITER.NOT);
            th.PushTag(Tag.TAG.PROT_NONE);
            try
            {
                compile(th, true);
            }
            catch (eTagJump tj)
            {
#if _DEBUG
                System.Console.WriteLine(tj.StackTrace);
#endif          
                state = tj.state;
                if (th.CurrentTag.tag != Tag.TAG.EMPTY)
                    errorPrint(th);
            }
            catch (Exception ex)
            {
#if _DEBUG
                System.Console.WriteLine(ex.StackTrace);
#endif          
                state = Tag.TAG.RAISE;
                if (th.CurrentTag.tag != Tag.TAG.EMPTY)
                    errorPrint(th, ex);
            }
            th.PopIter();
            th.PopTag(false);

            if (thCreated) ClearContext(th);
        }
        public void RunWithCompile()
        {
            bool thCreated;
            RThread th = GetCurrentContext(out thCreated);
            if (th.CompileFailed) return;
            
            Tag.TAG state = Tag.TAG.EMPTY;
            th.PushIter(ITER.NOT);
            th.PushTag(Tag.TAG.PROT_NONE);
            try
            {
                compile(th, false);
                topSelf = (RObject)Activator.CreateInstance(mainType, 
                                                   BindingFlags.NonPublic | BindingFlags.Instance,
                                                   null, new object[] { topSelf }, null);
                topSelf.Run();
                // save if completely ran
                dynAssembly.Save(dynName.Name);
            }
            catch (eTagJump tj)
            {
#if _DEBUG
                System.Console.WriteLine(tj.StackTrace);
#endif          
                state = tj.state;
                if (th.CurrentTag.tag != Tag.TAG.EMPTY)
                    errorPrint(th);
            }
            catch (Exception ex)
            {
#if _DEBUG
                System.Console.WriteLine(ex.StackTrace);
#endif          
                state = Tag.TAG.RAISE;
                if (th.CurrentTag.tag != Tag.TAG.EMPTY)
                    errorPrint(th, ex);
            }
            th.PopIter();
            th.PopTag(false);

            if (thCreated) ClearContext(th);
        }

        internal void errorPrint(RThread th)
        {
            if (th.errInfo == null) return;
            th.PushTag(Tag.TAG.PROT_NONE);
            RArray errat;
            try
            {
                errat = th.errInfo.Backtrace;
            }
            catch
            {
                errat = null;
            }
            th.PopTag(false);
            
            if (errat == null)
            {
                if (th.file != null)
                    System.Console.Error.Write(String.Format("{0}:{1}",
                                     th.file, th.line));
                else
                    System.Console.Error.Write(String.Format("{0}", th.line));
            }
            else if (errat.Count == 0)
            {
                th.errorPos();
            }
            else
            {
                if (errat[0] == null)
                    th.errorPos();
                else
                    System.Console.Error.Write(errat[0].ToString());
            }
            string einfo = String.Empty;
            RMetaObject eClass = ClassOf(th.errInfo);
            th.PushTag(Tag.TAG.PROT_NONE);
            try
            {
                einfo = RString.AsString(this, th.errInfo);
            }
            catch
            {
            }
            Tag tag2 = th.PopTag(true);
            if (eClass == eRuntimeError && einfo.Length == 0)
            {
                System.Console.Error.WriteLine(": unhandled exception");
            }
            else
            {
                string epath = eClass.ClassPath;
                if (einfo.Length == 0)
                {
                    System.Console.Error.WriteLine(": " + epath);
                }
                else
                {
                    if (epath[0] == '#') epath = null;
                    System.Console.Error.Write(": " + einfo);
                    if (epath != null)
                    {
                        System.Console.Error.WriteLine(" (" + epath + ")");
                    }
                }
            }
            printBacktrace(errat);
        }
        internal void errorPrint(RThread th, Exception errinfo)
        {
            if (errinfo is eTagJump)
            {
                errorPrint(th);
                return;
            }
            th.errorPos();

            string tp = errinfo.GetType().ToString();
            int n = tp.LastIndexOf('.');
            if (n >= 0) tp = tp.Substring(n + 1);
            if (tp[0] == 'e') tp = tp.Substring(1);
            System.Console.Error.WriteLine(String.Format(": {0}: ({1})",
                                                         errinfo.Message, tp));
            RArray ra = Backtrace(-1);
            printBacktrace(ra);
#if EXCEP_TRACE
            warning(errinfo.StackTrace);
#endif      
        }
        void printBacktrace(RArray errat)
        {
            if (errat != null)
            {
                for (int i = 1; i < errat.Count; i++)
                {
                    if (errat[i] is string || errat[i] is RString)
                    {
                        System.Console.Error.WriteLine(String.Format("\tfrom {0}", errat[i]));
                    }
                    if (i == 8 && errat.Count > 18)
                    {
                        System.Console.Error.WriteLine(String.Format("\t ... {0} levels...",
                                                                     errat.Count - 8 - 5));
                        i = errat.Count - 5;
                    }
                }
            }
        }
        
        internal Frame topFrame;
        public RObject topSelf;
        private int exitStatus = 0;
        public RObjectBase TraceFunc;
        internal AssemblyBuilder dynAssembly = null;
        internal AssemblyName dynName = null;
        internal ModuleBuilder dynModule = null;
        private int dynModName = 0;
        private Type mainType = typeof(RMainObject);
        internal Loader loader;
        public RClass cObject;
        public RModule cModule;
        public RKernel mKernel;
        public REnumerable mEnumerable;
        public RClass cClass;
        public RClass cNilClass;
        public RClass cFalseClass;
        public RClass cTrueClass;
        public RClass cData;
        public RClass cSymbol;
        public RProcClass cProc;
        public RThreadClass cThread;
        public RThreadGroupClass cThreadGroup;
        public RTimeClass cTime;
        public RDotNetClass cDotNet;
        //
        public RClass cString;
        public RClass cArray;
        //
        public RClass cNumeric;
        public RClass cInteger;
        public RClass cFixnum;
        public RClass cBignum;
        public RClass cFloat;
        public RHashClass cHash;
        public RIOClass cIO;
        public RRegexpClass cRegexp;
        public RClass cMatch;
        //
        public RClass eException;
        public RClass eSystemExit;
        public RClass eFatal;
        public RClass eInterrupt;
        public RClass eSignal;
        public RClass eStandardError;
        public RClass eTypeError;
        public RClass eArgError;
        public RClass eIndexError;
        public RClass eRangeError;
        public RClass eScriptError;
        public RClass eSyntaxError;
        public RClass eNameError;
        public RClass eLoadError;
        public RClass eNotImpError;
        public RClass eRuntimeError;
        public RClass eSecurityError;
        public RClass eNoMemError;
        public RClass eThreadError;
        public RClass eRegexpError;
        //
        private uint last_id;
        private uint last_defined_id;
        internal uint idEq;
        internal uint idEql;
        private uint missing;
        private uint initialize;
        private uint inspect_key = 0;
        //
        internal RNil oNil;
        internal RTrue oTrue;
        internal RFalse oFalse;
        internal RFixnum oFixZero;      
        internal RFixnum oFixnum;
        internal RFloat oFloat;
        internal RString oString;
        internal Symbol oSymbol;
        //
        internal RNCRef topCRef;
        //
        internal bool verbose = true;
        internal bool debug = true;
        internal bool yydebug = false;
        internal bool doLoop = false;
        internal bool doPrint = false;
        internal bool doLine = false;
        internal bool doSplit = false;
        internal bool doCheck = false;
        public bool __end__seen = false;
        internal bool compiled;
        internal string fSep = null;
        internal string outputFS = null;
        internal string recSep = "\n";
        internal string defaultRecSep = "\n";
        public string SourceFile
        {
            get { return GetCurrentContext().file; }
            set { GetCurrentContext().file = value; }
        }
        public int SourceLine
        {
            get { return GetCurrentContext().line; }
            set { GetCurrentContext().line = value; }
        }
        internal RString progName = null;
        internal RArray argv;
        private string script = null;
        internal Hashtable threads;
        internal RThread threadMain;

        internal bool IsBlockGiven
        {
            get { return (GetCurrentContext().frame.iter != 0); }
        }
        internal RProc Lambda()
        {
            return new RProc(this);
        }

        struct evalParam
        {
            internal evalParam(RBasic o, string s, string f, int l)
            {
                self = o;
                src = s;
                file = f;
                line = l;
            }
            public RBasic self;
            public string src;
            public string file;
            public int line;
        }
        delegate object ExecMethod(RThread th, object arg);
        private object EvalI(RThread th, object o)
        {
            evalParam param = (evalParam)o;
            return Eval(param.self, param.src, null, param.file, param.line);
        }
        private object Eval(RThread th, RMetaObject under, RBasic self, object src, string file, int line)
        {
            if (src is string == false)
            {
                if (th.safeLevel >= 4)
                {
                    CheckType(src, typeof(RString));
                }
                else
                {
                    CheckSafeString(th, src);
                }
            }
            evalParam param = new evalParam(self, src.ToString(), file, line);
            return ExecUnder(th, under, new ExecMethod(EvalI), param);
        }
        private object YieldI(RThread th, object o)
        {
            RBasic self = (RBasic)o;
            th.block.frame.cBase = th.frame.cBase;
            return Yield(self, self, th.rClass, false);
        }
        private object Yield(RThread th, RMetaObject under, RBasic self)
        {
            return ExecUnder(th, under, new ExecMethod(YieldI), self);
        }
        object ExecUnder(RThread th, RMetaObject under, ExecMethod func, object arg)
        {
            object val = null;
            RMetaObject cls = th.PushClass(under);
            th.PushFrame(false);
            th.CopyPrevFrame();
            RNode cbase = th.frame.cBase;
            if (cbase.clss != under)
            {
                th.frame.cBase = new RNCRef(under, cbase);
            }
            RNCRef old_cRef = th.cRef;
            Scope.ScopeMode vm = th.PushScope();
            th.PushTag(Tag.TAG.PROT_NONE);

            Tag.TAG state = Tag.TAG.EMPTY;
            try
            {
                val = func(th, arg);
            }
            catch (eTagJump ex)
            {
                state = ex.state;
            }
            catch (Exception ex)
            {
                state = Tag.TAG.RAISE;
                th.errInfo = new RException(this, ex);
            }
            th.PopTag(true);
            th.cRef = old_cRef;
            th.PopScope(vm);
            th.PopFrame();
            th.PopClass(cls);
            if (state != Tag.TAG.EMPTY)
                th.TagJump(state);
            return val;
        }
        
        internal object Yield(object o)
        {
            return Yield(o, null, null, false);
        }
        internal object Yield(object val, object self, object klass, bool acheck)
        {
            RThread th = GetCurrentContext();

            string file = th.file;
            int line = th.line;
            Tag.TAG state = Tag.TAG.EMPTY;
            object result = null;
            if (th.IsBlockGiven == false)
            {
                throw new eLocalJumpError("no block given");
            }
            RVarmap old = th.dyna_vars;
            th.dyna_vars = null;
            RMetaObject cls = th.rClass;
            Frame _frame = (Frame)th.block.frame.Clone();
            _frame.prev = th.frame;
            th.frame = _frame;
            RNCRef old_cRef = th.cRef;
            th.cRef = _frame.cBase;
            RModule old_wrapper = th.wrapper;
            Block blk = th.block;
            th.wrapper = blk.wrapper;
            Scope old_scope = th.scope;
            th.scope = blk.scope;
            th.block = blk.prev;
            if (blk.DScope)
            {
                /* put place holder for dynamic (in-block) local variables */
                th.dyna_vars = th.new_dvar(0, null, blk.dyna_vars);
            }
            else
            {
                /* FOR does not introduce new scope */
                th.dyna_vars = blk.dyna_vars;
            }
            th.rClass = (klass == null) ? blk.klass : (RMetaObject)klass;
            if (klass == null) self = blk.self;
            RNode node = blk.body;

            if (blk.var != null)
            {
                th.PushTag(Tag.TAG.PROT_NONE);
                state = Tag.TAG.EMPTY;
                try
                {

                    if (blk.var is RNBlockNoArg) // original = (NODE*)1
                    {
                        if (acheck && (val is QUndef == false) &&
                            val is RArray && ((RArray)val).Count != 0)
                        {
                            throw new ArgumentException("wrong # of arguments ("
                                                        + ((RArray)val).Count.ToString()
                                                        + " for 0)");
                        }
                    }
                    else
                    {
                        if (blk.var is RNMAsgn == false)
                        {
                            /* argument adjust for proc_call etc. */
                            if (acheck && (val is QUndef == false))
                            {
                                if (val is RArray && ((RArray)val).Count == 1)
                                {
                                    val = ((RArray)val)[0];
                                }
                                else if (val is object[] && ((object[])val).Length == 1)
                                {
                                    val = ((object[])val)[0];
                                }
                            }
                        }
                        Assign(self, blk.var, val, acheck);
                    }
                }
                catch (eTagJump e)
                {
                    state = e.state;
                }
                catch (Exception e)
                {
                    state = Tag.TAG.RAISE;
                    th.errInfo = new RException(this, e);
                }
                th.PopTag(true);
                if (state != Tag.TAG.EMPTY) goto pop_state;
            }
            else
            {
                /* argument adjust for proc_call etc. */
                if (acheck && (val is QUndef == false))
                {
                    if (val is RArray && ((RArray)val).Count == 1)
                    {
                        val = ((RArray)val)[0];
                    }
                    else if (val is object[] && ((object[])val).Length == 1)
                    {
                        val = ((object[])val)[0];
                    }
                }
            }

            th.PushIter(blk.iter);
            th.PushTag(Tag.TAG.PROT_NONE);
        redo:
            try
            {
                if (node == null)
                {
                    result = null;
                }
                else if (node is RNCFunc)
                {
                    result = ((RNCFunc)node).Funcall(ClassOf(self), self, 0, new object[]{self, val});
                }
                else if (node is RNIFunc)
                {
                    result = ((RNIFunc)node).Call(val, self);
                }
                else
                {
                    result = Eval(self, node);
                }
            }
            catch (eTagJump e)
            {
                state = e.state;
            }
            catch (Exception ex)
            {
                state = Tag.TAG.RAISE;
                th.errInfo = new RException(this, ex);
            }
            switch (state)
            {
            case Tag.TAG.REDO:
                state = Tag.TAG.EMPTY;
                goto redo;
            case Tag.TAG.NEXT:
                state = Tag.TAG.EMPTY;
                result = null;
                break;
            case Tag.TAG.BREAK:
            case Tag.TAG.RETURN:
//              state |= (serial++ << 8);
//              state |= 0x10;
                blk.DStatus = state;
                break;
            default:
                break;
            }

            th.PopTag(true);
        pop_state:
            th.PopIter();
            th.rClass = cls;
            th.dyna_vars = old;
            th.block = blk;
            th.frame = th.frame.prev;
            th.cRef = old_cRef;
            th.wrapper = old_wrapper;
            th.file = file;
            th.line = line;

            if (th.scope.DontRecycle)
            {
                old_scope.Dup();
            }
            th.scope = old_scope;
            if (state != Tag.TAG.EMPTY)
            {
                if (blk.IsTag == false)
                {
                    switch (state & Tag.TAG.MASK)
                    {
                    case Tag.TAG.BREAK:
                    case Tag.TAG.RETURN:
                        JumpTagButLocalJump(state & Tag.TAG.MASK);
                        break;
                    }
                }
                th.TagJump(state);
            }
            return result;
        }

        internal void JumpTagButLocalJump(Tag.TAG state)
        {
            switch (state) {
            case Tag.TAG.EMPTY:
                break;
            case Tag.TAG.RETURN:
                throw new eLocalJumpError("unexpected return");
            case Tag.TAG.NEXT:
                throw new eLocalJumpError("unexpected next");
            case Tag.TAG.BREAK:
                throw new eLocalJumpError("unexpected break");
            case Tag.TAG.REDO:
                throw new eLocalJumpError("unexpected redo");
            case Tag.TAG.RETRY:
                throw new eLocalJumpError("retry outside of rescue clause");
            default:
                //              JUMP_TAG(state);
                break;
            }
        }
        internal int ScanArgs(object[] argv, string fmt, object[] args)
        {
            int i = 0;
            int dst = 0;
            int idx = 0;
            if (fmt[idx] == '*') goto rest_arg;
            if (Char.IsDigit(fmt[idx]))
            {
                int n = (int)Char.GetNumericValue(fmt[idx]);
                if (n > argv.Length)
                    throw new ArgumentException(
                        String.Format("wrong # of arguments ({0} for {1})", argv.Length, n));
                for (i = 0; i < n; i++)
                {
                    args[dst++] = argv[i];
                }
                idx++;
            }
            if (idx < fmt.Length && Char.IsDigit(fmt[idx]))
            {
                int n = i + (int)Char.GetNumericValue(fmt[idx]);
                for (; i < n; i++)
                {
                    args[dst++] = (argv.Length > i) ? argv[i] : null;
                }
                idx++;
            }
        rest_arg:
            int rs = i;
            if (idx < fmt.Length && fmt[idx] == '*')
            {
                object[] rest = new object[argv.Length - i];
                args[dst] = rest;
                for (; i < argv.Length; i++)
                {
                    rest[i - rs] = argv[i];
                }
                dst++;
                idx++;
            }
            if (idx < fmt.Length && fmt[idx] == '&')
            {
                if (IsBlockGiven)
                {
                    args[dst] = Lambda();
                }
                else
                {
                    args[dst] = null;
                }
            }
            if (argv.Length > i)
            {
                throw new ArgumentException(
                    String.Format("wrong # of arguments({0} for {1})", argv.Length, i));
            }
            return argv.Length;

            
        }
        public void Secure(int level)
        {
            RThread th = GetCurrentContext();
            th.Secure(level);
        }
        public int SafeLevel
        {
            get {
                RThread th = GetCurrentContext();
                return (th == null) ? 0 : th.safeLevel; }
            set {
                RThread th = GetCurrentContext();
                th.safeLevel = value; }
        }
        public void CheckSafeString(object x)
        {
            RThread th = GetCurrentContext();
            CheckSafeString(th, x);
        }
        internal void CheckSafeString(RThread th, object x)
        {
            if (x is RBasic)
            {
                RBasic r = (RBasic)x;
                if (th.safeLevel > 0 && r.IsTainted)
                {
                    if (th.frame.lastFunc != 0)
                        throw new SecurityException("Insecure operation - " + id2name(th.frame.lastFunc));
                    else
                        throw new SecurityException("Insecure operation: -r");
                }
                th.Secure(4);
                if (r is RString) return;
            }
            if (x is string == false)
                throw new eTypeError("wrong argument type " + ClassOf(InstanceOf(x)).Name + " (expected String)");
        }
        public void CheckType(object x, Type t)
        {
            if (x is QUndef)
            {
                bug("undef leaked to the Ruby space");
            }
            if (t.IsInstanceOfType(x) == false)
            {
                foreach (RBuiltinType ent in RBuiltinType.Table)
                {
                    string etype;
                    if (ent.Type == t)
                    {
                        if (x == null)
                        {
                            etype = "nil";
                        }
                        else if (x is int)
                        {
                            etype = "Fixnum";
                        }
                        else if (RBasic.IsSpecialConstType(x))
                        {
                            etype = RString.AsString(this, x);
                        }
                        else
                        {
                            etype = ClassOf(x).ClassName;
                        }
                        throw new eTypeError("wrong argument type " + etype +
                                             " (expected " + ent.Name + ")");
                    }
                }
                bug("unknown type " + x.GetType().Name);
            }
        }
        internal void SecureVisibility(RBasic self)
        {
            RThread th = GetCurrentContext();
            if (th.safeLevel >= 4 && self.IsTainted == false)
            {
                throw new SecurityException("Insecure: can't change method visibility");
            }
        }
        public void ErrorFrozen(string what)
        {
            throw new eTypeError("can't modify frozen " + what);
        }
        static private object errAtGetter(uint id, GlobalEntry gb, NetRuby rb)
        {
            RThread th = rb.GetCurrentContext();
            if (th.errInfo != null)
            {
                return th.errInfo.Backtrace;
            }
            return null;
        }
        static private void errAtSetter(object val, uint id, GlobalEntry gb, NetRuby rb)
        {
            RThread th = rb.GetCurrentContext();
            if (th.errInfo == null)
            {
                throw new ArgumentException("$! not set");
            }
            RException.exc_set_backtrace(th.errInfo, val);
        }
        static private void errInfoSetter(object val, uint id, GlobalEntry gb, NetRuby rb)
        {
            RThread th = rb.GetCurrentContext();
            if (val != null)
            {
                RBasic b = rb.InstanceOf(val);
                if (b.IsKindOf(rb.eException) == false)
                    throw new eTypeError("assigning non-exception to $!");
            }
            th.errInfo = (RException)val;
        }
        static private object errInfoGetter(uint i, GlobalEntry gb, NetRuby rb)
        {
            RThread th = rb.GetCurrentContext();
            return th.errInfo;
        }
        static private object safeGetter(uint i, GlobalEntry gb, NetRuby rb)
        {
            return rb.GetCurrentContext().safeLevel;
        }
        static private void safeSetter(object val, uint i, GlobalEntry gb, NetRuby rb)
        {
            int level = RInteger.ToInt(rb, val);
            RThread th = rb.GetCurrentContext();
            if (level < th.safeLevel)
                throw new SecurityException(String.Format("tried to downgrade safe level from {0} to {1}", th.safeLevel, level));
            th.safeLevel = level;
        }
        static private object verboseGetter(uint i, GlobalEntry gb, NetRuby rb)
        {
            return rb.verbose;
        }
        static private void verboseSetter(object val, uint i, GlobalEntry gb, NetRuby rb)
        {
            if (val == null) rb.verbose = false;
            else if (val is bool) rb.verbose = (bool)val;
            else rb.verbose = true;
        }
        static private object debugGetter(uint i, GlobalEntry gb, NetRuby rb)
        {
            return rb.debug;
        }
        static private void debugSetter(object val, uint i, GlobalEntry gb, NetRuby rb)
        {
            if (val == null) rb.debug = false;
            else if (val is bool) rb.debug = (bool)val;
            else rb.debug = true;
        }
        
        static internal object lastLineGetter(uint i, GlobalEntry gb, NetRuby rb)
        {
            RThread th = rb.GetCurrentContext();
            if (th.scope.local_vars != null)
            {
                return th.scope.local_vars[0];
            }
            return null;
        }
        static private void lastLineSetter(object val, uint i, GlobalEntry gb, NetRuby rb)
        {
            RThread th = rb.GetCurrentContext();
            if (th.scope.local_vars != null)
            {
                th.scope.local_vars[0] = val.ToString();
            }
            else
            {
            }
        }
        
        static private object printGetter(uint i, GlobalEntry gb, NetRuby rb)
        {
            return rb.doPrint;
        }
        static private object splitGetter(uint i, GlobalEntry gb, NetRuby rb)
        {
            return rb.doSplit;
        }
        static private object lineGetter(uint i, GlobalEntry gb, NetRuby rb)
        {
            return rb.doLine;
        }
        static private object argvGetter(uint i, GlobalEntry gb, NetRuby rb)
        {
            return rb.argv;
        }
#if RUBY_ARG0
        static private void SetArg0(object val, uint i, GlobalEntry gb, NetRuby rb)
        {
        }
#endif  
        internal struct OPTBL {
            internal OPTBL(uint t, string s)
            {
                token = t;
                name = s;
            }
            internal uint token;
            internal string name;
        }
        internal static OPTBL[] op_tbl = new OPTBL[]{
            new OPTBL(Token.tDOT2,      ".."),
            new OPTBL(Token.tDOT3,      "..."),
            new OPTBL('+',      "+"),
            new OPTBL('-',      "-"),
            new OPTBL('+',      "+(binary)"),
            new OPTBL('-',      "-(binary)"),
            new OPTBL('*',      "*"),
            new OPTBL('/',      "/"),
            new OPTBL('%',      "%"),
            new OPTBL(Token.tPOW,       "**"),
            new OPTBL(Token.tUPLUS,     "+@"),
            new OPTBL(Token.tUMINUS,    "-@"),
            new OPTBL(Token.tUPLUS,     "+(unary)"),
            new OPTBL(Token.tUMINUS,    "-(unary)"),
            new OPTBL('|',      "|"),
            new OPTBL('^',      "^"),
            new OPTBL('&',      "&"),
            new OPTBL(Token.tCMP,       "<=>"),
            new OPTBL('>',      ">"),
            new OPTBL(Token.tGEQ,       ">="),
            new OPTBL('<',      "<"),
            new OPTBL(Token.tLEQ,       "<="),
            new OPTBL(Token.tEQ,        "=="),
            new OPTBL(Token.tEQQ,       "==="),
            new OPTBL(Token.tNEQ,       "!="),
            new OPTBL(Token.tMATCH,     "=~"),
            new OPTBL(Token.tNMATCH,    "!~"),
            new OPTBL('!',      "!"),
            new OPTBL('~',      "~"),
            new OPTBL('!',      "!(unary)"),
            new OPTBL('~',      "~(unary)"),
            new OPTBL('!',      "!@"),
            new OPTBL('~',      "~@"),
            new OPTBL(Token.tAREF,      "[]"),
            new OPTBL(Token.tASET,      "[]="),
            new OPTBL(Token.tLSHFT,     "<<"),
            new OPTBL(Token.tRSHFT,     ">>"),
            new OPTBL(Token.tCOLON2,    "::"),
            new OPTBL(Token.tCOLON3,    "::"),
            new OPTBL('`',      "`"),
        };
        internal st_table sym_tbl;
        internal st_table sym_rev_tbl;
        internal st_table global_tbl;
        internal st_table class_tbl;
        internal st_table autoload_tbl = null;
        internal st_table generic_iv_tbl;
        internal CacheEntry[] cache;
        internal Stack endProcs;
        internal Stack ephemeralEndProcs;       
        internal class EndProcData
        {
            internal delegate void EndMethod(object o);
            private EndProcData(EndMethod fnc, object dat)
            {
                method = fnc;
                data = dat;
            }
            internal void Exec()
            {
                method(data);
            }
            private event EndMethod method;
            private object data;
            internal static void SetEndProc(NetRuby ruby, EndMethod mtd, object dt, bool ephemeral)
            {
                Stack stk;
                if (ephemeral)
                {
                    if (ruby.ephemeralEndProcs == null)
                        ruby.ephemeralEndProcs = new Stack();
                    stk = ruby.ephemeralEndProcs;
                }
                else
                {
                    if (ruby.endProcs == null)
                        ruby.endProcs = new Stack();
                    stk = ruby.endProcs;
                }
                lock (stk.SyncRoot)
                {
                    stk.Push(new EndProcData(mtd, dt));
                }
            }
        }

        internal void ClearCache()
        {
            lock (cache.SyncRoot)
            {
                for (int i = 0; i < cache.Length; i++)
                {
                    cache[i].mid = 0;
                }
            }
        }
        internal void ClearCache(uint id)
        {
            lock (cache.SyncRoot)
            {
                for (int i = 0; i < cache.Length; i++)
                {
                    if (cache[i].mid == id)
                        cache[i].mid = 0;
                }
            }
        }
        internal void SetCache(RMetaObject o, uint id)
        {
            lock (cache.SyncRoot)
            {
                int idx = CacheEntry.EXPR1(o, id);
                cache[idx].SetEmtptyInfo(o, id);
            }
        }
        internal void SetCache(RMetaObject o, uint id, RNode body, RMetaObject org)
        {
            lock (cache.SyncRoot)
            {
                int idx = CacheEntry.EXPR1(o, id);
                cache[idx].SetInfo(o, id, body, org);
            }
        }
        //
        public uint intern(string name)
        {
            uint id;
            if (sym_tbl.lookup(name, out id) == true)
                return id;
            id = 0;
            switch (name[0])
            {
            case '$':
                id |= (uint)Parser.ID.GLOBAL;
                break;
            case '@':
                if (name[1] == '@')
                    id |= (uint)Parser.ID.CLASS;
                else
                    id |= (uint)Parser.ID.INSTANCE;
                break;
            default:
                if (name[0] != '_' && !Char.IsLetter(name[0]))
                {
                    int i;
                    for (i = 0; i < NetRuby.op_tbl.Length; i++)
                    {
                        if (NetRuby.op_tbl[i].name == name)
                        {
                            id = NetRuby.op_tbl[i].token;
                            goto id_regist;
                        }
                    }
                }

                int last = name.Length - 1;
                if (name[last] == '=')
                {
                    string buf = name.Substring(0, last);
                    id = intern(buf);
                    if (id > (uint)Token.LAST_TOKEN && !Parser.is_attrset_id(id))
                    {
                        id = Parser.id_attrset(id);
                        goto id_regist;
                    }
                    id = (uint)Parser.ID.ATTRSET;
                }
                else if (Char.IsUpper(name[0]))
                {
                    id = (uint)Parser.ID.CONST;
                }
                else
                {
                    id = (uint)Parser.ID.LOCAL;
                }
                break;
            }
            lock (this)
            {
                id |= ++last_id << (int)Parser.ID.SCOPE_SHIFT;
            }
        id_regist:
            lock (sym_tbl.SyncRoot)
            {
                sym_tbl[name] = id;
                sym_rev_tbl[id] = name;
            }
            return id;
        }
        public void _intern(uint id, string name)
        {
            lock (sym_tbl.SyncRoot)
            {
                sym_tbl[name] = id;
                sym_rev_tbl[id] = name;
                id >>= (int)Parser.ID.SCOPE_SHIFT;
                if (last_id < id)
                    last_id = id;
            }
        }
        internal string id2name(uint id)
        {
            if (id < Token.LAST_TOKEN) {
                int i = 0;

                for (i=0; i < op_tbl.Length; i++) {
                    if (op_tbl[i].token == id)
                        return op_tbl[i].name;
                }
            }
            string name = null;

            if (sym_rev_tbl.lookup(id, out name))
                return name;

            if (Parser.is_attrset_id(id)) {
                uint id2 = Parser.make_local_id(id);

            again:
                name = id2name(id2);
                if (name != null) {
                    string buf = name + "=";
                    intern(name + "=");
                    return id2name(id);
                }
                if (Parser.is_local_id(id2)) {
                    id2 = Parser.make_const_id(id);
                    goto again;
                }
            }
            return null;
        }

        internal uint global_id(string s)
        {
            if (s[0] == '$') return intern(s);
            return intern("$" + s);
        }
        internal GlobalEntry global_entry(uint id)
        {
            object o;
            GlobalEntry ret = null;
            lock (global_tbl.SyncRoot)
            {
                if (global_tbl.lookup(id, out o))
                    ret = (GlobalEntry)o;
                else
                {
                    ret = new GlobalEntry(id);
                    global_tbl.Add(id, ret);
                }
            }
            return ret;
        }
        internal void CloneGenericIVar(RBasic clone, RBasic obj)
        {
            if (generic_iv_tbl == null) return;
            lock (generic_iv_tbl.SyncRoot)
            {
                if (generic_iv_tbl.ContainsKey(obj))
                {
                    st_table tbl = (st_table)generic_iv_tbl[obj];
                    generic_iv_tbl[clone] = tbl.Clone();
                }
            }
        }
        internal bool IsGenericIVarDefined(RBasic obj, uint id)
        {
            if (generic_iv_tbl == null) return false;
            st_table tbl = null;
            if (generic_iv_tbl.lookup(obj, out tbl) == false) return false;
            object val;
            return tbl.lookup(id, out val);
        }
        internal object GenericIVarGet(RBasic obj, uint id)
        {
            if (generic_iv_tbl == null) return null;
            st_table tbl = null;
            if (generic_iv_tbl.lookup(obj, out tbl) == false) return null;
            object val;
            if (tbl.lookup(id, out val)) return val;
            return null;
        }
        internal void GenericIVarSet(RBasic obj, uint id, object val)
        {
            if (generic_iv_tbl == null)
            {
                lock (this)
                {
                    if (generic_iv_tbl == null)
                    {
                        generic_iv_tbl = new st_table();
                    }
                }
            }
            st_table tbl = null;
            lock (generic_iv_tbl.SyncRoot)
            {
                if (generic_iv_tbl.lookup(obj, out tbl) == false)
                {
                    tbl = new st_table();
                    generic_iv_tbl[obj] = tbl;
                }
                tbl[id] = val;
            }
        }
        internal object GenericIVarRemove(RBasic obj, uint id)
        {
            if (generic_iv_tbl == null) return null;
            st_table tbl;
            if (generic_iv_tbl.lookup(obj, out tbl) == false) return null;
            object val = tbl[id];
            lock (tbl.SyncRoot)
            {
                tbl.Remove(id);
                if (tbl.Count == 0)
                {
                    generic_iv_tbl.Remove(obj);
                }
            }
            return val;
        }

        public void DefineVariable(string name, object obj, GlobalEntry.Getter gtr, GlobalEntry.Setter str)
        {
            GlobalEntry ent = global_entry(global_id(name));
            lock (ent)
            {
                ent.data = obj;
                ent.ReplaceGetter(gtr);
                ent.ReplaceSetter(str);
            }
        }
        internal void DefineVirtualVariable(string name, GlobalEntry.Getter gtr, GlobalEntry.Setter str)
        {
            DefineVariable(name, null, gtr, str);
        }
        internal void DefineVariable(string name, object obj)
        {
            DefineVariable(name, obj, null, null);
        }
        internal void DefineReadonlyVariable(string name, object obj, GlobalEntry.Getter gtr)
        {
            GlobalEntry ent = global_entry(global_id(name));
            lock (ent)
            {
                ent.data = obj;
                ent.ReplaceGetter(gtr);
                ent.ReplaceSetter(new GlobalEntry.Setter(GlobalEntry.ReadonlySetter));
            }
        }
        internal void DefineGlobalConst(string name, object val)
        {
            DefineConst(cObject, name, val);
        }
        internal object GVarSet(GlobalEntry entry, object o)
        {
            RThread th = GetCurrentContext();
            if (th.safeLevel >= 4)
            {
                throw new SecurityException("Insecure: can't change global variable value");
            }
            lock (entry)
            {
                entry.SetValue(o, this);
            }
    // trace
            return o;
        }
        internal object GVarGet(GlobalEntry entry)
        {
            return entry.GetValue(this);
        }
        public void DefineConst(RMetaObject obj, string name, object val)
        {
            uint id = intern(name);
            if (Parser.is_const_id(id) == false)
            {
                throw new eNameError("wrong constant name " + name);
            }
            if (obj == cObject) Secure(4);
            obj.ConstSet(id, val);
        }
        public bool TopConstGet(uint id, out object val)
        {
            if (class_tbl.lookup(id, out val)) return true;
            if (autoload_tbl != null && autoload_tbl.ContainsKey(id))
            {
                AutoLoad(id);
                val = cObject.ConstGet(id);
                return true;
            }
            return false;
        }
        public object SearchConst(RThread th, object self, uint id)
        {
            RNode constBase = th.frame.cBase;
            while (constBase != null && constBase.next != null)
            {
                RMetaObject klass = constBase.clss;
                if (klass == null)
                {
                    return ClassOf(self).ConstGet(id);
                }
                object result;
                if (klass.valGet(id, out result)) return result;
                constBase = constBase.next;
            }
            return th.frame.cBase.clss.ConstGet(id);
        }
        internal GlobalEntry Global(uint v)
        {
            return global_entry(v);
        }
        internal uint[] Locals
        {
            get { return GetCurrentContext().Locals; }
        }
        public void AutoLoad(uint id)
        {
            ; // to be filled
        }
        public bool IsAutoloadDefined(uint id)
        {
            return (autoload_tbl != null && autoload_tbl.ContainsKey(id));
        }

        public string Inspect(Object o)
        {
            object x = Funcall(o, "inspect", null);
            return x.ToString();
        }
        public object ProtectInspect(RBasic obj, RBasic.InspectMethod method, object[] arg)
        {
            if (inspect_key == 0)
                inspect_key = intern("__inspect_key__");
            RThread th = GetCurrentContext();
            ArrayList inspect_tbl = (ArrayList)th.LocalARef(inspect_key);
            if (inspect_tbl == null)
            {
                inspect_tbl = new ArrayList();
                th.LocalASet(inspect_key, inspect_tbl);
            }
            int id = InstanceOf(obj).id;
            if (inspect_tbl.Contains(id))
            {
                return method(obj, arg);
            }
            return inspect_call(inspect_tbl, id, obj, method, arg);
        }
        private object inspect_call(ArrayList inspect_tbl, int id, RBasic obj, RBasic.InspectMethod method, object[] arg)
        {
            inspect_tbl.Add(id);
            object result = null;
            try
            {
                result = method(obj, arg);
            }
            finally
            {
                inspect_tbl.Remove(id);
            }
            return result;
        }
        
        internal bool IsInspecting(object obj) // for avoiding eternal loop by inspect
        {
            if (inspect_key == 0)
                inspect_key = intern("__inspect_key__");

            ArrayList inspect_tbl = (ArrayList)GetCurrentContext().LocalARef(inspect_key);
            if (inspect_tbl == null) return false;
            return inspect_tbl.Contains(InstanceOf(obj).id);
        }
        internal RArray ThreadList
        {
            get {
                RArray ary = new RArray(this, true);
                lock (threads.SyncRoot)
                {
                    foreach (DictionaryEntry ent in threads)
                    {
                        RThread r = (RThread)ent.Value;
                        if (r.IsAlive) ary.Add(r);
                    }
                }
                ary.Add(threadMain);
                return ary;
            }
        }
        public RThread GetCurrentContext()
        {
            Thread t = Thread.CurrentThread;
            RThread th;
            lock (threads.SyncRoot)  // Indexer will insert a new element if not found.
            {
                th = (RThread)threads[t];
            }
            return (th == null) ? threadMain : th;
        }
        
        internal RThread GetCurrentContext(out bool created)
        {
            created = false;
            Thread t = Thread.CurrentThread;
            if (t == threadMain.Owner) return threadMain;
            RThread th;
            lock (threads.SyncRoot)  // Indexer will insert a new element if not found.
            {
                th = (RThread)threads[t];
            }
            if (th == null)
            {
                lock (threadMain)
                {
                    th = new RThread(this, threadMain);
                }
                threads[t] = th;
                created = true;
            }
            return th;
        }
        internal void AddContext(RThread th)
        {
            lock (threads.SyncRoot)
            {
                threads[th.thread] = th;
            }
        }
        internal void ClearContext(RThread th)
        {
            lock (threads.SyncRoot)
            {
                threads.Remove(th.Owner);
            }
        }
        //
        public RModule DefineModule(string name)
        {
            uint id = intern(name);
            if (cObject.IsConstDefined(id))
            {
                object o = cObject.ConstGet(id);
                if (o is RModule) return (RModule)o;
                throw new eTypeError(name + " is not a module");
            }
            RModule module = new RModule(this, name);
            return module;
        }

        private void CallEndProc(object o)
        {
            RThread th = GetCurrentContext();
            th.PushIter(ITER.NOT);
            Frame frm = th.PushFrame(false);
            frm.self = frm.prev.self;
            frm.lastFunc = 0;
            frm.lastClass = null;
            try
            {
                ((RProc)o).Call();
            }
            catch (Exception e)
            {
                th.errorHandle(e);
            }
            th.PopFrame();
            th.PopIter();
        }
        internal void End()
        {
            RThread th = GetCurrentContext();
            Frame frm = th.PushFrame(false);
            frm.SetLastArgs(null, false);
            EndProcData.SetEndProc(this, new EndProcData.EndMethod(CallEndProc), Lambda(),
                                   th.wrapper != null);
            th.PopFrame();
        }
        object ruby_at_exit(RBasic r, params object[] args)
        {
            NetRuby ruby = r.ruby;
            object o = ruby.Lambda();
            EndProcData.SetEndProc(ruby, new EndProcData.EndMethod(ruby.CallEndProc), o,
                                   ruby.GetCurrentContext().wrapper != null);
            return o;
        }
        
        internal object ScopedFuncall(RMetaObject klass, object recver, uint id, object[] argv, RNScope n)
        {
            RThread th = GetCurrentContext();
#if LOCAL_TRACE
            System.Console.WriteLine("ScopedFuncall");
            for (int h = 0; h < argv.Length; h++)
            {
                System.Console.WriteLine("arg = " + ((argv[h]==null)?"null":argv[h].ToString()));
            }
#endif
            object result = null;
            object[] local_vars = null;
            RNCRef savedCRef = null;
            Scope.ScopeMode vm = th.PushScope();
            if (n.rval != null)
            {
                savedCRef = th.cRef;
                th.cRef = (RNCRef)n.rval;
                th.frame.cBase = th.cRef;
            }
            if (n.tbl != null)
            {
#if KEEP_ORIGINAL_NODE
                local_vars = new object[n.tbl.Length + 1];
                local_vars[0] = n;
#else
                local_vars = new object[n.tbl.Length];
                th.scope.InitLocal(n.tbl, local_vars);
#endif
            }
            RNode body = n.next;
            RNode b2 = body;
#if LOCAL_TRACE
            System.Console.WriteLine("local_vars = " +
                             ((local_vars == null)?"null":local_vars.Length.ToString()));
#endif
            RVarmap old = th.dyna_vars;
            th.dyna_vars = null;

            th.PushTag(Tag.TAG.PROT_FUNC);
            Tag.TAG state = Tag.TAG.EMPTY;
            try
            {
                bool fargset = false;
                RNode node = null;
                if (body is RNArgs)
                {
                    node = body;
                    body = null;
                }
                else if (body is RNBlock)
                {
                    node = body.head;
                    body = body.next;
                }
                int i = 0;
                if (node != null)
                {
                    if (node is RNArgs == false)
                    {
                        bug("no argumenet-node");
                    }
                    i = node.cnt;
                    if (i > argv.Length)
                    {
                        throw new ArgumentException(
                            String.Format("wrong # of arguments({0} for {1})", argv.Length, i));
                    }
                    if (node.rest == -1)
                    {
                        int opt = i;
                        RNode optnode = node.opt;
                        while (optnode != null)
                        {
                            opt++;
                            optnode = optnode.next;
                        }
                        if (opt < argv.Length)
                        {
                            throw new ArgumentException(
                                String.Format("wrong # of arguments({0} for {1})",
                                              argv.Length, opt));
                        }
                        // index offset is 2, for $_ and $~
                        fargset = true;
                    }
                }

                if (local_vars != null)
                {
                    if (i > 0)
                    {
                        // +2 for $_ and $~
                        Array.Copy(argv, 0, local_vars, 2, i);
                    }
#if LOCAL_TRACE
                    for (int h = 0; h < i; h++)
                    {
                        System.Console.WriteLine("local = " +
                                 ((local_vars[2+h]==null)?"null":local_vars[2+h].ToString()));
                    }
#endif              
                    int argc = argv.Length - i;
                    if (node.opt != null)
                    {
                        RNode opt = node.opt;
                        while (opt != null && argc > 0)
                        {
                            Assign(recver, opt.head, argv[i], true);
                            argc--;
                            i++;
                            opt = opt.next;
                        }
                        if (opt != null)
                        {
                            th.file = opt.file;
                            th.line = opt.Line;
                            Eval(recver, opt);
                        }
                    }
                    if (node.rest >= 0)
                    {
                        ArrayList a = new ArrayList();
                        if (argc > 0)
                        {
                            for (int ix = argc; ix < argv.Length; ix++)
                                a.Add(argv[ix]);
                        }
                        th.scope.local_vars[node.rest] = new RArray(this, a);
                    }
                }
                if (TraceFunc != null)
                {
                }
                if (fargset)
                {
                    th.frame.SetLastArgs(local_vars, true);
                }                   
                result = Eval(recver, body);
                if (fargset)
                {
                    ;               
                }
            }
            catch (eTagJump e)
            {
                Tag etag = th.CurrentTag;
                if (e.state == Tag.TAG.RETURN)
                {
                    result = etag.Result;
                    state = Tag.TAG.EMPTY;
                }
            }
            catch (Exception e)
            {
                th.errInfo = new RException(this, e);
                state = Tag.TAG.RAISE;
            }

            th.PopTag(true);

            th.dyna_vars = old;
            th.PopScope(vm);
            th.cRef = savedCRef;
            if (TraceFunc != null)
            {
            }
            switch (state)
            {
            case Tag.TAG.EMPTY:
                ;
                break;
            case Tag.TAG.RETRY:
                goto default;
            case Tag.TAG.RAISE:
                throw new eTagJump(th.errInfo);
            default:
                break;
            }
            return result;
        }

        internal void Assign(object self, RNode lhs, object val, bool check)
        {
            if (val is QUndef)
            {
                val = null;
            }
            if (val is string)
            {
                // create assignable object
                val = new RString(this, (string)val);
            }
            lhs.Assign(this, self, val, check);
        }

        public delegate object IterationProc(RBasic ob);
        public delegate object BlockProc(object it, object data, object self);
        public object Iterate(IterationProc itProc, RBasic dat1, BlockProc blProc, object data)
        {
            Tag.TAG state;
            object result = null;
            RThread th = GetCurrentContext();
            RNode node = new RNIFunc(th, blProc, data);
            RObjectBase self = topSelf;
        iter_retry:
            th.PushIter(ITER.PRE);
            Block _block = new Block(th, null, node, self);
            th.block = _block;
            th.PushTag(Tag.TAG.PROT_NONE);
            state = Tag.TAG.EMPTY;
            try
            {
                result = itProc(dat1);
            }
            catch (eTagJump e)
            {
                state = e.state;
                if (_block.CheckTag(e.state))
                {
                    state &= Tag.TAG.MASK;
                    if (state == Tag.TAG.RETURN)
                    {
                        Tag etag = th.CurrentTag;
                        result = etag.Result;
                    }
                }
            }
            catch (Exception e)
            {
                th.errInfo = new RException(this, e);
                state = Tag.TAG.RAISE;
            }
            th.PopTag(true);
            th.block = _block.prev;
            th.PopIter();
            switch (state)
            {
            case Tag.TAG.EMPTY:
                break;
            case Tag.TAG.RETRY:
                goto iter_retry;
            case Tag.TAG.BREAK:
                result = null;
                break;
            case Tag.TAG.RETURN:
                Tag etag = (Tag)th.protTag.Peek();
                etag.Result = result;
                goto default;
            default:
                th.TagJump(state);
                break;
            }
            return result;
        }

        internal object Iteration(RNode node, object self)
        {
            RThread th = GetCurrentContext();
            object result = null;
            for (;;)
            {
                Block _block = th.IterBlock(node.var, node.body, self);
                Tag.TAG state = Tag.TAG.EMPTY;
                try
                {
                    th.PushIter(ITER.PRE);
                    if (node is RNIter)
                    {
                        result = Eval(self, node.iter);
                    }
                    else if (node is RNFor)
                    {
                        string file = th.file;
                        int line = th.line;
                        _block.DScope = false;
                        object recv = CallIter(node, self);
                        th.file = file;
                        th.line = line;
                        result = Call(ClassOf(recv), recv, "each", null, 0);
                    }
                    else
                    {
                        bug("unknown node " + node.ToString() + " for Iteration");
                    }
                    th.PopIter();
                }
                catch (eTagJump e)
                {
                    state = e.state;
                    if (_block.CheckTag(e.state))
                    {
                        state &= Tag