struct.c

   1 /**********************************************************************
   2
   3   struct.c -
   4
   5   $Author$
   6   created at: Tue Mar 22 18:44:30 JST 1995
   7
   8   Copyright (C) 1993-2007 Yukihiro Matsumoto
   9
  10 **********************************************************************/
  11
  12 #include "id.h"
  13 #include "internal.h"
  14 #include "internal/class.h"
  15 #include "internal/error.h"
  16 #include "internal/hash.h"
  17 #include "internal/object.h"
  18 #include "internal/proc.h"
  19 #include "internal/struct.h"
  20 #include "internal/symbol.h"
  21 #include "vm_core.h"
  22 #include "builtin.h"
  23
  24 /* only for struct[:field] access */
  25 enum {
  26     AREF_HASH_UNIT = 5,
  27     AREF_HASH_THRESHOLD = 10
  28 };
  29
  30 /* Note: Data is a stricter version of the Struct: no attr writers & no
  31    hash-alike/array-alike behavior. It shares most of the implementation
  32    on the C level, but is unrelated on the Ruby level. */
  33 VALUE rb_cStruct;
  34 static VALUE rb_cData;
  35 static ID id_members, id_back_members, id_keyword_init;
  36
  37 static VALUE struct_alloc(VALUE);
  38
  39 static inline VALUE
  40 struct_ivar_get(VALUE c, ID id)
  41 {
  42     VALUE orig = c;
  43     VALUE ivar = rb_attr_get(c, id);
  44
  45     if (!NIL_P(ivar))
  46         return ivar;
  47
  48     for (;;) {
  49         c = rb_class_superclass(c);
  50         if (c == rb_cStruct || c == rb_cData || !RTEST(c))
  51             return Qnil;
  52         RUBY_ASSERT(RB_TYPE_P(c, T_CLASS));
  53         ivar = rb_attr_get(c, id);
  54         if (!NIL_P(ivar)) {
  55             return rb_ivar_set(orig, id, ivar);
  56         }
  57     }
  58 }
  59
  60 VALUE
  61 rb_struct_s_keyword_init(VALUE klass)
  62 {
  63     return struct_ivar_get(klass, id_keyword_init);
  64 }
  65
  66 VALUE
  67 rb_struct_s_members(VALUE klass)
  68 {
  69     VALUE members = struct_ivar_get(klass, id_members);
  70
  71     if (NIL_P(members)) {
  72         rb_raise(rb_eTypeError, "uninitialized struct");
  73     }
  74     if (!RB_TYPE_P(members, T_ARRAY)) {
  75         rb_raise(rb_eTypeError, "corrupted struct");
  76     }
  77     return members;
  78 }
  79
  80 VALUE
  81 rb_struct_members(VALUE s)
  82 {
  83     VALUE members = rb_struct_s_members(rb_obj_class(s));
  84
  85     if (RSTRUCT_LEN(s) != RARRAY_LEN(members)) {
  86         rb_raise(rb_eTypeError, "struct size differs (%ld required %ld given)",
  87                  RARRAY_LEN(members), RSTRUCT_LEN(s));
  88     }
  89     return members;
  90 }
  91
  92 static long
  93 struct_member_pos_ideal(VALUE name, long mask)
  94 {
  95     /* (id & (mask/2)) * 2 */
  96     return (SYM2ID(name) >> (ID_SCOPE_SHIFT - 1)) & mask;
  97 }
  98
  99 static long
 100 struct_member_pos_probe(long prev, long mask)
 101 {
 102     /* (((prev/2) * AREF_HASH_UNIT + 1) & (mask/2)) * 2 */
 103     return (prev * AREF_HASH_UNIT + 2) & mask;
 104 }
 105
 106 static VALUE
 107 struct_set_members(VALUE klass, VALUE /* frozen hidden array */ members)
 108 {
 109     VALUE back;
 110     const long members_length = RARRAY_LEN(members);
 111
 112     if (members_length <= AREF_HASH_THRESHOLD) {
 113         back = members;
 114     }
 115     else {
 116         long i, j, mask = 64;
 117         VALUE name;
 118
 119         while (mask < members_length * AREF_HASH_UNIT) mask *= 2;
 120
 121         back = rb_ary_hidden_new(mask + 1);
 122         rb_ary_store(back, mask, INT2FIX(members_length));
 123         mask -= 2;                        /* mask = (2**k-1)*2 */
 124
 125         for (i=0; i < members_length; i++) {
 126             name = RARRAY_AREF(members, i);
 127
 128             j = struct_member_pos_ideal(name, mask);
 129
 130             for (;;) {
 131                 if (!RTEST(RARRAY_AREF(back, j))) {
 132                     rb_ary_store(back, j, name);
 133                     rb_ary_store(back, j + 1, INT2FIX(i));
 134                     break;
 135                 }
 136                 j = struct_member_pos_probe(j, mask);
 137             }
 138         }
 139         OBJ_FREEZE(back);
 140     }
 141     rb_ivar_set(klass, id_members, members);
 142     rb_ivar_set(klass, id_back_members, back);
 143
 144     return members;
 145 }
 146
 147 static inline int
 148 struct_member_pos(VALUE s, VALUE name)
 149 {
 150     VALUE back = struct_ivar_get(rb_obj_class(s), id_back_members);
 151     long j, mask;
 152
 153     if (UNLIKELY(NIL_P(back))) {
 154         rb_raise(rb_eTypeError, "uninitialized struct");
 155     }
 156     if (UNLIKELY(!RB_TYPE_P(back, T_ARRAY))) {
 157         rb_raise(rb_eTypeError, "corrupted struct");
 158     }
 159
 160     mask = RARRAY_LEN(back);
 161
 162     if (mask <= AREF_HASH_THRESHOLD) {
 163         if (UNLIKELY(RSTRUCT_LEN(s) != mask)) {
 164             rb_raise(rb_eTypeError,
 165                      "struct size differs (%ld required %ld given)",
 166                      mask, RSTRUCT_LEN(s));
 167         }
 168         for (j = 0; j < mask; j++) {
 169             if (RARRAY_AREF(back, j) == name)
 170                 return (int)j;
 171         }
 172         return -1;
 173     }
 174
 175     if (UNLIKELY(RSTRUCT_LEN(s) != FIX2INT(RARRAY_AREF(back, mask-1)))) {
 176         rb_raise(rb_eTypeError, "struct size differs (%d required %ld given)",
 177                  FIX2INT(RARRAY_AREF(back, mask-1)), RSTRUCT_LEN(s));
 178     }
 179
 180     mask -= 3;
 181     j = struct_member_pos_ideal(name, mask);
 182
 183     for (;;) {
 184         VALUE e = RARRAY_AREF(back, j);
 185         if (e == name)
 186             return FIX2INT(RARRAY_AREF(back, j + 1));
 187         if (!RTEST(e)) {
 188             return -1;
 189         }
 190         j = struct_member_pos_probe(j, mask);
 191     }
 192 }
 193
 194 /*
 195  *  call-seq:
 196  *    StructClass::members -> array_of_symbols
 197  *
 198  *  Returns the member names of the Struct descendant as an array:
 199  *
 200  *     Customer = Struct.new(:name, :address, :zip)
 201  *     Customer.members # => [:name, :address, :zip]
 202  *
 203  */
 204
 205 static VALUE
 206 rb_struct_s_members_m(VALUE klass)
 207 {
 208     VALUE members = rb_struct_s_members(klass);
 209
 210     return rb_ary_dup(members);
 211 }
 212
 213 /*
 214  *  call-seq:
 215  *    members -> array_of_symbols
 216  *
 217  *  Returns the member names from +self+ as an array:
 218  *
 219  *     Customer = Struct.new(:name, :address, :zip)
 220  *     Customer.new.members # => [:name, :address, :zip]
 221  *
 222  *  Related: #to_a.
 223  */
 224
 225 static VALUE
 226 rb_struct_members_m(VALUE obj)
 227 {
 228     return rb_struct_s_members_m(rb_obj_class(obj));
 229 }
 230
 231 VALUE
 232 rb_struct_getmember(VALUE obj, ID id)
 233 {
 234     VALUE slot = ID2SYM(id);
 235     int i = struct_member_pos(obj, slot);
 236     if (i != -1) {
 237         return RSTRUCT_GET(obj, i);
 238     }
 239     rb_name_err_raise("'%1$s' is not a struct member", obj, ID2SYM(id));
 240
 241     UNREACHABLE_RETURN(Qnil);
 242 }
 243
 244 static void
 245 rb_struct_modify(VALUE s)
 246 {
 247     rb_check_frozen(s);
 248 }
 249
 250 static VALUE
 251 anonymous_struct(VALUE klass)
 252 {
 253     VALUE nstr;
 254
 255     nstr = rb_class_new(klass);
 256     rb_make_metaclass(nstr, RBASIC(klass)->klass);
 257     rb_class_inherited(klass, nstr);
 258     return nstr;
 259 }
 260
 261 static VALUE
 262 new_struct(VALUE name, VALUE super)
 263 {
 264     /* old style: should we warn? */
 265     ID id;
 266     name = rb_str_to_str(name);
 267     if (!rb_is_const_name(name)) {
 268         rb_name_err_raise("identifier %1$s needs to be constant",
 269                           super, name);
 270     }
 271     id = rb_to_id(name);
 272     if (rb_const_defined_at(super, id)) {
 273         rb_warn("redefining constant %"PRIsVALUE"::%"PRIsVALUE, super, name);
 274         rb_mod_remove_const(super, ID2SYM(id));
 275     }
 276     return rb_define_class_id_under_no_pin(super, id, super);
 277 }
 278
 279 NORETURN(static void invalid_struct_pos(VALUE s, VALUE idx));
 280
 281 static void
 282 define_aref_method(VALUE nstr, VALUE name, VALUE off)
 283 {
 284     rb_add_method_optimized(nstr, SYM2ID(name), OPTIMIZED_METHOD_TYPE_STRUCT_AREF, FIX2UINT(off), METHOD_VISI_PUBLIC);
 285 }
 286
 287 static void
 288 define_aset_method(VALUE nstr, VALUE name, VALUE off)
 289 {
 290     rb_add_method_optimized(nstr, SYM2ID(name), OPTIMIZED_METHOD_TYPE_STRUCT_ASET, FIX2UINT(off), METHOD_VISI_PUBLIC);
 291 }
 292
 293 static VALUE
 294 rb_struct_s_inspect(VALUE klass)
 295 {
 296     VALUE inspect = rb_class_name(klass);
 297     if (RTEST(rb_struct_s_keyword_init(klass))) {
 298         rb_str_cat_cstr(inspect, "(keyword_init: true)");
 299     }
 300     return inspect;
 301 }
 302
 303 static VALUE
 304 rb_data_s_new(int argc, const VALUE *argv, VALUE klass)
 305 {
 306     if (rb_keyword_given_p()) {
 307         if (argc > 1 || !RB_TYPE_P(argv[0], T_HASH)) {
 308             rb_error_arity(argc, 0, 0);
 309         }
 310         return rb_class_new_instance_pass_kw(argc, argv, klass);
 311     }
 312     else {
 313         VALUE members = struct_ivar_get(klass, id_members);
 314         int num_members = RARRAY_LENINT(members);
 315
 316         rb_check_arity(argc, 0, num_members);
 317         VALUE arg_hash = rb_hash_new_with_size(argc);
 318         for (long i=0; i<argc; i++) {
 319             VALUE k = rb_ary_entry(members, i), v = argv[i];
 320             rb_hash_aset(arg_hash, k, v);
 321         }
 322         return rb_class_new_instance_kw(1, &arg_hash, klass, RB_PASS_KEYWORDS);
 323     }
 324 }
 325
 326 #if 0 /* for RDoc */
 327
 328 /*
 329  * call-seq:
 330  *   StructClass::keyword_init? -> true or falsy value
 331  *
 332  * Returns +true+ if the class was initialized with <tt>keyword_init: true</tt>.
 333  * Otherwise returns +nil+ or +false+.
 334  *
 335  * Examples:
 336  *   Foo = Struct.new(:a)
 337  *   Foo.keyword_init? # => nil
 338  *   Bar = Struct.new(:a, keyword_init: true)
 339  *   Bar.keyword_init? # => true
 340  *   Baz = Struct.new(:a, keyword_init: false)
 341  *   Baz.keyword_init? # => false
 342  */
 343 static VALUE
 344 rb_struct_s_keyword_init_p(VALUE obj)
 345 {
 346 }
 347 #endif
 348
 349 #define rb_struct_s_keyword_init_p rb_struct_s_keyword_init
 350
 351 static VALUE
 352 setup_struct(VALUE nstr, VALUE members)
 353 {
 354     long i, len;
 355
 356     members = struct_set_members(nstr, members);
 357
 358     rb_define_alloc_func(nstr, struct_alloc);
 359     rb_define_singleton_method(nstr, "new", rb_class_new_instance_pass_kw, -1);
 360     rb_define_singleton_method(nstr, "[]", rb_class_new_instance_pass_kw, -1);
 361     rb_define_singleton_method(nstr, "members", rb_struct_s_members_m, 0);
 362     rb_define_singleton_method(nstr, "inspect", rb_struct_s_inspect, 0);
 363     rb_define_singleton_method(nstr, "keyword_init?", rb_struct_s_keyword_init_p, 0);
 364
 365     len = RARRAY_LEN(members);
 366     for (i=0; i< len; i++) {
 367         VALUE sym = RARRAY_AREF(members, i);
 368         ID id = SYM2ID(sym);
 369         VALUE off = LONG2NUM(i);
 370
 371         define_aref_method(nstr, sym, off);
 372         define_aset_method(nstr, ID2SYM(rb_id_attrset(id)), off);
 373     }
 374
 375     return nstr;
 376 }
 377
 378 static VALUE
 379 setup_data(VALUE subclass, VALUE members)
 380 {
 381     long i, len;
 382
 383     members = struct_set_members(subclass, members);
 384
 385     rb_define_alloc_func(subclass, struct_alloc);
 386     VALUE sclass = rb_singleton_class(subclass);
 387     rb_undef_method(sclass, "define");
 388     rb_define_method(sclass, "new", rb_data_s_new, -1);
 389     rb_define_method(sclass, "[]", rb_data_s_new, -1);
 390     rb_define_method(sclass, "members", rb_struct_s_members_m, 0);
 391     rb_define_method(sclass, "inspect", rb_struct_s_inspect, 0); // FIXME: just a separate method?..
 392
 393     len = RARRAY_LEN(members);
 394     for (i=0; i< len; i++) {
 395         VALUE sym = RARRAY_AREF(members, i);
 396         VALUE off = LONG2NUM(i);
 397
 398         define_aref_method(subclass, sym, off);
 399     }
 400
 401     return subclass;
 402 }
 403
 404 VALUE
 405 rb_struct_alloc_noinit(VALUE klass)
 406 {
 407     return struct_alloc(klass);
 408 }
 409
 410 static VALUE
 411 struct_make_members_list(va_list ar)
 412 {
 413     char *mem;
 414     VALUE ary, list = rb_ident_hash_new();
 415     RBASIC_CLEAR_CLASS(list);
 416     while ((mem = va_arg(ar, char*)) != 0) {
 417         VALUE sym = rb_sym_intern_ascii_cstr(mem);
 418         if (RTEST(rb_hash_has_key(list, sym))) {
 419             rb_raise(rb_eArgError, "duplicate member: %s", mem);
 420         }
 421         rb_hash_aset(list, sym, Qtrue);
 422     }
 423     ary = rb_hash_keys(list);
 424     RBASIC_CLEAR_CLASS(ary);
 425     OBJ_FREEZE(ary);
 426     return ary;
 427 }
 428
 429 static VALUE
 430 struct_define_without_accessor(VALUE outer, const char *class_name, VALUE super, rb_alloc_func_t alloc, VALUE members)
 431 {
 432     VALUE klass;
 433
 434     if (class_name) {
 435         if (outer) {
 436             klass = rb_define_class_under(outer, class_name, super);
 437         }
 438         else {
 439             klass = rb_define_class(class_name, super);
 440         }
 441     }
 442     else {
 443         klass = anonymous_struct(super);
 444     }
 445
 446     struct_set_members(klass, members);
 447
 448     if (alloc) {
 449         rb_define_alloc_func(klass, alloc);
 450     }
 451     else {
 452         rb_define_alloc_func(klass, struct_alloc);
 453     }
 454
 455     return klass;
 456 }
 457
 458 VALUE
 459 rb_struct_define_without_accessor_under(VALUE outer, const char *class_name, VALUE super, rb_alloc_func_t alloc, ...)
 460 {
 461     va_list ar;
 462     VALUE members;
 463
 464     va_start(ar, alloc);
 465     members = struct_make_members_list(ar);
 466     va_end(ar);
 467
 468     return struct_define_without_accessor(outer, class_name, super, alloc, members);
 469 }
 470
 471 VALUE
 472 rb_struct_define_without_accessor(const char *class_name, VALUE super, rb_alloc_func_t alloc, ...)
 473 {
 474     va_list ar;
 475     VALUE members;
 476
 477     va_start(ar, alloc);
 478     members = struct_make_members_list(ar);
 479     va_end(ar);
 480
 481     return struct_define_without_accessor(0, class_name, super, alloc, members);
 482 }
 483
 484 VALUE
 485 rb_struct_define(const char *name, ...)
 486 {
 487     va_list ar;
 488     VALUE st, ary;
 489
 490     va_start(ar, name);
 491     ary = struct_make_members_list(ar);
 492     va_end(ar);
 493
 494     if (!name) {
 495         st = anonymous_struct(rb_cStruct);
 496     }
 497     else {
 498         st = new_struct(rb_str_new2(name), rb_cStruct);
 499         rb_vm_register_global_object(st);
 500     }
 501     return setup_struct(st, ary);
 502 }
 503
 504 VALUE
 505 rb_struct_define_under(VALUE outer, const char *name, ...)
 506 {
 507     va_list ar;
 508     VALUE ary;
 509
 510     va_start(ar, name);
 511     ary = struct_make_members_list(ar);
 512     va_end(ar);
 513
 514     return setup_struct(rb_define_class_id_under(outer, rb_intern(name), rb_cStruct), ary);
 515 }
 516
 517 /*
 518  *  call-seq:
 519  *    Struct.new(*member_names, keyword_init: nil){|Struct_subclass| ... } -> Struct_subclass
 520  *    Struct.new(class_name, *member_names, keyword_init: nil){|Struct_subclass| ... } -> Struct_subclass
 521  *    Struct_subclass.new(*member_names) -> Struct_subclass_instance
 522  *    Struct_subclass.new(**member_names) -> Struct_subclass_instance
 523  *
 524  *  <tt>Struct.new</tt> returns a new subclass of +Struct+.  The new subclass:
 525  *
 526  *  - May be anonymous, or may have the name given by +class_name+.
 527  *  - May have members as given by +member_names+.
 528  *  - May have initialization via ordinary arguments, or via keyword arguments
 529  *
 530  *  The new subclass has its own method <tt>::new</tt>; thus:
 531  *
 532  *    Foo = Struct.new('Foo', :foo, :bar) # => Struct::Foo
 533  *    f = Foo.new(0, 1)                   # => #<struct Struct::Foo foo=0, bar=1>
 534  *
 535  *  <b>Class Name</b>
 536  *
 537  *  With string argument +class_name+,
 538  *  returns a new subclass of +Struct+ named <tt>Struct::<em>class_name</em></tt>:
 539  *
 540  *    Foo = Struct.new('Foo', :foo, :bar) # => Struct::Foo
 541  *    Foo.name                            # => "Struct::Foo"
 542  *    Foo.superclass                      # => Struct
 543  *
 544  *  Without string argument +class_name+,
 545  *  returns a new anonymous subclass of +Struct+:
 546  *
 547  *    Struct.new(:foo, :bar).name # => nil
 548  *
 549  *  <b>Block</b>
 550  *
 551  *  With a block given, the created subclass is yielded to the block:
 552  *
 553  *    Customer = Struct.new('Customer', :name, :address) do |new_class|
 554  *      p "The new subclass is #{new_class}"
 555  *      def greeting
 556  *        "Hello #{name} at #{address}"
 557  *      end
 558  *    end           # => Struct::Customer
 559  *    dave = Customer.new('Dave', '123 Main')
 560  *    dave # =>     #<struct Struct::Customer name="Dave", address="123 Main">
 561  *    dave.greeting # => "Hello Dave at 123 Main"
 562  *
 563  *  Output, from <tt>Struct.new</tt>:
 564  *
 565  *    "The new subclass is Struct::Customer"
 566  *
 567  *  <b>Member Names</b>
 568  *
 569  *  Symbol arguments +member_names+
 570  *  determines the members of the new subclass:
 571  *
 572  *    Struct.new(:foo, :bar).members        # => [:foo, :bar]
 573  *    Struct.new('Foo', :foo, :bar).members # => [:foo, :bar]
 574  *
 575  *  The new subclass has instance methods corresponding to +member_names+:
 576  *
 577  *    Foo = Struct.new('Foo', :foo, :bar)
 578  *    Foo.instance_methods(false) # => [:foo, :bar, :foo=, :bar=]
 579  *    f = Foo.new                 # => #<struct Struct::Foo foo=nil, bar=nil>
 580  *    f.foo                       # => nil
 581  *    f.foo = 0                   # => 0
 582  *    f.bar                       # => nil
 583  *    f.bar = 1                   # => 1
 584  *    f                           # => #<struct Struct::Foo foo=0, bar=1>
 585  *
 586  *  <b>Singleton Methods</b>
 587  *
 588  *  A subclass returned by Struct.new has these singleton methods:
 589  *
 590  *  - Method <tt>::new </tt> creates an instance of the subclass:
 591  *
 592  *      Foo.new          # => #<struct Struct::Foo foo=nil, bar=nil>
 593  *      Foo.new(0)       # => #<struct Struct::Foo foo=0, bar=nil>
 594  *      Foo.new(0, 1)    # => #<struct Struct::Foo foo=0, bar=1>
 595  *      Foo.new(0, 1, 2) # Raises ArgumentError: struct size differs
 596  *
 597  *      # Initialization with keyword arguments:
 598  *      Foo.new(foo: 0)         # => #<struct Struct::Foo foo=0, bar=nil>
 599  *      Foo.new(foo: 0, bar: 1) # => #<struct Struct::Foo foo=0, bar=1>
 600  *      Foo.new(foo: 0, bar: 1, baz: 2)
 601  *      # Raises ArgumentError: unknown keywords: baz
 602  *
 603  *  - Method <tt>:inspect</tt> returns a string representation of the subclass:
 604  *
 605  *      Foo.inspect
 606  *      # => "Struct::Foo"
 607  *
 608  *  - Method <tt>::members</tt> returns an array of the member names:
 609  *
 610  *      Foo.members # => [:foo, :bar]
 611  *
 612  *  <b>Keyword Argument</b>
 613  *
 614  *  By default, the arguments for initializing an instance of the new subclass
 615  *  can be both positional and keyword arguments.
 616  *
 617  *  Optional keyword argument <tt>keyword_init:</tt> allows to force only one
 618  *  type of arguments to be accepted:
 619  *
 620  *    KeywordsOnly = Struct.new(:foo, :bar, keyword_init: true)
 621  *    KeywordsOnly.new(bar: 1, foo: 0)
 622  *    # => #<struct KeywordsOnly foo=0, bar=1>
 623  *    KeywordsOnly.new(0, 1)
 624  *    # Raises ArgumentError: wrong number of arguments
 625  *
 626  *    PositionalOnly = Struct.new(:foo, :bar, keyword_init: false)
 627  *    PositionalOnly.new(0, 1)
 628  *    # => #<struct PositionalOnly foo=0, bar=1>
 629  *    PositionalOnly.new(bar: 1, foo: 0)
 630  *    # => #<struct PositionalOnly foo={:foo=>1, :bar=>2}, bar=nil>
 631  *    # Note that no error is raised, but arguments treated as one hash value
 632  *
 633  *    # Same as not providing keyword_init:
 634  *    Any = Struct.new(:foo, :bar, keyword_init: nil)
 635  *    Any.new(foo: 1, bar: 2)
 636  *    # => #<struct Any foo=1, bar=2>
 637  *    Any.new(1, 2)
 638  *    # => #<struct Any foo=1, bar=2>
 639  */
 640
 641 static VALUE
 642 rb_struct_s_def(int argc, VALUE *argv, VALUE klass)
 643 {
 644     VALUE name = Qnil, rest, keyword_init = Qnil;
 645     long i;
 646     VALUE st;
 647     VALUE opt;
 648
 649     argc = rb_scan_args(argc, argv, "0*:", NULL, &opt);
 650     if (argc >= 1 && !SYMBOL_P(argv[0])) {
 651         name = argv[0];
 652         --argc;
 653         ++argv;
 654     }
 655
 656     if (!NIL_P(opt)) {
 657         static ID keyword_ids[1];
 658
 659         if (!keyword_ids[0]) {
 660             keyword_ids[0] = rb_intern("keyword_init");
 661         }
 662         rb_get_kwargs(opt, keyword_ids, 0, 1, &keyword_init);
 663         if (UNDEF_P(keyword_init)) {
 664             keyword_init = Qnil;
 665         }
 666         else if (RTEST(keyword_init)) {
 667             keyword_init = Qtrue;
 668         }
 669     }
 670
 671     rest = rb_ident_hash_new();
 672     RBASIC_CLEAR_CLASS(rest);
 673     for (i=0; i<argc; i++) {
 674         VALUE mem = rb_to_symbol(argv[i]);
 675         if (rb_is_attrset_sym(mem)) {
 676             rb_raise(rb_eArgError, "invalid struct member: %"PRIsVALUE, mem);
 677         }
 678         if (RTEST(rb_hash_has_key(rest, mem))) {
 679             rb_raise(rb_eArgError, "duplicate member: %"PRIsVALUE, mem);
 680         }
 681         rb_hash_aset(rest, mem, Qtrue);
 682     }
 683     rest = rb_hash_keys(rest);
 684     RBASIC_CLEAR_CLASS(rest);
 685     OBJ_FREEZE(rest);
 686     if (NIL_P(name)) {
 687         st = anonymous_struct(klass);
 688     }
 689     else {
 690         st = new_struct(name, klass);
 691     }
 692     setup_struct(st, rest);
 693     rb_ivar_set(st, id_keyword_init, keyword_init);
 694     if (rb_block_given_p()) {
 695         rb_mod_module_eval(0, 0, st);
 696     }
 697
 698     return st;
 699 }
 700
 701 static long
 702 num_members(VALUE klass)
 703 {
 704     VALUE members;
 705     members = struct_ivar_get(klass, id_members);
 706     if (!RB_TYPE_P(members, T_ARRAY)) {
 707         rb_raise(rb_eTypeError, "broken members");
 708     }
 709     return RARRAY_LEN(members);
 710 }
 711
 712 /*
 713  */
 714
 715 struct struct_hash_set_arg {
 716     VALUE self;
 717     VALUE unknown_keywords;
 718 };
 719
 720 static int rb_struct_pos(VALUE s, VALUE *name);
 721
 722 static int
 723 struct_hash_set_i(VALUE key, VALUE val, VALUE arg)
 724 {
 725     struct struct_hash_set_arg *args = (struct struct_hash_set_arg *)arg;
 726     int i = rb_struct_pos(args->self, &key);
 727     if (i < 0) {
 728         if (NIL_P(args->unknown_keywords)) {
 729             args->unknown_keywords = rb_ary_new();
 730         }
 731         rb_ary_push(args->unknown_keywords, key);
 732     }
 733     else {
 734         rb_struct_modify(args->self);
 735         RSTRUCT_SET(args->self, i, val);
 736     }
 737     return ST_CONTINUE;
 738 }
 739
 740 static VALUE
 741 rb_struct_initialize_m(int argc, const VALUE *argv, VALUE self)
 742 {
 743     VALUE klass = rb_obj_class(self);
 744     rb_struct_modify(self);
 745     long n = num_members(klass);
 746     if (argc == 0) {
 747         rb_mem_clear((VALUE *)RSTRUCT_CONST_PTR(self), n);
 748         return Qnil;
 749     }
 750
 751     bool keyword_init = false;
 752     switch (rb_struct_s_keyword_init(klass)) {
 753       default:
 754         if (argc > 1 || !RB_TYPE_P(argv[0], T_HASH)) {
 755             rb_error_arity(argc, 0, 0);
 756         }
 757         keyword_init = true;
 758         break;
 759       case Qfalse:
 760         break;
 761       case Qnil:
 762         if (argc > 1 || !RB_TYPE_P(argv[0], T_HASH)) {
 763             break;
 764         }
 765         keyword_init = rb_keyword_given_p();
 766         break;
 767     }
 768     if (keyword_init) {
 769         struct struct_hash_set_arg arg;
 770         rb_mem_clear((VALUE *)RSTRUCT_CONST_PTR(self), n);
 771         arg.self = self;
 772         arg.unknown_keywords = Qnil;
 773         rb_hash_foreach(argv[0], struct_hash_set_i, (VALUE)&arg);
 774         if (arg.unknown_keywords != Qnil) {
 775             rb_raise(rb_eArgError, "unknown keywords: %s",
 776                      RSTRING_PTR(rb_ary_join(arg.unknown_keywords, rb_str_new2(", "))));
 777         }
 778     }
 779     else {
 780         if (n < argc) {
 781             rb_raise(rb_eArgError, "struct size differs");
 782         }
 783         for (long i=0; i<argc; i++) {
 784             RSTRUCT_SET(self, i, argv[i]);
 785         }
 786         if (n > argc) {
 787             rb_mem_clear((VALUE *)RSTRUCT_CONST_PTR(self)+argc, n-argc);
 788         }
 789     }
 790     return Qnil;
 791 }
 792
 793 VALUE
 794 rb_struct_initialize(VALUE self, VALUE values)
 795 {
 796     rb_struct_initialize_m(RARRAY_LENINT(values), RARRAY_CONST_PTR(values), self);
 797     if (rb_obj_is_kind_of(self, rb_cData)) OBJ_FREEZE(self);
 798     RB_GC_GUARD(values);
 799     return Qnil;
 800 }
 801
 802 static VALUE *
 803 struct_heap_alloc(VALUE st, size_t len)
 804 {
 805     return ALLOC_N(VALUE, len);
 806 }
 807
 808 static VALUE
 809 struct_alloc(VALUE klass)
 810 {
 811     long n = num_members(klass);
 812     size_t embedded_size = offsetof(struct RStruct, as.ary) + (sizeof(VALUE) * n);
 813     VALUE flags = T_STRUCT | (RGENGC_WB_PROTECTED_STRUCT ? FL_WB_PROTECTED : 0);
 814
 815     if (n > 0 && rb_gc_size_allocatable_p(embedded_size)) {
 816         flags |= n << RSTRUCT_EMBED_LEN_SHIFT;
 817
 818         NEWOBJ_OF(st, struct RStruct, klass, flags, embedded_size, 0);
 819
 820         rb_mem_clear((VALUE *)st->as.ary, n);
 821
 822         return (VALUE)st;
 823     }
 824     else {
 825         NEWOBJ_OF(st, struct RStruct, klass, flags, sizeof(struct RStruct), 0);
 826
 827         st->as.heap.ptr = struct_heap_alloc((VALUE)st, n);
 828         rb_mem_clear((VALUE *)st->as.heap.ptr, n);
 829         st->as.heap.len = n;
 830
 831         return (VALUE)st;
 832     }
 833 }
 834
 835 VALUE
 836 rb_struct_alloc(VALUE klass, VALUE values)
 837 {
 838     return rb_class_new_instance(RARRAY_LENINT(values), RARRAY_CONST_PTR(values), klass);
 839 }
 840
 841 VALUE
 842 rb_struct_new(VALUE klass, ...)
 843 {
 844     VALUE tmpargs[16], *mem = tmpargs;
 845     int size, i;
 846     va_list args;
 847
 848     size = rb_long2int(num_members(klass));
 849     if (size > numberof(tmpargs)) {
 850         tmpargs[0] = rb_ary_hidden_new(size);
 851         mem = RARRAY_PTR(tmpargs[0]);
 852     }
 853     va_start(args, klass);
 854     for (i=0; i<size; i++) {
 855         mem[i] = va_arg(args, VALUE);
 856     }
 857     va_end(args);
 858
 859     return rb_class_new_instance(size, mem, klass);
 860 }
 861
 862 static VALUE
 863 struct_enum_size(VALUE s, VALUE args, VALUE eobj)
 864 {
 865     return rb_struct_size(s);
 866 }
 867
 868 /*
 869  *  call-seq:
 870  *    each {|value| ... } -> self
 871  *    each -> enumerator
 872  *
 873  *  Calls the given block with the value of each member; returns +self+:
 874  *
 875  *    Customer = Struct.new(:name, :address, :zip)
 876  *    joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
 877  *    joe.each {|value| p value }
 878  *
 879  *  Output:
 880  *
 881  *    "Joe Smith"
 882  *    "123 Maple, Anytown NC"
 883  *    12345
 884  *
 885  *  Returns an Enumerator if no block is given.
 886  *
 887  *  Related: #each_pair.
 888  */
 889
 890 static VALUE
 891 rb_struct_each(VALUE s)
 892 {
 893     long i;
 894
 895     RETURN_SIZED_ENUMERATOR(s, 0, 0, struct_enum_size);
 896     for (i=0; i<RSTRUCT_LEN(s); i++) {
 897         rb_yield(RSTRUCT_GET(s, i));
 898     }
 899     return s;
 900 }
 901
 902 /*
 903  *  call-seq:
 904  *    each_pair {|(name, value)| ... } -> self
 905  *    each_pair -> enumerator
 906  *
 907  *  Calls the given block with each member name/value pair; returns +self+:
 908  *
 909  *    Customer = Struct.new(:name, :address, :zip) # => Customer
 910  *    joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
 911  *    joe.each_pair {|(name, value)| p "#{name} => #{value}" }
 912  *
 913  *  Output:
 914  *
 915  *    "name => Joe Smith"
 916  *    "address => 123 Maple, Anytown NC"
 917  *    "zip => 12345"
 918  *
 919  *  Returns an Enumerator if no block is given.
 920  *
 921  *  Related: #each.
 922  *
 923  */
 924
 925 static VALUE
 926 rb_struct_each_pair(VALUE s)
 927 {
 928     VALUE members;
 929     long i;
 930
 931     RETURN_SIZED_ENUMERATOR(s, 0, 0, struct_enum_size);
 932     members = rb_struct_members(s);
 933     if (rb_block_pair_yield_optimizable()) {
 934         for (i=0; i<RSTRUCT_LEN(s); i++) {
 935             VALUE key = rb_ary_entry(members, i);
 936             VALUE value = RSTRUCT_GET(s, i);
 937             rb_yield_values(2, key, value);
 938         }
 939     }
 940     else {
 941         for (i=0; i<RSTRUCT_LEN(s); i++) {
 942             VALUE key = rb_ary_entry(members, i);
 943             VALUE value = RSTRUCT_GET(s, i);
 944             rb_yield(rb_assoc_new(key, value));
 945         }
 946     }
 947     return s;
 948 }
 949
 950 static VALUE
 951 inspect_struct(VALUE s, VALUE prefix, int recur)
 952 {
 953     VALUE cname = rb_class_path(rb_obj_class(s));
 954     VALUE members;
 955     VALUE str = prefix;
 956     long i, len;
 957     char first = RSTRING_PTR(cname)[0];
 958
 959     if (recur || first != '#') {
 960         rb_str_append(str, cname);
 961     }
 962     if (recur) {
 963         return rb_str_cat2(str, ":...>");
 964     }
 965
 966     members = rb_struct_members(s);
 967     len = RSTRUCT_LEN(s);
 968
 969     for (i=0; i<len; i++) {
 970         VALUE slot;
 971         ID id;
 972
 973         if (i > 0) {
 974             rb_str_cat2(str, ", ");
 975         }
 976         else if (first != '#') {
 977             rb_str_cat2(str, " ");
 978         }
 979         slot = RARRAY_AREF(members, i);
 980         id = SYM2ID(slot);
 981         if (rb_is_local_id(id) || rb_is_const_id(id)) {
 982             rb_str_append(str, rb_id2str(id));
 983         }
 984         else {
 985             rb_str_append(str, rb_inspect(slot));
 986         }
 987         rb_str_cat2(str, "=");
 988         rb_str_append(str, rb_inspect(RSTRUCT_GET(s, i)));
 989     }
 990     rb_str_cat2(str, ">");
 991
 992     return str;
 993 }
 994
 995 /*
 996  *  call-seq:
 997  *    inspect -> string
 998  *
 999  *  Returns a string representation of +self+:
1000  *
1001  *    Customer = Struct.new(:name, :address, :zip) # => Customer
1002  *    joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1003  *    joe.inspect # => "#<struct Customer name=\"Joe Smith\", address=\"123 Maple, Anytown NC\", zip=12345>"
1004  *
1005  */
1006
1007 static VALUE
1008 rb_struct_inspect(VALUE s)
1009 {
1010     return rb_exec_recursive(inspect_struct, s, rb_str_new2("#<struct "));
1011 }
1012
1013 /*
1014  *  call-seq:
1015  *    to_a     -> array
1016  *
1017  *  Returns the values in +self+ as an array:
1018  *
1019  *    Customer = Struct.new(:name, :address, :zip)
1020  *    joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1021  *    joe.to_a # => ["Joe Smith", "123 Maple, Anytown NC", 12345]
1022  *
1023  *  Related: #members.
1024  */
1025
1026 static VALUE
1027 rb_struct_to_a(VALUE s)
1028 {
1029     return rb_ary_new4(RSTRUCT_LEN(s), RSTRUCT_CONST_PTR(s));
1030 }
1031
1032 /*
1033  *  call-seq:
1034  *    to_h -> hash
1035  *    to_h {|name, value| ... } -> hash
1036  *
1037  *  Returns a hash containing the name and value for each member:
1038  *
1039  *    Customer = Struct.new(:name, :address, :zip)
1040  *    joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1041  *    h = joe.to_h
1042  *    h # => {:name=>"Joe Smith", :address=>"123 Maple, Anytown NC", :zip=>12345}
1043  *
1044  *  If a block is given, it is called with each name/value pair;
1045  *  the block should return a 2-element array whose elements will become
1046  *  a key/value pair in the returned hash:
1047  *
1048  *    h = joe.to_h{|name, value| [name.upcase, value.to_s.upcase]}
1049  *    h # => {:NAME=>"JOE SMITH", :ADDRESS=>"123 MAPLE, ANYTOWN NC", :ZIP=>"12345"}
1050  *
1051  *  Raises ArgumentError if the block returns an inappropriate value.
1052  *
1053  */
1054
1055 static VALUE
1056 rb_struct_to_h(VALUE s)
1057 {
1058     VALUE h = rb_hash_new_with_size(RSTRUCT_LEN(s));
1059     VALUE members = rb_struct_members(s);
1060     long i;
1061     int block_given = rb_block_given_p();
1062
1063     for (i=0; i<RSTRUCT_LEN(s); i++) {
1064         VALUE k = rb_ary_entry(members, i), v = RSTRUCT_GET(s, i);
1065         if (block_given)
1066             rb_hash_set_pair(h, rb_yield_values(2, k, v));
1067         else
1068             rb_hash_aset(h, k, v);
1069     }
1070     return h;
1071 }
1072
1073 /*
1074  *  call-seq:
1075  *    deconstruct_keys(array_of_names) -> hash
1076  *
1077  *  Returns a hash of the name/value pairs for the given member names.
1078  *
1079  *    Customer = Struct.new(:name, :address, :zip)
1080  *    joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1081  *    h = joe.deconstruct_keys([:zip, :address])
1082  *    h # => {:zip=>12345, :address=>"123 Maple, Anytown NC"}
1083  *
1084  *  Returns all names and values if +array_of_names+ is +nil+:
1085  *
1086  *    h = joe.deconstruct_keys(nil)
1087  *    h # => {:name=>"Joseph Smith, Jr.", :address=>"123 Maple, Anytown NC", :zip=>12345}
1088  *
1089  */
1090 static VALUE
1091 rb_struct_deconstruct_keys(VALUE s, VALUE keys)
1092 {
1093     VALUE h;
1094     long i;
1095
1096     if (NIL_P(keys)) {
1097         return rb_struct_to_h(s);
1098     }
1099     if (UNLIKELY(!RB_TYPE_P(keys, T_ARRAY))) {
1100         rb_raise(rb_eTypeError,
1101                  "wrong argument type %"PRIsVALUE" (expected Array or nil)",
1102                  rb_obj_class(keys));
1103
1104     }
1105     if (RSTRUCT_LEN(s) < RARRAY_LEN(keys)) {
1106         return rb_hash_new_with_size(0);
1107     }
1108     h = rb_hash_new_with_size(RARRAY_LEN(keys));
1109     for (i=0; i<RARRAY_LEN(keys); i++) {
1110         VALUE key = RARRAY_AREF(keys, i);
1111         int i = rb_struct_pos(s, &key);
1112         if (i < 0) {
1113             return h;
1114         }
1115         rb_hash_aset(h, key, RSTRUCT_GET(s, i));
1116     }
1117     return h;
1118 }
1119
1120 /* :nodoc: */
1121 VALUE
1122 rb_struct_init_copy(VALUE copy, VALUE s)
1123 {
1124     long i, len;
1125
1126     if (!OBJ_INIT_COPY(copy, s)) return copy;
1127     if (RSTRUCT_LEN(copy) != RSTRUCT_LEN(s)) {
1128         rb_raise(rb_eTypeError, "struct size mismatch");
1129     }
1130
1131     for (i=0, len=RSTRUCT_LEN(copy); i<len; i++) {
1132         RSTRUCT_SET(copy, i, RSTRUCT_GET(s, i));
1133     }
1134
1135     return copy;
1136 }
1137
1138 static int
1139 rb_struct_pos(VALUE s, VALUE *name)
1140 {
1141     long i;
1142     VALUE idx = *name;
1143
1144     if (SYMBOL_P(idx)) {
1145         return struct_member_pos(s, idx);
1146     }
1147     else if (RB_TYPE_P(idx, T_STRING)) {
1148         idx = rb_check_symbol(name);
1149         if (NIL_P(idx)) return -1;
1150         return struct_member_pos(s, idx);
1151     }
1152     else {
1153         long len;
1154         i = NUM2LONG(idx);
1155         len = RSTRUCT_LEN(s);
1156         if (i < 0) {
1157             if (i + len < 0) {
1158                 *name = LONG2FIX(i);
1159                 return -1;
1160             }
1161             i += len;
1162         }
1163         else if (len <= i) {
1164             *name = LONG2FIX(i);
1165             return -1;
1166         }
1167         return (int)i;
1168     }
1169 }
1170
1171 static void
1172 invalid_struct_pos(VALUE s, VALUE idx)
1173 {
1174     if (FIXNUM_P(idx)) {
1175         long i = FIX2INT(idx), len = RSTRUCT_LEN(s);
1176         if (i < 0) {
1177             rb_raise(rb_eIndexError, "offset %ld too small for struct(size:%ld)",
1178                      i, len);
1179         }
1180         else {
1181             rb_raise(rb_eIndexError, "offset %ld too large for struct(size:%ld)",
1182                      i, len);
1183         }
1184     }
1185     else {
1186         rb_name_err_raise("no member '%1$s' in struct", s, idx);
1187     }
1188 }
1189
1190 /*
1191  *  call-seq:
1192  *    struct[name] -> object
1193  *    struct[n] -> object
1194  *
1195  *  Returns a value from +self+.
1196  *
1197  *  With symbol or string argument +name+ given, returns the value for the named member:
1198  *
1199  *    Customer = Struct.new(:name, :address, :zip)
1200  *    joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1201  *    joe[:zip] # => 12345
1202  *
1203  *  Raises NameError if +name+ is not the name of a member.
1204  *
1205  *  With integer argument +n+ given, returns <tt>self.values[n]</tt>
1206  *  if +n+ is in range;
1207  *  see Array@Array+Indexes:
1208  *
1209  *    joe[2]  # => 12345
1210  *    joe[-2] # => "123 Maple, Anytown NC"
1211  *
1212  *  Raises IndexError if +n+ is out of range.
1213  *
1214  */
1215
1216 VALUE
1217 rb_struct_aref(VALUE s, VALUE idx)
1218 {
1219     int i = rb_struct_pos(s, &idx);
1220     if (i < 0) invalid_struct_pos(s, idx);
1221     return RSTRUCT_GET(s, i);
1222 }
1223
1224 /*
1225  *  call-seq:
1226  *    struct[name] = value -> value
1227  *    struct[n] = value -> value
1228  *
1229  *  Assigns a value to a member.
1230  *
1231  *  With symbol or string argument +name+ given, assigns the given +value+
1232  *  to the named member; returns +value+:
1233  *
1234  *    Customer = Struct.new(:name, :address, :zip)
1235  *    joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1236  *    joe[:zip] = 54321 # => 54321
1237  *    joe # => #<struct Customer name="Joe Smith", address="123 Maple, Anytown NC", zip=54321>
1238  *
1239  *  Raises NameError if +name+ is not the name of a member.
1240  *
1241  *  With integer argument +n+ given, assigns the given +value+
1242  *  to the +n+-th member if +n+ is in range;
1243  *  see Array@Array+Indexes:
1244  *
1245  *    joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1246  *    joe[2] = 54321           # => 54321
1247  *    joe[-3] = 'Joseph Smith' # => "Joseph Smith"
1248  *    joe # => #<struct Customer name="Joseph Smith", address="123 Maple, Anytown NC", zip=54321>
1249  *
1250  *  Raises IndexError if +n+ is out of range.
1251  *
1252  */
1253
1254 VALUE
1255 rb_struct_aset(VALUE s, VALUE idx, VALUE val)
1256 {
1257     int i = rb_struct_pos(s, &idx);
1258     if (i < 0) invalid_struct_pos(s, idx);
1259     rb_struct_modify(s);
1260     RSTRUCT_SET(s, i, val);
1261     return val;
1262 }
1263
1264 FUNC_MINIMIZED(VALUE rb_struct_lookup(VALUE s, VALUE idx));
1265 NOINLINE(static VALUE rb_struct_lookup_default(VALUE s, VALUE idx, VALUE notfound));
1266
1267 VALUE
1268 rb_struct_lookup(VALUE s, VALUE idx)
1269 {
1270     return rb_struct_lookup_default(s, idx, Qnil);
1271 }
1272
1273 static VALUE
1274 rb_struct_lookup_default(VALUE s, VALUE idx, VALUE notfound)
1275 {
1276     int i = rb_struct_pos(s, &idx);
1277     if (i < 0) return notfound;
1278     return RSTRUCT_GET(s, i);
1279 }
1280
1281 static VALUE
1282 struct_entry(VALUE s, long n)
1283 {
1284     return rb_struct_aref(s, LONG2NUM(n));
1285 }
1286
1287 /*
1288  *  call-seq:
1289  *    values_at(*integers) -> array
1290  *    values_at(integer_range) -> array
1291  *
1292  *  Returns an array of values from +self+.
1293  *
1294  *  With integer arguments +integers+ given,
1295  *  returns an array containing each value given by one of +integers+:
1296  *
1297  *    Customer = Struct.new(:name, :address, :zip)
1298  *    joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1299  *    joe.values_at(0, 2)    # => ["Joe Smith", 12345]
1300  *    joe.values_at(2, 0)    # => [12345, "Joe Smith"]
1301  *    joe.values_at(2, 1, 0) # => [12345, "123 Maple, Anytown NC", "Joe Smith"]
1302  *    joe.values_at(0, -3)   # => ["Joe Smith", "Joe Smith"]
1303  *
1304  *  Raises IndexError if any of +integers+ is out of range;
1305  *  see Array@Array+Indexes.
1306  *
1307  *  With integer range argument +integer_range+ given,
1308  *  returns an array containing each value given by the elements of the range;
1309  *  fills with +nil+ values for range elements larger than the structure:
1310  *
1311  *    joe.values_at(0..2)
1312  *    # => ["Joe Smith", "123 Maple, Anytown NC", 12345]
1313  *    joe.values_at(-3..-1)
1314  *    # => ["Joe Smith", "123 Maple, Anytown NC", 12345]
1315  *    joe.values_at(1..4) # => ["123 Maple, Anytown NC", 12345, nil, nil]
1316  *
1317  *  Raises RangeError if any element of the range is negative and out of range;
1318  *  see Array@Array+Indexes.
1319  *
1320  */
1321
1322 static VALUE
1323 rb_struct_values_at(int argc, VALUE *argv, VALUE s)
1324 {
1325     return rb_get_values_at(s, RSTRUCT_LEN(s), argc, argv, struct_entry);
1326 }
1327
1328 /*
1329  *  call-seq:
1330  *    select {|value| ... } -> array
1331  *    select -> enumerator
1332  *
1333  *  With a block given, returns an array of values from +self+
1334  *  for which the block returns a truthy value:
1335  *
1336  *    Customer = Struct.new(:name, :address, :zip)
1337  *    joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1338  *    a = joe.select {|value| value.is_a?(String) }
1339  *    a # => ["Joe Smith", "123 Maple, Anytown NC"]
1340  *    a = joe.select {|value| value.is_a?(Integer) }
1341  *    a # => [12345]
1342  *
1343  *  With no block given, returns an Enumerator.
1344  */
1345
1346 static VALUE
1347 rb_struct_select(int argc, VALUE *argv, VALUE s)
1348 {
1349     VALUE result;
1350     long i;
1351
1352     rb_check_arity(argc, 0, 0);
1353     RETURN_SIZED_ENUMERATOR(s, 0, 0, struct_enum_size);
1354     result = rb_ary_new();
1355     for (i = 0; i < RSTRUCT_LEN(s); i++) {
1356         if (RTEST(rb_yield(RSTRUCT_GET(s, i)))) {
1357             rb_ary_push(result, RSTRUCT_GET(s, i));
1358         }
1359     }
1360
1361     return result;
1362 }
1363
1364 static VALUE
1365 recursive_equal(VALUE s, VALUE s2, int recur)
1366 {
1367     long i, len;
1368
1369     if (recur) return Qtrue; /* Subtle! */
1370     len = RSTRUCT_LEN(s);
1371     for (i=0; i<len; i++) {
1372         if (!rb_equal(RSTRUCT_GET(s, i), RSTRUCT_GET(s2, i))) return Qfalse;
1373     }
1374     return Qtrue;
1375 }
1376
1377
1378 /*
1379  *  call-seq:
1380  *    self == other -> true or false
1381  *
1382  *  Returns  +true+ if and only if the following are true; otherwise returns +false+:
1383  *
1384  *  - <tt>other.class == self.class</tt>.
1385  *  - For each member name +name+, <tt>other.name == self.name</tt>.
1386  *
1387  *  Examples:
1388  *
1389  *    Customer = Struct.new(:name, :address, :zip)
1390  *    joe    = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1391  *    joe_jr = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1392  *    joe_jr == joe # => true
1393  *    joe_jr[:name] = 'Joe Smith, Jr.'
1394  *    # => "Joe Smith, Jr."
1395  *    joe_jr == joe # => false
1396  */
1397
1398 static VALUE
1399 rb_struct_equal(VALUE s, VALUE s2)
1400 {
1401     if (s == s2) return Qtrue;
1402     if (!RB_TYPE_P(s2, T_STRUCT)) return Qfalse;
1403     if (rb_obj_class(s) != rb_obj_class(s2)) return Qfalse;
1404     if (RSTRUCT_LEN(s) != RSTRUCT_LEN(s2)) {
1405         rb_bug("inconsistent struct"); /* should never happen */
1406     }
1407
1408     return rb_exec_recursive_paired(recursive_equal, s, s2, s2);
1409 }
1410
1411 /*
1412  *  call-seq:
1413  *    hash -> integer
1414  *
1415  *  Returns the integer hash value for +self+.
1416  *
1417  *  Two structs of the same class and with the same content
1418  *  will have the same hash code (and will compare using Struct#eql?):
1419  *
1420  *    Customer = Struct.new(:name, :address, :zip)
1421  *    joe    = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1422  *    joe_jr = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1423  *    joe.hash == joe_jr.hash # => true
1424  *    joe_jr[:name] = 'Joe Smith, Jr.'
1425  *    joe.hash == joe_jr.hash # => false
1426  *
1427  *  Related: Object#hash.
1428  */
1429
1430 static VALUE
1431 rb_struct_hash(VALUE s)
1432 {
1433     long i, len;
1434     st_index_t h;
1435     VALUE n;
1436
1437     h = rb_hash_start(rb_hash(rb_obj_class(s)));
1438     len = RSTRUCT_LEN(s);
1439     for (i = 0; i < len; i++) {
1440         n = rb_hash(RSTRUCT_GET(s, i));
1441         h = rb_hash_uint(h, NUM2LONG(n));
1442     }
1443     h = rb_hash_end(h);
1444     return ST2FIX(h);
1445 }
1446
1447 static VALUE
1448 recursive_eql(VALUE s, VALUE s2, int recur)
1449 {
1450     long i, len;
1451
1452     if (recur) return Qtrue; /* Subtle! */
1453     len = RSTRUCT_LEN(s);
1454     for (i=0; i<len; i++) {
1455         if (!rb_eql(RSTRUCT_GET(s, i), RSTRUCT_GET(s2, i))) return Qfalse;
1456     }
1457     return Qtrue;
1458 }
1459
1460 /*
1461  * call-seq:
1462  *   eql?(other) -> true or false
1463  *
1464  *  Returns +true+ if and only if the following are true; otherwise returns +false+:
1465  *
1466  *  - <tt>other.class == self.class</tt>.
1467  *  - For each member name +name+, <tt>other.name.eql?(self.name)</tt>.
1468  *
1469  *     Customer = Struct.new(:name, :address, :zip)
1470  *     joe    = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1471  *     joe_jr = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
1472  *     joe_jr.eql?(joe) # => true
1473  *     joe_jr[:name] = 'Joe Smith, Jr.'
1474  *     joe_jr.eql?(joe) # => false
1475  *
1476  *  Related: Object#==.
1477  */
1478
1479 static VALUE
1480 rb_struct_eql(VALUE s, VALUE s2)
1481 {
1482     if (s == s2) return Qtrue;
1483     if (!RB_TYPE_P(s2, T_STRUCT)) return Qfalse;
1484     if (rb_obj_class(s) != rb_obj_class(s2)) return Qfalse;
1485     if (RSTRUCT_LEN(s) != RSTRUCT_LEN(s2)) {