rattler 0.5.0 → 0.6.0

data/features/step_definitions/grammar_steps.rb

@@ -1,13 +1,23 @@
-Given /grammar with\:/ do |source|
-  @parser_class = Rattler.compile_parser(source)
+Given /grammar with:$/ do |source|
+  @source = source
 end
 
-Given /class definition\:/ do |source|
+Given /grammar called "([^\"]*)" with:$/ do |name, source|
+  Rattler.compile((::Grammars[name.to_sym] = Module.new), source)
+end
+
+Given /class definition:$/ do |source|
   eval(source, TOPLEVEL_BINDING)
 end
 
+When /generate parser code$/ do
+  model = Rattler::Compiler::GrammarParser.parse!(@source)
+  @parser_code = Rattler::Compiler::ParserGenerator.code_for(model)
+end
+
 When /parse ([^[:alpha:]].*)$/ do |expr|
-  @parser = @parser_class.new(eval(expr, TOPLEVEL_BINDING))
+  parser_class = Rattler.compile_parser(@source)
+  @parser = parser_class.new(eval(expr, TOPLEVEL_BINDING))
 end
 
 When /parse position is (.+)$/ do |expr|
@@ -23,7 +33,7 @@ Then /parse should fail/ do
 end
 
 Then /parse result should be FAIL$/ do
-  Then "parse should fail"
+  step "parse should fail"
 end
 
 Then /parse position should be (.+)$/ do |expr|
@@ -41,3 +51,7 @@ end
 Then /^\$x should be (.+)$/ do |expr|
   $x.should == eval(expr, TOPLEVEL_BINDING)
 end
+
+Then /^the code should contain:$/ do |partial_content|
+  @parser_code.should include(partial_content)
+end

data/features/support/env.rb

@@ -13,6 +13,11 @@ require 'rattler'
 require 'rspec/expectations'
 require 'aruba/cucumber'
 
+::Grammars = {}
+def Object.const_missing(name)
+  ::Grammars[name] || super
+end
+
 Before do
   @aruba_timeout_seconds = 5
 end

data/lib/rattler.rb

@@ -1,79 +1,56 @@
-#
-# = rattler.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-
 # Rattler - Ruby Tool for Language Recognition
 #
-# @author Jason Arhart
 module Rattler
-  
+
   autoload :Runtime, 'rattler/runtime'
-  autoload :Grammar, 'rattler/grammar'  
   autoload :Parsers, 'rattler/parsers'
-  autoload :BackEnd, 'rattler/back_end'
+  autoload :Compiler, 'rattler/compiler'
   autoload :Util, 'rattler/util'
-  
+
   # Convenience methods for defining parsers
-  #
-  # @author Jason Arhart
   module HelperMethods
-    
+
     # @private
     @@defaults = {
       :type => :extended_packrat
     }
-    
+
     # @private
     @@parser_types = {
       :recursive_descent  => :RecursiveDescentParser,
       :packrat            => :PackratParser,
       :extended_packrat   => :ExtendedPackratParser
     }
-    
-    # Define parse rules with the given block
-    #
-    # @return [Rattler::Parsers::Rules] a set of parse rules
-    #
-    def define_rules(&block)
-      Rattler::Parsers.define(&block)
-    end
-    
-    # Define a parser with the given block and compile it into a parser class
+
+    # Define a parser with the given grammar and compile it into a parser class
     # using the given options
     #
     # @return [Class] a new parser class
-    def compile_parser(*args, &block)
-      options = @@defaults
+    def compile_parser(*args)
+      options = @@defaults.dup
       grammar = nil
       for arg in args
         case arg
-        when Hash then options = options.merge(arg)
+        when Hash then options.merge!(arg)
         when String then grammar = arg
         end
       end
-      base_class = options.fetch(:class) do
-        Rattler::Runtime::const_get @@parser_types[options[:type]]
-      end
-      Rattler::BackEnd::Compiler.compile_parser(base_class,
-        grammar || Rattler::Parsers.define(&block))
+      base_class = options.delete(:class) ||
+        (Rattler::Runtime::const_get @@parser_types[options[:type]])
+      Rattler::Compiler.compile_parser(base_class, grammar, options)
     end
-    
-    # Define a parser with the given block and compile it into match methods in
-    # the given module
-    def compile(mod, grammar=nil, &block)
-      grammar_or_rules = grammar || Rattler::Parsers.define(&block)
-      Rattler::BackEnd::Compiler.compile(mod, grammar_or_rules)
+
+    # (see Rattler::Compiler::ModuleMethods#compile)
+    def compile(mod, grammar_or_parser, opts={})
+      Rattler::Compiler.compile(mod, grammar_or_parser, opts)
     end
-    
+
   end
-  
+
   include HelperMethods
-  
+
   class <<self
     include HelperMethods
   end
-  
+
 end

data/lib/rattler/compiler.rb

@@ -0,0 +1,69 @@
+require 'rattler'
+
+module Rattler
+
+  # The +Compiler+ module contains the classes and methods used to turn
+  # parser models into ruby code.
+  module Compiler
+    autoload :GrammarParser, 'rattler/compiler/grammar_parser'
+    autoload :Metagrammar, 'rattler/compiler/metagrammar'
+    autoload :ParserGenerator, 'rattler/compiler/parser_generator'
+    autoload :RubyGenerator, 'rattler/compiler/ruby_generator'
+    autoload :Optimizer, 'rattler/compiler/optimizer'
+
+    # Compiler module methods
+    module ModuleMethods
+
+      include Rattler::Parsers
+
+      # Compile grammar source or a parser model into a new parser subclass of
+      # +base+.
+      #
+      # @overload compile(base, grammar, opts)
+      #   @param [Class] base the base class for the new parser class
+      #   @param [String] grammar the grammar source to compile
+      #   @return [Class] a new sublcass of +base+ with compiled match methods
+      #
+      # @overload compile(base, parser, opts)
+      #   @param [Class] base the base class for the new parser class
+      #   @param [Rattler::Parsers::Grammar,Rattler::Parsers::RuleSet,Rattler::Parsers::Rule]
+      #     parser the parser model to compile
+      #   @return [Class] a new sublcass of +base+ with compiled match methods
+      #
+      def compile_parser(base, grammar_or_parser, opts={})
+        compile(Class.new(base), grammar_or_parser, opts)
+      end
+
+      # Compile grammar source or a parser model into match methods in a
+      # module.
+      #
+      # @overload compile(mod, grammar, opts)
+      #   @param [Module] mod the target module for the match methods
+      #   @param [String] grammar the grammar source to compile
+      #   @return [Module] +mod+
+      #
+      # @overload compile(mod, parser, opts)
+      #   @param [Module] mod the target module for the match methods
+      #   @param [Rattler::Parsers::Grammar,Rattler::Parsers::RuleSet,Rattler::Parsers::Rule]
+      #     parser the parser model to compile
+      #   @return [Module] +mod+
+      #
+      def compile(mod, grammar_or_parser, opts={})
+        model = parser_model(grammar_or_parser)
+        mod.module_eval ParserGenerator.code_for(model, opts)
+        mod
+      end
+
+      private
+
+      def parser_model(arg)
+        case arg
+        when Grammar, RuleSet, Rule then arg
+        else GrammarParser.parse!(arg.to_str)
+        end
+      end
+    end
+
+    extend ModuleMethods
+  end
+end

data/lib/rattler/{grammar → compiler}/grammar_parser.rb

@@ -1,12 +1,6 @@
-#
-# = rattler/grammar/grammar_parser.rb
-#
-# Author:: Jason Arhart
-# Documentation:: Author
-#
-require 'rattler/grammar'
-
-module Rattler::Grammar
+require 'rattler/compiler'
+
+module Rattler::Compiler
   # @private
   class GrammarParser < Rattler::Runtime::ExtendedPackratParser #:nodoc:
 
@@ -23,6 +17,21 @@ module Rattler::Grammar
 
     private
 
+    def expand_relative(e)
+      "File.expand_path(#{e}, File.dirname(__FILE__))"
+    end
+
+    def heading(requires, modules, includes, start)
+      requires.
+        merge(modules.first || {}).
+        merge(includes).
+        merge(start.first || {})
+    end
+
+    def parser_decl(name, base)
+      {:parser_name => name, :base_name => base.first}
+    end
+
     def start_ws(e)
       @directive_stack.push :type => :ws, :value => @ws
       set_ws e
@@ -52,25 +61,28 @@ module Rattler::Grammar
       @inline = true
     end
 
+    def start_fragments
+      @directive_stack.push :type => :fragments, :value => [@ws, @inline]
+      set_fragments
+    end
+
+    def set_fragments
+      @ws = nil
+      @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 :inline  then @inline = d[:value]
+        when :wc        then @wc = d[:value]
+        when :ws        then @ws = d[:value]
+        when :inline    then @inline = d[:value]
+        when :fragments then @ws, @inline = d[:value]
         end
         true
       end
     end
 
-    def heading(requires, modules, includes)
-      requires.merge(modules.first || {}).merge(includes)
-    end
-
-    def parser_decl(name, base)
-      {:parser_name => name, :base_name => base.first}
-    end
-
     def list0(term_parser, sep_parser)
       ListParser[term_parser, sep_parser, 0, nil]
     end
@@ -79,20 +91,24 @@ module Rattler::Grammar
       ListParser[term_parser, sep_parser, 1, nil]
     end
 
+    def attributed(o, action)
+      (o + [action]).reduce {|s, a| s >> a }
+    end
+
     def optional(parser)
-      Repeat[parser, 0, 1]
+      parser.optional
     end
 
     def zero_or_more(parser)
-      Repeat[parser, 0, nil]
+      parser.zero_or_more
     end
 
     def one_or_more(parser)
-      Repeat[parser, 1, nil]
+      parser.one_or_more
     end
 
     def rule(name, parser)
-      Rule[name, (@ws ? parser.with_ws(@ws) : parser), {:inline => @inline}]
+      Rule[name, finish_expr(parser, name), {:inline => @inline}]
     end
 
     def literal(e)
@@ -115,5 +131,23 @@ module Rattler::Grammar
       end
     end
 
+    def finish_expr(parser, rule_name)
+      parser = finish_super(parser, rule_name)
+      @ws ? parser.with_ws(@ws) : parser
+    end
+
+    def finish_super(parser, rule_name)
+      case parser
+      when Super
+        parser.with_attrs(:rule_name => rule_name)
+      when Eof, ESymbol
+        parser
+      when Parser
+        parser.with_children(parser.map {|_| finish_super(_, rule_name) })
+      else
+        parser
+      end
+    end
+
   end
 end

data/lib/rattler/compiler/metagrammar.rb

@@ -0,0 +1,1570 @@
+# encoding: utf-8
+
+require 'rattler/compiler'
+
+module Rattler
+  module Compiler
+    # @private
+    module Metagrammar #:nodoc:
+      
+      include Rattler::Parsers
+      
+      # @private
+      def start_rule #:nodoc:
+        :grammar
+      end
+      
+      # @private
+      def match_grammar #:nodoc:
+        apply :match_grammar!
+      end
+      
+      # @private
+      def match_grammar! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:heading)) &&
+            (r0_1 = match(:rules)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)\z/) &&
+            Grammar.parsed(select_captures([r0_0, r0_1]))
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :grammar }
+      end
+      
+      # @private
+      def match_heading #:nodoc:
+        apply :match_heading!
+      end
+      
+      # @private
+      def match_heading! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:requires)) &&
+            (r0_1 = ((r = match(:module_decl)) ? [r] : [])) &&
+            (r0_2 = match(:includes)) &&
+            (r0_3 = ((r = match(:start_directive)) ? [r] : [])) &&
+            (heading r0_0, r0_1, r0_2, r0_3)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :heading }
+      end
+      
+      # @private
+      def match_requires #:nodoc:
+        apply :match_requires!
+      end
+      
+      # @private
+      def match_requires! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = begin
+              a0 = []
+              while r = match(:require_statement)
+                a0 << r
+              end
+              select_captures(a0)
+            end) &&
+            ({ :requires => r0_0 })
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :requires }
+      end
+      
+      # @private
+      def match_require_statement #:nodoc:
+        apply :match_require_statement!
+      end
+      
+      # @private
+      def match_require_statement! #:nodoc:
+        begin
+          @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>require)(?![[:alnum:]_])))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?!(?>(?>[[:blank:]])*)(?>\z|;|(?>(?>\r)?)(?>\n)|(?>\#)(?>(?>[^\n])*)))(?>.))+))(?>(?>(?>[[:blank:]])*)(?>\z|;|(?>(?>\r)?)(?>\n)|(?>\#)(?>(?>[^\n])*)))/) &&
+          @scanner[1]
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>require_relative)(?![[:alnum:]_]))/) &&
+            (r0_0 = begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?!(?>(?>[[:blank:]])*)(?>\z|;|(?>(?>\r)?)(?>\n)|(?>\#)(?>(?>[^\n])*)))(?>.))+)/) &&
+              @scanner[1]
+            end) &&
+            @scanner.skip(/(?>(?>[[:blank:]])*)(?>\z|;|(?>(?>\r)?)(?>\n)|(?>\#)(?>(?>[^\n])*))/) &&
+            (expand_relative r0_0)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :require_statement }
+      end
+      
+      # @private
+      def match_module_decl #:nodoc:
+        apply :match_module_decl!
+      end
+      
+      # @private
+      def match_module_decl! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>parser)(?![[:alnum:]_]))/) &&
+            (r0_0 = begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>(?>[[:upper:]])(?>(?>[[:alnum:]_])*)(?>::))*)(?>[[:upper:]])(?>(?>[[:alnum:]_])*))/) &&
+              @scanner[1]
+            end) &&
+            (r0_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 r0_0, r0_1)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>grammar)(?![[:alnum:]_]))/) &&
+            (r0_0 = begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>(?>[[:upper:]])(?>(?>[[:alnum:]_])*)(?>::))*)(?>[[:upper:]])(?>(?>[[:alnum:]_])*))/) &&
+              @scanner[1]
+            end) &&
+            @scanner.skip(/(?>(?>[[:blank:]])*)(?>\z|;|(?>(?>\r)?)(?>\n)|(?>\#)(?>(?>[^\n])*))/) &&
+            ({ :grammar_name => r0_0 })
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :module_decl }
+      end
+      
+      # @private
+      def match_includes #:nodoc:
+        apply :match_includes!
+      end
+      
+      # @private
+      def match_includes! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = 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
+              a0
+            end) &&
+            ({ :includes => r0_0 })
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :includes }
+      end
+      
+      # @private
+      def match_start_directive #:nodoc:
+        apply :match_start_directive!
+      end
+      
+      # @private
+      def match_start_directive! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%start)(?![[:alnum:]_]))/) &&
+            (r0_0 = begin
+              p1 = @scanner.pos
+              begin
+                @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>EOF)(?![[:alnum:]_])))/) &&
+                begin
+                  @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:alpha:]])(?>(?>[[:alnum:]_])*))/) &&
+                  @scanner[1]
+                end
+              end || begin
+                @scanner.pos = p1
+                false
+              end
+            end) &&
+            ({ :start_rule => r0_0 })
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :start_directive }
+      end
+      
+      # @private
+      def match_rules #:nodoc:
+        apply :match_rules!
+      end
+      
+      # @private
+      def match_rules! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = begin
+              a0 = []
+              while r = begin
+                match(:directive) ||
+                match(:rule) ||
+                match(:block_close)
+              end
+                a0 << r
+              end
+              select_captures(a0)
+            end) &&
+            RuleSet.parsed(select_captures([r0_0]))
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :rules }
+      end
+      
+      # @private
+      def match_directive #:nodoc:
+        apply :match_directive!
+      end
+      
+      # @private
+      def match_directive! #:nodoc:
+        match(:ws_directive) ||
+        match(:wc_directive) ||
+        match(:inline_directive) ||
+        match(:fragments) ||
+        fail! { :directive }
+      end
+      
+      # @private
+      def match_ws_directive #:nodoc:
+        apply :match_ws_directive!
+      end
+      
+      # @private
+      def match_ws_directive! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:ws_decl)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{)/) &&
+            (start_ws r0_0)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:ws_decl)) &&
+            (set_ws r0_0)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :ws_directive }
+      end
+      
+      # @private
+      def match_ws_decl #:nodoc:
+        apply :match_ws_decl!
+      end
+      
+      # @private
+      def match_ws_decl! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%whitespace)(?![[:alnum:]_]))/) &&
+            match(:unattributed)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :ws_decl }
+      end
+      
+      # @private
+      def match_wc_directive #:nodoc:
+        apply :match_wc_directive!
+      end
+      
+      # @private
+      def match_wc_directive! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:wc_decl)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{)/) &&
+            (start_wc r0_0)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:wc_decl)) &&
+            (set_wc r0_0)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :wc_directive }
+      end
+      
+      # @private
+      def match_wc_decl #:nodoc:
+        apply :match_wc_decl!
+      end
+      
+      # @private
+      def match_wc_decl! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%word_character)(?![[:alnum:]_]))/) &&
+            match(:unattributed)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :wc_decl }
+      end
+      
+      # @private
+      def match_inline_directive #:nodoc:
+        apply :match_inline_directive!
+      end
+      
+      # @private
+      def match_inline_directive! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%inline)(?![[:alnum:]_]))/) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{)/) &&
+            (start_inline)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%inline)(?![[:alnum:]_]))/) &&
+            (set_inline)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :inline_directive }
+      end
+      
+      # @private
+      def match_fragments #:nodoc:
+        apply :match_fragments!
+      end
+      
+      # @private
+      def match_fragments! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%fragments)(?![[:alnum:]_]))/) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{)/) &&
+            (start_fragments)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>%fragments)(?![[:alnum:]_]))/) &&
+            (set_fragments)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :fragments }
+      end
+      
+      # @private
+      def match_block_close #:nodoc:
+        apply :match_block_close!
+      end
+      
+      # @private
+      def match_block_close! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\})/) &&
+            (end_block)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :block_close }
+      end
+      
+      # @private
+      def match_rule #:nodoc:
+        apply :match_rule!
+      end
+      
+      # @private
+      def match_rule! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = begin
+              p1 = @scanner.pos
+              begin
+                @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>EOF)(?![[:alnum:]_])))/) &&
+                begin
+                  @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:alpha:]])(?>(?>[[:alnum:]_])*))/) &&
+                  @scanner[1]
+                end
+              end || begin
+                @scanner.pos = p1
+                false
+              end
+            end) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><\-)/) &&
+            (r0_1 = match(:expression)) &&
+            (rule r0_0, r0_1)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :rule }
+      end
+      
+      # @private
+      def match_unattributed #:nodoc:
+        apply :match_unattributed!
+      end
+      
+      # @private
+      def match_unattributed! #: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]))
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        match(:terms) ||
+        fail! { :unattributed }
+      end
+      
+      # @private
+      def match_expression #:nodoc:
+        apply :match_expression!
+      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]))
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        match(:attributed) ||
+        fail! { :expression }
+      end
+      
+      # @private
+      def match_attributed #:nodoc:
+        apply :match_attributed!
+      end
+      
+      # @private
+      def match_attributed! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = ((r = match(:attributed)) ? [r] : [])) &&
+            (r0_1 = begin
+              match(:semantic_action) ||
+              match(:node_action)
+            end) &&
+            AttributedSequence.parsed(select_captures([r0_0, r0_1]))
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        match(:attributed_terms) ||
+        fail! { :attributed }
+      end
+      
+      # @private
+      def match_old_node_action #:nodoc:
+        apply :match_old_node_action!
+      end
+      
+      # @private
+      def match_old_node_action! #:nodoc:
+        begin
+          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>[[:lower:]])(?>(?>[[:alnum:]_])*))|(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>(?>(?>[[:upper:]])(?>(?>[[:alnum:]_])*)(?>::))*)(?>[[:upper:]])(?>(?>[[:alnum:]_])*)))(?>(?>(?>\.)(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>[[:lower:]])(?>(?>[[:alnum:]_])*))))?))/) &&
+          @scanner[1]
+        end ||
+        fail { :old_node_action }
+      end
+      
+      # @private
+      def match_semantic_action #:nodoc:
+        apply :match_semantic_action!
+      end
+      
+      # @private
+      def match_semantic_action! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\{)/) &&
+            (r0_0 = match(:action_code)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\})/) &&
+            SemanticAction.parsed(select_captures([r0_0]))
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :semantic_action }
+      end
+      
+      # @private
+      def match_action_code #:nodoc:
+        apply :match_action_code!
+      end
+      
+      # @private
+      def match_action_code! #:nodoc:
+        begin
+          @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>\{)(?>(?>[^}])*)(?>\})|[^{}])*)/) &&
+          @scanner[1]
+        end ||
+        fail { :action_code }
+      end
+      
+      # @private
+      def match_node_action #:nodoc:
+        apply :match_node_action!
+      end
+      
+      # @private
+      def match_node_action! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><)/) &&
+            (r0_0 = ((r = begin
+              p1 = @scanner.pos
+              begin
+                (r1_0 = begin
+                  begin
+                    @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:lower:]])(?>(?>[[:alnum:]_])*))/) &&
+                    @scanner[1]
+                  end ||
+                  begin
+                    @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>(?>(?>[[:upper:]])(?>(?>[[:alnum:]_])*)(?>::))*)(?>[[:upper:]])(?>(?>[[:alnum:]_])*))/) &&
+                    @scanner[1]
+                  end
+                end) &&
+                (r1_1 = ((r = begin
+                  @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\.))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:lower:]])(?>(?>[[:alnum:]_])*)))/) &&
+                  @scanner[1]
+                end) ? [r] : [])) &&
+                [r1_0, r1_1]
+              end || begin
+                @scanner.pos = p1
+                false
+              end
+            end) ? [r] : [])) &&
+            (r0_1 = ((r = 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
+                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) ? [r] : [])) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>>)/) &&
+            NodeAction.parsed([r0_0, r0_1])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :node_action }
+      end
+      
+      # @private
+      def match_attributed_terms #:nodoc:
+        apply :match_attributed_terms!
+      end
+      
+      # @private
+      def match_attributed_terms! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:attributed)) &&
+            (r0_1 = match(:term)) &&
+            Sequence.parsed(select_captures([r0_0, r0_1]))
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        match(:terms) ||
+        fail! { :attributed_terms }
+      end
+      
+      # @private
+      def match_terms #:nodoc:
+        apply :match_terms!
+      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) ||
+        fail! { :terms }
+      end
+      
+      # @private
+      def match_term #:nodoc:
+        apply :match_term!
+      end
+      
+      # @private
+      def match_term! #:nodoc:
+        match(:fail_expr) ||
+        match(:labeled) ||
+        match(:labelable) ||
+        fail! { :term }
+      end
+      
+      # @private
+      def match_fail_expr #:nodoc:
+        apply :match_fail_expr!
+      end
+      
+      # @private
+      def match_fail_expr! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (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 ||
+              begin
+                @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>expected)(?![[: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 ||
+        fail { :fail_expr }
+      end
+      
+      # @private
+      def match_labeled #:nodoc:
+        apply :match_labeled!
+      end
+      
+      # @private
+      def match_labeled! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:lower:]])(?>(?>[[:alnum:]_])*))/) &&
+              @scanner[1]
+            end) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>:)/) &&
+            (r0_1 = match(:labelable)) &&
+            Label.parsed(select_captures([r0_0, r0_1]))
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :labeled }
+      end
+      
+      # @private
+      def match_labelable #:nodoc:
+        apply :match_labelable!
+      end
+      
+      # @private
+      def match_labelable! #:nodoc:
+        match(:semantic_term) ||
+        match(:list) ||
+        match(:list_term) ||
+        fail! { :labelable }
+      end
+      
+      # @private
+      def match_semantic_term #:nodoc:
+        apply :match_semantic_term!
+      end
+      
+      # @private
+      def match_semantic_term! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\^)/) &&
+            match(:semantic_action)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>&)/) &&
+            (r0_0 = match(:semantic_action)) &&
+            (Assert[r0_0])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>!)/) &&
+            (r0_0 = match(:semantic_action)) &&
+            (Disallow[r0_0])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>~)/) &&
+            (r0_0 = match(:semantic_action)) &&
+            (Skip[r0_0])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :semantic_term }
+      end
+      
+      # @private
+      def match_list #:nodoc:
+        apply :match_list!
+      end
+      
+      # @private
+      def match_list! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:list_term)) &&
+            @scanner.skip(/(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\*))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,))/) &&
+            (r0_1 = match(:list_term)) &&
+            (list0 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])*))*)(?>\+))(?>(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,))/) &&
+            (r0_1 = match(:list_term)) &&
+            (list1 r0_0, r0_1)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:list_term)) &&
+            (r0_1 = match(:repeat_count)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,)/) &&
+            (r0_2 = match(:list_term)) &&
+            ListParser.parsed(select_captures([r0_0, r0_1, r0_2]))
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :list }
+      end
+      
+      # @private
+      def match_list_term #:nodoc:
+        apply :match_list_term!
+      end
+      
+      # @private
+      def match_list_term! #:nodoc:
+        match(:prefixed) ||
+        match(:prefixable) ||
+        (fail! { :term })
+      end
+      
+      # @private
+      def match_prefixed #:nodoc:
+        apply :match_prefixed!
+      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 ||
+        fail { :prefixed }
+      end
+      
+      # @private
+      def match_prefixable #:nodoc:
+        apply :match_prefixable!
+      end
+      
+      # @private
+      def match_prefixable! #:nodoc:
+        match(:prefixed) ||
+        match(:suffixable) ||
+        (fail! { :primary })
+      end
+      
+      # @private
+      def match_suffixed #:nodoc:
+        apply :match_suffixed!
+      end
+      
+      # @private
+      def match_suffixed! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:suffixable)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\?)/) &&
+            (optional r0_0)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:suffixable)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\*)/) &&
+            @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,))/) &&
+            (zero_or_more r0_0)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:suffixable)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\+)/) &&
+            @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,))/) &&
+            (one_or_more r0_0)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = match(:suffixable)) &&
+            (r0_1 = match(:repeat_count)) &&
+            @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>,))/) &&
+            Repeat.parsed(select_captures([r0_0, r0_1]))
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :suffixed }
+      end
+      
+      # @private
+      def match_repeat_count #:nodoc:
+        apply :match_repeat_count!
+      end
+      
+      # @private
+      def match_repeat_count! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:digit:]])+)/) &&
+              @scanner[1]
+            end) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\.\.)/) &&
+            (r0_1 = begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:digit:]])+)/) &&
+              @scanner[1]
+            end) &&
+            ([r0_0, r0_1].map {|s| s.to_i })
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:digit:]])+)/) &&
+              @scanner[1]
+            end) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\.\.)/) &&
+            ([r0_0.to_i, nil])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:digit:]])+)/) &&
+              @scanner[1]
+            end) &&
+            ([r0_0.to_i] * 2)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :repeat_count }
+      end
+      
+      # @private
+      def match_suffixable #:nodoc:
+        apply :match_suffixable!
+      end
+      
+      # @private
+      def match_suffixable! #:nodoc:
+        match(:suffixed) ||
+        match(:primary) ||
+        (fail! { :primary })
+      end
+      
+      # @private
+      def match_primary #:nodoc:
+        apply :match_primary!
+      end
+      
+      # @private
+      def match_primary! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\()/) &&
+            (r0_0 = match(:expression)) &&
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\))/) &&
+            r0_0
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        match(:atom) ||
+        fail! { :primary }
+      end
+      
+      # @private
+      def match_atom #:nodoc:
+        apply :match_atom!
+      end
+      
+      # @private
+      def match_atom! #:nodoc:
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>EOF)(?![[:alnum:]_]))/) &&
+            Eof.parsed([])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>E)(?![[:alnum:]_]))/) &&
+            ESymbol.parsed([])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>super)(?![[:alnum:]_]))/) &&
+            (Super[:pending])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = begin
+              begin
+                @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
+            end) &&
+            (posix_class r0_0)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = begin
+              p1 = @scanner.pos
+              begin
+                @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>(?>EOF)(?![[:alnum:]_])))/) &&
+                begin
+                  @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>[[:alpha:]])(?>(?>[[:alnum:]_])*))/) &&
+                  @scanner[1]
+                end
+              end || begin
+                @scanner.pos = p1
+                false
+              end
+            end) &&
+            @scanner.skip(/(?!(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?><\-))/) &&
+            Apply.parsed([r0_0])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_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
+                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) &&
+            (literal r0_0)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>`)(?>(?>(?>\\)(?>.)|[^`])*)(?>`))/) &&
+              @scanner[1]
+            end) &&
+            (word_literal r0_0)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = begin
+              @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:]])|(?>\\)(?>.)|[^\\\]]))?)))+)(?>\]))/) &&
+              @scanner[1]
+            end) &&
+            (char_class r0_0)
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            (r0_0 = begin
+              @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)((?>\$)(?>[[:lower:]])(?>(?>[[:alnum:]_])*))/) &&
+              @scanner[1]
+            end) &&
+            BackReference.parsed([r0_0])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        begin
+          p0 = @scanner.pos
+          begin
+            @scanner.skip(/(?>(?>(?>[[:space:]])+|(?>\#)(?>(?>[^\n])*))*)(?>\.)/) &&
+            (Match[/./])
+          end || begin
+            @scanner.pos = p0
+            false
+          end
+        end ||
+        fail { :atom }
+      end
+      
+    end
+  end
+end
+
+if __FILE__ == $0
+  require 'rubygems'
+  require 'rattler'
+  Rattler::Util::GrammarCLI.run(Rattler::Compiler::Metagrammar)
+end