diff --git a/lib/puppet/parser/grammar.ra b/lib/puppet/parser/grammar.ra
index f0158cf43..50e46d9f9 100644
--- a/lib/puppet/parser/grammar.ra
+++ b/lib/puppet/parser/grammar.ra
@@ -1,790 +1,810 @@
 # vim: syntax=ruby
 
 # the parser
 
 class Puppet::Parser::Parser
 
 token STRING DQPRE DQMID DQPOST
 token LBRACK  RBRACK LBRACE RBRACE SYMBOL FARROW COMMA TRUE
 token FALSE EQUALS APPENDS LESSEQUAL NOTEQUAL DOT COLON LLCOLLECT RRCOLLECT
 token QMARK LPAREN RPAREN ISEQUAL GREATEREQUAL GREATERTHAN LESSTHAN
 token IF ELSE IMPORT DEFINE ELSIF VARIABLE CLASS INHERITS NODE BOOLEAN
 token NAME SEMIC CASE DEFAULT AT LCOLLECT RCOLLECT CLASSREF
 token NOT OR AND UNDEF PARROW PLUS MINUS TIMES DIV LSHIFT RSHIFT UMINUS
 token MATCH NOMATCH REGEX IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
 token IN UNLESS
 
 prechigh
   right NOT
   nonassoc UMINUS
   left  IN MATCH NOMATCH
   left  TIMES DIV
   left  MINUS PLUS
   left  LSHIFT RSHIFT
   left  NOTEQUAL ISEQUAL
   left  GREATEREQUAL GREATERTHAN LESSTHAN LESSEQUAL
   left  AND
   left  OR
 preclow
 
 rule
 program:    statements_and_declarations
   | nil
 
   statements_and_declarations:   statement_or_declaration {
     result = ast AST::ASTArray, :children => (val[0] ? [val[0]] : [])
   }
   | statements_and_declarations statement_or_declaration {
     if val[1]
       val[0].push(val[1])
     end
     result = val[0]
   }
 
 # statements is like statements_and_declarations, but it doesn't allow
 # nested definitions, classes, or nodes.
 statements: statements_and_declarations {
   val[0].each do |stmt|
     if stmt.is_a?(AST::TopLevelConstruct)
       error "Classes, definitions, and nodes may only appear at toplevel or inside other classes", \
           :line => stmt.context[:line], :file => stmt.context[:file]
     end
   end
   result = val[0]
 }
 
 # The main list of valid statements
 statement_or_declaration:    resource
   | virtualresource
   | collection
   | assignment
   | casestatement
   | ifstatement_begin
   | unlessstatement
   | import
   | fstatement
   | definition
   | hostclass
   | nodedef
   | resourceoverride
   | append
   | relationship
 
+keyword: AND
+ | CASE
+ | CLASS
+ | DEFAULT
+ | DEFINE
+ | ELSE
+ | ELSIF
+ | IF
+ | IN
+ | IMPORT
+ | INHERITS
+ | NODE
+ | OR
+ | UNDEF
+ | UNLESS
+
 relationship: relationship_side edge relationship_side {
   result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context)
 }
   | relationship edge relationship_side {
     result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context)
 }
 
 relationship_side: resource
   | resourceref
   | collection
   | variable
   | quotedtext
   | selector
   | casestatement
   | hasharrayaccesses
 
 edge: IN_EDGE | OUT_EDGE | IN_EDGE_SUB | OUT_EDGE_SUB
 
 fstatement:   NAME LPAREN expressions RPAREN {
   result = ast AST::Function,
     :name => val[0][:value],
     :line => val[0][:line],
     :arguments => val[2],
     :ftype => :statement
 }
 | NAME LPAREN expressions COMMA RPAREN {
   result = ast AST::Function,
     :name => val[0][:value],
     :line => val[0][:line],
     :arguments => val[2],
     :ftype => :statement
 }            | NAME LPAREN RPAREN {
   result = ast AST::Function,
     :name => val[0][:value],
     :line => val[0][:line],
     :arguments => AST::ASTArray.new({}),
     :ftype => :statement
 }
   | NAME funcvalues {
     result = ast AST::Function,
     :name => val[0][:value],
     :line => val[0][:line],
     :arguments => val[1],
     :ftype => :statement
 }
 
 funcvalues: rvalue { result = aryfy(val[0]) }
 # This rvalue could be an expression
   | funcvalues COMMA rvalue {
     val[0].push(val[2])
     result = val[0]
 }
 
 expressions: expression               { result = aryfy(val[0]) }
        | expressions comma expression { result = val[0].push(val[2]) }
 
 rvalue:       quotedtext
   | name
   | type
   | boolean
   | selector
   | variable
   | array
   | hasharrayaccesses
   | resourceref
   | funcrvalue
   | undef
 
 resource:       classname LBRACE resourceinstances endsemi RBRACE {
   @lexer.commentpop
   result = ast(AST::Resource, :type => val[0], :instances => val[2])
 }           | classname LBRACE params endcomma RBRACE {
   # This is a deprecated syntax.
   error "All resource specifications require names"
 }           | type LBRACE params endcomma RBRACE {
   # a defaults setting for a type
   @lexer.commentpop
   result = ast(AST::ResourceDefaults, :type => val[0].value, :parameters => val[2])
 }
 
 # Override a value set elsewhere in the configuration.
 resourceoverride:     resourceref LBRACE anyparams endcomma RBRACE {
   @lexer.commentpop
   result = ast AST::ResourceOverride, :object => val[0], :parameters => val[2]
 }
 
 # Exported and virtual resources; these don't get sent to the client
 # unless they get collected elsewhere in the db.
 virtualresource:  at resource {
   type = val[0]
 
   if (type == :exported and ! Puppet[:storeconfigs])
     Puppet.warning addcontext("You cannot collect without storeconfigs being set")
   end
 
   error "Defaults are not virtualizable" if val[1].is_a? AST::ResourceDefaults
 
   method = type.to_s + "="
 
   # Just mark our resource as exported and pass it through.
   val[1].send(method, true)
 
   result = val[1]
 }
 
 at:   AT { result = :virtual }
   | AT AT { result = :exported }
 
 # A collection statement.  Currently supports no arguments at all, but eventually
 # will, I assume.
 collection:     type collectrhand LBRACE anyparams endcomma RBRACE {
   @lexer.commentpop
   type = val[0].value.downcase
   args = {:type => type}
 
   if val[1].is_a?(AST::CollExpr)
     args[:query] = val[1]
     args[:query].type = type
     args[:form] = args[:query].form
   else
     args[:form] = val[1]
   end
   if args[:form] == :exported and ! Puppet[:storeconfigs]
     Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored")
   end
   args[:override] = val[3]
   result = ast AST::Collection, args
 }
   | type collectrhand {
   type = val[0].value.downcase
   args = {:type => type }
 
   if val[1].is_a?(AST::CollExpr)
     args[:query] = val[1]
     args[:query].type = type
     args[:form] = args[:query].form
   else
     args[:form] = val[1]
   end
   if args[:form] == :exported and ! Puppet[:storeconfigs]
     Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored")
   end
   result = ast AST::Collection, args
 }
 
 
 collectrhand:     LCOLLECT collstatements RCOLLECT {
   if val[1]
     result = val[1]
     result.form = :virtual
   else
     result = :virtual
   end
 }
   | LLCOLLECT collstatements RRCOLLECT {
     if val[1]
     result = val[1]
     result.form = :exported
   else
     result = :exported
   end
 }
 
 # A mini-language for handling collection comparisons.  This is organized
 # to avoid the need for precedence indications.
 collstatements:           nil
   | collstatement
   | collstatements colljoin collstatement {
     result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2]
 }
 
 collstatement:            collexpr
   | LPAREN collstatements RPAREN {
     result = val[1]
     result.parens = true
 }
 
 colljoin:                 AND { result=val[0][:value] }
   | OR  { result=val[0][:value] }
 
 collexpr:                 colllval ISEQUAL expression {
   result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2]
   #result = ast AST::CollExpr
   #result.push *val
 }
   | colllval NOTEQUAL expression {
     result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2]
     #result = ast AST::CollExpr
     #result.push *val
 }
 
 colllval:                 variable
   | name
 
 resourceinst:   resourcename COLON params endcomma {
   result = ast AST::ResourceInstance, :title => val[0], :parameters => val[2]
 }
 
 resourceinstances:   resourceinst { result = aryfy(val[0]) }
   | resourceinstances SEMIC resourceinst {
     val[0].push val[2]
     result = val[0]
 }
 
 endsemi:      # nothing
   | SEMIC
 
 undef:         UNDEF {
   result = ast AST::Undef, :value => :undef
 }
 
 name:         NAME {
   result = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
 }
 
 type:         CLASSREF {
   result = ast AST::Type, :value => val[0][:value], :line => val[0][:line]
 }
 
 resourcename:   quotedtext
   | name
   | type
   | selector
   | variable
   | array
   | hasharrayaccesses
 
 assignment:     VARIABLE EQUALS expression {
   raise Puppet::ParseError, "Cannot assign to variables in other namespaces" if val[0][:value] =~ /::/
   # this is distinct from referencing a variable
   variable = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
   result = ast AST::VarDef, :name => variable, :value => val[2], :line => val[0][:line]
 }
   | hasharrayaccess EQUALS expression {
     result = ast AST::VarDef, :name => val[0], :value => val[2]
 }
 
 append:     VARIABLE APPENDS expression {
   variable = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
   result = ast AST::VarDef, :name => variable, :value => val[2], :append => true, :line => val[0][:line]
 }
 
 params:   # nothing
 {
   result = ast AST::ASTArray
 }
   | param { result = aryfy(val[0]) }
   | params COMMA param {
     val[0].push(val[2])
     result = val[0]
 }
 
-param:        NAME FARROW expression {
+param_name: NAME 
+  | keyword 
+  | BOOLEAN
+
+param:        param_name FARROW expression {
   result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2]
 }
 
 addparam:     NAME PARROW expression {
   result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2],
     :add => true
 }
 
 anyparam:     param
   | addparam
 
 anyparams:   # nothing
 {
   result = ast AST::ASTArray
 }
   | anyparam { result = aryfy(val[0]) }
   | anyparams COMMA anyparam {
     val[0].push(val[2])
     result = val[0]
 }
 
 # We currently require arguments in these functions.
 funcrvalue:   NAME LPAREN expressions RPAREN {
   result = ast AST::Function,
     :name => val[0][:value], :line => val[0][:line],
     :arguments => val[2],
     :ftype => :rvalue
 }           | NAME LPAREN RPAREN {
   result = ast AST::Function,
     :name => val[0][:value], :line => val[0][:line],
     :arguments => AST::ASTArray.new({}),
     :ftype => :rvalue
 }
 
 quotedtext: STRING       { result = ast AST::String, :value => val[0][:value],                  :line => val[0][:line] }
   | DQPRE dqrval { result = ast AST::Concat, :value => [ast(AST::String,val[0])]+val[1], :line => val[0][:line] }
 
 dqrval: expression dqtail { result = [val[0]] + val[1] }
 
 dqtail: DQPOST        { result = [ast(AST::String,val[0])]          }
   | DQMID dqrval  { result = [ast(AST::String,val[0])] + val[1] }
 
 boolean:    BOOLEAN {
   result = ast AST::Boolean, :value => val[0][:value], :line => val[0][:line]
 }
 
 resourceref: NAME LBRACK expressions RBRACK {
   Puppet.warning addcontext("Deprecation notice:  Resource references should now be capitalized")
   result = ast AST::ResourceReference, :type => val[0][:value], :line => val[0][:line], :title => val[2]
 }               | type LBRACK expressions RBRACK {
   result = ast AST::ResourceReference, :type => val[0].value, :title => val[2]
 }
 
 unlessstatement: UNLESS expression LBRACE statements RBRACE {
   @lexer.commentpop
   args = {
     :test => ast(AST::Not, :value => val[1]),
     :statements => val[3]
   }
 
   result = ast AST::IfStatement, args
 }
   | UNLESS expression LBRACE RBRACE {
     @lexer.commentpop
     args = {
       :test => ast(AST::Not, :value => val[1]), 
       :statements => ast(AST::Nop)
     }
     result = ast AST::IfStatement, args
 }
 
 ifstatement_begin: IF ifstatement {
   result = val[1]
 }
 
 ifstatement:      expression LBRACE statements RBRACE else {
   @lexer.commentpop
   args = {
     :test => val[0],
     :statements => val[2]
   }
 
   args[:else] = val[4] if val[4]
 
   result = ast AST::IfStatement, args
 }
   | expression LBRACE RBRACE else {
     @lexer.commentpop
     args = {
       :test => val[0],
       :statements => ast(AST::Nop)
   }
 
   args[:else] = val[3] if val[3]
 
   result = ast AST::IfStatement, args
 }
 
 else:             # nothing
   | ELSIF ifstatement {
     result = ast AST::Else, :statements => val[1]
 }
   | ELSE LBRACE statements RBRACE {
     @lexer.commentpop
     result = ast AST::Else, :statements => val[2]
 }
   | ELSE LBRACE RBRACE {
     @lexer.commentpop
     result = ast AST::Else, :statements => ast(AST::Nop)
 }
 
 # Unlike yacc/bison, it seems racc
 # gives tons of shift/reduce warnings
 # with the following syntax:
 #
 # expression: ...
 #            | expression arithop expressio { ... }
 #
 # arithop: PLUS | MINUS | DIVIDE | TIMES ...
 #
 # So I had to develop the expression by adding one rule
 # per operator :-(
 
 expression:   rvalue
   | hash
   | expression IN expression {
     result = ast AST::InOperator, :lval => val[0], :rval => val[2]
 }
   | expression MATCH regex {
     result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression NOMATCH regex {
     result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression PLUS expression {
     result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression MINUS expression {
     result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression DIV expression {
     result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression TIMES expression {
     result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression LSHIFT expression {
     result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression RSHIFT expression {
     result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | MINUS expression =UMINUS {
     result = ast AST::Minus, :value => val[1]
 }
   | expression NOTEQUAL expression {
     result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression ISEQUAL expression {
     result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression GREATERTHAN expression {
     result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression GREATEREQUAL expression {
     result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression LESSTHAN expression {
     result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression LESSEQUAL expression {
     result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | NOT expression {
     result = ast AST::Not, :value => val[1]
 }
   | expression AND expression {
     result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | expression OR expression {
     result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 }
   | LPAREN expression RPAREN {
     result = val[1]
 }
 
 casestatement:  CASE expression LBRACE caseopts RBRACE {
   @lexer.commentpop
   result = ast AST::CaseStatement, :test => val[1], :options => val[3]
 }
 
 caseopts:     caseopt { result = aryfy(val[0]) }
   | caseopts caseopt {
     val[0].push val[1]
     result = val[0]
 }
 
 caseopt:        casevalues COLON LBRACE statements RBRACE {
   @lexer.commentpop
   result = ast AST::CaseOpt, :value => val[0], :statements => val[3]
 }               | casevalues COLON LBRACE RBRACE {
   @lexer.commentpop
 
     result = ast(
     AST::CaseOpt,
     :value => val[0],
 
     :statements => ast(AST::ASTArray)
   )
 }
 
 casevalues:       selectlhand { result = aryfy(val[0]) }
   | casevalues COMMA selectlhand {
     val[0].push(val[2])
     result = val[0]
 }
 
 selector:     selectlhand QMARK svalues {
   result = ast AST::Selector, :param => val[0], :values => val[2]
 }
 
 svalues:      selectval
   | LBRACE sintvalues endcomma RBRACE {
     @lexer.commentpop
     result = val[1]
 }
 
 sintvalues:   selectval
   | sintvalues comma selectval {
     if val[0].instance_of?(AST::ASTArray)
     val[0].push(val[2])
     result = val[0]
   else
     result = ast AST::ASTArray, :children => [val[0],val[2]]
   end
 }
 
 selectval:        selectlhand FARROW rvalue {
   result = ast AST::ResourceParam, :param => val[0], :value => val[2]
 }
 
 selectlhand:  name
   | type
   | quotedtext
   | variable
   | funcrvalue
   | boolean
   | undef
   | hasharrayaccess
   | DEFAULT {
     result = ast AST::Default, :value => val[0][:value], :line => val[0][:line]
 }
   | regex
 
 # These are only used for importing, and we don't interpolate there.
 string:        STRING       { result = [val[0][:value]] }
 strings:       string
   |  strings COMMA string { result = val[0] += val[2] }
 
 import: IMPORT strings {
   val[1].each do |file|
     import(file)
   end
 
   result = nil
 }
 
 # Disable definition inheritance for now. 8/27/06, luke
 #definition: DEFINE NAME argumentlist parent LBRACE statements RBRACE {
 definition: DEFINE classname argumentlist LBRACE statements RBRACE {
   @lexer.commentpop
   result = Puppet::Parser::AST::Definition.new(classname(val[1]),
                                                ast_context(true).merge(:arguments => val[2], :code => val[4],
                                                                        :line => val[0][:line]))
   @lexer.indefine = false
 
 #}           | DEFINE NAME argumentlist parent LBRACE RBRACE {
 }           | DEFINE classname argumentlist LBRACE RBRACE {
   @lexer.commentpop
   result = Puppet::Parser::AST::Definition.new(classname(val[1]),
                                                ast_context(true).merge(:arguments => val[2], :line => val[0][:line]))
   @lexer.indefine = false
 }
 
 #hostclass: CLASS NAME argumentlist parent LBRACE statements RBRACE {
 hostclass: CLASS classname argumentlist classparent LBRACE statements_and_declarations RBRACE {
   @lexer.commentpop
   # Our class gets defined in the parent namespace, not our own.
   @lexer.namepop
   result = Puppet::Parser::AST::Hostclass.new(classname(val[1]),
                                               ast_context(true).merge(:arguments => val[2], :parent => val[3],
                                                                       :code => val[5], :line => val[0][:line]))
 }           | CLASS classname argumentlist classparent LBRACE RBRACE {
   @lexer.commentpop
   # Our class gets defined in the parent namespace, not our own.
   @lexer.namepop
   result = Puppet::Parser::AST::Hostclass.new(classname(val[1]),
                                               ast_context(true).merge(:arguments => val[2], :parent => val[3],
                                                                       :line => val[0][:line]))
 }
 
 nodedef: NODE hostnames nodeparent LBRACE statements RBRACE {
   @lexer.commentpop
   result = Puppet::Parser::AST::Node.new(val[1],
                                          ast_context(true).merge(:parent => val[2], :code => val[4],
                                                                  :line => val[0][:line]))
 }       |  NODE hostnames nodeparent LBRACE RBRACE {
   @lexer.commentpop
   result = Puppet::Parser::AST::Node.new(val[1], ast_context(true).merge(:parent => val[2], :line => val[0][:line]))
 }
 
 classname:      NAME { result = val[0][:value] }
   | CLASS { result = "class" }
 
 # Multiple hostnames, as used for node names.  These are all literal
 # strings, not AST objects.
 hostnames:    nodename {
     result = [result]
 }
   | hostnames COMMA nodename {
     result = val[0]
     result << val[2]
 }
 
 nodename: hostname {
   result = ast AST::HostName, :value => val[0]
 }
 
 hostname: NAME { result = val[0][:value] }
   | STRING { result = val[0][:value] }
   | DEFAULT { result = val[0][:value] }
   | regex
 
 nil:    {
   result = nil
 }
 
 nothing:    {
   result = ast AST::ASTArray, :children => []
 }
 
 argumentlist: nil
   | LPAREN nothing RPAREN {
     result = nil
 }
   | LPAREN arguments endcomma RPAREN {
     result = val[1]
     result = [result] unless result[0].is_a?(Array)
 }
 
 arguments:    argument
   | arguments COMMA argument {
     result = val[0]
     result = [result] unless result[0].is_a?(Array)
     result << val[2]
 }
 
 argument:     NAME EQUALS expression {
   Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype")
   result = [val[0][:value], val[2]]
 }
   | NAME {
     Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype")
     result = [val[0][:value]]
 }           | VARIABLE EQUALS expression {
   result = [val[0][:value], val[2]]
 }           | VARIABLE {
   result = [val[0][:value]]
 }
 
 nodeparent:       nil
   | INHERITS hostname {
     result = val[1]
 }
 
 classparent:       nil
   | INHERITS classnameordefault {
     result = val[1]
 }
 
 classnameordefault: classname | DEFAULT
 
 variable:     VARIABLE {
   result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line]
 }
 
 array: LBRACK expressions       RBRACK { result = val[1] }
      | LBRACK expressions COMMA RBRACK { result = val[1] }
      | LBRACK               RBRACK { result = ast AST::ASTArray }
 
 comma:        FARROW
   | COMMA
 
 endcomma:     # nothing
   | COMMA { result = nil }
 
 regex:        REGEX {
   result = ast AST::Regex, :value => val[0][:value]
 }
 
 hash:        LBRACE hashpairs RBRACE {
   if val[1].instance_of?(AST::ASTHash)
     result = val[1]
   else
     result = ast AST::ASTHash, { :value => val[1] }
   end
 }
   | LBRACE hashpairs COMMA RBRACE {
     if val[1].instance_of?(AST::ASTHash)
     result = val[1]
   else
     result = ast AST::ASTHash, { :value => val[1] }
   end
 }           | LBRACE RBRACE {
   result = ast AST::ASTHash
 }
 
 hashpairs:  hashpair
   | hashpairs COMMA hashpair {
     if val[0].instance_of?(AST::ASTHash)
     result = val[0].merge(val[2])
   else
     result = ast AST::ASTHash, :value => val[0]
     result.merge(val[2])
   end
 }
 
 hashpair:   key FARROW expression {
   result = ast AST::ASTHash, { :value => { val[0] => val[2] } }
 }
 
 key:      NAME { result = val[0][:value] }
   | quotedtext { result = val[0] }
 
 hasharrayaccess: VARIABLE LBRACK expression RBRACK {
   result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2]
 }
 
 hasharrayaccesses:    hasharrayaccess
   | hasharrayaccesses LBRACK expression RBRACK {
     result = ast AST::HashOrArrayAccess, :variable => val[0], :key => val[2]
 }
 
 end
 ---- header ----
 require 'puppet'
 require 'puppet/util/loadedfile'
 require 'puppet/parser/lexer'
 require 'puppet/parser/ast'
 
 module Puppet
   class ParseError < Puppet::Error; end
   class ImportError < Racc::ParseError; end
   class AlreadyImportedError < ImportError; end
 end
 
 ---- inner ----
 
 # It got too annoying having code in a file that needs to be compiled.
 require 'puppet/parser/parser_support'
 
 # Make emacs happy
 # Local Variables:
 # mode: ruby
 # End:
diff --git a/lib/puppet/parser/parser.rb b/lib/puppet/parser/parser.rb
index d8dc5a890..828a9ddf7 100644
--- a/lib/puppet/parser/parser.rb
+++ b/lib/puppet/parser/parser.rb
@@ -1,2463 +1,2553 @@
 #
 # DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.4.7
+# This file is automatically generated by Racc 1.4.8
 # from Racc grammer file "".
 #
 
 require 'racc/parser.rb'
 
 require 'puppet'
 require 'puppet/util/loadedfile'
 require 'puppet/parser/lexer'
 require 'puppet/parser/ast'
 
 module Puppet
   class ParseError < Puppet::Error; end
   class ImportError < Racc::ParseError; end
   class AlreadyImportedError < ImportError; end
 end
 
 module Puppet
   module Parser
     class Parser < Racc::Parser
 
-module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 783)
+module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 806)
 
 # It got too annoying having code in a file that needs to be compiled.
 require 'puppet/parser/parser_support'
 
 # Make emacs happy
 # Local Variables:
 # mode: ruby
 # End:
 ...end grammar.ra/module_eval...
 ##### State transition tables begin ###
 
 clist = [
-'9,16,169,170,203,284,97,254,292,284,278,355,84,310,155,141,145,155,277',
-'-178,-165,293,154,-159,136,138,142,144,42,205,49,1,154,11,14,154,25',
-'30,37,309,45,50,3,9,16,17,288,137,140,36,378,147,148,131,132,134,135',
-'308,139,143,34,9,16,9,16,133,8,180,285,347,159,42,346,49,1,195,11,14',
-'53,25,30,37,54,45,50,3,9,16,17,17,139,143,36,376,64,274,275,133,30,179',
-'191,158,50,34,9,16,17,351,331,8,36,254,280,227,42,352,49,1,230,11,14',
-'34,25,30,37,318,45,50,3,9,16,17,274,275,119,36,374,64,87,104,182,30',
-'179,98,104,50,34,85,86,17,122,181,8,36,9,16,187,42,116,49,1,321,11,14',
-'34,25,30,37,306,45,50,3,9,16,17,182,227,107,36,297,108,230,107,-164',
-'53,108,181,104,54,34,53,187,158,315,54,8,97,326,98,34,42,116,49,1,34',
-'11,14,182,25,30,37,99,45,50,3,9,16,17,181,-160,264,36,314,187,316,107',
-'139,143,108,-162,141,145,34,133,263,95,-161,262,8,136,138,142,144,42',
-'-159,49,1,34,11,14,53,25,30,37,54,45,50,3,9,16,17,-158,137,140,36,363',
-'147,148,131,132,134,135,-160,139,143,34,9,16,323,347,133,8,346,350,254',
-'328,42,282,49,1,-163,11,14,303,25,30,37,201,45,50,3,9,16,17,202,-161',
-'210,36,286,64,195,182,273,30,179,274,275,50,34,9,16,17,181,73,8,36,337',
-'187,-158,42,201,49,1,340,11,14,34,25,30,37,-165,45,50,3,9,16,17,87,344',
-'-104,36,343,64,131,132,122,30,179,139,143,50,34,9,16,17,133,294,8,36',
-'345,254,255,42,-105,49,1,119,11,14,34,25,30,37,226,45,50,3,9,16,17,195',
-'354,312,36,-112,64,53,290,118,30,129,257,45,50,34,254,255,17,281,232',
-'8,36,254,280,359,42,116,49,1,361,11,14,34,25,30,37,-160,45,50,3,9,16',
-'17,131,132,-161,36,250,139,143,9,16,101,-211,73,133,79,34,100,-112,-112',
-'-112,-112,8,-23,-23,-23,-23,42,365,49,1,66,11,14,286,25,30,37,92,45',
-'50,3,64,366,17,284,30,76,36,282,50,367,201,154,17,68,9,16,36,34,73,82',
-'79,370,269,8,9,16,372,34,73,282,79,34,266,34,9,16,66,319,73,56,79,254',
-'280,261,379,380,66,64,,,,30,76,,,50,66,64,,17,68,30,76,36,,50,82,64',
-',17,68,30,76,36,34,50,82,,,17,68,9,16,36,34,73,82,79,,,,9,16,,34,112',
-',-178,,,,9,16,66,,73,,79,-29,-29,-29,-29,,111,64,,,,30,76,,,50,66,64',
-',17,68,30,76,36,,50,82,64,,17,,30,76,36,34,50,,,,17,68,9,16,36,34,73',
-'82,79,,,,9,16,,34,73,,79,,,,9,16,66,,73,,79,-25,-25,-25,-25,,66,64,',
-',,30,76,,,50,66,64,,17,68,30,76,36,,50,82,64,,17,68,30,76,36,34,50,82',
-',,17,68,9,16,36,34,73,82,79,,,,9,16,,34,73,,79,,,,9,16,66,,73,,79,59',
-'60,61,57,,66,64,,,,30,76,,,50,66,64,,17,68,30,76,36,,50,82,64,,17,68',
-'30,76,36,34,50,82,,,17,68,9,16,36,34,73,82,79,,,,9,16,,34,73,,79,,,',
-'9,16,66,,73,,79,59,60,61,57,,66,64,,,,30,76,,,50,66,64,,17,68,30,76',
-'36,,50,82,64,,17,68,30,76,36,34,50,82,,,17,68,9,16,36,34,73,82,79,,',
-',9,16,,34,73,,79,,,,9,16,66,,73,,,,147,148,131,132,66,64,,139,143,30',
-'76,,,50,133,64,,17,68,30,76,36,,50,82,64,,17,68,30,76,36,34,50,82,,',
-'17,,9,16,36,34,73,152,79,,,,9,16,,34,73,,79,,,,9,16,66,,73,,79,,,,,',
-'66,64,,,,30,76,,,50,66,64,,17,68,30,76,36,,50,82,64,,17,68,30,76,36',
-'34,50,82,,,17,68,9,16,36,34,73,82,79,,,,9,16,,34,73,,79,,,,9,16,66,',
-',,,,147,148,131,132,66,64,,139,143,30,76,,,50,133,64,,17,68,30,76,36',
-',50,82,64,,17,68,30,179,36,34,50,82,,,17,,9,16,36,34,73,,79,,,,9,16',
-',34,73,,79,,,,9,16,66,,73,,79,,,,,,66,64,,,,30,76,,,50,66,64,,17,68',
-'30,76,36,,50,82,64,,17,68,30,76,36,34,50,82,,,17,68,9,16,36,34,73,82',
-'79,,,,9,16,,34,73,,79,,,,9,16,66,,73,,79,,,,,,66,64,,,,30,76,,,50,66',
-'64,,17,68,30,76,36,,50,82,64,,17,68,30,76,36,34,50,82,9,16,17,68,,,36',
-'34,,82,9,16,,,73,,79,34,,,,147,148,131,132,134,135,,139,143,,,66,64',
-'53,133,,30,129,,45,50,,64,,17,,30,76,36,,50,,,,17,68,9,16,36,34,73,82',
-'79,,,,9,16,,34,73,,79,,,,9,16,66,258,73,,79,,,,,,66,64,,,,30,76,,,50',
-'66,64,,17,68,30,76,36,,50,82,64,,17,68,30,76,36,34,50,82,,,17,68,9,16',
-'36,34,73,82,79,,,,9,16,,34,73,,79,,,,9,16,66,,73,,79,,,,,,66,64,,,,30',
-'76,,,50,66,64,,17,68,30,76,36,,50,82,64,,17,68,30,76,36,34,50,82,,,17',
-'68,9,16,36,34,73,82,79,,,,9,16,,34,73,,79,,,,9,16,66,,,,,,,,,,66,64',
-',,,30,76,,,50,,64,,17,68,30,76,36,,50,82,64,,17,68,30,179,36,34,50,82',
-'298,,17,,,,36,34,,,141,145,,,,,,34,,136,138,142,144,,,,,,,,9,16,,,73',
-',79,,,,,,137,140,,,147,148,131,132,134,135,66,139,143,9,16,,,73,133',
-'79,,64,,,,30,76,,,50,,,,17,68,66,207,36,9,16,82,,73,152,79,,64,,34,',
-'30,76,,,50,,,,17,68,66,,36,9,16,82,,73,,,,64,,34,,30,76,,,50,,,,17,68',
-',,36,9,16,82,,73,,79,,64,,34,,30,76,,,50,9,16,,17,73,66,79,36,,,,,,',
-',,64,,34,,30,76,66,,50,9,16,,17,68,,,36,64,,82,,30,76,,,50,,34,,17,68',
-',,36,9,16,82,,73,,,,64,,34,,30,179,,,50,9,16,,17,73,,79,36,,,,,,,,,64',
-',34,,30,223,66,,50,,,,17,,,,36,64,,,,30,76,,,50,,34,213,17,68,,,36,',
-',82,141,145,,,,,146,34,,136,138,142,144,,,141,145,,,,,,,,136,138,142',
-'144,,,,,137,140,,,147,148,131,132,134,135,,139,143,,,137,140,,133,147',
-'148,131,132,134,135,211,139,143,,,,,,133,141,145,,,,,,,,136,138,142',
-'144,,,141,145,,,,,,,253,136,138,142,144,,,,,137,140,,,147,148,131,132',
-'134,135,,139,143,,,137,140,,133,147,148,131,132,134,135,,139,143,141',
-'145,,,,133,,,,136,138,142,144,,,141,145,,,,,,,,136,138,142,144,,,,,',
-',,,147,148,131,132,134,135,,139,143,,,137,140,,133,147,148,131,132,134',
-'135,,139,143,141,145,,,,133,,,,136,138,142,144,,,141,145,,,,,,,,136',
-'138,142,144,,,,,137,140,,,147,148,131,132,134,135,,139,143,,,137,140',
-',133,147,148,131,132,134,135,,139,143,141,145,,,,133,,,,136,138,142',
-'144,,,141,145,,,,,,,,136,138,142,144,,,,,137,140,,,147,148,131,132,134',
-'135,,139,143,,,137,140,,133,147,148,131,132,134,135,,139,143,141,145',
-',,,133,,,,136,138,142,144,,,141,145,,,,,,,,136,138,142,144,,,,,,140',
-',,147,148,131,132,134,135,,139,143,,,137,140,,133,147,148,131,132,134',
-'135,,139,143,141,145,,,,133,,,,136,138,142,144,,,141,145,,,,,,,,136',
-'138,142,144,,,,,137,140,,,147,148,131,132,134,135,,139,143,,,137,140',
-',133,147,148,131,132,134,135,,139,143,141,145,,,,133,,,,136,138,142',
-'144,,,141,145,,,,,,,,136,138,142,144,,,,,137,140,,,147,148,131,132,134',
-'135,,139,143,,,,,,133,147,148,131,132,134,135,,139,143,141,145,,,,133',
-',,,136,138,142,144,,,141,145,,,,,,,,136,138,142,144,,,,,,,145,,147,148',
-'131,132,134,135,136,139,143,,,137,140,145,133,147,148,131,132,134,135',
-'136,139,143,,,,,,133,,145,,147,148,131,132,134,135,136,139,143,,,,,145',
-'133,147,148,131,132,134,135,136,139,143,,,,,,133,,,,147,148,131,132',
-'134,135,,139,143,,,,,,133,147,148,131,132,134,135,,139,143,,,,,,133',
-'147,148,131,132,134,135,,139,143,,,,,,133' ]
-        racc_action_table = arr = Array.new(2307, nil)
+'9,13,167,168,103,155,372,103,249,105,173,344,90,250,373,142,146,333',
+'275,314,-183,-177,106,154,137,139,143,145,40,94,48,1,315,10,12,174,21',
+'29,35,332,44,49,2,9,13,15,102,138,141,34,272,148,149,132,133,135,136',
+'331,140,144,33,9,13,306,-184,134,8,98,275,300,99,40,352,48,1,369,10',
+'12,368,21,29,35,339,44,49,2,9,13,15,33,297,298,34,399,64,117,297,298',
+'29,222,9,13,49,33,9,13,15,161,72,8,34,53,-112,-96,40,54,48,1,345,10',
+'12,33,21,29,35,154,44,49,2,9,13,15,275,362,-178,34,330,64,160,94,179',
+'29,75,9,13,49,33,294,-179,15,342,178,8,34,53,293,183,40,54,48,1,-129',
+'10,12,33,21,29,35,179,44,49,2,9,13,15,336,72,98,34,178,99,160,132,133',
+'183,140,144,140,144,33,9,13,134,53,134,8,155,54,-196,33,205,206,208',
+'189,191,64,195,197,200,239,243,-177,207,247,154,9,13,15,-176,199,202',
+'244,397,64,249,179,337,29,222,250,303,49,33,9,13,15,178,190,194,34,327',
+'183,326,40,283,48,1,282,10,12,33,21,29,35,119,44,49,2,9,13,15,179,140',
+'144,34,318,64,-123,334,134,29,222,178,94,49,33,53,183,15,340,54,8,34',
+'275,300,154,40,15,48,1,310,10,12,33,21,29,35,309,44,49,2,9,13,15,307',
+'305,323,34,384,369,86,98,368,-130,99,303,142,146,33,84,85,307,292,356',
+'8,137,139,143,145,40,287,48,1,33,10,12,284,21,29,35,359,44,49,2,9,13',
+'15,33,138,141,34,349,148,149,132,133,135,136,33,140,144,33,9,13,248',
+'365,134,8,-130,-130,-130,-130,40,-122,48,1,232,10,12,366,21,29,35,225',
+'44,49,2,9,13,15,188,105,374,34,172,64,132,133,123,29,222,140,144,49',
+'33,9,13,15,134,316,8,34,377,275,276,40,378,48,1,117,10,12,33,21,29,35',
+'-182,44,49,2,9,13,15,-180,382,-178,34,395,64,53,-181,-179,29,129,301',
+'44,49,33,275,300,15,278,385,8,34,275,276,-176,40,-183,48,1,386,10,12',
+'33,21,29,35,86,44,49,2,9,13,15,123,296,-229,34,297,298,121,9,13,388',
+'119,72,117,78,33,-40,-40,-40,-40,391,8,59,60,61,57,40,-178,48,1,65,10',
+'12,393,21,29,35,303,44,49,2,64,-179,15,109,29,75,34,107,49,92,56,400',
+'15,68,9,13,34,33,72,83,78,401,,8,9,13,,33,72,,78,,,,9,13,65,,72,,78',
+'-38,-38,-38,-38,,65,64,,,,29,75,,,49,65,64,,15,68,29,75,34,,49,83,64',
+',15,68,29,75,34,33,49,83,,,15,68,9,13,34,33,72,83,78,,,,9,13,,33,113',
+',-196,,,,9,13,65,,72,,78,-44,-44,-44,-44,,112,64,,,,29,75,,,49,65,64',
+',15,68,29,75,34,,49,83,64,,15,,29,75,34,33,49,,,,15,68,9,13,34,33,72',
+'83,78,,,,9,13,,33,72,,78,,,,9,13,65,,72,,78,59,60,61,57,,65,64,,,,29',
+'75,,,49,65,64,,15,68,29,75,34,,49,83,64,,15,68,29,75,34,33,49,83,,,15',
+'68,9,13,34,33,72,83,78,,,,9,13,,33,72,,78,,,,9,13,65,,72,,,,148,149',
+'132,133,65,64,,140,144,29,75,,,49,134,64,,15,68,29,75,34,,49,83,64,',
+'15,68,29,75,34,33,49,83,,,15,,9,13,34,33,72,,78,,,,9,13,,33,72,,78,',
+',,9,13,65,,72,,78,,,,,,65,64,,,,29,75,,,49,65,64,,15,68,29,75,34,,49',
+'83,64,,15,68,29,75,34,33,49,83,9,13,15,68,72,,34,33,,83,9,13,,,72,152',
+'78,33,,,9,13,,,72,,78,,,,9,13,65,64,72,,78,29,222,,,49,65,64,,15,,29',
+'75,34,,49,65,64,,15,68,29,75,34,33,49,83,64,,15,68,29,75,34,33,49,83',
+',,15,68,9,13,34,33,72,83,78,,,,9,13,,33,72,,78,,,,9,13,65,,72,,78,,',
+',,,65,64,,,,29,75,,,49,65,64,,15,68,29,75,34,,49,83,64,,15,68,29,75',
+'34,33,49,83,,,15,68,9,13,34,33,72,83,78,,,,9,13,,33,72,,78,,,,9,13,65',
+',72,,78,,,,,,65,64,,,,29,75,,,49,65,64,,15,68,29,75,34,,49,83,64,,15',
+'68,29,75,34,33,49,83,,,15,68,9,13,34,33,72,83,78,,,,9,13,,33,72,,78',
+',,,9,13,65,,72,,78,,,,,,65,64,,,,29,75,,,49,65,64,,15,68,29,75,34,,49',
+'83,64,,15,68,29,75,34,33,49,83,,,15,68,9,13,34,33,72,83,78,,,,9,13,',
+'33,72,,78,148,149,132,133,,65,,140,144,,,,,,134,65,64,9,13,,29,75,,',
+'49,,64,,15,68,29,75,34,,49,83,,,15,68,,,34,33,,83,,,,,64,53,,33,29,129',
+',44,49,9,13,,15,72,,78,34,,,9,13,,,72,,78,,33,,,,65,,,,,,,,,,65,64,',
+',,29,75,,,49,,64,,15,68,29,75,34,,49,83,285,,15,68,,,34,33,,83,142,146',
+',,,,,33,,137,139,143,145,,,,,,9,13,9,13,,,72,371,78,,,,,,138,141,,,148',
+'149,132,133,135,136,65,140,144,,,,9,13,134,64,72,64,78,29,222,29,75',
+'49,,49,,15,,15,68,34,,34,65,,83,9,13,,,72,33,78,33,64,,,,29,75,,,49',
+',,,15,68,65,,34,9,13,83,,72,,78,,64,,33,,29,75,,,49,9,13,,15,68,65,223',
+'34,,,83,,,,,,64,,33,,29,75,,,49,,,,15,68,9,13,34,64,72,83,78,29,222',
+',,49,,33,,15,,,,34,9,13,65,279,72,,78,,,,33,,,64,,,,29,75,,,49,65,226',
+',15,68,,,34,,,83,64,,,,29,75,,33,49,,,,15,68,,,34,9,13,83,,72,152,78',
+',,,33,,,,,,,9,13,,,72,65,78,,,,,,,,,,64,,,,29,75,65,,49,,,,15,68,,,34',
+'64,,83,,29,75,,,49,,33,,15,68,9,13,34,,72,83,78,,,,9,13,,33,72,,78,',
+',,9,13,65,,72,,78,,,,,,65,64,,,,29,75,,,49,65,64,,15,68,29,75,34,,49',
+'83,64,,15,68,29,75,34,33,49,83,,,15,68,9,13,34,33,72,83,78,,,,9,13,',
+'33,72,,78,,,,,,65,,,,,,,,,,65,64,,,,29,75,,,49,,64,,15,68,29,75,34,',
+'49,83,,230,15,68,,,34,33,,83,142,146,,,,,147,33,,137,139,143,145,,,142',
+'146,,,,,,,,137,139,143,145,,,,,138,141,,,148,149,132,133,135,136,,140',
+'144,,,138,141,,134,148,149,132,133,135,136,229,140,144,,,,,,134,142',
+'146,,,,,,,,137,139,143,145,,,142,146,,,,,,,,137,139,143,145,,,,,138',
+'141,,,148,149,132,133,135,136,,140,144,,,138,141,,134,148,149,132,133',
+'135,136,,140,144,142,146,,,,134,,,,137,139,143,145,,,142,146,,,,,,,',
+'137,139,143,145,,,,,138,141,,,148,149,132,133,135,136,,140,144,,,138',
+'141,,134,148,149,132,133,135,136,,140,144,142,146,,,,134,,,,137,139',
+'143,145,,,142,146,,,,,,,,137,139,143,145,,,,,138,141,,,148,149,132,133',
+'135,136,,140,144,,,138,141,,134,148,149,132,133,135,136,,140,144,142',
+'146,,,,134,,,,137,139,143,145,,,142,146,,,,,,,,137,139,143,145,,,,,',
+'141,,,148,149,132,133,135,136,,140,144,,,,,,134,148,149,132,133,135',
+'136,,140,144,142,146,,,,134,,,,137,139,143,145,,,142,146,,,,,,,,137',
+'139,143,145,,,,,,,,,148,149,132,133,135,136,,140,144,,,138,141,,134',
+'148,149,132,133,135,136,,140,144,142,146,,,,134,,,,137,139,143,145,',
+',142,146,,,,,,,,137,139,143,145,,,,,138,141,,,148,149,132,133,135,136',
+',140,144,,,138,141,,134,148,149,132,133,135,136,,140,144,142,146,,,',
+'134,,,,137,139,143,145,,,142,146,,,,,,,,137,139,143,145,,,,,138,141',
+',,148,149,132,133,135,136,,140,144,,,138,141,,134,148,149,132,133,135',
+'136,,140,144,142,146,,,,134,,,,137,139,143,145,,,142,146,,,,,,,254,137',
+'139,143,145,,,,,,,146,,148,149,132,133,135,136,137,140,144,,,138,141',
+'146,134,148,149,132,133,135,136,137,140,144,,,,,,134,,146,,148,149,132',
+'133,135,136,137,140,144,,,,,146,134,148,149,132,133,135,136,137,140',
+'144,,,,,,134,,,,148,149,132,133,135,136,,140,144,,,,,,134,148,149,132',
+'133,135,136,,140,144,205,206,208,189,191,134,195,197,200,201,203,,207',
+'209,,,,,,199,202,204,205,206,208,189,191,,195,197,200,201,215,,207,209',
+',190,194,,,199,202,204,205,206,208,189,191,,195,197,200,201,215,,207',
+'209,,190,194,,,199,202,204,205,206,208,189,191,,195,197,200,201,203',
+',207,209,,190,194,,,199,202,204,205,206,208,189,191,,195,197,200,201',
+'215,,207,209,,190,194,,,199,202,204,205,206,208,189,191,,195,197,200',
+'201,203,,207,209,,190,194,,,199,202,204,148,149,132,133,135,136,,140',
+'144,,,,,,134,190,194,148,149,132,133,135,136,,140,144,,,,,,134' ]
+        racc_action_table = arr = ::Array.new(2463, nil)
         idx = 0
         clist.each do |str|
           str.split(',', -1).each do |i|
             arr[idx] = i.to_i unless i.empty?
             idx += 1
           end
         end
 
 clist = [
-'0,0,90,90,103,201,70,208,208,223,190,305,10,229,76,90,90,129,190,129',
-'10,208,223,70,90,90,90,90,0,103,0,0,76,0,0,129,0,0,0,228,0,0,0,372,372',
-'0,201,90,90,0,372,90,90,90,90,90,90,227,90,90,0,92,92,79,79,90,0,92',
-'196,297,79,372,297,372,372,98,372,372,20,372,372,372,20,372,372,372',
-'370,370,372,20,234,234,372,370,92,196,196,234,92,92,96,79,92,372,329',
-'329,92,301,272,372,92,259,259,122,370,301,370,370,122,370,370,92,370',
-'370,370,259,370,370,370,362,362,370,272,272,226,370,362,329,11,25,95',
-'329,329,93,203,329,370,11,11,329,89,95,370,329,262,262,95,362,81,362',
-'362,262,362,362,329,362,362,362,225,362,362,362,211,211,362,276,310',
-'25,362,211,25,310,203,80,14,203,276,205,14,362,266,276,262,249,266,362',
-'21,266,21,25,211,224,211,211,203,211,211,182,211,211,211,21,211,211',
-'211,232,232,211,182,221,166,211,232,182,255,205,233,233,205,77,166,166',
-'211,233,160,21,219,160,211,166,166,166,166,232,218,232,232,205,232,232',
-'1,232,232,232,1,232,232,232,323,323,232,217,166,166,232,323,166,166',
-'166,166,166,166,75,166,166,232,299,299,265,345,166,232,345,299,271,271',
-'323,216,323,323,72,323,323,215,323,323,323,100,323,323,323,248,248,323',
-'101,71,113,323,279,299,282,99,186,299,299,186,186,299,323,306,306,299',
-'99,306,323,299,283,99,67,248,286,248,248,287,248,248,299,248,248,248',
-'65,248,248,248,290,290,248,64,292,293,248,290,306,252,252,55,306,306',
-'252,252,306,248,58,58,306,252,209,248,306,296,209,209,290,207,290,290',
-'49,290,290,306,290,290,290,121,290,290,290,29,29,290,303,304,230,290',
-'294,58,58,204,46,58,58,153,58,58,290,153,153,58,192,124,290,58,192,192',
-'311,29,43,29,29,313,29,29,58,29,29,29,31,29,29,29,146,146,29,251,251',
-'27,29,146,251,251,145,145,24,328,145,251,145,29,22,294,294,294,294,29',
-'48,48,48,48,146,330,146,146,145,146,146,198,146,146,146,19,146,146,146',
-'145,335,146,195,145,145,146,193,145,342,191,179,145,145,144,144,145',
-'146,144,145,144,347,174,146,147,147,352,145,147,353,147,139,168,143',
-'148,148,144,260,148,3,148,260,260,156,375,377,147,144,,,,144,144,,,144',
-'148,147,,144,144,147,147,144,,147,144,148,,147,147,148,148,147,144,148',
-'147,,,148,148,142,142,148,147,142,148,142,,,,37,37,,148,37,,37,,,,42',
-'42,142,,42,,42,13,13,13,13,,37,142,,,,142,142,,,142,42,37,,142,142,37',
-'37,142,,37,142,42,,37,,42,42,37,142,42,,,,42,42,312,312,42,37,312,42',
-'312,,,,308,308,,42,308,,308,,,,141,141,312,,141,,141,5,5,5,5,,308,312',
-',,,312,312,,,312,141,308,,312,312,308,308,312,,308,312,141,,308,308',
-'141,141,308,312,141,308,,,141,141,140,140,141,308,140,141,140,,,,346',
-'346,,141,346,,346,,,,288,288,140,,288,,288,6,6,6,6,,346,140,,,,140,140',
-',,140,288,346,,140,140,346,346,140,,346,140,288,,346,346,288,288,346',
-'140,288,346,,,288,288,66,66,288,346,66,288,66,,,,284,284,,288,284,,284',
-',,,68,68,66,,68,,68,12,12,12,12,,284,66,,,,66,66,,,66,68,284,,66,66',
-'284,284,66,,284,66,68,,284,284,68,68,284,66,68,284,,,68,68,278,278,68',
-'284,278,68,278,,,,277,277,,68,277,,277,,,,269,269,278,,269,,,,237,237',
-'237,237,277,278,,237,237,278,278,,,278,237,277,,278,278,277,277,278',
-',277,278,269,,277,277,269,269,277,278,269,277,,,269,,73,73,269,277,73',
-'73,73,,,,169,169,,269,169,,169,,,,261,261,73,,261,,261,,,,,,169,73,',
-',,73,73,,,73,261,169,,73,73,169,169,73,,169,73,261,,169,169,261,261',
-'169,73,261,169,,,261,261,256,256,261,169,256,261,256,,,,138,138,,261',
-'138,,138,,,,351,351,256,,,,,,236,236,236,236,138,256,,236,236,256,256',
-',,256,236,138,,256,256,138,138,256,,138,256,351,,138,138,351,351,138',
-'256,351,138,,,351,,137,137,351,138,137,,137,,,,82,82,,351,82,,82,,,',
-'84,84,137,,84,,84,,,,,,82,137,,,,137,137,,,137,84,82,,137,137,82,82',
-'137,,82,137,84,,82,82,84,84,82,137,84,82,,,84,84,85,85,84,82,85,84,85',
-',,,86,86,,84,86,,86,,,,87,87,85,,87,,87,,,,,,86,85,,,,85,85,,,85,87',
-'86,,85,85,86,86,85,,86,85,87,,86,86,87,87,86,85,87,86,88,88,87,87,,',
-'87,86,,87,136,136,,,136,,136,87,,,,238,238,238,238,238,238,,238,238',
-',,136,88,88,238,,88,88,,88,88,,136,,88,,136,136,88,,136,,,,136,136,154',
-'154,136,88,154,136,154,,,,16,16,,136,16,,16,,,,135,135,154,154,135,',
-'135,,,,,,16,154,,,,154,154,,,154,135,16,,154,154,16,16,154,,16,154,135',
-',16,16,135,135,16,154,135,16,,,135,135,134,134,135,16,134,135,134,,',
-',133,133,,135,133,,133,,,,97,97,134,,97,,97,,,,,,133,134,,,,134,134',
-',,134,97,133,,134,134,133,133,134,,133,134,97,,133,133,97,97,133,134',
-'97,133,,,97,97,132,132,97,133,132,97,132,,,,8,8,,97,8,,8,,,,213,213',
-'132,,,,,,,,,,8,132,,,,132,132,,,132,,8,,132,132,8,8,132,,8,132,213,',
-'8,8,213,213,8,132,213,8,212,,213,,,,213,8,,,212,212,,,,,,213,,212,212',
-'212,212,,,,,,,,155,155,,,155,,155,,,,,,212,212,,,212,212,212,212,212',
-'212,155,212,212,111,111,,,111,212,111,,155,,,,155,155,,,155,,,,155,155',
-'111,111,155,112,112,155,,112,112,112,,111,,155,,111,111,,,111,,,,111',
-'111,112,,111,210,210,111,,210,,,,112,,111,,112,112,,,112,,,,112,112',
-',,112,131,131,112,,131,,131,,210,,112,,210,210,,,210,116,116,,210,116',
-'131,116,210,,,,,,,,,131,,210,,131,131,116,,131,180,180,,131,131,,,131',
-'116,,131,,116,116,,,116,,131,,116,116,,,116,118,118,116,,118,,,,180',
-',116,,180,180,,,180,45,45,,180,45,,45,180,,,,,,,,,118,,180,,118,118',
-'45,,118,,,,118,,,,118,45,,,,45,45,,,45,,118,117,45,45,,,45,,,45,117',
-'117,,,,,63,45,,117,117,117,117,,,63,63,,,,,,,,63,63,63,63,,,,,117,117',
-',,117,117,117,117,117,117,,117,117,,,63,63,,117,63,63,63,63,63,63,114',
-'63,63,,,,,,63,114,114,,,,,,,,114,114,114,114,,,149,149,,,,,,,149,149',
-'149,149,149,,,,,114,114,,,114,114,114,114,114,114,,114,114,,,149,149',
-',114,149,149,149,149,149,149,,149,149,242,242,,,,149,,,,242,242,242',
-'242,,,357,357,,,,,,,,357,357,357,357,,,,,,,,,242,242,242,242,242,242',
-',242,242,,,357,357,,242,357,357,357,357,357,357,,357,357,165,165,,,',
-'357,,,,165,165,165,165,,,151,151,,,,,,,,151,151,151,151,,,,,165,165',
-',,165,165,165,165,165,165,,165,165,,,151,151,,165,151,151,151,151,151',
-'151,,151,151,360,360,,,,151,,,,360,360,360,360,,,163,163,,,,,,,,163',
-'163,163,163,,,,,360,360,,,360,360,360,360,360,360,,360,360,,,163,163',
-',360,163,163,163,163,163,163,,163,163,239,239,,,,163,,,,239,239,239',
-'239,,,164,164,,,,,,,,164,164,164,164,,,,,,239,,,239,239,239,239,239',
-'239,,239,239,,,164,164,,239,164,164,164,164,164,164,,164,164,338,338',
-',,,164,,,,338,338,338,338,,,320,320,,,,,,,,320,320,320,320,,,,,338,338',
-',,338,338,338,338,338,338,,338,338,,,320,320,,338,320,320,320,320,320',
-'320,,320,320,341,341,,,,320,,,,341,341,341,341,,,333,333,,,,,,,,333',
-'333,333,333,,,,,341,341,,,341,341,341,341,341,341,,341,341,,,,,,341',
-'333,333,333,333,333,333,,333,333,334,334,,,,333,,,,334,334,334,334,',
-',317,317,,,,,,,,317,317,317,317,,,,,,,244,,334,334,334,334,334,334,244',
-'334,334,,,317,317,240,334,317,317,317,317,317,317,240,317,317,,,,,,317',
-',246,,244,244,244,244,244,244,246,244,244,,,,,243,244,240,240,240,240',
-'240,240,243,240,240,,,,,,240,,,,246,246,246,246,246,246,,246,246,,,',
-',,246,243,243,243,243,243,243,,243,243,,,,,,243,247,247,247,247,247',
-'247,,247,247,,,,,,247' ]
-        racc_action_check = arr = Array.new(2307, nil)
+'0,0,88,88,71,75,321,23,123,23,95,286,14,123,321,88,88,251,227,227,14',
+'71,23,75,88,88,88,88,0,21,0,0,227,0,0,95,0,0,0,250,0,0,0,147,147,0,23',
+'88,88,0,147,88,88,88,88,88,88,249,88,88,0,230,230,210,247,88,0,21,280',
+'280,21,147,295,147,147,318,147,147,318,147,147,147,280,147,147,147,393',
+'393,147,21,210,210,147,393,230,246,295,295,230,230,78,78,230,147,225',
+'225,230,78,225,147,230,287,243,244,393,287,393,393,287,393,393,230,393',
+'393,393,243,393,393,393,248,248,393,312,312,242,393,248,225,78,174,299',
+'225,225,282,282,225,393,177,240,225,282,299,393,225,12,177,299,248,12',
+'248,248,239,248,248,225,248,248,248,179,248,248,248,121,121,248,271',
+'121,174,248,179,174,282,273,273,179,255,255,273,273,248,372,372,255',
+'1,273,248,129,1,129,174,121,121,121,121,121,121,121,121,121,121,121',
+'238,121,121,129,391,391,121,237,121,121,121,391,372,334,102,276,372',
+'372,334,236,372,121,223,223,372,102,121,121,372,235,102,233,391,156',
+'391,391,156,391,391,372,391,391,391,232,391,391,391,229,229,391,106',
+'256,256,391,229,223,226,252,256,223,223,106,173,223,391,22,106,223,281',
+'22,391,223,281,281,222,229,22,229,229,219,229,229,223,229,229,229,215',
+'229,229,229,344,344,229,212,198,231,229,344,366,10,173,366,316,173,193',
+'231,231,229,10,10,302,175,304,229,231,231,231,231,344,166,344,344,173',
+'344,344,158,344,344,344,308,344,344,344,292,292,344,144,231,231,344',
+'292,231,231,231,231,231,231,140,231,231,344,363,363,122,314,231,344',
+'316,316,316,316,292,315,292,292,118,292,292,317,292,292,292,110,292',
+'292,292,26,26,292,104,100,325,292,92,363,274,274,87,363,363,274,274',
+'363,292,58,58,363,274,228,292,363,328,228,228,26,329,26,26,82,26,26',
+'363,26,26,26,81,26,26,26,383,383,26,79,335,77,26,383,58,58,74,73,58',
+'58,187,58,58,26,187,187,58,153,348,26,58,153,153,69,383,67,383,383,354',
+'383,383,58,383,383,383,64,383,383,383,270,270,383,55,184,362,383,184',
+'184,50,40,40,364,48,40,45,40,383,4,4,4,4,369,383,5,5,5,5,270,36,270',
+'270,40,270,270,373,270,270,270,376,270,270,270,40,30,270,28,40,40,270',
+'24,40,20,2,396,40,40,284,284,40,270,284,40,284,398,,270,13,13,,40,13',
+',13,,,,145,145,284,,145,,145,47,47,47,47,,13,284,,,,284,284,,,284,145',
+'13,,284,284,13,13,284,,13,284,145,,13,13,145,145,13,284,145,13,,,145',
+'145,309,309,145,13,309,145,309,,,,35,35,,145,35,,35,,,,44,44,309,,44',
+',44,11,11,11,11,,35,309,,,,309,309,,,309,44,35,,309,309,35,35,309,,35',
+'309,44,,35,,44,44,35,309,44,,,,44,44,368,368,44,35,368,44,368,,,,143',
+'143,,44,143,,143,,,,142,142,368,,142,,142,16,16,16,16,,143,368,,,,368',
+'368,,,368,142,143,,368,368,143,143,368,,143,368,142,,143,143,142,142',
+'143,368,142,143,,,142,142,65,65,142,143,65,142,65,,,,141,141,,142,141',
+',141,,,,310,310,65,,310,,,,259,259,259,259,141,65,,259,259,65,65,,,65',
+'259,141,,65,65,141,141,65,,141,65,310,,141,141,310,310,141,65,310,141',
+',,310,,68,68,310,141,68,,68,,,,139,139,,310,139,,139,,,,293,293,68,',
+'293,,293,,,,,,139,68,,,,68,68,,,68,293,139,,68,68,139,139,68,,139,68',
+'293,,139,139,293,293,139,68,293,139,326,326,293,293,326,,293,139,,293',
+'72,72,,,72,72,72,293,,,277,277,,,277,,277,,,,138,138,72,326,138,,138',
+'326,326,,,326,277,72,,326,,72,72,326,,72,138,277,,72,72,277,277,72,326',
+'277,72,138,,277,277,138,138,277,72,138,277,,,138,138,294,294,138,277',
+'294,138,294,,,,137,137,,138,137,,137,,,,332,332,294,,332,,332,,,,,,137',
+'294,,,,294,294,,,294,332,137,,294,294,137,137,294,,137,294,332,,137',
+'137,332,332,137,294,332,137,,,332,332,331,331,332,137,331,332,331,,',
+',83,83,,332,83,,83,,,,84,84,331,,84,,84,,,,,,83,331,,,,331,331,,,331',
+'84,83,,331,331,83,83,331,,83,331,84,,83,83,84,84,83,331,84,83,,,84,84',
+'85,85,84,83,85,84,85,,,,86,86,,84,86,,86,,,,136,136,85,,136,,136,,,',
+',,86,85,,,,85,85,,,85,136,86,,85,85,86,86,85,,86,85,136,,86,86,136,136',
+'86,85,136,86,,,136,136,8,8,136,86,8,136,8,,,,90,90,,136,90,,90,258,258',
+'258,258,,8,,258,258,,,,,,258,90,8,91,91,,8,8,,,8,,90,,8,8,90,90,8,,90',
+'8,,,90,90,,,90,8,,90,,,,,91,91,,90,91,91,,91,91,167,167,,91,167,,167',
+'91,,,305,305,,,305,,305,,91,,,,167,,,,,,,,,,305,167,,,,167,167,,,167',
+',305,,167,167,305,305,167,,305,167,165,,305,305,,,305,167,,305,165,165',
+',,,,,305,,165,165,165,165,,,,,,319,319,103,103,,,103,319,103,,,,,,165',
+'165,,,165,165,165,165,165,165,103,165,165,,,,135,135,165,319,135,103',
+'135,319,319,103,103,319,,103,,319,,103,103,319,,103,135,,103,134,134',
+',,134,319,134,103,135,,,,135,135,,,135,,,,135,135,134,,135,155,155,135',
+',155,,155,,134,,135,,134,134,,,134,109,109,,134,134,155,109,134,,,134',
+',,,,,155,,134,,155,155,,,155,,,,155,155,154,154,155,109,154,155,154',
+'109,109,,,109,,155,,109,,,,109,112,112,154,154,112,,112,,,,109,,,154',
+',,,154,154,,,154,112,112,,154,154,,,154,,,154,112,,,,112,112,,154,112',
+',,,112,112,,,112,113,113,112,,113,113,113,,,,112,,,,,,,133,133,,,133',
+'113,133,,,,,,,,,,113,,,,113,113,133,,113,,,,113,113,,,113,133,,113,',
+'133,133,,,133,,113,,133,133,132,132,133,,132,133,132,,,,117,117,,133',
+'117,,117,,,,148,148,132,,148,,148,,,,,,117,132,,,,132,132,,,132,148',
+'117,,132,132,117,117,132,,117,132,148,,117,117,148,148,117,132,148,117',
+',,148,148,149,149,148,117,149,148,149,,,,146,146,,148,146,,146,,,,,',
+'149,,,,,,,,,,146,149,,,,149,149,,,149,,146,,149,149,146,146,149,,146',
+'149,,116,146,146,,,146,149,,146,116,116,,,,,66,146,,116,116,116,116',
+',,66,66,,,,,,,,66,66,66,66,,,,,116,116,,,116,116,116,116,116,116,,116',
+'116,,,66,66,,116,66,66,66,66,66,66,114,66,66,,,,,,66,114,114,,,,,,,',
+'114,114,114,114,,,343,343,,,,,,,,343,343,343,343,,,,,114,114,,,114,114',
+'114,114,114,114,,114,114,,,343,343,,114,343,343,343,343,343,343,,343',
+'343,163,163,,,,343,,,,163,163,163,163,,,164,164,,,,,,,,164,164,164,164',
+',,,,163,163,,,163,163,163,163,163,163,,163,163,,,164,164,,163,164,164',
+'164,164,164,164,,164,164,170,170,,,,164,,,,170,170,170,170,,,338,338',
+',,,,,,,338,338,338,338,,,,,170,170,,,170,170,170,170,170,170,,170,170',
+',,338,338,,170,338,338,338,338,338,338,,338,338,261,261,,,,338,,,,261',
+'261,261,261,,,350,350,,,,,,,,350,350,350,350,,,,,,261,,,261,261,261',
+'261,261,261,,261,261,,,,,,261,350,350,350,350,350,350,,350,350,351,351',
+',,,350,,,,351,351,351,351,,,151,151,,,,,,,,151,151,151,151,,,,,,,,,351',
+'351,351,351,351,351,,351,351,,,151,151,,351,151,151,151,151,151,151',
+',151,151,357,357,,,,151,,,,357,357,357,357,,,360,360,,,,,,,,360,360',
+'360,360,,,,,357,357,,,357,357,357,357,357,357,,357,357,,,360,360,,357',
+'360,360,360,360,360,360,,360,360,379,379,,,,360,,,,379,379,379,379,',
+',380,380,,,,,,,,380,380,380,380,,,,,379,379,,,379,379,379,379,379,379',
+',379,379,,,380,380,,379,380,380,380,380,380,380,,380,380,264,264,,,',
+'380,,,,264,264,264,264,,,131,131,,,,,,,131,131,131,131,131,,,,,,,268',
+',264,264,264,264,264,264,268,264,264,,,131,131,262,264,131,131,131,131',
+'131,131,262,131,131,,,,,,131,,265,,268,268,268,268,268,268,265,268,268',
+',,,,266,268,262,262,262,262,262,262,266,262,262,,,,,,262,,,,265,265',
+'265,265,265,265,,265,265,,,,,,265,266,266,266,266,266,266,,266,266,327',
+'327,327,327,327,266,327,327,327,327,327,,327,327,,,,,,327,327,327,307',
+'307,307,307,307,,307,307,307,307,307,,307,307,,327,327,,,307,307,307',
+'107,107,107,107,107,,107,107,107,107,107,,107,107,,307,307,,,107,107',
+'107,105,105,105,105,105,,105,105,105,105,105,,105,105,,107,107,,,105',
+'105,105,188,188,188,188,188,,188,188,188,188,188,,188,188,,105,105,',
+',188,188,188,303,303,303,303,303,,303,303,303,303,303,,303,303,,188',
+'188,,,303,303,303,260,260,260,260,260,260,,260,260,,,,,,260,303,303',
+'269,269,269,269,269,269,,269,269,,,,,,269' ]
+        racc_action_check = arr = ::Array.new(2463, nil)
         idx = 0
         clist.each do |str|
           str.split(',', -1).each do |i|
             arr[idx] = i.to_i unless i.empty?
             idx += 1
           end
         end
 
 racc_action_pointer = [
-    -2,   214,   nil,   468,   nil,   585,   652,   nil,  1352,   nil,
-    -3,   132,   719,   518,   148,   nil,  1218,   nil,   nil,   446,
-    42,   190,   440,   nil,   442,   137,   nil,   412,   nil,   385,
-   nil,   403,   nil,   nil,   nil,   nil,   nil,   562,   nil,   nil,
-   nil,   nil,   572,   410,   nil,  1619,   390,   nil,   391,   374,
-   nil,   nil,   nil,   nil,   nil,   331,   nil,   nil,   360,   nil,
-   nil,   nil,   nil,  1672,   341,   317,   753,   305,   773,   nil,
-     0,   282,   267,   887,   nil,   249,     8,   206,   nil,    61,
-   160,   152,  1031,   nil,  1041,  1088,  1098,  1108,  1151,   126,
-    -2,   nil,    59,   135,   nil,   116,    92,  1295,    35,   287,
-   257,   304,   nil,    -8,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,  1460,  1485,   294,  1723,   nil,  1552,  1657,  1602,   nil,
-   nil,   371,    78,   nil,   401,   nil,   nil,   nil,   nil,    11,
-   nil,  1535,  1342,  1285,  1275,  1228,  1161,  1021,   964,   442,
-   686,   639,   552,   444,   485,   438,   428,   495,   505,  1738,
-   nil,  1858,   nil,   394,  1208,  1435,   505,   nil,   nil,   nil,
-   225,   nil,   nil,  1918,  1978,  1843,   213,   nil,   468,   897,
-   nil,   nil,   nil,   nil,   484,   nil,   nil,   nil,   nil,   460,
-  1577,   nil,   183,   nil,   nil,   nil,   266,   nil,   nil,   nil,
-    -8,   443,   401,   468,   nil,   465,    46,   nil,   453,   nil,
-   nil,    -6,   nil,   142,   389,   185,   nil,   350,    -4,   359,
-  1510,   170,  1400,  1362,   nil,   273,   275,   238,   221,   213,
-   nil,   196,   nil,    -2,   195,   127,   132,    42,    14,     1,
-   377,   nil,   213,   166,    30,   nil,   931,   797,  1121,  1963,
-  2191,   nil,  1783,  2224,  2176,   nil,  2209,  2239,   299,   184,
-   nil,   378,   298,   nil,   nil,   217,   954,   nil,   nil,   100,
-   503,   907,   152,   nil,   nil,   270,   154,   nil,   nil,   840,
-   nil,   273,    83,   nil,   nil,   nil,   151,   830,   820,   296,
-   nil,   nil,   270,   317,   763,   nil,   290,   324,   706,   nil,
-   342,   nil,   323,   326,   386,   nil,   360,    38,   nil,   274,
-   nil,    95,   nil,   350,   382,     2,   317,   nil,   629,   nil,
-   141,   389,   619,   410,   nil,   nil,   nil,  2158,   nil,   nil,
-  2038,   nil,   nil,   256,   nil,   nil,   nil,   nil,   434,   102,
-   450,   nil,   nil,  2098,  2143,   465,   nil,   nil,  2023,   nil,
-   nil,  2083,   473,   nil,   nil,   248,   696,   486,   nil,   nil,
-   nil,   974,   491,   490,   nil,   nil,   nil,  1798,   nil,   nil,
-  1903,   nil,   127,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-    84,   nil,    41,   nil,   nil,   508,   nil,   509,   nil,   nil,
-   nil ]
+    -2,   157,   482,   nil,   428,   434,   nil,   nil,  1137,   nil,
+   304,   561,   118,   538,    -3,   nil,   628,   nil,   nil,   nil,
+   525,    27,   240,     1,   515,   nil,   385,   nil,   496,   nil,
+   494,   nil,   nil,   nil,   nil,   605,   479,   nil,   nil,   nil,
+   481,   nil,   nil,   nil,   615,   482,   nil,   494,   484,   nil,
+   474,   nil,   nil,   nil,   nil,   452,   nil,   nil,   403,   nil,
+   nil,   nil,   nil,   nil,   463,   729,  1685,   436,   796,   434,
+   nil,    -2,   869,   418,   417,    -1,   nil,   412,    98,   410,
+   nil,   403,   413,  1013,  1023,  1070,  1080,   374,    -2,   nil,
+  1147,  1171,   394,   nil,   nil,    -2,   nil,   nil,   nil,   nil,
+   383,   nil,   201,  1296,   382,  2335,   237,  2313,   nil,  1391,
+   371,   nil,  1441,  1491,  1736,   nil,  1670,  1565,   364,   nil,
+   nil,   170,   356,   -27,   nil,   nil,   nil,   nil,   nil,   190,
+   nil,  2171,  1555,  1508,  1349,  1324,  1090,   946,   889,   806,
+   296,   739,   682,   672,   285,   548,  1632,    41,  1575,  1622,
+   nil,  1991,   nil,   444,  1421,  1374,   235,   nil,   325,   nil,
+   nil,   nil,   nil,  1796,  1811,  1261,   293,  1213,   nil,   nil,
+  1856,   nil,   nil,   271,   137,   314,   nil,   129,   nil,   144,
+   nil,   nil,   nil,   nil,   431,   nil,   nil,   437,  2357,   nil,
+   nil,   nil,   nil,   303,   nil,   nil,   nil,   nil,   294,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+    41,   nil,   292,   nil,   nil,   245,   nil,   nil,   nil,   279,
+   nil,   nil,   261,   231,   nil,   102,   244,     7,   402,   256,
+    59,   299,   252,   201,   nil,   220,   218,   195,   188,   138,
+   125,   nil,   111,   101,    90,   nil,    89,    41,   127,    42,
+    24,    -8,   256,   nil,   nil,   125,   202,   nil,  1103,   706,
+  2378,  1916,  2204,   nil,  2156,  2222,  2237,   nil,  2189,  2395,
+   471,   166,   nil,   127,   341,   nil,   219,   879,   nil,   nil,
+    57,   272,   141,   nil,   528,   nil,     3,    75,   nil,   nil,
+   nil,   nil,   342,   816,   936,    47,   nil,   nil,   nil,   116,
+   nil,   nil,   309,  2379,   314,  1223,   nil,  2291,   331,   595,
+   749,   nil,   121,   nil,   340,   350,   305,   370,    44,  1294,
+   nil,    -6,   nil,   nil,   nil,   383,   859,  2269,   403,   407,
+   nil,  1003,   956,   nil,   189,   409,   nil,   nil,  1871,   nil,
+   nil,   nil,   nil,  1751,   299,   nil,   nil,   nil,   443,   nil,
+  1931,  1976,   nil,   nil,   453,   nil,   nil,  2036,   nil,   nil,
+  2051,   nil,   469,   360,   476,   nil,   278,   nil,   662,   487,
+   nil,   nil,   188,   500,   nil,   nil,   500,   nil,   nil,  2096,
+  2111,   nil,   nil,   428,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   213,   nil,    84,   nil,   nil,   518,   nil,   528,   nil,
+   nil,   nil ]
 
 racc_action_default = [
-  -187,  -224,  -167,   -59,   -19,    -8,   -20,    -9,  -224,  -106,
-  -222,  -204,  -224,   -10,  -179,  -158,  -224,   -83,   -11,  -224,
-  -224,  -159,   -24,   -12,  -224,  -224,  -163,   -26,   -13,    -1,
-  -111,   -27,   -14,    -2,  -212,  -162,   -81,   -82,   -28,   -15,
-    -3,  -164,  -224,   -30,   -16,  -224,  -224,   -17,    -6,  -224,
-  -166,   -18,    -7,  -179,  -178,  -187,   -60,   -34,  -224,   -31,
-   -32,   -33,  -123,  -224,  -204,  -222,  -224,   -44,  -224,   -51,
-   -45,   -48,   -46,  -224,   -49,   -43,   -82,   -52,   -47,  -224,
-   -53,   -50,  -224,  -124,  -224,  -224,  -224,  -224,  -224,  -187,
-  -224,  -107,  -224,  -224,   -58,  -187,   -62,  -224,   -94,  -187,
-  -101,  -224,  -186,  -187,  -184,  -180,  -182,  -183,  -185,    -4,
-   -39,  -224,  -224,   -38,  -224,  -116,  -224,  -224,   -94,  -168,
-  -169,  -171,  -188,  -189,  -224,   -25,   -29,   -22,   -24,   -82,
-   -23,  -224,  -224,  -224,  -224,  -224,  -224,  -224,  -224,  -224,
-  -224,  -224,  -224,  -224,  -224,  -224,  -224,  -224,  -224,  -224,
-  -141,   -41,  -207,  -224,  -224,  -224,  -224,  -220,  -219,  -215,
-  -224,  -216,  -134,   -92,   -91,   -93,  -224,   -21,  -187,  -224,
-  -109,  -108,  -165,  -159,  -224,  -161,  -152,  -160,  -153,   -82,
-  -224,  -204,  -187,   -75,   -74,   -65,  -224,   -82,   -66,   -68,
-  -224,  -101,  -224,  -210,   -95,  -224,  -224,   -99,  -210,  -100,
-  -102,  -224,   381,  -224,  -224,  -224,  -198,   -37,  -224,  -224,
-  -224,  -224,  -224,  -224,   -77,  -224,  -210,   -85,   -86,   -88,
-   -89,   -84,   -87,   -82,   -90,   -79,  -224,  -197,  -224,  -210,
-  -195,  -192,  -224,  -131,  -130,  -125,  -132,  -133,  -136,  -143,
-  -138,  -126,  -142,  -140,  -137,  -127,  -139,  -135,    -5,  -224,
-  -115,  -128,  -129,  -144,  -208,  -209,  -224,  -205,  -105,  -224,
-  -224,  -224,  -224,  -213,  -221,  -224,  -224,  -200,  -110,  -224,
-  -155,  -210,  -224,   -63,   -71,   -70,  -224,  -224,  -224,  -210,
-  -209,  -113,  -211,  -224,  -224,   -64,  -211,  -224,  -224,  -181,
-  -224,  -199,  -209,   -35,  -205,   -40,  -224,  -119,  -223,  -224,
-  -146,  -224,  -150,   -94,  -224,  -224,   -80,  -170,  -224,  -190,
-  -211,  -224,  -224,  -224,  -173,  -114,  -206,   -42,  -104,  -112,
-  -218,  -214,  -217,  -224,  -201,  -202,  -203,  -157,  -209,  -224,
-  -224,   -69,   -67,   -72,   -73,  -224,   -96,   -56,   -97,  -103,
-   -57,   -98,  -224,  -177,   -36,  -119,  -224,  -224,  -118,  -147,
-  -145,  -224,  -224,  -210,   -55,   -54,   -78,  -196,  -193,  -191,
-  -194,  -172,  -224,  -175,  -156,  -154,   -61,  -176,  -117,  -120,
-  -224,  -151,  -224,   -76,  -174,  -224,  -122,  -224,  -149,  -121,
-  -148 ]
+  -205,  -242,   -74,   -19,    -8,   -20,    -9,  -185,  -242,  -124,
+  -222,   -10,  -197,  -242,  -240,   -98,  -242,   -11,  -176,   -12,
+  -242,  -242,  -242,  -177,   -39,   -13,    -1,  -181,  -242,  -129,
+   -41,   -14,    -2,  -230,   -96,   -97,   -42,   -15,    -3,  -180,
+  -242,   -43,   -16,  -182,  -242,   -45,   -17,    -6,  -242,  -184,
+  -242,   -18,    -7,  -197,  -196,  -205,   -75,   -49,  -242,   -46,
+   -47,   -48,  -142,  -141,  -222,  -242,  -242,  -240,  -242,   -59,
+   -66,   -60,  -242,   -63,   -61,   -97,   -64,   -58,  -242,   -67,
+   -62,   -68,   -65,  -242,  -242,  -242,  -242,  -205,  -242,  -125,
+  -242,  -242,  -242,  -204,  -202,  -205,  -198,  -200,  -201,  -203,
+  -242,   -73,  -205,  -242,   -77,  -109,  -205,  -119,    -4,  -242,
+   -53,   -54,  -242,  -242,  -242,  -134,  -242,  -242,  -189,  -186,
+  -187,  -109,  -242,  -206,  -207,   -40,   -44,   -37,   -39,   -97,
+   -38,  -242,  -242,  -242,  -242,  -242,  -242,  -242,  -242,  -242,
+  -242,  -242,  -242,  -242,  -242,  -242,  -242,  -242,  -242,  -242,
+  -159,   -56,  -225,  -242,  -242,  -242,  -242,  -234,  -242,  -238,
+  -237,  -233,  -152,  -106,  -108,  -242,  -205,  -242,  -127,  -126,
+  -107,   -36,   402,  -242,  -242,  -242,  -216,  -242,  -222,  -205,
+   -90,   -89,   -80,   -97,  -242,   -81,   -83,  -242,  -119,   -25,
+   -29,   -27,  -113,  -228,   -35,   -23,  -110,   -31,  -242,   -33,
+   -32,  -114,   -21,  -112,   -34,   -28,   -26,   -22,   -30,   -24,
+  -242,  -117,  -228,  -118,  -120,  -112,  -183,  -177,  -179,  -242,
+  -178,  -170,   -97,  -242,  -171,  -242,   -52,  -242,  -242,  -242,
+  -242,  -242,  -242,   -94,   -92,  -242,  -228,  -100,  -101,  -114,
+  -103,  -104,   -99,   -97,   -34,  -102,  -105,   -24,  -242,  -215,
+  -213,  -242,  -228,  -210,  -162,  -149,  -148,  -143,  -150,  -151,
+  -154,  -161,  -156,  -144,  -160,  -158,  -155,  -145,  -157,  -153,
+    -5,  -242,  -133,  -146,  -147,  -226,  -227,  -242,  -223,  -123,
+  -242,  -242,  -242,  -231,  -242,  -239,  -242,  -242,  -218,  -128,
+  -199,  -217,  -242,  -242,  -242,  -242,   -78,   -86,   -85,  -242,
+  -227,  -131,  -228,  -229,  -242,  -242,   -79,  -229,  -242,  -242,
+  -242,  -173,  -228,   -55,  -227,   -50,  -223,  -242,  -137,  -242,
+  -164,  -242,  -168,  -241,  -188,  -242,   -95,  -109,  -242,  -242,
+  -191,  -242,  -242,  -208,  -229,  -242,  -132,  -224,   -57,  -122,
+  -130,  -235,  -232,  -236,  -242,  -221,  -220,  -219,  -242,  -195,
+   -87,   -88,   -84,   -82,  -242,  -111,   -71,  -115,  -121,   -72,
+  -116,  -175,  -227,  -242,  -242,   -51,  -137,  -136,  -242,  -242,
+  -165,  -163,  -242,  -242,   -69,   -93,  -228,   -70,  -190,  -214,
+  -212,  -211,  -209,  -242,  -193,  -194,   -76,  -174,  -172,  -135,
+  -138,  -242,  -169,  -242,   -91,  -192,  -242,  -140,  -242,  -167,
+  -139,  -166 ]
 
 racc_goto_table = [
-    21,    35,    29,   178,   115,    55,   110,   220,   214,   231,
-   102,   109,   193,    26,    41,   120,   197,    91,    89,   198,
-    93,   161,   300,   105,   126,   348,    43,   124,   174,    21,
-    35,   249,   216,   186,   125,    96,   127,   196,   299,   339,
-    33,   153,    26,    41,    94,    22,    58,   332,   176,   171,
-   271,   305,    88,   121,   126,    43,   225,   265,    21,    35,
-   103,   168,   283,   204,   125,   192,   167,   287,   329,   291,
-    10,    26,    41,   368,    22,   228,   229,   113,   324,   208,
-   209,   160,   130,    24,    43,   304,   nil,   nil,    21,    35,
-   nil,   270,   173,    35,   nil,   123,   296,   nil,   311,    10,
-   nil,    26,    41,   128,   nil,    26,    41,   197,   349,   nil,
-   279,   nil,   130,   nil,    43,   nil,   174,   313,   218,    35,
-   272,   nil,   259,   260,   241,   nil,   nil,   nil,   245,   123,
-   nil,    26,    41,   128,   nil,   nil,   nil,   nil,   nil,   nil,
-   330,   nil,   nil,   206,   224,   nil,    21,    35,   335,   302,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    26,
-    41,   nil,   172,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   268,    38,    43,   nil,   nil,   342,    15,   nil,   nil,   295,
-   173,    35,   nil,   nil,   nil,   nil,   nil,   nil,   102,   nil,
-   102,    22,   307,    26,    41,   220,   356,   358,   336,   nil,
-    38,   289,   197,   nil,   322,    15,   nil,   nil,   267,   nil,
-   nil,    21,    35,   173,    35,   nil,    10,   353,   nil,   nil,
-   nil,   nil,   373,   nil,    26,    41,    26,    41,   nil,    38,
-   109,   nil,    21,    35,    15,   302,   nil,    43,   327,   nil,
-   364,   nil,   nil,   nil,   nil,    26,    41,   nil,    21,    35,
-   172,   nil,   nil,   nil,   nil,   375,    22,   377,    43,    38,
-   nil,    26,    41,   nil,    15,   174,   nil,   nil,    15,   nil,
-   325,   183,   nil,   nil,    43,   183,   nil,    22,   nil,   nil,
-   nil,    10,   nil,   172,   nil,   nil,   nil,   371,   nil,   222,
-    21,    35,   nil,    22,   217,   nil,   nil,   nil,   nil,   173,
-    35,   nil,    10,    26,    41,   nil,   218,    35,   369,   nil,
-   nil,   nil,    26,    41,   nil,   nil,    43,    38,    10,    26,
-    41,    27,    15,    21,    35,   362,   nil,   nil,   nil,   173,
-    35,   nil,   224,   nil,   nil,    22,    26,    41,   nil,   nil,
-   nil,   nil,    26,    41,   109,   nil,   nil,   nil,   nil,    43,
-    27,   173,    35,   nil,   nil,   nil,    15,   nil,   183,   nil,
-    10,   nil,    21,    35,    26,    41,   nil,   nil,    22,   172,
-    21,    35,    21,    35,   nil,    26,    41,   nil,   nil,    27,
-   nil,   nil,    38,    26,    41,    26,    41,    15,    43,    15,
-   nil,   nil,   nil,    10,   nil,   nil,    43,   nil,    43,   172,
-   nil,   nil,   nil,    38,    31,   nil,   nil,    22,    15,    27,
-   nil,   nil,   nil,   175,   nil,    22,   184,    22,   nil,    38,
-   184,   172,   nil,   nil,    15,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,    10,    31,   nil,   nil,   nil,   nil,   nil,   219,
-    10,   nil,    10,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   183,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    38,    31,   nil,   nil,   nil,    15,    27,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,    15,   nil,   222,   nil,   nil,
-   nil,   nil,   217,   157,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,    31,   nil,    38,   nil,   177,   nil,   nil,    15,
-   nil,   175,   nil,   184,   nil,    15,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   221,   nil,   nil,   nil,   nil,    15,   nil,   nil,
-   nil,    63,    27,    38,   175,   nil,   nil,   nil,    15,    90,
-   nil,    38,   nil,    38,   nil,   nil,    15,   nil,    15,   nil,
-    31,   nil,   nil,    27,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   114,   nil,   nil,   117,    27,
+    23,    55,    26,    27,   111,   108,   115,   253,   157,   219,
+   271,   120,    87,    89,   193,   234,    39,   224,    32,    93,
+   241,   211,   100,    96,   184,   304,    23,   320,   210,    27,
+   236,   101,   367,   212,   104,   153,    58,   125,   319,   127,
+   358,   353,    39,   221,   308,    43,   126,    91,   169,   122,
+   312,   325,   118,   233,   286,    95,   175,   363,    23,   291,
+   251,    27,    24,   252,   110,   347,   187,   130,   328,    45,
+   125,    43,   171,   124,    39,   227,   228,   156,    20,   126,
+   389,   166,   nil,   nil,   335,   nil,   nil,   nil,    24,   nil,
+   nil,    23,   317,   nil,    27,    45,   nil,   nil,   nil,   nil,
+   130,   295,   211,    43,   nil,   124,   nil,    39,   nil,   217,
+   nil,   329,    27,   176,   302,   nil,   370,   280,   281,   nil,
+   128,   238,    18,   219,    27,    39,   nil,    45,   nil,   nil,
+   322,   311,   nil,   nil,   354,   nil,    43,    39,   263,   nil,
+   nil,   nil,   267,   nil,   364,   nil,   nil,    23,    18,   nil,
+    27,   nil,   nil,   128,    43,   348,   nil,   nil,   nil,   nil,
+    45,   nil,   nil,    39,   nil,   nil,    43,   289,   nil,   nil,
+   nil,    93,    93,   nil,   nil,   290,    41,   nil,   nil,   nil,
+    18,    14,   nil,   nil,   288,   nil,   nil,   nil,   nil,   nil,
+   246,   nil,    43,   nil,   313,   324,   nil,   nil,   nil,   nil,
+   nil,   nil,    41,   nil,   nil,   nil,   nil,    14,   394,    24,
+   nil,   nil,   341,    18,   nil,   nil,    45,   355,   381,   322,
+   375,   211,   nil,   217,   180,   241,    27,   nil,   180,    23,
+   217,    18,    27,    27,    41,   nil,   376,   nil,   nil,    39,
+   nil,   nil,   nil,   237,   nil,    39,    39,   nil,    23,   108,
+   nil,    27,   nil,   nil,   396,   nil,   398,   nil,   nil,   nil,
+   nil,   nil,   nil,   219,    39,   nil,   nil,    41,    43,    18,
+    23,   387,   392,    27,    43,    43,   nil,   nil,   nil,   361,
+   nil,   nil,   nil,   nil,   nil,   nil,    39,   346,   nil,   nil,
+   216,    24,    23,    43,   nil,    27,   nil,   245,    45,   nil,
+   nil,   180,   nil,   nil,   nil,   nil,   nil,   nil,    39,   nil,
+    24,   nil,   nil,   nil,   nil,    43,   nil,    45,   nil,   217,
+   nil,   nil,    27,    41,   nil,   nil,   238,   nil,    14,    27,
+   nil,   nil,    24,   nil,   390,    39,   nil,    43,   nil,    45,
+   nil,   nil,    39,   nil,    23,    18,   383,    27,   nil,   nil,
+   nil,    18,    18,   nil,    24,   nil,   nil,   nil,   nil,   nil,
+    39,    45,   108,   217,    43,   nil,    27,   nil,   nil,   nil,
+    18,    43,   217,   nil,   nil,    27,   nil,   nil,   nil,    39,
+   nil,   nil,   nil,    23,   nil,   nil,    27,   nil,    39,    43,
+   nil,    23,    18,    23,    27,   246,    27,   nil,   nil,    39,
+   nil,    30,   nil,   nil,   216,    41,    24,    39,    43,    39,
+    14,   216,   nil,    45,    18,   nil,   nil,    43,   nil,   nil,
+   nil,   180,   nil,   nil,    41,   nil,   nil,    30,    43,    14,
+   nil,   nil,   nil,   nil,   nil,   nil,    43,   nil,    43,   nil,
+   nil,    18,   nil,   nil,   nil,    24,    41,   nil,   237,   nil,
+   nil,    14,    45,    24,   nil,    24,    36,   nil,   nil,    30,
+    45,   nil,    45,   nil,   nil,   nil,    18,   nil,    41,   nil,
+   nil,   nil,   nil,    14,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    36,   nil,   nil,    18,   nil,   nil,   nil,   nil,
+   nil,   nil,    30,   nil,    18,   nil,   nil,   nil,   nil,   nil,
+   216,   nil,   245,   181,   nil,    18,   nil,   181,   nil,   nil,
+   218,   nil,   nil,    18,    36,    18,   nil,   nil,   nil,   nil,
+    41,   nil,   240,   nil,   nil,    14,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   159,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   216,   nil,   nil,    36,    30,   nil,
+   nil,   nil,   nil,   216,   nil,   nil,   nil,   nil,   nil,    41,
+   nil,   nil,   nil,   nil,    14,   220,   nil,    41,   nil,    41,
+   nil,   nil,    14,   nil,    14,   nil,   nil,   242,   nil,   nil,
+   181,    66,   nil,   nil,   nil,   nil,    88,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   177,   nil,   nil,   nil,   nil,   149,
-   nil,   150,   nil,   nil,   nil,   nil,   nil,   184,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   162,   nil,   163,   164,   165,
-   166,    27,   nil,   nil,   nil,    31,   nil,   177,   nil,   nil,
-   175,   nil,   nil,   nil,   nil,   nil,   nil,   219,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,    31,   nil,   nil,   212,
-   nil,   nil,   nil,   nil,    27,   nil,   nil,   nil,   nil,   nil,
-   175,   nil,    31,   nil,   233,   234,   235,   236,   237,   238,
-   239,   240,   nil,   242,   243,   244,   157,   246,   247,   nil,
-   251,   252,   175,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,    27,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    27,    90,    27,    31,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   177,   nil,   nil,   nil,   nil,   nil,   nil,
-   221,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,    31,   nil,   nil,
-   nil,   nil,   nil,   177,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,    36,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   114,   nil,   nil,   nil,   116,   nil,   nil,
+   nil,   nil,   nil,   nil,   218,   nil,   nil,   nil,   nil,   nil,
+    30,   218,   nil,   nil,   nil,   nil,   nil,   nil,   131,   nil,
+   nil,   150,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    30,
+   nil,   nil,   nil,   nil,   nil,   nil,   162,   163,   164,   165,
+   nil,   nil,   nil,   170,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,    30,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   220,
+   nil,   nil,   nil,   nil,   nil,    36,   220,   nil,   nil,   nil,
+   231,   nil,   nil,    30,   nil,   nil,   nil,   nil,   nil,   nil,
+   181,   nil,   nil,   nil,    36,   255,   256,   257,   258,   259,
+   260,   261,   262,   nil,   264,   265,   266,   nil,   268,   269,
+   218,   273,   274,   nil,   nil,   nil,    36,   240,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   159,   nil,
+    88,   nil,   nil,   nil,   nil,    30,   nil,   nil,    36,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   177,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,    31,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,    31,   nil,    31,   nil,   nil,   317,
-   nil,   nil,   nil,   nil,   320,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   218,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   218,   nil,   220,   nil,   nil,   nil,   nil,
+   nil,   nil,   242,   nil,    30,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    30,   nil,    30,   nil,   nil,   nil,   nil,   nil,
+    36,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   220,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   220,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    36,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,    36,   nil,    36,
+   338,   nil,   nil,   nil,   nil,   nil,   nil,   343,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   350,   351,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   357,   nil,
+   nil,   nil,   360,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   333,   334,   nil,   nil,   nil,   nil,   nil,   338,   nil,   nil,
-   nil,   341,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   379,   380,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   357,   nil,   nil,   nil,   360,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   114 ]
+   nil,   114 ]
 
 racc_goto_check = [
-    34,    37,     2,    69,    60,    39,    30,    36,    52,    81,
-    63,     4,    42,    35,    38,    71,    55,    58,    39,    44,
-    34,    84,    65,    77,    10,    61,    27,    73,    67,    34,
-    37,     5,    42,    47,     8,    46,    21,    47,    64,    57,
-     3,    28,    35,    38,     6,    23,    22,    48,    68,    59,
-    70,    41,    22,    72,    10,    27,    40,    74,    34,    37,
-    75,    73,    43,    76,     8,    28,    21,    43,    32,    78,
-    54,    35,    38,    61,    23,    79,    80,    29,    82,    28,
-    28,    83,     6,     1,    27,    43,   nil,   nil,    34,    37,
-   nil,    69,    34,    37,   nil,     3,     5,   nil,    43,    54,
-   nil,    35,    38,    23,   nil,    35,    38,    55,    65,   nil,
-    44,   nil,     6,   nil,    27,   nil,    67,     5,    34,    37,
-    47,   nil,    28,    28,    63,   nil,   nil,   nil,    63,     3,
-   nil,    35,    38,    23,   nil,   nil,   nil,   nil,   nil,   nil,
-    43,   nil,   nil,     3,    27,   nil,    34,    37,    43,    67,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    35,
-    38,   nil,    54,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-    58,    26,    27,   nil,   nil,     5,    33,   nil,   nil,    30,
-    34,    37,   nil,   nil,   nil,   nil,   nil,   nil,    63,   nil,
-    63,    23,    71,    35,    38,    36,    52,    81,    55,   nil,
-    26,    77,    55,   nil,    84,    33,   nil,   nil,     3,   nil,
-   nil,    34,    37,    34,    37,   nil,    54,    42,   nil,   nil,
-   nil,   nil,    43,   nil,    35,    38,    35,    38,   nil,    26,
-     4,   nil,    34,    37,    33,    67,   nil,    27,    30,   nil,
-    69,   nil,   nil,   nil,   nil,    35,    38,   nil,    34,    37,
-    54,   nil,   nil,   nil,   nil,     5,    23,     5,    27,    26,
-   nil,    35,    38,   nil,    33,    67,   nil,   nil,    33,   nil,
-    39,    33,   nil,   nil,    27,    33,   nil,    23,   nil,   nil,
-   nil,    54,   nil,    54,   nil,   nil,   nil,    67,   nil,    26,
-    34,    37,   nil,    23,    33,   nil,   nil,   nil,   nil,    34,
-    37,   nil,    54,    35,    38,   nil,    34,    37,    60,   nil,
-   nil,   nil,    35,    38,   nil,   nil,    27,    26,    54,    35,
-    38,    24,    33,    34,    37,     2,   nil,   nil,   nil,    34,
-    37,   nil,    27,   nil,   nil,    23,    35,    38,   nil,   nil,
-   nil,   nil,    35,    38,     4,   nil,   nil,   nil,   nil,    27,
-    24,    34,    37,   nil,   nil,   nil,    33,   nil,    33,   nil,
-    54,   nil,    34,    37,    35,    38,   nil,   nil,    23,    54,
-    34,    37,    34,    37,   nil,    35,    38,   nil,   nil,    24,
-   nil,   nil,    26,    35,    38,    35,    38,    33,    27,    33,
-   nil,   nil,   nil,    54,   nil,   nil,    27,   nil,    27,    54,
-   nil,   nil,   nil,    26,    25,   nil,   nil,    23,    33,    24,
-   nil,   nil,   nil,    24,   nil,    23,    24,    23,   nil,    26,
-    24,    54,   nil,   nil,    33,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,    54,    25,   nil,   nil,   nil,   nil,   nil,    24,
-    54,   nil,    54,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,    33,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    26,    25,   nil,   nil,   nil,    33,    24,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,    33,   nil,    26,   nil,   nil,
-   nil,   nil,    33,    25,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,    25,   nil,    26,   nil,    25,   nil,   nil,    33,
-   nil,    24,   nil,    24,   nil,    33,   nil,   nil,   nil,   nil,
+    35,    40,     2,    36,    31,     4,    62,    83,    86,    69,
+     5,    73,    40,    60,    43,    53,    38,    71,     3,    65,
+    37,    56,    35,    79,    48,    44,    35,    67,    48,    36,
+    43,     6,    63,    45,    47,    29,    23,     8,    66,    22,
+    59,    49,    38,    70,    44,    39,    10,    23,    61,    75,
+    72,    42,    74,    41,    76,    77,    78,    33,    35,    80,
+    81,    36,    24,    82,    30,    84,    29,     6,    44,    28,
+     8,    39,    22,     3,    38,    29,    29,    85,     1,    10,
+    63,    75,   nil,   nil,    44,   nil,   nil,   nil,    24,   nil,
+   nil,    35,     5,   nil,    36,    28,   nil,   nil,   nil,   nil,
+     6,    48,    56,    39,   nil,     3,   nil,    38,   nil,    35,
+   nil,     5,    36,     3,    45,   nil,    67,    29,    29,   nil,
+    24,    35,    34,    69,    36,    38,   nil,    28,   nil,   nil,
+    69,    71,   nil,   nil,    44,   nil,    39,    38,    65,   nil,
+   nil,   nil,    65,   nil,    44,   nil,   nil,    35,    34,   nil,
+    36,   nil,   nil,    24,    39,     5,   nil,   nil,   nil,   nil,
+    28,   nil,   nil,    38,   nil,   nil,    39,    60,   nil,   nil,
+   nil,    65,    65,   nil,   nil,    79,    27,   nil,   nil,   nil,
+    34,    55,   nil,   nil,     3,   nil,   nil,   nil,   nil,   nil,
+    28,   nil,    39,   nil,    31,    73,   nil,   nil,   nil,   nil,
+   nil,   nil,    27,   nil,   nil,   nil,   nil,    55,    44,    24,
+   nil,   nil,    86,    34,   nil,   nil,    28,    56,    83,    69,
+    53,    56,   nil,    35,    34,    37,    36,   nil,    34,    35,
+    35,    34,    36,    36,    27,   nil,    43,   nil,   nil,    38,
+   nil,   nil,   nil,    34,   nil,    38,    38,   nil,    35,     4,
+   nil,    36,   nil,   nil,     5,   nil,     5,   nil,   nil,   nil,
+   nil,   nil,   nil,    69,    38,   nil,   nil,    27,    39,    34,
+    35,    71,    69,    36,    39,    39,   nil,   nil,   nil,    31,
+   nil,   nil,   nil,   nil,   nil,   nil,    38,    40,   nil,   nil,
+    55,    24,    35,    39,   nil,    36,   nil,    27,    28,   nil,
+   nil,    34,   nil,   nil,   nil,   nil,   nil,   nil,    38,   nil,
+    24,   nil,   nil,   nil,   nil,    39,   nil,    28,   nil,    35,
+   nil,   nil,    36,    27,   nil,   nil,    35,   nil,    55,    36,
+   nil,   nil,    24,   nil,    62,    38,   nil,    39,   nil,    28,
+   nil,   nil,    38,   nil,    35,    34,     2,    36,   nil,   nil,
+   nil,    34,    34,   nil,    24,   nil,   nil,   nil,   nil,   nil,
+    38,    28,     4,    35,    39,   nil,    36,   nil,   nil,   nil,
+    34,    39,    35,   nil,   nil,    36,   nil,   nil,   nil,    38,
+   nil,   nil,   nil,    35,   nil,   nil,    36,   nil,    38,    39,
+   nil,    35,    34,    35,    36,    28,    36,   nil,   nil,    38,
+   nil,    25,   nil,   nil,    55,    27,    24,    38,    39,    38,
+    55,    55,   nil,    28,    34,   nil,   nil,    39,   nil,   nil,
+   nil,    34,   nil,   nil,    27,   nil,   nil,    25,    39,    55,
+   nil,   nil,   nil,   nil,   nil,   nil,    39,   nil,    39,   nil,
+   nil,    34,   nil,   nil,   nil,    24,    27,   nil,    34,   nil,
+   nil,    55,    28,    24,   nil,    24,    26,   nil,   nil,    25,
+    28,   nil,    28,   nil,   nil,   nil,    34,   nil,    27,   nil,
+   nil,   nil,   nil,    55,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    26,   nil,   nil,    34,   nil,   nil,   nil,   nil,
+   nil,   nil,    25,   nil,    34,   nil,   nil,   nil,   nil,   nil,
+    55,   nil,    27,    25,   nil,    34,   nil,    25,   nil,   nil,
+    25,   nil,   nil,    34,    26,    34,   nil,   nil,   nil,   nil,
+    27,   nil,    25,   nil,   nil,    55,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,    26,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,    55,   nil,   nil,    26,    25,   nil,
+   nil,   nil,   nil,    55,   nil,   nil,   nil,   nil,   nil,    27,
+   nil,   nil,   nil,   nil,    55,    26,   nil,    27,   nil,    27,
+   nil,   nil,    55,   nil,    55,   nil,   nil,    26,   nil,   nil,
+    25,    32,   nil,   nil,   nil,   nil,    32,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,    25,   nil,   nil,   nil,   nil,    33,   nil,   nil,
-   nil,    31,    24,    26,    24,   nil,   nil,   nil,    33,    31,
-   nil,    26,   nil,    26,   nil,   nil,    33,   nil,    33,   nil,
-    25,   nil,   nil,    24,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,    31,   nil,   nil,    31,    24,
+   nil,   nil,   nil,    26,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,    32,   nil,   nil,   nil,    32,   nil,   nil,
+   nil,   nil,   nil,   nil,    25,   nil,   nil,   nil,   nil,   nil,
+    25,    25,   nil,   nil,   nil,   nil,   nil,   nil,    32,   nil,
+   nil,    32,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    25,
+   nil,   nil,   nil,   nil,   nil,   nil,    32,    32,    32,    32,
+   nil,   nil,   nil,    32,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,    25,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    26,
+   nil,   nil,   nil,   nil,   nil,    26,    26,   nil,   nil,   nil,
+    32,   nil,   nil,    25,   nil,   nil,   nil,   nil,   nil,   nil,
+    25,   nil,   nil,   nil,    26,    32,    32,    32,    32,    32,
+    32,    32,    32,   nil,    32,    32,    32,   nil,    32,    32,
+    25,    32,    32,   nil,   nil,   nil,    26,    25,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    26,   nil,
+    32,   nil,   nil,   nil,   nil,    25,   nil,   nil,    26,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,    25,   nil,   nil,   nil,   nil,    31,
-   nil,    31,   nil,   nil,   nil,   nil,   nil,    24,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,    31,   nil,    31,    31,    31,
-    31,    24,   nil,   nil,   nil,    25,   nil,    25,   nil,   nil,
-    24,   nil,   nil,   nil,   nil,   nil,   nil,    24,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,    25,   nil,   nil,    31,
-   nil,   nil,   nil,   nil,    24,   nil,   nil,   nil,   nil,   nil,
-    24,   nil,    25,   nil,    31,    31,    31,    31,    31,    31,
-    31,    31,   nil,    31,    31,    31,    25,    31,    31,   nil,
-    31,    31,    24,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,    24,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    24,    31,    24,    25,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,    25,   nil,   nil,   nil,   nil,   nil,   nil,
-    25,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,    25,   nil,   nil,
-   nil,   nil,   nil,    25,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,    25,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,    25,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,    25,   nil,    25,   nil,   nil,    31,
-   nil,   nil,   nil,   nil,    31,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,    25,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,    25,   nil,    26,   nil,   nil,   nil,   nil,
+   nil,   nil,    26,   nil,    25,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    25,   nil,    25,   nil,   nil,   nil,   nil,   nil,
+    26,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    26,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    26,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    26,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,    26,   nil,    26,
+    32,   nil,   nil,   nil,   nil,   nil,   nil,    32,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,    32,    32,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    32,   nil,
+   nil,   nil,    32,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-    31,    31,   nil,   nil,   nil,   nil,   nil,    31,   nil,   nil,
-   nil,    31,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,    32,    32,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    31,   nil,   nil,   nil,    31,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
    nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    31 ]
+   nil,    32 ]
 
 racc_goto_pointer = [
-   nil,    83,     2,    40,   -18,  -115,    24,   nil,   -24,   nil,
-   -34,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,   -22,    40,    45,   321,   404,   171,    26,   -32,    40,
-   -31,   523,  -203,   176,     0,    13,  -111,     1,    14,     4,
-   -62,  -174,   -86,  -131,   -81,   nil,    14,   -62,  -229,   nil,
-   nil,   nil,  -110,   nil,    70,   -84,   nil,  -247,     1,   -41,
-   -38,  -272,   nil,   -15,  -175,  -191,   nil,   -64,   -44,   -89,
-  -130,   -34,     4,   -28,  -111,    35,   -40,    -2,  -136,   -47,
-   -46,  -113,  -188,     2,   -58,   nil ]
+   nil,    78,     2,    18,   -21,  -137,     9,   nil,   -21,   nil,
+   -12,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   -19,    31,    62,   401,   456,   176,    69,   -37,
+    29,   -31,   573,  -255,   122,     0,     3,  -101,    16,    45,
+     0,   -68,  -182,   -91,  -168,   -74,   nil,    11,   -78,  -258,
+   nil,   nil,   nil,  -106,   nil,   181,   -86,   nil,   nil,  -267,
+     0,   -40,   -34,  -286,   nil,    -2,  -192,  -203,   nil,  -100,
+   -66,   -92,  -173,   -37,     4,    -6,  -112,    34,   -39,     2,
+  -115,   -63,   -60,  -116,  -222,    -1,   -70,   nil ]
 
 racc_goto_default = [
-   nil,   nil,   248,   185,    40,   nil,    48,    52,     5,     7,
-    13,    18,    23,    28,    32,    39,    44,    47,    51,     4,
-     6,    12,   nil,    69,    71,    75,    78,    81,   nil,   nil,
-    62,   151,   256,    67,    70,    72,    74,    77,    80,    46,
-   nil,   nil,   nil,   nil,   nil,    20,   nil,   nil,   188,   276,
-   189,   190,   nil,   215,    65,   194,   199,   200,   nil,   nil,
-   nil,   nil,    83,     2,   nil,   nil,   301,    19,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   106,   nil,
-   nil,   nil,   nil,   nil,   nil,   156 ]
+   nil,   nil,   270,   182,    38,   nil,    47,    52,     4,     6,
+    11,    17,    19,    25,    31,    37,    42,    46,    51,     3,
+     5,   192,    16,   nil,    70,    73,    77,    80,    82,   nil,
+   nil,    63,   151,   277,    69,    71,    74,    76,    79,    81,
+    50,   nil,   nil,   nil,   nil,   nil,    22,   nil,   nil,   185,
+   299,   186,   177,   nil,   235,    67,   196,   198,   213,   214,
+   nil,   nil,   nil,   nil,    62,     7,   nil,   nil,   321,    28,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+    97,   nil,   nil,   nil,   nil,   nil,   nil,   158 ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
   1, 70, :_reduce_none,
   1, 70, :_reduce_none,
   1, 71, :_reduce_3,
   2, 71, :_reduce_4,
   1, 74, :_reduce_5,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
   1, 73, :_reduce_none,
-  3, 89, :_reduce_21,
-  3, 89, :_reduce_22,
   1, 90, :_reduce_none,
   1, 90, :_reduce_none,
   1, 90, :_reduce_none,
   1, 90, :_reduce_none,
   1, 90, :_reduce_none,
   1, 90, :_reduce_none,
   1, 90, :_reduce_none,
   1, 90, :_reduce_none,
+  1, 90, :_reduce_none,
+  1, 90, :_reduce_none,
+  1, 90, :_reduce_none,
+  1, 90, :_reduce_none,
+  1, 90, :_reduce_none,
+  1, 90, :_reduce_none,
+  1, 90, :_reduce_none,
+  3, 89, :_reduce_36,
+  3, 89, :_reduce_37,
+  1, 91, :_reduce_none,
+  1, 91, :_reduce_none,
   1, 91, :_reduce_none,
   1, 91, :_reduce_none,
   1, 91, :_reduce_none,
   1, 91, :_reduce_none,
-  4, 83, :_reduce_35,
-  5, 83, :_reduce_36,
-  3, 83, :_reduce_37,
-  2, 83, :_reduce_38,
-  1, 98, :_reduce_39,
-  3, 98, :_reduce_40,
-  1, 97, :_reduce_41,
-  3, 97, :_reduce_42,
-  1, 99, :_reduce_none,
-  1, 99, :_reduce_none,
-  1, 99, :_reduce_none,
-  1, 99, :_reduce_none,
-  1, 99, :_reduce_none,
-  1, 99, :_reduce_none,
-  1, 99, :_reduce_none,
-  1, 99, :_reduce_none,
-  1, 99, :_reduce_none,
-  1, 99, :_reduce_none,
-  1, 99, :_reduce_none,
-  5, 75, :_reduce_54,
-  5, 75, :_reduce_55,
-  5, 75, :_reduce_56,
-  5, 87, :_reduce_57,
-  2, 76, :_reduce_58,
-  1, 114, :_reduce_59,
-  2, 114, :_reduce_60,
-  6, 77, :_reduce_61,
-  2, 77, :_reduce_62,
-  3, 115, :_reduce_63,
-  3, 115, :_reduce_64,
-  1, 116, :_reduce_none,
-  1, 116, :_reduce_none,
-  3, 116, :_reduce_67,
+  1, 91, :_reduce_none,
+  1, 91, :_reduce_none,
+  1, 92, :_reduce_none,
+  1, 92, :_reduce_none,
+  1, 92, :_reduce_none,
+  1, 92, :_reduce_none,
+  4, 83, :_reduce_50,
+  5, 83, :_reduce_51,
+  3, 83, :_reduce_52,
+  2, 83, :_reduce_53,
+  1, 99, :_reduce_54,
+  3, 99, :_reduce_55,
+  1, 98, :_reduce_56,
+  3, 98, :_reduce_57,
+  1, 100, :_reduce_none,
+  1, 100, :_reduce_none,
+  1, 100, :_reduce_none,
+  1, 100, :_reduce_none,
+  1, 100, :_reduce_none,
+  1, 100, :_reduce_none,
+  1, 100, :_reduce_none,
+  1, 100, :_reduce_none,
+  1, 100, :_reduce_none,
+  1, 100, :_reduce_none,
+  1, 100, :_reduce_none,
+  5, 75, :_reduce_69,
+  5, 75, :_reduce_70,
+  5, 75, :_reduce_71,
+  5, 87, :_reduce_72,
+  2, 76, :_reduce_73,
+  1, 115, :_reduce_74,
+  2, 115, :_reduce_75,
+  6, 77, :_reduce_76,
+  2, 77, :_reduce_77,
+  3, 116, :_reduce_78,
+  3, 116, :_reduce_79,
   1, 117, :_reduce_none,
-  3, 117, :_reduce_69,
-  1, 118, :_reduce_70,
-  1, 118, :_reduce_71,
-  3, 119, :_reduce_72,
-  3, 119, :_reduce_73,
-  1, 120, :_reduce_none,
-  1, 120, :_reduce_none,
-  4, 121, :_reduce_76,
-  1, 109, :_reduce_77,
-  3, 109, :_reduce_78,
-  0, 110, :_reduce_none,
-  1, 110, :_reduce_none,
-  1, 107, :_reduce_81,
-  1, 102, :_reduce_82,
-  1, 103, :_reduce_83,
-  1, 122, :_reduce_none,
-  1, 122, :_reduce_none,
-  1, 122, :_reduce_none,
-  1, 122, :_reduce_none,
-  1, 122, :_reduce_none,
-  1, 122, :_reduce_none,
-  1, 122, :_reduce_none,
-  3, 78, :_reduce_91,
-  3, 78, :_reduce_92,
-  3, 88, :_reduce_93,
-  0, 111, :_reduce_94,
-  1, 111, :_reduce_95,
-  3, 111, :_reduce_96,
-  3, 124, :_reduce_97,
-  3, 125, :_reduce_98,
+  1, 117, :_reduce_none,
+  3, 117, :_reduce_82,
+  1, 118, :_reduce_none,
+  3, 118, :_reduce_84,
+  1, 119, :_reduce_85,
+  1, 119, :_reduce_86,
+  3, 120, :_reduce_87,
+  3, 120, :_reduce_88,
+  1, 121, :_reduce_none,
+  1, 121, :_reduce_none,
+  4, 122, :_reduce_91,
+  1, 110, :_reduce_92,
+  3, 110, :_reduce_93,
+  0, 111, :_reduce_none,
+  1, 111, :_reduce_none,
+  1, 108, :_reduce_96,
+  1, 103, :_reduce_97,
+  1, 104, :_reduce_98,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  1, 123, :_reduce_none,
+  3, 78, :_reduce_106,
+  3, 78, :_reduce_107,
+  3, 88, :_reduce_108,
+  0, 112, :_reduce_109,
+  1, 112, :_reduce_110,
+  3, 112, :_reduce_111,
   1, 126, :_reduce_none,
   1, 126, :_reduce_none,
-  0, 113, :_reduce_101,
-  1, 113, :_reduce_102,
-  3, 113, :_reduce_103,
-  4, 106, :_reduce_104,
-  3, 106, :_reduce_105,
-  1, 94, :_reduce_106,
-  2, 94, :_reduce_107,
-  2, 127, :_reduce_108,
-  1, 128, :_reduce_109,
-  2, 128, :_reduce_110,
-  1, 104, :_reduce_111,
-  4, 92, :_reduce_112,
-  4, 92, :_reduce_113,
-  5, 81, :_reduce_114,
-  4, 81, :_reduce_115,
-  2, 80, :_reduce_116,
-  5, 129, :_reduce_117,
-  4, 129, :_reduce_118,
-  0, 130, :_reduce_none,
-  2, 130, :_reduce_120,
-  4, 130, :_reduce_121,
-  3, 130, :_reduce_122,
-  1, 100, :_reduce_none,
-  1, 100, :_reduce_none,
-  3, 100, :_reduce_125,
-  3, 100, :_reduce_126,
-  3, 100, :_reduce_127,
-  3, 100, :_reduce_128,
-  3, 100, :_reduce_129,
-  3, 100, :_reduce_130,
-  3, 100, :_reduce_131,
-  3, 100, :_reduce_132,
-  3, 100, :_reduce_133,
-  2, 100, :_reduce_134,
-  3, 100, :_reduce_135,
-  3, 100, :_reduce_136,
-  3, 100, :_reduce_137,
-  3, 100, :_reduce_138,
-  3, 100, :_reduce_139,
-  3, 100, :_reduce_140,
-  2, 100, :_reduce_141,
-  3, 100, :_reduce_142,
-  3, 100, :_reduce_143,
-  3, 100, :_reduce_144,
-  5, 79, :_reduce_145,
-  1, 133, :_reduce_146,
-  2, 133, :_reduce_147,
-  5, 134, :_reduce_148,
-  4, 134, :_reduce_149,
-  1, 135, :_reduce_150,
-  3, 135, :_reduce_151,
-  3, 95, :_reduce_152,
-  1, 137, :_reduce_none,
-  4, 137, :_reduce_154,
+  1, 126, :_reduce_none,
+  3, 125, :_reduce_115,
+  3, 127, :_reduce_116,
+  1, 128, :_reduce_none,
+  1, 128, :_reduce_none,
+  0, 114, :_reduce_119,
+  1, 114, :_reduce_120,
+  3, 114, :_reduce_121,
+  4, 107, :_reduce_122,
+  3, 107, :_reduce_123,
+  1, 95, :_reduce_124,
+  2, 95, :_reduce_125,
+  2, 129, :_reduce_126,
+  1, 130, :_reduce_127,
+  2, 130, :_reduce_128,
+  1, 105, :_reduce_129,
+  4, 93, :_reduce_130,
+  4, 93, :_reduce_131,
+  5, 81, :_reduce_132,
+  4, 81, :_reduce_133,
+  2, 80, :_reduce_134,
+  5, 131, :_reduce_135,
+  4, 131, :_reduce_136,
+  0, 132, :_reduce_none,
+  2, 132, :_reduce_138,
+  4, 132, :_reduce_139,
+  3, 132, :_reduce_140,
+  1, 101, :_reduce_none,
+  1, 101, :_reduce_none,
+  3, 101, :_reduce_143,
+  3, 101, :_reduce_144,
+  3, 101, :_reduce_145,
+  3, 101, :_reduce_146,
+  3, 101, :_reduce_147,
+  3, 101, :_reduce_148,
+  3, 101, :_reduce_149,
+  3, 101, :_reduce_150,
+  3, 101, :_reduce_151,
+  2, 101, :_reduce_152,
+  3, 101, :_reduce_153,
+  3, 101, :_reduce_154,
+  3, 101, :_reduce_155,
+  3, 101, :_reduce_156,
+  3, 101, :_reduce_157,
+  3, 101, :_reduce_158,
+  2, 101, :_reduce_159,
+  3, 101, :_reduce_160,
+  3, 101, :_reduce_161,
+  3, 101, :_reduce_162,
+  5, 79, :_reduce_163,
+  1, 135, :_reduce_164,
+  2, 135, :_reduce_165,
+  5, 136, :_reduce_166,
+  4, 136, :_reduce_167,
+  1, 137, :_reduce_168,
+  3, 137, :_reduce_169,
+  3, 96, :_reduce_170,
   1, 139, :_reduce_none,
-  3, 139, :_reduce_156,
-  3, 138, :_reduce_157,
-  1, 136, :_reduce_none,
-  1, 136, :_reduce_none,
-  1, 136, :_reduce_none,
-  1, 136, :_reduce_none,
-  1, 136, :_reduce_none,
-  1, 136, :_reduce_none,
-  1, 136, :_reduce_none,
-  1, 136, :_reduce_none,
-  1, 136, :_reduce_166,
-  1, 136, :_reduce_none,
-  1, 140, :_reduce_168,
+  4, 139, :_reduce_172,
   1, 141, :_reduce_none,
-  3, 141, :_reduce_170,
-  2, 82, :_reduce_171,
-  6, 84, :_reduce_172,
-  5, 84, :_reduce_173,
-  7, 85, :_reduce_174,
-  6, 85, :_reduce_175,
-  6, 86, :_reduce_176,
-  5, 86, :_reduce_177,
-  1, 108, :_reduce_178,
-  1, 108, :_reduce_179,
-  1, 144, :_reduce_180,
-  3, 144, :_reduce_181,
-  1, 146, :_reduce_182,
-  1, 147, :_reduce_183,
-  1, 147, :_reduce_184,
-  1, 147, :_reduce_185,
-  1, 147, :_reduce_none,
-  0, 72, :_reduce_187,
-  0, 148, :_reduce_188,
-  1, 142, :_reduce_none,
-  3, 142, :_reduce_190,
-  4, 142, :_reduce_191,
-  1, 149, :_reduce_none,
-  3, 149, :_reduce_193,
-  3, 150, :_reduce_194,
-  1, 150, :_reduce_195,
-  3, 150, :_reduce_196,
-  1, 150, :_reduce_197,
-  1, 145, :_reduce_none,
-  2, 145, :_reduce_199,
+  3, 141, :_reduce_174,
+  3, 140, :_reduce_175,
+  1, 138, :_reduce_none,
+  1, 138, :_reduce_none,
+  1, 138, :_reduce_none,
+  1, 138, :_reduce_none,
+  1, 138, :_reduce_none,
+  1, 138, :_reduce_none,
+  1, 138, :_reduce_none,
+  1, 138, :_reduce_none,
+  1, 138, :_reduce_184,
+  1, 138, :_reduce_none,
+  1, 142, :_reduce_186,
   1, 143, :_reduce_none,
-  2, 143, :_reduce_201,
-  1, 151, :_reduce_none,
+  3, 143, :_reduce_188,
+  2, 82, :_reduce_189,
+  6, 84, :_reduce_190,
+  5, 84, :_reduce_191,
+  7, 85, :_reduce_192,
+  6, 85, :_reduce_193,
+  6, 86, :_reduce_194,
+  5, 86, :_reduce_195,
+  1, 109, :_reduce_196,
+  1, 109, :_reduce_197,
+  1, 146, :_reduce_198,
+  3, 146, :_reduce_199,
+  1, 148, :_reduce_200,
+  1, 149, :_reduce_201,
+  1, 149, :_reduce_202,
+  1, 149, :_reduce_203,
+  1, 149, :_reduce_none,
+  0, 72, :_reduce_205,
+  0, 150, :_reduce_206,
+  1, 144, :_reduce_none,
+  3, 144, :_reduce_208,
+  4, 144, :_reduce_209,
   1, 151, :_reduce_none,
-  1, 93, :_reduce_204,
-  3, 105, :_reduce_205,
-  4, 105, :_reduce_206,
-  2, 105, :_reduce_207,
-  1, 101, :_reduce_none,
-  1, 101, :_reduce_none,
-  0, 112, :_reduce_none,
-  1, 112, :_reduce_211,
-  1, 132, :_reduce_212,
-  3, 131, :_reduce_213,
-  4, 131, :_reduce_214,
-  2, 131, :_reduce_215,
-  1, 152, :_reduce_none,
-  3, 152, :_reduce_217,
-  3, 153, :_reduce_218,
-  1, 154, :_reduce_219,
-  1, 154, :_reduce_220,
-  4, 123, :_reduce_221,
-  1, 96, :_reduce_none,
-  4, 96, :_reduce_223 ]
-
-racc_reduce_n = 224
-
-racc_shift_n = 381
+  3, 151, :_reduce_211,
+  3, 152, :_reduce_212,
+  1, 152, :_reduce_213,
+  3, 152, :_reduce_214,
+  1, 152, :_reduce_215,
+  1, 147, :_reduce_none,
+  2, 147, :_reduce_217,
+  1, 145, :_reduce_none,
+  2, 145, :_reduce_219,
+  1, 153, :_reduce_none,
+  1, 153, :_reduce_none,
+  1, 94, :_reduce_222,
+  3, 106, :_reduce_223,
+  4, 106, :_reduce_224,
+  2, 106, :_reduce_225,
+  1, 102, :_reduce_none,
+  1, 102, :_reduce_none,
+  0, 113, :_reduce_none,
+  1, 113, :_reduce_229,
+  1, 134, :_reduce_230,
+  3, 133, :_reduce_231,
+  4, 133, :_reduce_232,
+  2, 133, :_reduce_233,
+  1, 154, :_reduce_none,
+  3, 154, :_reduce_235,
+  3, 155, :_reduce_236,
+  1, 156, :_reduce_237,
+  1, 156, :_reduce_238,
+  4, 124, :_reduce_239,
+  1, 97, :_reduce_none,
+  4, 97, :_reduce_241 ]
+
+racc_reduce_n = 242
+
+racc_shift_n = 402
 
 racc_token_table = {
   false => 0,
   :error => 1,
   :STRING => 2,
   :DQPRE => 3,
   :DQMID => 4,
   :DQPOST => 5,
   :LBRACK => 6,
   :RBRACK => 7,
   :LBRACE => 8,
   :RBRACE => 9,
   :SYMBOL => 10,
   :FARROW => 11,
   :COMMA => 12,
   :TRUE => 13,
   :FALSE => 14,
   :EQUALS => 15,
   :APPENDS => 16,
   :LESSEQUAL => 17,
   :NOTEQUAL => 18,
   :DOT => 19,
   :COLON => 20,
   :LLCOLLECT => 21,
   :RRCOLLECT => 22,
   :QMARK => 23,
   :LPAREN => 24,
   :RPAREN => 25,
   :ISEQUAL => 26,
   :GREATEREQUAL => 27,
   :GREATERTHAN => 28,
   :LESSTHAN => 29,
   :IF => 30,
   :ELSE => 31,
   :IMPORT => 32,
   :DEFINE => 33,
   :ELSIF => 34,
   :VARIABLE => 35,
   :CLASS => 36,
   :INHERITS => 37,
   :NODE => 38,
   :BOOLEAN => 39,
   :NAME => 40,
   :SEMIC => 41,
   :CASE => 42,
   :DEFAULT => 43,
   :AT => 44,
   :LCOLLECT => 45,
   :RCOLLECT => 46,
   :CLASSREF => 47,
   :NOT => 48,
   :OR => 49,
   :AND => 50,
   :UNDEF => 51,
   :PARROW => 52,
   :PLUS => 53,
   :MINUS => 54,
   :TIMES => 55,
   :DIV => 56,
   :LSHIFT => 57,
   :RSHIFT => 58,
   :UMINUS => 59,
   :MATCH => 60,
   :NOMATCH => 61,
   :REGEX => 62,
   :IN_EDGE => 63,
   :OUT_EDGE => 64,
   :IN_EDGE_SUB => 65,
   :OUT_EDGE_SUB => 66,
   :IN => 67,
   :UNLESS => 68 }
 
 racc_nt_base = 69
 
 racc_use_result_var = true
 
 Racc_arg = [
   racc_action_table,
   racc_action_check,
   racc_action_default,
   racc_action_pointer,
   racc_goto_table,
   racc_goto_check,
   racc_goto_default,
   racc_goto_pointer,
   racc_nt_base,
   racc_reduce_table,
   racc_token_table,
   racc_shift_n,
   racc_reduce_n,
   racc_use_result_var ]
 
 Racc_token_to_s_table = [
   "$end",
   "error",
   "STRING",
   "DQPRE",
   "DQMID",
   "DQPOST",
   "LBRACK",
   "RBRACK",
   "LBRACE",
   "RBRACE",
   "SYMBOL",
   "FARROW",
   "COMMA",
   "TRUE",
   "FALSE",
   "EQUALS",
   "APPENDS",
   "LESSEQUAL",
   "NOTEQUAL",
   "DOT",
   "COLON",
   "LLCOLLECT",
   "RRCOLLECT",
   "QMARK",
   "LPAREN",
   "RPAREN",
   "ISEQUAL",
   "GREATEREQUAL",
   "GREATERTHAN",
   "LESSTHAN",
   "IF",
   "ELSE",
   "IMPORT",
   "DEFINE",
   "ELSIF",
   "VARIABLE",
   "CLASS",
   "INHERITS",
   "NODE",
   "BOOLEAN",
   "NAME",
   "SEMIC",
   "CASE",
   "DEFAULT",
   "AT",
   "LCOLLECT",
   "RCOLLECT",
   "CLASSREF",
   "NOT",
   "OR",
   "AND",
   "UNDEF",
   "PARROW",
   "PLUS",
   "MINUS",
   "TIMES",
   "DIV",
   "LSHIFT",
   "RSHIFT",
   "UMINUS",
   "MATCH",
   "NOMATCH",
   "REGEX",
   "IN_EDGE",
   "OUT_EDGE",
   "IN_EDGE_SUB",
   "OUT_EDGE_SUB",
   "IN",
   "UNLESS",
   "$start",
   "program",
   "statements_and_declarations",
   "nil",
   "statement_or_declaration",
   "statements",
   "resource",
   "virtualresource",
   "collection",
   "assignment",
   "casestatement",
   "ifstatement_begin",
   "unlessstatement",
   "import",
   "fstatement",
   "definition",
   "hostclass",
   "nodedef",
   "resourceoverride",
   "append",
   "relationship",
+  "keyword",
   "relationship_side",
   "edge",
   "resourceref",
   "variable",
   "quotedtext",
   "selector",
   "hasharrayaccesses",
   "expressions",
   "funcvalues",
   "rvalue",
   "expression",
   "comma",
   "name",
   "type",
   "boolean",
   "array",
   "funcrvalue",
   "undef",
   "classname",
   "resourceinstances",
   "endsemi",
   "params",
   "endcomma",
   "anyparams",
   "at",
   "collectrhand",
   "collstatements",
   "collstatement",
   "colljoin",
   "collexpr",
   "colllval",
   "resourceinst",
   "resourcename",
   "hasharrayaccess",
   "param",
+  "param_name",
   "addparam",
   "anyparam",
   "dqrval",
   "dqtail",
   "ifstatement",
   "else",
   "hash",
   "regex",
   "caseopts",
   "caseopt",
   "casevalues",
   "selectlhand",
   "svalues",
   "selectval",
   "sintvalues",
   "string",
   "strings",
   "argumentlist",
   "classparent",
   "hostnames",
   "nodeparent",
   "nodename",
   "hostname",
   "nothing",
   "arguments",
   "argument",
   "classnameordefault",
   "hashpairs",
   "hashpair",
   "key" ]
 
 Racc_debug_parser = false
 
 ##### State transition tables end #####
 
 # reduce 0 omitted
 
 # reduce 1 omitted
 
 # reduce 2 omitted
 
 module_eval(<<'.,.,', 'grammar.ra', 34)
   def _reduce_3(val, _values, result)
         result = ast AST::ASTArray, :children => (val[0] ? [val[0]] : [])
   
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'grammar.ra', 37)
   def _reduce_4(val, _values, result)
         if val[1]
       val[0].push(val[1])
     end
     result = val[0]
   
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'grammar.ra', 46)
   def _reduce_5(val, _values, result)
       val[0].each do |stmt|
     if stmt.is_a?(AST::TopLevelConstruct)
       error "Classes, definitions, and nodes may only appear at toplevel or inside other classes", \
           :line => stmt.context[:line], :file => stmt.context[:file]
     end
   end
   result = val[0]
 
     result
   end
 .,.,
 
 # reduce 6 omitted
 
 # reduce 7 omitted
 
 # reduce 8 omitted
 
 # reduce 9 omitted
 
 # reduce 10 omitted
 
 # reduce 11 omitted
 
 # reduce 12 omitted
 
 # reduce 13 omitted
 
 # reduce 14 omitted
 
 # reduce 15 omitted
 
 # reduce 16 omitted
 
 # reduce 17 omitted
 
 # reduce 18 omitted
 
 # reduce 19 omitted
 
 # reduce 20 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 73)
-  def _reduce_21(val, _values, result)
-      result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context)
+# reduce 21 omitted
 
-    result
-  end
-.,.,
-
-module_eval(<<'.,.,', 'grammar.ra', 76)
-  def _reduce_22(val, _values, result)
-        result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context)
-
-    result
-  end
-.,.,
+# reduce 22 omitted
 
 # reduce 23 omitted
 
 # reduce 24 omitted
 
 # reduce 25 omitted
 
 # reduce 26 omitted
 
 # reduce 27 omitted
 
 # reduce 28 omitted
 
 # reduce 29 omitted
 
 # reduce 30 omitted
 
 # reduce 31 omitted
 
 # reduce 32 omitted
 
 # reduce 33 omitted
 
 # reduce 34 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 91)
-  def _reduce_35(val, _values, result)
+# reduce 35 omitted
+
+module_eval(<<'.,.,', 'grammar.ra', 89)
+  def _reduce_36(val, _values, result)
+      result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context)
+
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'grammar.ra', 92)
+  def _reduce_37(val, _values, result)
+        result = AST::Relationship.new(val[0], val[2], val[1][:value], ast_context)
+
+    result
+  end
+.,.,
+
+# reduce 38 omitted
+
+# reduce 39 omitted
+
+# reduce 40 omitted
+
+# reduce 41 omitted
+
+# reduce 42 omitted
+
+# reduce 43 omitted
+
+# reduce 44 omitted
+
+# reduce 45 omitted
+
+# reduce 46 omitted
+
+# reduce 47 omitted
+
+# reduce 48 omitted
+
+# reduce 49 omitted
+
+module_eval(<<'.,.,', 'grammar.ra', 107)
+  def _reduce_50(val, _values, result)
       result = ast AST::Function,
     :name => val[0][:value],
     :line => val[0][:line],
     :arguments => val[2],
     :ftype => :statement
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 98)
-  def _reduce_36(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 114)
+  def _reduce_51(val, _values, result)
       result = ast AST::Function,
     :name => val[0][:value],
     :line => val[0][:line],
     :arguments => val[2],
     :ftype => :statement
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 104)
-  def _reduce_37(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 120)
+  def _reduce_52(val, _values, result)
       result = ast AST::Function,
     :name => val[0][:value],
     :line => val[0][:line],
     :arguments => AST::ASTArray.new({}),
     :ftype => :statement
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 111)
-  def _reduce_38(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 127)
+  def _reduce_53(val, _values, result)
         result = ast AST::Function,
     :name => val[0][:value],
     :line => val[0][:line],
     :arguments => val[1],
     :ftype => :statement
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 118)
-  def _reduce_39(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 134)
+  def _reduce_54(val, _values, result)
      result = aryfy(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 121)
-  def _reduce_40(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 137)
+  def _reduce_55(val, _values, result)
         val[0].push(val[2])
     result = val[0]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 125)
-  def _reduce_41(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 141)
+  def _reduce_56(val, _values, result)
      result = aryfy(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 126)
-  def _reduce_42(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 142)
+  def _reduce_57(val, _values, result)
      result = val[0].push(val[2]) 
     result
   end
 .,.,
 
-# reduce 43 omitted
+# reduce 58 omitted
 
-# reduce 44 omitted
+# reduce 59 omitted
 
-# reduce 45 omitted
+# reduce 60 omitted
 
-# reduce 46 omitted
+# reduce 61 omitted
 
-# reduce 47 omitted
+# reduce 62 omitted
 
-# reduce 48 omitted
+# reduce 63 omitted
 
-# reduce 49 omitted
+# reduce 64 omitted
 
-# reduce 50 omitted
+# reduce 65 omitted
 
-# reduce 51 omitted
+# reduce 66 omitted
 
-# reduce 52 omitted
+# reduce 67 omitted
 
-# reduce 53 omitted
+# reduce 68 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 141)
-  def _reduce_54(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 157)
+  def _reduce_69(val, _values, result)
       @lexer.commentpop
   result = ast(AST::Resource, :type => val[0], :instances => val[2])
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 144)
-  def _reduce_55(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 160)
+  def _reduce_70(val, _values, result)
       # This is a deprecated syntax.
   error "All resource specifications require names"
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 147)
-  def _reduce_56(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 163)
+  def _reduce_71(val, _values, result)
       # a defaults setting for a type
   @lexer.commentpop
   result = ast(AST::ResourceDefaults, :type => val[0].value, :parameters => val[2])
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 154)
-  def _reduce_57(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 170)
+  def _reduce_72(val, _values, result)
       @lexer.commentpop
   result = ast AST::ResourceOverride, :object => val[0], :parameters => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 161)
-  def _reduce_58(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 177)
+  def _reduce_73(val, _values, result)
       type = val[0]
 
   if (type == :exported and ! Puppet[:storeconfigs])
     Puppet.warning addcontext("You cannot collect without storeconfigs being set")
   end
 
   error "Defaults are not virtualizable" if val[1].is_a? AST::ResourceDefaults
 
   method = type.to_s + "="
 
   # Just mark our resource as exported and pass it through.
   val[1].send(method, true)
 
   result = val[1]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 177)
-  def _reduce_59(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 193)
+  def _reduce_74(val, _values, result)
      result = :virtual 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 178)
-  def _reduce_60(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 194)
+  def _reduce_75(val, _values, result)
      result = :exported 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 183)
-  def _reduce_61(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 199)
+  def _reduce_76(val, _values, result)
       @lexer.commentpop
   type = val[0].value.downcase
   args = {:type => type}
 
   if val[1].is_a?(AST::CollExpr)
     args[:query] = val[1]
     args[:query].type = type
     args[:form] = args[:query].form
   else
     args[:form] = val[1]
   end
   if args[:form] == :exported and ! Puppet[:storeconfigs]
     Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored")
   end
   args[:override] = val[3]
   result = ast AST::Collection, args
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 201)
-  def _reduce_62(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 217)
+  def _reduce_77(val, _values, result)
       type = val[0].value.downcase
   args = {:type => type }
 
   if val[1].is_a?(AST::CollExpr)
     args[:query] = val[1]
     args[:query].type = type
     args[:form] = args[:query].form
   else
     args[:form] = val[1]
   end
   if args[:form] == :exported and ! Puppet[:storeconfigs]
     Puppet.warning addcontext("You cannot collect exported resources without storeconfigs being set; the collection will be ignored")
   end
   result = ast AST::Collection, args
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 219)
-  def _reduce_63(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 235)
+  def _reduce_78(val, _values, result)
       if val[1]
     result = val[1]
     result.form = :virtual
   else
     result = :virtual
   end
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 227)
-  def _reduce_64(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 243)
+  def _reduce_79(val, _values, result)
         if val[1]
     result = val[1]
     result.form = :exported
   else
     result = :exported
   end
 
     result
   end
 .,.,
 
-# reduce 65 omitted
+# reduce 80 omitted
 
-# reduce 66 omitted
+# reduce 81 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 240)
-  def _reduce_67(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 256)
+  def _reduce_82(val, _values, result)
         result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2]
 
     result
   end
 .,.,
 
-# reduce 68 omitted
+# reduce 83 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 245)
-  def _reduce_69(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 261)
+  def _reduce_84(val, _values, result)
         result = val[1]
     result.parens = true
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 249)
-  def _reduce_70(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 265)
+  def _reduce_85(val, _values, result)
      result=val[0][:value] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 250)
-  def _reduce_71(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 266)
+  def _reduce_86(val, _values, result)
      result=val[0][:value] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 253)
-  def _reduce_72(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 269)
+  def _reduce_87(val, _values, result)
       result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2]
   #result = ast AST::CollExpr
   #result.push *val
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 258)
-  def _reduce_73(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 274)
+  def _reduce_88(val, _values, result)
         result = ast AST::CollExpr, :test1 => val[0], :oper => val[1][:value], :test2 => val[2]
     #result = ast AST::CollExpr
     #result.push *val
 
     result
   end
 .,.,
 
-# reduce 74 omitted
+# reduce 89 omitted
 
-# reduce 75 omitted
+# reduce 90 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 267)
-  def _reduce_76(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 283)
+  def _reduce_91(val, _values, result)
       result = ast AST::ResourceInstance, :title => val[0], :parameters => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 270)
-  def _reduce_77(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 286)
+  def _reduce_92(val, _values, result)
      result = aryfy(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 272)
-  def _reduce_78(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 288)
+  def _reduce_93(val, _values, result)
         val[0].push val[2]
     result = val[0]
 
     result
   end
 .,.,
 
-# reduce 79 omitted
+# reduce 94 omitted
 
-# reduce 80 omitted
+# reduce 95 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 280)
-  def _reduce_81(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 296)
+  def _reduce_96(val, _values, result)
       result = ast AST::Undef, :value => :undef
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 284)
-  def _reduce_82(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 300)
+  def _reduce_97(val, _values, result)
       result = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 288)
-  def _reduce_83(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 304)
+  def _reduce_98(val, _values, result)
       result = ast AST::Type, :value => val[0][:value], :line => val[0][:line]
 
     result
   end
 .,.,
 
-# reduce 84 omitted
+# reduce 99 omitted
 
-# reduce 85 omitted
+# reduce 100 omitted
 
-# reduce 86 omitted
+# reduce 101 omitted
 
-# reduce 87 omitted
+# reduce 102 omitted
 
-# reduce 88 omitted
+# reduce 103 omitted
 
-# reduce 89 omitted
+# reduce 104 omitted
 
-# reduce 90 omitted
+# reduce 105 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 300)
-  def _reduce_91(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 316)
+  def _reduce_106(val, _values, result)
       raise Puppet::ParseError, "Cannot assign to variables in other namespaces" if val[0][:value] =~ /::/
   # this is distinct from referencing a variable
   variable = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
   result = ast AST::VarDef, :name => variable, :value => val[2], :line => val[0][:line]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 306)
-  def _reduce_92(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 322)
+  def _reduce_107(val, _values, result)
         result = ast AST::VarDef, :name => val[0], :value => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 310)
-  def _reduce_93(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 326)
+  def _reduce_108(val, _values, result)
       variable = ast AST::Name, :value => val[0][:value], :line => val[0][:line]
   result = ast AST::VarDef, :name => variable, :value => val[2], :append => true, :line => val[0][:line]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 316)
-  def _reduce_94(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 332)
+  def _reduce_109(val, _values, result)
       result = ast AST::ASTArray
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 318)
-  def _reduce_95(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 334)
+  def _reduce_110(val, _values, result)
      result = aryfy(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 320)
-  def _reduce_96(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 336)
+  def _reduce_111(val, _values, result)
         val[0].push(val[2])
     result = val[0]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 325)
-  def _reduce_97(val, _values, result)
+# reduce 112 omitted
+
+# reduce 113 omitted
+
+# reduce 114 omitted
+
+module_eval(<<'.,.,', 'grammar.ra', 345)
+  def _reduce_115(val, _values, result)
       result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 329)
-  def _reduce_98(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 352)
+  def _reduce_116(val, _values, result)
       result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2],
     :add => true
 
     result
   end
 .,.,
 
-# reduce 99 omitted
+# reduce 117 omitted
 
-# reduce 100 omitted
+# reduce 118 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 338)
-  def _reduce_101(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 361)
+  def _reduce_119(val, _values, result)
       result = ast AST::ASTArray
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 340)
-  def _reduce_102(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 363)
+  def _reduce_120(val, _values, result)
      result = aryfy(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 342)
-  def _reduce_103(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 365)
+  def _reduce_121(val, _values, result)
         val[0].push(val[2])
     result = val[0]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 348)
-  def _reduce_104(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 371)
+  def _reduce_122(val, _values, result)
       result = ast AST::Function,
     :name => val[0][:value], :line => val[0][:line],
     :arguments => val[2],
     :ftype => :rvalue
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 353)
-  def _reduce_105(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 376)
+  def _reduce_123(val, _values, result)
       result = ast AST::Function,
     :name => val[0][:value], :line => val[0][:line],
     :arguments => AST::ASTArray.new({}),
     :ftype => :rvalue
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 359)
-  def _reduce_106(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 382)
+  def _reduce_124(val, _values, result)
      result = ast AST::String, :value => val[0][:value],                  :line => val[0][:line] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 360)
-  def _reduce_107(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 383)
+  def _reduce_125(val, _values, result)
      result = ast AST::Concat, :value => [ast(AST::String,val[0])]+val[1], :line => val[0][:line] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 362)
-  def _reduce_108(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 385)
+  def _reduce_126(val, _values, result)
      result = [val[0]] + val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 364)
-  def _reduce_109(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 387)
+  def _reduce_127(val, _values, result)
      result = [ast(AST::String,val[0])]          
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 365)
-  def _reduce_110(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 388)
+  def _reduce_128(val, _values, result)
      result = [ast(AST::String,val[0])] + val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 368)
-  def _reduce_111(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 391)
+  def _reduce_129(val, _values, result)
       result = ast AST::Boolean, :value => val[0][:value], :line => val[0][:line]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 372)
-  def _reduce_112(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 395)
+  def _reduce_130(val, _values, result)
       Puppet.warning addcontext("Deprecation notice:  Resource references should now be capitalized")
   result = ast AST::ResourceReference, :type => val[0][:value], :line => val[0][:line], :title => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 375)
-  def _reduce_113(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 398)
+  def _reduce_131(val, _values, result)
       result = ast AST::ResourceReference, :type => val[0].value, :title => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 379)
-  def _reduce_114(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 402)
+  def _reduce_132(val, _values, result)
       @lexer.commentpop
   args = {
     :test => ast(AST::Not, :value => val[1]),
     :statements => val[3]
   }
 
   result = ast AST::IfStatement, args
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 388)
-  def _reduce_115(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 411)
+  def _reduce_133(val, _values, result)
         @lexer.commentpop
     args = {
       :test => ast(AST::Not, :value => val[1]), 
       :statements => ast(AST::Nop)
     }
     result = ast AST::IfStatement, args
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 397)
-  def _reduce_116(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 420)
+  def _reduce_134(val, _values, result)
       result = val[1]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 401)
-  def _reduce_117(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 424)
+  def _reduce_135(val, _values, result)
       @lexer.commentpop
   args = {
     :test => val[0],
     :statements => val[2]
   }
 
   args[:else] = val[4] if val[4]
 
   result = ast AST::IfStatement, args
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 412)
-  def _reduce_118(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 435)
+  def _reduce_136(val, _values, result)
         @lexer.commentpop
     args = {
       :test => val[0],
       :statements => ast(AST::Nop)
   }
 
   args[:else] = val[3] if val[3]
 
   result = ast AST::IfStatement, args
 
     result
   end
 .,.,
 
-# reduce 119 omitted
+# reduce 137 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 425)
-  def _reduce_120(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 448)
+  def _reduce_138(val, _values, result)
         result = ast AST::Else, :statements => val[1]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 428)
-  def _reduce_121(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 451)
+  def _reduce_139(val, _values, result)
         @lexer.commentpop
     result = ast AST::Else, :statements => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 432)
-  def _reduce_122(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 455)
+  def _reduce_140(val, _values, result)
         @lexer.commentpop
     result = ast AST::Else, :statements => ast(AST::Nop)
 
     result
   end
 .,.,
 
-# reduce 123 omitted
+# reduce 141 omitted
 
-# reduce 124 omitted
+# reduce 142 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 451)
-  def _reduce_125(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 474)
+  def _reduce_143(val, _values, result)
         result = ast AST::InOperator, :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 454)
-  def _reduce_126(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 477)
+  def _reduce_144(val, _values, result)
         result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 457)
-  def _reduce_127(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 480)
+  def _reduce_145(val, _values, result)
         result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 460)
-  def _reduce_128(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 483)
+  def _reduce_146(val, _values, result)
         result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 463)
-  def _reduce_129(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 486)
+  def _reduce_147(val, _values, result)
         result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 466)
-  def _reduce_130(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 489)
+  def _reduce_148(val, _values, result)
         result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 469)
-  def _reduce_131(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 492)
+  def _reduce_149(val, _values, result)
         result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 472)
-  def _reduce_132(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 495)
+  def _reduce_150(val, _values, result)
         result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 475)
-  def _reduce_133(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 498)
+  def _reduce_151(val, _values, result)
         result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 478)
-  def _reduce_134(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 501)
+  def _reduce_152(val, _values, result)
         result = ast AST::Minus, :value => val[1]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 481)
-  def _reduce_135(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 504)
+  def _reduce_153(val, _values, result)
         result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 484)
-  def _reduce_136(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 507)
+  def _reduce_154(val, _values, result)
         result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 487)
-  def _reduce_137(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 510)
+  def _reduce_155(val, _values, result)
         result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 490)
-  def _reduce_138(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 513)
+  def _reduce_156(val, _values, result)
         result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 493)
-  def _reduce_139(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 516)
+  def _reduce_157(val, _values, result)
         result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 496)
-  def _reduce_140(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 519)
+  def _reduce_158(val, _values, result)
         result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 499)
-  def _reduce_141(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 522)
+  def _reduce_159(val, _values, result)
         result = ast AST::Not, :value => val[1]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 502)
-  def _reduce_142(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 525)
+  def _reduce_160(val, _values, result)
         result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 505)
-  def _reduce_143(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 528)
+  def _reduce_161(val, _values, result)
         result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 508)
-  def _reduce_144(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 531)
+  def _reduce_162(val, _values, result)
         result = val[1]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 512)
-  def _reduce_145(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 535)
+  def _reduce_163(val, _values, result)
       @lexer.commentpop
   result = ast AST::CaseStatement, :test => val[1], :options => val[3]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 516)
-  def _reduce_146(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 539)
+  def _reduce_164(val, _values, result)
      result = aryfy(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 518)
-  def _reduce_147(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 541)
+  def _reduce_165(val, _values, result)
         val[0].push val[1]
     result = val[0]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 523)
-  def _reduce_148(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 546)
+  def _reduce_166(val, _values, result)
       @lexer.commentpop
   result = ast AST::CaseOpt, :value => val[0], :statements => val[3]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 526)
-  def _reduce_149(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 549)
+  def _reduce_167(val, _values, result)
       @lexer.commentpop
 
     result = ast(
     AST::CaseOpt,
     :value => val[0],
 
     :statements => ast(AST::ASTArray)
   )
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 536)
-  def _reduce_150(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 559)
+  def _reduce_168(val, _values, result)
      result = aryfy(val[0]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 538)
-  def _reduce_151(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 561)
+  def _reduce_169(val, _values, result)
         val[0].push(val[2])
     result = val[0]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 543)
-  def _reduce_152(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 566)
+  def _reduce_170(val, _values, result)
       result = ast AST::Selector, :param => val[0], :values => val[2]
 
     result
   end
 .,.,
 
-# reduce 153 omitted
+# reduce 171 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 548)
-  def _reduce_154(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 571)
+  def _reduce_172(val, _values, result)
         @lexer.commentpop
     result = val[1]
 
     result
   end
 .,.,
 
-# reduce 155 omitted
+# reduce 173 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 554)
-  def _reduce_156(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 577)
+  def _reduce_174(val, _values, result)
         if val[0].instance_of?(AST::ASTArray)
     val[0].push(val[2])
     result = val[0]
   else
     result = ast AST::ASTArray, :children => [val[0],val[2]]
   end
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 563)
-  def _reduce_157(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 586)
+  def _reduce_175(val, _values, result)
       result = ast AST::ResourceParam, :param => val[0], :value => val[2]
 
     result
   end
 .,.,
 
-# reduce 158 omitted
+# reduce 176 omitted
 
-# reduce 159 omitted
+# reduce 177 omitted
 
-# reduce 160 omitted
+# reduce 178 omitted
 
-# reduce 161 omitted
+# reduce 179 omitted
 
-# reduce 162 omitted
+# reduce 180 omitted
 
-# reduce 163 omitted
+# reduce 181 omitted
 
-# reduce 164 omitted
+# reduce 182 omitted
 
-# reduce 165 omitted
+# reduce 183 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 575)
-  def _reduce_166(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 598)
+  def _reduce_184(val, _values, result)
         result = ast AST::Default, :value => val[0][:value], :line => val[0][:line]
 
     result
   end
 .,.,
 
-# reduce 167 omitted
+# reduce 185 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 580)
-  def _reduce_168(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 603)
+  def _reduce_186(val, _values, result)
      result = [val[0][:value]] 
     result
   end
 .,.,
 
-# reduce 169 omitted
+# reduce 187 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 582)
-  def _reduce_170(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 605)
+  def _reduce_188(val, _values, result)
      result = val[0] += val[2] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 585)
-  def _reduce_171(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 608)
+  def _reduce_189(val, _values, result)
       val[1].each do |file|
     import(file)
   end
 
   result = nil
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 595)
-  def _reduce_172(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 618)
+  def _reduce_190(val, _values, result)
       @lexer.commentpop
   result = Puppet::Parser::AST::Definition.new(classname(val[1]),
                                                ast_context(true).merge(:arguments => val[2], :code => val[4],
                                                                        :line => val[0][:line]))
   @lexer.indefine = false
 
 #}           | DEFINE NAME argumentlist parent LBRACE RBRACE {
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 603)
-  def _reduce_173(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 626)
+  def _reduce_191(val, _values, result)
       @lexer.commentpop
   result = Puppet::Parser::AST::Definition.new(classname(val[1]),
                                                ast_context(true).merge(:arguments => val[2], :line => val[0][:line]))
   @lexer.indefine = false
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 611)
-  def _reduce_174(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 634)
+  def _reduce_192(val, _values, result)
       @lexer.commentpop
   # Our class gets defined in the parent namespace, not our own.
   @lexer.namepop
   result = Puppet::Parser::AST::Hostclass.new(classname(val[1]),
                                               ast_context(true).merge(:arguments => val[2], :parent => val[3],
                                                                       :code => val[5], :line => val[0][:line]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 618)
-  def _reduce_175(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 641)
+  def _reduce_193(val, _values, result)
       @lexer.commentpop
   # Our class gets defined in the parent namespace, not our own.
   @lexer.namepop
   result = Puppet::Parser::AST::Hostclass.new(classname(val[1]),
                                               ast_context(true).merge(:arguments => val[2], :parent => val[3],
                                                                       :line => val[0][:line]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 627)
-  def _reduce_176(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 650)
+  def _reduce_194(val, _values, result)
       @lexer.commentpop
   result = Puppet::Parser::AST::Node.new(val[1],
                                          ast_context(true).merge(:parent => val[2], :code => val[4],
                                                                  :line => val[0][:line]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 632)
-  def _reduce_177(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 655)
+  def _reduce_195(val, _values, result)
       @lexer.commentpop
   result = Puppet::Parser::AST::Node.new(val[1], ast_context(true).merge(:parent => val[2], :line => val[0][:line]))
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 636)
-  def _reduce_178(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 659)
+  def _reduce_196(val, _values, result)
      result = val[0][:value] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 637)
-  def _reduce_179(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 660)
+  def _reduce_197(val, _values, result)
      result = "class" 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 642)
-  def _reduce_180(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 665)
+  def _reduce_198(val, _values, result)
         result = [result]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 645)
-  def _reduce_181(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 668)
+  def _reduce_199(val, _values, result)
         result = val[0]
     result << val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 650)
-  def _reduce_182(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 673)
+  def _reduce_200(val, _values, result)
       result = ast AST::HostName, :value => val[0]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 653)
-  def _reduce_183(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 676)
+  def _reduce_201(val, _values, result)
      result = val[0][:value] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 654)
-  def _reduce_184(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 677)
+  def _reduce_202(val, _values, result)
      result = val[0][:value] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 655)
-  def _reduce_185(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 678)
+  def _reduce_203(val, _values, result)
      result = val[0][:value] 
     result
   end
 .,.,
 
-# reduce 186 omitted
+# reduce 204 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 659)
-  def _reduce_187(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 682)
+  def _reduce_205(val, _values, result)
       result = nil
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 663)
-  def _reduce_188(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 686)
+  def _reduce_206(val, _values, result)
       result = ast AST::ASTArray, :children => []
 
     result
   end
 .,.,
 
-# reduce 189 omitted
+# reduce 207 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 668)
-  def _reduce_190(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 691)
+  def _reduce_208(val, _values, result)
         result = nil
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 671)
-  def _reduce_191(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 694)
+  def _reduce_209(val, _values, result)
         result = val[1]
     result = [result] unless result[0].is_a?(Array)
 
     result
   end
 .,.,
 
-# reduce 192 omitted
+# reduce 210 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 677)
-  def _reduce_193(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 700)
+  def _reduce_211(val, _values, result)
         result = val[0]
     result = [result] unless result[0].is_a?(Array)
     result << val[2]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 683)
-  def _reduce_194(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 706)
+  def _reduce_212(val, _values, result)
       Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype")
   result = [val[0][:value], val[2]]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 687)
-  def _reduce_195(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 710)
+  def _reduce_213(val, _values, result)
         Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype")
     result = [val[0][:value]]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 690)
-  def _reduce_196(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 713)
+  def _reduce_214(val, _values, result)
       result = [val[0][:value], val[2]]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 692)
-  def _reduce_197(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 715)
+  def _reduce_215(val, _values, result)
       result = [val[0][:value]]
 
     result
   end
 .,.,
 
-# reduce 198 omitted
+# reduce 216 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 697)
-  def _reduce_199(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 720)
+  def _reduce_217(val, _values, result)
         result = val[1]
 
     result
   end
 .,.,
 
-# reduce 200 omitted
+# reduce 218 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 702)
-  def _reduce_201(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 725)
+  def _reduce_219(val, _values, result)
         result = val[1]
 
     result
   end
 .,.,
 
-# reduce 202 omitted
+# reduce 220 omitted
 
-# reduce 203 omitted
+# reduce 221 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 708)
-  def _reduce_204(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 731)
+  def _reduce_222(val, _values, result)
       result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 711)
-  def _reduce_205(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 734)
+  def _reduce_223(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 712)
-  def _reduce_206(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 735)
+  def _reduce_224(val, _values, result)
      result = val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 713)
-  def _reduce_207(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 736)
+  def _reduce_225(val, _values, result)
      result = ast AST::ASTArray 
     result
   end
 .,.,
 
-# reduce 208 omitted
+# reduce 226 omitted
 
-# reduce 209 omitted
+# reduce 227 omitted
 
-# reduce 210 omitted
+# reduce 228 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 719)
-  def _reduce_211(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 742)
+  def _reduce_229(val, _values, result)
      result = nil 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 722)
-  def _reduce_212(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 745)
+  def _reduce_230(val, _values, result)
       result = ast AST::Regex, :value => val[0][:value]
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 726)
-  def _reduce_213(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 749)
+  def _reduce_231(val, _values, result)
       if val[1].instance_of?(AST::ASTHash)
     result = val[1]
   else
     result = ast AST::ASTHash, { :value => val[1] }
   end
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 733)
-  def _reduce_214(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 756)
+  def _reduce_232(val, _values, result)
         if val[1].instance_of?(AST::ASTHash)
     result = val[1]
   else
     result = ast AST::ASTHash, { :value => val[1] }
   end
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 739)
-  def _reduce_215(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 762)
+  def _reduce_233(val, _values, result)
       result = ast AST::ASTHash
 
     result
   end
 .,.,
 
-# reduce 216 omitted
+# reduce 234 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 744)
-  def _reduce_217(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 767)
+  def _reduce_235(val, _values, result)
         if val[0].instance_of?(AST::ASTHash)
     result = val[0].merge(val[2])
   else
     result = ast AST::ASTHash, :value => val[0]
     result.merge(val[2])
   end
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 753)
-  def _reduce_218(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 776)
+  def _reduce_236(val, _values, result)
       result = ast AST::ASTHash, { :value => { val[0] => val[2] } }
 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 756)
-  def _reduce_219(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 779)
+  def _reduce_237(val, _values, result)
      result = val[0][:value] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 757)
-  def _reduce_220(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 780)
+  def _reduce_238(val, _values, result)
      result = val[0] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'grammar.ra', 760)
-  def _reduce_221(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 783)
+  def _reduce_239(val, _values, result)
       result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2]
 
     result
   end
 .,.,
 
-# reduce 222 omitted
+# reduce 240 omitted
 
-module_eval(<<'.,.,', 'grammar.ra', 765)
-  def _reduce_223(val, _values, result)
+module_eval(<<'.,.,', 'grammar.ra', 788)
+  def _reduce_241(val, _values, result)
         result = ast AST::HashOrArrayAccess, :variable => val[0], :key => val[2]
 
     result
   end
 .,.,
 
 def _reduce_none(val, _values, result)
   val[0]
 end
 
     end   # class Parser
     end   # module Parser
   end   # module Puppet
diff --git a/spec/unit/parser/lexer_spec.rb b/spec/unit/parser/lexer_spec.rb
index 48f7304b4..f1a49111f 100755
--- a/spec/unit/parser/lexer_spec.rb
+++ b/spec/unit/parser/lexer_spec.rb
@@ -1,699 +1,700 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/parser/lexer'
 
 # This is a special matcher to match easily lexer output
 RSpec::Matchers.define :be_like do |*expected|
   match do |actual|
     expected.zip(actual).all? { |e,a| !e or a[0] == e or (e.is_a? Array and a[0] == e[0] and (a[1] == e[1] or (a[1].is_a?(Hash) and a[1][:value] == e[1]))) }
   end
 end
 __ = nil
 
 describe Puppet::Parser::Lexer do
   describe "when reading strings" do
     before { @lexer = Puppet::Parser::Lexer.new }
     it "should increment the line count for every carriage return in the string" do
       @lexer.line = 10
       @lexer.string = "this\nis\natest'"
       @lexer.slurpstring("'")
 
       @lexer.line.should == 12
     end
 
     it "should not increment the line count for escapes in the string" do
       @lexer.line = 10
       @lexer.string = "this\\nis\\natest'"
       @lexer.slurpstring("'")
 
       @lexer.line.should == 10
     end
 
     it "should not think the terminator is escaped, when preceeded by an even number of backslashes" do
       @lexer.line = 10
       @lexer.string = "here\nis\nthe\nstring\\\\'with\nextra\njunk"
       @lexer.slurpstring("'")
 
       @lexer.line.should == 13
     end
   end
 end
 
 describe Puppet::Parser::Lexer::Token do
   before do
     @token = Puppet::Parser::Lexer::Token.new(%r{something}, :NAME)
   end
 
   [:regex, :name, :string, :skip, :incr_line, :skip_text, :accumulate].each do |param|
     it "should have a #{param.to_s} reader" do
       @token.should be_respond_to(param)
     end
 
     it "should have a #{param.to_s} writer" do
       @token.should be_respond_to(param.to_s + "=")
     end
   end
 end
 
 describe Puppet::Parser::Lexer::Token, "when initializing" do
   it "should create a regex if the first argument is a string" do
     Puppet::Parser::Lexer::Token.new("something", :NAME).regex.should == %r{something}
   end
 
   it "should set the string if the first argument is one" do
     Puppet::Parser::Lexer::Token.new("something", :NAME).string.should == "something"
   end
 
   it "should set the regex if the first argument is one" do
     Puppet::Parser::Lexer::Token.new(%r{something}, :NAME).regex.should == %r{something}
   end
 end
 
 describe Puppet::Parser::Lexer::TokenList do
   before do
     @list = Puppet::Parser::Lexer::TokenList.new
   end
 
   it "should have a method for retrieving tokens by the name" do
     token = @list.add_token :name, "whatever"
     @list[:name].should equal(token)
   end
 
   it "should have a method for retrieving string tokens by the string" do
     token = @list.add_token :name, "whatever"
     @list.lookup("whatever").should equal(token)
   end
 
   it "should add tokens to the list when directed" do
     token = @list.add_token :name, "whatever"
     @list[:name].should equal(token)
   end
 
   it "should have a method for adding multiple tokens at once" do
     @list.add_tokens "whatever" => :name, "foo" => :bar
     @list[:name].should_not be_nil
     @list[:bar].should_not be_nil
   end
 
   it "should fail to add tokens sharing a name with an existing token" do
     @list.add_token :name, "whatever"
     lambda { @list.add_token :name, "whatever" }.should raise_error(ArgumentError)
   end
 
   it "should set provided options on tokens being added" do
     token = @list.add_token :name, "whatever", :skip_text => true
     token.skip_text.should == true
   end
 
   it "should define any provided blocks as a :convert method" do
     token = @list.add_token(:name, "whatever")  do "foo" end
     token.convert.should == "foo"
   end
 
   it "should store all string tokens in the :string_tokens list" do
     one = @list.add_token(:name, "1")
     @list.string_tokens.should be_include(one)
   end
 
   it "should store all regex tokens in the :regex_tokens list" do
     one = @list.add_token(:name, %r{one})
     @list.regex_tokens.should be_include(one)
   end
 
   it "should not store string tokens in the :regex_tokens list" do
     one = @list.add_token(:name, "1")
     @list.regex_tokens.should_not be_include(one)
   end
 
   it "should not store regex tokens in the :string_tokens list" do
     one = @list.add_token(:name, %r{one})
     @list.string_tokens.should_not be_include(one)
   end
 
   it "should sort the string tokens inversely by length when asked" do
     one = @list.add_token(:name, "1")
     two = @list.add_token(:other, "12")
     @list.sort_tokens
     @list.string_tokens.should == [two, one]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS do
   before do
     @lexer = Puppet::Parser::Lexer.new
   end
 
   {
     :LBRACK => '[',
     :RBRACK => ']',
     :LBRACE => '{',
     :RBRACE => '}',
     :LPAREN => '(',
     :RPAREN => ')',
     :EQUALS => '=',
     :ISEQUAL => '==',
     :GREATEREQUAL => '>=',
     :GREATERTHAN => '>',
     :LESSTHAN => '<',
     :LESSEQUAL => '<=',
     :NOTEQUAL => '!=',
     :NOT => '!',
     :COMMA => ',',
     :DOT => '.',
     :COLON => ':',
     :AT => '@',
     :LLCOLLECT => '<<|',
     :RRCOLLECT => '|>>',
     :LCOLLECT => '<|',
     :RCOLLECT => '|>',
     :SEMIC => ';',
     :QMARK => '?',
     :BACKSLASH => '\\',
     :FARROW => '=>',
     :PARROW => '+>',
     :APPENDS => '+=',
     :PLUS => '+',
     :MINUS => '-',
     :DIV => '/',
     :TIMES => '*',
     :LSHIFT => '<<',
     :RSHIFT => '>>',
     :MATCH => '=~',
     :NOMATCH => '!~',
     :IN_EDGE => '->',
     :OUT_EDGE => '<-',
     :IN_EDGE_SUB => '~>',
     :OUT_EDGE_SUB => '<~',
   }.each do |name, string|
     it "should have a token named #{name.to_s}" do
       Puppet::Parser::Lexer::TOKENS[name].should_not be_nil
     end
 
     it "should match '#{string}' for the token #{name.to_s}" do
       Puppet::Parser::Lexer::TOKENS[name].string.should == string
     end
   end
 
   {
     "case" => :CASE,
     "class" => :CLASS,
     "default" => :DEFAULT,
     "define" => :DEFINE,
     "import" => :IMPORT,
     "if" => :IF,
     "elsif" => :ELSIF,
     "else" => :ELSE,
     "inherits" => :INHERITS,
     "node" => :NODE,
     "and"  => :AND,
     "or"   => :OR,
     "undef"   => :UNDEF,
     "false" => :FALSE,
     "true" => :TRUE,
     "in" => :IN,
+    "unless" => :UNLESS,
   }.each do |string, name|
     it "should have a keyword named #{name.to_s}" do
       Puppet::Parser::Lexer::KEYWORDS[name].should_not be_nil
     end
 
     it "should have the keyword for #{name.to_s} set to #{string}" do
       Puppet::Parser::Lexer::KEYWORDS[name].string.should == string
     end
   end
 
   # These tokens' strings don't matter, just that the tokens exist.
   [:STRING, :DQPRE, :DQMID, :DQPOST, :BOOLEAN, :NAME, :NUMBER, :COMMENT, :MLCOMMENT, :RETURN, :SQUOTE, :DQUOTE, :VARIABLE].each do |name|
     it "should have a token named #{name.to_s}" do
       Puppet::Parser::Lexer::TOKENS[name].should_not be_nil
     end
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:CLASSREF] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:CLASSREF] }
 
   it "should match against single upper-case alpha-numeric terms" do
     @token.regex.should =~ "One"
   end
 
   it "should match against upper-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "One::Two"
   end
 
   it "should match against many upper-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "One::Two::Three::Four::Five"
   end
 
   it "should match against upper-case alpha-numeric terms prefixed by double colons" do
     @token.regex.should =~ "::One"
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:NAME] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:NAME] }
 
   it "should match against lower-case alpha-numeric terms" do
     @token.regex.should =~ "one-two"
   end
 
   it "should return itself and the value if the matched term is not a keyword" do
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(nil)
     @token.convert(stub("lexer"), "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"]
   end
 
   it "should return the keyword token and the value if the matched term is a keyword" do
     keyword = stub 'keyword', :name => :testing
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
     @token.convert(stub("lexer"), "myval").should == [keyword, "myval"]
   end
 
   it "should return the BOOLEAN token and 'true' if the matched term is the string 'true'" do
     keyword = stub 'keyword', :name => :TRUE
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
     @token.convert(stub('lexer'), "true").should == [Puppet::Parser::Lexer::TOKENS[:BOOLEAN], true]
   end
 
   it "should return the BOOLEAN token and 'false' if the matched term is the string 'false'" do
     keyword = stub 'keyword', :name => :FALSE
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
     @token.convert(stub('lexer'), "false").should == [Puppet::Parser::Lexer::TOKENS[:BOOLEAN], false]
   end
 
   it "should match against lower-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "one::two"
   end
 
   it "should match against many lower-case alpha-numeric terms separated by double colons" do
     @token.regex.should =~ "one::two::three::four::five"
   end
 
   it "should match against lower-case alpha-numeric terms prefixed by double colons" do
     @token.regex.should =~ "::one"
   end
 
   it "should match against nested terms starting with numbers" do
     @token.regex.should =~ "::1one::2two::3three"
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:NUMBER] do
   before do
     @token = Puppet::Parser::Lexer::TOKENS[:NUMBER]
     @regex = @token.regex
   end
 
   it "should match against numeric terms" do
     @regex.should =~ "2982383139"
   end
 
   it "should match against float terms" do
     @regex.should =~ "29823.235"
   end
 
   it "should match against hexadecimal terms" do
     @regex.should =~ "0xBEEF0023"
   end
 
   it "should match against float with exponent terms" do
     @regex.should =~ "10e23"
   end
 
   it "should match against float terms with negative exponents" do
     @regex.should =~ "10e-23"
   end
 
   it "should match against float terms with fractional parts and exponent" do
     @regex.should =~ "1.234e23"
   end
 
   it "should return the NAME token and the value" do
     @token.convert(stub("lexer"), "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:COMMENT] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:COMMENT] }
 
   it "should match against lines starting with '#'" do
     @token.regex.should =~ "# this is a comment"
   end
 
   it "should be marked to get skipped" do
     @token.skip?.should be_true
   end
 
   it "should be marked to accumulate" do
     @token.accumulate?.should be_true
   end
 
   it "'s block should return the comment without the #" do
     @token.convert(@lexer,"# this is a comment")[1].should == "this is a comment"
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:MLCOMMENT] do
   before do
     @token = Puppet::Parser::Lexer::TOKENS[:MLCOMMENT]
     @lexer = stub 'lexer', :line => 0
   end
 
   it "should match against lines enclosed with '/*' and '*/'" do
     @token.regex.should =~ "/* this is a comment */"
   end
 
   it "should match multiple lines enclosed with '/*' and '*/'" do
     @token.regex.should =~ """/*
       this is a comment
       */"""
   end
 
   it "should increase the lexer current line number by the amount of lines spanned by the comment" do
     @lexer.expects(:line=).with(2)
     @token.convert(@lexer, "1\n2\n3")
   end
 
   it "should not greedily match comments" do
     match = @token.regex.match("/* first */ word /* second */")
     match[1].should == " first "
   end
 
   it "should be marked to accumulate" do
     @token.accumulate?.should be_true
   end
 
   it "'s block should return the comment without the comment marks" do
     @lexer.stubs(:line=).with(0)
 
     @token.convert(@lexer,"/* this is a comment */")[1].should == "this is a comment"
   end
 
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:RETURN] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:RETURN] }
 
   it "should match against carriage returns" do
     @token.regex.should =~ "\n"
   end
 
   it "should be marked to initiate text skipping" do
     @token.skip_text.should be_true
   end
 
   it "should be marked to increment the line" do
     @token.incr_line.should be_true
   end
 end
 
 def tokens_scanned_from(s)
   lexer = Puppet::Parser::Lexer.new
   lexer.string = s
   lexer.fullscan[0..-2]
 end
 
 describe Puppet::Parser::Lexer,"when lexing strings" do
   {
     %q{'single quoted string')}                                     => [[:STRING,'single quoted string']],
     %q{"double quoted string"}                                      => [[:STRING,'double quoted string']],
     %q{'single quoted string with an escaped "\\'"'}                => [[:STRING,'single quoted string with an escaped "\'"']],
     %q{'single quoted string with an escaped "\$"'}                 => [[:STRING,'single quoted string with an escaped "\$"']],
     %q{'single quoted string with an escaped "\."'}                 => [[:STRING,'single quoted string with an escaped "\."']],
     %q{'single quoted string with an escaped "\n"'}                 => [[:STRING,'single quoted string with an escaped "\n"']],
     %q{'single quoted string with an escaped "\\\\"'}               => [[:STRING,'single quoted string with an escaped "\\\\"']],
     %q{"string with an escaped '\\"'"}                              => [[:STRING,"string with an escaped '\"'"]],
     %q{"string with an escaped '\\$'"}                              => [[:STRING,"string with an escaped '$'"]],
     %Q{"string with a line ending with a backslash: \\\nfoo"}       => [[:STRING,"string with a line ending with a backslash: foo"]],
     %q{"string with $v (but no braces)"}                            => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' (but no braces)']],
     %q["string with ${v} in braces"]                                => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' in braces']],
     %q["string with ${qualified::var} in braces"]                   => [[:DQPRE,"string with "],[:VARIABLE,'qualified::var'],[:DQPOST,' in braces']],
     %q{"string with $v and $v (but no braces)"}                     => [[:DQPRE,"string with "],[:VARIABLE,"v"],[:DQMID," and "],[:VARIABLE,"v"],[:DQPOST," (but no braces)"]],
     %q["string with ${v} and ${v} in braces"]                       => [[:DQPRE,"string with "],[:VARIABLE,"v"],[:DQMID," and "],[:VARIABLE,"v"],[:DQPOST," in braces"]],
     %q["string with ${'a nested single quoted string'} inside it."] => [[:DQPRE,"string with "],[:STRING,'a nested single quoted string'],[:DQPOST,' inside it.']],
     %q["string with ${['an array ',$v2]} in it."]                   => [[:DQPRE,"string with "],:LBRACK,[:STRING,"an array "],:COMMA,[:VARIABLE,"v2"],:RBRACK,[:DQPOST," in it."]],
     %q{a simple "scanner" test}                                     => [[:NAME,"a"],[:NAME,"simple"], [:STRING,"scanner"],[:NAME,"test"]],
     %q{a simple 'single quote scanner' test}                        => [[:NAME,"a"],[:NAME,"simple"], [:STRING,"single quote scanner"],[:NAME,"test"]],
     %q{a harder 'a $b \c"'}                                         => [[:NAME,"a"],[:NAME,"harder"], [:STRING,'a $b \c"']],
     %q{a harder "scanner test"}                                     => [[:NAME,"a"],[:NAME,"harder"], [:STRING,"scanner test"]],
     %q{a hardest "scanner \"test\""}                                => [[:NAME,"a"],[:NAME,"hardest"],[:STRING,'scanner "test"']],
     %Q{a hardestest "scanner \\"test\\"\n"}                         => [[:NAME,"a"],[:NAME,"hardestest"],[:STRING,%Q{scanner "test"\n}]],
     %q{function("call")}                                            => [[:NAME,"function"],[:LPAREN,"("],[:STRING,'call'],[:RPAREN,")"]],
     %q["string with ${(3+5)/4} nested math."]                       => [[:DQPRE,"string with "],:LPAREN,[:NAME,"3"],:PLUS,[:NAME,"5"],:RPAREN,:DIV,[:NAME,"4"],[:DQPOST," nested math."]],
     %q["$$$$"]                                                      => [[:STRING,"$$$$"]],
     %q["$variable"]                                                 => [[:DQPRE,""],[:VARIABLE,"variable"],[:DQPOST,""]],
     %q["$var$other"]                                                => [[:DQPRE,""],[:VARIABLE,"var"],[:DQMID,""],[:VARIABLE,"other"],[:DQPOST,""]],
     %q["foo$bar$"]                                                  => [[:DQPRE,"foo"],[:VARIABLE,"bar"],[:DQPOST,"$"]],
     %q["foo$$bar"]                                                  => [[:DQPRE,"foo$"],[:VARIABLE,"bar"],[:DQPOST,""]],
     %q[""]                                                          => [[:STRING,""]],
     %q["123 456 789 0"]                                             => [[:STRING,"123 456 789 0"]],
     %q["${123} 456 $0"]                                             => [[:DQPRE,""],[:VARIABLE,"123"],[:DQMID," 456 "],[:VARIABLE,"0"],[:DQPOST,""]],
     %q["$foo::::bar"]                                               => [[:DQPRE,""],[:VARIABLE,"foo"],[:DQPOST,"::::bar"]]
   }.each { |src,expected_result|
     it "should handle #{src} correctly" do
       tokens_scanned_from(src).should be_like(*expected_result)
     end
   }
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR] }
 
   it "should match against alpha words prefixed with '$'" do
     @token.regex.should =~ '$this_var'
   end
 
   it "should return the VARIABLE token and the variable name stripped of the '$'" do
     @token.convert(stub("lexer"), "$myval").should == [Puppet::Parser::Lexer::TOKENS[:VARIABLE], "myval"]
   end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:REGEX] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:REGEX] }
 
   it "should match against any expression enclosed in //" do
     @token.regex.should =~ '/this is a regex/'
   end
 
   it 'should not match if there is \n in the regex' do
     @token.regex.should_not =~ "/this is \n a regex/"
   end
 
   describe "when scanning" do
     it "should not consider escaped slashes to be the end of a regex" do
       tokens_scanned_from("$x =~ /this \\/ foo/").should be_like(__,__,[:REGEX,%r{this / foo}])
     end
 
     it "should not lex chained division as a regex" do
       tokens_scanned_from("$x = $a/$b/$c").collect { |name, data| name }.should_not be_include( :REGEX )
     end
 
     it "should accept a regular expression after NODE" do
       tokens_scanned_from("node /www.*\.mysite\.org/").should be_like(__,[:REGEX,Regexp.new("www.*\.mysite\.org")])
     end
 
     it "should accept regular expressions in a CASE" do
       s = %q{case $variable {
         "something": {$othervar = 4096 / 2}
         /regex/: {notice("this notably sucks")}
         }
       }
       tokens_scanned_from(s).should be_like(
         :CASE,:VARIABLE,:LBRACE,:STRING,:COLON,:LBRACE,:VARIABLE,:EQUALS,:NAME,:DIV,:NAME,:RBRACE,[:REGEX,/regex/],:COLON,:LBRACE,:NAME,:LPAREN,:STRING,:RPAREN,:RBRACE,:RBRACE
       )
     end
 
   end
 
 
   it "should return the REGEX token and a Regexp" do
     @token.convert(stub("lexer"), "/myregex/").should == [Puppet::Parser::Lexer::TOKENS[:REGEX], Regexp.new(/myregex/)]
   end
 end
 
 describe Puppet::Parser::Lexer, "when lexing comments" do
   before { @lexer = Puppet::Parser::Lexer.new }
 
   it "should accumulate token in munge_token" do
     token = stub 'token', :skip => true, :accumulate? => true, :incr_line => nil, :skip_text => false
 
     token.stubs(:convert).with(@lexer, "# this is a comment").returns([token, " this is a comment"])
     @lexer.munge_token(token, "# this is a comment")
     @lexer.munge_token(token, "# this is a comment")
 
     @lexer.getcomment.should == " this is a comment\n this is a comment\n"
   end
 
   it "should add a new comment stack level on LBRACE" do
     @lexer.string = "{"
 
     @lexer.expects(:commentpush)
 
     @lexer.fullscan
   end
 
   it "should add a new comment stack level on LPAREN" do
     @lexer.string = "("
 
     @lexer.expects(:commentpush)
 
     @lexer.fullscan
   end
 
   it "should pop the current comment on RPAREN" do
     @lexer.string = ")"
 
     @lexer.expects(:commentpop)
 
     @lexer.fullscan
   end
 
   it "should return the current comments on getcomment" do
     @lexer.string = "# comment"
     @lexer.fullscan
 
     @lexer.getcomment.should == "comment\n"
   end
 
   it "should discard the previous comments on blank line" do
     @lexer.string = "# 1\n\n# 2"
     @lexer.fullscan
 
     @lexer.getcomment.should == "2\n"
   end
 
   it "should skip whitespace before lexing the next token after a non-token" do
     tokens_scanned_from("/* 1\n\n */ \ntest").should be_like([:NAME, "test"])
   end
 
   it "should not return comments seen after the current line" do
     @lexer.string = "# 1\n\n# 2"
     @lexer.fullscan
 
     @lexer.getcomment(1).should == ""
   end
 
   it "should return a comment seen before the current line" do
     @lexer.string = "# 1\n# 2"
     @lexer.fullscan
 
     @lexer.getcomment(2).should == "1\n2\n"
   end
 end
 
 # FIXME: We need to rewrite all of these tests, but I just don't want to take the time right now.
 describe "Puppet::Parser::Lexer in the old tests" do
   before { @lexer = Puppet::Parser::Lexer.new }
 
   it "should do simple lexing" do
     {
       %q{\\}                      => [[:BACKSLASH,"\\"]],
       %q{simplest scanner test}   => [[:NAME,"simplest"],[:NAME,"scanner"],[:NAME,"test"]],
       %Q{returned scanner test\n} => [[:NAME,"returned"],[:NAME,"scanner"],[:NAME,"test"]]
     }.each { |source,expected|
       tokens_scanned_from(source).should be_like(*expected)
     }
   end
 
   it "should fail usefully" do
     lambda { tokens_scanned_from('^') }.should raise_error(RuntimeError)
   end
 
   it "should fail if the string is not set" do
     lambda { @lexer.fullscan }.should raise_error(Puppet::LexError)
   end
 
   it "should correctly identify keywords" do
     tokens_scanned_from("case").should be_like([:CASE, "case"])
   end
 
   it "should correctly parse class references" do
     %w{Many Different Words A Word}.each { |t| tokens_scanned_from(t).should be_like([:CLASSREF,t])}
   end
 
   # #774
   it "should correctly parse namespaced class refernces token" do
     %w{Foo ::Foo Foo::Bar ::Foo::Bar}.each { |t| tokens_scanned_from(t).should be_like([:CLASSREF, t]) }
   end
 
   it "should correctly parse names" do
     %w{this is a bunch of names}.each { |t| tokens_scanned_from(t).should be_like([:NAME,t]) }
   end
 
   it "should correctly parse names with numerals" do
     %w{1name name1 11names names11}.each { |t| tokens_scanned_from(t).should be_like([:NAME,t]) }
   end
 
   it "should correctly parse empty strings" do
     lambda { tokens_scanned_from('$var = ""') }.should_not raise_error
   end
 
   it "should correctly parse virtual resources" do
     tokens_scanned_from("@type {").should be_like([:AT, "@"], [:NAME, "type"], [:LBRACE, "{"])
   end
 
   it "should correctly deal with namespaces" do
     @lexer.string = %{class myclass}
     @lexer.fullscan
     @lexer.namespace.should == "myclass"
 
     @lexer.namepop
     @lexer.namespace.should == ""
 
     @lexer.string = "class base { class sub { class more"
     @lexer.fullscan
     @lexer.namespace.should == "base::sub::more"
 
     @lexer.namepop
     @lexer.namespace.should == "base::sub"
   end
 
   it "should not put class instantiation on the namespace" do
     @lexer.string = "class base { class sub { class { mode"
     @lexer.fullscan
     @lexer.namespace.should == "base::sub"
   end
 
   it "should correctly handle fully qualified names" do
     @lexer.string = "class base { class sub::more {"
     @lexer.fullscan
     @lexer.namespace.should == "base::sub::more"
 
     @lexer.namepop
     @lexer.namespace.should == "base"
   end
 
   it "should correctly lex variables" do
     ["$variable", "$::variable", "$qualified::variable", "$further::qualified::variable", "$hyphenated-variable", "$-variable-with-leading-dash"].each do |string|
       tokens_scanned_from(string).should be_like([:VARIABLE,string.sub(/^\$/,'')])
     end
   end
 
   it "should not include whitespace in a variable" do
     tokens_scanned_from("$foo bar").should_not be_like([:VARIABLE, "foo bar"])
   end
   it "should not include excess colons in a variable" do
     tokens_scanned_from("$foo::::bar").should_not be_like([:VARIABLE, "foo::::bar"])
   end
 end
 
 describe "Puppet::Parser::Lexer in the old tests when lexing example files" do
   my_fixtures('*.pp') do |file|
     it "should correctly lex #{file}" do
       lexer = Puppet::Parser::Lexer.new
       lexer.file = file
       lambda { lexer.fullscan }.should_not raise_error
     end
   end
 end
 
 describe "when trying to lex an non-existent file" do
   include PuppetSpec::Files
 
   it "should return an empty list of tokens" do
     lexer = Puppet::Parser::Lexer.new
     lexer.file = nofile = tmpfile('lexer')
     File.exists?(nofile).should == false
 
     lexer.fullscan.should == [[false,false]]
   end
 end
diff --git a/spec/unit/parser/parser_spec.rb b/spec/unit/parser/parser_spec.rb
index dc3de5e06..805e287af 100755
--- a/spec/unit/parser/parser_spec.rb
+++ b/spec/unit/parser/parser_spec.rb
@@ -1,439 +1,452 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 describe Puppet::Parser do
 
   Puppet::Parser::AST
 
   before :each do
     @known_resource_types = Puppet::Resource::TypeCollection.new("development")
     @parser = Puppet::Parser::Parser.new "development"
     @parser.stubs(:known_resource_types).returns @known_resource_types
     @true_ast = Puppet::Parser::AST::Boolean.new :value => true
   end
 
   it "should require an environment at initialization" do
     lambda { Puppet::Parser::Parser.new }.should raise_error(ArgumentError)
   end
 
   it "should set the environment" do
     env = Puppet::Node::Environment.new
     Puppet::Parser::Parser.new(env).environment.should == env
   end
 
   it "should convert the environment into an environment instance if a string is provided" do
     env = Puppet::Node::Environment.new("testing")
     Puppet::Parser::Parser.new("testing").environment.should == env
   end
 
   it "should be able to look up the environment-specific resource type collection" do
     rtc = Puppet::Node::Environment.new("development").known_resource_types
     parser = Puppet::Parser::Parser.new "development"
     parser.known_resource_types.should equal(rtc)
   end
 
   it "should delegate importing to the known resource type loader" do
     parser = Puppet::Parser::Parser.new "development"
     parser.known_resource_types.loader.expects(:import).with("newfile", "current_file")
     parser.lexer.expects(:file).returns "current_file"
     parser.import("newfile")
   end
 
   describe "when parsing files" do
     before do
       FileTest.stubs(:exist?).returns true
       File.stubs(:read).returns ""
       @parser.stubs(:watch_file)
     end
 
     it "should treat files ending in 'rb' as ruby files" do
       @parser.expects(:parse_ruby_file)
       @parser.file = "/my/file.rb"
       @parser.parse
     end
   end
 
   describe "when parsing append operator" do
 
     it "should not raise syntax errors" do
       lambda { @parser.parse("$var += something") }.should_not raise_error
     end
 
     it "shouldraise syntax error on incomplete syntax " do
       lambda { @parser.parse("$var += ") }.should raise_error
     end
 
     it "should create ast::VarDef with append=true" do
       vardef = @parser.parse("$var += 2").code[0]
       vardef.should be_a(Puppet::Parser::AST::VarDef)
       vardef.append.should == true
     end
 
     it "should work with arrays too" do
       vardef = @parser.parse("$var += ['test']").code[0]
       vardef.should be_a(Puppet::Parser::AST::VarDef)
       vardef.append.should == true
     end
 
   end
 
   describe "when parsing selector" do
     it "should support hash access on the left hand side" do
       lambda { @parser.parse("$h = { 'a' => 'b' } $a = $h['a'] ? { 'b' => 'd', default => undef }") }.should_not raise_error
     end
   end
 
   describe "parsing 'unless'" do
     it "should create the correct ast objects" do
       Puppet::Parser::AST::Not.expects(:new).with { |h| h[:value].is_a?(Puppet::Parser::AST::Boolean) }
       @parser.parse("unless false { $var = 1 }")
     end
     
     it "should not raise an error with empty statements" do
       lambda { @parser.parse("unless false { }") }.should_not raise_error
     end
+    
+    #test for bug #13296
+    it "should not override 'unless' as a parameter inside resources" do
+      lambda { @parser.parse("exec {'/bin/echo foo': unless => '/usr/bin/false',}") }.should_not raise_error
+    end
+  end
+
+  describe "when parsing parameter names" do
+    Puppet::Parser::Lexer::KEYWORDS.sort_tokens.each do |keyword|
+      it "should allow #{keyword} as a keyword" do
+        lambda { @parser.parse("exec {'/bin/echo foo': #{keyword} => '/usr/bin/false',}") }.should_not raise_error
+      end
+    end
   end
 
   describe "when parsing 'if'" do
     it "not, it should create the correct ast objects" do
       Puppet::Parser::AST::Not.expects(:new).with { |h| h[:value].is_a?(Puppet::Parser::AST::Boolean) }
       @parser.parse("if ! true { $var = 1 }")
     end
 
     it "boolean operation, it should create the correct ast objects" do
       Puppet::Parser::AST::BooleanOperator.expects(:new).with {
         |h| h[:rval].is_a?(Puppet::Parser::AST::Boolean) and h[:lval].is_a?(Puppet::Parser::AST::Boolean) and h[:operator]=="or"
       }
       @parser.parse("if true or true { $var = 1 }")
 
     end
 
     it "comparison operation, it should create the correct ast objects" do
       Puppet::Parser::AST::ComparisonOperator.expects(:new).with {
         |h| h[:lval].is_a?(Puppet::Parser::AST::Name) and h[:rval].is_a?(Puppet::Parser::AST::Name) and h[:operator]=="<"
       }
       @parser.parse("if 1 < 2 { $var = 1 }")
 
     end
 
   end
 
   describe "when parsing if complex expressions" do
     it "should create a correct ast tree" do
       aststub = stub_everything 'ast'
       Puppet::Parser::AST::ComparisonOperator.expects(:new).with {
         |h| h[:rval].is_a?(Puppet::Parser::AST::Name) and h[:lval].is_a?(Puppet::Parser::AST::Name) and h[:operator]==">"
       }.returns(aststub)
       Puppet::Parser::AST::ComparisonOperator.expects(:new).with {
         |h| h[:rval].is_a?(Puppet::Parser::AST::Name) and h[:lval].is_a?(Puppet::Parser::AST::Name) and h[:operator]=="=="
       }.returns(aststub)
       Puppet::Parser::AST::BooleanOperator.expects(:new).with {
         |h| h[:rval]==aststub and h[:lval]==aststub and h[:operator]=="and"
       }
       @parser.parse("if (1 > 2) and (1 == 2) { $var = 1 }")
     end
 
     it "should raise an error on incorrect expression" do
       lambda { @parser.parse("if (1 > 2 > ) or (1 == 2) { $var = 1 }") }.should raise_error
     end
 
   end
 
   describe "when parsing resource references" do
 
     it "should not raise syntax errors" do
       lambda { @parser.parse('exec { test: param => File["a"] }') }.should_not raise_error
     end
 
     it "should not raise syntax errors with multiple references" do
       lambda { @parser.parse('exec { test: param => File["a","b"] }') }.should_not raise_error
     end
 
     it "should create an ast::ResourceReference" do
       Puppet::Parser::AST::ResourceReference.expects(:new).with { |arg|
         arg[:line]==1 and arg[:type]=="File" and arg[:title].is_a?(Puppet::Parser::AST::ASTArray)
       }
       @parser.parse('exec { test: command => File["a","b"] }')
     end
   end
 
   describe "when parsing resource overrides" do
 
     it "should not raise syntax errors" do
       lambda { @parser.parse('Resource["title"] { param => value }') }.should_not raise_error
     end
 
     it "should not raise syntax errors with multiple overrides" do
       lambda { @parser.parse('Resource["title1","title2"] { param => value }') }.should_not raise_error
     end
 
     it "should create an ast::ResourceOverride" do
       #Puppet::Parser::AST::ResourceOverride.expects(:new).with { |arg|
       #  arg[:line]==1 and arg[:object].is_a?(Puppet::Parser::AST::ResourceReference) and arg[:parameters].is_a?(Puppet::Parser::AST::ResourceParam)
       #}
       ro = @parser.parse('Resource["title1","title2"] { param => value }').code[0]
       ro.should be_a(Puppet::Parser::AST::ResourceOverride)
       ro.line.should == 1
       ro.object.should be_a(Puppet::Parser::AST::ResourceReference)
       ro.parameters[0].should be_a(Puppet::Parser::AST::ResourceParam)
     end
 
   end
 
   describe "when parsing if statements" do
 
     it "should not raise errors with empty if" do
       lambda { @parser.parse("if true { }") }.should_not raise_error
     end
 
     it "should not raise errors with empty else" do
       lambda { @parser.parse("if false { notice('if') } else { }") }.should_not raise_error
     end
 
     it "should not raise errors with empty if and else" do
       lambda { @parser.parse("if false { } else { }") }.should_not raise_error
     end
 
     it "should create a nop node for empty branch" do
       Puppet::Parser::AST::Nop.expects(:new)
       @parser.parse("if true { }")
     end
 
     it "should create a nop node for empty else branch" do
       Puppet::Parser::AST::Nop.expects(:new)
       @parser.parse("if true { notice('test') } else { }")
     end
 
     it "should build a chain of 'ifs' if there's an 'elsif'" do
       lambda { @parser.parse(<<-PP) }.should_not raise_error
         if true { notice('test') } elsif true {} else { }
       PP
     end
 
   end
 
   describe "when parsing function calls" do
 
     it "should not raise errors with no arguments" do
       lambda { @parser.parse("tag()") }.should_not raise_error
     end
 
     it "should not raise errors with rvalue function with no args" do
       lambda { @parser.parse("$a = template()") }.should_not raise_error
     end
 
     it "should not raise errors with arguments" do
       lambda { @parser.parse("notice(1)") }.should_not raise_error
     end
 
     it "should not raise errors with multiple arguments" do
       lambda { @parser.parse("notice(1,2)") }.should_not raise_error
     end
 
     it "should not raise errors with multiple arguments and a trailing comma" do
       lambda { @parser.parse("notice(1,2,)") }.should_not raise_error
     end
 
   end
 
   describe "when parsing arrays with trailing comma" do
 
     it "should not raise errors with a trailing comma" do
       lambda { @parser.parse("$a = [1,2,]") }.should_not raise_error
     end
   end
 
   describe "when providing AST context" do
     before do
       @lexer = stub 'lexer', :line => 50, :file => "/foo/bar", :getcomment => "whev"
       @parser.stubs(:lexer).returns @lexer
     end
 
     it "should include the lexer's line" do
       @parser.ast_context[:line].should == 50
     end
 
     it "should include the lexer's file" do
       @parser.ast_context[:file].should == "/foo/bar"
     end
 
     it "should include the docs if directed to do so" do
       @parser.ast_context(true)[:doc].should == "whev"
     end
 
     it "should not include the docs when told not to" do
       @parser.ast_context(false)[:doc].should be_nil
     end
 
     it "should not include the docs by default" do
       @parser.ast_context[:doc].should be_nil
     end
   end
 
   describe "when building ast nodes" do
     before do
       @lexer = stub 'lexer', :line => 50, :file => "/foo/bar", :getcomment => "whev"
       @parser.stubs(:lexer).returns @lexer
       @class = Puppet::Resource::Type.new(:hostclass, "myclass", :use_docs => false)
     end
 
     it "should return a new instance of the provided class created with the provided options" do
       @class.expects(:new).with { |opts| opts[:foo] == "bar" }
       @parser.ast(@class, :foo => "bar")
     end
 
     it "should merge the ast context into the provided options" do
       @class.expects(:new).with { |opts| opts[:file] == "/foo" }
       @parser.expects(:ast_context).returns :file => "/foo"
       @parser.ast(@class, :foo => "bar")
     end
 
     it "should prefer provided options over AST context" do
       @class.expects(:new).with { |opts| opts[:file] == "/bar" }
       @lexer.expects(:file).returns "/foo"
       @parser.ast(@class, :file => "/bar")
     end
 
     it "should include docs when the AST class uses them" do
       @class.expects(:use_docs).returns true
       @class.stubs(:new)
       @parser.expects(:ast_context).with{ |docs, line| docs == true }.returns({})
       @parser.ast(@class, :file => "/bar")
     end
 
     it "should get docs from lexer using the correct AST line number" do
       @class.expects(:use_docs).returns true
       @class.stubs(:new).with{ |a| a[:doc] == "doc" }
       @lexer.expects(:getcomment).with(12).returns "doc"
       @parser.ast(@class, :file => "/bar", :line => 12)
     end
   end
 
   describe "when retrieving a specific node" do
     it "should delegate to the known_resource_types node" do
       @known_resource_types.expects(:node).with("node")
 
       @parser.node("node")
     end
   end
 
   describe "when retrieving a specific class" do
     it "should delegate to the loaded code" do
       @known_resource_types.expects(:hostclass).with("class")
 
       @parser.hostclass("class")
     end
   end
 
   describe "when retrieving a specific definitions" do
     it "should delegate to the loaded code" do
       @known_resource_types.expects(:definition).with("define")
 
       @parser.definition("define")
     end
   end
 
   describe "when determining the configuration version" do
     it "should determine it from the resource type collection" do
       @parser.known_resource_types.expects(:version).returns "foo"
       @parser.version.should == "foo"
     end
   end
 
   describe "when looking up definitions" do
     it "should use the known resource types to check for them by name" do
       @parser.known_resource_types.stubs(:find_or_load).with("namespace","name",:definition).returns(:this_value)
       @parser.find_definition("namespace","name").should == :this_value
     end
   end
 
   describe "when looking up hostclasses" do
     it "should use the known resource types to check for them by name" do
       @parser.known_resource_types.stubs(:find_or_load).with("namespace","name",:hostclass).returns(:this_value)
       @parser.find_hostclass("namespace","name").should == :this_value
     end
   end
 
   describe "when parsing classes" do
     before :each do
       @krt = Puppet::Resource::TypeCollection.new("development")
       @parser = Puppet::Parser::Parser.new "development"
       @parser.stubs(:known_resource_types).returns @krt
     end
 
     it "should not create new classes" do
       @parser.parse("class foobar {}").code[0].should be_a(Puppet::Parser::AST::Hostclass)
       @krt.hostclass("foobar").should be_nil
     end
 
     it "should correctly set the parent class when one is provided" do
       @parser.parse("class foobar inherits yayness {}").code[0].instantiate('')[0].parent.should == "yayness"
     end
 
     it "should correctly set the parent class for multiple classes at a time" do
       statements = @parser.parse("class foobar inherits yayness {}\nclass boo inherits bar {}").code
       statements[0].instantiate('')[0].parent.should == "yayness"
       statements[1].instantiate('')[0].parent.should == "bar"
     end
 
     it "should define the code when some is provided" do
       @parser.parse("class foobar { $var = val }").code[0].code.should_not be_nil
     end
 
     it "should accept parametrized classes with trailing comma" do
       @parser.parse("class foobar ($var1 = 0,) { $var = val }").code[0].code.should_not be_nil
     end
 
     it "should define parameters when provided" do
       foobar = @parser.parse("class foobar($biz,$baz) {}").code[0].instantiate('')[0]
       foobar.arguments.should == {"biz" => nil, "baz" => nil}
     end
   end
 
   describe "when parsing resources" do
     before :each do
       @krt = Puppet::Resource::TypeCollection.new("development")
       @parser = Puppet::Parser::Parser.new "development"
       @parser.stubs(:known_resource_types).returns @krt
     end
 
     it "should be able to parse class resources" do
       @krt.add(Puppet::Resource::Type.new(:hostclass, "foobar", :arguments => {"biz" => nil}))
       lambda { @parser.parse("class { foobar: biz => stuff }") }.should_not raise_error
     end
 
     it "should correctly mark exported resources as exported" do
       @parser.parse("@@file { '/file': }").code[0].exported.should be_true
     end
 
     it "should correctly mark virtual resources as virtual" do
       @parser.parse("@file { '/file': }").code[0].virtual.should be_true
     end
   end
 
   describe "when parsing nodes" do
     it "should be able to parse a node with a single name" do
       node = @parser.parse("node foo { }").code[0]
       node.should be_a Puppet::Parser::AST::Node
       node.names.length.should == 1
       node.names[0].value.should == "foo"
     end
 
     it "should be able to parse a node with two names" do
       node = @parser.parse("node foo, bar { }").code[0]
       node.should be_a Puppet::Parser::AST::Node
       node.names.length.should == 2
       node.names[0].value.should == "foo"
       node.names[1].value.should == "bar"
     end
 
     it "should be able to parse a node with three names" do
       node = @parser.parse("node foo, bar, baz { }").code[0]
       node.should be_a Puppet::Parser::AST::Node
       node.names.length.should == 3
       node.names[0].value.should == "foo"
       node.names[1].value.should == "bar"
       node.names[2].value.should == "baz"
     end
   end
 end