| Current Path : /opt/puppetlabs/puppet/lib/ruby/vendor_ruby/puppet/pops/parser/ |
| Current File : //opt/puppetlabs/puppet/lib/ruby/vendor_ruby/puppet/pops/parser/egrammar.ra |
# vim: syntax=ruby
# Parser using the Pops model, expression based
class Puppet::Pops::Parser::Parser
token STRING DQPRE DQMID DQPOST
token WORD
token LBRACK RBRACK LBRACE RBRACE SYMBOL FARROW COMMA TRUE
token FALSE EQUALS APPENDS DELETES LESSEQUAL NOTEQUAL DOT COLON LLCOLLECT RRCOLLECT
token QMARK WSLPAREN LPAREN RPAREN ISEQUAL GREATEREQUAL GREATERTHAN LESSTHAN
token IF ELSE
token DEFINE ELSIF VARIABLE CLASS INHERITS NODE BOOLEAN
token NAME SEMIC CASE DEFAULT AT ATAT LCOLLECT RCOLLECT CLASSREF
token NOT OR AND UNDEF PARROW PLUS MINUS TIMES DIV LSHIFT RSHIFT UMINUS
token MATCH NOMATCH REGEX IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
token IN UNLESS PIPE
token LAMBDA SELBRACE
token NUMBER
token HEREDOC SUBLOCATE
token RENDER_STRING RENDER_EXPR EPP_START EPP_END EPP_END_TRIM
token FUNCTION
token TYPE
token PRIVATE ATTR
token APPLICATION PRODUCES CONSUMES SITE
token PLAN APPLY
token LOW
prechigh
left HIGH
left SEMIC
left PIPE
left LPAREN WSLPAREN
left RPAREN
left DOT
nonassoc EPP_START
left LBRACK LISTSTART
left RBRACK
left LCOLLECT LLCOLLECT
right NOT
nonassoc SPLAT
nonassoc UMINUS
left IN
left MATCH NOMATCH
left TIMES DIV MODULO
left MINUS PLUS
left LSHIFT RSHIFT
left NOTEQUAL ISEQUAL
left GREATEREQUAL GREATERTHAN LESSTHAN LESSEQUAL
left QMARK
left AND
left OR
left LBRACE
left SELBRACE
left RBRACE
right AT ATAT
right APPENDS DELETES EQUALS
left IN_EDGE OUT_EDGE IN_EDGE_SUB OUT_EDGE_SUB
left FARROW
left COMMA
nonassoc RENDER_EXPR
nonassoc RENDER_STRING
left LOW
preclow
rule
# Produces [Model::Program] with a body containing what was parsed
program
: statements { result = create_program(Factory.block_or_expression(val[0])) }
| epp_expression { result = create_program(val[0]) }
| { result = create_empty_program }
# Produces a semantic model (non validated, but semantically adjusted).
statements
: syntactic_statements { result = transform_calls(val[0]) }
# Collects sequence of elements into a list that the statements rule can transform
# (Needed because language supports function calls without parentheses around arguments).
# Produces Array<Model::Expression>
#
syntactic_statements
: syntactic_statement { result = [val[0]]}
| syntactic_statements SEMIC syntactic_statement { result = val[0].push val[2] }
| syntactic_statements syntactic_statement { result = val[0].push val[1] }
# Produce a single expression or Array of expression
# This exists to handle multiple arguments to non parenthesized function call. If e is expression,
# the a program can consists of e [e,e,e] where the first may be a name of a function to call.
#
syntactic_statement
: assignment =LOW { result = val[0] }
| syntactic_statement COMMA assignment =LOW { result = aryfy(val[0]).push(val[1]).push(val[2]) }
# Assignment (is right recursive since assignment is right associative)
assignment
: relationship =LOW
| relationship EQUALS assignment { result = val[0].set(val[2]) ; loc result, val[1] }
| relationship APPENDS assignment { result = val[0].plus_set(val[2]) ; loc result, val[1] }
| relationship DELETES assignment { result = val[0].minus_set(val[2]); loc result, val[1] }
# Argument is like assignment but permits KEY_ENTRY which it converts it to a HASH_UNFOLDED
argument
: assignment
| hashpair { result = Factory.HASH_UNFOLDED([val[0]]); loc result, val[0] }
# Repeated adjacent HASH_UNFOLDED entries merged into one HASH_UNFOLDED
arguments
: argument { result = [val[0]] }
| arguments COMMA argument { result = Factory.ARGUMENTS(val[0], val[2]) }
relationship
: resource =LOW
| relationship IN_EDGE resource { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
| relationship IN_EDGE_SUB resource { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
| relationship OUT_EDGE resource { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
| relationship OUT_EDGE_SUB resource { result = val[0].relop(val[1][:value], val[2]); loc result, val[1] }
#-- RESOURCE
#
resource
: expression = LOW
#---VIRTUAL
| AT resource {
result = val[1]
unless Factory.set_resource_form(result, 'virtual')
# This is equivalent to a syntax error - additional semantic restrictions apply
error val[0], "Virtual (@) can only be applied to a Resource Expression"
end
# relocate the result
loc result, val[0], val[1]
}
#---EXPORTED
| ATAT resource {
result = val[1]
unless Factory.set_resource_form(result, 'exported')
# This is equivalent to a syntax error - additional semantic restrictions apply
error val[0], "Exported (@@) can only be applied to a Resource Expression"
end
# relocate the result
loc result, val[0], val[1]
}
#---RESOURCE TITLED 3x and 4x
| resource LBRACE expression COLON attribute_operations additional_resource_bodies RBRACE {
bodies = [Factory.RESOURCE_BODY(val[2], val[4])] + val[5]
result = Factory.RESOURCE(val[0], bodies)
loc result, val[0], val[6]
}
#---CLASS RESOURCE
| CLASS LBRACE resource_bodies endsemi RBRACE {
result = Factory.RESOURCE(Factory.fqn(token_text(val[0])), val[2])
loc result, val[0], val[4]
}
# --RESOURCE 3X Expression
# Handles both 3x overrides and defaults (i.e. single resource_body without title colon)
# Slated for possible deprecation since it requires transformation and mix static/evaluation check
#
| resource LBRACE attribute_operations endcomma RBRACE {
result = case Factory.resource_shape(val[0])
when :resource, :class
# This catches deprecated syntax.
# If the attribute operations does not include +>, then the found expression
# is actually a LEFT followed by LITERAL_HASH
#
unless tmp = transform_resource_wo_title(val[0], val[2], val[1], val[4])
error val[1], "Syntax error resource body without title or hash with +>"
end
tmp
when :defaults
Factory.RESOURCE_DEFAULTS(val[0], val[2])
when :override
# This was only done for override in original - TODO should it be here at all
Factory.RESOURCE_OVERRIDE(val[0], val[2])
else
error val[0], "Expression is not valid as a resource, resource-default, or resource-override"
end
loc result, val[0], val[4]
}
resource_body
: expression COLON attribute_operations endcomma { result = Factory.RESOURCE_BODY(val[0], val[2]) }
resource_bodies
: resource_body =HIGH { result = [val[0]] }
| resource_bodies SEMIC resource_body =HIGH { result = val[0].push val[2] }
# This is a rule for the intermediate state where RACC has seen enough tokens to understand that
# what is expressed is a Resource Expression, it now has to get to the finishing line
#
additional_resource_bodies
: endcomma { result = [] }
| endcomma SEMIC { result = [] }
| endcomma SEMIC resource_bodies endsemi { result = val[2] }
#-- EXPRESSION
#
expression
: primary_expression
| capability_mapping
| call_function_expression
| bracketed_expression
| expression IN expression { result = val[0].in val[2] ; loc result, val[1] }
| expression MATCH expression { result = val[0] =~ val[2] ; loc result, val[1] }
| expression NOMATCH expression { result = val[0].mne val[2] ; loc result, val[1] }
| expression PLUS expression { result = val[0] + val[2] ; loc result, val[1] }
| expression MINUS expression { result = val[0] - val[2] ; loc result, val[1] }
| expression DIV expression { result = val[0] / val[2] ; loc result, val[1] }
| expression TIMES expression { result = val[0] * val[2] ; loc result, val[1] }
| expression MODULO expression { result = val[0] % val[2] ; loc result, val[1] }
| expression LSHIFT expression { result = val[0] << val[2] ; loc result, val[1] }
| expression RSHIFT expression { result = val[0] >> val[2] ; loc result, val[1] }
| MINUS expression =UMINUS { result = val[1].minus ; loc result, val[0] }
| TIMES expression =SPLAT { result = val[1].unfold ; loc result, val[0] }
| expression NOTEQUAL expression { result = val[0].ne val[2] ; loc result, val[1] }
| expression ISEQUAL expression { result = val[0].eq val[2] ; loc result, val[1] }
| expression GREATERTHAN expression { result = val[0] > val[2] ; loc result, val[1] }
| expression GREATEREQUAL expression { result = val[0] >= val[2] ; loc result, val[1] }
| expression LESSTHAN expression { result = val[0] < val[2] ; loc result, val[1] }
| expression LESSEQUAL expression { result = val[0] <= val[2] ; loc result, val[1] }
| NOT expression { result = val[1].not ; loc result, val[0] }
| expression AND expression { result = val[0].and val[2] ; loc result, val[1] }
| expression OR expression { result = val[0].or val[2] ; loc result, val[1] }
| expression QMARK selector_entries { result = val[0].select(*val[2]) ; loc result, val[0] }
| LPAREN assignment RPAREN { result = val[1].paren ; loc result, val[0] }
| WSLPAREN assignment RPAREN { result = val[1].paren ; loc result, val[0] }
bracketed_expression
: expression LBRACK access_args endcomma RBRACK =LBRACK { result = val[0].access(val[2]); loc result, val[0], val[4] }
access_args
: access_arg { result = [val[0]] }
| access_args COMMA access_arg { result = Factory.ARGUMENTS(val[0], val[2]) }
access_arg
: expression
| hashpair { result = Factory.HASH_UNFOLDED([val[0]]); loc result, val[0] }
#---EXPRESSIONS
# (i.e. "argument list")
#
# This expression list can not contain function calls without parentheses around arguments
# Produces Array<Model::Expression>
#
expressions
: expression { result = [val[0]] }
| expressions COMMA expression { result = val[0].push(val[2]) }
primary_expression
: variable
| call_method_with_lambda_expression
| collection_expression
| case_expression
| if_expression
| unless_expression
| definition_expression
| application_expression
| hostclass_expression
| plan_expression
| apply_expression
| node_definition_expression
| site_definition_expression
| epp_render_expression
| function_definition
| type_alias
| type_definition
| reserved_word
| array
| hash
| regex
| quotedtext
| type
| NUMBER { result = Factory.NUMBER(val[0][:value]) ; loc result, val[0] }
| BOOLEAN { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
| DEFAULT { result = Factory.literal(:default) ; loc result, val[0] }
| UNDEF { result = Factory.literal(:undef) ; loc result, val[0] }
| NAME { result = Factory.QNAME_OR_NUMBER(val[0][:value]) ; loc result, val[0] }
#---CALL FUNCTION
#
# Produces Model::CallNamedFunction
call_function_expression
: call_function_start arguments endcomma RPAREN {
result = Factory.CALL_NAMED(val[0], true, val[1])
loc result, val[0], val[3]
}
| call_function_start RPAREN {
result = Factory.CALL_NAMED(val[0], true, [])
loc result, val[0], val[1]
}
| call_function_start arguments endcomma RPAREN lambda {
result = Factory.CALL_NAMED(val[0], true, val[1])
loc result, val[0], val[4]
result.lambda = val[4]
}
| call_function_start RPAREN lambda {
result = Factory.CALL_NAMED(val[0], true, [])
loc result, val[0], val[2]
result.lambda = val[2]
}
call_function_start
: expression LPAREN { result = val[0] }
| TYPE LPAREN { result = Factory.QNAME(val[0][:value]); loc result, val[0] }
#---CALL METHOD
#
call_method_with_lambda_expression
: call_method_expression =LOW { result = val[0] }
| call_method_expression lambda { result = val[0]; val[0].lambda = val[1] }
call_method_expression
: named_access LPAREN arguments RPAREN { result = Factory.CALL_METHOD(val[0], val[2]); loc result, val[1], val[3] }
| named_access LPAREN RPAREN { result = Factory.CALL_METHOD(val[0], []); loc result, val[1], val[3] }
| named_access =LOW { result = Factory.CALL_METHOD(val[0], []); loc result, val[0] }
named_access
: expression DOT NAME {
result = val[0].dot(Factory.fqn(val[2][:value]))
loc result, val[1], val[2]
}
| expression DOT TYPE {
result = val[0].dot(Factory.fqn(val[2][:value]))
loc result, val[1], val[2]
}
#---LAMBDA
#
lambda
: lambda_parameter_list opt_return_type lambda_rest {
result = Factory.LAMBDA(val[0][:value], val[2][:value], val[1])
loc result, val[0][:start], val[2][:end]
}
lambda_rest
: LBRACE statements RBRACE { result = {:end => val[2], :value =>val[1] } }
| LBRACE RBRACE { result = {:end => val[1], :value => nil } }
lambda_parameter_list
: PIPE PIPE { result = {:start => val[0], :value => [] } }
| PIPE parameters endcomma PIPE { result = {:start => val[0], :value => val[1] } }
#---CONDITIONALS
#--IF
#
if_expression
: IF if_part {
result = val[1]
loc(result, val[0], val[1])
}
# Produces Model::IfExpression
if_part
: expression LBRACE statements RBRACE else {
result = Factory.IF(val[0], Factory.block_or_expression(val[2], val[1], val[3]), val[4])
loc(result, val[0], (val[4] ? val[4] : val[3]))
}
| expression LBRACE RBRACE else {
result = Factory.IF(val[0], nil, val[3])
loc(result, val[0], (val[3] ? val[3] : val[2]))
}
# Produces [Model::Expression, nil] - nil if there is no else or elsif part
else
: # nothing
| ELSIF if_part {
result = val[1]
loc(result, val[0], val[1])
}
| ELSE LBRACE statements RBRACE {
result = Factory.block_or_expression(val[2], val[1], val[3])
}
| ELSE LBRACE RBRACE {
result = nil # don't think a nop is needed here either
}
#--UNLESS
#
unless_expression
: UNLESS expression LBRACE statements RBRACE unless_else {
result = Factory.UNLESS(val[1], Factory.block_or_expression(val[3], val[2], val[4]), val[5])
loc result, val[0], val[4]
}
| UNLESS expression LBRACE RBRACE unless_else {
result = Factory.UNLESS(val[1], nil, val[4])
loc result, val[0], val[4]
}
# Different from else part of if, since "elsif" is not supported, but 'else' is
#
# Produces [Model::Expression, nil] - nil if there is no else or elsif part
unless_else
: # nothing
| ELSE LBRACE statements RBRACE {
result = Factory.block_or_expression(val[2], val[1], val[3])
}
| ELSE LBRACE RBRACE {
result = nil # don't think a nop is needed here either
}
#--- CASE EXPRESSION
#
case_expression
: CASE expression LBRACE case_options RBRACE {
result = Factory.CASE(val[1], *val[3])
loc result, val[0], val[4]
}
# Produces Array<Model::CaseOption>
case_options
: case_option { result = [val[0]] }
| case_options case_option { result = val[0].push val[1] }
# Produced Model::CaseOption (aka When)
case_option
: expressions COLON LBRACE options_statements RBRACE {
result = Factory.WHEN(val[0], val[3]); loc result, val[1], val[4]
}
options_statements
: nil
| statements
# This special construct is required or racc will produce the wrong result when the selector entry
# LHS is generalized to any expression (LBRACE looks like a hash). Thus it is not possible to write
# a selector with a single entry where the entry LHS is a hash.
# The SELBRACE token is a LBRACE that follows a QMARK, and this is produced by the lexer with a lookback
# Produces Array<Model::SelectorEntry>
#
selector_entries
: selector_entry
| SELBRACE selector_entry_list endcomma RBRACE {
result = val[1]
}
# Produces Array<Model::SelectorEntry>
selector_entry_list
: selector_entry { result = [val[0]] }
| selector_entry_list COMMA selector_entry { result = val[0].push val[2] }
# Produces a Model::SelectorEntry
# This FARROW wins over FARROW in Hash
selector_entry
: expression FARROW expression { result = Factory.MAP(val[0], val[2]) ; loc result, val[1] }
#---COLLECTION
#
# A Collection is a predicate applied to a set of objects with an implied context (used variables are
# attributes of the object.
# i.e. this is equivalent to source.select(QUERY).apply(ATTRIBUTE_OPERATIONS)
#
collection_expression
: expression collect_query LBRACE attribute_operations endcomma RBRACE {
result = Factory.COLLECT(val[0], val[1], val[3])
loc result, val[0], val[5]
}
| expression collect_query =LOW {
result = Factory.COLLECT(val[0], val[1], [])
loc result, val[0], val[1]
}
collect_query
: LCOLLECT optional_query RCOLLECT { result = Factory.VIRTUAL_QUERY(val[1]) ; loc result, val[0], val[2] }
| LLCOLLECT optional_query RRCOLLECT { result = Factory.EXPORTED_QUERY(val[1]) ; loc result, val[0], val[2] }
optional_query
: nil
| expression
#---ATTRIBUTE OPERATIONS (Not an expression)
#
attribute_operations
: { result = [] }
| attribute_operation { result = [val[0]] }
| attribute_operations COMMA attribute_operation { result = val[0].push(val[2]) }
# Produces String
# QUESTION: Why is BOOLEAN valid as an attribute name?
#
attribute_name
: NAME
| keyword
# In this version, illegal combinations are validated instead of producing syntax errors
# (Can give nicer error message "+> is not applicable to...")
# Produces Model::AttributeOperation
#
attribute_operation
: attribute_name FARROW expression {
result = Factory.ATTRIBUTE_OP(val[0][:value], '=>', val[2])
loc result, val[0], val[2]
}
| attribute_name PARROW expression {
result = Factory.ATTRIBUTE_OP(val[0][:value], '+>', val[2])
loc result, val[0], val[2]
}
| TIMES FARROW expression {
result = Factory.ATTRIBUTES_OP(val[2]) ; loc result, val[0], val[2]
}
#---DEFINE
#
# Produces Model::Definition
#
definition_expression
: DEFINE classname parameter_list LBRACE opt_statements RBRACE {
definition = Factory.DEFINITION(classname(val[1][:value]), val[2], val[4])
loc(definition, val[0], val[5])
result = add_definition(definition)
# New lexer does not keep track of this, this is done in validation
if @lexer.respond_to?(:'indefine=')
@lexer.indefine = false
end
}
#---APPLICATION
application_expression
: APPLICATION classname parameter_list LBRACE opt_statements RBRACE {
definition = Factory.APPLICATION(classname(val[1][:value]), val[2], val[4])
loc(definition, val[0], val[5])
result = add_definition(definition)
}
capability_mapping
: classname capability_kw classname LBRACE attribute_operations endcomma RBRACE {
result = Factory.CAPABILITY_MAPPING(val[1][:value],
Factory.QREF(classname(val[0][:value])),
classname(val[2][:value]), val[4])
loc result, val[0], val[6]
add_mapping(result)
}
| bracketed_expression capability_kw classname LBRACE attribute_operations endcomma RBRACE {
result = Factory.CAPABILITY_MAPPING(val[1][:value],
val[0],
classname(val[2][:value]), val[4])
loc result, val[0], val[6]
add_mapping(result)
}
capability_kw
: PRODUCES
| CONSUMES
#--PLAN
plan_expression
: PLAN stacked_classname parameter_list LBRACE opt_statements RBRACE {
# Remove this plan's name from the namestack as all nested plans have been parsed
namepop
definition = Factory.PLAN(classname(val[1][:value]), val[2], val[4])
loc(definition, val[0], val[5])
result = add_definition(definition)
}
apply_expression
: APPLY LPAREN arguments endcomma RPAREN LBRACE statements RBRACE {
result = Factory.APPLY(val[2], Factory.APPLY_BLOCK(val[6]))
loc result, val[0], val[7]
}
| APPLY LPAREN arguments endcomma RPAREN LBRACE RBRACE {
result = Factory.APPLY(val[2], Factory.APPLY_BLOCK([]))
loc result, val[0], val[6]
}
#---HOSTCLASS
#
# Produces Model::HostClassDefinition
#
hostclass_expression
: CLASS stacked_classname parameter_list classparent LBRACE opt_statements RBRACE {
# Remove this class' name from the namestack as all nested classes have been parsed
namepop
definition = Factory.HOSTCLASS(classname(val[1][:value]), val[2], token_text(val[3]), val[5])
loc(definition, val[0], val[6])
result = add_definition(definition)
}
# Record the classname so nested classes gets a fully qualified name at parse-time
# This is a separate rule since racc does not support intermediate actions.
#
stacked_classname
: classname { namestack(val[0][:value]) ; result = val[0] }
opt_statements
: statements
| nil
# Produces String, name or nil result
classparent
: nil
| INHERITS classnameordefault { result = val[1] }
# Produces String (this construct allows a class to be named "default" and to be referenced as
# the parent class.
# TODO: Investigate the validity
# Produces a String (classname), or a token (DEFAULT).
#
classnameordefault
: classname
| DEFAULT
#---SITE
#
# Produces Model::SiteDefinition
#
site_definition_expression
: SITE LBRACE statements RBRACE {
definition = Factory.SITE(val[2])
loc(definition, val[0], val[3])
result = add_definition(definition)
}
| SITE LBRACE RBRACE {
definition = Factory.SITE(nil)
loc(definition, val[0], val[2])
result = add_definition(definition)
}
#---NODE
#
# Produces Model::NodeDefinition
#
node_definition_expression
: NODE hostnames endcomma nodeparent LBRACE statements RBRACE {
definition = Factory.NODE(val[1], val[3], val[5])
loc(definition, val[0], val[6])
result = add_definition(definition)
}
| NODE hostnames endcomma nodeparent LBRACE RBRACE {
definition = Factory.NODE(val[1], val[3], nil)
loc(definition, val[0], val[5])
result = add_definition(definition)
}
# Hostnames is not a list of names, it is a list of name matchers (including a Regexp).
# (The old implementation had a special "Hostname" object with some minimal validation)
#
# Produces Array<Model::LiteralExpression>
#
hostnames
: hostname { result = [result] }
| hostnames COMMA hostname { result = val[0].push(val[2]) }
# Produces a LiteralExpression (string, :default, or regexp)
# String with interpolation is validated for better error message
hostname
: dotted_name
| quotedtext
| DEFAULT { result = Factory.literal(:default); loc result, val[0] }
| regex
dotted_name
: name_or_number { result = Factory.literal(val[0][:value]); loc result, val[0] }
| dotted_name DOT name_or_number { result = Factory.concat(val[0], '.', val[2][:value]); loc result, val[0], val[2] }
name_or_number
: NAME
| NUMBER
# Produces Expression, since hostname is an Expression
nodeparent
: nil
| INHERITS hostname { result = val[1] }
#---FUNCTION DEFINITION
#
function_definition
: FUNCTION classname parameter_list opt_return_type LBRACE opt_statements RBRACE {
definition = Factory.FUNCTION(val[1][:value], val[2], val[5], val[3])
loc(definition, val[0], val[6])
result = add_definition(definition)
}
opt_return_type
: RSHIFT type { result = val[1] }
| RSHIFT type LBRACK access_args RBRACK { result = val[1].access(val[3]) ; loc result, val[1], val[4] }
| nil
#---NAMES AND PARAMETERS COMMON TO SEVERAL RULES
# Produces String
# TODO: The error that "class" is not a valid classname is bad - classname rule is also used for other things
classname
: NAME
| WORD
| CLASSREF
| CLASS { error val[0], "'class' keyword not allowed at this location" }
| STRING { error val[0], "A quoted string is not valid as a name here" }
# Produces Array<Model::Parameter>
parameter_list
: nil { result = [] }
| LPAREN RPAREN { result = [] }
| WSLPAREN RPAREN { result = [] }
| LPAREN parameters endcomma RPAREN { result = val[1] }
| WSLPAREN parameters endcomma RPAREN { result = val[1] }
# Produces Array<Model::Parameter>
parameters
: parameter { result = [val[0]] }
| parameters COMMA parameter { result = val[0].push(val[2]) }
# Produces Model::Parameter
parameter
: untyped_parameter
| typed_parameter
untyped_parameter
: regular_parameter
| splat_parameter
regular_parameter
: VARIABLE EQUALS expression { result = Factory.PARAM(val[0][:value], val[2]) ; loc result, val[0] }
| VARIABLE { result = Factory.PARAM(val[0][:value]); loc result, val[0] }
splat_parameter
: TIMES regular_parameter { result = val[1]; val[1].captures_rest }
typed_parameter
: parameter_type untyped_parameter { val[1].type_expr(val[0]) ; result = val[1] }
parameter_type
: type { result = val[0] }
| type LBRACK access_args RBRACK { result = val[0].access(val[2]) ; loc result, val[0], val[3] }
#--TYPE ALIAS
type_alias
: type_alias_lhs EQUALS type hash {
definition = Factory.TYPE_ASSIGNMENT(val[0], Factory.KEY_ENTRY(val[2], val[3]))
loc(definition, val[0], val[3])
result = add_definition(definition)
}
| type_alias_lhs EQUALS type LBRACK access_args endcomma RBRACK {
definition = Factory.TYPE_ASSIGNMENT(val[0], val[2].access(val[4]))
loc(definition, val[0], val[5])
result = add_definition(definition)
}
| type_alias_lhs EQUALS type {
definition = Factory.TYPE_ASSIGNMENT(val[0], val[2])
loc(definition, val[0], val[2])
result = add_definition(definition)
}
| type_alias_lhs EQUALS hash {
definition = Factory.TYPE_ASSIGNMENT(val[0], val[2])
loc(definition, val[0], val[2])
result = add_definition(definition)
}
| type_alias_lhs EQUALS array {
definition = Factory.TYPE_ASSIGNMENT(val[0], val[2])
loc(definition, val[0], val[4])
result = add_definition(definition)
}
type_alias_lhs
: TYPE parameter_type { result = val[1] }
#--TYPE definition
# TODO: Uses the optional_statements rule temporarily since the actual body awaits final spec on methods and attributes.
type_definition
: TYPE CLASSREF LBRACE optional_statements RBRACE {
definition = Factory.TYPE_DEFINITION(val[1][:value], nil, val[3])
loc(definition, val[0], val[4])
result = add_definition(definition)
}
| TYPE CLASSREF INHERITS CLASSREF LBRACE optional_statements RBRACE {
definition = Factory.TYPE_DEFINITION(val[1][:value], val[3][:value], val[5])
loc(definition, val[0], val[6])
result = add_definition(definition)
}
#--VARIABLE
#
variable
: VARIABLE {
fqn = Factory.fqn(val[0][:value])
loc(fqn, val[0])
fqn['offset'] += 1
fqn['length'] -= 1
result = fqn.var
loc(result, val[0])
}
#---RESERVED WORDS
#
reserved_word
: PRIVATE { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
| ATTR { result = Factory.RESERVED(val[0][:value]) ; loc result, val[0] }
#---LITERALS (dynamic and static)
#
array
: LISTSTART collection_entries endcomma RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
| LISTSTART RBRACK { result = Factory.literal([]) ; loc result, val[0], val[1] }
| LBRACK collection_entries endcomma RBRACK { result = Factory.LIST(val[1]); loc result, val[0], val[3] }
| LBRACK RBRACK { result = Factory.literal([]) ; loc result, val[0], val[1] }
hash
: LBRACE hashpairs RBRACE { result = Factory.HASH(val[1]); loc result, val[0], val[2] }
| LBRACE hashpairs COMMA RBRACE { result = Factory.HASH(val[1]); loc result, val[0], val[3] }
| LBRACE RBRACE { result = Factory.literal({}) ; loc result, val[0], val[1] }
hashpairs
: hashpair { result = [val[0]] }
| hashpairs COMMA hashpair { result = val[0].push val[2] }
hashpair
: hash_entry FARROW hash_entry { result = Factory.KEY_ENTRY(val[0], val[2]); loc result, val[1] }
collection_entry:
: argument
| collection_entry_keyword { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
# Like collection_entry but will not allow nested hashpair
hash_entry:
: assignment
| collection_entry_keyword { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
collection_entries
: collection_entry { result = [val[0]] }
| collection_entries COMMA collection_entry { result = Factory.ARGUMENTS(val[0], val[2]) }
# Keywords valid as a collection value
collection_entry_keyword
: TYPE
| FUNCTION
| APPLICATION
| CONSUMES
| PRODUCES
| SITE
quotedtext
: string
| dq_string
| heredoc
string
: STRING { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
| WORD { result = Factory.literal(val[0][:value]) ; loc result, val[0] }
dq_string : dqpre dqrval { result = Factory.STRING(val[0], *val[1]) ; loc result, val[0], val[1][-1] }
dqpre : DQPRE { result = Factory.literal(val[0][:value]); loc result, val[0] }
dqpost : DQPOST { result = Factory.literal(val[0][:value]); loc result, val[0] }
dqmid : DQMID { result = Factory.literal(val[0][:value]); loc result, val[0] }
dqrval : text_expression dqtail { result = [val[0]] + val[1] }
text_expression : assignment { result = Factory.TEXT(val[0]) }
dqtail
: dqpost { result = [val[0]] }
| dqmid dqrval { result = [val[0]] + val[1] }
heredoc
: HEREDOC sublocated_text { result = Factory.HEREDOC(val[0][:value], val[1]); loc result, val[0] }
sublocated_text
: SUBLOCATE string { result = Factory.SUBLOCATE(val[0], val[1]); }
| SUBLOCATE dq_string { result = Factory.SUBLOCATE(val[0], val[1]); }
epp_expression
: EPP_START epp_parameters_list optional_statements { result = Factory.EPP(val[1], val[2]); loc result, val[0] }
optional_statements
:
| statements
epp_parameters_list
: =LOW{ result = nil }
| PIPE PIPE { result = [] }
| PIPE parameters endcomma PIPE { result = val[1] }
epp_render_expression
: RENDER_STRING { result = Factory.RENDER_STRING(val[0][:value]); loc result, val[0] }
| RENDER_EXPR expression epp_end { result = Factory.RENDER_EXPR(val[1]); loc result, val[0], val[2] }
| RENDER_EXPR LBRACE statements RBRACE epp_end { result = Factory.RENDER_EXPR(Factory.block_or_expression(val[2], val[1], val[3])); loc result, val[0], val[4] }
epp_end
: EPP_END
| EPP_END_TRIM
type : CLASSREF { result = Factory.QREF(val[0][:value]) ; loc result, val[0] }
regex
: REGEX { result = Factory.literal(val[0][:value]); loc result, val[0] }
#---MARKERS, SPECIAL TOKENS, SYNTACTIC SUGAR, etc.
endcomma
: #
| COMMA { result = nil }
endsemi
: #
| SEMIC
keyword
: AND
| CASE
| CLASS
| DEFAULT
| DEFINE
| ELSE
| ELSIF
| IF
| IN
| INHERITS
| NODE
| OR
| UNDEF
| UNLESS
| TYPE
| ATTR
| FUNCTION
| PRIVATE
| APPLICATION
| CONSUMES
| PRODUCES
| SITE
nil
: { result = nil}
end
---- header ----
require 'puppet'
require 'puppet/pops'
module Puppet
class ParseError < Puppet::Error; end
class ImportError < Racc::ParseError; end
class AlreadyImportedError < ImportError; end
end
---- inner ----
# Make emacs happy
# Local Variables:
# mode: ruby
# End:
Copyright 2K16 - 2K18 Indonesian Hacker Rulez
;?>)