packcr 0.0.4 → 0.0.7

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

@@ -0,0 +1,167 @@
+class Packcr
+  class Node
+    class QuantityNode
+      def get_many_code(gen, onfail, indent, bare, oncut)
+        case gen.lang
+        when :c
+          erbout = +""
+          erbout << "{\n".freeze
+
+          if min > 0
+            erbout << "    const size_t p0 = ctx->position_offset;\n".freeze
+
+            if gen.location
+              erbout << "    const pcc_location_t p0_loc = ctx->position_offset_loc;\n".freeze
+            end
+            erbout << "    const size_t n0 = chunk->thunks.len;\n".freeze
+          end
+          erbout << "    int i;\n".freeze
+
+          if max < 0
+            erbout << "    for (i = 0;; i++) {\n".freeze
+
+          else
+            erbout << "    for (i = 0; i < #{max}; i++) {\n".freeze
+          end
+          erbout << "        const size_t p = ctx->position_offset;\n".freeze
+
+          if gen.location
+            erbout << "        const pcc_location_t p_loc = ctx->position_offset_loc;\n".freeze
+          end
+          erbout << "        const size_t n = chunk->thunks.len;\n".freeze
+
+          l = gen.next_label
+          r = expr.reachability
+          erbout << "#{gen.generate_code(expr, l, 8, false)}        if (ctx->position_offset == p) break;\n".freeze
+
+          if r != Packcr::CODE_REACH__ALWAYS_SUCCEED
+            erbout << "        continue;\n    L#{format("%04d", l)}:;\n        ctx->position_offset = p;\n".freeze
+
+            if gen.location
+              erbout << "        ctx->position_offset_loc = p_loc;\n".freeze
+            end
+            erbout << "        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);\n        break;\n".freeze
+          end
+          erbout << "    }\n".freeze
+
+          if min > 0
+            erbout << "    if (i < #{min}) {\n        ctx->position_offset = p0;\n".freeze
+
+            if gen.location
+              erbout << "        ctx->position_offset_loc = p0_loc;\n".freeze
+            end
+            erbout << "        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);\n        goto L#{format("%04d", onfail)};\n    }\n".freeze
+          end
+          erbout << "}\n".freeze
+
+          erbout
+        when :rb
+          erbout = +""
+          if min > 0
+            erbout << "q#{gen.level} = @position_offset\n".freeze
+
+            if gen.location
+              erbout << "q_loc#{gen.level} = @position_offset_loc\n".freeze
+            end
+            erbout << "m#{gen.level} = answer.thunks.length\n".freeze
+          end
+          erbout << "i#{gen.level} = 0\npos#{gen.level} = nil\n".freeze
+
+          if gen.location
+            erbout << "p_loc#{gen.level} = nil\n".freeze
+          end
+          erbout << "n#{gen.level} = nil\n".freeze
+
+          l = gen.next_label
+          erbout << "catch(#{l}) do\n  pos#{gen.level} = @position_offset\n".freeze
+
+          if gen.location
+            erbout << "  p_loc#{gen.level} = @position_offset_loc\n".freeze
+          end
+          erbout << "  n#{gen.level} = answer.thunks.length\n".freeze
+
+          r = expr.reachability
+
+          erbout << "#{gen.generate_code(expr, l, 2, false)}  i#{gen.level} += 1\n  if @position_offset != pos#{gen.level}".freeze
+          if max >= 0
+            erbout << " || i#{gen.level} < #{max}".freeze
+          end
+          erbout << "\n    redo\n  end\n  pos#{gen.level} = nil\nend\n".freeze
+
+          if r != Packcr::CODE_REACH__ALWAYS_SUCCEED
+            erbout << "if pos#{gen.level}\n  @position_offset = pos#{gen.level}\n".freeze
+
+            if gen.location
+              erbout << "  @position_offset_loc = p_loc#{gen.level}\n".freeze
+            end
+            erbout << "  answer.thunks[n#{gen.level}..-1] = []\nend\n".freeze
+          end
+          if min > 0
+            erbout << "if i#{gen.level} < #{min}\n  @position_offset = q#{gen.level}\n".freeze
+
+            if gen.location
+              erbout << "  @position_offset_loc = q_loc#{gen.level}\n".freeze
+            end
+            erbout << "  answer.thunks[m#{gen.level}..-1] = []\n  throw(#{onfail})\nend\n".freeze
+          end
+          erbout
+        end
+      end
+
+      def get_one_code(gen, onfail, indent, bare, oncut)
+        case gen.lang
+        when :c
+          erbout = +""
+          erbout << "{\n".freeze
+
+          l = gen.next_label
+          erbout << "    const size_t p = ctx->position_offset;\n".freeze
+
+          if gen.location
+            erbout << "    const pcc_location_t p_loc = ctx->position_offset_loc;\n".freeze
+          end
+          erbout << "    const size_t n = chunk->thunks.len;\n".freeze
+
+          r = expr.reachability
+          erbout << "#{gen.generate_code(expr, l, 4, false)}".freeze
+          if r != Packcr::CODE_REACH__ALWAYS_SUCCEED
+            m = gen.next_label
+            erbout << "    goto L#{format("%04d", m)};\nL#{format("%04d", l)}:;\n".freeze
+
+            if gen.location
+              erbout << "    ctx->position_offset_loc = p_loc;\n".freeze
+            end
+            erbout << "    ctx->position_offset = p;\n    pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);\nL#{format("%04d", m)}:;\n".freeze
+          end
+          erbout << "}\n".freeze
+
+          erbout
+        when :rb
+          erbout = +""
+          l = gen.next_label
+          erbout << "pos#{gen.level} = @position_offset\n".freeze
+
+          if gen.location
+            erbout << "p_loc#{gen.level} = @position_offset_loc\n".freeze
+          end
+          erbout << "n#{gen.level} = answer.thunks.length\n".freeze
+
+          r = expr.reachability
+          if r == Packcr::CODE_REACH__ALWAYS_SUCCEED
+
+            erbout << "#{gen.generate_code(expr, l, 0, false)}".freeze
+          else
+            m = gen.next_label
+            erbout << "catch(#{m}) do\n  catch(#{l}) do\n#{gen.generate_code(expr, l, 4, false)}    throw(#{m})\n  end\n".freeze
+
+            if gen.location
+              erbout << "  @position_offset_loc = p_loc#{gen.level}\n".freeze
+            end
+            erbout << "  @position_offset = pos#{gen.level}\n  answer.thunks[n#{gen.level}..-1] = []\nend\n".freeze
+          end
+          erbout
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+class Packcr
+  class Node
+    class ReferenceNode
+      def get_code(gen, onfail, indent, bare, oncut)
+        case gen.lang
+        when :c
+          erbout = +""
+          if index.nil?
+            erbout << "{\n    pcc_rule_set_t *l = NULL;\n    if (limits && ctx->position_offset == offset && pcc_rule_set__index(ctx->auxil, limits, pcc_evaluate_rule_#{name}) == PCC_VOID_VALUE) {\n        l = limits;\n    }\n    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_#{name}, &chunk->thunks, NULL, offset".freeze
+          else
+            erbout << "{\n    pcc_rule_set_t *l = NULL;\n    if (limits && ctx->position_offset == offset && pcc_rule_set__index(ctx->auxil, limits, pcc_evaluate_rule_#{name}) == PCC_VOID_VALUE) {\n        l = limits;\n    }\n    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_#{name}, &chunk->thunks, &(chunk->values.buf[#{index}]), offset".freeze
+
+          end
+          if gen.location
+            erbout << ", offset_loc".freeze
+          end
+          erbout << ", l)) goto L#{format("%04d", onfail)};\n}\n".freeze
+          erbout
+        when :rb
+          erbout = +""
+          if index.nil?
+            erbout << "if limits && @position_offset == offset && !limits[:evaluate_rule_#{name}]\n  if !apply_rule(:evaluate_rule_#{name}, answer.thunks, nil, 0, offset".freeze
+            if gen.location
+              erbout << ", offset_loc".freeze
+            end
+            erbout << ", limits: limits)\n    throw(#{onfail})\n  end\nelse\n  if !apply_rule(:evaluate_rule_#{name}, answer.thunks, nil, 0, offset".freeze
+          else
+            erbout << "if limits && @position_offset == offset && !limits[:evaluate_rule_#{name}]\n  if !apply_rule(:evaluate_rule_#{name}, answer.thunks, answer.values, #{index}, offset".freeze
+            if gen.location
+              erbout << ", offset_loc".freeze
+            end
+            erbout << ", limits: limits)\n    throw(#{onfail})\n  end\nelse\n  if !apply_rule(:evaluate_rule_#{name}, answer.thunks, answer.values, #{index}, offset".freeze
+
+          end
+          if gen.location
+            erbout << ", offset_loc".freeze
+          end
+          erbout << ")\n    throw(#{onfail})\n  end\nend\n".freeze
+          erbout
+        end
+      end
+
+      def get_reverse_code(gen, onsuccess, indent, bare, oncut)
+        case gen.lang
+        when :rb
+          erbout = +""
+          if index.nil?
+            erbout << "if limits && @position_offset == offset && !limits[:evaluate_rule_#{name}]\n  if apply_rule(:evaluate_rule_#{name}, answer.thunks, nil, 0, offset".freeze
+            if gen.location
+              erbout << ", offset_loc".freeze
+            end
+            erbout << ", limits: limits)\n    throw(#{onsuccess})\n  end\nelse\n  if apply_rule(:evaluate_rule_#{name}, answer.thunks, nil, 0, offset".freeze
+          else
+            erbout << "if limits && @position_offset == offset && !limits[:evaluate_rule_#{name}]\n  if apply_rule(:evaluate_rule_#{name}, answer.thunks, answer.values, #{index}, offset".freeze
+            if gen.location
+              erbout << ", offset_loc".freeze
+            end
+            erbout << ", limits: limits)\n    throw(#{onsuccess})\n  end\nelse\n  if apply_rule(:evaluate_rule_#{name}, answer.thunks, answer.values, #{index}, offset".freeze
+
+          end
+          if gen.location
+            erbout << ", offset_loc".freeze
+          end
+          erbout << ")\n    throw(#{onsuccess})\n  end\nend\n".freeze
+          erbout
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+class Packcr
+  class Node
+    class RuleNode
+      def get_code(gen, onfail, indent, bare, oncut)
+        case gen.lang
+        when :c
+          erbout = +""
+          erbout << "static pcc_thunk_chunk_t *pcc_evaluate_rule_#{name}(pcc_context_t *ctx, size_t offset".freeze
+          if gen.location
+            erbout << ", pcc_location_t offset_loc".freeze
+          end
+          erbout << ", pcc_rule_set_t *limits) {\n    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);\n    chunk->pos = ctx->position_offset;\n".freeze
+
+          if gen.location
+            erbout << "    chunk->pos_loc = ctx->position_offset_loc;\n".freeze
+          end
+          erbout << "    PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, \"#{name}\", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));\n    ctx->level++;\n    pcc_value_table__resize(ctx->auxil, &chunk->values, #{vars.length});\n    pcc_capture_table__resize(ctx->auxil, &chunk->capts, #{capts.length});\n".freeze
+
+          if !vars.empty?
+            erbout << "    pcc_value_table__clear(ctx->auxil, &chunk->values);\n".freeze
+          end
+          r = expr.reachability
+
+          erbout << "#{gen.generate_code(expr, 0, 4, false)}    ctx->level--;\n    PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, \"#{name}\", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->position_offset - chunk->pos));\n    return chunk;\n".freeze
+
+          if r != Packcr::CODE_REACH__ALWAYS_SUCCEED
+            erbout << "L0000:;\n    ctx->level--;\n    PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, \"#{name}\", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->position_offset - chunk->pos));\n    pcc_thunk_chunk__destroy(ctx, chunk);\n    return NULL;\n".freeze
+          end
+          erbout << "}\n".freeze
+
+          erbout
+        when :rb
+          erbout = +""
+          erbout << "def evaluate_rule_#{name}(offset".freeze
+          if gen.location
+            erbout << ", offset_loc".freeze
+          end
+          erbout << ", limits: nil)\n  answer = ThunkChunk.new\n  answer.pos = @position_offset\n".freeze
+
+          if gen.location
+            erbout << "  answer.pos_loc = @position_offset_loc\n".freeze
+          end
+          erbout << "  debug { warn \"\#{ \"  \" * @level}EVAL    #{name} \#{answer.pos} \#{@buffer[answer.pos..-1].inspect}\" }\n  @level += 1\n  answer.resize_captures(#{capts.length})\n".freeze
+
+          if !vars.empty?
+            erbout << "  answer.values = {}\n".freeze
+          end
+          r = expr.reachability
+          if r == Packcr::CODE_REACH__ALWAYS_SUCCEED
+
+            erbout << "#{gen.generate_code(expr, 0, 2, false)}  @level -= 1\n  debug { warn \"\#{ \"  \" * @level}MATCH   #{name} \#{answer.pos} \#{@buffer[answer.pos...@position_offset].inspect}\" }\n  return answer\n".freeze
+
+          else
+            erbout << "  catch(0) do\n#{gen.generate_code(expr, 0, 4, false)}    @level -= 1\n    debug { warn \"\#{ \"  \" * @level}MATCH   #{name} \#{answer.pos} \#{@buffer[answer.pos...@position_offset].inspect}\" }\n    return answer\n  end\n  @level -= 1\n  debug { warn \"\#{ \"  \" * @level}NOMATCH #{name} \#{answer.pos} \#{@buffer[answer.pos...@position_offset].inspect}\" }\n  return nil\n".freeze
+          end
+          erbout << "end\n".freeze
+
+          erbout
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+class Packcr
+  class Node
+    class SequenceNode
+      def get_code(gen, onfail, indent, bare, oncut)
+        case gen.lang
+        when :c
+          erbout = +""
+          if @cut && oncut
+            onfail = oncut
+            oncut = nil
+          end
+          nodes.each_with_index do |expr, i|
+            erbout << "#{gen.generate_code(expr, onfail, 0, false, oncut: oncut)}".freeze
+            next unless expr.reachability == Packcr::CODE_REACH__ALWAYS_FAIL
+
+            if i + 1 < nodes.length
+              erbout << "/* unreachable codes omitted */\n".freeze
+            end
+            break
+          end
+          erbout
+        when :rb
+          erbout = +""
+          if @cut && oncut
+            onfail = oncut
+            oncut = nil
+          end
+          nodes.each_with_index do |expr, i|
+            erbout << "#{gen.generate_code(expr, onfail, 0, false, oncut: oncut)}".freeze
+            next unless expr.reachability == Packcr::CODE_REACH__ALWAYS_FAIL
+
+            if i + 1 < nodes.length
+              erbout << "# unreachable codes omitted\n".freeze
+            end
+            break
+          end
+          erbout
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+class Packcr
+  class Node
+    class StringNode
+      def get_many_code(gen, onfail, indent, bare, oncut, n)
+        case gen.lang
+        when :c
+          erbout = +""
+          erbout << "if (\n    pcc_refill_buffer(ctx, #{n}) < #{n} ||\n".freeze
+
+          (n - 1).times do |i|
+            erbout << "    (ctx->buffer.buf + ctx->position_offset)[#{i}] != '#{Packcr.escape_character(value[i])}' ||\n".freeze
+          end
+          erbout << "    (ctx->buffer.buf + ctx->position_offset)[#{n - 1}] != '#{Packcr.escape_character(value[n - 1])}'\n) goto L#{format("%04d", onfail)};\n".freeze
+
+          if gen.location
+            erbout << "pcc_location_forward(&ctx->position_offset_loc, ctx->buffer.buf + ctx->position_offset, n);\n".freeze
+          end
+          erbout << "ctx->position_offset += #{n};\n".freeze
+
+          erbout
+        when :rb
+          erbout = +""
+          erbout << "if (\n  refill_buffer(#{n}) < #{n} ||\n  @buffer[@position_offset, #{n}] != #{value[0, n].dump}\n)\n  throw(#{onfail})\nend\n".freeze
+
+          if gen.location
+            erbout << "@position_offset_loc = @position_offset_loc.forward(@buffer, @position_offset, #{n})\n".freeze
+          end
+          erbout << "@position_offset += #{n}\n".freeze
+
+          erbout
+        end
+      end
+
+      def get_one_code(gen, onfail, indent, bare, oncut, n)
+        case gen.lang
+        when :c
+          erbout = +""
+          erbout << "if (\n    pcc_refill_buffer(ctx, 1) < 1 ||\n    ctx->buffer.buf[ctx->position_offset] != '#{Packcr.escape_character(value[0])}'\n) goto L#{format("%04d", onfail)};\n".freeze
+
+          if gen.location
+            erbout << "    pcc_location_forward(&ctx->position_offset_loc, ctx->buffer.buf + ctx->position_offset, 1);\n".freeze
+          end
+          erbout << "ctx->position_offset++;\n".freeze
+
+          erbout
+        when :rb
+          erbout = +""
+          erbout << "if (\n  refill_buffer(1) < 1 ||\n  @buffer[@position_offset] != \"#{Packcr.escape_character(value[0])}\"\n)\n  throw(#{onfail})\nend\n".freeze
+
+          if gen.location
+            erbout << "@position_offset_loc = @position_offset_loc.forward(@buffer, @position_offset, 1)\n".freeze
+          end
+          erbout << "@position_offset += 1\n".freeze
+
+          erbout
+        end
+      end
+    end
+  end
+end

data/lib/packcr/generator.rb

@@ -1,8 +1,6 @@
-require "stringio"
-
 class Packcr
   class Generator
-    attr_reader :ascii, :rule, :location, :lang
+    attr_reader :ascii, :rule, :location, :lang, :level
 
     def initialize(rule, ascii, location, lang = :c)
       @rule = rule
@@ -10,27 +8,32 @@ class Packcr
       @ascii = !!ascii
       @location = !!location
       @lang = lang
+      @level = 0
     end
 
     def next_label
       @label += 1
     end
 
-    def generate_code(node, onfail, indent, bare)
-      node.generate_code(self, onfail, indent, bare)
-    end
-
-    def generate_code_str(node, onfail, indent, bare)
-      @stream, stream = StringIO.new, @stream
+    def generate_code(node, onescape, indent, bare, reverse: false, oncut: nil)
+      stream = @stream
+      @stream = +""
+      @level += 1
       begin
-        return generate_code(node, onfail, indent, bare), @stream.string
+        if reverse
+          node.generate_reverse_code(self, onescape, indent, bare, oncut: oncut)
+        else
+          node.generate_code(self, onescape, indent, bare, oncut: oncut)
+        end
+        @stream
       ensure
+        @level -= 1
         @stream = stream
       end
     end
 
     def write(str)
-      @stream.write(str)
+      @stream << str
     end
   end
 end

data/lib/packcr/node/action_node.rb

@@ -33,26 +33,37 @@ class Packcr
         end
       end
 
-      def generate_code(gen, onfail, indent, bare)
-        gen.write Packcr.template("node/action.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
-        return Packcr::CODE_REACH__ALWAYS_SUCCEED
+      def generate_code(gen, onfail, indent, bare, oncut: nil)
+        gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
+      end
+
+      def reachability
+        Packcr::CODE_REACH__ALWAYS_SUCCEED
       end
 
       def verify_variables(vars)
         @vars = vars
       end
 
-      def verify_captures(ctx, capts)
+      def verify_captures(_ctx, capts)
         @capts = capts
       end
 
-      def link_references(ctx)
-      end
-
       def setup_rule(rule)
         @index = rule.codes.length
         rule.codes.push(self)
       end
+
+      def to_h
+        {
+          type: :action,
+          code: code&.text,
+          vars: vars&.map(&:to_h),
+          capts: capts&.map(&:to_h),
+        }
+      end
     end
   end
 end
+
+require "packcr/generated/node/action_node"

data/lib/packcr/node/alternate_node.rb

@@ -9,7 +9,7 @@ class Packcr
       end
 
       def alt(node)
-        @nodes << node
+        @nodes << node if node
         self
       end
 
@@ -27,14 +27,21 @@ class Packcr
         m
       end
 
-      def generate_code(gen, onfail, indent, bare)
-        b = false
-        m = gen.next_label
-
-        reach = nil
-        gen.write Packcr.template("node/alternate.#{gen.lang}.erb", binding, indent: indent - 4, unwrap: bare)
+      def generate_code(gen, onfail, indent, bare, oncut: nil)
+        gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
+      end
 
-        reach || Packcr::CODE_REACH__ALWAYS_FAIL
+      def reachability
+        r = Packcr::CODE_REACH__ALWAYS_FAIL
+        nodes.each do |expr|
+          case expr.reachability
+          when Packcr::CODE_REACH__ALWAYS_SUCCEED
+            return Packcr::CODE_REACH__ALWAYS_SUCCEED
+          when Packcr::CODE_REACH__BOTH
+            r = Packcr::CODE_REACH__BOTH
+          end
+        end
+        r
       end
 
       def verify_variables(vars)
@@ -66,11 +73,14 @@ class Packcr
         end
       end
 
-      def link_references(ctx)
-        nodes.each do |node|
-          node.link_references(ctx)
-        end
+      def to_h
+        {
+          type: :alternate,
+          nodes: nodes&.map(&:to_h),
+        }
       end
     end
   end
 end
+
+require "packcr/generated/node/alternate_node"

data/lib/packcr/node/capture_node.rb

@@ -15,25 +15,19 @@ class Packcr
         $stdout.print "#{" " * indent}}\n"
       end
 
-      def generate_code(gen, onfail, indent, bare)
-        r = nil
-        gen.write Packcr.template("node/capture.#{gen.lang}.erb", binding, indent: indent)
-        return r
+      def generate_code(gen, onfail, indent, bare, oncut: nil)
+        gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent)
       end
 
-      def verify_variables(vars)
-        expr.verify_variables(vars)
+      def reachability
+        expr.reachability
       end
 
       def verify_captures(ctx, capts)
-        expr.verify_captures(ctx, capts)
+        super
         capts.push(self)
       end
 
-      def link_references(ctx)
-        expr.link_references(ctx)
-      end
-
       def nodes
         [expr]
       end
@@ -41,8 +35,16 @@ class Packcr
       def setup_rule(rule)
         @index = rule.capts.length
         rule.capts << self
-        super
+      end
+
+      def to_h
+        {
+          type: :capture,
+          expr: expr&.to_h,
+        }
       end
     end
   end
 end
+
+require "packcr/generated/node/capture_node"