Module: Ibex::Frontend::GeneratedParserParameters

Included in:
GeneratedParserBase
Defined in:
lib/ibex/frontend/generated_parser_parameters.rb,
sig/ibex/frontend/generated_parser_parameters.rbs

Overview

Parameter-list and parameterized-reference builders for the generated frontend.

Instance Method Summary collapse

Instance Method Details

#build_parameterized_reference(callee, opening, arguments, named_reference, suffixes) ⇒ AST::item

RBS:

  • (Token callee, Token opening, Array[AST::item] arguments, [Token, Token]? named_reference, Array[Token] suffixes) -> AST::item

Parameters:

  • callee (Token)
  • opening (Token)
  • arguments (Array[AST::item])
  • named_reference ([ Token, Token ], nil)
  • suffixes (Array[Token])

Returns:

  • (AST::item) 


34
35
36
37
38
39
40
41
42
43
 
# File 'lib/ibex/frontend/generated_parser_parameters.rb', line 34

def build_parameterized_reference(callee, opening, arguments, named_reference, suffixes)
  # @type self: GeneratedParserBase
  extended_only!(opening.location, "parameterized rules")
  require_adjacency!(callee, opening, "parameter list must immediately follow rule name")
  item = AST::ParameterizedReference.new(
    name: token_string(callee), arguments: arguments, named_reference: named_reference_value(named_reference),
    loc: callee.location
  )
  apply_suffixes(item, suffixes)
end

#build_rule(inline_marker, lhs, parameter_clause, alternatives) ⇒ AST::Rule

RBS:

  • (Token? inline_marker, Token lhs, [Token, Array[String]]? parameter_clause, Array[AST::Alternative] alternatives) -> AST::Rule

Parameters:

Returns:



18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/ibex/frontend/generated_parser_parameters.rb', line 18

def build_rule(inline_marker, lhs, parameter_clause, alternatives)
  # @type self: GeneratedParserBase
  extended_only!(inline_marker.location, "inline rules") if inline_marker
  parameters = [] #: Array[String]
  if parameter_clause
    opening, parameters = parameter_clause
    require_adjacency!(lhs, opening, "parameter list must immediately follow rule name")
  end
  AST::Rule.new(
    lhs: token_string(lhs), parameters: parameters, alternatives: alternatives, loc: lhs.location,
    inline: !!inline_marker
  )
end

#build_rule_parameters(opening, parameters) ⇒ [ Token, Array[String] ]

RBS:

  • (Token opening, Array[Token] parameters) -> [Token, Array[String]]

Parameters:

Returns:

  • ([ Token, Array[String] ]) 


10
11
12
13
14
 
# File 'lib/ibex/frontend/generated_parser_parameters.rb', line 10

def build_rule_parameters(opening, parameters)
  # @type self: GeneratedParserBase
  extended_only!(opening.location, "parameterized rules")
  [opening, parameters.map { |parameter| token_string(parameter) }]
end

#require_adjacency!(left, right, message) ⇒ void

This method returns an undefined value.

RBS:

  • (Token left, Token right, String message) -> void

Parameters:



46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/ibex/frontend/generated_parser_parameters.rb', line 46

def require_adjacency!(left, right, message)
  # @type self: GeneratedParserBase
  left_span = left.span
  right_span = right.span
  adjacent = if left_span && right_span
               left_span.end_byte == right_span.start_byte
             else
               left.location.line == right.location.line &&
                 left.location.column + token_string(left).length == right.location.column
             end
  fail_at(right.location, message) unless adjacent
end