C# NetRuby.DefineClass方法代码示例

 static internal void Init(NetRuby rb)
 {
     RClass sym = rb.DefineClass("Symbol", rb.cObject);
     rb.cSymbol = sym;
     rb.oSymbol = new Symbol(rb);
     sym.DefineMethod("to_i", new RMethod(to_i), 0);
     sym.DefineMethod("to_int", new RMethod(to_i), 0);
     sym.DefineMethod("inspect", new RMethod(inspect), 0);
     sym.DefineMethod("to_s", new RMethod(to_s), 0);
     sym.DefineMethod("id2name", new RMethod(to_s), 0);
 }

        static internal void Init(NetRuby rb)
        {
            BindingFlags bf = BindingFlags.InvokeMethod
                | BindingFlags.Static | BindingFlags.Public
                | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy
                | BindingFlags.Instance;
            RClass ary = rb.DefineClass("Array", rb.cObject);
            RMetaObject.IncludeModule(ary, rb.mEnumerable);
            rb.cArray = ary;
            Type obj = typeof(RArray);
            ary.DefineSingletonMethod("new", new RMethod(s_new), -1);
            ary.DefineSingletonMethod("[]", obj.GetMethod("Create", bf));
        
            ary.DefineMethod("initialize", obj.GetMethod("Initialize", bf));

            ary.DefineMethod("to_ary", obj.GetMethod("ToArray", bf));
            ary.DefineMethod("==", obj.GetMethod("ArrayEqual", bf));
            ary.DefineMethod("eql?", obj.GetMethod("ArrayEql", bf));

            ary.DefineMethod("[]", obj.GetMethod("ARef", bf));
            ary.DefineMethod("[]=", obj.GetMethod("ASet", bf));
            ary.DefineMethod("at", obj.GetMethod("At", bf));
            ary.DefineMethod("first", obj.GetMethod("get_First", bf));
            ary.DefineMethod("last", obj.GetMethod("get_Last", bf));
            ary.DefineMethod("concat", obj.GetMethod("Concat", bf));
            ary.DefineMethod("<<", obj.GetMethod("Push", bf));
            ary.DefineMethod("push", obj.GetMethod("Push", bf));
            ary.DefineMethod("pop", obj.GetMethod("Pop", bf));
            ary.DefineMethod("shift", obj.GetMethod("Shift", bf));
            ary.DefineMethod("unshift", obj.GetMethod("Unshift", bf));
            ary.DefineMethod("each", obj.GetMethod("Each", bf));
            ary.DefineMethod("each_index", obj.GetMethod("EachIndex", bf));
            ary.DefineMethod("reverse_each", obj.GetMethod("ReverseEach", bf));
            ary.DefineMethod("length", obj.GetMethod("get_Count", bf));
            ary.DefineAlias("size", "length");
            ary.DefineMethod("empty?", obj.GetMethod("get_IsEmpty", bf));
            ary.DefineMethod("index", obj.GetMethod("Index", bf));
            ary.DefineMethod("rindex", obj.GetMethod("RIndex", bf));
        
            ary.DefineMethod("clone", obj.GetMethod("Clone", bf));
            ary.DefineMethod("join", obj.GetMethod("JoinMethod", bf));

            ary.DefineMethod("reverse", obj.GetMethod("Reverse", bf));
            ary.DefineMethod("reverse!", obj.GetMethod("ReverseAt", bf));
            ary.DefineMethod("sort", obj.GetMethod("Sort", bf));
            ary.DefineMethod("sort!", obj.GetMethod("SortAt", bf));
            ary.DefineMethod("collect", obj.GetMethod("Collect", bf));
            ary.DefineMethod("collect!", obj.GetMethod("CollectAt", bf));

            ary.DefineMethod("delete", obj.GetMethod("Delete", bf));
            ary.DefineMethod("delete_at", obj.GetMethod("DeleteAt", bf));
        
            ary.DefineMethod("clear", obj.GetMethod("Clear2", bf));
            ary.DefineMethod("fill", obj.GetMethod("Fill", bf));
            ary.DefineMethod("include", obj.GetMethod("Contains", bf));
        }

        internal static void Init(NetRuby rb)
        {
            rb.eThreadError = rb.DefineClass("ThreadError", rb.eException);
        
            RThreadClass t = new RThreadClass(rb);
            t.DefineClass("Thread", rb.cObject);
            rb.cThread = t;
            t.DefineSingletonMethod("new", new RMethod(thread_new), -1);
            t.DefineMethod("initialize", new RMethod(initialize), -2);
            t.DefineSingletonMethod("start", new RMethod(thread_start), -2);
            t.DefineSingletonMethod("fork", new RMethod(thread_start), -2);
            t.DefineSingletonMethod("stop", new RMethod(thread_stop), 0);
            t.DefineSingletonMethod("kill", new RMethod(thread_s_kill), 1);
            t.DefineSingletonMethod("exit", new RMethod(thread_exit), 0);
            t.DefineSingletonMethod("pass", new RMethod(thread_pass), 0);
            t.DefineSingletonMethod("current", new RMethod(thread_current), 0);
            t.DefineSingletonMethod("main", new RMethod(thread_main), 0);
            t.DefineSingletonMethod("list", new RMethod(thread_list), 0);

            t.DefineSingletonMethod("critical", new RMethod(critical_getset), 0);
            t.DefineSingletonMethod("critical", new RMethod(critical_getset), 1);
            t.DefineSingletonMethod("abort_on_exception", new RMethod(thread_s_abort_exc), 0);
            t.DefineSingletonMethod("abort_on_exception=", new RMethod(thread_s_abort_set), 1);
        
            t.DefineMethod("run", new RMethod(thread_run), 0);
            t.DefineMethod("wakeup", new RMethod(thread_wakeup), 0);
            t.DefineMethod("kill", new RMethod(thread_kill), 0);
            t.DefineMethod("exit", new RMethod(thread_kill), 0);
            t.DefineMethod("value", new RMethod(thread_value), 0);
            t.DefineMethod("status", new RMethod(thread_status), 0);
            t.DefineMethod("join", new RMethod(thread_join), 0);
            t.DefineMethod("alive?", new RMethod(thread_alive), 0);
            t.DefineMethod("stop?", new RMethod(thread_isstop), 0);
            t.DefineMethod("raise", new RMethod(thread_raise), 0);

            t.DefineMethod("abort_on_exception", new RMethod(thread_abort_exc), 0);
            t.DefineMethod("abort_on_exception=", new RMethod(thread_abort_set), 1);

            t.DefineMethod("priority", new RMethod(thread_priority), 0);
            t.DefineMethod("priority=", new RMethod(thread_priority_set), 1);
            ////t.DefineMethod("safe_level", new RMethod(thread_safe_level), 0);
        
            t.DefineMethod("[]", new RMethod(thread_aref), 1);
            t.DefineMethod("[]=", new RMethod(thread_aset), 2);
            t.DefineMethod("key?", new RMethod(thread_keyp), 1);
        }

//.........这里部分代码省略.........

            RMethod rm = new RMethod(ruby_id);
            DefineMethod("hash", rm, 0);
            DefineMethod("id", rm, 0);
            DefineMethod("__id__", rm, 0);
            rm = new RMethod(ruby_class);
            DefineMethod("type", rm, 0);
            DefineMethod("class", rm, 0);
        
            DefineMethod("clone", new RMethod(ruby_clone), 0);
            DefineMethod("dup", new RMethod(ruby_dup), 0);
                   DefineMethod("taint", new RMethod(ruby_taint), 0);
            DefineMethod("tainted?", new RMethod(ruby_istainted), 0);
        
            DefineMethod("Untaint", new RMethod(ruby_untaint), 0);
            DefineMethod("freeze", new RMethod(ruby_freeze), 0);
            DefineMethod("frozen?", new RMethod(ruby_isfrozen), 0);
        
            DefineMethod("to_a", new RMethod(ruby_to_a), 0);
            DefineMethod("to_s", new RMethod(ruby_to_s), 0);
            DefineMethod("inspect", new RMethod(ruby_inspect), 0);
            rm = new RMethod(ruby_methods);
            DefineMethod("methods", rm, 0);
            DefineMethod("public_methods", rm, 0);
            DefineMethod("singleton_methods", new RMethod(ruby_singleton_methods), 0);
            DefineMethod("protected_methods", new RMethod(ruby_protected_methods), 0);
            DefineMethod("private_methods", new RMethod(ruby_private_methods), 0);
            DefineMethod("instance_variables", new RMethod(ruby_instance_variables), 0);
            DefinePrivateMethod("remove_instance_variable",
                                new RMethod(ruby_remove_instance_variable), 1);
            DefineMethod("instance_of?", new RMethod(IsInstanceOf), 1);
            rm = new RMethod(IsKindOf);
            DefineMethod("kind_of?", rm, 1);
            DefineMethod("is_a?", rm, 1);

            rb.DefineGlobalFunction("singleton_method_added", rmDummy, 1);
            rb.DefineGlobalFunction("sprintf", new RMethod(sprintf), -1);
            rb.DefineGlobalFunction("format",  new RMethod(sprintf), -1);

            rb.DefineGlobalFunction("Integer", new RMethod(ruby_integer), 1);
            rb.DefineGlobalFunction("Float", new RMethod(ruby_float), 1);
            rb.DefineGlobalFunction("String", new RMethod(ruby_string), 1);
            rb.DefineGlobalFunction("Array", new RMethod(ruby_array), 1);
        
            rb.DefineGlobalFunction("sleep", new RMethod(ruby_sleep), -1);
        
            rb.oNil = new RNil(rb);
            rb.oNil.Init(rb);

            Symbol.Init(rb);

            obj = typeof(RMetaObject);
                rb.cModule.DefineMethod("===", obj.GetMethod("Eqq"));
            rb.cModule.DefineMethod("<=>", obj.GetMethod("CompareTo"));
            rb.cModule.DefineMethod("<", obj.GetMethod("lt"));
            rb.cModule.DefineMethod("<=", obj.GetMethod("le"));
            rb.cModule.DefineMethod(">", obj.GetMethod("gt"));
            rb.cModule.DefineMethod(">=", obj.GetMethod("ge"));
        
            rb.cModule.DefineMethod("included_modules", obj.GetMethod("IncludedModules"));
            rb.cModule.DefineMethod("name", obj.GetMethod("get_ModuleName"));

            rb.cModule.DefineMethod("attr", new RMethod(attr), -1);
            rb.cModule.DefineMethod("attr_reader", new RMethod(attr_reader), -1);
            rb.cModule.DefineMethod("attr_writer", new RMethod(attr_writer), -1);
            rb.cModule.DefineMethod("attr_accessor", new RMethod(attr_accessor), -1);

            rb.cModule.DefineSingletonMethod("new", new RMethod(s_new), 0);
            rb.cModule.DefineMethod("initialize", new RMethod(initialize), -1);
        
            rb.cModule.DefineMethod("instance_methods", obj.GetMethod("ClassInstanceMethods", bf));
            rb.cModule.DefineMethod("public_instance_methods", obj.GetMethod("ClassInstanceMethods", bf));
            rb.cModule.DefineMethod("protected_instance_methods", obj.GetMethod("ClassProtectedInstanceMethods", bf));
            rb.cModule.DefineMethod("private_instance_methods", obj.GetMethod("ClassPrivateInstanceMethods", bf));

            rb.cModule.DefineMethod("constants", new RMethod(rb.cModule.constants), 0);
            rb.cModule.DefineMethod("const_get", new RMethod(rb.cModule.const_get), 1);
            rb.cModule.DefineMethod("const_set", new RMethod(rb.cModule.const_set), 2);
            rb.cModule.DefineMethod("const_defined?", new RMethod(rb.cModule.is_const_defined), 1);
            rb.cModule.DefineMethod("remove_const", new RMethod(rb.cModule.remove_const), 1);
            rb.cModule.DefineMethod("method_added", rmDummy, 1);

            obj = rb.cClass.GetType();
            rb.cClass.DefineMethod("new", new RMethod(ruby_new), -1);
            rb.cClass.DefineMethod("superclass", new RMethod(ruby_superclass), 0);
            rb.cClass.DefineSingletonMethod("new", new RMethod(ruby_s_new), -1);
            rb.cClass.UndefMethod("extend_object");
            rb.cClass.UndefMethod("append_feartures");
            rb.cClass.DefineSingletonMethod("inherited", new RMethod(RClass.Inherited), 1);
        
            rb.cData = rb.DefineClass("Data", rb.cObject);
            rb.ClassOf(rb.cData).UndefMethod("new");

            rb.topSelf = new RMainObject(rb);

            rb.oTrue = new RTrue(rb);
            rb.oTrue.Init(rb);
            rb.oFalse = new RFalse(rb);
            rb.oFalse.Init(rb);
        }

        static internal new void Init(NetRuby rb)
        {
            RClass big = rb.DefineClass("Bignum", rb.cInteger);
            rb.cBignum = big;

            big.DefineMethod("~", new RMethod(ruby_neg), 0);
        
            RMethod rm = new RMethod(ruby_eq);
            big.DefineMethod("==", rm, 1);
            big.DefineMethod("===", rm, 1);
            big.DefineMethod("eql?", rm, 1);
        }

        internal void Init(NetRuby rb)
        {
            BindingFlags bf = BindingFlags.InvokeMethod
                | BindingFlags.Static | BindingFlags.Public
                | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy
                | BindingFlags.Instance;
            rb.cNilClass = rb.DefineClass("NilClass", rb.cObject);
            Type obj = typeof(RNil);
            rb.cNilClass.DefineMethod("to_i", obj.GetMethod("ToInteger", bf));
            rb.cNilClass.DefineMethod("to_a", obj.GetMethod("ToArray", bf));
            rb.cNilClass.DefineMethod("to_s", new RMethod(nil_to_s), 0);
            rb.cNilClass.DefineMethod("&", new RMethod(ruby_and), 1);
            rb.cNilClass.DefineMethod("|", new RMethod(ruby_or), 1);
            rb.cNilClass.DefineMethod("^", new RMethod(ruby_xor), 1);
            rb.cNilClass.DefineMethod("nil?", new RMethod(ruby_true), 0);

            rb.ClassOf(rb.cNilClass).UndefMethod("new");
            rb.DefineGlobalConst("NIL", null);
        }

        static internal void Init(NetRuby rb)
        {
            rb.eRegexpError = rb.DefineClass("RegexpError", rb.eStandardError);

            rb.DefineVirtualVariable("$~",
                                  new GlobalEntry.Getter(matchGetter),
                                  new GlobalEntry.Setter(matchSetter));
            rb.DefineVirtualVariable("$&",
                                     new GlobalEntry.Getter(lastMatchGetter), null);
            rb.DefineVirtualVariable("$`",
                                     new GlobalEntry.Getter(preMatchGetter), null);
            rb.DefineVirtualVariable("$'",
                                     new GlobalEntry.Getter(postMatchGetter), null);
            rb.DefineVirtualVariable("$+",
                                     new GlobalEntry.Getter(lastParenGetter), null);
            rb.DefineVirtualVariable("$=",
                                  new GlobalEntry.Getter(iCaseGetter),
                                  new GlobalEntry.Setter(iCaseSetter));
            rb.DefineVirtualVariable("$KCODE",
                                  new GlobalEntry.Getter(kCodeGetter),
                                  new GlobalEntry.Setter(kCodeSetter));
            rb.DefineVirtualVariable("$-K",
                                  new GlobalEntry.Getter(kCodeGetter),
                                  new GlobalEntry.Setter(kCodeSetter));

            RRegexpClass reg = new RRegexpClass(rb);
            reg.DefineClass("Regexp", rb.cObject);
            rb.cRegexp = reg;

            reg.DefineSingletonMethod("new", new RMethod(s_new), -1);
            reg.DefineSingletonMethod("compile", new RMethod(s_new), -1);
            reg.DefineSingletonMethod("quote", new RMethod(s_quote), -1);
            reg.DefineSingletonMethod("escape", new RMethod(s_quote), -1);
            reg.DefineSingletonMethod("last_match", new RMethod(s_lastmatch), 0);
        
            reg.DefineMethod("initialize", new RMethod(initialize), -1);
            reg.DefineMethod("=~", new RMethod(match), 1);
            reg.DefineMethod("===", new RMethod(match), 1);
            reg.DefineMethod("~", new RMethod(match2), 0);
            reg.DefineMethod("match", new RMethod(match_m), 1);
            reg.DefineMethod("source", new RMethod(source), 0);
            reg.DefineMethod("casefold?", new RMethod(casefold_p), 0);
            reg.DefineMethod("kcode", new RMethod(kcode_m), 0);

            reg.DefineConst("IGNORECASE", RegexOptions.IgnoreCase);
            reg.DefineConst("EXTENDED", RegexOptions.IgnorePatternWhitespace);
            reg.DefineConst("MULTILINE", RegexOptions.Multiline);

            RClass md = rb.DefineClass("MatchData", rb.cObject);
            rb.DefineGlobalConst("MatchingData", md);
            rb.cMatch = md;
            rb.ClassOf(md).UndefMethod("new");
            md.DefineMethod("size", new RMethod(match_size), 0);
            md.DefineMethod("length", new RMethod(match_size), 0);
            md.DefineMethod("offset", new RMethod(match_offset), 1);
            md.DefineMethod("begin", new RMethod(match_begin), 1);
            md.DefineMethod("end", new RMethod(match_end), 1);
            md.DefineMethod("to_a", new RMethod(match_to_a), 0);
            md.DefineMethod("[]", new RMethod(match_aref), -1);
            md.DefineMethod("pre_match", new RMethod(match_pre), 0);
            md.DefineMethod("post_match", new RMethod(match_post), 0);
            md.DefineMethod("to_s", new RMethod(match_to_s), 0);
            md.DefineMethod("string", new RMethod(match_string), 0);
        }

 internal static void Init(NetRuby rb)
 {
     RClass ex = rb.DefineClass("Exception", rb.cObject);
     rb.eException = ex;
     ex.DefineSingletonMethod("exception", new RMethod(exc_new), -1);
     ex.DefineMethod("exception", new RMethod(exc_exception), -1);
     ex.DefineMethod("initialize", new RMethod(exc_initialize), -1);
     ex.DefineMethod("message", new RMethod(exc_to_s), 0);
     ex.DefineMethod("backtrace", new RMethod(exc_backtrace), 0);
     ex.DefineMethod("set_backtrace", new RMethod(exc_set_backtrace), 0);
     rb.eSystemExit = rb.DefineClass("SystemExit", ex);
     rb.eFatal              = rb.DefineClass("Fatal", ex);
     rb.eInterrupt   = rb.DefineClass("Interrupt", ex);
     rb.eSignal      = rb.DefineClass("SignalException", ex);
     rb.eStandardError = rb.DefineClass("StandardError", ex);
     rb.eTypeError   = rb.DefineClass("TypeError", rb.eStandardError);
     rb.eArgError    = rb.DefineClass("ArgumentError", rb.eStandardError);
     rb.eIndexError  = rb.DefineClass("IndexError", rb.eStandardError);
     rb.eRangeError  = rb.DefineClass("RangeError", rb.eStandardError);
     rb.eScriptError = rb.DefineClass("ScriptError", ex);
     rb.eSyntaxError = rb.DefineClass("SyntaxError", rb.eScriptError);
     rb.eNameError   = rb.DefineClass("NameError", rb.eScriptError);
     rb.eLoadError   = rb.DefineClass("LoadError", rb.eScriptError);
     rb.eNotImpError = rb.DefineClass("NotImplementedError", rb.eScriptError);
     rb.eRuntimeError = rb.DefineClass("RuntimeError", rb.eStandardError);
     rb.eSecurityError = rb.DefineClass("SecurityError", rb.eStandardError);
     rb.eNoMemError = rb.DefineClass("NoMemoryError", ex);
 }

        internal static new void Init(NetRuby rb)
        {
            RClass it = rb.DefineClass("Integer", rb.cNumeric);
            rb.cInteger = it;
            rb.ClassOf(it).UndefMethod("new");

            it.DefineMethod("upto", new RMethod(int_upto), 1);
            it.DefineMethod("downto", new RMethod(int_downto), 1);
            it.DefineMethod("step", new RMethod(int_step), 2);

            it.DefineMethod("to_int", new RMethod(num_to_i), 0);
            it.DefineMethod("floor", new RMethod(num_to_i), 0);
            it.DefineMethod("ceil", new RMethod(num_to_i), 0);
            it.DefineMethod("round", new RMethod(num_to_i), 0);

        }

        static internal void Init(NetRuby rb)
        {
            BindingFlags bf = BindingFlags.InvokeMethod
                | BindingFlags.Static | BindingFlags.Public
                | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy
                | BindingFlags.Instance;
            RClass str = rb.DefineClass("String", rb.cObject);
            rb.cString = str;
            rb.oString = new RString(rb, String.Empty);
#if MIXIN
            RClass.IncludeModule(str, rb.mComparable);
            RClass.IncludeModule(str, rb.mEnumerable);
#endif
            Type obj = typeof(RString);
            str.DefineSingletonMethod("new", obj.GetMethod("New", bf));
            str.DefineMethod("initialize", obj.GetMethod("Initialize", bf));
            str.DefineMethod("clone", obj.GetMethod("Clone", bf));
            str.DefineMethod("dup", obj.GetMethod("Dup", new Type[0]));
            str.DefineMethod("<=>", obj.GetMethod("CompareMethod", bf));
            str.DefineMethod("eql?", obj.GetMethod("Equals", bf & (~BindingFlags.Static)));
            str.DefineMethod("equal?", new RMethod(rb.oString.str_equal), 1);
            str.DefineMethod("+", obj.GetMethod("Plus", bf));
            str.DefineMethod("length", obj.GetMethod("get_Length", bf));
            str.DefineMethod("size", obj.GetMethod("get_Length", bf));
            str.DefineMethod("empty?", obj.GetMethod("get_IsEmpty", bf));
        
            str.DefineMethod("to_i", obj.GetMethod("ToInteger", new Type[0]));
            str.DefineMethod("to_f", obj.GetMethod("ToFloat", bf));
            MethodInfo mi = obj.GetMethod("ToRString", bf);
            str.DefineMethod("to_s", mi);
            str.DefineMethod("to_str", mi);
            str.DefineMethod("inspect", obj.GetMethod("Inspect", bf));
            str.DefineMethod("dump", obj.GetMethod("Dump", bf));

            str.DefineMethod("upcase", obj.GetMethod("UpCase", bf));
            str.DefineMethod("downcase", obj.GetMethod("DownCase", bf));
            str.DefineMethod("capitalize", obj.GetMethod("Capitalize", bf));
            str.DefineMethod("swapcase", obj.GetMethod("SwapCase", bf));

            str.DefineMethod("upcase!", obj.GetMethod("UpCaseBang", bf));
            str.DefineMethod("downcase!", obj.GetMethod("DownCaseBang", bf));
            str.DefineMethod("capitalize!", obj.GetMethod("CapitalizeBang", bf));
            str.DefineMethod("swapcase!", obj.GetMethod("SwapCaseBang", bf));

            str.DefineMethod("sub", obj.GetMethod("Sub", bf));
            str.DefineMethod("gsub", obj.GetMethod("Gsub", bf));

            str.DefineMethod("sub!", obj.GetMethod("SubAt", bf));
            str.DefineMethod("gsub!", obj.GetMethod("GsubAt", bf));
        }