rbtree 0.4.4 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '068088a72443fb756ebedf00226f9e628552528fdb6a02a904bd984a9ab961b5'
-  data.tar.gz: 58c816a9433efa6680e7469db60810b6c9754949463143787bcc0979ad54a86a
+  metadata.gz: a5ec1fb39918d82821706cea18cb63b25fd4d20a989579664f7b95774f43881f
+  data.tar.gz: 3795d33cbbf811cdfd7b92664eca4156760c8d3bb36fa28a9854720279c6c1dd
 SHA512:
-  metadata.gz: 562b5482ebab8b47f3357e01f76abaa2f480c76a0316033704e783441b90234b4bb0933165204f421592efcf9c0376255c33fb14ce31cb96e82cb61b045ecafd
-  data.tar.gz: 81ff68b66a15597981ffdcecab5b1c49db8f73aa8b93e8b5f354d0072bd28282a4bce7fd0cacc90649006c9cc41c800abc03131b60bdae5c3b5ab3f783ea620c
+  metadata.gz: 3df17e8770de0b0e7396b454905ca5a1d1de24d2dc006de0283a29c9a0805b772442f510dd9ce66bbe590499128d5375da4e61ae7e8396abed455833204af79d
+  data.tar.gz: ba6402624a047e104e2ddb70a37b19f1d01c2ce7b88752f19c9396fd197c8b58c8e3e3daa21974038b1a44676ee2af40c220dfc1fd300ad6796590fecdca5e30

data/README

@@ -57,6 +57,12 @@ Run the following command.
   $ sudo gem install rbtree
 
 == Changes
+=== 0.4.6
+* Make it work with clang 15.
+
+=== 0.4.5
+* Support Ruby 3.2.0-dev (development branch).
+
 === 0.4.4
 * Remove the rb_safe_level warning on Ruby 2.7.
 

data/extconf.rb

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

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
@@ -134,22 +137,24 @@ 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);
@@ -323,8 +328,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 +347,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;
 
@@ -594,8 +601,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;
@@ -765,7 +773,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 +904,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 +923,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 +1283,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 +1298,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 +1324,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 +1359,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 +1384,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;
 }
 
@@ -1462,8 +1483,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;
@@ -1701,12 +1723,28 @@ static ID id_object_group;
 static ID id_pp;
 static ID id_text;
 
+#if defined(RUBY_VERSION_MAJOR) && RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8
+#define RUBY_1_8
+#endif
+
+#ifdef RUBY_1_8
 static VALUE
 pp_group(VALUE args_)
 {
     VALUE* args = (VALUE*)args_;
     return rb_funcall(args[0], id_group, 3, args[1], args[2], args[3]);
 }
+#endif
+
+static VALUE
+call_group_with_block(VALUE *group_args, VALUE (*blk)(RB_BLOCK_CALL_FUNC_ARGLIST(nil, arg)), VALUE data)
+{
+#ifdef RUBY_1_8
+    return rb_iterate(pp_group, (VALUE)&group_args, blk, data);
+#else
+    return rb_block_call(group_args[0], id_group, 3, group_args + 1, blk, data);
+#endif
+}
 
 typedef struct {
     VALUE pp;
@@ -1714,16 +1752,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 +1773,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 +1802,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 +1812,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 +1822,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 +1835,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,12 +1844,14 @@ pp_rbtree(VALUE nil, pp_rbtree_arg_t* rbtree_arg)
     return rb_funcall(pp, id_pp, 1, CMP_PROC(rbtree));
 }
 
+#ifdef RUBY_1_8
 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);
 }
+#endif
 
 /*********************************************************************/
 
@@ -1820,7 +1864,11 @@ rbtree_pretty_print(VALUE self, VALUE pp)
     pp_rbtree_arg_t arg;
     arg.rbtree = self;
     arg.pp = pp;
+#ifdef RUBY_1_8
     return rb_iterate(pp_rbtree_group, (VALUE)&arg, pp_rbtree, (VALUE)&arg);
+#else
+    return rb_block_call(arg.pp, id_object_group, 1, &self, pp_rbtree, (VALUE)&arg);
+#endif
 }
 
 /* :nodoc:
@@ -1895,9 +1943,15 @@ 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", rb_cData);
+    MultiRBTree = rb_define_class("MultiRBTree",
+#ifdef HAVE_RB_CDATA
+        rb_cData
+#else
+        rb_cObject
+#endif
+    );
     RBTree = rb_define_class("RBTree", MultiRBTree);
 
     rb_include_module(MultiRBTree, rb_mEnumerable);

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbtree
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.6
 platform: ruby
 authors:
 - OZAWA Takuma
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-01 00:00:00.000000000 Z
+date: 2022-12-10 00:00:00.000000000 Z
 dependencies: []
 description: |
   A RBTree is a sorted associative collection that is implemented with a
@@ -57,9 +57,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.4.0.dev
 signing_key:
 specification_version: 4
 summary: A sorted associative collection.
-test_files:
-- test.rb
+test_files: []