packcr 0.0.4 → 0.0.7

data/lib/packcr/node/charclass_node.rb

@@ -13,44 +13,58 @@ class Packcr
         $stdout.print "')\n"
       end
 
-      def generate_code(gen, onfail, indent, bare)
-        if gen.ascii
-          return generate_ascii_code(gen, onfail, indent, bare)
-        else
-          return generate_utf8_charclass_code(gen, onfail, indent, bare)
-        end
+      def reversible?(gen)
+        gen.lang == :rb && !gen.ascii
       end
 
-      def verify_variables(vars)
+      def generate_code(gen, onfail, indent, bare, oncut: nil)
+        return generate_ascii_code(gen, onfail, indent, bare) if gen.ascii
+
+        generate_utf8_charclass_code(gen, onfail, indent, bare)
       end
 
-      def verify_captures(ctx, capts)
+      def generate_reverse_code(gen, onsuccess, indent, bare, oncut: nil)
+        raise "unexpected" if gen.ascii
+
+        generate_utf8_charclass_reverse_code(gen, onsuccess, indent, bare)
       end
 
-      def link_references(ctx)
+      def reachability
+        charclass = value
+        n = charclass&.length || 0
+        return Packcr::CODE_REACH__BOTH if charclass.nil? || n > 0
+
+        Packcr::CODE_REACH__ALWAYS_FAIL
       end
 
       private
 
       def generate_utf8_charclass_code(gen, onfail, indent, bare)
-        charclass = self.value
+        charclass = value
         if charclass && charclass.encoding != Encoding::UTF_8
           charclass = charclass.dup.force_encoding(Encoding::UTF_8)
         end
         n = charclass&.length || 0
         if charclass.nil? || n > 0
-          a = charclass && charclass[0] == '^'
-          i = a ? 1 : 0
-          gen.write Packcr.template("node/charclass_utf8.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
-          return Packcr::CODE_REACH__BOTH
+          gen.write Packcr.format_code(get_utf8_code(gen, onfail, indent, bare, charclass, n), indent: indent, unwrap: bare)
         else
-          gen.write Packcr.template("node/charclass_fail.#{gen.lang}.erb", binding, indent: indent)
-          return Packcr::CODE_REACH__ALWAYS_FAIL
+          gen.write Packcr.format_code(get_fail_code(gen, onfail, indent, bare), indent: indent)
+        end
+      end
+
+      def generate_utf8_charclass_reverse_code(gen, onsuccess, indent, bare)
+        charclass = value
+        if charclass && charclass.encoding != Encoding::UTF_8
+          charclass = charclass.dup.force_encoding(Encoding::UTF_8)
         end
+        n = charclass&.length || 0
+        return unless charclass.nil? || n > 0
+
+        gen.write Packcr.format_code(get_utf8_reverse_code(gen, onsuccess, indent, bare, charclass, n), indent: indent, unwrap: bare)
       end
 
       def generate_ascii_code(gen, onfail, indent, bare)
-        charclass = self.value
+        charclass = value
         if charclass
           n = charclass.length
           a = charclass[0] == "^"
@@ -60,20 +74,26 @@ class Packcr
           end
           if n > 0
             if n > 1
-              gen.write Packcr.template("node/charclass.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
+              gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, charclass, n, a), indent: indent, unwrap: bare)
             else
-              gen.write Packcr.template("node/charclass_one.#{gen.lang}.erb", binding, indent: indent)
+              gen.write Packcr.format_code(get_one_code(gen, onfail, indent, bare, charclass, n, a), indent: indent)
             end
-            return Packcr::CODE_REACH__BOTH
           else
-            gen.write Packcr.template("node/charclass_fail.#{gen.lang}.erb", binding, indent: indent)
-            return Packcr::CODE_REACH__ALWAYS_FAIL
+            gen.write Packcr.format_code(get_fail_code(gen, onfail, indent, bare), indent: indent)
           end
         else
-          gen.write Packcr.template("node/charclass_any.#{gen.lang}.erb", binding, indent: indent)
-          return Packcr::CODE_REACH__BOTH
+          gen.write Packcr.format_code(get_any_code(gen, onfail, indent, bare, charclass), indent: indent)
         end
       end
+
+      def to_h
+        {
+          type: :charclass,
+          value: value,
+        }
+      end
     end
   end
 end
+
+require "packcr/generated/node/charclass_node"

data/lib/packcr/node/eof_node.rb

@@ -0,0 +1,25 @@
+class Packcr
+  class Node
+    class EofNode < Packcr::Node
+      def debug_dump(indent = 0)
+        $stdout.print "#{" " * indent}Eof()\n"
+      end
+
+      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__BOTH
+      end
+
+      def to_h
+        {
+          type: :eof,
+        }
+      end
+    end
+  end
+end
+
+require "packcr/generated/node/eof_node"

data/lib/packcr/node/error_node.rb

@@ -29,26 +29,22 @@ class Packcr
         $stdout.print "#{" " * indent}}\n"
       end
 
-      def generate_code(gen, onfail, indent, bare)
-        l = gen.next_label
-        m = gen.next_label
-        r, code = gen.generate_code_str(expr, l, 4, true)
-        gen.write Packcr.template("node/error.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
-        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, unwrap: bare)
+      end
+
+      def reachability
+        expr.reachability
       end
 
       def verify_variables(vars)
         @vars = vars
-        expr.verify_variables(vars)
+        super
       end
 
       def verify_captures(ctx, capts)
         @capts = capts
-        expr.verify_captures(ctx, capts)
-      end
-
-      def link_references(ctx)
-        expr.link_references(ctx)
+        super
       end
 
       def nodes
@@ -58,8 +54,19 @@ class Packcr
       def setup_rule(rule)
         @index = rule.codes.length
         rule.codes.push(self)
-        super
+      end
+
+      def to_h
+        {
+          type: :error,
+          code: code&.text,
+          vars: vars&.map(&:to_h),
+          capts: capts&.map(&:to_h),
+          index: @index,
+        }
       end
     end
   end
 end
+
+require "packcr/generated/node/error_node"

data/lib/packcr/node/expand_node.rb

@@ -3,8 +3,10 @@ class Packcr
     class ExpandNode < Packcr::Node
       attr_accessor :index, :line, :col
 
-      def initialize(index = nil)
+      def initialize(index = nil, line = nil, col = nil)
         @index = index
+        @line = line
+        @col = col
       end
 
       def debug_dump(indent = 0)
@@ -13,12 +15,12 @@ class Packcr
         $stdout.print ")\n"
       end
 
-      def generate_code(gen, onfail, indent, bare)
-        gen.write Packcr.template("node/expand.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
-        return Packcr::CODE_REACH__BOTH
+      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 verify_variables(vars)
+      def reachability
+        Packcr::CODE_REACH__BOTH
       end
 
       def verify_captures(ctx, capts)
@@ -26,15 +28,22 @@ class Packcr
           unless capt.is_a?(Packcr::Node::CaptureNode)
             raise "unexpected capture: #{capt.class}"
           end
+
           index == capt.index
         end
-        if !found && index != nil
-          ctx.error line + 1, col + 1, "Capture #{index + 1} not available at this position"
-        end
+        return if found || index.nil?
+
+        ctx.error line + 1, col + 1, "Capture #{index + 1} not available at this position"
       end
 
-      def link_references(ctx)
+      def to_h
+        {
+          type: :expand,
+          index: index,
+        }
       end
     end
   end
 end
+
+require "packcr/generated/node/expand_node"

data/lib/packcr/node/predicate_node.rb

@@ -15,42 +15,35 @@ class Packcr
         $stdout.print "#{" " * indent}}\n"
       end
 
-      def generate_code(gen, onfail, indent, bare)
-        r = nil
+      def generate_code(gen, onfail, indent, bare, oncut: nil)
         if neg
-          l = gen.next_label
-          r, code = gen.generate_code_str(expr, l, 4, false)
-          gen.write Packcr.template("node/predicate_neg.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
-          case r
-          when Packcr::CODE_REACH__ALWAYS_SUCCEED
-            r = Packcr::CODE_REACH__ALWAYS_FAIL
-          when Packcr::CODE_REACH__ALWAYS_FAIL
-            r = Packcr::CODE_REACH__ALWAYS_SUCCEED
-          end
+          gen.write Packcr.format_code(get_neg_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
         else
-          l = gen.next_label
-          m = gen.next_label
-          r, code = gen.generate_code_str(expr, l, 4, false)
-          gen.write Packcr.template("node/predicate.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
+          gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
         end
-        return r
       end
 
-      def verify_variables(vars)
-        expr.verify_variables(vars)
-      end
-
-      def verify_captures(ctx, capts)
-        expr.verify_captures(ctx, capts)
-      end
-
-      def link_references(ctx)
-        expr.link_references(ctx)
+      def reachability
+        if neg
+          -expr.reachability
+        else
+          expr.reachability
+        end
       end
 
       def nodes
         [expr]
       end
+
+      def to_h
+        {
+          type: :predicate,
+          expr: expr&.to_h,
+          neg: neg,
+        }
+      end
     end
   end
 end
+
+require "packcr/generated/node/predicate_node"

data/lib/packcr/node/quantity_node.rb

@@ -16,45 +16,52 @@ class Packcr
         $stdout.print "#{" " * indent}}\n"
       end
 
-      def generate_code(gen, onfail, indent, bare)
+      def generate_code(gen, onfail, indent, bare, oncut: nil)
         if max > 1 || max < 0
-          r = nil
-          gen.write Packcr.template("node/quantify_many.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
-          if min <= 0
-            return Packcr::CODE_REACH__ALWAYS_SUCCEED
-          end
-          if r == Packcr::CODE_REACH__ALWAYS_FAIL
-            return Packcr::CODE_REACH__ALWAYS_FAIL
-          end
-          return Packcr::CODE_REACH__BOTH
+          gen.write Packcr.format_code(get_many_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
         elsif max == 1
           if min > 0
-            return gen.generate_code(expr, onfail, indent, bare)
+            gen.write gen.generate_code(expr, onfail, indent, bare, oncut: oncut)
           else
-            gen.write Packcr.template("node/quantify_one.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
-            return Packcr::CODE_REACH__ALWAYS_SUCCEED
+            gen.write Packcr.format_code(get_one_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
           end
-        else
-          # no code to generate
-          return Packcr::CODE_REACH__ALWAYS_SUCCEED
         end
       end
 
-      def verify_variables(vars)
-        expr.verify_variables(vars)
-      end
+      def reachability
+        if max > 1 || max < 0
+          if min <= 0
+            return Packcr::CODE_REACH__ALWAYS_SUCCEED
+          end
+          if expr.reachability == Packcr::CODE_REACH__ALWAYS_FAIL
+            return Packcr::CODE_REACH__ALWAYS_FAIL
+          end
 
-      def verify_captures(ctx, capts)
-        expr.verify_captures(ctx, capts)
-      end
+          Packcr::CODE_REACH__BOTH
+        elsif max == 1
+          return expr.reachability if min > 0
+
+          Packcr::CODE_REACH__ALWAYS_SUCCEED
 
-      def link_references(ctx)
-        expr.link_references(ctx)
+        else
+          Packcr::CODE_REACH__ALWAYS_SUCCEED
+        end
       end
 
       def nodes
         [expr]
       end
+
+      def to_h
+        {
+          type: :predicate,
+          expr: expr&.to_h,
+          min: min,
+          max: max,
+        }
+      end
     end
   end
 end
+
+require "packcr/generated/node/quantity_node"

data/lib/packcr/node/reference_node.rb

@@ -16,17 +16,30 @@ class Packcr
         $stdout.print ", name:'#{name}', rule:'#{rule&.name || "(null)"}')\n"
       end
 
-      def generate_code(gen, onfail, indent, bare)
-        gen.write Packcr.template("node/reference.#{gen.lang}.erb", binding, indent: indent)
+      def reversible?(gen)
+        gen.lang == :rb
+      end
+
+      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 generate_reverse_code(gen, onsuccess, indent, bare, oncut: nil)
+        gen.write Packcr.format_code(get_reverse_code(gen, onsuccess, indent, bare, oncut), indent: indent)
+      end
+
+      def reachability
         Packcr::CODE_REACH__BOTH
       end
 
       def setup_rule(rule)
         return unless var
+
         i = rule.vars.index do |ref|
           unless ref.is_a?(Packcr::Node::ReferenceNode)
             raise "Unexpected node type: #{ref.class}"
           end
+
           var == ref.var
         end
         if !i
@@ -43,26 +56,35 @@ class Packcr
           unless var.is_a?(Packcr::Node::ReferenceNode)
             raise "unexpected var: #{var.class}"
           end
+
           index == var.index
         end
         vars.push(self) if !found
       end
 
-      def verify_captures(ctx, capts)
-      end
-
       def link_references(ctx)
-        rule = ctx.rule(name)
-        if !rule
-          ctx.error line + 1, col + 1, "No definition of rule '#{name}'"
-        else
+        rule = ctx.root.rule(name)
+        if rule
           unless rule.is_a?(Packcr::Node::RuleNode)
             raise "unexpected node type #{rule.class}"
           end
+
           rule.add_ref
           self.rule = rule
+        else
+          ctx.error line + 1, col + 1, "No definition of rule '#{name}'"
         end
       end
+
+      def to_h
+        {
+          type: :reference,
+          name: name,
+          var: var,
+        }
+      end
     end
   end
 end
+
+require "packcr/generated/node/reference_node"

data/lib/packcr/node/root_node.rb

@@ -0,0 +1,61 @@
+class Packcr
+  class Node
+    class RootNode < Packcr::Node
+      attr_accessor :rules
+      attr_reader :rulehash
+
+      def initialize
+        @rules = []
+        @rulehash = {}
+        @implicit_rules = []
+      end
+
+      def debug_dump
+        @rules.each(&:debug_dump)
+      end
+
+      def make_rulehash(ctx)
+        @rules.each do |rule|
+          if @rulehash[rule.name]
+            ctx.error rule.line + 1, rule.col + 1, "Multiple definition of rule '#{rule.name}'"
+          else
+            @rulehash[rule.name] = rule
+          end
+        end
+      end
+
+      def setup(ctx)
+        make_rulehash(ctx)
+        @rules.first&.top = true
+        @rules.each do |rule|
+          rule.setup(ctx)
+        end
+        @rules.each do |rule|
+          rule.verify(ctx)
+        end
+      end
+
+      def rule(name)
+        rule = @rulehash[name]
+        return rule if rule
+
+        case name
+        when "EOF"
+          expr = Packcr::Node::EofNode.new
+        else
+          return nil
+        end
+        rule = Packcr::Node::RuleNode.new(expr, name)
+        @rules << rule
+        @rulehash[name] = rule
+      end
+
+      def to_h
+        {
+          type: :root,
+          rules: rules.map(&:to_h),
+        }
+      end
+    end
+  end
+end

data/lib/packcr/node/rule_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class RuleNode < Packcr::Node
-      attr_accessor :codes, :name, :expr, :ref, :vars, :capts, :line, :col
+      attr_accessor :codes, :name, :expr, :ref, :vars, :capts, :line, :col, :top
 
       def initialize(expr = nil, name = nil, line = nil, col = nil)
         super()
@@ -21,22 +21,48 @@ class Packcr
         $stdout.print "#{" " * indent}}\n"
       end
 
+      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
+        expr.reachability
+      end
+
       def verify(ctx)
         expr.verify_variables([])
         expr.verify_captures(ctx, [])
+        verify_rule_reference(ctx)
+      end
+
+      def verify_rule_reference(ctx)
+        return if top
+
+        return unless ref == 0
+
+        ctx.error line + 1, col + 1, "Never used rule '#{name}'"
       end
 
       def add_ref
         @ref += 1
       end
 
-      def setup
-        setup_rule(self)
+      def setup(ctx)
+        super(ctx, self)
       end
 
       def nodes
         [expr]
       end
+
+      def to_h
+        {
+          type: :rule,
+          expr: expr&.to_h,
+        }
+      end
     end
   end
 end
+
+require "packcr/generated/node/rule_node"

data/lib/packcr/node/sequence_node.rb

@@ -3,18 +3,44 @@ class Packcr
     class SequenceNode < Packcr::Node
       attr_accessor :nodes
 
-      def initialize(*nodes)
+      def initialize(*nodes, cut: false)
         super()
         self.nodes = nodes
+        @cut = cut
       end
 
-      def seq(node)
-        @nodes << node
+      def sequence?
+        true
+      end
+
+      def seq(node, cut: false)
+        if node&.sequence?
+          node.nodes.each do |child|
+            seq(child, cut: cut)
+            cut = false
+          end
+          return self
+        end
+
+        if cut
+          if node
+            node = Packcr::Node::SequenceNode.new(node, cut: true)
+          else
+            node = Packcr::Node::SequenceNode.new(cut: true)
+          end
+        end
+        if node
+          if @nodes.last.sequence?
+            @nodes.last.seq(node)
+          else
+            @nodes << node
+          end
+        end
         self
       end
 
       def debug_dump(indent = 0)
-        $stdout.print "#{" " * indent}Sequence(max:#{max}, len:#{nodes.length}) {\n"
+        $stdout.print "#{" " * indent}Sequence(max:#{max}, len:#{nodes.length}#{@cut ? ", cut: true" : ""}) {\n"
         nodes.each do |child_node|
           child_node.debug_dump(indent + 2)
         end
@@ -27,40 +53,31 @@ class Packcr
         m
       end
 
-      def generate_code(gen, onfail, indent, bare)
-        b = false
-        nodes.each_with_index do |expr, i|
-          case gen.generate_code(expr, onfail, indent, false)
+      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 reachability
+        r = Packcr::CODE_REACH__ALWAYS_SUCCEED
+        nodes.each do |expr|
+          case expr.reachability
           when Packcr::CODE_REACH__ALWAYS_FAIL
-            if i + 1 < nodes.length
-              gen.write Packcr.template("node/sequence_unreachable.#{gen.lang}.erb", binding, indent: indent)
-            end
             return Packcr::CODE_REACH__ALWAYS_FAIL
-          when Packcr::CODE_REACH__ALWAYS_SUCCEED
-          else
-            b = true
+          when Packcr::CODE_REACH__BOTH
+            r = Packcr::CODE_REACH__BOTH
           end
         end
-        return b ? Packcr::CODE_REACH__BOTH : Packcr::CODE_REACH__ALWAYS_SUCCEED
+        r
       end
 
-      def verify_variables(vars)
-        nodes.each do |node|
-          node.verify_variables(vars)
-        end
-      end
-
-      def verify_captures(ctx, capts)
-        nodes.each do |node|
-          node.verify_captures(ctx, capts)
-        end
-      end
-
-      def link_references(ctx)
-        nodes.each do |node|
-          node.link_references(ctx)
-        end
+      def to_h
+        {
+          type: :sequence,
+          nodes: nodes.map(&:to_h),
+        }
       end
     end
   end
 end
+
+require "packcr/generated/node/sequence_node"