rbtree 0.4.5 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5bc8dc390afc34242d6cd951136f2d86c9a0bafc809ed93d39d0fdf6c8ea9c0
-  data.tar.gz: '059f888a97995d9bc64edcdafb504817b570e07df03c3385e5c5fe3e8bbc8f72'
+  metadata.gz: 72f18733355c87536d364795cdd7fcf58df0da573a6783c990640421e2a86053
+  data.tar.gz: 36a91f75a7fe0dd31124dc59484728d418c76571e9f998e37c9df7aaa3ff8688
 SHA512:
-  metadata.gz: 9a27e36148fab48e03777b3151dc70ee69262da497263bf83cc25c3b9c6b8c7080857cd75c0d2ac8b3837f511d8a448565f1ae64b1da7740dd26b6ec4fca955a
-  data.tar.gz: 9f682a9ce24a0cd3ff101d91cc145fbed066de4788cbb5b25abecfc1604c0e0065d1dc5d35d0f35d10df911bde971ab9f18edafd84030ae5309ce578be6cbc35
+  metadata.gz: c3d86bf49df4a5e270ff242203dd0f7af50f4588392766b20274678b441dd09f622621312817799073e0f3edb2a0246bc62667dcd36faa5c168198d6d7fa97b2
+  data.tar.gz: f9fb843cd939997bbb4231f85f7eedd48b51c37b32200835567f4875130fc84ac9cc546a82e908567338e40d6874cc0fbd3658216aae2ec09a110c446c7413fb

data/README

@@ -57,6 +57,12 @@ Run the following command.
   $ sudo gem install rbtree
 
 == Changes
+=== 0.4.7
+* Use the typed data API, as the untyped data API will be removed in Ruby 4.1.
+
+=== 0.4.6
+* Make it work with clang 15.
+
 === 0.4.5
 * Support Ruby 3.2.0-dev (development branch).
 

data/extconf.rb

@@ -5,14 +5,6 @@ if enable_config('debug')
 else
   $defs << '-DNDEBUG'
 end
-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')
 have_func('rb_safe_level', 'ruby.h')
 have_func('rb_cData', 'ruby.h')
-if Hash.method_defined?(:flatten)
-  $defs << '-DHAVE_HASH_FLATTEN'
-end
 create_makefile('rbtree')

data/rbtree.c

@@ -3,6 +3,9 @@
  * Copyright (c) 2002-2013 OZAWA Takuma
  */
 #include <ruby.h>
+#ifdef HAVE_RUBY_VERSION_H
+#include <ruby/version.h>
+#endif
 #ifdef HAVE_RUBY_ST_H
 #include <ruby/st.h>
 #else
@@ -13,24 +16,6 @@
 #define RBTREE_PROC_DEFAULT FL_USER2
 #define HASH_PROC_DEFAULT   FL_USER2
 
-#ifdef RETURN_SIZED_ENUMERATOR
-#define HAVE_SIZED_ENUMERATOR
-#else
-#ifdef RETURN_ENUMERATOR
-#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) RETURN_ENUMERATOR(obj, argc, argv)
-#else
-#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) ((void)0)
-#endif
-#endif
-
-#ifndef RARRAY_AREF
-#define RARRAY_AREF(a, i) (RARRAY_PTR(a)[i])
-#endif
-
-#ifndef RHASH_SET_IFNONE
-#define RHASH_SET_IFNONE(h, v) (RHASH(h)->ifnone = (v))
-#endif
-
 VALUE RBTree;
 VALUE MultiRBTree;
 
@@ -61,16 +46,18 @@ typedef struct {
 /*********************************************************************/
 
 static void
-rbtree_free(rbtree_t* rbtree)
+rbtree_free(void* arg)
 {
+    rbtree_t* rbtree = arg;
     dict_free_nodes(rbtree->dict);
     xfree(rbtree->dict);
     xfree(rbtree);
 }
 
 static void
-rbtree_mark(rbtree_t* rbtree)
+rbtree_mark(void* arg)
 {
+    rbtree_t* rbtree = arg;
     if (rbtree == NULL) return;
 
     if (rbtree->dict != NULL) {
@@ -88,6 +75,15 @@ rbtree_mark(rbtree_t* rbtree)
     rb_gc_mark(rbtree->cmp_proc);
 }
 
+#ifdef TypedData_Make_Struct
+static const rb_data_type_t rbtree_type = {
+    "RBTree",
+    {
+        rbtree_mark, rbtree_free,
+    },
+};
+#endif
+
 static dnode_t*
 rbtree_alloc_node(void* context)
 {
@@ -118,7 +114,6 @@ rbtree_check_argument_count(const int argc, const int min, const int max)
 static void
 rbtree_check_proc_arity(VALUE proc, const int expected)
 {
-#ifdef HAVE_RB_PROC_LAMBDA_P
     if (rb_proc_lambda_p(proc)) {
         const int arity = rb_proc_arity(proc);
         const int min = arity < 0 ? -arity - 1 : arity;
@@ -127,29 +122,30 @@ rbtree_check_proc_arity(VALUE proc, const int expected)
             rb_raise(rb_eTypeError, "proc takes %d arguments", expected);
         }
     }
-#endif
 }
 
 static int
 rbtree_cmp(const void* key1, const void* key2, void* context)
 {
     VALUE result;
-    if (TYPE(key1) == T_STRING && TYPE(key2) == T_STRING)
+    if (TYPE((VALUE)key1) == T_STRING && TYPE((VALUE)key2) == T_STRING)
         return rb_str_cmp((VALUE)key1, (VALUE)key2);
     result = rb_funcall2((VALUE)key1, id_cmp, 1, (VALUE*)&key2);
     return rb_cmpint(result, (VALUE)key1, (VALUE)key2);
 }
 
 static VALUE
-rbtree_user_cmp_ensure(rbtree_t* rbtree)
+rbtree_user_cmp_ensure(VALUE arg)
 {
+    rbtree_t* rbtree = (rbtree_t*)arg;
     rbtree->iter_lev--;
     return Qnil;
 }
 
 static VALUE
-rbtree_user_cmp_body(VALUE* args)
+rbtree_user_cmp_body(VALUE arg)
 {
+    VALUE *args = (VALUE*)arg;
     rbtree_t* rbtree = (rbtree_t*)args[2];
     rbtree->iter_lev++;
     return rb_funcall2(rbtree->cmp_proc, id_call, 2, args);
@@ -186,20 +182,22 @@ static VALUE
 rbtree_alloc(VALUE klass)
 {
     dict_t* dict;
-    VALUE rbtree = Data_Wrap_Struct(klass, rbtree_mark, rbtree_free, NULL);
-    RBTREE(rbtree) = ALLOC(rbtree_t);
-    MEMZERO(RBTREE(rbtree), rbtree_t, 1);
+    rbtree_t *t;
+#ifdef TypedData_Make_Struct
+    VALUE rbtree = TypedData_Make_Struct(klass, rbtree_t, &rbtree_type, t);
+#else
+    VALUE rbtree = Data_Make_Struct(klass, rbtree_mark, rbtree_free, t);
+#endif
 
     dict = ALLOC(dict_t);
     dict_init(dict, rbtree_cmp);
-    dict_set_allocator(dict, rbtree_alloc_node, rbtree_free_node,
-                       RBTREE(rbtree));
+    dict_set_allocator(dict, rbtree_alloc_node, rbtree_free_node, t);
     if (!RTEST(rb_class_inherited_p(klass, RBTree)))
         dict_allow_dupes(dict);
 
-    DICT(rbtree) = dict;
-    IFNONE(rbtree) = Qnil;
-    CMP_PROC(rbtree) = Qnil;
+    t->dict = dict;
+    t->ifnone = Qnil;
+    t->cmp_proc = Qnil;
     return rbtree;
 }
 
@@ -323,8 +321,9 @@ typedef struct {
 } rbtree_insert_arg_t;
 
 static VALUE
-insert_node_body(rbtree_insert_arg_t* arg)
+insert_node_body(VALUE arg_)
 {
+    rbtree_insert_arg_t* arg = (rbtree_insert_arg_t*)arg_;
     dict_t* dict = arg->dict;
     dnode_t* node = arg->node;
 
@@ -341,8 +340,9 @@ insert_node_body(rbtree_insert_arg_t* arg)
 }
 
 static VALUE
-insert_node_ensure(rbtree_insert_arg_t* arg)
+insert_node_ensure(VALUE arg_)
 {
+    rbtree_insert_arg_t* arg = (rbtree_insert_arg_t*)arg_;
     dict_t* dict = arg->dict;
     dnode_t* node = arg->node;
 
@@ -562,13 +562,7 @@ rbtree_equal(VALUE self, VALUE other)
 
         return Qfalse;
     }
-#if defined(HAVE_RB_EXEC_RECURSIVE_PAIRED)
     return rb_exec_recursive_paired(rbtree_recursive_equal, self, other, other);
-#elif defined(HAVE_RB_EXEC_RECURSIVE)
-    return rb_exec_recursive(rbtree_recursive_equal, self, other);
-#else
-    return rbtree_recursive_equal(self, other, 0);
-#endif
 }
 
 /*********************************************************************/
@@ -594,8 +588,9 @@ rbtree_each_ensure(VALUE self)
 }
 
 static VALUE
-rbtree_each_body(rbtree_each_arg_t* arg)
+rbtree_each_body(VALUE arg_)
 {
+    rbtree_each_arg_t* arg = (rbtree_each_arg_t*)arg_;
     VALUE self = arg->self;
     dict_t* dict = DICT(self);
     dnode_t* node;
@@ -749,11 +744,7 @@ 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;
 
@@ -765,7 +756,11 @@ copy_dict(VALUE src, VALUE dest, dict_comp_t cmp_func, VALUE cmp_proc)
     }
     rbtree_free(RBTREE(temp));
     RBTREE(temp) = NULL;
+#if defined(RUBY_API_VERSION_CODE) && RUBY_API_VERSION_CODE >= 30100
+    /* do nothing */
+#else
     rb_gc_force_recycle(temp);
+#endif
 
     DICT(dest)->dict_context = RBTREE(dest);
     CMP_PROC(dest) = cmp_proc;
@@ -892,8 +887,9 @@ typedef struct {
 } rbtree_remove_if_arg_t;
 
 static VALUE
-rbtree_remove_if_ensure(rbtree_remove_if_arg_t* arg)
+rbtree_remove_if_ensure(VALUE arg_)
 {
+    rbtree_remove_if_arg_t* arg = (rbtree_remove_if_arg_t*)arg_;
     dict_t* dict = DICT(arg->self);
     dnode_list_t* list = arg->list;
 
@@ -910,8 +906,9 @@ rbtree_remove_if_ensure(rbtree_remove_if_arg_t* arg)
 }
 
 static VALUE
-rbtree_remove_if_body(rbtree_remove_if_arg_t* arg)
+rbtree_remove_if_body(VALUE arg_)
 {
+    rbtree_remove_if_arg_t* arg = (rbtree_remove_if_arg_t*)arg_;
     VALUE self = arg->self;
     dict_t* dict = DICT(self);
     dnode_t* node;
@@ -1269,6 +1266,13 @@ to_a_i(dnode_t* node, void* ary)
     return EACH_NEXT;
 }
 
+
+#if defined(RUBY_API_VERSION_CODE) && RUBY_API_VERSION_CODE >= 30100
+#  define RBTREE_OBJ_INFECT(obj1, obj2)
+#else
+#  define RBTREE_OBJ_INFECT(obj1, obj2) OBJ_INFECT(obj1, obj2)
+#endif
+
 /*
  *
  */
@@ -1277,7 +1281,7 @@ rbtree_to_a(VALUE self)
 {
     VALUE ary = rb_ary_new2(dict_count(DICT(self)));
     rbtree_for_each(self, to_a_i, (void*)ary);
-    OBJ_INFECT(ary, self);
+    RBTREE_OBJ_INFECT(ary, self);
     return ary;
 }
 
@@ -1303,7 +1307,7 @@ rbtree_to_hash(VALUE self)
     RHASH_SET_IFNONE(hash, IFNONE(self));
     if (FL_TEST(self, RBTREE_PROC_DEFAULT))
         FL_SET(hash, HASH_PROC_DEFAULT);
-    OBJ_INFECT(hash, self);
+    RBTREE_OBJ_INFECT(hash, self);
     return hash;
 }
 
@@ -1338,13 +1342,13 @@ inspect_i(dnode_t* node, void* result_)
 
     str = rb_inspect(GET_KEY(node));
     rb_str_append(result, str);
-    OBJ_INFECT(result, str);
+    RBTREE_OBJ_INFECT(result, str);
 
     rb_str_cat2(result, "=>");
 
     str = rb_inspect(GET_VAL(node));
     rb_str_append(result, str);
-    OBJ_INFECT(result, str);
+    RBTREE_OBJ_INFECT(result, str);
 
     return EACH_NEXT;
 }
@@ -1363,15 +1367,15 @@ inspect_rbtree(VALUE self, VALUE result)
     str = rb_inspect(IFNONE(self));
     rb_str_cat2(result, ", default=");
     rb_str_append(result, str);
-    OBJ_INFECT(result, str);
+    RBTREE_OBJ_INFECT(result, str);
 
     str = rb_inspect(CMP_PROC(self));
     rb_str_cat2(result, ", cmp_proc=");
     rb_str_append(result, str);
-    OBJ_INFECT(result, str);
+    RBTREE_OBJ_INFECT(result, str);
 
     rb_str_cat2(result, ">");
-    OBJ_INFECT(result, self);
+    RBTREE_OBJ_INFECT(result, self);
     return result;
 }
 
@@ -1390,14 +1394,7 @@ rbtree_inspect_recursive(VALUE self, VALUE arg, int recursive)
 VALUE
 rbtree_inspect(VALUE self)
 {
-#ifdef HAVE_RB_EXEC_RECURSIVE
     return rb_exec_recursive(rbtree_inspect_recursive, self, Qnil);
-#else
-    VALUE str = rbtree_begin_inspect(self);
-    if (rb_inspecting_p(self))
-        return rb_str_cat2(str, "...>");
-    return rb_protect_inspect(inspect_rbtree, self, str);
-#endif
 }
 
 /*
@@ -1462,8 +1459,9 @@ typedef struct {
 } rbtree_bound_arg_t;
 
 static VALUE
-rbtree_bound_body(rbtree_bound_arg_t* arg)
+rbtree_bound_body(VALUE arg_)
 {
+    rbtree_bound_arg_t* arg = (rbtree_bound_arg_t*)arg_;
     VALUE self = arg->self;
     dict_t* dict = DICT(self);
     dnode_t* lower_node = arg->lower_node;
@@ -1487,7 +1485,6 @@ rbtree_bound_body(rbtree_bound_arg_t* arg)
     return result;
 }
 
-#ifdef HAVE_SIZED_ENUMERATOR
 static VALUE
 rbtree_bound_size(VALUE self, VALUE args)
 {
@@ -1516,7 +1513,6 @@ rbtree_bound_size(VALUE self, VALUE args)
     }
     return ULONG2NUM(count);
 }
-#endif
 
 /*********************************************************************/
 
@@ -1702,10 +1698,9 @@ static ID id_pp;
 static ID id_text;
 
 static VALUE
-pp_group(VALUE args_)
+call_group_with_block(VALUE *group_args, VALUE (*blk)(RB_BLOCK_CALL_FUNC_ARGLIST(nil, arg)), VALUE data)
 {
-    VALUE* args = (VALUE*)args_;
-    return rb_funcall(args[0], id_group, 3, args[1], args[2], args[3]);
+    return rb_block_call(group_args[0], id_group, 3, group_args + 1, blk, data);
 }
 
 typedef struct {
@@ -1714,16 +1709,18 @@ typedef struct {
 } pp_pair_arg_t;
 
 static VALUE
-pp_value(VALUE nil, pp_pair_arg_t* pair_arg)
+pp_value(RB_BLOCK_CALL_FUNC_ARGLIST(nil, arg))
 {
+    pp_pair_arg_t* pair_arg = (pp_pair_arg_t*)arg;
     VALUE pp = pair_arg->pp;
     rb_funcall(pp, id_breakable, 1, rb_str_new(NULL, 0));
     return rb_funcall(pp, id_pp, 1, GET_VAL(pair_arg->node));
 }
 
 static VALUE
-pp_pair(VALUE nil, pp_pair_arg_t* pair_arg)
+pp_pair(RB_BLOCK_CALL_FUNC_ARGLIST(nil, arg))
 {
+    pp_pair_arg_t* pair_arg = (pp_pair_arg_t*)arg;
     VALUE pp = pair_arg->pp;
     VALUE group_args[4];
     group_args[0] = pp;
@@ -1733,7 +1730,7 @@ pp_pair(VALUE nil, pp_pair_arg_t* pair_arg)
 
     rb_funcall(pp, id_pp, 1, GET_KEY(pair_arg->node));
     rb_funcall(pp, id_text, 1, rb_str_new2("=>"));
-    return rb_iterate(pp_group, (VALUE)&group_args, pp_value, (VALUE)pair_arg);
+    return call_group_with_block(group_args, pp_value, (VALUE)pair_arg);
 }
 
 typedef struct {
@@ -1762,7 +1759,7 @@ pp_each_pair_i(dnode_t* node, void* each_pair_arg_)
     pair_arg.pp = each_pair_arg->pp;
     pair_arg.node = node;
 
-    rb_iterate(pp_group, (VALUE)&group_args, pp_pair, (VALUE)&pair_arg);
+    call_group_with_block(group_args, pp_pair, (VALUE)&pair_arg);
     return EACH_NEXT;
 }
 
@@ -1772,8 +1769,9 @@ typedef struct {
 } pp_rbtree_arg_t;
 
 static VALUE
-pp_each_pair(VALUE nil, pp_rbtree_arg_t* rbtree_arg)
+pp_each_pair(RB_BLOCK_CALL_FUNC_ARGLIST(nil, arg))
 {
+    pp_rbtree_arg_t* rbtree_arg = (pp_rbtree_arg_t*)arg;
     pp_each_pair_arg_t each_pair_arg;
     each_pair_arg.pp = rbtree_arg->pp;
     each_pair_arg.first = 1;
@@ -1781,8 +1779,9 @@ pp_each_pair(VALUE nil, pp_rbtree_arg_t* rbtree_arg)
 }
 
 static VALUE
-pp_rbtree(VALUE nil, pp_rbtree_arg_t* rbtree_arg)
+pp_rbtree(RB_BLOCK_CALL_FUNC_ARGLIST(nil, arg))
 {
+    pp_rbtree_arg_t* rbtree_arg = (pp_rbtree_arg_t*)arg;
     VALUE pp = rbtree_arg->pp;
     VALUE rbtree = rbtree_arg->rbtree;
 
@@ -1793,7 +1792,7 @@ pp_rbtree(VALUE nil, pp_rbtree_arg_t* rbtree_arg)
     group_args[3] = rb_str_new2("}");
 
     rb_funcall(pp, id_text, 1, rb_str_new2(": "));
-    rb_iterate(pp_group, (VALUE)&group_args, pp_each_pair, (VALUE)rbtree_arg);
+    call_group_with_block(group_args, pp_each_pair, (VALUE)rbtree_arg);
     rb_funcall(pp, id_comma_breakable, 0);
     rb_funcall(pp, id_text, 1, rb_str_new2("default="));
     rb_funcall(pp, id_pp, 1, IFNONE(rbtree));
@@ -1802,13 +1801,6 @@ pp_rbtree(VALUE nil, pp_rbtree_arg_t* rbtree_arg)
     return rb_funcall(pp, id_pp, 1, CMP_PROC(rbtree));
 }
 
-static VALUE
-pp_rbtree_group(VALUE arg_)
-{
-    pp_rbtree_arg_t* arg = (pp_rbtree_arg_t*)arg_;
-    return rb_funcall(arg->pp, id_object_group, 1, arg->rbtree);
-}
-
 /*********************************************************************/
 
 /* :nodoc:
@@ -1820,7 +1812,7 @@ rbtree_pretty_print(VALUE self, VALUE pp)
     pp_rbtree_arg_t arg;
     arg.rbtree = self;
     arg.pp = pp;
-    return rb_iterate(pp_rbtree_group, (VALUE)&arg, pp_rbtree, (VALUE)&arg);
+    return rb_block_call(arg.pp, id_object_group, 1, &self, pp_rbtree, (VALUE)&arg);
 }
 
 /* :nodoc:
@@ -1853,11 +1845,7 @@ rbtree_dump(VALUE self, VALUE limit)
     rb_ary_push(ary, IFNONE(self));
 
     result = rb_marshal_dump(ary, Qnil);
-#ifdef HAVE_RB_ARY_RESIZE
     rb_ary_resize(ary, 0);
-#else
-    rb_ary_clear(ary);
-#endif
     return result;
 }
 
@@ -1876,11 +1864,7 @@ rbtree_s_load(VALUE klass, VALUE str)
         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);
-#endif
     return rbtree;
 }
 
@@ -1895,7 +1879,7 @@ rbtree_s_load(VALUE klass, VALUE str)
  * A sorted associative collection that cannot contain duplicate
  * keys. RBTree is a subclass of MultiRBTree.
  */
-void Init_rbtree()
+void Init_rbtree(void)
 {
     MultiRBTree = rb_define_class("MultiRBTree",
 #ifdef HAVE_RB_CDATA
@@ -1967,9 +1951,7 @@ void Init_rbtree()
     rb_define_method(MultiRBTree, "merge!", rbtree_update, 1);
     rb_define_method(MultiRBTree, "merge", rbtree_merge, 1);
     rb_define_method(MultiRBTree, "replace", rbtree_initialize_copy, 1);
-#ifdef HAVE_HASH_FLATTEN
     rb_define_method(MultiRBTree, "flatten", rbtree_flatten, -1);
-#endif
 
     rb_define_method(MultiRBTree, "include?", rbtree_has_key, 1);
     rb_define_method(MultiRBTree, "member?", rbtree_has_key, 1);