ynl 0.4.2 → 0.5.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGELOG.md +5 -0
- data/lib/ynl/family.rb +2 -1
- data/lib/ynl/generator.rb +317 -129
- data/lib/ynl/models.rb +12 -107
- data/lib/ynl/parser.rb +303 -214
- data/lib/ynl/version.rb +1 -1
- data/lib/ynl.rb +1 -51
- data/sig/generated/ynl/generator.rbs +11 -1
- data/sig/generated/ynl/models.rbs +5 -33
- data/sig/generated/ynl/parser.rbs +43 -20
- metadata +3 -3
data/lib/ynl/generator.rb
CHANGED
|
@@ -15,7 +15,7 @@ module Ynl
|
|
|
15
15
|
end
|
|
16
16
|
|
|
17
17
|
def as_variable_name
|
|
18
|
-
split(WORD_DELIM).join('_').tap {|s| s.prepend('x_') unless s.start_with?(/[
|
|
18
|
+
split(WORD_DELIM).join('_').downcase.tap {|s| s.prepend('x_') unless s.start_with?(/[a-z]/) }
|
|
19
19
|
end
|
|
20
20
|
alias as_method_name as_variable_name
|
|
21
21
|
|
|
@@ -55,7 +55,6 @@ module Ynl
|
|
|
55
55
|
# @rbs (?superclass: String?, ?namespace: String?, ?default_resolver: String?) -> void
|
|
56
56
|
def generate(superclass: nil, namespace: nil, default_resolver: nil)
|
|
57
57
|
raw = @ynl.protocol == 'netlink-raw'
|
|
58
|
-
@wire = raw ? '::Nl::Raw' : '::Nl::Genl'
|
|
59
58
|
superclass ||= raw ? '::Nl::Raw::Family' : '::Nl::Genl::Family'
|
|
60
59
|
build_selector_plan
|
|
61
60
|
|
|
@@ -88,32 +87,55 @@ module Ynl
|
|
|
88
87
|
deferred_struct_consts = []
|
|
89
88
|
emit_module('Structs') do
|
|
90
89
|
@ynl.structs.each do |name, struct|
|
|
90
|
+
fields = struct.members.reject { it.type.is_a?(Types::Pad) }
|
|
91
91
|
emit_comment(struct.doc)
|
|
92
92
|
write(name.as_class_name, " = Struct.new(")
|
|
93
93
|
indent do
|
|
94
|
-
|
|
94
|
+
fields.each do |member|
|
|
95
95
|
write(member.name.as_variable_name.as_symbol_literal, ', #: ', struct_member_rbs_type(member.type))
|
|
96
96
|
end
|
|
97
97
|
end
|
|
98
98
|
write(')')
|
|
99
99
|
emit_class(name.as_class_name) do
|
|
100
|
-
|
|
100
|
+
fields.each do |member|
|
|
101
101
|
emit_yard_attribute(
|
|
102
102
|
member.name.as_method_name,
|
|
103
103
|
struct_member_yard_type(member.type),
|
|
104
104
|
member.doc,
|
|
105
105
|
)
|
|
106
106
|
end
|
|
107
|
-
members =
|
|
107
|
+
members = fields.map do |member|
|
|
108
108
|
"#{member.name.as_variable_name}: #{to_struct_member_datatype(member.type)}"
|
|
109
109
|
end
|
|
110
|
-
members = "
|
|
110
|
+
members = "{#{members.join(', ')}}.freeze"
|
|
111
111
|
if struct.members.any? { it.type.is_a?(Types::Binary) && it.type.struct }
|
|
112
112
|
deferred_struct_consts << ["Structs::#{name.as_class_name}::MEMBERS", members]
|
|
113
113
|
else
|
|
114
|
-
emit_const('MEMBERS', members, rbs: 'Hash[::Symbol, ::Nl::_DataType]', internal: true)
|
|
114
|
+
emit_const('MEMBERS', members, rbs: 'Hash[::Symbol, ::Nl::_DataType]', internal: true, make_shareable: true)
|
|
115
115
|
end
|
|
116
116
|
|
|
117
|
+
emit_internal
|
|
118
|
+
emit_rbs_comment('(Hash[Symbol, untyped] params, ?context: untyped) -> instance')
|
|
119
|
+
write('def self.from_params(params, context: nil)')
|
|
120
|
+
indent do
|
|
121
|
+
write('unknown = params.keys - members')
|
|
122
|
+
write('raise ArgumentError, "unknown struct members: #{unknown.join(\', \')}" unless unknown.empty?')
|
|
123
|
+
write('self.new(')
|
|
124
|
+
indent do
|
|
125
|
+
fields.each do |member|
|
|
126
|
+
member_name = member.name.as_variable_name.as_symbol_literal
|
|
127
|
+
value = if member.type.is_a?(Types::Scalar)
|
|
128
|
+
"params.fetch(#{member_name}, 0)"
|
|
129
|
+
else
|
|
130
|
+
"params[#{member_name}]"
|
|
131
|
+
end
|
|
132
|
+
write("MEMBERS[#{member_name}].coerce(#{value}, context:),")
|
|
133
|
+
end
|
|
134
|
+
end
|
|
135
|
+
write(')')
|
|
136
|
+
end
|
|
137
|
+
write('end')
|
|
138
|
+
|
|
117
139
|
emit_comment('Decodes the struct.')
|
|
118
140
|
emit_rbs_comment(
|
|
119
141
|
'decoder: ::Nl::Decoder',
|
|
@@ -123,7 +145,8 @@ module Ynl
|
|
|
123
145
|
emit_yard_return('self')
|
|
124
146
|
write('def self.decode(decoder)')
|
|
125
147
|
indent do
|
|
126
|
-
|
|
148
|
+
values = emit_fixed_field_decode(struct)
|
|
149
|
+
write("self.new(#{values.join(', ')})")
|
|
127
150
|
end
|
|
128
151
|
write('end')
|
|
129
152
|
|
|
@@ -136,119 +159,105 @@ module Ynl
|
|
|
136
159
|
emit_yard_return('void')
|
|
137
160
|
write('def encode(encoder)')
|
|
138
161
|
indent do
|
|
139
|
-
|
|
162
|
+
struct.members.each do |member|
|
|
163
|
+
if member.type.is_a?(Types::Pad)
|
|
164
|
+
if member.type.length
|
|
165
|
+
write("encoder.put_string(#{("\0" * member.type.length).dump})")
|
|
166
|
+
end
|
|
167
|
+
next
|
|
168
|
+
end
|
|
169
|
+
member_name = member.name.as_variable_name.as_symbol_literal
|
|
170
|
+
write("MEMBERS[#{member_name}].encode(encoder, public_send(#{member_name}))")
|
|
171
|
+
end
|
|
140
172
|
end
|
|
141
173
|
write('end')
|
|
142
174
|
end
|
|
143
175
|
end
|
|
144
176
|
end
|
|
145
177
|
deferred_struct_consts.each do |name, members|
|
|
146
|
-
emit_const(name, members, rbs: 'Hash[::Symbol, ::Nl::_DataType]', internal: true)
|
|
178
|
+
emit_const(name, members, rbs: 'Hash[::Symbol, ::Nl::_DataType]', internal: true, make_shareable: true)
|
|
147
179
|
end
|
|
148
180
|
|
|
149
|
-
deferred_sub_message_datatypes = []
|
|
150
181
|
emit_module('AttributeSets') do
|
|
151
|
-
deferred_consts = []
|
|
152
182
|
@ynl.attribute_sets.each do |name, attr_set|
|
|
153
183
|
emit_comment(attr_set.doc)
|
|
154
184
|
emit_class(name.as_class_name, '::Nl::AttributeSet') do
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
elsif attr.type.is_a?(Types::NestedAttributes) ||
|
|
174
|
-
attr.type.is_a?(Types::NestTypeValue) ||
|
|
175
|
-
(attr.type.is_a?(Types::IndexedArray) && attr.type.sub_type.is_a?(Types::NestedAttributes))
|
|
176
|
-
deferred_consts << ["#{name.as_class_name}::#{attr.name.as_class_name}::DATATYPE", to_datatype(attr.type, attr.checks, owner: attr_set)]
|
|
177
|
-
else
|
|
178
|
-
emit_const('DATATYPE', to_datatype(attr.type, attr.checks, owner: attr_set), internal: true)
|
|
179
|
-
end
|
|
185
|
+
emit_module('Definitions') do
|
|
186
|
+
selector_names = @local_selectors.fetch(attr_set)
|
|
187
|
+
external_selector_names = @external_selectors.fetch(attr_set)
|
|
188
|
+
unless selector_names.empty?
|
|
189
|
+
emit_const(
|
|
190
|
+
'LOCAL_SELECTOR_NAMES',
|
|
191
|
+
"[#{selector_names.map { it.as_variable_name.as_symbol_literal }.join(', ')}].freeze",
|
|
192
|
+
internal: true,
|
|
193
|
+
make_shareable: true,
|
|
194
|
+
)
|
|
195
|
+
end
|
|
196
|
+
unless external_selector_names.empty?
|
|
197
|
+
emit_const(
|
|
198
|
+
'EXTERNAL_SELECTOR_NAMES',
|
|
199
|
+
"[#{external_selector_names.map { it.as_variable_name.as_symbol_literal }.join(', ')}].freeze",
|
|
200
|
+
internal: true,
|
|
201
|
+
make_shareable: true,
|
|
202
|
+
)
|
|
180
203
|
end
|
|
181
|
-
end
|
|
182
|
-
|
|
183
|
-
selector_names = @local_selectors.fetch(attr_set)
|
|
184
|
-
external_selector_names = @external_selectors.fetch(attr_set)
|
|
185
|
-
unless selector_names.empty? && external_selector_names.empty?
|
|
186
|
-
emit_const(
|
|
187
|
-
'SELECTOR_NAMES',
|
|
188
|
-
"Ractor.make_shareable({local: [#{selector_names.map { it.as_variable_name.as_symbol_literal }.join(', ')}], external: [#{external_selector_names.map { it.as_variable_name.as_symbol_literal }.join(', ')}]})",
|
|
189
|
-
internal: true,
|
|
190
|
-
)
|
|
191
|
-
end
|
|
192
|
-
|
|
193
|
-
emit_const(
|
|
194
|
-
'BY_NAME',
|
|
195
|
-
"Ractor.make_shareable({#{attr_set.attributes.map { "#{it.name.as_variable_name.as_symbol_literal} => #{it.name.as_class_name}" }.join(', ') }})",
|
|
196
|
-
rbs: 'Hash[::Symbol, Attribute]',
|
|
197
|
-
internal: true,
|
|
198
|
-
)
|
|
199
|
-
|
|
200
|
-
emit_const(
|
|
201
|
-
'BY_TYPE',
|
|
202
|
-
"Ractor.make_shareable({#{attr_set.attributes.map { "#{it.value} => #{it.name.as_class_name}" }.join(', ') }})",
|
|
203
|
-
rbs: 'Hash[::Integer, Attribute]',
|
|
204
|
-
internal: true,
|
|
205
|
-
)
|
|
206
204
|
|
|
207
|
-
|
|
208
|
-
|
|
205
|
+
attr_set.attributes.each do |attribute|
|
|
206
|
+
next if attribute.type.is_a?(Types::Pad)
|
|
209
207
|
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
"self[#{attribute.name.as_variable_name.as_symbol_literal}].map(&:value)"
|
|
216
|
-
else
|
|
217
|
-
"self[#{attribute.name.as_variable_name.as_symbol_literal}]&.value"
|
|
208
|
+
emit_comment(attribute_doc(attribute))
|
|
209
|
+
emit_rbs_comment('return: ' + attribute_rbs_type(attribute))
|
|
210
|
+
emit_yard_return(attribute_yard_type(attribute))
|
|
211
|
+
expression = "self[#{attribute.name.as_variable_name.as_symbol_literal}]"
|
|
212
|
+
emit_getter(attribute.name.as_method_name, expression)
|
|
218
213
|
end
|
|
219
|
-
emit_getter(attribute.name.as_method_name, expression)
|
|
220
214
|
end
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
)
|
|
228
|
-
emit_yard_param('name', 'Symbol')
|
|
229
|
-
emit_yard_return('Attribute')
|
|
230
|
-
emit_getter('by_name(name)', 'BY_NAME.fetch(name)')
|
|
231
|
-
|
|
232
|
-
emit_comment('Looks up Attribute class by type value.')
|
|
233
|
-
emit_rbs_comment(
|
|
234
|
-
'type: Integer',
|
|
235
|
-
'return: Attribute',
|
|
236
|
-
)
|
|
237
|
-
emit_yard_param('type', 'Integer')
|
|
238
|
-
emit_yard_return('Attribute')
|
|
239
|
-
emit_getter('by_type(type)', 'BY_TYPE.fetch(type)')
|
|
215
|
+
write('include Definitions')
|
|
216
|
+
emit_comment('Decodes attributes from the decoder into a new attribute set.')
|
|
217
|
+
emit_rbs_comment('(::Nl::Decoder decoder, ?external_selectors: ::Array[untyped]) -> instance')
|
|
218
|
+
write('def self.decode(decoder, external_selectors: ::Nl::Selector::EMPTY_VALUES)')
|
|
219
|
+
indent do
|
|
220
|
+
count = @local_selectors.fetch(attr_set).length
|
|
221
|
+
write("super(decoder, BY_TYPE, #{count}, external_selectors)")
|
|
240
222
|
end
|
|
223
|
+
write('end')
|
|
241
224
|
end
|
|
242
225
|
end
|
|
243
|
-
deferred_consts.each do |const|
|
|
244
|
-
emit_const(*const, internal: true)
|
|
245
|
-
end
|
|
246
226
|
end
|
|
247
227
|
|
|
248
|
-
|
|
249
228
|
emit_sub_messages
|
|
250
|
-
|
|
251
|
-
|
|
229
|
+
|
|
230
|
+
# Construct immutable definitions after every referenced attribute set
|
|
231
|
+
# and sub-message class exists, including recursive schema references.
|
|
232
|
+
emit_module('AttributeSets') do
|
|
233
|
+
@ynl.attribute_sets.each do |name, attr_set|
|
|
234
|
+
emit_class(name.as_class_name) do
|
|
235
|
+
emit_module('Definitions') do
|
|
236
|
+
emit_internal
|
|
237
|
+
size = (attr_set.attributes.map(&:value).max || -1) + 1
|
|
238
|
+
write("BY_TYPE = ::Array.new(#{size}).tap do |definitions|")
|
|
239
|
+
indent do
|
|
240
|
+
attr_set.attributes.each do |attr|
|
|
241
|
+
slot = @local_selectors.fetch(attr_set).index(attr.name)
|
|
242
|
+
definition = "::Nl::AttributeSet::Definition.new(" \
|
|
243
|
+
"id: #{attr.value}, name: #{attr.name.as_variable_name.as_symbol_literal}, " \
|
|
244
|
+
"datatype: #{to_datatype(attr.type, attr.checks, owner: attr_set)}, " \
|
|
245
|
+
"multi: #{attr.multi?}, order: #{@attribute_orders.fetch(attr_set).fetch(attr)}, " \
|
|
246
|
+
"selector_slot: #{slot.inspect})"
|
|
247
|
+
write("definitions[#{attr.value}] = #{definition}")
|
|
248
|
+
end
|
|
249
|
+
end
|
|
250
|
+
write('end.freeze #: Array[::Nl::AttributeSet::Definition?]')
|
|
251
|
+
write('Ractor.make_shareable(BY_TYPE) if defined?(Ractor)')
|
|
252
|
+
emit_const(
|
|
253
|
+
'BY_NAME',
|
|
254
|
+
'BY_TYPE.compact.to_h { [it.name, it] }.freeze',
|
|
255
|
+
rbs: 'Hash[::Symbol, ::Nl::AttributeSet::Definition]',
|
|
256
|
+
internal: true,
|
|
257
|
+
)
|
|
258
|
+
end
|
|
259
|
+
end
|
|
260
|
+
end
|
|
252
261
|
end
|
|
253
262
|
|
|
254
263
|
emit_module('Messages') do
|
|
@@ -284,7 +293,7 @@ module Ynl
|
|
|
284
293
|
|
|
285
294
|
emit_const(
|
|
286
295
|
'NOTIFICATIONS',
|
|
287
|
-
"
|
|
296
|
+
"{#{notification_operations.map { |oper| "#{oper.notification.message.value} => Notifications::#{oper.name.as_class_name}" }.join(', ') }}.freeze",
|
|
288
297
|
rbs: 'Hash[::Integer, ::Class]',
|
|
289
298
|
internal: true,
|
|
290
299
|
)
|
|
@@ -437,9 +446,10 @@ module Ynl
|
|
|
437
446
|
write('end')
|
|
438
447
|
end
|
|
439
448
|
|
|
440
|
-
private def emit_const(name, value, rbs: nil, internal: false)
|
|
449
|
+
private def emit_const(name, value, rbs: nil, internal: false, make_shareable: false)
|
|
441
450
|
emit_internal if internal
|
|
442
451
|
write(name, ' = ', value, *([' #: ', rbs] if rbs))
|
|
452
|
+
write('Ractor.make_shareable(', name, ') if defined?(Ractor)') if make_shareable
|
|
443
453
|
end
|
|
444
454
|
|
|
445
455
|
private def emit_value_definitions(namespace, definitions)
|
|
@@ -562,14 +572,132 @@ module Ynl
|
|
|
562
572
|
end
|
|
563
573
|
end
|
|
564
574
|
|
|
575
|
+
private def emit_fixed_field_decode(struct, members: 'MEMBERS')
|
|
576
|
+
values = []
|
|
577
|
+
index = 0
|
|
578
|
+
while index < struct.members.length
|
|
579
|
+
group = []
|
|
580
|
+
size = 0
|
|
581
|
+
load_size = nil
|
|
582
|
+
group_length = 0
|
|
583
|
+
struct.members.drop(index).each do |member|
|
|
584
|
+
width = grouped_member_width(member.type)
|
|
585
|
+
break unless width && size + width <= 4
|
|
586
|
+
group << member
|
|
587
|
+
size += width
|
|
588
|
+
if [2, 4].include?(size) && group.length > 1
|
|
589
|
+
load_size = size
|
|
590
|
+
group_length = group.length
|
|
591
|
+
end
|
|
592
|
+
break if size == 4
|
|
593
|
+
end
|
|
594
|
+
|
|
595
|
+
if load_size
|
|
596
|
+
# A fixed load order keeps byte extraction independent of the host.
|
|
597
|
+
write("word = decoder.get_u#{load_size * 8}")
|
|
598
|
+
offset = 0
|
|
599
|
+
group.take(group_length).each do |member|
|
|
600
|
+
unless member.type.is_a?(Types::Pad)
|
|
601
|
+
value = "value_#{index}"
|
|
602
|
+
write("#{value} = #{grouped_scalar_value(member.type, offset)}")
|
|
603
|
+
values << value
|
|
604
|
+
end
|
|
605
|
+
offset += grouped_member_width(member.type)
|
|
606
|
+
index += 1
|
|
607
|
+
end
|
|
608
|
+
else
|
|
609
|
+
member = struct.members[index]
|
|
610
|
+
if member.type.is_a?(Types::Pad)
|
|
611
|
+
write("decoder.skip(#{member.type.length})")
|
|
612
|
+
index += 1
|
|
613
|
+
next
|
|
614
|
+
end
|
|
615
|
+
member_name = member.name.as_variable_name.as_symbol_literal
|
|
616
|
+
value = "value_#{index}"
|
|
617
|
+
if reader = struct_member_reader(member.type)
|
|
618
|
+
write("#{value} = decoder.#{reader}")
|
|
619
|
+
else
|
|
620
|
+
write("#{value} = #{members}[#{member_name}].decode(decoder)")
|
|
621
|
+
end
|
|
622
|
+
values << value
|
|
623
|
+
index += 1
|
|
624
|
+
end
|
|
625
|
+
end
|
|
626
|
+
values
|
|
627
|
+
end
|
|
628
|
+
|
|
629
|
+
private def emit_payload_storage(header, attribute_set, external:)
|
|
630
|
+
write('include ATTRIBUTE_SET::Definitions') if attribute_set
|
|
631
|
+
fields = header ? header.members.reject { it.type.is_a?(Types::Pad) } : []
|
|
632
|
+
parameters = fields.map { it.name.as_variable_name }
|
|
633
|
+
parameters << 'attributes = []' if attribute_set
|
|
634
|
+
write("def initialize(#{parameters.join(', ')})")
|
|
635
|
+
indent do
|
|
636
|
+
fields.zip(parameters).each { |field, parameter| write("@#{field.name.as_variable_name} = #{parameter}") }
|
|
637
|
+
write('@attributes = attributes') if attribute_set
|
|
638
|
+
end
|
|
639
|
+
write('end')
|
|
640
|
+
|
|
641
|
+
emit_internal
|
|
642
|
+
write('def self.build_instance(params, external_selectors: ::Nl::Selector::EMPTY_VALUES)')
|
|
643
|
+
indent do
|
|
644
|
+
header_names = header ? 'FIXED_HEADER.members' : '::Nl::Message::EMPTY_FIELD_NAMES'
|
|
645
|
+
write("validate_params(params, #{header_names}, ATTRIBUTES)")
|
|
646
|
+
write('new(')
|
|
647
|
+
indent do
|
|
648
|
+
fields.each do |field|
|
|
649
|
+
name = field.name.as_variable_name.as_symbol_literal
|
|
650
|
+
value = field.type.is_a?(Types::Scalar) ? "params.fetch(#{name}, 0)" : "params[#{name}]"
|
|
651
|
+
write("FIXED_HEADER::MEMBERS[#{name}].coerce(#{value}),")
|
|
652
|
+
end
|
|
653
|
+
write('build_attributes(params.slice(*ATTRIBUTES), external_selectors:),') if attribute_set
|
|
654
|
+
end
|
|
655
|
+
write(')')
|
|
656
|
+
end
|
|
657
|
+
write('end')
|
|
658
|
+
|
|
659
|
+
args = 'decoder'
|
|
660
|
+
args += ', external_selectors: ::Nl::Selector::EMPTY_VALUES' if external
|
|
661
|
+
emit_comment('Decodes a message payload from the decoder into a new instance.')
|
|
662
|
+
signature = '::Nl::Decoder decoder'
|
|
663
|
+
signature += ', ?external_selectors: ::Array[untyped]' if external
|
|
664
|
+
emit_rbs_comment("(#{signature}) -> instance")
|
|
665
|
+
write("def self.decode(#{args})")
|
|
666
|
+
indent do
|
|
667
|
+
values = header ? emit_fixed_field_decode(header, members: 'FIXED_HEADER::MEMBERS') : []
|
|
668
|
+
if attribute_set
|
|
669
|
+
arguments = "decoder, BY_TYPE, #{@local_selectors.fetch(attribute_set).length}"
|
|
670
|
+
arguments += ', external_selectors:' if external
|
|
671
|
+
values << "decode_attributes(#{arguments})"
|
|
672
|
+
end
|
|
673
|
+
write("new(#{values.join(', ')})")
|
|
674
|
+
end
|
|
675
|
+
write('end')
|
|
676
|
+
|
|
677
|
+
write('def encode(encoder, external_selectors: ::Nl::Selector::EMPTY_VALUES)')
|
|
678
|
+
indent do
|
|
679
|
+
header&.members&.each do |field|
|
|
680
|
+
if field.type.is_a?(Types::Pad)
|
|
681
|
+
write("encoder.put_string(#{("\0" * field.type.length).dump})") if field.type.length
|
|
682
|
+
else
|
|
683
|
+
name = field.name.as_variable_name
|
|
684
|
+
write("FIXED_HEADER::MEMBERS[#{name.as_symbol_literal}].encode(encoder, @#{name})")
|
|
685
|
+
end
|
|
686
|
+
end
|
|
687
|
+
write('encode_attributes(encoder, external_selectors:)') if attribute_set
|
|
688
|
+
end
|
|
689
|
+
write('end')
|
|
690
|
+
end
|
|
691
|
+
|
|
565
692
|
private def emit_message_class(name, message, fixed_header:, attribute_set:, doc:)
|
|
566
693
|
emit_comment(doc)
|
|
567
|
-
emit_class(name,
|
|
694
|
+
emit_class(name, '::Nl::Message') do
|
|
568
695
|
emit_const('TYPE', message.value)
|
|
569
696
|
emit_const('FIXED_HEADER', fixed_header&.then { 'Structs::' + it.name.as_class_name } || 'nil')
|
|
570
697
|
emit_const('ATTRIBUTE_SET', "AttributeSets::#{attribute_set.name.as_class_name}")
|
|
571
698
|
attribute_params = attribute_set.attributes.map(&:name) & message.attributes
|
|
572
|
-
emit_const('ATTRIBUTES', "
|
|
699
|
+
emit_const('ATTRIBUTES', "%i[#{attribute_params.map { it.as_variable_name }.join(' ')}].freeze")
|
|
700
|
+
emit_payload_storage(fixed_header, attribute_set, external: false)
|
|
573
701
|
fixed_header&.members&.each do |member|
|
|
574
702
|
param = member.name
|
|
575
703
|
datatype = member.type
|
|
@@ -578,7 +706,7 @@ module Ynl
|
|
|
578
706
|
emit_comment(member.doc)
|
|
579
707
|
emit_rbs_comment('return: ' + struct_member_rbs_type(datatype))
|
|
580
708
|
emit_yard_return(struct_member_yard_type(datatype))
|
|
581
|
-
emit_getter(param.as_method_name, "
|
|
709
|
+
emit_getter(param.as_method_name, "@#{param.as_variable_name}")
|
|
582
710
|
end
|
|
583
711
|
attribute_params.each do |param|
|
|
584
712
|
attribute = attribute_set.attributes.find { it.name == param }
|
|
@@ -593,15 +721,14 @@ module Ynl
|
|
|
593
721
|
emit_comment(attribute_doc(attribute))
|
|
594
722
|
emit_rbs_comment('return: ' + attribute_rbs_type(attribute))
|
|
595
723
|
emit_yard_return(attribute_yard_type(attribute))
|
|
596
|
-
emit_yard_see("AttributeSets::#{attribute_set.name.as_class_name}::#{attribute.name.as_class_name}")
|
|
597
724
|
if attribute.multi?
|
|
598
|
-
emit_getter(param.as_method_name, "
|
|
725
|
+
emit_getter(param.as_method_name, "self[#{param.as_variable_name.as_symbol_literal}]")
|
|
599
726
|
next
|
|
600
727
|
end
|
|
601
728
|
if extending
|
|
602
|
-
emit_getter(param.as_method_name, "
|
|
729
|
+
emit_getter(param.as_method_name, "self[#{param.as_variable_name.as_symbol_literal}] || @#{param.as_variable_name}")
|
|
603
730
|
else
|
|
604
|
-
emit_getter(param.as_method_name, "
|
|
731
|
+
emit_getter(param.as_method_name, "self[#{param.as_variable_name.as_symbol_literal}]")
|
|
605
732
|
end
|
|
606
733
|
end
|
|
607
734
|
end
|
|
@@ -628,10 +755,14 @@ module Ynl
|
|
|
628
755
|
end
|
|
629
756
|
|
|
630
757
|
private def emit_sub_message_class(name, format)
|
|
631
|
-
emit_class(name, '::Nl::
|
|
758
|
+
emit_class(name, '::Nl::Message') do
|
|
632
759
|
emit_const('FIXED_HEADER', format.fixed_header&.then { 'Structs::' + it.name.as_class_name } || 'nil')
|
|
633
760
|
emit_const('ATTRIBUTE_SET', format.attribute_set&.then { 'AttributeSets::' + it.name.as_class_name } || 'nil')
|
|
634
761
|
|
|
762
|
+
names = format.attribute_set&.attributes&.map(&:name) || []
|
|
763
|
+
emit_const('ATTRIBUTES', "%i[#{names.map { it.as_variable_name }.join(' ')}].freeze")
|
|
764
|
+
emit_payload_storage(format.fixed_header, format.attribute_set, external: true)
|
|
765
|
+
|
|
635
766
|
format.fixed_header&.members&.each do |member|
|
|
636
767
|
next if member.type.is_a?(Types::Pad)
|
|
637
768
|
extending = format.attribute_set&.attributes&.any? { it.name == member.name }
|
|
@@ -639,7 +770,7 @@ module Ynl
|
|
|
639
770
|
emit_comment(member.doc)
|
|
640
771
|
emit_rbs_comment('return: ' + struct_member_rbs_type(member.type))
|
|
641
772
|
emit_yard_return(struct_member_yard_type(member.type))
|
|
642
|
-
emit_getter(member.name.as_method_name, "
|
|
773
|
+
emit_getter(member.name.as_method_name, "@#{member.name.as_variable_name}")
|
|
643
774
|
end
|
|
644
775
|
|
|
645
776
|
format.attribute_set&.attributes&.each do |attribute|
|
|
@@ -648,13 +779,12 @@ module Ynl
|
|
|
648
779
|
emit_comment(attribute_doc(attribute))
|
|
649
780
|
emit_rbs_comment('return: ' + attribute_rbs_type(attribute))
|
|
650
781
|
emit_yard_return(attribute_yard_type(attribute))
|
|
651
|
-
emit_yard_see("AttributeSets::#{format.attribute_set.name.as_class_name}::#{attribute.name.as_class_name}")
|
|
652
782
|
expression = if attribute.multi?
|
|
653
|
-
"
|
|
783
|
+
"self[#{attribute.name.as_variable_name.as_symbol_literal}]"
|
|
654
784
|
elsif extending
|
|
655
|
-
"
|
|
785
|
+
"self[#{attribute.name.as_variable_name.as_symbol_literal}] || @#{attribute.name.as_variable_name}"
|
|
656
786
|
else
|
|
657
|
-
"
|
|
787
|
+
"self[#{attribute.name.as_variable_name.as_symbol_literal}]"
|
|
658
788
|
end
|
|
659
789
|
emit_getter(attribute.name.as_method_name, expression)
|
|
660
790
|
end
|
|
@@ -778,14 +908,14 @@ module Ynl
|
|
|
778
908
|
formats = type.sub_message.formats.map do |format|
|
|
779
909
|
"SubMessages::#{type.sub_message.name.as_class_name}::#{format.value.as_class_name}"
|
|
780
910
|
end
|
|
781
|
-
(formats << '::Nl::
|
|
911
|
+
(formats << '::Nl::RawAttributeValue').join(' | ')
|
|
782
912
|
end
|
|
783
913
|
|
|
784
914
|
private def sub_message_yard_type(type)
|
|
785
915
|
formats = type.sub_message.formats.map do |format|
|
|
786
916
|
"SubMessages::#{type.sub_message.name.as_class_name}::#{format.value.as_class_name}"
|
|
787
917
|
end
|
|
788
|
-
(formats << 'Nl::
|
|
918
|
+
(formats << 'Nl::RawAttributeValue').join(', ')
|
|
789
919
|
end
|
|
790
920
|
|
|
791
921
|
private def yard_type(type)
|
|
@@ -805,7 +935,7 @@ module Ynl
|
|
|
805
935
|
type.type_values.length.times { value_type = "Hash<Integer, #{value_type}>" }
|
|
806
936
|
value_type
|
|
807
937
|
when Types::SubMessage
|
|
808
|
-
'Nl::
|
|
938
|
+
'Nl::Message, Nl::RawAttributeValue'
|
|
809
939
|
when Types::Pad
|
|
810
940
|
'nil'
|
|
811
941
|
when Types::Bitfield32
|
|
@@ -831,7 +961,7 @@ module Ynl
|
|
|
831
961
|
end
|
|
832
962
|
emit_const(
|
|
833
963
|
'MCAST_GROUPS',
|
|
834
|
-
"
|
|
964
|
+
"{#{entries.join(', ')}}.freeze",
|
|
835
965
|
rbs: 'Hash[::Symbol, ::Nl::McastGroup]',
|
|
836
966
|
internal: true,
|
|
837
967
|
)
|
|
@@ -1077,7 +1207,7 @@ module Ynl
|
|
|
1077
1207
|
bindings = @external_selectors.fetch(child).map do |selector|
|
|
1078
1208
|
selector_source_literal(parent, selector)
|
|
1079
1209
|
end
|
|
1080
|
-
"
|
|
1210
|
+
"[#{bindings.join(', ')}]"
|
|
1081
1211
|
end
|
|
1082
1212
|
|
|
1083
1213
|
private def selector_value_literal(set, selector, format_value)
|
|
@@ -1119,7 +1249,7 @@ module Ynl
|
|
|
1119
1249
|
end
|
|
1120
1250
|
|
|
1121
1251
|
private def to_datatype(type, checks, owner: nil)
|
|
1122
|
-
case type
|
|
1252
|
+
datatype = case type
|
|
1123
1253
|
when Types::Pad
|
|
1124
1254
|
"::Nl::DataTypes::Pad.new(#{type.length})"
|
|
1125
1255
|
when Types::Flag
|
|
@@ -1129,20 +1259,20 @@ module Ynl
|
|
|
1129
1259
|
when Types::Scalar
|
|
1130
1260
|
byte_order = "::Nl::Endian::#{type.byte_order.name.as_class_name}"
|
|
1131
1261
|
if ['sint', 'uint'].include?(type.type)
|
|
1132
|
-
"::Nl::DataTypes::VariableInteger.new(#{byte_order}, signed: #{type.type == 'sint'}
|
|
1262
|
+
"::Nl::DataTypes::VariableInteger.new(#{byte_order}, signed: #{type.type == 'sint'})"
|
|
1133
1263
|
else
|
|
1134
|
-
"::Nl::DataTypes::Scalar
|
|
1264
|
+
"::Nl::DataTypes::Scalar[#{byte_order}::#{type.type.as_const_name}].new"
|
|
1135
1265
|
end
|
|
1136
1266
|
when Types::String
|
|
1137
|
-
"::Nl::DataTypes::String.new
|
|
1267
|
+
"::Nl::DataTypes::String.new"
|
|
1138
1268
|
when Types::Binary
|
|
1139
1269
|
if type.struct
|
|
1140
|
-
"::Nl::DataTypes::Struct.new(Structs::#{type.struct.name.as_class_name},
|
|
1270
|
+
"::Nl::DataTypes::Struct.new(Structs::#{type.struct.name.as_class_name}, consume_remaining: true)"
|
|
1141
1271
|
else
|
|
1142
|
-
"::Nl::DataTypes::Binary.new
|
|
1272
|
+
"::Nl::DataTypes::Binary.new"
|
|
1143
1273
|
end
|
|
1144
1274
|
when Types::PackedArray
|
|
1145
|
-
"::Nl::DataTypes::PackedArray.new(#{to_datatype(type.sub_type, nil)}
|
|
1275
|
+
"::Nl::DataTypes::PackedArray.new(#{to_datatype(type.sub_type, nil)})"
|
|
1146
1276
|
when Types::NestedAttributes
|
|
1147
1277
|
bindings = selector_bindings_literal(owner, type.attribute_set)
|
|
1148
1278
|
"::Nl::DataTypes::NestedAttributes.new(AttributeSets::#{type.attribute_set.name.as_class_name}, selector_bindings: #{bindings})"
|
|
@@ -1164,21 +1294,79 @@ module Ynl
|
|
|
1164
1294
|
else
|
|
1165
1295
|
raise "Unknown type: #{type.class}"
|
|
1166
1296
|
end
|
|
1297
|
+
|
|
1298
|
+
return datatype if !checks || checks.empty?
|
|
1299
|
+
|
|
1300
|
+
case type
|
|
1301
|
+
when Types::Scalar, Types::String
|
|
1302
|
+
"::Nl::DataTypes::Checked.new(#{datatype}, check: #{to_checks(checks)})"
|
|
1303
|
+
when Types::Binary
|
|
1304
|
+
wrapper = type.struct ? 'CheckedPayload' : 'Checked'
|
|
1305
|
+
"::Nl::DataTypes::#{wrapper}.new(#{datatype}, check: #{to_checks(checks)})"
|
|
1306
|
+
when Types::PackedArray
|
|
1307
|
+
"::Nl::DataTypes::CheckedPayload.new(#{datatype}, check: #{to_checks(checks)})"
|
|
1308
|
+
else
|
|
1309
|
+
datatype
|
|
1310
|
+
end
|
|
1311
|
+
end
|
|
1312
|
+
|
|
1313
|
+
private def grouped_member_width(type)
|
|
1314
|
+
return type.length if type.is_a?(Types::Pad)
|
|
1315
|
+
return unless type.is_a?(Types::Scalar)
|
|
1316
|
+
|
|
1317
|
+
case type.type
|
|
1318
|
+
when 'u8', 's8' then 1
|
|
1319
|
+
when 'u16', 's16' then 2
|
|
1320
|
+
end
|
|
1321
|
+
end
|
|
1322
|
+
|
|
1323
|
+
private def grouped_scalar_value(type, offset)
|
|
1324
|
+
low = "((word >> #{offset * 8}) & 0xff)"
|
|
1325
|
+
if grouped_member_width(type) == 1
|
|
1326
|
+
value = low
|
|
1327
|
+
sign = '0x80'
|
|
1328
|
+
else
|
|
1329
|
+
little = "((word >> #{offset * 8}) & 0xffff)"
|
|
1330
|
+
high = "((word >> #{(offset + 1) * 8}) & 0xff)"
|
|
1331
|
+
big = "((#{low} << 8) | #{high})"
|
|
1332
|
+
value = case type.byte_order
|
|
1333
|
+
when :little then little
|
|
1334
|
+
when :big then big
|
|
1335
|
+
when :host
|
|
1336
|
+
"(::IO::Buffer::HOST_ENDIAN == ::IO::Buffer::LITTLE_ENDIAN ? #{little} : #{big})"
|
|
1337
|
+
end
|
|
1338
|
+
sign = '0x8000'
|
|
1339
|
+
end
|
|
1340
|
+
type.type.start_with?('s') ? "((#{value} ^ #{sign}) - #{sign})" : value
|
|
1341
|
+
end
|
|
1342
|
+
|
|
1343
|
+
private def struct_member_reader(type)
|
|
1344
|
+
return unless type.is_a?(Types::Scalar)
|
|
1345
|
+
return if ['uint', 'sint'].include?(type.type)
|
|
1346
|
+
|
|
1347
|
+
case type.byte_order
|
|
1348
|
+
when :host
|
|
1349
|
+
"get_host_#{type.type}"
|
|
1350
|
+
when :big
|
|
1351
|
+
"get_#{type.type.upcase}"
|
|
1352
|
+
when :little
|
|
1353
|
+
"get_#{['u8', 's8'].include?(type.type) ? type.type.upcase : type.type}"
|
|
1354
|
+
end
|
|
1167
1355
|
end
|
|
1168
1356
|
|
|
1169
1357
|
private def to_struct_member_datatype(type)
|
|
1170
1358
|
if type.is_a?(Types::Binary) && type.struct
|
|
1171
|
-
"::Nl::DataTypes::Struct.new(Structs::#{type.struct.name.as_class_name}
|
|
1359
|
+
"::Nl::DataTypes::Struct.new(Structs::#{type.struct.name.as_class_name})"
|
|
1172
1360
|
elsif type.is_a?(Types::Binary)
|
|
1173
|
-
"::Nl::DataTypes::Binary.new(length: #{type.length}
|
|
1361
|
+
"::Nl::DataTypes::Binary.new(length: #{type.length})"
|
|
1174
1362
|
else
|
|
1175
1363
|
to_datatype(type, nil)
|
|
1176
1364
|
end
|
|
1177
1365
|
end
|
|
1178
1366
|
|
|
1179
1367
|
private def to_checks(checks)
|
|
1180
|
-
|
|
1181
|
-
|
|
1368
|
+
body = "{ #{checks.map { to_check(it) }.join('; ')} }"
|
|
1369
|
+
"nil.instance_exec { -> #{body} }"
|
|
1182
1370
|
end
|
|
1183
1371
|
|
|
1184
1372
|
private def to_check(check)
|