rattler 0.4.2 → 0.5.0

data/lib/rattler/back_end/optimizer/simplify_redundant_repeat.rb

@@ -16,27 +16,30 @@ module Rattler::BackEnd::Optimizer
 
     include Rattler::Parsers
 
-    @@repeat_types = [ZeroOrMore, OneOrMore, Optional]
-
     protected
 
     def _applies_to?(parser, context)
       context.matching? and
-      [parser, parser.child].all? {|_| repeat? _ }
+      [parser, parser.child].all? {|_| simple_repeat? _ }
     end
 
     def _apply(parser, context)
-      if @@repeat_types.any? {|_| parser.is_a?(_) and parser.child.is_a?(_) }
+      if (parser.zero_or_more? and parser.child.zero_or_more?) or
+          (parser.one_or_more? and parser.child.one_or_more?) or
+          (parser.optional? and parser.child.optional?)
         parser.child
       else
-        ZeroOrMore[parser.child.child]
+        Repeat[parser.child.child, 0, nil]
       end
     end
 
     private
 
-    def repeat?(parser)
-      @@repeat_types.any? {|_| parser.is_a? _ }
+    def simple_repeat?(parser)
+      parser.is_a? Repeat and
+      ( parser.zero_or_more? or
+        parser.one_or_more? or
+        parser.optional? )
     end
 
   end

data/lib/rattler/back_end/optimizer/specialize_repeat.rb

@@ -0,0 +1,40 @@
+#
+# = rattler/back_end/optimizer/normalize_repeat.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler'
+
+module Rattler::BackEnd::Optimizer
+  #
+  # A Repeat with bounds equivalent to optional, zero-or-more, or one-or-more
+  # can be replaced by an Optional, a ZeroOrMore, or a OneOrMore, respectively.
+  #
+  # @author Jason Arhart
+  #
+  class SpecializeRepeat < Optimization
+
+    include Rattler::Parsers
+
+    protected
+
+    def _applies_to?(parser, context)
+      parser.is_a? Repeat and
+      ( parser.optional? or
+        parser.zero_or_more? or
+        parser.one_or_more? )
+    end
+
+    def _apply(parser, context)
+      if parser.optional?
+        Optional[parser.child]
+      elsif parser.zero_or_more?
+        ZeroOrMore[parser.child]
+      elsif parser.one_or_more?
+        OneOrMore[parser.child]
+      end
+    end
+
+  end
+end

data/lib/rattler/back_end/parser_generator.rb

@@ -27,14 +27,15 @@ module Rattler::BackEnd
     autoload :MatchGenerator, 'rattler/back_end/parser_generator/match_generator'
     autoload :ChoiceGenerator, 'rattler/back_end/parser_generator/choice_generator'
     autoload :SequenceGenerator, 'rattler/back_end/parser_generator/sequence_generator'
-    autoload :OptionalGenerator, 'rattler/back_end/parser_generator/optional_generator'
-    autoload :ZeroOrMoreGenerator, 'rattler/back_end/parser_generator/zero_or_more_generator'
-    autoload :OneOrMoreGenerator, 'rattler/back_end/parser_generator/one_or_more_generator'
+    autoload :RepeatGenerator, 'rattler/back_end/parser_generator/repeat_generator'
+    autoload :GeneralRepeatGenerator, 'rattler/back_end/parser_generator/general_repeat_generator'
     autoload :ListGenerator, 'rattler/back_end/parser_generator/list_generator'
-    autoload :List1Generator, 'rattler/back_end/parser_generator/list1_generator'
+    autoload :GeneralListGenerator, 'rattler/back_end/parser_generator/general_list_generator'
     autoload :ApplyGenerator, 'rattler/back_end/parser_generator/apply_generator'
     autoload :AssertGenerator, 'rattler/back_end/parser_generator/assert_generator'
     autoload :DisallowGenerator, 'rattler/back_end/parser_generator/disallow_generator'
+    autoload :EofGenerator, 'rattler/back_end/parser_generator/eof_generator'
+    autoload :ESymbolGenerator, 'rattler/back_end/parser_generator/e_symbol_generator'
     autoload :DispatchActionGenerator, 'rattler/back_end/parser_generator/dispatch_action_generator'
     autoload :DirectActionGenerator, 'rattler/back_end/parser_generator/direct_action_generator'
     autoload :TokenGenerator, 'rattler/back_end/parser_generator/token_generator'
@@ -42,8 +43,12 @@ module Rattler::BackEnd
     autoload :LabelGenerator, 'rattler/back_end/parser_generator/label_generator'
     autoload :BackReferenceGenerator, 'rattler/back_end/parser_generator/back_reference_generator'
     autoload :FailGenerator, 'rattler/back_end/parser_generator/fail_generator'
-    autoload :RepeatGenerating, 'rattler/back_end/parser_generator/repeat_generating'
-    autoload :ListGenerating, 'rattler/back_end/parser_generator/list_generating'
+    autoload :DelegatingGenerator, 'rattler/back_end/parser_generator/delegating_generator'
+    autoload :ZeroOrMoreGenerating, 'rattler/back_end/parser_generator/zero_or_more_generating'
+    autoload :OptionalGenerating, 'rattler/back_end/parser_generator/optional_generating'
+    autoload :OneOrMoreGenerating, 'rattler/back_end/parser_generator/one_or_more_generating'
+    autoload :List0Generating, 'rattler/back_end/parser_generator/list0_generating'
+    autoload :List1Generating, 'rattler/back_end/parser_generator/list1_generating'
     autoload :PredicatePropogating, 'rattler/back_end/parser_generator/predicate_propogating'
     autoload :TokenPropogating, 'rattler/back_end/parser_generator/token_propogating'
     autoload :SkipPropogating, 'rattler/back_end/parser_generator/skip_propogating'

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

@@ -0,0 +1,20 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+
+  # @private
+  class DelegatingGenerator < ExprGenerator #:nodoc:
+
+    def initialize(*args)
+      @init_args = args
+      super
+    end
+
+    GEN_METHOD_NAMES.each do |symbol|
+      define_method(symbol) do |parser, *args|
+        impl(parser, @init_args).send symbol, parser, *args
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+
+  # @private
+  class ESymbolGenerator < ExprGenerator #:nodoc:
+
+    def gen_basic(*_)
+      @g << 'true'
+    end
+
+    alias_method :gen_assert, :gen_basic
+
+    def gen_disallow(*_)
+      @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
+
+    alias_method :gen_skip, :gen_basic
+
+  end
+
+  # @private
+  class NestedESymbolGenerator < ESymbolGenerator #:nodoc:
+    include Nested
+  end
+
+  def ESymbolGenerator.nested(*args)
+    NestedESymbolGenerator.new(*args)
+  end
+
+  # @private
+  class TopLevelESymbolGenerator < ESymbolGenerator #:nodoc:
+    include TopLevel
+  end
+
+  def ESymbolGenerator.top_level(*args)
+    TopLevelESymbolGenerator.new(*args)
+  end
+
+end

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

@@ -0,0 +1,58 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+
+  # @private
+  class EofGenerator < ExprGenerator #:nodoc:
+
+    def gen_basic(*_)
+      @g << '@scanner.eos?'
+    end
+
+    alias_method :gen_assert, :gen_basic
+
+    def gen_disallow(*_)
+      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
+
+    alias_method :gen_skip, :gen_basic
+
+    private
+
+    def gen_symantic(result)
+      expr { @g << "#{result} if @scanner.eos?" }
+    end
+
+  end
+
+  # @private
+  class NestedEofGenerator < EofGenerator #:nodoc:
+    include Nested
+  end
+
+  def EofGenerator.nested(*args)
+    NestedEofGenerator.new(*args)
+  end
+
+  # @private
+  class TopLevelEofGenerator < EofGenerator #:nodoc:
+    include TopLevel
+  end
+
+  def EofGenerator.top_level(*args)
+    TopLevelEofGenerator.new(*args)
+  end
+
+end

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

@@ -30,10 +30,10 @@ module Rattler::BackEnd::ParserGenerator
 
     def gen_token(parser, scope={})
       expr :block do
-        (@g << "tp = @scanner.pos").newline
+        (@g << "#{token_pos_name} = @scanner.pos").newline
         gen_intermediate_skip parser, scope
         (@g << ' &&').newline
-        @g << "@scanner.string[tp...(@scanner.pos)]"
+        @g << "@scanner.string[#{token_pos_name}...(@scanner.pos)]"
       end
     end
 
@@ -65,6 +65,10 @@ module Rattler::BackEnd::ParserGenerator
       "p#{sequence_level}"
     end
 
+    def token_pos_name
+      "tp#{sequence_level}"
+    end
+
     def lookahead
       (@g << "#{saved_pos_name} = @scanner.pos").newline
       yield

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

@@ -1,13 +1,23 @@
 require 'rattler/back_end/parser_generator'
 
 module Rattler::BackEnd::ParserGenerator
-  
+
   # @private
   GEN_METHOD_TYPES = %w{
-    basic assert disallow dispatch_action direct_action token skip
+    basic
+    assert
+    disallow
+    dispatch_action
+    direct_action
+    token
+    skip
+    intermediate
+    intermediate_assert
+    intermediate_disallow
+    intermediate_skip
   }
-  
-  # @private
+
+  @private
   GEN_METHOD_NAMES = GEN_METHOD_TYPES.map {|_| :"gen_#{_}" }
-  
+
 end

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

@@ -0,0 +1,194 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+
+  # @private
+  class GeneralListGenerator < ExprGenerator #:nodoc:
+    include NestedSubGenerating
+
+    def initialize(*args)
+      @init_args = args
+      super
+    end
+
+    def gen_basic(list, scope={})
+      if list.capturing?
+        gen_capturing list, scope
+      else
+        gen_skip list, scope
+      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={})
+      gen_predicate(list, scope) do
+        @g.newline << "#{count_name} >= #{list.lower_bound}"
+      end
+    end
+
+    def gen_disallow(list, scope={})
+      gen_predicate(list, scope) do
+        @g.newline << "#{count_name} < #{list.lower_bound}"
+      end
+    end
+
+    def gen_skip(list, scope={})
+      expr :block do
+        (@g << "#{count_name} = 0").newline
+        (@g << "#{start_pos_name} = @scanner.pos").newline
+        gen_skipping(list, scope) { (@g << "#{count_name} += 1").newline }
+        gen_skipping_result list
+      end
+    end
+
+    protected
+
+    def gen_capturing(list, scope)
+      expr :block do
+        start_capturing list
+        gen_capturing_loop list, scope
+        gen_result(list, block_given? ? yield(accumulator_name) : accumulator_name)
+      end
+    end
+
+    def start_capturing(list)
+      (@g << "#{accumulator_name} = []").newline
+      (@g << "#{start_pos_name} = @scanner.pos").newline
+      (@g << "#{end_pos_name} = nil").newline
+    end
+
+    def gen_capturing_loop(list, scope)
+      @g << "while #{result_name} = "
+      generate list.child, :basic, scope
+      @g.block '' do
+        @g << "#{end_pos_name} = @scanner.pos"
+        gen_capturing_loop_body list
+        gen_skip_separator list.sep_parser, scope
+      end.newline
+    end
+
+    def gen_capturing_loop_body(list)
+      @g.newline << "#{accumulator_name} << #{result_name}"
+      gen_upper_bound_check list, "#{accumulator_name}.size"
+    end
+
+    def gen_result(list, captures)
+      @g.block "if #{accumulator_name}.size >= #{list.lower_bound}", '' do
+        @g << "@scanner.pos = #{end_pos_name} unless #{end_pos_name}.nil?"
+        @g.newline << captures
+      end
+      @g.block 'else' do
+        (@g << "@scanner.pos = #{start_pos_name}").newline << 'false'
+      end
+    end
+
+    def gen_predicate(list, scope)
+      expr :block do
+        @g << "#{count_name} = 0"
+        @g.newline << "#{start_pos_name} = @scanner.pos"
+        gen_loop list, :intermediate_skip, scope do
+          gen_predicate_loop_body list
+        end
+        @g.newline << "@scanner.pos = #{start_pos_name}"
+        yield
+      end
+    end
+
+    def gen_predicate_loop_body(list)
+      @g << "#{count_name} += 1"
+      gen_upper_bound_check list, count_name
+    end
+
+    def gen_skipping(list, scope)
+      @g << "#{end_pos_name} = nil"
+      gen_loop list, :intermediate_skip, scope do
+        yield if block_given?
+        gen_skipping_loop_body list
+      end
+      @g.newline
+    end
+
+    def gen_skipping_loop_body(list)
+      @g << "#{end_pos_name} = @scanner.pos"
+      gen_upper_bound_check list, count_name
+    end
+
+    def gen_skipping_result(list)
+      @g.block "if #{count_name} >= #{list.lower_bound}", '' do
+        @g << "@scanner.pos = #{end_pos_name} unless #{end_pos_name}.nil?"
+        @g.newline << 'true'
+      end
+      @g.block 'else' do
+        @g << "@scanner.pos = #{start_pos_name}"
+        @g.newline << 'false'
+      end
+    end
+
+    def gen_loop(list, term_as, scope)
+      @g.newline << 'while '
+      generate list.term_parser, term_as, scope
+      @g.block '' do
+        yield if block_given?
+        gen_skip_separator list.sep_parser, scope
+      end
+    end
+
+    def gen_upper_bound_check(list, count_expr)
+      if list.upper_bound?
+        @g.newline << "break unless #{count_expr} < #{list.upper_bound}"
+      end
+    end
+
+    def gen_skip_separator(sep_parser, scope)
+      @g.newline << 'break unless '
+      generate sep_parser, :intermediate_skip, scope
+    end
+
+    def accumulator_name
+      "a#{repeat_level}"
+    end
+
+    def start_pos_name
+      "sp#{repeat_level}"
+    end
+
+    def end_pos_name
+      "ep#{repeat_level}"
+    end
+
+    def count_name
+      "c#{repeat_level}"
+    end
+
+  end
+
+  # @private
+  class NestedGeneralListGenerator < GeneralListGenerator #:nodoc:
+    include Nested
+  end
+
+  def GeneralListGenerator.nested(*args)
+    NestedGeneralListGenerator.new(*args)
+  end
+
+  # @private
+  class TopLevelGeneralListGenerator < GeneralListGenerator #:nodoc:
+    include TopLevel
+  end
+
+  def GeneralListGenerator.top_level(*args)
+    TopLevelGeneralListGenerator.new(*args)
+  end
+
+end