revert newhash refactoring

We need to fix GC bug before merging this.  Revert revisions
58452, 58435, 58434, 58428, 58427 in this order.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@58463 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

hash.c

@@ -626,76 +626,48 @@ rb_hash_initialize(int argc, VALUE *argv, VALUE hash)
     return hash;
 }
 
-static inline VALUE
+/*
-hash_alloc_from_st(VALUE klass, st_table *ntbl)
+ *  call-seq:
-{
+ *     Hash[ key, value, ... ]         -> new_hash
-    VALUE h = hash_alloc(klass);
+ *     Hash[ [ [key, value], ... ] ]   -> new_hash
-    RHASH(h)->ntbl = ntbl;
+ *     Hash[ object ]                  -> new_hash
-    return h;
+ *
-}
+ *  Creates a new hash populated with the given objects.
-
+ *
-static inline void
+ *  Similar to the literal <code>{ _key_ => _value_, ... }</code>. In the first
-hash_insert_raw(VALUE hash, st_table *tbl, VALUE key, VALUE val)
+ *  form, keys and values occur in pairs, so there must be an even number of
-{
+ *  arguments.
-    st_data_t v = (st_data_t)val;
+ *
-    st_data_t k = (rb_obj_class(key) == rb_cString) ?
+ *  The second and third form take a single argument which is either an array
-        (st_data_t)rb_str_new_frozen(key) :
+ *  of key-value pairs or an object convertible to a hash.
-        (st_data_t)key;
+ *
-
+ *     Hash["a", 100, "b", 200]             #=> {"a"=>100, "b"=>200}
-    st_insert(tbl, k, v);
+ *     Hash[ [ ["a", 100], ["b", 200] ] ]   #=> {"a"=>100, "b"=>200}
-    RB_OBJ_WRITTEN(hash, Qundef, key);
+ *     Hash["a" => 100, "b" => 200]         #=> {"a"=>100, "b"=>200}
-    RB_OBJ_WRITTEN(hash, Qundef, val);
+ */
-}
 
 static VALUE
-rb_hash_new_from_values_with_klass(long argc, const VALUE *argv, VALUE klass)
+rb_hash_s_create(int argc, VALUE *argv, VALUE klass)
 {
-    long i;
+    VALUE hash, tmp;
-    st_table *t;
+    int i;
-    VALUE v;
 
-    if (argc % 2) {
+    if (argc == 1) {
-	rb_raise(rb_eArgError, "odd number of arguments for Hash");
+	tmp = rb_hash_s_try_convert(Qnil, argv[0]);
-    }
-
-    t = st_init_table_with_size(&objhash, argc / 2);
-    v = hash_alloc_from_st(klass, t);
-
-    for (i = 0; i < argc; /* */) {
-	VALUE key = argv[i++];
-	VALUE val = argv[i++];
-
-	hash_insert_raw(v, t, key, val);
-    }
-    return v;
-}
-
-VALUE
-rb_hash_new_from_values(long argc, const VALUE *argv)
-{
-    return rb_hash_new_from_values_with_klass(argc, argv, rb_cHash);
-}
-
-static VALUE
-rb_hash_new_from_object(VALUE klass, VALUE obj)
-{
-    VALUE tmp = rb_hash_s_try_convert(Qnil, obj);
 	if (!NIL_P(tmp)) {
-	VALUE hash = hash_alloc(klass);
+	    hash = hash_alloc(klass);
 	    if (RHASH(tmp)->ntbl) {
 		RHASH(hash)->ntbl = st_copy(RHASH(tmp)->ntbl);
 	    }
 	    return hash;
 	}
 
-    tmp = rb_check_array_type(obj);
+	tmp = rb_check_array_type(argv[0]);
 	if (!NIL_P(tmp)) {
 	    long i;
-	long len = RARRAY_LEN(tmp);
-	st_table *tbl = len ? st_init_table_with_size(&objhash, len) : NULL;
-	VALUE hv = hash_alloc_from_st(klass, tbl);;
 
-	for (i = 0; i < len; ++i) {
+	    hash = hash_alloc(klass);
+	    for (i = 0; i < RARRAY_LEN(tmp); ++i) {
 		VALUE e = RARRAY_AREF(tmp, i);
 		VALUE v = rb_check_array_type(e);
 		VALUE key, val = Qnil;
@@ -721,43 +693,25 @@ rb_hash_new_from_object(VALUE klass, VALUE obj)
 		    val = RARRAY_AREF(v, 1);
 		  case 1:
 		    key = RARRAY_AREF(v, 0);
-		hash_insert_raw(hv, tbl, key, val);
+		    rb_hash_aset(hash, key, val);
 		}
 	    }
-	return hv;
+	    return hash;
 	}
-
+    }
+    if (argc % 2 != 0) {
 	rb_raise(rb_eArgError, "odd number of arguments for Hash");
-}
-
-/*
- *  call-seq:
- *     Hash[ key, value, ... ]         -> new_hash
- *     Hash[ [ [key, value], ... ] ]   -> new_hash
- *     Hash[ object ]                  -> new_hash
- *
- *  Creates a new hash populated with the given objects.
- *
- *  Similar to the literal <code>{ _key_ => _value_, ... }</code>. In the first
- *  form, keys and values occur in pairs, so there must be an even number of
- *  arguments.
- *
- *  The second and third form take a single argument which is either an array
- *  of key-value pairs or an object convertible to a hash.
- *
- *     Hash["a", 100, "b", 200]             #=> {"a"=>100, "b"=>200}
- *     Hash[ [ ["a", 100], ["b", 200] ] ]   #=> {"a"=>100, "b"=>200}
- *     Hash["a" => 100, "b" => 200]         #=> {"a"=>100, "b"=>200}
- */
-
-static VALUE
-rb_hash_s_create(int argc, VALUE *argv, VALUE klass)
-{
-    switch (argc) {
-      case 0:  return hash_alloc(klass);
-      case 1:  return rb_hash_new_from_object(klass, argv[0]);
-      default: return rb_hash_new_from_values_with_klass(argc, argv, klass);
     }
+
+    hash = hash_alloc(klass);
+    if (argc > 0) {
+        RHASH(hash)->ntbl = st_init_table_with_size(&objhash, argc / 2);
+    }
+    for (i=0; i<argc; i+=2) {
+        rb_hash_aset(hash, argv[i], argv[i + 1]);
+    }
+
+    return hash;
 }
 
 static VALUE

insns.def

@@ -492,13 +492,16 @@ newhash
 (...)
 (VALUE val) // inc += 1 - num;
 {
+    rb_num_t i;
+
     RUBY_DTRACE_CREATE_HOOK(HASH, num);
 
-    if (num) {
-	val = rb_hash_new_from_values(num, STACK_ADDR_FROM_TOP(num));
-    }
-    else {
     val = rb_hash_new();
+
+    for (i = num; i > 0; i -= 2) {
+	const VALUE v = TOPN(i - 2);
+	const VALUE k = TOPN(i - 1);
+	rb_hash_aset(val, k, v);
     }
     POPN(num);
 }

internal.h

@@ -1236,7 +1236,6 @@ VALUE rb_hash_rehash(VALUE hash);
 int rb_hash_add_new_element(VALUE hash, VALUE key, VALUE val);
 #define HASH_DELETED  FL_USER1
 #define HASH_PROC_DEFAULT FL_USER2
-extern VALUE rb_hash_new_from_values(long, const VALUE *);
 
 /* inits.c */
 void rb_call_inits(void);

vm.c

@@ -2646,6 +2646,7 @@ m_core_set_postexe(VALUE self)
     return Qnil;
 }
 
+static VALUE core_hash_merge_ary(VALUE hash, VALUE ary);
 static VALUE core_hash_from_ary(VALUE ary);
 static VALUE core_hash_merge_kwd(int argc, VALUE *argv);
 
@@ -2655,6 +2656,7 @@ core_hash_merge(VALUE hash, long argc, const VALUE *argv)
     long i;
 
     Check_Type(hash, T_HASH);
+    VM_ASSERT(argc % 2 == 0);
     for (i=0; i<argc; i+=2) {
 	rb_hash_aset(hash, argv[i], argv[i+1]);
     }
@@ -2672,18 +2674,27 @@ m_core_hash_from_ary(VALUE self, VALUE ary)
 static VALUE
 core_hash_from_ary(VALUE ary)
 {
-    long n;
+    VALUE hash = rb_hash_new();
 
+    RUBY_DTRACE_CREATE_HOOK(HASH, (Check_Type(ary, T_ARRAY), RARRAY_LEN(ary)));
+    return core_hash_merge_ary(hash, ary);
+}
+
+#if 0
+static VALUE
+m_core_hash_merge_ary(VALUE self, VALUE hash, VALUE ary)
+{
+    REWIND_CFP(core_hash_merge_ary(hash, ary));
+    return hash;
+}
+#endif
+
+static VALUE
+core_hash_merge_ary(VALUE hash, VALUE ary)
+{
     Check_Type(ary, T_ARRAY);
-    n = RARRAY_LEN(ary);
+    core_hash_merge(hash, RARRAY_LEN(ary), RARRAY_CONST_PTR(ary));
-    RUBY_DTRACE_CREATE_HOOK(HASH, n);
+    return hash;
-    if (n) {
-        VM_ASSERT(n % 2 == 0);
-        return rb_hash_new_from_values(n, RARRAY_PTR(ary));
-    }
-    else {
-        return rb_hash_new();
-    }
 }
 
 static VALUE