rattler 0.3.0 → 0.4.0

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

@@ -8,36 +8,30 @@ module Rattler::BackEnd::ParserGenerator
     include TokenPropogating
     include SkipPropogating
 
-    def gen_basic(skip)
-      generate skip.child, :skip
+    def gen_basic(skip, scope={})
+      generate skip.child, :skip, scope
     end
 
-    def gen_dispatch_action_nested(skip, target, method_name)
-      atomic_block { gen_dispatch_action_top_level skip, target, method_name }
+    def gen_dispatch_action_nested(skip, code, scope={})
+      atomic_block { gen_dispatch_action_top_level skip, code, scope }
     end
 
-    def gen_dispatch_action_top_level(skip, target, method_name)
-      gen_intermediate_skip skip
-      (@g << ' &&').newline
-      @g << dispatch_action_result(target, method_name, :array_expr => '[]')
+    def gen_dispatch_action_top_level(skip, code, scope={})
+      gen_intermediate_skip skip, scope
+      (@g << ' &&').newline << code.bind(scope, '[]')
     end
 
-    def gen_direct_action_nested(skip, action)
-      atomic_block { gen_direct_action_top_level skip, action }
+    def gen_direct_action_nested(skip, code, scope={})
+      atomic_block { gen_direct_action_top_level skip, code, scope }
     end
 
-    def gen_direct_action_top_level(skip, action)
-      gen_intermediate_skip skip
-      (@g << ' &&').newline
-      @g << direct_action_result(action, :bind_args => [])
+    def gen_direct_action_top_level(skip, code, scope={})
+      gen_intermediate_skip skip, scope
+      (@g << ' &&').newline << '(' << code.bind(scope, []) << ')'
     end
 
-    def gen_intermediate(skip)
-      generate skip.child, :intermediate_skip
-    end
-
-    def gen_intermediate_skip(skip)
-      gen_intermediate skip
+    def gen_intermediate(skip, scope={})
+      gen_intermediate_skip skip, scope
     end
 
   end

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

@@ -4,12 +4,12 @@ module Rattler::BackEnd::ParserGenerator
   # @private
   module SkipPropogating #:nodoc:
 
-    def gen_skip(parser)
-      generate parser.child, :skip
+    def gen_skip(parser, scope={})
+      generate parser.child, :skip, scope
     end
 
-    def gen_intermediate_skip(parser)
-      generate parser.child, :intermediate_skip
+    def gen_intermediate_skip(parser, scope={})
+      generate parser.child, :intermediate_skip, scope
     end
 
   end

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

@@ -74,9 +74,15 @@ module Rattler::BackEnd::ParserGenerator
       when Label
         cache_generator LabelGenerator
 
+      when BackReference
+        cache_generator BackReferenceGenerator
+
       when Fail
         cache_generator FailGenerator
 
+      when GroupMatch
+        cache_generator GroupMatchGenerator
+
       end
     end
 

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

@@ -8,26 +8,26 @@ module Rattler::BackEnd::ParserGenerator
     include TokenPropogating
     include SkipPropogating
 
-    def gen_basic(token)
-      generate token.child, :token
+    def gen_basic(token, scope={})
+      generate token.child, :token, scope
     end
 
-    def gen_dispatch_action_nested(token, target, method_name)
-      atomic_block { gen_dispatch_action_top_level token, target, method_name }
+    def gen_dispatch_action_nested(token, code, scope={})
+      atomic_block { gen_dispatch_action_top_level token, code, scope }
     end
 
-    def gen_dispatch_action_top_level(token, target, method_name)
-      @g.surround("(#{result_name} = ", ')') { gen_basic token }
-      (@g << ' &&').newline << dispatch_action_result(target, method_name)
+    def gen_dispatch_action_top_level(token, code, scope={})
+      @g.surround("(#{result_name} = ", ')') { gen_basic token, scope }
+      (@g << ' &&').newline << code.bind(scope, "[#{result_name}]")
     end
 
-    def gen_direct_action_nested(token, action)
-      atomic_block { gen_direct_action_top_level token, action }
+    def gen_direct_action_nested(token, code, scope={})
+      atomic_block { gen_direct_action_top_level token, code, scope }
     end
 
-    def gen_direct_action_top_level(token, action)
-      @g.surround("(#{result_name} = ", ')') { gen_basic token }
-      (@g << ' &&').newline << direct_action_result(action)
+    def gen_direct_action_top_level(token, code, scope={})
+      @g.surround("(#{result_name} = ", ')') { gen_basic token, scope }
+      (@g << ' &&').newline << '(' << code.bind(scope, [result_name]) << ')'
     end
 
   end

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

@@ -3,8 +3,8 @@ require 'rattler/back_end/parser_generator'
 module Rattler::BackEnd::ParserGenerator
   # @private
   module TokenPropogating #:nodoc:
-    def gen_token(parser)
-      generate parser.child, :token
+    def gen_token(parser, scope={})
+      generate parser.child, :token, scope
     end
   end
 end

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

@@ -7,17 +7,17 @@ module Rattler::BackEnd::ParserGenerator
     include RepeatGenerating
     include NestedSubGenerating
 
-    def gen_assert(optional)
+    def gen_assert(optional, scope={})
       @g << 'true'
     end
 
-    def gen_disallow(optional)
+    def gen_disallow(optional, scope={})
       @g << 'false'
     end
 
-    def gen_skip_top_level(repeat)
+    def gen_skip_top_level(repeat, scope={})
       @g << 'while '
-      generate repeat.child, :intermediate_skip
+      generate repeat.child, :intermediate_skip, scope
       (@g << '; end').newline
       @g << 'true'
     end

data/lib/rattler/grammar.rb

@@ -17,7 +17,8 @@ module Rattler
     autoload :GrammarParser, 'rattler/grammar/grammar_parser'
     autoload :GrammarDSL, 'rattler/grammar/grammar_dsl'
     autoload :Metagrammar, 'rattler/grammar/metagrammar'
-    
+    autoload :Analysis, 'rattler/grammar/analysis'
+
     # Parse +source+ as a grammar and raise a {Rattler::Runtime::SyntaxError}
     # if the parse fails.
     #
@@ -28,7 +29,7 @@ module Rattler
     def self.parse!(source, options={})
       GrammarParser.parse!(source, options={})
     end
-    
+
     # Parse +source+ as a grammar.
     #
     # @param (see Rattler::RecursiveDescentParser#initialize)
@@ -37,6 +38,6 @@ module Rattler
     def self.parser(source, options={})
       GrammarParser.new(source, options={})
     end
-    
+
   end
 end

data/lib/rattler/grammar/analysis.rb

@@ -0,0 +1,91 @@
+#
+# = rattler/grammar/grammar.rb
+#
+# Author:: Jason Arhart
+# Documentation:: Author
+#
+require 'rattler/grammar'
+require 'set'
+
+module Rattler::Grammar
+  class Analysis
+
+    include Rattler::Parsers
+
+    def initialize(rules)
+      @rules = rules
+      @references = {}
+      @left_references = {}
+      @direct_references = {}
+      @direct_left_references = {}
+    end
+
+    def regular?(rule_name)
+      not recursive?(rule_name)
+    end
+
+    def recursive?(rule_name)
+      referenced_from? rule_name, rule_name
+    end
+
+    def left_recursive?(rule_name)
+      left_referenced_from? rule_name, rule_name
+    end
+
+    def referenced?(rule_name)
+      rule_name == @rules.start_rule or
+      referenced_from? @rules.start_rule, rule_name
+    end
+
+    def referenced_from?(referencer, referencee)
+      references_from(referencer).include? referencee
+    end
+
+    def left_referenced_from?(referencer, referencee)
+      left_references_from(referencer).include? referencee
+    end
+
+    private
+
+    def references_from(rule_name)
+      @references[rule_name] ||= trace_references rule_name, :direct_references
+    end
+
+    def left_references_from(rule_name)
+      @left_references[rule_name] ||= trace_references rule_name, :direct_left_references
+    end
+
+    def trace_references(rule_name, enum, references=nil)
+      references ||= Set[]
+      for r in send(enum, @rules[rule_name].expr)
+        trace_references(r, enum, references << r) unless references.include? r
+      end
+      references
+    end
+
+    def direct_references(expr)
+      @direct_references[expr] ||= case expr
+      when Apply
+        Set[expr.rule_name]
+      when Rattler::Parsers::Parser
+        expr.map {|_| direct_references _ }.to_set.flatten
+      else
+        Set[]
+      end
+    end
+
+    def direct_left_references(expr)
+      @direct_left_references[expr] ||= case expr
+      when Apply
+        Set[expr.rule_name]
+      when Choice
+        expr.map {|_| direct_left_references _ }.to_set.flatten
+      when Rattler::Parsers::Parser
+        direct_left_references expr.child
+      else
+        Set[]
+      end
+    end
+
+  end
+end

data/lib/rattler/grammar/grammar.rb

@@ -11,18 +11,26 @@ module Rattler::Grammar
   # +Grammar+ represents a parsed grammar
   #
   # @author Jason Arhart
-  class Grammar
-    
+  class Grammar < Rattler::Util::Node
+
     # The name of the default parser base class
     DEFAULT_PARSER_BASE = 'Rattler::Runtime::PackratParser'
-    
+
+    @@default_opts = {
+      :grammar_name => nil,
+      :parser_name => nil,
+      :base_name => DEFAULT_PARSER_BASE,
+      :requires => [],
+      :includes => []
+    }
+
     # @private
     def self.parsed(results, *_) #:nodoc:
       options, rules = results
       self.new(rules, options)
     end
-    
-    # @param rules [Rules] the parse rules that define the parser
+
+    # @param rules [RuleSet] the parse rules that define the parser
     #
     # @option opts [String] start_rule (rules.first)
     # @option opts [String] grammar_name (nil)
@@ -31,27 +39,31 @@ module Rattler::Grammar
     # @option opts [Array<String>] requires ([])
     # @option opts [Array<String>] includes ([])
     def initialize(rules, opts={})
-      @__rules__ = rules
-      @start_rule = opts[:start_rule] || rules.first.name
-      @grammar_name = opts[:grammar_name]
-      @parser_name = opts[:parser_name]
-      @base_name = opts[:base_name] || DEFAULT_PARSER_BASE
-      @requires = opts[:requires] || []
-      @includes = opts[:includes] || []
-      @name = @grammar_name || @parser_name
-    end
-    
-    attr_reader :start_rule, :grammar_name, :parser_name, :base_name, :name
-    attr_reader :requires, :includes
-    
-    # @return the parse rules
-    def rules
-      @rules ||= begin
-        r = @__rules__.optimized
-        r.start_rule = start_rule
-        r
+      super @@default_opts.merge(opts)
+
+      case attrs[:start_rule]
+      when Symbol then attrs[:start_rule] = rules[start_rule]
+      when nil    then attrs[:start_rule] = rules.first
       end
+
+      @rules = rules.with_attrs(:start_rule => start_rule.name)
+
+      attrs[:name] ||= grammar_name || parser_name
     end
-    
+
+    attr_reader :rules
+
+    def rule(name)
+      rules[name]
+    end
+
+    def analysis
+      rules.analysis
+    end
+
+    def with_rules(new_rules)
+      self.class.new new_rules, attrs
+    end
+
   end
 end

data/lib/rattler/grammar/grammar_parser.rb

@@ -17,14 +17,15 @@ module Rattler::Grammar
       super
       @ws = nil
       @wc = Match[/[[:alnum:]_]/]
+      @inline = false
       @directive_stack = []
     end
 
     private
 
     def start_ws(e)
-      @directive_stack.push(:type => :ws, :value => @ws)
-      set_ws(e)
+      @directive_stack.push :type => :ws, :value => @ws
+      set_ws e
     end
 
     def set_ws(e)
@@ -33,8 +34,8 @@ module Rattler::Grammar
     end
 
     def start_wc(e)
-      @directive_stack.push(:type => :wc, :value => @wc)
-      set_wc(e)
+      @directive_stack.push :type => :wc, :value => @wc
+      set_wc e
     end
 
     def set_wc(e)
@@ -42,11 +43,21 @@ module Rattler::Grammar
       true
     end
 
+    def start_inline
+      @directive_stack.push :type => :inline, :value => @inline
+      set_inline
+    end
+
+    def set_inline
+      @inline = true
+    end
+
     def end_block
       if d = @directive_stack.pop
         case d[:type]
-        when :wc then @wc = d[:value]
-        when :ws then @ws = d[:value]
+        when :wc      then @wc = d[:value]
+        when :ws      then @ws = d[:value]
+        when :inline  then @inline = d[:value]
         end
         true
       end
@@ -61,7 +72,7 @@ module Rattler::Grammar
     end
 
     def rule(name, parser)
-      Rule[name, (@ws ? parser.with_ws(@ws) : parser)]
+      Rule[name, (@ws ? parser.with_ws(@ws) : parser), {:inline => @inline}]
     end
 
     def literal(e)
@@ -69,10 +80,7 @@ module Rattler::Grammar
     end
 
     def word_literal(e)
-      Token[Sequence[
-        Match[Regexp.compile(Regexp.escape(eval("%q#{e}", TOPLEVEL_BINDING)))],
-        Disallow[@wc]
-      ]]
+      Token[Sequence[literal("%q#{e}"), Disallow[@wc]]]
     end
 
     def char_class(e)

data/lib/rattler/grammar/metagrammar.rb

@@ -16,20 +16,142 @@ module Rattler
       def match_grammar #:nodoc:
         p0 = @scanner.pos
         begin
-          (r0_0 = match(:heading)) &&
-          (r0_1 = match(:rules)) &&
-          begin
+          (r0_0 = begin
             p1 = @scanner.pos
             begin
-              @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-              @scanner.eos? &&
-              true
+              (r1_0 = begin
+                a0 = []
+                while r = begin
+                  @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>require)(?![[:alnum:]_])))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?!(?>(?>[[:blank:]])*)(?>\z|;|(?>(?>\r)?)(?>\n)|(?>\#)(?>(?>[^\n])*)))(?>.))+))(?>(?>(?>[[:blank:]])*)(?>\z|;|(?>(?>\r)?)(?>\n)|(?>\#)(?>(?>[^\n])*)))/) &&
+                  @scanner[1]
+                end
+                  a0 << r
+                end
+                ({ :requires => select_captures(a0) })
+              end) &&
+              (r1_1 = ((r = begin
+                begin
+                  p2 = @scanner.pos
+                  begin
+                    (r2_0 = begin
+                      @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>parser)(?![[:alnum:]_])))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>(?>[[:upper:]])(?>(?>[[:alnum:]_])*)(?>::))*)(?>[[:upper:]])(?>(?>[[:alnum:]_])*)))/) &&
+                      @scanner[1]
+                    end) &&
+                    (r2_1 = ((r = begin
+                      @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>(?>[[:upper:]])(?>(?>[[:alnum:]_])*)(?>::))*)(?>[[:upper:]])(?>(?>[[:alnum:]_])*)))/) &&
+                      @scanner[1]
+                    end) ? [r] : [])) &&
+                    @scanner.skip(/(?>(?>(?>[[:blank:]])*)(?>\z|;|(?>(?>\r)?)(?>\n)|(?>\#)(?>(?>[^\n])*)))/) &&
+                    (parser_decl r2_0, r2_1)
+                  end || begin
+                    @scanner.pos = p2
+                    false
+                  end
+                end ||
+                begin
+                  @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>grammar)(?![[:alnum:]_])))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>(?>[[:upper:]])(?>(?>[[:alnum:]_])*)(?>::))*)(?>[[:upper:]])(?>(?>[[:alnum:]_])*)))(?>(?>(?>[[:blank:]])*)(?>\z|;|(?>(?>\r)?)(?>\n)|(?>\#)(?>(?>[^\n])*)))/) &&
+                  ({ :grammar_name => @scanner[1] })
+                end
+              end) ? [r] : [])) &&
+              (r1_2 = begin
+                a0 = []
+                while r = begin
+                  @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>include)(?![[:alnum:]_])))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>(?>[[:upper:]])(?>(?>[[:alnum:]_])*)(?>::))*)(?>[[:upper:]])(?>(?>[[:alnum:]_])*)))(?>(?>(?>[[:blank:]])*)(?>\z|;|(?>(?>\r)?)(?>\n)|(?>\#)(?>(?>[^\n])*)))/) &&
+                  @scanner[1]
+                end
+                  a0 << r
+                end
+                ({ :includes => select_captures(a0) })
+              end) &&
+              (heading r1_0, r1_1, r1_2)
             end || begin
               @scanner.pos = p1
               false
             end
-          end &&
-          Grammar.parsed(select_captures([r0_0, r0_1]))
+          end) &&
+          (r0_1 = begin
+            a0 = []
+            while r = begin
+              begin
+                p1 = @scanner.pos
+                begin
+                  @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%whitespace)(?![[:alnum:]_]))/) &&
+                  (r1_0 = match(:unattributed)) &&
+                  @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{)/) &&
+                  (start_ws r1_0)
+                end || begin
+                  @scanner.pos = p1
+                  false
+                end
+              end ||
+              begin
+                p1 = @scanner.pos
+                begin
+                  @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%whitespace)(?![[:alnum:]_]))/) &&
+                  (r1_0 = match(:unattributed)) &&
+                  (set_ws r1_0)
+                end || begin
+                  @scanner.pos = p1
+                  false
+                end
+              end ||
+              begin
+                p1 = @scanner.pos
+                begin
+                  @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%word_character)(?![[:alnum:]_]))/) &&
+                  (r1_0 = match(:unattributed)) &&
+                  @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{)/) &&
+                  (start_wc r1_0)
+                end || begin
+                  @scanner.pos = p1
+                  false
+                end
+              end ||
+              begin
+                p1 = @scanner.pos
+                begin
+                  @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%word_character)(?![[:alnum:]_]))/) &&
+                  (r1_0 = match(:unattributed)) &&
+                  (set_wc r1_0)
+                end || begin
+                  @scanner.pos = p1
+                  false
+                end
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%inline)(?![[:alnum:]_])))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{))/) &&
+                (start_inline)
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%inline)(?![[:alnum:]_]))/) &&
+                (set_inline)
+              end ||
+              begin
+                p1 = @scanner.pos
+                begin
+                  @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>EOF)(?![[:alnum:]_])))/) &&
+                  (r1_0 = begin
+                    @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:alnum:]_])+))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><\-))/) &&
+                    @scanner[1]
+                  end) &&
+                  (r1_1 = match(:expression)) &&
+                  (rule r1_0, r1_1)
+                end || begin
+                  @scanner.pos = p1
+                  false
+                end
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\})/) &&
+                (end_block)
+              end
+            end
+              a0 << r
+            end
+            RuleSet.parsed(select_captures(a0)) unless a0.empty?
+          end) &&
+          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)\z/) &&
+          Grammar.parsed([r0_0, r0_1])
         end || begin
           @scanner.pos = p0
           false
@@ -37,58 +159,67 @@ module Rattler
       end
       
       # @private
-      def match_heading #:nodoc:
-        p0 = @scanner.pos
+      def match_unattributed #:nodoc:
+        memoize_lr :match_unattributed!
+      end
+      
+      # @private
+      def match_unattributed! #:nodoc:
         begin
-          (r0_0 = match(:requires)) &&
-          (r0_1 = ((r = match(:module_decl)) ? [r] : [])) &&
-          (r0_2 = match(:includes)) &&
-          (heading *[r0_0, r0_1, r0_2])
-        end || begin
-          @scanner.pos = p0
-          false
-        end
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:unattributed)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\/)/) &&
+            (r0_1 = match(:terms)) &&
+            Choice.parsed(select_captures([r0_0, r0_1]))
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        match(:terms)
+      end
+      
+      # @private
+      def match_expression #:nodoc:
+        memoize_lr :match_expression!
       end
       
       # @private
-      def match_requires #:nodoc:
-        a0 = []
-        while r = begin
+      def match_expression! #:nodoc:
+        begin
           p0 = @scanner.pos
           begin
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>require)(?>(?![[:alnum:]_])))/) &&
-            (r0_0 = match(:literal)) &&
-            match(:eol) &&
-            r0_0
+            (r0_0 = match(:expression)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\/)/) &&
+            (r0_1 = match(:attributed)) &&
+            Choice.parsed(select_captures([r0_0, r0_1]))
           end || begin
             @scanner.pos = p0
             false
           end
-        end
-          a0 << r
-        end
-        ({ :requires => select_captures(a0) })
+        end ||
+        match(:attributed)
+      end
+      
+      # @private
+      def match_attributed #:nodoc:
+        memoize_lr :match_attributed!
       end
       
       # @private
-      def match_module_decl #:nodoc:
+      def match_attributed! #:nodoc:
         begin
           p0 = @scanner.pos
           begin
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>parser)(?>(?![[:alnum:]_])))/) &&
-            (r0_0 = match(:constant)) &&
+            (r0_0 = match(:attributed)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><)/) &&
             (r0_1 = ((r = begin
-              p1 = @scanner.pos
-              begin
-                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><)/) &&
-                match(:constant)
-              end || begin
-                @scanner.pos = p1
-                false
-              end
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>[[:lower:]])(?>(?>[[:alnum:]_])*))|(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>(?>(?>[[:upper:]])(?>(?>[[:alnum:]_])*)(?>::))*)(?>[[:upper:]])(?>(?>[[:alnum:]_])*)))(?>(?>(?>\.)(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>[[:lower:]])(?>(?>[[:alnum:]_])*))))?))/) &&
+              @scanner[1]
             end) ? [r] : [])) &&
-            match(:eol) &&
-            (parser_decl *[r0_0, r0_1])
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>>)/) &&
+            DispatchAction.parsed(select_captures([r0_0, r0_1]))
           end || begin
             @scanner.pos = p0
             false
@@ -97,78 +228,229 @@ module Rattler
         begin
           p0 = @scanner.pos
           begin
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>grammar)(?>(?![[:alnum:]_])))/) &&
-            (r0_0 = match(:constant)) &&
-            match(:eol) &&
-            ({ :grammar_name => r0_0 })
+            (r0_0 = match(:attributed)) &&
+            (r0_1 = begin
+              @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>\{)(?>(?>[^}])*)(?>\})|[^{}])*))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\}))/) &&
+              @scanner[1]
+            end) &&
+            DirectAction.parsed(select_captures([r0_0, r0_1]))
           end || begin
             @scanner.pos = p0
             false
           end
-        end
+        end ||
+        match(:terms)
+      end
+      
+      # @private
+      def match_terms #:nodoc:
+        memoize_lr :match_terms!
       end
       
       # @private
-      def match_includes #:nodoc:
-        a0 = []
-        while r = begin
+      def match_terms! #:nodoc:
+        begin
           p0 = @scanner.pos
           begin
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>include)(?>(?![[:alnum:]_])))/) &&
-            (r0_0 = match(:constant)) &&
-            match(:eol) &&
-            r0_0
+            (r0_0 = match(:terms)) &&
+            (r0_1 = match(:term)) &&
+            Sequence.parsed(select_captures([r0_0, r0_1]))
           end || begin
             @scanner.pos = p0
             false
           end
-        end
-          a0 << r
-        end
-        ({ :includes => select_captures(a0) })
-      end
-      
-      # @private
-      def match_rules #:nodoc:
-        a0 = []
-        while r = begin
-          match(:directive) ||
-          match(:rule) ||
-          match(:block_close)
-        end
-          a0 << r
-        end
-        Rules.parsed(select_captures(a0)) unless a0.empty?
+        end ||
+        match(:term)
       end
       
       # @private
-      def match_directive #:nodoc:
-        match(:ws_directive) ||
-        match(:wc_directive)
+      def match_term #:nodoc:
+        memoize :match_term!
       end
       
       # @private
-      def match_ws_directive #:nodoc:
+      def match_term! #:nodoc:
         begin
           p0 = @scanner.pos
           begin
-            (r0_0 = match(:ws_decl)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{)/) &&
-            (start_ws r0_0)
+            (r0_0 = begin
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>fail)(?![[:alnum:]_]))/) &&
+                @scanner[1]
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>fail_rule)(?![[:alnum:]_]))/) &&
+                @scanner[1]
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>fail_parse)(?![[:alnum:]_]))/) &&
+                @scanner[1]
+              end
+            end) &&
+            (r0_1 = begin
+              begin
+                p1 = @scanner.pos
+                begin
+                  @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\()/) &&
+                  (r1_0 = begin
+                    begin
+                      @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>")(?>(?>(?>\\)(?>.)|[^"])*)(?>"))/) &&
+                      @scanner[1]
+                    end ||
+                    begin
+                      @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>')(?>(?>(?>\\)(?>.)|[^'])*)(?>'))/) &&
+                      @scanner[1]
+                    end ||
+                    begin
+                      @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%\()(?>(?>(?>\\)(?>.)|[^)])*)(?>\)))/) &&
+                      @scanner[1]
+                    end ||
+                    begin
+                      @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%\{)(?>(?>(?>\\)(?>.)|[^}])*)(?>\}))/) &&
+                      @scanner[1]
+                    end ||
+                    begin
+                      @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%\[)(?>(?>(?>\\)(?>.)|[^\]])*)(?>\]))/) &&
+                      @scanner[1]
+                    end ||
+                    begin
+                      @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%<)(?>(?>(?>\\)(?>.)|[^>])*)(?>>))/) &&
+                      @scanner[1]
+                    end ||
+                    begin
+                      p2 = @scanner.pos
+                      begin
+                        @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
+                        begin
+                          p3 = @scanner.pos
+                          begin
+                            @scanner.skip(/%/) &&
+                            (r3_0 = @scanner.scan(/[[:punct:]]/)) &&
+                            begin
+                              while begin
+                                @scanner.skip(/(?>\\)(?>.)/) ||
+                                begin
+                                  p4 = @scanner.pos
+                                  begin
+                                    @scanner.skip(/(?!#{r3_0})/) &&
+                                    @scanner.skip(/./) &&
+                                    true
+                                  end || begin
+                                    @scanner.pos = p4
+                                    false
+                                  end
+                                end
+                              end; end
+                              true
+                            end &&
+                            @scanner.skip(/#{r3_0}/) &&
+                            @scanner.string[p3...(@scanner.pos)]
+                          end || begin
+                            @scanner.pos = p3
+                            false
+                          end
+                        end
+                      end || begin
+                        @scanner.pos = p2
+                        false
+                      end
+                    end
+                  end) &&
+                  @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\))/) &&
+                  r1_0
+                end || begin
+                  @scanner.pos = p1
+                  false
+                end
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>")(?>(?>(?>\\)(?>.)|[^"])*)(?>"))/) &&
+                @scanner[1]
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>')(?>(?>(?>\\)(?>.)|[^'])*)(?>'))/) &&
+                @scanner[1]
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%\()(?>(?>(?>\\)(?>.)|[^)])*)(?>\)))/) &&
+                @scanner[1]
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%\{)(?>(?>(?>\\)(?>.)|[^}])*)(?>\}))/) &&
+                @scanner[1]
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%\[)(?>(?>(?>\\)(?>.)|[^\]])*)(?>\]))/) &&
+                @scanner[1]
+              end ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%<)(?>(?>(?>\\)(?>.)|[^>])*)(?>>))/) &&
+                @scanner[1]
+              end ||
+              begin
+                p1 = @scanner.pos
+                begin
+                  @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
+                  begin
+                    p2 = @scanner.pos
+                    begin
+                      @scanner.skip(/%/) &&
+                      (r2_0 = @scanner.scan(/[[:punct:]]/)) &&
+                      begin
+                        while begin
+                          @scanner.skip(/(?>\\)(?>.)/) ||
+                          begin
+                            p3 = @scanner.pos
+                            begin
+                              @scanner.skip(/(?!#{r2_0})/) &&
+                              @scanner.skip(/./) &&
+                              true
+                            end || begin
+                              @scanner.pos = p3
+                              false
+                            end
+                          end
+                        end; end
+                        true
+                      end &&
+                      @scanner.skip(/#{r2_0}/) &&
+                      @scanner.string[p2...(@scanner.pos)]
+                    end || begin
+                      @scanner.pos = p2
+                      false
+                    end
+                  end
+                end || begin
+                  @scanner.pos = p1
+                  false
+                end
+              end
+            end) &&
+            Fail.parsed([r0_0, r0_1])
           end || begin
             @scanner.pos = p0
             false
           end
         end ||
-        ((r = match(:ws_decl)) && (set_ws r))
+        match(:labeled) ||
+        match(:labelable)
+      end
+      
+      # @private
+      def match_labeled #:nodoc:
+        memoize :match_labeled!
       end
       
       # @private
-      def match_ws_decl #:nodoc:
+      def match_labeled! #:nodoc:
         p0 = @scanner.pos
         begin
-          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%whitespace)(?>(?![[:alnum:]_])))/) &&
-          match(:unattributed)
+          (r0_0 = begin
+            @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:lower:]])(?>(?>[[:alnum:]_])*)))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>:))/) &&
+            @scanner[1]
+          end) &&
+          (r0_1 = match(:labelable)) &&
+          Label.parsed(select_captures([r0_0, r0_1]))
         end || begin
           @scanner.pos = p0
           false
@@ -176,97 +458,96 @@ module Rattler
       end
       
       # @private
-      def match_wc_directive #:nodoc:
+      def match_labelable #:nodoc:
+        memoize :match_labelable!
+      end
+      
+      # @private
+      def match_labelable! #:nodoc:
+        match(:list) ||
+        match(:list_term)
+      end
+      
+      # @private
+      def match_list #:nodoc:
+        memoize :match_list!
+      end
+      
+      # @private
+      def match_list! #:nodoc:
         begin
           p0 = @scanner.pos
           begin
-            (r0_0 = match(:wc_decl)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{)/) &&
-            (start_wc r0_0)
+            (r0_0 = match(:list_term)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\*,)/) &&
+            (r0_1 = match(:list_term)) &&
+            List.parsed(select_captures([r0_0, r0_1]))
           end || begin
             @scanner.pos = p0
             false
           end
         end ||
-        ((r = match(:wc_decl)) && (set_wc r))
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:list_term)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\+,)/) &&
+            (r0_1 = match(:list_term)) &&
+            List1.parsed(select_captures([r0_0, r0_1]))
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end
       end
       
       # @private
-      def match_wc_decl #:nodoc:
-        p0 = @scanner.pos
-        begin
-          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%word_character)(?>(?![[:alnum:]_])))/) &&
-          match(:unattributed)
-        end || begin
-          @scanner.pos = p0
-          false
-        end
+      def match_list_term #:nodoc:
+        memoize :match_list_term!
       end
       
       # @private
-      def match_block_close #:nodoc:
-        @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\})/) &&
-        (end_block)
+      def match_list_term! #:nodoc:
+        match(:prefixed) ||
+        match(:prefixable) ||
+        (fail! { "term expected" })
       end
       
       # @private
-      def match_rule #:nodoc:
-        p0 = @scanner.pos
-        begin
-          (r0_0 = match(:identifier)) &&
-          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><\-)/) &&
-          (r0_1 = match(:expression)) &&
-          (rule *[r0_0, r0_1])
-        end || begin
-          @scanner.pos = p0
-          false
-        end
+      def match_prefixed #:nodoc:
+        memoize :match_prefixed!
       end
       
       # @private
-      def match_unattributed #:nodoc:
+      def match_prefixed! #:nodoc:
         begin
           p0 = @scanner.pos
           begin
-            (r0_0 = match(:unattributed)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\|)/) &&
-            (r0_1 = match(:terms)) &&
-            Choice.parsed(select_captures([r0_0, r0_1]))
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>&)/) &&
+            (r0_0 = match(:prefixable)) &&
+            Assert.parsed(select_captures([r0_0]))
           end || begin
             @scanner.pos = p0
             false
           end
         end ||
-        match(:terms)
-      end
-      
-      # @private
-      def match_expression #:nodoc:
         begin
           p0 = @scanner.pos
           begin
-            (r0_0 = match(:expression)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\|)/) &&
-            (r0_1 = match(:attributed)) &&
-            Choice.parsed(select_captures([r0_0, r0_1]))
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>!)/) &&
+            (r0_0 = match(:prefixable)) &&
+            Disallow.parsed(select_captures([r0_0]))
           end || begin
             @scanner.pos = p0
             false
           end
         end ||
-        match(:attributed)
-      end
-      
-      # @private
-      def match_attributed #:nodoc:
         begin
           p0 = @scanner.pos
           begin
-            (r0_0 = match(:attributed)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><)/) &&
-            (r0_1 = ((r = match(:dispatch)) ? [r] : [])) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>>)/) &&
-            DispatchAction.parsed(select_captures([r0_0, r0_1]))
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>~)/) &&
+            (r0_0 = match(:prefixable)) &&
+            Skip.parsed(select_captures([r0_0]))
           end || begin
             @scanner.pos = p0
             false
@@ -275,260 +556,34 @@ module Rattler
         begin
           p0 = @scanner.pos
           begin
-            (r0_0 = match(:attributed)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{)/) &&
-            (r0_1 = match(:action)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\})/) &&
-            DirectAction.parsed(select_captures([r0_0, r0_1]))
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>@)/) &&
+            (r0_0 = match(:prefixable)) &&
+            Token.parsed(select_captures([r0_0]))
           end || begin
             @scanner.pos = p0
             false
           end
-        end ||
-        match(:terms)
+        end
       end
       
       # @private
-      def match_dispatch #:nodoc:
-        p0 = @scanner.pos
-        begin
-          @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-          begin
-            p1 = @scanner.pos
-            begin
-              match(:name) &&
-              begin
-                begin
-                  p2 = @scanner.pos
-                  begin
-                    @scanner.skip(/\./) &&
-                    match(:var_name) &&
-                    true
-                  end || begin
-                    @scanner.pos = p2
-                    false
-                  end
-                end
-                true
-              end &&
-              @scanner.string[p1...(@scanner.pos)]
-            end || begin
-              @scanner.pos = p1
-              false
-            end
-          end
-        end || begin
-          @scanner.pos = p0
-          false
-        end
-      end
-      
-      # @private
-      def match_action #:nodoc:
-        p0 = @scanner.pos
-        begin
-          @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-          @scanner.scan(/(?>(?>\{)(?>(?>[^}])*)(?>\})|[^{}])*/)
-        end || begin
-          @scanner.pos = p0
-          false
-        end
-      end
-      
-      # @private
-      def match_terms #:nodoc:
-        begin
-          p0 = @scanner.pos
-          begin
-            (r0_0 = match(:terms)) &&
-            (r0_1 = match(:term)) &&
-            Sequence.parsed(select_captures([r0_0, r0_1]))
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        match(:term)
-      end
-      
-      # @private
-      def match_term #:nodoc:
-        match(:fail_expr) ||
-        match(:labeled) ||
-        match(:labelable)
-      end
-      
-      # @private
-      def match_fail_expr #:nodoc:
-        p0 = @scanner.pos
-        begin
-          (r0_0 = begin
-            begin
-              p1 = @scanner.pos
-              begin
-                @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-                @scanner.scan(/(?>fail)(?>(?![[:alnum:]_]))/)
-              end || begin
-                @scanner.pos = p1
-                false
-              end
-            end ||
-            begin
-              p1 = @scanner.pos
-              begin
-                @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-                @scanner.scan(/(?>fail_rule)(?>(?![[:alnum:]_]))/)
-              end || begin
-                @scanner.pos = p1
-                false
-              end
-            end ||
-            begin
-              p1 = @scanner.pos
-              begin
-                @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-                @scanner.scan(/(?>fail_parse)(?>(?![[:alnum:]_]))/)
-              end || begin
-                @scanner.pos = p1
-                false
-              end
-            end
-          end) &&
-          (r0_1 = match(:fail_arg)) &&
-          Fail.parsed(select_captures([r0_0, r0_1]))
-        end || begin
-          @scanner.pos = p0
-          false
-        end
-      end
-      
-      # @private
-      def match_fail_arg #:nodoc:
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\()/) &&
-            (r0_0 = match(:literal)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\))/) &&
-            r0_0
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        match(:literal)
-      end
-      
-      # @private
-      def match_labeled #:nodoc:
-        p0 = @scanner.pos
-        begin
-          (r0_0 = match(:var_name)) &&
-          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>:)/) &&
-          (r0_1 = match(:labelable)) &&
-          Label.parsed(select_captures([r0_0, r0_1]))
-        end || begin
-          @scanner.pos = p0
-          false
-        end
-      end
-      
-      # @private
-      def match_labelable #:nodoc:
-        match(:list) ||
-        match(:list_term)
-      end
-      
-      # @private
-      def match_list #:nodoc:
-        begin
-          p0 = @scanner.pos
-          begin
-            (r0_0 = match(:list_term)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\*\^)/) &&
-            (r0_1 = match(:list_term)) &&
-            List.parsed(select_captures([r0_0, r0_1]))
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            (r0_0 = match(:list_term)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\+\^)/) &&
-            (r0_1 = match(:list_term)) &&
-            List1.parsed(select_captures([r0_0, r0_1]))
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end
-      end
-      
-      # @private
-      def match_list_term #:nodoc:
-        match(:prefixed) ||
-        match(:prefixable)
-      end
-      
-      # @private
-      def match_prefixed #:nodoc:
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>&)/) &&
-            (r0_0 = match(:prefixable)) &&
-            Assert.parsed(select_captures([r0_0]))
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>!)/) &&
-            (r0_0 = match(:prefixable)) &&
-            Disallow.parsed(select_captures([r0_0]))
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>~)/) &&
-            (r0_0 = match(:prefixable)) &&
-            Skip.parsed(select_captures([r0_0]))
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>@)/) &&
-            (r0_0 = match(:prefixable)) &&
-            Token.parsed(select_captures([r0_0]))
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end
+      def match_prefixable #:nodoc:
+        memoize :match_prefixable!
       end
       
       # @private
-      def match_prefixable #:nodoc:
+      def match_prefixable! #:nodoc:
         match(:suffixed) ||
         match(:primary)
       end
       
       # @private
       def match_suffixed #:nodoc:
+        memoize :match_suffixed!
+      end
+      
+      # @private
+      def match_suffixed! #:nodoc:
         begin
           p0 = @scanner.pos
           begin
@@ -544,16 +599,7 @@ module Rattler
           p0 = @scanner.pos
           begin
             (r0_0 = match(:primary)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\*)/) &&
-            begin
-              p1 = @scanner.pos
-              r = !begin
-                @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-                @scanner.skip(/\^/)
-              end
-              @scanner.pos = p1
-              r
-            end &&
+            @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\*))(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,))/) &&
             ZeroOrMore.parsed(select_captures([r0_0]))
           end || begin
             @scanner.pos = p0
@@ -564,16 +610,7 @@ module Rattler
           p0 = @scanner.pos
           begin
             (r0_0 = match(:primary)) &&
-            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\+)/) &&
-            begin
-              p1 = @scanner.pos
-              r = !begin
-                @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-                @scanner.skip(/\^/)
-              end
-              @scanner.pos = p1
-              r
-            end &&
+            @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\+))(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,))/) &&
             OneOrMore.parsed(select_captures([r0_0]))
           end || begin
             @scanner.pos = p0
@@ -584,6 +621,11 @@ module Rattler
       
       # @private
       def match_primary #:nodoc:
+        memoize :match_primary!
+      end
+      
+      # @private
+      def match_primary! #:nodoc:
         begin
           p0 = @scanner.pos
           begin
@@ -596,442 +638,169 @@ module Rattler
             false
           end
         end ||
-        match(:atom)
-      end
-      
-      # @private
-      def match_atom #:nodoc:
         begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            (r0_0 = @scanner.scan(/(?>EOF)(?>(?![[:alnum:]_]))/)) &&
-            Eof.parsed([r0_0])
-          end || begin
-            @scanner.pos = p0
-            false
-          end
+          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>EOF)(?![[:alnum:]_]))/) &&
+          Eof.parsed([])
         end ||
-        ((r = match(:posix_class)) && (posix_class r)) ||
         begin
-          p0 = @scanner.pos
-          begin
-            (r0_0 = match(:identifier)) &&
+          (r = begin
             begin
-              p1 = @scanner.pos
-              r = !begin
-                @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-                @scanner.skip(/<\-/)
-              end
-              @scanner.pos = p1
-              r
-            end &&
-            Apply.parsed(select_captures([r0_0]))
-          end || begin
-            @scanner.pos = p0
-            false
-          end
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>ALNUM)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>ALPHA)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>ASCII)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>BLANK)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>CNTRL)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>DIGIT)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>GRAPH)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>LOWER)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>PRINT)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>PUNCT)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>SPACE)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>UPPER)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>XDIGIT)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>WORD)(?![[:alnum:]_]))/) &&
+              @scanner[1]
+            end ||
+            (fail! { "posix_class expected" })
+          end) && (posix_class r)
         end ||
-        ((r = match(:literal)) && (literal r)) ||
-        ((r = match(:word_literal)) && (word_literal r)) ||
-        ((r = match(:class)) && (char_class r)) ||
-        ((r = match(:regexp)) && Match.parsed([r])) ||
-        begin
-          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\.)/) &&
-          (Match[/./])
-        end
-      end
-      
-      # @private
-      def match_posix_class #:nodoc:
         begin
           p0 = @scanner.pos
           begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>ALNUM)(?>(?![[:alnum:]_]))/)
+            @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>EOF)(?![[:alnum:]_])))/) &&
+            (r0_0 = begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:alnum:]_])+)/) &&
+              @scanner[1]
+            end) &&
+            @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><\-))/) &&
+            Apply.parsed([r0_0])
           end || begin
             @scanner.pos = p0
             false
           end
         end ||
         begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>ALPHA)(?>(?![[:alnum:]_]))/)
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>ASCII)(?>(?![[:alnum:]_]))/)
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>BLANK)(?>(?![[:alnum:]_]))/)
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>CNTRL)(?>(?![[:alnum:]_]))/)
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>DIGIT)(?>(?![[:alnum:]_]))/)
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>GRAPH)(?>(?![[:alnum:]_]))/)
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>LOWER)(?>(?![[:alnum:]_]))/)
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>PRINT)(?>(?![[:alnum:]_]))/)
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>PUNCT)(?>(?![[:alnum:]_]))/)
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>SPACE)(?>(?![[:alnum:]_]))/)
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>UPPER)(?>(?![[:alnum:]_]))/)
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>XDIGIT)(?>(?![[:alnum:]_]))/)
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end ||
-        begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-            @scanner.scan(/(?>WORD)(?>(?![[:alnum:]_]))/)
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end
-      end
-      
-      # @private
-      def match_literal #:nodoc:
-        p0 = @scanner.pos
-        begin
-          @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-          @scanner.scan(/(["'])(?:\\.|(?:(?!\1).))*\1/)
-        end || begin
-          @scanner.pos = p0
-          false
-        end
-      end
-      
-      # @private
-      def match_word_literal #:nodoc:
-        p0 = @scanner.pos
-        begin
-          @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-          @scanner.scan(/(?>`)(?>(?>(?>\\)(?>.)|[^`])*)(?>`)/)
-        end || begin
-          @scanner.pos = p0
-          false
-        end
-      end
-      
-      # @private
-      def match_class #:nodoc:
-        p0 = @scanner.pos
-        begin
-          @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-          begin
-            p1 = @scanner.pos
+          (r = begin
             begin
-              @scanner.skip(/\[/) &&
-              begin
-                r = false
-                while begin
-                  p2 = @scanner.pos
-                  begin
-                    @scanner.skip(/(?!\])/) &&
-                    match(:range) &&
-                    true
-                  end || begin
-                    @scanner.pos = p2
-                    false
-                  end
-                end
-                  r = true
-                end
-                r
-              end &&
-              @scanner.skip(/\]/) &&
-              @scanner.string[p1...(@scanner.pos)]
-            end || begin
-              @scanner.pos = p1
-              false
-            end
-          end
-        end || begin
-          @scanner.pos = p0
-          false
-        end
-      end
-      
-      # @private
-      def match_regexp #:nodoc:
-        p0 = @scanner.pos
-        begin
-          @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-          @scanner.scan(/\/(?:\\.|[^\/])+\/(?:[iomx]+(?!\w))?/)
-        end || begin
-          @scanner.pos = p0
-          false
-        end
-      end
-      
-      # @private
-      def match_name #:nodoc:
-        match(:var_name) ||
-        match(:constant)
-      end
-      
-      # @private
-      def match_identifier #:nodoc:
-        p0 = @scanner.pos
-        begin
-          begin
-            p1 = @scanner.pos
-            r = !begin
-              @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-              @scanner.skip(/(?>EOF)(?>(?![[:alnum:]_]))/)
-            end
-            @scanner.pos = p1
-            r
-          end &&
-          begin
-            p1 = @scanner.pos
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>")(?>(?>(?>\\)(?>.)|[^"])*)(?>"))/) &&
+              @scanner[1]
+            end ||
             begin
-              @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-              @scanner.scan(/(?>[[:alnum:]_])+/)
-            end || begin
-              @scanner.pos = p1
-              false
-            end
-          end
-        end || begin
-          @scanner.pos = p0
-          false
-        end
-      end
-      
-      # @private
-      def match_var_name #:nodoc:
-        p0 = @scanner.pos
-        begin
-          @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-          @scanner.scan(/(?>[[:lower:]])(?>(?>[[:alnum:]_])*)/)
-        end || begin
-          @scanner.pos = p0
-          false
-        end
-      end
-      
-      # @private
-      def match_constant #:nodoc:
-        p0 = @scanner.pos
-        begin
-          @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-          begin
-            p1 = @scanner.pos
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>')(?>(?>(?>\\)(?>.)|[^'])*)(?>'))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%\()(?>(?>(?>\\)(?>.)|[^)])*)(?>\)))/) &&
+              @scanner[1]
+            end ||
             begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%\{)(?>(?>(?>\\)(?>.)|[^}])*)(?>\}))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%\[)(?>(?>(?>\\)(?>.)|[^\]])*)(?>\]))/) &&
+              @scanner[1]
+            end ||
+            begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>%<)(?>(?>(?>\\)(?>.)|[^>])*)(?>>))/) &&
+              @scanner[1]
+            end ||
+            begin
+              p0 = @scanner.pos
               begin
-                while begin
-                  p2 = @scanner.pos
+                @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
+                begin
+                  p1 = @scanner.pos
                   begin
-                    match(:const_name) &&
-                    @scanner.skip(/::/) &&
-                    true
+                    @scanner.skip(/%/) &&
+                    (r1_0 = @scanner.scan(/[[:punct:]]/)) &&
+                    begin
+                      while begin
+                        @scanner.skip(/(?>\\)(?>.)/) ||
+                        begin
+                          p2 = @scanner.pos
+                          begin
+                            @scanner.skip(/(?!#{r1_0})/) &&
+                            @scanner.skip(/./) &&
+                            true
+                          end || begin
+                            @scanner.pos = p2
+                            false
+                          end
+                        end
+                      end; end
+                      true
+                    end &&
+                    @scanner.skip(/#{r1_0}/) &&
+                    @scanner.string[p1...(@scanner.pos)]
                   end || begin
-                    @scanner.pos = p2
+                    @scanner.pos = p1
                     false
                   end
-                end; end
-                true
-              end &&
-              match(:const_name) &&
-              @scanner.string[p1...(@scanner.pos)]
-            end || begin
-              @scanner.pos = p1
-              false
+                end
+              end || begin
+                @scanner.pos = p0
+                false
+              end
             end
-          end
-        end || begin
-          @scanner.pos = p0
-          false
-        end
-      end
-      
-      # @private
-      def match_const_name #:nodoc:
-        p0 = @scanner.pos
+          end) && (literal r)
+        end ||
         begin
-          @scanner.skip(/(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*/) &&
-          @scanner.scan(/(?>[[:upper:]])(?>(?>[[:alnum:]_])*)/)
-        end || begin
-          @scanner.pos = p0
-          false
-        end
-      end
-      
-      # @private
-      def match_range #:nodoc:
+          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>`)(?>(?>(?>\\)(?>.)|[^`])*)(?>`))/) &&
+          (word_literal @scanner[1])
+        end ||
         begin
-          p0 = @scanner.pos
-          begin
-            @scanner.skip(/\[:/) &&
-            match(:posix_name) &&
-            @scanner.skip(/:\]/) &&
-            @scanner.string[p0...(@scanner.pos)]
-          end || begin
-            @scanner.pos = p0
-            false
-          end
+          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>\[)(?>(?>(?!\])(?>(?>\[:)(?>(?>alnum)(?![[:alnum:]_])|(?>alpha)(?![[:alnum:]_])|(?>ascii)(?![[:alnum:]_])|(?>blank)(?![[:alnum:]_])|(?>cntrl)(?![[:alnum:]_])|(?>digit)(?![[:alnum:]_])|(?>graph)(?![[:alnum:]_])|(?>lower)(?![[:alnum:]_])|(?>print)(?![[:alnum:]_])|(?>punct)(?![[:alnum:]_])|(?>space)(?![[:alnum:]_])|(?>upper)(?![[:alnum:]_])|(?>xdigit)(?![[:alnum:]_]))(?>:\])|(?>(?>\\)(?>[0-3])(?>[0-7])(?>[0-7])|(?>\\x)(?>[[:xdigit:]])(?>[[:xdigit:]])|(?>\\)(?>.)|[^\\\]])(?>(?>(?>\-)(?>(?>\\)(?>[0-3])(?>[0-7])(?>[0-7])|(?>\\x)(?>[[:xdigit:]])(?>[[:xdigit:]])|(?>\\)(?>.)|[^\\\]]))?)))+)(?>\]))/) &&
+          (char_class @scanner[1])
         end ||
         begin
-          p0 = @scanner.pos
-          begin
-            match(:class_char) &&
-            begin
-              begin
-                p1 = @scanner.pos
-                begin
-                  @scanner.skip(/\-/) &&
-                  match(:class_char) &&
-                  true
-                end || begin
-                  @scanner.pos = p1
-                  false
-                end
-              end
-              true
-            end &&
-            @scanner.string[p0...(@scanner.pos)]
-          end || begin
-            @scanner.pos = p0
-            false
-          end
-        end
-      end
-      
-      # @private
-      def match_posix_name #:nodoc:
-        @scanner.scan(/(?>alnum)(?>(?![[:alnum:]_]))/) ||
-        @scanner.scan(/(?>alpha)(?>(?![[:alnum:]_]))/) ||
-        @scanner.scan(/(?>ascii)(?>(?![[:alnum:]_]))/) ||
-        @scanner.scan(/(?>blank)(?>(?![[:alnum:]_]))/) ||
-        @scanner.scan(/(?>cntrl)(?>(?![[:alnum:]_]))/) ||
-        @scanner.scan(/(?>digit)(?>(?![[:alnum:]_]))/) ||
-        @scanner.scan(/(?>graph)(?>(?![[:alnum:]_]))/) ||
-        @scanner.scan(/(?>lower)(?>(?![[:alnum:]_]))/) ||
-        @scanner.scan(/(?>print)(?>(?![[:alnum:]_]))/) ||
-        @scanner.scan(/(?>punct)(?>(?![[:alnum:]_]))/) ||
-        @scanner.scan(/(?>space)(?>(?![[:alnum:]_]))/) ||
-        @scanner.scan(/(?>upper)(?>(?![[:alnum:]_]))/) ||
-        @scanner.scan(/(?>xdigit)(?>(?![[:alnum:]_]))/) ||
-        @scanner.scan(/(?>word)(?>(?![[:alnum:]_]))/)
-      end
-      
-      # @private
-      def match_class_char #:nodoc:
-        @scanner.scan(/(?>\\)(?>[0-3])(?>[0-7])(?>[0-7])|(?>\\x)(?>[[:xdigit:]])(?>[[:xdigit:]])|(?>\\)(?>.)|[^\\\]]/)
-      end
-      
-      # @private
-      def match_eol #:nodoc:
-        p0 = @scanner.pos
+          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>\$)(?>[[:lower:]])(?>(?>[[:alnum:]_])*))/) &&
+          BackReference.parsed([@scanner[1]])
+        end ||
         begin
-          @scanner.skip(/(?>[[:blank:]])*/) &&
-          begin
-            @scanner.eos? ||
-            @scanner.skip(/;|(?>(?>\r)?)(?>\n)|(?>\#)(?>(?>[^\n])*)/)
-          end &&
-          true
-        end || begin
-          @scanner.pos = p0
-          false
-        end
+          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\.)/) &&
+          (Match[/./])
+        end ||
+        (fail! { "atom expected" })
       end
       
     end