packcr 0.0.8 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cacf5e781ba49bcc7d755ac5ba6e348646a08e4a807efd4375ba720232262556
-  data.tar.gz: ce70800733fbc71527539174f373786489f3fdda416b5435bf8aa687de1cd321
+  metadata.gz: ec849cdb4d638eb308cdefaf4a2e743ec49e71b46b7343265f8f8b78f5508c5a
+  data.tar.gz: d9c7e0db4c53e247edfb28ca9a6266364e0647152a202c92ca94bdf60ed0e5e0
 SHA512:
-  metadata.gz: f0cf28feb81c97f094f6b098656ab4ec30f312e99c84789c5e5f53cf8a520c4c63a561d48a240b7ab0699d2e063820e3b923118d33e2a9e3b5dfc2884993ac9d
-  data.tar.gz: c858ad58e577af40013bbd7438eb3c4066d0c76b0a6407c5ab051ae63a379936594da974a1c203a72659d3dcebc4794c0aaaf5beea2ab98169388a89c0c79773
+  metadata.gz: d7b5ec64eb5ea1a407efb518ee0a169f7d0a24294e9d0924fbd7c9bf7a95fd20de13f0ccda290e8deea34b4745d08e07022576fa120dc58f2d81cb4c0e12ee4e
+  data.tar.gz: aa881736505df4e86e9a511b48941781e89a3618445e71a88034097624750e902edaa986ea0d875e537933034c4e0e12b5e8a971206732f2084f0b06d2db2b90

data/README.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-PackCR is a parser generator for C or Ruby.
+PackCR is a parser generator for C, Ruby, and Rust.
 This library is a port of PackCC rewritten in ruby.
 The Original PackCC is https://github.com/arithy/packcc.
 

data/lib/packcr/context.rb

@@ -40,9 +40,9 @@ class Packcr
           get_header_code: @hname,
         }
         @hid = File.basename(@hname).upcase.gsub(/[^A-Z0-9]/, "_")
-      when :rb
+      when :rb, :rs
         @patterns = {
-          get_source_code: "#{path}.rb",
+          get_source_code: "#{path}.#{@lang}",
         }
       else
         raise "unexpected lang: #{@lang}"
@@ -96,6 +96,17 @@ class Packcr
       end
     end
 
+    def line_comment_code(line)
+      line = line.chomp
+      case @lang
+      when :c
+        line.gsub("*/", "* /")
+        "/* #{line} */"
+      when :rb
+        "# #{line}"
+      end
+    end
+
     def class_name
       prefix.gsub(/(?:_|^|(\W))([a-z])/) { "#{::Regexp.last_match(1)}#{::Regexp.last_match(2)}".upcase }
     end
@@ -150,9 +161,7 @@ class Packcr
 
         next if @errnum.zero?
 
-        results.each do |_, r|
-          r.close
-        end
+        results.each_value(&:close)
         return false
       end
 

data/lib/packcr/generated/context.rb

@@ -20,6 +20,8 @@ class Packcr
         erbout << "#ifdef __cplusplus\nextern \"C\" {\n#endif\n\ntypedef struct #{prefix}_context_tag #{prefix}_context_t;\n\n#{prefix}_context_t *#{prefix}_create(#{auxil_def}auxil);\nint #{prefix}_parse(#{prefix}_context_t *ctx, #{value_def}*ret);\nvoid #{prefix}_destroy(#{prefix}_context_t *ctx);\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif /* !PACKCR_INCLUDED_#{@hid} */\n".freeze
 
         erbout
+      else
+        raise "unknown lang #{lang}"
       end
     end
 
@@ -29,10 +31,10 @@ class Packcr
         erbout = +""
         erbout << "/* A packrat parser generated by PackCR #{Packcr::VERSION} */\n\n".freeze
 
-        code(:esource).each do |code|
-          erbout << "#{stream.get_code_block(code, 0, @iname)}".freeze
-        end
         if !code(:esource).empty?
+          code(:esource).each do |code|
+            erbout << "#{stream.get_code_block(code, 0, @iname)}".freeze
+          end
           erbout << "\n".freeze
         end
         erbout << "#ifdef _MSC_VER\n#undef _CRT_SECURE_NO_WARNINGS\n#define _CRT_SECURE_NO_WARNINGS\n#endif /* _MSC_VER */\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n#ifndef _MSC_VER\n#if defined __GNUC__ && defined _WIN32 /* MinGW */\n#ifndef PACKCR_USE_SYSTEM_STRNLEN\n#define strnlen(str, maxlen) packcr_strnlen(str, maxlen)\nstatic size_t packcr_strnlen(const char *str, size_t maxlen) {\n    size_t i;\n    for (i = 0; i < maxlen && str[i]; i++);\n    return i;\n}\n#endif /* !PACKCR_USE_SYSTEM_STRNLEN */\n#endif /* defined __GNUC__ && defined _WIN32 */\n#endif /* !_MSC_VER */\n\n#include \"#{@hname}\"\n".freeze
@@ -191,7 +193,29 @@ class Packcr
         if @location
           erbout << "            memo->offset_loc = ctx->position_offset_loc;\n".freeze
         end
-        erbout << "        }\n    } else {\n        c = packcr_get_rule_thunk_chunk(ctx, rule);\n    }\n    if (c == NULL) return PACKCR_FALSE;\n    if (value == NULL) value = &null;\n    memset(value, 0, sizeof(packcr_value_t)); /* in case */\n    packcr_thunk_array__add(ctx->auxil, thunks, packcr_thunk__create_node(ctx->auxil, &c->thunks, value));\n    return PACKCR_TRUE;\n}\n\nMARK_FUNC_AS_USED\nstatic void packcr_do_action(packcr_context_t *ctx, const packcr_thunk_array_t *thunks, packcr_value_t *value) {\n    size_t i;\n    for (i = 0; i < thunks->len; i++) {\n        packcr_thunk_t *const thunk = thunks->buf[i];\n        switch (thunk->type) {\n        case PACKCR_THUNK_LEAF:\n            thunk->data.leaf.action(ctx, thunk, value);\n            break;\n        case PACKCR_THUNK_NODE:\n            packcr_do_action(ctx, thunk->data.node.thunks, thunk->data.node.value);\n            break;\n        default: /* unknown */\n            break;\n        }\n    }\n}\n\n".freeze
+        erbout << "        }\n    } else {\n        c = packcr_get_rule_thunk_chunk(ctx, rule);\n    }\n    if (c == NULL) return PACKCR_FALSE;\n    if (value == NULL) value = &null;\n    memset(value, 0, sizeof(packcr_value_t)); /* in case */\n    packcr_thunk_array__add(ctx->auxil, thunks, packcr_thunk__create_node(ctx->auxil, &c->thunks, value));\n    return PACKCR_TRUE;\n}\n\nMARK_FUNC_AS_USED\nstatic void packcr_do_action(packcr_context_t *ctx, const packcr_thunk_array_t *thunks, packcr_value_t *value) {\n    size_t i;\n    for (i = 0; i < thunks->len; i++) {\n        packcr_thunk_t *const thunk = thunks->buf[i];\n        switch (thunk->type) {\n        case PACKCR_THUNK_LEAF:\n            thunk->data.leaf.action(ctx, thunk, value);\n            break;\n        case PACKCR_THUNK_NODE:\n            packcr_do_action(ctx, thunk->data.node.thunks, thunk->data.node.value);\n            break;\n        default: /* unknown */\n            break;\n        }\n    }\n}\n\n#{prefix}_context_t *#{prefix}_create(#{auxil_def}auxil) {\n    return packcr_context__create(auxil);\n}\n\nvoid #{prefix}_destroy(#{prefix}_context_t *ctx) {\n    packcr_context__destroy(ctx);\n}\n".freeze
+
+        if !@root.rules.empty?
+          erbout << "\n".freeze
+
+          @root.rules.each do |rule|
+            erbout << "static packcr_thunk_chunk_t *packcr_evaluate_rule_#{rule.name}(packcr_context_t *ctx, size_t offset".freeze
+            if @location
+              erbout << ", packcr_location_t offset_loc".freeze
+            end
+            erbout << ", packcr_rule_set_t *limits);\n".freeze
+          end
+        end
+        erbout << "\nint #{prefix}_parse(#{prefix}_context_t *ctx, #{value_def}*ret) {\n    size_t pos = ctx->buffer_start_position;\n".freeze
+
+        if !@root.rules.empty?
+          erbout << "    if (packcr_apply_rule(ctx, packcr_evaluate_rule_#{@root.rules[0].name}, &ctx->thunks, ret, ctx->position_offset".freeze
+          if @location
+            erbout << ", ctx->position_offset_loc".freeze
+          end
+          erbout << ", NULL))\n        packcr_do_action(ctx, &ctx->thunks, ret);\n    else\n        PACKCR_ERROR(ctx->auxil);\n    packcr_commit_buffer(ctx);\n".freeze
+        end
+        erbout << "    packcr_thunk_array__revert(ctx->auxil, &ctx->thunks, 0);\n    return pos != ctx->buffer_start_position && packcr_refill_buffer(ctx, 1) >= 1;\n}\n\n".freeze
 
         @root.rules.each do |rule|
           rule.codes.each do |code|
@@ -233,30 +257,12 @@ class Packcr
             erbout << "#undef __\n#undef auxil\n}\n\n".freeze
           end
         end
-        @root.rules.each do |rule|
-          erbout << "static packcr_thunk_chunk_t *packcr_evaluate_rule_#{rule.name}(packcr_context_t *ctx, size_t offset".freeze
-          if @location
-            erbout << ", packcr_location_t offset_loc".freeze
-          end
-          erbout << ", packcr_rule_set_t *limits);\n".freeze
-        end
         erbout << "\n".freeze
 
         @root.rules.each do |rule|
           gen = ::Packcr::Generator.new(rule, @ascii, @location)
           erbout << "#{gen.generate_code(rule, 0, 0, false)}\n".freeze
         end
-        erbout << "#{prefix}_context_t *#{prefix}_create(#{auxil_def}auxil) {\n    return packcr_context__create(auxil);\n}\n\nint #{prefix}_parse(#{prefix}_context_t *ctx, #{value_def}*ret) {\n    size_t pos = ctx->buffer_start_position;\n".freeze
-
-        if !@root.rules.empty?
-          erbout << "    if (packcr_apply_rule(ctx, packcr_evaluate_rule_#{@root.rules[0].name}, &ctx->thunks, ret, ctx->position_offset".freeze
-          if @location
-            erbout << ", ctx->position_offset_loc".freeze
-          end
-          erbout << ", NULL))\n        packcr_do_action(ctx, &ctx->thunks, ret);\n    else\n        PACKCR_ERROR(ctx->auxil);\n    packcr_commit_buffer(ctx);\n".freeze
-        end
-        erbout << "    packcr_thunk_array__revert(ctx->auxil, &ctx->thunks, 0);\n    return pos != ctx->buffer_start_position && packcr_refill_buffer(ctx, 1) >= 1;\n}\n\nvoid #{prefix}_destroy(#{prefix}_context_t *ctx) {\n    packcr_context__destroy(ctx);\n}\n".freeze
-
         if !code(:lsource).empty?
           erbout << "\n".freeze
 
@@ -267,14 +273,13 @@ class Packcr
         erbout
       when :rb
         erbout = +""
-        erbout << "# A packrat parser generated by PackCR #{Packcr::VERSION}\n".freeze
+        erbout << "# A packrat parser generated by PackCR #{Packcr::VERSION}\n\n".freeze
 
         if !code(:esource).empty?
-          erbout << "\n".freeze
-
           code(:esource).each do |code|
             erbout << "#{stream.get_code_block(code, 0, @iname)}".freeze
           end
+          erbout << "\n".freeze
         end
         erbout << "class #{class_name}\n".freeze
 
@@ -284,7 +289,40 @@ class Packcr
         code(:source).each do |code|
           erbout << "  #{stream.get_code_block(code, 2, @iname)}\n".freeze
         end
-        erbout << "  def initialize(".freeze
+        erbout << "  class LrMemoTable\n    def initialize\n      @memos = {}\n    end\n\n    def clear\n      @memos.clear\n    end\n\n    def []=(index, rule_name, memo)\n      entry = @memos[index] ||= {}\n      entry[rule_name] = memo\n    end\n\n    def [](index, rule_name)\n      @memos.dig(index, rule_name)\n    end\n  end\n\n  class LrMemo\n    attr_accessor :grow, :answer, :offset, :fail\n".freeze
+
+        if @location
+          erbout << "    attr_accessor :offset_loc\n".freeze
+        end
+        erbout << "\n    def initialize(offset".freeze
+        if @location
+          erbout << ", offset_loc".freeze
+        end
+        erbout << ")\n      @offset = offset\n".freeze
+
+        if @location
+          erbout << "      @offset_loc = offset_loc\n".freeze
+        end
+        erbout << "      @fail = true\n      @grow = false\n    end\n\n    def answer=(answer)\n      @fail = nil\n      @answer = answer\n    end\n  end\n\n  class ThunkChunk\n    attr_accessor :thunks, :capts, :pos, :values\n".freeze
+
+        if @location
+          erbout << "    attr_accessor :pos_loc\n".freeze
+        end
+        erbout << "\n    def initialize\n      super\n      @thunks = []\n      @capts = {}\n      @pos = 0\n      @values = {}\n    end\n\n    def resize_captures(len)\n      len.times do |i|\n        @capts[i] = Capture.new\n      end\n    end\n  end\n\n  class ThunkLeaf\n    attr_accessor :capt0, :capts, :value_refs, :action\n\n    def initialize(action, capt0 = Capture.new, value_refs = {}, capts = {})\n      @value_refs = value_refs\n      @capts = capts\n      @capt0 = capt0\n      @action = action\n    end\n\n    def do_action(ctx, values, index)\n      ctx.public_send(action, self, values, index)\n    end\n  end\n\n  class ThunkNode\n    attr_accessor :thunks, :values, :index\n\n    def initialize(thunks, values, index)\n      @thunks = thunks\n      @values = values\n      @index = index\n      values[index] ||= Value.new if values\n    end\n\n    def do_action(ctx, _values, _index)\n      @thunks.each do |thunk|\n        thunk.do_action(ctx, @values, @index)\n      end\n    end\n\n    def clear\n      @thunks.clear\n    end\n  end\n\n  class Capture\n    attr_accessor :range_start, :range_end\n".freeze
+
+        if @location
+          erbout << "    attr_accessor :start_loc, :end_loc\n".freeze
+        end
+        erbout << "\n    def initialize(range_start = 0, range_end = 0".freeze
+        if @location
+          erbout << ", start_loc = nil, end_loc = nil".freeze
+        end
+        erbout << ")\n      @range_start = range_start\n      @range_end = range_end\n".freeze
+
+        if @location
+          erbout << "      @start_loc = start_loc || Location.new\n      @end_loc = end_loc || Location.new\n".freeze
+        end
+        erbout << "    end\n\n    def capture_string(buffer)\n      @capture_string ||= buffer[@range_start, @range_end - @range_start]\n    end\n  end\n\n  class Value\n    attr_accessor :value\n  end\n\n  def initialize(".freeze
         if @auxil_type
           erbout << "#{auxil_type}, ".freeze
         end
@@ -326,43 +364,7 @@ class Packcr
           end
           erbout << ")\n      @thunk.do_action(self, nil, 0)\n    else\n      raise SyntaxError, \"can't parse\"\n    end\n    commit_buffer\n".freeze
         end
-        erbout << "    @thunk.clear\n    refill_buffer(1) >= 1 && pos != @buffer_start_position\n  end\n\n  def run\n    nil while parse\n  end\n\n".freeze
-
-        @root.rules.each do |rule|
-          rule.codes.each do |code|
-            erbout << "  def action_#{rule.name}_#{code.index}(__packcr_in, __packcr_vars, __packcr_index)\n    ____ = (__packcr_vars[__packcr_index] ||= Value.new).value if __packcr_vars\n".freeze
-
-            code.vars.each do |ref|
-              erbout << "    #{ref.var} = (__packcr_in.value_refs[#{ref.index}]  ||= Value.new).value\n".freeze
-            end
-            erbout << "    __0 = __packcr_in.capt0.capture_string(@buffer)\n    __0s = @buffer_start_position + __packcr_in.capt0.range_start\n    __0e = @buffer_start_position + __packcr_in.capt0.range_end\n".freeze
-
-            if @location
-              erbout << "    __0sl = @buffer_start_position_loc + __packcr_in.capt0.start_loc\n    __0el = @buffer_start_position_loc + __packcr_in.capt0.end_loc\n".freeze
-            end
-            if @capture_in_code
-              erbout << "    __0c = __packcr_in.capt0\n".freeze
-            end
-            code.capts.each do |capture|
-              erbout << "    __#{capture.index + 1} = __packcr_in.capts[#{capture.index}].capture_string(@buffer)\n    __#{capture.index + 1}s = @buffer_start_position + __packcr_in.capts[#{capture.index}].range_start\n    __#{capture.index + 1}e = @buffer_start_position + __packcr_in.capts[#{capture.index}].range_end\n".freeze
-
-              if @location
-                erbout << "    __#{capture.index + 1}sl = @buffer_start_position_loc + __packcr_in.capts[#{capture.index}].start_loc\n    __#{capture.index + 1}el = @buffer_start_position_loc + __packcr_in.capts[#{capture.index}].end_loc\n".freeze
-              end
-              next unless @capture_in_code
-
-              erbout << "    __#{capture.index + 1}c = __packcr_in.capts[#{capture.index}]\n".freeze
-            end
-
-            erbout << "#{stream.get_code_block(code.code, 4, @iname)}\n    __packcr_vars[__packcr_index].value = ____ if __packcr_vars\n  end\n\n".freeze
-          end
-        end
-        @root.rules.each do |rule|
-          gen = ::Packcr::Generator.new(rule, @ascii, @location, :rb)
-
-          erbout << "#{gen.generate_code(rule, 0, 2, false)}\n".freeze
-        end
-        erbout << "  def grow_lr(rule, offset".freeze
+        erbout << "    @thunk.clear\n    refill_buffer(1) >= 1 && pos != @buffer_start_position\n  end\n\n  def run\n    nil while parse\n  end\n\n  def grow_lr(rule, offset".freeze
         if @location
           erbout << ", offset_loc".freeze
         end
@@ -434,40 +436,135 @@ class Packcr
         if @location
           erbout << "        memo.offset_loc = @position_offset_loc\n".freeze
         end
-        erbout << "      end\n    else\n      answer = rule_answer(rule)\n    end\n\n    if !answer\n      return false\n    end\n    values ||= @global_values\n    thunks << ThunkNode.new(answer.thunks, values, index)\n    return true\n  end\n\n  def do_action(thunks, values, index)\n    thunks.each do |thunk|\n      thunk.do_action(self, values, index)\n    end\n  end\n\n  class LrMemoTable\n    def initialize\n      @memos = {}\n    end\n\n    def clear\n      @memos.clear\n    end\n\n    def []=(index, rule_name, memo)\n      entry = @memos[index] ||= {}\n      entry[rule_name] = memo\n    end\n\n    def [](index, rule_name)\n      @memos.dig(index, rule_name)\n    end\n  end\n\n  class LrMemo\n    attr_accessor :grow, :answer, :offset, :fail\n".freeze
+        erbout << "      end\n    else\n      answer = rule_answer(rule)\n    end\n\n    if !answer\n      return false\n    end\n    values ||= @global_values\n    thunks << ThunkNode.new(answer.thunks, values, index)\n    return true\n  end\n\n  def do_action(thunks, values, index)\n    thunks.each do |thunk|\n      thunk.do_action(self, values, index)\n    end\n  end\n".freeze
 
-        if @location
-          erbout << "    attr_accessor :offset_loc\n".freeze
+        @root.rules.each do |rule|
+          rule.codes.each do |code|
+            erbout << "\n  def action_#{rule.name}_#{code.index}(__packcr_in, __packcr_vars, __packcr_index)\n    ____ = (__packcr_vars[__packcr_index] ||= Value.new).value if __packcr_vars\n".freeze
+
+            code.vars.each do |ref|
+              erbout << "    #{ref.var} = (__packcr_in.value_refs[#{ref.index}]  ||= Value.new).value\n".freeze
+            end
+            erbout << "    __0 = __packcr_in.capt0.capture_string(@buffer)\n    __0s = @buffer_start_position + __packcr_in.capt0.range_start\n    __0e = @buffer_start_position + __packcr_in.capt0.range_end\n".freeze
+
+            if @location
+              erbout << "    __0sl = @buffer_start_position_loc + __packcr_in.capt0.start_loc\n    __0el = @buffer_start_position_loc + __packcr_in.capt0.end_loc\n".freeze
+            end
+            if @capture_in_code
+              erbout << "    __0c = __packcr_in.capt0\n".freeze
+            end
+            code.capts.each do |capture|
+              erbout << "    __#{capture.index + 1} = __packcr_in.capts[#{capture.index}].capture_string(@buffer)\n    __#{capture.index + 1}s = @buffer_start_position + __packcr_in.capts[#{capture.index}].range_start\n    __#{capture.index + 1}e = @buffer_start_position + __packcr_in.capts[#{capture.index}].range_end\n".freeze
+
+              if @location
+                erbout << "    __#{capture.index + 1}sl = @buffer_start_position_loc + __packcr_in.capts[#{capture.index}].start_loc\n    __#{capture.index + 1}el = @buffer_start_position_loc + __packcr_in.capts[#{capture.index}].end_loc\n".freeze
+              end
+              next unless @capture_in_code
+
+              erbout << "    __#{capture.index + 1}c = __packcr_in.capts[#{capture.index}]\n".freeze
+            end
+
+            erbout << "#{stream.get_code_block(code.code, 4, @iname)}\n    __packcr_vars[__packcr_index].value = ____ if __packcr_vars\n  end\n".freeze
+          end
         end
-        erbout << "\n    def initialize(offset".freeze
-        if @location
-          erbout << ", offset_loc".freeze
+        @root.rules.each do |rule|
+          erbout << "\n".freeze
+
+          gen = ::Packcr::Generator.new(rule, @ascii, @location, :rb)
+
+          erbout << "#{gen.generate_code(rule, 0, 2, false)}".freeze
         end
-        erbout << ")\n      @offset = offset\n".freeze
+        erbout << "end\n".freeze
 
-        if @location
-          erbout << "      @offset_loc = offset_loc\n".freeze
+        if !code(:lsource).empty?
+          erbout << "\n".freeze
+
+          code(:lsource).each do |code|
+            erbout << "#{stream.get_code_block(code, 0, @iname)}".freeze
+          end
         end
-        erbout << "      @fail = true\n      @grow = false\n    end\n\n    def answer=(answer)\n      @fail = nil\n      @answer = answer\n    end\n  end\n\n  class ThunkChunk\n    attr_accessor :thunks, :capts, :pos, :values\n".freeze
+        erbout
+      when :rs
+        erbout = +""
+        erbout << "/* A packrat parser generated by PackCR #{Packcr::VERSION} */\n\nuse std::cell::RefCell;\nuse std::collections::{HashMap, HashSet};\nuse std::io::Read;\nuse std::rc::Rc;\n".freeze
 
-        if @location
-          erbout << "    attr_accessor :pos_loc\n".freeze
+        if !code(:esource).empty?
+          erbout << "\n".freeze
+
+          code(:esource).each do |code|
+            erbout << "#{stream.get_code_block(code, 0, @iname)}".freeze
+          end
         end
-        erbout << "\n    def initialize\n      super\n      @thunks = []\n      @capts = {}\n      @pos = 0\n      @values = {}\n    end\n\n    def resize_captures(len)\n      len.times do |i|\n        @capts[i] = Capture.new\n      end\n    end\n  end\n\n  class ThunkLeaf\n    attr_accessor :capt0, :capts, :value_refs, :action\n\n    def initialize(action, capt0 = Capture.new, value_refs = {}, capts = {})\n      @value_refs = value_refs\n      @capts = capts\n      @capt0 = capt0\n      @action = action\n    end\n\n    def do_action(ctx, values, index)\n      ctx.public_send(action, self, values, index)\n    end\n  end\n\n  class ThunkNode\n    attr_accessor :thunks, :values, :index\n\n    def initialize(thunks, values, index)\n      @thunks = thunks\n      @values = values\n      @index = index\n      values[index] ||= Value.new if values\n    end\n\n    def do_action(ctx, _values, _index)\n      @thunks.each do |thunk|\n        thunk.do_action(ctx, @values, @index)\n      end\n    end\n\n    def clear\n      @thunks.clear\n    end\n  end\n\n  class Capture\n    attr_accessor :range_start, :range_end\n".freeze
+        use_value = @root.rules.map { |r| r.vars.size }.max > 0
+        erbout << "\nstruct LrMemoTable {\n    memos: HashMap<usize, LrMemoMap>,\n}\nimpl LrMemoTable {\n    fn new() -> Self {\n        Self {\n            memos: HashMap::new(),\n        }\n    }\n\n    fn clear(&mut self) {\n        self.memos.clear();\n    }\n\n    fn set(&mut self, index: usize, rule: Rule, memo: LrMemo) {\n        let memo_map = self.memos.entry(index).or_default();\n        memo_map.insert(rule, memo);\n    }\n\n    fn get(&mut self, index: usize, rule: Rule) -> &mut LrMemo {\n        self.memos.get_mut(&index).unwrap().get_mut(&rule).unwrap()\n    }\n    fn has(&self, index: usize, rule: Rule) -> bool {\n        self.memos\n            .get(&index)\n            .is_some_and(|memo_map| memo_map.contains_key(&rule))\n    }\n}\n\nstruct LrMemo {\n    offset: usize,\n    answer: Option<Rc<RefCell<ThunkChunk>>>,\n    grow: bool,\n}\n\nimpl LrMemo {\n    fn new(offset: usize) -> Self {\n        Self {\n            offset,\n            answer: None,\n            grow: false,\n        }\n    }\n\n    fn start_grow(&mut self) -> bool {\n        if !self.grow && self.answer.is_none() {\n            self.grow = true;\n            true\n        } else {\n            false\n        }\n    }\n\n    fn update(&mut self, answer: Option<ThunkChunk>, offset: usize) {\n        self.answer = answer.map(|c| Rc::new(RefCell::new(c)));\n        self.offset = offset;\n    }\n\n    fn clone_answer(&mut self) -> Option<Rc<RefCell<ThunkChunk>>> {\n        self.answer.as_ref().map(Rc::clone)\n    }\n}\n\nstruct ThunkChunk {\n    thunks: Rc<RefCell<Vec<Thunk>>>,\n    capts: CaptureTable,\n    pos: usize,\n    values: ValueTable,\n}\n\nimpl ThunkChunk {\n    fn new(pos: usize) -> Self {\n        Self {\n            values: ValueTable::new(),\n            capts: CaptureTable::new(),\n            thunks: Rc::new(RefCell::new(Vec::new())),\n            pos,\n        }\n    }\n\n    fn push_leaf(\n        &self,\n        action: Action,\n        end: usize,\n        value_indices: &[usize],\n        capt_indices: &[usize],\n    ) {\n        {\n            let start = self.pos;\n            let mut value_refs = HashMap::new();\n            for &index in value_indices {\n                value_refs.insert(index, ValueRef::new(index, self.values.clone()));\n            }\n            let mut capts = HashMap::new();\n            for &index in capt_indices {\n                capts.insert(index, self.capts[index].clone());\n            }\n            let leaf = Thunk::Leaf(ThunkLeaf::new(action, start, end, value_refs, capts));\n            self.thunks.borrow_mut().push(leaf);\n        }\n    }\n\n    fn value_ref(&self, index: usize) -> ValueRef {\n        ValueRef::new(index, self.values.clone())\n    }\n}\n\nenum Thunk {\n    Leaf(ThunkLeaf),\n    Node(ThunkNode),\n}\nimpl Thunk {\n    fn do_action(&self, processor: &ThunkProcessor, value: ValueRef) -> Value {\n        match self {\n            Thunk::Leaf(leaf) => leaf.do_action(processor, value),\n            Thunk::Node(node) => node.do_action(processor),\n        }\n    }\n}\n\n#[allow(dead_code)]\nstruct ThunkLeaf {\n    value_refs: HashMap<usize, ValueRef>,\n    capts: HashMap<usize, Capture>,\n    capt0: Capture,\n    action: Action,\n}\nimpl ThunkLeaf {\n    fn new(\n        action: Action,\n        start: usize,\n        end: usize,\n        value_refs: HashMap<usize, ValueRef>,\n        capts: HashMap<usize, Capture>,\n    ) -> Self {\n        Self {\n            value_refs,\n            capts,\n            capt0: Capture { start, end },\n            action,\n        }\n    }\n\n    fn do_action(&self, processor: &ThunkProcessor, mut value: ValueRef) -> Value {\n        value.with_mut(|v| {\n            processor.call_action(self.action, self, v);\n        });\n        value.get()\n    }\n".freeze
 
-        if @location
-          erbout << "    attr_accessor :start_loc, :end_loc\n".freeze
+        if use_value
+          erbout << "\n    fn values(&self) -> HashMap<usize, Value> {\n        self.value_refs.iter().map(|(k, v)| (*k, v.get())).collect()\n    }\n".freeze
         end
-        erbout << "\n    def initialize(range_start = 0, range_end = 0".freeze
-        if @location
-          erbout << ", start_loc = nil, end_loc = nil".freeze
+        erbout << "}\n\nstruct ThunkNode {\n    thunks: Rc<RefCell<Vec<Thunk>>>,\n    value: ValueRef,\n}\nimpl ThunkNode {\n    fn do_action(&self, processor: &ThunkProcessor) -> Value {\n        let mut v = 0;\n        for thunk in self.thunks.borrow_mut().iter_mut() {\n            v = thunk.do_action(processor, self.value.clone());\n        }\n        v\n    }\n}\n\n#[derive(Clone)]\nstruct Capture {\n    start: usize,\n    end: usize,\n}\n\ntype Value = i32;\n\nstruct ValueTable {\n    table: Rc<RefCell<HashMap<usize, Value>>>,\n}\nimpl ValueTable {\n    fn new() -> Self {\n        Self {\n            table: Rc::new(RefCell::new(HashMap::new())),\n        }\n    }\n".freeze
+
+        if use_value
+          erbout << "\n    fn clear(&mut self) {\n        self.table.borrow_mut().clear();\n    }\n".freeze
         end
-        erbout << ")\n      @range_start = range_start\n      @range_end = range_end\n".freeze
+        erbout << "\n    fn with_mut<F>(&mut self, index: usize, f: F)\n    where\n        F: FnOnce(&mut Value),\n    {\n        let mut table = self.table.borrow_mut();\n        let value = table.entry(index).or_insert(0);\n        f(value);\n    }\n}\nimpl Clone for ValueTable {\n    fn clone(&self) -> Self {\n        Self {\n            table: self.table.clone(),\n        }\n    }\n}\n\nstruct ValueRef {\n    values: ValueTable,\n    index: usize,\n}\nimpl ValueRef {\n    fn new(index: usize, values: ValueTable) -> Self {\n        Self { index, values }\n    }\n\n    fn with_mut<F>(&mut self, f: F)\n    where\n        F: FnOnce(&mut i32),\n    {\n        self.values.with_mut(self.index, f);\n    }\n\n    fn get(&self) -> i32 {\n        *self.values.table.borrow().get(&self.index).unwrap_or(&0)\n    }\n}\nimpl Clone for ValueRef {\n    fn clone(&self) -> Self {\n        Self {\n            index: self.index,\n            values: self.values.clone(),\n        }\n    }\n}\n\nstruct CaptureTable {\n    table: HashMap<usize, Capture>,\n    len: usize,\n}\n\ntype RuleSet = HashSet<Rule>;\ntype RuleLimit = Option<RuleSet>;\n\ntype LrMemoMap = HashMap<Rule, LrMemo>;\n\nimpl CaptureTable {\n    fn new() -> Self {\n        Self {\n            table: HashMap::new(),\n            len: 0,\n        }\n    }\n\n    fn resize(&mut self, len: usize) {\n        let current_len = self.len;\n        if len > current_len {\n            for i in current_len..len {\n                self.table.insert(i, Capture { start: 0, end: 0 });\n            }\n        } else if len < current_len {\n            for i in len..current_len {\n                self.table.remove(&i);\n            }\n        }\n        self.len = len;\n    }\n}\nimpl std::ops::Index<usize> for CaptureTable {\n    type Output = Capture;\n\n    fn index(&self, index: usize) -> &Self::Output {\n        &self.table[&index]\n    }\n}\nimpl std::ops::IndexMut<usize> for CaptureTable {\n    fn index_mut(&mut self, index: usize) -> &mut Self::Output {\n        if self.len <= index {\n            self.resize(index + 1);\n        }\n        self.table.get_mut(&index).unwrap()\n    }\n}\n\nstruct Input {\n    input: Box<dyn std::io::Read>,\n    start_position: usize,\n    position_offset: usize,\n    buffer: String,\n    closed: bool,\n}\n\nimpl Input {\n    fn new(input: impl std::io::Read + 'static) -> Self {\n        Self {\n            input: Box::new(input),\n            start_position: 0,\n            position_offset: 0,\n            buffer: String::new(),\n            closed: false,\n        }\n    }\n\n    fn refill_buffer(&mut self, num: usize) -> usize {\n        let mut len = self.buffer.len();\n        if len >= self.position_offset + num {\n            return len - self.position_offset;\n        }\n\n        let mut input_buffer = [0u8; 1024];\n\n        while len < self.position_offset + num {\n            match self.input.read(&mut input_buffer) {\n                Ok(0) => break,\n                Ok(bytes_read) => {\n                    let s = std::string::String::from_utf8_lossy(&input_buffer[..bytes_read]);\n                    self.buffer.push_str(&s);\n                }\n                Err(_) => break,\n            }\n            len = self.buffer.len();\n        }\n\n        len - self.position_offset\n    }\n\n    fn commit_buffer(&mut self) {\n        let position_offset = self.position_offset;\n\n        self.buffer.drain(..position_offset);\n\n        self.start_position += position_offset;\n        self.position_offset = 0;\n    }\n\n    #[allow(dead_code)]\n    fn get_char_as_utf32(&mut self) -> (i32, usize) {\n        if self.refill_buffer(1) < 1 {\n            return (0, 0);\n        }\n\n        let current_position = self.position_offset;\n        let remaining_chars: &str = &self.buffer[current_position..];\n\n        if let Some(ch) = remaining_chars.chars().next() {\n            let bytes_used = ch.len_utf8();\n\n            if self.refill_buffer(bytes_used) < bytes_used {\n                return (0, 0);\n            }\n\n            let utf32_value = ch as u32 as i32;\n\n            return (utf32_value, bytes_used);\n        }\n\n        (0, 0)\n    }\n\n    fn back_to(&mut self, memo: &mut LrMemo) -> Option<Rc<RefCell<ThunkChunk>>> {\n        self.position_offset = memo.offset;\n        memo.clone_answer()\n    }\n}\n\nconst NOP: Result<usize, usize> = Ok(0);\nconst fn throw(label: usize) -> Result<usize, usize> {\n    Err(label)\n}\n\nfn catch(label: usize, f: impl FnOnce() -> Result<usize, usize>) -> Result<usize, usize> {\n    match f() {\n        Ok(_) => NOP,\n        Err(e) if e == label => NOP,\n        Err(e) => throw(e),\n    }\n}\n\nstruct #{class_name} {\n    level: usize,\n    memos: LrMemoTable,\n    input: Input,\n}\n\nimpl #{class_name} {\n    fn new(input: impl std::io::Read + 'static) -> Self {\n        Self {\n            level: 0,\n            memos: LrMemoTable::new(),\n            input: Input::new(input),\n        }\n    }\n\n    fn parse(&mut self) -> Option<Value> {\n        if self.input.closed {\n            return None;\n        }\n\n        let mut answer = ThunkChunk::new(0);\n        let pos = self.input.start_position;\n".freeze
 
-        if @location
-          erbout << "      @start_loc = start_loc || Location.new\n      @end_loc = end_loc || Location.new\n".freeze
+        if !@root.rules.empty?
+          erbout << "\n        let value = {\n            let node = self.rule_thunk_node(\n                Rule::#{Packcr.camelize(@root.rules[0].name)},\n                &mut answer,\n                0,\n                self.input.position_offset,\n                &None,\n            );\n            self.memos.clear();\n            node.map(|node| node.do_action(&ThunkProcessor::new(&self.input.buffer)))\n        };\n        self.input.commit_buffer();\n        if pos == self.input.start_position || self.input.refill_buffer(1) < 1 {\n            self.input.closed = true;\n        }\n        value\n".freeze
+        end
+        erbout << "    }\n\n    fn grow_lr(&mut self, rule: Rule, offset: usize) {\n        loop {\n            let old_offset = self.input.position_offset;\n            self.input.position_offset = offset;\n\n            let answer = self.call_rule(rule, offset, Some(RuleSet::new()));\n            match answer {\n                Some(answer) if self.input.position_offset > old_offset => {\n                    let memo = self.memos.get(offset, rule);\n                    memo.update(Some(answer), self.input.position_offset);\n                }\n                _ => {\n                    return;\n                }\n            }\n        }\n    }\n\n    fn rule_answer_without_limits(&mut self, rule: Rule) -> Option<Rc<RefCell<ThunkChunk>>> {\n        let offset = self.input.position_offset;\n        if !self.memos.has(offset, rule) {\n            let memo = LrMemo::new(offset);\n            self.memos.set(offset, rule, memo);\n            let answer = self.call_rule(rule, offset, None);\n\n            let memo = self.memos.get(offset, rule);\n            memo.update(answer, self.input.position_offset);\n            if !memo.grow {\n                return self.input.back_to(memo);\n            }\n            self.grow_lr(rule, offset);\n\n            let memo = self.memos.get(offset, rule);\n            memo.grow = false;\n            return self.input.back_to(memo);\n        }\n\n        let memo = self.memos.get(offset, rule);\n        if memo.start_grow() {\n            return None;\n        }\n        self.input.back_to(memo)\n    }\n\n    fn rule_answer_with_limits(\n        &mut self,\n        rule: Rule,\n        limits: RuleSet,\n    ) -> Option<Rc<RefCell<ThunkChunk>>> {\n        let offset = self.input.position_offset;\n        let answer = self.call_rule(rule, offset, Some(limits));\n        if !self.memos.has(offset, rule) {\n            return answer.map(|answer| Rc::new(RefCell::new(answer)));\n        }\n\n        let memo = self.memos.get(offset, rule);\n        if self.input.position_offset > memo.offset {\n            memo.update(answer, self.input.position_offset);\n        }\n        self.input.back_to(memo)\n    }\n\n    fn apply_rule(\n        &mut self,\n        rule: Rule,\n        parent: &mut ThunkChunk,\n        value_index: usize,\n        offset: usize,\n        limits: &RuleLimit,\n    ) -> bool {\n        let node = self.rule_thunk_node(rule, parent, value_index, offset, limits);\n        node.is_some_and(|node| {\n            parent.thunks.borrow_mut().push(Thunk::Node(node));\n            true\n        })\n    }\n\n    fn rule_thunk_node(\n        &mut self,\n        rule: Rule,\n        parent: &ThunkChunk,\n        value_index: usize,\n        offset: usize,\n        limits: &RuleLimit,\n    ) -> Option<ThunkNode> {\n        match limits {\n            Some(limit_set)\n                if self.input.position_offset == offset && !limit_set.contains(&rule) =>\n            {\n                self.rule_answer_with_limits(rule, limits.clone().unwrap())\n            }\n            _ => self.rule_answer_without_limits(rule),\n        }\n        .map(|answer| ThunkNode {\n            thunks: answer.borrow().thunks.clone(),\n            value: parent.value_ref(value_index),\n        })\n    }\n\n    fn call_rule(\n        &mut self,\n        rule: Rule,\n        offset: usize,\n        mut limits: RuleLimit,\n    ) -> Option<ThunkChunk> {\n        if let Some(ref mut limits) = limits {\n            limits.insert(rule);\n        }\n        match rule {\n".freeze
+
+        @root.rules.each do |rule|
+          erbout << "            Rule::#{Packcr.camelize(rule.name)} => self.evaluate_rule_#{rule.name}(offset, limits),\n".freeze
+        end
+        erbout << "        }\n    }\n".freeze
+
+        @root.rules.each do |rule|
+          erbout << "\n".freeze
+
+          gen = ::Packcr::Generator.new(rule, @ascii, @location, :rs)
+
+          erbout << "#{gen.generate_code(rule, 0, 4, false)}".freeze
+        end
+        erbout << "}\n\nstruct ThunkProcessor<'a> {\n    buffer: &'a str,\n}\n\nimpl<'a> ThunkProcessor<'a> {\n    fn new(buffer: &'a str) -> Self {\n        Self { buffer }\n    }\n\n    fn call_action(&self, action: Action, thunk: &ThunkLeaf, value: &mut i32) {\n        match action {\n".freeze
+
+        @root.rules.each do |rule|
+          rule.codes.each do |code|
+            erbout << "            Action::#{Packcr.camelize(rule.name)}#{code.index} => self.action_#{rule.name}_#{code.index}(thunk, value),\n".freeze
+          end
+        end
+        erbout << "        }\n    }\n".freeze
+
+        @root.rules.each do |rule|
+          rule.codes.each do |code|
+            erbout << "\n    #[allow(unused_variables, non_snake_case)]\n    fn action_#{rule.name}_#{code.index}(&self, leaf: &ThunkLeaf, out: &mut i32) {\n".freeze
+
+            code.vars.each_with_index do |ref, i|
+              if i == 0
+                erbout << "        let values = leaf.values();\n".freeze
+              end
+              erbout << "        let #{ref.var} = values[&#{ref.index}];\n".freeze
+            end
+            erbout << "        let _0 = {\n            let capt = &leaf.capt0;\n            &self.buffer[(capt.start)..(capt.end)]\n        };\n".freeze
+
+            code.capts.size.times do |i|
+              erbout << "        let _#{i + 1} = {\n            let capt = &leaf.capts[&#{i}];\n            &self.buffer[(capt.start)..(capt.end)]\n        };\n".freeze
+            end
+            erbout << "    #{stream.get_code_block(code.code, 4, @iname)}    }\n".freeze
+          end
+        end
+        erbout << "}\n\n#[derive(Copy, Clone)]\nenum Action {\n".freeze
+
+        @root.rules.each do |rule|
+          rule.codes.each do |code|
+            erbout << "    #{Packcr.camelize(rule.name)}#{code.index},\n".freeze
+          end
+        end
+        erbout << "}\n\n#[derive(Copy, Clone, PartialEq, Eq, Hash)]\nenum Rule {\n".freeze
+
+        @root.rules.each do |rule|
+          erbout << "    #{Packcr.camelize(rule.name)},\n".freeze
         end
-        erbout << "    end\n\n    def capture_string(buffer)\n      @capture_string ||= buffer[@range_start, @range_end - @range_start]\n    end\n  end\n\n  class Value\n    attr_accessor :value\n  end\nend\n".freeze
+        erbout << "}\n".freeze
 
         if !code(:lsource).empty?
           erbout << "\n".freeze
@@ -477,6 +574,8 @@ class Packcr
           end
         end
         erbout
+      else
+        raise "unknown lang #{lang}"
       end
     end
   end

data/lib/packcr/generated/node/action_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class ActionNode
-      def get_code(gen, onfail, indent, bare, oncut)
+      def get_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""
@@ -53,6 +53,21 @@ class Packcr
           erbout << "  )\n)\n".freeze
 
           erbout
+        when :rs
+          erbout = +""
+          erbout << "answer.push_leaf(Action::#{Packcr.camelize(gen.rule.name)}#{index}, self.input.position_offset, &[".freeze
+          vars.each_with_index do |var, i|
+            erbout << "#{", " if i > 0}#{var.index}".freeze
+          end
+          erbout << "], &[".freeze
+          capts.each_with_index do |capt, i|
+            erbout << "#{", " if i > 0}#{capt.index}".freeze
+          end
+          erbout << "]);\n".freeze
+
+          erbout
+        else
+          raise "unknown lang #{gen.lang}"
         end
       end
     end

data/lib/packcr/generated/node/alternate_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class AlternateNode
-      def get_code(gen, onfail, indent, bare, oncut)
+      def get_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""
@@ -19,13 +19,12 @@ class Packcr
             r = expr.reachability
 
             erbout << "#{gen.generate_code(expr, l, 4, false)}".freeze
-            case r
-            when Packcr::CODE_REACH__ALWAYS_SUCCEED
+            if r == Packcr::CODE_REACH__ALWAYS_SUCCEED
               if c
                 erbout << "    /* unreachable codes omitted */\n".freeze
               end
               break
-            when Packcr::CODE_REACH__BOTH
+            elsif r == Packcr::CODE_REACH__BOTH
               erbout << "    goto L#{format("%04d", m)};\n".freeze
             end
             erbout << "L#{format("%04d", l)}:;\n    ctx->position_offset = p;\n".freeze
@@ -64,15 +63,14 @@ class Packcr
               r = expr.reachability
 
               erbout << "#{gen.generate_code(expr, l, 4, false, oncut: onfail)}".freeze
-              case r
-              when Packcr::CODE_REACH__ALWAYS_SUCCEED
+              if r == Packcr::CODE_REACH__ALWAYS_SUCCEED
                 if c
                   erbout << "    # unreachable codes omitted\n".freeze
                 end
                 erbout << "  end\n".freeze
 
                 break
-              when Packcr::CODE_REACH__BOTH
+              elsif r == Packcr::CODE_REACH__BOTH
                 erbout << "    throw(#{m})\n".freeze
               end
               erbout << "  end\n".freeze
@@ -91,6 +89,48 @@ class Packcr
           erbout << "end\n".freeze
 
           erbout
+        when :rs
+          erbout = +""
+          m = gen.next_label
+          erbout << "catch(#{m}, || {\n    let p = self.input.position_offset;\n".freeze
+
+          if gen.location
+            erbout << "    TODO\n".freeze
+          end
+          nodes.each_with_index do |expr, i|
+            c = i + 1 < nodes.length
+            if expr.reversible?(gen)
+
+              erbout << "#{gen.generate_code(expr, m, 4, false, reverse: true, oncut: onfail)}".freeze
+            else
+              l = gen.next_label
+              r = expr.reachability
+              if r == Packcr::CODE_REACH__ALWAYS_SUCCEED
+                erbout << "    catch(#{l}, || {\n#{gen.generate_code(expr, l, 8, false, oncut: onfail)}".freeze
+                if c
+                  erbout << "        // unreachable codes omitted\n".freeze
+                end
+                erbout << "        NOP\n    })?\n".freeze
+
+                break
+              else
+                erbout << "    catch(#{l}, || {\n#{gen.generate_code(expr, l, 8, false, oncut: onfail)}        throw(#{m})\n    })?;\n".freeze
+              end
+            end
+            erbout << "    self.input.position_offset = p;\n".freeze
+
+            if gen.location
+              erbout << "    TODO\n".freeze
+            end
+            next if c
+
+            erbout << "    throw(#{onfail})\n".freeze
+          end
+          erbout << "})?;\n".freeze
+
+          erbout
+        else
+          raise "unknown lang #{gen.lang}"
         end
       end
     end

data/lib/packcr/generated/node/capture_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class CaptureNode
-      def get_code(gen, onfail, indent, bare, oncut)
+      def get_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""
@@ -32,6 +32,21 @@ class Packcr
             erbout << "q_loc#{gen.level} = @position_offset_loc\ncapt#{gen.level}.start_loc = p_loc#{gen.level}\ncapt#{gen.level}.end_loc = q_loc#{gen.level}\n".freeze
           end
           erbout
+        when :rs
+          erbout = +""
+          erbout << "let p_inner = self.input.position_offset;\n".freeze
+
+          if gen.location
+            erbout << "TODO\n".freeze
+          end
+          erbout << "{\n#{gen.generate_code(expr, onfail, 4, false)}}\nlet q = self.input.position_offset;\nanswer.capts[#{index}].start = p_inner;\nanswer.capts[#{index}].end = q;\n".freeze
+
+          if gen.location
+            erbout << "TODO\n".freeze
+          end
+          erbout
+        else
+          raise "unknown lang #{gen.lang}"
         end
       end
     end