ruby-internal 0.7.2 → 0.7.3

data/ext/internal/node/nodeinfo.c.rpp

@@ -61,6 +61,7 @@ VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
     case NEN_NONE:
       return Qnil;
 #ruby <<END
+  $: << '.' # TODO: hack
   require 'read_node_h'
   require 'nodes'
   require 'node_type_descrip'
@@ -129,7 +130,7 @@ VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
           else
           {
             path = rb_class_path(klass);
-            if(STR2CSTR(path)[0] == '#')
+            if(StringValuePtr(path)[0] == '#')
             {
               rb_raise(rb_eArgError, "cannot dump anonymous class");
             }
@@ -256,20 +257,23 @@ void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash,
       END
     when /\.value$/
       puts <<-END
+      int flags;
       Check_Type(v, T_ARRAY);
       if(RARRAY_LEN(v) != 2)
       {
         rb_raise(rb_eArgError, "wrong size for array");
       }
-      int flags = NUM2INT(RARRAY_PTR(v)[0]);
+      flags = NUM2INT(RARRAY_PTR(v)[0]);
       switch(flags & T_MASK)
       {
         case T_CLASS:
         case T_MODULE:
         {
-          VALUE str = RARRAY_PTR(v)[1];
+          VALUE str, klass;
+
+          str = RARRAY_PTR(v)[1];
           Check_Type(str, T_STRING);
-          VALUE klass = rb_path2class(STR2CSTR(str));
+          klass = rb_path2class(StringValuePtr(str));
           if(flags & FL_SINGLETON)
           {
             *(VALUE *)(&n->nd_#{node_elem_name}) =

data/ext/internal/node/nodeinfo.h.rpp

@@ -9,7 +9,8 @@ enum Node_Elem_Name
 {
   NEN_NONE,
 #ruby <<END
-  require 'read_node_h.rb'
+  $: << '.' # TODO: hack
+  require 'read_node_h'
 
   NODEINFO.sort.each do |node_elem_name, node_elem_ref|
     puts "  NEN_#{node_elem_name.upcase},"

data/ext/internal/noex/noex.c

@@ -2,6 +2,10 @@
 
 #include "internal/node/ruby_internal_node.h"
 
+#ifdef RUBY_VM
+#include "method.h"
+#endif
+
 void Init_noex(void)
 {
   /*

data/ext/internal/proc/proc.c

@@ -133,13 +133,13 @@ static VALUE proc_dump(VALUE self, VALUE limit)
   {
 #ifdef RUBY_VM
     rb_proc_t * p;
-    VALUE iseq;
+    VALUE iseq, str;
     rb_iseq_t * iseqdat;
     GetProcPtr(self, p);
     iseq = p->block.iseq->self;
     iseqdat = iseq_check(iseq);
     iseqdat->type = ISEQ_TYPE_TOP; /* TODO: is this right? */
-    VALUE str = marshal_dump(iseq, limit);
+    str = marshal_dump(iseq, limit);
     return str;
 #else
     struct BLOCK * b;

data/ext/internal/vm/constants/constants.c

@@ -25,7 +25,9 @@ void Init_constants(void)
   rb_define_const(rb_cRubyVM, "CALL_TAILCALL_BIT", INT2NUM(VM_CALL_TAILCALL_BIT));
   rb_define_const(rb_cRubyVM, "CALL_TAILRECURSION_BIT", INT2NUM(VM_CALL_TAILRECURSION_BIT));
   rb_define_const(rb_cRubyVM, "CALL_SUPER_BIT", INT2NUM(VM_CALL_SUPER_BIT));
+#ifdef HAVE_RUBY_CALL_SEND_BIT
   rb_define_const(rb_cRubyVM, "CALL_SEND_BIT", INT2NUM(VM_CALL_SEND_BIT));
+#endif
   rb_define_const(rb_cRubyVM, "SPECIAL_OBJECT_VMCORE", INT2NUM(VM_SPECIAL_OBJECT_VMCORE));
   rb_define_const(rb_cRubyVM, "SPECIAL_OBJECT_CBASE", INT2NUM(VM_SPECIAL_OBJECT_CBASE));
 #endif

data/ext/internal/vm/constants/extconf.rb

@@ -1,3 +1,5 @@
 $: << '../../..'
 require 'mkmf-ruby-internal'
 create_ruby_internal_makefile 'internal/vm/constants/constants'
+
+have_const('VM_CALL_SEND_BIT', [ 'ruby.h', 'vm_core.h' ])

data/ext/internal/vm/control_frame/control_frame.c

@@ -85,11 +85,20 @@ static VALUE control_frame_proc(VALUE control_frame)
  */
 static VALUE control_frame_method_id(VALUE control_frame)
 {
+  ID method_id;
   struct RubyInternalControlFrame * cfp;
+
   Data_Get_Struct(control_frame, struct RubyInternalControlFrame, cfp);
-  if(cfp->control_frame->method_id)
+
+#if RUBY_VERSION_CODE >= 192
+  method_id = cfp->control_frame->me->called_id; /* TODO: right? */
+#else
+  method_id = cfp->control_frame->method_id;
+#endif
+
+  if(method_id)
   {
-    return ID2SYM(cfp->control_frame->method_id);
+    return ID2SYM(method_id);
   }
   else
   {
@@ -105,9 +114,18 @@ static VALUE control_frame_method_id(VALUE control_frame)
  */
 static VALUE control_frame_method_class(VALUE control_frame)
 {
+  VALUE klass;
   struct RubyInternalControlFrame * cfp;
+
   Data_Get_Struct(control_frame, struct RubyInternalControlFrame, cfp);
-  return cfp->control_frame->method_class;
+
+#if RUBY_VERSION_CODE >= 192
+  klass = cfp->control_frame->me->klass; /* TODO: right? */
+#else
+  klass = cfp->control_frame->method_class;
+#endif
+
+  return klass;
 }
 
 /*

data/ext/internal/vm/control_frame/extconf.rb

@@ -1,3 +1,7 @@
 $: << '../../..'
 require 'mkmf-ruby-internal'
+
+ruby_version_code = RUBY_VERSION.gsub(/\./, '').to_i
+$CPPFLAGS << " -DRUBY_VERSION_CODE=#{ruby_version_code}"
+
 create_ruby_internal_makefile 'internal/vm/control_frame/control_frame'

data/ext/internal/vm/inline_cache/inline_cache.c

@@ -15,8 +15,15 @@
  */
 static VALUE inline_cache_klass(VALUE self)
 {
-  /* TODO: returning the real value can crash the interpreter */
-  return Qnil;
+  IC inline_cache = (IC)unwrap_node(self);
+  if (inline_cache->ic_class == Qundef)
+  {
+    return Qnil;
+  }
+  else
+  {
+    return inline_cache->ic_class;
+  }
 }
 
 /*
@@ -27,8 +34,8 @@ static VALUE inline_cache_klass(VALUE self)
  */
 static VALUE inline_cache_value(VALUE self)
 {
-  IC inline_cache = unwrap_node(self);
-  return inline_cache->ic_value;
+  /* TODO: Wrap the LABEL object (from compile.c) */
+  return Qnil;
 }
 
 /*
@@ -39,7 +46,7 @@ static VALUE inline_cache_value(VALUE self)
  */
 static VALUE inline_cache_vmstat(VALUE self)
 {
-  IC inline_cache = unwrap_node(self);
+  IC inline_cache = (IC)unwrap_node(self);
   return INT2NUM(inline_cache->ic_vmstat);
 }
 

data/ext/internal/vm/instruction/insns_info.c

@@ -2,6 +2,9 @@
 
 #ifdef RUBY_VM
 
+#include "iseq.h"
+#include "vm_core.h"
+
 static rb_compile_option_t COMPILE_OPTION_DEFAULT = {
     OPT_INLINE_CONST_CACHE, /* int inline_const_cache; */
     OPT_PEEPHOLE_OPTIMIZATION, /* int peephole_optimization; */
@@ -601,9 +604,9 @@ static VALUE insn_GETINSTANCEVARIABLE_name(VALUE self)
 static VALUE insn_GETINSTANCEVARIABLE_operand_names(VALUE self)
 {
   VALUE v[] = {
-    ID2SYM(rb_intern("id"))
+    ID2SYM(rb_intern("id")), ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(1, v);
+  return rb_ary_new4(2, v);
 }
 
 /*
@@ -667,9 +670,9 @@ static VALUE insn_SETINSTANCEVARIABLE_name(VALUE self)
 static VALUE insn_SETINSTANCEVARIABLE_operand_names(VALUE self)
 {
   VALUE v[] = {
-    ID2SYM(rb_intern("id"))
+    ID2SYM(rb_intern("id")), ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(1, v);
+  return rb_ary_new4(2, v);
 }
 
 /*
@@ -3571,7 +3574,7 @@ static VALUE insn_GETINLINECACHE_name(VALUE self)
 static VALUE insn_GETINLINECACHE_operand_names(VALUE self)
 {
   VALUE v[] = {
-    ID2SYM(rb_intern("ic")), ID2SYM(rb_intern("dst"))
+    ID2SYM(rb_intern("dst")), ID2SYM(rb_intern("ic"))
   };
   return rb_ary_new4(2, v);
 }
@@ -3637,7 +3640,7 @@ static VALUE insn_ONCEINLINECACHE_name(VALUE self)
 static VALUE insn_ONCEINLINECACHE_operand_names(VALUE self)
 {
   VALUE v[] = {
-    ID2SYM(rb_intern("ic")), ID2SYM(rb_intern("dst"))
+    ID2SYM(rb_intern("dst")), ID2SYM(rb_intern("ic"))
   };
   return rb_ary_new4(2, v);
 }
@@ -3703,7 +3706,7 @@ static VALUE insn_SETINLINECACHE_name(VALUE self)
 static VALUE insn_SETINLINECACHE_operand_names(VALUE self)
 {
   VALUE v[] = {
-    ID2SYM(rb_intern("dst"))
+    ID2SYM(rb_intern("ic"))
   };
   return rb_ary_new4(1, v);
 }
@@ -3901,9 +3904,9 @@ static VALUE insn_OPT_PLUS_name(VALUE self)
 static VALUE insn_OPT_PLUS_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -3967,9 +3970,9 @@ static VALUE insn_OPT_MINUS_name(VALUE self)
 static VALUE insn_OPT_MINUS_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -4033,9 +4036,9 @@ static VALUE insn_OPT_MULT_name(VALUE self)
 static VALUE insn_OPT_MULT_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -4099,9 +4102,9 @@ static VALUE insn_OPT_DIV_name(VALUE self)
 static VALUE insn_OPT_DIV_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -4165,9 +4168,9 @@ static VALUE insn_OPT_MOD_name(VALUE self)
 static VALUE insn_OPT_MOD_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -4297,7 +4300,7 @@ static VALUE insn_OPT_NEQ_name(VALUE self)
 static VALUE insn_OPT_NEQ_operand_names(VALUE self)
 {
   VALUE v[] = {
-    ID2SYM(rb_intern("ic1")), ID2SYM(rb_intern("ic2"))
+    ID2SYM(rb_intern("ic")), ID2SYM(rb_intern("ic_eq"))
   };
   return rb_ary_new4(2, v);
 }
@@ -4363,9 +4366,9 @@ static VALUE insn_OPT_LT_name(VALUE self)
 static VALUE insn_OPT_LT_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -4429,9 +4432,9 @@ static VALUE insn_OPT_LE_name(VALUE self)
 static VALUE insn_OPT_LE_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -4495,9 +4498,9 @@ static VALUE insn_OPT_GT_name(VALUE self)
 static VALUE insn_OPT_GT_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -4561,9 +4564,9 @@ static VALUE insn_OPT_GE_name(VALUE self)
 static VALUE insn_OPT_GE_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -4627,9 +4630,9 @@ static VALUE insn_OPT_LTLT_name(VALUE self)
 static VALUE insn_OPT_LTLT_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -4693,9 +4696,9 @@ static VALUE insn_OPT_AREF_name(VALUE self)
 static VALUE insn_OPT_AREF_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -4759,9 +4762,9 @@ static VALUE insn_OPT_ASET_name(VALUE self)
 static VALUE insn_OPT_ASET_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -4825,9 +4828,9 @@ static VALUE insn_OPT_LENGTH_name(VALUE self)
 static VALUE insn_OPT_LENGTH_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -4836,7 +4839,7 @@ static VALUE insn_OPT_LENGTH_operand_names(VALUE self)
  *
  * Returns the length of the instruction.
  */
-static VALUE insn_OPT_SUCC_length(VALUE self)
+static VALUE insn_OPT_SIZE_length(VALUE self)
 {
   return LONG2NUM(insn_len(72));
 }
@@ -4847,7 +4850,7 @@ static VALUE insn_OPT_SUCC_length(VALUE self)
  *
  * Returns the numeric instruction number.
  */
-static VALUE insn_OPT_SUCC_to_i(VALUE self)
+static VALUE insn_OPT_SIZE_to_i(VALUE self)
 {
   return NUM2LONG(72);
 }
@@ -4858,7 +4861,7 @@ static VALUE insn_OPT_SUCC_to_i(VALUE self)
  *
  * Returns an array containing the types of the operands.
  */
-static VALUE insn_OPT_SUCC_operand_types(VALUE self)
+static VALUE insn_OPT_SIZE_operand_types(VALUE self)
 {
   VALUE operand_types = rb_ary_new();
   char const * s;
@@ -4871,6 +4874,72 @@ static VALUE insn_OPT_SUCC_operand_types(VALUE self)
   return operand_types;
 }
 
+/*
+ * call-seq:
+ *   insn.name => Symbol
+ *
+ * Returns the name of the instruction.
+ */
+static VALUE insn_OPT_SIZE_name(VALUE self)
+{
+  return rb_intern("OPT_SIZE");
+}
+
+/*
+ * call-seq:
+ *   insn.name => Symbol
+ *
+ * Returns the name of the operands for this instruction.
+ */
+static VALUE insn_OPT_SIZE_operand_names(VALUE self)
+{
+  VALUE v[] = {
+    ID2SYM(rb_intern("ic"))
+  };
+  return rb_ary_new4(1, v);
+}
+
+/*
+ * call-seq:
+ *   insn.length => Integer
+ *
+ * Returns the length of the instruction.
+ */
+static VALUE insn_OPT_SUCC_length(VALUE self)
+{
+  return LONG2NUM(insn_len(73));
+}
+
+/*
+ * call-seq:
+ *   insn.to_i => Integer
+ *
+ * Returns the numeric instruction number.
+ */
+static VALUE insn_OPT_SUCC_to_i(VALUE self)
+{
+  return NUM2LONG(73);
+}
+
+/*
+ * call-seq:
+ *   insn.operand_types => Array of Symbol
+ *
+ * Returns an array containing the types of the operands.
+ */
+static VALUE insn_OPT_SUCC_operand_types(VALUE self)
+{
+  VALUE operand_types = rb_ary_new();
+  char const * s;
+
+  for(s = insn_op_types(73); *s != '\0'; ++s)
+  {
+    rb_ary_push(operand_types, ID2SYM(operand_type_name_of(*s)));
+  }
+
+  return operand_types;
+}
+
 /*
  * call-seq:
  *   insn.name => Symbol
@@ -4891,9 +4960,9 @@ static VALUE insn_OPT_SUCC_name(VALUE self)
 static VALUE insn_OPT_SUCC_operand_names(VALUE self)
 {
   VALUE v[] = {
-    
+    ID2SYM(rb_intern("ic"))
   };
-  return rb_ary_new4(0, v);
+  return rb_ary_new4(1, v);
 }
 
 /*
@@ -4904,7 +4973,7 @@ static VALUE insn_OPT_SUCC_operand_names(VALUE self)
  */
 static VALUE insn_OPT_NOT_length(VALUE self)
 {
-  return LONG2NUM(insn_len(73));
+  return LONG2NUM(insn_len(74));
 }
 
 /*
@@ -4915,7 +4984,7 @@ static VALUE insn_OPT_NOT_length(VALUE self)
  */
 static VALUE insn_OPT_NOT_to_i(VALUE self)
 {
-  return NUM2LONG(73);
+  return NUM2LONG(74);
 }
 
 /*
@@ -4929,7 +4998,7 @@ static VALUE insn_OPT_NOT_operand_types(VALUE self)
   VALUE operand_types = rb_ary_new();
   char const * s;
 
-  for(s = insn_op_types(73); *s != '\0'; ++s)
+  for(s = insn_op_types(74); *s != '\0'; ++s)
   {
     rb_ary_push(operand_types, ID2SYM(operand_type_name_of(*s)));
   }
@@ -4970,7 +5039,7 @@ static VALUE insn_OPT_NOT_operand_names(VALUE self)
  */
 static VALUE insn_OPT_REGEXPMATCH1_length(VALUE self)
 {
-  return LONG2NUM(insn_len(74));
+  return LONG2NUM(insn_len(75));
 }
 
 /*
@@ -4981,7 +5050,7 @@ static VALUE insn_OPT_REGEXPMATCH1_length(VALUE self)
  */
 static VALUE insn_OPT_REGEXPMATCH1_to_i(VALUE self)
 {
-  return NUM2LONG(74);
+  return NUM2LONG(75);
 }
 
 /*
@@ -4995,7 +5064,7 @@ static VALUE insn_OPT_REGEXPMATCH1_operand_types(VALUE self)
   VALUE operand_types = rb_ary_new();
   char const * s;
 
-  for(s = insn_op_types(74); *s != '\0'; ++s)
+  for(s = insn_op_types(75); *s != '\0'; ++s)
   {
     rb_ary_push(operand_types, ID2SYM(operand_type_name_of(*s)));
   }
@@ -5036,7 +5105,7 @@ static VALUE insn_OPT_REGEXPMATCH1_operand_names(VALUE self)
  */
 static VALUE insn_OPT_REGEXPMATCH2_length(VALUE self)
 {
-  return LONG2NUM(insn_len(75));
+  return LONG2NUM(insn_len(76));
 }
 
 /*
@@ -5047,7 +5116,7 @@ static VALUE insn_OPT_REGEXPMATCH2_length(VALUE self)
  */
 static VALUE insn_OPT_REGEXPMATCH2_to_i(VALUE self)
 {
-  return NUM2LONG(75);
+  return NUM2LONG(76);
 }
 
 /*
@@ -5061,7 +5130,7 @@ static VALUE insn_OPT_REGEXPMATCH2_operand_types(VALUE self)
   VALUE operand_types = rb_ary_new();
   char const * s;
 
-  for(s = insn_op_types(75); *s != '\0'; ++s)
+  for(s = insn_op_types(76); *s != '\0'; ++s)
   {
     rb_ary_push(operand_types, ID2SYM(operand_type_name_of(*s)));
   }
@@ -5102,7 +5171,7 @@ static VALUE insn_OPT_REGEXPMATCH2_operand_names(VALUE self)
  */
 static VALUE insn_OPT_CALL_C_FUNCTION_length(VALUE self)
 {
-  return LONG2NUM(insn_len(76));
+  return LONG2NUM(insn_len(77));
 }
 
 /*
@@ -5113,7 +5182,7 @@ static VALUE insn_OPT_CALL_C_FUNCTION_length(VALUE self)
  */
 static VALUE insn_OPT_CALL_C_FUNCTION_to_i(VALUE self)
 {
-  return NUM2LONG(76);
+  return NUM2LONG(77);
 }
 
 /*
@@ -5127,7 +5196,7 @@ static VALUE insn_OPT_CALL_C_FUNCTION_operand_types(VALUE self)
   VALUE operand_types = rb_ary_new();
   char const * s;
 
-  for(s = insn_op_types(76); *s != '\0'; ++s)
+  for(s = insn_op_types(77); *s != '\0'; ++s)
   {
     rb_ary_push(operand_types, ID2SYM(operand_type_name_of(*s)));
   }
@@ -5168,7 +5237,7 @@ static VALUE insn_OPT_CALL_C_FUNCTION_operand_names(VALUE self)
  */
 static VALUE insn_BITBLT_length(VALUE self)
 {
-  return LONG2NUM(insn_len(77));
+  return LONG2NUM(insn_len(78));
 }
 
 /*
@@ -5179,7 +5248,7 @@ static VALUE insn_BITBLT_length(VALUE self)
  */
 static VALUE insn_BITBLT_to_i(VALUE self)
 {
-  return NUM2LONG(77);
+  return NUM2LONG(78);
 }
 
 /*
@@ -5193,7 +5262,7 @@ static VALUE insn_BITBLT_operand_types(VALUE self)
   VALUE operand_types = rb_ary_new();
   char const * s;
 
-  for(s = insn_op_types(77); *s != '\0'; ++s)
+  for(s = insn_op_types(78); *s != '\0'; ++s)
   {
     rb_ary_push(operand_types, ID2SYM(operand_type_name_of(*s)));
   }
@@ -5234,7 +5303,7 @@ static VALUE insn_BITBLT_operand_names(VALUE self)
  */
 static VALUE insn_ANSWER_length(VALUE self)
 {
-  return LONG2NUM(insn_len(78));
+  return LONG2NUM(insn_len(79));
 }
 
 /*
@@ -5245,7 +5314,7 @@ static VALUE insn_ANSWER_length(VALUE self)
  */
 static VALUE insn_ANSWER_to_i(VALUE self)
 {
-  return NUM2LONG(78);
+  return NUM2LONG(79);
 }
 
 /*
@@ -5259,7 +5328,7 @@ static VALUE insn_ANSWER_operand_types(VALUE self)
   VALUE operand_types = rb_ary_new();
   char const * s;
 
-  for(s = insn_op_types(78); *s != '\0'; ++s)
+  for(s = insn_op_types(79); *s != '\0'; ++s)
   {
     rb_ary_push(operand_types, ID2SYM(operand_type_name_of(*s)));
   }
@@ -5875,7 +5944,15 @@ void define_instruction_subclasses(VALUE rb_cInstruction)
     rb_define_method(rb_cInstruction_OPT_LENGTH, "name", insn_OPT_LENGTH_name, 0);
   }
   {
-    VALUE rb_cInstruction_OPT_SUCC = instruction_class[72] = rb_define_class_under(rb_cInstruction, "OPT_SUCC", rb_cInstruction);
+    VALUE rb_cInstruction_OPT_SIZE = instruction_class[72] = rb_define_class_under(rb_cInstruction, "OPT_SIZE", rb_cInstruction);
+    rb_define_method(rb_cInstruction_OPT_SIZE, "length", insn_OPT_SIZE_length, 0);
+    rb_define_method(rb_cInstruction_OPT_SIZE, "to_i", insn_OPT_SIZE_to_i, 0);
+    rb_define_method(rb_cInstruction_OPT_SIZE, "operand_types", insn_OPT_SIZE_operand_types, 0);
+    rb_define_method(rb_cInstruction_OPT_SIZE, "operand_names", insn_OPT_SIZE_operand_names, 0);
+    rb_define_method(rb_cInstruction_OPT_SIZE, "name", insn_OPT_SIZE_name, 0);
+  }
+  {
+    VALUE rb_cInstruction_OPT_SUCC = instruction_class[73] = rb_define_class_under(rb_cInstruction, "OPT_SUCC", rb_cInstruction);
     rb_define_method(rb_cInstruction_OPT_SUCC, "length", insn_OPT_SUCC_length, 0);
     rb_define_method(rb_cInstruction_OPT_SUCC, "to_i", insn_OPT_SUCC_to_i, 0);
     rb_define_method(rb_cInstruction_OPT_SUCC, "operand_types", insn_OPT_SUCC_operand_types, 0);
@@ -5883,7 +5960,7 @@ void define_instruction_subclasses(VALUE rb_cInstruction)
     rb_define_method(rb_cInstruction_OPT_SUCC, "name", insn_OPT_SUCC_name, 0);
   }
   {
-    VALUE rb_cInstruction_OPT_NOT = instruction_class[73] = rb_define_class_under(rb_cInstruction, "OPT_NOT", rb_cInstruction);
+    VALUE rb_cInstruction_OPT_NOT = instruction_class[74] = rb_define_class_under(rb_cInstruction, "OPT_NOT", rb_cInstruction);
     rb_define_method(rb_cInstruction_OPT_NOT, "length", insn_OPT_NOT_length, 0);
     rb_define_method(rb_cInstruction_OPT_NOT, "to_i", insn_OPT_NOT_to_i, 0);
     rb_define_method(rb_cInstruction_OPT_NOT, "operand_types", insn_OPT_NOT_operand_types, 0);
@@ -5891,7 +5968,7 @@ void define_instruction_subclasses(VALUE rb_cInstruction)
     rb_define_method(rb_cInstruction_OPT_NOT, "name", insn_OPT_NOT_name, 0);
   }
   {
-    VALUE rb_cInstruction_OPT_REGEXPMATCH1 = instruction_class[74] = rb_define_class_under(rb_cInstruction, "OPT_REGEXPMATCH1", rb_cInstruction);
+    VALUE rb_cInstruction_OPT_REGEXPMATCH1 = instruction_class[75] = rb_define_class_under(rb_cInstruction, "OPT_REGEXPMATCH1", rb_cInstruction);
     rb_define_method(rb_cInstruction_OPT_REGEXPMATCH1, "length", insn_OPT_REGEXPMATCH1_length, 0);
     rb_define_method(rb_cInstruction_OPT_REGEXPMATCH1, "to_i", insn_OPT_REGEXPMATCH1_to_i, 0);
     rb_define_method(rb_cInstruction_OPT_REGEXPMATCH1, "operand_types", insn_OPT_REGEXPMATCH1_operand_types, 0);
@@ -5899,7 +5976,7 @@ void define_instruction_subclasses(VALUE rb_cInstruction)
     rb_define_method(rb_cInstruction_OPT_REGEXPMATCH1, "name", insn_OPT_REGEXPMATCH1_name, 0);
   }
   {
-    VALUE rb_cInstruction_OPT_REGEXPMATCH2 = instruction_class[75] = rb_define_class_under(rb_cInstruction, "OPT_REGEXPMATCH2", rb_cInstruction);
+    VALUE rb_cInstruction_OPT_REGEXPMATCH2 = instruction_class[76] = rb_define_class_under(rb_cInstruction, "OPT_REGEXPMATCH2", rb_cInstruction);
     rb_define_method(rb_cInstruction_OPT_REGEXPMATCH2, "length", insn_OPT_REGEXPMATCH2_length, 0);
     rb_define_method(rb_cInstruction_OPT_REGEXPMATCH2, "to_i", insn_OPT_REGEXPMATCH2_to_i, 0);
     rb_define_method(rb_cInstruction_OPT_REGEXPMATCH2, "operand_types", insn_OPT_REGEXPMATCH2_operand_types, 0);
@@ -5907,7 +5984,7 @@ void define_instruction_subclasses(VALUE rb_cInstruction)
     rb_define_method(rb_cInstruction_OPT_REGEXPMATCH2, "name", insn_OPT_REGEXPMATCH2_name, 0);
   }
   {
-    VALUE rb_cInstruction_OPT_CALL_C_FUNCTION = instruction_class[76] = rb_define_class_under(rb_cInstruction, "OPT_CALL_C_FUNCTION", rb_cInstruction);
+    VALUE rb_cInstruction_OPT_CALL_C_FUNCTION = instruction_class[77] = rb_define_class_under(rb_cInstruction, "OPT_CALL_C_FUNCTION", rb_cInstruction);
     rb_define_method(rb_cInstruction_OPT_CALL_C_FUNCTION, "length", insn_OPT_CALL_C_FUNCTION_length, 0);
     rb_define_method(rb_cInstruction_OPT_CALL_C_FUNCTION, "to_i", insn_OPT_CALL_C_FUNCTION_to_i, 0);
     rb_define_method(rb_cInstruction_OPT_CALL_C_FUNCTION, "operand_types", insn_OPT_CALL_C_FUNCTION_operand_types, 0);
@@ -5915,7 +5992,7 @@ void define_instruction_subclasses(VALUE rb_cInstruction)
     rb_define_method(rb_cInstruction_OPT_CALL_C_FUNCTION, "name", insn_OPT_CALL_C_FUNCTION_name, 0);
   }
   {
-    VALUE rb_cInstruction_BITBLT = instruction_class[77] = rb_define_class_under(rb_cInstruction, "BITBLT", rb_cInstruction);
+    VALUE rb_cInstruction_BITBLT = instruction_class[78] = rb_define_class_under(rb_cInstruction, "BITBLT", rb_cInstruction);
     rb_define_method(rb_cInstruction_BITBLT, "length", insn_BITBLT_length, 0);
     rb_define_method(rb_cInstruction_BITBLT, "to_i", insn_BITBLT_to_i, 0);
     rb_define_method(rb_cInstruction_BITBLT, "operand_types", insn_BITBLT_operand_types, 0);
@@ -5923,7 +6000,7 @@ void define_instruction_subclasses(VALUE rb_cInstruction)
     rb_define_method(rb_cInstruction_BITBLT, "name", insn_BITBLT_name, 0);
   }
   {
-    VALUE rb_cInstruction_ANSWER = instruction_class[78] = rb_define_class_under(rb_cInstruction, "ANSWER", rb_cInstruction);
+    VALUE rb_cInstruction_ANSWER = instruction_class[79] = rb_define_class_under(rb_cInstruction, "ANSWER", rb_cInstruction);
     rb_define_method(rb_cInstruction_ANSWER, "length", insn_ANSWER_length, 0);
     rb_define_method(rb_cInstruction_ANSWER, "to_i", insn_ANSWER_to_i, 0);
     rb_define_method(rb_cInstruction_ANSWER, "operand_types", insn_ANSWER_operand_types, 0);