packcr 0.0.3 → 0.0.6

data/lib/packcr/generator.rb

@@ -1,7 +1,6 @@
-
 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
@@ -9,27 +8,31 @@ 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

@@ -3,8 +3,9 @@ class Packcr
     class ActionNode < Packcr::Node
       attr_accessor :code, :index, :vars, :capts
 
-      def initialize
-        super
+      def initialize(code = nil)
+        super()
+        @code = code
         self.vars = []
         self.capts = []
       end
@@ -32,9 +33,12 @@ class Packcr
         end
       end
 
-      def generate_code(gen, onfail, indent, bare)
+      def generate_code(gen, onfail, indent, bare, oncut: nil)
         gen.write Packcr.template("node/action.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
-        return Packcr::CODE_REACH__ALWAYS_SUCCEED
+      end
+
+      def reachability
+        Packcr::CODE_REACH__ALWAYS_SUCCEED
       end
 
       def verify_variables(vars)
@@ -45,7 +49,18 @@ class Packcr
         @capts = capts
       end
 
-      def link_references(ctx)
+      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

data/lib/packcr/node/alternate_node.rb

@@ -3,9 +3,14 @@ class Packcr
     class AlternateNode < Packcr::Node
       attr_accessor :nodes
 
-      def initialize
-        super
-        self.nodes = []
+      def initialize(*nodes)
+        super()
+        self.nodes = nodes
+      end
+
+      def alt(node)
+        @nodes << node if node
+        self
       end
 
       def debug_dump(indent = 0)
@@ -22,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.template("node/alternate.#{gen.lang}.erb", binding, 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)
@@ -61,10 +73,11 @@ 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

data/lib/packcr/node/capture_node.rb

@@ -3,6 +3,10 @@ class Packcr
     class CaptureNode < Packcr::Node
       attr_accessor :expr, :index
 
+      def initialize(expr = nil)
+        @expr = expr
+      end
+
       def debug_dump(indent = 0)
         $stdout.print "#{" " * indent}Capture(index:"
         Packcr.dump_integer_value(index)
@@ -11,23 +15,33 @@ 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)
         gen.write Packcr.template("node/capture.#{gen.lang}.erb", binding, indent: indent)
-        return r
       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)
+      def nodes
+        [expr]
+      end
+
+      def setup_rule(rule)
+        @index = rule.capts.length
+        rule.capts << self
+      end
+
+      def to_h
+        {
+          type: :capture,
+          expr: expr&.to_h,
+        }
       end
     end
   end

data/lib/packcr/node/charclass_node.rb

@@ -3,13 +3,21 @@ class Packcr
     class CharclassNode < Packcr::Node
       attr_accessor :value
 
+      def initialize(value = nil)
+        @value = value
+      end
+
       def debug_dump(indent = 0)
         $stdout.print "#{" " * indent}Charclass(value:'"
         Packcr.dump_escaped_string(value)
         $stdout.print "')\n"
       end
 
-      def generate_code(gen, onfail, indent, bare)
+      def reversible?(gen)
+        gen.lang == :rb && !gen.ascii
+      end
+
+      def generate_code(gen, onfail, indent, bare, oncut: nil)
         if gen.ascii
           return generate_ascii_code(gen, onfail, indent, bare)
         else
@@ -17,13 +25,22 @@ class Packcr
         end
       end
 
-      def verify_variables(vars)
-      end
-
-      def verify_captures(ctx, capts)
+      def generate_reverse_code(gen, onsuccess, indent, bare, oncut: nil)
+        if gen.ascii
+          raise "unexpected"
+        else
+          return generate_utf8_charclass_reverse_code(gen, onsuccess, indent, bare)
+        end
       end
 
-      def link_references(ctx)
+      def reachability
+        charclass = self.value
+        n = charclass&.length || 0
+        if charclass.nil? || n > 0
+          return Packcr::CODE_REACH__BOTH
+        else
+          return Packcr::CODE_REACH__ALWAYS_FAIL
+        end
       end
 
       private
@@ -35,13 +52,20 @@ class Packcr
         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
         else
           gen.write Packcr.template("node/charclass_fail.#{gen.lang}.erb", binding, indent: indent)
-          return Packcr::CODE_REACH__ALWAYS_FAIL
+        end
+      end
+
+      def generate_utf8_charclass_reverse_code(gen, onsuccess, indent, bare)
+        charclass = self.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
+          gen.write Packcr.template("node/charclass_utf8_reverse.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
         end
       end
 
@@ -60,16 +84,20 @@ class Packcr
             else
               gen.write Packcr.template("node/charclass_one.#{gen.lang}.erb", binding, 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
           end
         else
           gen.write Packcr.template("node/charclass_any.#{gen.lang}.erb", binding, indent: indent)
-          return Packcr::CODE_REACH__BOTH
         end
       end
+
+      def to_h
+        {
+          type: :charclass,
+          value: value,
+        }
+      end
     end
   end
 end

data/lib/packcr/node/eof_node.rb

@@ -0,0 +1,23 @@
+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.template("node/eof.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
+      end
+
+      def reachability
+        return Packcr::CODE_REACH__BOTH
+      end
+
+      def to_h
+        {
+          type: :eof,
+        }
+      end
+    end
+  end
+end

data/lib/packcr/node/error_node.rb

@@ -3,8 +3,11 @@ class Packcr
     class ErrorNode < Packcr::Node
       attr_accessor :expr, :code, :index, :vars, :capts
 
-      def initialize
-        super
+      def initialize(expr = nil, code = nil, index = nil)
+        super()
+        @expr = expr
+        @code = code
+        @index = index
         self.vars = []
         self.capts = []
       end
@@ -26,26 +29,41 @@ 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)
+      def generate_code(gen, onfail, indent, bare, oncut: nil)
         gen.write Packcr.template("node/error.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
-        return r
+      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)
+        super
+      end
+
+      def nodes
+        [expr]
+      end
+
+      def setup_rule(rule)
+        @index = rule.codes.length
+        rule.codes.push(self)
       end
 
-      def link_references(ctx)
-        expr.link_references(ctx)
+      def to_h
+        {
+          type: :error,
+          code: code&.text,
+          vars: vars&.map(&:to_h),
+          capts: capts&.map(&:to_h),
+          index: @index,
+        }
       end
     end
   end

data/lib/packcr/node/expand_node.rb

@@ -3,18 +3,24 @@ class Packcr
     class ExpandNode < Packcr::Node
       attr_accessor :index, :line, :col
 
+      def initialize(index = nil, line = nil, col = nil)
+        @index = index
+        @line = line
+        @col = col
+      end
+
       def debug_dump(indent = 0)
         $stdout.print "#{" " * indent}Expand(index:"
         Packcr.dump_integer_value(index)
         $stdout.print ")\n"
       end
 
-      def generate_code(gen, onfail, indent, bare)
+      def generate_code(gen, onfail, indent, bare, oncut: nil)
         gen.write Packcr.template("node/expand.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
-        return Packcr::CODE_REACH__BOTH
       end
 
-      def verify_variables(vars)
+      def reachability
+        return Packcr::CODE_REACH__BOTH
       end
 
       def verify_captures(ctx, capts)
@@ -29,7 +35,11 @@ class Packcr
         end
       end
 
-      def link_references(ctx)
+      def to_h
+        {
+          type: :expand,
+          index: index,
+        }
       end
     end
   end

data/lib/packcr/node/predicate_node.rb

@@ -3,9 +3,10 @@ class Packcr
     class PredicateNode < Packcr::Node
       attr_accessor :neg, :expr
 
-      def initialize
-        super
-        self.neg = false
+      def initialize(expr = nil, neg = false)
+        super()
+        @expr = expr
+        @neg = neg
       end
 
       def debug_dump(indent = 0)
@@ -14,37 +15,32 @@ 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
         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)
         end
-        return r
       end
 
-      def verify_variables(vars)
-        expr.verify_variables(vars)
+      def reachability
+        if neg
+          -expr.reachability
+        else
+          expr.reachability
+        end
       end
 
-      def verify_captures(ctx, capts)
-        expr.verify_captures(ctx, capts)
+      def nodes
+        [expr]
       end
 
-      def link_references(ctx)
-        expr.link_references(ctx)
+      def to_h
+        {
+          type: :predicate,
+          expr: expr&.to_h,
+          neg: neg,
+        }
       end
     end
   end

data/lib/packcr/node/quantity_node.rb

@@ -3,10 +3,11 @@ class Packcr
     class QuantityNode < Packcr::Node
       attr_accessor :min, :max, :expr
 
-      def initialize
-        super
-        self.min = 0
-        self.max = 0
+      def initialize(expr = nil, min = 0, max = 0)
+        super()
+        @expr = expr
+        @min = min
+        @max = max
       end
 
       def debug_dump(indent = 0)
@@ -15,40 +16,49 @@ 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)
+        elsif max == 1
+          if min > 0
+            gen.write gen.generate_code(expr, onfail, indent, bare)
+          else
+            gen.write Packcr.template("node/quantify_one.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
+          end
+        end
+      end
+
+      def reachability
+        if max > 1 || max < 0
           if min <= 0
             return Packcr::CODE_REACH__ALWAYS_SUCCEED
           end
-          if r == Packcr::CODE_REACH__ALWAYS_FAIL
+          if expr.reachability == Packcr::CODE_REACH__ALWAYS_FAIL
             return Packcr::CODE_REACH__ALWAYS_FAIL
           end
           return Packcr::CODE_REACH__BOTH
         elsif max == 1
           if min > 0
-            return gen.generate_code(expr, onfail, indent, bare)
+            return expr.reachability
           else
-            gen.write Packcr.template("node/quantify_one.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
             return Packcr::CODE_REACH__ALWAYS_SUCCEED
           end
         else
-          # no code to generate
           return Packcr::CODE_REACH__ALWAYS_SUCCEED
         end
       end
 
-      def verify_variables(vars)
-        expr.verify_variables(vars)
-      end
-
-      def verify_captures(ctx, capts)
-        expr.verify_captures(ctx, capts)
+      def nodes
+        [expr]
       end
 
-      def link_references(ctx)
-        expr.link_references(ctx)
+      def to_h
+        {
+          type: :predicate,
+          expr: expr&.to_h,
+          min: min,
+          max: max,
+        }
       end
     end
   end

data/lib/packcr/node/reference_node.rb

@@ -3,17 +3,50 @@ class Packcr
     class ReferenceNode < Packcr::Node
       attr_accessor :var, :index, :name, :rule, :line, :col
 
+      def initialize(name = nil, var = nil, line = nil, col = nil)
+        @name = name
+        @var = var
+        @line = line
+        @col = col
+      end
+
       def debug_dump(indent = 0)
         $stdout.print "#{" " * indent}Reference(var:'#{var || "(null)"}', index:"
         Packcr.dump_integer_value(index)
         $stdout.print ", name:'#{name}', rule:'#{rule&.name || "(null)"}')\n"
       end
 
-      def generate_code(gen, onfail, indent, bare)
+      def reversible?(gen)
+        gen.lang == :rb
+      end
+
+      def generate_code(gen, onfail, indent, bare, oncut: nil)
         gen.write Packcr.template("node/reference.#{gen.lang}.erb", binding, indent: indent)
+      end
+
+      def generate_reverse_code(gen, onsuccess, indent, bare, oncut: nil)
+        gen.write Packcr.template("node/reference_reverse.#{gen.lang}.erb", binding, 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
+          i = rule.vars.length
+          rule.vars << self
+        end
+        @index = i
+      end
+
       def verify_variables(vars)
         return if index.nil?
 
@@ -26,11 +59,8 @@ class Packcr
         vars.push(self) if !found
       end
 
-      def verify_captures(ctx, capts)
-      end
-
       def link_references(ctx)
-        rule = ctx.rule(name)
+        rule = ctx.root.rule(name)
         if !rule
           ctx.error line + 1, col + 1, "No definition of rule '#{name}'"
         else
@@ -41,6 +71,14 @@ class Packcr
           self.rule = rule
         end
       end
+
+      def to_h
+        {
+          type: :reference,
+          name: name,
+          var: var,
+        }
+      end
     end
   end
 end