rattler 0.3.0 → 0.4.0

data/lib/rattler/runner.rb

@@ -12,24 +12,26 @@ require 'pathname'
 module Rattler
   # <tt>Rattler::Runner</tt> 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
-    
+
     # Run the command-line parser
     #
     # @param (see #initialize)
     def self.run(args)
       self.new(args).run
     end
-    
+
     # Create a new command-line parser.
     #
     # @param [Array] args the command-line arguments
     def initialize(args)
+      @standalone = false
+      @optimize = true
       options.parse!(args)
       if args.size == 1
         @srcfname = Pathname.new(args.shift)
@@ -38,7 +40,7 @@ module Rattler
         exit ERRNO_USAGE
       end
     end
-    
+
     # Run the command-line parser.
     def run
       if result = analyze
@@ -48,48 +50,69 @@ module Rattler
         exit ERRNO_PARSE_ERROR
       end
     end
-    
+
     private
-    
+
     def options
       @options ||= OptionParser.new do |opts|
+
         opts.banner = "Usage: #{File.basename($0)} FILENAME [options]"
+
         opts.separator ''
+
+        opts.on '-l', '--lib DIRECTORY',
+                'Specify the destination lib directory' do |libdir|
+          @libdir = Pathname.new(libdir)
+        end
+
         opts.on '-d', '--dest DIRECTORY',
-                'Specify the destination directory' do |destdir|
-          @destdir = Pathname.new(destdir).realpath
+                'Specify an explicit destination directory' do |destdir|
+          @destdir = Pathname.new(destdir)
         end
+
         opts.on '-o', '--output FILENAME',
-                'Specify a different output filename' do |ofname|
+                'Specify a different output filename ("-" = STDOUT)' do |ofname|
           @ofname = ofname
         end
+
         opts.on '-f', '--force',
                 'Force overwrite if the output file exists' do |f|
           @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
+        end
+
         opts.separator ''
+
         opts.on_tail '-h', '--help', 'Show this message' do
-          puts opts
-          exit
+          abort "#{opts}\n"
         end
       end
     end
-    
+
     def parser
       @parser ||= Rattler::Grammar::GrammarParser.new(@srcfname.read)
     end
-    
+
     def analyze
       parser.parse
     rescue Exception => e
       puts e
       exit ERRNO_READ_ERROR
     end
-    
+
     def synthesize(g)
       open_output(g) do |io|
         begin
-          io.puts(Rattler::BackEnd::ParserGenerator.code_for(g))
+          io.puts code_for(g)
         rescue Exception => e
           puts e
           exit ERRNO_GEN_ERROR
@@ -99,7 +122,15 @@ module Rattler
       puts e
       exit ERRNO_WRITE_ERROR
     end
-    
+
+    def code_for(g)
+      Rattler::BackEnd::ParserGenerator.code_for g, generator_options
+    end
+
+    def generator_options
+      { :standalone => @standalone, :no_optimize => !@optimize }
+    end
+
     def open_output(g)
       if @ofname == '-'
         yield $stdout
@@ -107,32 +138,39 @@ module Rattler
         open_to_write(full_dest_name(g)) {|io| yield io }
       end
     end
-    
+
     def report(dest)
       puts "#{relative_path @srcfname} -> #{relative_path dest}"
     end
-    
+
     def open_to_write(dest)
-      raise "File exists - #{relative_path dest}" if dest.exist? and not @force
+      if dest.exist? and not @force
+        raise "File exists - #{relative_path dest} (use --force to overwrite)"
+      end
       dest.dirname.mkpath
       report(dest)
       dest.open('w') { |f| yield f }
     end
-    
+
     def full_dest_name(g)
       names = g.name.split('::').map {|_| underscore _ }
-      names[-1] = @ofname || (names[-1] + '.rb')
-      destdir.join(*names)
+      ofname = @ofname || (names[-1] + '.rb')
+      if @destdir
+        @destdir.join(ofname)
+      else
+        names[-1] = ofname
+        libdir.join(*names)
+      end
     end
-    
-    def destdir
-      @destdir ||= Pathname.getwd
+
+    def libdir
+      @libdir ||= Pathname.getwd
     end
-    
+
     def relative_path(p)
       p.dirname.realpath.relative_path_from(Pathname.getwd) + p.basename
     end
-    
+
     # copied shamelessly from ActiveSupport
     def underscore(camel_cased_word)
       camel_cased_word.to_s.gsub(/::/, '/').
@@ -141,6 +179,6 @@ module Rattler
         tr("-", "_").
         downcase
     end
-    
+
   end
 end

data/lib/rattler/runtime/extended_packrat_parser.rb

@@ -28,33 +28,39 @@ module Rattler::Runtime
       @lr_stack = []
     end
 
-    private
-
-    # @private
-    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
-      @lr_stack.pop
-      if lr.head
-        m.end_pos = @scanner.pos
-        lr.seed = result
-        lr_answer rule_name, start_pos, m
+    def apply(rule_name)
+      start_pos = @scanner.pos
+      if m = memo_lr(rule_name, start_pos)
+        recall m, rule_name
       else
-        memorize m, result
+        lr = LR.new(false, rule_name, nil)
+        @lr_stack.push lr
+        m = inject_memo rule_name, start_pos, lr, start_pos
+        result = eval_rule rule_name
+        @lr_stack.pop
+        if lr.head
+          m.end_pos = @scanner.pos
+          lr.seed = result
+          lr_answer rule_name, start_pos, m
+        else
+          save m, result
+        end
       end
     end
 
+    alias_method :memoize_lr, :apply
+
+    private
+
     # @private
-    def memo(rule_name, start_pos) #:nodoc:
-      m = super
+    def memo_lr(rule_name, start_pos) #:nodoc:
+      m = memo(rule_name, start_pos)
       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
+        return inject_fail rule_name, start_pos
       end
       if head.eval_set.delete(rule_name)
-        memorize m, eval_rule(rule_name)
+        save m, eval_rule(rule_name)
       end
       return m
     end
@@ -84,7 +90,7 @@ module Rattler::Runtime
       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
+        save m, m.result.seed
       end
     end
 
@@ -99,7 +105,7 @@ module Rattler::Runtime
           @heads.delete(start_pos)
           return recall m, rule_name
         end
-        memorize m, result
+        save m, result
       end
     end
 

data/lib/rattler/runtime/packrat_parser.rb

@@ -27,10 +27,6 @@ module Rattler::Runtime
       @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
@@ -47,51 +43,51 @@ module Rattler::Runtime
       if m = memo(rule_name, start_pos)
         recall m, rule_name
       else
-        apply! rule_name, start_pos
+        m = inject_fail rule_name, start_pos
+        save m, eval_rule(rule_name)
       end
     end
 
+    alias_method :memoize, :apply
+
+    alias_method :eval_rule, :send
+
     private
 
     # @private
-    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)
+    def memo(rule_name, start_pos) #:nodoc:
+      @memo[rule_name][start_pos]
     end
 
-    def memo(rule_name, start_pos)
-      @memo[rule_name][start_pos]
+    # @private
+    def inject_memo(rule_name, start_pos, result, end_pos) #:nodoc:
+      @memo[rule_name][start_pos] = MemoEntry.new(result, end_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)
+    # @private
+    def inject_fail(rule_name, fail_pos) #:nodoc:
+      @memo[rule_name][fail_pos] = MemoEntry.new(false, fail_pos)
     end
 
     # @private
-    def memorize(m, result) #:nodoc:
+    def save(m, result) #:nodoc:
       m.end_pos = @scanner.pos
-      m.failure_pos = @failure_pos
-      m.failure_msg = @failure_msg
       m.result = result
     end
 
     # @private
     def recall(m, rule_name) #:nodoc:
       @scanner.pos = m.end_pos
-      @failure_pos = m.failure_pos
-      @failure_msg = m.failure_msg
       m.result
     end
 
     # @private
     class MemoEntry #:nodoc:
-      def initialize(result, end_pos, failure_pos, failure_msg)
+      def initialize(result, end_pos)
         @result = result
         @end_pos = end_pos
-        @failure_pos = failure_pos
-        @failure_msg = failure_msg
       end
-      attr_accessor :result, :end_pos, :failure_pos, :failure_msg
+      attr_accessor :result, :end_pos
     end
 
   end

data/lib/rattler/runtime/parser.rb

@@ -14,7 +14,7 @@ module Rattler::Runtime
   #
   # @author Jason Arhart
   #
-  class Parser
+  class Parser < Rattler::Util::Node
 
     # Parse +source+ and raise a {SyntaxError} if the parse fails.
     #
@@ -25,6 +25,16 @@ module Rattler::Runtime
       self.new(source, options).parse!
     end
 
+    # Parse the entirety of +source+ and raise a {SyntaxError} if the parse
+    # fails.
+    #
+    # @param (see #initialize)
+    # @raise (see #parse!)
+    # @return (see #parse!)
+    def self.parse_fully!(source, options={})
+      self.new(source, options).parse_fully!
+    end
+
     # Create a new parser to parse +source+.
     #
     # @param [String] source the source to parse
@@ -71,7 +81,7 @@ module Rattler::Runtime
     #
     # @return (see #parse_fully)
     def parse_fully!
-      parse_full or raise_error
+      parse_fully or raise_error
     end
 
     # The current parse position

data/lib/rattler/runtime/recursive_descent_parser.rb

@@ -38,7 +38,7 @@ module Rattler::Runtime
     # @return (see #apply)
     #
     def match(rule_name)
-      apply(rule_name) or fail { rule_name }
+      send @rule_method_names[rule_name] or fail { rule_name }
     end
 
     def method_missing(symbol, *args)
@@ -59,16 +59,8 @@ module Rattler::Runtime
       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.
-    #
-    # @param [Symbol] rule_name the name of the rule to apply
-    #
-    # @return the result of applying the rule
-    #
-    def apply(rule_name)
-      send @rule_method_names[rule_name]
+    def apply(rule_method_name)
+      send rule_method_name
     end
 
   end

data/lib/rattler/util.rb

@@ -12,5 +12,6 @@ module Rattler
     autoload :LineCounter, 'rattler/util/line_counter'
     autoload :Node, 'rattler/util/node'
     autoload :ParserSpecHelper, 'rattler/util/parser_spec_helper'
+    autoload :GraphViz, 'rattler/util/graphviz'
   end
-end
+end

data/lib/rattler/util/graphviz.rb

@@ -0,0 +1,29 @@
+#
+# = rattler/util/graphviz.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler/util'
+
+module Rattler::Util
+  #
+  # The +GraphViz+ provides utilities to build GraphViz objects representing
+  # trees of nodes.
+  #
+  # @author Jason Arhart
+  #
+  module GraphViz
+
+    autoload :DigraphBuilder, 'rattler/util/graphviz/digraph_builder'
+    autoload :NodeBuilder, 'rattler/util/graphviz/node_builder'
+
+    # Return a new +GraphViz+ digraph object representing +root+.
+    #
+    # @return a new +GraphViz+ digraph object representing +root+
+    def self.digraph(root)
+      DigraphBuilder.digraph(root)
+    end
+
+  end
+end