summaryrefslogtreecommitdiffhomepage
path: root/src/variable.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/variable.c')
-rw-r--r--src/variable.c483
1 files changed, 294 insertions, 189 deletions
diff --git a/src/variable.c b/src/variable.c
index de36efac6..e6f2f397e 100644
--- a/src/variable.c
+++ b/src/variable.c
@@ -9,155 +9,241 @@
#include <mruby/class.h>
#include <mruby/proc.h>
#include <mruby/string.h>
+#include <mruby/variable.h>
-typedef int (iv_foreach_func)(mrb_state*,mrb_sym,mrb_value,void*);
-
-#include <mruby/khash.h>
-
-#ifndef MRB_IVHASH_INIT_SIZE
-#define MRB_IVHASH_INIT_SIZE KHASH_MIN_SIZE
+#ifndef MRB_IV_SEGMENT_SIZE
+#define MRB_IV_SEGMENT_SIZE 4
#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 segment {
+ mrb_sym key[MRB_IV_SEGMENT_SIZE];
+ mrb_value val[MRB_IV_SEGMENT_SIZE];
+ struct segment *next;
+} segment;
/* Instance variable table structure */
typedef struct iv_tbl {
- khash_t(iv) h;
+ segment *rootseg;
+ size_t size;
+ size_t last_len;
} 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)
{
- return (iv_tbl*)kh_init_size(iv, mrb, MRB_IVHASH_INIT_SIZE);
+ iv_tbl *t;
+
+ t = (iv_tbl*)mrb_malloc(mrb, sizeof(iv_tbl));
+ t->size = 0;
+ t->rootseg = NULL;
+ t->last_len = 0;
+
+ return t;
}
-/*
- * 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)
{
- khash_t(iv) *h = &t->h;
- khiter_t k;
+ segment *seg;
+ segment *prev = NULL;
+ segment *matched_seg = NULL;
+ size_t matched_idx = 0;
+ 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];
+ /* 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;
+ t->size++;
+ return;
+ }
+ if (!matched_seg && key == 0) {
+ matched_seg = seg;
+ matched_idx = i;
+ }
+ else if (key == sym) {
+ seg->val[i] = val;
+ return;
+ }
+ }
+ prev = seg;
+ seg = seg->next;
+ }
- k = kh_put(iv, mrb, h, sym);
- kh_value(h, k) = val;
+ /* 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;
+ }
}
-/*
- * 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)
{
- khash_t(iv) *h = &t->h;
- khiter_t k;
+ segment *seg;
+ size_t i;
- k = kh_get(iv, mrb, h, sym);
- if (k != kh_end(h)) {
- if (vp) *vp = kh_value(h, k);
- return TRUE;
+ 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 (!seg->next && i >= t->last_len) {
+ return FALSE;
+ }
+ if (key == sym) {
+ if (vp) *vp = seg->val[i];
+ return TRUE;
+ }
+ }
+ seg = seg->next;
}
return FALSE;
}
-/*
- * 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)
{
+ segment *seg;
+ size_t i;
+
if (t == NULL) return FALSE;
- else {
- khash_t(iv) *h = &t->h;
- khiter_t k;
-
- 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;
+ seg = t->rootseg;
+ while (seg) {
+ for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
+ mrb_sym key = seg->key[i];
+
+ 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;
+ }
}
+ seg = seg->next;
}
return FALSE;
}
-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)
{
- if (t == NULL) {
- return TRUE;
- }
- else {
- khash_t(iv) *h = &t->h;
- khiter_t k;
- int n;
-
- 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);
+ 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];
+
+ /* no value in last segment after last_len */
+ if (!seg->next && i >= t->last_len) {
+ return;
+ }
+ if (key != 0) {
+ if ((*func)(mrb, key, seg->val[i], p) != 0) {
+ return;
}
}
}
+ 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)
{
- if (t) {
- return kh_size(&t->h);
+ 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;
}
+/* Copy the instance variable table. */
static iv_tbl*
iv_copy(mrb_state *mrb, iv_tbl *t)
{
- return (iv_tbl*)kh_copy(iv, mrb, &t->h);
+ segment *seg;
+ iv_tbl *t2;
+
+ size_t i;
+
+ seg = t->rootseg;
+ t2 = iv_new(mrb);
+
+ while (seg != NULL) {
+ for (i=0; i<MRB_IV_SEGMENT_SIZE; i++) {
+ mrb_sym key = seg->key[i];
+ mrb_value val = seg->val[i];
+
+ if ((seg->next == NULL) && (i >= t->last_len)) {
+ return t2;
+ }
+ iv_put(mrb, t2, key, val);
+ }
+ seg = seg->next;
+ }
+ return t2;
}
+/* Free memory of the instance variable table. */
static void
iv_free(mrb_state *mrb, iv_tbl *t)
{
- kh_destroy(iv, mrb, &t->h);
+ segment *seg;
+
+ seg = t->rootseg;
+ while (seg) {
+ segment *p = seg;
+ seg = seg->next;
+ mrb_free(mrb, p);
+ }
+ mrb_free(mrb, t);
}
static int
@@ -170,9 +256,7 @@ iv_mark_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
static void
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);
}
void
@@ -255,19 +339,64 @@ mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym)
return mrb_nil_value();
}
+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;
+ mrb_check_frozen(mrb, obj);
+ mrb_obj_iv_set_force(mrb, obj, sym, v);
+}
- if (MRB_FROZEN_P(obj)) {
- mrb_raisef(mrb, E_FROZEN_ERROR, "can't modify frozen %S", mrb_obj_value(obj));
- }
- if (!t) {
- t = obj->iv = iv_new(mrb);
+/* 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_sym2name(mrb, sym)[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));
+ }
+ }
+ }
+ }
}
- mrb_write_barrier(mrb, (struct RBasic*)obj);
- iv_put(mrb, t, sym, v);
}
MRB_API void
@@ -300,28 +429,23 @@ mrb_iv_defined(mrb_state *mrb, mrb_value obj, mrb_sym sym)
return mrb_obj_iv_defined(mrb, mrb_obj_ptr(obj), sym);
}
-#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;
+ mrb_int len;
s = mrb_sym2name_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;
+ if (ISDIGIT(s[1])) return FALSE;
+ return mrb_ident_p(s+1, len-1);
}
MRB_API void
-mrb_iv_check(mrb_state *mrb, mrb_sym iv_name)
+mrb_iv_name_sym_check(mrb_state *mrb, mrb_sym iv_name)
{
- if (!mrb_iv_p(mrb, iv_name)) {
+ if (!mrb_iv_name_sym_p(mrb, iv_name)) {
mrb_name_error(mrb, iv_name, "'%S' is not allowed as an instance variable name", mrb_sym2str(mrb, iv_name));
}
}
@@ -401,27 +525,14 @@ mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym)
iv_tbl *t = mrb_obj_ptr(obj)->iv;
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);
-}
-
static int
iv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
{
@@ -460,7 +571,7 @@ mrb_obj_instance_variables(mrb_state *mrb, mrb_value self)
mrb_value ary;
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);
}
return ary;
@@ -506,15 +617,13 @@ mrb_mod_class_variables(mrb_state *mrb, mrb_value mod)
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);
c = c->super;
}
return ary;
}
-MRB_API mrb_value
+mrb_value
mrb_mod_cv_get(mrb_state *mrb, struct RClass *c, mrb_sym sym)
{
struct RClass * cls = c;
@@ -563,14 +672,13 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
struct RClass * cls = c;
while (c) {
- if (c->iv) {
- iv_tbl *t = 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;
- }
+ 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;
}
@@ -595,12 +703,13 @@ mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
c = cls;
}
+ mrb_check_frozen(mrb, c);
if (!c->iv) {
c->iv = iv_new(mrb);
}
- mrb_write_barrier(mrb, (struct RBasic*)c);
iv_put(mrb, c->iv, sym, v);
+ mrb_write_barrier(mrb, (struct RBasic*)c);
}
MRB_API void
@@ -609,14 +718,12 @@ mrb_cv_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v)
mrb_mod_cv_set(mrb, mrb_class_ptr(mod), sym, v);
}
-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;
}
@@ -662,24 +769,23 @@ mod_const_check(mrb_state *mrb, mrb_value mod)
}
static mrb_value
-const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym, mrb_bool top)
+const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym)
{
struct RClass *c = base;
mrb_value v;
mrb_bool retry = FALSE;
mrb_value name;
- struct RClass *oclass = mrb->object_class;
L_RETRY:
while (c) {
- if (c->iv && (top || c != oclass || base == oclass)) {
+ if (c->iv) {
if (iv_get(mrb, c->iv, sym, &v))
return v;
}
c = c->super;
}
if (!retry && base->tt == MRB_TT_MODULE) {
- c = oclass;
+ c = mrb->object_class;
retry = TRUE;
goto L_RETRY;
}
@@ -691,7 +797,7 @@ MRB_API mrb_value
mrb_const_get(mrb_state *mrb, mrb_value mod, mrb_sym sym)
{
mod_const_check(mrb, mod);
- return const_get(mrb, mrb_class_ptr(mod), sym, FALSE);
+ return const_get(mrb, mrb_class_ptr(mod), sym);
}
mrb_value
@@ -703,27 +809,30 @@ mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
struct RProc *proc;
c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
- if (c->iv && iv_get(mrb, c->iv, sym, &v)) {
+ if (iv_get(mrb, c->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__"));
+
+ if (!iv_get(mrb, c2->iv, mrb_intern_lit(mrb, "__attached__"), &klass)) {
+ c2 = NULL;
+ break;
+ }
c2 = mrb_class_ptr(klass);
}
- if (c2->tt == MRB_TT_CLASS || c2->tt == MRB_TT_MODULE) c = c2;
+ 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 && c2->iv && iv_get(mrb, c2->iv, sym, &v)) {
+ if (c2 && iv_get(mrb, c2->iv, sym, &v)) {
return v;
}
proc = proc->upper;
}
- return const_get(mrb, c, sym, TRUE);
+ return const_get(mrb, c, sym);
}
MRB_API void
@@ -796,9 +905,7 @@ mrb_mod_constants(mrb_state *mrb, mrb_value mod)
mrb_get_args(mrb, "|b", &inherit);
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;
if (c == mrb->object_class) break;
@@ -811,9 +918,6 @@ mrb_gv_get(mrb_state *mrb, mrb_sym sym)
{
mrb_value v;
- if (!mrb->globals) {
- return mrb_nil_value();
- }
if (iv_get(mrb, mrb->globals, sym, &v))
return v;
return mrb_nil_value();
@@ -825,20 +929,15 @@ mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
iv_tbl *t;
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);
}
MRB_API void
mrb_gv_remove(mrb_state *mrb, mrb_sym sym)
{
- if (!mrb->globals) {
- return;
- }
iv_del(mrb, mrb->globals, sym, NULL);
}
@@ -867,18 +966,8 @@ mrb_f_global_variables(mrb_state *mrb, mrb_value self)
{
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;
}
@@ -892,7 +981,7 @@ mrb_const_defined_0(mrb_state *mrb, mrb_value mod, mrb_sym id, mrb_bool exclude,
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;
}
if (!recurse && (klass != mrb->object_class)) break;
@@ -928,25 +1017,25 @@ struct csym_arg {
struct RClass *c;
mrb_sym sym;
};
-
+
static int
csym_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
{
struct csym_arg *a = (struct csym_arg*)p;
struct RClass *c = a->c;
-
+
if (mrb_type(v) == c->tt && mrb_class_ptr(v) == c) {
a->sym = sym;
return 1; /* stop iteration */
}
return 0;
}
-
+
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;
@@ -1009,8 +1098,24 @@ mrb_class_find_path(mrb_state *mrb, struct RClass *c)
str = mrb_sym2name_len(mrb, name, &len);
mrb_str_cat(mrb, path, str, len);
- 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);
+ 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;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-15 09:17:56 +0000