debase-ruby_core_source 0.7.9 → 0.7.10

data/lib/debase/ruby_core_source/ruby-2.0.0-p647/gc.h

@@ -0,0 +1,104 @@
+
+#ifndef RUBY_GC_H
+#define RUBY_GC_H 1
+
+#if defined(__x86_64__) && defined(__GNUC__) && !defined(__native_client__)
+#define SET_MACHINE_STACK_END(p) __asm__ volatile ("movq\t%%rsp, %0" : "=r" (*(p)))
+#elif defined(__i386) && defined(__GNUC__) && !defined(__native_client__)
+#define SET_MACHINE_STACK_END(p) __asm__ volatile ("movl\t%%esp, %0" : "=r" (*(p)))
+#else
+NOINLINE(void rb_gc_set_stack_end(VALUE **stack_end_p));
+#define SET_MACHINE_STACK_END(p) rb_gc_set_stack_end(p)
+#define USE_CONSERVATIVE_STACK_END
+#endif
+
+/* for GC debug */
+
+#ifndef RUBY_MARK_FREE_DEBUG
+#define RUBY_MARK_FREE_DEBUG 0
+#endif
+
+#if RUBY_MARK_FREE_DEBUG
+extern int ruby_gc_debug_indent;
+
+static inline void
+rb_gc_debug_indent(void)
+{
+    printf("%*s", ruby_gc_debug_indent, "");
+}
+
+static inline void
+rb_gc_debug_body(const char *mode, const char *msg, int st, void *ptr)
+{
+    if (st == 0) {
+	ruby_gc_debug_indent--;
+    }
+    rb_gc_debug_indent();
+    printf("%s: %s %s (%p)\n", mode, st ? "->" : "<-", msg, ptr);
+
+    if (st) {
+	ruby_gc_debug_indent++;
+    }
+
+    fflush(stdout);
+}
+
+#define RUBY_MARK_ENTER(msg) rb_gc_debug_body("mark", (msg), 1, ptr)
+#define RUBY_MARK_LEAVE(msg) rb_gc_debug_body("mark", (msg), 0, ptr)
+#define RUBY_FREE_ENTER(msg) rb_gc_debug_body("free", (msg), 1, ptr)
+#define RUBY_FREE_LEAVE(msg) rb_gc_debug_body("free", (msg), 0, ptr)
+#define RUBY_GC_INFO         rb_gc_debug_indent(); printf
+
+#else
+#define RUBY_MARK_ENTER(msg)
+#define RUBY_MARK_LEAVE(msg)
+#define RUBY_FREE_ENTER(msg)
+#define RUBY_FREE_LEAVE(msg)
+#define RUBY_GC_INFO if(0)printf
+#endif
+
+#define RUBY_MARK_UNLESS_NULL(ptr) if(RTEST(ptr)){rb_gc_mark(ptr);}
+#define RUBY_FREE_UNLESS_NULL(ptr) if(ptr){ruby_xfree(ptr);(ptr)=NULL;}
+
+#if STACK_GROW_DIRECTION > 0
+# define STACK_UPPER(x, a, b) (a)
+#elif STACK_GROW_DIRECTION < 0
+# define STACK_UPPER(x, a, b) (b)
+#else
+RUBY_EXTERN int ruby_stack_grow_direction;
+int ruby_get_stack_grow_direction(volatile VALUE *addr);
+# define stack_growup_p(x) (			\
+	(ruby_stack_grow_direction ?		\
+	 ruby_stack_grow_direction :		\
+	 ruby_get_stack_grow_direction(x)) > 0)
+# define STACK_UPPER(x, a, b) (stack_growup_p(x) ? (a) : (b))
+#endif
+
+#if STACK_GROW_DIRECTION
+#define STACK_GROW_DIR_DETECTION
+#define STACK_DIR_UPPER(a,b) STACK_UPPER(0, (a), (b))
+#else
+#define STACK_GROW_DIR_DETECTION VALUE stack_grow_dir_detection
+#define STACK_DIR_UPPER(a,b) STACK_UPPER(&stack_grow_dir_detection, (a), (b))
+#endif
+#define IS_STACK_DIR_UPPER() STACK_DIR_UPPER(1,0)
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+/* exports for objspace module */
+size_t rb_objspace_data_type_memsize(VALUE obj);
+void rb_objspace_reachable_objects_from(VALUE obj, void (func)(VALUE, void *), void *data);
+int rb_objspace_markable_object_p(VALUE obj);
+int rb_objspace_internal_object_p(VALUE obj);
+
+void rb_objspace_each_objects(
+    int (*callback)(void *start, void *end, size_t stride, void *data),
+    void *data);
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#endif /* RUBY_GC_H */

data/lib/debase/ruby_core_source/ruby-2.0.0-p647/id.h

@@ -0,0 +1,135 @@
+/* DO NOT EDIT THIS FILE DIRECTLY */
+/**********************************************************************
+
+  id.h -
+
+  $Author: nobu $
+  created at: Sun Oct 19 21:12:51 2008
+
+  Copyright (C) 2007 Koichi Sasada
+
+**********************************************************************/
+
+#ifndef RUBY_ID_H
+#define RUBY_ID_H
+
+#define ID_SCOPE_SHIFT 3
+#define ID_SCOPE_MASK 0x07
+#define ID_LOCAL      0x00
+#define ID_INSTANCE   0x01
+#define ID_GLOBAL     0x03
+#define ID_ATTRSET    0x04
+#define ID_CONST      0x05
+#define ID_CLASS      0x06
+#define ID_JUNK       0x07
+#define ID_INTERNAL   ID_JUNK
+
+#define ID2ATTRSET(id) (((id)&~ID_SCOPE_MASK)|ID_ATTRSET)
+
+#define symIFUNC ID2SYM(idIFUNC)
+#define symCFUNC ID2SYM(idCFUNC)
+
+#define RUBY_TOKEN_DOT2 128
+#define RUBY_TOKEN_DOT3 129
+#define RUBY_TOKEN_UPLUS 130
+#define RUBY_TOKEN_UMINUS 131
+#define RUBY_TOKEN_POW 132
+#define RUBY_TOKEN_DSTAR 133
+#define RUBY_TOKEN_CMP 134
+#define RUBY_TOKEN_LSHFT 135
+#define RUBY_TOKEN_RSHFT 136
+#define RUBY_TOKEN_LEQ 137
+#define RUBY_TOKEN_GEQ 138
+#define RUBY_TOKEN_EQ 139
+#define RUBY_TOKEN_EQQ 140
+#define RUBY_TOKEN_NEQ 141
+#define RUBY_TOKEN_MATCH 142
+#define RUBY_TOKEN_NMATCH 143
+#define RUBY_TOKEN_AREF 144
+#define RUBY_TOKEN_ASET 145
+#define RUBY_TOKEN_COLON2 146
+#define RUBY_TOKEN_COLON3 147
+#define RUBY_TOKEN(t) RUBY_TOKEN_##t
+
+enum ruby_method_ids {
+    idDot2 = RUBY_TOKEN(DOT2),
+    idDot3 = RUBY_TOKEN(DOT3),
+    idUPlus = RUBY_TOKEN(UPLUS),
+    idUMinus = RUBY_TOKEN(UMINUS),
+    idPow = RUBY_TOKEN(POW),
+    idCmp = RUBY_TOKEN(CMP),
+    idPLUS = '+',
+    idMINUS = '-',
+    idMULT = '*',
+    idDIV = '/',
+    idMOD = '%',
+    idLT = '<',
+    idLTLT = RUBY_TOKEN(LSHFT),
+    idLE = RUBY_TOKEN(LEQ),
+    idGT = '>',
+    idGE = RUBY_TOKEN(GEQ),
+    idEq = RUBY_TOKEN(EQ),
+    idEqq = RUBY_TOKEN(EQQ),
+    idNeq = RUBY_TOKEN(NEQ),
+    idNot = '!',
+    idBackquote = '`',
+    idEqTilde = RUBY_TOKEN(MATCH),
+    idNeqTilde = RUBY_TOKEN(NMATCH),
+    idAREF = RUBY_TOKEN(AREF),
+    idASET = RUBY_TOKEN(ASET),
+    tPRESERVED_ID_BEGIN = 147,
+    idNULL,
+    idEmptyP,
+    idRespond_to,
+    idRespond_to_missing,
+    idIFUNC,
+    idCFUNC,
+    id_core_set_method_alias,
+    id_core_set_variable_alias,
+    id_core_undef_method,
+    id_core_define_method,
+    id_core_define_singleton_method,
+    id_core_set_postexe,
+    id_core_hash_from_ary,
+    id_core_hash_merge_ary,
+    id_core_hash_merge_ptr,
+    id_core_hash_merge_kwd,
+    tPRESERVED_ID_END,
+    tIntern,
+    tMethodMissing,
+    tLength,
+    tSize,
+    tGets,
+    tSucc,
+    tEach,
+    tProc,
+    tLambda,
+    tSend,
+    t__send__,
+    tInitialize,
+    tInitialize_copy,
+    tInitialize_clone,
+    tInitialize_dup,
+    tUScore,
+#define TOKEN2LOCALID(n) id##n = ((t##n<<ID_SCOPE_SHIFT)|ID_LOCAL)
+    TOKEN2LOCALID(Intern),
+    TOKEN2LOCALID(MethodMissing),
+    TOKEN2LOCALID(Length),
+    TOKEN2LOCALID(Size),
+    TOKEN2LOCALID(Gets),
+    TOKEN2LOCALID(Succ),
+    TOKEN2LOCALID(Each),
+    TOKEN2LOCALID(Proc),
+    TOKEN2LOCALID(Lambda),
+    TOKEN2LOCALID(Send),
+    TOKEN2LOCALID(__send__),
+    TOKEN2LOCALID(Initialize),
+    TOKEN2LOCALID(Initialize_copy),
+    TOKEN2LOCALID(Initialize_clone),
+    TOKEN2LOCALID(Initialize_dup),
+    TOKEN2LOCALID(UScore),
+    tLAST_OP_ID = tPRESERVED_ID_END-1,
+    idLAST_OP_ID = tLAST_OP_ID >> ID_SCOPE_SHIFT
+};
+
+#endif /* RUBY_ID_H */

data/lib/debase/ruby_core_source/ruby-2.0.0-p647/insns.inc

@@ -0,0 +1,187 @@
+/** -*-c-*-
+  This file contains YARV instructions list.
+
+  ----
+  This file is auto generated by insns2vm.rb
+  DO NOT TOUCH!
+
+  If you want to fix something, you must edit 'template/insns.inc.tmpl'
+  or insns2vm.rb
+ */
+
+
+/* BIN : Basic Instruction Name */
+#define BIN(n) YARVINSN_##n
+
+enum ruby_vminsn_type {
+  BIN(nop)                       = 0,
+
+  BIN(getlocal)                  = 1,
+
+  BIN(setlocal)                  = 2,
+
+  BIN(getspecial)                = 3,
+
+  BIN(setspecial)                = 4,
+
+  BIN(getinstancevariable)       = 5,
+
+  BIN(setinstancevariable)       = 6,
+
+  BIN(getclassvariable)          = 7,
+
+  BIN(setclassvariable)          = 8,
+
+  BIN(getconstant)               = 9,
+
+  BIN(setconstant)               = 10,
+
+  BIN(getglobal)                 = 11,
+
+  BIN(setglobal)                 = 12,
+
+  BIN(putnil)                    = 13,
+
+  BIN(putself)                   = 14,
+
+  BIN(putobject)                 = 15,
+
+  BIN(putspecialobject)          = 16,
+
+  BIN(putiseq)                   = 17,
+
+  BIN(putstring)                 = 18,
+
+  BIN(concatstrings)             = 19,
+
+  BIN(tostring)                  = 20,
+
+  BIN(toregexp)                  = 21,
+
+  BIN(newarray)                  = 22,
+
+  BIN(duparray)                  = 23,
+
+  BIN(expandarray)               = 24,
+
+  BIN(concatarray)               = 25,
+
+  BIN(splatarray)                = 26,
+
+  BIN(newhash)                   = 27,
+
+  BIN(newrange)                  = 28,
+
+  BIN(pop)                       = 29,
+
+  BIN(dup)                       = 30,
+
+  BIN(dupn)                      = 31,
+
+  BIN(swap)                      = 32,
+
+  BIN(reput)                     = 33,
+
+  BIN(topn)                      = 34,
+
+  BIN(setn)                      = 35,
+
+  BIN(adjuststack)               = 36,
+
+  BIN(defined)                   = 37,
+
+  BIN(checkmatch)                = 38,
+
+  BIN(trace)                     = 39,
+
+  BIN(defineclass)               = 40,
+
+  BIN(send)                      = 41,
+
+  BIN(opt_send_simple)           = 42,
+
+  BIN(invokesuper)               = 43,
+
+  BIN(invokeblock)               = 44,
+
+  BIN(leave)                     = 45,
+
+  BIN(throw)                     = 46,
+
+  BIN(jump)                      = 47,
+
+  BIN(branchif)                  = 48,
+
+  BIN(branchunless)              = 49,
+
+  BIN(getinlinecache)            = 50,
+
+  BIN(onceinlinecache)           = 51,
+
+  BIN(setinlinecache)            = 52,
+
+  BIN(opt_case_dispatch)         = 53,
+
+  BIN(opt_plus)                  = 54,
+
+  BIN(opt_minus)                 = 55,
+
+  BIN(opt_mult)                  = 56,
+
+  BIN(opt_div)                   = 57,
+
+  BIN(opt_mod)                   = 58,
+
+  BIN(opt_eq)                    = 59,
+
+  BIN(opt_neq)                   = 60,
+
+  BIN(opt_lt)                    = 61,
+
+  BIN(opt_le)                    = 62,
+
+  BIN(opt_gt)                    = 63,
+
+  BIN(opt_ge)                    = 64,
+
+  BIN(opt_ltlt)                  = 65,
+
+  BIN(opt_aref)                  = 66,
+
+  BIN(opt_aset)                  = 67,
+
+  BIN(opt_length)                = 68,
+
+  BIN(opt_size)                  = 69,
+
+  BIN(opt_empty_p)               = 70,
+
+  BIN(opt_succ)                  = 71,
+
+  BIN(opt_not)                   = 72,
+
+  BIN(opt_regexpmatch1)          = 73,
+
+  BIN(opt_regexpmatch2)          = 74,
+
+  BIN(opt_call_c_function)       = 75,
+
+  BIN(bitblt)                    = 76,
+
+  BIN(answer)                    = 77,
+
+  BIN(getlocal_OP__WC__0)        = 78,
+
+  BIN(getlocal_OP__WC__1)        = 79,
+
+  BIN(setlocal_OP__WC__0)        = 80,
+
+  BIN(setlocal_OP__WC__1)        = 81,
+
+  BIN(putobject_OP_INT2FIX_O_0_C_) = 82,
+
+  BIN(putobject_OP_INT2FIX_O_1_C_) = 83,
+
+  VM_INSTRUCTION_SIZE            = 84
+};
+

data/lib/debase/ruby_core_source/ruby-2.0.0-p647/insns_info.inc

@@ -0,0 +1,724 @@
+/** -*-c-*-
+  This file contains instruction information for yarv instruction sequence.
+
+  ----
+  This file is auto generated by insns2vm.rb
+  DO NOT TOUCH!
+
+  If you want to fix something, you must edit 'template/insns_info.inc.tmpl'
+  or insns2vm.rb
+ */
+
+#define TS_OFFSET 'O'
+#define TS_NUM 'N'
+#define TS_LINDEX 'L'
+#define TS_VALUE 'V'
+#define TS_ID 'I'
+#define TS_GENTRY 'G'
+#define TS_IC 'K'
+#define TS_CALLINFO 'C'
+#define TS_CDHASH 'H'
+#define TS_ISEQ 'S'
+#define TS_VARIABLE '.'
+#define TS_FUNCPTR 'F'
+
+static const char *const insn_name_info[] = {
+  "nop",
+  "getlocal",
+  "setlocal",
+  "getspecial",
+  "setspecial",
+  "getinstancevariable",
+  "setinstancevariable",
+  "getclassvariable",
+  "setclassvariable",
+  "getconstant",
+  "setconstant",
+  "getglobal",
+  "setglobal",
+  "putnil",
+  "putself",
+  "putobject",
+  "putspecialobject",
+  "putiseq",
+  "putstring",
+  "concatstrings",
+  "tostring",
+  "toregexp",
+  "newarray",
+  "duparray",
+  "expandarray",
+  "concatarray",
+  "splatarray",
+  "newhash",
+  "newrange",
+  "pop",
+  "dup",
+  "dupn",
+  "swap",
+  "reput",
+  "topn",
+  "setn",
+  "adjuststack",
+  "defined",
+  "checkmatch",
+  "trace",
+  "defineclass",
+  "send",
+  "opt_send_simple",
+  "invokesuper",
+  "invokeblock",
+  "leave",
+  "throw",
+  "jump",
+  "branchif",
+  "branchunless",
+  "getinlinecache",
+  "onceinlinecache",
+  "setinlinecache",
+  "opt_case_dispatch",
+  "opt_plus",
+  "opt_minus",
+  "opt_mult",
+  "opt_div",
+  "opt_mod",
+  "opt_eq",
+  "opt_neq",
+  "opt_lt",
+  "opt_le",
+  "opt_gt",
+  "opt_ge",
+  "opt_ltlt",
+  "opt_aref",
+  "opt_aset",
+  "opt_length",
+  "opt_size",
+  "opt_empty_p",
+  "opt_succ",
+  "opt_not",
+  "opt_regexpmatch1",
+  "opt_regexpmatch2",
+  "opt_call_c_function",
+  "bitblt",
+  "answer",
+  "getlocal_OP__WC__0",
+  "getlocal_OP__WC__1",
+  "setlocal_OP__WC__0",
+  "setlocal_OP__WC__1",
+  "putobject_OP_INT2FIX_O_0_C_",
+  "putobject_OP_INT2FIX_O_1_C_",
+
+};
+
+static const char *const insn_operand_info[] = {
+  "", 
+  "LN", 
+  "LN", 
+  "NN", 
+  "N", 
+  "IK", 
+  "IK", 
+  "I", 
+  "I", 
+  "I", 
+  "I", 
+  "G", 
+  "G", 
+  "", 
+  "", 
+  "V", 
+  "N", 
+  "S", 
+  "V", 
+  "N", 
+  "", 
+  "NN", 
+  "N", 
+  "V", 
+  "NN", 
+  "", 
+  "V", 
+  "N", 
+  "N", 
+  "", 
+  "", 
+  "N", 
+  "", 
+  "", 
+  "N", 
+  "N", 
+  "N", 
+  "NVV", 
+  "N", 
+  "N", 
+  "ISN", 
+  "C", 
+  "C", 
+  "C", 
+  "C", 
+  "", 
+  "N", 
+  "O", 
+  "O", 
+  "O", 
+  "OK", 
+  "OK", 
+  "K", 
+  "HO", 
+  "C", 
+  "C", 
+  "C", 
+  "C", 
+  "C", 
+  "C", 
+  "CC", 
+  "C", 
+  "C", 
+  "C", 
+  "C", 
+  "C", 
+  "C", 
+  "C", 
+  "C", 
+  "C", 
+  "C", 
+  "C", 
+  "C", 
+  "V", 
+  "", 
+  "F", 
+  "", 
+  "", 
+  "L", 
+  "L", 
+  "L", 
+  "L", 
+  "", 
+  "", 
+
+};
+
+static const int insn_len_info[] = {
+  1,
+  3,
+  3,
+  3,
+  2,
+  3,
+  3,
+  2,
+  2,
+  2,
+  2,
+  2,
+  2,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  2,
+  1,
+  3,
+  2,
+  2,
+  3,
+  1,
+  2,
+  2,
+  2,
+  1,
+  1,
+  2,
+  1,
+  1,
+  2,
+  2,
+  2,
+  4,
+  2,
+  2,
+  4,
+  2,
+  2,
+  2,
+  2,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  2,
+  3,
+  2,
+  2,
+  2,
+  2,
+  2,
+  2,
+  3,
+  2,
+  2,
+  2,
+  2,
+  2,
+  2,
+  2,
+  2,
+  2,
+  2,
+  2,
+  2,
+  2,
+  1,
+  2,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  1,
+  1,
+
+};
+
+#ifdef USE_INSN_RET_NUM
+static const int insn_stack_push_num_info[] = {
+  0,
+  1,
+  0,
+  1,
+  0,
+  1,
+  0,
+  1,
+  0,
+  1,
+  0,
+  1,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  2,
+  1,
+  2,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  1,
+  1,
+
+};
+#endif
+
+#ifdef USE_INSN_STACK_INCREASE
+static int
+insn_stack_increase(int depth, int insn, VALUE *opes)
+{
+  switch(insn){
+        case BIN(nop):{
+          return depth + 0;
+        }
+        case BIN(getlocal):{
+          return depth + 1;
+        }
+        case BIN(setlocal):{
+          return depth + -1;
+        }
+        case BIN(getspecial):{
+          return depth + 1;
+        }
+        case BIN(setspecial):{
+          return depth + -1;
+        }
+        case BIN(getinstancevariable):{
+          return depth + 1;
+        }
+        case BIN(setinstancevariable):{
+          return depth + -1;
+        }
+        case BIN(getclassvariable):{
+          return depth + 1;
+        }
+        case BIN(setclassvariable):{
+          return depth + -1;
+        }
+        case BIN(getconstant):{
+          return depth + 0;
+        }
+        case BIN(setconstant):{
+          return depth + -2;
+        }
+        case BIN(getglobal):{
+          return depth + 1;
+        }
+        case BIN(setglobal):{
+          return depth + -1;
+        }
+        case BIN(putnil):{
+          return depth + 1;
+        }
+        case BIN(putself):{
+          return depth + 1;
+        }
+        case BIN(putobject):{
+          return depth + 1;
+        }
+        case BIN(putspecialobject):{
+          return depth + 1;
+        }
+        case BIN(putiseq):{
+          return depth + 1;
+        }
+        case BIN(putstring):{
+          return depth + 1;
+        }
+        case BIN(concatstrings):{
+          int inc = 0;
+        int num = FIX2INT(opes[0]);
+        inc += 1 - num;;
+        return depth + inc;
+        }
+        case BIN(tostring):{
+          return depth + 0;
+        }
+        case BIN(toregexp):{
+          int inc = 0;
+        int cnt = FIX2INT(opes[1]);
+        inc += 1 - cnt;;
+        return depth + inc;
+        }
+        case BIN(newarray):{
+          int inc = 0;
+        int num = FIX2INT(opes[0]);
+        inc += 1 - num;;
+        return depth + inc;
+        }
+        case BIN(duparray):{
+          return depth + 1;
+        }
+        case BIN(expandarray):{
+          int inc = 0;
+        int num = FIX2INT(opes[0]);
+        int flag = FIX2INT(opes[1]);
+        inc += num - 1 + (flag & 1 ? 1 : 0);;
+        return depth + inc;
+        }
+        case BIN(concatarray):{
+          return depth + -1;
+        }
+        case BIN(splatarray):{
+          return depth + 0;
+        }
+        case BIN(newhash):{
+          int inc = 0;
+        int num = FIX2INT(opes[0]);
+        inc += 1 - num;;
+        return depth + inc;
+        }
+        case BIN(newrange):{
+          return depth + -1;
+        }
+        case BIN(pop):{
+          return depth + -1;
+        }
+        case BIN(dup):{
+          return depth + 1;
+        }
+        case BIN(dupn):{
+          int inc = 0;
+        int n = FIX2INT(opes[0]);
+        inc += n;;
+        return depth + inc;
+        }
+        case BIN(swap):{
+          return depth + 0;
+        }
+        case BIN(reput):{
+          int inc = 0;
+        inc += 0;;
+        return depth + inc;
+        }
+        case BIN(topn):{
+          int inc = 0;
+        inc += 1;;
+        return depth + inc;
+        }
+        case BIN(setn):{
+          int inc = 0;
+        inc += 0;
+        return depth + inc;
+        }
+        case BIN(adjuststack):{
+          int inc = 0;
+        int n = FIX2INT(opes[0]);
+        inc -= n;
+        return depth + inc;
+        }
+        case BIN(defined):{
+          return depth + 0;
+        }
+        case BIN(checkmatch):{
+          return depth + -1;
+        }
+        case BIN(trace):{
+          return depth + 0;
+        }
+        case BIN(defineclass):{
+          return depth + -1;
+        }
+        case BIN(send):{
+          int inc = 0;
+        CALL_INFO ci = (CALL_INFO)(opes[0]);
+        inc += - (int)(ci->orig_argc + ((ci->flag & VM_CALL_ARGS_BLOCKARG) ? 1 : 0));;
+        return depth + inc;
+        }
+        case BIN(opt_send_simple):{
+          int inc = 0;
+        CALL_INFO ci = (CALL_INFO)(opes[0]);
+        inc += -ci->orig_argc;;
+        return depth + inc;
+        }
+        case BIN(invokesuper):{
+          int inc = 0;
+        CALL_INFO ci = (CALL_INFO)(opes[0]);
+        inc += - (int)(ci->orig_argc + ((ci->flag & VM_CALL_ARGS_BLOCKARG) ? 1 : 0));;
+        return depth + inc;
+        }
+        case BIN(invokeblock):{
+          int inc = 0;
+        CALL_INFO ci = (CALL_INFO)(opes[0]);
+        inc += 1 - ci->orig_argc;;
+        return depth + inc;
+        }
+        case BIN(leave):{
+          return depth + 0;
+        }
+        case BIN(throw):{
+          return depth + 0;
+        }
+        case BIN(jump):{
+          return depth + 0;
+        }
+        case BIN(branchif):{
+          return depth + -1;
+        }
+        case BIN(branchunless):{
+          return depth + -1;
+        }
+        case BIN(getinlinecache):{
+          return depth + 1;
+        }
+        case BIN(onceinlinecache):{
+          return depth + 1;
+        }
+        case BIN(setinlinecache):{
+          return depth + 0;
+        }
+        case BIN(opt_case_dispatch):{
+          int inc = 0;
+        inc += -1;;
+        return depth + inc;
+        }
+        case BIN(opt_plus):{
+          return depth + -1;
+        }
+        case BIN(opt_minus):{
+          return depth + -1;
+        }
+        case BIN(opt_mult):{
+          return depth + -1;
+        }
+        case BIN(opt_div):{
+          return depth + -1;
+        }
+        case BIN(opt_mod):{
+          return depth + -1;
+        }
+        case BIN(opt_eq):{
+          return depth + -1;
+        }
+        case BIN(opt_neq):{
+          return depth + -1;
+        }
+        case BIN(opt_lt):{
+          return depth + -1;
+        }
+        case BIN(opt_le):{
+          return depth + -1;
+        }
+        case BIN(opt_gt):{
+          return depth + -1;
+        }
+        case BIN(opt_ge):{
+          return depth + -1;
+        }
+        case BIN(opt_ltlt):{
+          return depth + -1;
+        }
+        case BIN(opt_aref):{
+          return depth + -1;
+        }
+        case BIN(opt_aset):{
+          return depth + -2;
+        }
+        case BIN(opt_length):{
+          return depth + 0;
+        }
+        case BIN(opt_size):{
+          return depth + 0;
+        }
+        case BIN(opt_empty_p):{
+          return depth + 0;
+        }
+        case BIN(opt_succ):{
+          return depth + 0;
+        }
+        case BIN(opt_not):{
+          return depth + 0;
+        }
+        case BIN(opt_regexpmatch1):{
+          return depth + 0;
+        }
+        case BIN(opt_regexpmatch2):{
+          return depth + -1;
+        }
+        case BIN(opt_call_c_function):{
+          return depth + 0;
+        }
+        case BIN(bitblt):{
+          return depth + 1;
+        }
+        case BIN(answer):{
+          return depth + 1;
+        }
+        case BIN(getlocal_OP__WC__0):{
+          return depth + 1;
+        }
+        case BIN(getlocal_OP__WC__1):{
+          return depth + 1;
+        }
+        case BIN(setlocal_OP__WC__0):{
+          return depth + -1;
+        }
+        case BIN(setlocal_OP__WC__1):{
+          return depth + -1;
+        }
+        case BIN(putobject_OP_INT2FIX_O_0_C_):{
+          return depth + 1;
+        }
+        case BIN(putobject_OP_INT2FIX_O_1_C_):{
+          return depth + 1;
+        }
+
+  default:
+    rb_bug("insn_sp_increase: unreachable");
+  }
+  return 0;
+}
+#endif
+
+/* some utilities */
+
+static int
+insn_len(VALUE insn)
+{
+  return insn_len_info[(int)insn];
+}
+
+static const char *
+insn_name(VALUE insn)
+{
+  return insn_name_info[(int)insn];
+}
+
+static const char *
+insn_op_types(VALUE insn)
+{
+  return insn_operand_info[(int)insn];
+}
+
+static int
+insn_op_type(VALUE insn, long pos)
+{
+  int len = insn_len(insn) - 1;
+  if(pos < len){
+    return insn_operand_info[(int)insn][pos];
+  }
+  else{
+    return 0;
+  }
+}
+
+#ifdef USE_INSN_RET_NUM
+static int
+insn_ret_num(VALUE insn)
+{
+  return insn_stack_push_num_info[(int)insn];
+}
+#endif