script_core 0.2.7 → 0.3.0

data/ext/enterprise_script_service/mruby/src/symbol.c

@@ -11,6 +11,47 @@
 #include <mruby/string.h>
 #include <mruby/dump.h>
 #include <mruby/class.h>
+#include <mruby/presym.h>
+
+#ifndef MRB_NO_PRESYM
+
+#ifndef MRB_PRESYM_SCANNING
+/* const uint16_t presym_length_table[]   */
+/* const char * const presym_name_table[] */
+# include <mruby/presym/table.h>
+#endif
+
+static mrb_sym
+presym_find(const char *name, size_t len)
+{
+  if (presym_length_table[MRB_PRESYM_MAX-1] < len) return 0;
+
+  mrb_sym start, idx, presym_size = MRB_PRESYM_MAX;
+  int cmp;
+  for (start = 0; presym_size != 0; presym_size/=2) {
+    idx = start+presym_size/2;
+    cmp = (int)len-(int)presym_length_table[idx];
+    if (cmp == 0) {
+      cmp = memcmp(name, presym_name_table[idx], len);
+      if (cmp == 0) return idx+1;
+    }
+    if (0 < cmp) {
+      start = ++idx;
+      --presym_size;
+    }
+  }
+  return 0;
+}
+
+static const char*
+presym_sym2name(mrb_sym sym, mrb_int *lenp)
+{
+  if (sym > MRB_PRESYM_MAX) return NULL;
+  if (lenp) *lenp = presym_length_table[sym-1];
+  return presym_name_table[sym-1];
+}
+
+#endif  /* MRB_NO_PRESYM */
 
 /* ------------------------------------------------------ */
 typedef struct symbol_name {
@@ -20,46 +61,35 @@ typedef struct symbol_name {
   const char *name;
 } symbol_name;
 
-#define SYMBOL_INLINE_BIT_POS       1
-#define SYMBOL_INLINE_LOWER_BIT_POS 2
-#define SYMBOL_INLINE               (1 << (SYMBOL_INLINE_BIT_POS - 1))
-#define SYMBOL_INLINE_LOWER         (1 << (SYMBOL_INLINE_LOWER_BIT_POS - 1))
-#define SYMBOL_NORMAL_SHIFT         SYMBOL_INLINE_BIT_POS
-#define SYMBOL_INLINE_SHIFT         SYMBOL_INLINE_LOWER_BIT_POS
-#ifdef MRB_ENABLE_ALL_SYMBOLS
-# define SYMBOL_INLINE_P(sym) FALSE
-# define SYMBOL_INLINE_LOWER_P(sym) FALSE
-# define sym_inline_pack(name, len) 0
-# define sym_inline_unpack(sym, buf, lenp) NULL
-#else
-# define SYMBOL_INLINE_P(sym) ((sym) & SYMBOL_INLINE)
-# define SYMBOL_INLINE_LOWER_P(sym) ((sym) & SYMBOL_INLINE_LOWER)
-#endif
-
 static void
 sym_validate_len(mrb_state *mrb, size_t len)
 {
-  if (len >= RITE_LV_NULL_MARK) {
+  if (len >= UINT16_MAX) {
     mrb_raise(mrb, E_ARGUMENT_ERROR, "symbol length too long");
   }
 }
 
-#ifndef MRB_ENABLE_ALL_SYMBOLS
+#ifdef MRB_USE_ALL_SYMBOLS
+# define SYMBOL_INLINE_P(sym) FALSE
+# define sym_inline_pack(name, len) 0
+# define sym_inline_unpack(sym, buf, lenp) NULL
+#else
+# define SYMBOL_INLINE_P(sym) ((sym) >= (1<<24))
+
 static const char pack_table[] = "_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
 
 static mrb_sym
 sym_inline_pack(const char *name, size_t len)
 {
-  const size_t lower_length_max = (MRB_SYMBOL_BIT - 2) / 5;
-  const size_t mix_length_max   = (MRB_SYMBOL_BIT - 2) / 6;
+  const size_t pack_length_max = 5;
 
   char c;
   const char *p;
   size_t i;
   mrb_sym sym = 0;
-  mrb_bool lower = TRUE;
 
-  if (len > lower_length_max) return 0; /* too long */
+  if (len > pack_length_max) return 0; /* too long */
+  if (len == 0) return 0; /* empty string */
   for (i=0; i<len; i++) {
     uint32_t bits;
 
@@ -68,36 +98,21 @@ sym_inline_pack(const char *name, size_t len)
     p = strchr(pack_table, (int)c);
     if (p == 0) return 0;       /* non alnum char */
     bits = (uint32_t)(p - pack_table)+1;
-    if (bits > 27) lower = FALSE;
-    if (i >= mix_length_max) break;
-    sym |= bits<<(i*6+SYMBOL_INLINE_SHIFT);
+    sym |= bits<<(24-i*6);
   }
-  if (lower) {
-    sym = 0;
-    for (i=0; i<len; i++) {
-      uint32_t bits;
-
-      c = name[i];
-      p = strchr(pack_table, (int)c);
-      bits = (uint32_t)(p - pack_table)+1;
-      sym |= bits<<(i*5+SYMBOL_INLINE_SHIFT);
-    }
-    return sym | SYMBOL_INLINE | SYMBOL_INLINE_LOWER;
-  }
-  if (len > mix_length_max) return 0;
-  return sym | SYMBOL_INLINE;
+  mrb_assert(SYMBOL_INLINE_P(sym));
+  return sym;
 }
 
 static const char*
 sym_inline_unpack(mrb_sym sym, char *buf, mrb_int *lenp)
 {
-  int bit_per_char = SYMBOL_INLINE_LOWER_P(sym) ? 5 : 6;
   int i;
 
   mrb_assert(SYMBOL_INLINE_P(sym));
 
-  for (i=0; i<30/bit_per_char; i++) {
-    uint32_t bits = sym>>(i*bit_per_char+SYMBOL_INLINE_SHIFT) & ((1<<bit_per_char)-1);
+  for (i=0; i<5; i++) {
+    uint32_t bits = sym>>(24-i*6) & 0x3f;
     if (bits == 0) break;
     buf[i] = pack_table[bits-1];;
   }
@@ -130,6 +145,12 @@ find_symbol(mrb_state *mrb, const char *name, size_t len, uint8_t *hashp)
   symbol_name *sname;
   uint8_t hash;
 
+#ifndef MRB_NO_PRESYM
+  /* presym */
+  i = presym_find(name, len);
+  if (i > 0) return i;
+#endif
+
   /* inline symbol */
   i = sym_inline_pack(name, len);
   if (i > 0) return i;
@@ -142,14 +163,14 @@ find_symbol(mrb_state *mrb, const char *name, size_t len, uint8_t *hashp)
   do {
     sname = &mrb->symtbl[i];
     if (sname->len == len && memcmp(sname->name, name, len) == 0) {
-      return i<<SYMBOL_NORMAL_SHIFT;
+      return (i+MRB_PRESYM_MAX);
     }
     if (sname->prev == 0xff) {
       i -= 0xff;
       sname = &mrb->symtbl[i];
       while (mrb->symtbl < sname) {
         if (sname->len == len && memcmp(sname->name, name, len) == 0) {
-          return (mrb_sym)(sname - mrb->symtbl)<<SYMBOL_NORMAL_SHIFT;
+          return (mrb_sym)((sname - mrb->symtbl)+MRB_PRESYM_MAX);
         }
         sname--;
       }
@@ -205,7 +226,7 @@ sym_intern(mrb_state *mrb, const char *name, size_t len, mrb_bool lit)
   }
   mrb->symhash[hash] = mrb->symidx = sym;
 
-  return sym<<SYMBOL_NORMAL_SHIFT;
+  return (sym+MRB_PRESYM_MAX);
 }
 
 MRB_API mrb_sym
@@ -232,36 +253,69 @@ mrb_intern_str(mrb_state *mrb, mrb_value str)
   return mrb_intern(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
 }
 
-MRB_API mrb_value
-mrb_check_intern(mrb_state *mrb, const char *name, size_t len)
+MRB_API mrb_sym
+mrb_intern_check(mrb_state *mrb, const char *name, size_t len)
 {
   mrb_sym sym;
 
   sym_validate_len(mrb, len);
   sym = find_symbol(mrb, name, len, NULL);
-  if (sym > 0) return mrb_symbol_value(sym);
-  return mrb_nil_value();
+  if (sym > 0) return sym;
+  return 0;
+}
+
+MRB_API mrb_value
+mrb_check_intern(mrb_state *mrb, const char *name, size_t len)
+{
+  mrb_sym sym = mrb_intern_check(mrb, name, len);
+  if (sym == 0) return mrb_nil_value();
+  return mrb_symbol_value(sym);
+}
+
+MRB_API mrb_sym
+mrb_intern_check_cstr(mrb_state *mrb, const char *name)
+{
+  return mrb_intern_check(mrb, name, strlen(name));
 }
 
 MRB_API mrb_value
 mrb_check_intern_cstr(mrb_state *mrb, const char *name)
 {
-  return mrb_check_intern(mrb, name, strlen(name));
+  mrb_sym sym = mrb_intern_check_cstr(mrb, name);
+  if (sym == 0) return mrb_nil_value();
+  return mrb_symbol_value(sym);
+}
+
+MRB_API mrb_sym
+mrb_intern_check_str(mrb_state *mrb, mrb_value str)
+{
+  return mrb_intern_check(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
 }
 
 MRB_API mrb_value
 mrb_check_intern_str(mrb_state *mrb, mrb_value str)
 {
-  return mrb_check_intern(mrb, RSTRING_PTR(str), RSTRING_LEN(str));
+  mrb_sym sym = mrb_intern_check_str(mrb, str);
+  if (sym == 0) return mrb_nil_value();
+  return mrb_symbol_value(sym);
 }
 
 static const char*
 sym2name_len(mrb_state *mrb, mrb_sym sym, char *buf, mrb_int *lenp)
 {
+  if (sym == 0) goto outofsym;
   if (SYMBOL_INLINE_P(sym)) return sym_inline_unpack(sym, buf, lenp);
 
-  sym >>= SYMBOL_NORMAL_SHIFT;
-  if (sym == 0 || mrb->symidx < sym) {
+#ifndef MRB_NO_PRESYM
+  {
+    const char *name = presym_sym2name(sym, lenp);
+    if (name) return name;
+  }
+#endif
+  sym -= MRB_PRESYM_MAX;
+
+  if (mrb->symidx < sym) {
+  outofsym:
     if (lenp) *lenp = 0;
     return NULL;
   }
@@ -273,7 +327,19 @@ sym2name_len(mrb_state *mrb, mrb_sym sym, char *buf, mrb_int *lenp)
 MRB_API const char*
 mrb_sym_name_len(mrb_state *mrb, mrb_sym sym, mrb_int *lenp)
 {
+#ifdef MRB_USE_ALL_SYMBOLS
+  return sym2name_len(mrb, sym, NULL, lenp);
+#else
   return sym2name_len(mrb, sym, mrb->symbuf, lenp);
+#endif
+}
+
+mrb_bool
+mrb_sym_static_p(mrb_state *mrb, mrb_sym sym)
+{
+  if (SYMBOL_INLINE_P(sym)) return TRUE;
+  if (sym > MRB_PRESYM_MAX) return FALSE;
+  return TRUE;
 }
 
 void
@@ -497,7 +563,7 @@ sym_inspect(mrb_state *mrb, mrb_value sym)
   char *sp;
 
   name = mrb_sym_name_len(mrb, id, &len);
-  str = mrb_str_new(mrb, 0, len+1);
+  str = mrb_str_new(mrb, NULL, len+1);
   sp = RSTRING_PTR(str);
   sp[0] = ':';
   memcpy(sp+1, name, len);
@@ -540,8 +606,7 @@ sym_name(mrb_state *mrb, mrb_sym sym, mrb_bool dump)
     return name;
   }
   else {
-    mrb_value str = SYMBOL_INLINE_P(sym) ?
-      mrb_str_new(mrb, name, len) : mrb_str_new_static(mrb, name, len);
+    mrb_value str = mrb_str_new_static(mrb, name, len);
     str = mrb_str_dump(mrb, str);
     return RSTRING_PTR(str);
   }

data/ext/enterprise_script_service/mruby/src/value_array.h

@@ -6,6 +6,7 @@
 static inline void
 value_move(mrb_value *s1, const mrb_value *s2, size_t n)
 {
+  if (n == 0) return;
   if (s1 > s2 && s1 < s2 + n)
   {
     s1 += n;

data/ext/enterprise_script_service/mruby/src/variable.c

@@ -10,22 +10,18 @@
 #include <mruby/proc.h>
 #include <mruby/string.h>
 #include <mruby/variable.h>
+#include <mruby/presym.h>
 
-#ifndef MRB_IV_SEGMENT_SIZE
-#define MRB_IV_SEGMENT_SIZE 4
-#endif
-
-typedef struct segment {
-  mrb_sym key[MRB_IV_SEGMENT_SIZE];
-  mrb_value val[MRB_IV_SEGMENT_SIZE];
-  struct segment *next;
-} segment;
+struct iv_elem {
+  mrb_sym key;
+  mrb_value val;
+};
 
 /* Instance variable table structure */
 typedef struct iv_tbl {
-  segment *rootseg;
   size_t size;
-  size_t last_len;
+  size_t alloc;
+  struct iv_elem *table;
 } iv_tbl;
 
 /* Creates the instance variable table. */
@@ -36,67 +32,82 @@ iv_new(mrb_state *mrb)
 
   t = (iv_tbl*)mrb_malloc(mrb, sizeof(iv_tbl));
   t->size = 0;
-  t->rootseg =  NULL;
-  t->last_len = 0;
+  t->alloc = 0;
+  t->table = NULL;
 
   return t;
 }
 
+static void iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val);
+
+static void
+iv_rehash(mrb_state *mrb, iv_tbl *t)
+{
+  size_t old_alloc = t->alloc;
+  size_t new_alloc = old_alloc+1;
+  struct iv_elem *old_table = t->table;
+
+  khash_power2(new_alloc);
+  if (old_alloc == new_alloc) return;
+
+  t->alloc = new_alloc;
+  t->size = 0;
+  t->table = (struct iv_elem*)mrb_calloc(mrb, sizeof(struct iv_elem), new_alloc);
+
+  for (size_t i = 0; i < old_alloc; i++) {
+    struct iv_elem *slot = &old_table[i];
+
+    /* key = 0 means empty; val = undef means deleted */
+    if (slot->key != 0 && !mrb_undef_p(slot->val)) {
+      iv_put(mrb, t, slot->key, slot->val);
+    }
+  }
+  mrb_free(mrb, old_table);
+}
+
+#define slot_empty_p(slot) ((slot)->key == 0 && !mrb_undef_p((slot)->val))
+
 /* Set the value for the symbol in the instance variable table. */
 static void
 iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val)
 {
-  segment *seg;
-  segment *prev = NULL;
-  segment *matched_seg = NULL;
-  size_t matched_idx = 0;
-  size_t i;
+  size_t hash, pos, start;
+  struct iv_elem *dslot = NULL;
 
   if (t == NULL) return;
-  seg = t->rootseg;
-  while (seg) {
-    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
-      mrb_sym key = seg->key[i];
-      /* Found room in last segment after last_len */
-      if (!seg->next && i >= t->last_len) {
-        seg->key[i] = sym;
-        seg->val[i] = val;
-        t->last_len = i+1;
+  if (t->alloc == 0) {
+    iv_rehash(mrb, t);
+  }
+  hash = kh_int_hash_func(mrb, sym);
+  start = pos = hash & (t->alloc-1);
+  for (;;) {
+    struct iv_elem *slot = &t->table[pos];
+
+    if (slot->key == sym) {
+      slot->val = val;
+      return;
+    }
+    else if (slot_empty_p(slot)) {
+      t->size++;
+      slot->key = sym;
+      slot->val = val;
+      return;
+    }
+    else if (!dslot && mrb_undef_p(slot->val)) { /* deleted */
+      dslot = slot;
+    }
+    pos = (pos+1) & (t->alloc-1);
+    if (pos == start) {         /* not found */
+      if (dslot) {
         t->size++;
+        dslot->key = sym;
+        dslot->val = val;
         return;
       }
-      if (!matched_seg && key == 0) {
-        matched_seg = seg;
-        matched_idx = i;
-      }
-      else if (key == sym) {
-        seg->val[i] = val;
-        return;
-      }
+      /* no room */
+      iv_rehash(mrb, t);
+      start = pos = hash & (t->alloc-1);
     }
-    prev = seg;
-    seg = seg->next;
-  }
-
-  /* Not found */
-  if (matched_seg) {
-    matched_seg->key[matched_idx] = sym;
-    matched_seg->val[matched_idx] = val;
-    t->size++;
-    return;
-  }
-
-  seg = (segment*)mrb_malloc(mrb, sizeof(segment));
-  seg->next = NULL;
-  seg->key[0] = sym;
-  seg->val[0] = val;
-  t->last_len = 1;
-  t->size++;
-  if (prev) {
-    prev->next = seg;
-  }
-  else {
-    t->rootseg = seg;
   }
 }
 
@@ -104,80 +115,81 @@ iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val)
 static mrb_bool
 iv_get(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
 {
-  segment *seg;
-  size_t i;
+  size_t hash, pos, start;
 
   if (t == NULL) return FALSE;
-  seg = t->rootseg;
-  while (seg) {
-    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
-      mrb_sym key = seg->key[i];
+  if (t->alloc == 0) return FALSE;
+  if (t->size == 0) return FALSE;
 
-      if (!seg->next && i >= t->last_len) {
-        return FALSE;
-      }
-      if (key == sym) {
-        if (vp) *vp = seg->val[i];
-        return TRUE;
-      }
+  hash = kh_int_hash_func(mrb, sym);
+  start = pos = hash & (t->alloc-1);
+  for (;;) {
+    struct iv_elem *slot = &t->table[pos];
+
+    if (slot->key == sym) {
+      if (vp) *vp = slot->val;
+      return TRUE;
+    }
+    else if (slot_empty_p(slot)) {
+      return FALSE;
+    }
+    pos = (pos+1) & (t->alloc-1);
+    if (pos == start) {         /* not found */
+      return FALSE;
     }
-    seg = seg->next;
   }
-  return FALSE;
 }
 
 /* Deletes the value for the symbol from the instance variable table. */
 static mrb_bool
 iv_del(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
 {
-  segment *seg;
-  size_t i;
+  size_t hash, pos, start;
 
   if (t == NULL) return FALSE;
-  seg = t->rootseg;
-  while (seg) {
-    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
-      mrb_sym key = seg->key[i];
+  if (t->alloc == 0) return  FALSE;
+  if (t->size == 0) return FALSE;
 
-      if (!seg->next && i >= t->last_len) {
-        return FALSE;
-      }
-      if (key == sym) {
-        t->size--;
-        seg->key[i] = 0;
-        if (vp) *vp = seg->val[i];
-        return TRUE;
-      }
+  hash = kh_int_hash_func(mrb, sym);
+  start = pos = hash & (t->alloc-1);
+  for (;;) {
+    struct iv_elem *slot = &t->table[pos];
+
+    if (slot->key == sym) {
+      if (vp) *vp = slot->val;
+      t->size--;
+      slot->key = 0;
+      slot->val = mrb_undef_value();
+      return TRUE;
+    }
+    else if (slot_empty_p(slot)) {
+      return FALSE;
+    }
+    pos = (pos+1) & (t->alloc-1);
+    if (pos == start) {         /* not found */
+      return FALSE;
     }
-    seg = seg->next;
   }
-  return FALSE;
 }
 
 /* Iterates over the instance variable table. */
 static void
 iv_foreach(mrb_state *mrb, iv_tbl *t, mrb_iv_foreach_func *func, void *p)
 {
-  segment *seg;
   size_t i;
 
   if (t == NULL) return;
-  seg = t->rootseg;
-  while (seg) {
-    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
-      mrb_sym key = seg->key[i];
+  if (t->alloc == 0) return;
+  if (t->size == 0) return;
+
+  for (i=0; i<t->alloc; i++) {
+    struct iv_elem *slot = &t->table[i];
 
-      /* no value in last segment after last_len */
-      if (!seg->next && i >= t->last_len) {
+    if (slot->key && !mrb_undef_p(slot->val)) {
+      if ((*func)(mrb, slot->key, slot->val, p) != 0) {
         return;
       }
-      if (key != 0) {
-        if ((*func)(mrb, key, seg->val[i], p) != 0) {
-          return;
-        }
-      }
     }
-    seg = seg->next;
   }
   return;
 }
@@ -186,47 +198,28 @@ iv_foreach(mrb_state *mrb, iv_tbl *t, mrb_iv_foreach_func *func, void *p)
 static size_t
 iv_size(mrb_state *mrb, iv_tbl *t)
 {
-  segment *seg;
-  size_t size = 0;
-
   if (t == NULL) return 0;
-  if (t->size > 0) return t->size;
-  seg = t->rootseg;
-  while (seg) {
-    if (seg->next == NULL) {
-      size += t->last_len;
-      return size;
-    }
-    seg = seg->next;
-    size += MRB_IV_SEGMENT_SIZE;
-  }
-  /* empty iv_tbl */
-  return 0;
+  return t->size;
 }
 
 /* Copy the instance variable table. */
 static iv_tbl*
 iv_copy(mrb_state *mrb, iv_tbl *t)
 {
-  segment *seg;
   iv_tbl *t2;
-
   size_t i;
 
-  seg = t->rootseg;
-  t2 = iv_new(mrb);
+  if (t == NULL) return NULL;
+  if (t->alloc == 0) return NULL;
+  if (t->size == 0) return NULL;
 
-  while (seg != NULL) {
-    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
-      mrb_sym key = seg->key[i];
-      mrb_value val = seg->val[i];
+  t2 = iv_new(mrb);
+  for (i=0; i<t->alloc; i++) {
+    struct iv_elem *slot = &t->table[i];
 
-      if ((seg->next == NULL) && (i >= t->last_len)) {
-        return t2;
-      }
-      iv_put(mrb, t2, key, val);
+    if (slot->key && !mrb_undef_p(slot->val)) {
+      iv_put(mrb, t2, slot->key, slot->val);
     }
-    seg = seg->next;
   }
   return t2;
 }
@@ -235,14 +228,7 @@ iv_copy(mrb_state *mrb, iv_tbl *t)
 static void
 iv_free(mrb_state *mrb, iv_tbl *t)
 {
-  segment *seg;
-
-  seg = t->rootseg;
-  while (seg) {
-    segment *p = seg;
-    seg = seg->next;
-    mrb_free(mrb, p);
-  }
+  mrb_free(mrb, t->table);
   mrb_free(mrb, t);
 }
 
@@ -349,7 +335,7 @@ mrb_obj_iv_set_force(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value
     obj->iv = iv_new(mrb);
   }
   iv_put(mrb, obj->iv, sym, v);
-  mrb_write_barrier(mrb, (struct RBasic*)obj);
+  mrb_field_write_barrier_value(mrb, (struct RBasic*)obj, v);
 }
 
 MRB_API void
@@ -379,11 +365,11 @@ assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
   if (namespace_p(obj->tt) && namespace_p(mrb_type(v))) {
     struct RObject *c = mrb_obj_ptr(v);
     if (obj != c && ISUPPER(mrb_sym_name_len(mrb, sym, NULL)[0])) {
-      mrb_sym id_classname = mrb_intern_lit(mrb, "__classname__");
+      mrb_sym id_classname = MRB_SYM(__classname__);
       mrb_value o = mrb_obj_iv_get(mrb, c, id_classname);
 
       if (mrb_nil_p(o)) {
-        mrb_sym id_outer = mrb_intern_lit(mrb, "__outer__");
+        mrb_sym id_outer = MRB_SYM(__outer__);
         o = mrb_obj_iv_get(mrb, c, id_outer);
 
         if (mrb_nil_p(o)) {
@@ -643,8 +629,7 @@ mrb_mod_cv_get(mrb_state *mrb, struct RClass *c, mrb_sym sym)
   if (cls && cls->tt == MRB_TT_SCLASS) {
     mrb_value klass;
 
-    klass = mrb_obj_iv_get(mrb, (struct RObject *)cls,
-                           mrb_intern_lit(mrb, "__attached__"));
+    klass = mrb_obj_iv_get(mrb, (struct RObject *)cls, MRB_SYM(__attached__));
     c = mrb_class_ptr(klass);
     if (c->tt == MRB_TT_CLASS || c->tt == MRB_TT_MODULE) {
       given = FALSE;
@@ -679,7 +664,7 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
     if (iv_get(mrb, t, sym, NULL)) {
       mrb_check_frozen(mrb, c);
       iv_put(mrb, t, sym, v);
-      mrb_write_barrier(mrb, (struct RBasic*)c);
+      mrb_field_write_barrier_value(mrb, (struct RBasic*)c, v);
       return;
     }
     c = c->super;
@@ -688,8 +673,7 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
   if (cls && cls->tt == MRB_TT_SCLASS) {
     mrb_value klass;
 
-    klass = mrb_obj_iv_get(mrb, (struct RObject*)cls,
-                           mrb_intern_lit(mrb, "__attached__"));
+    klass = mrb_obj_iv_get(mrb, (struct RObject*)cls, MRB_SYM(__attached__));
     switch (mrb_type(klass)) {
     case MRB_TT_CLASS:
     case MRB_TT_MODULE:
@@ -711,7 +695,7 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
   }
 
   iv_put(mrb, c->iv, sym, v);
-  mrb_write_barrier(mrb, (struct RBasic*)c);
+  mrb_field_write_barrier_value(mrb, (struct RBasic*)c, v);
 }
 
 MRB_API void
@@ -743,11 +727,11 @@ mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym)
 {
   struct RClass *c;
 
-  struct RProc *p = mrb->c->ci->proc;
+  const struct RProc *p = mrb->c->ci->proc;
 
   for (;;) {
     c = MRB_PROC_TARGET_CLASS(p);
-    if (c->tt != MRB_TT_SCLASS) break;
+    if (c && c->tt != MRB_TT_SCLASS) break;
     p = p->upper;
   }
   return mrb_mod_cv_get(mrb, c, sym);
@@ -757,11 +741,11 @@ void
 mrb_vm_cv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
 {
   struct RClass *c;
-  struct RProc *p = mrb->c->ci->proc;
+  const struct RProc *p = mrb->c->ci->proc;
 
   for (;;) {
     c = MRB_PROC_TARGET_CLASS(p);
-    if (c->tt != MRB_TT_SCLASS) break;
+    if (c && c->tt != MRB_TT_SCLASS) break;
     p = p->upper;
   }
   mrb_mod_cv_set(mrb, c, sym, v);
@@ -803,7 +787,7 @@ L_RETRY:
     goto L_RETRY;
   }
   name = mrb_symbol_value(sym);
-  return mrb_funcall_argv(mrb, mrb_obj_value(base), mrb_intern_lit(mrb, "const_missing"), 1, &name);
+  return mrb_funcall_argv(mrb, mrb_obj_value(base), MRB_SYM(const_missing), 1, &name);
 }
 
 MRB_API mrb_value
@@ -819,9 +803,10 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
   struct RClass *c;
   struct RClass *c2;
   mrb_value v;
-  struct RProc *proc;
+  const struct RProc *proc;
 
   c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
+  if (!c) c = mrb->object_class;
   if (iv_get(mrb, c->iv, sym, &v)) {
     return v;
   }
@@ -829,7 +814,7 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
   while (c2 && c2->tt == MRB_TT_SCLASS) {
     mrb_value klass;
 
-    if (!iv_get(mrb, c2->iv, mrb_intern_lit(mrb, "__attached__"), &klass)) {
+    if (!iv_get(mrb, c2->iv, MRB_SYM(__attached__), &klass)) {
       c2 = NULL;
       break;
     }
@@ -864,6 +849,7 @@ mrb_vm_const_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
   struct RClass *c;
 
   c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
+  if (!c) c = mrb->object_class;
   mrb_obj_iv_set(mrb, (struct RObject*)c, sym, v);
 }
 
@@ -874,6 +860,12 @@ mrb_const_remove(mrb_state *mrb, mrb_value mod, mrb_sym sym)
   mrb_iv_remove(mrb, mod, sym);
 }
 
+MRB_API void
+mrb_define_const_id(mrb_state *mrb, struct RClass *mod, mrb_sym name, mrb_value v)
+{
+  mrb_obj_iv_set(mrb, (struct RObject*)mod, name, v);
+}
+
 MRB_API void
 mrb_define_const(mrb_state *mrb, struct RClass *mod, const char *name, mrb_value v)
 {
@@ -1070,7 +1062,7 @@ outer_class(mrb_state *mrb, struct RClass *c)
 {
   mrb_value ov;
 
-  ov = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__outer__"));
+  ov = mrb_obj_iv_get(mrb, (struct RObject*)c, MRB_SYM(__outer__));
   if (mrb_nil_p(ov)) return NULL;
   switch (mrb_type(ov)) {
   case MRB_TT_CLASS:
@@ -1120,14 +1112,22 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c)
   str = mrb_sym_name_len(mrb, name, &len);
   mrb_str_cat(mrb, path, str, len);
   if (RSTRING_PTR(path)[0] != '#') {
-    iv_del(mrb, c->iv, mrb_intern_lit(mrb, "__outer__"), NULL);
-    iv_put(mrb, c->iv, mrb_intern_lit(mrb, "__classname__"), path);
+    iv_del(mrb, c->iv, MRB_SYM(__outer__), NULL);
+    iv_put(mrb, c->iv, MRB_SYM(__classname__), path);
     mrb_field_write_barrier_value(mrb, (struct RBasic*)c, path);
     path = mrb_str_dup(mrb, path);
   }
   return path;
 }
 
+size_t
+mrb_obj_iv_tbl_memsize(mrb_value obj)
+{
+  iv_tbl *t = mrb_obj_ptr(obj)->iv;
+  if (t == NULL) return 0;
+  return sizeof(iv_tbl) + t->alloc*sizeof(struct iv_elem);
+}
+
 #define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
 
 mrb_bool