Changeset 439 for EcnlProtoTool/trunk/mruby-2.1.1/src/variable.c

Timestamp:

Jul 9, 2020, 8:51:43 AM (4 years ago)

Author:

coas-nagasima

Message:

mrubyを2.1.1に更新

Location:

EcnlProtoTool/trunk/mruby-2.1.1

Files:

• . (moved) (moved from EcnlProtoTool/trunk/mruby-1.3.0 )
• src/variable.c (modified) (49 diffs)

EcnlProtoTool/trunk/mruby-2.1.1/src/variable.c

@@ -10 +10 @@
 #include <mruby/proc.h>
 #include <mruby/string.h>
-
-typedef int (iv_foreach_func)(mrb_state*,mrb_sym,mrb_value,void*);
-
-#ifdef MRB_USE_IV_SEGLIST
-
-#ifndef MRB_SEGMENT_SIZE
-#define MRB_SEGMENT_SIZE 4
+#include <mruby/variable.h>
+
+#ifndef MRB_IV_SEGMENT_SIZE
+#define MRB_IV_SEGMENT_SIZE 4
 #endif
 
 typedef struct segment {
-  mrb_sym key[MRB_SEGMENT_SIZE];
-  mrb_value val[MRB_SEGMENT_SIZE];
+  mrb_sym key[MRB_IV_SEGMENT_SIZE];
+  mrb_value val[MRB_IV_SEGMENT_SIZE];
   struct segment *next;
 } segment;
@@ -32 +29 @@
 } iv_tbl;
 
-/*
- * Creates the instance variable table.
- *
- * Parameters
- *   mrb
- * Returns
- *   the instance variable table.
- */
+/* Creates the instance variable table. */
 static iv_tbl*
 iv_new(mrb_state *mrb)
@@ -53 +43 @@
 }
 
-/*
- * Set the value for the symbol in the instance variable table.
- *
- * Parameters
- *   mrb
- *   t     the instance variable table to be set in.
- *   sym   the symbol to be used as the key.
- *   val   the value to be set.
- */
+/* 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 = t->rootseg;
+  segment *seg;
   segment *prev = NULL;
   segment *matched_seg = NULL;
@@ -71 +53 @@
   size_t i;
 
+  if (t == NULL) return;
+  seg = t->rootseg;
   while (seg) {
-    for (i=0; i<MRB_SEGMENT_SIZE; i++) {
+    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
       mrb_sym key = seg->key[i];
       /* Found room in last segment after last_len */
@@ -96 +80 @@
 
   /* Not found */
-  t->size++;
   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));
-  if (!seg) return;
   seg->next = NULL;
   seg->key[0] = sym;
   seg->val[0] = val;
   t->last_len = 1;
+  t->size++;
   if (prev) {
     prev->next = seg;
@@ -117 +101 @@
 }
 
-/*
- * Get a value for a symbol from the instance variable table.
- *
- * Parameters
- *   mrb
- *   t     the variable table to be searched.
- *   sym   the symbol to be used as the key.
- *   vp    the value pointer. Receives the value if the specified symbol is
- *         contained in the instance variable table.
- * Returns
- *   true if the specified symbol is contained in the instance variable table.
- */
+/* Get a value for a symbol from the instance variable table. */
 static mrb_bool
 iv_get(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
@@ -135 +108 @@
   size_t i;
 
+  if (t == NULL) return FALSE;
   seg = t->rootseg;
   while (seg) {
-    for (i=0; i<MRB_SEGMENT_SIZE; i++) {
+    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
       mrb_sym key = seg->key[i];
 
@@ -153 +127 @@
 }
 
-/*
- * Deletes the value for the symbol from the instance variable table.
- *
- * Parameters
- *   t    the variable table to be searched.
- *   sym  the symbol to be used as the key.
- *   vp   the value pointer. Receive the deleted value if the symbol is
- *        contained in the instance variable table.
- * Returns
- *   true if the specified symbol is contained in the instance variable table.
- */
+/* 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)
@@ -170 +134 @@
   size_t i;
 
+  if (t == NULL) return FALSE;
   seg = t->rootseg;
   while (seg) {
-    for (i=0; i<MRB_SEGMENT_SIZE; i++) {
+    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
       mrb_sym key = seg->key[i];
 
@@ -190 +155 @@
 }
 
-static mrb_bool
-iv_foreach(mrb_state *mrb, iv_tbl *t, iv_foreach_func *func, void *p)
+/* 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;
-  int n;
-
+
+  if (t == NULL) return;
   seg = t->rootseg;
   while (seg) {
-    for (i=0; i<MRB_SEGMENT_SIZE; i++) {
+    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
       mrb_sym key = seg->key[i];
 
       /* no value in last segment after last_len */
       if (!seg->next && i >= t->last_len) {
-        return FALSE;
+        return;
       }
       if (key != 0) {
-        n =(*func)(mrb, key, seg->val[i], p);
-        if (n > 0) return FALSE;
-        if (n < 0) {
-          t->size--;
-          seg->key[i] = 0;
+        if ((*func)(mrb, key, seg->val[i], p) != 0) {
+          return;
         }
       }
@@ -217 +180 @@
     seg = seg->next;
   }
-  return TRUE;
-}
-
+  return;
+}
+
+/* Get the size of the instance variable table. */
 static size_t
 iv_size(mrb_state *mrb, iv_tbl *t)
@@ -226 +190 @@
   size_t size = 0;
 
-  if (!t) return 0;
+  if (t == NULL) return 0;
   if (t->size > 0) return t->size;
   seg = t->rootseg;
@@ -235 +199 @@
     }
     seg = seg->next;
-    size += MRB_SEGMENT_SIZE;
+    size += MRB_IV_SEGMENT_SIZE;
   }
   /* empty iv_tbl */
@@ -241 +205 @@
 }
 
+/* Copy the instance variable table. */
 static iv_tbl*
 iv_copy(mrb_state *mrb, iv_tbl *t)
@@ -253 +218 @@
 
   while (seg != NULL) {
-    for (i=0; i<MRB_SEGMENT_SIZE; i++) {
+    for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
       mrb_sym key = seg->key[i];
       mrb_value val = seg->val[i];
@@ -267 +232 @@
 }
 
+/* Free memory of the instance variable table. */
 static void
 iv_free(mrb_state *mrb, iv_tbl *t)
@@ -281 +247 @@
 }
 
-#else
-
-#include <mruby/khash.h>
-
-#ifndef MRB_IVHASH_INIT_SIZE
-#define MRB_IVHASH_INIT_SIZE 8
-#endif
-
-KHASH_DECLARE(iv, mrb_sym, mrb_value, TRUE)
-KHASH_DEFINE(iv, mrb_sym, mrb_value, TRUE, kh_int_hash_func, kh_int_hash_equal)
-
-typedef struct iv_tbl {
-  khash_t(iv) h;
-} iv_tbl;
-
-static iv_tbl*
-iv_new(mrb_state *mrb)
-{
-  return (iv_tbl*)kh_init_size(iv, mrb, MRB_IVHASH_INIT_SIZE);
-}
-
-static void
-iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val)
-{
-  khash_t(iv) *h = &t->h;
-  khiter_t k;
-
-  k = kh_put(iv, mrb, h, sym);
-  kh_value(h, k) = val;
-}
-
-static mrb_bool
-iv_get(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
-{
-  khash_t(iv) *h = &t->h;
-  khiter_t k;
-
-  k = kh_get(iv, mrb, h, sym);
-  if (k != kh_end(h)) {
-    if (vp) *vp = kh_value(h, k);
-    return TRUE;
-  }
-  return FALSE;
-}
-
-static mrb_bool
-iv_del(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
-{
-  khash_t(iv) *h = &t->h;
-  khiter_t k;
-
-  if (h) {
-    k = kh_get(iv, mrb, h, sym);
-    if (k != kh_end(h)) {
-      mrb_value val = kh_value(h, k);
-      kh_del(iv, mrb, h, k);
-      if (vp) *vp = val;
-      return TRUE;
-    }
-  }
-  return FALSE;
-}
-
-static mrb_bool
-iv_foreach(mrb_state *mrb, iv_tbl *t, iv_foreach_func *func, void *p)
-{
-  khash_t(iv) *h = &t->h;
-  khiter_t k;
-  int n;
-
-  if (h) {
-    for (k = kh_begin(h); k != kh_end(h); k++) {
-      if (kh_exist(h, k)) {
-        n = (*func)(mrb, kh_key(h, k), kh_value(h, k), p);
-        if (n > 0) return FALSE;
-        if (n < 0) {
-          kh_del(iv, mrb, h, k);
-        }
-      }
-    }
-  }
-  return TRUE;
-}
-
-static size_t
-iv_size(mrb_state *mrb, iv_tbl *t)
-{
-  khash_t(iv) *h;
-
-  if (t && (h = &t->h)) {
-    return kh_size(h);
-  }
-  return 0;
-}
-
-static iv_tbl*
-iv_copy(mrb_state *mrb, iv_tbl *t)
-{
-  return (iv_tbl*)kh_copy(iv, mrb, &t->h);
-}
-
-static void
-iv_free(mrb_state *mrb, iv_tbl *t)
-{
-  kh_destroy(iv, mrb, &t->h);
-}
-
-#endif
-
 static int
 iv_mark_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
@@ -400 +257 @@
 mark_tbl(mrb_state *mrb, iv_tbl *t)
 {
-  if (t) {
-    iv_foreach(mrb, t, iv_mark_i, 0);
-  }
+  iv_foreach(mrb, t, iv_mark_i, 0);
 }
 
@@ -485 +340 @@
 }
 
+static inline void assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v);
+
+void
+mrb_obj_iv_set_force(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
+{
+  assign_class_name(mrb, obj, sym, v);
+  if (!obj->iv) {
+    obj->iv = iv_new(mrb);
+  }
+  iv_put(mrb, obj->iv, sym, v);
+  mrb_write_barrier(mrb, (struct RBasic*)obj);
+}
+
 MRB_API void
 mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 {
-  iv_tbl *t = obj->iv;
-
-  if (MRB_FROZEN_P(obj)) {
-    mrb_raisef(mrb, E_RUNTIME_ERROR, "can't modify frozen %S", mrb_obj_value(obj));
-  }
-  if (!t) {
-    t = obj->iv = iv_new(mrb);
-  }
-  mrb_write_barrier(mrb, (struct RBasic*)obj);
-  iv_put(mrb, t, sym, v);
-}
-
-MRB_API void
-mrb_obj_iv_ifnone(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
-{
-  iv_tbl *t = obj->iv;
-
-  if (!t) {
-    t = obj->iv = iv_new(mrb);
-  }
-  else if (iv_get(mrb, t, sym, &v)) {
-    return;
-  }
-  mrb_write_barrier(mrb, (struct RBasic*)obj);
-  iv_put(mrb, t, sym, v);
+  mrb_check_frozen(mrb, obj);
+  mrb_obj_iv_set_force(mrb, obj, sym, v);
+}
+
+/* Iterates over the instance variable table. */
+MRB_API void
+mrb_iv_foreach(mrb_state *mrb, mrb_value obj, mrb_iv_foreach_func *func, void *p)
+{
+  if (!obj_iv_p(obj)) return;
+  iv_foreach(mrb, mrb_obj_ptr(obj)->iv, func, p);
+}
+
+static inline mrb_bool
+namespace_p(enum mrb_vtype tt)
+{
+  return tt == MRB_TT_CLASS || tt == MRB_TT_MODULE ? TRUE : FALSE;
+}
+
+static inline void
+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_value o = mrb_obj_iv_get(mrb, c, id_classname);
+
+      if (mrb_nil_p(o)) {
+        mrb_sym id_outer = mrb_intern_lit(mrb, "__outer__");
+        o = mrb_obj_iv_get(mrb, c, id_outer);
+
+        if (mrb_nil_p(o)) {
+          if ((struct RClass *)obj == mrb->object_class) {
+            mrb_obj_iv_set_force(mrb, c, id_classname, mrb_symbol_value(sym));
+          }
+          else {
+            mrb_obj_iv_set_force(mrb, c, id_outer, mrb_obj_value(obj));
+          }
+        }
+      }
+    }
+  }
 }
 
@@ -545 +430 @@
 }
 
-#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
-
 MRB_API mrb_bool
-mrb_iv_p(mrb_state *mrb, mrb_sym iv_name)
+mrb_iv_name_sym_p(mrb_state *mrb, mrb_sym iv_name)
 {
   const char *s;
-  mrb_int i, len;
-
-  s = mrb_sym2name_len(mrb, iv_name, &len);
+  mrb_int len;
+
+  s = mrb_sym_name_len(mrb, iv_name, &len);
   if (len < 2) return FALSE;
   if (s[0] != '@') return FALSE;
-  if (s[1] == '@') return FALSE;
-  for (i=1; i<len; i++) {
-    if (!identchar(s[i])) return FALSE;
-  }
-  return TRUE;
-}
-
-MRB_API void
-mrb_iv_check(mrb_state *mrb, mrb_sym iv_name)
-{
-  if (!mrb_iv_p(mrb, iv_name)) {
-    mrb_name_error(mrb, iv_name, "'%S' is not allowed as an instance variable name", mrb_sym2str(mrb, iv_name));
+  if (ISDIGIT(s[1])) return FALSE;
+  return mrb_ident_p(s+1, len-1);
+}
+
+MRB_API void
+mrb_iv_name_sym_check(mrb_state *mrb, mrb_sym iv_name)
+{
+  if (!mrb_iv_name_sym_p(mrb, iv_name)) {
+    mrb_name_error(mrb, iv_name, "'%n' is not allowed as an instance variable name", iv_name);
   }
 }
@@ -604 +484 @@
     mrb_str_cat_lit(mrb, str, ", ");
   }
-  s = mrb_sym2name_len(mrb, sym, &len);
+  s = mrb_sym_name_len(mrb, sym, &len);
   mrb_str_cat(mrb, str, s, len);
   mrb_str_cat_lit(mrb, str, "=");
-  if (mrb_type(v) == MRB_TT_OBJECT) {
+  if (mrb_object_p(v)) {
     ins = mrb_any_to_s(mrb, v);
   }
@@ -625 +505 @@
   if (len > 0) {
     const char *cn = mrb_obj_classname(mrb, mrb_obj_value(obj));
-    mrb_value str = mrb_str_buf_new(mrb, 30);
+    mrb_value str = mrb_str_new_capa(mrb, 30);
 
     mrb_str_cat_lit(mrb, str, "-<");
     mrb_str_cat_cstr(mrb, str, cn);
     mrb_str_cat_lit(mrb, str, ":");
-    mrb_str_concat(mrb, str, mrb_ptr_to_str(mrb, obj));
+    mrb_str_cat_str(mrb, str, mrb_ptr_to_str(mrb, obj));
 
     iv_foreach(mrb, t, inspect_i, &str);
@@ -646 +526 @@
     mrb_value val;
 
-    if (t && iv_del(mrb, t, sym, &val)) {
+    mrb_check_frozen(mrb, mrb_obj_ptr(obj));
+    if (iv_del(mrb, t, sym, &val)) {
       return val;
     }
   }
   return mrb_undef_value();
-}
-
-mrb_value
-mrb_vm_iv_get(mrb_state *mrb, mrb_sym sym)
-{
-  /* get self */
-  return mrb_iv_get(mrb, mrb->c->stack[0], sym);
-}
-
-void
-mrb_vm_iv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
-{
-  /* get self */
-  mrb_iv_set(mrb, mrb->c->stack[0], sym, v);
 }
 
@@ -675 +542 @@
 
   ary = *(mrb_value*)p;
-  s = mrb_sym2name_len(mrb, sym, &len);
+  s = mrb_sym_name_len(mrb, sym, &len);
   if (len > 1 && s[0] == '@' && s[1] != '@') {
     mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
@@ -705 +572 @@
 
   ary = mrb_ary_new(mrb);
-  if (obj_iv_p(self) && mrb_obj_ptr(self)->iv) {
+  if (obj_iv_p(self)) {
     iv_foreach(mrb, mrb_obj_ptr(self)->iv, iv_i, &ary);
   }
@@ -719 +586 @@
 
   ary = *(mrb_value*)p;
-  s = mrb_sym2name_len(mrb, sym, &len);
+  s = mrb_sym_name_len(mrb, sym, &len);
   if (len > 2 && s[0] == '@' && s[1] == '@') {
     mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
@@ -729 +596 @@
 /*
  *  call-seq:
- *     mod.class_variables   -> array
+ *     mod.class_variables(inherit=true)   -> array
  *
  *  Returns an array of the names of class variables in <i>mod</i>.
@@ -747 +614 @@
   mrb_value ary;
   struct RClass *c;
-
+  mrb_bool inherit = TRUE;
+
+  mrb_get_args(mrb, "|b", &inherit);
   ary = mrb_ary_new(mrb);
   c = mrb_class_ptr(mod);
   while (c) {
-    if (c->iv) {
-      iv_foreach(mrb, c->iv, cv_i, &ary);
-    }
+    iv_foreach(mrb, c->iv, cv_i, &ary);
+    if (!inherit) break;
     c = c->super;
   }
@@ -759 +627 @@
 }
 
-MRB_API mrb_value
+mrb_value
 mrb_mod_cv_get(mrb_state *mrb, struct RClass *c, mrb_sym sym)
 {
@@ -790 +658 @@
     }
   }
-  mrb_name_error(mrb, sym, "uninitialized class variable %S in %S",
-                 mrb_sym2str(mrb, sym), mrb_obj_value(cls));
+  mrb_name_error(mrb, sym, "uninitialized class variable %n in %C", sym, cls);
   /* not reached */
   return mrb_nil_value();
@@ -808 +675 @@
 
   while (c) {
-    if (c->iv) {
-      iv_tbl *t = c->iv;
-
-      if (iv_get(mrb, t, sym, NULL)) {
-        mrb_write_barrier(mrb, (struct RBasic*)c);
-        iv_put(mrb, t, sym, v);
-        return;
-      }
+    iv_tbl *t = c->iv;
+
+    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);
+      return;
     }
     c = c->super;
@@ -840 +706 @@
   }
 
+  mrb_check_frozen(mrb, c);
   if (!c->iv) {
     c->iv = iv_new(mrb);
   }
 
+  iv_put(mrb, c->iv, sym, v);
   mrb_write_barrier(mrb, (struct RBasic*)c);
-  iv_put(mrb, c->iv, sym, v);
 }
 
@@ -854 +721 @@
 }
 
-MRB_API mrb_bool
+mrb_bool
 mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym)
 {
   while (c) {
-    if (c->iv) {
-      iv_tbl *t = c->iv;
-      if (iv_get(mrb, t, sym, NULL)) return TRUE;
-    }
+    iv_tbl *t = c->iv;
+    if (iv_get(mrb, t, sym, NULL)) return TRUE;
     c = c->super;
   }
@@ -877 +742 @@
 mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym)
 {
-  struct RClass *c = mrb->c->ci->proc->target_class;
-
-  if (!c) c = mrb->c->ci->target_class;
-
+  struct RClass *c;
+
+  struct RProc *p = mrb->c->ci->proc;
+
+  for (;;) {
+    c = MRB_PROC_TARGET_CLASS(p);
+    if (c->tt != MRB_TT_SCLASS) break;
+    p = p->upper;
+  }
   return mrb_mod_cv_get(mrb, c, sym);
 }
@@ -887 +757 @@
 mrb_vm_cv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
 {
-  struct RClass *c = mrb->c->ci->proc->target_class;
-
-  if (!c) c = mrb->c->ci->target_class;
+  struct RClass *c;
+  struct RProc *p = mrb->c->ci->proc;
+
+  for (;;) {
+    c = MRB_PROC_TARGET_CLASS(p);
+    if (c->tt != MRB_TT_SCLASS) break;
+    p = p->upper;
+  }
   mrb_mod_cv_set(mrb, c, sym, v);
 }
@@ -912 +787 @@
   struct RClass *c = base;
   mrb_value v;
-  iv_tbl *t;
   mrb_bool retry = FALSE;
   mrb_value name;
@@ -919 +793 @@
   while (c) {
     if (c->iv) {
-      t = c->iv;
-      if (iv_get(mrb, t, sym, &v))
+      if (iv_get(mrb, c->iv, sym, &v))
         return v;
     }
     c = c->super;
   }
-  if (!retry && base && base->tt == MRB_TT_MODULE) {
+  if (!retry && base->tt == MRB_TT_MODULE) {
     c = mrb->object_class;
     retry = TRUE;
@@ -944 +817 @@
 mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
 {
-  struct RClass *c = mrb->c->ci->proc->target_class;
-
-  if (!c) c = mrb->c->ci->target_class;
-  if (c) {
-    struct RClass *c2;
-    mrb_value v;
-
-    if (c->iv && iv_get(mrb, c->iv, sym, &v)) {
+  struct RClass *c;
+  struct RClass *c2;
+  mrb_value v;
+  struct RProc *proc;
+
+  c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
+  if (iv_get(mrb, c->iv, sym, &v)) {
+    return v;
+  }
+  c2 = c;
+  while (c2 && c2->tt == MRB_TT_SCLASS) {
+    mrb_value klass;
+
+    if (!iv_get(mrb, c2->iv, mrb_intern_lit(mrb, "__attached__"), &klass)) {
+      c2 = NULL;
+      break;
+    }
+    c2 = mrb_class_ptr(klass);
+  }
+  if (c2 && (c2->tt == MRB_TT_CLASS || c2->tt == MRB_TT_MODULE)) c = c2;
+  mrb_assert(!MRB_PROC_CFUNC_P(mrb->c->ci->proc));
+  proc = mrb->c->ci->proc;
+  while (proc) {
+    c2 = MRB_PROC_TARGET_CLASS(proc);
+    if (c2 && iv_get(mrb, c2->iv, sym, &v)) {
       return v;
     }
-    c2 = c;
-    while (c2 && c2->tt == MRB_TT_SCLASS) {
-      mrb_value klass;
-      klass = mrb_obj_iv_get(mrb, (struct RObject *)c2,
-                             mrb_intern_lit(mrb, "__attached__"));
-      c2 = mrb_class_ptr(klass);
-    }
-    if (c2->tt == MRB_TT_CLASS || c2->tt == MRB_TT_MODULE) c = c2;
-    c2 = c;
-    for (;;) {
-      c2 = mrb_class_outer_module(mrb, c2);
-      if (!c2) break;
-      if (c2->iv && iv_get(mrb, c2->iv, sym, &v)) {
-        return v;
-      }
-    }
+    proc = proc->upper;
   }
   return const_get(mrb, c, sym);
@@ -978 +853 @@
 {
   mod_const_check(mrb, mod);
+  if (mrb_type(v) == MRB_TT_CLASS || mrb_type(v) == MRB_TT_MODULE) {
+    mrb_class_name_class(mrb, mrb_class_ptr(mod), mrb_class_ptr(v), sym);
+  }
   mrb_iv_set(mrb, mod, sym, v);
 }
@@ -984 +862 @@
 mrb_vm_const_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
 {
-  struct RClass *c = mrb->c->ci->proc->target_class;
-
-  if (!c) c = mrb->c->ci->target_class;
+  struct RClass *c;
+
+  c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
   mrb_obj_iv_set(mrb, (struct RObject*)c, sym, v);
 }
@@ -1017 +895 @@
 
   ary = *(mrb_value*)p;
-  s = mrb_sym2name_len(mrb, sym, &len);
+  s = mrb_sym_name_len(mrb, sym, &len);
   if (len >= 1 && ISUPPER(s[0])) {
-    mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
+    mrb_int i, alen = RARRAY_LEN(ary);
+
+    for (i=0; i<alen; i++) {
+      if (mrb_symbol(RARRAY_PTR(ary)[i]) == sym)
+        break;
+    }
+    if (i==alen) {
+      mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
+    }
   }
   return 0;
@@ -1041 +927 @@
   ary = mrb_ary_new(mrb);
   while (c) {
-    if (c->iv) {
-      iv_foreach(mrb, c->iv, const_i, &ary);
-    }
+    iv_foreach(mrb, c->iv, const_i, &ary);
     if (!inherit) break;
     c = c->super;
@@ -1056 +940 @@
   mrb_value v;
 
-  if (!mrb->globals) {
-    return mrb_nil_value();
-  }
   if (iv_get(mrb, mrb->globals, sym, &v))
     return v;
@@ -1070 +951 @@
 
   if (!mrb->globals) {
-    t = mrb->globals = iv_new(mrb);
-  }
-  else {
-    t = mrb->globals;
-  }
+    mrb->globals = iv_new(mrb);
+  }
+  t = mrb->globals;
   iv_put(mrb, t, sym, v);
 }
@@ -1081 +960 @@
 mrb_gv_remove(mrb_state *mrb, mrb_sym sym)
 {
-  if (!mrb->globals) {
-    return;
-  }
   iv_del(mrb, mrb->globals, sym, NULL);
 }
@@ -1112 +988 @@
   iv_tbl *t = mrb->globals;
   mrb_value ary = mrb_ary_new(mrb);
-  size_t i;
-  char buf[3];
-
-  if (t) {
-    iv_foreach(mrb, t, gv_i, &ary);
-  }
-  buf[0] = '$';
-  buf[2] = 0;
-  for (i = 1; i <= 9; ++i) {
-    buf[1] = (char)(i + '0');
-    mrb_ary_push(mrb, ary, mrb_symbol_value(mrb_intern(mrb, buf, 2)));
-  }
+
+  iv_foreach(mrb, t, gv_i, &ary);
   return ary;
 }
@@ -1132 +998 @@
   struct RClass *klass = mrb_class_ptr(mod);
   struct RClass *tmp;
-  mrb_bool mod_retry = 0;
+  mrb_bool mod_retry = FALSE;
 
   tmp = klass;
 retry:
   while (tmp) {
-    if (tmp->iv && iv_get(mrb, tmp->iv, id, NULL)) {
+    if (iv_get(mrb, tmp->iv, id, NULL)) {
       return TRUE;
     }
@@ -1144 +1010 @@
   }
   if (!exclude && !mod_retry && (klass->tt == MRB_TT_MODULE)) {
-    mod_retry = 1;
+    mod_retry = TRUE;
     tmp = mrb->object_class;
     goto retry;
@@ -1187 +1053 @@
 }
 
-mrb_sym
-mrb_class_sym(mrb_state *mrb, struct RClass *c, struct RClass *outer)
-{
-  mrb_value name;
-
-  name = mrb_obj_iv_get(mrb, (struct RObject*)c, mrb_intern_lit(mrb, "__classid__"));
-  if (mrb_nil_p(name)) {
-
-    if (!outer) return 0;
-    else {
-      struct csym_arg arg;
-
-      arg.c = c;
-      arg.sym = 0;
-      iv_foreach(mrb, outer->iv, csym_i, &arg);
-      return arg.sym;
-    }
-  }
-  return mrb_symbol(name);
-}
+static mrb_sym
+find_class_sym(mrb_state *mrb, struct RClass *outer, struct RClass *c)
+{
+  struct csym_arg arg;
+
+  if (!outer) return 0;
+  if (outer == c) return 0;
+  arg.c = c;
+  arg.sym = 0;
+  iv_foreach(mrb, outer->iv, csym_i, &arg);
+  return arg.sym;
+}
+
+static struct RClass*
+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__"));
+  if (mrb_nil_p(ov)) return NULL;
+  switch (mrb_type(ov)) {
+  case MRB_TT_CLASS:
+  case MRB_TT_MODULE:
+    return mrb_class_ptr(ov);
+  default:
+    break;
+  }
+  return NULL;
+}
+
+static mrb_bool
+detect_outer_loop(mrb_state *mrb, struct RClass *c)
+{
+  struct RClass *t = c;         /* tortoise */
+  struct RClass *h = c;         /* hare */
+
+  for (;;) {
+    if (h == NULL) return FALSE;
+    h = outer_class(mrb, h);
+    if (h == NULL) return FALSE;
+    h = outer_class(mrb, h);
+    t = outer_class(mrb, t);
+    if (t == h) return TRUE;
+  }
+}
+
+mrb_value
+mrb_class_find_path(mrb_state *mrb, struct RClass *c)
+{
+  struct RClass *outer;
+  mrb_value path;
+  mrb_sym name;
+  const char *str;
+  mrb_int len;
+
+  if (detect_outer_loop(mrb, c)) return mrb_nil_value();
+  outer = outer_class(mrb, c);
+  if (outer == NULL) return mrb_nil_value();
+  name = find_class_sym(mrb, outer, c);
+  if (name == 0) return mrb_nil_value();
+  str = mrb_class_name(mrb, outer);
+  path = mrb_str_new_capa(mrb, 40);
+  mrb_str_cat_cstr(mrb, path, str);
+  mrb_str_cat_cstr(mrb, path, "::");
+
+  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);
+    mrb_field_write_barrier_value(mrb, (struct RBasic*)c, path);
+    path = mrb_str_dup(mrb, path);
+  }
+  return path;
+}
+
+#define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
+
+mrb_bool
+mrb_ident_p(const char *s, mrb_int len)
+{
+  mrb_int i;
+
+  for (i = 0; i < len; i++) {
+    if (!identchar(s[i])) return FALSE;
+  }
+  return TRUE;
+}