rattler 0.3.0 → 0.4.0

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

@@ -8,30 +8,30 @@ module Rattler::BackEnd::ParserGenerator
     include TokenPropogating
     include SkipPropogating
 
-    def gen_basic_nested(action)
-      generate action.child, :direct_action_nested, action.bindable_code
+    def gen_basic_nested(action, scope={})
+      generate action.child, :direct_action_nested, action.bindable_code, scope
     end
 
-    def gen_basic_top_level(action)
-      generate action.child, :direct_action_top_level, action.bindable_code
+    def gen_basic_top_level(action, scope={})
+      generate action.child, :direct_action_top_level, action.bindable_code, scope
     end
 
-    def gen_dispatch_action_nested(inner, target, method_name)
-      atomic_block { gen_dispatch_action_top_level inner, target, method_name }
+    def gen_dispatch_action_nested(inner, code, scope={})
+      atomic_block { gen_dispatch_action_top_level inner, code, scope }
     end
 
-    def gen_dispatch_action_top_level(inner, target, method_name)
-      @g.surround("(#{result_name} = ", ')') { gen_basic_nested inner }
-      (@g << ' &&').newline << dispatch_action_result(target, method_name)
+    def gen_dispatch_action_top_level(inner, code, scope={})
+      @g.surround("(#{result_name} = ", ')') { gen_basic_nested inner, scope }
+      (@g << ' &&').newline << code.bind(scope, "[#{result_name}]")
     end
 
-    def gen_direct_action_nested(inner, code)
-      atomic_block { gen_direct_action_top_level inner, code }
+    def gen_direct_action_nested(inner, code, scope={})
+      atomic_block { gen_direct_action_top_level inner, code, scope }
     end
 
-    def gen_direct_action_top_level(inner, code)
-      @g.surround("(#{result_name} = ", ')') { gen_basic_nested inner }
-      (@g << ' &&').newline << direct_action_result(code)
+    def gen_direct_action_top_level(inner, code, scope={})
+      @g.surround("(#{result_name} = ", ')') { gen_basic_nested inner, scope }
+      (@g << ' &&').newline << '(' << code.bind(scope, [result_name]) << ')'
     end
 
   end

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

@@ -5,67 +5,66 @@ module Rattler::BackEnd::ParserGenerator
   # @private
   class DisallowGenerator < ExprGenerator #:nodoc:
 
-    def gen_basic(disallow)
-      generate disallow.child, :disallow
+    def gen_basic(disallow, scope={})
+      generate disallow.child, :disallow, scope
     end
 
-    def gen_assert(disallow)
+    def gen_assert(disallow, scope={})
       @g << 'false'
     end
 
-    def gen_disallow(disallow)
-      gen_basic disallow
+    def gen_disallow(disallow, scope={})
+      gen_basic disallow, scope
     end
 
-    def gen_skip_nested(disallow)
-      gen_basic_nested disallow
+    def gen_skip_nested(disallow, scope={})
+      gen_basic_nested disallow, scope
     end
 
-    def gen_skip_top_level(disallow)
-      gen_basic_top_level disallow
+    def gen_skip_top_level(disallow, scope={})
+      gen_basic_top_level disallow, scope
     end
 
-    def gen_dispatch_action_nested(disallow, target, method_name)
-      atomic_block { gen_dispatch_action_top_level disallow, target, method_name }
+    def gen_dispatch_action_nested(disallow, code, scope={})
+      atomic_block { gen_dispatch_action_top_level disallow, code, scope }
     end
 
-    def gen_dispatch_action_top_level(disallow, target, method_name)
-      gen_action disallow,
-        dispatch_action_result(target, method_name, :array_expr => '[]')
+    def gen_dispatch_action_top_level(disallow, code, scope={})
+      gen_action disallow, code.bind(scope, '[]'), scope
     end
 
-    def gen_direct_action_nested(disallow, code)
-      atomic_block { gen_direct_action_top_level disallow, code }
+    def gen_direct_action_nested(disallow, code, scope={})
+      atomic_block { gen_direct_action_top_level disallow, code, scope }
     end
 
-    def gen_direct_action_top_level(disallow, code)
-      gen_action disallow, direct_action_result(code)
+    def gen_direct_action_top_level(disallow, code, scope={})
+      gen_action disallow, "(#{code.bind scope, []})", scope
     end
 
-    def gen_token_nested(disallow)
-      atomic_block { gen_token_top_level disallow }
+    def gen_token_nested(disallow, scope={})
+      atomic_block { gen_token_top_level disallow, scope }
     end
 
-    def gen_token_top_level(disallow)
-      gen_action disallow, "''"
+    def gen_token_top_level(disallow, scope={})
+      gen_action disallow, "''", scope
     end
 
-    def gen_intermediate(disallow)
-      generate disallow.child, :intermediate_disallow
+    def gen_intermediate(disallow, scope={})
+      generate disallow.child, :intermediate_disallow, scope
     end
 
-    def gen_intermediate_disallow(disallow)
-      gen_intermediate disallow
+    def gen_intermediate_disallow(disallow, scope={})
+      gen_intermediate disallow, scope
     end
 
-    def gen_intermediate_skip(disallow)
-      gen_intermediate disallow
+    def gen_intermediate_skip(disallow, scope={})
+      gen_intermediate disallow, scope
     end
 
     private
 
-    def gen_action(disallow, result_code)
-      gen_intermediate disallow
+    def gen_action(disallow, result_code, scope={})
+      gen_intermediate disallow, scope
       (@g << ' &&').newline << result_code
     end
 

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

@@ -8,32 +8,30 @@ module Rattler::BackEnd::ParserGenerator
     include TokenPropogating
     include SkipPropogating
 
-    def gen_basic_nested(action)
-      generate action.child, :dispatch_action_nested,
-        action.target, action.method_name
+    def gen_basic_nested(action, scope={})
+      generate action.child, :dispatch_action_nested, action.bindable_code, scope
     end
 
-    def gen_basic_top_level(action)
-      generate action.child, :dispatch_action_top_level,
-        action.target, action.method_name
+    def gen_basic_top_level(action, scope={})
+      generate action.child, :dispatch_action_top_level, action.bindable_code, scope
     end
 
-    def gen_dispatch_action_nested(inner, target, method_name)
-      atomic_block { gen_dispatch_action_top_level inner, target, method_name }
+    def gen_dispatch_action_nested(inner, code, scope={})
+      atomic_block { gen_dispatch_action_top_level inner, code }
     end
 
-    def gen_dispatch_action_top_level(inner, target, method_name)
+    def gen_dispatch_action_top_level(inner, code, scope={})
       @g.surround("(#{result_name} = ", ')') { gen_basic_nested inner }
-      (@g << ' &&').newline << dispatch_action_result(target, method_name)
+      (@g << ' &&').newline << code.bind(scope, "[#{result_name}]")
     end
 
-    def gen_direct_action_nested(inner, code)
+    def gen_direct_action_nested(inner, code, scope={})
       atomic_block { gen_direct_action_top_level inner, code }
     end
 
-    def gen_direct_action_top_level(inner, code)
+    def gen_direct_action_top_level(inner, code, scope={})
       @g.surround("(#{result_name} = ", ')') { gen_basic_nested inner }
-      (@g << ' &&').newline << direct_action_result(code)
+      (@g << ' &&').newline << '(' << code.bind(scope, [result_name]) << ')'
     end
 
   end

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

@@ -4,7 +4,6 @@ module Rattler::BackEnd::ParserGenerator
 
   # @private
   class ExprGenerator #:nodoc:
-    # include GeneratorHelper
 
     include Rattler::Parsers
 
@@ -15,79 +14,79 @@ module Rattler::BackEnd::ParserGenerator
       @repeat_level = repeat_level
     end
 
-    def gen_basic_nested(parser)
-      gen_basic parser
+    def gen_basic_nested(parser, scope={})
+      gen_basic parser, scope
     end
 
-    def gen_basic_top_level(parser)
-      gen_basic parser
+    def gen_basic_top_level(parser, scope={})
+      gen_basic parser, scope
     end
 
-    def gen_assert_nested(parser)
-      gen_assert parser
+    def gen_assert_nested(parser, scope={})
+      gen_assert parser, scope
     end
 
-    def gen_assert_top_level(parser)
-      gen_assert parser
+    def gen_assert_top_level(parser, scope={})
+      gen_assert parser, scope
     end
 
-    def gen_disallow_nested(parser)
-      gen_disallow parser
+    def gen_disallow_nested(parser, scope={})
+      gen_disallow parser, scope
     end
 
-    def gen_disallow_top_level(parser)
-      gen_disallow parser
+    def gen_disallow_top_level(parser, scope={})
+      gen_disallow parser, scope
     end
 
-    def gen_dispatch_action_nested(parser, target, method_name)
-      gen_dispatch_action parser, target, method_name
+    def gen_dispatch_action_nested(parser, code, scope={})
+      gen_dispatch_action parser, code, scope
     end
 
-    def gen_dispatch_action_top_level(parser, target, method_name)
-      gen_dispatch_action parser, target, method_name
+    def gen_dispatch_action_top_level(parser, code, scope={})
+      gen_dispatch_action parser, code, scope
     end
 
-    def gen_direct_action_nested(parser, action)
-      gen_direct_action parser, action
+    def gen_direct_action_nested(parser, code, scope={})
+      gen_direct_action parser, code, scope
     end
 
-    def gen_direct_action_top_level(parser, action)
-      gen_direct_action parser, action
+    def gen_direct_action_top_level(parser, code, scope={})
+      gen_direct_action parser, code, scope
     end
 
-    def gen_token_nested(parser)
-      atomic_block { gen_token_top_level parser }
+    def gen_token_nested(parser, scope={})
+      atomic_block { gen_token_top_level parser, scope }
     end
 
-    def gen_token_top_level(parser)
+    def gen_token_top_level(parser, scope={})
       (@g << "tp = @scanner.pos").newline
-      gen_intermediate_skip parser
+      gen_intermediate_skip parser, scope
       (@g << ' &&').newline
       @g << "@scanner.string[tp...(@scanner.pos)]"
     end
 
-    def gen_skip_nested(parser)
-      gen_skip parser
+    def gen_skip_nested(parser, scope={})
+      gen_skip parser, scope
     end
 
-    def gen_skip_top_level(parser)
-      gen_skip parser
+    def gen_skip_top_level(parser, scope={})
+      gen_skip parser, scope
     end
 
-    def gen_intermediate(parser)
-      gen_basic_nested parser
+    def gen_intermediate(parser, scope={})
+      gen_basic_nested parser, scope
     end
 
-    def gen_intermediate_assert(parser)
-      gen_assert_nested parser
+    def gen_intermediate_assert(parser, scope={})
+      gen_assert_nested parser, scope
     end
 
-    def gen_intermediate_disallow(parser)
-      gen_disallow_nested parser
+    def gen_intermediate_disallow(parser, scope={})
+      gen_disallow_nested parser, scope
     end
 
-    def gen_intermediate_skip(parser)
-      gen_skip_nested parser
+    def gen_intermediate_skip(parser, scope={})
+      gen_skip_nested parser, scope
     end
 
     protected
@@ -110,25 +109,6 @@ module Rattler::BackEnd::ParserGenerator
       "p#{sequence_level}"
     end
 
-    def dispatch_action_result(target, method_name, options = {})
-      args = [options[:array_expr] || "[#{result_name}]"]
-      labeled = options[:labeled]
-      if labeled and not labeled.empty?
-        if labeled.respond_to?(:to_hash)
-          labeled = '{' + labeled.map {|k, v| ":#{k} => #{v}"}.join(', ') + '}'
-        end
-        args << ":labeled => #{labeled}"
-      end
-      t = target == 'self' ? '' : "#{target}."
-      "#{t}#{method_name}(#{args.join ', '})"
-    end
-
-    def direct_action_result(code, options = {})
-      args = options[:bind_args] || [result_name]
-      labeled = options[:labeled] || {}
-      "(#{code.bind args, labeled})"
-    end
-
     def lookahead
       (@g << "#{saved_pos_name} = @scanner.pos").newline
       yield

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

@@ -1,71 +1,71 @@
 require 'rattler/back_end/parser_generator'
 
 module Rattler::BackEnd::ParserGenerator
-  
+
   # @private
   class FailGenerator < ExprGenerator #:nodoc:
-    
-    def gen_basic_nested(fail)
+
+    def gen_basic_nested(fail, scope={})
       case fail.attrs[:type]
       when :expr  then gen_fail_expr_nested fail.message
       when :rule  then gen_fail_rule_nested fail.message
       when :parse then gen_fail_parse_nested fail.message
       end
     end
-    
-    def gen_basic_top_level(fail)
+
+    def gen_basic_top_level(fail, scope={})
       case fail.attrs[:type]
       when :expr  then gen_fail_expr_top_level fail.message
       when :rule  then gen_fail_rule_top_level fail.message
       when :parse then gen_fail_parse_top_level fail.message
       end
     end
-    
+
     private
-    
+
     def gen_fail_expr_nested(message)
       atomic_expr { gen_fail_expr_top_level message }
     end
-    
+
     def gen_fail_expr_top_level(message)
       @g << "fail! { #{message.inspect} }"
     end
-    
+
     def gen_fail_rule_nested(message)
       gen_fail_rule_top_level message
       @g.newline << 'false'
     end
-    
+
     def gen_fail_rule_top_level(message)
       @g << "return(fail! { #{message.inspect} })"
     end
-    
+
     def gen_fail_parse_nested(message)
       atomic_expr { gen_fail_parse_top_level message }
     end
-    
+
     def gen_fail_parse_top_level(message)
       @g << "fail_parse { #{message.inspect} }"
     end
-    
+
   end
-  
+
   # @private
   class NestedFailGenerator < FailGenerator #:nodoc:
     include Nested
   end
-  
+
   def FailGenerator.nested(*args)
     NestedFailGenerator.new(*args)
   end
-  
+
   # @private
   class TopLevelFailGenerator < FailGenerator #:nodoc:
     include TopLevel
   end
-  
+
   def FailGenerator.top_level(*args)
     TopLevelFailGenerator.new(*args)
   end
-  
+
 end

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

@@ -0,0 +1,18 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+  # @private
+  class GroupMatch < Rattler::Parsers::Parser #:nodoc:
+
+    alias_method :match, :child
+
+    def re
+      match.re
+    end
+
+    def capture_count
+      num_groups
+    end
+
+  end
+end

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

@@ -0,0 +1,76 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+
+  # @private
+  class GroupMatchGenerator < ExprGenerator #:nodoc:
+    include PredicatePropogating
+    include TokenPropogating
+    include SkipPropogating
+
+    def gen_basic_nested(group_match, scope={})
+      atomic_block { gen_basic_top_level group_match, scope }
+    end
+
+    def gen_basic_top_level(group_match, scope={})
+      gen_capture group_match, result_expr(group_match)
+    end
+
+    def gen_dispatch_action_nested(group_match, code, scope={})
+      atomic_block { gen_dispatch_action_top_level group_match, code, scope }
+    end
+
+    def gen_dispatch_action_top_level(group_match, code, scope={})
+      gen_capture group_match, code.bind(scope, "[#{group_exprs(group_match).join ', '}]")
+    end
+
+    def gen_direct_action_nested(group_match, code, scope={})
+      atomic_block { gen_direct_action_top_level group_match, code, scope }
+    end
+
+    def gen_direct_action_top_level(group_match, code, scope={})
+      gen_capture group_match, "(#{code.bind(scope, group_exprs(group_match))})"
+    end
+
+    private
+
+    def gen_capture(group_match, expr)
+      generate group_match.match, :intermediate_skip
+      (@g << ' &&').newline << expr
+    end
+
+    def result_expr(group_match)
+      if group_match.num_groups == 1
+        group_exprs(group_match).first
+      else
+        "[#{group_exprs(group_match).join ', '}]"
+      end
+    end
+
+    def group_exprs(group_match)
+      (1..(group_match.num_groups)).map {|n| "@scanner[#{n}]" }
+    end
+
+  end
+
+  # @private
+  class NestedGroupMatchGenerator < GroupMatchGenerator #:nodoc:
+    include Nested
+    include NestedSubGenerating
+  end
+
+  def GroupMatchGenerator.nested(*args)
+    NestedGroupMatchGenerator.new(*args)
+  end
+
+  # @private
+  class TopLevelGroupMatchGenerator < GroupMatchGenerator #:nodoc:
+    include TopLevel
+    include NestedSubGenerating
+  end
+
+  def GroupMatchGenerator.top_level(*args)
+    TopLevelGroupMatchGenerator.new(*args)
+  end
+
+end