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.
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?(/[A-Z]/i) }
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
- struct.members.each do |member|
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
- struct.members.each do |member|
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 = struct.members.map do |member|
107
+ members = fields.map do |member|
108
108
  "#{member.name.as_variable_name}: #{to_struct_member_datatype(member.type)}"
109
109
  end
110
- members = "Ractor.make_shareable({#{members.join(', ')}})"
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
- write('self.new(*MEMBERS.map {|name, datatype| datatype.decode(decoder) })')
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
- write('MEMBERS.each {|name, datatype| datatype.encode(encoder, self.public_send(name)) }')
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
- emit_comment("Abstract class")
156
- emit_class('Attribute', '::Nl::AttributeSet::Attribute') do
157
- end
158
- attr_set.attributes.each do |attr|
159
- emit_comment(attribute_doc(attr))
160
- emit_class(attr.name.as_class_name, 'Attribute') do
161
- emit_const('TYPE', attr.value)
162
- emit_const('NAME', attr.name.as_variable_name.as_symbol_literal)
163
- emit_const('MULTI', 'true', internal: true) if attr.multi?
164
- emit_const('ORDER', @attribute_orders.fetch(attr_set).fetch(attr), internal: true)
165
- if slot = @local_selectors.fetch(attr_set).index(attr.name)
166
- emit_const('SELECTOR_SLOT', slot, internal: true)
167
- end
168
- if attr.type.is_a?(Types::SubMessage)
169
- deferred_sub_message_datatypes << [
170
- "AttributeSets::#{name.as_class_name}::#{attr.name.as_class_name}::DATATYPE",
171
- to_datatype(attr.type, attr.checks, owner: attr_set),
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
- attr_set.attributes.each do |attribute|
208
- next if attribute.type.is_a?(Types::Pad)
205
+ attr_set.attributes.each do |attribute|
206
+ next if attribute.type.is_a?(Types::Pad)
209
207
 
210
- emit_comment(attribute_doc(attribute))
211
- emit_rbs_comment('return: ' + attribute_rbs_type(attribute))
212
- emit_yard_return(attribute_yard_type(attribute))
213
- emit_yard_see(attribute.name.as_class_name)
214
- expression = if attribute.multi?
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
- emit_singleton_class do
223
- emit_comment('Looks up Attribute class by name.')
224
- emit_rbs_comment(
225
- 'name: Symbol',
226
- 'return: Attribute',
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
- deferred_sub_message_datatypes.each do |const|
251
- emit_const(*const, internal: true)
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
- "Ractor.make_shareable({#{notification_operations.map { |oper| "#{oper.notification.message.value} => Notifications::#{oper.name.as_class_name}" }.join(', ') }})",
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, "#@wire::Message") do
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', "Ractor.make_shareable(%i[#{attribute_params.map { it.as_variable_name }.join(' ')}])")
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, "fixed_header.#{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, "attributes[#{param.as_variable_name.as_symbol_literal}].map(&:value)")
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, "attributes[#{param.as_variable_name.as_symbol_literal}]&.value || fixed_header.#{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, "attributes[#{param.as_variable_name.as_symbol_literal}]&.value")
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::SubMessage') do
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, "fixed_header.#{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
- "attributes[#{attribute.name.as_variable_name.as_symbol_literal}].map(&:value)"
783
+ "self[#{attribute.name.as_variable_name.as_symbol_literal}]"
654
784
  elsif extending
655
- "attributes[#{attribute.name.as_variable_name.as_symbol_literal}]&.value || fixed_header.#{attribute.name.as_method_name}"
785
+ "self[#{attribute.name.as_variable_name.as_symbol_literal}] || @#{attribute.name.as_variable_name}"
656
786
  else
657
- "attributes[#{attribute.name.as_variable_name.as_symbol_literal}]&.value"
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::RawSubMessage').join(' | ')
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::RawSubMessage').join(', ')
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::SubMessage'
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
- "Ractor.make_shareable({#{entries.join(', ')}})",
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
- "Ractor.make_shareable([#{bindings.join(', ')}])"
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'}, check: #{to_checks(checks)})"
1262
+ "::Nl::DataTypes::VariableInteger.new(#{byte_order}, signed: #{type.type == 'sint'})"
1133
1263
  else
1134
- "::Nl::DataTypes::Scalar.new(#{byte_order}::#{type.type.as_const_name}, check: #{to_checks(checks)})"
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(check: #{to_checks(checks)})"
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}, check: #{to_checks(checks)}, consume_remaining: true)"
1270
+ "::Nl::DataTypes::Struct.new(Structs::#{type.struct.name.as_class_name}, consume_remaining: true)"
1141
1271
  else
1142
- "::Nl::DataTypes::Binary.new(check: #{to_checks(checks)})"
1272
+ "::Nl::DataTypes::Binary.new"
1143
1273
  end
1144
1274
  when Types::PackedArray
1145
- "::Nl::DataTypes::PackedArray.new(#{to_datatype(type.sub_type, nil)}, check: #{to_checks(checks)})"
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}, check: nil)"
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}, check: nil)"
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
- return 'nil' if !checks || checks.empty?
1181
- %Q{-> { #{checks.map { to_check(it) }.join('; ')} }}
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)