Class: Puppet::Pops::Parser::Parser

Inherits:
Racc::Parser
  • Object
show all
Defined in:
lib/puppet/pops/parser/parser_support.rb,
lib/puppet/pops/parser/eparser.rb

Overview

It is only concerned with parsing.

Direct Known Subclasses

EppParser

Constant Summary collapse

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",
"WORD",
"LBRACK",
"RBRACK",
"LBRACE",
"RBRACE",
"SYMBOL",
"FARROW",
"COMMA",
"TRUE",
"FALSE",
"EQUALS",
"APPENDS",
"DELETES",
"LESSEQUAL",
"NOTEQUAL",
"DOT",
"COLON",
"LLCOLLECT",
"RRCOLLECT",
"QMARK",
"WSLPAREN",
"LPAREN",
"RPAREN",
"ISEQUAL",
"GREATEREQUAL",
"GREATERTHAN",
"LESSTHAN",
"IF",
"ELSE",
"DEFINE",
"ELSIF",
"VARIABLE",
"CLASS",
"INHERITS",
"NODE",
"BOOLEAN",
"NAME",
"SEMIC",
"CASE",
"DEFAULT",
"AT",
"ATAT",
"LCOLLECT",
"RCOLLECT",
"CLASSREF",
"NOT",
"OR",
"AND",
"UNDEF",
"PARROW",
"PLUS",
"MINUS",
"TIMES",
"DIV",
"LSHIFT",
"RSHIFT",
"UMINUS",
"MATCH",
"NOMATCH",
"REGEX",
"IN_EDGE",
"OUT_EDGE",
"IN_EDGE_SUB",
"OUT_EDGE_SUB",
"IN",
"UNLESS",
"PIPE",
"LAMBDA",
"SELBRACE",
"NUMBER",
"HEREDOC",
"SUBLOCATE",
"RENDER_STRING",
"RENDER_EXPR",
"EPP_START",
"EPP_END",
"EPP_END_TRIM",
"FUNCTION",
"TYPE",
"PRIVATE",
"ATTR",
"PLAN",
"APPLY",
"LOW",
"HIGH",
"LISTSTART",
"SPLAT",
"MODULO",
"$start",
"program",
"statements",
"epp_expression",
"syntactic_statements",
"syntactic_statement",
"assignment",
"relationship",
"argument",
"hashpair",
"arguments",
"resource",
"expression",
"attribute_operations",
"additional_resource_bodies",
"resource_bodies",
"endsemi",
"endcomma",
"resource_body",
"primary_expression",
"call_function_expression",
"bracketed_expression",
"selector_entries",
"access_args",
"access_arg",
"expressions",
"variable",
"call_method_with_lambda_expression",
"collection_expression",
"case_expression",
"if_expression",
"unless_expression",
"definition_expression",
"hostclass_expression",
"plan_expression",
"apply_expression",
"node_definition_expression",
"epp_render_expression",
"function_definition",
"type_alias",
"type_definition",
"reserved_word",
"array",
"hash",
"regex",
"quotedtext",
"type",
"call_function_start",
"lambda",
"call_method_expression",
"named_access",
"lambda_parameter_list",
"opt_return_type",
"lambda_rest",
"parameters",
"if_part",
"else",
"unless_else",
"case_options",
"case_option",
"options_statements",
"nil",
"selector_entry",
"selector_entry_list",
"collect_query",
"optional_query",
"attribute_operation",
"attribute_name",
"keyword",
"classname",
"parameter_list",
"opt_statements",
"stacked_classname",
"classparent",
"classnameordefault",
"hostnames",
"nodeparent",
"hostname",
"dotted_name",
"name_or_number",
"parameter",
"untyped_parameter",
"typed_parameter",
"regular_parameter",
"splat_parameter",
"parameter_type",
"type_alias_lhs",
"optional_statements",
"collection_entries",
"hashpairs",
"hash_entry",
"collection_entry",
"collection_entry_keyword",
"string",
"dq_string",
"heredoc",
"dqpre",
"dqrval",
"dqpost",
"dqmid",
"text_expression",
"dqtail",
"sublocated_text",
"epp_parameters_list",
"epp_end" ]
Racc_debug_parser = 
false
Factory =

Simplify access to the Model factory Note that the parser/parser support does not have direct knowledge about the Model. All model construction/manipulation is made by the Factory.

Model::Factory

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Parser

Returns a new instance of Parser.


84
85
86
87
88
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 84

def initialize()
  @lexer = Lexer2.new
  @namestack = []
  @definitions = []
end

Instance Attribute Details

#definitions ⇒ Object (readonly) 


25
26
27
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 25

def definitions
  @definitions
end

#lexer ⇒ Object 


24
25
26
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 24

def lexer
  @lexer
end

Instance Method Details

#_parse ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Performs the parsing and returns the resulting model. The lexer holds state, and this is setup with #parse_string, or #parse_file.


238
239
240
241
242
243
244
245
246
247
248
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 238

def _parse()
  begin
    @yydebug = false
    main = yyparse(@lexer,:scan)
  end
  return main
ensure
  @lexer.clear
  @namestack = []
  @definitions = []
end

#_reduce_none(val, _values, result) ⇒ Object 


3161
3162
3163
 
# File 'lib/puppet/pops/parser/eparser.rb', line 3161

def _reduce_none(val, _values, result)
  val[0]
end

#add_definition(definition) ⇒ Object 


176
177
178
179
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 176

def add_definition(definition)
  @definitions << definition.model
  definition
end

#aryfy(o) ⇒ Object 


159
160
161
162
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 159

def aryfy(o)
  o = [o] unless o.is_a?(Array)
  o
end

#classname(name) ⇒ Object

Produces the fully qualified name, with the full (current) namespace for a given name.

This is needed because class bodies are lazily evaluated and an inner class' container(s) may not have been evaluated before some external reference is made to the inner class; its must therefore know its complete name before evaluation-time.


46
47
48
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 46

def classname(name)
  [namespace, name].join('::').sub(/^::/, '')
end

#create_empty_program ⇒ Object

Creates an empty program with a single No-op at the input's EOF offset with 0 length.


220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 220

def create_empty_program()
  locator = @lexer.locator
  no_op = Factory.literal(nil)
  # Create a synthetic NOOP token at EOF offset with 0 size. The lexer does not produce an EOF token that is
  # visible to the grammar rules. Creating this token is mainly to reuse the positioning logic as it
  # expects a token decorated with location information.
  _, token = @lexer.emit_completed([:NOOP,'',0], locator.string.bytesize)
  loc(no_op, token)
  # Program with a Noop
  program = Factory.PROGRAM(no_op, [], locator)
  program
end

#create_program(body) ⇒ Object

Creates a program with the given body.


213
214
215
216
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 213

def create_program(body)
  locator = @lexer.locator
  Factory.PROGRAM(body, definitions, locator)
end

#error(semantic, message) ⇒ Object

Raises a Parse error with location information. Information about file is always obtained from the lexer. Line and position is produced if the given semantic is a Positioned object and have been given an offset.


53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 53

def error(semantic, message)
  except = Puppet::ParseError.new(message)
  if semantic.is_a?(LexerSupport::TokenValue)
    except.file = semantic[:file];
    except.line = semantic[:line];
    except.pos = semantic[:pos];
  else
    locator = @lexer.locator
    except.file = locator.file
    if semantic.is_a?(Factory)
      offset = semantic['offset']
      unless offset.nil?
        except.line = locator.line_for_offset(offset)
        except.pos = locator.pos_on_line(offset)
      end
    end
  end
  raise except
end

#heredoc_loc(factory, start_locatable, end_locatable = nil) ⇒ Factory

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Mark the factory wrapped heredoc model object with location information

Returns:


155
156
157
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 155

def heredoc_loc(factory, start_locatable, end_locatable = nil)
  factory.record_heredoc_position(start_locatable, end_locatable)
end

#loc(factory, start_locatable, end_locatable = nil) ⇒ Factory

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Mark the factory wrapped model object with location information

Returns:


147
148
149
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 147

def loc(factory, start_locatable, end_locatable = nil)
  factory.record_position(@lexer.locator, start_locatable, end_locatable)
end

#namepop ⇒ Object 


172
173
174
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 172

def namepop()
  @namestack.pop
end

#namespace ⇒ Object 


164
165
166
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 164

def namespace
  @namestack.join('::')
end

#namestack(name) ⇒ Object 


168
169
170
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 168

def namestack(name)
  @namestack << name
end

#on_error(token, value, stack) ⇒ Object

This is a callback from the generated parser (when an error occurs while parsing)

Raises:


92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 92

def on_error(token,value,stack)
  if token == 0 # denotes end of file
    value_at = 'end of input'
  else
    value_at = "'#{value[:value]}'"
  end
  error = Issues::SYNTAX_ERROR.format(:where => value_at)
  error = "#{error}, token: #{token}" if @yydebug

  # Note, old parser had processing of "expected token here" - do not try to reinstate:
  # The 'expected' is only of value at end of input, otherwise any parse error involving a
  # start of a pair will be reported as expecting the close of the pair - e.g. "$x.each |$x {|", would
  # report that "seeing the '{', the '}' is expected. That would be wrong.
  # Real "expected" tokens are very difficult to compute (would require parsing of racc output data). Output of the stack
  # could help, but can require extensive backtracking and produce many options.
  #
  # The lexer should handle the "expected instead of end of file for strings, and interpolation", other expectancies
  # must be handled by the grammar. The lexer may have enqueued tokens far ahead - the lexer's opinion about this
  # is not trustworthy.
  #
  file = nil
  line = nil
  pos  = nil
  if token != 0
    file = value[:file]
    locator = value.locator
    if locator.is_a?(Puppet::Pops::Parser::Locator::SubLocator)
      # The error occurs when doing sub-parsing and the token must be transformed
      # Transpose the local offset, length to global "coordinates"
      global_offset, _ = locator.to_global(value.offset, value.length)
      line = locator.locator.line_for_offset(global_offset)
      pos = locator.locator.pos_on_line(global_offset)
    else
      line = value[:line]
      pos  = value[:pos]
    end
  else
    # At end of input, use what the lexer thinks is the source file
    file = lexer.file
  end
  file = nil unless file.is_a?(String) && !file.empty?
  raise Puppet::ParseErrorWithIssue.new(error, file, line, pos, nil, Issues::SYNTAX_ERROR.issue_code)
end

#parse_file(file) ⇒ Object

Parses a file expected to contain pp DSL logic.


74
75
76
77
78
79
80
81
82
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 74

def parse_file(file)
  unless Puppet::FileSystem.exist?(file)
    unless file =~ /\.pp$/
      file = file + ".pp"
    end
  end
  @lexer.file = file
  _parse
end

#parse_string(code, path = nil) ⇒ Object

Parses a String of pp DSL code.


138
139
140
141
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 138

def parse_string(code, path = nil)
  @lexer.lex_string(code, path)
  _parse()
end

#token_text(t) ⇒ Object

Returns the token text of the given lexer token, or nil, if token is nil


28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 28

def token_text t
  return t if t.nil?
  if t.is_a?(Factory) && t.model_class <= Model::QualifiedName
    t['value']
  elsif t.is_a?(Model::QualifiedName)
    t.value
  else
    # else it is a lexer token
    t[:value]
  end
end

#transform_calls(expressions) ⇒ Object

Transforms an array of expressions containing literal name expressions to calls if followed by an expression, or expression list


184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 184

def transform_calls(expressions)
  # Factory transform raises an error if a non qualified name is followed by an argument list
  # since there is no way that that can be transformed back to sanity. This occurs in situations like this:
  #
  #  $a = 10, notice hello
  #
  # where the "10, notice" forms an argument list. The parser builds an Array with the expressions and includes
  # the comma tokens to enable the error to be reported against the first comma.
  #
  begin
    Factory.transform_calls(expressions)
  rescue Factory::ArgsToNonCallError => e
    # e.args[1] is the first comma token in the list
    # e.name_expr is the function name expression
    if e.name_expr.is_a?(Factory) && e.name_expr.model_class <= Model::QualifiedName
      error(e.args[1], _("attempt to pass argument list to the function '%{name}' which cannot be called without parentheses") % { name: e.name_expr['value'] })
    else
      error(e.args[1], _("illegal comma separated argument list"))
    end
  end
end

#transform_resource_wo_title(left, resource, lbrace_token, rbrace_token) ⇒ Object

Transforms a LEFT followed by the result of attribute_operations, this may be a call or an invalid sequence


207
208
209
 
# File 'lib/puppet/pops/parser/parser_support.rb', line 207

def transform_resource_wo_title(left, resource, lbrace_token, rbrace_token)
  Factory.transform_resource_wo_title(left, resource, lbrace_token, rbrace_token)
end