0
@@ -4,13 +4,14 @@
0
 namespace rubinius {
0
   class Array : public BuiltinType {
0
     public:
0
-    const static size_t fields = 4;
0
+    const static size_t fields = 5;
0
     const static object_type type = ArrayType;
0
 
0
-    INTEGER total;
0
-    Tuple* tuple;
0
-    INTEGER start;
0
-    OBJECT shared;
0
+    OBJECT __ivars__; // slot
0
+    INTEGER total; // slot
0
+    Tuple* tuple; // slot
0
+    INTEGER start; // slot
0
+    OBJECT shared; // slot
0
 
0
     size_t size() {
0
       return total->n2i();
0
@@ -23,6 +24,13 @@ namespace rubinius {
0
     OBJECT set(STATE, size_t idx, OBJECT val);
0
     OBJECT append(STATE, OBJECT val);
0
     bool   includes_p(STATE, OBJECT val);
0
+
0
+    class Info : public TypeInfo {
0
+    public:
0
+      Info(object_type type) : TypeInfo(type) { }
0
+      virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val);
0
+      virtual OBJECT get_field(STATE, OBJECT target, size_t index);
0
+    };
0
   };
0
 };
0
 

0
@@ -170,7 +170,7 @@ namespace rubinius {
0
   }
0
 
0
   void Bignum::init(STATE) {
0
-    state->add_type_info(new Bignum::Info(G(bignum)));
0
+    state->add_type_info(new Bignum::Info(Bignum::type));
0
   }
0
 
0
   Bignum* Bignum::create(STATE, native_int num) {
0
@@ -253,7 +253,6 @@ namespace rubinius {
0
 
0
   INTEGER Bignum::div(STATE, INTEGER b, INTEGER mod_obj) {
0
     NMP;
0
-    mp_int *mod = MP(mod_obj);
0
     mp_int m, x, y, z;
0
 
0
     if(kind_of<Fixnum>(b)) {
0
@@ -297,7 +296,8 @@ namespace rubinius {
0
       mp_copy(&y, &m);
0
     }
0
 
0
-    if(mod) {
0
+    if(!mod_obj->nil_p()) {
0
+      mp_int *mod = MP(mod_obj);
0
       mp_copy(&m, mod);
0
     }
0
 

0
@@ -57,7 +57,7 @@ namespace rubinius {
0
 
0
     class Info : public TypeInfo {
0
     public:
0
-      Info(Class* cls) : TypeInfo(cls) { }
0
+      Info(object_type type) : TypeInfo(type) { }
0
       virtual void cleanup(OBJECT obj);
0
     };
0
   };

0
@@ -9,6 +9,13 @@ namespace rubinius {
0
   }
0
 
0
   void Channel::send(STATE, OBJECT val) {
0
+    if(!waiting->empty_p()) {
0
+      Thread* thr = as<Thread>(waiting->shift(state));
0
+      thr->set_top(state, val);
0
+      state->queue_thread(thr);
0
+      return;
0
+    }
0
+
0
     if(value->nil_p()) {
0
       List* lst = List::create(state);
0
       lst->append(state, val);
0
@@ -33,10 +40,7 @@ namespace rubinius {
0
   }
0
 
0
   bool Channel::has_readers_p() {
0
-    return false;
0
+    return !waiting->empty_p();
0
   }
0
 
0
-  void Thread::sleep_for(STATE, Channel* chan) {
0
-
0
-  }
0
 }

0
@@ -7,16 +7,25 @@ namespace rubinius {
0
     const static size_t fields = 3;
0
     const static object_type type = ChannelType;
0
 
0
-    OBJECT value;
0
-    List* waiting;
0
+    OBJECT __ivars__; // slot
0
+    OBJECT value; // slot
0
+    List* waiting; // slot
0
 
0
     static Channel* create(STATE);
0
     void send(STATE, OBJECT);
0
     void receive(STATE);
0
     bool has_readers_p();
0
+
0
+    class Info : public TypeInfo {
0
+    public:
0
+      Info(object_type type) : TypeInfo(type) { }
0
+      virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val);
0
+      virtual OBJECT get_field(STATE, OBJECT target, size_t index);
0
+    };
0
   };
0
 
0
   class ChannelCallback : public ObjectCallback {
0
+  public:
0
     TypedRoot<Channel*> channel;
0
 
0
     ChannelCallback(STATE, Channel* chan) : ObjectCallback(state) {

0
@@ -78,14 +78,13 @@ namespace rubinius {
0
   MetaClass* MetaClass::attach(STATE, OBJECT obj, OBJECT sup) {
0
     MetaClass *meta;
0
 
0
-    meta = (MetaClass*)state->om->new_object(G(metaclass),
0
-                                             MetaClass::fields);
0
+    meta = (MetaClass*)state->new_object(G(metaclass));
0
     if(!sup) { sup = obj->klass; }
0
     meta->IsMeta = TRUE;
0
     SET(meta, attached_instance, obj);
0
     meta->setup(state);
0
     SET(meta, superclass, sup);
0
-    state->om->set_class(obj, meta);
0
+    SET(obj, klass, meta);
0
 
0
     return meta;
0
   }

0
@@ -6,16 +6,14 @@
0
 namespace rubinius {
0
   class Module : public BuiltinType {
0
     public:
0
-    const static size_t fields = 7;
0
+    const static size_t fields = 5;
0
     const static object_type type = ModuleType;
0
 
0
-    OBJECT instance_variables;
0
-    LookupTable* method_table;
0
-    OBJECT method_cache;
0
-    SYMBOL name;
0
-    LookupTable* constants;
0
-    OBJECT encloser;
0
-    Class* superclass;
0
+    OBJECT __ivars__; // slot
0
+    LookupTable* method_table; // slot
0
+    SYMBOL name; // slot
0
+    LookupTable* constants; // slot
0
+    Module* superclass; // slot
0
 
0
     static Module* create(STATE);
0
     void setup(STATE);
0
@@ -28,23 +26,37 @@ namespace rubinius {
0
     OBJECT get_const(STATE, char* sym);
0
 
0
     void set_name(STATE, Module* under, SYMBOL name);
0
+
0
+    class Info : public TypeInfo {
0
+    public:
0
+      Info(object_type type) : TypeInfo(type) { }
0
+      virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val);
0
+      virtual OBJECT get_field(STATE, OBJECT target, size_t index);
0
+    };
0
   };
0
 
0
   class Class : public Module {
0
     public:
0
-    const static size_t fields = 11;
0
+    const static size_t fields = 9;
0
     const static object_type type = ClassType;
0
 
0
-    FIXNUM instance_fields;
0
-    OBJECT has_ivars;
0
-    OBJECT needs_cleanup;
0
-    FIXNUM instance_type;
0
+    FIXNUM instance_fields; // slot
0
+    OBJECT has_ivars; // slot
0
+    OBJECT needs_cleanup; // slot
0
+    FIXNUM instance_type; // slot
0
 
0
     void set_object_type(size_t type) {
0
       instance_type = Object::i2n(type);
0
     }
0
 
0
     static Class* create(STATE, Class* super);
0
+
0
+    class Info : public TypeInfo {
0
+    public:
0
+      Info(object_type type) : TypeInfo(type) { }
0
+      virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val);
0
+      virtual OBJECT get_field(STATE, OBJECT target, size_t index);
0
+    };
0
   };
0
 
0
   /* See t1 */
0
@@ -57,22 +69,34 @@ namespace rubinius {
0
 
0
   class MetaClass : public Class {
0
     public:
0
-    const static size_t fields = 12;
0
+    const static size_t fields = 10;
0
     const static object_type type = MetaclassType;
0
 
0
-    OBJECT attached_instance;
0
-
0
-    static bool is_a(OBJECT obj) {
0
-      return obj->obj_type == MetaclassType;
0
-    }
0
+    OBJECT attached_instance; // slot
0
 
0
     static MetaClass* attach(STATE, OBJECT obj, OBJECT sup = NULL);
0
+
0
+    class Info : public TypeInfo {
0
+    public:
0
+      Info(object_type type) : TypeInfo(type) { }
0
+      virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val);
0
+      virtual OBJECT get_field(STATE, OBJECT target, size_t index);
0
+    };
0
   };
0
 
0
   class IncludedModule : public Module {
0
     public:
0
+    const static size_t field = 6;
0
+    const static object_type type = IncModType;
0
 
0
-    OBJECT module;
0
+    OBJECT module; // slot
0
+
0
+    class Info : public TypeInfo {
0
+    public:
0
+      Info(object_type type) : TypeInfo(type) { }
0
+      virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val);
0
+      virtual OBJECT get_field(STATE, OBJECT target, size_t index);
0
+    };
0
   };
0
 
0
 };

0
@@ -1,5 +1,6 @@
0
 #include "builtin.hpp"
0
 #include "ffi.hpp"
0
+#include "marshal.hpp"
0
 
0
 namespace rubinius {
0
   CompiledMethod* CompiledMethod::create(STATE) {
0
@@ -7,8 +8,8 @@ namespace rubinius {
0
     return cm;
0
   }
0
 
0
-  CompiledMethod::Visibility* CompiledMethod::Visibility::create(STATE) {
0
-    return (CompiledMethod::Visibility*)state->new_object(G(cmethod_vis));
0
+  MethodVisibility* MethodVisibility::create(STATE) {
0
+    return (MethodVisibility*)state->new_object(G(cmethod_vis));
0
   }
0
 
0
   void CompiledMethod::post_marshal(STATE) {

0
@@ -13,6 +13,9 @@ namespace rubinius {
0
 
0
   }
0
 
0
+  void MethodContext::Info::mark(MethodContext* obj) {
0
+  }
0
+
0
   BlockContext* BlockContext::create(STATE) {
0
     return (BlockContext*)state->new_struct(G(blokctx), sizeof(BlockContext));
0
   }
0
@@ -21,13 +24,17 @@ namespace rubinius {
0
 
0
   }
0
 
0
+  void BlockEnvironment::call(STATE, Message& msg) {
0
+
0
+  }
0
+
0
   BlockContext* BlockEnvironment::create_context(STATE) {
0
     BlockContext* ctx = BlockContext::create(state);
0
     SET(ctx, sender, (MethodContext*)Qnil);
0
     SET(ctx, name, (SYMBOL)this);
0
     SET(ctx, cm, method);
0
     SET(ctx, stack, Tuple::create(state, method->stack_size->to_nint()));
0
-    
0
+
0
     ctx->vmm = method->vmmethod(state);
0
     ctx->ip = 0;
0
     ctx->sp = method->number_of_locals() - 1;
0
@@ -37,9 +44,9 @@ namespace rubinius {
0
 
0
   BlockEnvironment* BlockEnvironment::under_context(STATE, CompiledMethod* cm,
0
       MethodContext* parent, MethodContext* active) {
0
-    
0
+
0
     BlockEnvironment* be = (BlockEnvironment*)state->new_object(G(blokenv));
0
-    
0
+
0
     parent->reference(state);
0
     active->reference(state);
0
 

0
@@ -27,7 +27,7 @@ namespace rubinius {
0
     int    sp;
0
     size_t args;
0
     OBJECT block;
0
-    SYMBOL name;
0
+    OBJECT name;
0
     bool   no_value;
0
 
0
     /* Locals are stored at the top of the stack. */
0
@@ -37,6 +37,8 @@ namespace rubinius {
0
     void reference(STATE);
0
 
0
     class Info : public TypeInfo {
0
+    public:
0
+      Info(object_type type) : TypeInfo(type) { }
0
       virtual void mark(MethodContext* obj);
0
     };
0
   };
0
@@ -52,9 +54,18 @@ namespace rubinius {
0
 
0
     static BlockContext* create(STATE);
0
 
0
-    class Info : public MethodContext::Info { };
0
+    class Info : public MethodContext::Info {
0
+    public:
0
+      Info(object_type type) : MethodContext::Info(type) { }
0
+    };
0
   };
0
 
0
+  template <>
0
+    static bool kind_of<MethodContext>(OBJECT obj) {
0
+      return obj->obj_type == MethodContext::type ||
0
+        obj->obj_type == BlockContext::type;
0
+    }
0
+
0
 }
0
 
0
 #endif

0
@@ -11,6 +11,17 @@ namespace rubinius {
0
     return flt;
0
   }
0
 
0
+  OBJECT Float::compare(STATE, Float* other) {
0
+    double b = other->to_double();
0
+    if(val < b) {
0
+      return Object::i2n(-1);
0
+    } else if(val > b) {
0
+      return Object::i2n(1);
0
+    } else {
0
+      return Object::i2n(0);
0
+    }
0
+  }
0
+
0
   Float* Float::coerce(STATE, OBJECT value) {
0
     if(value->fixnum_p()) {
0
       return Float::create(state, (double)(as<Fixnum>(value)->to_nint()));

0
@@ -17,13 +17,15 @@ namespace rubinius {
0
     static bool is_a(OBJECT obj) {
0
       return obj->obj_type == FloatType;
0
     }
0
-    
0
+
0
     double val;
0
 
0
     static Float* create(STATE, double val);
0
     static Float* coerce(STATE, OBJECT value);
0
     double to_double(STATE) { return val; }
0
+    double to_double() { return val; }
0
     void into_string(STATE, char* buf, size_t sz);
0
+    OBJECT compare(STATE, Float* other);
0
 
0
     static int radix()      { return FLT_RADIX; }
0
     static int rounds()     { return FLT_ROUNDS; }
0
@@ -36,6 +38,11 @@ namespace rubinius {
0
     static int dig()        { return DBL_DIG; }
0
     static int mant_dig()   { return DBL_MANT_DIG; }
0
     static double epsilon() { return DBL_EPSILON; }
0
+
0
+    class Info : public TypeInfo {
0
+    public:
0
+      Info(object_type type) : TypeInfo(type) { }
0
+    };
0
   };
0
 }
0
 

0
@@ -1,8 +1,6 @@
0
 #include "builtin.hpp"
0
 
0
-#define MAX_DENSITY 0.75
0
 #define find_bin(hash, total) (hash & (total - 1))
0
-#define hash_redistribute_p(hash) (hash->entries->n2i() >= MAX_DENSITY * hash->bins->n2i())
0
 
0
 #define CSM_SIZE 12
0
 namespace rubinius {
0
@@ -26,8 +24,8 @@ namespace rubinius {
0
   Hash* Hash::dup(STATE) {
0
     size_t size, i;
0
     Hash *dup;
0
-    OBJECT tmp, ent, next;
0
-    Tuple *vals, *lst;
0
+    OBJECT tmp;
0
+    Tuple *vals, *lst, *ent, *next;
0
 
0
     size = bins->n2i();
0
     dup = Hash::create(state, size);
0
@@ -42,26 +40,26 @@ namespace rubinius {
0
     SET(dup, values, vals);
0
 
0
     for(i = 0; i < size; i++) {
0
-      tmp = (Tuple*)values->at(i);
0
-      if(tmp->nil_p()) continue;
0
+      tmp = try_as<Tuple>(values->at(i));
0
+      if(!tmp) continue;
0
 
0
-      ent = tmp->dup(state);
0
+      ent = as<Tuple>(tmp->dup(state));
0
       vals->put(state, i, ent);
0
-      next = ent->at(3);
0
-      lst = (Tuple*)ent;
0
+      next = try_as<Tuple>(ent->at(3));
0
+      lst = ent;
0
 
0
-      while(!next->nil_p()) {
0
-        next = next->dup(state);
0
+      while(next) {
0
+        next = as<Tuple>(next->dup(state));
0
         lst->put(state, 3, next);
0
-        lst = (Tuple*)next;
0
-        next = next->at(3);
0
+        lst = next;
0
+        next = try_as<Tuple>(next->at(3));
0
       }
0
     }
0
 
0
     return dup;
0
   }
0
 
0
-  OBJECT Hash::entry_new(STATE, hashval hsh, OBJECT key, OBJECT data) {
0
+  Tuple* Hash::entry_new(STATE, hashval hsh, OBJECT key, OBJECT data) {
0
     Tuple* tup = Tuple::create(state, 4);
0
     tup->put(state, 0, Object::i2n(hsh));
0
     tup->put(state, 1, key);
0
@@ -70,14 +68,14 @@ namespace rubinius {
0
     return tup;
0
   }
0
 
0
-  OBJECT Hash::entry_append(STATE, OBJECT top, OBJECT nxt) {
0
+  Tuple* Hash::entry_append(STATE, Tuple* top, Tuple* nxt) {
0
     int depth = 1;
0
-    Tuple* cur = (Tuple*)top->at(3);
0
-    Tuple* last = (Tuple*)top;
0
+    Tuple* cur = try_as<Tuple>(top->at(3));
0
+    Tuple* last = top;
0
 
0
-    while(!cur->nil_p()) {
0
+    while(cur) {
0
       last = cur;
0
-      cur = (Tuple*)cur->at(3);
0
+      cur = try_as<Tuple>(cur->at(3));
0
       depth++;
0
     }
0
 
0
@@ -85,17 +83,13 @@ namespace rubinius {
0
     return nxt;
0
   }
0
 
0
-  OBJECT Hash::add_entry(STATE, hashval hsh, OBJECT ent) {
0
-    OBJECT entry;
0
-
0
+  OBJECT Hash::add_entry(STATE, hashval hsh, Tuple* ent) {
0
     size_t bin = find_bin(hsh, bins->n2i());
0
 
0
-    entry = values->at(bin);
0
-
0
-    if(entry->nil_p()) {
0
-      values->put(state, bin, ent);
0
-    } else {
0
+    if(Tuple* entry = try_as<Tuple>(values->at(bin))) {
0
       entry_append(state, entry, ent);
0
+    } else {
0
+      values->put(state, bin, ent);
0
     }
0
 
0
     entries = Object::i2n(entries->n2i() + 1);
0
@@ -112,20 +106,18 @@ namespace rubinius {
0
     Tuple* new_values = Tuple::create(state, size);
0
 
0
     for(size_t i = 0; i < num; i++) {
0
-      Tuple* entry = (Tuple*)values->at(i);
0
+      Tuple* entry = try_as<Tuple>(values->at(i));
0
 
0
-      while(!entry->nil_p()) {
0
-        Tuple* next = (Tuple*)entry->at(3);
0
+      while(entry) {
0
+        Tuple* next = try_as<Tuple>(entry->at(3));
0
         entry->put(state, 3, Qnil);
0
 
0
         native_int hash = as<Integer>(entry->at(0))->n2i();
0
         size_t bin = find_bin(hash, size);
0
-        OBJECT slot = new_values->at(bin);
0
-
0
-        if(slot->nil_p()) {
0
-          new_values->put(state, bin, entry);
0
-        } else {
0
+        if(Tuple* slot = try_as<Tuple>(new_values->at(bin))) {
0
           entry_append(state, slot, entry);
0
+        } else {
0
+          new_values->put(state, bin, entry);
0
         }
0
 
0
         entry = next;
0
@@ -136,25 +128,29 @@ namespace rubinius {
0
     bins = Object::i2n(size);
0
   }
0
 
0
-  OBJECT Hash::find_entry(STATE, hashval hsh) {
0
+  /* Find the entry that has a hash value of +hsh+. Return NULL if nothing
0
+   * found. */
0
+  Tuple* Hash::find_entry(STATE, hashval hsh) {
0
     size_t num = bins->n2i();
0
     size_t bin = find_bin(hsh, num);
0
-    OBJECT entry = values->at(bin);
0
+    Tuple* entry = try_as<Tuple>(values->at(bin));
0
+    if(!entry) return NULL;
0
 
0
-    while(!entry->nil_p()) {
0
+    for(;;) {
0
       INTEGER th = as<Integer>(entry->at(0));
0
       if((hashval)th->n2i() == hsh) {
0
         return entry;
0
       }
0
-      entry = entry->at(3);
0
+
0
+      if((entry = try_as<Tuple>(entry->at(3))) == NULL) return NULL;
0
     }
0
-    return Qnil;
0
+    return NULL;
0
   }
0
 
0
   OBJECT Hash::add(STATE, hashval hsh, OBJECT key, OBJECT data) {
0
-    Tuple* entry = (Tuple*)find_entry(state, hsh);
0
+    Tuple* entry = find_entry(state, hsh);
0
 
0
-    if(!entry->nil_p()) {
0
+    if(entry) {
0
       entry->put(state, 2, data);
0
       return data;
0
     }
0
@@ -171,8 +167,8 @@ namespace rubinius {
0
   }
0
 
0
   OBJECT Hash::get(STATE, hashval hsh) {
0
-    OBJECT entry = find_entry(state, hsh);
0
-    if(!entry->nil_p()) {
0
+    Tuple* entry = find_entry(state, hsh);
0
+    if(entry) {
0
       return entry->at(2);
0
     }
0
 
0
@@ -183,20 +179,20 @@ namespace rubinius {
0
    * Uses +==+ to verify the key in the table matches +key+.
0
    * Return TRUE if key was found, and *value will be filled. */
0
   int Hash::lookup(STATE, OBJECT key, hashval hash, OBJECT *value) {
0
-    OBJECT ent, hk;
0
+    OBJECT hk;
0
 
0
-    ent = find_entry(state, hash);
0
-    if(ent->reference_p()) {
0
-      while((hashval)as<Integer>(ent->at(0))->n2i() == hash) {
0
-        hk = ent->at(1);
0
-        if(hk == key) {
0
-          *value = ent->at(2);
0
-          return TRUE;
0
-        }
0
+    Tuple* ent = find_entry(state, hash);
0
+    if(!ent) return FALSE;
0
 
0
-        ent = ent->at(3);
0
-        if(ent->nil_p()) break;
0
+    while((hashval)as<Integer>(ent->at(0))->n2i() == hash) {
0
+      hk = ent->at(1);
0
+      if(hk == key) {
0
+        *value = ent->at(2);
0
+        return TRUE;
0
       }
0
+
0
+      ent = try_as<Tuple>(ent->at(3));
0
+      if(!ent) break;
0
     }
0
 
0
     return FALSE;
0
@@ -207,20 +203,20 @@ namespace rubinius {
0
    * Return TRUE if key was found, and *value will be filled. */
0
   int Hash::lookup2(STATE, int (*compare)(STATE, OBJECT, OBJECT),
0
       OBJECT key, hashval hash, OBJECT *value) {
0
-    OBJECT ent, hk;
0
+    OBJECT hk;
0
 
0
-    ent = find_entry(state, hash);
0
-    if(ent->reference_p()) {
0
-      while((hashval)as<Integer>(ent->at(0))->n2i() == hash) {
0
-        hk = ent->at(1);
0
-        if(compare(state, hk, key)) {
0
-          *value = ent->at(2);
0
-          return TRUE;
0
-        }
0
+    Tuple* ent = find_entry(state, hash);
0
+    if(!ent) return FALSE;
0
 
0
-        ent = ent->at(3);
0
-        if(ent->nil_p()) break;
0
+    while((hashval)as<Integer>(ent->at(0))->n2i() == hash) {
0
+      hk = ent->at(1);
0
+      if(compare(state, hk, key)) {
0
+        *value = ent->at(2);
0
+        return TRUE;
0
       }
0
+
0
+      ent = try_as<Tuple>(ent->at(3));
0
+      if(!ent) break;
0
     }
0
 
0
     return FALSE;
0
@@ -232,8 +228,8 @@ namespace rubinius {
0
     Tuple* ent;
0
     Tuple* base;
0
 
0
-    base = ent = (Tuple*)find_entry(state, hash);
0
-    if(ent->reference_p()) {
0
+    base = ent = find_entry(state, hash);
0
+    if(ent) {
0
       while((hashval)as<Integer>(ent->at(0))->n2i() == hash) {
0
         hk = ent->at(1);
0
         if(compare(state, hk, key)) {
0
@@ -241,8 +237,8 @@ namespace rubinius {
0
           return;
0
         }
0
 
0
-        ent = (Tuple*)ent->at(3);
0
-        if(ent->nil_p()) break;
0
+        ent = try_as<Tuple>(ent->at(3));
0
+        if(!ent) break;
0
       }
0
 
0
     }
0
@@ -251,14 +247,14 @@ namespace rubinius {
0
       redistribute(state);
0
     }
0
 
0
-    if(base->reference_p()) {
0
-      ent = (Tuple*)entry_new(state, hash, key, value);
0
+    if(base) {
0
+      ent = entry_new(state, hash, key, value);
0
       entry_append(state, base, ent);
0
       entries = Object::i2n(entries->n2i() + 1);
0
       return;
0
     }
0
 
0
-    ent = (Tuple*)entry_new(state, hash, key, value);
0
+    ent = entry_new(state, hash, key, value);
0
     add_entry(state, hash, ent);
0
   }
0
 
0
@@ -268,10 +264,8 @@ namespace rubinius {
0
    */
0
 
0
   OBJECT Hash::get_undef(STATE, hashval hsh) {
0
-    OBJECT entry;
0
-
0
-    entry = find_entry(state, hsh);
0
-    if(RTEST(entry)) {
0
+    Tuple* entry = find_entry(state, hsh);
0
+    if(entry) {
0
       return entry->at(2);
0
     } else {
0
       return Qundef;
0
@@ -313,7 +307,7 @@ namespace rubinius {
0
     return Qnil;
0
   }
0
 
0
-  Hash* Hash::from_tuple(STATE, OBJECT tup) {
0
+  Hash* Hash::from_tuple(STATE, Tuple* tup) {
0
     OBJECT key, val;
0
     int i, fel;
0
 

0
@@ -11,22 +11,22 @@ namespace rubinius {
0
     const static size_t fields = 7;
0
     const static object_type type = HashType;
0
 
0
-    OBJECT instance_variables;
0
-    OBJECT keys;
0
-    Tuple* values;
0
-    FIXNUM bins;
0
-    FIXNUM entries;
0
-    OBJECT default_value;
0
-    OBJECT default_proc;
0
+    OBJECT __ivars__; // slot
0
+    OBJECT keys; // slot
0
+    Tuple* values; // slot
0
+    FIXNUM bins; // slot
0
+    FIXNUM entries; // slot
0
+    OBJECT default_value; // slot
0
+    OBJECT default_proc; // slot
0
 
0
     static Hash* create(STATE, size_t size = HASH_MINSIZE);
0
     void   setup(STATE, size_t size);
0
     Hash*  dup(STATE);
0
-    static OBJECT entry_new(STATE, hashval hsh, OBJECT key, OBJECT data);
0
-    static OBJECT entry_append(STATE, OBJECT top, OBJECT nxt);
0
-    OBJECT add_entry(STATE, hashval hsh, OBJECT ent);
0
+    static Tuple* entry_new(STATE, hashval hsh, OBJECT key, OBJECT data);
0
+    static Tuple* entry_append(STATE, Tuple* top, Tuple* nxt);
0
+    OBJECT add_entry(STATE, hashval hsh, Tuple* ent);
0
     void   redistribute(STATE);
0
-    OBJECT find_entry(STATE, hashval hsh);
0
+    Tuple* find_entry(STATE, hashval hsh);
0
     OBJECT add(STATE, hashval hsh, OBJECT key, OBJECT data);
0
     OBJECT set(STATE, OBJECT key, OBJECT val);
0
     OBJECT get(STATE, hashval hsh);
0
@@ -38,14 +38,24 @@ namespace rubinius {
0
     OBJECT get_undef(STATE, hashval hsh);
0
     OBJECT remove(STATE, hashval hsh);
0
 
0
-    static Hash*  from_tuple(STATE, OBJECT tup);
0
+    static Hash*  from_tuple(STATE, Tuple* tup);
0
     static Tuple* csm_new(STATE);
0
     static OBJECT csm_find(STATE, Tuple* csm, OBJECT key);
0
     static OBJECT csm_add(STATE, Tuple* csm, OBJECT key, OBJECT val);
0
     static Hash*  csm_into_hash(STATE, Tuple* csm);
0
     static LookupTable* csm_into_lookuptable(STATE, Tuple* csm);
0
 
0
+    class Info : public TypeInfo {
0
+    public:
0
+      Info(object_type type) : TypeInfo(type) { }
0
+      virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val);
0
+      virtual OBJECT get_field(STATE, OBJECT target, size_t index);
0
+    };
0
+
0
   };
0
+
0
+#define HASH_MAX_DENSITY 0.75
0
+#define hash_redistribute_p(hash) (hash->entries->n2i() >= HASH_MAX_DENSITY * hash->bins->n2i())
0
 };
0
 
0
 #endif

0
@@ -6,11 +6,11 @@
0
 
0
 namespace rubinius {
0
   void IO::init(STATE) {
0
-    GO(iobuffer).set(state->new_class("Buffer", G(object), IO::Buffer::fields, G(io)));
0
+    GO(iobuffer).set(state->new_class("Buffer", G(object), IOBuffer::fields, G(io)));
0
   }
0
 
0
-  IO::Buffer* IO::Buffer::create(STATE, size_t bytes) {
0
-    IO::Buffer* buf = (IO::Buffer*)state->new_object(G(iobuffer));
0
+  IOBuffer* IOBuffer::create(STATE, size_t bytes) {
0
+    IOBuffer* buf = (IOBuffer*)state->new_object(G(iobuffer));
0
     SET(buf, storage, ByteArray::create(state, bytes));
0
     SET(buf, total, Object::i2n(bytes));
0
     SET(buf, used, Object::i2n(0));
0
@@ -23,4 +23,9 @@ namespace rubinius {
0
     SET(io, descriptor, Object::i2n(state, fd));
0
     return io;
0
   }
0
+
0
+  void IO::initialize(STATE, int fd, char* mode) {
0
+    SET(this, descriptor, Object::i2n(state, fd));
0
+    SET(this, mode, String::create(state, mode));
0
+  }
0
 };

0
@@ -1,13 +1,13 @@
0
 #include "builtin.hpp"
0
 
0
 namespace rubinius {
0
-  ISeq* ISeq::create(STATE, size_t instructions) {
0
-    ISeq* is = (ISeq*)state->new_object(G(iseq));
0
-    is->instructions = Tuple::create(state, instructions);
0
+  InstructionSequence* InstructionSequence::create(STATE, size_t instructions) {
0
+    InstructionSequence* is = (InstructionSequence*)state->new_object(G(iseq));
0
+    is->opcodes = Tuple::create(state, instructions);
0
     return is;
0
   }
0
 
0
-  void ISeq::post_marshal(STATE) {
0
+  void InstructionSequence::post_marshal(STATE) {
0
 
0
   }
0
 

0
@@ -4,16 +4,24 @@
0
 #include "objects.hpp"
0
 
0
 namespace rubinius {
0
-  class ISeq : public BuiltinType {
0
+  class InstructionSequence : public BuiltinType {
0
   public:
0
-    const static size_t fields = 2;
0
+    const static size_t fields = 3;
0
     const static object_type type = ISeqType;
0
 
0
-    OBJECT instance_variables;
0
-    Tuple* instructions;
0
+    OBJECT __ivars__; // slot
0
+    Tuple* opcodes; // slot
0
+    FIXNUM stack_depth; // slot
0
 
0
     void post_marshal(STATE);
0
-    static ISeq* create(STATE, size_t instructions);
0
+    static InstructionSequence* create(STATE, size_t instructions);
0
+
0
+    class Info : public TypeInfo {
0
+    public:
0
+      Info(object_type type) : TypeInfo(type) { }
0
+      virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val);
0
+      virtual OBJECT get_field(STATE, OBJECT target, size_t index);
0
+    };
0
 
0
 #include "gen/iseq_instruction_names.hpp"
0
   };

0
@@ -10,22 +10,24 @@ namespace rubinius {
0
     cls->set_object_type(ListType);
0
 
0
     GO(list_node).set(state->new_class("Node", G(object),
0
-                                                List::Node::fields, cls));
0
+                                                ListNode::fields, cls));
0
+
0
+    G(list_node)->set_object_type(ListNodeType);
0
   }
0
 
0
   /* Create a new List object, containing no elements. */
0
   List* List::create(STATE) {
0
     List* list = (List*)state->new_object(G(list));
0
-    list->count = Object::i2n(0);
0
+    SET(list, count, Object::i2n(0));
0
 
0
     return list;
0
   }
0
 
0
   /* Append +obj+ to the current List. */
0
   void List::append(STATE, OBJECT obj) {
0
-    List::Node* node = (List::Node*)state->new_object(G(list_node));
0
+    ListNode* node = (ListNode*)state->new_object(G(list_node));
0
     SET(node, object, obj);
0
-    List::Node* cur_last = last;
0
+    ListNode* cur_last = last;
0
 
0
     if(!cur_last->nil_p()) {
0
       SET(cur_last, next, node);
0
@@ -37,12 +39,12 @@ namespace rubinius {
0
       SET(this, first, node);
0
     }
0
 
0
-    count = Object::i2n(state, count->n2i() + 1);
0
+    SET(this, count, Object::i2n(state, count->n2i() + 1));
0
   }
0
 
0
   /* Return the +index+ numbered element from the beginning. */
0
   OBJECT List::locate(STATE, size_t index) {
0
-    Node* cur = first;
0
+    ListNode* cur = first;
0
 
0
     while(index > 0) {
0
       if(cur->nil_p()) return Qnil;
0
@@ -60,12 +62,12 @@ namespace rubinius {
0
   OBJECT List::shift(STATE) {
0
     if(empty_p()) return Qnil;
0
 
0
-    count = Object::i2n(state, count->n2i() - 1);
0
-    List::Node* n = first;
0
+    SET(this, count, Object::i2n(state, count->n2i() - 1));
0
+    ListNode* n = first;
0
     SET(this, first, first->next);
0
 
0
     if(last == n) {
0
-      last = (Node*)Qnil;
0
+      SET(this, last, Qnil);
0
     }
0
 
0
     return n->object;
0
@@ -79,9 +81,9 @@ namespace rubinius {
0
 
0
     size_t deleted = 0, counted = 0;
0
 
0
-    Node* node = first;
0
-    Node* lst =  (Node*)Qnil;
0
-    Node* nxt =  (Node*)Qnil;
0
+    ListNode* node = first;
0
+    ListNode* lst =  (ListNode*)Qnil;
0
+    ListNode* nxt =  (ListNode*)Qnil;
0
 
0
     while(!node->nil_p()) {
0
       nxt = node->next;
0
@@ -98,7 +100,7 @@ namespace rubinius {
0
           SET(this, last, lst);
0
         }
0
 
0
-        lst = (Node*)Qnil;
0
+        lst = (ListNode*)Qnil;
0
       } else {
0
         counted++;
0
         lst = node;
0
@@ -107,7 +109,7 @@ namespace rubinius {
0
       node = nxt;
0
     }
0
 
0
-    count = Object::i2n(state, counted);
0
+    SET(this, count, Object::i2n(state, counted));
0
 
0
     return deleted;
0
   }

0
@@ -5,24 +5,34 @@
0
 
0
 namespace rubinius {
0
 
0
-  class List : public BuiltinType {
0
-    public:
0
+  class ListNode : public BuiltinType {
0
+  public:
0
 
0
-    class Node : public BuiltinType {
0
-      public:
0
+    const static size_t fields = 2;
0
+    const static object_type type = ListNodeType;
0
 
0
-      const static size_t fields = 2;
0
+    OBJECT object; // slot
0
+    ListNode* next; // slot
0
 
0
-      OBJECT object;
0
-      Node* next;
0
+    class Info : public TypeInfo {
0
+    public:
0
+      Info(object_type type) : TypeInfo(type) { }
0
+      virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val);
0
+      virtual OBJECT get_field(STATE, OBJECT target, size_t index);
0
     };
0
-      
0
-    const static size_t fields = 3;
0
+
0
+  };
0
+
0
+  class List : public BuiltinType {
0
+  public:
0
+
0
+    const static size_t fields = 4;
0
     const static object_type type = ListType;
0
 
0
-    INTEGER count;
0
-    Node* first;
0
-    Node* last;
0
+    OBJECT __ivars__; // slot
0
+    INTEGER count; // slot
0
+    ListNode* first; // slot
0
+    ListNode* last; // slot
0
 
0
     /* Returns true if the List is empty, contains no elements. */
0
     bool empty_p() {
0
@@ -40,6 +50,14 @@ namespace rubinius {
0
     OBJECT shift(STATE);
0
     OBJECT locate(STATE, size_t index);
0
     size_t remove(STATE, OBJECT obj);
0
+
0
+    class Info : public TypeInfo {
0
+    public:
0
+      Info(object_type type) : TypeInfo(type) { }
0
+      virtual void set_field(STATE, OBJECT target, size_t index, OBJECT val);
0
+      virtual OBJECT get_field(STATE, OBJECT target, size_t index);
0
+    };
0
+
0
   };
0
 
0
 };

0
@@ -52,9 +52,9 @@ namespace rubinius {
0
     state->om->set_class(dup, class_object(state));
0
     size_t num = entries->n2i();
0
 
0
-    Array* entries = (Array*)all_entries(state);
0
+    Array* entries = all_entries(state);
0
     for(i = 0; i < num; i++) {
0
-      OBJECT entry = entries->get(state, i);
0
+      Tuple* entry = as<Tuple>(entries->get(state, i));
0
       OBJECT key =   entry->at(0);
0
       OBJECT value = entry->at(1);
0
       dup->store(state, key, value);
0
@@ -71,13 +71,13 @@ namespace rubinius {
0
     return tup;
0
   }
0
 
0
-  OBJECT LookupTable::entry_append(STATE, OBJECT top, OBJECT nxt) {
0
-    Tuple* cur = (Tuple*)top->at(2);
0
-    Tuple* last = (Tuple*)top;
0
+  OBJECT LookupTable::entry_append(STATE, Tuple* top, OBJECT nxt) {
0
+    Tuple* cur = try_as<Tuple>(top->at(2));
0
+    Tuple* last = top;
0
 
0
-    while(!cur->nil_p()) {
0
+    while(cur) {
0
       last = cur;
0
-      cur = (Tuple*)cur->at(2);
0
+      cur = try_as<Tuple>(cur->at(2));
0
     }
0
 
0
     last->put(state, 2, nxt);
0
@@ -96,9 +96,9 @@ namespace rubinius {
0
         entry->put(state, 2, Qnil);
0
 
0
         size_t bin = find_bin(key_hash(entry->at(0)), size);
0
-        OBJECT slot = new_values->at(bin);
0
+        Tuple* slot = try_as<Tuple>(new_values->at(bin));
0
 
0
-        if(slot->nil_p()) {
0
+        if(!slot) {
0
           new_values->put(state, bin, entry);
0
         } else {
0
           entry_append(state, slot, entry);
0
@@ -149,38 +149,32 @@ namespace rubinius {
0
     return val;
0
   }
0
 
0
-  OBJECT LookupTable::find_entry(STATE, OBJECT key) {
0
+  Tuple* LookupTable::find_entry(STATE, OBJECT key) {
0
     unsigned int bin;
0
-    OBJECT entry;
0
+    Tuple* entry;
0
 
0
     key_to_sym(key);
0
     bin = find_bin(key_hash(key), bins->n2i());
0
-    entry = values->at(bin);
0
+    entry = try_as<Tuple>(values->at(bin));
0
 
0
-    while(!entry->nil_p()) {
0
+    while(entry) {
0
       if(entry->at(0) == key) {
0
         return entry;
0
       }
0
-      entry = entry->at(2);
0
+      entry = try_as<Tuple>(entry->at(2));
0
     }
0
-    return Qnil;
0
+    return NULL;
0
   }
0
 
0
   OBJECT LookupTable::fetch(STATE, OBJECT key) {
0
-    OBJECT entry;
0
-
0
-    entry = find_entry(state, key);
0
-    if(!entry->nil_p()) {
0
-      return entry->at(1);
0
-    }
0
+    Tuple* entry = find_entry(state, key);
0
+    if(entry) return entry->at(1);
0
     return Qnil;
0
   }
0
 
0
   OBJECT LookupTable::fetch(STATE, OBJECT key, bool* found) {
0
-    OBJECT entry;
0
-
0
-    entry = find_entry(state, key);
0
-    if(!entry->nil_p()) {
0
+    Tuple* entry = find_entry(state, key);
0
+    if(entry) {
0
       *found = true;
0
       return entry->at(1);
0
     }
0
@@ -195,10 +189,8 @@ namespace rubinius {
0
    * in cpu.c in e.g. cpu_const_get_in_context.
0
    */
0
   OBJECT LookupTable::find(STATE, OBJECT key) {
0
-    OBJECT entry;
0
-
0
-    entry = find_entry(state, key);
0
-    if(!entry->nil_p()) {
0
+    Tuple* entry = find_entry(state, key);
0
+    if(entry) {
0
       return entry->at(1);
0
     }
0
     return Qundef;
0
@@ -247,35 +239,33 @@ namespace rubinius {
0
   }
0
 
0
   OBJECT LookupTable::has_key(STATE, OBJECT key) {
0
-    OBJECT entry;
0
+    Tuple* entry = find_entry(state, key);
0
 
0
-    entry = find_entry(state, key);
0
-    if(!entry->nil_p()) {
0
-      return Qtrue;
0
-    }
0
+    if(entry) return Qtrue;
0
     return Qfalse;
0
   }
0
 
0
-  Array* LookupTable::collect(STATE, LookupTable* tbl, OBJECT (*action)(STATE, OBJECT)) {
0
+  Array* LookupTable::collect(STATE, LookupTable* tbl, OBJECT (*action)(STATE, Tuple*)) {
0
     size_t i, j;
0
-    OBJECT values, entry;
0
+    Tuple* values;
0
+    Tuple* entry;
0
 
0
     Array* ary = Array::create(state, tbl->entries->n2i());
0
     size_t num_bins = tbl->bins->n2i();
0
     values = tbl->values;
0
 
0
     for(i = j = 0; i < num_bins; i++) {
0
-      entry = values->at(i);
0
+      entry = try_as<Tuple>(values->at(i));
0
 
0
-      while(!entry->nil_p()) {
0
+      while(entry) {
0
         ary->set(state, j++, action(state, entry));
0
-        entry = entry->at(2);
0
+        entry = try_as<Tuple>(entry->at(2));
0
       }
0
     }
0
     return ary;
0
   }
0
 
0
-  OBJECT LookupTable::get_key(STATE, OBJECT entry) {
0
+  OBJECT LookupTable::get_key(STATE, Tuple* entry) {
0
     return entry->at(0);
0
   }
0
 
0
@@ -283,7 +273,7 @@ namespace rubinius {
0
     return collect(state, this, get_key);
0
   }
0
 
0
-  OBJECT LookupTable::get_value(STATE, OBJECT entry) {
0
+  OBJECT LookupTable::get_value(STATE, Tuple* entry) {
0
     return entry->at(1);
0
   }
0
 
0
@@ -291,11 +281,11 @@ namespace rubinius {
0
     return collect(state, this, get_value);
0
   }
0
 
0
-  OBJECT LookupTable::get_entry(STATE, OBJECT entry) {
0
+  OBJECT LookupTable::get_entry(STATE, Tuple* entry) {
0
     return entry;
0
   }
0
 
0
-  OBJECT LookupTable::all_entries(STATE) {
0
+  Array* LookupTable::all_entries(STATE) {
0
     return collect(state, this, get_entry);
0
   }
0