rattler 0.2.2 → 0.3.0

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

@@ -1,20 +1,21 @@
 require 'rattler/back_end/parser_generator'
 
 module Rattler::BackEnd::ParserGenerator
-  
+
   # @private
   class OneOrMoreGenerator < ExprGenerator #:nodoc:
     include RepeatGenerating
+    include NestedSubGenerating
     include PredicatePropogating
-    
+
     def gen_skip_top_level(one_or_more)
       (@g << "#{result_name} = false").newline
       @g << 'while '
-      generate one_or_more.child, :gen_intermediate_skip
+      generate one_or_more.child, :intermediate_skip
       @g.block('') { @g << "#{result_name} = true" }.newline
       @g << result_name
     end
-    
+
     protected
 
     def gen_result(captures)
@@ -22,34 +23,32 @@ module Rattler::BackEnd::ParserGenerator
     end
 
   end
-  
+
   # @private
   class NestedOneOrMoreGenerator < OneOrMoreGenerator #:nodoc:
     include Nested
-    include NestedGenerators
   end
-  
+
   def OneOrMoreGenerator.nested(*args)
     NestedOneOrMoreGenerator.new(*args)
   end
-  
+
   # @private
   class TopLevelOneOrMoreGenerator < OneOrMoreGenerator #:nodoc:
     include TopLevel
-    include NestedGenerators
 
     def gen_assert(parser)
-      generate parser.child, :gen_assert_top_level
+      generate parser.child, :assert_top_level
     end
-    
+
     def gen_disallow(parser)
-      generate parser.child, :gen_disallow_top_level
+      generate parser.child, :disallow_top_level
     end
-    
+
   end
-  
+
   def OneOrMoreGenerator.top_level(*args)
     TopLevelOneOrMoreGenerator.new(*args)
   end
-  
+
 end

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

@@ -1,15 +1,15 @@
 require 'rattler/back_end/parser_generator'
 
 module Rattler::BackEnd::ParserGenerator
-  
+
   # @private
   class OptionalGenerator < ExprGenerator #:nodoc:
-    include NestedGenerators
-    
+    include NestedSubGenerating
+
     def gen_basic_nested(optional)
       atomic_expr { gen_basic_top_level optional }
     end
-    
+
     def gen_basic_top_level(optional)
       if optional.capturing?
         @g.surround("(#{result_name} = ", ')') { generate optional.child }
@@ -18,57 +18,57 @@ module Rattler::BackEnd::ParserGenerator
         gen_skip_top_level optional
       end
     end
-    
+
     def gen_assert(optional)
       @g << 'true'
     end
-    
+
     def gen_disallow(optional)
       @g << 'false'
     end
-    
+
     def gen_dispatch_action_nested(optional, target, method_name)
       atomic_block { gen_dispatch_action_top_level optional, target, method_name }
     end
-    
+
     def gen_dispatch_action_top_level(optional, target, method_name)
       @g << "#{result_name} = "
       generate optional.child
       @g.newline << dispatch_action_result(target, method_name,
           :array_expr => "#{result_name} ? [#{result_name}] : []")
     end
-    
+
     def gen_direct_action_nested(optional, action)
       atomic_block { gen_direct_action_top_level optional, action }
     end
-    
+
     def gen_direct_action_top_level(optional, action)
       @g << "#{result_name} = "
       generate optional.child
       @g.newline << direct_action_result(action,
           :bind_args => ["(#{result_name} ? [#{result_name}] : [])"])
     end
-    
+
     def gen_token_nested(optional)
       atomic_block { gen_token_top_level optional }
     end
-    
+
     def gen_token_top_level(optional)
-      generate optional.child, :gen_token
+      generate optional.child, :token
       @g << " || ''"
     end
-    
+
     def gen_skip_nested(optional)
       atomic_block { gen_skip_top_level optional }
     end
-    
+
     def gen_skip_top_level(optional)
-      generate optional.child, :gen_intermediate_skip
+      generate optional.child, :intermediate_skip
       @g.newline << 'true'
     end
-    
+
     private
-    
+
     def gen_capturing(optional)
       if optional.capturing?
         yield
@@ -76,25 +76,25 @@ module Rattler::BackEnd::ParserGenerator
         gen_skip_top_level optional
       end
     end
-    
+
   end
-  
+
   # @private
   class NestedOptionalGenerator < OptionalGenerator #:nodoc:
     include Nested
   end
-  
+
   def OptionalGenerator.nested(*args)
     NestedOptionalGenerator.new(*args)
   end
-  
+
   # @private
   class TopLevelOptionalGenerator < OptionalGenerator #:nodoc:
     include TopLevel
   end
-  
+
   def OptionalGenerator.top_level(*args)
     TopLevelOptionalGenerator.new(*args)
   end
-  
+
 end

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

@@ -3,22 +3,22 @@ require 'rattler/back_end/parser_generator'
 module Rattler::BackEnd::ParserGenerator
   # @private
   module PredicatePropogating #:nodoc:
-    
+
     def gen_assert(parser)
-      generate parser.child, :gen_assert
+      generate parser.child, :assert
     end
-    
+
     def gen_disallow(parser)
-      generate parser.child, :gen_disallow
+      generate parser.child, :disallow
     end
-    
+
     def gen_intermediate_assert(parser)
-      generate parser.child, :gen_intermediate_assert
+      generate parser.child, :intermediate_assert
     end
-    
+
     def gen_intermediate_disallow(parser)
-      generate parser.child, :gen_intermediate_disallow
+      generate parser.child, :intermediate_disallow
     end
-    
+
   end
 end

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

@@ -7,63 +7,63 @@ module Rattler::BackEnd::ParserGenerator
     def gen_basic_nested(repeat)
       atomic_block { gen_basic_top_level repeat }
     end
-    
+
     def gen_basic_top_level(repeat)
       if repeat.capturing?
-        gen_loop repeat, :gen_basic_nested
+        gen_loop repeat, :basic_nested
         gen_result accumulator_name
       else
         gen_skip_top_level repeat
       end
     end
-    
+
     def gen_dispatch_action_nested(repeat, target, method_name)
       atomic_block do
         gen_dispatch_action_top_level repeat, target, method_name
       end
     end
-    
+
     def gen_dispatch_action_top_level(repeat, target, method_name)
       gen_loop repeat
       gen_result dispatch_action_result(target, method_name,
           :array_expr => "select_captures(#{accumulator_name})")
     end
-    
+
     def gen_direct_action_nested(repeat, action)
       atomic_block { gen_direct_action_top_level repeat, action }
     end
-    
+
     def gen_direct_action_top_level(repeat, action)
       gen_loop repeat
       gen_result direct_action_result(action,
           :bind_args => ["select_captures(#{accumulator_name})"])
     end
-    
+
     def gen_token_nested(repeat)
       atomic_block { gen_token_top_level repeat }
     end
-    
+
     def gen_token_top_level(repeat)
-      gen_loop repeat, :gen_token
+      gen_loop repeat, :token
       gen_result "#{accumulator_name}.join"
     end
-    
+
     def gen_skip_nested(repeat)
       atomic_block { gen_skip_top_level repeat }
     end
-    
+
     private
-    
-    def gen_loop(repeat, gen_method = :gen_basic)
+
+    def gen_loop(repeat, child_as = :basic)
       (@g << "#{accumulator_name} = []").newline
       @g << "while #{result_name} = "
-      generate repeat.child, gen_method
+      generate repeat.child, child_as
       @g.block('') { @g << "#{accumulator_name} << #{result_name}" }.newline
     end
-    
+
     def accumulator_name
       "a#{repeat_level}"
     end
-    
+
   end
 end

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

@@ -1,22 +1,22 @@
 require 'rattler/back_end/parser_generator'
 
 module Rattler::BackEnd::ParserGenerator
-  
+
   # @private
   class SequenceGenerator < ExprGenerator #:nodoc:
-    include NestedGenerators
-    
+    include NestedSubGenerating
+
     include Rattler::Parsers
-    
+
     def initialize(*args)
       super
       @capture_names = []
     end
-    
+
     def gen_basic_nested(sequence)
       atomic_block { gen_basic_top_level sequence }
     end
-    
+
     def gen_basic_top_level(sequence)
       with_backtracking do
         if sequence.capture_count == 1 and sequence.children.last.capturing?
@@ -29,16 +29,16 @@ module Rattler::BackEnd::ParserGenerator
         end
       end
     end
-    
+
     def gen_assert_nested(sequence)
       atomic_block { gen_assert_top_level sequence }
     end
-    
+
     def gen_assert_top_level(sequence)
       lookahead do
         @g.block("#{result_name} = begin") do
           sequence.each do |_|
-            @g.suffix(' &&') { generate _, :gen_intermediate_skip }.newline
+            @g.suffix(' &&') { generate _, :intermediate_skip }.newline
           end
           @g << "true"
         end
@@ -46,75 +46,75 @@ module Rattler::BackEnd::ParserGenerator
       end
       @g << result_name
     end
-    
+
     def gen_disallow_nested(sequence)
       atomic_block { gen_disallow_top_level sequence }
     end
-    
+
     def gen_disallow_top_level(sequence)
       lookahead do
         @g.block("#{result_name} = !begin") do
           @g.intersperse_nl(sequence, ' &&') do |_|
-            generate _, :gen_intermediate_skip
+            generate _, :intermediate_skip
           end
         end
         @g.newline
       end
       @g << result_name
     end
-    
+
     def gen_dispatch_action_nested(sequence, target, method_name)
       atomic_block do
         gen_dispatch_action_top_level sequence, target, method_name
       end
     end
-    
+
     def gen_dispatch_action_top_level(sequence, target, method_name)
       gen_action_code(sequence) do |labeled|
         dispatch_action_result(target, method_name,
           :array_expr => result_array_expr(sequence), :labeled => labeled)
       end
     end
-    
+
     def gen_direct_action_nested(sequence, action)
       atomic_block { gen_direct_action_top_level sequence, action }
     end
-    
+
     def gen_direct_action_top_level(sequence, action)
       gen_action_code(sequence) do |labeled|
         direct_action_result(action,
           :bind_args => @capture_names, :labeled => labeled)
       end
     end
-    
+
     def gen_token_nested(sequence)
       atomic_block { gen_token_top_level sequence }
     end
-    
+
     def gen_token_top_level(sequence)
       with_backtracking do
         sequence.each do |_|
-          @g.suffix(' &&') { generate _, :gen_intermediate_skip }.newline
+          @g.suffix(' &&') { generate _, :intermediate_skip }.newline
         end
         @g << "@scanner.string[#{saved_pos_name}...(@scanner.pos)]"
       end
     end
-    
+
     def gen_skip_nested(sequence)
       atomic_block { gen_skip_top_level sequence }
     end
-    
+
     def gen_skip_top_level(sequence)
       with_backtracking do
         sequence.each do |_|
-          @g.suffix(' &&') { generate _, :gen_intermediate_skip }.newline
+          @g.suffix(' &&') { generate _, :intermediate_skip }.newline
         end
         @g << "true"
       end
     end
-    
+
     private
-    
+
     def gen_capturing(child)
       if child.capturing?
         if block_given?
@@ -123,10 +123,10 @@ module Rattler::BackEnd::ParserGenerator
           @g.surround("(#{capture_name} = ", ')') { generate child }
         end
       else
-        generate child, :gen_intermediate
+        generate child, :intermediate
       end
     end
-    
+
     def with_backtracking
       (@g << "#{saved_pos_name} = @scanner.pos").newline
       @g.block 'begin' do
@@ -136,7 +136,7 @@ module Rattler::BackEnd::ParserGenerator
         (@g << "@scanner.pos = #{saved_pos_name}").newline << 'false'
       end
     end
-    
+
     def result_expr(sequence)
       case @capture_names.size
       when 0 then 'true'
@@ -144,7 +144,7 @@ module Rattler::BackEnd::ParserGenerator
       else result_array_expr(sequence)
       end
     end
-    
+
     def result_array_expr(sequence)
       if sequence.any? {|_| Apply === _ }
         "select_captures(#{capture_names_expr})"
@@ -152,7 +152,7 @@ module Rattler::BackEnd::ParserGenerator
         capture_names_expr
       end
     end
-    
+
     def gen_action_code(sequence)
       with_backtracking do
         labeled = {}
@@ -163,44 +163,44 @@ module Rattler::BackEnd::ParserGenerator
         @g << yield(labeled)
       end
     end
-    
+
     def capture_names_expr
       '[' + @capture_names.join(', ') + ']'
     end
-    
+
     def capture_name
       @capture_names << "r#{sequence_level}_#{@capture_names.size}"
       @capture_names.last
     end
-    
+
     def last_capture_name
       @capture_names.last
     end
-    
+
     attr_reader :capture_names
-    
+
     def saved_pos_name
       "p#{sequence_level}"
     end
-    
+
   end
-  
+
   # @private
   class NestedSequenceGenerator < SequenceGenerator #:nodoc:
     include Nested
   end
-  
+
   def SequenceGenerator.nested(*args)
     NestedSequenceGenerator.new(*args)
   end
-  
+
   # @private
   class TopLevelSequenceGenerator < SequenceGenerator #:nodoc:
     include TopLevel
   end
-  
+
   def SequenceGenerator.top_level(*args)
     TopLevelSequenceGenerator.new(*args)
   end
-  
+
 end

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

@@ -1,65 +1,65 @@
 require 'rattler/back_end/parser_generator'
 
 module Rattler::BackEnd::ParserGenerator
-  
+
   # @private
   class SkipGenerator < ExprGenerator #:nodoc:
     include PredicatePropogating
     include TokenPropogating
     include SkipPropogating
-    
+
     def gen_basic(skip)
-      generate skip.child, :gen_skip
+      generate skip.child, :skip
     end
-    
+
     def gen_dispatch_action_nested(skip, target, method_name)
       atomic_block { gen_dispatch_action_top_level skip, target, method_name }
     end
-    
+
     def gen_dispatch_action_top_level(skip, target, method_name)
       gen_intermediate_skip skip
       (@g << ' &&').newline
       @g << dispatch_action_result(target, method_name, :array_expr => '[]')
     end
-    
+
     def gen_direct_action_nested(skip, action)
       atomic_block { gen_direct_action_top_level skip, action }
     end
-    
+
     def gen_direct_action_top_level(skip, action)
       gen_intermediate_skip skip
       (@g << ' &&').newline
       @g << direct_action_result(action, :bind_args => [])
     end
-    
+
     def gen_intermediate(skip)
-      generate skip.child, :gen_intermediate_skip
+      generate skip.child, :intermediate_skip
     end
-    
+
     def gen_intermediate_skip(skip)
       gen_intermediate skip
     end
-    
+
   end
-  
+
   # @private
   class NestedSkipGenerator < SkipGenerator #:nodoc:
     include Nested
-    include NestedGenerators
+    include NestedSubGenerating
   end
-  
+
   def SkipGenerator.nested(*args)
     NestedSkipGenerator.new(*args)
   end
-  
+
   # @private
   class TopLevelSkipGenerator < SkipGenerator #:nodoc:
     include TopLevel
-    include TopLevelGenerators
+    include TopLevelSubGenerating
   end
-  
+
   def SkipGenerator.top_level(*args)
     TopLevelSkipGenerator.new(*args)
   end
-  
+
 end

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

@@ -3,14 +3,14 @@ require 'rattler/back_end/parser_generator'
 module Rattler::BackEnd::ParserGenerator
   # @private
   module SkipPropogating #:nodoc:
-    
+
     def gen_skip(parser)
-      generate parser.child, :gen_skip
+      generate parser.child, :skip
     end
-    
+
     def gen_intermediate_skip(parser)
-      generate parser.child, :gen_intermediate_skip
+      generate parser.child, :intermediate_skip
     end
-    
+
   end
 end