rattler 0.4.2 → 0.5.0

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

@@ -0,0 +1,177 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+
+  # @private
+  class GeneralRepeatGenerator < ExprGenerator #:nodoc:
+    include NestedSubGenerating
+
+    def gen_basic(repeat, scope={})
+      if repeat.capturing?
+        gen_capturing repeat, scope
+      else
+        gen_skip repeat, scope
+      end
+    end
+
+    def gen_assert(repeat, scope={})
+      gen_predicate(repeat, scope) { gen_assert_result repeat }
+    end
+
+    def gen_disallow(repeat, scope={})
+      gen_predicate(repeat, scope) { gen_disallow_result repeat }
+    end
+
+    def gen_dispatch_action(repeat, code, scope={})
+      expr :block do
+        gen_loop repeat, scope
+        gen_result repeat, code.bind(scope, "select_captures(#{accumulator_name})")
+      end
+    end
+
+    def gen_direct_action(repeat, code, scope={})
+      expr :block do
+        gen_loop repeat, scope
+        gen_result(repeat, '(' + code.bind(scope, ["select_captures(#{accumulator_name})"]) + ')')
+      end
+    end
+
+    def gen_token(repeat, scope={})
+      expr :block do
+        gen_loop(repeat, scope) { |child| generate child, :token, scope }
+        gen_result repeat, "#{accumulator_name}.join"
+      end
+    end
+
+    def gen_skip(repeat, scope={})
+      expr :block do
+        setup_skip_loop repeat
+        @g << 'while '
+        generate repeat.child, :intermediate_skip, scope
+        @g.block('') { gen_skip_loop_body repeat }.newline
+        gen_skip_result repeat
+      end
+    end
+
+    protected
+
+    def gen_capturing(repeat, scope)
+      expr :block do
+        gen_loop(repeat, scope) { |child| gen_nested child, :basic, scope }
+        gen_result repeat, accumulator_name
+      end
+    end
+
+    def gen_loop(repeat, scope)
+      setup_loop repeat
+      @g << "while #{result_name} = "
+      if block_given?
+        yield repeat.child
+      else
+        generate repeat.child, :basic, scope
+      end
+      @g.block('') { gen_loop_body repeat }.newline
+    end
+
+    def setup_loop(repeat)
+      (@g << "#{accumulator_name} = []").newline
+      if repeat.respond_to? :lower_bound and repeat.lower_bound > 1
+        (@g << "#{saved_pos_name} = @scanner.pos").newline
+      end
+    end
+
+    def gen_loop_body(repeat)
+      @g << "#{accumulator_name} << #{result_name}"
+      if repeat.respond_to? :upper_bound and repeat.upper_bound?
+        @g.newline << "break if #{accumulator_name}.size >= #{repeat.upper_bound}"
+      end
+    end
+
+    def gen_result(repeat, captures)
+      @g.block "if #{accumulator_name}.size >= #{repeat.lower_bound}", '' do
+        @g << captures
+      end
+      @g.block 'else' do
+        (@g << "@scanner.pos = #{saved_pos_name}").newline << 'false'
+      end
+    end
+
+    def gen_predicate(repeat, scope)
+      expr :block do
+        setup_skip_loop repeat
+        @g << 'while '
+        generate repeat.child, :intermediate_skip, scope
+        @g.block('') { gen_assert_loop_body repeat }.newline
+        yield
+      end
+    end
+
+    def setup_skip_loop(repeat)
+      (@g << "#{count_name} = 0").newline
+      (@g << "#{saved_pos_name} = @scanner.pos").newline
+    end
+
+    def gen_skip_loop_body(repeat)
+      @g << "#{count_name} += 1"
+      if repeat.upper_bound?
+        @g.newline << "break if #{count_name} >= #{repeat.upper_bound}"
+      end
+    end
+
+    def gen_skip_result(repeat)
+      @g.block "if #{count_name} >= #{repeat.lower_bound}", '' do
+        @g << 'true'
+      end
+      @g.block 'else' do
+        (@g << "@scanner.pos = #{saved_pos_name}").newline << 'false'
+      end
+    end
+
+    def gen_assert_loop_body(repeat)
+      @g << "#{count_name} += 1"
+      @g.newline << "break if #{count_name} >= #{repeat.lower_bound}"
+    end
+
+    def gen_assert_result(repeat)
+      @g << "@scanner.pos = #{saved_pos_name}"
+      @g.newline << "(#{count_name} >= #{repeat.lower_bound})"
+    end
+
+    def gen_disallow_result(repeat)
+      @g << "@scanner.pos = #{saved_pos_name}"
+      @g.newline << "(#{count_name} < #{repeat.lower_bound})"
+    end
+
+    def accumulator_name
+      "a#{repeat_level}"
+    end
+
+    def saved_pos_name
+      "rp#{repeat_level}"
+    end
+
+    def count_name
+      "c#{repeat_level}"
+    end
+
+  end
+
+  # @private
+  class NestedGeneralRepeatGenerator < GeneralRepeatGenerator #:nodoc:
+    include Nested
+  end
+
+  def GeneralRepeatGenerator.nested(*args)
+    NestedGeneralRepeatGenerator.new(*args)
+  end
+
+  # @private
+  class TopLevelGeneralRepeatGenerator < GeneralRepeatGenerator #:nodoc:
+    include TopLevel
+  end
+
+  def GeneralRepeatGenerator.top_level(*args)
+    TopLevelGeneralRepeatGenerator.new(*args)
+  end
+
+end

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

@@ -13,7 +13,10 @@ module Rattler::BackEnd::ParserGenerator
     end
 
     def gen_dispatch_action(label, code, scope={})
-      generate label.child, :dispatch_action, code, scope
+      expr :block do
+        scope = gen_capturing label.child, scope, label.label
+        (@g << ' &&').newline << code.bind(scope, dispatch_action_args)
+      end
     end
 
     def gen_direct_action(label, code, scope={})

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

@@ -0,0 +1,36 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+  # @private
+  module List0Generating #:nodoc:
+
+    def gen_assert(optional, scope={})
+      @g << 'true'
+    end
+
+    def gen_disallow(optional, scope={})
+      @g << 'false'
+    end
+
+    def gen_skip(list, scope={})
+      expr :block do
+        gen_skipping list, scope
+        @g << "@scanner.pos = #{end_pos_name} unless #{end_pos_name}.nil?"
+        @g.newline << 'true'
+      end
+    end
+
+    protected
+
+    def start_capturing(list)
+      (@g << "#{accumulator_name} = []").newline
+      (@g << "#{end_pos_name} = nil").newline
+    end
+
+    def gen_result(list, captures)
+      @g << "@scanner.pos = #{end_pos_name} unless #{end_pos_name}.nil?"
+      @g.newline << captures
+    end
+
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+  # @private
+  module List1Generating #:nodoc:
+    include PredicatePropogating
+
+    def gen_skip(list, scope={})
+      expr :block do
+        (@g << "#{result_name} = false").newline
+        gen_skipping(list, scope) { (@g << "#{result_name} = true").newline }
+        @g << "@scanner.pos = #{end_pos_name} unless #{end_pos_name}.nil?"
+        @g.newline << result_name
+      end
+    end
+
+    protected
+
+    def start_capturing(list)
+      (@g << "#{accumulator_name} = []").newline
+      (@g << "#{end_pos_name} = nil").newline
+    end
+
+    def gen_result(list, captures)
+      @g << "@scanner.pos = #{end_pos_name} unless #{end_pos_name}.nil?"
+      @g.newline << captures << " unless #{accumulator_name}.empty?"
+    end
+
+  end
+end

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

@@ -3,36 +3,30 @@ require 'rattler/back_end/parser_generator'
 module Rattler::BackEnd::ParserGenerator
 
   # @private
-  class ListGenerator < ExprGenerator #:nodoc:
-    include ListGenerating
+  class ListGenerator < DelegatingGenerator #:nodoc:
     include NestedSubGenerating
 
-    def gen_assert(optional, scope={})
-      @g << 'true'
-    end
+    protected
 
-    def gen_disallow(optional, scope={})
-      @g << 'false'
+    def impl(list, init_args)
+      generator = default_impl(list, init_args)
+      specialize_for list, generator
+      generator
     end
 
-    def gen_skip(list, scope={})
-      expr :block do
-        gen_skipping list, scope
-        @g.newline << 'true'
+    def specialize_for(list, generator)
+      case list.lower_bound
+      when 0 then generator.extend List0Generating
+      when 1 then generator.extend List1Generating
       end
     end
-
-    protected
-
-    def gen_result(captures)
-      @g << captures
-    end
-
   end
 
   # @private
   class NestedListGenerator < ListGenerator #:nodoc:
-    include Nested
+    def default_impl(list, init_args)
+      GeneralListGenerator.nested(*init_args)
+    end
   end
 
   def ListGenerator.nested(*args)
@@ -41,7 +35,9 @@ module Rattler::BackEnd::ParserGenerator
 
   # @private
   class TopLevelListGenerator < ListGenerator #:nodoc:
-    include TopLevel
+    def default_impl(list, init_args)
+      GeneralListGenerator.top_level(*init_args)
+    end
   end
 
   def ListGenerator.top_level(*args)

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

@@ -0,0 +1,25 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+  # @private
+  module OneOrMoreGenerating #:nodoc:
+    include PredicatePropogating
+
+    def gen_skip(one_or_more, scope={})
+      expr :block do
+        (@g << "#{result_name} = false").newline
+        @g << 'while '
+        generate one_or_more.child, :intermediate_skip, scope
+        @g.block('') { @g << "#{result_name} = true" }.newline
+        @g << result_name
+      end
+    end
+
+    protected
+
+    def gen_result(one_or_more, captures)
+      @g << captures << " unless #{accumulator_name}.empty?"
+    end
+
+  end
+end

data/lib/rattler/back_end/parser_generator/{optional_generator.rb → optional_generating.rb}

@@ -1,81 +1,66 @@
-require 'rattler/back_end/parser_generator'
-
-module Rattler::BackEnd::ParserGenerator
-
-  # @private
-  class OptionalGenerator < ExprGenerator #:nodoc:
-    include NestedSubGenerating
-
-    def gen_basic(optional, scope={})
-      if optional.capturing?
-        expr do
-          @g.surround("(#{result_name} = ", ')') do
-            generate optional.child, :basic, scope
-          end
-          @g << " ? [#{result_name}] : []"
-        end
-      else
-        gen_skip optional, scope
-      end
-    end
-
-    def gen_assert(optional, scope={})
-      @g << 'true'
-    end
-
-    def gen_disallow(optional, scope={})
-      @g << 'false'
-    end
-
-    def gen_dispatch_action(optional, code, scope={})
-      expr :block do
-        @g << "#{result_name} = "
-        generate optional.child, :basic, scope
-        @g.newline << code.bind(scope, "#{result_name} ? [#{result_name}] : []")
-      end
-    end
-
-    def gen_direct_action(optional, code, scope={})
-      expr :block do
-        @g << "#{result_name} = "
-        generate optional.child, :basic, scope
-        @g.newline <<
-          '(' << code.bind(scope, ["(#{result_name} ? [#{result_name}] : [])"]) << ')'
-      end
-    end
-
-    def gen_token(optional, scope={})
-      expr :block do
-        generate optional.child, :token, scope
-        @g << " || ''"
-      end
-    end
-
-    def gen_skip(optional, scope={})
-      expr :block do
-        generate optional.child, :intermediate_skip, scope
-        @g.newline << 'true'
-      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
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+  # @private
+  module OptionalGenerating #:nodoc:
+
+    def gen_assert(optional, scope={})
+      @g << 'true'
+    end
+
+    def gen_disallow(optional, scope={})
+      @g << 'false'
+    end
+
+    def gen_dispatch_action(optional, code, scope={})
+      expr :block do
+        gen_loop optional, scope
+        @g.newline << code.bind(scope, "#{result_name} ? [#{result_name}] : []")
+      end
+    end
+
+    def gen_direct_action(optional, code, scope={})
+      expr :block do
+        @g << "#{result_name} = "
+        generate optional.child, :basic, scope
+        @g.newline <<
+          '(' << code.bind(scope, ["(#{result_name} ? [#{result_name}] : [])"]) << ')'
+      end
+    end
+
+    def gen_token(optional, scope={})
+      expr :block do
+        generate optional.child, :token, scope
+        @g << " || ''"
+      end
+    end
+
+    def gen_skip(optional, scope={})
+      expr :block do
+        generate optional.child, :intermediate_skip, scope
+        @g.newline << 'true'
+      end
+    end
+
+    protected
+
+    def gen_capturing(optional, scope)
+      expr do
+        @g.surround("(#{result_name} = ", ')') do
+          generate optional.child, :basic, scope
+        end
+        @g << " ? [#{result_name}] : []"
+      end
+    end
+
+    def gen_loop(optional, scope)
+      @g << "#{result_name} = "
+      generate optional.child, :basic, scope
+    end
+
+    def gen_result(optional, captures)
+      @g.newline << captures
+    end
+
+  end
+end