kanayago 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7dc8924bd1972c79a19ec99a5317d3805ec71536f4f53e11ee12e11930c16af2
+  data.tar.gz: a7ef01c1049b9e4132299b21a58b37ecd61fd18813f5f9208a02f6950d3b46fa
+SHA512:
+  metadata.gz: 29da7596273da188566563726bd3cd26fde141ec06c30cad03ddc0b52ccc7083815c125425d011a14e253fc070fecf71831d56523064f8fbfbc9bca3fc3d7da2
+  data.tar.gz: 03c77678bee8697c788a9ef5d7f9e65db5014608ba41f0d9e2223f1b1cfd96195aa8379d05482a404deeaa9d9b17dd72c3f015cf889b9f74b8e29255e356e8d1

data/.rubocop.yml

@@ -0,0 +1,15 @@
+inherit_from: .rubocop_todo.yml
+
+Metrics/BlockLength:
+  Exclude:
+    - Rakefile
+    - kanayago.gemspec
+
+RBS:
+  Enabled: true
+
+require:
+  - rubocop-minitest
+  - rubocop-on-rbs
+  - rubocop-rake
+

data/.rubocop_todo.yml

@@ -0,0 +1,23 @@
+# Offense count: 4
+# Configuration parameters: CountComments, CountAsOne.
+Metrics/ClassLength:
+  Max: 318
+
+# Offense count: 40
+# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
+Metrics/MethodLength:
+  Max: 49
+
+# Offense count: 2
+# Configuration parameters: AllowedConstants.
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+
+# Offense count: 4
+# Configuration parameters: AllowedVariables.
+Style/GlobalVars:
+  Exclude:
+    - 'ext/kanayago/extconf.rb'
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 S-H-GAMELINKS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,79 @@
+# Kanayago
+
+Trying to Make Ruby's Parser Available as a Gem.
+
+## Installation
+
+First, install Ruby master with Universal Parser.
+
+```console
+RUBY_CONFIGURE_OPTS="cppflags=-DUNIVERSAL_PARSER" rbenv install ruby-dev
+```
+
+Clone this repository.
+
+```console
+git clone https://github.com/S-H-GAMELINKS/kanayago.git
+```
+
+Move `kanayago` directory, and run `bundle install`.
+
+```console
+cd kanayago && bundle install
+```
+
+Finally, build `Kanayago` gem  and install it.
+
+```console
+bundle exec rake build
+gem install pkg/kanayago-0.1.0.gem
+```
+
+## Usage
+
+```ruby
+require 'kanayago/kanayago'
+
+result = Kanayago.parse('117 + 117')
+
+p result
+# =>
+#{
+#  "NODE_SCOPE" => {
+#    "args" => nil,
+#    "body" => {
+#      "NODE_OPCALL" => {
+#        "recv" => {
+#          "NODE_INTEGER" => 117
+#        },
+#        "mid" => :+,
+#        "args" => {
+#          "NODE_LIST" => [
+#            {
+#              "NODE_INTEGER"=>117
+#            }
+#          ]
+#        }
+#      }
+#    }
+#  }
+#}
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/S-H-GAMELINKS/kanayago.
+
+## Referenced implementations
+
+[yui-knk/ruby-parser](https://github.com/yui-knk/ruby-parser)
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/extensiontask'
+require 'rake/testtask'
+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
+
+namespace :ruby_parser do
+  desc 'import ruby parser files'
+  task :import do
+    `git clone https://github.com/ruby/ruby.git tmp/ruby --depth=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)
+    end
+
+    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|
+      f << <<~SRC
+        #define RUBY_DTRACE_PARSE_BEGIN_ENABLED() (0)
+        #define RUBY_DTRACE_PARSE_BEGIN(arg0, arg1) (void)(arg0), (void)(arg1);
+        #define RUBY_DTRACE_PARSE_END_ENABLED() (0)
+        #define RUBY_DTRACE_PARSE_END(arg0, arg1) (void)(arg0), (void)(arg1);
+      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`
+  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'
+  end
+
+  desc 'clean to ruby parser file'
+  task :clean do
+    dist = File.expand_path('./ext/kanayago')
+
+    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',
+                    'parse.y', 'parse.tmp.y', 'probes.h', 'shape.h']
+
+    delete_files.each do |file|
+      FileUtils.rm File.join(dist, file), force: true
+    end
+
+    delete_directories = %w[ccan internal]
+
+    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']
+
+GEMSPEC = Gem::Specification.load('kanayago.gemspec')
+
+Rake::ExtensionTask.new('kanayago', GEMSPEC) do |ext|
+  ext.lib_dir = 'lib/kanayago'
+end
+
+namespace :queue do
+  desc 'run test with test-queue'
+  task :test do
+    sh 'bundle exec minitest-queue $(find test/ -name \*_test.rb)'
+  end
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+desc 'try to kanayago code'
+task :run do
+  sh 'ruby test.rb'
+end
+
+desc 'debug to kanayago code in gdb'
+task :gdb do
+  sh 'bundle exec gdb --args ruby test.rb'
+end
+
+task default: %i[clobber compile]

data/ext/kanayago/ccan/check_type/check_type.h

@@ -0,0 +1,63 @@
+/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
+#ifndef CCAN_CHECK_TYPE_H
+#define CCAN_CHECK_TYPE_H
+
+/**
+ * ccan_check_type - issue a warning or build failure if type is not correct.
+ * @expr: the expression whose type we should check (not evaluated).
+ * @type: the exact type we expect the expression to be.
+ *
+ * This macro is usually used within other macros to try to ensure that a macro
+ * argument is of the expected type.  No type promotion of the expression is
+ * done: an unsigned int is not the same as an int!
+ *
+ * ccan_check_type() always evaluates to 0.
+ *
+ * If your compiler does not support typeof, then the best we can do is fail
+ * to compile if the sizes of the types are unequal (a less complete check).
+ *
+ * Example:
+ *	// They should always pass a 64-bit value to _set_some_value!
+ *	#define set_some_value(expr)			\
+ *		_set_some_value((ccan_check_type((expr), uint64_t), (expr)))
+ */
+
+/**
+ * ccan_check_types_match - issue a warning or build failure if types are not same.
+ * @expr1: the first expression (not evaluated).
+ * @expr2: the second expression (not evaluated).
+ *
+ * This macro is usually used within other macros to try to ensure that
+ * arguments are of identical types.  No type promotion of the expressions is
+ * done: an unsigned int is not the same as an int!
+ *
+ * ccan_check_types_match() always evaluates to 0.
+ *
+ * If your compiler does not support typeof, then the best we can do is fail
+ * to compile if the sizes of the types are unequal (a less complete check).
+ *
+ * Example:
+ *	// Do subtraction to get to enclosing type, but make sure that
+ *	// pointer is of correct type for that member.
+ *	#define ccan_container_of(mbr_ptr, encl_type, mbr)			\
+ *		(ccan_check_types_match((mbr_ptr), &((encl_type *)0)->mbr),	\
+ *		 ((encl_type *)						\
+ *		  ((char *)(mbr_ptr) - offsetof(enclosing_type, mbr))))
+ */
+#if defined(HAVE_TYPEOF) && HAVE_TYPEOF
+#define ccan_check_type(expr, type)			\
+	((typeof(expr) *)0 != (type *)0)
+
+#define ccan_check_types_match(expr1, expr2)		\
+	((typeof(expr1) *)0 != (typeof(expr2) *)0)
+#else
+#include "ccan/build_assert/build_assert.h"
+/* Without typeof, we can only test the sizes. */
+#define ccan_check_type(expr, type)					\
+	CCAN_BUILD_ASSERT_OR_ZERO(sizeof(expr) == sizeof(type))
+
+#define ccan_check_types_match(expr1, expr2)				\
+	CCAN_BUILD_ASSERT_OR_ZERO(sizeof(expr1) == sizeof(expr2))
+#endif /* HAVE_TYPEOF */
+
+#endif /* CCAN_CHECK_TYPE_H */

data/ext/kanayago/ccan/container_of/container_of.h

@@ -0,0 +1,142 @@
+/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
+#ifndef CCAN_CONTAINER_OF_H
+#define CCAN_CONTAINER_OF_H
+#include "ccan/check_type/check_type.h"
+
+/**
+ * ccan_container_of - get pointer to enclosing structure
+ * @member_ptr: pointer to the structure member
+ * @containing_type: the type this member is within
+ * @member: the name of this member within the structure.
+ *
+ * Given a pointer to a member of a structure, this macro does pointer
+ * subtraction to return the pointer to the enclosing type.
+ *
+ * Example:
+ *	struct foo {
+ *		int fielda, fieldb;
+ *		// ...
+ *	};
+ *	struct info {
+ *		int some_other_field;
+ *		struct foo my_foo;
+ *	};
+ *
+ *	static struct info *foo_to_info(struct foo *foo)
+ *	{
+ *		return ccan_container_of(foo, struct info, my_foo);
+ *	}
+ */
+#define ccan_container_of(member_ptr, containing_type, member)		\
+	 ((containing_type *)						\
+	  ((char *)(member_ptr)						\
+	   - ccan_container_off(containing_type, member))		\
+	  + ccan_check_types_match(*(member_ptr), ((containing_type *)0)->member))
+
+
+/**
+ * ccan_container_of_or_null - get pointer to enclosing structure, or NULL
+ * @member_ptr: pointer to the structure member
+ * @containing_type: the type this member is within
+ * @member: the name of this member within the structure.
+ *
+ * Given a pointer to a member of a structure, this macro does pointer
+ * subtraction to return the pointer to the enclosing type, unless it
+ * is given NULL, in which case it also returns NULL.
+ *
+ * Example:
+ *	struct foo {
+ *		int fielda, fieldb;
+ *		// ...
+ *	};
+ *	struct info {
+ *		int some_other_field;
+ *		struct foo my_foo;
+ *	};
+ *
+ *	static struct info *foo_to_info_allowing_null(struct foo *foo)
+ *	{
+ *		return ccan_container_of_or_null(foo, struct info, my_foo);
+ *	}
+ */
+static inline char *container_of_or_null_(void *member_ptr, size_t offset)
+{
+	return member_ptr ? (char *)member_ptr - offset : NULL;
+}
+#define ccan_container_of_or_null(member_ptr, containing_type, member)	\
+	((containing_type *)						\
+	 ccan_container_of_or_null_(member_ptr,				\
+			       ccan_container_off(containing_type, member))	\
+	 + ccan_check_types_match(*(member_ptr), ((containing_type *)0)->member))
+
+/**
+ * ccan_container_off - get offset to enclosing structure
+ * @containing_type: the type this member is within
+ * @member: the name of this member within the structure.
+ *
+ * Given a pointer to a member of a structure, this macro does
+ * typechecking and figures out the offset to the enclosing type.
+ *
+ * Example:
+ *	struct foo {
+ *		int fielda, fieldb;
+ *		// ...
+ *	};
+ *	struct info {
+ *		int some_other_field;
+ *		struct foo my_foo;
+ *	};
+ *
+ *	static struct info *foo_to_info(struct foo *foo)
+ *	{
+ *		size_t off = ccan_container_off(struct info, my_foo);
+ *		return (void *)((char *)foo - off);
+ *	}
+ */
+#define ccan_container_off(containing_type, member)	\
+	offsetof(containing_type, member)
+
+/**
+ * ccan_container_of_var - get pointer to enclosing structure using a variable
+ * @member_ptr: pointer to the structure member
+ * @container_var: a pointer of same type as this member's container
+ * @member: the name of this member within the structure.
+ *
+ * Given a pointer to a member of a structure, this macro does pointer
+ * subtraction to return the pointer to the enclosing type.
+ *
+ * Example:
+ *	static struct info *foo_to_i(struct foo *foo)
+ *	{
+ *		struct info *i = ccan_container_of_var(foo, i, my_foo);
+ *		return i;
+ *	}
+ */
+#if defined(HAVE_TYPEOF) && HAVE_TYPEOF
+#define ccan_container_of_var(member_ptr, container_var, member) \
+	ccan_container_of(member_ptr, typeof(*container_var), member)
+#else
+#define ccan_container_of_var(member_ptr, container_var, member)	\
+	((void *)((char *)(member_ptr)	-			\
+		  ccan_container_off_var(container_var, member)))
+#endif
+
+/**
+ * ccan_container_off_var - get offset of a field in enclosing structure
+ * @container_var: a pointer to a container structure
+ * @member: the name of a member within the structure.
+ *
+ * Given (any) pointer to a structure and a its member name, this
+ * macro does pointer subtraction to return offset of member in a
+ * structure memory layout.
+ *
+ */
+#if defined(HAVE_TYPEOF) && HAVE_TYPEOF
+#define ccan_container_off_var(var, member)		\
+	ccan_container_off(typeof(*var), member)
+#else
+#define ccan_container_off_var(var, member)			\
+	((const char *)&(var)->member - (const char *)(var))
+#endif
+
+#endif /* CCAN_CONTAINER_OF_H */