rattler 0.2.2 → 0.3.0

data/lib/rattler/back_end/parser_generator/sub_generating.rb

@@ -0,0 +1,128 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+
+  # @private
+  module SubGenerating #:nodoc:
+
+    include Rattler::Parsers
+
+    protected
+
+    def generate(parser, as=:basic, *args)
+      case parser
+      when Eof then gen_eof
+      else generator(parser).send(:"gen_#{as}", parser, *args)
+      end
+    end
+
+
+    def gen_eof
+      @g << '@scanner.eos?'
+    end
+
+    private
+
+    def generator(parser)
+      case parser
+
+      when Match
+        cache_generator MatchGenerator
+
+      when Choice
+        cache_generator ChoiceGenerator, :new_choice_level => true
+
+      when Sequence
+        new_generator SequenceGenerator, :new_sequence_level => true
+
+      when Optional
+        cache_generator OptionalGenerator
+
+      when ZeroOrMore
+        cache_generator ZeroOrMoreGenerator, :new_repeat_level => true
+
+      when OneOrMore
+        cache_generator OneOrMoreGenerator, :new_repeat_level => true
+
+      when List
+        cache_generator ListGenerator, :new_repeat_level => true
+
+      when List1
+        cache_generator List1Generator, :new_repeat_level => true
+
+      when Apply
+        cache_generator ApplyGenerator
+
+      when Assert
+        cache_generator AssertGenerator
+
+      when Disallow
+        cache_generator DisallowGenerator
+
+      when DispatchAction
+        cache_generator DispatchActionGenerator
+
+      when DirectAction
+        cache_generator DirectActionGenerator
+
+      when Token
+        cache_generator TokenGenerator
+
+      when Skip
+        cache_generator SkipGenerator
+
+      when Label
+        cache_generator LabelGenerator
+
+      when Fail
+        cache_generator FailGenerator
+
+      end
+    end
+
+    def cache_generator(factory, *args)
+      generator_cache.fetch factory do
+        generator_cache[factory] = new_generator factory, *args
+      end
+    end
+
+    def new_generator(factory, opts = {})
+      factory.send factory_method, @g,
+        new_level(choice_level, opts[:new_choice_level]),
+        new_level(sequence_level, opts[:new_sequence_level]),
+        new_level(repeat_level, opts[:new_repeat_level])
+    end
+
+    def new_level(old_level, inc=true)
+      if inc
+        old_level ? (old_level + 1) : 0
+      else
+        old_level
+      end
+    end
+
+    def generator_cache
+      @generator_cache ||= {}
+    end
+
+  end
+
+  module NestedSubGenerating
+    include SubGenerating
+
+    protected
+    def factory_method
+      :nested
+    end
+  end
+
+  module TopLevelSubGenerating
+    include SubGenerating
+
+    protected
+    def factory_method
+      :top_level
+    end
+  end
+
+end

data/lib/rattler/back_end/parser_generator/token_generator.rb

@@ -1,55 +1,55 @@
 require 'rattler/back_end/parser_generator'
 
 module Rattler::BackEnd::ParserGenerator
-  
+
   # @private
   class TokenGenerator < ExprGenerator #:nodoc:
     include PredicatePropogating
     include TokenPropogating
     include SkipPropogating
-    
+
     def gen_basic(token)
-      generate token.child, :gen_token
+      generate token.child, :token
     end
-    
+
     def gen_dispatch_action_nested(token, target, method_name)
       atomic_block { gen_dispatch_action_top_level token, target, method_name }
     end
-    
+
     def gen_dispatch_action_top_level(token, target, method_name)
       @g.surround("(#{result_name} = ", ')') { gen_basic token }
       (@g << ' &&').newline << dispatch_action_result(target, method_name)
     end
-    
+
     def gen_direct_action_nested(token, action)
       atomic_block { gen_direct_action_top_level token, action }
     end
-    
+
     def gen_direct_action_top_level(token, action)
       @g.surround("(#{result_name} = ", ')') { gen_basic token }
       (@g << ' &&').newline << direct_action_result(action)
     end
-    
+
   end
-  
+
   # @private
   class NestedTokenGenerator < TokenGenerator #:nodoc:
     include Nested
-    include NestedGenerators
+    include NestedSubGenerating
   end
-  
+
   def TokenGenerator.nested(*args)
     NestedTokenGenerator.new(*args)
   end
-  
+
   # @private
   class TopLevelTokenGenerator < TokenGenerator #:nodoc:
     include TopLevel
-    include TopLevelGenerators
+    include TopLevelSubGenerating
   end
-  
+
   def TokenGenerator.top_level(*args)
     TopLevelTokenGenerator.new(*args)
   end
-  
+
 end

data/lib/rattler/back_end/parser_generator/token_propogating.rb

@@ -4,7 +4,7 @@ module Rattler::BackEnd::ParserGenerator
   # @private
   module TokenPropogating #:nodoc:
     def gen_token(parser)
-      generate parser.child, :gen_token
+      generate parser.child, :token
     end
   end
 end

data/lib/rattler/back_end/parser_generator/zero_or_more_generator.rb

@@ -1,26 +1,27 @@
 require 'rattler/back_end/parser_generator'
 
 module Rattler::BackEnd::ParserGenerator
-  
+
   # @private
   class ZeroOrMoreGenerator < ExprGenerator #:nodoc:
     include RepeatGenerating
-    
+    include NestedSubGenerating
+
     def gen_assert(optional)
       @g << 'true'
     end
-    
+
     def gen_disallow(optional)
       @g << 'false'
     end
-    
+
     def gen_skip_top_level(repeat)
       @g << 'while '
-      generate repeat.child, :gen_intermediate_skip
+      generate repeat.child, :intermediate_skip
       (@g << '; end').newline
       @g << 'true'
     end
-    
+
     protected
 
     def gen_result(captures)
@@ -28,25 +29,23 @@ module Rattler::BackEnd::ParserGenerator
     end
 
   end
-  
+
   # @private
   class NestedZeroOrMoreGenerator < ZeroOrMoreGenerator #:nodoc:
     include Nested
-    include NestedGenerators
   end
-  
+
   def ZeroOrMoreGenerator.nested(*args)
     NestedZeroOrMoreGenerator.new(*args)
   end
-  
+
   # @private
   class TopLevelZeroOrMoreGenerator < ZeroOrMoreGenerator #:nodoc:
     include TopLevel
-    include NestedGenerators
   end
-  
+
   def ZeroOrMoreGenerator.top_level(*args)
     TopLevelZeroOrMoreGenerator.new(*args)
   end
-  
+
 end

data/lib/rattler/back_end/parser_generator.rb

@@ -13,14 +13,14 @@ module Rattler::BackEnd
   # @author Jason Arhart
   #
   module ParserGenerator
-    
+
     autoload :RuleGenerator, 'rattler/back_end/parser_generator/rule_generator'
     autoload :ExprGenerator, 'rattler/back_end/parser_generator/expr_generator'
     autoload :GeneratorHelper, 'rattler/back_end/parser_generator/generator_helper'
     autoload :TopLevelGenerator, 'rattler/back_end/parser_generator/expr_generator'
-    autoload :Generators, 'rattler/back_end/parser_generator/generators'
-    autoload :NestedGenerators, 'rattler/back_end/parser_generator/nested_generators'
-    autoload :TopLevelGenerators, 'rattler/back_end/parser_generator/top_level_generators'
+    autoload :SubGenerating, 'rattler/back_end/parser_generator/sub_generating'
+    autoload :NestedSubGenerating, 'rattler/back_end/parser_generator/sub_generating'
+    autoload :TopLevelSubGenerating, 'rattler/back_end/parser_generator/sub_generating'
     autoload :Nested, 'rattler/back_end/parser_generator/nested'
     autoload :TopLevel, 'rattler/back_end/parser_generator/top_level'
     autoload :MatchGenerator, 'rattler/back_end/parser_generator/match_generator'
@@ -29,6 +29,8 @@ module Rattler::BackEnd
     autoload :OptionalGenerator, 'rattler/back_end/parser_generator/optional_generator'
     autoload :ZeroOrMoreGenerator, 'rattler/back_end/parser_generator/zero_or_more_generator'
     autoload :OneOrMoreGenerator, 'rattler/back_end/parser_generator/one_or_more_generator'
+    autoload :ListGenerator, 'rattler/back_end/parser_generator/list_generator'
+    autoload :List1Generator, 'rattler/back_end/parser_generator/list1_generator'
     autoload :ApplyGenerator, 'rattler/back_end/parser_generator/apply_generator'
     autoload :AssertGenerator, 'rattler/back_end/parser_generator/assert_generator'
     autoload :DisallowGenerator, 'rattler/back_end/parser_generator/disallow_generator'
@@ -39,11 +41,12 @@ module Rattler::BackEnd
     autoload :LabelGenerator, 'rattler/back_end/parser_generator/label_generator'
     autoload :FailGenerator, 'rattler/back_end/parser_generator/fail_generator'
     autoload :RepeatGenerating, 'rattler/back_end/parser_generator/repeat_generating'
+    autoload :ListGenerating, 'rattler/back_end/parser_generator/list_generating'
     autoload :PredicatePropogating, 'rattler/back_end/parser_generator/predicate_propogating'
     autoload :TokenPropogating, 'rattler/back_end/parser_generator/token_propogating'
     autoload :SkipPropogating, 'rattler/back_end/parser_generator/skip_propogating'
     autoload :GEN_METHOD_NAMES, 'rattler/back_end/parser_generator/gen_method_names'
-    
+
     # Generate parsing code for a parser model using a ruby generator +g+.
     #
     # @overload generate(g, grammar)
@@ -70,7 +73,7 @@ module Rattler::BackEnd
       RuleGenerator.new(g).generate(parser)
       nil
     end
-    
+
     # Generate parsing code for +parser+ using a new {RubyGenerator} with the
     # given options and return the generated code.
     #
@@ -93,6 +96,6 @@ module Rattler::BackEnd
     def self.code_for(parser, options={})
       ::Rattler::BackEnd::RubyGenerator.code(options) {|g| generate(g, parser) }
     end
-    
+
   end
 end

data/lib/rattler/grammar/grammar_parser.rb

@@ -9,44 +9,39 @@ require 'rattler/grammar'
 module Rattler::Grammar
   # @private
   class GrammarParser < Rattler::Runtime::ExtendedPackratParser #:nodoc:
-    
+
     include Metagrammar
     include Rattler::Parsers
-    
+
     def initialize(*args)
       super
       @ws = nil
       @wc = Match[/[[:alnum:]_]/]
       @directive_stack = []
-      
-      @ws_stack = []
-      @ws = nil
-      @wc_stack = []
-      @wc = Match[/[[:alnum:]_]/]
     end
-    
+
     private
-    
+
     def start_ws(e)
       @directive_stack.push(:type => :ws, :value => @ws)
       set_ws(e)
     end
-    
+
     def set_ws(e)
       @ws = e
       true
     end
-    
+
     def start_wc(e)
       @directive_stack.push(:type => :wc, :value => @wc)
       set_wc(e)
     end
-    
+
     def set_wc(e)
       @wc = e
       true
     end
-    
+
     def end_block
       if d = @directive_stack.pop
         case d[:type]
@@ -56,34 +51,34 @@ module Rattler::Grammar
         true
       end
     end
-    
+
     def heading(requires, modules, includes)
       requires.merge(modules.first || {}).merge(includes)
     end
-    
+
     def parser_decl(name, base)
       {:parser_name => name, :base_name => base.first}
     end
-    
+
     def rule(name, parser)
       Rule[name, (@ws ? parser.with_ws(@ws) : parser)]
     end
-    
+
     def literal(e)
       Match[Regexp.compile(Regexp.escape(eval(e, TOPLEVEL_BINDING)))]
     end
-    
+
     def word_literal(e)
       Token[Sequence[
         Match[Regexp.compile(Regexp.escape(eval("%q#{e}", TOPLEVEL_BINDING)))],
         Disallow[@wc]
       ]]
     end
-    
+
     def char_class(e)
       Match[Regexp.compile(e)]
     end
-    
+
     def posix_class(name)
       if name == 'WORD'
         Match[/[[:alnum:]_]/]
@@ -91,6 +86,6 @@ module Rattler::Grammar
         char_class("[[:#{name.downcase}:]]")
       end
     end
-    
+
   end
 end