packcr 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cacf5e781ba49bcc7d755ac5ba6e348646a08e4a807efd4375ba720232262556
-  data.tar.gz: ce70800733fbc71527539174f373786489f3fdda416b5435bf8aa687de1cd321
+  metadata.gz: a1797f847b90f8c53e2745592691b7f7ae12a5e18a1861f25b7e84825278529d
+  data.tar.gz: f593a9234386b345f4af1de58467c31640ad2233918f3149f00d53c8df70c379
 SHA512:
-  metadata.gz: f0cf28feb81c97f094f6b098656ab4ec30f312e99c84789c5e5f53cf8a520c4c63a561d48a240b7ab0699d2e063820e3b923118d33e2a9e3b5dfc2884993ac9d
-  data.tar.gz: c858ad58e577af40013bbd7438eb3c4066d0c76b0a6407c5ab051ae63a379936594da974a1c203a72659d3dcebc4794c0aaaf5beea2ab98169388a89c0c79773
+  metadata.gz: ba48fc2f71db11977fd9c1f12f520d639d9618383f08fcbe5b7e71930084f29f32e3fed2baac800ccedd8f3e50f026daf530636ebabd31e9bc682a4798e17b8e
+  data.tar.gz: 1cad26bb87e543e4404df9f5e491398655e3fdc36dbe50452a6805229c06db196ba7c2c2878e461e595321376f00c65110ccba78dad3474f8039991cdff0fd9b

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,140 @@ 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\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(&mut self, index: usize, rule: Rule) -> bool {\n        let memo_opt = self.memos.get_mut(&index);\n        if memo_opt.is_none() {\n            return false;\n        }\n        memo_opt.unwrap().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_some() {\n            return false;\n        }\n        self.answer = None;\n        self.grow = true;\n        true\n    }\n\n    fn start_match(&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 answer_as_deref_mut(&mut self) -> Option<Rc<RefCell<ThunkChunk>>> {\n        self.answer.as_ref()?;\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) {\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) {\n        value.with_mut(|v| {\n            processor.call_action(self.action, self, v);\n        });\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) {\n        for thunk in self.thunks.borrow().iter() {\n            thunk.do_action(processor, self.value.clone());\n        }\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".freeze
 
-        if @location
-          erbout << "      @start_loc = start_loc || Location.new\n      @end_loc = end_loc || Location.new\n".freeze
+        if use_value
+          erbout << "    fn get(&self) -> i32 {\n        *self.values.table.borrow().get(&self.index).unwrap_or(&0)\n    }\n".freeze
+        end
+        erbout << "}\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>;\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}\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        }\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.answer_as_deref_mut()\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 error(&self) -> ! {\n        eprintln!(\"Syntax error\");\n        std::process::exit(1);\n    }\n\n    fn refill_buffer(&mut self, num: usize) -> usize {\n        self.input.refill_buffer(num)\n    }\n\n    fn commit_buffer(&mut self) {\n        self.input.commit_buffer();\n        self.memos.clear();\n    }\n\n    fn parse(&mut self) -> bool {\n        let mut answer = ThunkChunk::new(0);\n        let pos = self.input.start_position;\n\n".freeze
+
+        if !@root.rules.empty?
+          erbout << "        let apply_result = self.apply_rule(\n            Rule::#{Packcr.camelize(@root.rules[0].name)},\n            &mut answer,\n            0,\n            self.input.position_offset,\n            None,\n        );\n\n        if apply_result {\n            if let Thunk::Node(node) = answer.thunks.borrow_mut().last().unwrap() {\n                node.do_action(&ThunkProcessor::new(&self.input.buffer));\n            }\n        } else {\n            self.error();\n        }\n\n".freeze
+        end
+        erbout << "        self.commit_buffer();\n        pos != self.input.start_position && self.refill_buffer(1) >= 1\n    }\n\n    #[allow(dead_code)]\n    fn get_char_as_utf32(&mut self) -> (i32, usize) {\n        self.input.get_char_as_utf32()\n    }\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            if answer.is_none() || self.input.position_offset <= old_offset {\n                return;\n            }\n\n            let memo = self.memos.get(offset, rule);\n            memo.start_match(answer, self.input.position_offset);\n        }\n    }\n\n    fn rule_answer(&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.start_match(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            answer.as_ref()?;\n            return Some(Rc::new(RefCell::new(answer.unwrap())));\n        }\n        let memo = self.memos.get(offset, rule);\n\n        if self.input.position_offset > memo.offset {\n            memo.start_match(answer, self.input.position_offset);\n            return memo.answer_as_deref_mut();\n        }\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: Option<RuleSet>,\n    ) -> bool {\n        let answer = 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.unwrap())\n            }\n            _ => self.rule_answer(rule),\n        };\n\n        let Some(answer) = answer else {\n            return false;\n        };\n\n        let new_node = Thunk::Node(ThunkNode {\n            thunks: answer.borrow().thunks.clone(),\n            value: parent.value_ref(value_index),\n        });\n        parent.thunks.borrow_mut().push(new_node);\n\n        true\n    }\n\n    fn call_rule(\n        &mut self,\n        rule: Rule,\n        offset: usize,\n        mut limits: Option<RuleSet>,\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\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 +579,8 @@ class Packcr
           end
         end
         erbout
+      else
+        raise "unknown lang #{lang}"
       end
     end
   end

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

@@ -53,6 +53,23 @@ class Packcr
           erbout << "  )\n)\n".freeze
 
           erbout
+        when :rs
+          erbout = +""
+          erbout << "answer.push_leaf(\n    Action::#{Packcr.camelize(gen.rule.name)}#{index},\n    self.input.position_offset,\n    &[".freeze
+
+          vars.each_with_index do |var, i|
+            erbout << "#{", " if i > 0}#{var.index}".freeze
+          end
+          erbout << "],\n    &[".freeze
+
+          capts.each_with_index do |capt, i|
+            erbout << "#{", " if i > 0}#{capt.index}".freeze
+          end
+          erbout << "],\n);\n".freeze
+
+          erbout
+        else
+          raise "unknown lang #{gen.lang}"
         end
       end
     end

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

@@ -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,54 @@ class Packcr
           erbout << "end\n".freeze
 
           erbout
+        when :rs
+          erbout = +""
+          m = gen.next_label
+          erbout << "'L#{format("%04d", 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|
+            erbout << "    {\n".freeze
+
+            c = i + 1 < nodes.length
+            if expr.reversible?(gen)
+
+              erbout << "#{gen.generate_code(expr, m, 8, false, reverse: true, oncut: onfail)}".freeze
+            else
+              l = gen.next_label
+              erbout << "        'L#{format("%04d", l)}: {\n".freeze
+
+              r = expr.reachability
+
+              erbout << "#{gen.generate_code(expr, l, 12, false, oncut: onfail)}".freeze
+              if r == Packcr::CODE_REACH__ALWAYS_SUCCEED
+                if c
+                  erbout << "            // unreachable codes omitted\n".freeze
+                end
+                erbout << "        }\n".freeze
+
+                break
+              elsif r == Packcr::CODE_REACH__BOTH
+                erbout << "            break 'L#{format("%04d", m)};\n".freeze
+              end
+              erbout << "        }\n".freeze
+            end
+            erbout << "    }\n    self.input.position_offset = p;\n".freeze
+
+            if gen.location
+              erbout << "    TODO\n".freeze
+            end
+            next if c
+
+            erbout << "    break 'L#{format("%04d", onfail)};\n".freeze
+          end
+          erbout << "} // 'L#{format("%04d", m)}\n".freeze
+
+          erbout
+        else
+          raise "unknown lang #{gen.lang}"
         end
       end
     end

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

@@ -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