nodewrap 0.5.0

data/ext/insns_info.c.rpp

@@ -0,0 +1,210 @@
+#include "insns_info.h"
+#include "ruby_version.h"
+
+#ifdef RUBY_HAS_YARV
+
+#ruby <<END
+  require 'ruby_source_dir'
+  insns_location = "#{RUBY_SOURCE_DIR}/insns.inc"
+  insns_info_location = "#{RUBY_SOURCE_DIR}/insns_info.inc"
+  insns_def_location = "#{RUBY_SOURCE_DIR}/insns.def"
+  iseq_c_location = "#{RUBY_SOURCE_DIR}/iseq.c"
+
+  INSTRUCTION_NAMES = []
+  record_instruction_names = false
+
+  [ insns_location, insns_info_location ].each do |file|
+    next if not File.exist?(file)
+
+    File.open(file) do |input|
+      while (line = input.gets) != nil do
+        line.chomp!
+        if line =~ /^\}/ then
+          record_instruction_names = false
+        end
+        if record_instruction_names then
+          name = line.chomp(',').gsub(/"/, '').lstrip.upcase
+          INSTRUCTION_NAMES.push(name) if name != ''
+        end
+        if line =~ /static.*insn_name_info.*=/ then
+          record_instruction_names = true
+        end
+      end
+    end
+  end
+
+  write = false
+
+  [ iseq_c_location ].each do |file|
+    next if not File.exist?(file)
+
+    File.open(file) do |input|
+      while (line = input.gets) != nil do
+        line.chomp!
+        case line
+        when /^make_compile_option\(/
+          puts 'void'
+          write = true
+        when /^static.*COMPILE_OPTION_DEFAULT.*=/
+          write = true
+        when /^static.*COMPILE_OPTION_FALSE;/
+          puts line
+        end
+        puts line if write
+        if line =~ /^\}/ then
+          write = false
+        end
+      end
+    end
+  end
+
+  INSTRUCTION_OPERAND_NAMES = {}
+
+  [ insns_def_location ].each do |file|
+    next if not File.exist?(file)
+
+    File.open(file) do |input|
+      while (line = input.gets) != nil do
+        line.chomp!
+        case line
+        when /^DEFINE_INSN/
+          name = input.gets.chomp
+          operand_line = input.gets.chomp
+          operand_line.gsub!(/\((.*)\)/, '\1')
+          operands = operand_line.split(',')
+          operand_names = operands.map { |x| x.split[1] }
+          INSTRUCTION_OPERAND_NAMES[name] = operand_names
+        end
+      end
+    end
+  end
+
+  nil
+END
+
+VALUE instruction_class[YARV_MAX_INSTRUCTION_SIZE];
+
+static ID operand_type_name_of(int operand_type)
+{
+  char const * retval = "????";
+
+  switch(operand_type)
+  {
+    case TS_ISEQ: retval = "iseq"; break;
+    case TS_GENTRY: retval = "gentry"; break;
+    case TS_OFFSET: retval = "operand"; break;
+    case TS_DINDEX: retval = "dindex"; break;
+    case TS_VARIABLE: retval = "variable"; break;
+    case TS_CDHASH: retval = "cdhash"; break;
+    case TS_IC: retval = "ic"; break;
+    case TS_ID: retval = "id"; break;
+    case TS_VALUE: retval = "value"; break;
+    case TS_LINDEX: retval = "lindex"; break;
+    case TS_NUM: retval = "num"; break;
+  }
+
+  return rb_intern(retval);
+}
+
+#ruby <<END
+INSTRUCTION_NAMES.each_with_index do |name, index|
+  $operand_names = INSTRUCTION_OPERAND_NAMES[name.downcase]
+
+# 1 #<VM::Instruction::TRACE:0x402d991c @length=2, @operands=[1],
+#   @instruction=45, @operand_types=[:num], @name=:trace>
+  puts <<-END
+/*
+ * call-seq:
+ *   insn.length => Integer
+ *
+ * Returns the length of the instruction.
+ */
+static VALUE insn_#{name}_length(VALUE self)
+{
+  return LONG2NUM(insn_len(#{index}));
+}
+
+/*
+ * call-seq:
+ *   insn.to_i => Integer
+ *
+ * Returns the numeric instruction number.
+ */
+static VALUE insn_#{name}_to_i(VALUE self)
+{
+  return NUM2LONG(#{index});
+}
+
+/*
+ * call-seq:
+ *   insn.operand_types => Array of Symbol
+ *
+ * Returns an array containing the types of the operands.
+ */
+static VALUE insn_#{name}_operand_types(VALUE self)
+{
+  VALUE operand_types = rb_ary_new();
+  char * s;
+
+  for(s = insn_op_types(#{index}); *s != '\\0'; ++s)
+  {
+    rb_ary_push(operand_types, ID2SYM(operand_type_name_of(*s)));
+  }
+
+  return operand_types;
+}
+
+/*
+ * call-seq:
+ *   insn.name => Symbol
+ *
+ * Returns the name of the instruction.
+ */
+static VALUE insn_#{name}_name(VALUE self)
+{
+  return rb_intern("#{name}");
+}
+
+/*
+ * call-seq:
+ *   insn.name => Symbol
+ *
+ * Returns the name of the operands for this instruction.
+ */
+static VALUE insn_#{name}_operand_names(VALUE self)
+{
+  VALUE v[] = {
+    #{$operand_names.map { |x| "ID2SYM(rb_intern(\"#{x}\"))" }.join(', ')}
+  };
+  return rb_ary_new4(#{$operand_names.size}, v);
+}
+
+  END
+end
+nil
+END
+
+void define_instruction_subclasses(VALUE rb_cInstruction)
+{
+  /* For rdoc: rb_cVM = rb_define_class("VM", rb_cObject); */
+  /* For rdoc: rb_cInstruction = rb_define_class_under(rb_cVM, "Instruction", rb_cObject); */
+
+#ruby <<END
+  INSTRUCTION_NAMES.each_with_index do |name, index|
+    puts <<-END
+  {
+    VALUE rb_cInstruction_#{name} = instruction_class[#{index}] = rb_define_class_under(rb_cInstruction, "#{name}", rb_cInstruction);
+    rb_define_method(rb_cInstruction_#{name}, "length", insn_#{name}_length, 0);
+    rb_define_method(rb_cInstruction_#{name}, "to_i", insn_#{name}_to_i, 0);
+    rb_define_method(rb_cInstruction_#{name}, "operand_types", insn_#{name}_operand_types, 0);
+    rb_define_method(rb_cInstruction_#{name}, "operand_names", insn_#{name}_operand_names, 0);
+    rb_define_method(rb_cInstruction_#{name}, "name", insn_#{name}_name, 0);
+  }
+    END
+  end
+  nil
+END
+}
+
+#endif
+

data/ext/insns_info.h

@@ -0,0 +1,819 @@
+#ifndef insns_info__h_
+#define insns_info__h_
+
+#include "ruby_version.h"
+
+#ifdef RUBY_HAS_YARV
+
+#include "vm.h"
+#include "ruby.h"
+#include "yarvcore.h"
+
+/** -*-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{
+  BIN(nop)                       = 0,
+  BIN(getlocal)                  = 1,
+  BIN(setlocal)                  = 2,
+  BIN(getspecial)                = 3,
+  BIN(setspecial)                = 4,
+  BIN(getdynamic)                = 5,
+  BIN(setdynamic)                = 6,
+  BIN(getinstancevariable)       = 7,
+  BIN(setinstancevariable)       = 8,
+  BIN(getclassvariable)          = 9,
+  BIN(setclassvariable)          = 10,
+  BIN(getconstant)               = 11,
+  BIN(setconstant)               = 12,
+  BIN(getglobal)                 = 13,
+  BIN(setglobal)                 = 14,
+  BIN(putnil)                    = 15,
+  BIN(putself)                   = 16,
+  BIN(putundef)                  = 17,
+  BIN(putobject)                 = 18,
+  BIN(putstring)                 = 19,
+  BIN(concatstrings)             = 20,
+  BIN(tostring)                  = 21,
+  BIN(toregexp)                  = 22,
+  BIN(newarray)                  = 23,
+  BIN(duparray)                  = 24,
+  BIN(expandarray)               = 25,
+  BIN(concatarray)               = 26,
+  BIN(splatarray)                = 27,
+  BIN(checkincludearray)         = 28,
+  BIN(newhash)                   = 29,
+  BIN(newrange)                  = 30,
+  BIN(putnot)                    = 31,
+  BIN(pop)                       = 32,
+  BIN(dup)                       = 33,
+  BIN(dupn)                      = 34,
+  BIN(swap)                      = 35,
+  BIN(reput)                     = 36,
+  BIN(topn)                      = 37,
+  BIN(setn)                      = 38,
+  BIN(emptstack)                 = 39,
+  BIN(definemethod)              = 40,
+  BIN(alias)                     = 41,
+  BIN(undef)                     = 42,
+  BIN(defined)                   = 43,
+  BIN(postexe)                   = 44,
+  BIN(trace)                     = 45,
+  BIN(defineclass)               = 46,
+  BIN(send)                      = 47,
+  BIN(invokesuper)               = 48,
+  BIN(invokeblock)               = 49,
+  BIN(leave)                     = 50,
+  BIN(finish)                    = 51,
+  BIN(throw)                     = 52,
+  BIN(jump)                      = 53,
+  BIN(branchif)                  = 54,
+  BIN(branchunless)              = 55,
+  BIN(getinlinecache)            = 56,
+  BIN(onceinlinecache)           = 57,
+  BIN(setinlinecache)            = 58,
+  BIN(opt_case_dispatch)         = 59,
+  BIN(opt_checkenv)              = 60,
+  BIN(opt_plus)                  = 61,
+  BIN(opt_minus)                 = 62,
+  BIN(opt_mult)                  = 63,
+  BIN(opt_div)                   = 64,
+  BIN(opt_mod)                   = 65,
+  BIN(opt_eq)                    = 66,
+  BIN(opt_lt)                    = 67,
+  BIN(opt_le)                    = 68,
+  BIN(opt_gt)                    = 69,
+  BIN(opt_ge)                    = 70,
+  BIN(opt_ltlt)                  = 71,
+  BIN(opt_aref)                  = 72,
+  BIN(opt_aset)                  = 73,
+  BIN(opt_length)                = 74,
+  BIN(opt_succ)                  = 75,
+  BIN(opt_regexpmatch1)          = 76,
+  BIN(opt_regexpmatch2)          = 77,
+  BIN(opt_call_native_compiled)  = 78,
+  BIN(bitblt)                    = 79,
+  BIN(answer)                    = 80,
+
+};
+
+#define YARV_MAX_INSTRUCTION_SIZE 81
+
+/** -*-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_ISEQ 'S'
+#define TS_GENTRY 'G'
+#define TS_OFFSET 'O'
+#define TS_DINDEX 'D'
+#define TS_VARIABLE '.'
+#define TS_CDHASH 'H'
+#define TS_IC 'C'
+#define TS_ID 'I'
+#define TS_VALUE 'V'
+#define TS_LINDEX 'L'
+#define TS_NUM 'N'
+
+static char *insn_name_info[] = {
+  "nop",
+  "getlocal",
+  "setlocal",
+  "getspecial",
+  "setspecial",
+  "getdynamic",
+  "setdynamic",
+  "getinstancevariable",
+  "setinstancevariable",
+  "getclassvariable",
+  "setclassvariable",
+  "getconstant",
+  "setconstant",
+  "getglobal",
+  "setglobal",
+  "putnil",
+  "putself",
+  "putundef",
+  "putobject",
+  "putstring",
+  "concatstrings",
+  "tostring",
+  "toregexp",
+  "newarray",
+  "duparray",
+  "expandarray",
+  "concatarray",
+  "splatarray",
+  "checkincludearray",
+  "newhash",
+  "newrange",
+  "putnot",
+  "pop",
+  "dup",
+  "dupn",
+  "swap",
+  "reput",
+  "topn",
+  "setn",
+  "emptstack",
+  "definemethod",
+  "alias",
+  "undef",
+  "defined",
+  "postexe",
+  "trace",
+  "defineclass",
+  "send",
+  "invokesuper",
+  "invokeblock",
+  "leave",
+  "finish",
+  "throw",
+  "jump",
+  "branchif",
+  "branchunless",
+  "getinlinecache",
+  "onceinlinecache",
+  "setinlinecache",
+  "opt_case_dispatch",
+  "opt_checkenv",
+  "opt_plus",
+  "opt_minus",
+  "opt_mult",
+  "opt_div",
+  "opt_mod",
+  "opt_eq",
+  "opt_lt",
+  "opt_le",
+  "opt_gt",
+  "opt_ge",
+  "opt_ltlt",
+  "opt_aref",
+  "opt_aset",
+  "opt_length",
+  "opt_succ",
+  "opt_regexpmatch1",
+  "opt_regexpmatch2",
+  "opt_call_native_compiled",
+  "bitblt",
+  "answer",
+
+};
+
+static char *insn_operand_info[] = {
+  "", 
+  "L", 
+  "L", 
+  "NN", 
+  "N", 
+  "DN", 
+  "DN", 
+  "I", 
+  "I", 
+  "I", 
+  "I", 
+  "I", 
+  "I", 
+  "G", 
+  "G", 
+  "", 
+  "", 
+  "", 
+  "V", 
+  "V", 
+  "N", 
+  "", 
+  "N", 
+  "N", 
+  "V", 
+  "NN", 
+  "", 
+  "V", 
+  "V", 
+  "N", 
+  "N", 
+  "", 
+  "", 
+  "", 
+  "N", 
+  "", 
+  "", 
+  "N", 
+  "N", 
+  "", 
+  "ISN", 
+  "VII", 
+  "I", 
+  "NVV", 
+  "S", 
+  "N", 
+  "ISN", 
+  "INSNC", 
+  "NSN", 
+  "NN", 
+  "", 
+  "", 
+  "N", 
+  "O", 
+  "O", 
+  "O", 
+  "CO", 
+  "CO", 
+  "O", 
+  "HO", 
+  "", 
+  "", 
+  "", 
+  "", 
+  "", 
+  "", 
+  "", 
+  "", 
+  "", 
+  "", 
+  "", 
+  "", 
+  "", 
+  "", 
+  "", 
+  "", 
+  "V", 
+  "", 
+  "", 
+  "", 
+  "", 
+
+};
+
+static int insn_len_info[] = {
+  1,
+  2,
+  2,
+  3,
+  2,
+  3,
+  3,
+  2,
+  2,
+  2,
+  2,
+  2,
+  2,
+  2,
+  2,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  1,
+  2,
+  2,
+  2,
+  3,
+  1,
+  2,
+  2,
+  2,
+  2,
+  1,
+  1,
+  1,
+  2,
+  1,
+  1,
+  2,
+  2,
+  1,
+  4,
+  4,
+  2,
+  4,
+  2,
+  2,
+  4,
+  6,
+  4,
+  3,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  2,
+  3,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  2,
+  1,
+  1,
+  1,
+  1,
+
+};
+
+static int insn_stack_push_num_info[] = {
+  0,
+  1,
+  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,
+  2,
+  1,
+  1,
+  1,
+  0,
+  2,
+  1,
+  2,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  0,
+  1,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  1,
+  1,
+
+};
+
+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(getdynamic):{
+        return depth + 1;
+      }
+      case BIN(setdynamic):{
+        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(putundef):{
+        return depth + 1;
+      }
+      case BIN(putobject):{
+        return depth + 1;
+      }
+      case BIN(putstring):{
+        return depth + 1;
+      }
+      case BIN(concatstrings):{
+        int inc = 0;
+        unsigned long num = FIX2INT(opes[0]);
+         inc += 1 - num;;
+        return depth + inc;
+      }
+      case BIN(tostring):{
+        return depth + 0;
+      }
+      case BIN(toregexp):{
+        return depth + 0;
+      }
+      case BIN(newarray):{
+        int inc = 0;
+        unsigned long num = FIX2INT(opes[0]);
+         inc += 1 - num;;
+        return depth + inc;
+      }
+      case BIN(duparray):{
+        return depth + 1;
+      }
+      case BIN(expandarray):{
+        int inc = 0;
+        unsigned long num = FIX2INT(opes[0]);
+        unsigned long flag = FIX2INT(opes[1]);
+         inc += (num > 0) ? num - 1 + (flag ? 1 : 0) : num + 1 - (flag ? 1 : 0);;
+        return depth + inc;
+      }
+      case BIN(concatarray):{
+        return depth + -1;
+      }
+      case BIN(splatarray):{
+        return depth + 0;
+      }
+      case BIN(checkincludearray):{
+        return depth + 0;
+      }
+      case BIN(newhash):{
+        int inc = 0;
+        unsigned long num = FIX2INT(opes[0]);
+         inc += 1 - num;;
+        return depth + inc;
+      }
+      case BIN(newrange):{
+        return depth + -1;
+      }
+      case BIN(putnot):{
+        return depth + 0;
+      }
+      case BIN(pop):{
+        return depth + -1;
+      }
+      case BIN(dup):{
+        return depth + 1;
+      }
+      case BIN(dupn):{
+        int inc = 0;
+        unsigned long 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;
+        unsigned long n = FIX2INT(opes[0]);
+         inc += 1;;
+        return depth + inc;
+      }
+      case BIN(setn):{
+        int inc = 0;
+        unsigned long n = FIX2INT(opes[0]);
+         inc += 0;
+        return depth + inc;
+      }
+      case BIN(emptstack):{
+        int inc = 0;
+         inc = 0; depth = 0;;
+        return depth + inc;
+      }
+      case BIN(definemethod):{
+        return depth + -1;
+      }
+      case BIN(alias):{
+        return depth + 0;
+      }
+      case BIN(undef):{
+        return depth + 0;
+      }
+      case BIN(defined):{
+        return depth + 0;
+      }
+      case BIN(postexe):{
+        return depth + 0;
+      }
+      case BIN(trace):{
+        return depth + 0;
+      }
+      case BIN(defineclass):{
+        return depth + -1;
+      }
+      case BIN(send):{
+        int inc = 0;
+        unsigned long op_argc = FIX2INT(opes[1]);
+        unsigned long op_flag = FIX2INT(opes[3]);
+         inc += - (op_argc + ((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0));;
+        return depth + inc;
+      }
+      case BIN(invokesuper):{
+        int inc = 0;
+        unsigned long op_argc = FIX2INT(opes[0]);
+        unsigned long flag = FIX2INT(opes[2]);
+         inc += - op_argc;;
+        return depth + inc;
+      }
+      case BIN(invokeblock):{
+        int inc = 0;
+        unsigned long num = FIX2INT(opes[0]);
+        unsigned long flag = FIX2INT(opes[1]);
+         inc += 1 - num;;
+        return depth + inc;
+      }
+      case BIN(leave):{
+        return depth + 0;
+      }
+      case BIN(finish):{
+        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_checkenv):{
+        return depth + 0;
+      }
+      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_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_succ):{
+        return depth + 0;
+      }
+      case BIN(opt_regexpmatch1):{
+        return depth + 0;
+      }
+      case BIN(opt_regexpmatch2):{
+        return depth + -1;
+      }
+      case BIN(opt_call_native_compiled):{
+        return depth + 0;
+      }
+      case BIN(bitblt):{
+        return depth + 1;
+      }
+      case BIN(answer):{
+        return depth + 1;
+      }
+
+  default:
+    rb_bug("insn_sp_increase: unreachable");
+  }
+  return 0;
+}
+
+/* some utilities */
+
+static int
+insn_len(int insn)
+{
+  return insn_len_info[insn];
+}
+
+static char *
+insn_name(int insn)
+{
+  return insn_name_info[insn];
+}
+
+static char *
+insn_op_types(int insn)
+{
+  return insn_operand_info[insn];
+}
+
+static int
+insn_op_type(int insn, int pos)
+{
+  int len = insn_len(insn) - 1;
+  if(pos < len){
+    return insn_operand_info[insn][pos];
+  }
+  else{
+    return 0;
+  }
+}
+
+static int
+insn_ret_num(int insn)
+{
+  return insn_stack_push_num_info[insn];
+}
+void
+make_compile_option(rb_compile_option_t *option, VALUE opt);
+void
+make_compile_option_value(rb_compile_option_t *option);
+
+extern VALUE instruction_class[YARV_MAX_INSTRUCTION_SIZE];
+void define_instruction_subclasses(VALUE rb_cInstruction);
+
+#endif
+
+#endif
+