rattler 0.5.0 → 0.6.0

data/lib/rattler/parsers/sequence.rb

@@ -1,21 +1,11 @@
-#
-# = rattler/parsers/sequence.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-
 require 'rattler/parsers'
 
 module Rattler::Parsers
-  #
+
   # +Sequence+ combines two or more parsers and matches by trying each one in
   # sequence and failing unless they all succeed.
-  #
-  # @author Jason Arhart
-  #
   class Sequence < Parser
-    include Combining
+    include Sequencing
 
     # @private
     def self.parsed(results, *_) #:nodoc:
@@ -25,48 +15,43 @@ module Rattler::Parsers
     # Try each parser in sequence, and if they all succeed return an array of
     # captured results, or return +false+ if any parser fails.
     #
-    # @param (see Parser#parse_labeled)
+    # @param (see Match#parse)
     #
     # @return an array of captured results of each parser in sequence, or
     #   +false+
-    def parse(scanner, rules, scope = {})
-      parse_and_yield_scope scanner, rules, scope
-    end
-
-    def parse_and_yield_scope(scanner, rules, scope = {})
-      pos = scanner.pos
-      results = []
-      for child in children
-        if r = child.parse(scanner, rules, scope) {|_| scope = _ }
-          results << r unless r == true
-        else
-          scanner.pos = pos
-          return false
+    def parse(scanner, rules, scope = ParserScope.empty)
+      backtracking(scanner) do
+        if scope = parse_children(scanner, rules, scope.nest)
+          yield scope if block_given?
+          parse_result(scope)
         end
       end
-      yield scope if block_given?
-      case capture_count
-      when 0 then true
-      when 1 then results[0]
-      else results
-      end
     end
 
-    # Return a new parser that tries both this parser and +other+ and fails
-    # unless both parse in sequence.
-    #
-    # @param other (see Parser#&)
-    # @return (see Parser#&)
+    # (see Parser#&)
     def &(other)
       Sequence[(children + [other])]
     end
 
-    # The number of child parsers that are capturing
-    #
-    # @return the number of child parsers that are capturing
+    # (see Parser#>>)
+    def >>(semantic)
+      AttributedSequence[(children + [semantic])]
+    end
+
+    # @return [Fixnum] the number of child parsers that are capturing
     def capture_count
       @capture_count ||= count {|_| _.capturing? }
     end
 
+    private
+
+    def parse_result(scope)
+      case capture_count
+      when 0 then true
+      when 1 then scope.captures[0]
+      else scope.captures
+      end
+    end
+
   end
 end

data/lib/rattler/parsers/sequencing.rb

@@ -0,0 +1,40 @@
+require 'rattler/parsers'
+
+module Rattler::Parsers
+
+  # +Sequencing+ describes a parser that combines two or more parsers and
+  # matches in sequence.
+  module Sequencing
+    include Combining
+
+    # @return +true+
+    def sequence?
+      true
+    end
+
+    protected
+
+    # @private
+    def backtracking(scanner) #:nodoc:
+      pos = scanner.pos
+      yield or begin
+        scanner.pos = pos
+        false
+      end
+    end
+
+    # @private
+    def parse_children(scanner, rules, scope) #:nodoc:
+      for child in children
+        if r = child.parse(scanner, rules, scope) {|_| scope = scope.merge _ }
+          scope = scope.capture(r) unless r == true
+          yield r if block_given?
+        else
+          return false
+        end
+      end
+      scope
+    end
+
+  end
+end

data/lib/rattler/parsers/skip.rb

@@ -1,14 +1,7 @@
-#
-# = rattler/parsers/skip.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-
 require 'rattler/parsers'
 
 module Rattler::Parsers
-  #
+
   # +Skip+ decorates a parser to skip over what it matches without capturing
   # the results
   #
@@ -23,20 +16,26 @@ module Rattler::Parsers
     # If the decorated parser matches return +true+, otherwise return a false
     # value.
     #
-    # @param (see Parser#parse_labeled)
+    # @param (see Match#parse)
     #
     # @return [Boolean] +true+ if the decorated parser matches at the parse
     #   position
-    def parse(scanner, rules, scope = {})
-      child.parse(scanner, rules, scope) && true
+    def parse(*args)
+      child.parse(*args) && true
     end
 
-    # Always +false+
     # @return false
+    # @see Parser#capturing?
     def capturing?
       false
     end
 
+    # @return true
+    # @see Parser#capturing_decidable?
+    def capturing_decidable?
+      true
+    end
+
     # @return (see Parser#skip)
     def skip
       self

data/lib/rattler/parsers/super.rb

@@ -0,0 +1,33 @@
+require 'rattler/parsers'
+
+module Rattler::Parsers
+
+  # +Super+ parses by applying the rule of the same name inherited from a
+  # super-grammar.
+  class Super < Parser
+
+    # @param [Symbol] rule_name the name of the referenced rule
+    #
+    # @return [Apply] a new parser that parses by applying the rule
+    #   referenced by +rule_name+ in a super-grammar
+    def self.[](rule_name)
+      self.new(:rule_name => rule_name.to_sym)
+    end
+
+    # Apply the parse rule of the same name inherited from a super-grammar.
+    #
+    # @param (see Match#parse)
+    #
+    # @return the result of applying parse rule of the same name inherited from
+    #   a super-grammar
+    def parse(scanner, rules, scope = ParserScope.empty)
+      rules.inherited_rule(rule_name).parse(scanner, rules, scope)
+    end
+
+    # (see Parser#capturing_decidable?)
+    def capturing_decidable?
+      false
+    end
+
+  end
+end

data/lib/rattler/parsers/token.rb

@@ -1,28 +1,18 @@
-#
-# = rattler/parsers/token.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-
 require 'rattler/parsers'
 
 module Rattler::Parsers
-  #
+
   # +Token+ decorates a parser to return the entire matched string
-  #
-  # @author Jason Arhart
-  #
   class Token < Parser
     include Atomic
 
     # If the decorated parser matches return the entire matched string,
     # otherwise return a false value.
     #
-    # @param (see Parser#parse_labeled)
+    # @param (see Match#parse)
     #
     # @return (see Match#parse)
-    def parse(scanner, rules, scope = {})
+    def parse(scanner, rules, scope = ParserScope.empty)
       p = scanner.pos
       child.parse(scanner, rules, scope) && scanner.string[p...(scanner.pos)]
     end

data/lib/rattler/rake_task.rb

@@ -0,0 +1,50 @@
+require 'rattler/runner'
+require 'rake'
+require 'rake/tasklib'
+
+module Rattler
+
+  # The rake task to generate parser code from a grammar
+  #
+  class RakeTask < ::Rake::TaskLib
+    include ::Rake::DSL if defined?(::Rake::DSL)
+
+    attr_accessor :name
+    attr_accessor :grammar
+    attr_accessor :rtlr_opts
+    attr_accessor :verbose
+
+    def initialize(name = :rattler)
+      @name = name
+      @grammar = nil
+      @rtlr_opts = []
+      @verbose = true
+
+      yield self if block_given?
+
+      define_task
+    end
+
+    private
+
+    def define_task
+      task name do
+        RakeFileUtils.send(:verbose, verbose) do
+          ::Rattler::Runner.run(run_args) if valid?
+        end
+      end
+    end
+
+    def run_args
+      [grammar] + rtlr_opts
+    end
+
+    def valid?
+      unless grammar
+        puts "No grammar specified"
+        return false
+      end
+      true
+    end
+  end
+end

data/lib/rattler/runner.rb

@@ -1,23 +1,26 @@
-#
-# = rattler/runner.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
 require 'rattler'
 
 require 'optparse'
 require 'pathname'
 
 module Rattler
-  # <tt>Rattler::Runner</tt> defines the command-line parser generator.
+  # +Runner+ defines the command-line parser generator.
   class Runner
 
-    ERRNO_USAGE = 1         # Invalid command line arguments
-    ERRNO_READ_ERROR = 2    # Error reading grammar file
-    ERRNO_WRITE_ERROR = 3   # Error writing parser file
-    ERRNO_PARSE_ERROR = 4   # Error parsing grammar
-    ERRNO_GEN_ERROR = 5     # Error generaing ruby code
+    # Invalid command line arguments
+    ERRNO_USAGE = 1
+
+    # Error reading grammar file
+    ERRNO_READ_ERROR = 2
+
+    # Error writing parser file
+    ERRNO_WRITE_ERROR = 3
+
+    # Error parsing grammar
+    ERRNO_PARSE_ERROR = 4
+
+    # Error generaing ruby code
+    ERRNO_GEN_ERROR = 5
 
     # Run the command-line parser
     #
@@ -28,9 +31,8 @@ module Rattler
 
     # Create a new command-line parser.
     #
-    # @param [Array] args the command-line arguments
+    # @param [Array<String>] args the command-line arguments
     def initialize(args)
-      @standalone = false
       @optimize = true
       options.parse!(args)
       if args.size == 1
@@ -80,11 +82,6 @@ module Rattler
           @force = f
         end
 
-        opts.on '-s', '--standalone',
-                'Optimize for use as a standalone parser' do |s|
-          @standalone = s
-        end
-
         opts.on '-n', '--no-optimize',
                 'Disable optimization' do |n|
           @optimize = n
@@ -99,7 +96,7 @@ module Rattler
     end
 
     def parser
-      @parser ||= Rattler::Grammar::GrammarParser.new(@srcfname.read)
+      @parser ||= Rattler::Compiler::GrammarParser.new(@srcfname.read)
     end
 
     def analyze
@@ -124,11 +121,11 @@ module Rattler
     end
 
     def code_for(g)
-      Rattler::BackEnd::ParserGenerator.code_for g, generator_options
+      Rattler::Compiler::ParserGenerator.code_for g, generator_options
     end
 
     def generator_options
-      { :standalone => @standalone, :no_optimize => !@optimize }
+      { :no_optimize => !@optimize }
     end
 
     def open_output(g)

data/lib/rattler/runtime.rb

@@ -1,17 +1,7 @@
-#
-# = rattler/runtime.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
 require 'rattler'
 
 module Rattler
-  #
   # The +Runtime+ module defines the classes used by concrete parsers.
-  #
-  # @author Jason Arhart
-  #
   module Runtime
     autoload :Parser, 'rattler/runtime/parser'
     autoload :RecursiveDescentParser, 'rattler/runtime/recursive_descent_parser'

data/lib/rattler/runtime/extended_packrat_parser.rb

@@ -1,20 +1,10 @@
-#
-# = rattler/runtime/extended_packrat_parser.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-
 require 'rattler/runtime'
 
 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.
-  #
-  # @author Jason Arhart
-  #
   class ExtendedPackratParser < PackratParser
 
     # Create a new extended packrat parser to parse +source+.
@@ -28,47 +18,52 @@ module Rattler::Runtime
       @lr_stack = []
     end
 
-    def apply(rule_name)
+    # Apply a rule by dispatching to the given match method. The result of
+    # applying the rule is memoized so that the match method is invoked at most
+    # once at a given parse position.
+    #
+    # @param (see PackratParser#apply)
+    # @return (see PackratParser#apply)
+    #
+    def apply(match_method_name)
       start_pos = @scanner.pos
-      if m = memo_lr(rule_name, start_pos)
-        recall m, rule_name
+      if m = memo_lr(match_method_name, start_pos)
+        recall m, match_method_name
       else
-        lr = LR.new(false, rule_name, nil)
+        lr = LR.new(false, match_method_name, nil)
         @lr_stack.push lr
-        m = inject_memo rule_name, start_pos, lr, start_pos
-        result = eval_rule rule_name
+        m = inject_memo match_method_name, start_pos, lr, start_pos
+        result = eval_rule match_method_name
         @lr_stack.pop
         if lr.head
           m.end_pos = @scanner.pos
           lr.seed = result
-          lr_answer rule_name, start_pos, m
+          lr_answer match_method_name, start_pos, m
         else
           save m, result
         end
       end
     end
 
-    alias_method :memoize_lr, :apply
-
     private
 
     # @private
-    def memo_lr(rule_name, start_pos) #:nodoc:
-      m = memo(rule_name, start_pos)
+    def memo_lr(match_method_name, start_pos) #:nodoc:
+      m = memo(match_method_name, start_pos)
       head = @heads[start_pos] or return m
-      if !m && !head.involves?(rule_name)
-        return inject_fail rule_name, start_pos
+      if !m && !head.involves?(match_method_name)
+        return inject_fail match_method_name, start_pos
       end
-      if head.eval_set.delete(rule_name)
-        save m, eval_rule(rule_name)
+      if head.eval_set.delete(match_method_name)
+        save m, eval_rule(match_method_name)
       end
       return m
     end
 
     # @private
-    def recall(m, rule_name) #:nodoc:
+    def recall(m, match_method_name) #:nodoc:
       if (result = m.result).is_a? LR
-        setup_lr rule_name, result
+        setup_lr match_method_name, result
         result.seed
       else
         super
@@ -76,34 +71,34 @@ module Rattler::Runtime
     end
 
     # @private
-    def setup_lr(rule_name, lr) #:nodoc:
-      lr.head ||= Head.new(rule_name)
+    def setup_lr(match_method_name, lr) #:nodoc:
+      lr.head ||= Head.new(match_method_name)
       @lr_stack.reverse_each do |_|
         return if _.head == lr.head
-        lr.head.involved_set[_.rule_name] = _.rule_name
+        lr.head.involved_set[_.match_method_name] = _.match_method_name
       end
     end
 
     # @private
-    def lr_answer(rule_name, start_pos, m) #:nodoc:
+    def lr_answer(match_method_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
+      if head.match_method_name == match_method_name
+        grow_lr(match_method_name, start_pos, m, head) if m.result = m.result.seed
       else
         save m, m.result.seed
       end
     end
 
     # @private
-    def grow_lr(rule_name, start_pos, m, head) #:nodoc:
+    def grow_lr(match_method_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)
+        result = eval_rule(match_method_name)
         if !result or @scanner.pos <= m.end_pos
           @heads.delete(start_pos)
-          return recall m, rule_name
+          return recall m, match_method_name
         end
         save m, result
       end
@@ -111,24 +106,24 @@ module Rattler::Runtime
 
     # @private
     class LR #:nodoc:
-      def initialize(seed, rule_name, head)
+      def initialize(seed, match_method_name, head)
         @seed = seed
-        @rule_name = rule_name
+        @match_method_name = match_method_name
         @head = head
       end
-      attr_accessor :seed, :rule_name, :head
+      attr_accessor :seed, :match_method_name, :head
     end
 
     # @private
     class Head #:nodoc:
-      def initialize(rule_name)
-        @rule_name = rule_name
+      def initialize(match_method_name)
+        @match_method_name = match_method_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
+      attr_accessor :match_method_name, :involved_set, :eval_set
+      def involves?(match_method_name)
+        match_method_name == self.match_method_name or involved_set.has_key? match_method_name
       end
     end