add tag v2_2_9

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

6 files changed, 350 insertions, 0 deletions

diff --git a/ruby_2_2/ext/-test-/st/foreach/extconf.rb b/ruby_2_2/ext/-test-/st/foreach/extconf.rb
new file mode 100644
index 0000000000..969f386ff9
--- /dev/null
+++ b/ruby_2_2/ext/-test-/st/foreach/extconf.rb
@@ -0,0 +1 @@
+create_makefile("-test-/st/foreach")
diff --git a/ruby_2_2/ext/-test-/st/foreach/foreach.c b/ruby_2_2/ext/-test-/st/foreach/foreach.c
new file mode 100644
index 0000000000..1e0fd515c9
--- /dev/null
+++ b/ruby_2_2/ext/-test-/st/foreach/foreach.c
@@ -0,0 +1,175 @@
+#include <ruby.h>
+#include <ruby/st.h>
+
+static st_data_t expect_size = 32;
+struct checker {
+    st_table *tbl;
+    st_index_t nr;
+    VALUE test;
+};
+
+static void
+force_unpack_check(struct checker *c, st_data_t key, st_data_t val)
+{
+    if (c->nr == 0) {
+	st_data_t i;
+
+	if (!c->tbl->entries_packed) rb_bug("should be packed\n");
+
+	/* force unpacking during iteration: */
+	for (i = 1; i < expect_size; i++)
+	    st_add_direct(c->tbl, i, i);
+
+	if (c->tbl->entries_packed) rb_bug("should be unpacked\n");
+    }
+
+    if (key != c->nr) {
+	rb_bug("unexpected key: %"PRIuVALUE" (expected %"PRIuVALUE")\n", (VALUE)key, (VALUE)c->nr);
+    }
+    if (val != c->nr) {
+	rb_bug("unexpected val: %"PRIuVALUE" (expected %"PRIuVALUE")\n", (VALUE)val, (VALUE)c->nr);
+    }
+
+    c->nr++;
+}
+
+static int
+unp_fec_i(st_data_t key, st_data_t val, st_data_t args, int error)
+{
+    struct checker *c = (struct checker *)args;
+
+    if (error) {
+	if (c->test == ID2SYM(rb_intern("delete2")))
+	    return ST_STOP;
+
+	rb_bug("unexpected error");
+    }
+
+    force_unpack_check(c, key, val);
+
+    if (c->test == ID2SYM(rb_intern("check"))) {
+	return ST_CHECK;
+    }
+    if (c->test == ID2SYM(rb_intern("delete1"))) {
+	if (c->nr == 1) return ST_DELETE;
+	return ST_CHECK;
+    }
+    if (c->test == ID2SYM(rb_intern("delete2"))) {
+	if (c->nr == 1) {
+	    st_data_t k = 0;
+	    st_data_t v;
+
+	    if (!st_delete(c->tbl, &k, &v)) {
+		rb_bug("failed to delete\n");
+	    }
+	    if (v != 0) {
+		rb_bug("unexpected value deleted: %"PRIuVALUE" (expected 0)", (VALUE)v);
+	    }
+	}
+	return ST_CHECK;
+    }
+
+    rb_raise(rb_eArgError, "unexpected arg: %+"PRIsVALUE, c->test);
+}
+
+static VALUE
+unp_fec(VALUE self, VALUE test)
+{
+    st_table *tbl = st_init_numtable();
+    struct checker c;
+
+    c.tbl = tbl;
+    c.nr = 0;
+    c.test = test;
+
+    st_add_direct(tbl, 0, 0);
+
+    if (!tbl->entries_packed) rb_bug("should still be packed\n");
+
+    st_foreach_check(tbl, unp_fec_i, (st_data_t)&c, -1);
+
+    if (c.test == ID2SYM(rb_intern("delete2"))) {
+	if (c.nr != 1) {
+	    rb_bug("mismatched iteration: %"PRIuVALUE" (expected 1)\n", (VALUE)c.nr);
+	}
+    }
+    else if (c.nr != expect_size) {
+	rb_bug("mismatched iteration: %"PRIuVALUE" (expected %"PRIuVALUE")\n",
+		(VALUE)c.nr, (VALUE)expect_size);
+    }
+
+    if (tbl->entries_packed) rb_bug("should be unpacked\n");
+
+    st_free_table(tbl);
+
+    return Qnil;
+}
+
+static int
+unp_fe_i(st_data_t key, st_data_t val, st_data_t args, int error)
+{
+    struct checker *c = (struct checker *)args;
+
+    force_unpack_check(c, key, val);
+    if (c->test == ID2SYM(rb_intern("unpacked"))) {
+	return ST_CONTINUE;
+    }
+    else if (c->test == ID2SYM(rb_intern("unpack_delete"))) {
+	if (c->nr == 1) {
+	    st_data_t k = 0;
+	    st_data_t v;
+
+	    if (!st_delete(c->tbl, &k, &v)) {
+		rb_bug("failed to delete\n");
+	    }
+	    if (v != 0) {
+		rb_bug("unexpected value deleted: %"PRIuVALUE" (expected 0)", (VALUE)v);
+	    }
+	    return ST_CONTINUE;
+	}
+	rb_bug("should never get here\n");
+    }
+
+    rb_raise(rb_eArgError, "unexpected arg: %+"PRIsVALUE, c->test);
+}
+
+static VALUE
+unp_fe(VALUE self, VALUE test)
+{
+    st_table *tbl = st_init_numtable();
+    struct checker c;
+
+    c.tbl = tbl;
+    c.nr = 0;
+    c.test = test;
+
+    st_add_direct(tbl, 0, 0);
+
+    if (!tbl->entries_packed) rb_bug("should still be packed\n");
+
+    st_foreach(tbl, unp_fe_i, (st_data_t)&c);
+
+    if (c.test == ID2SYM(rb_intern("unpack_delete"))) {
+	if (c.nr != 1) {
+	    rb_bug("mismatched iteration: %"PRIuVALUE" (expected 1)\n", (VALUE)c.nr);
+	}
+    }
+    else if (c.nr != expect_size) {
+	rb_bug("mismatched iteration: %"PRIuVALUE" (expected %"PRIuVALUE"o)\n",
+		(VALUE)c.nr, (VALUE)expect_size);
+    }
+
+    if (tbl->entries_packed) rb_bug("should be unpacked\n");
+
+    st_free_table(tbl);
+
+    return Qnil;
+}
+
+void
+Init_foreach(void)
+{
+    VALUE bug = rb_define_module("Bug");
+    rb_define_singleton_method(bug, "unp_st_foreach_check", unp_fec, 1);
+    rb_define_singleton_method(bug, "unp_st_foreach", unp_fe, 1);
+}
diff --git a/ruby_2_2/ext/-test-/st/numhash/extconf.rb b/ruby_2_2/ext/-test-/st/numhash/extconf.rb
new file mode 100644
index 0000000000..867fd75d2a
--- /dev/null
+++ b/ruby_2_2/ext/-test-/st/numhash/extconf.rb
@@ -0,0 +1 @@
+create_makefile("-test-/st/numhash")
diff --git a/ruby_2_2/ext/-test-/st/numhash/numhash.c b/ruby_2_2/ext/-test-/st/numhash/numhash.c
new file mode 100644
index 0000000000..e033886f9d
--- /dev/null
+++ b/ruby_2_2/ext/-test-/st/numhash/numhash.c
@@ -0,0 +1,138 @@
+#include <ruby.h>
+#include <ruby/st.h>
+
+static void
+numhash_free(void *ptr)
+{
+    if (ptr) st_free_table(ptr);
+}
+
+static size_t
+numhash_memsize(const void *ptr)
+{
+    return ptr ? st_memsize(ptr) : 0;
+}
+
+static const rb_data_type_t numhash_type = {
+    "numhash",
+    {0, numhash_free, numhash_memsize,},
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED,
+};
+
+static VALUE
+numhash_alloc(VALUE klass)
+{
+    return TypedData_Wrap_Struct(klass, &numhash_type, 0);
+}
+
+static VALUE
+numhash_init(VALUE self)
+{
+    st_table *tbl = (st_table *)Check_TypedStruct(self, &numhash_type);
+    if (tbl) st_free_table(tbl);
+    DATA_PTR(self) = st_init_numtable();
+    return self;
+}
+
+static VALUE
+numhash_aref(VALUE self, VALUE key)
+{
+    st_data_t data;
+    st_table *tbl = (st_table *)Check_TypedStruct(self, &numhash_type);
+    if (!SPECIAL_CONST_P(key)) rb_raise(rb_eArgError, "not a special const");
+    if (st_lookup(tbl, (st_data_t)key, &data))
+	return (VALUE)data;
+    return Qnil;
+}
+
+static VALUE
+numhash_aset(VALUE self, VALUE key, VALUE data)
+{
+    st_table *tbl = (st_table *)Check_TypedStruct(self, &numhash_type);
+    if (!SPECIAL_CONST_P(key)) rb_raise(rb_eArgError, "not a special const");
+    if (!SPECIAL_CONST_P(data)) rb_raise(rb_eArgError, "not a special const");
+    st_insert(tbl, (st_data_t)key, (st_data_t)data);
+    return self;
+}
+
+static int
+numhash_i(st_data_t key, st_data_t value, st_data_t arg)
+{
+    VALUE ret;
+    ret = rb_yield_values(3, (VALUE)key, (VALUE)value, (VALUE)arg);
+    if (ret == Qtrue) return ST_CHECK;
+    return ST_CONTINUE;
+}
+
+static VALUE
+numhash_each(VALUE self)
+{
+    st_table *table = (st_table *)Check_TypedStruct(self, &numhash_type);
+    st_data_t data = (st_data_t)self;
+    return st_foreach_check(table, numhash_i, data, data) ? Qtrue : Qfalse;
+}
+
+static int
+update_func(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
+{
+    VALUE ret = rb_yield_values(existing ? 2 : 1, (VALUE)*key, (VALUE)*value);
+    switch (ret) {
+      case Qfalse:
+	return ST_STOP;
+      case Qnil:
+	return ST_DELETE;
+      default:
+	*value = ret;
+	return ST_CONTINUE;
+    }
+}
+
+static VALUE
+numhash_update(VALUE self, VALUE key)
+{
+    st_table *table = (st_table *)Check_TypedStruct(self, &numhash_type);
+    if (st_update(table, (st_data_t)key, update_func, 0))
+	return Qtrue;
+    else
+	return Qfalse;
+}
+
+#if SIZEOF_LONG == SIZEOF_VOIDP
+# define ST2NUM(x) ULONG2NUM(x)
+#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
+# define ST2NUM(x) ULL2NUM(x)
+#endif
+
+static VALUE
+numhash_size(VALUE self)
+{
+    st_table *table = (st_table *)Check_TypedStruct(self, &numhash_type);
+    return ST2NUM(table->num_entries);
+}
+
+static VALUE
+numhash_delete_safe(VALUE self, VALUE key)
+{
+    st_table *table = (st_table *)Check_TypedStruct(self, &numhash_type);
+    st_data_t val, k = (st_data_t)key;
+    if (st_delete_safe(table, &k, &val, (st_data_t)self)) {
+	return val;
+    }
+    return Qnil;
+}
+
+void
+Init_numhash(void)
+{
+    VALUE st = rb_define_class_under(rb_define_module("Bug"), "StNumHash", rb_cData);
+    rb_define_alloc_func(st, numhash_alloc);
+    rb_define_method(st, "initialize", numhash_init, 0);
+    rb_define_method(st, "[]", numhash_aref, 1);
+    rb_define_method(st, "[]=", numhash_aset, 2);
+    rb_define_method(st, "each", numhash_each, 0);
+    rb_define_method(st, "update", numhash_update, 1);
+    rb_define_method(st, "size", numhash_size, 0);
+    rb_define_method(st, "delete_safe", numhash_delete_safe, 1);
+}
+
diff --git a/ruby_2_2/ext/-test-/st/update/extconf.rb b/ruby_2_2/ext/-test-/st/update/extconf.rb
new file mode 100644
index 0000000000..96dbae43ab
--- /dev/null
+++ b/ruby_2_2/ext/-test-/st/update/extconf.rb
@@ -0,0 +1 @@
+create_makefile("-test-/st/update")
diff --git a/ruby_2_2/ext/-test-/st/update/update.c b/ruby_2_2/ext/-test-/st/update/update.c
new file mode 100644
index 0000000000..979ad3e334
--- /dev/null
+++ b/ruby_2_2/ext/-test-/st/update/update.c
@@ -0,0 +1,34 @@
+#include <ruby.h>
+#include <ruby/st.h>
+
+static int
+update_func(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
+{
+    VALUE ret = rb_yield_values(existing ? 2 : 1, (VALUE)*key, (VALUE)*value);
+    switch (ret) {
+      case Qfalse:
+	return ST_STOP;
+      case Qnil:
+	return ST_DELETE;
+      default:
+	*value = ret;
+	return ST_CONTINUE;
+    }
+}
+
+static VALUE
+test_st_update(VALUE self, VALUE key)
+{
+    if (st_update(RHASH_TBL(self), (st_data_t)key, update_func, 0))
+	return Qtrue;
+    else
+	return Qfalse;
+}
+
+void
+Init_update(void)
+{
+    VALUE st = rb_define_class_under(rb_define_module("Bug"), "StTable", rb_cHash);
+    rb_define_method(st, "st_update", test_st_update, 1);
+}
+