packcr 0.0.3

data/lib/packcr/generator.rb

@@ -0,0 +1,35 @@
+
+class Packcr
+  class Generator
+    attr_reader :ascii, :rule, :location, :lang
+
+    def initialize(rule, ascii, location, lang = :c)
+      @rule = rule
+      @label = 0
+      @ascii = !!ascii
+      @location = !!location
+      @lang = lang
+    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
+      begin
+        return generate_code(node, onfail, indent, bare), @stream.string
+      ensure
+        @stream = stream
+      end
+    end
+
+    def write(str)
+      @stream.write(str)
+    end
+  end
+end

data/lib/packcr/node/action_node.rb

@@ -0,0 +1,52 @@
+class Packcr
+  class Node
+    class ActionNode < Packcr::Node
+      attr_accessor :code, :index, :vars, :capts
+
+      def initialize
+        super
+        self.vars = []
+        self.capts = []
+      end
+
+      def debug_dump(indent = 0)
+        $stdout.print "#{" " * indent}Action(index:"
+        Packcr.dump_integer_value(index)
+        $stdout.print ", code:{"
+        Packcr.dump_escaped_string(code.text)
+        $stdout.print "}, vars:"
+
+        vars = self.vars
+        capts = self.capts
+        if vars.length + capts.length > 0
+          $stdout.print "\n"
+          vars.each do |ref|
+            $stdout.print "#{" " * (indent + 2)}'#{ref.var}'\n"
+          end
+          capts.each do |capt|
+            $stdout.print "#{" " * (indent + 2)}$#{capt.index + 1}\n"
+          end
+          $stdout.print "#{" " * indent})\n"
+        else
+          $stdout.print "none)\n"
+        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
+      end
+
+      def verify_variables(vars)
+        @vars = vars
+      end
+
+      def verify_captures(ctx, capts)
+        @capts = capts
+      end
+
+      def link_references(ctx)
+      end
+    end
+  end
+end

data/lib/packcr/node/alternate_node.rb

@@ -0,0 +1,71 @@
+class Packcr
+  class Node
+    class AlternateNode < Packcr::Node
+      attr_accessor :nodes
+
+      def initialize
+        super
+        self.nodes = []
+      end
+
+      def debug_dump(indent = 0)
+        $stdout.print "#{" " * indent}Alternate(max:#{max}, len:#{nodes.length}) {\n"
+        nodes.each do |node|
+          node.debug_dump(indent + 2)
+        end
+        $stdout.print "#{" " * indent}}\n"
+      end
+
+      def max
+        m = 1
+        m <<= 1 while m < @nodes.length
+        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)
+
+        reach || Packcr::CODE_REACH__ALWAYS_FAIL
+      end
+
+      def verify_variables(vars)
+        m = vars.length
+        v = vars.dup
+        nodes.each do |node|
+          v = v[0, m]
+          node.verify_variables(v)
+          v[m...-1].each do |added_node|
+            found = vars[m...-1].any? do |added_var|
+              added_node.index == added_var.index
+            end
+            if !found
+              vars.push(added_node)
+            end
+          end
+        end
+      end
+
+      def verify_captures(ctx, capts)
+        m = capts.length
+        v = capts.dup
+        nodes.each do |node|
+          v = v[0, m]
+          node.verify_captures(ctx, v)
+          v[m...-1].each do |added_node|
+            capts.push(added_node)
+          end
+        end
+      end
+
+      def link_references(ctx)
+        nodes.each do |node|
+          node.link_references(ctx)
+        end
+      end
+    end
+  end
+end

data/lib/packcr/node/capture_node.rb

@@ -0,0 +1,34 @@
+class Packcr
+  class Node
+    class CaptureNode < Packcr::Node
+      attr_accessor :expr, :index
+
+      def debug_dump(indent = 0)
+        $stdout.print "#{" " * indent}Capture(index:"
+        Packcr.dump_integer_value(index)
+        $stdout.print ") {\n"
+        expr.debug_dump(indent + 2)
+        $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
+      end
+
+      def verify_variables(vars)
+        expr.verify_variables(vars)
+      end
+
+      def verify_captures(ctx, capts)
+        expr.verify_captures(ctx, capts)
+        capts.push(self)
+      end
+
+      def link_references(ctx)
+        expr.link_references(ctx)
+      end
+    end
+  end
+end

data/lib/packcr/node/charclass_node.rb

@@ -0,0 +1,75 @@
+class Packcr
+  class Node
+    class CharclassNode < Packcr::Node
+      attr_accessor :value
+
+      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)
+        if gen.ascii
+          return generate_ascii_code(gen, onfail, indent, bare)
+        else
+          return generate_utf8_charclass_code(gen, onfail, indent, bare)
+        end
+      end
+
+      def verify_variables(vars)
+      end
+
+      def verify_captures(ctx, capts)
+      end
+
+      def link_references(ctx)
+      end
+
+      private
+
+      def generate_utf8_charclass_code(gen, onfail, 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
+          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_ascii_code(gen, onfail, indent, bare)
+        charclass = self.value
+        if charclass
+          n = charclass.length
+          a = charclass[0] == "^"
+          if a
+            n -= 1
+            charclass = charclass[1..-1]
+          end
+          if n > 0
+            if n > 1
+              gen.write Packcr.template("node/charclass.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
+            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
+    end
+  end
+end

data/lib/packcr/node/error_node.rb

@@ -0,0 +1,52 @@
+class Packcr
+  class Node
+    class ErrorNode < Packcr::Node
+      attr_accessor :expr, :code, :index, :vars, :capts
+
+      def initialize
+        super
+        self.vars = []
+        self.capts = []
+      end
+
+      def debug_dump(indent = 0)
+        $stdout.print "#{" " * indent}Error(index:"
+        Packcr.dump_integer_value(index)
+        $stdout.print ", code:{"
+        Packcr.dump_escaped_string(code.text)
+        $stdout.print "}, vars:\n"
+        vars.each do |ref|
+          $stdout.print "#{" " * (indent + 2)}'#{ref.var}'\n"
+        end
+        capts.each do |capt|
+          $stdout.print "#{" " * (indent + 2)}$#{capt.index + 1}\n"
+        end
+        $stdout.print "#{" " * indent}) {\n"
+        expr.debug_dump(indent + 2)
+        $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
+      end
+
+      def verify_variables(vars)
+        @vars = vars
+        expr.verify_variables(vars)
+      end
+
+      def verify_captures(ctx, capts)
+        @capts = capts
+        expr.verify_captures(ctx, capts)
+      end
+
+      def link_references(ctx)
+        expr.link_references(ctx)
+      end
+    end
+  end
+end

data/lib/packcr/node/expand_node.rb

@@ -0,0 +1,36 @@
+class Packcr
+  class Node
+    class ExpandNode < Packcr::Node
+      attr_accessor :index, :line, :col
+
+      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)
+        gen.write Packcr.template("node/expand.#{gen.lang}.erb", binding, indent: indent, unwrap: bare)
+        return Packcr::CODE_REACH__BOTH
+      end
+
+      def verify_variables(vars)
+      end
+
+      def verify_captures(ctx, capts)
+        found = capts.any? do |capt|
+          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
+      end
+
+      def link_references(ctx)
+      end
+    end
+  end
+end

data/lib/packcr/node/predicate_node.rb

@@ -0,0 +1,51 @@
+class Packcr
+  class Node
+    class PredicateNode < Packcr::Node
+      attr_accessor :neg, :expr
+
+      def initialize
+        super
+        self.neg = false
+      end
+
+      def debug_dump(indent = 0)
+        $stdout.print "#{" " * indent}Predicate(neg:#{neg ? 1 : 0}) {\n"
+        expr.debug_dump(indent + 2)
+        $stdout.print "#{" " * indent}}\n"
+      end
+
+      def generate_code(gen, onfail, indent, bare)
+        r = 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)
+      end
+
+      def verify_captures(ctx, capts)
+        expr.verify_captures(ctx, capts)
+      end
+
+      def link_references(ctx)
+        expr.link_references(ctx)
+      end
+    end
+  end
+end

data/lib/packcr/node/quantity_node.rb

@@ -0,0 +1,55 @@
+class Packcr
+  class Node
+    class QuantityNode < Packcr::Node
+      attr_accessor :min, :max, :expr
+
+      def initialize
+        super
+        self.min = 0
+        self.max = 0
+      end
+
+      def debug_dump(indent = 0)
+        $stdout.print "#{" " * indent}Quantity(min:#{min}, max:#{max}) {\n"
+        expr.debug_dump(indent + 2)
+        $stdout.print "#{" " * indent}}\n"
+      end
+
+      def generate_code(gen, onfail, indent, bare)
+        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
+        elsif max == 1
+          if min > 0
+            return gen.generate_code(expr, onfail, indent, bare)
+          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)
+      end
+
+      def link_references(ctx)
+        expr.link_references(ctx)
+      end
+    end
+  end
+end

data/lib/packcr/node/reference_node.rb

@@ -0,0 +1,46 @@
+class Packcr
+  class Node
+    class ReferenceNode < Packcr::Node
+      attr_accessor :var, :index, :name, :rule, :line, :col
+
+      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)
+        gen.write Packcr.template("node/reference.#{gen.lang}.erb", binding, indent: indent)
+        Packcr::CODE_REACH__BOTH
+      end
+
+      def verify_variables(vars)
+        return if index.nil?
+
+        found = vars.any? do |var|
+          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
+          unless rule.is_a?(Packcr::Node::RuleNode)
+            raise "unexpected node type #{rule.class}"
+          end
+          rule.add_ref
+          self.rule = rule
+        end
+      end
+    end
+  end
+end

data/lib/packcr/node/rule_node.rb

@@ -0,0 +1,30 @@
+class Packcr
+  class Node
+    class RuleNode < Packcr::Node
+      attr_accessor :codes, :name, :expr, :ref, :vars, :capts, :line, :col
+
+      def initialize
+        super
+        self.ref = 0
+        self.vars = []
+        self.capts = []
+        self.codes = []
+      end
+
+      def debug_dump(indent = 0)
+        $stdout.print "#{" " * indent}Rule(name:'#{name}', ref:#{ref}, vars.len:#{vars.length}, capts.len:#{capts.length}, codes.len:#{codes.length}) {\n"
+        expr.debug_dump(indent + 2)
+        $stdout.print "#{" " * indent}}\n"
+      end
+
+      def verify(ctx)
+        expr.verify_variables([])
+        expr.verify_captures(ctx, [])
+      end
+
+      def add_ref
+        @ref += 1
+      end
+    end
+  end
+end

data/lib/packcr/node/sequence_node.rb

@@ -0,0 +1,61 @@
+class Packcr
+  class Node
+    class SequenceNode < Packcr::Node
+      attr_accessor :nodes
+
+      def initialize
+        super
+        self.nodes = []
+      end
+
+      def debug_dump(indent = 0)
+        $stdout.print "#{" " * indent}Sequence(max:#{max}, len:#{nodes.length}) {\n"
+        nodes.each do |child_node|
+          child_node.debug_dump(indent + 2)
+        end
+        $stdout.print "#{" " * indent}}\n"
+      end
+
+      def max
+        m = 1
+        m <<= 1 while m < @nodes.length
+        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)
+          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
+          end
+        end
+        return b ? Packcr::CODE_REACH__BOTH : Packcr::CODE_REACH__ALWAYS_SUCCEED
+      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
+      end
+    end
+  end
+end

data/lib/packcr/node/string_node.rb

@@ -0,0 +1,43 @@
+class Packcr
+  class Node
+    class StringNode < Packcr::Node
+      attr_accessor :value
+
+      def value=(value)
+        @value = value&.b
+      end
+
+      def debug_dump(indent = 0)
+        $stdout.print "#{" " * indent}String(value:'"
+        Packcr.dump_escaped_string(value)
+        $stdout.print "')\n"
+      end
+
+      def generate_code(gen, onfail, indent, bare)
+        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)
+      end
+
+      def link_references(ctx)
+      end
+    end
+  end
+end

data/lib/packcr/node.rb

@@ -0,0 +1,17 @@
+class Packcr
+  class Node
+  end
+end
+
+require "packcr/node/rule_node"
+require "packcr/node/reference_node"
+require "packcr/node/string_node"
+require "packcr/node/charclass_node"
+require "packcr/node/quantity_node"
+require "packcr/node/predicate_node"
+require "packcr/node/sequence_node"
+require "packcr/node/alternate_node"
+require "packcr/node/capture_node"
+require "packcr/node/expand_node"
+require "packcr/node/action_node"
+require "packcr/node/error_node"