rattler 0.2.2 → 0.3.0

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

@@ -1,94 +1,94 @@
 require 'rattler/back_end/parser_generator'
 
 module Rattler::BackEnd::ParserGenerator
-  
+
   # @private
   class DisallowGenerator < ExprGenerator #:nodoc:
-    
+
     def gen_basic(disallow)
-      generate disallow.child, :gen_disallow
+      generate disallow.child, :disallow
     end
-    
+
     def gen_assert(disallow)
       @g << 'false'
     end
-    
+
     def gen_disallow(disallow)
       gen_basic disallow
     end
-    
+
     def gen_skip_nested(disallow)
       gen_basic_nested disallow
     end
-    
+
     def gen_skip_top_level(disallow)
       gen_basic_top_level disallow
     end
-    
+
     def gen_dispatch_action_nested(disallow, target, method_name)
       atomic_block { gen_dispatch_action_top_level disallow, target, method_name }
     end
-    
+
     def gen_dispatch_action_top_level(disallow, target, method_name)
       gen_action disallow,
         dispatch_action_result(target, method_name, :array_expr => '[]')
     end
-    
+
     def gen_direct_action_nested(disallow, code)
       atomic_block { gen_direct_action_top_level disallow, code }
     end
-    
+
     def gen_direct_action_top_level(disallow, code)
       gen_action disallow, direct_action_result(code)
     end
-    
+
     def gen_token_nested(disallow)
       atomic_block { gen_token_top_level disallow }
     end
-    
+
     def gen_token_top_level(disallow)
       gen_action disallow, "''"
     end
-    
+
     def gen_intermediate(disallow)
-      generate disallow.child, :gen_intermediate_disallow
+      generate disallow.child, :intermediate_disallow
     end
-    
+
     def gen_intermediate_disallow(disallow)
       gen_intermediate disallow
     end
-    
+
     def gen_intermediate_skip(disallow)
       gen_intermediate disallow
     end
-    
+
     private
-    
+
     def gen_action(disallow, result_code)
       gen_intermediate disallow
       (@g << ' &&').newline << result_code
     end
-    
+
   end
-  
+
   # @private
   class NestedDisallowGenerator < DisallowGenerator #:nodoc:
     include Nested
-    include NestedGenerators
+    include NestedSubGenerating
   end
-  
+
   def DisallowGenerator.nested(*args)
     NestedDisallowGenerator.new(*args)
   end
-  
+
   # @private
   class TopLevelDisallowGenerator < DisallowGenerator #:nodoc:
     include TopLevel
-    include TopLevelGenerators
+    include TopLevelSubGenerating
   end
-  
+
   def DisallowGenerator.top_level(*args)
     TopLevelDisallowGenerator.new(*args)
   end
-  
+
 end

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

@@ -1,61 +1,61 @@
 require 'rattler/back_end/parser_generator'
 
 module Rattler::BackEnd::ParserGenerator
-  
+
   # @private
   class DispatchActionGenerator < ExprGenerator #:nodoc:
     include PredicatePropogating
     include TokenPropogating
     include SkipPropogating
-    
+
     def gen_basic_nested(action)
-      generate action.child, :gen_dispatch_action_nested,
+      generate action.child, :dispatch_action_nested,
         action.target, action.method_name
     end
-    
+
     def gen_basic_top_level(action)
-      generate action.child, :gen_dispatch_action_top_level,
+      generate action.child, :dispatch_action_top_level,
         action.target, action.method_name
     end
-    
+
     def gen_dispatch_action_nested(inner, target, method_name)
       atomic_block { gen_dispatch_action_top_level inner, target, method_name }
     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)
     end
-    
+
     def gen_direct_action_nested(inner, code)
       atomic_block { gen_direct_action_top_level inner, code }
     end
-    
+
     def gen_direct_action_top_level(inner, code)
       @g.surround("(#{result_name} = ", ')') { gen_basic_nested inner }
       (@g << ' &&').newline << direct_action_result(code)
     end
-    
+
   end
-  
+
   # @private
   class NestedDispatchActionGenerator < DispatchActionGenerator #:nodoc:
     include Nested
-    include NestedGenerators
+    include NestedSubGenerating
   end
-  
+
   def DispatchActionGenerator.nested(*args)
     NestedDispatchActionGenerator.new(*args)
   end
-  
+
   # @private
   class TopLevelDispatchActionGenerator < DispatchActionGenerator #:nodoc:
     include TopLevel
-    include TopLevelGenerators
+    include TopLevelSubGenerating
   end
-  
+
   def DispatchActionGenerator.top_level(*args)
     TopLevelDispatchActionGenerator.new(*args)
   end
-  
+
 end

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

@@ -1,60 +1,149 @@
 require 'rattler/back_end/parser_generator'
 
 module Rattler::BackEnd::ParserGenerator
-  
+
   # @private
   class ExprGenerator #:nodoc:
-    include GeneratorHelper
-    
+    # include GeneratorHelper
+
     include Rattler::Parsers
-    
+
     def initialize(g, choice_level=nil, sequence_level=nil, repeat_level=nil)
       @g = g
       @choice_level = choice_level
       @sequence_level = sequence_level
       @repeat_level = repeat_level
     end
-    
-    def generate(parser, gen_method=:gen_basic, *args)
-      case parser
-      when Eof then gen_eof
-      else generator(parser).send(gen_method, parser, *args)
-      end
+
+    def gen_basic_nested(parser)
+      gen_basic parser
     end
-    
-    def gen_eof
-      @g << '@scanner.eos?'
-    end
-    
-    private
-    
-    def generator(parser)
-      case parser
-      when Match          then match_generator
-      when Choice         then choice_generator
-      when Sequence       then sequence_generator
-      when Optional       then optional_generator
-      when ZeroOrMore     then zero_or_more_generator
-      when OneOrMore      then one_or_more_generator
-      when Apply          then apply_generator
-      when Assert         then assert_generator
-      when Disallow       then disallow_generator
-      when DispatchAction then dispatch_action_generator
-      when DirectAction   then direct_action_generator
-      when Token          then token_generator
-      when Skip           then skip_generator
-      when Label          then label_generator
-      when Fail           then fail_generator
-      end
+
+    def gen_basic_top_level(parser)
+      gen_basic parser
+    end
+
+    def gen_assert_nested(parser)
+      gen_assert parser
+    end
+
+    def gen_assert_top_level(parser)
+      gen_assert parser
+    end
+
+    def gen_disallow_nested(parser)
+      gen_disallow parser
+    end
+
+    def gen_disallow_top_level(parser)
+      gen_disallow parser
+    end
+
+    def gen_dispatch_action_nested(parser, target, method_name)
+      gen_dispatch_action parser, target, method_name
+    end
+
+    def gen_dispatch_action_top_level(parser, target, method_name)
+      gen_dispatch_action parser, target, method_name
+    end
+
+    def gen_direct_action_nested(parser, action)
+      gen_direct_action parser, action
+    end
+
+    def gen_direct_action_top_level(parser, action)
+      gen_direct_action parser, action
+    end
+
+    def gen_token_nested(parser)
+      atomic_block { gen_token_top_level parser }
+    end
+
+    def gen_token_top_level(parser)
+      (@g << "tp = @scanner.pos").newline
+      gen_intermediate_skip parser
+      (@g << ' &&').newline
+      @g << "@scanner.string[tp...(@scanner.pos)]"
+    end
+
+    def gen_skip_nested(parser)
+      gen_skip parser
+    end
+
+    def gen_skip_top_level(parser)
+      gen_skip parser
     end
-    
+
+    def gen_intermediate(parser)
+      gen_basic_nested parser
+    end
+
+    def gen_intermediate_assert(parser)
+      gen_assert_nested parser
+    end
+
+    def gen_intermediate_disallow(parser)
+      gen_disallow_nested parser
+    end
+
+    def gen_intermediate_skip(parser)
+      gen_skip_nested parser
+    end
+
+    protected
+
     attr_reader :choice_level, :sequence_level, :repeat_level
-    
+
+    def atomic_expr
+      @g.surround('(', ')') { yield }
+    end
+
+    def atomic_block
+      @g.block('begin') { yield }
+    end
+
+    def result_name
+      'r'
+    end
+
+    def saved_pos_name
+      "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
+      (@g << "@scanner.pos = #{saved_pos_name}").newline
+    end
+
   end
-  
+
   # @private
   class TopLevelGenerator < ExprGenerator #:nodoc:
-    include TopLevelGenerators
+    include TopLevelSubGenerating
+
+    def generate(parser)
+      super
+    end
   end
-  
+
 end

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

@@ -1,45 +1,45 @@
 require 'rattler/back_end/parser_generator'
 
 module Rattler::BackEnd::ParserGenerator
-  
+
   # @private
   class LabelGenerator < ExprGenerator #:nodoc:
     include PredicatePropogating
     include TokenPropogating
     include SkipPropogating
-    
+
     def gen_basic(label)
-      generate label.child, :gen_basic
+      generate label.child, :basic
     end
-    
+
     def gen_dispatch_action(label, target, method_name)
-      generate label.child, :gen_dispatch_action, target, method_name
+      generate label.child, :dispatch_action, target, method_name
     end
-    
+
     def gen_direct_action(label, code)
-      generate label.child, :gen_direct_action, code
+      generate label.child, :direct_action, code
     end
-    
+
   end
-  
+
   # @private
   class NestedLabelGenerator < LabelGenerator #:nodoc:
     include Nested
-    include NestedGenerators
+    include NestedSubGenerating
   end
-  
+
   def LabelGenerator.nested(*args)
     NestedLabelGenerator.new(*args)
   end
-  
+
   # @private
   class TopLevelLabelGenerator < LabelGenerator #:nodoc:
     include TopLevel
-    include TopLevelGenerators
+    include TopLevelSubGenerating
   end
-  
+
   def LabelGenerator.top_level(*args)
     TopLevelLabelGenerator.new(*args)
   end
-  
+
 end

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

@@ -0,0 +1,61 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+
+  # @private
+  class List1Generator < ExprGenerator #:nodoc:
+    include ListGenerating
+    include NestedSubGenerating
+    include PredicatePropogating
+
+    def gen_skip_top_level(list)
+      (@g << "#{result_name} = false").newline
+      (@g << "#{saved_pos_name} = nil").newline
+      @g << 'while '
+      generate list.child, :intermediate_skip
+      @g.block '' do
+        (@g << "#{result_name} = true").newline
+        (@g << "#{saved_pos_name} = @scanner.pos").newline
+        @g << 'break unless '
+        generate list.sep_parser, :intermediate_skip
+      end.newline
+      @g << "@scanner.pos = #{saved_pos_name} unless #{saved_pos_name}.nil?"
+      @g.newline << result_name
+    end
+
+    protected
+
+    def gen_result(captures)
+      @g << captures << " unless #{accumulator_name}.empty?"
+    end
+
+  end
+
+  # @private
+  class NestedList1Generator < List1Generator #:nodoc:
+    include Nested
+  end
+
+  def List1Generator.nested(*args)
+    NestedList1Generator.new(*args)
+  end
+
+  # @private
+  class TopLevelList1Generator < List1Generator #:nodoc:
+    include TopLevel
+
+    def gen_assert(parser)
+      generate parser.child, :assert_top_level
+    end
+
+    def gen_disallow(parser)
+      generate parser.child, :disallow_top_level
+    end
+
+  end
+
+  def List1Generator.top_level(*args)
+    TopLevelList1Generator.new(*args)
+  end
+
+end

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

@@ -0,0 +1,71 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+  # @private
+  module ListGenerating #:nodoc:
+
+    def gen_basic_nested(list)
+      atomic_block { gen_basic_top_level list }
+    end
+
+    def gen_basic_top_level(list)
+      list.capturing? ? gen_capturing(list) : gen_skip_top_level(list)
+    end
+
+    def gen_dispatch_action_nested(list, target, method_name)
+      atomic_block do
+        gen_dispatch_action_top_level list, target, method_name
+      end
+    end
+
+    def gen_dispatch_action_top_level(list, target, method_name)
+      gen_capturing list do |a|
+        dispatch_action_result target, method_name,
+            :array_expr => "select_captures(#{a})"
+      end
+    end
+
+    def gen_direct_action_nested(list, action)
+      atomic_block do
+        gen_direct_action_top_level list, action
+      end
+    end
+
+    def gen_direct_action_top_level(list, action)
+      gen_capturing list do |a|
+        direct_action_result action, :bind_args => ["select_captures(#{a})"]
+      end
+    end
+
+    def gen_skip_nested(list)
+      atomic_block { gen_skip_top_level list }
+    end
+
+    protected
+
+    def gen_capturing(list)
+      (@g << "#{accumulator_name} = []").newline
+      (@g << "#{saved_pos_name} = nil").newline
+      @g << "while #{result_name} = "
+      generate list.child, :basic
+      @g.block '' do
+        (@g << "#{saved_pos_name} = @scanner.pos").newline
+        (@g << "#{accumulator_name} << #{result_name}").newline
+        @g << 'break unless '
+        generate list.sep_parser, :intermediate_skip
+      end.newline
+      @g << "@scanner.pos = #{saved_pos_name} unless #{saved_pos_name}.nil?"
+      @g.newline
+      gen_result(block_given? ? yield(accumulator_name) : accumulator_name)
+    end
+
+    def accumulator_name
+      "a#{repeat_level}"
+    end
+
+    def saved_pos_name
+      "lp#{repeat_level}"
+    end
+
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'rattler/back_end/parser_generator'
+
+module Rattler::BackEnd::ParserGenerator
+
+  # @private
+  class ListGenerator < ExprGenerator #:nodoc:
+    include ListGenerating
+    include NestedSubGenerating
+
+    def gen_assert(optional)
+      @g << 'true'
+    end
+
+    def gen_disallow(optional)
+      @g << 'false'
+    end
+
+    def gen_skip_top_level(list)
+      (@g << "#{saved_pos_name} = nil").newline
+      @g << 'while '
+      generate list.child, :intermediate_skip
+      @g.block '' do
+        (@g << "#{saved_pos_name} = @scanner.pos").newline
+        @g << 'break unless '
+        generate list.sep_parser, :intermediate_skip
+      end.newline
+      @g << "@scanner.pos = #{saved_pos_name} unless #{saved_pos_name}.nil?"
+      @g.newline << true
+    end
+
+    protected
+
+    def gen_result(captures)
+      @g << captures
+    end
+
+  end
+
+  # @private
+  class NestedListGenerator < ListGenerator #:nodoc:
+    include Nested
+  end
+
+  def ListGenerator.nested(*args)
+    NestedListGenerator.new(*args)
+  end
+
+  # @private
+  class TopLevelListGenerator < ListGenerator #:nodoc:
+    include TopLevel
+  end
+
+  def ListGenerator.top_level(*args)
+    TopLevelListGenerator.new(*args)
+  end
+
+end