kanayago 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7dc8924bd1972c79a19ec99a5317d3805ec71536f4f53e11ee12e11930c16af2
-  data.tar.gz: a7ef01c1049b9e4132299b21a58b37ecd61fd18813f5f9208a02f6950d3b46fa
+  metadata.gz: 6b8dcde5a49288a284edf3323cc0279740a923e0ea85d895571dcfa1be774970
+  data.tar.gz: 5c7bf5ef11155f14e6b8f2049bd344228c10089cb430b4d4c453a7b02e94bdb5
 SHA512:
-  metadata.gz: 29da7596273da188566563726bd3cd26fde141ec06c30cad03ddc0b52ccc7083815c125425d011a14e253fc070fecf71831d56523064f8fbfbc9bca3fc3d7da2
-  data.tar.gz: 03c77678bee8697c788a9ef5d7f9e65db5014608ba41f0d9e2223f1b1cfd96195aa8379d05482a404deeaa9d9b17dd72c3f015cf889b9f74b8e29255e356e8d1
+  metadata.gz: ce3d04f88db918e619f94195b2ca33cae122466b502a56df3e399acfadc7e4ed193ff045b0d12e326ff2fbeb4435587ce75507a02c7a1185c4f3a0290f7d3935
+  data.tar.gz: 0a3981c9eae87d6fd12ff320a3f3d8759c78830b2936569c604e7c1c82ca614f2ba07c2d1e97b2c765c81ed4eb0b7e63424af75e8342320c8bc0134fb69aa3b5

data/.rubocop.yml

@@ -1,13 +1,25 @@
 inherit_from: .rubocop_todo.yml
 
+AllCops:
+  NewCops: enable
+
 Metrics/BlockLength:
   Exclude:
     - Rakefile
     - kanayago.gemspec
 
+Metrics/AbcSize:
+  Enabled: false
+
+Minitest/MultipleAssertions:
+  Enabled: false
+
 RBS:
   Enabled: true
 
+Style/Documentation:
+  Enabled: false
+
 require:
   - rubocop-minitest
   - rubocop-on-rbs

data/.ruby-version

@@ -0,0 +1 @@
+ruby-dev

data/README.md

@@ -1,16 +1,21 @@
-# Kanayago
+# Kanayago(金屋子)
 
 Trying to Make Ruby's Parser Available as a Gem.
 
-## Installation
+## Support Ruby version
 
-First, install Ruby master with Universal Parser.
+Kanayago(金屋子)　is supported Ruby 3.4 or Ruby head.
+
+## Installation
+### From RubyGems
 
-```console
-RUBY_CONFIGURE_OPTS="cppflags=-DUNIVERSAL_PARSER" rbenv install ruby-dev
 ```
+gem install kanayago
+```
+
+### Build and Install in local
 
-Clone this repository.
+First, clone this repository.
 
 ```console
 git clone https://github.com/S-H-GAMELINKS/kanayago.git
@@ -26,7 +31,7 @@ Finally, build `Kanayago` gem  and install it.
 
 ```console
 bundle exec rake build
-gem install pkg/kanayago-0.1.0.gem
+gem install pkg/kanayago-0.2.0.gem
 ```
 
 ## Usage
@@ -35,29 +40,15 @@ gem install pkg/kanayago-0.1.0.gem
 require 'kanayago/kanayago'
 
 result = Kanayago.parse('117 + 117')
+# => #<Kanayago::ScopeNode:0x00007f522199c5a8>
+
+p result.body
+# => #<Kanayago::OperatorCallNode:0x00007f5221b06358>
 
-p result
-# =>
-#{
-#  "NODE_SCOPE" => {
-#    "args" => nil,
-#    "body" => {
-#      "NODE_OPCALL" => {
-#        "recv" => {
-#          "NODE_INTEGER" => 117
-#        },
-#        "mid" => :+,
-#        "args" => {
-#          "NODE_LIST" => [
-#            {
-#              "NODE_INTEGER"=>117
-#            }
-#          ]
-#        }
-#      }
-#    }
-#  }
-#}
+p result.body.recv
+p result.body.recv.val
+# => #<Kanayago::IntegerNode:0x00007f5221b06330>
+# => 117
 ```
 
 ## Development

data/Rakefile

@@ -7,95 +7,36 @@ require 'test_queue'
 require 'test_queue/runner/minitest'
 require 'fileutils'
 
-COPY_TARGETS = %w[
-  ccan/check_type/check_type.h
-  ccan/container_of/container_of.h
-  ccan/list/list.h
-  ccan/str/str.h
-  constant.h
-  id_table.h
-  internal/array.h
-  internal/basic_operators.h
-  internal/bignum.h
-  internal/bits.h
-  internal/compile.h
-  internal/compilers.h
-  internal/complex.h
-  internal/encoding.h
-  internal/error.h
-  internal/fixnum.h
-  internal/gc.h
-  internal/hash.h
-  internal/imemo.h
-  internal/io.h
-  internal/numeric.h
-  internal/parse.h
-  internal/rational.h
-  internal/re.h
-  internal/ruby_parser.h
-  internal/sanitizers.h
-  internal/serial.h
-  internal/static_assert.h
-  internal/string.h
-  internal/symbol.h
-  internal/thread.h
-  internal/variable.h
-  internal/warnings.h
-  internal/vm.h
-  internal.h
-  method.h
-  node.c
-  node.h
-  parse.y
-  parser_bits.h
-  parser_node.h
-  parser_st.c
-  parser_st.h
-  parser_value.h
-  ruby_assert.h
-  ruby_atomic.h
-  ruby_parser.c
-  rubyparser.h
-  shape.h
-  st.c
-  symbol.h
-  thread_pthread.h
-  universal_parser.c
-  vm_core.h
-  vm_opts.h
-].freeze
+if RUBY_DESCRIPTION.include?('dev')
+  require_relative 'patch/head/copy_target'
+else
+  require_relative "patch/#{RUBY_VERSION[0..2]}/copy_target"
+end
 
 namespace :ruby_parser do
   desc 'import ruby parser files'
   task :import do
-    `git clone https://github.com/ruby/ruby.git tmp/ruby --depth=1`
+    tar_name = if RUBY_DESCRIPTION.include?('dev')
+                 'snapshot/snapshot-master.tar.gz'
+               else
+                 "#{RUBY_VERSION[0..2]}/ruby-#{RUBY_VERSION}.tar.gz"
+               end
+
+    `mkdir -p tmp/ruby`
+    `curl -L https://cache.ruby-lang.org/pub/ruby/#{tar_name} -o tmp/ruby.tar.gz`
+    `tar -zxvf tmp/ruby.tar.gz -C tmp/ruby --strip-components 1`
 
     dist = File.expand_path('ext/kanayago', __dir__)
     ruby_dir = File.expand_path('tmp/ruby', __dir__)
 
-    directories = ['ccan', 'ccan/check_type', 'ccan/container', 'ccan/container_of', 'ccan/list', 'ccan/str',
-                   'internal']
-
-    directories.each do |dir|
-      Dir.mkdir File.join(dist, dir)
+    MAKE_DIRECTORIES.each do |dir|
+      Dir.mkdir File.join(dist, dir) unless Dir.exist? dir
     end
 
-    COPY_TARGETS.each do |target|
+    RUBY_PARSER_COPY_TARGETS.each do |target|
       FileUtils.cp File.join(ruby_dir, target), File.join(dist, target)
     end
 
-    # "parse.tmp.y"
-    id2token_path = File.join(ruby_dir, 'tool/id2token.rb')
-    parse_y_path = File.join(dist, 'parse.y')
-    parse_tmp_y_path = File.join(dist, 'parse.tmp.y')
-    sh "ruby #{id2token_path} #{parse_y_path} > #{parse_tmp_y_path}"
-
-    # "id.h"
-    generic_erb_path = File.join(ruby_dir, 'tool/generic_erb.rb')
-    id_h_tmpl_path = File.join(ruby_dir, 'template/id.h.tmpl')
-    id_h_path = File.join(dist, 'id.h')
-    sh "ruby #{generic_erb_path} --output=#{id_h_path} #{id_h_tmpl_path}"
-
     # "probes.h"
     probes_h_path = File.join(dist, 'probes.h')
     File.open(probes_h_path, 'w+') do |f|
@@ -107,29 +48,25 @@ namespace :ruby_parser do
       SRC
     end
 
-    # "node_name.inc"
-    node_name_path = File.join(ruby_dir, 'tool/node_name.rb')
-    rubyparser_h_path = File.join(dist, 'rubyparser.h')
-    node_name_inc_path = File.join(dist, 'node_name.inc')
-    sh "ruby -n #{node_name_path} < #{rubyparser_h_path} > #{node_name_inc_path}"
-
-    # "lex.c"
-    sh 'cd tmp/ruby && ./autogen.sh && ./configure && make'
-    FileUtils.mv File.join(ruby_dir, 'lex.c'), File.join(dist, 'lex.c')
-
-    `rm -rf tmp/ruby`
+    `rm -rf tmp/ruby tmp/ruby.tar.gz`
   end
 
-  desc 'build ruby parse.c and parse.h with lrama'
-  task :build do
-    sh 'bundle exec lrama -oext/kanayago/parse.c -Hext/kanayago/parse.h ext/kanayago/parse.tmp.y'
+  desc 'patched ro ruby parse that build for Kanayago'
+  task :patch do
+    running_ruby_version = if RUBY_DESCRIPTION.include?('dev')
+                             'head'
+                           else
+                             RUBY_VERSION[..2]
+                           end
+
+    sh "patch -p1 < patch/#{running_ruby_version}/kanayago.patch"
   end
 
   desc 'clean to ruby parser file'
   task :clean do
     dist = File.expand_path('./ext/kanayago')
 
-    COPY_TARGETS.each do |target|
+    RUBY_PARSER_COPY_TARGETS.each do |target|
       FileUtils.rm File.join(dist, target), force: true
     end
     delete_files = ['constant.h', 'id.h', 'id.h', 'id.h', 'id_table.h', 'lex.c', 'node_name.inc', 'parse.c', 'parse.h',
@@ -139,16 +76,14 @@ namespace :ruby_parser do
       FileUtils.rm File.join(dist, file), force: true
     end
 
-    delete_directories = %w[ccan internal]
-
-    delete_directories.each do |dir|
+    DELETE_DIRECTORIES.each do |dir|
       FileUtils.rm_rf File.join(dist, dir)
     end
   end
 end
 
-task build: ['ruby_parser:build', 'compile']
-task install: ['ruby_parser:build', 'compile']
+task build: ['ruby_parser:import', 'ruby_parser:patch', 'compile']
+task install: ['ruby_parser:import', 'ruby_parser:patch', 'compile']
 
 GEMSPEC = Gem::Specification.load('kanayago.gemspec')
 
@@ -169,6 +104,18 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
+namespace :sample do
+  desc 'Generate RSpec tests from Ruby code using Kanayago AST'
+  task :rspec_generate do
+    sh 'ruby sample/test_generator.rb'
+  end
+
+  desc 'Generate Minitest tests from Ruby code using Kanayago AST'
+  task :minitest_generate do
+    sh 'ruby sample/minitest_generator.rb'
+  end
+end
+
 desc 'try to kanayago code'
 task :run do
   sh 'ruby test.rb'

data/ext/kanayago/extconf.rb

@@ -8,6 +8,12 @@ $objs = %w[
   parser_st
   ruby_parser
   kanayago
+  scope_node
+  literal_node
+  string_node
+  statement_node
+  variable_node
+  pattern_node
 ].map do |o|
   o + ".#{$OBJEXT}"
 end

data/ext/kanayago/id.h

@@ -1,4 +1,4 @@
-/* DO NOT EDIT THIS FILE DIRECTLY */
+/* DO NOT EDIT THIS FILE DIRECTLY: source is at template/id.h.tmpl */
 /**********************************************************************
 
   id.h -
@@ -14,15 +14,14 @@
 #define RUBY_ID_H
 
 enum ruby_id_types {
-    RUBY_ID_STATIC_SYM  = 0x01,
     RUBY_ID_LOCAL       = 0x00,
+    RUBY_ID_STATIC_SYM  = 0x01,
     RUBY_ID_INSTANCE    = (0x01<<1),
     RUBY_ID_GLOBAL      = (0x03<<1),
     RUBY_ID_ATTRSET     = (0x04<<1),
     RUBY_ID_CONST       = (0x05<<1),
     RUBY_ID_CLASS       = (0x06<<1),
-    RUBY_ID_JUNK        = (0x07<<1),
-    RUBY_ID_INTERNAL    = RUBY_ID_JUNK,
+    RUBY_ID_INTERNAL    = (0x07<<1),
     RUBY_ID_SCOPE_SHIFT = 4,
     RUBY_ID_SCOPE_MASK  = (~(~0U<<(RUBY_ID_SCOPE_SHIFT-1))<<1)
 };
@@ -36,7 +35,6 @@ enum ruby_id_types {
 #define ID_ATTRSET     RUBY_ID_ATTRSET
 #define ID_CONST       RUBY_ID_CONST
 #define ID_CLASS       RUBY_ID_CLASS
-#define ID_JUNK        RUBY_ID_JUNK
 #define ID_INTERNAL    RUBY_ID_INTERNAL
 
 #define symIFUNC ID2SYM(idIFUNC)
@@ -110,6 +108,7 @@ enum ruby_method_ids {
     idANDDOT = RUBY_TOKEN(ANDDOT),
     tPRESERVED_ID_BEGIN = 150,
     idNilP,
+    idIncludeP,
     idNULL,
     idEmptyP,
     idEqlP,
@@ -139,6 +138,7 @@ enum ruby_method_ids {
     tInspect,
     tIntern,
     tObject_id,
+    t__id__,
     tConst_added,
     tConst_missing,
     tMethodMissing,
@@ -192,6 +192,8 @@ enum ruby_method_ids {
     tPath,
     tPack,
     tBuffer,
+    tAborted,
+    tExited,
     tUScore,
     tNUMPARAM_1,
     tNUMPARAM_2,
@@ -221,6 +223,7 @@ enum ruby_method_ids {
 
     /* CONST tokens {{{ */
     tTOKEN_CONST_BEGIN = tTOKEN_GLOBAL_END-1,
+    tRuby,
     tTOKEN_CONST_END,
     /* CONST tokens }}} */
 
@@ -245,6 +248,7 @@ enum ruby_method_ids {
     DEFINE_LOCALID_FROM_TOKEN(Inspect),
     DEFINE_LOCALID_FROM_TOKEN(Intern),
     DEFINE_LOCALID_FROM_TOKEN(Object_id),
+    DEFINE_LOCALID_FROM_TOKEN(__id__),
     DEFINE_LOCALID_FROM_TOKEN(Const_added),
     DEFINE_LOCALID_FROM_TOKEN(Const_missing),
     DEFINE_LOCALID_FROM_TOKEN(MethodMissing),
@@ -298,6 +302,8 @@ enum ruby_method_ids {
     DEFINE_LOCALID_FROM_TOKEN(Path),
     DEFINE_LOCALID_FROM_TOKEN(Pack),
     DEFINE_LOCALID_FROM_TOKEN(Buffer),
+    DEFINE_LOCALID_FROM_TOKEN(Aborted),
+    DEFINE_LOCALID_FROM_TOKEN(Exited),
     DEFINE_LOCALID_FROM_TOKEN(UScore),
     DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_1),
     DEFINE_LOCALID_FROM_TOKEN(NUMPARAM_2),
@@ -327,6 +333,7 @@ enum ruby_method_ids {
 
     /* CONST IDs {{{ */
 #define DEFINE_CONSTID_FROM_TOKEN(n) id##n = TOKEN2CONSTID(t##n)
+    DEFINE_CONSTID_FROM_TOKEN(Ruby),
 #undef DEFINE_CONSTID_FROM_TOKEN
     /* CONST IDs }}} */
 

data/ext/kanayago/id_table.h

@@ -16,7 +16,10 @@ enum rb_id_table_iterator_result {
 };
 
 struct rb_id_table *rb_id_table_create(size_t size);
+struct rb_id_table *rb_id_table_init(struct rb_id_table *tbl, size_t capa);
+
 void rb_id_table_free(struct rb_id_table *tbl);
+void rb_id_table_free_items(struct rb_id_table *tbl);
 void rb_id_table_clear(struct rb_id_table *tbl);
 
 size_t rb_id_table_memsize(const struct rb_id_table *tbl);
@@ -32,6 +35,18 @@ void rb_id_table_foreach(struct rb_id_table *tbl, rb_id_table_foreach_func_t *fu
 void rb_id_table_foreach_values(struct rb_id_table *tbl, rb_id_table_foreach_values_func_t *func, void *data);
 void rb_id_table_foreach_values_with_replace(struct rb_id_table *tbl, rb_id_table_foreach_values_func_t *func, rb_id_table_update_value_callback_func_t *replace, void *data);
 
+VALUE rb_managed_id_table_create(const rb_data_type_t *type, size_t capa);
+VALUE rb_managed_id_table_new(size_t capa);
+VALUE rb_managed_id_table_dup(VALUE table);
+int rb_managed_id_table_insert(VALUE table, ID id, VALUE val);
+int rb_managed_id_table_lookup(VALUE table, ID id, VALUE *valp);
+size_t rb_managed_id_table_size(VALUE table);
+void rb_managed_id_table_foreach(VALUE table, rb_id_table_foreach_func_t *func, void *data);
+void rb_managed_id_table_foreach_values(VALUE table, rb_id_table_foreach_values_func_t *func, void *data);
+int rb_managed_id_table_delete(VALUE table, ID id);
+
+extern const rb_data_type_t rb_managed_id_table_type;
+
 RUBY_SYMBOL_EXPORT_BEGIN
 size_t rb_id_table_size(const struct rb_id_table *tbl);
 RUBY_SYMBOL_EXPORT_END

data/ext/kanayago/include/ruby/st.h

@@ -0,0 +1,199 @@
+/* This is a public domain general purpose hash table package
+   originally written by Peter Moore @ UCB.
+
+   The hash table data structures were redesigned and the package was
+   rewritten by Vladimir Makarov <vmakarov@redhat.com>.  */
+
+#ifndef RUBY_ST_H
+#define RUBY_ST_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#include "ruby/defines.h"
+
+RUBY_SYMBOL_EXPORT_BEGIN
+
+#if SIZEOF_LONG == SIZEOF_VOIDP
+typedef unsigned long st_data_t;
+#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
+typedef unsigned LONG_LONG st_data_t;
+#else
+# error ---->> st.c requires sizeof(void*) == sizeof(long) or sizeof(LONG_LONG) to be compiled. <<----
+#endif
+#define ST_DATA_T_DEFINED
+
+#ifndef CHAR_BIT
+# ifdef HAVE_LIMITS_H
+#  include <limits.h>
+# else
+#  define CHAR_BIT 8
+# endif
+#endif
+#ifndef _
+# define _(args) args
+#endif
+#ifndef ANYARGS
+# ifdef __cplusplus
+#   define ANYARGS ...
+# else
+#   define ANYARGS
+# endif
+#endif
+
+typedef struct st_table st_table;
+
+typedef st_data_t st_index_t;
+
+/* Maximal value of unsigned integer type st_index_t.  */
+#define MAX_ST_INDEX_VAL (~(st_index_t) 0)
+
+typedef int st_compare_func(st_data_t, st_data_t);
+typedef st_index_t st_hash_func(st_data_t);
+
+typedef char st_check_for_sizeof_st_index_t[SIZEOF_VOIDP == (int)sizeof(st_index_t) ? 1 : -1];
+#define SIZEOF_ST_INDEX_T SIZEOF_VOIDP
+
+struct st_hash_type {
+    int (*compare)(st_data_t, st_data_t); /* st_compare_func* */
+    st_index_t (*hash)(st_data_t);        /* st_hash_func* */
+};
+
+#define ST_INDEX_BITS (SIZEOF_ST_INDEX_T * CHAR_BIT)
+
+#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR) && defined(HAVE_BUILTIN___BUILTIN_TYPES_COMPATIBLE_P)
+# define ST_DATA_COMPATIBLE_P(type) \
+   __builtin_choose_expr(__builtin_types_compatible_p(type, st_data_t), 1, 0)
+#else
+# define ST_DATA_COMPATIBLE_P(type) 0
+#endif
+
+typedef struct st_table_entry st_table_entry;
+
+struct st_table_entry; /* defined in st.c */
+
+struct st_table {
+    /* Cached features of the table -- see st.c for more details.  */
+    unsigned char entry_power, bin_power, size_ind;
+    /* How many times the table was rebuilt.  */
+    unsigned int rebuilds_num;
+    const struct st_hash_type *type;
+    /* Number of entries currently in the table.  */
+    st_index_t num_entries;
+    /* Array of bins used for access by keys.  */
+    st_index_t *bins;
+    /* Start and bound index of entries in array entries.
+       entries_starts and entries_bound are in interval
+       [0,allocated_entries].  */
+    st_index_t entries_start, entries_bound;
+    /* Array of size 2^entry_power.  */
+    st_table_entry *entries;
+};
+
+#define st_is_member(table,key) st_lookup((table),(key),(st_data_t *)0)
+
+enum st_retval {ST_CONTINUE, ST_STOP, ST_DELETE, ST_CHECK, ST_REPLACE};
+
+size_t rb_st_table_size(const struct st_table *tbl);
+#define st_table_size rb_st_table_size
+st_table *rb_st_init_table(const struct st_hash_type *);
+#define st_init_table rb_st_init_table
+st_table *rb_st_init_table_with_size(const struct st_hash_type *, st_index_t);
+#define st_init_table_with_size rb_st_init_table_with_size
+st_table *rb_st_init_numtable(void);
+#define st_init_numtable rb_st_init_numtable
+st_table *rb_st_init_numtable_with_size(st_index_t);
+#define st_init_numtable_with_size rb_st_init_numtable_with_size
+st_table *rb_st_init_strtable(void);
+#define st_init_strtable rb_st_init_strtable
+st_table *rb_st_init_strtable_with_size(st_index_t);
+#define st_init_strtable_with_size rb_st_init_strtable_with_size
+st_table *rb_st_init_strcasetable(void);
+#define st_init_strcasetable rb_st_init_strcasetable
+st_table *rb_st_init_strcasetable_with_size(st_index_t);
+#define st_init_strcasetable_with_size rb_st_init_strcasetable_with_size
+int rb_st_delete(st_table *, st_data_t *, st_data_t *); /* returns 0:notfound 1:deleted */
+#define st_delete rb_st_delete
+int rb_st_delete_safe(st_table *, st_data_t *, st_data_t *, st_data_t);
+#define st_delete_safe rb_st_delete_safe
+int rb_st_shift(st_table *, st_data_t *, st_data_t *); /* returns 0:notfound 1:deleted */
+#define st_shift rb_st_shift
+int rb_st_insert(st_table *, st_data_t, st_data_t);
+#define st_insert rb_st_insert
+int rb_st_insert2(st_table *, st_data_t, st_data_t, st_data_t (*)(st_data_t));
+#define st_insert2 rb_st_insert2
+int rb_st_lookup(st_table *, st_data_t, st_data_t *);
+#define st_lookup rb_st_lookup
+int rb_st_get_key(st_table *, st_data_t, st_data_t *);
+#define st_get_key rb_st_get_key
+typedef int st_update_callback_func(st_data_t *key, st_data_t *value, st_data_t arg, int existing);
+/* *key may be altered, but must equal to the old key, i.e., the
+ * results of hash() are same and compare() returns 0, otherwise the
+ * behavior is undefined */
+int rb_st_update(st_table *table, st_data_t key, st_update_callback_func *func, st_data_t arg);
+#define st_update rb_st_update
+typedef int st_foreach_callback_func(st_data_t, st_data_t, st_data_t);
+typedef int st_foreach_check_callback_func(st_data_t, st_data_t, st_data_t, int);
+int rb_st_foreach_with_replace(st_table *tab, st_foreach_check_callback_func *func, st_update_callback_func *replace, st_data_t arg);
+#define st_foreach_with_replace rb_st_foreach_with_replace
+int rb_st_foreach(st_table *, st_foreach_callback_func *, st_data_t);
+#define st_foreach rb_st_foreach
+int rb_st_foreach_check(st_table *, st_foreach_check_callback_func *, st_data_t, st_data_t);
+#define st_foreach_check rb_st_foreach_check
+st_index_t rb_st_keys(st_table *table, st_data_t *keys, st_index_t size);
+#define st_keys rb_st_keys
+st_index_t rb_st_keys_check(st_table *table, st_data_t *keys, st_index_t size, st_data_t never);
+#define st_keys_check rb_st_keys_check
+st_index_t rb_st_values(st_table *table, st_data_t *values, st_index_t size);
+#define st_values rb_st_values
+st_index_t rb_st_values_check(st_table *table, st_data_t *values, st_index_t size, st_data_t never);
+#define st_values_check rb_st_values_check
+void rb_st_add_direct(st_table *, st_data_t, st_data_t);
+#define st_add_direct rb_st_add_direct
+void rb_st_free_table(st_table *);
+#define st_free_table rb_st_free_table
+void rb_st_cleanup_safe(st_table *, st_data_t);
+#define st_cleanup_safe rb_st_cleanup_safe
+void rb_st_clear(st_table *);
+#define st_clear rb_st_clear
+st_table *rb_st_copy(st_table *);
+#define st_copy rb_st_copy
+CONSTFUNC(int rb_st_numcmp(st_data_t, st_data_t));
+#define st_numcmp rb_st_numcmp
+CONSTFUNC(st_index_t rb_st_numhash(st_data_t));
+#define st_numhash rb_st_numhash
+PUREFUNC(int rb_st_locale_insensitive_strcasecmp(const char *s1, const char *s2));
+#define st_locale_insensitive_strcasecmp rb_st_locale_insensitive_strcasecmp
+PUREFUNC(int rb_st_locale_insensitive_strncasecmp(const char *s1, const char *s2, size_t n));
+#define st_locale_insensitive_strncasecmp rb_st_locale_insensitive_strncasecmp
+#define st_strcasecmp rb_st_locale_insensitive_strcasecmp
+#define st_strncasecmp rb_st_locale_insensitive_strncasecmp
+PUREFUNC(size_t rb_st_memsize(const st_table *));
+#define st_memsize rb_st_memsize
+PUREFUNC(st_index_t rb_st_hash(const void *ptr, size_t len, st_index_t h));
+#define st_hash rb_st_hash
+CONSTFUNC(st_index_t rb_st_hash_uint32(st_index_t h, uint32_t i));
+#define st_hash_uint32 rb_st_hash_uint32
+CONSTFUNC(st_index_t rb_st_hash_uint(st_index_t h, st_index_t i));
+#define st_hash_uint rb_st_hash_uint
+CONSTFUNC(st_index_t rb_st_hash_end(st_index_t h));
+#define st_hash_end rb_st_hash_end
+CONSTFUNC(st_index_t rb_st_hash_start(st_index_t h));
+#define st_hash_start(h) ((st_index_t)(h))
+
+void rb_hash_bulk_insert_into_st_table(long, const VALUE *, VALUE);
+
+RUBY_SYMBOL_EXPORT_END
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_ST_H */

data/ext/kanayago/internal/array.h

@@ -37,6 +37,7 @@ size_t rb_ary_size_as_embedded(VALUE ary);
 void rb_ary_make_embedded(VALUE ary);
 bool rb_ary_embeddable_p(VALUE ary);
 VALUE rb_ary_diff(VALUE ary1, VALUE ary2);
+RUBY_EXTERN VALUE rb_cArray_empty_frozen;
 
 static inline VALUE rb_ary_entry_internal(VALUE ary, long offset);
 static inline bool ARY_PTR_USING_P(VALUE ary);
@@ -139,6 +140,8 @@ RARRAY_AREF(VALUE ary, long i)
     VALUE val;
     RBIMPL_ASSERT_TYPE(ary, RUBY_T_ARRAY);
 
+    RUBY_ASSERT(i < RARRAY_LEN(ary));
+
     RBIMPL_WARNING_PUSH();
 #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 13
     RBIMPL_WARNING_IGNORED(-Warray-bounds);

data/ext/kanayago/internal/basic_operators.h

@@ -38,6 +38,7 @@ enum ruby_basic_operators {
     BOP_CMP,
     BOP_DEFAULT,
     BOP_PACK,
+    BOP_INCLUDE_P,
 
     BOP_LAST_
 };

data/ext/kanayago/internal/bignum.h

@@ -121,6 +121,7 @@ VALUE rb_integer_float_eq(VALUE x, VALUE y);
 VALUE rb_str_convert_to_inum(VALUE str, int base, int badcheck, int raise_exception);
 VALUE rb_big_comp(VALUE x);
 VALUE rb_big_aref(VALUE x, VALUE y);
+VALUE rb_big_aref2(VALUE num, VALUE beg, VALUE len);
 VALUE rb_big_abs(VALUE x);
 VALUE rb_big_size_m(VALUE big);
 VALUE rb_big_bit_length(VALUE big);