rbtree 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 42305188c5448bb5c684e198069f323816d32d5a
-  data.tar.gz: f1d5608adf7f2c1d142048d5abbe499d11cc83a6
+  metadata.gz: 35a51532a317785f995191b86990fd197d3a08d7
+  data.tar.gz: fc58dc292ed9763c6b8731ca2998c6affe591007
 SHA512:
-  metadata.gz: 892207ef1dc38a23044b15480bcd57a4ab722cc944131f1d56d1878aa668b539d0c10f6a0cdd6c52b7d3255e17c14fb466ed898a3bc56fbe0e15472da912a888
-  data.tar.gz: c2a3503fcc68622ab775d421843b25d07afa7f1702e870ad57a600f3c06b904179c86d62bc6dd3d6c86e5948af09f95e37998de35fb7c8e48e00c4478fae9e15
+  metadata.gz: 75b7c55bd29b9341ae5969742855aa15893af18574d7c5ff734ea8e52b3e25f1ccb290c72bb27b58ae8e61db533b2d04b15cab80ff3e64239aee02f63591be35
+  data.tar.gz: d1b1c0def86af19fd6b6a2bdcf7e2147b3f0e1ea340276d283884ee50b7fe3bd91c5f55e7495dcda3652fd9443b55d930044ce007ab707dc196cca3f45834011

data/README

@@ -57,6 +57,9 @@ Run the following command.
   $ sudo gem install rbtree
 
 == Changes
+=== 0.4.2
+* Fixed build failure with Ruby 2.1.0.
+
 === 0.4.1
 * Fixed a crash that could be triggered when GC happened.
 
@@ -78,9 +81,3 @@ dict.c and dict.h are modified copies that are originally in Kazlib
 1.20 written by Kaz Kylheku. Its license is similar to the MIT
 license. See dict.c and dict.h for the details. The web page of Kazlib
 is at http://www.kylheku.com/~kaz/kazlib.html.
-
-== Contact
-
-Run the following command.
-
-  $ ruby -e "puts 'YnVybmluZ2Rvd250aGVvcGVyYUB5YWhvby5jby5qcA==\n'.unpack('m')"

data/dict.c

@@ -14,12 +14,12 @@
  * into proprietary software; there is no requirement for such software to
  * contain a copyright notice related to this source.
  *
- * $Id: dict.c,v 1.15 2005/10/06 05:16:35 kuma Exp $
- * $Name:  $
+ * $Id: dict.c,v 1.40.2.7 2000/11/13 01:36:44 kaz Exp $
+ * $Name: kazlib_1_20 $
  */
 
 /*
- * Modified for Ruby/RBTree by OZAWA Takuma.
+ * Modified for Ruby/RBTree.
  */
 
 #include <stdlib.h>
@@ -29,7 +29,7 @@
 #include "dict.h"
 
 #ifdef KAZLIB_RCSID
-static const char rcsid[] = "$Id: dict.c,v 1.15 2005/10/06 05:16:35 kuma Exp $";
+static const char rcsid[] = "$Id: dict.c,v 1.40.2.7 2000/11/13 01:36:44 kaz Exp $";
 #endif
 
 /*
@@ -1190,3 +1190,308 @@ void dict_merge(dict_t *dest, dict_t *source)
     dict_clear(source);
     dict_load_end(&load);
 }
+
+#ifdef KAZLIB_TEST_MAIN
+
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdarg.h>
+
+typedef char input_t[256];
+
+static int tokenize(char *string, ...)
+{
+    char **tokptr; 
+    va_list arglist;
+    int tokcount = 0;
+
+    va_start(arglist, string);
+    tokptr = va_arg(arglist, char **);
+    while (tokptr) {
+	while (*string && isspace((unsigned char) *string))
+	    string++;
+	if (!*string)
+	    break;
+	*tokptr = string;
+	while (*string && !isspace((unsigned char) *string))
+	    string++;
+	tokptr = va_arg(arglist, char **);
+	tokcount++;
+	if (!*string)
+	    break;
+	*string++ = 0;
+    }
+    va_end(arglist);
+
+    return tokcount;
+}
+
+static int comparef(const void *key1, const void *key2)
+{
+    return strcmp(key1, key2);
+}
+
+static char *dupstring(char *str)
+{
+    int sz = strlen(str) + 1;
+    char *new = malloc(sz);
+    if (new)
+	memcpy(new, str, sz);
+    return new;
+}
+
+static dnode_t *new_node(void *c)
+{
+    static dnode_t few[5];
+    static int count;
+
+    if (count < 5)
+	return few + count++;
+
+    return NULL;
+}
+
+static void del_node(dnode_t *n, void *c)
+{
+}
+
+static int prompt = 0;
+
+static void construct(dict_t *d)
+{
+    input_t in;
+    int done = 0;
+    dict_load_t dl;
+    dnode_t *dn;
+    char *tok1, *tok2, *val;
+    const char *key;
+    char *help = 
+	"p                      turn prompt on\n"
+	"q                      finish construction\n"
+	"a <key> <val>          add new entry\n";
+
+    if (!dict_isempty(d))
+	puts("warning: dictionary not empty!");
+
+    dict_load_begin(&dl, d);
+
+    while (!done) {
+	if (prompt)
+	    putchar('>');
+	fflush(stdout);
+
+	if (!fgets(in, sizeof(input_t), stdin))
+	    break;
+
+	switch (in[0]) {
+	    case '?':
+		puts(help);
+		break;
+	    case 'p':
+		prompt = 1;
+		break;
+	    case 'q':
+		done = 1;
+		break;
+	    case 'a':
+		if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
+		    puts("what?");
+		    break;
+		}
+		key = dupstring(tok1);
+		val = dupstring(tok2);
+		dn = dnode_create(val);
+
+		if (!key || !val || !dn) {
+		    puts("out of memory");
+		    free((void *) key);
+		    free(val);
+		    if (dn)
+			dnode_destroy(dn);
+		}
+
+		dict_load_next(&dl, dn, key);
+		break;
+	    default:
+		putchar('?');
+		putchar('\n');
+		break;
+	}
+    }
+
+    dict_load_end(&dl);
+}
+
+int main(void)
+{
+    input_t in;
+    dict_t darray[10];
+    dict_t *d = &darray[0];
+    dnode_t *dn;
+    int i;
+    char *tok1, *tok2, *val;
+    const char *key;
+
+    char *help =
+	"a <key> <val>          add value to dictionary\n"
+	"d <key>                delete value from dictionary\n"
+	"l <key>                lookup value in dictionary\n"
+	"( <key>                lookup lower bound\n"
+	") <key>                lookup upper bound\n"
+	"# <num>                switch to alternate dictionary (0-9)\n"
+	"j <num> <num>          merge two dictionaries\n"
+	"f                      free the whole dictionary\n"
+	"k                      allow duplicate keys\n"
+	"c                      show number of entries\n"
+	"t                      dump whole dictionary in sort order\n"
+	"m                      make dictionary out of sorted items\n"
+	"p                      turn prompt on\n"
+	"s                      switch to non-functioning allocator\n"
+	"q                      quit";
+
+    for (i = 0; i < sizeof darray / sizeof *darray; i++)
+	dict_init(&darray[i], DICTCOUNT_T_MAX, comparef);
+
+    for (;;) {
+	if (prompt)
+	    putchar('>');
+	fflush(stdout);
+
+	if (!fgets(in, sizeof(input_t), stdin))
+	    break;
+
+	switch(in[0]) {
+	    case '?':
+		puts(help);
+		break;
+	    case 'a':
+		if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
+		    puts("what?");
+		    break;
+		}
+		key = dupstring(tok1);
+		val = dupstring(tok2);
+
+		if (!key || !val) {
+		    puts("out of memory");
+		    free((void *) key);
+		    free(val);
+		}
+
+		if (!dict_alloc_insert(d, key, val)) {
+		    puts("dict_alloc_insert failed");
+		    free((void *) key);
+		    free(val);
+		    break;
+		}
+		break;
+	    case 'd':
+		if (tokenize(in+1, &tok1, (char **) 0) != 1) {
+		    puts("what?");
+		    break;
+		}
+		dn = dict_lookup(d, tok1);
+		if (!dn) {
+		    puts("dict_lookup failed");
+		    break;
+		}
+		val = dnode_get(dn);
+		key = dnode_getkey(dn);
+		dict_delete_free(d, dn);
+
+		free(val);
+		free((void *) key);
+		break;
+	    case 'f':
+		dict_free(d);
+		break;
+	    case 'l':
+	    case '(':
+	    case ')':
+		if (tokenize(in+1, &tok1, (char **) 0) != 1) {
+		    puts("what?");
+		    break;
+		}
+		dn = 0;
+		switch (in[0]) {
+		case 'l':
+		    dn = dict_lookup(d, tok1);
+		    break;
+		case '(':
+		    dn = dict_lower_bound(d, tok1);
+		    break;
+		case ')':
+		    dn = dict_upper_bound(d, tok1);
+		    break;
+		}
+		if (!dn) {
+		    puts("lookup failed");
+		    break;
+		}
+		val = dnode_get(dn);
+		puts(val);
+		break;
+	    case 'm':
+		construct(d);
+		break;
+	    case 'k':
+		dict_allow_dupes(d);
+		break;
+	    case 'c':
+		printf("%lu\n", (unsigned long) dict_count(d));
+		break;
+	    case 't':
+		for (dn = dict_first(d); dn; dn = dict_next(d, dn)) {
+		    printf("%s\t%s\n", (char *) dnode_getkey(dn),
+			    (char *) dnode_get(dn));
+		}
+		break;
+	    case 'q':
+		exit(0);
+		break;
+	    case '\0':
+		break;
+	    case 'p':
+		prompt = 1;
+		break;
+	    case 's':
+		dict_set_allocator(d, new_node, del_node, NULL);
+		break;
+	    case '#':
+		if (tokenize(in+1, &tok1, (char **) 0) != 1) {
+		    puts("what?");
+		    break;
+		} else {
+		    int dictnum = atoi(tok1);
+		    if (dictnum < 0 || dictnum > 9) {
+			puts("invalid number");
+			break;
+		    }
+		    d = &darray[dictnum];
+		}
+		break;
+	    case 'j':
+		if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
+		    puts("what?");
+		    break;
+		} else {
+		    int dict1 = atoi(tok1), dict2 = atoi(tok2);
+		    if (dict1 < 0 || dict1 > 9 || dict2 < 0 || dict2 > 9) {
+			puts("invalid number");
+			break;
+		    }
+		    dict_merge(&darray[dict1], &darray[dict2]);
+		}
+		break;
+	    default:
+		putchar('?');
+		putchar('\n');
+		break;
+	}
+    }
+
+    return 0;
+}
+
+#endif

data/dict.h

@@ -14,12 +14,12 @@
  * into proprietary software; there is no requirement for such software to
  * contain a copyright notice related to this source.
  *
- * $Id: dict.h,v 1.9 2005/10/06 05:16:35 kuma Exp $
- * $Name:  $
+ * $Id: dict.h,v 1.22.2.6 2000/11/13 01:36:44 kaz Exp $
+ * $Name: kazlib_1_20 $
  */
 
 /*
- * Modified for Ruby/RBTree by OZAWA Takuma.
+ * Modified for Ruby/RBTree.
  */
 
 #ifndef DICT_H

data/extconf.rb

@@ -5,10 +5,11 @@ if enable_config('debug')
 else
   $defs << '-DNDEBUG'
 end
-have_header('ruby/st.h')
 have_func('rb_exec_recursive', 'ruby.h')
 have_func('rb_exec_recursive_paired', 'ruby.h')
 have_func('rb_proc_lambda_p', 'ruby.h')
+have_func('rb_ary_resize', 'ruby.h')
+have_func('rb_obj_hide', 'ruby.h')
 if Hash.method_defined?(:flatten)
   $defs << '-DHAVE_HASH_FLATTEN'
 end

data/rbtree.c

@@ -23,11 +23,12 @@
 #endif
 #endif
 
-#ifndef RHASH_TBL
-#define RHASH_TBL(h) RHASH(h)->tbl
+#ifndef RARRAY_AREF
+#define RARRAY_AREF(a, i) (RARRAY_PTR(a)[i])
 #endif
-#ifndef RHASH_IFNONE
-#define RHASH_IFNONE(h) RHASH(h)->ifnone
+
+#ifndef RHASH_SET_IFNONE
+#define RHASH_SET_IFNONE(h, v) (RHASH(h)->ifnone = (v))
 #endif
 
 VALUE RBTree;
@@ -100,15 +101,17 @@ rbtree_free_node(dnode_t* node, void* context)
 }
 
 static void
-rbtree_argc_error(const int argc, const int min, const int max)
-{
-    const char* message = "wrong number of arguments";
-    if (min == max) {
-        rb_raise(rb_eArgError, "%s (%d for %d)", message, argc, min);
-    } else if (max == INT_MAX) {
-        rb_raise(rb_eArgError, "%s (%d for %d+)", message, argc, -min - 1);
-    } else {
-        rb_raise(rb_eArgError, "%s (%d for %d..%d)", message, argc, min, max);
+rbtree_check_argument_count(const int argc, const int min, const int max)
+{
+    if (argc < min || argc > max) {
+        static const char* const  message = "wrong number of arguments";
+        if (min == max) {
+            rb_raise(rb_eArgError, "%s (%d for %d)", message, argc, min);
+        } else if (max == INT_MAX) {
+            rb_raise(rb_eArgError, "%s (%d for %d+)", message, argc, -min - 1);
+        } else {
+            rb_raise(rb_eArgError, "%s (%d for %d..%d)", message, argc, min, max);
+        }
     }
 }
 
@@ -181,7 +184,7 @@ static VALUE
 rbtree_alloc(VALUE klass)
 {
     dict_t* dict;
-    VALUE rbtree = Data_Wrap_Struct(klass, rbtree_mark, rbtree_free, 0);
+    VALUE rbtree = Data_Wrap_Struct(klass, rbtree_mark, rbtree_free, NULL);
     RBTREE(rbtree) = ALLOC(rbtree_t);
     MEMZERO(RBTREE(rbtree), rbtree_t, 1);
     
@@ -248,18 +251,18 @@ rbtree_s_create(int argc, VALUE* argv, VALUE klass)
         if (!NIL_P(temp)) {
             rbtree = rbtree_alloc(klass);
             for (i = 0; i < RARRAY_LEN(temp); i++) {
-                VALUE v = rb_check_array_type(RARRAY_PTR(temp)[i]);
+                VALUE v = rb_check_array_type(RARRAY_AREF(temp, i));
                 if (NIL_P(v)) {
                     rb_warn("wrong element type %s at %ld (expected Array)",
-                            rb_obj_classname(RARRAY_PTR(temp)[i]), i);
+                            rb_obj_classname(RARRAY_AREF(temp, i)), i);
                     continue;
                 }
                 switch(RARRAY_LEN(v)) {
                 case 1:
-                    rbtree_aset(rbtree, RARRAY_PTR(v)[0], Qnil);
+                    rbtree_aset(rbtree, RARRAY_AREF(v, 0), Qnil);
                     break;
                 case 2:
-                    rbtree_aset(rbtree, RARRAY_PTR(v)[0], RARRAY_PTR(v)[1]);
+                    rbtree_aset(rbtree, RARRAY_AREF(v, 0), RARRAY_AREF(v, 1));
                     break;
                 default:
                     rb_warn("invalid number of elements (%ld for 1..2)",
@@ -289,17 +292,14 @@ rbtree_initialize(int argc, VALUE* argv, VALUE self)
 
     if (rb_block_given_p()) {
         VALUE proc;
-        if (argc > 0) {
-            rbtree_argc_error(argc, 0, 0);
-        }
+        rbtree_check_argument_count(argc, 0, 0);
         proc = rb_block_proc();
         rbtree_check_proc_arity(proc, 2);
         IFNONE(self) = proc;
         FL_SET(self, RBTREE_PROC_DEFAULT);
     } else {
-        if (argc > 1) {
-            rbtree_argc_error(argc, 1, 1);
-        } else if (argc == 1) {
+        rbtree_check_argument_count(argc, 0, 1);
+        if (argc == 1) {
             IFNONE(self) = argv[0];
         }
     }
@@ -418,12 +418,9 @@ rbtree_fetch(int argc, VALUE* argv, VALUE self)
 {
     dnode_t* node;
 
-    if (argc == 0 || argc > 2) {
-        rbtree_argc_error(argc, 1, 2);
-    } else if (argc == 2) {
-        if (rb_block_given_p()) {
-            rb_warn("block supersedes default value argument");
-        }
+    rbtree_check_argument_count(argc, 1, 2);
+    if (argc == 2 && rb_block_given_p()) {
+        rb_warn("block supersedes default value argument");
     }
 
     node = dict_lookup(DICT(self), TO_KEY(argv[0]));
@@ -464,9 +461,7 @@ rbtree_empty_p(VALUE self)
 VALUE
 rbtree_default(int argc, VALUE* argv, VALUE self)
 {
-    if (argc > 1) {
-        rbtree_argc_error(argc, 0, 1);
-    }
+    rbtree_check_argument_count(argc, 0, 1);
     if (FL_TEST(self, RBTREE_PROC_DEFAULT)) {
         if (argc == 0) {
             return Qnil;
@@ -752,7 +747,11 @@ static void
 copy_dict(VALUE src, VALUE dest, dict_comp_t cmp_func, VALUE cmp_proc)
 {
     VALUE temp = rbtree_alloc(CLASS_OF(dest));
+#ifdef HAVE_RB_OBJ_HIDE
+    rb_obj_hide(temp);
+#else
     RBASIC(temp)->klass = 0;
+#endif
     DICT(temp)->dict_compare = cmp_func;
     CMP_PROC(temp) = cmp_proc;
 
@@ -763,6 +762,7 @@ copy_dict(VALUE src, VALUE dest, dict_comp_t cmp_func, VALUE cmp_proc)
         DICT(dest) = t;
     }
     rbtree_free(RBTREE(temp));
+    RBTREE(temp) = NULL;
     rb_gc_force_recycle(temp);
 
     DICT(dest)->dict_context = RBTREE(dest);
@@ -840,9 +840,8 @@ VALUE
 rbtree_index(VALUE self, VALUE value)
 {
     VALUE klass = rb_obj_is_kind_of(self, RBTree) ? RBTree : MultiRBTree;
-    volatile VALUE class_name = rb_class_name(klass);
-    rb_warn("%s#index is deprecated; use %s#key",
-            RSTRING_PTR(class_name), RSTRING_PTR(class_name));
+    const char* classname = rb_class2name(klass);
+    rb_warn("%s#index is deprecated; use %s#key", classname, classname);
     return rbtree_key(self, value);
 }
 
@@ -1163,6 +1162,14 @@ rbtree_merge(VALUE self, VALUE other)
     return rbtree_update(rb_obj_dup(self), other);
 }
 
+static each_return_t
+to_flat_ary_i(dnode_t* node, void* ary)
+{
+    rb_ary_push((VALUE)ary, GET_KEY(node));
+    rb_ary_push((VALUE)ary, GET_VAL(node));
+    return EACH_NEXT;
+}
+
 /*
  *
  */
@@ -1170,15 +1177,17 @@ VALUE
 rbtree_flatten(int argc, VALUE* argv, VALUE self)
 {
     VALUE ary;
-    VALUE level;
-    
-    ary = rbtree_to_a(self);
-    if (argc == 0) {
-        argc = 1;
-        level = INT2FIX(1);
-        argv = &level;
+
+    rbtree_check_argument_count(argc, 0, 1);
+    ary = rb_ary_new2(dict_count(DICT(self)) * 2);
+    rbtree_for_each(self, to_flat_ary_i, (void*)ary);
+    if (argc == 1) {
+        const int level = NUM2INT(argv[0]) - 1;
+        if (level > 0) {
+            argv[0] = INT2FIX(level);
+            rb_funcall2(ary, id_flatten_bang, argc, argv);
+        }
     }
-    rb_funcall2(ary, id_flatten_bang, argc, argv);
     return ary;
 }
 
@@ -1289,7 +1298,7 @@ rbtree_to_hash(VALUE self)
     
     hash = rb_hash_new();
     rbtree_for_each(self, to_hash_i, (void*)hash);
-    RHASH_IFNONE(hash) = IFNONE(self);
+    RHASH_SET_IFNONE(hash, IFNONE(self));
     if (FL_TEST(self, RBTREE_PROC_DEFAULT))
         FL_SET(hash, HASH_PROC_DEFAULT);
     OBJ_INFECT(hash, self);
@@ -1308,10 +1317,10 @@ rbtree_to_rbtree(VALUE self)
 static VALUE
 rbtree_begin_inspect(VALUE self)
 {
-    volatile VALUE class_name = rb_class_name(CLASS_OF(self));
-    VALUE str = rb_str_new(NULL, RSTRING_LEN(class_name) + 4);
-    sprintf(RSTRING_PTR(str), "#<%s: ", RSTRING_PTR(class_name));
-    return str;
+    VALUE result = rb_str_new2("#<");
+    rb_str_cat2(result, rb_obj_classname(self));
+    rb_str_cat2(result, ": ");
+    return result;
 }
 
 static each_return_t
@@ -1480,8 +1489,8 @@ rbtree_bound_body(rbtree_bound_arg_t* arg)
 static VALUE
 rbtree_bound_size(VALUE self, VALUE args)
 {
-    VALUE key1 = RARRAY_PTR(args)[0];
-    VALUE key2 = RARRAY_PTR(args)[RARRAY_LEN(args) - 1];
+    VALUE key1 = RARRAY_AREF(args, 0);
+    VALUE key2 = RARRAY_AREF(args, RARRAY_LEN(args) - 1);
     dnode_t* lower_node = dict_lower_bound(DICT(self), TO_KEY(key1));
     dnode_t* upper_node = dict_upper_bound(DICT(self), TO_KEY(key2));
     dictcount_t count = 0;
@@ -1536,9 +1545,7 @@ rbtree_bound(int argc, VALUE* argv, VALUE self)
     dnode_t* upper_node;
     VALUE result;
     
-    if (argc == 0 || argc > 2) {
-        rbtree_argc_error(argc, 1, 2);
-    }
+    rbtree_check_argument_count(argc, 1, 2);
     
     RETURN_SIZED_ENUMERATOR(self, argc, argv, rbtree_bound_size);
     
@@ -1633,17 +1640,16 @@ rbtree_readjust(int argc, VALUE* argv, VALUE self)
     rbtree_modify(self);
 
     if (rb_block_given_p()) {
-        if (argc != 0) {
-            rbtree_argc_error(argc, 0, 0);
-        }
+        rbtree_check_argument_count(argc, 0, 0);
         cmp_func = rbtree_user_cmp;
         cmp_proc = rb_block_proc();
         rbtree_check_proc_arity(cmp_proc, 2);
     } else {
+        rbtree_check_argument_count(argc, 0, 1);
         if (argc == 0) {
             cmp_func = DICT(self)->dict_compare;
             cmp_proc = CMP_PROC(self);
-        } else if (argc == 1) {
+        } else {
             if (NIL_P(argv[0])) {
                 cmp_func = rbtree_cmp;
                 cmp_proc = Qnil;
@@ -1658,8 +1664,6 @@ rbtree_readjust(int argc, VALUE* argv, VALUE self)
                 cmp_proc = proc;
                 rbtree_check_proc_arity(cmp_proc, 2);
             }
-        } else {
-            rbtree_argc_error(argc, 0, 1);
         }
     }
 
@@ -1828,14 +1832,6 @@ rbtree_pretty_print_cycle(VALUE self, VALUE pp)
 
 /*********************************************************************/
 
-static each_return_t
-to_flat_ary_i(dnode_t* node, void* ary)
-{
-    rb_ary_push((VALUE)ary, GET_KEY(node));
-    rb_ary_push((VALUE)ary, GET_VAL(node));
-    return EACH_NEXT;
-}
-
 /* :nodoc:
  *
  */
@@ -1855,8 +1851,11 @@ rbtree_dump(VALUE self, VALUE limit)
     rb_ary_push(ary, IFNONE(self));
 
     result = rb_marshal_dump(ary, limit);
+#ifdef HAVE_RB_ARY_RESIZE
+    rb_ary_resize(ary, 0);
+#else
     rb_ary_clear(ary);
-    rb_gc_force_recycle(ary);
+#endif
     return result;
 }
 
@@ -1868,16 +1867,18 @@ rbtree_s_load(VALUE klass, VALUE str)
 {
     VALUE rbtree = rbtree_alloc(klass);
     VALUE ary = rb_marshal_load(str);
-    VALUE* ptr = RARRAY_PTR(ary);
     long len = RARRAY_LEN(ary) - 1;
     long i;
     
     for (i = 0; i < len; i += 2)
-        rbtree_aset(rbtree, ptr[i], ptr[i + 1]);
-    IFNONE(rbtree) = ptr[len];
+        rbtree_aset(rbtree, RARRAY_AREF(ary, i), RARRAY_AREF(ary, i + 1));
+    IFNONE(rbtree) = RARRAY_AREF(ary, len);
     
+#ifdef HAVE_RB_ARY_RESIZE
+    rb_ary_resize(ary, 0);
+#else
     rb_ary_clear(ary);
-    rb_gc_force_recycle(ary);
+#endif
     return rbtree;
 }
 

data/test.rb

@@ -11,6 +11,10 @@ class RBTreeTest < Test::Unit::TestCase
     @rbtree = RBTree[*%w(b B d D a A c C)]
   end
   
+  def have_enumerator?
+    defined?(Enumerable::Enumerator) or defined?(Enumerator)
+  end
+  
   def test_new
     assert_nothing_raised {
       RBTree.new
@@ -250,12 +254,6 @@ class RBTreeTest < Test::Unit::TestCase
       b[1] = b
       assert_equal(a, b)
     end
-    
-    # a = RBTree.new
-    # a[1] = a
-    # b = RBTree.new
-    # b[1] = a
-    # assert_not_equal(a, b)
   end
   
   def test_fetch
@@ -304,7 +302,7 @@ class RBTreeTest < Test::Unit::TestCase
     }
     assert_equal(4, @rbtree.size)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       enumerator = @rbtree.each
       assert_equal(%w(a A b B c C d D), enumerator.to_a.flatten)
     end
@@ -329,7 +327,7 @@ class RBTreeTest < Test::Unit::TestCase
     }
     assert_equal(4, @rbtree.size)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       enumerator = @rbtree.each_key
       assert_equal(%w(a b c d), enumerator.to_a.flatten)
     end
@@ -354,7 +352,7 @@ class RBTreeTest < Test::Unit::TestCase
     }
     assert_equal(4, @rbtree.size)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       enumerator = @rbtree.each_value
       assert_equal(%w(A B C D), enumerator.to_a.flatten)
     end
@@ -428,7 +426,7 @@ class RBTreeTest < Test::Unit::TestCase
     }
     assert_equal(0, @rbtree.size)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       rbtree = RBTree[*%w(b B d D a A c C)]
       rbtree.delete_if.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(c C d D)], rbtree)
@@ -440,7 +438,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_same(@rbtree, result)
     assert_equal(RBTree[*%w(a A b B)], @rbtree)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       rbtree = RBTree[*%w(b B d D a A c C)]
       rbtree.keep_if.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(a A b B)], rbtree)
@@ -456,7 +454,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_same(@rbtree, result)
     assert_equal(RBTree[*%w(c C d D)], result)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       rbtree = RBTree[*%w(b B d D a A c C)]
       rbtree.reject!.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(c C d D)], rbtree)
@@ -472,7 +470,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal(RBTree[*%w(c C d D)], result)
     assert_equal(4, @rbtree.size)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       result = @rbtree.reject.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(c C d D)], result)
     end
@@ -487,7 +485,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_same(@rbtree, result)
     assert_equal(RBTree[*%w(a A b B)], result)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       rbtree = RBTree[*%w(b B d D a A c C)]
       rbtree.select!.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(a A b B)], rbtree)
@@ -503,7 +501,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal(RBTree[*%w(a A b B)], result)
     assert_raises(ArgumentError) { @rbtree.select("c") }
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       result = @rbtree.select.with_index {|(key, val), i| i < 2 }
       assert_equal(RBTree[*%w(a A b B)], result)
     end
@@ -554,13 +552,13 @@ class RBTreeTest < Test::Unit::TestCase
       rbtree[["a"]] = ["A"]
       rbtree[[["b"]]] = [["B"]]
       assert_equal([["a"], ["A"], [["b"]], [["B"]]], rbtree.flatten)
-      assert_equal([[["a"], ["A"]], [[["b"]], [["B"]]]], rbtree.flatten(0))
+      assert_equal([["a"], ["A"], [["b"]], [["B"]]], rbtree.flatten(0))
       assert_equal([["a"], ["A"], [["b"]], [["B"]]], rbtree.flatten(1))
       assert_equal(["a", "A", ["b"], ["B"]], rbtree.flatten(2))
       assert_equal(["a", "A", "b", "B"], rbtree.flatten(3))
       
       assert_raises(TypeError) { @rbtree.flatten("e") }
-      assert_raises(ArgumentError) { @rbtree.flatten(2, 2) } 
+      assert_raises(ArgumentError) { @rbtree.flatten(1, 2) } 
     end
   end
 
@@ -669,7 +667,7 @@ class RBTreeTest < Test::Unit::TestCase
     assert_equal([], rbtree.bound("Y", "Z").to_a)
     assert_equal([], rbtree.bound("f", "g").to_a)
     assert_equal([], rbtree.bound("f", "Z").to_a)
-  
+    
     if defined?(Enumerator) and Enumerator.method_defined?(:size)
       assert_equal(2, rbtree.bound("a", "c").size)
       assert_equal(1, rbtree.bound("a").size)
@@ -821,7 +819,7 @@ class RBTreeTest < Test::Unit::TestCase
     @rbtree.reverse_each { |key, val| result.push([key, val]) }
     assert_equal(%w(d D c C b B a A), result.flatten)
     
-    if defined?(Enumerable::Enumerator) or defined?(Enumerator)
+    if have_enumerator?
       enumerator = @rbtree.reverse_each
       assert_equal(%w(d D c C b B a A), enumerator.to_a.flatten)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbtree
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - OZAWA Takuma
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-29 00:00:00.000000000 Z
+date: 2013-12-26 00:00:00.000000000 Z
 dependencies: []
 description: |
   A RBTree is a sorted associative collection that is implemented with a
@@ -38,27 +38,27 @@ licenses:
 metadata: {}
 post_install_message: 
 rdoc_options:
-- --title
+- "--title"
 - Ruby/RBTree
-- --main
+- "--main"
 - README
-- --exclude
-- \A(?!README|rbtree\.c).*\z
+- "--exclude"
+- "\\A(?!README|rbtree\\.c).*\\z"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.8.6
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: rbtree
-rubygems_version: 2.0.0
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A sorted associative collection.