kpeg 0.7

data/lib/kpeg/grammar_renderer.rb

@@ -0,0 +1,172 @@
+require 'kpeg/string_escape'
+
+module KPeg
+  class GrammarRenderer
+    def initialize(gram)
+      @grammar = gram
+    end
+
+    def render(io)
+      widest = @grammar.rules.keys.sort { |a,b| a.size <=> b.size }.last
+      indent = widest.size
+
+      @grammar.setup_actions.each do |act|
+        io.print "%% {"
+        io.print act.action
+        io.print "}\n\n"
+      end
+
+      @grammar.rule_order.each do |name|
+        rule = @grammar.find(name)
+
+        io.print(' ' * (indent - name.size))
+        io.print "#{name} = "
+
+        op = rule.op
+
+        if op.kind_of? Choice
+          op.ops.each_with_index do |r,idx|
+            unless idx == 0
+              io.print "\n#{' ' * (indent+1)}| "
+            end
+
+            render_op io, r
+          end
+        else
+          render_op io, op
+        end
+
+        io.puts
+      end
+    end
+
+    def parens?(op)
+      case op
+      when Sequence, AndPredicate, NotPredicate
+        return true
+      end
+
+      false
+    end
+
+    def self.escape(str, embed=false)
+      parc = StringEscape.new(str)
+
+      rule = (embed ? "embed" : nil)
+
+      unless parc.parse(rule)
+        parc.raise_error
+      end
+
+      return parc.text
+    end
+
+    def render_op(io, op)
+      case op
+      when Dot
+        io.print "."
+      when LiteralString
+        esc = GrammarRenderer.escape op.string
+        io.print '"'
+        io.print esc
+        io.print '"'
+      when LiteralRegexp
+        io.print op.regexp.inspect
+      when CharRange
+        io.print "[#{op.start}-#{op.fin}]"
+      when Sequence
+        op.ops.each_with_index do |r,idx|
+          unless idx == 0
+            io.print " "
+          end
+          render_op io, r
+        end
+      when Choice
+        io.print "("
+        op.ops.each_with_index do |r,idx|
+          unless idx == 0
+            io.print " | "
+          end
+
+          render_op io, r
+        end
+        io.print ")"
+      when Multiple
+        if parens?(op.op)
+          io.print "("
+          render_op io, op.op
+          io.print ")"
+        else
+          render_op io, op.op
+        end
+
+        if op.max
+          if op.min == 0 and op.max == 1
+            io.print "?"
+          else
+            io.print "[#{op.min}, #{op.max}]"
+          end
+        elsif op.min == 0
+          io.print "*"
+        elsif op.min == 1
+          io.print "+"
+        else
+          io.print "[#{op.min},*]"
+        end
+      when AndPredicate
+        io.print "&"
+        if parens?(op.op)
+          io.print "("
+          render_op io, op.op
+          io.print ")"
+        else
+          render_op io, op.op
+        end
+      when NotPredicate
+        io.print "!"
+        if parens?(op.op)
+          io.print "("
+          render_op io, op.op
+          io.print ")"
+        else
+          render_op io, op.op
+        end
+      when RuleReference
+        io.print op.rule_name
+      when InvokeRule
+        if op.arguments
+          io.print "#{op.rule_name}#{op.arguments}"
+        else
+          io.print "@#{op.rule_name}"
+        end
+      when ForeignInvokeRule
+        if op.arguments
+          io.print "%#{op.grammar_name}.#{op.rule_name}#{op.arguments}"
+        else
+          io.print "%#{op.grammar_name}.#{op.rule_name}"
+        end
+      when Tag
+        if parens?(op.op)
+          io.print "("
+          render_op io, op.op
+          io.print ")"
+        else
+          render_op io, op.op
+        end
+
+        if op.tag_name
+          io.print ":#{op.tag_name}"
+        end
+      when Action
+        io.print "{#{op.action}}"
+      when Collect
+        io.print "< "
+        render_op io, op.op
+        io.print " >"
+      else
+        raise "Unknown op type - #{op.class}"
+      end
+    end
+  end
+
+end

data/lib/kpeg/match.rb

@@ -0,0 +1,70 @@
+module KPeg
+  class Match; end
+
+  class MatchString < Match
+    def initialize(op, string)
+      @op = op
+      @string = string
+    end
+
+    attr_reader :op, :string
+
+    def explain(indent="")
+      puts "#{indent}KPeg::Match:#{object_id.to_s(16)}"
+      puts "#{indent}  op: #{@op.inspect}"
+      puts "#{indent}  string: #{@string.inspect}"
+    end
+
+    alias_method :total_string, :string
+
+    def value(obj=nil)
+      return @string unless @op.action
+      if obj
+        obj.instance_exec(@string, &@op.action)
+      else
+        @op.action.call(@string)
+      end
+    end
+  end
+
+  class MatchComposition < Match
+    def initialize(op, matches)
+      @op = op
+      @matches = matches
+    end
+
+    attr_reader :op, :matches
+
+    def explain(indent="")
+      puts "#{indent}KPeg::Match:#{object_id.to_s(16)}"
+      puts "#{indent}  op: #{@op.inspect}"
+      puts "#{indent}  matches:"
+      @matches.each do |m|
+        m.explain("#{indent}    ")
+      end
+    end
+
+    def total_string
+      @matches.map { |m| m.total_string }.join
+    end
+
+    def value(obj=nil)
+      values = @matches.map { |m| m.value(obj) }
+
+      values = @op.prune_values(values)
+
+      unless @op.action
+        return values.first if values.size == 1
+        return values
+      end
+
+      if obj
+        obj.instance_exec(*values, &@op.action)
+      else
+        @op.action.call(*values)
+      end
+    end
+  end
+
+
+end

data/lib/kpeg/parser.rb

@@ -0,0 +1,193 @@
+require 'kpeg/position'
+
+module KPeg
+  class Parser < StringScanner
+    def initialize(str, grammar, log=false)
+      super str
+
+      @grammar = grammar
+      # A 2 level hash.
+      @memoizations = Hash.new { |h,k| h[k] = {} }
+
+      @failing_offset = nil
+      @failing_op = nil
+      @log = log
+    end
+
+    attr_reader :grammar, :memoizations, :failing_offset
+    attr_accessor :failing_op
+
+    include Position
+
+    def switch_grammar(gram)
+      begin
+        old = @grammar
+        @grammar = gram
+        yield
+      ensure
+        @grammar = old
+      end
+    end
+
+    def fail(op)
+      @failing_offset = pos
+      @failing_op = op
+      return nil
+    end
+
+    def expected_string
+      case @failing_op
+      when Choice
+        return Range.new(@failing_op.start, @failing_op.fin)
+      when Dot
+        return nil
+      else
+        @failing_op.string
+      end
+    end
+
+    class LeftRecursive
+      def initialize(detected=false)
+        @detected = detected
+      end
+
+      attr_accessor :detected
+    end
+
+    class MemoEntry
+      def initialize(ans, pos)
+        @ans = ans
+        @pos = pos
+        @uses = 1
+      end
+
+      attr_reader :ans, :pos, :uses
+
+      def inc!
+        @uses += 1
+      end
+
+      def move!(ans, pos)
+        @ans = ans
+        @pos = pos
+      end
+    end
+
+    # Call a rule without memoization
+    def invoke(rule)
+      rule.op.match(self)
+    end
+
+    def apply(rule)
+      ans = nil
+      if m = @memoizations[rule][pos]
+        m.inc!
+
+        self.pos = m.pos
+        if m.ans.kind_of? LeftRecursive
+          m.ans.detected = true
+          if @log
+            puts "LR #{rule.name} @ #{self.inspect}"
+          end
+          return nil
+        end
+
+        ans = m.ans
+      else
+        lr = LeftRecursive.new(false)
+        m = MemoEntry.new(lr, pos)
+        @memoizations[rule][pos] = m
+        start_pos = pos
+
+        if @log
+          puts "START #{rule.name} @ #{self.inspect}"
+        end
+
+        ans = rule.op.match(self)
+
+        m.move! ans, pos
+
+        # Don't bother trying to grow the left recursion
+        # if it's failing straight away (thus there is no seed)
+        if ans and lr.detected
+          ans = grow_lr(rule, start_pos, m)
+        end
+      end
+
+      if @log
+        if ans
+          puts "   OK #{rule.name} @ #{self.inspect}"
+        else
+          puts " FAIL #{rule.name} @ #{self.inspect}"
+        end
+      end
+      return ans
+    end
+
+    def grow_lr(rule, start_pos, m)
+      while true
+        self.pos = start_pos
+        ans = rule.op.match(self)
+        return nil unless ans
+
+        break if pos <= m.pos
+
+        m.move! ans, pos
+      end
+
+      self.pos = m.pos
+      return m.ans
+    end
+
+    def failed?
+      !!@failing_op
+    end
+
+    def parse(name=nil)
+      if name
+        rule = @grammar.find(name)
+        unless rule
+          raise "Unknown rule - #{name}"
+        end
+      else
+        rule = @grammar.root
+      end
+
+      match = apply rule
+
+      if pos == string.size
+        @failing_op = nil
+      end
+
+      return match
+    end
+
+    def expectation
+      error_pos = @failing_offset
+      line_no = current_line(error_pos)
+      col_no = current_column(error_pos)
+
+      expected = expected_string()
+
+      prefix = nil
+
+      case expected
+      when String
+        prefix = expected.inspect
+      when Range
+        prefix = "to be between #{expected.begin} and #{expected.end}"
+      when Array
+        prefix = "to be one of #{expected.inspect}"
+      when nil
+        prefix = "anything (no more input)"
+      else
+        prefix = "unknown"
+      end
+
+      return "Expected #{prefix} at line #{line_no}, column #{col_no} (offset #{error_pos})"
+    end
+
+  end
+
+
+end

data/lib/kpeg/position.rb

@@ -0,0 +1,34 @@
+module KPeg
+  module Position
+    # STANDALONE START
+    def current_column(target=pos)
+      if c = string.rindex("\n", target-1)
+        return target - c - 1
+      end
+
+      target + 1
+    end
+
+    def current_line(target=pos)
+      cur_offset = 0
+      cur_line = 0
+
+      string.each_line do |line|
+        cur_line += 1
+        cur_offset += line.size
+        return cur_line if cur_offset >= target
+      end
+
+      -1
+    end
+
+    def lines
+      lines = []
+      string.each_line { |l| lines << l }
+      lines
+    end
+
+    # STANDALONE END
+
+  end
+end