## mark a section (Learn more)

diff --git a/kernel/alpha.rb b/kernel/alpha.rb index 55d4eb4..e19fe9b 100644 --- a/kernel/alpha.rb +++ b/kernel/alpha.rb @@ -101,6 +101,39 @@ module Kernel def method_missing(meth, *args) raise NoMethodError, "Unable to send '#{meth}' on '#{self}' (#{self.class})" end + + # reimplemented in kernel/common/kernel.rb + def initialize_copy(other) + end + + def copy_header(other) + Ruby.primitive :object_copy_header + raise PrimitiveFailure, "Kernel#copy_header primitive failed" + end + + def copy_object(other) + Ruby.primitive :object_copy_object + raise PrimitiveFailure, "Kernel#copy_object primitive failed" + end + + def copy_metaclass(other) + Ruby.primitive :object_copy_metaclass + raise PrimitiveFailure, "Kernel#copy_metaclass primitive failed" + end + + def dup + copy = self.class.allocate + copy.copy_object self + copy.send :initialize_copy, self + copy + end + + def clone + copy = dup + copy.copy_metaclass self + copy.freeze if frozen? + copy + end end class CompiledMethod < Executable diff --git a/kernel/bootstrap/bytearray.rb b/kernel/bootstrap/bytearray.rb index 3be2594..d5dee09 100644 --- a/kernel/bootstrap/bytearray.rb +++ b/kernel/bootstrap/bytearray.rb @@ -1,11 +1,15 @@ class ByteArray - def self.allocate(cnt) + def self.allocate + raise TypeError, "ByteArray cannot be created via allocate()" + end + + def self.allocate_sized(cnt) Ruby.primitive :bytearray_allocate raise PrimitiveFailure, "ByteArray#allocate primitive failed" end def self.new(cnt) - obj = allocate(cnt) + obj = allocate_sized cnt Rubinius.asm(obj) do |obj| push_block run obj @@ -53,7 +57,8 @@ class ByteArray def dup(cls=nil) cls ||= self.class obj = cls.new(self.size) - dup_into obj + obj.copy_object self + obj.send :initialize_copy, self return obj end diff --git a/kernel/bootstrap/data.rb b/kernel/bootstrap/data.rb new file mode 100644 index 0000000..741ea90 --- /dev/null +++ b/kernel/bootstrap/data.rb @@ -0,0 +1,8 @@ +class Data + def dup + copy = self.class.allocate + copy.copy_header self + copy.send :initialize_copy, self + copy + end +end diff --git a/kernel/bootstrap/kernel.rb b/kernel/bootstrap/kernel.rb index eeaf07e..16efb97 100644 --- a/kernel/bootstrap/kernel.rb +++ b/kernel/bootstrap/kernel.rb @@ -1,15 +1,5 @@ module Kernel - def clone - Ruby.primitive :object_clone - raise TypeError, "Kernel#clone primitive failed" - end - - def dup - Ruby.primitive :object_dup - raise TypeError, "Kernel#dup primitive failed" - end - def equal?(other) Ruby.primitive :object_equal raise PrimitiveFailure, "Kernel#equal? primitive failed" diff --git a/kernel/bootstrap/lookuptable.rb b/kernel/bootstrap/lookuptable.rb index 0459d2f..1376b00 100644 --- a/kernel/bootstrap/lookuptable.rb +++ b/kernel/bootstrap/lookuptable.rb @@ -76,12 +76,16 @@ class LookupTable end end - def dup - Ruby.primitive :lookuptable_dup - raise PrimitiveFailure, "LookupTable#dup primitive failed" + def duplicate + Ruby.primitive :lookuptable_duplicate + raise PrimitiveFailure, "LookupTable#duplicate primitive failed" end - alias_method :clone, :dup + def dup + copy = duplicate + copy.send :initialize_copy, self + copy + end def fetch(key, return_on_failure) Ruby.primitive :lookuptable_fetch diff --git a/kernel/bootstrap/tuple.rb b/kernel/bootstrap/tuple.rb index 62ced70..506ea19 100644 --- a/kernel/bootstrap/tuple.rb +++ b/kernel/bootstrap/tuple.rb @@ -1,5 +1,9 @@ class Tuple + def self.allocate + raise TypeError, "Tuple cannot be created via allocate()" + end + def self.new(cnt) Ruby.primitive :tuple_allocate raise PrimitiveFailure, "Tuple.new primitive failed" @@ -40,6 +44,13 @@ class Tuple raise PrimitiveFailure, "Tuple#copy_from primitive failed" end + def dup + obj = self.class.new(self.size) + obj.copy_object self + obj.send :initialize_copy, self + obj + end + def delete(start,length,object) Ruby.primitive :tuple_delete_inplace raise PrimitiveFailure, "Tuple#delete primitive failed" diff --git a/kernel/common/kernel.rb b/kernel/common/kernel.rb index 5a4e4d0..c4de1b7 100644 --- a/kernel/common/kernel.rb +++ b/kernel/common/kernel.rb @@ -77,23 +77,6 @@ module Kernel end private :FloatValue - alias_method :primitive_clone, :clone - - def clone - copy = primitive_clone - copy.send :initialize_copy, self - copy.freeze if frozen? - copy - end - - alias_method :primitive_dup, :dup - - def dup - copy = primitive_dup - copy.send :initialize_copy, self - copy - end - def initialize_copy(source) unless source.class == self.class then raise TypeError, "initialize_copy should take same class object" diff --git a/kernel/platform/memorypointer.rb b/kernel/platform/memorypointer.rb index ff43ef1..5efb0c4 100644 --- a/kernel/platform/memorypointer.rb +++ b/kernel/platform/memorypointer.rb @@ -82,25 +82,18 @@ module FFI end end - def clone - other = Platform::POSIX.malloc total - other.total = total - other.type_size = type_size - Platform::POSIX.memcpy other, self, total - other - end - def dup other = Platform::POSIX.malloc total other.total = total other.type_size = type_size Platform::POSIX.memcpy other, self, total + other.send :initialize_copy, self other end - def address= thingy + def address=(address) Ruby.primitive :memorypointer_set_address - raise PrimitiveFailure, "Unable to fuck over your address well enough" + raise PrimitiveFailure, "MemoryPointer#address= primitive failed" end # Indicates how many bytes the chunk of memory that is pointed to takes up. diff --git a/kernel/platform/struct.rb b/kernel/platform/struct.rb index 44b7ce7..71ebd48 100644 --- a/kernel/platform/struct.rb +++ b/kernel/platform/struct.rb @@ -77,8 +77,8 @@ module FFI @pointer.free end - def initialize_copy ptr - @pointer = @pointer.dup + def initialize_copy(ptr) + @pointer = ptr.pointer.dup end def [](field) diff --git a/vm/builtin/lookuptable.cpp b/vm/builtin/lookuptable.cpp index d256c00..b8dd6e5 100644 --- a/vm/builtin/lookuptable.cpp +++ b/vm/builtin/lookuptable.cpp @@ -49,7 +49,7 @@ namespace rubinius { return tbl; } - LookupTable* LookupTable::dup(STATE) { + LookupTable* LookupTable::duplicate(STATE) { size_t size, i; LookupTable *dup; diff --git a/vm/builtin/lookuptable.hpp b/vm/builtin/lookuptable.hpp index 9fc12cc..8103c86 100644 --- a/vm/builtin/lookuptable.hpp +++ b/vm/builtin/lookuptable.hpp @@ -96,8 +96,8 @@ namespace rubinius { Object* fetch(STATE, Object* key, bool* found); - // Ruby.primitive :lookuptable_dup - LookupTable* dup(STATE); + // Ruby.primitive :lookuptable_duplicate + LookupTable* duplicate(STATE); void redistribute(STATE, size_t size); LookupTableBucket* find_entry(STATE, Object* key); Object* find(STATE, Object* key); diff --git a/vm/builtin/object.cpp b/vm/builtin/object.cpp index 931a00f..aa380e6 100644 --- a/vm/builtin/object.cpp +++ b/vm/builtin/object.cpp @@ -51,41 +51,39 @@ namespace rubinius { type_info(state)->cleanup(this); } - Object* Object::clone(STATE) { - Object* other = dup(state); + Object* Object::duplicate(STATE) { + Object* other = state->om->allocate_object(this->total_size(state)); + + return other->copy_object(state, this); + } - other->copy_internal_state_from(state, this); + Object* Object::copy_object(STATE, Object* other) { + copy_header(state, other); + copy_body(state, other); - return other; + return this; } - void Object::copy_internal_state_from(STATE, Object* original) { - if(MetaClass* mc = try_as<MetaClass>(original->klass())) { - LookupTable* source_methods = mc->method_table()->dup(state); - LookupTable* source_constants = mc->constants()->dup(state); + Object* Object::copy_metaclass(STATE, Object* other) { + if(MetaClass* mc = try_as<MetaClass>(other->klass())) { + LookupTable* source_methods = mc->method_table()->duplicate(state); + LookupTable* source_constants = mc->constants()->duplicate(state); - this->metaclass(state)->method_table(state, source_methods); - this->metaclass(state)->constants(state, source_constants); + metaclass(state)->method_table(state, source_methods); + metaclass(state)->constants(state, source_constants); // This allows us to preserve included modules - this->metaclass(state)->superclass(state, mc->superclass()); + metaclass(state)->superclass(state, mc->superclass()); } - } - Object* Object::dup(STATE) { - Object* other = state->om->allocate_object(this->total_size(state)); - -#ifdef RBX_GC_STATS - // This counter is only valid if the line above allocates in the - // young object space. - stats::GCStats::get()->young_object_types[this->type_id()]++; -#endif + return this; + } - other->initialize_copy(this, age); - other->copy_body(state, this); + Object* Object::copy_header(STATE, Object* other) { + initialize_copy(other, age); - // Set the dup's class this's class - other->klass(state, class_object(state)); + // Ensure that the metaclass is not shared + klass(state, other->class_object(state)); // HACK: If other is mature, remember it. // We could inspect inspect the references we just copied to see @@ -93,19 +91,19 @@ namespace rubinius { // then remember other. The up side to just remembering it like // this is that other is rarely mature, and the remember_set is // flushed on each collection anyway. - if(other->zone == MatureObjectZone) { - state->om->remember_object(other); + if(zone == MatureObjectZone) { + state->om->remember_object(this); } // Copy ivars. - if(ivars_->reference_p()) { + if(other->ivars_->reference_p()) { // NOTE Don't combine these 2 branches even though they both just call - // ::dup. There is a special LookupTable::dup that can only be seen + // ::copy. There is a special LookupTable::copy that can only be seen // when the receiver is of LookupTable* type. Without the explicit cast // and call, the wrong one will be called. - if(LookupTable* lt = try_as<LookupTable>(ivars_)) { - other->ivars_ = lt->dup(state); - LookupTable* ld = as<LookupTable>(other->ivars_); + if(LookupTable* lt = try_as<LookupTable>(other->ivars_)) { + ivars_ = lt->duplicate(state); + LookupTable* ld = as<LookupTable>(ivars_); // We store the object_id in the ivar table, so nuke it. ld->remove(state, G(sym_object_id)); @@ -113,9 +111,9 @@ namespace rubinius { } else { // Use as<> so that we throw a TypeError if there is something else // here. - CompactLookupTable* clt = as<CompactLookupTable>(ivars_); - other->ivars_ = clt->dup(state); - CompactLookupTable* ld = as<CompactLookupTable>(other->ivars_); + CompactLookupTable* clt = as<CompactLookupTable>(other->ivars_); + ivars_ = clt->duplicate(state); + CompactLookupTable* ld = as<CompactLookupTable>(ivars_); // We store the object_id in the ivar table, so nuke it. ld->remove(state, G(sym_object_id)); @@ -123,7 +121,7 @@ namespace rubinius { }; } - return other; + return this; } Object* Object::equal(STATE, Object* other) { diff --git a/vm/builtin/object.hpp b/vm/builtin/object.hpp index 8a1cc72..e01c08b 100644 --- a/vm/builtin/object.hpp +++ b/vm/builtin/object.hpp @@ -108,17 +108,38 @@ namespace rubinius { public: /* Type information, field access, copy support &c. */ - /** Sets the other Object's flags the same as this. @see vm/oop.hpp. */ - void copy_flags(STATE, Object* other); - /** Copies metaclass from original to this one. @see clone(). */ - void copy_internal_state_from(STATE, Object* original); - /** NOT IMPLEMENTED. Copies instance variables to the other Object. */ - void copy_ivars(STATE, Object* other); - /** NOT IMPLEMENTED. Copies this Object's MetaClass to the other Object. */ - void copy_metaclass(STATE, Object* other); + /** + * Returns a copy of this object. This is NOT the same as Ruby + * Object#dup. Code that needs Object#dup semantics MUST call + * #dup from Ruby. This method is used in the VM to duplicate + * data structures. It will not call the Ruby allocate() or + * initialize_copy() methods. + */ + Object* duplicate(STATE); + + /** + * Copies the header and instance variables from other. Called + * by Kernel#dup. + */ + // Ruby.primitive :object_copy_header + Object* copy_header(STATE, Object* other); + + /** + * Copies the entire object by first calling copy_header and + * then copying the body. Called by ByteArray#dup and Tuple#dup. + */ + // Ruby.primitive :object_copy_object + Object* copy_object(STATE, Object* other); + + /** + * Copies this Object's MetaClass to the other Object. Called + * by Kernel#clone. + */ + // Ruby.primitive :object_copy_metaclass + Object* copy_metaclass(STATE, Object* other); /** True if this Object* is actually a Fixnum, false otherwise. */ - bool fixnum_p() const; + bool fixnum_p() const; /** * Retrieve the Object stored in given field index of this Object. @@ -175,33 +196,11 @@ namespace rubinius { // Ruby.primitive :object_change_class_to Object* change_class_to(STATE, Class* other_klass); - /** - * Ruby #clone. - * - * Creates and returns a new Object that is a copy of this one - * including internal state. - * - * @see dup() - */ - // Ruby.primitive :object_clone - Object* clone(STATE); - /** Returns the Class object of which this Object is an instance. */ // Ruby.primitive :object_class Class* class_object(STATE) const; /** - * Ruby #dup. - * - * Creates and returns a new Object that is a copy of this one - * except for internal state. - * - * @see clone() - */ - // Ruby.primitive :object_dup - Object* dup(STATE); - - /** * Ruby #equal?. * * Returns true if and only if this and the other object are diff --git a/vm/builtin/string.cpp b/vm/builtin/string.cpp index 18ec906..c725eaf 100644 --- a/vm/builtin/string.cpp +++ b/vm/builtin/string.cpp @@ -185,7 +185,7 @@ namespace rubinius { String* String::string_dup(STATE) { String* ns; - ns = as<String>(dup(state)); + ns = as<String>(duplicate(state)); ns->shared(state, Qtrue); shared(state, Qtrue); @@ -195,7 +195,7 @@ namespace rubinius { } void String::unshare(STATE) { - data(state, as<ByteArray>(data_->dup(state))); + data(state, as<ByteArray>(data_->duplicate(state))); shared(state, Qfalse); } diff --git a/vm/capi/object.cpp b/vm/capi/object.cpp index 29fefb5..e5d8676 100644 --- a/vm/capi/object.cpp +++ b/vm/capi/object.cpp @@ -130,9 +130,8 @@ extern "C" { VALUE rb_obj_clone(VALUE obj_handle) { NativeMethodEnvironment* env = NativeMethodEnvironment::get(); - Object* object = env->get_object(obj_handle); - - return env->get_handle(object->clone(env->state())); + env->flush_cached_data(false); + return rb_funcall(obj_handle, rb_intern("clone"), 0); } VALUE rb_inspect(VALUE obj_handle) {

This paste will be private.