src/variable.c

   1 /*
   2 ** variable.c - mruby variables
   3 **
   4 ** See Copyright Notice in mruby.h
   5 */
   6
   7 #include <mruby.h>
   8 #include <mruby/array.h>
   9 #include <mruby/class.h>
  10 #include <mruby/proc.h>
  11 #include <mruby/string.h>
  12 #include <mruby/variable.h>
  13 #include <mruby/internal.h>
  14 #include <mruby/presym.h>
  15
  16 /* Instance variable table structure */
  17 typedef struct iv_tbl {
  18   int size, alloc;
  19   mrb_value *ptr;
  20 } iv_tbl;
  21
  22 #define IV_EMPTY 0
  23 #define IV_DELETED (1UL<<31)
  24 #define IV_KEY_P(k) (((k)&~((uint32_t)IV_DELETED))!=0)
  25
  26 /* Creates the instance variable table. */
  27 static iv_tbl*
  28 iv_new(mrb_state *mrb)
  29 {
  30   iv_tbl *t;
  31
  32   t = (iv_tbl*)mrb_malloc(mrb, sizeof(iv_tbl));
  33   t->size = 0;
  34   t->alloc = 0;
  35   t->ptr = NULL;
  36
  37   return t;
  38 }
  39
  40 static void iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val);
  41
  42 static void
  43 iv_rehash(mrb_state *mrb, iv_tbl *t)
  44 {
  45   int old_alloc = t->alloc;
  46   int new_alloc = old_alloc > 0 ? old_alloc << 1 : 4;
  47   mrb_value *old_ptr = t->ptr;
  48
  49   t->ptr = (mrb_value*)mrb_calloc(mrb, sizeof(mrb_value)+sizeof(mrb_sym), new_alloc);
  50   t->size = 0;
  51   t->alloc = new_alloc;
  52   if (old_alloc == 0) return;
  53
  54   mrb_sym *keys = (mrb_sym*)&old_ptr[old_alloc];
  55   mrb_value *vals = old_ptr;
  56   for (int i = 0; i < old_alloc; i++) {
  57     if (IV_KEY_P(keys[i])) {
  58       iv_put(mrb, t, keys[i], vals[i]);
  59     }
  60   }
  61   mrb_free(mrb, old_ptr);
  62 }
  63
  64 /* Set the value for the symbol in the instance variable table. */
  65 static void
  66 iv_put(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value val)
  67 {
  68   int hash, pos, start, dpos = -1;
  69
  70   if (t->alloc == 0) {
  71     iv_rehash(mrb, t);
  72   }
  73
  74   mrb_sym *keys = (mrb_sym*)&t->ptr[t->alloc];
  75   mrb_value *vals = t->ptr;
  76   hash = mrb_int_hash_func(mrb, sym);
  77   start = pos = hash & (t->alloc-1);
  78   for (;;) {
  79     mrb_sym key = keys[pos];
  80     if (key == sym) {
  81       vals[pos] = val;
  82       return;
  83     }
  84     else if (key == IV_EMPTY) {
  85       t->size++;
  86       keys[pos] = sym;
  87       vals[pos] = val;
  88       return;
  89     }
  90     else if (key == IV_DELETED && dpos < 0) {
  91       dpos = pos;
  92     }
  93     pos = (pos+1) & (t->alloc-1);
  94     if (pos == start) {         /* not found */
  95       if (dpos >= 0) {
  96         t->size++;
  97         keys[dpos] = sym;
  98         vals[dpos] = val;
  99         return;
 100       }
 101       /* no room */
 102       iv_rehash(mrb, t);
 103       keys = (mrb_sym*)&t->ptr[t->alloc];
 104       vals = t->ptr;
 105       start = pos = hash & (t->alloc-1);
 106     }
 107   }
 108 }
 109
 110 /* Get a value for a symbol from the instance variable table. */
 111 static int
 112 iv_get(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
 113 {
 114   int hash, pos, start;
 115
 116   if (t == NULL) return FALSE;
 117   if (t->alloc == 0) return FALSE;
 118   if (t->size == 0) return FALSE;
 119
 120   mrb_sym *keys = (mrb_sym*)&t->ptr[t->alloc];
 121   mrb_value *vals = t->ptr;
 122   hash = mrb_int_hash_func(mrb, sym);
 123   start = pos = hash & (t->alloc-1);
 124   for (;;) {
 125     mrb_sym key = keys[pos];
 126     if (key == sym) {
 127       if (vp) *vp = vals[pos];
 128       return pos+1;
 129     }
 130     else if (key == IV_EMPTY) {
 131       return 0;
 132     }
 133     pos = (pos+1) & (t->alloc-1);
 134     if (pos == start) {         /* not found */
 135       return 0;
 136     }
 137   }
 138 }
 139
 140 /* Deletes the value for the symbol from the instance variable table. */
 141 static mrb_bool
 142 iv_del(mrb_state *mrb, iv_tbl *t, mrb_sym sym, mrb_value *vp)
 143 {
 144   int hash, pos, start;
 145
 146   if (t == NULL) return FALSE;
 147   if (t->alloc == 0) return FALSE;
 148   if (t->size == 0) return FALSE;
 149
 150   mrb_sym *keys = (mrb_sym*)&t->ptr[t->alloc];
 151   mrb_value *vals = t->ptr;
 152   hash = mrb_int_hash_func(mrb, sym);
 153   start = pos = hash & (t->alloc-1);
 154   for (;;) {
 155     mrb_sym key = keys[pos];
 156     if (key == sym) {
 157       if (vp) *vp = vals[pos];
 158       t->size--;
 159       keys[pos] = IV_DELETED;
 160       return TRUE;
 161     }
 162     else if (key == IV_EMPTY) {
 163       return FALSE;
 164     }
 165     pos = (pos+1) & (t->alloc-1);
 166     if (pos == start) {         /* not found */
 167       return FALSE;
 168     }
 169   }
 170 }
 171
 172 /* Iterates over the instance variable table. */
 173 static void
 174 iv_foreach(mrb_state *mrb, iv_tbl *t, mrb_iv_foreach_func *func, void *p)
 175 {
 176   if (t == NULL) return;
 177   if (t->alloc == 0) return;
 178   if (t->size == 0) return;
 179
 180   mrb_sym *keys = (mrb_sym*)&t->ptr[t->alloc];
 181   mrb_value *vals = t->ptr;
 182   for (int i=0; i<t->alloc; i++) {
 183     if (IV_KEY_P(keys[i])) {
 184       if ((*func)(mrb, keys[i], vals[i], p) != 0) {
 185         return;
 186       }
 187     }
 188   }
 189   return;
 190 }
 191
 192 /* Get the size of the instance variable table. */
 193 /* Size is approximated by the allocated table size. */
 194 static size_t
 195 iv_size(mrb_state *mrb, iv_tbl *t)
 196 {
 197   if (t == NULL) return 0;
 198   return (size_t)t->size;
 199 }
 200
 201 /* Copy the instance variable table. */
 202 static iv_tbl*
 203 iv_copy(mrb_state *mrb, iv_tbl *t)
 204 {
 205   iv_tbl *t2;
 206
 207   if (t == NULL) return NULL;
 208   if (t->alloc == 0) return NULL;
 209   if (t->size == 0) return NULL;
 210
 211   mrb_sym *keys = (mrb_sym*)&t->ptr[t->alloc];
 212   mrb_value *vals = t->ptr;
 213   t2 = iv_new(mrb);
 214   for (int i=0; i<t->alloc; i++) {
 215     if (IV_KEY_P(keys[i])) {
 216       iv_put(mrb, t2, keys[i], vals[i]);
 217     }
 218   }
 219   return t2;
 220 }
 221
 222 /* Free memory of the instance variable table. */
 223 static void
 224 iv_free(mrb_state *mrb, iv_tbl *t)
 225 {
 226   mrb_free(mrb, t->ptr);
 227   mrb_free(mrb, t);
 228 }
 229
 230 static int
 231 iv_mark_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 232 {
 233   mrb_gc_mark_value(mrb, v);
 234   return 0;
 235 }
 236
 237 static void
 238 mark_tbl(mrb_state *mrb, iv_tbl *t)
 239 {
 240   iv_foreach(mrb, t, iv_mark_i, 0);
 241 }
 242
 243 void
 244 mrb_gc_mark_gv(mrb_state *mrb)
 245 {
 246   mark_tbl(mrb, mrb->globals);
 247 }
 248
 249 void
 250 mrb_gc_free_gv(mrb_state *mrb)
 251 {
 252   if (mrb->globals)
 253     iv_free(mrb, mrb->globals);
 254 }
 255
 256 size_t
 257 mrb_gc_mark_iv(mrb_state *mrb, struct RObject *obj)
 258 {
 259   mark_tbl(mrb, obj->iv);
 260   return iv_size(mrb, obj->iv);
 261 }
 262
 263 void
 264 mrb_gc_free_iv(mrb_state *mrb, struct RObject *obj)
 265 {
 266   if (obj->iv) {
 267     iv_free(mrb, obj->iv);
 268   }
 269 }
 270
 271 mrb_value
 272 mrb_vm_special_get(mrb_state *mrb, mrb_sym i)
 273 {
 274   return mrb_fixnum_value(0);
 275 }
 276
 277 void
 278 mrb_vm_special_set(mrb_state *mrb, mrb_sym i, mrb_value v)
 279 {
 280 }
 281
 282 static mrb_bool
 283 obj_iv_p(mrb_value obj)
 284 {
 285   switch (mrb_type(obj)) {
 286     case MRB_TT_OBJECT:
 287     case MRB_TT_CLASS:
 288     case MRB_TT_MODULE:
 289     case MRB_TT_SCLASS:
 290     case MRB_TT_HASH:
 291     case MRB_TT_CDATA:
 292     case MRB_TT_EXCEPTION:
 293       return TRUE;
 294     default:
 295       return FALSE;
 296   }
 297 }
 298
 299 static iv_tbl*
 300 class_iv_ptr(struct RClass *c)
 301 {
 302   return c->tt == MRB_TT_ICLASS ? c->c->iv : c->iv;
 303 }
 304
 305 MRB_API mrb_value
 306 mrb_obj_iv_get(mrb_state *mrb, struct RObject *obj, mrb_sym sym)
 307 {
 308   mrb_value v;
 309
 310   if (obj->iv && iv_get(mrb, obj->iv, sym, &v))
 311     return v;
 312   return mrb_nil_value();
 313 }
 314
 315 MRB_API mrb_value
 316 mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 317 {
 318   if (obj_iv_p(obj)) {
 319     return mrb_obj_iv_get(mrb, mrb_obj_ptr(obj), sym);
 320   }
 321   return mrb_nil_value();
 322 }
 323
 324 static inline mrb_bool
 325 namespace_p(enum mrb_vtype tt)
 326 {
 327   return tt == MRB_TT_CLASS || tt == MRB_TT_MODULE ? TRUE : FALSE;
 328 }
 329
 330 static inline void
 331 assign_class_name(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 332 {
 333   if (namespace_p(mrb_type(v))) {
 334     struct RObject *c = mrb_obj_ptr(v);
 335     if (obj != c && ISUPPER(mrb_sym_name_len(mrb, sym, NULL)[0])) {
 336       mrb_sym id_classname = MRB_SYM(__classname__);
 337       mrb_value o = mrb_obj_iv_get(mrb, c, id_classname);
 338
 339       if (mrb_nil_p(o)) {
 340         mrb_sym id_outer = MRB_SYM(__outer__);
 341         o = mrb_obj_iv_get(mrb, c, id_outer);
 342
 343         if (mrb_nil_p(o)) {
 344           if ((struct RClass*)obj == mrb->object_class) {
 345             mrb_obj_iv_set_force(mrb, c, id_classname, mrb_symbol_value(sym));
 346           }
 347           else {
 348             mrb_obj_iv_set_force(mrb, c, id_outer, mrb_obj_value(obj));
 349           }
 350         }
 351       }
 352     }
 353   }
 354 }
 355
 356 void
 357 mrb_obj_iv_set_force(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 358 {
 359   if (namespace_p(obj->tt)) {
 360     assign_class_name(mrb, obj, sym, v);
 361   }
 362   if (!obj->iv) {
 363     obj->iv = iv_new(mrb);
 364   }
 365   iv_put(mrb, obj->iv, sym, v);
 366   mrb_field_write_barrier_value(mrb, (struct RBasic*)obj, v);
 367 }
 368
 369 MRB_API void
 370 mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v)
 371 {
 372   mrb_check_frozen(mrb, obj);
 373   mrb_obj_iv_set_force(mrb, obj, sym, v);
 374 }
 375
 376 /* Iterates over the instance variable table. */
 377 MRB_API void
 378 mrb_iv_foreach(mrb_state *mrb, mrb_value obj, mrb_iv_foreach_func *func, void *p)
 379 {
 380   if (!obj_iv_p(obj)) return;
 381   iv_foreach(mrb, mrb_obj_ptr(obj)->iv, func, p);
 382 }
 383
 384 MRB_API void
 385 mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v)
 386 {
 387   if (obj_iv_p(obj)) {
 388     mrb_obj_iv_set(mrb, mrb_obj_ptr(obj), sym, v);
 389   }
 390   else {
 391     mrb_raise(mrb, E_ARGUMENT_ERROR, "cannot set instance variable");
 392   }
 393 }
 394
 395 MRB_API mrb_bool
 396 mrb_obj_iv_defined(mrb_state *mrb, struct RObject *obj, mrb_sym sym)
 397 {
 398   iv_tbl *t;
 399
 400   t = obj->iv;
 401   if (t && iv_get(mrb, t, sym, NULL)) return TRUE;
 402   return FALSE;
 403 }
 404
 405 MRB_API mrb_bool
 406 mrb_iv_defined(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 407 {
 408   if (!obj_iv_p(obj)) return FALSE;
 409   return mrb_obj_iv_defined(mrb, mrb_obj_ptr(obj), sym);
 410 }
 411
 412 MRB_API mrb_bool
 413 mrb_iv_name_sym_p(mrb_state *mrb, mrb_sym iv_name)
 414 {
 415   const char *s;
 416   mrb_int len;
 417
 418   s = mrb_sym_name_len(mrb, iv_name, &len);
 419   if (len < 2) return FALSE;
 420   if (s[0] != '@') return FALSE;
 421   if (ISDIGIT(s[1])) return FALSE;
 422   return mrb_ident_p(s+1, len-1);
 423 }
 424
 425 MRB_API void
 426 mrb_iv_name_sym_check(mrb_state *mrb, mrb_sym iv_name)
 427 {
 428   if (!mrb_iv_name_sym_p(mrb, iv_name)) {
 429     mrb_name_error(mrb, iv_name, "'%n' is not allowed as an instance variable name", iv_name);
 430   }
 431 }
 432
 433 MRB_API void
 434 mrb_iv_copy(mrb_state *mrb, mrb_value dest, mrb_value src)
 435 {
 436   struct RObject *d = mrb_obj_ptr(dest);
 437   struct RObject *s = mrb_obj_ptr(src);
 438
 439   if (d->iv) {
 440     iv_free(mrb, d->iv);
 441     d->iv = 0;
 442   }
 443   if (s->iv) {
 444     mrb_write_barrier(mrb, (struct RBasic*)d);
 445     d->iv = iv_copy(mrb, s->iv);
 446   }
 447 }
 448
 449 static int
 450 inspect_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 451 {
 452   mrb_value str = *(mrb_value*)p;
 453   const char *s;
 454   mrb_int len;
 455   mrb_value ins;
 456   char *sp = RSTRING_PTR(str);
 457
 458   /* need not to show internal data */
 459   if (sp[0] == '-') { /* first element */
 460     sp[0] = '#';
 461     mrb_str_cat_lit(mrb, str, " ");
 462   }
 463   else {
 464     mrb_str_cat_lit(mrb, str, ", ");
 465   }
 466   s = mrb_sym_name_len(mrb, sym, &len);
 467   mrb_str_cat(mrb, str, s, len);
 468   mrb_str_cat_lit(mrb, str, "=");
 469   ins = mrb_inspect(mrb, v);
 470   mrb_str_cat_str(mrb, str, ins);
 471   return 0;
 472 }
 473
 474 mrb_value
 475 mrb_obj_iv_inspect(mrb_state *mrb, struct RObject *obj)
 476 {
 477   iv_tbl *t = obj->iv;
 478   size_t len = iv_size(mrb, t);
 479
 480   if (len > 0) {
 481     const char *cn = mrb_obj_classname(mrb, mrb_obj_value(obj));
 482     mrb_value str = mrb_str_new_capa(mrb, 30);
 483
 484     mrb_str_cat_lit(mrb, str, "-<");
 485     mrb_str_cat_cstr(mrb, str, cn);
 486     mrb_str_cat_lit(mrb, str, ":");
 487     mrb_str_cat_str(mrb, str, mrb_ptr_to_str(mrb, obj));
 488
 489     if (mrb_inspect_recursive_p(mrb, mrb_obj_value(obj))) {
 490       mrb_str_cat_lit(mrb, str, " ...>");
 491       return str;
 492     }
 493     iv_foreach(mrb, t, inspect_i, &str);
 494     mrb_str_cat_lit(mrb, str, ">");
 495     return str;
 496   }
 497   return mrb_any_to_s(mrb, mrb_obj_value(obj));
 498 }
 499
 500 MRB_API mrb_value
 501 mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym)
 502 {
 503   if (obj_iv_p(obj)) {
 504     struct RObject *o = mrb_obj_ptr(obj);
 505     iv_tbl *t = o->iv;
 506     mrb_value val;
 507
 508     mrb_check_frozen(mrb, o);
 509     if (iv_del(mrb, t, sym, &val)) {
 510       return val;
 511     }
 512   }
 513   return mrb_undef_value();
 514 }
 515
 516 static int
 517 iv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 518 {
 519   mrb_value ary;
 520   const char* s;
 521   mrb_int len;
 522
 523   ary = *(mrb_value*)p;
 524   s = mrb_sym_name_len(mrb, sym, &len);
 525   if (len > 1 && s[0] == '@' && s[1] != '@') {
 526     mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
 527   }
 528   return 0;
 529 }
 530
 531 /* 15.3.1.3.23 */
 532 /*
 533  *  call-seq:
 534  *     obj.instance_variables    -> array
 535  *
 536  *  Returns an array of instance variable names for the receiver. Note
 537  *  that simply defining an accessor does not create the corresponding
 538  *  instance variable.
 539  *
 540  *     class Fred
 541  *       attr_accessor :a1
 542  *       def initialize
 543  *         @iv = 3
 544  *       end
 545  *     end
 546  *     Fred.new.instance_variables   #=> [:@iv]
 547  */
 548 mrb_value
 549 mrb_obj_instance_variables(mrb_state *mrb, mrb_value self)
 550 {
 551   mrb_value ary;
 552
 553   ary = mrb_ary_new(mrb);
 554   if (obj_iv_p(self)) {
 555     iv_foreach(mrb, mrb_obj_ptr(self)->iv, iv_i, &ary);
 556   }
 557   return ary;
 558 }
 559
 560 static int
 561 cv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 562 {
 563   mrb_value ary;
 564   const char* s;
 565   mrb_int len;
 566
 567   ary = *(mrb_value*)p;
 568   s = mrb_sym_name_len(mrb, sym, &len);
 569   if (len > 2 && s[0] == '@' && s[1] == '@') {
 570     mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
 571   }
 572   return 0;
 573 }
 574
 575 /* 15.2.2.4.19 */
 576 /*
 577  *  call-seq:
 578  *     mod.class_variables(inherit=true)   -> array
 579  *
 580  *  Returns an array of the names of class variables in <i>mod</i>.
 581  *
 582  *     class One
 583  *       @@var1 = 1
 584  *     end
 585  *     class Two < One
 586  *       @@var2 = 2
 587  *     end
 588  *     One.class_variables   #=> [:@@var1]
 589  *     Two.class_variables   #=> [:@@var2]
 590  */
 591 mrb_value
 592 mrb_mod_class_variables(mrb_state *mrb, mrb_value mod)
 593 {
 594   mrb_value ary;
 595   struct RClass *c;
 596   mrb_bool inherit = TRUE;
 597
 598   mrb_get_args(mrb, "|b", &inherit);
 599   ary = mrb_ary_new(mrb);
 600   c = mrb_class_ptr(mod);
 601   while (c) {
 602     iv_foreach(mrb, class_iv_ptr(c), cv_i, &ary);
 603     if (!inherit) break;
 604     c = c->super;
 605   }
 606   return ary;
 607 }
 608
 609 mrb_value
 610 mrb_mod_cv_get(mrb_state *mrb, struct RClass *c, mrb_sym sym)
 611 {
 612   struct RClass * cls = c;
 613   mrb_value v;
 614   int given = FALSE;
 615
 616   while (c) {
 617     if (iv_get(mrb, class_iv_ptr(c), sym, &v)) {
 618       given = TRUE;
 619     }
 620     c = c->super;
 621   }
 622   if (given) return v;
 623   if (cls && cls->tt == MRB_TT_SCLASS) {
 624     mrb_value klass;
 625
 626     klass = mrb_obj_iv_get(mrb, (struct RObject*)cls, MRB_SYM(__attached__));
 627     c = mrb_class_ptr(klass);
 628     if (c->tt == MRB_TT_CLASS || c->tt == MRB_TT_MODULE) {
 629       given = FALSE;
 630       while (c) {
 631         if (iv_get(mrb, class_iv_ptr(c), sym, &v)) {
 632           given = TRUE;
 633         }
 634         c = c->super;
 635       }
 636       if (given) return v;
 637     }
 638   }
 639   mrb_name_error(mrb, sym, "uninitialized class variable %n in %C", sym, cls);
 640   /* not reached */
 641   return mrb_nil_value();
 642 }
 643
 644 MRB_API mrb_value
 645 mrb_cv_get(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 646 {
 647   return mrb_mod_cv_get(mrb, mrb_class_ptr(mod), sym);
 648 }
 649
 650 MRB_API void
 651 mrb_mod_cv_set(mrb_state *mrb, struct RClass *c, mrb_sym sym, mrb_value v)
 652 {
 653   struct RClass * cls = c;
 654
 655   while (c) {
 656     iv_tbl *t = class_iv_ptr(c);
 657     int pos = iv_get(mrb, t, sym, NULL);
 658
 659     if (pos) {
 660       mrb_check_frozen(mrb, c);
 661       t->ptr[pos-1] = v;        /* iv_get returns pos+1 to put */
 662       mrb_field_write_barrier_value(mrb, (struct RBasic*)c, v);
 663       return;
 664     }
 665     c = c->super;
 666   }
 667
 668   if (cls && cls->tt == MRB_TT_SCLASS) {
 669     mrb_value klass;
 670
 671     klass = mrb_obj_iv_get(mrb, (struct RObject*)cls, MRB_SYM(__attached__));
 672     switch (mrb_type(klass)) {
 673     case MRB_TT_CLASS:
 674     case MRB_TT_MODULE:
 675     case MRB_TT_SCLASS:
 676       c = mrb_class_ptr(klass);
 677       break;
 678     default:
 679       c = cls;
 680       break;
 681     }
 682   }
 683   else if (cls && cls->tt == MRB_TT_ICLASS) {
 684     c = cls->c;
 685   }
 686   else {
 687     c = cls;
 688   }
 689
 690   mrb_check_frozen(mrb, c);
 691   if (!c->iv) {
 692     c->iv = iv_new(mrb);
 693   }
 694
 695   iv_put(mrb, c->iv, sym, v);
 696   mrb_field_write_barrier_value(mrb, (struct RBasic*)c, v);
 697 }
 698
 699 MRB_API void
 700 mrb_cv_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v)
 701 {
 702   mrb_mod_cv_set(mrb, mrb_class_ptr(mod), sym, v);
 703 }
 704
 705 mrb_bool
 706 mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym)
 707 {
 708   while (c) {
 709     iv_tbl *t = class_iv_ptr(c);
 710     if (iv_get(mrb, t, sym, NULL)) return TRUE;
 711     c = c->super;
 712   }
 713
 714   return FALSE;
 715 }
 716
 717 MRB_API mrb_bool
 718 mrb_cv_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 719 {
 720   return mrb_mod_cv_defined(mrb, mrb_class_ptr(mod), sym);
 721 }
 722
 723 mrb_value
 724 mrb_vm_cv_get(mrb_state *mrb, mrb_sym sym)
 725 {
 726   struct RClass *c;
 727
 728   const struct RProc *p = mrb->c->ci->proc;
 729
 730   for (;;) {
 731     c = MRB_PROC_TARGET_CLASS(p);
 732     if (c && c->tt != MRB_TT_SCLASS) break;
 733     p = p->upper;
 734   }
 735   return mrb_mod_cv_get(mrb, c, sym);
 736 }
 737
 738 void
 739 mrb_vm_cv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
 740 {
 741   struct RClass *c;
 742   const struct RProc *p = mrb->c->ci->proc;
 743
 744   for (;;) {
 745     c = MRB_PROC_TARGET_CLASS(p);
 746     if (c && c->tt != MRB_TT_SCLASS) break;
 747     p = p->upper;
 748   }
 749   mrb_mod_cv_set(mrb, c, sym, v);
 750 }
 751
 752 static void
 753 mod_const_check(mrb_state *mrb, mrb_value mod)
 754 {
 755   switch (mrb_type(mod)) {
 756   case MRB_TT_CLASS:
 757   case MRB_TT_MODULE:
 758   case MRB_TT_SCLASS:
 759     break;
 760   default:
 761     mrb_raise(mrb, E_TYPE_ERROR, "constant look-up for non class/module");
 762     break;
 763   }
 764 }
 765
 766 static mrb_value
 767 const_get(mrb_state *mrb, struct RClass *base, mrb_sym sym, mrb_bool skip)
 768 {
 769   struct RClass *c = base;
 770   mrb_value v;
 771   mrb_bool retry = FALSE;
 772
 773   /* if skip then skip the current class (already searched) */
 774   if (skip) c = c->super;
 775 L_RETRY:
 776   while (c) {
 777     if (!MRB_FLAG_TEST(c, MRB_FL_CLASS_IS_PREPENDED) && iv_get(mrb, class_iv_ptr(c), sym, &v)) {
 778       return v;
 779     }
 780     c = c->super;
 781     if (!skip && c == mrb->object_class) break;
 782   }
 783   if (!retry && base->tt == MRB_TT_MODULE && skip) {
 784     c = mrb->object_class;
 785     retry = TRUE;
 786     goto L_RETRY;
 787   }
 788   mrb_value mod = mrb_obj_value(base);
 789   if (mrb_func_basic_p(mrb, mod, MRB_SYM(const_missing), mrb_mod_const_missing)) {
 790     return mrb_const_missing(mrb, mod, sym);
 791   }
 792   mrb_value name = mrb_symbol_value(sym);
 793   return mrb_funcall_argv(mrb, mod, MRB_SYM(const_missing), 1, &name);
 794 }
 795
 796 MRB_API mrb_value
 797 mrb_const_get(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 798 {
 799   mod_const_check(mrb, mod);
 800   return const_get(mrb, mrb_class_ptr(mod), sym, FALSE);
 801 }
 802
 803 mrb_value
 804 mrb_vm_const_get(mrb_state *mrb, mrb_sym sym)
 805 {
 806   struct RClass *c;
 807   struct RClass *c2;
 808   mrb_value v;
 809   const struct RProc *proc = mrb->c->ci->proc;
 810
 811   c = MRB_PROC_TARGET_CLASS(proc);
 812   if (!c) c = mrb->object_class;
 813   if (iv_get(mrb, class_iv_ptr(c), sym, &v)) {
 814     return v;
 815   }
 816   c2 = c;
 817   while (c2 && c2->tt == MRB_TT_SCLASS) {
 818     mrb_value klass;
 819
 820     if (!iv_get(mrb, class_iv_ptr(c2), MRB_SYM(__attached__), &klass)) {
 821       c2 = NULL;
 822       break;
 823     }
 824     c2 = mrb_class_ptr(klass);
 825   }
 826   if (c2 && (c2->tt == MRB_TT_CLASS || c2->tt == MRB_TT_MODULE)) c = c2;
 827   proc = proc->upper;
 828   while (proc) {
 829     c2 = MRB_PROC_TARGET_CLASS(proc);
 830     if (!c2) c2 = mrb->object_class;
 831     if (c2 && iv_get(mrb, class_iv_ptr(c2), sym, &v)) {
 832       return v;
 833     }
 834     proc = proc->upper;
 835   }
 836   return const_get(mrb, c, sym, TRUE);
 837 }
 838
 839 MRB_API void
 840 mrb_const_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v)
 841 {
 842   mod_const_check(mrb, mod);
 843   if (mrb_type(v) == MRB_TT_CLASS || mrb_type(v) == MRB_TT_MODULE) {
 844     mrb_class_name_class(mrb, mrb_class_ptr(mod), mrb_class_ptr(v), sym);
 845   }
 846   mrb_iv_set(mrb, mod, sym, v);
 847 }
 848
 849 void
 850 mrb_vm_const_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
 851 {
 852   struct RClass *c;
 853
 854   c = MRB_PROC_TARGET_CLASS(mrb->c->ci->proc);
 855   if (!c) c = mrb->object_class;
 856   mrb_obj_iv_set(mrb, (struct RObject*)c, sym, v);
 857 }
 858
 859 MRB_API void
 860 mrb_const_remove(mrb_state *mrb, mrb_value mod, mrb_sym sym)
 861 {
 862   mod_const_check(mrb, mod);
 863   mrb_iv_remove(mrb, mod, sym);
 864 }
 865
 866 MRB_API void
 867 mrb_define_const_id(mrb_state *mrb, struct RClass *mod, mrb_sym name, mrb_value v)
 868 {
 869   mrb_obj_iv_set(mrb, (struct RObject*)mod, name, v);
 870 }
 871
 872 MRB_API void
 873 mrb_define_const(mrb_state *mrb, struct RClass *mod, const char *name, mrb_value v)
 874 {
 875   mrb_obj_iv_set(mrb, (struct RObject*)mod, mrb_intern_cstr(mrb, name), v);
 876 }
 877
 878 MRB_API void
 879 mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val)
 880 {
 881   mrb_define_const(mrb, mrb->object_class, name, val);
 882 }
 883
 884 static int
 885 const_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 886 {
 887   mrb_value ary;
 888   const char* s;
 889   mrb_int len;
 890
 891   ary = *(mrb_value*)p;
 892   s = mrb_sym_name_len(mrb, sym, &len);
 893   if (len >= 1 && ISUPPER(s[0])) {
 894     mrb_int i, alen = RARRAY_LEN(ary);
 895
 896     for (i=0; i<alen; i++) {
 897       if (mrb_symbol(RARRAY_PTR(ary)[i]) == sym)
 898         break;
 899     }
 900     if (i==alen) {
 901       mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
 902     }
 903   }
 904   return 0;
 905 }
 906
 907 /* 15.2.2.4.24 */
 908 /*
 909  *  call-seq:
 910  *     mod.constants    -> array
 911  *
 912  *  Returns an array of all names of constants defined in the receiver.
 913  */
 914 mrb_value
 915 mrb_mod_constants(mrb_state *mrb, mrb_value mod)
 916 {
 917   mrb_value ary;
 918   mrb_bool inherit = TRUE;
 919   struct RClass *c = mrb_class_ptr(mod);
 920
 921   mrb_get_args(mrb, "|b", &inherit);
 922   ary = mrb_ary_new(mrb);
 923   while (c) {
 924     iv_foreach(mrb, class_iv_ptr(c), const_i, &ary);
 925     if (!inherit) break;
 926     c = c->super;
 927     if (c == mrb->object_class) break;
 928   }
 929   return ary;
 930 }
 931
 932 MRB_API mrb_value
 933 mrb_gv_get(mrb_state *mrb, mrb_sym sym)
 934 {
 935   mrb_value v;
 936
 937   if (iv_get(mrb, mrb->globals, sym, &v))
 938     return v;
 939   return mrb_nil_value();
 940 }
 941
 942 MRB_API void
 943 mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value v)
 944 {
 945   iv_tbl *t;
 946
 947   if (!mrb->globals) {
 948     mrb->globals = iv_new(mrb);
 949   }
 950   t = mrb->globals;
 951   iv_put(mrb, t, sym, v);
 952 }
 953
 954 MRB_API void
 955 mrb_gv_remove(mrb_state *mrb, mrb_sym sym)
 956 {
 957   iv_del(mrb, mrb->globals, sym, NULL);
 958 }
 959
 960 static int
 961 gv_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
 962 {
 963   mrb_value ary;
 964
 965   ary = *(mrb_value*)p;
 966   mrb_ary_push(mrb, ary, mrb_symbol_value(sym));
 967   return 0;
 968 }
 969
 970 /* 15.3.1.2.4  */
 971 /* 15.3.1.3.14 */
 972 /*
 973  *  call-seq:
 974  *     global_variables    -> array
 975  *
 976  *  Returns an array of the names of global variables.
 977  *
 978  *     global_variables.grep /std/   #=> [:$stdin, :$stdout, :$stderr]
 979  */
 980 mrb_value
 981 mrb_f_global_variables(mrb_state *mrb, mrb_value self)
 982 {
 983   iv_tbl *t = mrb->globals;
 984   mrb_value ary = mrb_ary_new(mrb);
 985
 986   iv_foreach(mrb, t, gv_i, &ary);
 987   return ary;
 988 }
 989
 990 static mrb_bool
 991 const_defined_0(mrb_state *mrb, mrb_value mod, mrb_sym id, mrb_bool exclude, mrb_bool recurse)
 992 {
 993   struct RClass *klass = mrb_class_ptr(mod);
 994   struct RClass *tmp;
 995   mrb_bool mod_retry = FALSE;
 996
 997   tmp = klass;
 998 retry:
 999   while (tmp) {
1000     if (iv_get(mrb, class_iv_ptr(tmp), id, NULL)) {
1001       return TRUE;
1002     }
1003     if (!recurse && (klass != mrb->object_class)) break;
1004     tmp = tmp->super;
1005   }
1006   if (!exclude && !mod_retry && (klass->tt == MRB_TT_MODULE)) {
1007     mod_retry = TRUE;
1008     tmp = mrb->object_class;
1009     goto retry;
1010   }
1011   return FALSE;
1012 }
1013
1014 MRB_API mrb_bool
1015 mrb_const_defined(mrb_state *mrb, mrb_value mod, mrb_sym id)
1016 {
1017   return const_defined_0(mrb, mod, id, TRUE, TRUE);
1018 }
1019
1020 MRB_API mrb_bool
1021 mrb_const_defined_at(mrb_state *mrb, mrb_value mod, mrb_sym id)
1022 {
1023   return const_defined_0(mrb, mod, id, TRUE, FALSE);
1024 }
1025
1026 MRB_API mrb_value
1027 mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id)
1028 {
1029   return mrb_iv_get(mrb, obj, id);
1030 }
1031
1032 struct csym_arg {
1033   struct RClass *c;
1034   mrb_sym sym;
1035 };
1036
1037 static int
1038 csym_i(mrb_state *mrb, mrb_sym sym, mrb_value v, void *p)
1039 {
1040   struct csym_arg *a = (struct csym_arg*)p;
1041   struct RClass *c = a->c;
1042
1043   if (mrb_type(v) == c->tt && mrb_class_ptr(v) == c) {
1044     a->sym = sym;
1045     return 1;     /* stop iteration */
1046   }
1047   return 0;
1048 }
1049
1050 static mrb_sym
1051 find_class_sym(mrb_state *mrb, struct RClass *outer, struct RClass *c)
1052 {
1053   struct csym_arg arg;
1054
1055   if (!outer) return 0;
1056   if (outer == c) return 0;
1057   arg.c = c;
1058   arg.sym = 0;
1059   iv_foreach(mrb, class_iv_ptr(outer), csym_i, &arg);
1060   return arg.sym;
1061 }
1062
1063 static struct RClass*
1064 outer_class(mrb_state *mrb, struct RClass *c)
1065 {
1066   mrb_value ov;
1067
1068   ov = mrb_obj_iv_get(mrb, (struct RObject*)c, MRB_SYM(__outer__));
1069   if (mrb_nil_p(ov)) return NULL;
1070   switch (mrb_type(ov)) {
1071   case MRB_TT_CLASS:
1072   case MRB_TT_MODULE:
1073     return mrb_class_ptr(ov);
1074   default:
1075     break;
1076   }
1077   return NULL;
1078 }
1079
1080 static mrb_bool
1081 detect_outer_loop(mrb_state *mrb, struct RClass *c)
1082 {
1083   struct RClass *t = c;         /* tortoise */
1084   struct RClass *h = c;         /* hare */
1085
1086   for (;;) {
1087     if (h == NULL) return FALSE;
1088     h = outer_class(mrb, h);
1089     if (h == NULL) return FALSE;
1090     h = outer_class(mrb, h);
1091     t = outer_class(mrb, t);
1092     if (t == h) return TRUE;
1093   }
1094 }
1095
1096 mrb_value
1097 mrb_class_find_path(mrb_state *mrb, struct RClass *c)
1098 {
1099   struct RClass *outer;
1100   mrb_value path;
1101   mrb_sym name;
1102   const char *str;
1103   mrb_int len;
1104
1105   if (detect_outer_loop(mrb, c)) return mrb_nil_value();
1106   outer = outer_class(mrb, c);
1107   if (outer == NULL) return mrb_nil_value();
1108   name = find_class_sym(mrb, outer, c);
1109   if (name == 0) return mrb_nil_value();
1110   path = mrb_str_new_capa(mrb, 40);
1111   str = mrb_class_name(mrb, outer);
1112   mrb_str_cat_cstr(mrb, path, str);
1113   mrb_str_cat_cstr(mrb, path, "::");
1114
1115   str = mrb_sym_name_len(mrb, name, &len);
1116   mrb_str_cat(mrb, path, str, len);
1117   if (RSTRING_PTR(path)[0] != '#') {
1118     iv_del(mrb, c->iv, MRB_SYM(__outer__), NULL);
1119     iv_put(mrb, c->iv, MRB_SYM(__classname__), path);
1120     mrb_field_write_barrier_value(mrb, (struct RBasic*)c, path);
1121     path = mrb_str_dup(mrb, path);
1122   }
1123   return path;
1124 }
1125
1126 size_t
1127 mrb_obj_iv_tbl_memsize(mrb_value obj)
1128 {
1129   iv_tbl *t = mrb_obj_ptr(obj)->iv;
1130   if (t == NULL) return 0;
1131   return sizeof(iv_tbl) + t->alloc*(sizeof(mrb_value)+sizeof(mrb_sym));
1132 }
1133
1134 #define identchar(c) (ISALNUM(c) || (c) == '_' || !ISASCII(c))
1135
1136 mrb_bool
1137 mrb_ident_p(const char *s, mrb_int len)
1138 {
1139   for (mrb_int i = 0; i < len; i++) {
1140     if (!identchar(s[i])) return FALSE;
1141   }
1142   return TRUE;
1143 }