diff --git a/lib/puppet/parser/grammar.ra b/lib/puppet/parser/grammar.ra index fe5d30635..f0158cf43 100644 --- a/lib/puppet/parser/grammar.ra +++ b/lib/puppet/parser/grammar.ra @@ -1,771 +1,790 @@ # 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 +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 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 { 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/lexer.rb b/lib/puppet/parser/lexer.rb index cb1ff4536..c4bee35aa 100644 --- a/lib/puppet/parser/lexer.rb +++ b/lib/puppet/parser/lexer.rb @@ -1,583 +1,584 @@ # the scanner/lexer require 'strscan' require 'puppet' module Puppet class LexError < RuntimeError; end end module Puppet::Parser; end class Puppet::Parser::Lexer attr_reader :last, :file, :lexing_context, :token_queue attr_accessor :line, :indefine def lex_error msg raise Puppet::LexError.new(msg) end class Token attr_accessor :regex, :name, :string, :skip, :incr_line, :skip_text, :accumulate def initialize(regex, name) if regex.is_a?(String) @name, @string = name, regex @regex = Regexp.new(Regexp.escape(@string)) else @name, @regex = name, regex end end # MQR: Why not just alias? %w{skip accumulate}.each do |method| define_method(method+"?") do self.send(method) end end def to_s if self.string @string else @name.to_s end end def acceptable?(context={}) # By default tokens are aceeptable in any context true end end # Maintain a list of tokens. class TokenList attr_reader :regex_tokens, :string_tokens def [](name) @tokens[name] end # Create a new token. def add_token(name, regex, options = {}, &block) token = Token.new(regex, name) raise(ArgumentError, "Token #{name} already exists") if @tokens.include?(name) @tokens[token.name] = token if token.string @string_tokens << token @tokens_by_string[token.string] = token else @regex_tokens << token end options.each do |name, option| token.send(name.to_s + "=", option) end token.meta_def(:convert, &block) if block_given? token end def initialize @tokens = {} @regex_tokens = [] @string_tokens = [] @tokens_by_string = {} end # Look up a token by its value, rather than name. def lookup(string) @tokens_by_string[string] end # Define more tokens. def add_tokens(hash) hash.each do |regex, name| add_token(name, regex) end end # Sort our tokens by length, so we know once we match, we're done. # This helps us avoid the O(n^2) nature of token matching. def sort_tokens @string_tokens.sort! { |a, b| b.string.length <=> a.string.length } end end TOKENS = TokenList.new TOKENS.add_tokens( '[' => :LBRACK, ']' => :RBRACK, '{' => :LBRACE, '}' => :RBRACE, '(' => :LPAREN, ')' => :RPAREN, '=' => :EQUALS, '+=' => :APPENDS, '==' => :ISEQUAL, '>=' => :GREATEREQUAL, '>' => :GREATERTHAN, '<' => :LESSTHAN, '<=' => :LESSEQUAL, '!=' => :NOTEQUAL, '!' => :NOT, ',' => :COMMA, '.' => :DOT, ':' => :COLON, '@' => :AT, '<<|' => :LLCOLLECT, '->' => :IN_EDGE, '<-' => :OUT_EDGE, '~>' => :IN_EDGE_SUB, '<~' => :OUT_EDGE_SUB, '|>>' => :RRCOLLECT, '<|' => :LCOLLECT, '|>' => :RCOLLECT, ';' => :SEMIC, '?' => :QMARK, '\\' => :BACKSLASH, '=>' => :FARROW, '+>' => :PARROW, '+' => :PLUS, '-' => :MINUS, '/' => :DIV, '*' => :TIMES, '<<' => :LSHIFT, '>>' => :RSHIFT, '=~' => :MATCH, '!~' => :NOMATCH, %r{((::){0,1}[A-Z][-\w]*)+} => :CLASSREF, "" => :STRING, "" => :DQPRE, "" => :DQMID, "" => :DQPOST, "" => :BOOLEAN ) # Numbers are treated separately from names, so that they may contain dots. TOKENS.add_token :NUMBER, %r{\b(?:0[xX][0-9A-Fa-f]+|0?\d+(?:\.\d+)?(?:[eE]-?\d+)?)\b} do |lexer, value| [TOKENS[:NAME], value] end #:stopdoc: # Issue #4161 def (TOKENS[:NUMBER]).acceptable?(context={}) ![:DQPRE,:DQMID].include? context[:after] end #:startdoc: TOKENS.add_token :NAME, %r{((::)?[a-z0-9][-\w]*)(::[a-z0-9][-\w]*)*} do |lexer, value| string_token = self # we're looking for keywords here if tmp = KEYWORDS.lookup(value) string_token = tmp if [:TRUE, :FALSE].include?(string_token.name) value = eval(value) string_token = TOKENS[:BOOLEAN] end end [string_token, value] end [:NAME,:CLASSNAME,:CLASSREF].each { |name_token| #:stopdoc: # Issue #4161 def (TOKENS[name_token]).acceptable?(context={}) ![:DQPRE,:DQMID].include? context[:after] end #:startdoc: } TOKENS.add_token :COMMENT, %r{#.*}, :accumulate => true, :skip => true do |lexer,value| value.sub!(/# ?/,'') [self, value] end TOKENS.add_token :MLCOMMENT, %r{/\*(.*?)\*/}m, :accumulate => true, :skip => true do |lexer, value| lexer.line += value.count("\n") value.sub!(/^\/\* ?/,'') value.sub!(/ ?\*\/$/,'') [self,value] end TOKENS.add_token :REGEX, %r{/[^/\n]*/} do |lexer, value| # Make sure we haven't matched an escaped / while value[-2..-2] == '\\' other = lexer.scan_until(%r{/}) value += other end regex = value.sub(%r{\A/}, "").sub(%r{/\Z}, '').gsub("\\/", "/") [self, Regexp.new(regex)] end #:stopdoc: # Issue #4161 def (TOKENS[:REGEX]).acceptable?(context={}) [:NODE,:LBRACE,:RBRACE,:MATCH,:NOMATCH,:COMMA].include? context[:after] end #:startdoc: TOKENS.add_token :RETURN, "\n", :skip => true, :incr_line => true, :skip_text => true TOKENS.add_token :SQUOTE, "'" do |lexer, value| [TOKENS[:STRING], lexer.slurpstring(value,["'"],:ignore_invalid_escapes).first ] end DQ_initial_token_types = {'$' => :DQPRE,'"' => :STRING} DQ_continuation_token_types = {'$' => :DQMID,'"' => :DQPOST} TOKENS.add_token :DQUOTE, /"/ do |lexer, value| lexer.tokenize_interpolated_string(DQ_initial_token_types) end TOKENS.add_token :DQCONT, /\}/ do |lexer, value| lexer.tokenize_interpolated_string(DQ_continuation_token_types) end #:stopdoc: # Issue #4161 def (TOKENS[:DQCONT]).acceptable?(context={}) context[:string_interpolation_depth] > 0 end #:startdoc: TOKENS.add_token :DOLLAR_VAR, %r{\$(::)?([-\w]+::)*[-\w]+} do |lexer, value| [TOKENS[:VARIABLE],value[1..-1]] end TOKENS.add_token :VARIABLE, %r{(::)?([-\w]+::)*[-\w]+} #:stopdoc: # Issue #4161 def (TOKENS[:VARIABLE]).acceptable?(context={}) [:DQPRE,:DQMID].include? context[:after] end #:startdoc: TOKENS.sort_tokens @@pairs = { "{" => "}", "(" => ")", "[" => "]", "<|" => "|>", "<<|" => "|>>" } KEYWORDS = TokenList.new KEYWORDS.add_tokens( "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 + "in" => :IN, + "unless" => :UNLESS ) def clear initvars end def expected return nil if @expected.empty? name = @expected[-1] TOKENS.lookup(name) or lex_error "Could not find expected token #{name}" end # scan the whole file # basically just used for testing def fullscan array = [] self.scan { |token, str| # Ignore any definition nesting problems @indefine = false array.push([token,str]) } array end def file=(file) @file = file @line = 1 contents = File.exists?(file) ? File.read(file) : "" @scanner = StringScanner.new(contents) end def shift_token @token_queue.shift end def find_string_token # We know our longest string token is three chars, so try each size in turn # until we either match or run out of chars. This way our worst-case is three # tries, where it is otherwise the number of string token we have. Also, # the lookups are optimized hash lookups, instead of regex scans. # s = @scanner.peek(3) token = TOKENS.lookup(s[0,3]) || TOKENS.lookup(s[0,2]) || TOKENS.lookup(s[0,1]) [ token, token && @scanner.scan(token.regex) ] end # Find the next token that matches a regex. We look for these first. def find_regex_token @regex += 1 best_token = nil best_length = 0 # I tried optimizing based on the first char, but it had # a slightly negative affect and was a good bit more complicated. TOKENS.regex_tokens.each do |token| if length = @scanner.match?(token.regex) and token.acceptable?(lexing_context) # We've found a longer match if length > best_length best_length = length best_token = token end end end return best_token, @scanner.scan(best_token.regex) if best_token end # Find the next token, returning the string and the token. def find_token @find += 1 shift_token || find_regex_token || find_string_token end def indefine? if defined?(@indefine) @indefine else false end end def initialize @find = 0 @regex = 0 initvars end def initvars @line = 1 @previous_token = nil @scanner = nil @file = nil # AAARRGGGG! okay, regexes in ruby are bloody annoying # no one else has "\n" =~ /\s/ @skip = %r{[ \t\r]+} @namestack = [] @token_queue = [] @indefine = false @expected = [] @commentstack = [ ['', @line] ] @lexing_context = { :after => nil, :start_of_line => true, :string_interpolation_depth => 0 } end # Make any necessary changes to the token and/or value. def munge_token(token, value) @line += 1 if token.incr_line skip if token.skip_text return if token.skip and not token.accumulate? token, value = token.convert(self, value) if token.respond_to?(:convert) return unless token if token.accumulate? comment = @commentstack.pop comment[0] << value + "\n" @commentstack.push(comment) end return if token.skip return token, { :value => value, :line => @line } end # Go up one in the namespace. def namepop @namestack.pop end # Collect the current namespace. def namespace @namestack.join("::") end # This value might have :: in it, but we don't care -- it'll be # handled normally when joining, and when popping we want to pop # this full value, however long the namespace is. def namestack(value) @namestack << value end def rest @scanner.rest end # this is the heart of the lexer def scan #Puppet.debug("entering scan") lex_error "Invalid or empty string" unless @scanner # Skip any initial whitespace. skip until token_queue.empty? and @scanner.eos? do yielded = false matched_token, value = find_token # error out if we didn't match anything at all lex_error "Could not match #{@scanner.rest[/^(\S+|\s+|.*)/]}" unless matched_token newline = matched_token.name == :RETURN # this matches a blank line; eat the previously accumulated comments getcomment if lexing_context[:start_of_line] and newline lexing_context[:start_of_line] = newline final_token, token_value = munge_token(matched_token, value) unless final_token skip next end lexing_context[:after] = final_token.name unless newline lexing_context[:string_interpolation_depth] += 1 if final_token.name == :DQPRE lexing_context[:string_interpolation_depth] -= 1 if final_token.name == :DQPOST value = token_value[:value] if match = @@pairs[value] and final_token.name != :DQUOTE and final_token.name != :SQUOTE @expected << match elsif exp = @expected[-1] and exp == value and final_token.name != :DQUOTE and final_token.name != :SQUOTE @expected.pop end if final_token.name == :LBRACE or final_token.name == :LPAREN commentpush end if final_token.name == :RPAREN commentpop end yield [final_token.name, token_value] if @previous_token namestack(value) if @previous_token.name == :CLASS and value != '{' if @previous_token.name == :DEFINE if indefine? msg = "Cannot nest definition #{value} inside #{@indefine}" self.indefine = false raise Puppet::ParseError, msg end @indefine = value end end @previous_token = final_token skip end @scanner = nil # This indicates that we're done parsing. yield [false,false] end # Skip any skipchars in our remaining string. def skip @scanner.skip(@skip) end # Provide some limited access to the scanner, for those # tokens that need it. def scan_until(regex) @scanner.scan_until(regex) end # we've encountered the start of a string... # slurp in the rest of the string and return it def slurpstring(terminators,escapes=%w{ \\ $ ' " n t s }+["\n"],ignore_invalid_escapes=false) # we search for the next quote that isn't preceded by a # backslash; the caret is there to match empty strings str = @scanner.scan_until(/([^\\]|^|[^\\])([\\]{2})*[#{terminators}]/) or lex_error "Unclosed quote after '#{last}' in '#{rest}'" @line += str.count("\n") # literal carriage returns add to the line count. str.gsub!(/\\(.)/m) { ch = $1 if escapes.include? ch case ch when 'n'; "\n" when 't'; "\t" when 's'; " " when "\n"; '' else ch end else Puppet.warning "Unrecognised escape sequence '\\#{ch}'#{file && " in file #{file}"}#{line && " at line #{line}"}" unless ignore_invalid_escapes "\\#{ch}" end } [ str[0..-2],str[-1,1] ] end def tokenize_interpolated_string(token_type,preamble='') value,terminator = slurpstring('"$') token_queue << [TOKENS[token_type[terminator]],preamble+value] if terminator != '$' or @scanner.scan(/\{/) token_queue.shift elsif var_name = @scanner.scan(TOKENS[:VARIABLE].regex) token_queue << [TOKENS[:VARIABLE],var_name] tokenize_interpolated_string(DQ_continuation_token_types) else tokenize_interpolated_string(token_type,token_queue.pop.last + terminator) end end # just parse a string, not a whole file def string=(string) @scanner = StringScanner.new(string) end # returns the content of the currently accumulated content cache def commentpop @commentstack.pop[0] end def getcomment(line = nil) comment = @commentstack.last if line.nil? or comment[1] <= line @commentstack.pop @commentstack.push(['', @line]) return comment[0] end '' end def commentpush @commentstack.push(['', @line]) end end diff --git a/lib/puppet/parser/parser.rb b/lib/puppet/parser/parser.rb index 9873e748a..d8dc5a890 100644 --- a/lib/puppet/parser/parser.rb +++ b/lib/puppet/parser/parser.rb @@ -1,2421 +1,2463 @@ # # DO NOT MODIFY!!!! # This file is automatically generated by Racc 1.4.7 # 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', 764) +module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 783) # 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 = [ -'183,187,245,69,248,70,241,290,169,9,17,69,351,190,194,199,333,169,71', -'-175,291,305,182,185,191,193,168,100,-156,9,17,235,236,9,17,168,175', -'88,166,92,200,345,67,251,343,184,189,171,100,195,196,177,178,180,181', -'77,186,192,9,17,245,143,88,179,92,102,76,171,104,303,31,91,142,168,48', -'241,312,148,18,82,77,313,36,9,17,95,102,35,302,104,371,76,346,35,51', -'31,91,-111,52,48,347,9,17,18,82,235,236,36,35,345,95,40,343,47,1,143', -'10,15,35,25,31,38,100,44,48,3,142,115,18,9,17,148,36,88,76,92,51,54', -'31,136,52,239,48,35,51,-162,18,18,52,238,36,77,-111,-111,-111,-111,262', -'9,17,261,102,35,76,104,369,250,31,91,143,-104,48,247,241,243,18,82,51', -'320,36,142,52,95,35,327,148,40,330,47,1,35,10,15,143,25,31,38,155,44', -'48,3,9,17,18,142,223,322,36,296,148,227,9,17,234,64,88,235,236,35,195', -'196,177,178,62,63,223,186,192,162,40,227,47,1,179,10,15,288,25,31,38', -'286,44,48,3,76,328,18,329,31,91,36,106,48,9,17,-157,18,88,-158,92,36', -'35,195,196,177,178,180,181,-156,186,192,35,-155,186,192,77,179,282,9', -'17,179,195,196,177,178,367,76,35,186,192,31,91,35,263,48,179,186,192', -'18,82,252,250,36,179,247,95,40,245,47,1,162,10,15,35,25,31,38,244,44', -'48,3,241,243,18,9,17,168,36,88,257,92,177,178,241,256,331,186,192,35', -'241,243,9,17,179,229,88,77,92,177,178,228,292,221,186,192,241,256,76', -'218,197,179,31,91,77,338,48,155,340,341,18,82,-103,106,36,76,-161,95', -'342,31,91,-159,-157,48,-160,35,-158,18,82,9,17,36,306,88,95,92,64,-155', -'354,9,17,-162,35,88,356,92,-208,119,162,9,17,77,-28,-28,-28,-28,58,59', -'60,56,357,77,76,155,151,70,31,91,119,115,48,360,76,247,18,82,31,91,36', -'107,48,95,76,106,18,82,31,136,36,35,48,95,9,17,18,364,-157,366,36,35', -'97,-158,9,17,72,61,88,55,92,35,-24,-24,-24,-24,58,59,60,56,372,373,40', -',47,1,77,10,15,,25,31,38,,44,48,3,76,,18,,31,91,36,,48,,285,,18,82,', -',36,35,,95,190,194,-22,-22,-22,-22,,35,,182,185,191,193,,,,,,,,9,17', -',,109,,-175,,,,,,184,189,,,195,196,177,178,180,181,108,186,192,9,17', -',,88,179,92,,76,,,,31,91,,,48,9,17,,18,88,77,92,36,,,,,,,,,76,,35,,31', -'91,77,,48,,,,18,82,,,36,76,,95,,31,91,,,48,,35,,18,82,9,17,36,,88,95', -'92,,,,9,17,,35,88,,92,,,,,,77,,,,,,,,,,77,76,,9,17,31,91,,,48,359,76', -',18,82,31,91,36,,48,95,,,18,82,,,36,35,,95,40,,47,1,,10,15,35,25,31', -'38,,44,48,3,,,18,9,17,,36,88,,92,,,,9,17,,,35,,,,,,9,17,77,,,,137,,', -',,,,76,,,,31,91,,,48,,76,51,18,82,31,126,36,44,48,95,76,,18,,31,136', -'36,35,48,9,17,,18,88,,92,36,35,,9,17,,,88,,92,,35,,9,17,77,,88,,92,', -',,,,77,76,,,,31,91,,,48,77,76,,18,82,31,91,36,,48,95,76,,18,82,31,91', -'36,35,48,95,,,18,82,9,17,36,35,88,95,92,,,,9,17,,35,,,,,,,9,17,77,,88', -',92,,,,,,,76,,,,31,91,,,48,77,76,,18,82,31,136,36,,48,95,76,,18,,31', -'91,36,35,48,,,,18,82,9,17,36,35,88,95,92,,,,9,17,,35,88,,92,,,,9,17', -'77,,88,,92,,,,,,77,76,,,,31,91,,,48,77,76,,18,82,31,91,36,,48,95,76', -',18,82,31,91,36,35,48,95,,,18,82,9,17,36,35,88,95,92,,,,9,17,,35,88', -',92,,,,9,17,77,,,,,,,,,,77,76,,,,31,91,,,48,,76,,18,82,31,91,36,,48', -'95,76,,18,82,31,136,36,35,48,95,,,18,,9,17,36,35,88,,92,,,,9,17,,35', -'88,,92,,,,9,17,77,,88,,92,,,,,,77,76,,,,31,91,,,48,77,76,,18,82,31,91', -'36,,48,95,76,,18,82,31,91,36,35,48,95,,,18,82,9,17,36,35,88,95,92,,', -',9,17,,35,88,,92,,,,9,17,77,,,,,349,,,,,77,76,,,,31,91,,,48,,76,,18', -'82,31,91,36,,48,95,76,,18,82,31,136,36,35,48,95,,,18,,9,17,36,35,88', -',92,,,,9,17,,35,88,,92,,,,9,17,77,,88,,92,,,,,,77,76,,,,31,91,,,48,77', -'76,,18,82,31,91,36,,48,95,76,,18,82,31,91,36,35,48,95,,,18,82,9,17,36', -'35,,95,,308,,,,,,35,,195,196,177,178,180,181,,186,192,,9,17,,40,179', -'47,1,,10,15,,25,31,38,,44,48,3,,,18,9,17,,36,88,,92,40,,47,1,,10,15', -'35,25,31,38,,44,48,3,77,,18,9,17,,36,88,,92,,76,,,,31,91,35,,48,,,,18', -'82,77,,36,9,17,95,,88,,92,,76,,35,,31,91,,,48,,,,18,82,77,,36,9,17,95', -',88,,92,,76,,35,,31,91,,,48,,,,18,82,77,,36,9,17,95,,,,,,76,,35,,31', -'91,9,17,48,,88,,18,82,,,36,,,95,40,,47,1,,10,15,35,25,31,38,,44,48,3', -',,18,,76,,36,,31,136,,,48,,,,18,35,9,17,36,,88,,92,,,,9,17,,35,88,,92', -',,,9,17,77,,88,,,,,,,,77,76,,,,31,91,,,48,,76,,18,82,31,91,36,,48,95', -'76,,18,82,31,210,36,35,48,95,,,18,,9,17,36,35,88,,92,,,,9,17,,35,88', -'166,92,,,,,,77,215,,,,,,,,,77,76,,9,17,31,91,,,48,336,76,,18,82,31,91', -'36,,48,95,,,18,82,,,36,35,,95,40,,47,1,,10,15,35,25,31,38,,44,48,3,', -',18,9,17,,36,88,,92,,,,,,,,35,,,9,17,,,88,77,92,,,,,,,,,,76,,,,31,91', -'77,258,48,,,,18,82,,,36,76,,95,,31,91,9,17,48,,35,232,18,82,,,36,,,95', -',190,194,,,,,35,,,182,185,191,193,,,,9,17,76,51,88,,31,126,,44,48,,', -',18,,184,189,36,,195,196,177,178,180,181,,186,192,35,,,,76,179,,,31', -'91,,,48,,219,,18,,,,36,,,190,194,,,,,220,,35,182,185,191,193,,,190,194', -',,,,,,,182,185,191,193,,,,,184,189,,,195,196,177,178,180,181,,186,192', -',,184,189,,179,195,196,177,178,180,181,,186,192,190,194,,,,179,,,,182', -'185,191,193,,,190,194,,,,,,,,182,185,191,193,,,,,,,,,195,196,177,178', -'180,181,,186,192,,,184,189,,179,195,196,177,178,180,181,,186,192,190', -'194,,,,179,,,,182,185,191,193,,,190,194,,,,,,,,182,185,191,193,,,,,184', -'189,,,195,196,177,178,180,181,,186,192,,,184,189,,179,195,196,177,178', -'180,181,,186,192,190,194,,,,179,,,,182,185,191,193,,,190,194,,,,,,,', -'182,185,191,193,,,,,184,189,,,195,196,177,178,180,181,,186,192,,,184', -'189,,179,195,196,177,178,180,181,,186,192,190,194,,,,179,,,,182,185', -'191,193,,,190,194,,,,,,,,182,185,191,193,,,,,184,189,,,195,196,177,178', -'180,181,,186,192,,,184,189,,179,195,196,177,178,180,181,,186,192,190', -'194,,,,179,,,,182,185,191,193,,,190,194,,,,,,,255,182,185,191,193,,', -',,184,189,,,195,196,177,178,180,181,,186,192,,,184,189,,179,195,196', -'177,178,180,181,,186,192,190,194,,,,179,,,,182,185,191,193,,,190,194', -',,,,,,,182,185,191,193,,,,,184,189,,,195,196,177,178,180,181,,186,192', -',,184,189,,179,195,196,177,178,180,181,,186,192,190,194,,,,179,,,,182', -'185,191,193,,,190,194,,,,,,,,182,185,191,193,,,,,,189,,,195,196,177', -'178,180,181,,186,192,,,,,,179,195,196,177,178,180,181,,186,192,190,194', -',,,179,,,,182,185,191,193,,,,194,,,,,,,,182,,,,,,,,,,194,,195,196,177', -'178,180,181,182,186,192,,,,,194,179,195,196,177,178,180,181,182,186', -'192,,,,,,179,,194,,195,196,177,178,180,181,182,186,192,,,,,,179,195', -'196,177,178,180,181,,186,192,,,,,,179,,,,195,196,177,178,180,181,,186', -'192,,,,,,179' ] - racc_action_table = arr = Array.new(2325, nil) +'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) 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 = [ -'96,96,162,12,157,12,216,216,91,261,261,79,304,96,96,105,261,126,12,126', -'216,225,96,96,96,96,91,25,79,92,92,157,157,88,88,126,92,88,88,88,105', -'296,12,162,296,96,96,261,200,96,96,96,96,96,96,88,96,96,238,238,210', -'71,238,96,238,25,88,92,25,224,88,88,71,210,88,231,231,71,88,88,238,233', -'88,366,366,88,200,25,223,200,366,238,298,88,1,238,238,292,1,238,298', -'220,220,238,238,233,233,238,200,342,238,366,342,366,366,143,366,366', -'238,366,366,366,199,366,366,366,143,221,366,239,239,143,366,239,220', -'239,11,2,220,220,11,150,220,366,15,2,220,11,15,150,220,239,292,292,292', -'292,172,364,364,172,199,220,239,199,364,240,239,239,237,215,239,214', -'259,259,239,239,252,246,239,237,252,239,199,252,237,364,259,364,364', -'239,364,364,67,364,364,364,247,364,364,364,219,219,364,67,119,249,364', -'219,67,119,218,218,145,10,218,145,145,364,268,268,268,268,10,10,305', -'268,268,250,219,305,219,219,268,219,219,213,219,219,219,211,219,219', -'219,218,254,219,256,218,218,219,209,218,242,242,207,218,242,205,242', -'218,219,279,279,279,279,279,279,204,279,279,218,203,264,264,242,279', -'198,358,358,264,267,267,267,267,358,242,192,267,267,242,242,186,174', -'242,267,265,265,242,242,163,159,242,265,156,242,358,155,358,358,151', -'358,358,242,358,358,358,152,358,358,358,152,152,358,245,245,136,358', -'245,167,245,280,280,167,167,260,280,280,358,260,260,17,17,280,131,17', -'245,17,281,281,121,217,117,281,281,217,217,245,110,97,281,245,245,17', -'287,245,288,289,290,245,245,291,90,245,17,89,245,295,17,17,86,85,17', -'81,245,80,17,17,251,251,17,227,251,17,251,76,75,307,263,263,74,17,263', -'311,263,312,73,72,346,346,251,7,7,7,7,4,4,4,4,317,263,251,70,68,65,251', -'251,53,47,251,335,263,339,251,251,263,263,251,37,263,251,346,32,263', -'263,346,346,263,251,346,263,24,24,346,345,22,347,346,263,21,19,343,343', -'13,8,343,3,343,346,50,50,50,50,49,49,49,49,368,370,24,,24,24,343,24', -'24,,24,24,24,,24,24,24,343,,24,,343,343,24,,343,,202,,343,343,,,343', -'24,,343,202,202,42,42,42,42,,343,,202,202,202,202,,,,,,,,38,38,,,38', -',38,,,,,,202,202,,,202,202,202,202,202,202,38,202,202,40,40,,,40,202', -'40,,38,,,,38,38,,,38,44,44,,38,44,40,44,38,,,,,,,,,40,,38,,40,40,44', -',40,,,,40,40,,,40,44,,40,,44,44,,,44,,40,,44,44,196,196,44,,196,44,196', -',,,195,195,,44,195,,195,,,,,,196,,,,,,,,,,195,196,,328,328,196,196,', -',196,328,195,,196,196,195,195,196,,195,196,,,195,195,,,195,196,,195', -'328,,328,328,,328,328,195,328,328,328,,328,328,328,,,328,54,54,,328', -'54,,54,,,,57,57,,,328,,,,,,61,61,54,,,,61,,,,,,,54,,,,54,54,,,54,,57', -'57,54,54,57,57,54,57,57,54,61,,57,,61,61,57,54,61,62,62,,61,62,,62,61', -'57,,63,63,,,63,,63,,61,,64,64,62,,64,,64,,,,,,63,62,,,,62,62,,,62,64', -'63,,62,62,63,63,62,,63,62,64,,63,63,64,64,63,62,64,63,,,64,64,194,194', -'64,63,194,64,194,,,,137,137,,64,,,,,,,193,193,194,,193,,193,,,,,,,194', -',,,194,194,,,194,193,137,,194,194,137,137,194,,137,194,193,,137,,193', -'193,137,194,193,,,,193,193,69,69,193,137,69,193,69,,,,191,191,,193,191', -',191,,,,190,190,69,,190,,190,,,,,,191,69,,,,69,69,,,69,190,191,,69,69', -'191,191,69,,191,69,190,,191,191,190,190,191,69,190,191,,,190,190,189', -'189,190,191,189,190,189,,,,185,185,,190,185,,185,,,,310,310,189,,,,', -',,,,,185,189,,,,189,189,,,189,,185,,189,189,185,185,189,,185,189,310', -',185,185,310,310,185,189,310,185,,,310,,306,306,310,185,306,,306,,,', -'184,184,,310,184,,184,,,,77,77,306,,77,,77,,,,,,184,306,,,,306,306,', -',306,77,184,,306,306,184,184,306,,184,306,77,,184,184,77,77,184,306', -'77,184,,,77,77,183,183,77,184,183,77,183,,,,302,302,,77,302,,302,,,', -'300,300,183,,,,,300,,,,,302,183,,,,183,183,,,183,,302,,183,183,302,302', -'183,,302,183,300,,302,302,300,300,302,183,300,302,,,300,,82,82,300,302', -'82,,82,,,,182,182,,300,182,,182,,,,181,181,82,,181,,181,,,,,,182,82', -',,,82,82,,,82,181,182,,82,82,182,182,82,,182,82,181,,182,182,181,181', -'182,82,181,182,,,181,181,228,228,181,182,,181,,228,,,,,,181,,269,269', -'269,269,269,269,,269,269,,294,294,,228,269,228,228,,228,228,,228,228', -'228,,228,228,228,,,228,180,180,,228,180,,180,294,,294,294,,294,294,228', -'294,294,294,,294,294,294,180,,294,179,179,,294,179,,179,,180,,,,180', -'180,294,,180,,,,180,180,179,,180,178,178,180,,178,,178,,179,,180,,179', -'179,,,179,,,,179,179,178,,179,95,95,179,,95,,95,,178,,179,,178,178,', -',178,,,,178,178,95,,178,0,0,178,,,,,,95,,178,,95,95,286,286,95,,286', -',95,95,,,95,,,95,0,,0,0,,0,0,95,0,0,0,,0,0,0,,,0,,286,,0,,286,286,,', -'286,,,,286,0,177,177,286,,177,,177,,,,106,106,,286,106,,106,,,,107,107', -'177,,107,,,,,,,,106,177,,,,177,177,,,177,,106,,177,177,106,106,177,', -'106,177,107,,106,106,107,107,106,177,107,106,,,107,,108,108,107,106', -'108,,108,,,,109,109,,107,109,109,109,,,,,,108,108,,,,,,,,,109,108,,282', -'282,108,108,,,108,282,109,,108,108,109,109,108,,109,108,,,109,109,,', -'109,108,,109,282,,282,282,,282,282,109,282,282,282,,282,282,282,,,282', -'169,169,,282,169,,169,,,,,,,,282,,,168,168,,,168,169,168,,,,,,,,,,169', -',,,169,169,168,168,169,,,,169,169,,,169,168,,169,,168,168,118,118,168', -',169,140,168,168,,,168,,,168,,140,140,,,,,168,,,140,140,140,140,,,,229', -'229,118,118,229,,118,118,,118,118,,,,118,,140,140,118,,140,140,140,140', -'140,140,,140,140,118,,,,229,140,,,229,229,,,229,,113,,229,,,,229,,,113', -'113,,,,,114,,229,113,113,113,113,,,114,114,,,,,,,,114,114,114,114,,', -',,113,113,,,113,113,113,113,113,113,,113,113,,,114,114,,113,114,114', -'114,114,114,114,,114,114,316,316,,,,114,,,,316,316,316,316,,,319,319', -',,,,,,,319,319,319,319,,,,,,,,,316,316,316,316,316,316,,316,316,,,319', -'319,,316,319,319,319,319,319,319,,319,319,324,324,,,,319,,,,324,324', -'324,324,,,138,138,,,,,,,,138,138,138,138,,,,,324,324,,,324,324,324,324', -'324,324,,324,324,,,138,138,,324,138,138,138,138,138,138,,138,138,139', -'139,,,,138,,,,139,139,139,139,,,318,318,,,,,,,,318,318,318,318,,,,,139', -'139,,,139,139,139,139,139,139,,139,139,,,318,318,,139,318,318,318,318', -'318,318,,318,318,122,122,,,,318,,,,122,122,122,122,,,353,353,,,,,,,', -'353,353,353,353,,,,,122,122,,,122,122,122,122,122,122,,122,122,,,353', -'353,,122,353,353,353,353,353,353,,353,353,334,334,,,,353,,,,334,334', -'334,334,,,164,164,,,,,,,164,164,164,164,164,,,,,334,334,,,334,334,334', -'334,334,334,,334,334,,,164,164,,334,164,164,164,164,164,164,,164,164', -'350,350,,,,164,,,,350,350,350,350,,,153,153,,,,,,,,153,153,153,153,', -',,,350,350,,,350,350,350,350,350,350,,350,350,,,153,153,,350,153,153', -'153,153,153,153,,153,153,271,271,,,,153,,,,271,271,271,271,,,274,274', -',,,,,,,274,274,274,274,,,,,,271,,,271,271,271,271,271,271,,271,271,', -',,,,271,274,274,274,274,274,274,,274,274,315,315,,,,274,,,,315,315,315', -'315,,,,272,,,,,,,,272,,,,,,,,,,276,,315,315,315,315,315,315,276,315', -'315,,,,,275,315,272,272,272,272,272,272,275,272,272,,,,,,272,,278,,276', -'276,276,276,276,276,278,276,276,,,,,,276,275,275,275,275,275,275,,275', -'275,,,,,,275,,,,278,278,278,278,278,278,,278,278,,,,,,278' ] - racc_action_check = arr = Array.new(2325, nil) +'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) 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 = [ - 1378, 58, 122, 421, 351, nil, nil, 347, 440, nil, - 207, 100, -3, 454, nil, 108, nil, 338, nil, 436, - nil, 458, 431, nil, 448, 25, nil, nil, nil, nil, - nil, nil, 435, nil, nil, nil, nil, 429, 531, nil, - 556, nil, 452, nil, 573, nil, nil, 425, nil, 409, - 405, nil, nil, 402, 701, nil, nil, 711, nil, nil, - nil, 721, 763, 773, 783, 415, nil, 168, 414, 897, - 381, 37, 366, 381, 376, 372, 388, 1051, nil, 5, - 361, 359, 1165, nil, nil, 357, 356, nil, 31, 351, - 365, 2, 27, nil, nil, 1353, -4, 358, nil, nil, - nil, nil, nil, nil, nil, 3, 1449, 1459, 1506, 1516, - 345, nil, nil, 1711, 1726, nil, nil, 339, 1643, 169, - nil, 341, 1951, nil, nil, nil, 11, nil, nil, nil, - nil, 332, nil, nil, nil, nil, 301, 840, 1846, 1891, - 1643, nil, nil, 91, nil, 166, nil, nil, nil, nil, - 123, 269, 309, 2086, nil, 295, 291, -18, nil, 288, - nil, nil, -9, 262, 2026, nil, nil, 321, 1604, 1587, - nil, nil, 147, nil, 281, nil, nil, 1439, 1328, 1303, - 1278, 1185, 1175, 1098, 1041, 974, 229, nil, nil, 964, - 917, 907, 224, 850, 830, 630, 620, nil, 268, 120, - 46, nil, 496, 248, 244, 234, nil, 231, nil, 244, - 49, 198, nil, 215, 159, 146, -5, 343, 208, 198, - 99, 125, nil, 73, 44, 9, nil, 375, 1232, 1674, - nil, 64, nil, 56, nil, nil, nil, 144, 56, 127, - 153, nil, 250, nil, nil, 321, 168, 156, nil, 196, - 187, 385, 140, nil, 236, nil, 239, nil, nil, 161, - 327, 7, nil, 395, 212, 235, nil, 227, 165, 1196, - nil, 2131, 2206, nil, 2146, 2239, 2224, nil, 2257, 208, - 275, 292, 1541, nil, nil, nil, 1392, 354, 325, 357, - 342, 347, 89, nil, 1257, 367, 10, nil, 80, nil, - 1118, nil, 1108, nil, -13, 189, 1031, 387, nil, nil, - 984, 393, 395, nil, nil, 2191, 1771, 409, 1906, 1786, - nil, nil, nil, nil, 1831, nil, nil, nil, 655, nil, - nil, nil, nil, nil, 2011, 420, nil, nil, nil, 419, - nil, nil, 78, 458, nil, 445, 405, 447, nil, nil, - 2071, nil, nil, 1966, nil, nil, nil, nil, 275, nil, - nil, nil, nil, nil, 155, nil, 81, nil, 467, nil, - 468, nil, nil, nil ] + -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 ] racc_action_default = [ - -184, -221, -219, -58, -221, -9, -155, -10, -221, -105, - -201, -221, -156, -23, -11, -176, -160, -221, -82, -25, - -12, -221, -26, -13, -1, -221, -159, -27, -14, -2, - -161, -110, -29, -15, -3, -209, -80, -221, -81, -16, - -221, -17, -6, -164, -221, -18, -7, -221, -163, -19, - -8, -176, -175, -184, -221, -59, -33, -221, -30, -31, - -32, -221, -221, -221, -221, -221, -57, -184, -61, -221, - -93, -184, -100, -184, -219, -43, -201, -221, -50, -44, - -47, -45, -221, -106, -48, -42, -51, -46, -221, -52, - -49, -81, -221, -121, -120, -221, -221, -221, -4, -177, - -181, -179, -180, -183, -182, -184, -221, -93, -221, -221, - -37, -38, -113, -221, -221, -165, -166, -168, -221, -185, - -186, -221, -91, -20, -28, -23, -81, -22, -24, -162, - -156, -221, -158, -149, -157, -150, -81, -221, -90, -92, - -221, -74, -201, -184, -73, -221, -65, -64, -81, -67, - -221, -100, -221, -40, -94, -221, -207, -221, -98, -207, - -99, -101, -221, -184, -221, -138, -204, -221, -221, -221, - -217, -216, -221, -213, -221, -212, -131, -221, -221, -221, - -221, -221, -221, -221, -221, -221, -221, -108, -107, -221, - -221, -221, -221, -221, -221, -221, -221, 374, -221, -221, - -221, -195, -221, -84, -85, -87, -88, -83, -86, -89, - -81, -78, -76, -221, -207, -36, -221, -221, -221, -221, - -221, -221, -21, -194, -221, -207, -189, -192, -221, -221, - -152, -207, -218, -221, -62, -70, -69, -221, -221, -221, - -207, -205, -221, -206, -112, -221, -221, -208, -63, -221, - -208, -221, -221, -197, -221, -141, -206, -202, -104, -221, - -221, -221, -210, -221, -128, -127, -122, -129, -130, -133, - -109, -140, -135, -123, -139, -137, -134, -124, -136, -132, - -125, -126, -221, -178, -196, -220, -79, -221, -93, -221, - -206, -34, -202, -39, -5, -221, -116, -143, -221, -147, - -221, -167, -221, -187, -221, -208, -221, -221, -170, -154, - -221, -221, -206, -68, -66, -71, -72, -221, -41, -96, - -55, -95, -56, -102, -97, -198, -199, -200, -221, -203, - -103, -111, -214, -211, -215, -221, -174, -77, -53, -207, - -54, -35, -116, -221, -115, -221, -221, -221, -144, -142, - -193, -188, -190, -191, -169, -153, -151, -60, -221, -172, - -173, -75, -114, -117, -221, -148, -221, -171, -221, -119, - -221, -146, -118, -145 ] + -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 ] racc_goto_table = [ - 12, 112, 24, 30, 98, 135, 156, 131, 53, 111, - 246, 65, 226, 249, 99, 212, 206, 173, 116, 83, - 66, 297, 73, 159, 12, 26, 158, 30, 295, 123, - 344, 124, 16, 57, 152, 145, 103, 307, 128, 157, - 68, 300, 29, 214, 323, 121, 314, 13, 133, 26, - 188, 231, 287, 167, 117, 211, 16, 12, 254, 105, - 30, 130, 198, 310, 30, 163, 127, 284, 289, 224, - 225, 13, 110, 216, 217, 325, 362, 172, 118, 304, - 21, 230, 26, 131, nil, 311, 26, nil, nil, 16, - 222, 335, 124, 16, 317, 120, nil, nil, nil, 128, - nil, 348, 240, nil, 125, 158, nil, 204, nil, nil, - 30, 233, nil, nil, nil, 120, nil, nil, 12, nil, - 6, 30, nil, nil, nil, nil, nil, 127, nil, nil, - nil, nil, 26, 259, 260, 2, nil, 130, nil, 16, - 30, nil, nil, 26, 6, nil, nil, 201, nil, nil, - 16, nil, nil, nil, nil, nil, nil, nil, nil, 2, - 27, nil, 26, nil, nil, 125, 299, nil, nil, 16, - nil, nil, nil, 368, nil, 370, nil, 6, nil, nil, - nil, 6, nil, nil, 27, 270, 332, 141, 283, 293, - nil, 141, 301, 361, 337, 206, 129, 273, 352, nil, - 309, 321, nil, 277, 158, 253, nil, nil, nil, nil, - 103, 103, nil, nil, nil, nil, nil, 27, nil, 12, - 130, nil, 30, 30, 339, nil, nil, 203, 12, nil, - nil, 30, nil, nil, nil, nil, nil, nil, 6, nil, - nil, nil, nil, nil, 26, 26, 299, nil, nil, nil, - nil, 16, 16, 26, 355, 22, 131, 6, nil, 326, - 16, nil, nil, 141, nil, nil, 13, 208, nil, nil, - nil, nil, 129, nil, 98, 13, nil, 32, 27, 22, - nil, nil, 12, nil, nil, 30, 204, nil, nil, 30, - nil, nil, 365, nil, 12, nil, nil, 30, nil, nil, - 130, 32, nil, 30, 363, nil, nil, 26, nil, nil, - 130, 26, 22, 30, 16, nil, 134, nil, 16, 26, - nil, nil, nil, nil, nil, 26, 16, nil, 12, 13, - 358, 30, 16, nil, 32, 26, nil, nil, 98, 6, - 6, 13, 16, nil, nil, nil, 130, 170, 6, 30, - nil, nil, nil, 26, 2, 129, nil, 141, 12, nil, - 16, 30, 207, 2, 12, nil, 12, 30, nil, 30, - nil, 26, nil, 22, nil, 13, nil, nil, 16, 27, - 19, nil, nil, 26, 209, nil, nil, nil, 27, 26, - 16, 26, 134, nil, nil, 32, 16, nil, 16, nil, - nil, nil, 6, nil, 19, 13, 203, nil, nil, nil, - nil, 13, nil, 13, 6, nil, nil, 2, nil, nil, - 6, nil, nil, nil, nil, nil, nil, nil, nil, 2, - 6, nil, nil, nil, nil, 129, nil, 19, nil, nil, - nil, 132, 27, nil, nil, 129, 208, 144, 6, nil, - nil, 144, nil, nil, 27, nil, nil, nil, nil, nil, - nil, nil, nil, 2, nil, nil, 6, nil, nil, nil, - nil, nil, nil, nil, 22, 134, nil, nil, 6, nil, - nil, 129, nil, 22, 6, nil, 6, 205, 27, nil, - nil, nil, nil, 2, nil, nil, 32, nil, 19, 2, - nil, 2, nil, nil, nil, 32, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, 170, 132, 27, nil, - nil, nil, nil, 144, 27, nil, 27, nil, nil, nil, - nil, nil, nil, 96, nil, nil, nil, 22, nil, nil, - nil, 207, nil, nil, nil, nil, nil, nil, nil, 22, - nil, nil, nil, nil, nil, 134, 113, nil, nil, 32, - 114, nil, nil, 209, nil, 134, nil, nil, nil, nil, - 122, 32, nil, nil, nil, nil, nil, nil, 138, 139, - 140, nil, nil, 22, nil, nil, nil, nil, nil, nil, - nil, nil, nil, 164, nil, nil, nil, nil, 165, 19, - 132, 134, nil, nil, nil, 32, nil, nil, 19, nil, - nil, 176, nil, 22, nil, nil, nil, 144, nil, 22, - nil, 22, 202, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, 32, nil, nil, nil, nil, - nil, 32, nil, 32, nil, nil, nil, nil, nil, nil, + 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, 19, nil, nil, nil, 205, nil, nil, nil, - nil, nil, nil, nil, 19, nil, nil, nil, nil, nil, - 132, nil, nil, nil, nil, nil, nil, nil, nil, nil, - 132, nil, nil, 264, 265, 266, 267, 268, 269, 96, - 271, 272, nil, nil, nil, 274, 275, 276, 19, 278, - 279, 280, 281, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, 132, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, 19, nil, - nil, nil, nil, nil, 19, nil, 19, nil, nil, nil, - nil, nil, nil, nil, 315, 316, nil, nil, 318, nil, - nil, 319, nil, nil, nil, nil, nil, 324, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, 334, + 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, 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, 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, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, 350, nil, - nil, nil, 353, 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, 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, 113 ] + nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, + nil, nil, nil, nil, nil, nil, nil, nil, nil, 114 ] racc_goto_check = [ - 33, 59, 2, 37, 4, 68, 41, 66, 38, 29, - 42, 33, 80, 42, 76, 51, 35, 83, 70, 57, - 6, 64, 38, 43, 33, 36, 54, 37, 5, 20, - 60, 10, 34, 21, 27, 46, 62, 5, 8, 46, - 45, 63, 3, 41, 56, 72, 47, 22, 67, 36, - 58, 69, 40, 27, 71, 39, 34, 33, 73, 74, - 37, 33, 75, 31, 37, 72, 6, 77, 42, 78, - 79, 22, 28, 27, 27, 81, 60, 82, 21, 42, - 1, 68, 36, 66, nil, 42, 36, nil, nil, 34, - 20, 5, 10, 34, 42, 3, nil, nil, nil, 8, - nil, 64, 43, nil, 22, 54, nil, 33, nil, nil, - 37, 46, nil, nil, nil, 3, nil, nil, 33, nil, - 32, 37, nil, nil, nil, nil, nil, 6, nil, nil, - nil, nil, 36, 27, 27, 53, nil, 33, nil, 34, - 37, nil, nil, 36, 32, nil, nil, 3, nil, nil, - 34, nil, nil, nil, nil, nil, nil, nil, nil, 53, - 25, nil, 36, nil, nil, 22, 66, nil, nil, 34, - nil, nil, nil, 5, nil, 5, nil, 32, nil, nil, - nil, 32, nil, nil, 25, 57, 83, 32, 76, 29, - nil, 32, 70, 42, 51, 35, 53, 62, 80, nil, - 29, 54, nil, 62, 54, 3, nil, nil, nil, nil, - 62, 62, nil, nil, nil, nil, nil, 25, nil, 33, - 33, nil, 37, 37, 41, nil, nil, 32, 33, nil, - nil, 37, nil, nil, nil, nil, nil, nil, 32, nil, - nil, nil, nil, nil, 36, 36, 66, nil, nil, nil, - nil, 34, 34, 36, 68, 24, 66, 32, nil, 38, - 34, nil, nil, 32, nil, nil, 22, 25, nil, nil, - nil, nil, 53, nil, 4, 22, nil, 26, 25, 24, - nil, nil, 33, nil, nil, 37, 33, nil, nil, 37, - nil, nil, 66, nil, 33, nil, nil, 37, nil, nil, - 33, 26, nil, 37, 59, nil, nil, 36, nil, nil, - 33, 36, 24, 37, 34, nil, 24, nil, 34, 36, - nil, nil, nil, nil, nil, 36, 34, nil, 33, 22, - 2, 37, 34, nil, 26, 36, nil, nil, 4, 32, - 32, 22, 34, nil, nil, nil, 33, 24, 32, 37, - nil, nil, nil, 36, 53, 53, nil, 32, 33, nil, - 34, 37, 24, 53, 33, nil, 33, 37, nil, 37, - nil, 36, nil, 24, nil, 22, nil, nil, 34, 25, - 23, nil, nil, 36, 26, nil, nil, nil, 25, 36, - 34, 36, 24, nil, nil, 26, 34, nil, 34, nil, - nil, nil, 32, nil, 23, 22, 32, nil, nil, nil, - nil, 22, nil, 22, 32, nil, nil, 53, nil, nil, - 32, nil, nil, nil, nil, nil, nil, nil, nil, 53, - 32, nil, nil, nil, nil, 53, nil, 23, nil, nil, - nil, 23, 25, nil, nil, 53, 25, 23, 32, nil, - nil, 23, nil, nil, 25, nil, nil, nil, nil, nil, - nil, nil, nil, 53, nil, nil, 32, nil, nil, nil, - nil, nil, nil, nil, 24, 24, nil, nil, 32, nil, - nil, 53, nil, 24, 32, nil, 32, 23, 25, nil, - nil, nil, nil, 53, nil, nil, 26, nil, 23, 53, - nil, 53, nil, nil, nil, 26, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, 24, 23, 25, nil, - nil, nil, nil, 23, 25, nil, 25, nil, nil, nil, - nil, nil, nil, 30, nil, nil, nil, 24, nil, nil, - nil, 24, nil, nil, nil, nil, nil, nil, nil, 24, - nil, nil, nil, nil, nil, 24, 30, nil, nil, 26, - 30, nil, nil, 26, nil, 24, nil, nil, nil, nil, - 30, 26, nil, nil, nil, nil, nil, nil, 30, 30, - 30, nil, nil, 24, nil, nil, nil, nil, nil, nil, - nil, nil, nil, 30, nil, nil, nil, nil, 30, 23, - 23, 24, nil, nil, nil, 26, nil, nil, 23, nil, - nil, 30, nil, 24, nil, nil, nil, 23, nil, 24, - nil, 24, 30, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, 26, nil, nil, nil, nil, - nil, 26, nil, 26, nil, nil, nil, nil, nil, nil, + 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, + 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, nil, nil, nil, nil, nil, nil, nil, - nil, nil, 23, nil, nil, nil, 23, nil, nil, nil, - nil, nil, nil, nil, 23, nil, nil, nil, nil, nil, - 23, nil, nil, nil, nil, nil, nil, nil, nil, nil, - 23, nil, nil, 30, 30, 30, 30, 30, 30, 30, - 30, 30, nil, nil, nil, 30, 30, 30, 23, 30, - 30, 30, 30, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, 23, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, 23, nil, - nil, nil, nil, nil, 23, nil, 23, nil, nil, nil, - nil, nil, nil, nil, 30, 30, nil, nil, 30, nil, - nil, 30, nil, nil, nil, nil, nil, 30, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, nil, 30, + 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, 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, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, 30, nil, - nil, nil, 30, 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, 30 ] + nil, nil, nil, nil, nil, nil, nil, nil, nil, 31 ] racc_goto_pointer = [ - nil, 80, 2, 42, -20, -191, 9, nil, -19, nil, - -26, nil, nil, nil, nil, nil, nil, nil, nil, nil, - -28, 29, 47, 380, 255, 160, 277, -35, 34, -29, - 516, -168, 120, 0, 32, -91, 25, 3, 7, -52, - -159, -64, -146, -49, nil, 28, -32, -191, nil, nil, - nil, -92, nil, 135, -46, nil, -206, 2, -46, -39, - -266, nil, 11, -179, -199, nil, -54, -13, -56, -86, - -29, 7, -8, -105, 34, -43, -11, -133, -50, -49, - -107, -177, -15, -75, nil ] + 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 ] racc_goto_default = [ - nil, nil, 294, 147, 34, nil, 42, 46, 50, 5, - 7, 14, 20, 23, 28, 33, 39, 41, 45, 49, - 4, nil, 78, 80, 85, 87, 90, nil, nil, 94, - 153, 242, 75, 79, 81, 84, 86, 89, 37, nil, - nil, nil, nil, nil, 11, nil, nil, 146, 237, 149, - 150, nil, 213, 74, 154, 160, 161, nil, nil, nil, - nil, 93, 43, nil, nil, 298, 8, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, 101, nil, nil, - nil, nil, nil, nil, 174 ] + 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 ] racc_reduce_table = [ 0, 0, :racc_error, - 1, 69, :_reduce_none, - 1, 69, :_reduce_none, - 1, 70, :_reduce_3, - 2, 70, :_reduce_4, - 1, 73, :_reduce_5, - 1, 72, :_reduce_none, - 1, 72, :_reduce_none, - 1, 72, :_reduce_none, - 1, 72, :_reduce_none, - 1, 72, :_reduce_none, - 1, 72, :_reduce_none, - 1, 72, :_reduce_none, - 1, 72, :_reduce_none, - 1, 72, :_reduce_none, - 1, 72, :_reduce_none, - 1, 72, :_reduce_none, - 1, 72, :_reduce_none, - 1, 72, :_reduce_none, - 1, 72, :_reduce_none, - 3, 87, :_reduce_20, - 3, 87, :_reduce_21, - 1, 88, :_reduce_none, - 1, 88, :_reduce_none, - 1, 88, :_reduce_none, - 1, 88, :_reduce_none, - 1, 88, :_reduce_none, - 1, 88, :_reduce_none, - 1, 88, :_reduce_none, - 1, 88, :_reduce_none, - 1, 89, :_reduce_none, - 1, 89, :_reduce_none, - 1, 89, :_reduce_none, - 1, 89, :_reduce_none, - 4, 81, :_reduce_34, - 5, 81, :_reduce_35, - 3, 81, :_reduce_36, - 2, 81, :_reduce_37, - 1, 96, :_reduce_38, - 3, 96, :_reduce_39, - 1, 95, :_reduce_40, - 3, 95, :_reduce_41, - 1, 97, :_reduce_none, - 1, 97, :_reduce_none, - 1, 97, :_reduce_none, - 1, 97, :_reduce_none, - 1, 97, :_reduce_none, - 1, 97, :_reduce_none, - 1, 97, :_reduce_none, - 1, 97, :_reduce_none, - 1, 97, :_reduce_none, - 1, 97, :_reduce_none, - 1, 97, :_reduce_none, - 5, 74, :_reduce_53, - 5, 74, :_reduce_54, - 5, 74, :_reduce_55, - 5, 85, :_reduce_56, - 2, 75, :_reduce_57, - 1, 112, :_reduce_58, - 2, 112, :_reduce_59, - 6, 76, :_reduce_60, - 2, 76, :_reduce_61, - 3, 113, :_reduce_62, - 3, 113, :_reduce_63, - 1, 114, :_reduce_none, - 1, 114, :_reduce_none, - 3, 114, :_reduce_66, - 1, 115, :_reduce_none, - 3, 115, :_reduce_68, - 1, 116, :_reduce_69, - 1, 116, :_reduce_70, - 3, 117, :_reduce_71, - 3, 117, :_reduce_72, - 1, 118, :_reduce_none, - 1, 118, :_reduce_none, - 4, 119, :_reduce_75, - 1, 107, :_reduce_76, - 3, 107, :_reduce_77, - 0, 108, :_reduce_none, - 1, 108, :_reduce_none, - 1, 105, :_reduce_80, - 1, 100, :_reduce_81, - 1, 101, :_reduce_82, - 1, 120, :_reduce_none, - 1, 120, :_reduce_none, - 1, 120, :_reduce_none, - 1, 120, :_reduce_none, - 1, 120, :_reduce_none, + 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, 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, 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, - 3, 77, :_reduce_90, - 3, 77, :_reduce_91, - 3, 86, :_reduce_92, - 0, 109, :_reduce_93, - 1, 109, :_reduce_94, - 3, 109, :_reduce_95, - 3, 122, :_reduce_96, - 3, 123, :_reduce_97, - 1, 124, :_reduce_none, - 1, 124, :_reduce_none, - 0, 111, :_reduce_100, - 1, 111, :_reduce_101, - 3, 111, :_reduce_102, - 4, 104, :_reduce_103, - 3, 104, :_reduce_104, - 1, 92, :_reduce_105, - 2, 92, :_reduce_106, - 2, 125, :_reduce_107, - 1, 126, :_reduce_108, - 2, 126, :_reduce_109, - 1, 102, :_reduce_110, - 4, 90, :_reduce_111, - 4, 90, :_reduce_112, - 2, 79, :_reduce_113, - 5, 127, :_reduce_114, - 4, 127, :_reduce_115, - 0, 128, :_reduce_none, - 2, 128, :_reduce_117, - 4, 128, :_reduce_118, - 3, 128, :_reduce_119, - 1, 98, :_reduce_none, - 1, 98, :_reduce_none, - 3, 98, :_reduce_122, - 3, 98, :_reduce_123, - 3, 98, :_reduce_124, - 3, 98, :_reduce_125, - 3, 98, :_reduce_126, - 3, 98, :_reduce_127, - 3, 98, :_reduce_128, - 3, 98, :_reduce_129, - 3, 98, :_reduce_130, - 2, 98, :_reduce_131, - 3, 98, :_reduce_132, - 3, 98, :_reduce_133, - 3, 98, :_reduce_134, - 3, 98, :_reduce_135, - 3, 98, :_reduce_136, - 3, 98, :_reduce_137, - 2, 98, :_reduce_138, - 3, 98, :_reduce_139, - 3, 98, :_reduce_140, - 3, 98, :_reduce_141, - 5, 78, :_reduce_142, - 1, 131, :_reduce_143, - 2, 131, :_reduce_144, - 5, 132, :_reduce_145, - 4, 132, :_reduce_146, - 1, 133, :_reduce_147, - 3, 133, :_reduce_148, - 3, 93, :_reduce_149, - 1, 135, :_reduce_none, - 4, 135, :_reduce_151, + 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, 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, - 3, 137, :_reduce_153, - 3, 136, :_reduce_154, - 1, 134, :_reduce_none, - 1, 134, :_reduce_none, - 1, 134, :_reduce_none, - 1, 134, :_reduce_none, - 1, 134, :_reduce_none, - 1, 134, :_reduce_none, - 1, 134, :_reduce_none, - 1, 134, :_reduce_none, - 1, 134, :_reduce_163, - 1, 134, :_reduce_none, - 1, 138, :_reduce_165, + 4, 137, :_reduce_154, 1, 139, :_reduce_none, - 3, 139, :_reduce_167, - 2, 80, :_reduce_168, - 6, 82, :_reduce_169, - 5, 82, :_reduce_170, - 7, 83, :_reduce_171, - 6, 83, :_reduce_172, - 6, 84, :_reduce_173, - 5, 84, :_reduce_174, - 1, 106, :_reduce_175, - 1, 106, :_reduce_176, - 1, 142, :_reduce_177, - 3, 142, :_reduce_178, - 1, 144, :_reduce_179, - 1, 145, :_reduce_180, - 1, 145, :_reduce_181, - 1, 145, :_reduce_182, - 1, 145, :_reduce_none, - 0, 71, :_reduce_184, - 0, 146, :_reduce_185, - 1, 140, :_reduce_none, - 3, 140, :_reduce_187, - 4, 140, :_reduce_188, - 1, 147, :_reduce_none, - 3, 147, :_reduce_190, - 3, 148, :_reduce_191, - 1, 148, :_reduce_192, - 3, 148, :_reduce_193, - 1, 148, :_reduce_194, - 1, 143, :_reduce_none, - 2, 143, :_reduce_196, + 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, 1, 141, :_reduce_none, - 2, 141, :_reduce_198, - 1, 149, :_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, - 1, 91, :_reduce_201, - 3, 103, :_reduce_202, - 4, 103, :_reduce_203, - 2, 103, :_reduce_204, - 1, 99, :_reduce_none, - 1, 99, :_reduce_none, - 0, 110, :_reduce_none, - 1, 110, :_reduce_208, - 1, 130, :_reduce_209, - 3, 129, :_reduce_210, - 4, 129, :_reduce_211, - 2, 129, :_reduce_212, - 1, 150, :_reduce_none, - 3, 150, :_reduce_214, - 3, 151, :_reduce_215, - 1, 152, :_reduce_216, - 1, 152, :_reduce_217, - 4, 121, :_reduce_218, - 1, 94, :_reduce_none, - 4, 94, :_reduce_220 ] - -racc_reduce_n = 221 - -racc_shift_n = 374 + 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, + 1, 143, :_reduce_none, + 2, 143, :_reduce_201, + 1, 151, :_reduce_none, + 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 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 } + :IN => 67, + :UNLESS => 68 } -racc_nt_base = 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", "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", "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 -module_eval(<<'.,.,', 'grammar.ra', 72) - def _reduce_20(val, _values, result) +# 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) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 75) - def _reduce_21(val, _values, result) +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 -module_eval(<<'.,.,', 'grammar.ra', 90) - def _reduce_34(val, _values, result) +# reduce 34 omitted + +module_eval(<<'.,.,', 'grammar.ra', 91) + def _reduce_35(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', 97) - def _reduce_35(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 98) + def _reduce_36(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', 103) - def _reduce_36(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 104) + def _reduce_37(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', 110) - def _reduce_37(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 111) + def _reduce_38(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', 117) - def _reduce_38(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 118) + def _reduce_39(val, _values, result) result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 120) - def _reduce_39(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 121) + def _reduce_40(val, _values, result) val[0].push(val[2]) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 124) - def _reduce_40(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 125) + def _reduce_41(val, _values, result) result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 125) - def _reduce_41(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 126) + def _reduce_42(val, _values, result) result = val[0].push(val[2]) result end .,., -# reduce 42 omitted - # reduce 43 omitted # reduce 44 omitted # reduce 45 omitted # reduce 46 omitted # reduce 47 omitted # reduce 48 omitted # reduce 49 omitted # reduce 50 omitted # reduce 51 omitted # reduce 52 omitted -module_eval(<<'.,.,', 'grammar.ra', 140) - def _reduce_53(val, _values, result) +# reduce 53 omitted + +module_eval(<<'.,.,', 'grammar.ra', 141) + def _reduce_54(val, _values, result) @lexer.commentpop result = ast(AST::Resource, :type => val[0], :instances => val[2]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 143) - def _reduce_54(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 144) + def _reduce_55(val, _values, result) # This is a deprecated syntax. error "All resource specifications require names" result end .,., -module_eval(<<'.,.,', 'grammar.ra', 146) - def _reduce_55(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 147) + def _reduce_56(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', 153) - def _reduce_56(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 154) + def _reduce_57(val, _values, result) @lexer.commentpop result = ast AST::ResourceOverride, :object => val[0], :parameters => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 160) - def _reduce_57(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 161) + def _reduce_58(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', 176) - def _reduce_58(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 177) + def _reduce_59(val, _values, result) result = :virtual result end .,., -module_eval(<<'.,.,', 'grammar.ra', 177) - def _reduce_59(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 178) + def _reduce_60(val, _values, result) result = :exported result end .,., -module_eval(<<'.,.,', 'grammar.ra', 182) - def _reduce_60(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 183) + def _reduce_61(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', 200) - def _reduce_61(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 201) + def _reduce_62(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', 218) - def _reduce_62(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 219) + def _reduce_63(val, _values, result) if val[1] result = val[1] result.form = :virtual else result = :virtual end result end .,., -module_eval(<<'.,.,', 'grammar.ra', 226) - def _reduce_63(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 227) + def _reduce_64(val, _values, result) if val[1] result = val[1] result.form = :exported else result = :exported end result end .,., -# reduce 64 omitted - # reduce 65 omitted -module_eval(<<'.,.,', 'grammar.ra', 239) - def _reduce_66(val, _values, result) +# reduce 66 omitted + +module_eval(<<'.,.,', 'grammar.ra', 240) + def _reduce_67(val, _values, result) result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2] result end .,., -# reduce 67 omitted +# reduce 68 omitted -module_eval(<<'.,.,', 'grammar.ra', 244) - def _reduce_68(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 245) + def _reduce_69(val, _values, result) result = val[1] result.parens = true result end .,., -module_eval(<<'.,.,', 'grammar.ra', 248) - def _reduce_69(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 249) + def _reduce_70(val, _values, result) result=val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 249) - def _reduce_70(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 250) + def _reduce_71(val, _values, result) result=val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 252) - def _reduce_71(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 253) + def _reduce_72(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', 257) - def _reduce_72(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 258) + def _reduce_73(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 73 omitted - # reduce 74 omitted -module_eval(<<'.,.,', 'grammar.ra', 266) - def _reduce_75(val, _values, result) +# reduce 75 omitted + +module_eval(<<'.,.,', 'grammar.ra', 267) + def _reduce_76(val, _values, result) result = ast AST::ResourceInstance, :title => val[0], :parameters => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 269) - def _reduce_76(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 270) + def _reduce_77(val, _values, result) result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 271) - def _reduce_77(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 272) + def _reduce_78(val, _values, result) val[0].push val[2] result = val[0] result end .,., -# reduce 78 omitted - # reduce 79 omitted -module_eval(<<'.,.,', 'grammar.ra', 279) - def _reduce_80(val, _values, result) +# reduce 80 omitted + +module_eval(<<'.,.,', 'grammar.ra', 280) + def _reduce_81(val, _values, result) result = ast AST::Undef, :value => :undef result end .,., -module_eval(<<'.,.,', 'grammar.ra', 283) - def _reduce_81(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 284) + def _reduce_82(val, _values, result) result = ast AST::Name, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 287) - def _reduce_82(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 288) + def _reduce_83(val, _values, result) result = ast AST::Type, :value => val[0][:value], :line => val[0][:line] result end .,., -# reduce 83 omitted - # reduce 84 omitted # reduce 85 omitted # reduce 86 omitted # reduce 87 omitted # reduce 88 omitted # reduce 89 omitted -module_eval(<<'.,.,', 'grammar.ra', 299) - def _reduce_90(val, _values, result) +# reduce 90 omitted + +module_eval(<<'.,.,', 'grammar.ra', 300) + def _reduce_91(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', 305) - def _reduce_91(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 306) + def _reduce_92(val, _values, result) result = ast AST::VarDef, :name => val[0], :value => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 309) - def _reduce_92(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 310) + def _reduce_93(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', 315) - def _reduce_93(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 316) + def _reduce_94(val, _values, result) result = ast AST::ASTArray result end .,., -module_eval(<<'.,.,', 'grammar.ra', 317) - def _reduce_94(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 318) + def _reduce_95(val, _values, result) result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 319) - def _reduce_95(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 320) + def _reduce_96(val, _values, result) val[0].push(val[2]) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 324) - def _reduce_96(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 325) + def _reduce_97(val, _values, result) result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 328) - def _reduce_97(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 329) + def _reduce_98(val, _values, result) result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2], :add => true result end .,., -# reduce 98 omitted - # reduce 99 omitted -module_eval(<<'.,.,', 'grammar.ra', 337) - def _reduce_100(val, _values, result) +# reduce 100 omitted + +module_eval(<<'.,.,', 'grammar.ra', 338) + def _reduce_101(val, _values, result) result = ast AST::ASTArray result end .,., -module_eval(<<'.,.,', 'grammar.ra', 339) - def _reduce_101(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 340) + def _reduce_102(val, _values, result) result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 341) - def _reduce_102(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 342) + def _reduce_103(val, _values, result) val[0].push(val[2]) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 347) - def _reduce_103(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 348) + def _reduce_104(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', 352) - def _reduce_104(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 353) + def _reduce_105(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', 358) - def _reduce_105(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 359) + def _reduce_106(val, _values, result) result = ast AST::String, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 359) - def _reduce_106(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 360) + def _reduce_107(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', 361) - def _reduce_107(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 362) + def _reduce_108(val, _values, result) result = [val[0]] + val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 363) - def _reduce_108(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 364) + def _reduce_109(val, _values, result) result = [ast(AST::String,val[0])] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 364) - def _reduce_109(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 365) + def _reduce_110(val, _values, result) result = [ast(AST::String,val[0])] + val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 367) - def _reduce_110(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 368) + def _reduce_111(val, _values, result) result = ast AST::Boolean, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 371) - def _reduce_111(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 372) + def _reduce_112(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', 374) - def _reduce_112(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 375) + def _reduce_113(val, _values, result) result = ast AST::ResourceReference, :type => val[0].value, :title => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 378) - def _reduce_113(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 379) + def _reduce_114(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) + @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) result = val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 382) - def _reduce_114(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 401) + def _reduce_117(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', 393) - def _reduce_115(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 412) + def _reduce_118(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 116 omitted +# reduce 119 omitted -module_eval(<<'.,.,', 'grammar.ra', 406) - def _reduce_117(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 425) + def _reduce_120(val, _values, result) result = ast AST::Else, :statements => val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 409) - def _reduce_118(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 428) + def _reduce_121(val, _values, result) @lexer.commentpop result = ast AST::Else, :statements => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 413) - def _reduce_119(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 432) + def _reduce_122(val, _values, result) @lexer.commentpop result = ast AST::Else, :statements => ast(AST::Nop) result end .,., -# reduce 120 omitted +# reduce 123 omitted -# reduce 121 omitted +# reduce 124 omitted -module_eval(<<'.,.,', 'grammar.ra', 432) - def _reduce_122(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 451) + def _reduce_125(val, _values, result) result = ast AST::InOperator, :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 435) - def _reduce_123(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 454) + def _reduce_126(val, _values, result) result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 438) - def _reduce_124(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 457) + def _reduce_127(val, _values, result) result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 441) - def _reduce_125(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 460) + def _reduce_128(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 444) - def _reduce_126(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 463) + def _reduce_129(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 447) - def _reduce_127(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 466) + def _reduce_130(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 450) - def _reduce_128(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 469) + def _reduce_131(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 453) - def _reduce_129(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 472) + def _reduce_132(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 456) - def _reduce_130(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 475) + def _reduce_133(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 459) - def _reduce_131(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 478) + def _reduce_134(val, _values, result) result = ast AST::Minus, :value => val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 462) - def _reduce_132(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 481) + def _reduce_135(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 465) - def _reduce_133(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 484) + def _reduce_136(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 468) - def _reduce_134(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 487) + def _reduce_137(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 471) - def _reduce_135(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 490) + def _reduce_138(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 474) - def _reduce_136(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 493) + def _reduce_139(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 477) - def _reduce_137(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 496) + def _reduce_140(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 480) - def _reduce_138(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 499) + def _reduce_141(val, _values, result) result = ast AST::Not, :value => val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 483) - def _reduce_139(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 502) + def _reduce_142(val, _values, result) result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 486) - def _reduce_140(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 505) + def _reduce_143(val, _values, result) result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 489) - def _reduce_141(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 508) + def _reduce_144(val, _values, result) result = val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 493) - def _reduce_142(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 512) + def _reduce_145(val, _values, result) @lexer.commentpop result = ast AST::CaseStatement, :test => val[1], :options => val[3] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 497) - def _reduce_143(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 516) + def _reduce_146(val, _values, result) result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 499) - def _reduce_144(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 518) + def _reduce_147(val, _values, result) val[0].push val[1] result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 504) - def _reduce_145(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 523) + def _reduce_148(val, _values, result) @lexer.commentpop result = ast AST::CaseOpt, :value => val[0], :statements => val[3] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 507) - def _reduce_146(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 526) + def _reduce_149(val, _values, result) @lexer.commentpop result = ast( AST::CaseOpt, :value => val[0], :statements => ast(AST::ASTArray) ) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 517) - def _reduce_147(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 536) + def _reduce_150(val, _values, result) result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 519) - def _reduce_148(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 538) + def _reduce_151(val, _values, result) val[0].push(val[2]) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 524) - def _reduce_149(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 543) + def _reduce_152(val, _values, result) result = ast AST::Selector, :param => val[0], :values => val[2] result end .,., -# reduce 150 omitted +# reduce 153 omitted -module_eval(<<'.,.,', 'grammar.ra', 529) - def _reduce_151(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 548) + def _reduce_154(val, _values, result) @lexer.commentpop result = val[1] result end .,., -# reduce 152 omitted +# reduce 155 omitted -module_eval(<<'.,.,', 'grammar.ra', 535) - def _reduce_153(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 554) + def _reduce_156(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', 544) - def _reduce_154(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 563) + def _reduce_157(val, _values, result) result = ast AST::ResourceParam, :param => val[0], :value => val[2] result end .,., -# reduce 155 omitted - -# reduce 156 omitted - -# reduce 157 omitted - # reduce 158 omitted # reduce 159 omitted # reduce 160 omitted # reduce 161 omitted # reduce 162 omitted -module_eval(<<'.,.,', 'grammar.ra', 556) - def _reduce_163(val, _values, result) +# reduce 163 omitted + +# reduce 164 omitted + +# reduce 165 omitted + +module_eval(<<'.,.,', 'grammar.ra', 575) + def _reduce_166(val, _values, result) result = ast AST::Default, :value => val[0][:value], :line => val[0][:line] result end .,., -# reduce 164 omitted +# reduce 167 omitted -module_eval(<<'.,.,', 'grammar.ra', 561) - def _reduce_165(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 580) + def _reduce_168(val, _values, result) result = [val[0][:value]] result end .,., -# reduce 166 omitted +# reduce 169 omitted -module_eval(<<'.,.,', 'grammar.ra', 563) - def _reduce_167(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 582) + def _reduce_170(val, _values, result) result = val[0] += val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 566) - def _reduce_168(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 585) + def _reduce_171(val, _values, result) val[1].each do |file| import(file) end result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 576) - def _reduce_169(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 595) + def _reduce_172(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', 584) - def _reduce_170(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 603) + def _reduce_173(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', 592) - def _reduce_171(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 611) + def _reduce_174(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', 599) - def _reduce_172(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 618) + def _reduce_175(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', 608) - def _reduce_173(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 627) + def _reduce_176(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', 613) - def _reduce_174(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 632) + def _reduce_177(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', 617) - def _reduce_175(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 636) + def _reduce_178(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 618) - def _reduce_176(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 637) + def _reduce_179(val, _values, result) result = "class" result end .,., -module_eval(<<'.,.,', 'grammar.ra', 623) - def _reduce_177(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 642) + def _reduce_180(val, _values, result) result = [result] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 626) - def _reduce_178(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 645) + def _reduce_181(val, _values, result) result = val[0] result << val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 631) - def _reduce_179(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 650) + def _reduce_182(val, _values, result) result = ast AST::HostName, :value => val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 634) - def _reduce_180(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 653) + def _reduce_183(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 635) - def _reduce_181(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 654) + def _reduce_184(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 636) - def _reduce_182(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 655) + def _reduce_185(val, _values, result) result = val[0][:value] result end .,., -# reduce 183 omitted +# reduce 186 omitted -module_eval(<<'.,.,', 'grammar.ra', 640) - def _reduce_184(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 659) + def _reduce_187(val, _values, result) result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 644) - def _reduce_185(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 663) + def _reduce_188(val, _values, result) result = ast AST::ASTArray, :children => [] result end .,., -# reduce 186 omitted +# reduce 189 omitted -module_eval(<<'.,.,', 'grammar.ra', 649) - def _reduce_187(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 668) + def _reduce_190(val, _values, result) result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 652) - def _reduce_188(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 671) + def _reduce_191(val, _values, result) result = val[1] result = [result] unless result[0].is_a?(Array) result end .,., -# reduce 189 omitted +# reduce 192 omitted -module_eval(<<'.,.,', 'grammar.ra', 658) - def _reduce_190(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 677) + def _reduce_193(val, _values, result) result = val[0] result = [result] unless result[0].is_a?(Array) result << val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 664) - def _reduce_191(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 683) + def _reduce_194(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', 668) - def _reduce_192(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 687) + def _reduce_195(val, _values, result) Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype") result = [val[0][:value]] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 671) - def _reduce_193(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 690) + def _reduce_196(val, _values, result) result = [val[0][:value], val[2]] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 673) - def _reduce_194(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 692) + def _reduce_197(val, _values, result) result = [val[0][:value]] result end .,., -# reduce 195 omitted +# reduce 198 omitted -module_eval(<<'.,.,', 'grammar.ra', 678) - def _reduce_196(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 697) + def _reduce_199(val, _values, result) result = val[1] result end .,., -# reduce 197 omitted +# reduce 200 omitted -module_eval(<<'.,.,', 'grammar.ra', 683) - def _reduce_198(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 702) + def _reduce_201(val, _values, result) result = val[1] result end .,., -# reduce 199 omitted +# reduce 202 omitted -# reduce 200 omitted +# reduce 203 omitted -module_eval(<<'.,.,', 'grammar.ra', 689) - def _reduce_201(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 708) + def _reduce_204(val, _values, result) result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 692) - def _reduce_202(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 711) + def _reduce_205(val, _values, result) result = val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 693) - def _reduce_203(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 712) + def _reduce_206(val, _values, result) result = val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 694) - def _reduce_204(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 713) + def _reduce_207(val, _values, result) result = ast AST::ASTArray result end .,., -# reduce 205 omitted +# reduce 208 omitted -# reduce 206 omitted +# reduce 209 omitted -# reduce 207 omitted +# reduce 210 omitted -module_eval(<<'.,.,', 'grammar.ra', 700) - def _reduce_208(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 719) + def _reduce_211(val, _values, result) result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 703) - def _reduce_209(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 722) + def _reduce_212(val, _values, result) result = ast AST::Regex, :value => val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 707) - def _reduce_210(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 726) + def _reduce_213(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', 714) - def _reduce_211(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 733) + def _reduce_214(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', 720) - def _reduce_212(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 739) + def _reduce_215(val, _values, result) result = ast AST::ASTHash result end .,., -# reduce 213 omitted +# reduce 216 omitted -module_eval(<<'.,.,', 'grammar.ra', 725) - def _reduce_214(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 744) + def _reduce_217(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', 734) - def _reduce_215(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 753) + def _reduce_218(val, _values, result) result = ast AST::ASTHash, { :value => { val[0] => val[2] } } result end .,., -module_eval(<<'.,.,', 'grammar.ra', 737) - def _reduce_216(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 756) + def _reduce_219(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 738) - def _reduce_217(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 757) + def _reduce_220(val, _values, result) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 741) - def _reduce_218(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 760) + def _reduce_221(val, _values, result) result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2] result end .,., -# reduce 219 omitted +# reduce 222 omitted -module_eval(<<'.,.,', 'grammar.ra', 746) - def _reduce_220(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 765) + def _reduce_223(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/parser_spec.rb b/spec/unit/parser/parser_spec.rb index beb046845..dc3de5e06 100755 --- a/spec/unit/parser/parser_spec.rb +++ b/spec/unit/parser/parser_spec.rb @@ -1,428 +1,439 @@ #!/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 + 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