Module: Ibex::NormalizeParameterLowering

Included in:
Normalizer
Defined in:
lib/ibex/normalize/parameter_lowering.rb,
sig/ibex/normalize/parameter_lowering.rbs

Overview

Resumable, source-ordered lowering for specialized parameter alternatives.

Instance Method Summary collapse

Instance Method Details

#advance_parameter_alternative(frame) ⇒ void

This method returns an undefined value.

RBS:

  • (NormalizeParameters::parameter_frame frame) -> void

Parameters:

  • frame (NormalizeParameters::parameter_frame) 


9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 9

def advance_parameter_alternative(frame)
  # @type self: Normalizer
  with_parameter_frame_context(frame) do
    operations = frame.fetch(:operations)
    if operations.any?
      operation = operations.pop #: NormalizeParameters::parameter_operation
      process_parameter_operation(frame, operation)
    elsif parameter_items_remaining?(frame)
      start_parameter_item(frame)
    else
      finish_parameter_alternative(frame)
    end
  end
end

#finish_parameter_alternative(frame) ⇒ void

This method returns an undefined value.

RBS:

  • (NormalizeParameters::parameter_frame frame) -> void

Parameters:

  • frame (NormalizeParameters::parameter_frame) 


132
133
134
135
136
137
138
139
140
141
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 132

def finish_parameter_alternative(frame)
  # @type self: Normalizer
  _template, rule, alternative = frame.fetch(:current) || raise(Ibex::Error, "missing parameter alternative")
  action = normalize_action(alternative.action, frame.fetch(:named_refs))
  add_production(
    rule.lhs, frame.fetch(:rhs), action, alternative.precedence,
    { kind: :user, loc: alternative.loc.to_h }, rule.documentation
  )
  clear_parameter_alternative(frame)
end

#finish_parameter_item(frame, item) ⇒ void

This method returns an undefined value.

RBS:

  • (NormalizeParameters::parameter_frame frame, Frontend::AST::item item) -> void

Parameters:

  • frame (NormalizeParameters::parameter_frame)
  • item (Frontend::AST::item) 


124
125
126
127
128
129
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 124

def finish_parameter_item(frame, item)
  # @type self: Normalizer
  rhs = frame.fetch(:rhs)
  rhs << (frame.fetch(:values).pop || raise(Ibex::Error, "missing parameter value"))
  add_named_reference(item, frame.fetch(:named_refs), rhs.length - 1)
end

#lower_parameter_call(frame, item) ⇒ void

This method returns an undefined value.

RBS:

  • (NormalizeParameters::parameter_frame frame, Frontend::AST::ParameterizedReference item) -> void

Parameters:



117
118
119
120
121
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 117

def lower_parameter_call(frame, item)
  # @type self: Normalizer
  helper, = schedule_parameter_specialization(item)
  frame.fetch(:values) << helper
end

#lower_parameter_item(frame, item) ⇒ void

This method returns an undefined value.

RBS:

  • (NormalizeParameters::parameter_frame frame, Frontend::AST::item item) -> void

Parameters:

  • frame (NormalizeParameters::parameter_frame)
  • item (Frontend::AST::item) 


98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 98

def lower_parameter_item(frame, item)
  # @type self: Normalizer
  case item
  when Frontend::AST::SymbolReference
    frame.fetch(:values) << symbol_for_reference(item).name
  when Frontend::AST::ParameterizedReference
    lower_parameter_call(frame, item)
  when Frontend::AST::Group
    lower_parameter_group(frame, item)
  when Frontend::AST::Optional, Frontend::AST::Star, Frontend::AST::Plus
    lower_parameter_suffix(frame, item)
  when Frontend::AST::SeparatedList
    lower_parameter_separated_list(frame, item)
  else
    fail_at(item.loc, "unsupported nested EBNF expression")
  end
end

#parameter_items_remaining?(frame) ⇒ Boolean

RBS:

  • (NormalizeParameters::parameter_frame frame) -> bool

Parameters:

  • frame (NormalizeParameters::parameter_frame)

Returns:

  • (Boolean) 


42
43
44
45
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 42

def parameter_items_remaining?(frame)
  _template, _rule, alternative = frame.fetch(:current) || raise(Ibex::Error, "missing parameter alternative")
  frame.fetch(:item_index) < alternative.items.length
end

#process_parameter_operation(frame, operation) ⇒ void

This method returns an undefined value.

RBS:

  • (NormalizeParameters::parameter_frame frame, NormalizeParameters::parameter_operation operation) -> void

Parameters:

  • frame (NormalizeParameters::parameter_frame)
  • operation (NormalizeParameters::parameter_operation) 


64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 64

def process_parameter_operation(frame, operation)
  # @type self: Normalizer
  kind = operation.fetch(0) #: Symbol
  case kind
  when :item
    item = operation.fetch(1) #: Frontend::AST::item
    lower_parameter_item(frame, item)
  when :finish_item
    item = operation.fetch(1) #: Frontend::AST::item
    finish_parameter_item(frame, item)
  when :value
    value = operation.fetch(1) #: String
    frame.fetch(:values) << value
  when :finish_suffix
    item = operation.fetch(1) #: Frontend::AST::Optional | Frontend::AST::Star | Frontend::AST::Plus
    finish_parameter_suffix(frame, item)
  when :finish_separated
    item = operation.fetch(1) #: Frontend::AST::SeparatedList
    finish_parameter_separated_list(frame, item)
  when :group_alternative
    helper = operation.fetch(1) #: String
    item = operation.fetch(2) #: Frontend::AST::Group
    alternative = operation.fetch(3) #: Array[Frontend::AST::item]
    start_parameter_group_alternative(frame, helper, item, alternative)
  when :finish_group_alternative
    helper = operation.fetch(1) #: String
    item = operation.fetch(2) #: Frontend::AST::Group
    length = operation.fetch(3) #: Integer
    finish_parameter_group_alternative(frame, helper, item, length)
  else raise Ibex::Error, "internal parameter lowering operation #{kind.inspect}"
  end
end

#start_parameter_item(frame) ⇒ void

This method returns an undefined value.

RBS:

  • (NormalizeParameters::parameter_frame frame) -> void

Parameters:

  • frame (NormalizeParameters::parameter_frame) 


48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 48

def start_parameter_item(frame)
  # @type self: Normalizer
  _template, _rule, alternative = frame.fetch(:current) || raise(Ibex::Error, "missing parameter alternative")
  index = frame.fetch(:item_index)
  item = alternative.items.fetch(index)
  frame[:item_index] = index + 1
  if item.is_a?(Frontend::AST::InlineAction)
    frame.fetch(:rhs) << expand_inline_action(
      item, frame.fetch(:rhs).length, frame.fetch(:named_refs)
    )
  else
    frame.fetch(:operations).push([:finish_item, item], [:item, item])
  end
end

#with_parameter_frame_context(frame) { ... } ⇒ void

This method returns an undefined value.

RBS:

  • (NormalizeParameters::parameter_frame frame) { () -> void } -> void

Parameters:

  • frame (NormalizeParameters::parameter_frame)

Yields:

Yield Returns:

  • (void) 


25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/ibex/normalize/parameter_lowering.rb', line 25

def with_parameter_frame_context(frame)
  # @type self: Normalizer
  template, = frame.fetch(:current) || raise(Ibex::Error, "missing parameter alternative")
  previous_chain = @current_include_chain
  previous_expansion = @current_parameter_expansion
  reference = frame.fetch(:reference)
  @current_include_chain = @resolution&.include_chain_for(template) || []
  @current_parameter_expansion = {
    rule: reference.name, arguments: frame.fetch(:rendered_arguments)
  }
  yield
ensure
  @current_include_chain = previous_chain
  @current_parameter_expansion = previous_expansion
end