packcr 0.0.3 → 0.0.6

data/lib/packcr/node/root_node.rb

@@ -0,0 +1,60 @@
+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,14 +1,18 @@
 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
-        super
+      def initialize(expr = nil, name = nil, line = nil, col = nil)
+        super()
         self.ref = 0
         self.vars = []
         self.capts = []
         self.codes = []
+        @expr = expr
+        @name = name
+        @line = line
+        @col = col
       end
 
       def debug_dump(indent = 0)
@@ -17,14 +21,45 @@ class Packcr
         $stdout.print "#{" " * indent}}\n"
       end
 
+      def generate_code(gen, onfail, indent, bare, oncut: nil)
+        gen.write Packcr.template("node/rule.#{gen.lang}.erb", binding, 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
+        if ref == 0
+          ctx.error line + 1, col + 1, "Never used rule '#{name}'"
+        end
       end
 
       def add_ref
         @ref += 1
       end
+
+      def setup(ctx)
+        super(ctx, self)
+      end
+
+      def nodes
+        [expr]
+      end
+
+      def to_h
+        {
+          type: :rule,
+          expr: expr&.to_h,
+        }
+      end
     end
   end
 end

data/lib/packcr/node/sequence_node.rb

@@ -3,13 +3,44 @@ class Packcr
     class SequenceNode < Packcr::Node
       attr_accessor :nodes
 
-      def initialize
-        super
-        self.nodes = []
+      def initialize(*nodes, cut: false)
+        super()
+        self.nodes = nodes
+        @cut = cut
+      end
+
+      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
@@ -22,39 +53,28 @@ 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.template("node/sequence.#{gen.lang}.erb", binding, 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

data/lib/packcr/node/string_node.rb

@@ -3,6 +3,10 @@ class Packcr
     class StringNode < Packcr::Node
       attr_accessor :value
 
+      def initialize(value = nil)
+        self.value = value
+      end
+
       def value=(value)
         @value = value&.b
       end
@@ -13,30 +17,30 @@ class Packcr
         $stdout.print "')\n"
       end
 
-      def generate_code(gen, onfail, indent, bare)
+      def generate_code(gen, onfail, indent, bare, oncut: nil)
         n = value&.length || 0
         if n > 0
           if n > 1
             gen.write Packcr.template("node/string_many.#{gen.lang}.erb", binding, indent: indent)
-            return Packcr::CODE_REACH__BOTH
           else
             gen.write Packcr.template("node/string_one.#{gen.lang}.erb", binding, indent: indent)
-            return Packcr::CODE_REACH__BOTH
           end
-        else
-          # no code to generate
-          return Packcr::CODE_REACH__ALWAYS_SUCCEED
         end
-        Packcr::CODE_REACH__BOTH
-      end
-
-      def verify_variables(vars)
       end
 
-      def verify_captures(ctx, capts)
+      def reachability
+        n = value&.length || 0
+        if n <= 0
+          return Packcr::CODE_REACH__ALWAYS_SUCCEED
+        end
+        Packcr::CODE_REACH__BOTH
       end
 
-      def link_references(ctx)
+      def to_h
+        {
+          type: :string,
+          value: value,
+        }
       end
     end
   end

data/lib/packcr/node.rb

@@ -1,8 +1,55 @@
 class Packcr
   class Node
+    def seq(expr, cut: false)
+      SequenceNode.new(self).seq(expr, cut: cut)
+    end
+
+    def alt(expr)
+      AlternateNode.new(self).alt(expr)
+    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)
+    end
+
+    def setup_rule(rule)
+    end
+
+    def setup(ctx, rule)
+      setup_rule(rule)
+      link_references(ctx)
+
+      nodes.each do |node|
+        node.setup(ctx, rule)
+      end
+    end
+
+    def nodes
+      []
+    end
+
+    def reversible?(gen)
+      false
+    end
+
+    def sequence?
+      false
+    end
   end
 end
 
+require "packcr/node/root_node"
 require "packcr/node/rule_node"
 require "packcr/node/reference_node"
 require "packcr/node/string_node"
@@ -15,3 +62,4 @@ require "packcr/node/capture_node"
 require "packcr/node/expand_node"
 require "packcr/node/action_node"
 require "packcr/node/error_node"
+require "packcr/node/eof_node"