rattler 0.2.2 → 0.3.0

data/lib/rattler/runtime/extended_packrat_parser.rb

@@ -11,52 +11,120 @@ module Rattler::Runtime
   #
   # +ExtendedPackratParser+ implements the algorithm described by Alessandro
   # Warth, James R. Douglass, and Todd Millstein for extending packrat parsing
-  # to support left-recursive grammars. It currently only implements the first
-  # part to support direct left recursion.
+  # to support left-recursive grammars.
   #
   # @author Jason Arhart
   #
   class ExtendedPackratParser < PackratParser
 
+    # Create a new extended packrat parser to parse +source+.
+    #
+    # @param (see PackratParser#initialize)
+    # @option (see PackratParser#initialize)
+    #
+    def initialize(source, options={})
+      super
+      @heads = {}
+      @lr_stack = []
+    end
+
     private
-    
+
     # @private
-    def apply!(rule_name, key, start_pos) #:nodoc:
-      lr = LR.new
-      m = @memo[key] = MemoEntry.new(lr, start_pos, nil, nil)
+    def apply!(rule_name, start_pos) #:nodoc:
+      lr = LR.new(false, rule_name, nil)
+      @lr_stack.push lr
+      m = inject_memo rule_name, start_pos, lr, start_pos, nil, nil
       result = eval_rule rule_name
-      memorize m, result
-      result = grow_lr(rule_name, start_pos, m) if result and lr.detected
-      result
+      @lr_stack.pop
+      if lr.head
+        m.end_pos = @scanner.pos
+        lr.seed = result
+        lr_answer rule_name, start_pos, m
+      else
+        memorize m, result
+      end
+    end
+
+    # @private
+    def memo(rule_name, start_pos) #:nodoc:
+      m = super
+      head = @heads[start_pos] or return m
+      if !m && !head.involves?(rule_name)
+        return inject_memo rule_name, start_pos, false, start_pos, nil, nil
+      end
+      if head.eval_set.delete(rule_name)
+        memorize m, eval_rule(rule_name)
+      end
+      return m
     end
 
-    def recall(m)
+    # @private
+    def recall(m, rule_name) #:nodoc:
       if (result = m.result).is_a? LR
-        result.detected = true
-        false
+        setup_lr rule_name, result
+        result.seed
       else
         super
       end
     end
 
     # @private
-    def grow_lr(rule_name, start_pos, m) #:nodoc:
+    def setup_lr(rule_name, lr) #:nodoc:
+      lr.head ||= Head.new(rule_name)
+      @lr_stack.reverse_each do |_|
+        return if _.head == lr.head
+        lr.head.involved_set[_.rule_name] = _.rule_name
+      end
+    end
+
+    # @private
+    def lr_answer(rule_name, start_pos, m) #:nodoc:
+      head = m.result.head
+      if head.rule_name == rule_name
+        grow_lr(rule_name, start_pos, m, head) if m.result = m.result.seed
+      else
+        memorize m, m.result.seed
+      end
+    end
+
+    # @private
+    def grow_lr(rule_name, start_pos, m, head) #:nodoc:
+      @heads[start_pos] = head
       loop do
         @scanner.pos = start_pos
+        head.eval_set.replace(head.involved_set)
         result = eval_rule(rule_name)
-        return recall(m) if !result or @scanner.pos <= m.end_pos
+        if !result or @scanner.pos <= m.end_pos
+          @heads.delete(start_pos)
+          return recall m, rule_name
+        end
         memorize m, result
       end
     end
-    
+
     # @private
-    class LR
-      def initialize(detected = false)
-        @detected = detected
+    class LR #:nodoc:
+      def initialize(seed, rule_name, head)
+        @seed = seed
+        @rule_name = rule_name
+        @head = head
       end
-      attr_accessor :detected
+      attr_accessor :seed, :rule_name, :head
     end
 
-  end
+    # @private
+    class Head #:nodoc:
+      def initialize(rule_name)
+        @rule_name = rule_name
+        @involved_set = {}
+        @eval_set = {}
+      end
+      attr_accessor :rule_name, :involved_set, :eval_set
+      def involves?(rule_name)
+        rule_name == self.rule_name or involved_set.has_key? rule_name
+      end
+    end
 
+  end
 end

data/lib/rattler/runtime/packrat_parser.rb

@@ -16,7 +16,7 @@ module Rattler::Runtime
   # @author Jason Arhart
   #
   class PackratParser < RecursiveDescentParser
-    
+
     # Create a new packrat parser to parse +source+.
     #
     # @param (see RecursiveDescentParser#initialize)
@@ -24,15 +24,15 @@ module Rattler::Runtime
     #
     def initialize(source, options={})
       super
-      @memo = {}
+      @memo = Hash.new {|h, rule_name| h[rule_name] = {} }
     end
-    
+
     # @private
     alias_method :eval_rule, :apply
     private :eval_rule
-    
+
     protected
-    
+
     # Apply a rule by dispatching to the method associated with the given rule
     # name, which is named by <tt>"match_#{rule_name}"<tt>, and if the match
     # fails set a parse error. The result of applying the rule is memoized
@@ -44,22 +44,29 @@ module Rattler::Runtime
     #
     def apply(rule_name)
       start_pos = @scanner.pos
-      key = [rule_name, start_pos]
-      if @memo.has_key? key
-        recall @memo[key]
+      if m = memo(rule_name, start_pos)
+        recall m, rule_name
       else
-        apply! rule_name, key, start_pos
+        apply! rule_name, start_pos
       end
     end
-    
+
     private
 
     # @private
-    def apply!(rule_name, key, start_pos) #:nodoc:
-      m = @memo[key] = MemoEntry.new(false, start_pos, start_pos, 'left-recursion detected')
+    def apply!(rule_name, start_pos) #:nodoc:
+      m = inject_memo rule_name, start_pos, false, start_pos, start_pos, 'left-recursion detected'
       memorize m, eval_rule(rule_name)
     end
 
+    def memo(rule_name, start_pos)
+      @memo[rule_name][start_pos]
+    end
+
+    def inject_memo(rule_name, start_pos, result, end_pos, failure_pos, failure_msg)
+      @memo[rule_name][start_pos] = MemoEntry.new(result, end_pos, failure_pos, failure_msg)
+    end
+
     # @private
     def memorize(m, result) #:nodoc:
       m.end_pos = @scanner.pos
@@ -69,7 +76,7 @@ module Rattler::Runtime
     end
 
     # @private
-    def recall(m) #:nodoc:
+    def recall(m, rule_name) #:nodoc:
       @scanner.pos = m.end_pos
       @failure_pos = m.failure_pos
       @failure_msg = m.failure_msg
@@ -77,7 +84,7 @@ module Rattler::Runtime
     end
 
     # @private
-    class MemoEntry
+    class MemoEntry #:nodoc:
       def initialize(result, end_pos, failure_pos, failure_msg)
         @result = result
         @end_pos = end_pos

data/lib/rattler/runtime/parser.rb

@@ -15,7 +15,16 @@ module Rattler::Runtime
   # @author Jason Arhart
   #
   class Parser
-    
+
+    # Parse +source+ and raise a {SyntaxError} if the parse fails.
+    #
+    # @param (see #initialize)
+    # @raise (see #parse!)
+    # @return (see #parse!)
+    def self.parse!(source, options={})
+      self.new(source, options).parse!
+    end
+
     # Create a new parser to parse +source+.
     #
     # @param [String] source the source to parse
@@ -26,24 +35,58 @@ module Rattler::Runtime
       @scanner = StringScanner.new(source)
       @tab_size = options[:tab_size]
     end
-    
+
     # The source that this parser parses
     # @return [String] the source that this parser parses
     attr_reader :source
-    
+
+    # Parse or register a parse failure
+    #
+    # @return the parse result
+    def parse
+      catch(:parse_failed) { return finish __parse__ }
+      false
+    end
+
+    # Parse or raise a {SyntaxError}
+    #
+    # @raise [SyntaxError] a {SyntaxError} if the parse fails
+    #
+    # @return (see #parse)
+    def parse!
+      parse or raise_error
+    end
+
+    # Parse the entire source or register a parse failure
+    #
+    # @return the parse result if the entire source was matched
+    def parse_fully
+      (result = parse) && (@scanner.eos? || fail { :EOF }) && result
+    end
+
+    # Parse the entire source or raise a {SyntaxError}
+    #
+    # @raise [SyntaxError] a {SyntaxError} if the parse fails or the entire
+    #   source is not matched
+    #
+    # @return (see #parse_fully)
+    def parse_fully!
+      parse_full or raise_error
+    end
+
     # The current parse position
     # @return [Integer] the current parse position
     def pos
       @scanner.pos
     end
-    
+
     # Set the current parse position
     # @param [Integer] n the new parse position
     # @return [Integer] n
     def pos=(n)
       @scanner.pos = n
     end
-    
+
     # Fail and register a parse failure, unless a failure has already
     # occurred at the same or later position in the source.
     #
@@ -58,28 +101,41 @@ module Rattler::Runtime
         register_failure pos, (block_given? ? yield : nil)
       end
     end
-    
+
     # Fail and register a parse failure, unless a failure has already
     # occurred at a later position in the source.
     #
-    # @yieldreturn [String, Symbol] a failure message or rule name
-    #
-    # @see ParseFailure
+    # @yieldreturn (see #fail)
     #
-    # @return [false]
+    # @return (see #fail)
     def fail! # :yield:
       pos = @scanner.pos
       unless failure? and @failure_pos > pos
         register_failure pos, (block_given? ? yield : nil)
       end
     end
-    
+
+    # Fail the same as <tt>#fail</tt> but cause the entire parse to fail
+    # immediately.
+    #
+    # @yieldreturn (see #fail)
+    #
+    # @return (see #fail)
+    def fail_parse
+      if block_given?
+        fail! { yield }
+      else
+        fail!
+      end
+      throw :parse_failed
+    end
+
     # Return true if there is a parse failure
     # @return [Boolean] true if there is a parse failure
     def failure?
       !@failure_pos.nil?
     end
-    
+
     # Return the last parse failure
     # @return [ParseFailure] the last parse failure
     def failure
@@ -87,9 +143,9 @@ module Rattler::Runtime
         @__failure__ ||= ParseFailure.new(source, @failure_pos, @failure_msg)
       end
     end
-    
+
     protected
-    
+
     # Finish any necessary clean-up based on the final parse result.
     # @param final_result the final parse result
     # @return final_result
@@ -97,7 +153,7 @@ module Rattler::Runtime
       clear_failure if final_result
       final_result
     end
-    
+
     # Register a parse failure
     #
     # @param [Integer] position the position of the failure
@@ -110,20 +166,20 @@ module Rattler::Runtime
       @__failure__ = nil
       false
     end
-    
+
     # Clear the registered failure
     def clear_failure
       @failure_pos = nil
       @failure_msg = nil
       @__failure__ = nil
     end
-    
+
     # Raise a {SyntaxError} for the last parse failure
     # @raise [SyntaxError] a {SyntaxError} for the last parse failure
     # @return [nothing]
     def raise_error
       raise SyntaxError, failure.to_s
     end
-    
+
   end
 end

data/lib/rattler/runtime/recursive_descent_parser.rb

@@ -19,17 +19,7 @@ module Rattler::Runtime
   class RecursiveDescentParser < Parser
     include ParserHelper
     include Rattler::Grammar::GrammarDSL
-    
-    # Parse +source+ by matching the start rule and raise a {SyntaxError} if
-    # the parse fails.
-    #
-    # @param (see #initialize)
-    # @raise (see #parse!)
-    # @return (see #parse!)
-    def self.parse!(source, options={})
-      self.new(source, options).parse!
-    end
-    
+
     # Create a new recursive descent parser to parse +source+.
     #
     # @param (see Parser#initialize)
@@ -39,26 +29,7 @@ module Rattler::Runtime
       super
       @rule_method_names = Hash.new {|h, name| h[name] = :"match_#{name}" }
     end
-    
-    # Parse by matching the rule returned by <tt>#start_rule</tt> or
-    # <tt>:start</tt> if <tt>#start_rule</tt> is not defined.
-    #
-    # @return the result of applying the start rule
-    def parse
-      catch(:parse_failed) { return finish(match(start_rule)) }
-      false
-    end
-    
-    # Parse by matching the start rule and raise a {SyntaxError} if the parse
-    # fails.
-    #
-    # @raise [SyntaxError] a {SyntaxError} if the parse fails
-    #
-    # @return the result of applying the start rule if successful
-    def parse!
-      parse or raise_error
-    end
-    
+
     # Apply a rule by dispatching to the method associated with +rule_name+
     # which is named by <tt>"match_#{rule_name}"<tt>, and if the match fails
     # register a parse failure.
@@ -69,17 +40,25 @@ module Rattler::Runtime
     def match(rule_name)
       apply(rule_name) or fail { rule_name }
     end
-    
+
     def method_missing(symbol, *args)
       (symbol == :start_rule) ? :start : super
     end
-    
+
     def respond_to?(symbol)
       super or (symbol == :start_rule)
     end
-    
+
     protected
-    
+
+    # Parse by matching the rule returned by <tt>#start_rule</tt> or
+    # <tt>:start</tt> if <tt>#start_rule</tt> is not defined.
+    #
+    # @return the result of applying the start rule
+    def __parse__
+      match start_rule
+    end
+
     # Apply a rule by dispatching to the method associated with the given rule
     # name, which is named by <tt>"match_#{rule_name}"<tt>. This method is
     # called by +match+ and should not be called directly.
@@ -91,16 +70,6 @@ module Rattler::Runtime
     def apply(rule_name)
       send @rule_method_names[rule_name]
     end
-    
-    # Fail the same as <tt>#fail</tt> but cause the entire parse to fail.
-    def fail_parse
-      if block_given?
-        fail! { yield }
-      else
-        fail!
-      end
-      throw :parse_failed
-    end
-    
+
   end
 end