rattler 0.4.1 → 0.4.2

data/lib/rattler/back_end/parser_generator/skip_propogating.rbc

@@ -0,0 +1,432 @@
+!RBIX
+3105615304195158506
+x
+M
+1
+n
+n
+x
+10
+__script__
+i
+41
+5
+7
+0
+64
+47
+49
+1
+1
+15
+99
+7
+2
+45
+3
+4
+43
+5
+49
+6
+2
+13
+99
+12
+7
+7
+12
+7
+8
+12
+65
+12
+49
+9
+4
+15
+49
+7
+0
+15
+2
+11
+I
+6
+I
+0
+I
+0
+I
+0
+n
+p
+10
+s
+33
+rattler/back_end/parser_generator
+x
+7
+require
+x
+15
+ParserGenerator
+x
+7
+Rattler
+n
+x
+7
+BackEnd
+x
+17
+open_module_under
+x
+15
+__module_init__
+M
+1
+n
+n
+x
+15
+ParserGenerator
+i
+28
+5
+66
+99
+7
+0
+65
+49
+1
+2
+13
+99
+12
+7
+2
+12
+7
+3
+12
+65
+12
+49
+4
+4
+15
+49
+2
+0
+11
+I
+6
+I
+0
+I
+0
+I
+0
+n
+p
+5
+x
+15
+SkipPropogating
+x
+11
+open_module
+x
+15
+__module_init__
+M
+1
+n
+n
+x
+15
+SkipPropogating
+i
+30
+5
+66
+99
+7
+0
+7
+1
+65
+67
+49
+2
+0
+49
+3
+4
+15
+99
+7
+4
+7
+5
+65
+67
+49
+2
+0
+49
+3
+4
+11
+I
+5
+I
+0
+I
+0
+I
+0
+n
+p
+6
+x
+8
+gen_skip
+M
+1
+n
+n
+x
+8
+gen_skip
+i
+29
+23
+1
+10
+14
+44
+43
+0
+78
+49
+1
+1
+19
+1
+15
+5
+20
+0
+49
+2
+0
+7
+3
+20
+1
+47
+49
+4
+3
+11
+I
+6
+I
+2
+I
+1
+I
+2
+n
+p
+5
+x
+4
+Hash
+x
+16
+new_from_literal
+x
+5
+child
+x
+4
+skip
+x
+8
+generate
+p
+5
+I
+-1
+I
+7
+I
+e
+I
+8
+I
+1d
+x
+103
+/home/jarhart/Dropbox/Workspaces/Ruby/rattler/lib/rattler/back_end/parser_generator/skip_propogating.rb
+p
+2
+x
+6
+parser
+x
+5
+scope
+x
+17
+method_visibility
+x
+15
+add_defn_method
+x
+21
+gen_intermediate_skip
+M
+1
+n
+n
+x
+21
+gen_intermediate_skip
+i
+29
+23
+1
+10
+14
+44
+43
+0
+78
+49
+1
+1
+19
+1
+15
+5
+20
+0
+49
+2
+0
+7
+3
+20
+1
+47
+49
+4
+3
+11
+I
+6
+I
+2
+I
+1
+I
+2
+n
+p
+5
+x
+4
+Hash
+x
+16
+new_from_literal
+x
+5
+child
+x
+17
+intermediate_skip
+x
+8
+generate
+p
+5
+I
+-1
+I
+b
+I
+e
+I
+c
+I
+1d
+x
+103
+/home/jarhart/Dropbox/Workspaces/Ruby/rattler/lib/rattler/back_end/parser_generator/skip_propogating.rb
+p
+2
+x
+6
+parser
+x
+5
+scope
+p
+5
+I
+2
+I
+7
+I
+10
+I
+b
+I
+1e
+x
+103
+/home/jarhart/Dropbox/Workspaces/Ruby/rattler/lib/rattler/back_end/parser_generator/skip_propogating.rb
+p
+0
+x
+13
+attach_method
+p
+3
+I
+2
+I
+5
+I
+1c
+x
+103
+/home/jarhart/Dropbox/Workspaces/Ruby/rattler/lib/rattler/back_end/parser_generator/skip_propogating.rb
+p
+0
+x
+13
+attach_method
+p
+5
+I
+0
+I
+1
+I
+9
+I
+3
+I
+29
+x
+103
+/home/jarhart/Dropbox/Workspaces/Ruby/rattler/lib/rattler/back_end/parser_generator/skip_propogating.rb
+p
+0

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

@@ -10,12 +10,16 @@ module Rattler::BackEnd::ParserGenerator
     protected
 
     def generate(parser, as=:basic, *args)
-      case parser
-      when Eof then gen_eof
-      else generator(parser).send(:"gen_#{as}", parser, *args)
-      end
+      gen_with generator(parser), parser, as, *args
+    end
+
+    def gen_nested(parser, as=:basic, *args)
+      gen_with generator(parser, :nested), parser, as, *args
     end
 
+    def gen_top_level(parser, as=:basic, *args)
+      gen_with generator(parser, :top_level), parser, as, *args
+    end
 
     def gen_eof
       @g << '@scanner.eos?'
@@ -23,77 +27,86 @@ module Rattler::BackEnd::ParserGenerator
 
     private
 
-    def generator(parser)
+    def gen_with(g, parser, as=:basic, *args)
+      case parser
+      when Eof then gen_eof
+      else g.send(:"gen_#{as}", parser, *args)
+      end
+    end
+
+    def generator(parser, context=nil)
+      context ||= default_context
+
       case parser
 
       when Match
-        cache_generator MatchGenerator
+        cache_generator MatchGenerator, context
 
       when Choice
-        cache_generator ChoiceGenerator, :new_choice_level => true
+        cache_generator ChoiceGenerator, context, :new_choice_level => true
 
       when Sequence
-        new_generator SequenceGenerator, :new_sequence_level => true
+        new_generator SequenceGenerator, context, :new_sequence_level => true
 
       when Optional
-        cache_generator OptionalGenerator
+        cache_generator OptionalGenerator, context
 
       when ZeroOrMore
-        cache_generator ZeroOrMoreGenerator, :new_repeat_level => true
+        cache_generator ZeroOrMoreGenerator, context, :new_repeat_level => true
 
       when OneOrMore
-        cache_generator OneOrMoreGenerator, :new_repeat_level => true
+        cache_generator OneOrMoreGenerator, context, :new_repeat_level => true
 
-      when List
-        cache_generator ListGenerator, :new_repeat_level => true
+      when List0
+        cache_generator ListGenerator, context, :new_repeat_level => true
 
       when List1
-        cache_generator List1Generator, :new_repeat_level => true
+        cache_generator List1Generator, context, :new_repeat_level => true
 
       when Apply
-        cache_generator ApplyGenerator
+        cache_generator ApplyGenerator, context
 
       when Assert
-        cache_generator AssertGenerator
+        cache_generator AssertGenerator, context
 
       when Disallow
-        cache_generator DisallowGenerator
+        cache_generator DisallowGenerator, context
 
       when DispatchAction
-        cache_generator DispatchActionGenerator
+        cache_generator DispatchActionGenerator, context
 
       when DirectAction
-        cache_generator DirectActionGenerator
+        cache_generator DirectActionGenerator, context
 
       when Token
-        cache_generator TokenGenerator
+        cache_generator TokenGenerator, context
 
       when Skip
-        cache_generator SkipGenerator
+        cache_generator SkipGenerator, context
 
       when Label
-        cache_generator LabelGenerator
+        cache_generator LabelGenerator, context
 
       when BackReference
-        cache_generator BackReferenceGenerator
+        cache_generator BackReferenceGenerator, context
 
       when Fail
-        cache_generator FailGenerator
+        cache_generator FailGenerator, context
 
       when GroupMatch
-        cache_generator GroupMatchGenerator
+        cache_generator GroupMatchGenerator, context
 
       end
     end
 
-    def cache_generator(factory, *args)
-      generator_cache.fetch factory do
-        generator_cache[factory] = new_generator factory, *args
+    def cache_generator(factory, context, *args)
+      generator_cache[context].fetch factory do
+        generator_cache[factory] = new_generator factory, context, *args
       end
     end
 
-    def new_generator(factory, opts = {})
-      factory.send factory_method, @g,
+    def new_generator(factory, context, opts = {})
+      factory.send context, @g,
         new_level(choice_level, opts[:new_choice_level]),
         new_level(sequence_level, opts[:new_sequence_level]),
         new_level(repeat_level, opts[:new_repeat_level])
@@ -108,7 +121,7 @@ module Rattler::BackEnd::ParserGenerator
     end
 
     def generator_cache
-      @generator_cache ||= {}
+      @generator_cache ||= Hash.new {|h, k| h[k] = {} }
     end
 
   end
@@ -117,18 +130,24 @@ module Rattler::BackEnd::ParserGenerator
     include SubGenerating
 
     protected
-    def factory_method
+
+    def default_context
       :nested
     end
+
+    alias_method :factory_method, :default_context
   end
 
   module TopLevelSubGenerating
     include SubGenerating
 
     protected
-    def factory_method
+
+    def default_context
       :top_level
     end
+
+    alias_method :factory_method, :default_context
   end
 
 end