script_core 0.2.7 → 0.3.0

data/ext/enterprise_script_service/mruby/include/mruby/irep.h

@@ -16,36 +16,72 @@
 MRB_BEGIN_DECL
 
 enum irep_pool_type {
-  IREP_TT_STRING,
-  IREP_TT_FIXNUM,
-  IREP_TT_FLOAT,
+  IREP_TT_STR   = 0,          /* string (need free) */
+  IREP_TT_SSTR  = 2,          /* string (static) */
+  IREP_TT_INT32 = 1,          /* 32bit integer */
+  IREP_TT_INT64 = 3,          /* 64bit integer */
+  IREP_TT_FLOAT = 5,          /* float (double/float) */
 };
 
-struct mrb_locals {
-  mrb_sym name;
-  uint16_t r;
+#define IREP_TT_NFLAG 1       /* number (non string) flag */
+#define IREP_TT_SFLAG 2       /* static string flag */
+
+typedef struct mrb_pool_value {
+  uint32_t tt;     /* packed type and length (for string) */
+  union {
+    const char *str;
+    int32_t i32;
+#if defined(MRB_64BIT) || defined(MRB_INT64)
+    int64_t i64;
+#endif
+#ifndef MRB_NO_FLOAT
+    mrb_float f;
+#endif
+  } u;
+} mrb_pool_value;
+
+enum mrb_catch_type {
+  MRB_CATCH_RESCUE = 0,
+  MRB_CATCH_ENSURE = 1,
+};
+
+struct mrb_irep_catch_handler {
+  uint8_t type;         /* enum mrb_catch_type */
+  uint8_t begin[4];     /* The starting address to match the hander. Includes this. */
+  uint8_t end[4];       /* The endpoint address that matches the hander. Not Includes this. */
+  uint8_t target[4];    /* The address to jump to if a match is made. */
 };
 
 /* Program data array struct */
 typedef struct mrb_irep {
   uint16_t nlocals;        /* Number of local variables */
   uint16_t nregs;          /* Number of register variables */
+  uint16_t clen;           /* Number of catch handlers */
   uint8_t flags;
 
   const mrb_code *iseq;
-  mrb_value *pool;
-  mrb_sym *syms;
-  struct mrb_irep **reps;
-
-  struct mrb_locals *lv;
+  /*
+   * A catch handler table is placed after the iseq entity.
+   * The reason it doesn't add fields to the structure is to keep the mrb_irep structure from bloating.
+   * The catch handler table can be obtained with `mrb_irep_catch_handler_table(irep)`.
+   */
+  const mrb_pool_value *pool;
+  const mrb_sym *syms;
+  const struct mrb_irep * const *reps;
+
+  const mrb_sym *lv;
   /* debug info */
   struct mrb_irep_debug_info* debug_info;
 
-  uint16_t ilen, plen, slen, rlen;
-  uint32_t refcnt;
+  uint32_t ilen;
+  uint16_t plen, slen;
+  uint16_t rlen;
+  uint16_t refcnt;
 } mrb_irep;
 
 #define MRB_ISEQ_NO_FREE 1
+#define MRB_IREP_NO_FREE 2
+#define MRB_IREP_STATIC  (MRB_ISEQ_NO_FREE | MRB_IREP_NO_FREE)
 
 MRB_API mrb_irep *mrb_add_irep(mrb_state *mrb);
 
@@ -87,11 +123,25 @@ struct mrb_insn_data {
   uint8_t insn;
   uint16_t a;
   uint16_t b;
-  uint8_t c;
+  uint16_t c;
 };
 
 struct mrb_insn_data mrb_decode_insn(const mrb_code *pc);
 
+static inline const struct mrb_irep_catch_handler *
+mrb_irep_catch_handler_table(const struct mrb_irep *irep)
+{
+  if (irep->clen > 0) {
+    return (const struct mrb_irep_catch_handler*)(irep->iseq + irep->ilen);
+  }
+  else {
+    return (const struct mrb_irep_catch_handler*)NULL;
+  }
+}
+
+#define mrb_irep_catch_handler_pack(n, v)   uint32_to_bin(n, v)
+#define mrb_irep_catch_handler_unpack(v)    bin_to_uint32(v)
+
 MRB_END_DECL
 
 #endif  /* MRUBY_IREP_H */

data/ext/enterprise_script_service/mruby/include/mruby/khash.h

@@ -61,7 +61,6 @@ static const uint8_t __m_either[] = {0x03, 0x0c, 0x30, 0xc0};
   typedef struct kh_##name {                                            \
     khint_t n_buckets;                                                  \
     khint_t size;                                                       \
-    khint_t n_occupied;                                                 \
     uint8_t *ed_flags;                                                  \
     khkey_t *keys;                                                      \
     khval_t *vals;                                                      \
@@ -73,7 +72,6 @@ static const uint8_t __m_either[] = {0x03, 0x0c, 0x30, 0xc0};
   void kh_clear_##name(mrb_state *mrb, kh_##name##_t *h);               \
   khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key);           \
   khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key, int *ret); \
-  void kh_put_prepare_##name(mrb_state *mrb, kh_##name##_t *h);                   \
   void kh_resize_##name(mrb_state *mrb, kh_##name##_t *h, khint_t new_n_buckets); \
   void kh_del_##name(mrb_state *mrb, kh_##name##_t *h, khint_t x);                \
   kh_##name##_t *kh_copy_##name(mrb_state *mrb, kh_##name##_t *h);
@@ -93,7 +91,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
    khval_t: value data type
    kh_is_map: (0: hash set / 1: hash map)
    __hash_func: hash function
-   __hash_equal: hash comparation function
+   __hash_equal: hash comparison function
 */
 #define KHASH_DEFINE(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
   mrb_noreturn void mrb_raise_nomemory(mrb_state *mrb);                 \
@@ -103,7 +101,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
     size_t len = sizeof(khkey_t) + (kh_is_map ? sizeof(khval_t) : 0);   \
     uint8_t *p = (uint8_t*)mrb_malloc_simple(mrb, sizeof(uint8_t)*sz/4+len*sz); \
     if (!p) { return 1; }                                               \
-    h->size = h->n_occupied = 0;                                        \
+    h->size = 0;                                                        \
     h->keys = (khkey_t *)p;                                             \
     h->vals = kh_is_map ? (khval_t *)(p+sizeof(khkey_t)*sz) : NULL;     \
     h->ed_flags = p+len*sz;                                             \
@@ -143,7 +141,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
     (void)mrb;                                                          \
     if (h && h->ed_flags) {                                             \
       kh_fill_flags(h->ed_flags, 0xaa, h->n_buckets/4);                 \
-      h->size = h->n_occupied = 0;                                      \
+      h->size = 0;                                                      \
     }                                                                   \
   }                                                                     \
   khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key)  \
@@ -184,16 +182,12 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
       mrb_free(mrb, old_keys);                                          \
     }                                                                   \
   }                                                                     \
-  void kh_put_prepare_##name(mrb_state *mrb, kh_##name##_t *h)          \
-  {                                                                     \
-    if (h->n_occupied >= khash_upper_bound(h)) {                        \
-      kh_resize_##name(mrb, h, h->n_buckets*2);                         \
-    }                                                                   \
-  }                                                                     \
   khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key, int *ret) \
   {                                                                     \
     khint_t k, del_k, step = 0;                                         \
-    kh_put_prepare_##name(mrb, h);                                      \
+    if (h->size >= khash_upper_bound(h)) {                              \
+      kh_resize_##name(mrb, h, h->n_buckets*2);                         \
+    }                                                                   \
     k = __hash_func(mrb,key) & khash_mask(h);                           \
     del_k = kh_end(h);                                                  \
     while (!__ac_isempty(h->ed_flags, k)) {                             \
@@ -221,7 +215,6 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
       h->keys[k] = key;                                                 \
       h->ed_flags[k/4] &= ~__m_empty[k%4];                              \
       h->size++;                                                        \
-      h->n_occupied++;                                                  \
       if (ret) *ret = 1;                                                \
       return k;                                                         \
     }                                                                   \
@@ -256,7 +249,6 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
 #define kh_destroy(name, mrb, h) kh_destroy_##name(mrb, h)
 #define kh_clear(name, mrb, h) kh_clear_##name(mrb, h)
 #define kh_resize(name, mrb, h, s) kh_resize_##name(mrb, h, s)
-#define kh_put_prepare(name, mrb, h) kh_put_prepare_##name(mrb, h)
 #define kh_put(name, mrb, h, k) kh_put_##name(mrb, h, k, NULL)
 #define kh_put2(name, mrb, h, k, r) kh_put_##name(mrb, h, k, r)
 #define kh_get(name, mrb, h, k) kh_get_##name(mrb, h, k)

data/ext/enterprise_script_service/mruby/include/mruby/numeric.h

@@ -1,5 +1,5 @@
 /**
-** @file mruby/numeric.h - Numeric, Integer, Float, Fixnum class
+** @file mruby/numeric.h - Numeric, Integer, Float class
 **
 ** See Copyright Notice in mruby.h
 */
@@ -12,17 +12,17 @@
 /**
  * Numeric class and it's sub-classes.
  *
- * Integer, Float and Fixnum
+ * Integer and Float
  */
 MRB_BEGIN_DECL
 
-#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_INT_MAX)
-#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_INT_MIN)
+#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_FIXNUM_MAX)
+#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_FIXNUM_MIN)
 #define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t))
 #define POSFIXABLE(f) TYPED_POSFIXABLE(f,mrb_int)
 #define NEGFIXABLE(f) TYPED_NEGFIXABLE(f,mrb_int)
 #define FIXABLE(f) TYPED_FIXABLE(f,mrb_int)
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 #ifdef MRB_INT64
 #define FIXABLE_FLOAT(f) ((f)>=-9223372036854775808.0 && (f)<9223372036854775808.0)
 #else
@@ -30,16 +30,15 @@ MRB_BEGIN_DECL
 #endif
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API mrb_value mrb_flo_to_fixnum(mrb_state *mrb, mrb_value val);
 #endif
 MRB_API mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base);
 /* ArgumentError if format string doesn't match /%(\.[0-9]+)?[aAeEfFgG]/ */
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 MRB_API mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt);
 MRB_API int mrb_float_to_cstr(mrb_state *mrb, char *buf, size_t len, const char *fmt, mrb_float f);
 MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value x);
-MRB_API mrb_value mrb_int_value(mrb_state *mrb, mrb_float f);
 #endif
 
 MRB_API mrb_value mrb_num_plus(mrb_state *mrb, mrb_value x, mrb_value y);
@@ -71,103 +70,77 @@ MRB_API mrb_value mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y);
 
 #ifdef MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
 
-#ifndef MRB_WORD_BOXING
-# define WBCHK(x) 0
-#else
-# define WBCHK(x) !FIXABLE(x)
-#endif
-
 static inline mrb_bool
 mrb_int_add_overflow(mrb_int augend, mrb_int addend, mrb_int *sum)
 {
-  return __builtin_add_overflow(augend, addend, sum) || WBCHK(*sum);
+  return __builtin_add_overflow(augend, addend, sum);
 }
 
 static inline mrb_bool
 mrb_int_sub_overflow(mrb_int minuend, mrb_int subtrahend, mrb_int *difference)
 {
-  return __builtin_sub_overflow(minuend, subtrahend, difference) || WBCHK(*difference);
+  return __builtin_sub_overflow(minuend, subtrahend, difference);
 }
 
 static inline mrb_bool
 mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
 {
-  return __builtin_mul_overflow(multiplier, multiplicand, product) || WBCHK(*product);
+  return __builtin_mul_overflow(multiplier, multiplicand, product);
 }
 
-#undef WBCHK
-
 #else
 
-#define MRB_UINT_MAKE2(n) uint ## n ## _t
-#define MRB_UINT_MAKE(n) MRB_UINT_MAKE2(n)
-#define mrb_uint MRB_UINT_MAKE(MRB_INT_BIT)
-
-#define MRB_INT_OVERFLOW_MASK ((mrb_uint)1 << (MRB_INT_BIT - 1 - MRB_FIXNUM_SHIFT))
+#define MRB_INT_OVERFLOW_MASK ((mrb_uint)1 << (MRB_INT_BIT - 1))
 
 static inline mrb_bool
-mrb_int_add_overflow(mrb_int augend, mrb_int addend, mrb_int *sum)
+mrb_int_add_overflow(mrb_int a, mrb_int b, mrb_int *c)
 {
-  mrb_uint x = (mrb_uint)augend;
-  mrb_uint y = (mrb_uint)addend;
+  mrb_uint x = (mrb_uint)a;
+  mrb_uint y = (mrb_uint)b;
   mrb_uint z = (mrb_uint)(x + y);
-  *sum = (mrb_int)z;
+  *c = (mrb_int)z;
   return !!(((x ^ z) & (y ^ z)) & MRB_INT_OVERFLOW_MASK);
 }
 
 static inline mrb_bool
-mrb_int_sub_overflow(mrb_int minuend, mrb_int subtrahend, mrb_int *difference)
+mrb_int_sub_overflow(mrb_int a, mrb_int b, mrb_int *c)
 {
-  mrb_uint x = (mrb_uint)minuend;
-  mrb_uint y = (mrb_uint)subtrahend;
+  mrb_uint x = (mrb_uint)a;
+  mrb_uint y = (mrb_uint)b;
   mrb_uint z = (mrb_uint)(x - y);
-  *difference = (mrb_int)z;
+  *c = (mrb_int)z;
   return !!(((x ^ z) & (~y ^ z)) & MRB_INT_OVERFLOW_MASK);
 }
 
 static inline mrb_bool
-mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
+mrb_int_mul_overflow(mrb_int a, mrb_int b, mrb_int *c)
 {
-#if MRB_INT_BIT == 32
-  int64_t n = (int64_t)multiplier * multiplicand;
-  *product = (mrb_int)n;
-  return !FIXABLE(n);
-#else
-  if (multiplier > 0) {
-    if (multiplicand > 0) {
-      if (multiplier > MRB_INT_MAX / multiplicand) return TRUE;
-    }
-    else {
-      if (multiplicand < MRB_INT_MAX / multiplier) return TRUE;
-    }
-  }
-  else {
-    if (multiplicand > 0) {
-      if (multiplier < MRB_INT_MAX / multiplicand) return TRUE;
-    }
-    else {
-      if (multiplier != 0 && multiplicand < MRB_INT_MAX / multiplier) return TRUE;
-    }
-  }
-  *product = multiplier * multiplicand;
+#ifdef MRB_INT32
+  int64_t n = (int64_t)a * b;
+  *c = (mrb_int)n;
+  return n > MRB_INT_MAX || n < MRB_INT_MIN;
+#else /* MRB_INT64 */
+  if (a > 0 && b > 0 && a > MRB_INT_MAX / b) return TRUE;
+  if (a < 0 && b > 0 && a < MRB_INT_MIN / b) return TRUE;
+  if (a > 0 && b < 0 && b < MRB_INT_MIN / a) return TRUE;
+  if (a < 0 && b < 0 && (a <= MRB_INT_MIN || b <= MRB_INT_MIN || -a > MRB_INT_MAX / -b))
+    return TRUE;
+  *c = a * b;
   return FALSE;
 #endif
 }
 
 #undef MRB_INT_OVERFLOW_MASK
-#undef mrb_uint
-#undef MRB_UINT_MAKE
-#undef MRB_UINT_MAKE2
 
 #endif
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 # include <stdint.h>
 # include <float.h>
 
 # define MRB_FLT_RADIX          FLT_RADIX
 
-# ifdef MRB_USE_FLOAT
+# ifdef MRB_USE_FLOAT32
 #  define MRB_FLT_MANT_DIG      FLT_MANT_DIG
 #  define MRB_FLT_EPSILON       FLT_EPSILON
 #  define MRB_FLT_DIG           FLT_DIG
@@ -178,7 +151,7 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
 #  define MRB_FLT_MAX           FLT_MAX
 #  define MRB_FLT_MAX_10_EXP    FLT_MAX_10_EXP
 
-# else /* not MRB_USE_FLOAT */
+# else /* not MRB_USE_FLOAT32 */
 #  define MRB_FLT_MANT_DIG      DBL_MANT_DIG
 #  define MRB_FLT_EPSILON       DBL_EPSILON
 #  define MRB_FLT_DIG           DBL_DIG
@@ -188,8 +161,8 @@ mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
 #  define MRB_FLT_MAX_EXP       DBL_MAX_EXP
 #  define MRB_FLT_MAX           DBL_MAX
 #  define MRB_FLT_MAX_10_EXP    DBL_MAX_10_EXP
-# endif /* MRB_USE_FLOAT */
-#endif /* MRB_WITHOUT_FLOAT */
+# endif /* MRB_USE_FLOAT32 */
+#endif /* MRB_NO_FLOAT */
 
 MRB_END_DECL
 

data/ext/enterprise_script_service/mruby/include/mruby/opcode.h

@@ -36,34 +36,8 @@ enum mrb_insn {
 #define FETCH_BB() do {a=READ_B(); b=READ_B();} while (0)
 #define FETCH_BBB() do {a=READ_B(); b=READ_B(); c=READ_B();} while (0)
 #define FETCH_BS() do {a=READ_B(); b=READ_S();} while (0)
+#define FETCH_BSS() do {a=READ_B(); b=READ_S(); c=READ_S();} while (0)
 #define FETCH_S() do {a=READ_S();} while (0)
 #define FETCH_W() do {a=READ_W();} while (0)
 
-/* with OP_EXT1 (1st 16bit) */
-#define FETCH_Z_1() FETCH_Z()
-#define FETCH_B_1() FETCH_S()
-#define FETCH_BB_1() do {a=READ_S(); b=READ_B();} while (0)
-#define FETCH_BBB_1() do {a=READ_S(); b=READ_B(); c=READ_B();} while (0)
-#define FETCH_BS_1() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_S_1() FETCH_S()
-#define FETCH_W_1() FETCH_W()
-
-/* with OP_EXT2 (2nd 16bit) */
-#define FETCH_Z_2() FETCH_Z()
-#define FETCH_B_2() FETCH_B()
-#define FETCH_BB_2() do {a=READ_B(); b=READ_S();} while (0)
-#define FETCH_BBB_2() do {a=READ_B(); b=READ_S(); c=READ_B();} while (0)
-#define FETCH_BS_2() FETCH_BS()
-#define FETCH_S_2() FETCH_S()
-#define FETCH_W_2() FETCH_W()
-
-/* with OP_EXT3 (1st & 2nd 16bit) */
-#define FETCH_Z_3() FETCH_Z()
-#define FETCH_B_3() FETCH_B()
-#define FETCH_BB_3() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_BBB_3() do {a=READ_S(); b=READ_S(); c=READ_B();} while (0)
-#define FETCH_BS_3() do {a=READ_S(); b=READ_S();} while (0)
-#define FETCH_S_3() FETCH_S()
-#define FETCH_W_3() FETCH_W()
-
 #endif  /* MRUBY_OPCODE_H */

data/ext/enterprise_script_service/mruby/include/mruby/ops.h

@@ -1,11 +1,12 @@
 /* operand types:
-   + Z: no operand (Z,Z,Z,Z)
-   + B: 8bit (B,S,B,B)
-   + BB: 8+8bit (BB,SB,BS,SS)
-   + BBB: 8+8+8bit (BBB,SBB,BSB,SSB)
-   + BS: 8+16bit (BS,SS,BS,BS)
-   + S: 16bit (S,S,S,S)
-   + W: 24bit (W,W,W,W)
+   + Z: no operand
+   + B: 8bit
+   + BB: 8+8bit
+   + BBB: 8+8+8bit
+   + BS: 8+16bit
+   + BSS: 8+16+16bit
+   + S: 16bit
+   + W: 24bit
 */
 
 /*-----------------------------------------------------------------------
@@ -14,6 +15,7 @@ operation code    operands      semantics
 OPCODE(NOP,        Z)        /* no operation */
 OPCODE(MOVE,       BB)       /* R(a) = R(b) */
 OPCODE(LOADL,      BB)       /* R(a) = Pool(b) */
+OPCODE(LOADL16,    BS)       /* R(a) = Pool(b) */
 OPCODE(LOADI,      BB)       /* R(a) = mrb_int(b) */
 OPCODE(LOADINEG,   BB)       /* R(a) = mrb_int(-b) */
 OPCODE(LOADI__1,   B)        /* R(a) = mrb_int(-1) */
@@ -25,7 +27,10 @@ OPCODE(LOADI_4,    B)        /* R(a) = mrb_int(4) */
 OPCODE(LOADI_5,    B)        /* R(a) = mrb_int(5) */
 OPCODE(LOADI_6,    B)        /* R(a) = mrb_int(6) */
 OPCODE(LOADI_7,    B)        /* R(a) = mrb_int(7) */
+OPCODE(LOADI16,    BS)       /* R(a) = mrb_int(b) */
+OPCODE(LOADI32,    BSS)      /* R(a) = mrb_int((b<<16)+c) */
 OPCODE(LOADSYM,    BB)       /* R(a) = Syms(b) */
+OPCODE(LOADSYM16,  BS)       /* R(a) = Syms(b) */
 OPCODE(LOADNIL,    B)        /* R(a) = nil */
 OPCODE(LOADSELF,   B)        /* R(a) = self */
 OPCODE(LOADT,      B)        /* R(a) = true */
@@ -44,28 +49,26 @@ OPCODE(GETMCNST,   BB)       /* R(a) = R(a)::Syms(b) */
 OPCODE(SETMCNST,   BB)       /* R(a+1)::Syms(b) = R(a) */
 OPCODE(GETUPVAR,   BBB)      /* R(a) = uvget(b,c) */
 OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R(a)) */
-OPCODE(JMP,        S)        /* pc=a */
-OPCODE(JMPIF,      BS)       /* if R(a) pc=b */
-OPCODE(JMPNOT,     BS)       /* if !R(a) pc=b */
-OPCODE(JMPNIL,     BS)       /* if R(a)==nil pc=b */
-OPCODE(ONERR,      S)        /* rescue_push(a) */
+OPCODE(JMP,        S)        /* pc+=a */
+OPCODE(JMPIF,      BS)       /* if R(a) pc+=b */
+OPCODE(JMPNOT,     BS)       /* if !R(a) pc+=b */
+OPCODE(JMPNIL,     BS)       /* if R(a)==nil pc+=b */
+OPCODE(JMPUW,      S)        /* unwind_and_jump_to(a) */
 OPCODE(EXCEPT,     B)        /* R(a) = exc */
 OPCODE(RESCUE,     BB)       /* R(b) = R(a).isa?(R(b)) */
-OPCODE(POPERR,     B)        /* a.times{rescue_pop()} */
-OPCODE(RAISE,      B)        /* raise(R(a)) */
-OPCODE(EPUSH,      B)        /* ensure_push(SEQ[a]) */
-OPCODE(EPOP,       B)        /* A.times{ensure_pop().call} */
+OPCODE(RAISEIF,    B)        /* raise(R(a)) if R(a) */
 OPCODE(SENDV,      BB)       /* R(a) = call(R(a),Syms(b),*R(a+1)) */
 OPCODE(SENDVB,     BB)       /* R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2)) */
 OPCODE(SEND,       BBB)      /* R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c)) */
 OPCODE(SENDB,      BBB)      /* R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c),&R(a+c+1)) */
+OPCODE(SENDVK,     BB)       /* R(a) = call(R(a),Syms(b),*R(a+1),**(a+2),&R(a+3)) # todo */
 OPCODE(CALL,       Z)        /* R(0) = self.call(frame.argc, frame.argv) */
 OPCODE(SUPER,      BB)       /* R(a) = super(R(a+1),... ,R(a+b+1)) */
 OPCODE(ARGARY,     BS)       /* R(a) = argument array (16=m5:r1:m5:d1:lv4) */
 OPCODE(ENTER,      W)        /* arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1) */
-OPCODE(KEY_P,      BB)       /* R(a) = kdict.key?(Syms(b))                      # todo */
-OPCODE(KEYEND,     Z)        /* raise unless kdict.empty?                       # todo */
-OPCODE(KARG,       BB)       /* R(a) = kdict[Syms(b)]; kdict.delete(Syms(b))    # todo */
+OPCODE(KEY_P,      BB)       /* R(a) = kdict.key?(Syms(b)) */
+OPCODE(KEYEND,     Z)        /* raise unless kdict.empty? */
+OPCODE(KARG,       BB)       /* R(a) = kdict[Syms(b)]; kdict.delete(Syms(b)) */
 OPCODE(RETURN,     B)        /* return R(a) (normal) */
 OPCODE(RETURN_BLK, B)        /* return R(a) (in-block return) */
 OPCODE(BREAK,      B)        /* break R(a) */
@@ -91,19 +94,24 @@ OPCODE(ASET,       BBB)      /* R(a)[c] = R(b) */
 OPCODE(APOST,      BBB)      /* *R(a),R(a+1)..R(a+c) = R(a)[b..] */
 OPCODE(INTERN,     B)        /* R(a) = intern(R(a)) */
 OPCODE(STRING,     BB)       /* R(a) = str_dup(Lit(b)) */
+OPCODE(STRING16,   BS)       /* R(a) = str_dup(Lit(b)) */
 OPCODE(STRCAT,     B)        /* str_cat(R(a),R(a+1)) */
 OPCODE(HASH,       BB)       /* R(a) = hash_new(R(a),R(a+1)..R(a+b*2-1)) */
 OPCODE(HASHADD,    BB)       /* R(a) = hash_push(R(a),R(a+1)..R(a+b*2)) */
 OPCODE(HASHCAT,    B)        /* R(a) = hash_cat(R(a),R(a+1)) */
 OPCODE(LAMBDA,     BB)       /* R(a) = lambda(SEQ[b],L_LAMBDA) */
+OPCODE(LAMBDA16,   BS)       /* R(a) = lambda(SEQ[b],L_LAMBDA) */
 OPCODE(BLOCK,      BB)       /* R(a) = lambda(SEQ[b],L_BLOCK) */
+OPCODE(BLOCK16,    BS)       /* R(a) = lambda(SEQ[b],L_BLOCK) */
 OPCODE(METHOD,     BB)       /* R(a) = lambda(SEQ[b],L_METHOD) */
+OPCODE(METHOD16,   BS)       /* R(a) = lambda(SEQ[b],L_METHOD) */
 OPCODE(RANGE_INC,  B)        /* R(a) = range_new(R(a),R(a+1),FALSE) */
 OPCODE(RANGE_EXC,  B)        /* R(a) = range_new(R(a),R(a+1),TRUE) */
 OPCODE(OCLASS,     B)        /* R(a) = ::Object */
 OPCODE(CLASS,      BB)       /* R(a) = newclass(R(a),Syms(b),R(a+1)) */
 OPCODE(MODULE,     BB)       /* R(a) = newmodule(R(a),Syms(b)) */
 OPCODE(EXEC,       BB)       /* R(a) = blockexec(R(a),SEQ[b]) */
+OPCODE(EXEC16,     BS)       /* R(a) = blockexec(R(a),SEQ[b]) */
 OPCODE(DEF,        BB)       /* R(a).newmethod(Syms(b),R(a+1)) */
 OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms(a),Syms(b)) */
 OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms(a)) */
@@ -111,8 +119,4 @@ OPCODE(SCLASS,     B)        /* R(a) = R(a).singleton_class */
 OPCODE(TCLASS,     B)        /* R(a) = target_class */
 OPCODE(DEBUG,      BBB)      /* print a,b,c */
 OPCODE(ERR,        B)        /* raise(LocalJumpError, Lit(a)) */
-OPCODE(EXT1,       Z)        /* make 1st operand 16bit */
-OPCODE(EXT2,       Z)        /* make 2nd operand 16bit */
-OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
 OPCODE(STOP,       Z)        /* stop VM */
-OPCODE(LOADI16,    BS)       /* R(a) = mrb_int(b) */