diff --git a/lib/puppet/parser/grammar.ra b/lib/puppet/parser/grammar.ra index d2bd06e94..d68c2f163 100644 --- a/lib/puppet/parser/grammar.ra +++ b/lib/puppet/parser/grammar.ra @@ -1,796 +1,770 @@ # 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 CLASSNAME CLASSREF +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 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 | 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 edge: IN_EDGE | OUT_EDGE | IN_EDGE_SUB | OUT_EDGE_SUB -fstatement: NAME LPAREN funcvalues RPAREN { +fstatement: NAME LPAREN expressions RPAREN { result = ast AST::Function, :name => val[0][:value], :line => val[0][:line], :arguments => val[2], :ftype => :statement } -| NAME LPAREN funcvalues COMMA RPAREN { +| 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: namestring { result = aryfy(val[0]) } - | resourceref { result = aryfy(val[0]) } - | funcvalues COMMA namestring { - val[0].push(val[2]) - result = val[0] -} - | funcvalues COMMA resourceref { +funcvalues: rvalue { result = aryfy(val[0]) } +# This rvalue could be an expression + | funcvalues COMMA rvalue { val[0].push(val[2]) result = val[0] } -# This is *almost* an rvalue, but I couldn't get a full -# rvalue to work without scads of shift/reduce conflicts. -namestring: name - | variable +expressions: expression { result = aryfy(val[0]) } + | expressions comma expression { result = val[0].push(val[2]) } + +rvalue: quotedtext + | name | type | boolean - | funcrvalue | selector - | quotedtext + | variable + | array | hasharrayaccesses - | CLASSNAME { - result = ast AST::Name, :value => val[0][:value] - } + | 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" } | classref LBRACE params endcomma RBRACE { # a defaults setting for a type @lexer.commentpop result = ast(AST::ResourceDefaults, :type => val[0], :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: classref collectrhand LBRACE anyparams endcomma RBRACE { @lexer.commentpop Puppet.warning addcontext("Collection names must now be capitalized") if val[0] =~ /^[a-z]/ type = val[0].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 } | classref collectrhand { if val[0] =~ /^[a-z]/ Puppet.warning addcontext("Collection names must now be capitalized") end type = val[0].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 simplervalue { +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 simplervalue { + | 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 rvalue { +param: NAME FARROW expression { result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2] } -addparam: NAME PARROW rvalue { +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] } -rvalues: rvalue { result = aryfy(val[0]) } - | rvalues comma rvalue { result = val[0].push(val[2]) } - -simplervalue: quotedtext - | name - | type - | boolean - | selector - | variable - -rvalue: quotedtext - | name - | type - | boolean - | selector - | variable - | array - | hash - | hasharrayaccesses - | resourceref - | funcrvalue - | undef - # We currently require arguments in these functions. -funcrvalue: NAME LPAREN funcvalues RPAREN { +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 rvalues RBRACK { +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] -} | classref LBRACK rvalues RBRACK { +} | classref LBRACK expressions RBRACK { result = ast AST::ResourceReference, :type => val[0], :title => val[2] } 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 - | expression IN 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 rvalue LBRACE caseopts RBRACE { +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])) } classref: CLASSREF { result = val[0][:value] } -classname: NAME { result = val[0][:value] } - | CLASSNAME { result = val[0][:value] } +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 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 rvalue { +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 rvalue { +} | 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 rvalues RBRACK { result = val[1] } - | LBRACK rvalues COMMA RBRACK { result = val[1] } +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 rvalue { +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 rvalue RBRACK { +hasharrayaccess: VARIABLE LBRACK expression RBRACK { result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2] } hasharrayaccesses: hasharrayaccess - | hasharrayaccesses LBRACK rvalue RBRACK { + | 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 2f416615e..cb1ff4536 100644 --- a/lib/puppet/parser/lexer.rb +++ b/lib/puppet/parser/lexer.rb @@ -1,583 +1,583 @@ # 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{([a-z][-\w]*)?(::[a-z][-\w]*)+} => :CLASSNAME, # Require '::' in the class name, else we'd compete with NAME %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]*} do |lexer, value| + 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.add_token :DOLLAR_VAR, %r{\$(::)?([-\w]+::)*[-\w]+} do |lexer, value| [TOKENS[:VARIABLE],value[1..-1]] end - TOKENS.add_token :VARIABLE, %r{(\w*::)*\w+} + 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 ) 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(%r{(\w*::)*\w+|[0-9]}) + 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 611398d14..f46d20d9f 100644 --- a/lib/puppet/parser/parser.rb +++ b/lib/puppet/parser/parser.rb @@ -1,2616 +1,2333 @@ # # DO NOT MODIFY!!!! # This file is automatically generated by Racc 1.4.6 # 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', 789) +module_eval(<<'...end grammar.ra/module_eval...', 'grammar.ra', 763) # 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 ### -racc_action_table = [ - 242, 243, 55, 68, 71, 299, 157, 55, 78, 117, - 199, 68, 71, 181, 186, -169, 36, 112, 341, 113, - 38, 55, 177, 179, 182, 185, 170, 10, 68, 71, - 231, 158, 114, 292, 293, 356, 257, 368, 68, 71, - 59, 198, 100, 61, 103, 59, 180, 184, 61, 198, - 189, 172, 173, 174, 176, 178, 111, 183, 187, 59, - 95, 66, 61, 60, 175, 79, 253, 154, 60, 88, - 345, 66, 233, 229, 139, 79, 81, 231, 84, 88, - 68, 71, 60, 225, 74, 99, 68, 71, 84, 60, - 100, 90, 103, 203, 203, 292, 293, 223, 296, 60, - 203, 117, 231, 78, 202, 202, 295, 240, 95, 209, - 209, 202, 166, 66, 186, 170, 209, 79, 253, 66, - 241, 88, 177, 79, 81, 334, 139, 88, 68, 71, - 84, 310, 74, 99, 68, 71, 84, 357, 100, 90, - 103, 60, 183, 187, 311, 358, 307, 60, 308, 175, - 189, 172, 173, 174, 176, 178, 95, 183, 187, 36, - 309, 66, 288, 38, 175, 79, 253, 66, 218, 88, - 10, 79, 81, 219, 139, 88, 338, 312, 84, 336, - 74, 99, 68, 71, 84, 218, 100, 90, 103, 60, - 219, 173, 174, 217, 285, 60, 183, 187, 257, 284, - 203, 68, 71, 175, 95, 100, 36, 103, 68, 71, - 127, 202, 100, 316, 103, 66, 209, 10, 15, 79, - 81, 173, 174, 88, 183, 187, 183, 187, 74, 99, - 95, 175, 84, 175, 66, 90, 113, 338, 79, 81, - 336, 66, 88, 60, 213, 79, 81, 74, 319, 88, - 216, 84, 68, 71, 74, 99, 213, 49, 84, 68, - 71, 90, 60, 100, 215, 103, 47, 48, 287, 60, - 154, 286, 189, 172, 173, 174, 324, 68, 71, 183, - 187, 100, 213, 103, 36, 66, 175, 327, 38, 79, - 253, 314, 66, 88, 200, 10, 79, 81, 139, 95, - 88, -171, 84, 68, 71, 74, 330, 78, 170, 84, - 66, -172, 259, 60, 79, 81, 257, 258, 88, -173, - 60, -168, -170, 74, 99, 70, 228, 84, 68, 71, - 90, 36, 100, -167, 103, 127, 66, -167, 60, 161, - 79, 81, 10, 15, 88, -169, -171, 297, 72, 74, - 95, 257, 258, 84, 68, 71, 36, -172, 100, -168, - 38, 66, 112, -170, 60, 79, 81, 10, 15, 88, - -22, -22, -22, -22, 74, 99, 68, 71, 84, 290, - 100, 90, 103, 292, 293, -167, 167, 66, 166, 60, - 335, 79, 253, 229, -187, 88, 339, 68, 71, 161, - 139, 100, 49, 103, 84, 43, 44, 40, 41, 66, - 234, -169, -174, 79, 81, 60, 156, 88, 154, 68, - 71, 354, 74, 100, 122, 103, 84, 122, 359, 161, - 66, 60, -170, 53, 79, 81, 229, 60, 88, 366, - 68, 71, 52, 74, 100, -168, 103, 84, 43, 44, - 40, 41, 66, 232, 51, 373, 79, 81, 60, 374, - 88, -169, 95, -167, -170, 74, 68, 71, -168, 84, - 100, -172, 103, 66, 60, 376, 45, 79, 81, -222, - 60, 88, -24, -24, -24, -24, 74, 99, 95, 234, - 84, 379, 238, 90, 39, 384, 68, 71, 385, 66, - 100, 60, 103, 79, 81, nil, nil, 88, nil, nil, - nil, nil, 74, 99, nil, nil, 84, nil, 95, 90, - nil, nil, 68, 71, nil, nil, 100, 60, 103, 66, - nil, nil, nil, 79, 81, nil, nil, 88, nil, nil, - nil, nil, 74, 99, 95, nil, 84, nil, nil, 90, - nil, nil, 68, 71, nil, 66, 100, 60, 103, 79, - 81, nil, nil, 88, nil, nil, nil, nil, 74, 99, - nil, nil, 84, nil, 95, 90, nil, nil, 68, 71, - nil, nil, 100, 60, 103, 66, nil, nil, nil, 79, - 81, nil, nil, 88, nil, nil, nil, nil, 74, 99, - 95, nil, 84, nil, nil, 90, nil, nil, 68, 71, - nil, 66, 100, 60, 103, 79, 81, nil, nil, 88, - nil, nil, nil, nil, 74, 99, nil, nil, 84, nil, - 95, 90, nil, nil, 68, 71, nil, nil, 100, 60, - 103, 66, nil, nil, nil, 79, 81, nil, nil, 88, - 68, 71, nil, nil, 74, 99, 68, 71, 84, nil, - 100, 90, 103, nil, nil, nil, nil, 66, nil, 60, - nil, 79, 81, nil, nil, 88, nil, nil, 95, nil, - 74, 68, 71, 66, 84, 100, nil, 79, 253, 66, - nil, 88, nil, 79, 81, 60, 139, 88, nil, nil, - 84, nil, 74, 99, nil, nil, 84, 68, 71, 90, - nil, 60, nil, nil, 66, nil, nil, 60, 79, 144, - nil, nil, 88, nil, nil, nil, nil, 139, 68, 71, - nil, 84, 100, nil, 103, nil, nil, nil, nil, nil, - 66, nil, 60, nil, 79, 253, 68, 71, 88, nil, - 100, nil, 103, 139, nil, nil, nil, 84, nil, nil, - nil, 66, nil, nil, nil, 79, 81, nil, 60, 88, - nil, 68, 71, nil, 74, nil, nil, nil, 84, 66, - nil, nil, nil, 79, 81, nil, nil, 88, nil, 60, - nil, nil, 74, nil, 261, nil, 84, 68, 71, nil, - nil, 100, nil, 103, 66, nil, nil, 60, 79, 81, - nil, nil, 88, nil, nil, nil, 72, 74, 68, 71, - nil, 84, 100, nil, 103, nil, nil, nil, nil, nil, - 66, nil, 60, nil, 79, 81, nil, nil, 88, nil, - 95, nil, nil, 74, 68, 71, nil, 84, nil, nil, - nil, 66, nil, nil, nil, 79, 81, nil, 60, 88, - nil, nil, nil, nil, 74, 99, nil, 162, 84, 68, - 71, 90, nil, 100, nil, 103, nil, 66, nil, 60, - nil, 79, 81, nil, nil, 88, nil, nil, nil, 72, - 74, 95, nil, nil, 84, 68, 71, nil, nil, 100, - nil, 103, 66, nil, nil, 60, 79, 81, nil, nil, - 88, nil, nil, nil, nil, 74, 99, 95, nil, 84, - 68, 71, 90, nil, 100, nil, 103, nil, 66, nil, - 60, nil, 79, 81, 68, 71, 88, nil, nil, nil, - 255, 74, 99, nil, nil, 84, nil, nil, 90, nil, - nil, nil, nil, 66, nil, nil, 60, 79, 81, 68, - 71, 88, nil, 100, nil, 103, 74, 66, nil, nil, - 84, 79, 253, nil, nil, 88, nil, nil, 68, 71, - 139, 60, nil, nil, 84, nil, nil, nil, nil, nil, - nil, nil, 66, nil, nil, 60, 79, 81, nil, nil, - 88, 328, nil, 68, 71, 74, nil, nil, nil, 84, - nil, 66, nil, nil, nil, 79, 81, nil, nil, 88, - 60, 68, 71, 72, 74, 100, 193, 103, 84, nil, - nil, nil, nil, nil, nil, nil, 66, nil, nil, 60, - 79, 253, 68, 71, 88, nil, 100, nil, 103, 139, - nil, nil, nil, 84, 66, nil, nil, nil, 79, 81, - nil, nil, 88, nil, 60, nil, nil, 74, 68, 71, - nil, 84, 100, nil, 103, 66, nil, nil, nil, 79, - 81, nil, 60, 88, nil, nil, nil, nil, 74, nil, - 95, nil, 84, nil, 68, 71, nil, nil, 100, nil, - 103, 66, nil, 60, nil, 79, 81, nil, nil, 88, - nil, nil, nil, nil, 74, 99, 95, nil, 84, 68, - 71, 90, nil, 100, nil, 103, nil, 66, nil, 60, - nil, 79, 81, 68, 71, 88, nil, nil, nil, nil, - 74, 99, nil, nil, 84, nil, nil, 90, nil, nil, - nil, nil, 66, nil, nil, 60, 79, 81, nil, nil, - 88, nil, nil, nil, nil, 74, 66, nil, nil, 84, - 79, 81, nil, nil, 88, nil, nil, nil, 72, 74, - 60, 68, 71, 84, nil, 100, nil, 103, 189, 172, - 173, 174, 176, 178, 60, 183, 187, nil, 189, 172, - 173, 174, 175, 95, nil, 183, 187, 68, 71, nil, - nil, 100, 175, 103, 66, nil, nil, nil, 79, 81, - nil, nil, 88, nil, nil, nil, nil, 74, 99, 95, - nil, 84, nil, nil, 90, nil, nil, 68, 71, nil, - 66, 100, 60, 103, 79, 81, nil, nil, 88, nil, - nil, nil, nil, 74, 99, nil, nil, 84, nil, 95, - 90, nil, nil, 68, 71, nil, nil, 100, 60, 103, - 66, nil, nil, nil, 79, 81, nil, nil, 88, nil, - nil, nil, nil, 74, 99, 95, nil, 84, nil, nil, - 90, nil, nil, nil, nil, nil, 66, nil, 60, nil, - 79, 81, 188, nil, 88, nil, nil, nil, nil, 74, - 99, 181, 186, 84, nil, nil, 90, nil, nil, nil, - 177, 179, 182, 185, 60, nil, 181, 186, nil, nil, - nil, nil, nil, nil, nil, 177, 179, 182, 185, nil, - nil, nil, nil, nil, 180, 184, nil, nil, 189, 172, - 173, 174, 176, 178, nil, 183, 187, nil, nil, 180, - 184, nil, 175, 189, 172, 173, 174, 176, 178, nil, - 183, 187, 181, 186, nil, nil, nil, 175, nil, nil, - 283, 177, 179, 182, 185, nil, nil, 181, 186, nil, - nil, nil, nil, nil, nil, nil, 177, 179, 182, 185, - nil, nil, nil, nil, nil, 180, 184, nil, nil, 189, - 172, 173, 174, 176, 178, nil, 183, 187, nil, nil, - nil, 184, nil, 175, 189, 172, 173, 174, 176, 178, - nil, 183, 187, 181, 186, nil, nil, nil, 175, nil, - nil, nil, 177, 179, 182, 185, nil, nil, 181, 186, - nil, nil, nil, nil, nil, nil, nil, 177, 179, 182, - 185, nil, nil, nil, nil, nil, 180, 184, nil, nil, - 189, 172, 173, 174, 176, 178, nil, 183, 187, nil, - nil, 180, 184, nil, 175, 189, 172, 173, 174, 176, - 178, nil, 183, 187, 181, 186, nil, nil, nil, 175, - nil, nil, nil, 177, 179, 182, 185, nil, nil, 26, - 186, 32, 1, nil, 8, 11, nil, 18, 177, 23, - nil, 29, nil, 2, nil, nil, 10, 15, nil, 186, - nil, 189, 172, 173, 174, 176, 178, 177, 183, 187, - nil, nil, nil, nil, 186, 175, 189, 172, 173, 174, - 176, 178, 177, 183, 187, nil, nil, nil, nil, nil, - 175, nil, nil, nil, nil, 189, 172, 173, 174, 176, - 178, nil, 183, 187, 281, nil, nil, nil, nil, 175, - 189, 172, 173, 174, 176, 178, nil, 183, 187, nil, - nil, nil, nil, 377, 175, 26, nil, 32, 1, nil, - 8, 11, nil, 18, nil, 23, nil, 29, nil, 2, - nil, nil, 10, 15, 26, 364, 32, 1, nil, 8, - 11, nil, 18, nil, 23, nil, 29, nil, 2, nil, - nil, 10, 15, nil, 383, nil, 26, nil, 32, 1, - nil, 8, 11, nil, 18, nil, 23, nil, 29, nil, - 2, nil, nil, 10, 15, 26, 306, 32, 1, nil, - 8, 11, nil, 18, nil, 23, nil, 29, nil, 2, - nil, nil, 10, 15, nil, 381, nil, 26, nil, 32, - 1, nil, 8, 11, nil, 18, nil, 23, nil, 29, - nil, 2, nil, nil, 10, 15, 26, 326, 32, 1, - nil, 8, 11, nil, 18, nil, 23, nil, 29, nil, - 2, nil, nil, 10, 15, nil, nil, nil, 26, nil, - 32, 1, nil, 8, 11, nil, 18, nil, 23, nil, - 29, nil, 2, nil, nil, 10, 15, 26, nil, 32, - 1, nil, 8, 11, nil, 18, nil, 23, nil, 29, - nil, 2, nil, nil, 10, 15, 26, nil, 32, 1, - nil, 8, 11, nil, 18, nil, 23, nil, 29, nil, - 2, nil, nil, 10, 15, 189, 172, 173, 174, 176, - 178, nil, 183, 187, nil, nil, nil, nil, nil, 175 ] - -racc_action_check = [ - 164, 164, 18, 103, 103, 214, 56, 157, 81, 32, - 103, 286, 286, 164, 164, 136, 11, 27, 286, 27, - 11, 158, 164, 164, 164, 164, 81, 11, 300, 300, - 154, 56, 27, 214, 214, 300, 332, 332, 189, 189, - 18, 103, 189, 18, 189, 157, 164, 164, 157, 286, - 164, 164, 164, 164, 164, 164, 27, 164, 164, 158, - 189, 300, 158, 18, 164, 300, 300, 200, 157, 300, - 294, 189, 154, 212, 300, 189, 189, 213, 300, 189, - 369, 369, 158, 134, 189, 189, 186, 186, 189, 300, - 186, 189, 186, 203, 291, 294, 294, 133, 206, 189, - 111, 216, 144, 127, 203, 291, 206, 163, 186, 203, - 291, 111, 262, 369, 273, 144, 111, 369, 369, 186, - 163, 369, 273, 186, 186, 262, 369, 186, 357, 357, - 369, 221, 186, 186, 185, 185, 186, 302, 185, 186, - 185, 369, 264, 264, 221, 302, 218, 186, 219, 264, - 273, 273, 273, 273, 273, 273, 185, 273, 273, 1, - 220, 357, 197, 1, 273, 357, 357, 185, 122, 357, - 1, 185, 185, 122, 357, 185, 281, 224, 357, 281, - 185, 185, 176, 176, 185, 310, 176, 185, 176, 357, - 310, 282, 282, 121, 192, 185, 282, 282, 192, 192, - 114, 175, 175, 282, 176, 175, 46, 175, 336, 336, - 46, 114, 336, 227, 336, 176, 114, 46, 46, 176, - 176, 263, 263, 176, 265, 265, 263, 263, 176, 176, - 336, 265, 176, 263, 175, 176, 119, 335, 175, 175, - 335, 336, 175, 176, 229, 336, 336, 175, 230, 336, - 116, 175, 215, 215, 336, 336, 232, 8, 336, 330, - 330, 336, 175, 330, 115, 330, 8, 8, 194, 336, - 234, 194, 267, 267, 267, 267, 235, 184, 184, 267, - 267, 184, 113, 184, 225, 215, 267, 239, 225, 215, - 215, 225, 330, 215, 110, 225, 330, 330, 215, 184, - 330, 108, 215, 23, 23, 330, 250, 23, 253, 330, - 184, 107, 169, 215, 184, 184, 169, 169, 184, 106, - 330, 105, 102, 184, 184, 23, 140, 184, 26, 26, - 184, 42, 26, 141, 26, 42, 23, 101, 184, 96, - 23, 23, 42, 42, 23, 94, 89, 211, 23, 23, - 26, 211, 211, 23, 228, 228, 33, 87, 228, 85, - 33, 26, 83, 82, 23, 26, 26, 33, 33, 26, - 31, 31, 31, 31, 26, 26, 29, 29, 26, 201, - 29, 26, 29, 201, 201, 80, 77, 228, 75, 26, - 280, 228, 228, 142, 74, 228, 284, 308, 308, 69, - 228, 308, 66, 308, 228, 6, 6, 6, 6, 29, - 289, 65, 64, 29, 29, 228, 53, 29, 52, 307, - 307, 298, 29, 307, 50, 307, 29, 37, 305, 138, - 308, 187, 143, 17, 308, 308, 321, 29, 308, 325, - 174, 174, 13, 308, 174, 146, 174, 308, 3, 3, - 3, 3, 307, 147, 12, 338, 307, 307, 308, 343, - 307, 347, 174, 348, 350, 307, 179, 179, 351, 307, - 179, 352, 179, 174, 183, 358, 5, 174, 174, 368, - 307, 174, 4, 4, 4, 4, 174, 174, 179, 155, - 174, 370, 159, 174, 2, 380, 173, 173, 382, 179, - 173, 174, 173, 179, 179, nil, nil, 179, nil, nil, - nil, nil, 179, 179, nil, nil, 179, nil, 173, 179, - nil, nil, 45, 45, nil, nil, 45, 179, 45, 173, - nil, nil, nil, 173, 173, nil, nil, 173, nil, nil, - nil, nil, 173, 173, 45, nil, 173, nil, nil, 173, - nil, nil, 172, 172, nil, 45, 172, 173, 172, 45, - 45, nil, nil, 45, nil, nil, nil, nil, 45, 45, - nil, nil, 45, nil, 172, 45, nil, nil, 47, 47, - nil, nil, 47, 45, 47, 172, nil, nil, nil, 172, - 172, nil, nil, 172, nil, nil, nil, nil, 172, 172, - 47, nil, 172, nil, nil, 172, nil, nil, 48, 48, - nil, 47, 48, 172, 48, 47, 47, nil, nil, 47, - nil, nil, nil, nil, 47, 47, nil, nil, 47, nil, - 48, 47, nil, nil, 49, 49, nil, nil, 49, 47, - 49, 48, nil, nil, nil, 48, 48, nil, nil, 48, - 296, 296, nil, nil, 48, 48, 177, 177, 48, nil, - 177, 48, 177, nil, nil, nil, nil, 49, nil, 48, - nil, 49, 49, nil, nil, 49, nil, nil, 177, nil, - 49, 51, 51, 296, 49, 51, nil, 296, 296, 177, - nil, 296, nil, 177, 177, 49, 296, 177, nil, nil, - 296, nil, 177, 177, nil, nil, 177, 295, 295, 177, - nil, 296, nil, nil, 51, nil, nil, 177, 51, 51, - nil, nil, 51, nil, nil, nil, nil, 51, 231, 231, - nil, 51, 231, nil, 231, nil, nil, nil, nil, nil, - 295, nil, 51, nil, 295, 295, 233, 233, 295, nil, - 233, nil, 233, 295, nil, nil, nil, 295, nil, nil, - nil, 231, nil, nil, nil, 231, 231, nil, 295, 231, - nil, 170, 170, nil, 231, nil, nil, nil, 231, 233, - nil, nil, nil, 233, 233, nil, nil, 233, nil, 231, - nil, nil, 233, nil, 170, nil, 233, 288, 288, nil, - nil, 288, nil, 288, 170, nil, nil, 233, 170, 170, - nil, nil, 170, nil, nil, nil, 170, 170, 182, 182, - nil, 170, 182, nil, 182, nil, nil, nil, nil, nil, - 288, nil, 170, nil, 288, 288, nil, nil, 288, nil, - 182, nil, nil, 288, 70, 70, nil, 288, nil, nil, - nil, 182, nil, nil, nil, 182, 182, nil, 288, 182, - nil, nil, nil, nil, 182, 182, nil, 70, 182, 71, - 71, 182, nil, 71, nil, 71, nil, 70, nil, 182, - nil, 70, 70, nil, nil, 70, nil, nil, nil, 70, - 70, 71, nil, nil, 70, 180, 180, nil, nil, 180, - nil, 180, 71, nil, nil, 70, 71, 71, nil, nil, - 71, nil, nil, nil, nil, 71, 71, 180, nil, 71, - 112, 112, 71, nil, 112, nil, 112, nil, 180, nil, - 71, nil, 180, 180, 167, 167, 180, nil, nil, nil, - 167, 180, 180, nil, nil, 180, nil, nil, 180, nil, - nil, nil, nil, 112, nil, nil, 180, 112, 112, 78, - 78, 112, nil, 78, nil, 78, 112, 167, nil, nil, - 112, 167, 167, nil, nil, 167, nil, nil, 240, 240, - 167, 112, nil, nil, 167, nil, nil, nil, nil, nil, - nil, nil, 78, nil, nil, 167, 78, 78, nil, nil, - 78, 240, nil, 255, 255, 78, nil, nil, nil, 78, - nil, 240, nil, nil, nil, 240, 240, nil, nil, 240, - 78, 100, 100, 240, 240, 100, 100, 100, 240, nil, - nil, nil, nil, nil, nil, nil, 255, nil, nil, 240, - 255, 255, 260, 260, 255, nil, 260, nil, 260, 255, - nil, nil, nil, 255, 100, nil, nil, nil, 100, 100, - nil, nil, 100, nil, 255, nil, nil, 100, 181, 181, - nil, 100, 181, nil, 181, 260, nil, nil, nil, 260, - 260, nil, 100, 260, nil, nil, nil, nil, 260, nil, - 181, nil, 260, nil, 90, 90, nil, nil, 90, nil, - 90, 181, nil, 260, nil, 181, 181, nil, nil, 181, - nil, nil, nil, nil, 181, 181, 90, nil, 181, 161, - 161, 181, nil, 161, nil, 161, nil, 90, nil, 181, - nil, 90, 90, 166, 166, 90, nil, nil, nil, nil, - 90, 90, nil, nil, 90, nil, nil, 90, nil, nil, - nil, nil, 161, nil, nil, 90, 161, 161, nil, nil, - 161, nil, nil, nil, nil, 161, 166, nil, nil, 161, - 166, 166, nil, nil, 166, nil, nil, nil, 166, 166, - 161, 95, 95, 166, nil, 95, nil, 95, 277, 277, - 277, 277, 277, 277, 166, 277, 277, nil, 269, 269, - 269, 269, 277, 95, nil, 269, 269, 178, 178, nil, - nil, 178, 269, 178, 95, nil, nil, nil, 95, 95, - nil, nil, 95, nil, nil, nil, nil, 95, 95, 178, - nil, 95, nil, nil, 95, nil, nil, 99, 99, nil, - 178, 99, 95, 99, 178, 178, nil, nil, 178, nil, - nil, nil, nil, 178, 178, nil, nil, 178, nil, 99, - 178, nil, nil, 242, 242, nil, nil, 242, 178, 242, - 99, nil, nil, nil, 99, 99, nil, nil, 99, nil, - nil, nil, nil, 99, 99, 242, nil, 99, nil, nil, - 99, nil, nil, nil, nil, nil, 242, nil, 99, nil, - 242, 242, 91, nil, 242, nil, nil, nil, nil, 242, - 242, 91, 91, 242, nil, nil, 242, nil, nil, nil, - 91, 91, 91, 91, 242, nil, 129, 129, nil, nil, - nil, nil, nil, nil, nil, 129, 129, 129, 129, nil, - nil, nil, nil, nil, 91, 91, nil, nil, 91, 91, - 91, 91, 91, 91, nil, 91, 91, nil, nil, 129, - 129, nil, 91, 129, 129, 129, 129, 129, 129, nil, - 129, 129, 190, 190, nil, nil, nil, 129, nil, nil, - 190, 190, 190, 190, 190, nil, nil, 271, 271, nil, - nil, nil, nil, nil, nil, nil, 271, 271, 271, 271, - nil, nil, nil, nil, nil, 190, 190, nil, nil, 190, - 190, 190, 190, 190, 190, nil, 190, 190, nil, nil, - nil, 271, nil, 190, 271, 271, 271, 271, 271, 271, - nil, 271, 271, 131, 131, nil, nil, nil, 271, nil, - nil, nil, 131, 131, 131, 131, nil, nil, 132, 132, - nil, nil, nil, nil, nil, nil, nil, 132, 132, 132, - 132, nil, nil, nil, nil, nil, 131, 131, nil, nil, - 131, 131, 131, 131, 131, 131, nil, 131, 131, nil, - nil, 132, 132, nil, 131, 132, 132, 132, 132, 132, - 132, nil, 132, 132, 275, 275, nil, nil, nil, 132, - nil, nil, nil, 275, 275, 275, 275, nil, nil, 279, - 276, 279, 279, nil, 279, 279, nil, 279, 276, 279, - nil, 279, nil, 279, nil, nil, 279, 279, nil, 270, - nil, 275, 275, 275, 275, 275, 275, 270, 275, 275, - nil, nil, nil, nil, 272, 275, 276, 276, 276, 276, - 276, 276, 272, 276, 276, nil, nil, nil, nil, nil, - 276, nil, nil, nil, nil, 270, 270, 270, 270, 270, - 270, nil, 270, 270, 188, nil, nil, nil, nil, 270, - 272, 272, 272, 272, 272, 272, nil, 272, 272, nil, - nil, nil, nil, 363, 272, 188, nil, 188, 188, nil, - 188, 188, nil, 188, nil, 188, nil, 188, nil, 188, - nil, nil, 188, 188, 363, 312, 363, 363, nil, 363, - 363, nil, 363, nil, 363, nil, 363, nil, 363, nil, - nil, 363, 363, nil, 376, nil, 312, nil, 312, 312, - nil, 312, 312, nil, 312, nil, 312, nil, 312, nil, - 312, nil, nil, 312, 312, 376, 217, 376, 376, nil, - 376, 376, nil, 376, nil, 376, nil, 376, nil, 376, - nil, nil, 376, 376, nil, 373, nil, 217, nil, 217, - 217, nil, 217, 217, nil, 217, nil, 217, nil, 217, - nil, 217, nil, nil, 217, 217, 373, 238, 373, 373, - nil, 373, 373, nil, 373, nil, 373, nil, 373, nil, - 373, nil, nil, 373, 373, nil, nil, nil, 238, nil, - 238, 238, nil, 238, 238, nil, 238, nil, 238, nil, - 238, nil, 238, nil, nil, 238, 238, 20, nil, 20, - 20, nil, 20, 20, nil, 20, nil, 20, nil, 20, - nil, 20, nil, nil, 20, 20, 0, nil, 0, 0, - nil, 0, 0, nil, 0, nil, 0, nil, 0, nil, - 0, nil, nil, 0, 0, 268, 268, 268, 268, 268, - 268, nil, 268, 268, nil, nil, nil, nil, nil, 268 ] +clist = [ +'222,221,209,61,62,249,204,209,127,323,192,317,322,184,179,109,214,251', +'301,330,126,106,180,182,181,183,126,329,184,179,302,206,245,244,335', +'245,244,180,182,181,183,195,126,210,106,186,185,334,85,173,174,176,175', +'177,178,275,171,172,276,105,186,185,107,170,173,174,176,175,177,178', +'308,171,172,61,62,157,81,94,170,95,80,71,105,61,62,107,162,94,77,95', +'73,161,309,61,62,93,157,94,81,95,-106,-157,114,76,71,93,70,162,288,34', +'63,59,161,287,68,93,70,311,60,92,63,59,58,151,68,91,70,75,60,92,63,59', +'58,71,68,91,157,151,60,92,61,62,58,71,94,91,95,162,314,288,61,62,161', +'71,287,-106,-106,-106,-106,248,61,62,93,157,94,81,95,247,81,80,106,208', +'80,70,162,341,34,63,59,161,81,68,93,70,80,60,92,63,225,58,151,68,91', +'70,132,138,77,63,59,58,71,68,-170,61,62,60,92,64,105,58,71,107,91,61', +'62,61,62,94,323,95,71,322,324,61,62,44,152,94,242,95,71,245,244,61,62', +'93,70,94,81,95,63,59,114,320,68,93,70,299,60,34,63,59,58,195,68,93,70', +'73,60,92,63,59,58,71,68,91,70,198,60,92,63,59,58,71,68,91,61,62,60,92', +'214,212,58,71,117,91,61,62,295,85,94,201,95,71,211,201,61,62,83,84,94', +'292,95,291,171,172,61,62,93,70,94,170,95,63,225,171,172,68,93,70,-156', +'138,170,63,59,58,-154,68,93,70,125,60,92,63,59,58,71,68,91,70,-153,60', +'92,63,59,58,71,68,91,214,346,60,92,61,62,58,71,94,91,95,-155,-151,-150', +'61,62,-152,71,94,124,95,283,117,333,61,62,93,274,94,97,95,214,224,336', +'61,62,93,70,94,250,337,63,59,214,251,68,93,70,338,60,92,63,59,58,127', +'68,91,70,277,60,92,63,59,58,71,68,91,70,208,60,92,63,59,58,71,68,91', +'305,236,60,238,61,62,58,71,94,239,95,238,349,-152,61,62,97,71,94,-150', +'95,86,352,-151,61,62,93,223,94,303,95,214,224,214,251,353,93,70,82,355', +'-153,63,59,125,72,68,93,70,43,60,92,63,59,58,361,68,91,70,362,60,92', +'63,59,58,71,68,91,238,-204,60,92,61,62,58,71,94,91,95,38,39,40,41,209', +'117,71,176,175,71,61,62,171,172,94,93,95,71,35,170,38,39,40,41,369,370', +'70,,61,62,63,59,93,122,68,327,,,60,92,,,58,70,,91,,63,59,,,68,,71,,60', +'92,61,62,58,,70,91,228,,63,225,,,68,71,,,138,61,62,,58,94,,95,176,175', +',,,171,172,71,,70,,,170,63,225,93,,68,61,62,,138,94,,95,58,70,,,,63', +'59,,,68,,71,,60,92,93,,58,61,62,91,,94,,95,,70,,71,,63,59,,,68,,,,60', +'92,93,218,58,61,62,91,,94,,95,,70,,71,,63,59,,,68,,,,60,92,93,,58,61', +'62,91,,94,,95,,70,,71,,63,59,,,68,,,,60,92,93,,58,61,62,91,,94,,,,70', +',71,,63,59,,,68,,,,60,92,,,58,61,62,91,,94,,95,,70,,71,,63,59,,,68,61', +'62,,60,,93,,58,,61,62,,,94,,95,70,,71,,63,59,,,68,,,,60,92,,93,58,70', +',91,,63,225,,,68,70,71,,138,63,59,,58,68,,61,62,60,92,94,,58,,71,91', +'61,62,,,94,,95,71,,,61,62,,,94,131,95,,,,61,62,93,70,94,,95,63,225,', +',68,93,70,,138,,63,59,58,,68,93,70,,60,92,63,59,58,71,68,91,70,,60,92', +'63,59,58,71,68,91,61,62,60,92,,,58,71,,91,61,62,,,94,,,71,,,61,62,,', +'94,,95,,,,61,62,,70,94,,95,63,225,,,68,93,70,,138,,63,137,58,,68,93', +'70,,138,,63,59,58,71,68,,70,,60,92,63,59,58,71,68,91,252,,60,92,,,58', +'71,,91,184,179,-24,-24,-24,-24,,71,,180,182,181,183,,,173,174,176,175', +',61,62,171,172,94,131,95,,,170,,,186,185,,,173,174,176,175,177,178,93', +'171,172,61,62,,,94,170,95,,70,,,,63,59,,,68,,,,60,92,93,,58,61,62,91', +',94,,95,,70,,71,,63,59,,,68,,,,60,92,93,,58,61,62,91,,94,,95,,70,,71', +',63,59,,,68,,,,60,92,93,,58,61,62,91,,94,,95,,70,,71,,63,59,,,68,,,', +'60,92,93,,58,61,62,91,,94,,95,,70,,71,,63,59,,,68,,,,60,92,93,,58,61', +'62,91,,94,,95,,70,,71,,63,59,,,68,,,,60,92,93,,58,61,62,91,,94,,95,', +'70,,71,,63,59,,,68,,,,60,92,93,,58,61,62,91,,94,,95,,70,,71,,63,59,', +',68,,,,60,92,93,,58,61,62,91,,94,,95,,70,,71,,63,59,,,68,,,,60,92,93', +',58,61,62,91,,94,,95,,70,,71,,63,59,,,68,,,,60,92,93,,58,,,91,-22,-22', +'-22,-22,,70,,71,,63,59,,,68,,,169,60,92,,,58,,,91,184,179,,,,,197,71', +',180,182,181,183,,,184,179,,,,,,,,180,182,181,183,,,,,186,185,,,173', +'174,176,175,177,178,,171,172,,,186,185,,170,173,174,176,175,177,178', +',171,172,184,179,,,,170,,,,180,182,181,183,,,184,179,,,,,,,,180,182', +'181,183,,,,,186,185,,,173,174,176,175,177,178,,171,172,,,186,185,,170', +'173,174,176,175,177,178,,171,172,184,179,,,,170,,,,180,182,181,183,', +',184,179,,,,,,,,180,182,181,183,,,,,186,185,,,173,174,176,175,177,178', +',171,172,,,186,185,,170,173,174,176,175,177,178,,171,172,184,179,,,', +'170,,,273,180,182,181,183,,,184,179,,,,,,,,180,182,181,183,,,,,186,185', +',,173,174,176,175,177,178,,171,172,,,186,185,,170,173,174,176,175,177', +'178,,171,172,184,179,,,,170,,,,180,182,181,183,,,184,179,,,,,,,,180', +'182,181,183,,,,,186,185,,,173,174,176,175,177,178,,171,172,,,186,185', +',170,173,174,176,175,177,178,,171,172,184,179,,,,170,,,,180,182,181', +'183,,,184,179,,,,,,,,180,182,181,183,,,,,186,185,,,173,174,176,175,177', +'178,,171,172,,,,,,170,173,174,176,175,177,178,,171,172,184,179,,,,170', +',,,180,182,181,183,,,184,179,,,,,,,,180,182,181,183,,,,,,,,,173,174', +'176,175,177,178,,171,172,,,186,185,,170,173,174,176,175,177,178,,171', +'172,184,179,,,,170,,,,180,182,181,183,,,184,179,,,,,,,,180,182,181,183', +',,,,,,,,173,174,176,175,177,178,,171,172,,,,185,,170,173,174,176,175', +'177,178,,171,172,184,179,,,,170,,,,180,182,181,183,,,,179,,,,,,,,180', +',,,,,,,186,185,179,,173,174,176,175,177,178,180,171,172,,,,,179,170', +'173,174,176,175,177,178,180,171,172,,,,,,170,,179,,173,174,176,175,177', +'178,180,171,172,,,,,,170,173,174,176,175,177,178,,171,172,,332,,,,170', +',,,173,174,176,175,177,178,,171,172,,360,,,28,170,30,31,,26,32,,33,', +'21,,29,368,25,,,34,28,,30,31,,26,32,,33,,21,367,29,,25,,28,34,30,31', +',26,32,,33,,21,343,29,,25,,28,34,30,31,,26,32,,33,,21,255,29,,25,,28', +'34,30,31,,26,32,,33,,21,365,29,,25,,28,34,30,31,,26,32,,33,,21,,29,', +'25,,28,34,30,31,,26,32,,33,,21,,29,28,25,30,31,34,26,32,,33,,21,,29', +'28,25,30,31,34,26,32,,33,,21,,29,28,25,30,31,34,26,32,,33,,21,,29,,25', +',,34,173,174,176,175,177,178,,171,172,,,,,,170,173,174,176,175,177,178', +',171,172,173,174,176,175,,170,,171,172,,,,,,170' ] + racc_action_table = arr = Array.new(2065, 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 = [ +'129,129,117,95,95,163,102,137,59,255,95,246,255,129,129,35,217,217,216', +'280,137,33,129,129,129,129,59,280,216,216,217,102,163,163,285,246,246', +'216,216,216,216,95,225,117,204,129,129,285,70,129,129,129,129,129,129', +'191,129,129,191,33,216,216,33,129,216,216,216,216,216,216,229,216,216', +'170,170,243,31,170,216,170,31,33,204,173,173,204,243,173,23,173,23,243', +'235,174,174,170,157,174,37,174,223,67,37,23,204,173,170,157,201,37,170', +'170,157,201,170,174,173,237,170,170,173,173,170,238,173,170,174,23,173', +'173,174,174,173,170,174,173,75,239,174,174,175,175,174,173,175,174,175', +'75,240,335,345,345,75,174,335,223,223,223,223,158,176,176,175,76,176', +'24,176,158,291,24,206,241,291,175,76,291,24,175,175,76,32,175,176,345', +'32,175,175,345,345,175,73,345,175,176,66,345,65,176,176,345,175,176', +'60,21,21,176,176,21,206,176,345,206,176,337,337,276,276,337,320,337', +'176,320,276,177,177,21,74,177,153,177,206,153,153,336,336,337,21,336', +'42,336,21,21,42,254,21,177,337,212,21,42,337,337,21,276,337,336,177', +'78,337,337,177,177,337,21,177,337,336,99,177,177,336,336,177,337,336', +'177,330,330,336,336,121,121,336,177,208,336,178,178,207,26,178,100,178', +'336,121,101,322,322,26,26,322,203,322,202,261,261,28,28,178,330,28,261', +'28,330,330,262,262,330,322,178,57,330,262,178,178,330,56,178,28,322', +'54,178,178,322,322,178,330,322,178,28,52,322,322,28,28,322,178,28,322', +'306,306,28,28,29,29,28,322,29,28,29,50,49,48,179,179,47,28,179,45,179', +'199,43,284,180,180,29,190,180,198,180,190,190,287,308,308,179,29,308', +'164,288,29,29,164,164,29,180,179,289,29,29,179,179,29,114,179,29,180', +'194,179,179,180,180,179,29,180,179,308,116,180,180,308,308,180,179,308', +'180,224,133,308,134,181,181,308,180,181,135,181,313,315,139,182,182', +'30,308,182,140,182,27,323,141,183,183,181,130,183,219,183,130,130,219', +'219,329,182,181,25,331,143,181,181,145,22,181,183,182,20,181,181,182', +'182,181,342,182,181,183,344,182,182,183,183,182,181,183,182,150,346', +'183,183,184,184,183,182,184,183,184,19,19,19,19,151,152,183,260,260', +'172,44,44,260,260,44,184,44,171,1,260,18,18,18,18,364,366,184,,278,278', +'184,184,44,44,184,278,,,184,184,,,184,44,,184,,44,44,,,44,,184,,44,44', +'132,132,44,,278,44,132,,278,278,,,278,44,,,278,277,277,,278,277,,277', +'259,259,,,,259,259,278,,132,,,259,132,132,277,,132,185,185,,132,185', +',185,132,277,,,,277,277,,,277,,132,,277,277,185,,277,126,126,277,,126', +',126,,185,,277,,185,185,,,185,,,,185,185,126,126,185,127,127,185,,127', +',127,,126,,185,,126,126,,,126,,,,126,126,127,,126,125,125,126,,125,', +'125,,127,,126,,127,127,,,127,,,,127,127,125,,127,124,124,127,,124,,', +',125,,127,,125,125,,,125,,,,125,125,,,125,186,186,125,,186,,186,,124', +',125,,124,124,,,124,197,197,,124,,186,,124,,248,248,,,248,,248,186,', +'124,,186,186,,,186,,,,186,186,,248,186,197,,186,,197,197,,,197,248,186', +',197,248,248,,197,248,,236,236,248,248,236,,248,,197,248,62,62,,,62', +',62,248,,,64,64,,,64,64,64,,,,247,247,62,236,247,,247,236,236,,,236', +'64,62,,236,,62,62,236,,62,247,64,,62,62,64,64,62,236,64,62,247,,64,64', +'247,247,64,62,247,64,228,228,247,247,,,247,64,,247,72,72,,,72,,,247', +',,209,209,,,209,,209,,,,222,222,,228,222,,222,228,228,,,228,209,72,', +'228,,72,72,228,,72,222,209,,72,,209,209,72,228,209,,222,,209,209,222', +'222,209,72,222,209,167,,222,222,,,222,209,,222,167,167,7,7,7,7,,222', +',167,167,167,167,,,263,263,263,263,,94,94,263,263,94,94,94,,,263,,,167', +'167,,,167,167,167,167,167,167,94,167,167,77,77,,,77,167,77,,94,,,,94', +'94,,,94,,,,94,94,77,,94,210,210,94,,210,,210,,77,,94,,77,77,,,77,,,', +'77,77,210,,77,83,83,77,,83,,83,,210,,77,,210,210,,,210,,,,210,210,83', +',210,84,84,210,,84,,84,,83,,210,,83,83,,,83,,,,83,83,84,,83,85,85,83', +',85,,85,,84,,83,,84,84,,,84,,,,84,84,85,,84,86,86,84,,86,,86,,85,,84', +',85,85,,,85,,,,85,85,86,,85,91,91,85,,91,,91,,86,,85,,86,86,,,86,,,', +'86,86,91,,86,92,92,86,,92,,92,,91,,86,,91,91,,,91,,,,91,91,92,,91,93', +'93,91,,93,,93,,92,,91,,92,92,,,92,,,,92,92,93,,92,213,213,92,,213,,213', +',93,,92,,93,93,,,93,,,,93,93,213,,93,,,93,5,5,5,5,,213,,93,,213,213', +',,213,,,88,213,213,,,213,,,213,88,88,,,,,96,213,,88,88,88,88,,,96,96', +',,,,,,,96,96,96,96,,,,,88,88,,,88,88,88,88,88,88,,88,88,,,96,96,,88', +'96,96,96,96,96,96,,96,96,300,300,,,,96,,,,300,300,300,300,,,166,166', +',,,,,,,166,166,166,166,,,,,300,300,,,300,300,300,300,300,300,,300,300', +',,166,166,,300,166,166,166,166,166,166,,166,166,165,165,,,,166,,,,165', +'165,165,165,,,168,168,,,,,,,,168,168,168,168,,,,,165,165,,,165,165,165', +'165,165,165,,165,165,,,168,168,,165,168,168,168,168,168,168,,168,168', +'189,189,,,,168,,,189,189,189,189,189,,,358,358,,,,,,,,358,358,358,358', +',,,,189,189,,,189,189,189,189,189,189,,189,189,,,358,358,,189,358,358', +'358,358,358,358,,358,358,357,357,,,,358,,,,357,357,357,357,,,123,123', +',,,,,,,123,123,123,123,,,,,357,357,,,357,357,357,357,357,357,,357,357', +',,123,123,,357,123,123,123,123,123,123,,123,123,326,326,,,,123,,,,326', +'326,326,326,,,319,319,,,,,,,,319,319,319,319,,,,,326,326,,,326,326,326', +'326,326,326,,326,326,,,,,,326,319,319,319,319,319,319,,319,319,318,318', +',,,319,,,,318,318,318,318,,,298,298,,,,,,,,298,298,298,298,,,,,,,,,318', +'318,318,318,318,318,,318,318,,,298,298,,318,298,298,298,298,298,298', +',298,298,271,271,,,,298,,,,271,271,271,271,,,272,272,,,,,,,,272,272', +'272,272,,,,,,,,,271,271,271,271,271,271,,271,271,,,,272,,271,272,272', +'272,272,272,272,,272,272,297,297,,,,272,,,,297,297,297,297,,,,269,,', +',,,,,269,,,,,,,,297,297,268,,297,297,297,297,297,297,268,297,297,,,', +',267,297,269,269,269,269,269,269,267,269,269,,,,,,269,,270,,268,268', +'268,268,268,268,270,268,268,,,,,,268,267,267,267,267,267,267,,267,267', +',283,,,,267,,,,270,270,270,270,270,270,,270,270,,338,,,283,270,283,283', +',283,283,,283,,283,,283,359,283,,,283,338,,338,338,,338,338,,338,,338', +'353,338,,338,,359,338,359,359,,359,359,,359,,359,292,359,,359,,353,359', +'353,353,,353,353,,353,,353,169,353,,353,,292,353,292,292,,292,292,,292', +',292,352,292,,292,,169,292,169,169,,169,169,,169,,169,,169,,169,,352', +'169,352,352,,352,352,,352,,352,,352,0,352,0,0,352,0,0,,0,,0,,0,253,0', +'253,253,0,253,253,,253,,253,,253,2,253,2,2,253,2,2,,2,,2,,2,,2,,,2,266', +'266,266,266,266,266,,266,266,,,,,,266,265,265,265,265,265,265,,265,265', +'264,264,264,264,,265,,264,264,,,,,,264' ] + racc_action_check = arr = Array.new(2065, 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 = [ - 1726, 123, 450, 384, 418, 461, 341, nil, 251, nil, - nil, -20, 446, 434, nil, nil, nil, 433, 0, nil, - 1707, nil, nil, 301, nil, nil, 326, 11, nil, 374, - nil, 306, 7, 320, nil, nil, nil, 403, nil, nil, - nil, nil, 295, nil, nil, 520, 170, 576, 606, 632, - 400, 679, 378, 416, nil, nil, -6, nil, nil, nil, - nil, nil, nil, nil, 389, 388, 396, nil, nil, 393, - 842, 867, nil, nil, 388, 376, nil, 363, 957, nil, - 362, 2, 340, 356, nil, 336, nil, 334, nil, 323, - 1092, 1294, nil, nil, 322, 1179, 333, nil, nil, 1235, - 1019, 314, 299, 1, nil, 298, 296, 288, 278, nil, - 286, 76, 918, 242, 176, 256, 238, nil, nil, 228, - nil, 185, 133, nil, nil, nil, nil, 97, nil, 1309, - nil, 1416, 1431, 90, 46, nil, -8, nil, 423, nil, - 285, 310, 381, 409, 91, nil, 422, 433, nil, nil, - nil, nil, nil, nil, 19, 477, nil, 5, 19, 484, - nil, 1117, nil, 95, -4, nil, 1131, 932, nil, 305, - 769, nil, 550, 494, 438, 199, 180, 654, 1205, 464, - 893, 1066, 816, 411, 275, 132, 84, 368, 1565, 36, - 1355, nil, 187, nil, 259, nil, nil, 151, nil, nil, - 27, 333, nil, 69, nil, nil, 80, nil, nil, nil, - nil, 340, 61, 66, -17, 250, 99, 1647, 131, 133, - 135, 119, nil, nil, 169, 248, nil, 204, 352, 204, - 239, 726, 216, 744, 230, 267, nil, nil, 1688, 280, - 976, nil, 1261, nil, nil, nil, nil, nil, nil, nil, - 295, nil, nil, 284, nil, 1001, nil, nil, nil, nil, - 1040, nil, 100, 165, 81, 163, nil, 218, 1721, 1144, - 1511, 1370, 1526, 96, nil, 1477, 1492, 1134, nil, 1479, - 381, 145, 135, nil, 389, nil, 9, nil, 795, 398, - nil, 70, nil, nil, 45, 705, 648, nil, 412, nil, - 26, nil, 125, nil, nil, 419, nil, 417, 395, nil, - 150, nil, 1606, nil, nil, nil, nil, nil, nil, nil, - nil, 424, nil, nil, nil, 430, nil, nil, nil, nil, - 257, nil, 25, nil, nil, 206, 206, nil, 447, nil, - nil, nil, nil, 450, nil, nil, nil, 438, 440, nil, - 441, 445, 448, nil, nil, nil, nil, 126, 467, nil, - nil, nil, nil, 1584, nil, nil, nil, nil, 470, 78, - 482, nil, nil, 1666, nil, nil, 1625, nil, nil, nil, - 486, nil, 489, nil, nil, nil ] + 1952, 522, 1978, nil, nil, 1188, nil, 892, nil, nil, + nil, nil, nil, nil, nil, nil, nil, nil, 461, 441, + 466, 201, 462, 82, 129, 420, 283, 432, 304, 351, + 440, 40, 144, 19, nil, 15, nil, 62, nil, nil, + nil, nil, 202, 331, 512, 356, nil, 342, 339, 338, + 337, nil, 317, nil, 324, nil, 303, 297, nil, 2, + 196, nil, 805, nil, 815, 190, 171, 78, nil, nil, + 42, nil, 878, 150, 218, 112, 139, 996, 249, nil, + nil, nil, nil, 1046, 1071, 1096, 1121, nil, 1259, nil, + nil, 1146, 1171, 1196, 971, 1, 1274, nil, nil, 255, + 267, 271, -6, nil, nil, nil, nil, nil, nil, nil, + nil, nil, nil, nil, 397, nil, 405, -9, nil, nil, + nil, 269, nil, 1514, 701, 676, 626, 651, nil, -4, + 446, nil, 559, 386, 417, 415, nil, -4, nil, 416, + 422, 426, nil, 443, nil, 463, nil, nil, nil, nil, + 481, 497, 469, 182, nil, nil, nil, 72, 141, nil, + nil, nil, nil, -17, 381, 1379, 1334, 936, 1394, 1923, + 71, 459, 451, 81, 91, 138, 158, 221, 284, 361, + 371, 428, 438, 448, 495, 601, 726, nil, nil, 1439, + 369, 46, nil, nil, 396, nil, nil, 743, 376, 362, + nil, 73, 266, 293, 42, nil, 168, 279, 244, 888, + 1021, nil, 222, 1221, nil, nil, 11, 5, nil, 448, + nil, nil, 898, 92, 419, 18, nil, nil, 868, 59, + nil, nil, nil, nil, nil, 83, 795, 108, 83, 97, + 139, 159, nil, 51, nil, nil, -14, 825, 752, nil, + nil, nil, nil, 1965, 234, -22, nil, nil, nil, 530, + 456, 244, 255, 915, 1997, 1988, 1973, 1787, 1772, 1754, + 1805, 1679, 1694, nil, nil, nil, 213, 576, 530, nil, + 7, nil, nil, 1841, 347, 22, nil, 367, 374, 389, + nil, 132, 1907, nil, nil, nil, nil, 1739, 1634, nil, + 1319, nil, nil, nil, nil, nil, 338, nil, 381, nil, + nil, nil, nil, 425, nil, 429, nil, nil, 1619, 1574, + 187, nil, 294, 440, nil, nil, 1559, nil, nil, 453, + 274, 456, nil, nil, nil, 114, 231, 211, 1859, nil, + nil, nil, 471, nil, 475, 148, 485, nil, nil, nil, + nil, nil, 1939, 1891, nil, nil, nil, 1499, 1454, 1875, + nil, nil, nil, nil, 519, nil, 520, nil, nil, nil, + nil ] racc_action_default = [ - -198, -235, -51, -19, -8, -235, -235, -9, -235, -10, - -189, -190, -235, -23, -11, -187, -12, -235, -235, -13, - -1, -14, -2, -188, -15, -3, -235, -235, -16, -235, - -17, -6, -235, -235, -18, -7, -190, -198, -188, -52, - -27, -28, -235, -25, -26, -235, -235, -235, -235, -235, - -198, -86, -93, -235, -197, -195, -198, -191, -193, -194, - -223, -196, -4, -42, -233, -43, -215, -176, -118, -44, - -235, -235, -45, -34, -75, -32, -33, -235, -235, -123, - -37, -74, -38, -235, -73, -39, -173, -40, -175, -41, - -235, -235, -126, -108, -104, -235, -112, -133, -113, -235, - -235, -105, -109, -235, -111, -106, -115, -107, -114, -110, - -54, -198, -235, -86, -198, -235, -180, -177, -178, -235, - -50, -235, -199, -200, -24, -21, -23, -188, -22, -84, - -20, -83, -85, -235, -198, -79, -76, -87, -82, -75, - -71, -77, -221, -80, -74, -69, -78, -235, -172, -171, - -81, -91, -92, -94, -235, -221, 386, -235, -235, -235, - -209, -235, -31, -235, -235, -119, -235, -235, -96, -235, - -235, -143, -235, -235, -235, -235, -235, -235, -235, -235, - -235, -235, -235, -235, -235, -235, -235, -235, -235, -235, - -235, -150, -235, -218, -235, -231, -227, -235, -230, -226, - -93, -235, -215, -198, -58, -60, -235, -67, -57, -74, - -66, -235, -221, -235, -235, -235, -235, -235, -208, -206, - -235, -235, -203, -232, -235, -235, -211, -235, -72, -222, - -235, -235, -86, -235, -222, -235, -192, -210, -235, -235, - -235, -29, -235, -121, -120, -36, -35, -174, -169, -167, - -235, -170, -161, -74, -168, -235, -162, -219, -220, -124, - -235, -117, -235, -138, -140, -139, -134, -141, -145, -142, - -147, -152, -149, -146, -135, -151, -148, -144, -136, -5, - -235, -129, -137, -153, -220, -216, -235, -224, -235, -221, - -55, -235, -63, -62, -235, -235, -235, -125, -235, -56, - -235, -155, -235, -159, -179, -235, -182, -235, -235, -201, - -235, -202, -235, -213, -214, -212, -46, -70, -88, -47, - -89, -221, -90, -95, -49, -235, -186, -234, -30, -122, - -235, -164, -221, -97, -116, -129, -235, -128, -235, -217, - -228, -225, -229, -235, -59, -61, -102, -98, -99, -64, - -103, -100, -101, -65, -48, -156, -154, -235, -235, -181, - -207, -205, -204, -235, -184, -68, -185, -166, -220, -235, - -235, -127, -130, -235, -53, -160, -235, -183, -165, -163, - -235, -132, -235, -158, -131, -157 ] + -180, -217, -1, -2, -3, -6, -7, -8, -9, -10, + -11, -12, -13, -14, -15, -16, -17, -18, -19, -217, + -23, -171, -217, -217, -217, -53, -217, -217, -217, -217, + -217, -217, -172, -217, -170, -217, -4, -217, -25, -26, + -27, -28, -217, -95, -217, -32, -33, -37, -38, -39, + -40, -41, -42, -43, -44, -45, -46, -47, -75, -76, + -77, -100, -217, -105, -217, -217, -217, -215, -158, -159, + -197, -205, -88, -88, -56, -180, -180, -217, -217, -52, + -171, -172, -54, -217, -217, -217, -217, -108, -217, -115, + -116, -217, -217, -217, -217, -217, -217, -160, -161, -163, + -180, -180, -180, -173, -175, -176, -177, -178, -179, 371, + -21, -22, -23, -24, -171, -20, -203, -217, -93, -94, + -96, -217, -31, -35, -217, -217, -217, -217, -101, -217, + -217, -200, -217, -73, -203, -217, -71, -76, -77, -78, + -79, -80, -81, -82, -83, -84, -89, -154, -155, -156, + -203, -217, -95, -217, -59, -60, -62, -180, -217, -68, + -69, -76, -197, -217, -217, -85, -87, -217, -86, -217, + -217, -217, -217, -217, -217, -217, -217, -217, -217, -217, + -217, -217, -217, -217, -217, -217, -217, -126, -133, -217, + -217, -217, -208, -209, -217, -212, -213, -217, -217, -217, + -182, -181, -180, -217, -217, -191, -217, -217, -204, -217, + -217, -29, -202, -217, -201, -34, -217, -217, -99, -217, + -102, -103, -217, -198, -202, -76, -144, -145, -217, -217, + -150, -151, -152, -153, -157, -217, -74, -217, -204, -88, + -217, -203, -57, -217, -64, -65, -217, -217, -217, -58, + -107, -202, -214, -5, -217, -111, -117, -118, -119, -120, + -121, -122, -123, -124, -125, -127, -128, -129, -130, -131, + -132, -134, -135, -136, -198, -206, -217, -217, -217, -138, + -217, -142, -162, -217, -217, -217, -185, -188, -190, -217, + -193, -217, -217, -174, -192, -51, -97, -91, -92, -30, + -36, -216, -98, -106, -104, -199, -203, -147, -217, -48, + -72, -49, -90, -203, -50, -217, -61, -63, -66, -67, + -111, -110, -217, -217, -207, -210, -211, -137, -139, -217, + -217, -217, -165, -183, -184, -217, -217, -217, -217, -194, + -195, -196, -217, -169, -217, -217, -202, -149, -70, -55, + -109, -112, -217, -217, -143, -164, -186, -187, -189, -217, + -167, -168, -146, -148, -217, -114, -217, -141, -166, -113, + -140 ] racc_goto_table = [ - 27, 13, 20, 222, 89, 92, 115, 37, 62, 5, - 65, 196, 256, 145, 230, 150, 118, 50, 155, 301, - 27, 13, 246, 75, 73, 57, 133, 235, 201, 5, - 250, 214, 149, 119, 337, 165, 121, 344, 136, 69, - 169, 120, 27, 126, 142, 22, 27, 126, 300, 134, - 128, 89, 63, 151, 128, 168, 125, 65, 280, 124, - 130, 42, 192, 124, 46, 349, 353, 138, 244, 87, - 163, 73, 252, 369, 211, 332, 323, 168, 303, 116, - 135, 140, 123, 224, 298, 56, 69, 305, 371, 168, - 195, 159, 227, 237, 220, 123, 246, 148, 221, 63, - 331, 160, 110, 315, 355, 194, 212, 17, 325, nil, - nil, 86, nil, nil, nil, nil, 87, nil, 250, nil, - 294, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, 239, 86, - nil, nil, nil, nil, nil, nil, nil, 89, 149, nil, - nil, 89, 266, 65, 248, nil, nil, 65, 86, nil, - nil, 343, nil, 303, 236, nil, 289, 245, nil, nil, - 262, 73, nil, nil, nil, 82, 247, nil, nil, 226, - nil, nil, 69, nil, nil, nil, 69, nil, 27, 13, - 317, 362, 150, 365, 340, 63, 149, 5, nil, 63, - 304, 151, 248, 143, 370, 85, 329, nil, 320, 149, - 322, nil, 87, 148, 378, 136, 87, 27, 13, nil, - 375, 89, 82, nil, 247, 321, 5, 65, nil, 54, - 318, 313, 250, 146, nil, 151, 149, 333, 27, 13, - nil, 245, 248, 380, 138, nil, 382, 5, nil, nil, - nil, nil, 85, nil, 86, 86, 69, 135, 86, nil, - nil, 148, nil, 210, 247, 342, 210, 62, nil, 63, - 80, nil, nil, 195, 148, nil, 149, 149, nil, 27, - 13, 149, 347, 347, 360, 361, 87, 248, 5, nil, - nil, nil, nil, nil, nil, nil, nil, nil, 141, nil, - nil, 148, nil, 86, 247, 247, nil, 367, nil, 247, - nil, nil, 27, 13, 363, 372, 86, 80, 82, 251, - nil, 5, 82, nil, 346, 346, nil, nil, 86, nil, - nil, nil, nil, nil, nil, nil, nil, nil, 149, nil, - nil, 352, 352, 86, 248, nil, 148, nil, 85, 254, - 149, 62, 85, nil, nil, 210, 248, nil, 207, nil, - nil, 207, nil, 27, 13, nil, 247, 251, 54, 54, - nil, nil, 5, 27, 13, nil, 27, 13, 247, nil, - 143, nil, 5, 86, 86, 5, nil, nil, 86, nil, - nil, nil, 82, nil, 274, nil, nil, 254, 278, nil, - nil, nil, nil, 148, nil, nil, nil, 251, nil, nil, - 146, nil, nil, 80, 249, 148, nil, 80, nil, nil, - nil, nil, 85, nil, nil, nil, nil, nil, nil, 129, - nil, 131, 132, nil, nil, nil, nil, 254, nil, nil, - nil, nil, nil, 210, nil, 86, nil, 350, 350, nil, - 207, nil, 251, nil, nil, 164, nil, 86, nil, nil, - nil, nil, 249, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, 171, 141, nil, 351, 351, 190, - nil, nil, 254, 191, nil, nil, nil, 80, nil, nil, + 23, 36, 23, 27, 2, 27, 46, 87, 20, 193, + 20, 139, 149, 103, 148, 140, 108, 98, 160, 160, + 100, 101, 227, 286, 78, 3, 279, 229, 145, 146, + 146, 128, 134, 150, 196, 116, 207, 23, 321, 110, + 153, 163, 23, 113, 115, 112, 121, 133, 113, 79, + 112, 278, 136, 220, 237, 235, 88, 96, 37, 42, + 254, 226, 111, 296, 142, 144, 130, 111, 199, 202, + 240, 232, 149, 306, 148, 230, 345, 99, 316, 164, + 289, 102, 203, 74, 294, 284, 285, 45, 339, 191, + 129, 1, 281, nil, nil, nil, 190, nil, nil, nil, + 160, nil, nil, 350, nil, nil, nil, 328, nil, 215, + nil, 165, 166, 167, 168, nil, nil, nil, 307, 187, + 188, 189, 246, 229, nil, 200, 200, 205, 217, 219, + nil, nil, nil, 147, 141, 234, 232, 149, nil, 148, + 230, nil, nil, nil, 241, nil, nil, nil, nil, nil, + nil, nil, nil, 216, 257, 258, nil, 356, nil, nil, + nil, 315, nil, nil, nil, nil, nil, 232, 149, 23, + 148, 230, 27, 281, 331, 139, 149, 20, 148, 140, + nil, nil, nil, 342, 293, 282, 160, 108, nil, 108, + 325, 304, 145, 147, 231, 312, 146, nil, 256, 313, + 234, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 196, 310, 232, 149, 143, + 148, 230, 159, 159, nil, 354, 344, 290, 142, 144, + nil, 234, nil, 348, nil, 363, nil, 297, 298, nil, + 229, 300, nil, 364, 366, nil, nil, nil, nil, nil, + 129, nil, 36, 23, nil, nil, 27, nil, 147, 231, + nil, 20, nil, nil, nil, nil, nil, nil, nil, 232, + 149, nil, 148, 230, nil, 318, 319, nil, nil, 233, + 340, 234, nil, 23, 232, 149, 27, 148, 230, 147, + 231, 20, 23, 347, nil, 27, nil, 147, 141, nil, + 20, 351, nil, nil, 159, 326, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, 249, nil, nil, nil, nil, nil, nil, 251, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, 251, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, 207, 254, - nil, nil, 348, 348, nil, nil, nil, 249, nil, nil, - nil, 254, nil, nil, nil, nil, 263, 264, 265, nil, - 267, 268, 269, 270, 271, 272, 273, nil, 275, 276, - 277, nil, nil, 282, nil, nil, nil, nil, nil, nil, + nil, nil, nil, 234, nil, nil, nil, nil, 23, 147, + 231, 27, 359, nil, 233, nil, 20, nil, 234, nil, + 88, nil, 23, 23, nil, 27, 27, nil, 36, 23, + 20, 20, 27, nil, 357, 358, nil, 20, nil, nil, + nil, nil, nil, nil, nil, 233, nil, nil, nil, nil, + nil, nil, nil, 143, nil, nil, nil, nil, nil, nil, + 159, 147, 231, nil, nil, nil, nil, nil, nil, nil, + nil, nil, nil, nil, nil, nil, 147, 231, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, + nil, nil, nil, nil, nil, 233, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, 249, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, 249, nil, nil, nil, - nil, nil, nil, nil, nil, nil, 164 ] + 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, nil, nil, nil, nil, 233, nil, nil, + nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, + nil, nil, 233 ] racc_goto_check = [ - 38, 22, 2, 83, 29, 63, 55, 33, 4, 53, - 31, 86, 71, 48, 37, 51, 73, 33, 39, 67, - 38, 22, 24, 23, 22, 79, 55, 37, 42, 53, - 69, 42, 29, 38, 64, 61, 75, 43, 31, 32, - 58, 6, 38, 22, 36, 3, 38, 22, 66, 75, - 6, 29, 30, 54, 6, 55, 20, 31, 5, 8, - 20, 21, 58, 8, 21, 47, 47, 32, 62, 28, - 23, 22, 70, 59, 58, 72, 57, 55, 69, 74, - 30, 34, 3, 76, 37, 77, 32, 5, 64, 55, - 31, 78, 35, 80, 81, 3, 24, 28, 82, 30, - 71, 3, 41, 84, 67, 85, 36, 1, 5, nil, - nil, 50, nil, nil, nil, nil, 28, nil, 69, nil, - 42, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, 55, 50, - nil, nil, nil, nil, nil, nil, nil, 29, 29, nil, - nil, 29, 55, 31, 31, nil, nil, 31, 50, nil, - nil, 37, nil, 69, 79, nil, 39, 22, nil, nil, - 23, 22, nil, nil, nil, 26, 53, nil, nil, 3, - nil, nil, 32, nil, nil, nil, 32, nil, 38, 22, - 48, 83, 51, 37, 86, 30, 29, 53, nil, 30, - 73, 54, 31, 26, 37, 27, 61, nil, 55, 29, - 55, nil, 28, 28, 71, 31, 28, 38, 22, nil, - 69, 29, 26, nil, 53, 36, 53, 31, nil, 65, - 54, 33, 69, 27, nil, 54, 29, 55, 38, 22, - nil, 22, 31, 5, 32, nil, 5, 53, nil, nil, - nil, nil, 27, nil, 50, 50, 32, 30, 50, nil, - nil, 28, nil, 26, 53, 55, 26, 4, nil, 30, - 25, nil, nil, 31, 28, nil, 29, 29, nil, 38, - 22, 29, 31, 31, 55, 55, 28, 31, 53, nil, - nil, nil, nil, nil, nil, nil, nil, nil, 25, nil, - nil, 28, nil, 50, 53, 53, nil, 55, nil, 53, - nil, nil, 38, 22, 2, 63, 50, 25, 26, 26, - nil, 53, 26, nil, 30, 30, nil, nil, 50, nil, - nil, nil, nil, nil, nil, nil, nil, nil, 29, nil, - nil, 28, 28, 50, 31, nil, 28, nil, 27, 27, - 29, 4, 27, nil, nil, 26, 31, nil, 25, nil, - nil, 25, nil, 38, 22, nil, 53, 26, 65, 65, - nil, nil, 53, 38, 22, nil, 38, 22, 53, nil, - 26, nil, 53, 50, 50, 53, nil, nil, 50, nil, - nil, nil, 26, nil, 65, nil, nil, 27, 65, nil, - nil, nil, nil, 28, nil, nil, nil, 26, nil, nil, - 27, nil, nil, 25, 25, 28, nil, 25, nil, nil, - nil, nil, 27, nil, nil, nil, nil, nil, nil, 52, - nil, 52, 52, nil, nil, nil, nil, 27, nil, nil, - nil, nil, nil, 26, nil, 50, nil, 26, 26, nil, - 25, nil, 26, nil, nil, 52, nil, 50, nil, nil, - nil, nil, 25, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, 52, 25, nil, 27, 27, 52, - nil, nil, 27, 52, nil, nil, nil, 25, nil, nil, + 43, 4, 43, 54, 2, 54, 25, 60, 22, 84, + 22, 28, 37, 77, 31, 29, 63, 71, 29, 29, + 38, 38, 69, 81, 43, 3, 65, 67, 35, 55, + 55, 58, 41, 41, 28, 44, 42, 43, 61, 20, + 47, 47, 43, 8, 20, 22, 23, 39, 8, 6, + 22, 64, 52, 59, 42, 40, 26, 26, 21, 21, + 5, 68, 6, 57, 32, 34, 23, 6, 73, 73, + 42, 28, 37, 70, 31, 29, 27, 72, 48, 23, + 74, 75, 76, 46, 78, 79, 80, 24, 82, 83, + 26, 1, 67, nil, nil, nil, 23, nil, nil, nil, + 29, nil, nil, 61, nil, nil, nil, 65, nil, 25, + nil, 26, 26, 26, 26, nil, nil, nil, 69, 26, + 26, 26, 47, 67, nil, 3, 3, 3, 23, 23, + nil, nil, nil, 36, 30, 54, 28, 37, nil, 31, + 29, nil, nil, nil, 44, nil, nil, nil, nil, nil, + nil, nil, nil, 26, 63, 63, nil, 81, nil, nil, + nil, 42, nil, nil, nil, nil, nil, 28, 37, 43, + 31, 29, 54, 67, 5, 28, 37, 22, 31, 29, + nil, nil, nil, 5, 77, 71, 29, 63, nil, 63, + 84, 58, 35, 36, 30, 55, 55, nil, 26, 41, + 54, 26, 26, 26, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 28, 52, 28, 37, 33, + 31, 29, 33, 33, nil, 67, 42, 3, 32, 34, + nil, 54, nil, 42, nil, 69, nil, 26, 26, nil, + 67, 26, nil, 5, 5, nil, nil, nil, nil, nil, + 26, nil, 4, 43, nil, nil, 54, nil, 36, 30, + nil, 22, nil, nil, nil, nil, nil, nil, nil, 28, + 37, nil, 31, 29, nil, 26, 26, nil, nil, 33, + 38, 54, nil, 43, 28, 37, 54, 31, 29, 36, + 30, 22, 43, 25, nil, 54, nil, 36, 30, nil, + 22, 60, nil, nil, 33, 26, 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, 54, nil, nil, nil, nil, 43, 36, + 30, 54, 2, nil, 33, nil, 22, nil, 54, nil, + 26, nil, 43, 43, nil, 54, 54, nil, 4, 43, + 22, 22, 54, nil, 26, 26, nil, 22, nil, nil, + nil, nil, nil, nil, nil, 33, nil, nil, nil, nil, + nil, nil, nil, 33, nil, nil, nil, nil, nil, nil, + 33, 36, 30, nil, nil, nil, nil, nil, nil, nil, + nil, nil, nil, nil, nil, nil, 36, 30, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, 25, nil, nil, nil, nil, nil, nil, 26, + nil, nil, nil, nil, nil, 33, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - nil, 26, nil, nil, nil, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, nil, nil, 25, 27, - nil, nil, 25, 25, nil, nil, nil, 25, nil, nil, - nil, 27, nil, nil, nil, nil, 52, 52, 52, nil, - 52, 52, 52, 52, 52, 52, 52, nil, 52, 52, - 52, nil, nil, 52, 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, 25, nil, nil, nil, nil, nil, - nil, nil, nil, nil, nil, nil, 25, nil, nil, nil, - nil, nil, nil, nil, nil, nil, 52 ] + nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, + nil, nil, nil, nil, nil, nil, nil, 33, nil, nil, + nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, + nil, nil, 33 ] racc_goto_pointer = [ - nil, 107, 2, 45, -12, -130, 8, nil, 17, nil, + nil, 91, 4, 25, -1, -109, 25, nil, 6, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - 14, 58, 1, 0, -144, 247, 152, 182, 46, -19, - 29, -13, 16, 6, 30, -48, -7, -128, 0, -34, - nil, 75, -83, -254, nil, nil, nil, -230, -38, nil, - 88, -36, 384, 9, 1, -23, nil, -158, -38, -259, - nil, -36, -96, -21, -247, 211, -167, -196, nil, -137, - -95, -155, -180, -16, 47, -1, -51, 67, 35, 7, - -65, -28, -24, -119, -122, 2, -92, nil ] + 2, 40, 8, 2, 66, -15, 28, -230, -61, -57, + 62, -58, -8, 147, -7, -44, 61, -60, -11, -25, + -78, -40, -80, 0, -8, nil, 60, -35, -165, nil, + nil, nil, -20, nil, 3, -43, nil, -145, -31, -76, + -21, -217, nil, -17, -146, -171, nil, -105, -71, -110, + -155, -13, 47, -32, -122, 48, -20, -20, -122, -116, + -115, -178, -203, -6, -86, nil ] racc_goto_default = [ - nil, nil, 279, 208, 25, nil, 31, 35, 4, 7, - 9, 14, 16, 19, 21, 24, 28, 30, 34, 3, - 6, nil, 98, nil, 76, 101, 102, 105, 107, 108, - 93, 94, 96, 12, nil, nil, nil, nil, 83, nil, - 33, nil, nil, 204, 291, 205, 206, nil, nil, 147, - 106, 109, 91, 64, 137, 97, 152, 153, nil, 260, - 104, nil, nil, nil, nil, 67, nil, nil, 302, 77, - nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, - 58, nil, nil, nil, nil, nil, nil, 197 ] + nil, nil, 253, 154, 4, nil, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, nil, 55, nil, nil, 89, 123, 213, 47, 48, + 49, 50, 51, 52, 53, 54, 56, 57, 22, nil, + nil, nil, nil, 65, nil, 24, nil, nil, 155, 243, + 156, 158, nil, 135, 67, 118, 119, 120, nil, nil, + nil, nil, 90, 69, nil, nil, 280, 66, nil, nil, + nil, nil, nil, nil, nil, nil, nil, nil, 104, nil, + nil, nil, nil, nil, nil, 194 ] racc_reduce_table = [ 0, 0, :racc_error, - 1, 70, :_reduce_none, - 1, 70, :_reduce_none, - 1, 71, :_reduce_3, - 2, 71, :_reduce_4, - 1, 74, :_reduce_5, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 1, 73, :_reduce_none, - 3, 88, :_reduce_20, - 3, 88, :_reduce_21, + 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, 89, :_reduce_none, 1, 89, :_reduce_none, 1, 89, :_reduce_none, - 1, 90, :_reduce_none, - 1, 90, :_reduce_none, - 1, 90, :_reduce_none, - 1, 90, :_reduce_none, - 4, 82, :_reduce_29, - 5, 82, :_reduce_30, - 3, 82, :_reduce_31, - 2, 82, :_reduce_32, + 1, 89, :_reduce_none, + 4, 81, :_reduce_29, + 5, 81, :_reduce_30, + 3, 81, :_reduce_31, + 2, 81, :_reduce_32, 1, 92, :_reduce_33, - 1, 92, :_reduce_34, - 3, 92, :_reduce_35, - 3, 92, :_reduce_36, + 3, 92, :_reduce_34, + 1, 91, :_reduce_35, + 3, 91, :_reduce_36, + 1, 93, :_reduce_none, 1, 93, :_reduce_none, 1, 93, :_reduce_none, 1, 93, :_reduce_none, 1, 93, :_reduce_none, 1, 93, :_reduce_none, 1, 93, :_reduce_none, 1, 93, :_reduce_none, 1, 93, :_reduce_none, - 1, 93, :_reduce_45, - 5, 75, :_reduce_46, - 5, 75, :_reduce_47, - 5, 75, :_reduce_48, - 5, 86, :_reduce_49, - 2, 76, :_reduce_50, - 1, 109, :_reduce_51, - 2, 109, :_reduce_52, - 6, 77, :_reduce_53, - 2, 77, :_reduce_54, - 3, 110, :_reduce_55, - 3, 110, :_reduce_56, - 1, 111, :_reduce_none, - 1, 111, :_reduce_none, - 3, 111, :_reduce_59, - 1, 112, :_reduce_none, - 3, 112, :_reduce_61, - 1, 113, :_reduce_62, - 1, 113, :_reduce_63, - 3, 114, :_reduce_64, - 3, 114, :_reduce_65, + 1, 93, :_reduce_none, + 1, 93, :_reduce_none, + 5, 74, :_reduce_48, + 5, 74, :_reduce_49, + 5, 74, :_reduce_50, + 5, 85, :_reduce_51, + 2, 75, :_reduce_52, + 1, 113, :_reduce_53, + 2, 113, :_reduce_54, + 6, 76, :_reduce_55, + 2, 76, :_reduce_56, + 3, 114, :_reduce_57, + 3, 114, :_reduce_58, 1, 115, :_reduce_none, 1, 115, :_reduce_none, - 4, 117, :_reduce_68, - 1, 103, :_reduce_69, - 3, 103, :_reduce_70, - 0, 104, :_reduce_none, - 1, 104, :_reduce_none, - 1, 119, :_reduce_73, - 1, 94, :_reduce_74, - 1, 96, :_reduce_75, - 1, 118, :_reduce_none, - 1, 118, :_reduce_none, - 1, 118, :_reduce_none, - 1, 118, :_reduce_none, - 1, 118, :_reduce_none, - 1, 118, :_reduce_none, - 1, 118, :_reduce_none, - 3, 78, :_reduce_83, - 3, 78, :_reduce_84, - 3, 87, :_reduce_85, - 0, 105, :_reduce_86, - 1, 105, :_reduce_87, - 3, 105, :_reduce_88, - 3, 123, :_reduce_89, - 3, 125, :_reduce_90, - 1, 126, :_reduce_none, - 1, 126, :_reduce_none, - 0, 108, :_reduce_93, - 1, 108, :_reduce_94, - 3, 108, :_reduce_95, - 1, 127, :_reduce_96, - 3, 127, :_reduce_97, - 1, 116, :_reduce_none, - 1, 116, :_reduce_none, - 1, 116, :_reduce_none, + 3, 115, :_reduce_61, 1, 116, :_reduce_none, - 1, 116, :_reduce_none, - 1, 116, :_reduce_none, - 1, 124, :_reduce_none, - 1, 124, :_reduce_none, - 1, 124, :_reduce_none, - 1, 124, :_reduce_none, - 1, 124, :_reduce_none, - 1, 124, :_reduce_none, - 1, 124, :_reduce_none, - 1, 124, :_reduce_none, - 1, 124, :_reduce_none, - 1, 124, :_reduce_none, - 1, 124, :_reduce_none, - 1, 124, :_reduce_none, - 4, 98, :_reduce_116, - 3, 98, :_reduce_117, - 1, 100, :_reduce_118, - 2, 100, :_reduce_119, - 2, 130, :_reduce_120, - 1, 131, :_reduce_121, - 2, 131, :_reduce_122, - 1, 97, :_reduce_123, - 4, 91, :_reduce_124, - 4, 91, :_reduce_125, - 2, 80, :_reduce_126, - 5, 132, :_reduce_127, - 4, 132, :_reduce_128, - 0, 133, :_reduce_none, - 2, 133, :_reduce_130, - 4, 133, :_reduce_131, - 3, 133, :_reduce_132, + 3, 116, :_reduce_63, + 1, 117, :_reduce_64, + 1, 117, :_reduce_65, + 3, 118, :_reduce_66, + 3, 118, :_reduce_67, + 1, 119, :_reduce_none, + 1, 119, :_reduce_none, + 4, 120, :_reduce_70, + 1, 107, :_reduce_71, + 3, 107, :_reduce_72, + 0, 108, :_reduce_none, + 1, 108, :_reduce_none, + 1, 105, :_reduce_75, + 1, 97, :_reduce_76, + 1, 98, :_reduce_77, 1, 121, :_reduce_none, - 3, 121, :_reduce_134, - 3, 121, :_reduce_135, - 3, 121, :_reduce_136, - 3, 121, :_reduce_137, - 3, 121, :_reduce_138, - 3, 121, :_reduce_139, - 3, 121, :_reduce_140, - 3, 121, :_reduce_141, - 3, 121, :_reduce_142, - 2, 121, :_reduce_143, - 3, 121, :_reduce_144, - 3, 121, :_reduce_145, - 3, 121, :_reduce_146, - 3, 121, :_reduce_147, - 3, 121, :_reduce_148, - 3, 121, :_reduce_149, - 2, 121, :_reduce_150, - 3, 121, :_reduce_151, - 3, 121, :_reduce_152, - 3, 121, :_reduce_153, - 5, 79, :_reduce_154, - 1, 135, :_reduce_155, - 2, 135, :_reduce_156, - 5, 136, :_reduce_157, - 4, 136, :_reduce_158, - 1, 137, :_reduce_159, - 3, 137, :_reduce_160, - 3, 99, :_reduce_161, - 1, 139, :_reduce_none, - 4, 139, :_reduce_163, - 1, 141, :_reduce_none, - 3, 141, :_reduce_165, - 3, 140, :_reduce_166, - 1, 138, :_reduce_none, - 1, 138, :_reduce_none, - 1, 138, :_reduce_none, - 1, 138, :_reduce_none, - 1, 138, :_reduce_none, - 1, 138, :_reduce_none, - 1, 138, :_reduce_none, - 1, 138, :_reduce_none, - 1, 138, :_reduce_175, + 1, 121, :_reduce_none, + 1, 121, :_reduce_none, + 1, 121, :_reduce_none, + 1, 121, :_reduce_none, + 1, 121, :_reduce_none, + 1, 121, :_reduce_none, + 3, 77, :_reduce_85, + 3, 77, :_reduce_86, + 3, 86, :_reduce_87, + 0, 109, :_reduce_88, + 1, 109, :_reduce_89, + 3, 109, :_reduce_90, + 3, 123, :_reduce_91, + 3, 124, :_reduce_92, + 1, 125, :_reduce_none, + 1, 125, :_reduce_none, + 0, 112, :_reduce_95, + 1, 112, :_reduce_96, + 3, 112, :_reduce_97, + 4, 104, :_reduce_98, + 3, 104, :_reduce_99, + 1, 96, :_reduce_100, + 2, 96, :_reduce_101, + 2, 126, :_reduce_102, + 1, 127, :_reduce_103, + 2, 127, :_reduce_104, + 1, 99, :_reduce_105, + 4, 90, :_reduce_106, + 4, 90, :_reduce_107, + 2, 79, :_reduce_108, + 5, 128, :_reduce_109, + 4, 128, :_reduce_110, + 0, 129, :_reduce_none, + 2, 129, :_reduce_112, + 4, 129, :_reduce_113, + 3, 129, :_reduce_114, + 1, 94, :_reduce_none, + 1, 94, :_reduce_none, + 3, 94, :_reduce_117, + 3, 94, :_reduce_118, + 3, 94, :_reduce_119, + 3, 94, :_reduce_120, + 3, 94, :_reduce_121, + 3, 94, :_reduce_122, + 3, 94, :_reduce_123, + 3, 94, :_reduce_124, + 3, 94, :_reduce_125, + 2, 94, :_reduce_126, + 3, 94, :_reduce_127, + 3, 94, :_reduce_128, + 3, 94, :_reduce_129, + 3, 94, :_reduce_130, + 3, 94, :_reduce_131, + 3, 94, :_reduce_132, + 2, 94, :_reduce_133, + 3, 94, :_reduce_134, + 3, 94, :_reduce_135, + 3, 94, :_reduce_136, + 5, 78, :_reduce_137, + 1, 132, :_reduce_138, + 2, 132, :_reduce_139, + 5, 133, :_reduce_140, + 4, 133, :_reduce_141, + 1, 134, :_reduce_142, + 3, 134, :_reduce_143, + 3, 100, :_reduce_144, + 1, 136, :_reduce_none, + 4, 136, :_reduce_146, 1, 138, :_reduce_none, - 1, 142, :_reduce_177, - 1, 143, :_reduce_none, - 3, 143, :_reduce_179, - 2, 81, :_reduce_180, - 6, 83, :_reduce_181, - 5, 83, :_reduce_182, - 7, 84, :_reduce_183, - 6, 84, :_reduce_184, - 6, 85, :_reduce_185, - 5, 85, :_reduce_186, - 1, 107, :_reduce_187, - 1, 102, :_reduce_188, - 1, 102, :_reduce_189, - 1, 102, :_reduce_190, - 1, 146, :_reduce_191, - 3, 146, :_reduce_192, - 1, 148, :_reduce_193, - 1, 149, :_reduce_194, - 1, 149, :_reduce_195, - 1, 149, :_reduce_196, - 1, 149, :_reduce_none, - 0, 72, :_reduce_198, - 0, 150, :_reduce_199, + 3, 138, :_reduce_148, + 3, 137, :_reduce_149, + 1, 135, :_reduce_none, + 1, 135, :_reduce_none, + 1, 135, :_reduce_none, + 1, 135, :_reduce_none, + 1, 135, :_reduce_none, + 1, 135, :_reduce_none, + 1, 135, :_reduce_none, + 1, 135, :_reduce_none, + 1, 135, :_reduce_158, + 1, 135, :_reduce_none, + 1, 139, :_reduce_160, + 1, 140, :_reduce_none, + 3, 140, :_reduce_162, + 2, 80, :_reduce_163, + 6, 82, :_reduce_164, + 5, 82, :_reduce_165, + 7, 83, :_reduce_166, + 6, 83, :_reduce_167, + 6, 84, :_reduce_168, + 5, 84, :_reduce_169, + 1, 111, :_reduce_170, + 1, 106, :_reduce_171, + 1, 106, :_reduce_172, + 1, 143, :_reduce_173, + 3, 143, :_reduce_174, + 1, 145, :_reduce_175, + 1, 146, :_reduce_176, + 1, 146, :_reduce_177, + 1, 146, :_reduce_178, + 1, 146, :_reduce_none, + 0, 71, :_reduce_180, + 0, 147, :_reduce_181, + 1, 141, :_reduce_none, + 3, 141, :_reduce_183, + 3, 141, :_reduce_184, + 1, 148, :_reduce_none, + 3, 148, :_reduce_186, + 3, 149, :_reduce_187, + 1, 149, :_reduce_188, + 3, 149, :_reduce_189, + 1, 149, :_reduce_190, 1, 144, :_reduce_none, - 3, 144, :_reduce_201, - 3, 144, :_reduce_202, + 2, 144, :_reduce_192, + 1, 142, :_reduce_none, + 2, 142, :_reduce_194, + 1, 150, :_reduce_none, + 1, 150, :_reduce_none, + 1, 101, :_reduce_197, + 3, 102, :_reduce_198, + 4, 102, :_reduce_199, + 2, 102, :_reduce_200, + 1, 95, :_reduce_none, + 1, 95, :_reduce_none, + 0, 110, :_reduce_none, + 1, 110, :_reduce_204, + 1, 131, :_reduce_205, + 3, 130, :_reduce_206, + 4, 130, :_reduce_207, + 2, 130, :_reduce_208, 1, 151, :_reduce_none, - 3, 151, :_reduce_204, - 3, 152, :_reduce_205, - 1, 152, :_reduce_206, - 3, 152, :_reduce_207, - 1, 152, :_reduce_208, - 1, 147, :_reduce_none, - 2, 147, :_reduce_210, - 1, 145, :_reduce_none, - 2, 145, :_reduce_212, - 1, 153, :_reduce_none, - 1, 153, :_reduce_none, - 1, 95, :_reduce_215, - 3, 120, :_reduce_216, - 4, 120, :_reduce_217, - 2, 120, :_reduce_218, - 1, 128, :_reduce_none, - 1, 128, :_reduce_none, - 0, 106, :_reduce_none, - 1, 106, :_reduce_222, - 1, 134, :_reduce_223, - 3, 129, :_reduce_224, - 4, 129, :_reduce_225, - 2, 129, :_reduce_226, - 1, 154, :_reduce_none, - 3, 154, :_reduce_228, - 3, 155, :_reduce_229, - 1, 156, :_reduce_230, - 1, 156, :_reduce_231, - 4, 122, :_reduce_232, - 1, 101, :_reduce_none, - 4, 101, :_reduce_234 ] - -racc_reduce_n = 235 - -racc_shift_n = 386 + 3, 151, :_reduce_210, + 3, 152, :_reduce_211, + 1, 153, :_reduce_212, + 1, 153, :_reduce_213, + 4, 122, :_reduce_214, + 1, 103, :_reduce_none, + 4, 103, :_reduce_216 ] + +racc_reduce_n = 217 + +racc_shift_n = 371 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, - :CLASSNAME => 47, - :CLASSREF => 48, - :NOT => 49, - :OR => 50, - :AND => 51, - :UNDEF => 52, - :PARROW => 53, - :PLUS => 54, - :MINUS => 55, - :TIMES => 56, - :DIV => 57, - :LSHIFT => 58, - :RSHIFT => 59, - :UMINUS => 60, - :MATCH => 61, - :NOMATCH => 62, - :REGEX => 63, - :IN_EDGE => 64, - :OUT_EDGE => 65, - :IN_EDGE_SUB => 66, - :OUT_EDGE_SUB => 67, - :IN => 68 } - -racc_nt_base = 69 + :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 } + +racc_nt_base = 68 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", - "CLASSNAME", "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", "$start", "program", "statements_and_declarations", "nil", "statement_or_declaration", "statements", "resource", "virtualresource", "collection", "assignment", "casestatement", "ifstatement_begin", "import", "fstatement", "definition", "hostclass", "nodedef", "resourceoverride", "append", "relationship", "relationship_side", "edge", "resourceref", + "expressions", "funcvalues", - "namestring", + "rvalue", + "expression", + "comma", + "quotedtext", "name", - "variable", "type", "boolean", - "funcrvalue", "selector", - "quotedtext", + "variable", + "array", "hasharrayaccesses", + "funcrvalue", + "undef", "classname", "resourceinstances", "endsemi", "params", "endcomma", "classref", "anyparams", "at", "collectrhand", "collstatements", "collstatement", "colljoin", "collexpr", "colllval", - "simplervalue", "resourceinst", "resourcename", - "undef", - "array", - "expression", "hasharrayaccess", "param", - "rvalue", "addparam", "anyparam", - "rvalues", - "comma", - "hash", "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) 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) 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 module_eval(<<'.,.,', 'grammar.ra', 83) def _reduce_29(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', 90) def _reduce_30(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', 96) def _reduce_31(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', 103) def _reduce_32(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', 110) def _reduce_33(val, _values, result) result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 111) +module_eval(<<'.,.,', 'grammar.ra', 113) def _reduce_34(val, _values, result) - result = aryfy(val[0]) + val[0].push(val[2]) + result = val[0] + result end .,., -module_eval(<<'.,.,', 'grammar.ra', 113) +module_eval(<<'.,.,', 'grammar.ra', 117) def _reduce_35(val, _values, result) - val[0].push(val[2]) - result = val[0] - + result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 117) +module_eval(<<'.,.,', 'grammar.ra', 118) def _reduce_36(val, _values, result) - val[0].push(val[2]) - result = val[0] - + result = val[0].push(val[2]) result end .,., # reduce 37 omitted # reduce 38 omitted # reduce 39 omitted # reduce 40 omitted # reduce 41 omitted # reduce 42 omitted # reduce 43 omitted # reduce 44 omitted -module_eval(<<'.,.,', 'grammar.ra', 132) - def _reduce_45(val, _values, result) - result = ast AST::Name, :value => val[0][:value] - - result - end -.,., +# reduce 45 omitted -module_eval(<<'.,.,', 'grammar.ra', 136) - def _reduce_46(val, _values, result) +# reduce 46 omitted + +# reduce 47 omitted + +module_eval(<<'.,.,', 'grammar.ra', 133) + def _reduce_48(val, _values, result) @lexer.commentpop result = ast(AST::Resource, :type => val[0], :instances => val[2]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 139) - def _reduce_47(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 136) + def _reduce_49(val, _values, result) # This is a deprecated syntax. error "All resource specifications require names" result end .,., -module_eval(<<'.,.,', 'grammar.ra', 142) - def _reduce_48(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 139) + def _reduce_50(val, _values, result) # a defaults setting for a type @lexer.commentpop result = ast(AST::ResourceDefaults, :type => val[0], :parameters => val[2]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 149) - def _reduce_49(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 146) + def _reduce_51(val, _values, result) @lexer.commentpop result = ast AST::ResourceOverride, :object => val[0], :parameters => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 156) - def _reduce_50(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 153) + def _reduce_52(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', 172) - def _reduce_51(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 169) + def _reduce_53(val, _values, result) result = :virtual result end .,., -module_eval(<<'.,.,', 'grammar.ra', 173) - def _reduce_52(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 170) + def _reduce_54(val, _values, result) result = :exported result end .,., -module_eval(<<'.,.,', 'grammar.ra', 178) - def _reduce_53(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 175) + def _reduce_55(val, _values, result) @lexer.commentpop Puppet.warning addcontext("Collection names must now be capitalized") if val[0] =~ /^[a-z]/ type = val[0].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', 197) - def _reduce_54(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 194) + def _reduce_56(val, _values, result) if val[0] =~ /^[a-z]/ Puppet.warning addcontext("Collection names must now be capitalized") end type = val[0].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_55(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 215) + def _reduce_57(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_56(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 223) + def _reduce_58(val, _values, result) if val[1] result = val[1] result.form = :exported else result = :exported end result end .,., -# reduce 57 omitted +# reduce 59 omitted -# reduce 58 omitted +# reduce 60 omitted -module_eval(<<'.,.,', 'grammar.ra', 239) - def _reduce_59(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 236) + def _reduce_61(val, _values, result) result = ast AST::CollExpr, :test1 => val[0], :oper => val[1], :test2 => val[2] result end .,., -# reduce 60 omitted +# reduce 62 omitted -module_eval(<<'.,.,', 'grammar.ra', 244) - def _reduce_61(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 241) + def _reduce_63(val, _values, result) result = val[1] result.parens = true result end .,., -module_eval(<<'.,.,', 'grammar.ra', 248) - def _reduce_62(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 245) + def _reduce_64(val, _values, result) result=val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 249) - def _reduce_63(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 246) + def _reduce_65(val, _values, result) result=val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 252) - def _reduce_64(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 249) + def _reduce_66(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_65(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 254) + def _reduce_67(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 66 omitted +# reduce 68 omitted -# reduce 67 omitted +# reduce 69 omitted -module_eval(<<'.,.,', 'grammar.ra', 266) - def _reduce_68(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 263) + def _reduce_70(val, _values, result) result = ast AST::ResourceInstance, :title => val[0], :parameters => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 269) - def _reduce_69(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 266) + def _reduce_71(val, _values, result) result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 271) - def _reduce_70(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 268) + def _reduce_72(val, _values, result) val[0].push val[2] result = val[0] result end .,., -# reduce 71 omitted +# reduce 73 omitted -# reduce 72 omitted +# reduce 74 omitted -module_eval(<<'.,.,', 'grammar.ra', 279) - def _reduce_73(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 276) + def _reduce_75(val, _values, result) result = ast AST::Undef, :value => :undef result end .,., -module_eval(<<'.,.,', 'grammar.ra', 283) - def _reduce_74(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 280) + def _reduce_76(val, _values, result) result = ast AST::Name, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 287) - def _reduce_75(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 284) + def _reduce_77(val, _values, result) result = ast AST::Type, :value => val[0][:value], :line => val[0][:line] result end .,., -# reduce 76 omitted - -# reduce 77 omitted - # reduce 78 omitted # reduce 79 omitted # reduce 80 omitted # reduce 81 omitted # reduce 82 omitted -module_eval(<<'.,.,', 'grammar.ra', 299) - def _reduce_83(val, _values, result) +# reduce 83 omitted + +# reduce 84 omitted + +module_eval(<<'.,.,', 'grammar.ra', 296) + def _reduce_85(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_84(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 302) + def _reduce_86(val, _values, result) result = ast AST::VarDef, :name => val[0], :value => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 309) - def _reduce_85(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 306) + def _reduce_87(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_86(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 312) + def _reduce_88(val, _values, result) result = ast AST::ASTArray result end .,., -module_eval(<<'.,.,', 'grammar.ra', 317) - def _reduce_87(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 314) + def _reduce_89(val, _values, result) result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 319) - def _reduce_88(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 316) + def _reduce_90(val, _values, result) val[0].push(val[2]) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 324) - def _reduce_89(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 321) + def _reduce_91(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_90(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 325) + def _reduce_92(val, _values, result) result = ast AST::ResourceParam, :param => val[0][:value], :line => val[0][:line], :value => val[2], :add => true result end .,., -# reduce 91 omitted +# reduce 93 omitted -# reduce 92 omitted +# reduce 94 omitted -module_eval(<<'.,.,', 'grammar.ra', 337) - def _reduce_93(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 334) + def _reduce_95(val, _values, result) result = ast AST::ASTArray result end .,., -module_eval(<<'.,.,', 'grammar.ra', 339) - def _reduce_94(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 336) + def _reduce_96(val, _values, result) result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 341) - def _reduce_95(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 338) + def _reduce_97(val, _values, result) val[0].push(val[2]) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 345) - def _reduce_96(val, _values, result) - result = aryfy(val[0]) - result - end -.,., - -module_eval(<<'.,.,', 'grammar.ra', 346) - def _reduce_97(val, _values, result) - result = val[0].push(val[2]) - result - end -.,., - -# reduce 98 omitted - -# reduce 99 omitted - -# reduce 100 omitted - -# reduce 101 omitted - -# reduce 102 omitted - -# reduce 103 omitted - -# reduce 104 omitted - -# reduce 105 omitted - -# reduce 106 omitted - -# reduce 107 omitted - -# reduce 108 omitted - -# reduce 109 omitted - -# reduce 110 omitted - -# reduce 111 omitted - -# reduce 112 omitted - -# reduce 113 omitted - -# reduce 114 omitted - -# reduce 115 omitted - -module_eval(<<'.,.,', 'grammar.ra', 370) - def _reduce_116(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 344) + def _reduce_98(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', 375) - def _reduce_117(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 349) + def _reduce_99(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', 381) - def _reduce_118(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 355) + def _reduce_100(val, _values, result) result = ast AST::String, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 382) - def _reduce_119(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 356) + def _reduce_101(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', 384) - def _reduce_120(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 358) + def _reduce_102(val, _values, result) result = [val[0]] + val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 386) - def _reduce_121(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 360) + def _reduce_103(val, _values, result) result = [ast(AST::String,val[0])] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 387) - def _reduce_122(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 361) + def _reduce_104(val, _values, result) result = [ast(AST::String,val[0])] + val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 390) - def _reduce_123(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 364) + def _reduce_105(val, _values, result) result = ast AST::Boolean, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 394) - def _reduce_124(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 368) + def _reduce_106(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', 397) - def _reduce_125(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 371) + def _reduce_107(val, _values, result) result = ast AST::ResourceReference, :type => val[0], :title => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 401) - def _reduce_126(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 375) + def _reduce_108(val, _values, result) result = val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 405) - def _reduce_127(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 379) + def _reduce_109(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', 416) - def _reduce_128(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 390) + def _reduce_110(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 129 omitted +# reduce 111 omitted -module_eval(<<'.,.,', 'grammar.ra', 429) - def _reduce_130(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 403) + def _reduce_112(val, _values, result) result = ast AST::Else, :statements => val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 432) - def _reduce_131(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 406) + def _reduce_113(val, _values, result) @lexer.commentpop result = ast AST::Else, :statements => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 436) - def _reduce_132(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 410) + def _reduce_114(val, _values, result) @lexer.commentpop result = ast AST::Else, :statements => ast(AST::Nop) result end .,., -# reduce 133 omitted +# reduce 115 omitted -module_eval(<<'.,.,', 'grammar.ra', 454) - def _reduce_134(val, _values, result) +# reduce 116 omitted + +module_eval(<<'.,.,', 'grammar.ra', 429) + def _reduce_117(val, _values, result) result = ast AST::InOperator, :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 457) - def _reduce_135(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 432) + def _reduce_118(val, _values, result) result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 460) - def _reduce_136(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 435) + def _reduce_119(val, _values, result) result = ast AST::MatchOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 463) - def _reduce_137(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 438) + def _reduce_120(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 466) - def _reduce_138(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 441) + def _reduce_121(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 469) - def _reduce_139(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 444) + def _reduce_122(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 472) - def _reduce_140(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 447) + def _reduce_123(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 475) - def _reduce_141(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 450) + def _reduce_124(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 478) - def _reduce_142(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 453) + def _reduce_125(val, _values, result) result = ast AST::ArithmeticOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 481) - def _reduce_143(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 456) + def _reduce_126(val, _values, result) result = ast AST::Minus, :value => val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 484) - def _reduce_144(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 459) + def _reduce_127(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 487) - def _reduce_145(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 462) + def _reduce_128(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 490) - def _reduce_146(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 465) + def _reduce_129(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 493) - def _reduce_147(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 468) + def _reduce_130(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 496) - def _reduce_148(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 471) + def _reduce_131(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 499) - def _reduce_149(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 474) + def _reduce_132(val, _values, result) result = ast AST::ComparisonOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 502) - def _reduce_150(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 477) + def _reduce_133(val, _values, result) result = ast AST::Not, :value => val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 505) - def _reduce_151(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 480) + def _reduce_134(val, _values, result) result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 508) - def _reduce_152(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 483) + def _reduce_135(val, _values, result) result = ast AST::BooleanOperator, :operator => val[1][:value], :lval => val[0], :rval => val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 511) - def _reduce_153(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 486) + def _reduce_136(val, _values, result) result = val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 515) - def _reduce_154(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 490) + def _reduce_137(val, _values, result) @lexer.commentpop result = ast AST::CaseStatement, :test => val[1], :options => val[3] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 519) - def _reduce_155(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 494) + def _reduce_138(val, _values, result) result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 521) - def _reduce_156(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 496) + def _reduce_139(val, _values, result) val[0].push val[1] result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 526) - def _reduce_157(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 501) + def _reduce_140(val, _values, result) @lexer.commentpop result = ast AST::CaseOpt, :value => val[0], :statements => val[3] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 529) - def _reduce_158(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 504) + def _reduce_141(val, _values, result) @lexer.commentpop result = ast( AST::CaseOpt, :value => val[0], :statements => ast(AST::ASTArray) ) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 539) - def _reduce_159(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 514) + def _reduce_142(val, _values, result) result = aryfy(val[0]) result end .,., -module_eval(<<'.,.,', 'grammar.ra', 541) - def _reduce_160(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 516) + def _reduce_143(val, _values, result) val[0].push(val[2]) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 546) - def _reduce_161(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 521) + def _reduce_144(val, _values, result) result = ast AST::Selector, :param => val[0], :values => val[2] result end .,., -# reduce 162 omitted +# reduce 145 omitted -module_eval(<<'.,.,', 'grammar.ra', 551) - def _reduce_163(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 526) + def _reduce_146(val, _values, result) @lexer.commentpop result = val[1] result end .,., -# reduce 164 omitted +# reduce 147 omitted -module_eval(<<'.,.,', 'grammar.ra', 557) - def _reduce_165(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 532) + def _reduce_148(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', 566) - def _reduce_166(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 541) + def _reduce_149(val, _values, result) result = ast AST::ResourceParam, :param => val[0], :value => val[2] result end .,., -# reduce 167 omitted +# reduce 150 omitted -# reduce 168 omitted +# reduce 151 omitted -# reduce 169 omitted +# reduce 152 omitted -# reduce 170 omitted +# reduce 153 omitted -# reduce 171 omitted +# reduce 154 omitted -# reduce 172 omitted +# reduce 155 omitted -# reduce 173 omitted +# reduce 156 omitted -# reduce 174 omitted +# reduce 157 omitted -module_eval(<<'.,.,', 'grammar.ra', 578) - def _reduce_175(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 553) + def _reduce_158(val, _values, result) result = ast AST::Default, :value => val[0][:value], :line => val[0][:line] result end .,., -# reduce 176 omitted +# reduce 159 omitted -module_eval(<<'.,.,', 'grammar.ra', 583) - def _reduce_177(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 558) + def _reduce_160(val, _values, result) result = [val[0][:value]] result end .,., -# reduce 178 omitted +# reduce 161 omitted -module_eval(<<'.,.,', 'grammar.ra', 585) - def _reduce_179(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 560) + def _reduce_162(val, _values, result) result = val[0] += val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 588) - def _reduce_180(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 563) + def _reduce_163(val, _values, result) val[1].each do |file| import(file) end result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 598) - def _reduce_181(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 573) + def _reduce_164(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', 606) - def _reduce_182(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 581) + def _reduce_165(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', 614) - def _reduce_183(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 589) + def _reduce_166(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', 621) - def _reduce_184(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 596) + def _reduce_167(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', 630) - def _reduce_185(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 605) + def _reduce_168(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', 635) - def _reduce_186(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 610) + def _reduce_169(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', 639) - def _reduce_187(val, _values, result) - result = val[0][:value] - result - end -.,., - -module_eval(<<'.,.,', 'grammar.ra', 641) - def _reduce_188(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 614) + def _reduce_170(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 642) - def _reduce_189(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 616) + def _reduce_171(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 643) - def _reduce_190(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 617) + def _reduce_172(val, _values, result) result = "class" result end .,., -module_eval(<<'.,.,', 'grammar.ra', 648) - def _reduce_191(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 622) + def _reduce_173(val, _values, result) result = [result] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 651) - def _reduce_192(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 625) + def _reduce_174(val, _values, result) result = val[0] result << val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 656) - def _reduce_193(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 630) + def _reduce_175(val, _values, result) result = ast AST::HostName, :value => val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 659) - def _reduce_194(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 633) + def _reduce_176(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 660) - def _reduce_195(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 634) + def _reduce_177(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 661) - def _reduce_196(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 635) + def _reduce_178(val, _values, result) result = val[0][:value] result end .,., -# reduce 197 omitted +# reduce 179 omitted -module_eval(<<'.,.,', 'grammar.ra', 665) - def _reduce_198(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 639) + def _reduce_180(val, _values, result) result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 669) - def _reduce_199(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 643) + def _reduce_181(val, _values, result) result = ast AST::ASTArray, :children => [] result end .,., -# reduce 200 omitted +# reduce 182 omitted -module_eval(<<'.,.,', 'grammar.ra', 674) - def _reduce_201(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 648) + def _reduce_183(val, _values, result) result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 677) - def _reduce_202(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 651) + def _reduce_184(val, _values, result) result = val[1] result = [result] unless result[0].is_a?(Array) result end .,., -# reduce 203 omitted +# reduce 185 omitted -module_eval(<<'.,.,', 'grammar.ra', 683) - def _reduce_204(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 657) + def _reduce_186(val, _values, result) result = val[0] result = [result] unless result[0].is_a?(Array) result << val[2] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 689) - def _reduce_205(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 663) + def _reduce_187(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', 693) - def _reduce_206(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 667) + def _reduce_188(val, _values, result) Puppet.warning addcontext("Deprecation notice: must now include '$' in prototype") result = [val[0][:value]] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 696) - def _reduce_207(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 670) + def _reduce_189(val, _values, result) result = [val[0][:value], val[2]] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 698) - def _reduce_208(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 672) + def _reduce_190(val, _values, result) result = [val[0][:value]] result end .,., -# reduce 209 omitted +# reduce 191 omitted -module_eval(<<'.,.,', 'grammar.ra', 703) - def _reduce_210(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 677) + def _reduce_192(val, _values, result) result = val[1] result end .,., -# reduce 211 omitted +# reduce 193 omitted -module_eval(<<'.,.,', 'grammar.ra', 708) - def _reduce_212(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 682) + def _reduce_194(val, _values, result) result = val[1] result end .,., -# reduce 213 omitted +# reduce 195 omitted -# reduce 214 omitted +# reduce 196 omitted -module_eval(<<'.,.,', 'grammar.ra', 714) - def _reduce_215(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 688) + def _reduce_197(val, _values, result) result = ast AST::Variable, :value => val[0][:value], :line => val[0][:line] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 717) - def _reduce_216(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 691) + def _reduce_198(val, _values, result) result = val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 718) - def _reduce_217(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 692) + def _reduce_199(val, _values, result) result = val[1] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 719) - def _reduce_218(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 693) + def _reduce_200(val, _values, result) result = ast AST::ASTArray result end .,., -# reduce 219 omitted +# reduce 201 omitted -# reduce 220 omitted +# reduce 202 omitted -# reduce 221 omitted +# reduce 203 omitted -module_eval(<<'.,.,', 'grammar.ra', 725) - def _reduce_222(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 699) + def _reduce_204(val, _values, result) result = nil result end .,., -module_eval(<<'.,.,', 'grammar.ra', 728) - def _reduce_223(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 702) + def _reduce_205(val, _values, result) result = ast AST::Regex, :value => val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 732) - def _reduce_224(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 706) + def _reduce_206(val, _values, result) if val[1].instance_of?(AST::ASTHash) result = val[1] else result = ast AST::ASTHash, { :value => val[1] } end result end .,., -module_eval(<<'.,.,', 'grammar.ra', 739) - def _reduce_225(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 713) + def _reduce_207(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', 745) - def _reduce_226(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 719) + def _reduce_208(val, _values, result) result = ast AST::ASTHash result end .,., -# reduce 227 omitted +# reduce 209 omitted -module_eval(<<'.,.,', 'grammar.ra', 750) - def _reduce_228(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 724) + def _reduce_210(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', 759) - def _reduce_229(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 733) + def _reduce_211(val, _values, result) result = ast AST::ASTHash, { :value => { val[0] => val[2] } } result end .,., -module_eval(<<'.,.,', 'grammar.ra', 762) - def _reduce_230(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 736) + def _reduce_212(val, _values, result) result = val[0][:value] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 763) - def _reduce_231(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 737) + def _reduce_213(val, _values, result) result = val[0] result end .,., -module_eval(<<'.,.,', 'grammar.ra', 766) - def _reduce_232(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 740) + def _reduce_214(val, _values, result) result = ast AST::HashOrArrayAccess, :variable => val[0][:value], :key => val[2] result end .,., -# reduce 233 omitted +# reduce 215 omitted -module_eval(<<'.,.,', 'grammar.ra', 771) - def _reduce_234(val, _values, result) +module_eval(<<'.,.,', 'grammar.ra', 745) + def _reduce_216(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/integration/parser/parser_spec.rb b/spec/integration/parser/parser_spec.rb index 65c9ee302..b55aa04ce 100755 --- a/spec/integration/parser/parser_spec.rb +++ b/spec/integration/parser/parser_spec.rb @@ -1,121 +1,152 @@ #!/usr/bin/env rspec require 'spec_helper' describe Puppet::Parser::Parser do module ParseMatcher class ParseAs def initialize(klass) @parser = Puppet::Parser::Parser.new "development" @class = klass end def result_instance @result.code[0] end def matches?(string) @string = string @result = @parser.parse(string) result_instance.instance_of?(@class) end def description "parse as a #{@class}" end def failure_message " expected #{@string} to parse as #{@class} but was #{result_instance.class}" end def negative_failure_message " expected #{@string} not to parse as #{@class}" end end def parse_as(klass) ParseAs.new(klass) end class ParseWith def initialize(block) @parser = Puppet::Parser::Parser.new "development" @block = block end def result_instance @result.code[0] end def matches?(string) @string = string @result = @parser.parse(string) @block.call(result_instance) end def description "parse with the block evaluating to true" end def failure_message " expected #{@string} to parse with a true result in the block" end def negative_failure_message " expected #{@string} not to parse with a true result in the block" end end def parse_with(&block) ParseWith.new(block) end end include ParseMatcher before :each do @resource_type_collection = Puppet::Resource::TypeCollection.new("env") @parser = Puppet::Parser::Parser.new "development" end describe "when parsing comments before statement" do it "should associate the documentation to the statement AST node" do ast = @parser.parse(""" # comment class test {} """) ast.code[0].should be_a(Puppet::Parser::AST::Hostclass) ast.code[0].name.should == 'test' ast.code[0].instantiate('')[0].doc.should == "comment\n" end end describe "when parsing" do it "should be able to parse normal left to right relationships" do "Notify[foo] -> Notify[bar]".should parse_as(Puppet::Parser::AST::Relationship) end it "should be able to parse right to left relationships" do "Notify[foo] <- Notify[bar]".should parse_as(Puppet::Parser::AST::Relationship) end it "should be able to parse normal left to right subscriptions" do "Notify[foo] ~> Notify[bar]".should parse_as(Puppet::Parser::AST::Relationship) end it "should be able to parse right to left subscriptions" do "Notify[foo] <~ Notify[bar]".should parse_as(Puppet::Parser::AST::Relationship) end it "should correctly set the arrow type of a relationship" do "Notify[foo] <~ Notify[bar]".should parse_with { |rel| rel.arrow == "<~" } end it "should be able to parse deep hash access" do %q{ $hash = { 'a' => { 'b' => { 'c' => 'it works' } } } $out = $hash['a']['b']['c'] }.should parse_with { |v| v.value.is_a?(Puppet::Parser::AST::ASTHash) } end + + it "should fail if asked to parse '$foo::::bar'" do + expect { @parser.parse("$foo::::bar") }.should raise_error(Puppet::ParseError, /Syntax error at ':'/) + end + + describe "function calls" do + it "should be able to pass an array to a function" do + "my_function([1,2,3])".should parse_with { |fun| + fun.is_a?(Puppet::Parser::AST::Function) && + fun.arguments.first.evaluate(stub 'scope') == ['1','2','3'] + } + end + + it "should be able to pass a hash to a function" do + "my_function({foo => bar})".should parse_with { |fun| + fun.is_a?(Puppet::Parser::AST::Function) && + fun.arguments.first.evaluate(stub 'scope') == {'foo' => 'bar'} + } + end + end + + describe "collections" do + it "should find resources according to an expression" do + %q{ + File <| mode == 0700 + 0050 + 0050 |> + }.should parse_with { |coll| + coll.is_a?(Puppet::Parser::AST::Collection) && + coll.query.evaluate(stub 'scope').first == "param_values.value = '528' and param_names.name = 'mode'" + } + end + end end end diff --git a/spec/unit/parser/lexer_spec.rb b/spec/unit/parser/lexer_spec.rb index 6cdb0553a..48f7304b4 100755 --- a/spec/unit/parser/lexer_spec.rb +++ b/spec/unit/parser/lexer_spec.rb @@ -1,689 +1,699 @@ #!/usr/bin/env rspec require 'spec_helper' require 'puppet/parser/lexer' # This is a special matcher to match easily lexer output RSpec::Matchers.define :be_like do |*expected| match do |actual| expected.zip(actual).all? { |e,a| !e or a[0] == e or (e.is_a? Array and a[0] == e[0] and (a[1] == e[1] or (a[1].is_a?(Hash) and a[1][:value] == e[1]))) } end end __ = nil describe Puppet::Parser::Lexer do describe "when reading strings" do before { @lexer = Puppet::Parser::Lexer.new } it "should increment the line count for every carriage return in the string" do @lexer.line = 10 @lexer.string = "this\nis\natest'" @lexer.slurpstring("'") @lexer.line.should == 12 end it "should not increment the line count for escapes in the string" do @lexer.line = 10 @lexer.string = "this\\nis\\natest'" @lexer.slurpstring("'") @lexer.line.should == 10 end it "should not think the terminator is escaped, when preceeded by an even number of backslashes" do @lexer.line = 10 @lexer.string = "here\nis\nthe\nstring\\\\'with\nextra\njunk" @lexer.slurpstring("'") @lexer.line.should == 13 end end end describe Puppet::Parser::Lexer::Token do before do @token = Puppet::Parser::Lexer::Token.new(%r{something}, :NAME) end [:regex, :name, :string, :skip, :incr_line, :skip_text, :accumulate].each do |param| it "should have a #{param.to_s} reader" do @token.should be_respond_to(param) end it "should have a #{param.to_s} writer" do @token.should be_respond_to(param.to_s + "=") end end end describe Puppet::Parser::Lexer::Token, "when initializing" do it "should create a regex if the first argument is a string" do Puppet::Parser::Lexer::Token.new("something", :NAME).regex.should == %r{something} end it "should set the string if the first argument is one" do Puppet::Parser::Lexer::Token.new("something", :NAME).string.should == "something" end it "should set the regex if the first argument is one" do Puppet::Parser::Lexer::Token.new(%r{something}, :NAME).regex.should == %r{something} end end describe Puppet::Parser::Lexer::TokenList do before do @list = Puppet::Parser::Lexer::TokenList.new end it "should have a method for retrieving tokens by the name" do token = @list.add_token :name, "whatever" @list[:name].should equal(token) end it "should have a method for retrieving string tokens by the string" do token = @list.add_token :name, "whatever" @list.lookup("whatever").should equal(token) end it "should add tokens to the list when directed" do token = @list.add_token :name, "whatever" @list[:name].should equal(token) end it "should have a method for adding multiple tokens at once" do @list.add_tokens "whatever" => :name, "foo" => :bar @list[:name].should_not be_nil @list[:bar].should_not be_nil end it "should fail to add tokens sharing a name with an existing token" do @list.add_token :name, "whatever" lambda { @list.add_token :name, "whatever" }.should raise_error(ArgumentError) end it "should set provided options on tokens being added" do token = @list.add_token :name, "whatever", :skip_text => true token.skip_text.should == true end it "should define any provided blocks as a :convert method" do token = @list.add_token(:name, "whatever") do "foo" end token.convert.should == "foo" end it "should store all string tokens in the :string_tokens list" do one = @list.add_token(:name, "1") @list.string_tokens.should be_include(one) end it "should store all regex tokens in the :regex_tokens list" do one = @list.add_token(:name, %r{one}) @list.regex_tokens.should be_include(one) end it "should not store string tokens in the :regex_tokens list" do one = @list.add_token(:name, "1") @list.regex_tokens.should_not be_include(one) end it "should not store regex tokens in the :string_tokens list" do one = @list.add_token(:name, %r{one}) @list.string_tokens.should_not be_include(one) end it "should sort the string tokens inversely by length when asked" do one = @list.add_token(:name, "1") two = @list.add_token(:other, "12") @list.sort_tokens @list.string_tokens.should == [two, one] end end describe Puppet::Parser::Lexer::TOKENS do before do @lexer = Puppet::Parser::Lexer.new end { :LBRACK => '[', :RBRACK => ']', :LBRACE => '{', :RBRACE => '}', :LPAREN => '(', :RPAREN => ')', :EQUALS => '=', :ISEQUAL => '==', :GREATEREQUAL => '>=', :GREATERTHAN => '>', :LESSTHAN => '<', :LESSEQUAL => '<=', :NOTEQUAL => '!=', :NOT => '!', :COMMA => ',', :DOT => '.', :COLON => ':', :AT => '@', :LLCOLLECT => '<<|', :RRCOLLECT => '|>>', :LCOLLECT => '<|', :RCOLLECT => '|>', :SEMIC => ';', :QMARK => '?', :BACKSLASH => '\\', :FARROW => '=>', :PARROW => '+>', :APPENDS => '+=', :PLUS => '+', :MINUS => '-', :DIV => '/', :TIMES => '*', :LSHIFT => '<<', :RSHIFT => '>>', :MATCH => '=~', :NOMATCH => '!~', :IN_EDGE => '->', :OUT_EDGE => '<-', :IN_EDGE_SUB => '~>', :OUT_EDGE_SUB => '<~', }.each do |name, string| it "should have a token named #{name.to_s}" do Puppet::Parser::Lexer::TOKENS[name].should_not be_nil end it "should match '#{string}' for the token #{name.to_s}" do Puppet::Parser::Lexer::TOKENS[name].string.should == string end end { "case" => :CASE, "class" => :CLASS, "default" => :DEFAULT, "define" => :DEFINE, "import" => :IMPORT, "if" => :IF, "elsif" => :ELSIF, "else" => :ELSE, "inherits" => :INHERITS, "node" => :NODE, "and" => :AND, "or" => :OR, "undef" => :UNDEF, "false" => :FALSE, "true" => :TRUE, "in" => :IN, }.each do |string, name| it "should have a keyword named #{name.to_s}" do Puppet::Parser::Lexer::KEYWORDS[name].should_not be_nil end it "should have the keyword for #{name.to_s} set to #{string}" do Puppet::Parser::Lexer::KEYWORDS[name].string.should == string end end # These tokens' strings don't matter, just that the tokens exist. [:STRING, :DQPRE, :DQMID, :DQPOST, :BOOLEAN, :NAME, :NUMBER, :COMMENT, :MLCOMMENT, :RETURN, :SQUOTE, :DQUOTE, :VARIABLE].each do |name| it "should have a token named #{name.to_s}" do Puppet::Parser::Lexer::TOKENS[name].should_not be_nil end end end -describe Puppet::Parser::Lexer::TOKENS[:CLASSNAME] do - before { @token = Puppet::Parser::Lexer::TOKENS[:CLASSNAME] } - - it "should match against lower-case alpha-numeric terms separated by double colons" do - @token.regex.should =~ "one::two" - end - - it "should match against many lower-case alpha-numeric terms separated by double colons" do - @token.regex.should =~ "one::two::three::four::five" - end - - it "should match against lower-case alpha-numeric terms prefixed by double colons" do - @token.regex.should =~ "::one" - end -end - describe Puppet::Parser::Lexer::TOKENS[:CLASSREF] do before { @token = Puppet::Parser::Lexer::TOKENS[:CLASSREF] } it "should match against single upper-case alpha-numeric terms" do @token.regex.should =~ "One" end it "should match against upper-case alpha-numeric terms separated by double colons" do @token.regex.should =~ "One::Two" end it "should match against many upper-case alpha-numeric terms separated by double colons" do @token.regex.should =~ "One::Two::Three::Four::Five" end it "should match against upper-case alpha-numeric terms prefixed by double colons" do @token.regex.should =~ "::One" end end describe Puppet::Parser::Lexer::TOKENS[:NAME] do before { @token = Puppet::Parser::Lexer::TOKENS[:NAME] } it "should match against lower-case alpha-numeric terms" do @token.regex.should =~ "one-two" end it "should return itself and the value if the matched term is not a keyword" do Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(nil) @token.convert(stub("lexer"), "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"] end it "should return the keyword token and the value if the matched term is a keyword" do keyword = stub 'keyword', :name => :testing Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword) @token.convert(stub("lexer"), "myval").should == [keyword, "myval"] end it "should return the BOOLEAN token and 'true' if the matched term is the string 'true'" do keyword = stub 'keyword', :name => :TRUE Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword) @token.convert(stub('lexer'), "true").should == [Puppet::Parser::Lexer::TOKENS[:BOOLEAN], true] end it "should return the BOOLEAN token and 'false' if the matched term is the string 'false'" do keyword = stub 'keyword', :name => :FALSE Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword) @token.convert(stub('lexer'), "false").should == [Puppet::Parser::Lexer::TOKENS[:BOOLEAN], false] end + + it "should match against lower-case alpha-numeric terms separated by double colons" do + @token.regex.should =~ "one::two" + end + + it "should match against many lower-case alpha-numeric terms separated by double colons" do + @token.regex.should =~ "one::two::three::four::five" + end + + it "should match against lower-case alpha-numeric terms prefixed by double colons" do + @token.regex.should =~ "::one" + end + + it "should match against nested terms starting with numbers" do + @token.regex.should =~ "::1one::2two::3three" + end end describe Puppet::Parser::Lexer::TOKENS[:NUMBER] do before do @token = Puppet::Parser::Lexer::TOKENS[:NUMBER] @regex = @token.regex end it "should match against numeric terms" do @regex.should =~ "2982383139" end it "should match against float terms" do @regex.should =~ "29823.235" end it "should match against hexadecimal terms" do @regex.should =~ "0xBEEF0023" end it "should match against float with exponent terms" do @regex.should =~ "10e23" end it "should match against float terms with negative exponents" do @regex.should =~ "10e-23" end it "should match against float terms with fractional parts and exponent" do @regex.should =~ "1.234e23" end it "should return the NAME token and the value" do @token.convert(stub("lexer"), "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"] end end describe Puppet::Parser::Lexer::TOKENS[:COMMENT] do before { @token = Puppet::Parser::Lexer::TOKENS[:COMMENT] } it "should match against lines starting with '#'" do @token.regex.should =~ "# this is a comment" end it "should be marked to get skipped" do @token.skip?.should be_true end it "should be marked to accumulate" do @token.accumulate?.should be_true end it "'s block should return the comment without the #" do @token.convert(@lexer,"# this is a comment")[1].should == "this is a comment" end end describe Puppet::Parser::Lexer::TOKENS[:MLCOMMENT] do before do @token = Puppet::Parser::Lexer::TOKENS[:MLCOMMENT] @lexer = stub 'lexer', :line => 0 end it "should match against lines enclosed with '/*' and '*/'" do @token.regex.should =~ "/* this is a comment */" end it "should match multiple lines enclosed with '/*' and '*/'" do @token.regex.should =~ """/* this is a comment */""" end it "should increase the lexer current line number by the amount of lines spanned by the comment" do @lexer.expects(:line=).with(2) @token.convert(@lexer, "1\n2\n3") end it "should not greedily match comments" do match = @token.regex.match("/* first */ word /* second */") match[1].should == " first " end it "should be marked to accumulate" do @token.accumulate?.should be_true end it "'s block should return the comment without the comment marks" do @lexer.stubs(:line=).with(0) @token.convert(@lexer,"/* this is a comment */")[1].should == "this is a comment" end end describe Puppet::Parser::Lexer::TOKENS[:RETURN] do before { @token = Puppet::Parser::Lexer::TOKENS[:RETURN] } it "should match against carriage returns" do @token.regex.should =~ "\n" end it "should be marked to initiate text skipping" do @token.skip_text.should be_true end it "should be marked to increment the line" do @token.incr_line.should be_true end end def tokens_scanned_from(s) lexer = Puppet::Parser::Lexer.new lexer.string = s lexer.fullscan[0..-2] end describe Puppet::Parser::Lexer,"when lexing strings" do { %q{'single quoted string')} => [[:STRING,'single quoted string']], %q{"double quoted string"} => [[:STRING,'double quoted string']], %q{'single quoted string with an escaped "\\'"'} => [[:STRING,'single quoted string with an escaped "\'"']], %q{'single quoted string with an escaped "\$"'} => [[:STRING,'single quoted string with an escaped "\$"']], %q{'single quoted string with an escaped "\."'} => [[:STRING,'single quoted string with an escaped "\."']], %q{'single quoted string with an escaped "\n"'} => [[:STRING,'single quoted string with an escaped "\n"']], %q{'single quoted string with an escaped "\\\\"'} => [[:STRING,'single quoted string with an escaped "\\\\"']], %q{"string with an escaped '\\"'"} => [[:STRING,"string with an escaped '\"'"]], %q{"string with an escaped '\\$'"} => [[:STRING,"string with an escaped '$'"]], %Q{"string with a line ending with a backslash: \\\nfoo"} => [[:STRING,"string with a line ending with a backslash: foo"]], %q{"string with $v (but no braces)"} => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' (but no braces)']], %q["string with ${v} in braces"] => [[:DQPRE,"string with "],[:VARIABLE,'v'],[:DQPOST,' in braces']], %q["string with ${qualified::var} in braces"] => [[:DQPRE,"string with "],[:VARIABLE,'qualified::var'],[:DQPOST,' in braces']], %q{"string with $v and $v (but no braces)"} => [[:DQPRE,"string with "],[:VARIABLE,"v"],[:DQMID," and "],[:VARIABLE,"v"],[:DQPOST," (but no braces)"]], %q["string with ${v} and ${v} in braces"] => [[:DQPRE,"string with "],[:VARIABLE,"v"],[:DQMID," and "],[:VARIABLE,"v"],[:DQPOST," in braces"]], %q["string with ${'a nested single quoted string'} inside it."] => [[:DQPRE,"string with "],[:STRING,'a nested single quoted string'],[:DQPOST,' inside it.']], %q["string with ${['an array ',$v2]} in it."] => [[:DQPRE,"string with "],:LBRACK,[:STRING,"an array "],:COMMA,[:VARIABLE,"v2"],:RBRACK,[:DQPOST," in it."]], %q{a simple "scanner" test} => [[:NAME,"a"],[:NAME,"simple"], [:STRING,"scanner"],[:NAME,"test"]], %q{a simple 'single quote scanner' test} => [[:NAME,"a"],[:NAME,"simple"], [:STRING,"single quote scanner"],[:NAME,"test"]], %q{a harder 'a $b \c"'} => [[:NAME,"a"],[:NAME,"harder"], [:STRING,'a $b \c"']], %q{a harder "scanner test"} => [[:NAME,"a"],[:NAME,"harder"], [:STRING,"scanner test"]], %q{a hardest "scanner \"test\""} => [[:NAME,"a"],[:NAME,"hardest"],[:STRING,'scanner "test"']], %Q{a hardestest "scanner \\"test\\"\n"} => [[:NAME,"a"],[:NAME,"hardestest"],[:STRING,%Q{scanner "test"\n}]], %q{function("call")} => [[:NAME,"function"],[:LPAREN,"("],[:STRING,'call'],[:RPAREN,")"]], %q["string with ${(3+5)/4} nested math."] => [[:DQPRE,"string with "],:LPAREN,[:NAME,"3"],:PLUS,[:NAME,"5"],:RPAREN,:DIV,[:NAME,"4"],[:DQPOST," nested math."]], %q["$$$$"] => [[:STRING,"$$$$"]], %q["$variable"] => [[:DQPRE,""],[:VARIABLE,"variable"],[:DQPOST,""]], %q["$var$other"] => [[:DQPRE,""],[:VARIABLE,"var"],[:DQMID,""],[:VARIABLE,"other"],[:DQPOST,""]], %q["foo$bar$"] => [[:DQPRE,"foo"],[:VARIABLE,"bar"],[:DQPOST,"$"]], %q["foo$$bar"] => [[:DQPRE,"foo$"],[:VARIABLE,"bar"],[:DQPOST,""]], %q[""] => [[:STRING,""]], + %q["123 456 789 0"] => [[:STRING,"123 456 789 0"]], + %q["${123} 456 $0"] => [[:DQPRE,""],[:VARIABLE,"123"],[:DQMID," 456 "],[:VARIABLE,"0"],[:DQPOST,""]], + %q["$foo::::bar"] => [[:DQPRE,""],[:VARIABLE,"foo"],[:DQPOST,"::::bar"]] }.each { |src,expected_result| it "should handle #{src} correctly" do tokens_scanned_from(src).should be_like(*expected_result) end } end describe Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR] do before { @token = Puppet::Parser::Lexer::TOKENS[:DOLLAR_VAR] } it "should match against alpha words prefixed with '$'" do @token.regex.should =~ '$this_var' end it "should return the VARIABLE token and the variable name stripped of the '$'" do @token.convert(stub("lexer"), "$myval").should == [Puppet::Parser::Lexer::TOKENS[:VARIABLE], "myval"] end end describe Puppet::Parser::Lexer::TOKENS[:REGEX] do before { @token = Puppet::Parser::Lexer::TOKENS[:REGEX] } it "should match against any expression enclosed in //" do @token.regex.should =~ '/this is a regex/' end it 'should not match if there is \n in the regex' do @token.regex.should_not =~ "/this is \n a regex/" end describe "when scanning" do it "should not consider escaped slashes to be the end of a regex" do tokens_scanned_from("$x =~ /this \\/ foo/").should be_like(__,__,[:REGEX,%r{this / foo}]) end it "should not lex chained division as a regex" do tokens_scanned_from("$x = $a/$b/$c").collect { |name, data| name }.should_not be_include( :REGEX ) end it "should accept a regular expression after NODE" do tokens_scanned_from("node /www.*\.mysite\.org/").should be_like(__,[:REGEX,Regexp.new("www.*\.mysite\.org")]) end it "should accept regular expressions in a CASE" do s = %q{case $variable { "something": {$othervar = 4096 / 2} /regex/: {notice("this notably sucks")} } } tokens_scanned_from(s).should be_like( :CASE,:VARIABLE,:LBRACE,:STRING,:COLON,:LBRACE,:VARIABLE,:EQUALS,:NAME,:DIV,:NAME,:RBRACE,[:REGEX,/regex/],:COLON,:LBRACE,:NAME,:LPAREN,:STRING,:RPAREN,:RBRACE,:RBRACE ) end end it "should return the REGEX token and a Regexp" do @token.convert(stub("lexer"), "/myregex/").should == [Puppet::Parser::Lexer::TOKENS[:REGEX], Regexp.new(/myregex/)] end end describe Puppet::Parser::Lexer, "when lexing comments" do before { @lexer = Puppet::Parser::Lexer.new } it "should accumulate token in munge_token" do token = stub 'token', :skip => true, :accumulate? => true, :incr_line => nil, :skip_text => false token.stubs(:convert).with(@lexer, "# this is a comment").returns([token, " this is a comment"]) @lexer.munge_token(token, "# this is a comment") @lexer.munge_token(token, "# this is a comment") @lexer.getcomment.should == " this is a comment\n this is a comment\n" end it "should add a new comment stack level on LBRACE" do @lexer.string = "{" @lexer.expects(:commentpush) @lexer.fullscan end it "should add a new comment stack level on LPAREN" do @lexer.string = "(" @lexer.expects(:commentpush) @lexer.fullscan end it "should pop the current comment on RPAREN" do @lexer.string = ")" @lexer.expects(:commentpop) @lexer.fullscan end it "should return the current comments on getcomment" do @lexer.string = "# comment" @lexer.fullscan @lexer.getcomment.should == "comment\n" end it "should discard the previous comments on blank line" do @lexer.string = "# 1\n\n# 2" @lexer.fullscan @lexer.getcomment.should == "2\n" end it "should skip whitespace before lexing the next token after a non-token" do tokens_scanned_from("/* 1\n\n */ \ntest").should be_like([:NAME, "test"]) end it "should not return comments seen after the current line" do @lexer.string = "# 1\n\n# 2" @lexer.fullscan @lexer.getcomment(1).should == "" end it "should return a comment seen before the current line" do @lexer.string = "# 1\n# 2" @lexer.fullscan @lexer.getcomment(2).should == "1\n2\n" end end # FIXME: We need to rewrite all of these tests, but I just don't want to take the time right now. describe "Puppet::Parser::Lexer in the old tests" do before { @lexer = Puppet::Parser::Lexer.new } it "should do simple lexing" do { %q{\\} => [[:BACKSLASH,"\\"]], %q{simplest scanner test} => [[:NAME,"simplest"],[:NAME,"scanner"],[:NAME,"test"]], %Q{returned scanner test\n} => [[:NAME,"returned"],[:NAME,"scanner"],[:NAME,"test"]] }.each { |source,expected| tokens_scanned_from(source).should be_like(*expected) } end it "should fail usefully" do lambda { tokens_scanned_from('^') }.should raise_error(RuntimeError) end it "should fail if the string is not set" do lambda { @lexer.fullscan }.should raise_error(Puppet::LexError) end it "should correctly identify keywords" do tokens_scanned_from("case").should be_like([:CASE, "case"]) end it "should correctly parse class references" do %w{Many Different Words A Word}.each { |t| tokens_scanned_from(t).should be_like([:CLASSREF,t])} end # #774 it "should correctly parse namespaced class refernces token" do %w{Foo ::Foo Foo::Bar ::Foo::Bar}.each { |t| tokens_scanned_from(t).should be_like([:CLASSREF, t]) } end it "should correctly parse names" do %w{this is a bunch of names}.each { |t| tokens_scanned_from(t).should be_like([:NAME,t]) } end it "should correctly parse names with numerals" do %w{1name name1 11names names11}.each { |t| tokens_scanned_from(t).should be_like([:NAME,t]) } end it "should correctly parse empty strings" do lambda { tokens_scanned_from('$var = ""') }.should_not raise_error end it "should correctly parse virtual resources" do tokens_scanned_from("@type {").should be_like([:AT, "@"], [:NAME, "type"], [:LBRACE, "{"]) end it "should correctly deal with namespaces" do @lexer.string = %{class myclass} @lexer.fullscan @lexer.namespace.should == "myclass" @lexer.namepop @lexer.namespace.should == "" @lexer.string = "class base { class sub { class more" @lexer.fullscan @lexer.namespace.should == "base::sub::more" @lexer.namepop @lexer.namespace.should == "base::sub" end it "should not put class instantiation on the namespace" do @lexer.string = "class base { class sub { class { mode" @lexer.fullscan @lexer.namespace.should == "base::sub" end it "should correctly handle fully qualified names" do @lexer.string = "class base { class sub::more {" @lexer.fullscan @lexer.namespace.should == "base::sub::more" @lexer.namepop @lexer.namespace.should == "base" end it "should correctly lex variables" do - ["$variable", "$::variable", "$qualified::variable", "$further::qualified::variable"].each do |string| + ["$variable", "$::variable", "$qualified::variable", "$further::qualified::variable", "$hyphenated-variable", "$-variable-with-leading-dash"].each do |string| tokens_scanned_from(string).should be_like([:VARIABLE,string.sub(/^\$/,'')]) end end + + it "should not include whitespace in a variable" do + tokens_scanned_from("$foo bar").should_not be_like([:VARIABLE, "foo bar"]) + end + it "should not include excess colons in a variable" do + tokens_scanned_from("$foo::::bar").should_not be_like([:VARIABLE, "foo::::bar"]) + end end describe "Puppet::Parser::Lexer in the old tests when lexing example files" do my_fixtures('*.pp') do |file| it "should correctly lex #{file}" do lexer = Puppet::Parser::Lexer.new lexer.file = file lambda { lexer.fullscan }.should_not raise_error end end end describe "when trying to lex an non-existent file" do include PuppetSpec::Files it "should return an empty list of tokens" do lexer = Puppet::Parser::Lexer.new lexer.file = nofile = tmpfile('lexer') File.exists?(nofile).should == false lexer.fullscan.should == [[false,false]] end end