rattler 0.3.0 → 0.4.0

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

@@ -8,16 +8,35 @@ module Rattler::BackEnd::ParserGenerator
     include TokenPropogating
     include SkipPropogating
 
-    def gen_basic(label)
-      generate label.child, :basic
+    def gen_basic(label, scope={})
+      generate label.child, :basic, scope
     end
 
-    def gen_dispatch_action(label, target, method_name)
-      generate label.child, :dispatch_action, target, method_name
+    def gen_dispatch_action(label, code, scope={})
+      generate label.child, :dispatch_action, code, scope
     end
 
-    def gen_direct_action(label, code)
-      generate label.child, :direct_action, code
+    def gen_direct_action_nested(label, code, scope={})
+      atomic_block { gen_direct_action_top_level label, code, scope }
+    end
+
+    def gen_direct_action_top_level(label, code, scope={})
+      scope = gen_capturing label.child, scope, label.label
+      (@g << ' &&').newline << '(' << code.bind(scope, [result_name]) << ')'
+    end
+
+    private
+
+    def gen_capturing(child, scope, label)
+      if child.capturing?
+        @g.surround("(#{result_name} = ", ')') do
+          generate child, :basic_nested, scope
+        end
+        scope.merge(label => result_name)
+      else
+        generate child, :intermediate, scope
+        scope
+      end
     end
 
   end

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

@@ -8,16 +8,16 @@ module Rattler::BackEnd::ParserGenerator
     include NestedSubGenerating
     include PredicatePropogating
 
-    def gen_skip_top_level(list)
+    def gen_skip_top_level(list, scope={})
       (@g << "#{result_name} = false").newline
       (@g << "#{saved_pos_name} = nil").newline
       @g << 'while '
-      generate list.child, :intermediate_skip
+      generate list.child, :intermediate_skip, scope
       @g.block '' do
         (@g << "#{result_name} = true").newline
         (@g << "#{saved_pos_name} = @scanner.pos").newline
         @g << 'break unless '
-        generate list.sep_parser, :intermediate_skip
+        generate list.sep_parser, :intermediate_skip, scope
       end.newline
       @g << "@scanner.pos = #{saved_pos_name} unless #{saved_pos_name}.nil?"
       @g.newline << result_name
@@ -44,12 +44,12 @@ module Rattler::BackEnd::ParserGenerator
   class TopLevelList1Generator < List1Generator #:nodoc:
     include TopLevel
 
-    def gen_assert(parser)
-      generate parser.child, :assert_top_level
+    def gen_assert(parser, scope = {})
+      generate parser.child, :assert_top_level, scope
     end
 
-    def gen_disallow(parser)
-      generate parser.child, :disallow_top_level
+    def gen_disallow(parser, scope = {})
+      generate parser.child, :disallow_top_level, scope
     end
 
   end

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

@@ -4,55 +4,54 @@ module Rattler::BackEnd::ParserGenerator
   # @private
   module ListGenerating #:nodoc:
 
-    def gen_basic_nested(list)
-      atomic_block { gen_basic_top_level list }
+    def gen_basic_nested(list, scope={})
+      atomic_block { gen_basic_top_level list, scope }
     end
 
-    def gen_basic_top_level(list)
-      list.capturing? ? gen_capturing(list) : gen_skip_top_level(list)
+    def gen_basic_top_level(list, scope={})
+      list.capturing? ? gen_capturing(list, scope) : gen_skip_top_level(list, scope)
     end
 
-    def gen_dispatch_action_nested(list, target, method_name)
+    def gen_dispatch_action_nested(list, code, scope={})
       atomic_block do
-        gen_dispatch_action_top_level list, target, method_name
+        gen_dispatch_action_top_level list, code, scope
       end
     end
 
-    def gen_dispatch_action_top_level(list, target, method_name)
-      gen_capturing list do |a|
-        dispatch_action_result target, method_name,
-            :array_expr => "select_captures(#{a})"
+    def gen_dispatch_action_top_level(list, code, scope={})
+      gen_capturing list, scope do |a|
+        code.bind scope, "select_captures(#{a})"
       end
     end
 
-    def gen_direct_action_nested(list, action)
+    def gen_direct_action_nested(list, code, scope={})
       atomic_block do
-        gen_direct_action_top_level list, action
+        gen_direct_action_top_level list, code, scope
       end
     end
 
-    def gen_direct_action_top_level(list, action)
-      gen_capturing list do |a|
-        direct_action_result action, :bind_args => ["select_captures(#{a})"]
+    def gen_direct_action_top_level(list, code, scope={})
+      gen_capturing list, scope do |a|
+        '(' + code.bind(scope, ["select_captures(#{a})"]) + ')'
       end
     end
 
-    def gen_skip_nested(list)
-      atomic_block { gen_skip_top_level list }
+    def gen_skip_nested(list, scope={})
+      atomic_block { gen_skip_top_level list, scope }
     end
 
     protected
 
-    def gen_capturing(list)
+    def gen_capturing(list, scope={})
       (@g << "#{accumulator_name} = []").newline
       (@g << "#{saved_pos_name} = nil").newline
       @g << "while #{result_name} = "
-      generate list.child, :basic
+      generate list.child, :basic, scope
       @g.block '' do
         (@g << "#{saved_pos_name} = @scanner.pos").newline
         (@g << "#{accumulator_name} << #{result_name}").newline
         @g << 'break unless '
-        generate list.sep_parser, :intermediate_skip
+        generate list.sep_parser, :intermediate_skip, scope
       end.newline
       @g << "@scanner.pos = #{saved_pos_name} unless #{saved_pos_name}.nil?"
       @g.newline

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

@@ -7,22 +7,22 @@ module Rattler::BackEnd::ParserGenerator
     include ListGenerating
     include NestedSubGenerating
 
-    def gen_assert(optional)
+    def gen_assert(optional, scope={})
       @g << 'true'
     end
 
-    def gen_disallow(optional)
+    def gen_disallow(optional, scope={})
       @g << 'false'
     end
 
-    def gen_skip_top_level(list)
+    def gen_skip_top_level(list, scope={})
       (@g << "#{saved_pos_name} = nil").newline
       @g << 'while '
-      generate list.child, :intermediate_skip
+      generate list.child, :intermediate_skip, scope
       @g.block '' do
         (@g << "#{saved_pos_name} = @scanner.pos").newline
         @g << 'break unless '
-        generate list.sep_parser, :intermediate_skip
+        generate list.sep_parser, :intermediate_skip, scope
       end.newline
       @g << "@scanner.pos = #{saved_pos_name} unless #{saved_pos_name}.nil?"
       @g.newline << true

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

@@ -1,93 +1,93 @@
 require 'rattler/back_end/parser_generator'
 
 module Rattler::BackEnd::ParserGenerator
-  
+
   # @private
   class MatchGenerator < ExprGenerator #:nodoc:
-    
-    def gen_basic(match)
+
+    def gen_basic(match, scope={})
       @g << "@scanner.scan(#{match.re.inspect})"
     end
-    
-    def gen_assert_nested(match)
-      atomic_expr { gen_assert_top_level match }
+
+    def gen_assert_nested(match, scope={})
+      atomic_expr { gen_assert_top_level match, scope }
     end
-    
-    def gen_assert_top_level(match)
-      gen_intermediate_assert match
+
+    def gen_assert_top_level(match, scope={})
+      gen_intermediate_assert match, scope
       @g << ' && true'
     end
-    
-    def gen_disallow_nested(match)
-      atomic_expr { gen_disallow_top_level match }
+
+    def gen_disallow_nested(match, scope={})
+      atomic_expr { gen_disallow_top_level match, scope }
     end
-    
-    def gen_disallow_top_level(match)
-      gen_intermediate_disallow match
+
+    def gen_disallow_top_level(match, scope={})
+      gen_intermediate_disallow match, scope
       @g << ' && true'
     end
-    
-    def gen_dispatch_action_nested(match, target, method_name)
-      atomic_block { gen_dispatch_action_top_level match, target, method_name }
+
+    def gen_dispatch_action_nested(match, code, scope={})
+      atomic_block { gen_dispatch_action_top_level match, code, scope }
     end
-    
-    def gen_dispatch_action_top_level(match, target, method_name)
-      @g.surround("(#{result_name} = ", ')') { gen_basic match }
-      (@g << ' &&').newline << dispatch_action_result(target, method_name)
+
+    def gen_dispatch_action_top_level(match, code, scope={})
+      @g.surround("(#{result_name} = ", ')') { gen_basic match, scope }
+      (@g << ' &&').newline << code.bind(scope, "[#{result_name}]")
     end
-    
-    def gen_direct_action_nested(match, code)
-      atomic_block { gen_direct_action_top_level match, code }
+
+    def gen_direct_action_nested(match, code, scope={})
+      atomic_block { gen_direct_action_top_level match, code, scope }
     end
-    
-    def gen_direct_action_top_level(match, code)
-      @g.surround("(#{result_name} = ", ')') { gen_basic match }
-      (@g << ' &&').newline << direct_action_result(code)
+
+    def gen_direct_action_top_level(match, code, scope={})
+      @g.surround("(#{result_name} = ", ')') { gen_basic match, scope }
+      (@g << ' &&').newline << '(' << code.bind(scope, [result_name]) << ')'
     end
-    
-    def gen_token(match)
-      gen_basic match
+
+    def gen_token(match, scope={})
+      gen_basic match, scope
     end
-    
-    def gen_skip_nested(match)
-      atomic_expr { gen_skip_top_level match }
+
+    def gen_skip_nested(match, scope={})
+      atomic_expr { gen_skip_top_level match, scope }
     end
-    
-    def gen_skip_top_level(match)
-      gen_intermediate_skip match
+
+    def gen_skip_top_level(match, scope={})
+      gen_intermediate_skip match, scope
       @g << ' && true'
     end
-    
-    def gen_intermediate_assert(match)
-      @g << "@scanner.skip(#{match.assert_re.inspect})"
+
+    def gen_intermediate_assert(match, scope={})
+      @g << "@scanner.skip(#{/(?=#{match.re.source})/.inspect})"
     end
-    
-    def gen_intermediate_disallow(match)
-      @g << "@scanner.skip(#{match.disallow_re.inspect})"
+
+    def gen_intermediate_disallow(match, scope={})
+      @g << "@scanner.skip(#{/(?!#{match.re.source})/.inspect})"
     end
-    
-    def gen_intermediate_skip(match)
+
+    def gen_intermediate_skip(match, scope={})
       @g << "@scanner.skip(#{match.re.inspect})"
     end
-    
+
   end
-  
+
   # @private
   class NestedMatchGenerator < MatchGenerator #:nodoc:
     include Nested
   end
-  
+
   def MatchGenerator.nested(*args)
     NestedMatchGenerator.new(*args)
   end
-  
+
   # @private
   class TopLevelMatchGenerator < MatchGenerator #:nodoc:
     include TopLevel
   end
-  
+
   def MatchGenerator.top_level(*args)
     TopLevelMatchGenerator.new(*args)
   end
-  
+
 end

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

@@ -8,10 +8,10 @@ module Rattler::BackEnd::ParserGenerator
     include NestedSubGenerating
     include PredicatePropogating
 
-    def gen_skip_top_level(one_or_more)
+    def gen_skip_top_level(one_or_more, scope={})
       (@g << "#{result_name} = false").newline
       @g << 'while '
-      generate one_or_more.child, :intermediate_skip
+      generate one_or_more.child, :intermediate_skip, scope
       @g.block('') { @g << "#{result_name} = true" }.newline
       @g << result_name
     end
@@ -37,12 +37,12 @@ module Rattler::BackEnd::ParserGenerator
   class TopLevelOneOrMoreGenerator < OneOrMoreGenerator #:nodoc:
     include TopLevel
 
-    def gen_assert(parser)
-      generate parser.child, :assert_top_level
+    def gen_assert(parser, scope = {})
+      generate parser.child, :assert_top_level, scope
     end
 
-    def gen_disallow(parser)
-      generate parser.child, :disallow_top_level
+    def gen_disallow(parser, scope = {})
+      generate parser.child, :disallow_top_level, scope
     end
 
   end

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

@@ -6,74 +6,75 @@ module Rattler::BackEnd::ParserGenerator
   class OptionalGenerator < ExprGenerator #:nodoc:
     include NestedSubGenerating
 
-    def gen_basic_nested(optional)
-      atomic_expr { gen_basic_top_level optional }
+    def gen_basic_nested(optional, scope={})
+      atomic_expr { gen_basic_top_level optional, scope }
     end
 
-    def gen_basic_top_level(optional)
+    def gen_basic_top_level(optional, scope={})
       if optional.capturing?
-        @g.surround("(#{result_name} = ", ')') { generate optional.child }
+        @g.surround("(#{result_name} = ", ')') do
+          generate optional.child, :basic, scope
+        end
         @g << " ? [#{result_name}] : []"
       else
-        gen_skip_top_level optional
+        gen_skip_top_level optional, scope
       end
     end
 
-    def gen_assert(optional)
+    def gen_assert(optional, scope={})
       @g << 'true'
     end
 
-    def gen_disallow(optional)
+    def gen_disallow(optional, scope={})
       @g << 'false'
     end
 
-    def gen_dispatch_action_nested(optional, target, method_name)
-      atomic_block { gen_dispatch_action_top_level optional, target, method_name }
+    def gen_dispatch_action_nested(optional, code, scope={})
+      atomic_block { gen_dispatch_action_top_level optional, code, scope }
     end
 
-    def gen_dispatch_action_top_level(optional, target, method_name)
+    def gen_dispatch_action_top_level(optional, code, scope={})
       @g << "#{result_name} = "
-      generate optional.child
-      @g.newline << dispatch_action_result(target, method_name,
-          :array_expr => "#{result_name} ? [#{result_name}] : []")
+      generate optional.child, :basic, scope
+      @g.newline << code.bind(scope, "#{result_name} ? [#{result_name}] : []")
     end
 
-    def gen_direct_action_nested(optional, action)
-      atomic_block { gen_direct_action_top_level optional, action }
+    def gen_direct_action_nested(optional, code, scope={})
+      atomic_block { gen_direct_action_top_level optional, code, scope }
     end
 
-    def gen_direct_action_top_level(optional, action)
+    def gen_direct_action_top_level(optional, code, scope={})
       @g << "#{result_name} = "
-      generate optional.child
-      @g.newline << direct_action_result(action,
-          :bind_args => ["(#{result_name} ? [#{result_name}] : [])"])
+      generate optional.child, :basic, scope
+      @g.newline <<
+        '(' << code.bind(scope, ["(#{result_name} ? [#{result_name}] : [])"]) << ')'
     end
 
-    def gen_token_nested(optional)
-      atomic_block { gen_token_top_level optional }
+    def gen_token_nested(optional, scope={})
+      atomic_block { gen_token_top_level optional, scope }
     end
 
-    def gen_token_top_level(optional)
-      generate optional.child, :token
+    def gen_token_top_level(optional, scope={})
+      generate optional.child, :token, scope
       @g << " || ''"
     end
 
-    def gen_skip_nested(optional)
-      atomic_block { gen_skip_top_level optional }
+    def gen_skip_nested(optional, scope={})
+      atomic_block { gen_skip_top_level optional, scope }
     end
 
-    def gen_skip_top_level(optional)
-      generate optional.child, :intermediate_skip
+    def gen_skip_top_level(optional, scope={})
+      generate optional.child, :intermediate_skip, scope
       @g.newline << 'true'
     end
 
     private
 
-    def gen_capturing(optional)
+    def gen_capturing(optional, scope={})
       if optional.capturing?
         yield
       else
-        gen_skip_top_level optional
+        gen_skip_top_level optional, scope
       end
     end