rattler 0.5.0 → 0.6.0

data/lib/rattler/compiler/parser_generator/attributed_sequence_generator.rb

@@ -0,0 +1,37 @@
+require 'rattler/compiler/parser_generator'
+
+module Rattler::Compiler::ParserGenerator
+
+  # @private
+  class AttributedSequenceGenerator < ExprGenerator #:nodoc:
+    include SequenceGenerating
+
+    def gen_basic(sequence, scope = ParserScope.empty)
+      with_backtracking do
+        gen_children_capturing(sequence, scope.nest) do |last_child, scope|
+          gen_nested last_child, :basic, scope
+        end
+      end
+    end
+
+  end
+
+  # @private
+  class NestedAttributedSequenceGenerator < AttributedSequenceGenerator #:nodoc:
+    include Nested
+  end
+
+  def AttributedSequenceGenerator.nested(*args)
+    NestedAttributedSequenceGenerator.new(*args)
+  end
+
+  # @private
+  class TopLevelAttributedSequenceGenerator < AttributedSequenceGenerator #:nodoc:
+    include TopLevel
+  end
+
+  def AttributedSequenceGenerator.top_level(*args)
+    TopLevelAttributedSequenceGenerator.new(*args)
+  end
+
+end

data/lib/rattler/{back_end → compiler}/parser_generator/back_reference_generator.rb

@@ -1,48 +1,48 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class BackReferenceGenerator < ExprGenerator #:nodoc:
 
-    def gen_basic(ref, scope={})
+    def gen_basic(ref, scope = ParserScope.empty)
       @g << "@scanner.scan(#{ref.re_expr(scope)})"
     end
 
-    def gen_assert(ref, scope={})
+    def gen_assert(ref, scope = ParserScope.empty)
       expr do
         gen_intermediate_assert ref, scope
         @g << ' && true'
       end
     end
 
-    def gen_disallow(ref, scope={})
+    def gen_disallow(ref, scope = ParserScope.empty)
       expr do
         gen_intermediate_disallow ref, scope
         @g << ' && true'
       end
     end
 
-    def gen_token(ref, scope={})
+    def gen_token(ref, scope = ParserScope.empty)
       gen_basic ref, scope
     end
 
-    def gen_skip(ref, scope={})
+    def gen_skip(ref, scope = ParserScope.empty)
       expr do
         gen_intermediate_skip ref, scope
         @g << ' && true'
       end
     end
 
-    def gen_intermediate_assert(ref, scope={})
+    def gen_intermediate_assert(ref, scope = ParserScope.empty)
       @g << "@scanner.skip(/(?=#{ref.re_source(scope)})/)"
     end
 
-    def gen_intermediate_disallow(ref, scope={})
+    def gen_intermediate_disallow(ref, scope = ParserScope.empty)
       @g << "@scanner.skip(/(?!#{ref.re_source(scope)})/)"
     end
 
-    def gen_intermediate_skip(ref, scope={})
+    def gen_intermediate_skip(ref, scope = ParserScope.empty)
       @g << "@scanner.skip(#{ref.re_expr(scope)})"
     end
 

data/lib/rattler/{back_end → compiler}/parser_generator/choice_generator.rb

@@ -1,55 +1,43 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class ChoiceGenerator < ExprGenerator #:nodoc:
     include NestedSubGenerating
 
-    def gen_basic(choice, scope={})
+    def gen_basic(choice, scope = ParserScope.empty)
       expr :block do
         @g.intersperse_nl(choice, ' ||') {|_| generate _, :basic, scope }
       end
     end
 
-    def gen_assert(choice, scope={})
+    def gen_assert(choice, scope = ParserScope.empty)
       expr do
         gen_intermediate_assert choice, scope
         @g << ' && true'
       end
     end
 
-    def gen_disallow(choice, scope={})
+    def gen_disallow(choice, scope = ParserScope.empty)
       @g << '!'
       gen_intermediate_assert choice, scope
     end
 
-    def gen_dispatch_action(choice, code, scope={})
-      expr :block do
-        gen_action_code(choice) { code.bind scope, "[#{result_name}]" }
-      end
-    end
-
-    def gen_direct_action(choice, code, scope={})
-      expr :block do
-        gen_action_code(choice) { "(#{code.bind scope, [result_name]})" }
-      end
-    end
-
-    def gen_token(choice, scope={})
+    def gen_token(choice, scope = ParserScope.empty)
       expr :block do
         @g.intersperse_nl(choice, ' ||') {|_| generate _, :token, scope }
       end
     end
 
-    def gen_skip(choice, scope={})
+    def gen_skip(choice, scope = ParserScope.empty)
       expr do
         gen_intermediate_skip choice, scope
         @g << ' && true'
       end
     end
 
-    def gen_intermediate_assert(choice, scope={})
+    def gen_intermediate_assert(choice, scope = ParserScope.empty)
       @g.block 'begin' do
         @g.intersperse_nl(choice, ' ||') do |_|
           generate _, :intermediate_assert, scope
@@ -57,7 +45,7 @@ module Rattler::BackEnd::ParserGenerator
       end
     end
 
-    def gen_intermediate_skip(choice, scope={})
+    def gen_intermediate_skip(choice, scope = ParserScope.empty)
       @g.block 'begin' do
         @g.intersperse_nl(choice, ' ||') do |_|
           generate _, :intermediate_skip, scope
@@ -67,7 +55,7 @@ module Rattler::BackEnd::ParserGenerator
 
     private
 
-    def gen_action_code(choice, scope={})
+    def gen_action_code(choice, scope = ParserScope.empty)
       @g.block("(#{result_name} = begin", 'end)') do
         @g.intersperse_nl(choice, ' ||') {|child| generate child }
       end << ' && '

data/lib/rattler/{back_end → compiler}/parser_generator/delegating_generator.rb

@@ -1,6 +1,6 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class DelegatingGenerator < ExprGenerator #:nodoc:

data/lib/rattler/{back_end → compiler}/parser_generator/disallow_generator.rb

@@ -1,53 +1,45 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class DisallowGenerator < ExprGenerator #:nodoc:
 
-    def gen_basic(disallow, scope={})
+    def gen_basic(disallow, scope = ParserScope.empty)
       generate disallow.child, :disallow, scope
     end
 
-    def gen_assert(disallow, scope={})
+    def gen_assert(disallow, scope = ParserScope.empty)
       @g << 'false'
     end
 
-    def gen_disallow(disallow, scope={})
+    def gen_disallow(disallow, scope = ParserScope.empty)
       gen_basic disallow, scope
     end
 
-    def gen_skip(disallow, scope={})
+    def gen_skip(disallow, scope = ParserScope.empty)
       gen_basic disallow, scope
     end
 
-    def gen_dispatch_action(disallow, code, scope={})
-      expr(:block) { gen_action disallow, code.bind(scope, '[]'), scope }
-    end
-
-    def gen_direct_action(disallow, code, scope={})
-      expr(:block) { gen_action disallow, "(#{code.bind scope, []})", scope }
-    end
-
-    def gen_token(disallow, scope={})
+    def gen_token(disallow, scope = ParserScope.empty)
       expr(:block) { gen_action disallow, "''", scope }
     end
 
-    def gen_intermediate(disallow, scope={})
+    def gen_intermediate(disallow, scope = ParserScope.empty)
       generate disallow.child, :intermediate_disallow, scope
     end
 
-    def gen_intermediate_disallow(disallow, scope={})
+    def gen_intermediate_disallow(disallow, scope = ParserScope.empty)
       gen_intermediate disallow, scope
     end
 
-    def gen_intermediate_skip(disallow, scope={})
+    def gen_intermediate_skip(disallow, scope = ParserScope.empty)
       gen_intermediate disallow, scope
     end
 
     private
 
-    def gen_action(disallow, result_code, scope={})
+    def gen_action(disallow, result_code, scope = ParserScope.empty)
       gen_intermediate disallow, scope
       (@g << ' &&').newline << result_code
     end

data/lib/rattler/{back_end → compiler}/parser_generator/e_symbol_generator.rb

@@ -1,6 +1,6 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class ESymbolGenerator < ExprGenerator #:nodoc:
@@ -15,14 +15,6 @@ module Rattler::BackEnd::ParserGenerator
       @g << 'false'
     end
 
-    def gen_dispatch_action(eof, code, scope={})
-      @g << code.bind(scope, '[]')
-    end
-
-    def gen_direct_action(eof, code, scope={})
-      expr { @g <<  code.bind(scope, []) }
-    end
-
     def gen_token(*_)
       @g << "''"
     end

data/lib/rattler/{back_end → compiler}/parser_generator/eof_generator.rb

@@ -1,6 +1,6 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class EofGenerator < ExprGenerator #:nodoc:
@@ -15,14 +15,6 @@ module Rattler::BackEnd::ParserGenerator
       expr { @g << '!@scanner.eos?' }
     end
 
-    def gen_dispatch_action(eof, code, scope={})
-      gen_symantic code.bind(scope, '[]')
-    end
-
-    def gen_direct_action(eof, code, scope={})
-      gen_symantic '(' + code.bind(scope, []) + ')'
-    end
-
     def gen_token(*_)
       gen_symantic "''"
     end

data/lib/rattler/{back_end → compiler}/parser_generator/expr_generator.rb

@@ -1,6 +1,6 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class ExprGenerator #:nodoc:
@@ -14,21 +14,7 @@ module Rattler::BackEnd::ParserGenerator
       @repeat_level = repeat_level
     end
 
-    def gen_dispatch_action(parser, code, scope={})
-      expr :block do
-        gen_capture { block_given? ? yield : gen_basic(parser, scope) }
-        (@g << ' &&').newline << code.bind(scope, dispatch_action_args)
-      end
-    end
-
-    def gen_direct_action(parser, code, scope={})
-      expr :block do
-        gen_capture { block_given? ? yield : gen_basic(parser, scope) }
-        (@g << ' &&').newline << '(' << code.bind(scope, direct_action_args) << ')'
-      end
-    end
-
-    def gen_token(parser, scope={})
+    def gen_token(parser, scope = ParserScope.empty)
       expr :block do
         (@g << "#{token_pos_name} = @scanner.pos").newline
         gen_intermediate_skip parser, scope
@@ -37,19 +23,19 @@ module Rattler::BackEnd::ParserGenerator
       end
     end
 
-    def gen_intermediate(parser, scope={})
+    def gen_intermediate(parser, scope = ParserScope.empty)
       gen_basic parser, scope
     end
 
-    def gen_intermediate_assert(parser, scope={})
+    def gen_intermediate_assert(parser, scope = ParserScope.empty)
       gen_assert parser, scope
     end
 
-    def gen_intermediate_disallow(parser, scope={})
+    def gen_intermediate_disallow(parser, scope = ParserScope.empty)
       gen_disallow parser, scope
     end
 
-    def gen_intermediate_skip(parser, scope={})
+    def gen_intermediate_skip(parser, scope = ParserScope.empty)
       gen_skip parser, scope
     end
 
@@ -79,23 +65,11 @@ module Rattler::BackEnd::ParserGenerator
       @g.surround("(#{result_name} = ", ')') { yield }
     end
 
-    def dispatch_action_args
-      "[#{result_name}]"
-    end
-
-    def direct_action_args
-      [result_name]
-    end
-
   end
 
   # @private
-  class TopLevelGenerator < ExprGenerator #:nodoc:
-    include TopLevelSubGenerating
-
-    def generate(parser)
-      super
-    end
+  class NestedExprGenerator < ExprGenerator #:nodoc:
+    include NestedSubGenerating
   end
 
 end

data/lib/rattler/{back_end → compiler}/parser_generator/fail_generator.rb

@@ -1,11 +1,11 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class FailGenerator < ExprGenerator #:nodoc:
 
-    def gen_basic(fail, scope={})
+    def gen_basic(fail, scope = ParserScope.empty)
       case fail.attrs[:type]
       when :expr  then gen_fail_expr fail.message
       when :rule  then gen_fail_rule fail.message
@@ -13,6 +13,10 @@ module Rattler::BackEnd::ParserGenerator
       end
     end
 
+    def gen_skip(fail, scope = ParserScope.empty)
+      gen_basic fail, scope
+    end
+
     private
 
     def gen_fail_expr(message)

data/lib/rattler/{back_end → compiler}/parser_generator/gen_method_names.rb

@@ -1,14 +1,12 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   GEN_METHOD_TYPES = %w{
     basic
     assert
     disallow
-    dispatch_action
-    direct_action
     token
     skip
     intermediate
@@ -17,7 +15,7 @@ module Rattler::BackEnd::ParserGenerator
     intermediate_skip
   }
 
-  @private
+  # @private
   GEN_METHOD_NAMES = GEN_METHOD_TYPES.map {|_| :"gen_#{_}" }
 
 end

data/lib/rattler/{back_end → compiler}/parser_generator/general_list_generator.rb

@@ -1,6 +1,6 @@
-require 'rattler/back_end/parser_generator'
+require 'rattler/compiler/parser_generator'
 
-module Rattler::BackEnd::ParserGenerator
+module Rattler::Compiler::ParserGenerator
 
   # @private
   class GeneralListGenerator < ExprGenerator #:nodoc:
@@ -11,7 +11,7 @@ module Rattler::BackEnd::ParserGenerator
       super
     end
 
-    def gen_basic(list, scope={})
+    def gen_basic(list, scope = ParserScope.empty)
       if list.capturing?
         gen_capturing list, scope
       else
@@ -19,31 +19,19 @@ module Rattler::BackEnd::ParserGenerator
       end
     end
 
-    def gen_dispatch_action(list, code, scope={})
-      gen_capturing list, scope do |a|
-        code.bind scope, "select_captures(#{a})"
-      end
-    end
-
-    def gen_direct_action(list, code, scope={})
-      gen_capturing list, scope do |a|
-        '(' + code.bind(scope, ["select_captures(#{a})"]) + ')'
-      end
-    end
-
-    def gen_assert(list, scope={})
+    def gen_assert(list, scope = ParserScope.empty)
       gen_predicate(list, scope) do
         @g.newline << "#{count_name} >= #{list.lower_bound}"
       end
     end
 
-    def gen_disallow(list, scope={})
+    def gen_disallow(list, scope = ParserScope.empty)
       gen_predicate(list, scope) do
         @g.newline << "#{count_name} < #{list.lower_bound}"
       end
     end
 
-    def gen_skip(list, scope={})
+    def gen_skip(list, scope = ParserScope.empty)
       expr :block do
         (@g << "#{count_name} = 0").newline
         (@g << "#{start_pos_name} = @scanner.pos").newline