class.c

   1 /**********************************************************************
   2
   3   class.c -
   4
   5   $Author$
   6   created at: Tue Aug 10 15:05:44 JST 1993
   7
   8   Copyright (C) 1993-2007 Yukihiro Matsumoto
   9
  10 **********************************************************************/
  11
  12 #include "ruby/ruby.h"
  13 #include "ruby/signal.h"
  14 #include "ruby/node.h"
  15 #include "ruby/st.h"
  16 #include <ctype.h>
  17
  18 extern st_table *rb_class_tbl;
  19
  20 static VALUE
  21 class_alloc(VALUE flags, VALUE klass)
  22 {
  23     rb_classext_t *ext = ALLOC(rb_classext_t);
  24     NEWOBJ(obj, struct RClass);
  25     OBJSETUP(obj, klass, flags);
  26     obj->ptr = ext;
  27     RCLASS_IV_TBL(obj) = 0;
  28     RCLASS_M_TBL(obj) = 0;
  29     RCLASS_SUPER(obj) = 0;
  30     RCLASS_IV_INDEX_TBL(obj) = 0;
  31     return (VALUE)obj;
  32 }
  33
  34 VALUE
  35 rb_class_boot(VALUE super)
  36 {
  37     VALUE klass = class_alloc(T_CLASS, rb_cClass);
  38
  39     RCLASS_SUPER(klass) = super;
  40     RCLASS_M_TBL(klass) = st_init_numtable();
  41
  42     OBJ_INFECT(klass, super);
  43     return (VALUE)klass;
  44 }
  45
  46 void
  47 rb_check_inheritable(VALUE super)
  48 {
  49     if (TYPE(super) != T_CLASS) {
  50         rb_raise(rb_eTypeError, "superclass must be a Class (%s given)",
  51                  rb_obj_classname(super));
  52     }
  53     if (RBASIC(super)->flags & FL_SINGLETON) {
  54         rb_raise(rb_eTypeError, "can't make subclass of singleton class");
  55     }
  56 }
  57
  58 VALUE
  59 rb_class_new(VALUE super)
  60 {
  61     Check_Type(super, T_CLASS);
  62     rb_check_inheritable(super);
  63     if (super == rb_cClass) {
  64         rb_raise(rb_eTypeError, "can't make subclass of Class");
  65     }
  66     return rb_class_boot(super);
  67 }
  68
  69 struct clone_method_data {
  70     st_table *tbl;
  71     VALUE klass;
  72 };
  73
  74 static int
  75 clone_method(ID mid, NODE *body, struct clone_method_data *data)
  76 {
  77     if (body == 0) {
  78         st_insert(data->tbl, mid, 0);
  79     }
  80     else {
  81         st_insert(data->tbl, mid,
  82                   (st_data_t)
  83                   NEW_FBODY(
  84                       NEW_METHOD(body->nd_body->nd_body,
  85                                  data->klass, /* TODO */
  86                                  body->nd_body->nd_noex),
  87                       0));
  88     }
  89     return ST_CONTINUE;
  90 }
  91
  92 /* :nodoc: */
  93 VALUE
  94 rb_mod_init_copy(VALUE clone, VALUE orig)
  95 {
  96     rb_obj_init_copy(clone, orig);
  97     if (!FL_TEST(CLASS_OF(clone), FL_SINGLETON)) {
  98         RBASIC(clone)->klass = rb_singleton_class_clone(orig);
  99     }
 100     RCLASS_SUPER(clone) = RCLASS_SUPER(orig);
 101     if (RCLASS_IV_TBL(orig)) {
 102         ID id;
 103
 104         RCLASS_IV_TBL(clone) = st_copy(RCLASS_IV_TBL(orig));
 105         id = rb_intern("__classpath__");
 106         st_delete(RCLASS_IV_TBL(clone), (st_data_t*)&id, 0);
 107         id = rb_intern("__classid__");
 108         st_delete(RCLASS_IV_TBL(clone), (st_data_t*)&id, 0);
 109     }
 110     if (RCLASS_M_TBL(orig)) {
 111         struct clone_method_data data;
 112         data.tbl = RCLASS_M_TBL(clone) = st_init_numtable();
 113         data.klass = clone;
 114         st_foreach(RCLASS_M_TBL(orig), clone_method,
 115           (st_data_t)&data);
 116     }
 117
 118     return clone;
 119 }
 120
 121 /* :nodoc: */
 122 VALUE
 123 rb_class_init_copy(VALUE clone, VALUE orig)
 124 {
 125     if (RCLASS_SUPER(clone) != 0) {
 126         rb_raise(rb_eTypeError, "already initialized class");
 127     }
 128     if (FL_TEST(orig, FL_SINGLETON)) {
 129         rb_raise(rb_eTypeError, "can't copy singleton class");
 130     }
 131     return rb_mod_init_copy(clone, orig);
 132 }
 133
 134 VALUE
 135 rb_singleton_class_clone(VALUE obj)
 136 {
 137     VALUE klass = RBASIC(obj)->klass;
 138
 139     if (!FL_TEST(klass, FL_SINGLETON))
 140         return klass;
 141     else {
 142         struct clone_method_data data;
 143         /* copy singleton(unnamed) class */
 144         VALUE clone = class_alloc(RBASIC(klass)->flags, 0);
 145
 146         if (BUILTIN_TYPE(obj) == T_CLASS) {
 147             RBASIC(clone)->klass = (VALUE)clone;
 148         }
 149         else {
 150             RBASIC(clone)->klass = rb_singleton_class_clone(klass);
 151         }
 152
 153         RCLASS_SUPER(clone) = RCLASS_SUPER(klass);
 154         if (RCLASS_IV_TBL(klass)) {
 155             RCLASS_IV_TBL(clone) = st_copy(RCLASS_IV_TBL(klass));
 156         }
 157         RCLASS_M_TBL(clone) = st_init_numtable();
 158         data.tbl = RCLASS_M_TBL(clone);
 159         data.klass = (VALUE)clone;
 160         st_foreach(RCLASS_M_TBL(klass), clone_method,
 161           (st_data_t)&data);
 162         rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)clone);
 163         FL_SET(clone, FL_SINGLETON);
 164         return (VALUE)clone;
 165     }
 166 }
 167
 168 void
 169 rb_singleton_class_attached(VALUE klass, VALUE obj)
 170 {
 171     if (FL_TEST(klass, FL_SINGLETON)) {
 172         if (!RCLASS_IV_TBL(klass)) {
 173             RCLASS_IV_TBL(klass) = st_init_numtable();
 174         }
 175         st_insert(RCLASS_IV_TBL(klass), rb_intern("__attached__"), obj);
 176     }
 177 }
 178
 179 VALUE
 180 rb_make_metaclass(VALUE obj, VALUE super)
 181 {
 182     if (BUILTIN_TYPE(obj) == T_CLASS && FL_TEST(obj, FL_SINGLETON)) {
 183         return RBASIC(obj)->klass = rb_cClass;
 184     }
 185     else {
 186         VALUE metasuper;
 187         VALUE klass = rb_class_boot(super);
 188
 189         FL_SET(klass, FL_SINGLETON);
 190         RBASIC(obj)->klass = klass;
 191         rb_singleton_class_attached(klass, obj);
 192
 193         metasuper = RBASIC(rb_class_real(super))->klass;
 194         /* metaclass of a superclass may be NULL at boot time */
 195         if (metasuper) {
 196             RBASIC(klass)->klass = metasuper;
 197         }
 198         return klass;
 199     }
 200 }
 201
 202 VALUE
 203 rb_define_class_id(ID id, VALUE super)
 204 {
 205     VALUE klass;
 206
 207     if (!super) super = rb_cObject;
 208     klass = rb_class_new(super);
 209     rb_make_metaclass(klass, RBASIC(super)->klass);
 210
 211     return klass;
 212 }
 213
 214 VALUE
 215 rb_class_inherited(VALUE super, VALUE klass)
 216 {
 217     if (!super) super = rb_cObject;
 218     return rb_funcall(super, rb_intern("inherited"), 1, klass);
 219 }
 220
 221 VALUE
 222 rb_define_class(const char *name, VALUE super)
 223 {
 224     VALUE klass;
 225     ID id;
 226
 227     id = rb_intern(name);
 228     if (rb_const_defined(rb_cObject, id)) {
 229         klass = rb_const_get(rb_cObject, id);
 230         if (TYPE(klass) != T_CLASS) {
 231             rb_raise(rb_eTypeError, "%s is not a class", name);
 232         }
 233         if (rb_class_real(RCLASS_SUPER(klass)) != super) {
 234             rb_name_error(id, "%s is already defined", name);
 235         }
 236         return klass;
 237     }
 238     if (!super) {
 239         rb_warn("no super class for `%s', Object assumed", name);
 240     }
 241     klass = rb_define_class_id(id, super);
 242     st_add_direct(rb_class_tbl, id, klass);
 243     rb_name_class(klass, id);
 244     rb_const_set(rb_cObject, id, klass);
 245     rb_class_inherited(super, klass);
 246
 247     return klass;
 248 }
 249
 250 VALUE
 251 rb_define_class_under(VALUE outer, const char *name, VALUE super)
 252 {
 253     VALUE klass;
 254     ID id;
 255
 256     id = rb_intern(name);
 257     if (rb_const_defined_at(outer, id)) {
 258         klass = rb_const_get_at(outer, id);
 259         if (TYPE(klass) != T_CLASS) {
 260             rb_raise(rb_eTypeError, "%s is not a class", name);
 261         }
 262         if (rb_class_real(RCLASS_SUPER(klass)) != super) {
 263             rb_name_error(id, "%s is already defined", name);
 264         }
 265         return klass;
 266     }
 267     if (!super) {
 268         rb_warn("no super class for `%s::%s', Object assumed",
 269                 rb_class2name(outer), name);
 270     }
 271     klass = rb_define_class_id(id, super);
 272     rb_set_class_path(klass, outer, name);
 273     rb_const_set(outer, id, klass);
 274     rb_class_inherited(super, klass);
 275
 276     return klass;
 277 }
 278
 279 VALUE
 280 rb_module_new(void)
 281 {
 282     VALUE mdl = class_alloc(T_MODULE, rb_cModule);
 283
 284     RCLASS_M_TBL(mdl) = st_init_numtable();
 285
 286     return (VALUE)mdl;
 287 }
 288
 289 VALUE
 290 rb_define_module_id(ID id)
 291 {
 292     VALUE mdl;
 293
 294     mdl = rb_module_new();
 295     rb_name_class(mdl, id);
 296
 297     return mdl;
 298 }
 299
 300 VALUE
 301 rb_define_module(const char *name)
 302 {
 303     VALUE module;
 304     ID id;
 305
 306     id = rb_intern(name);
 307     if (rb_const_defined(rb_cObject, id)) {
 308         module = rb_const_get(rb_cObject, id);
 309         if (TYPE(module) == T_MODULE)
 310             return module;
 311         rb_raise(rb_eTypeError, "%s is not a module", rb_obj_classname(module));
 312     }
 313     module = rb_define_module_id(id);
 314     st_add_direct(rb_class_tbl, id, module);
 315     rb_const_set(rb_cObject, id, module);
 316
 317     return module;
 318 }
 319
 320 VALUE
 321 rb_define_module_under(VALUE outer, const char *name)
 322 {
 323     VALUE module;
 324     ID id;
 325
 326     id = rb_intern(name);
 327     if (rb_const_defined_at(outer, id)) {
 328         module = rb_const_get_at(outer, id);
 329         if (TYPE(module) == T_MODULE)
 330             return module;
 331         rb_raise(rb_eTypeError, "%s::%s is not a module",
 332                  rb_class2name(outer), rb_obj_classname(module));
 333     }
 334     module = rb_define_module_id(id);
 335     rb_const_set(outer, id, module);
 336     rb_set_class_path(module, outer, name);
 337
 338     return module;
 339 }
 340
 341 static VALUE
 342 include_class_new(VALUE module, VALUE super)
 343 {
 344     VALUE klass = class_alloc(T_ICLASS, rb_cClass);
 345
 346     if (BUILTIN_TYPE(module) == T_ICLASS) {
 347         module = RBASIC(module)->klass;
 348     }
 349     if (!RCLASS_IV_TBL(module)) {
 350         RCLASS_IV_TBL(module) = st_init_numtable();
 351     }
 352     RCLASS_IV_TBL(klass) = RCLASS_IV_TBL(module);
 353     RCLASS_M_TBL(klass) = RCLASS_M_TBL(module);
 354     RCLASS_SUPER(klass) = super;
 355     if (TYPE(module) == T_ICLASS) {
 356         RBASIC(klass)->klass = RBASIC(module)->klass;
 357     }
 358     else {
 359         RBASIC(klass)->klass = module;
 360     }
 361     OBJ_INFECT(klass, module);
 362     OBJ_INFECT(klass, super);
 363
 364     return (VALUE)klass;
 365 }
 366
 367 void
 368 rb_include_module(VALUE klass, VALUE module)
 369 {
 370     VALUE p, c;
 371     int changed = 0;
 372
 373     rb_frozen_class_p(klass);
 374     if (!OBJ_TAINTED(klass)) {
 375         rb_secure(4);
 376     }
 377
 378     if (TYPE(module) != T_MODULE) {
 379         Check_Type(module, T_MODULE);
 380     }
 381
 382     OBJ_INFECT(klass, module);
 383     c = klass;
 384     while (module) {
 385        int superclass_seen = Qfalse;
 386
 387         if (RCLASS_M_TBL(klass) == RCLASS_M_TBL(module))
 388             rb_raise(rb_eArgError, "cyclic include detected");
 389        /* ignore if the module included already in superclasses */
 390        for (p = RCLASS_SUPER(klass); p; p = RCLASS_SUPER(p)) {
 391            switch (BUILTIN_TYPE(p)) {
 392              case T_ICLASS:
 393                if (RCLASS_M_TBL(p) == RCLASS_M_TBL(module)) {
 394                    if (!superclass_seen) {
 395                        c = p;  /* move insertion point */
 396                    }
 397                    goto skip;
 398                }
 399                break;
 400              case T_CLASS:
 401                superclass_seen = Qtrue;
 402                break;
 403            }
 404        }
 405        c = RCLASS_SUPER(c) = include_class_new(module, RCLASS_SUPER(c));
 406         changed = 1;
 407       skip:
 408         module = RCLASS_SUPER(module);
 409     }
 410     if (changed) rb_clear_cache();
 411 }
 412
 413 /*
 414  *  call-seq:
 415  *     mod.included_modules -> array
 416  *
 417  *  Returns the list of modules included in <i>mod</i>.
 418  *
 419  *     module Mixin
 420  *     end
 421  *
 422  *     module Outer
 423  *       include Mixin
 424  *     end
 425  *
 426  *     Mixin.included_modules   #=> []
 427  *     Outer.included_modules   #=> [Mixin]
 428  */
 429
 430 VALUE
 431 rb_mod_included_modules(VALUE mod)
 432 {
 433     VALUE ary = rb_ary_new();
 434     VALUE p;
 435
 436     for (p = RCLASS_SUPER(mod); p; p = RCLASS_SUPER(p)) {
 437         if (BUILTIN_TYPE(p) == T_ICLASS) {
 438             rb_ary_push(ary, RBASIC(p)->klass);
 439         }
 440     }
 441     return ary;
 442 }
 443
 444 /*
 445  *  call-seq:
 446  *     mod.include?(module)    => true or false
 447  *
 448  *  Returns <code>true</code> if <i>module</i> is included in
 449  *  <i>mod</i> or one of <i>mod</i>'s ancestors.
 450  *
 451  *     module A
 452  *     end
 453  *     class B
 454  *       include A
 455  *     end
 456  *     class C < B
 457  *     end
 458  *     B.include?(A)   #=> true
 459  *     C.include?(A)   #=> true
 460  *     A.include?(A)   #=> false
 461  */
 462
 463 VALUE
 464 rb_mod_include_p(VALUE mod, VALUE mod2)
 465 {
 466     VALUE p;
 467
 468     Check_Type(mod2, T_MODULE);
 469     for (p = RCLASS_SUPER(mod); p; p = RCLASS_SUPER(p)) {
 470         if (BUILTIN_TYPE(p) == T_ICLASS) {
 471             if (RBASIC(p)->klass == mod2) return Qtrue;
 472         }
 473     }
 474     return Qfalse;
 475 }
 476
 477 /*
 478  *  call-seq:
 479  *     mod.ancestors -> array
 480  *
 481  *  Returns a list of modules included in <i>mod</i> (including
 482  *  <i>mod</i> itself).
 483  *
 484  *     module Mod
 485  *       include Math
 486  *       include Comparable
 487  *     end
 488  *
 489  *     Mod.ancestors    #=> [Mod, Comparable, Math]
 490  *     Math.ancestors   #=> [Math]
 491  */
 492
 493 VALUE
 494 rb_mod_ancestors(VALUE mod)
 495 {
 496     VALUE p, ary = rb_ary_new();
 497
 498     for (p = mod; p; p = RCLASS_SUPER(p)) {
 499         if (FL_TEST(p, FL_SINGLETON))
 500             continue;
 501         if (BUILTIN_TYPE(p) == T_ICLASS) {
 502             rb_ary_push(ary, RBASIC(p)->klass);
 503         }
 504         else {
 505             rb_ary_push(ary, p);
 506         }
 507     }
 508     return ary;
 509 }
 510
 511 #define VISI(x) ((x)&NOEX_MASK)
 512 #define VISI_CHECK(x,f) (VISI(x) == (f))
 513
 514 static int
 515 ins_methods_push(ID name, long type, VALUE ary, long visi)
 516 {
 517     if (type == -1) return ST_CONTINUE;
 518
 519     switch (visi) {
 520       case NOEX_PRIVATE:
 521       case NOEX_PROTECTED:
 522       case NOEX_PUBLIC:
 523         visi = (type == visi);
 524         break;
 525       default:
 526         visi = (type != NOEX_PRIVATE);
 527         break;
 528     }
 529     if (visi) {
 530         rb_ary_push(ary, ID2SYM(name));
 531     }
 532     return ST_CONTINUE;
 533 }
 534
 535 static int
 536 ins_methods_i(ID name, long type, VALUE ary)
 537 {
 538     return ins_methods_push(name, type, ary, -1); /* everything but private */
 539 }
 540
 541 static int
 542 ins_methods_prot_i(ID name, long type, VALUE ary)
 543 {
 544     return ins_methods_push(name, type, ary, NOEX_PROTECTED);
 545 }
 546
 547 static int
 548 ins_methods_priv_i(ID name, long type, VALUE ary)
 549 {
 550     return ins_methods_push(name, type, ary, NOEX_PRIVATE);
 551 }
 552
 553 static int
 554 ins_methods_pub_i(ID name, long type, VALUE ary)
 555 {
 556     return ins_methods_push(name, type, ary, NOEX_PUBLIC);
 557 }
 558
 559 static int
 560 method_entry(ID key, NODE *body, st_table *list)
 561 {
 562     long type;
 563
 564     if (key == ID_ALLOCATOR) {
 565         return ST_CONTINUE;
 566     }
 567
 568     if (!st_lookup(list, key, 0)) {
 569         if (body ==0 || !body->nd_body->nd_body) {
 570             type = -1; /* none */
 571         }
 572         else {
 573             type = VISI(body->nd_body->nd_noex);
 574         }
 575         st_add_direct(list, key, type);
 576     }
 577     return ST_CONTINUE;
 578 }
 579
 580 static VALUE
 581 class_instance_method_list(int argc, VALUE *argv, VALUE mod, int (*func) (ID, long, VALUE))
 582 {
 583     VALUE ary;
 584     int recur;
 585     st_table *list;
 586
 587     if (argc == 0) {
 588         recur = Qtrue;
 589     }
 590     else {
 591         VALUE r;
 592         rb_scan_args(argc, argv, "01", &r);
 593         recur = RTEST(r);
 594     }
 595
 596     list = st_init_numtable();
 597     for (; mod; mod = RCLASS_SUPER(mod)) {
 598         st_foreach(RCLASS_M_TBL(mod), method_entry, (st_data_t)list);
 599         if (BUILTIN_TYPE(mod) == T_ICLASS) continue;
 600         if (FL_TEST(mod, FL_SINGLETON)) continue;
 601         if (!recur) break;
 602     }
 603     ary = rb_ary_new();
 604     st_foreach(list, func, ary);
 605     st_free_table(list);
 606
 607     return ary;
 608 }
 609
 610 /*
 611  *  call-seq:
 612  *     mod.instance_methods(include_super=true)   => array
 613  *
 614  *  Returns an array containing the names of public instance methods in
 615  *  the receiver. For a module, these are the public methods; for a
 616  *  class, they are the instance (not singleton) methods. With no
 617  *  argument, or with an argument that is <code>false</code>, the
 618  *  instance methods in <i>mod</i> are returned, otherwise the methods
 619  *  in <i>mod</i> and <i>mod</i>'s superclasses are returned.
 620  *
 621  *     module A
 622  *       def method1()  end
 623  *     end
 624  *     class B
 625  *       def method2()  end
 626  *     end
 627  *     class C < B
 628  *       def method3()  end
 629  *     end
 630  *
 631  *     A.instance_methods                #=> [:method1]
 632  *     B.instance_methods(false)         #=> [:method2]
 633  *     C.instance_methods(false)         #=> [:method3]
 634  *     C.instance_methods(true).length   #=> 43
 635  */
 636
 637 VALUE
 638 rb_class_instance_methods(int argc, VALUE *argv, VALUE mod)
 639 {
 640     return class_instance_method_list(argc, argv, mod, ins_methods_i);
 641 }
 642
 643 /*
 644  *  call-seq:
 645  *     mod.protected_instance_methods(include_super=true)   => array
 646  *
 647  *  Returns a list of the protected instance methods defined in
 648  *  <i>mod</i>. If the optional parameter is not <code>false</code>, the
 649  *  methods of any ancestors are included.
 650  */
 651
 652 VALUE
 653 rb_class_protected_instance_methods(int argc, VALUE *argv, VALUE mod)
 654 {
 655     return class_instance_method_list(argc, argv, mod, ins_methods_prot_i);
 656 }
 657
 658 /*
 659  *  call-seq:
 660  *     mod.private_instance_methods(include_super=true)    => array
 661  *
 662  *  Returns a list of the private instance methods defined in
 663  *  <i>mod</i>. If the optional parameter is not <code>false</code>, the
 664  *  methods of any ancestors are included.
 665  *
 666  *     module Mod
 667  *       def method1()  end
 668  *       private :method1
 669  *       def method2()  end
 670  *     end
 671  *     Mod.instance_methods           #=> [:method2]
 672  *     Mod.private_instance_methods   #=> [:method1]
 673  */
 674
 675 VALUE
 676 rb_class_private_instance_methods(int argc, VALUE *argv, VALUE mod)
 677 {
 678     return class_instance_method_list(argc, argv, mod, ins_methods_priv_i);
 679 }
 680
 681 /*
 682  *  call-seq:
 683  *     mod.public_instance_methods(include_super=true)   => array
 684  *
 685  *  Returns a list of the public instance methods defined in <i>mod</i>.
 686  *  If the optional parameter is not <code>false</code>, the methods of
 687  *  any ancestors are included.
 688  */
 689
 690 VALUE
 691 rb_class_public_instance_methods(int argc, VALUE *argv, VALUE mod)
 692 {
 693     return class_instance_method_list(argc, argv, mod, ins_methods_pub_i);
 694 }
 695
 696 /*
 697  *  call-seq:
 698  *     obj.singleton_methods(all=true)    => array
 699  *
 700  *  Returns an array of the names of singleton methods for <i>obj</i>.
 701  *  If the optional <i>all</i> parameter is true, the list will include
 702  *  methods in modules included in <i>obj</i>.
 703  *
 704  *     module Other
 705  *       def three() end
 706  *     end
 707  *
 708  *     class Single
 709  *       def Single.four() end
 710  *     end
 711  *
 712  *     a = Single.new
 713  *
 714  *     def a.one()
 715  *     end
 716  *
 717  *     class << a
 718  *       include Other
 719  *       def two()
 720  *       end
 721  *     end
 722  *
 723  *     Single.singleton_methods    #=> [:four]
 724  *     a.singleton_methods(false)  #=> [:two, :one]
 725  *     a.singleton_methods         #=> [:two, :one, :three]
 726  */
 727
 728 VALUE
 729 rb_obj_singleton_methods(int argc, VALUE *argv, VALUE obj)
 730 {
 731     VALUE recur, ary, klass;
 732     st_table *list;
 733
 734     if (argc == 0) {
 735         recur = Qtrue;
 736     }
 737     else {
 738         rb_scan_args(argc, argv, "01", &recur);
 739     }
 740     klass = CLASS_OF(obj);
 741     list = st_init_numtable();
 742     if (klass && FL_TEST(klass, FL_SINGLETON)) {
 743         st_foreach(RCLASS_M_TBL(klass), method_entry, (st_data_t)list);
 744         klass = RCLASS_SUPER(klass);
 745     }
 746     if (RTEST(recur)) {
 747         while (klass && (FL_TEST(klass, FL_SINGLETON) || TYPE(klass) == T_ICLASS)) {
 748             st_foreach(RCLASS_M_TBL(klass), method_entry, (st_data_t)list);
 749             klass = RCLASS_SUPER(klass);
 750         }
 751     }
 752     ary = rb_ary_new();
 753     st_foreach(list, ins_methods_i, ary);
 754     st_free_table(list);
 755
 756     return ary;
 757 }
 758
 759 void
 760 rb_define_method_id(VALUE klass, ID name, VALUE (*func)(ANYARGS), int argc)
 761 {
 762     rb_add_method(klass, name, NEW_CFUNC(func,argc), NOEX_PUBLIC);
 763 }
 764
 765 void
 766 rb_define_method(VALUE klass, const char *name, VALUE (*func)(ANYARGS), int argc)
 767 {
 768     rb_add_method(klass, rb_intern(name), NEW_CFUNC(func, argc), NOEX_PUBLIC);
 769 }
 770
 771 void
 772 rb_define_protected_method(VALUE klass, const char *name, VALUE (*func)(ANYARGS), int argc)
 773 {
 774     rb_add_method(klass, rb_intern(name), NEW_CFUNC(func, argc), NOEX_PROTECTED);
 775 }
 776
 777 void
 778 rb_define_private_method(VALUE klass, const char *name, VALUE (*func)(ANYARGS), int argc)
 779 {
 780     rb_add_method(klass, rb_intern(name), NEW_CFUNC(func, argc), NOEX_PRIVATE);
 781 }
 782
 783 void
 784 rb_undef_method(VALUE klass, const char *name)
 785 {
 786     rb_add_method(klass, rb_intern(name), 0, NOEX_UNDEF);
 787 }
 788
 789 #define SPECIAL_SINGLETON(x,c) do {\
 790     if (obj == (x)) {\
 791         return c;\
 792     }\
 793 } while (0)
 794
 795 VALUE
 796 rb_singleton_class(VALUE obj)
 797 {
 798     VALUE klass;
 799
 800     if (FIXNUM_P(obj) || SYMBOL_P(obj)) {
 801         rb_raise(rb_eTypeError, "can't define singleton");
 802     }
 803     if (rb_special_const_p(obj)) {
 804         SPECIAL_SINGLETON(Qnil, rb_cNilClass);
 805         SPECIAL_SINGLETON(Qfalse, rb_cFalseClass);
 806         SPECIAL_SINGLETON(Qtrue, rb_cTrueClass);
 807         rb_bug("unknown immediate %ld", obj);
 808     }
 809
 810     DEFER_INTS;
 811     if (FL_TEST(RBASIC(obj)->klass, FL_SINGLETON) &&
 812         rb_iv_get(RBASIC(obj)->klass, "__attached__") == obj) {
 813         klass = RBASIC(obj)->klass;
 814     }
 815     else {
 816         klass = rb_make_metaclass(obj, RBASIC(obj)->klass);
 817     }
 818     if (OBJ_TAINTED(obj)) {
 819         OBJ_TAINT(klass);
 820     }
 821     else {
 822         FL_UNSET(klass, FL_TAINT);
 823     }
 824     if (OBJ_FROZEN(obj)) OBJ_FREEZE(klass);
 825     ALLOW_INTS;
 826
 827     return klass;
 828 }
 829
 830 void
 831 rb_define_singleton_method(VALUE obj, const char *name, VALUE (*func)(ANYARGS), int argc)
 832 {
 833     rb_define_method(rb_singleton_class(obj), name, func, argc);
 834 }
 835
 836 void
 837 rb_define_module_function(VALUE module, const char *name, VALUE (*func)(ANYARGS), int argc)
 838 {
 839     rb_define_private_method(module, name, func, argc);
 840     rb_define_singleton_method(module, name, func, argc);
 841 }
 842
 843 void
 844 rb_define_global_function(const char *name, VALUE (*func)(ANYARGS), int argc)
 845 {
 846     rb_define_module_function(rb_mKernel, name, func, argc);
 847 }
 848
 849 void
 850 rb_define_alias(VALUE klass, const char *name1, const char *name2)
 851 {
 852     rb_alias(klass, rb_intern(name1), rb_intern(name2));
 853 }
 854
 855 void
 856 rb_define_attr(VALUE klass, const char *name, int read, int write)
 857 {
 858     rb_attr(klass, rb_intern(name), read, write, Qfalse);
 859 }
 860
 861 #include <stdarg.h>
 862
 863 int
 864 rb_scan_args(int argc, const VALUE *argv, const char *fmt, ...)
 865 {
 866     int n, i = 0;
 867     const char *p = fmt;
 868     VALUE *var;
 869     va_list vargs;
 870
 871     va_start(vargs, fmt);
 872
 873     if (*p == '*') goto rest_arg;
 874
 875     if (ISDIGIT(*p)) {
 876         n = *p - '0';
 877         if (n > argc)
 878             rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, n);
 879         for (i=0; i<n; i++) {
 880             var = va_arg(vargs, VALUE*);
 881             if (var) *var = argv[i];
 882         }
 883         p++;
 884     }
 885     else {
 886         goto error;
 887     }
 888
 889     if (ISDIGIT(*p)) {
 890         n = i + *p - '0';
 891         for (; i<n; i++) {
 892             var = va_arg(vargs, VALUE*);
 893             if (argc > i) {
 894                 if (var) *var = argv[i];
 895             }
 896             else {
 897                 if (var) *var = Qnil;
 898             }
 899         }
 900         p++;
 901     }
 902
 903     if(*p == '*') {
 904       rest_arg:
 905         var = va_arg(vargs, VALUE*);
 906         if (argc > i) {
 907             if (var) *var = rb_ary_new4(argc-i, argv+i);
 908             i = argc;
 909         }
 910         else {
 911             if (var) *var = rb_ary_new();
 912         }
 913         p++;
 914     }
 915
 916     if (*p == '&') {
 917         var = va_arg(vargs, VALUE*);
 918         if (rb_block_given_p()) {
 919             *var = rb_block_proc();
 920         }
 921         else {
 922             *var = Qnil;
 923         }
 924         p++;
 925     }
 926     va_end(vargs);
 927
 928     if (*p != '\0') {
 929         goto error;
 930     }
 931
 932     if (argc > i) {
 933         rb_raise(rb_eArgError, "wrong number of arguments (%d for %d)", argc, i);
 934     }
 935
 936     return argc;
 937
 938   error:
 939     rb_fatal("bad scan arg format: %s", fmt);
 940     return 0;
 941 }