rattler 0.3.0 → 0.4.0

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

@@ -4,20 +4,20 @@ module Rattler::BackEnd::ParserGenerator
   # @private
   module PredicatePropogating #:nodoc:
 
-    def gen_assert(parser)
-      generate parser.child, :assert
+    def gen_assert(parser, scope={})
+      generate parser.child, :assert, scope
     end
 
-    def gen_disallow(parser)
-      generate parser.child, :disallow
+    def gen_disallow(parser, scope={})
+      generate parser.child, :disallow, scope
     end
 
-    def gen_intermediate_assert(parser)
-      generate parser.child, :intermediate_assert
+    def gen_intermediate_assert(parser, scope={})
+      generate parser.child, :intermediate_assert, scope
     end
 
-    def gen_intermediate_disallow(parser)
-      generate parser.child, :intermediate_disallow
+    def gen_intermediate_disallow(parser, scope={})
+      generate parser.child, :intermediate_disallow, scope
     end
 
   end

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

@@ -4,60 +4,58 @@ module Rattler::BackEnd::ParserGenerator
   # @private
   module RepeatGenerating #:nodoc:
 
-    def gen_basic_nested(repeat)
-      atomic_block { gen_basic_top_level repeat }
+    def gen_basic_nested(repeat, scope={})
+      atomic_block { gen_basic_top_level repeat, scope }
     end
 
-    def gen_basic_top_level(repeat)
+    def gen_basic_top_level(repeat, scope={})
       if repeat.capturing?
-        gen_loop repeat, :basic_nested
+        gen_loop repeat, :basic_nested, scope
         gen_result accumulator_name
       else
-        gen_skip_top_level repeat
+        gen_skip_top_level repeat, scope
       end
     end
 
-    def gen_dispatch_action_nested(repeat, target, method_name)
+    def gen_dispatch_action_nested(repeat, code, scope={})
       atomic_block do
-        gen_dispatch_action_top_level repeat, target, method_name
+        gen_dispatch_action_top_level repeat, code, scope
       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})")
+    def gen_dispatch_action_top_level(repeat, code, scope={})
+      gen_loop repeat, :basic, scope
+      gen_result code.bind(scope, "select_captures(#{accumulator_name})")
     end
 
-    def gen_direct_action_nested(repeat, action)
-      atomic_block { gen_direct_action_top_level repeat, action }
+    def gen_direct_action_nested(repeat, code, scope={})
+      atomic_block { gen_direct_action_top_level repeat, code, scope }
     end
 
-    def gen_direct_action_top_level(repeat, action)
-      gen_loop repeat
-      gen_result direct_action_result(action,
-          :bind_args => ["select_captures(#{accumulator_name})"])
+    def gen_direct_action_top_level(repeat, code, scope={})
+      gen_loop repeat, :basic, scope
+      gen_result('(' + code.bind(scope, ["select_captures(#{accumulator_name})"]) + ')')
     end
 
-    def gen_token_nested(repeat)
-      atomic_block { gen_token_top_level repeat }
+    def gen_token_nested(repeat, scope={})
+      atomic_block { gen_token_top_level repeat, scope }
     end
 
-    def gen_token_top_level(repeat)
-      gen_loop repeat, :token
+    def gen_token_top_level(repeat, scope={})
+      gen_loop repeat, :token, scope
       gen_result "#{accumulator_name}.join"
     end
 
-    def gen_skip_nested(repeat)
-      atomic_block { gen_skip_top_level repeat }
+    def gen_skip_nested(repeat, scope={})
+      atomic_block { gen_skip_top_level repeat, scope }
     end
 
     private
 
-    def gen_loop(repeat, child_as = :basic)
+    def gen_loop(repeat, child_as = :basic, scope={})
       (@g << "#{accumulator_name} = []").newline
       @g << "while #{result_name} = "
-      generate repeat.child, child_as
+      generate repeat.child, child_as, scope
       @g.block('') { @g << "#{accumulator_name} << #{result_name}" }.newline
     end
 

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

@@ -3,103 +3,51 @@ require 'rattler/back_end/parser_generator'
 module Rattler::BackEnd::ParserGenerator
   # @private
   class RuleGenerator #:nodoc:
-    
+
     Grammar = Rattler::Grammar::Grammar
     include Rattler::Parsers
-    
+
     def initialize(g)
       @g = g
       @top_level_generator = TopLevelGenerator.new(@g)
     end
-    
-    def generate(parser)
+
+    def generate(parser, opts={})
       case parser
-      when Grammar  then gen_parser parser
-      when Rules    then gen_rules parser
-      when Rule     then gen_rule parser
+      when Rule then gen_rule_modular parser
       else @top_level_generator.generate parser
       end
       self
     end
-    
-    private
-    
-    def gen_parser(grammar)
-      gen_requires grammar.requires
-      gen_module(grammar) do
-        gen_includes grammar.includes
-        generate grammar.rules
-      end
-    end
-    
-    def gen_requires(requires)
-      requires.each {|_| (@g << "require #{_}").newline }
-      @g.newline
-    end
-    
-    def gen_module(grammar)
-      if grammar.grammar_name
-        gen_grammar_def(grammar.grammar_name) { yield }
-      elsif grammar.parser_name
-        gen_parser_def(grammar.parser_name, grammar.base_name) { yield }
+
+    def gen_rule_standalone(rule, rule_set)
+      if rule_set.analysis.left_recursive? rule.name
+        gen_rule_hook rule, 'memoize_lr'
+      elsif rule_set.analysis.recursive? rule.name
+        gen_rule_hook rule, 'memoize'
       else
-        yield
-      end
-    end
-    
-    def gen_includes(includes)
-      unless includes.empty?
-        includes.each {|_| (@g << "include #{_}").newline }
-        @g.newline
+        gen_rule_method rule, "match_#{rule.name}"
       end
     end
-    
-    def gen_rules(rules)
-      gen_start_rule rules.start_rule if rules.start_rule
-      @g.intersperse(rules, :newlines => 2) {|_| generate _ }
+
+    def gen_rule_modular(rule)
+      gen_rule_hook rule, 'apply'
     end
-    
-    def gen_start_rule(start_rule)
+
+    private
+
+    def gen_rule_hook(rule, hook_name)
       (@g << "# @private").newline
-      @g.block('def start_rule #:nodoc:') { @g << ":#{start_rule}"}.newline
-      @g.newline
+      @g.block("def match_#{rule.name} #:nodoc:") do
+        @g << "#{hook_name} :match_#{rule.name}!"
+      end.newline.newline
+      gen_rule_method rule, "match_#{rule.name}!"
     end
-    
-    def gen_rule(rule)
+
+    def gen_rule_method(rule, method_name)
       (@g << "# @private").newline
-      @g.block("def match_#{rule.name} #:nodoc:") { generate rule.child }
-    end
-    
-    def gen_grammar_def(grammar_name)
-      nest_modules(grammar_name.split('::')) do |name|
-        (@g << "# @private").newline
-        module_block("module #{name} #:nodoc:") { yield }
-      end
-    end
-    
-    def gen_parser_def(parser_name, base_name)
-      nest_modules(parser_name.split('::')) do |name|
-        (@g << "# @private").newline
-        module_block("class #{name} < #{base_name} #:nodoc:") { yield }
-      end
+      @g.block("def #{method_name} #:nodoc:") { generate rule.child }
     end
-    
-    def nest_modules(path)
-      mod, *rest = path
-      if rest.empty?
-        yield mod
-      else
-        @g.block("module #{mod}") { nest_modules(rest) {|_| yield _ } }
-      end
-    end
-    
-    def module_block(decl)
-      @g.block(decl) do
-        @g.newline
-        yield
-        @g.newline
-      end
-    end
-    
+
   end
 end

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

@@ -0,0 +1,102 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+  # @private
+  class RuleSetGenerator #:nodoc:
+
+    Grammar = Rattler::Grammar::Grammar
+    include Rattler::Parsers
+
+    def initialize(g)
+      @g = g
+      @rule_generator = RuleGenerator.new(@g)
+    end
+
+    def generate(parser, opts={})
+      case parser
+      when Grammar  then gen_parser parser, opts
+      when RuleSet  then gen_rules parser, opts
+      end
+      self
+    end
+
+    def gen_parser(grammar, opts={})
+      gen_requires grammar.requires
+      gen_module(grammar) do
+        gen_includes grammar.includes
+        gen_rules grammar.rules, opts
+      end
+    end
+
+    def gen_requires(requires)
+      requires.each {|_| (@g << "require #{_}").newline }
+      @g.newline
+    end
+
+    def gen_module(grammar)
+      if grammar.grammar_name
+        gen_grammar_def(grammar.grammar_name) { yield }
+      elsif grammar.parser_name
+        gen_parser_def(grammar.parser_name, grammar.base_name) { yield }
+      else
+        yield
+      end
+    end
+
+    def gen_includes(includes)
+      unless includes.empty?
+        includes.each {|_| (@g << "include #{_}").newline }
+        @g.newline
+      end
+    end
+
+    def gen_rules(rules, opts={})
+      gen_start_rule rules.start_rule if rules.start_rule
+      @g.intersperse(rules, :newlines => 2) do |rule|
+        if opts[:standalone]
+          @rule_generator.gen_rule_standalone rule, rules
+        else
+          @rule_generator.gen_rule_modular rule
+        end
+      end
+    end
+
+    def gen_start_rule(start_rule)
+      (@g << "# @private").newline
+      @g.block('def start_rule #:nodoc:') { @g << ":#{start_rule}"}.newline
+      @g.newline
+    end
+
+    def gen_grammar_def(grammar_name)
+      nest_modules(grammar_name.split('::')) do |name|
+        (@g << "# @private").newline
+        module_block("module #{name} #:nodoc:") { yield }
+      end
+    end
+
+    def gen_parser_def(parser_name, base_name)
+      nest_modules(parser_name.split('::')) do |name|
+        (@g << "# @private").newline
+        module_block("class #{name} < #{base_name} #:nodoc:") { yield }
+      end
+    end
+
+    def nest_modules(path)
+      mod, *rest = path
+      if rest.empty?
+        yield mod
+      else
+        @g.block("module #{mod}") { nest_modules(rest) {|_| yield _ } }
+      end
+    end
+
+    def module_block(decl)
+      @g.block(decl) do
+        @g.newline
+        yield
+        @g.newline
+      end
+    end
+
+  end
+end

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

@@ -13,32 +13,34 @@ module Rattler::BackEnd::ParserGenerator
       @capture_names = []
     end
 
-    def gen_basic_nested(sequence)
-      atomic_block { gen_basic_top_level sequence }
+    def gen_basic_nested(sequence, scope={})
+      atomic_block { gen_basic_top_level sequence, scope }
     end
 
-    def gen_basic_top_level(sequence)
+    def gen_basic_top_level(sequence, scope={})
       with_backtracking do
         if sequence.capture_count == 1 and sequence.children.last.capturing?
           @g.intersperse_nl(sequence, ' &&') do |child|
-            gen_capturing(child) { generate child }
+            scope = gen_capturing(child, scope) { generate child, :basic, scope }
           end
         else
-          sequence.each { |_| @g.suffix(' &&') { gen_capturing _ }.newline }
+          sequence.each do |child|
+            @g.suffix(' &&') { scope = gen_capturing child, scope }.newline
+          end
           @g << result_expr(sequence)
         end
       end
     end
 
-    def gen_assert_nested(sequence)
-      atomic_block { gen_assert_top_level sequence }
+    def gen_assert_nested(sequence, scope={})
+      atomic_block { gen_assert_top_level sequence, scope }
     end
 
-    def gen_assert_top_level(sequence)
+    def gen_assert_top_level(sequence, scope={})
       lookahead do
         @g.block("#{result_name} = begin") do
           sequence.each do |_|
-            @g.suffix(' &&') { generate _, :intermediate_skip }.newline
+            @g.suffix(' &&') { scope = gen_matching _, scope }.newline
           end
           @g << "true"
         end
@@ -47,15 +49,15 @@ module Rattler::BackEnd::ParserGenerator
       @g << result_name
     end
 
-    def gen_disallow_nested(sequence)
-      atomic_block { gen_disallow_top_level sequence }
+    def gen_disallow_nested(sequence, scope={})
+      atomic_block { gen_disallow_top_level sequence, scope }
     end
 
-    def gen_disallow_top_level(sequence)
+    def gen_disallow_top_level(sequence, scope={})
       lookahead do
         @g.block("#{result_name} = !begin") do
           @g.intersperse_nl(sequence, ' &&') do |_|
-            generate _, :intermediate_skip
+            scope = gen_matching _, scope
           end
         end
         @g.newline
@@ -63,51 +65,49 @@ module Rattler::BackEnd::ParserGenerator
       @g << result_name
     end
 
-    def gen_dispatch_action_nested(sequence, target, method_name)
+    def gen_dispatch_action_nested(sequence, code, scope={})
       atomic_block do
-        gen_dispatch_action_top_level sequence, target, method_name
+        gen_dispatch_action_top_level sequence, code, scope
       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)
+    def gen_dispatch_action_top_level(sequence, code, scope={})
+      gen_action_code(sequence, scope) do |new_scope|
+        code.bind new_scope, result_array_expr(sequence)
       end
     end
 
-    def gen_direct_action_nested(sequence, action)
-      atomic_block { gen_direct_action_top_level sequence, action }
+    def gen_direct_action_nested(sequence, code, scope={})
+      atomic_block { gen_direct_action_top_level sequence, code, scope }
     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)
+    def gen_direct_action_top_level(sequence, code, scope={})
+      gen_action_code(sequence, scope) do |new_scope|
+        "(#{code.bind new_scope, @capture_names})"
       end
     end
 
-    def gen_token_nested(sequence)
-      atomic_block { gen_token_top_level sequence }
+    def gen_token_nested(sequence, scope={})
+      atomic_block { gen_token_top_level sequence, scope }
     end
 
-    def gen_token_top_level(sequence)
+    def gen_token_top_level(sequence, scope={})
       with_backtracking do
         sequence.each do |_|
-          @g.suffix(' &&') { generate _, :intermediate_skip }.newline
+          @g.suffix(' &&') { scope = gen_matching _, scope }.newline
         end
         @g << "@scanner.string[#{saved_pos_name}...(@scanner.pos)]"
       end
     end
 
-    def gen_skip_nested(sequence)
-      atomic_block { gen_skip_top_level sequence }
+    def gen_skip_nested(sequence, scope={})
+      atomic_block { gen_skip_top_level sequence, scope }
     end
 
-    def gen_skip_top_level(sequence)
+    def gen_skip_top_level(sequence, scope={})
       with_backtracking do
         sequence.each do |_|
-          @g.suffix(' &&') { generate _, :intermediate_skip }.newline
+          @g.suffix(' &&') { scope = gen_matching _, scope }.newline
         end
         @g << "true"
       end
@@ -115,16 +115,26 @@ module Rattler::BackEnd::ParserGenerator
 
     private
 
-    def gen_capturing(child)
+    def gen_matching(child, scope)
+      if child.labeled?
+        @g.surround("(#{capture_name} = ", ')') { generate child, :basic, scope }
+      else
+        generate child, :intermediate_skip, scope
+      end
+      child.labeled? ? scope.merge(child.label => last_capture_name) : scope
+    end
+
+    def gen_capturing(child, scope)
       if child.capturing?
         if block_given?
           yield
         else
-          @g.surround("(#{capture_name} = ", ')') { generate child }
+          @g.surround("(#{capture_name} = ", ')') { generate child, :basic, scope }
         end
       else
-        generate child, :intermediate
+        generate child, :intermediate, scope
       end
+      child.labeled? ? scope.merge(child.label => last_capture_name) : scope
     end
 
     def with_backtracking
@@ -153,14 +163,12 @@ module Rattler::BackEnd::ParserGenerator
       end
     end
 
-    def gen_action_code(sequence)
+    def gen_action_code(sequence, scope={})
       with_backtracking do
-        labeled = {}
         for child in sequence
-          @g.suffix(' &&') { gen_capturing child }.newline
-          labeled[child.label] = last_capture_name if child.labeled?
+          @g.suffix(' &&') { scope = gen_capturing child, scope }.newline
         end
-        @g << yield(labeled)
+        @g << yield(scope)
       end
     end