Lines Matching +full:self +full:-
1 # SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
31 def __init__(self, family, yaml): argument
32 self.yaml = yaml
33 self.family = family
35 if 'name' in self.yaml:
36 self.name = self.yaml['name']
37 self.ident_name = self.name.replace('-', '_')
39 self._super_resolved = False
40 family.add_unresolved(self)
42 def __getitem__(self, key): argument
43 return self.yaml[key]
45 def __contains__(self, key): argument
46 return key in self.yaml
48 def get(self, key, default=None): argument
49 return self.yaml.get(key, default)
51 def resolve_up(self, up): argument
52 if not self._super_resolved:
54 self._super_resolved = True
56 def resolve(self): argument
72 def __init__(self, enum_set, yaml, prev, value_start): argument
77 self.doc = yaml.get('doc', '')
78 self.enum_set = enum_set
81 self.value = yaml['value']
83 self.value = prev.value + 1
85 self.value = value_start
87 def has_doc(self): argument
88 return bool(self.doc)
90 def raw_value(self): argument
91 return self.value
93 def user_value(self, as_flags=None): argument
94 if self.enum_set['type'] == 'flags' or as_flags:
95 return 1 << self.value
97 return self.value
113 def __init__(self, family, yaml): argument
116 self.type = yaml['type']
119 value_start = self.yaml.get('value-start', 0)
120 self.entries = dict()
121 self.entries_by_val = dict()
122 for entry in self.yaml['entries']:
123 e = self.new_entry(entry, prev_entry, value_start)
124 self.entries[e.name] = e
125 self.entries_by_val[e.raw_value()] = e
128 def new_entry(self, entry, prev_entry, value_start): argument
129 return SpecEnumEntry(self, entry, prev_entry, value_start)
131 def has_doc(self): argument
132 if 'doc' in self.yaml:
134 for entry in self.entries.values():
139 def get_mask(self, as_flags=None): argument
141 for e in self.entries.values():
161 def __init__(self, family, attr_set, yaml, value): argument
164 self.value = value
165 self.attr_set = attr_set
166 self.is_multi = yaml.get('multi-attr', False)
167 self.struct_name = yaml.get('struct')
168 self.sub_type = yaml.get('sub-type')
169 self.byte_order = yaml.get('byte-order')
170 self.len = yaml.get('len')
171 self.display_hint = yaml.get('display-hint')
187 def __init__(self, family, yaml): argument
190 self.subset_of = self.yaml.get('subset-of', None)
192 self.attrs = collections.OrderedDict()
193 self.attrs_by_val = collections.OrderedDict()
195 if self.subset_of is None:
197 for elem in self.yaml['attributes']:
201 attr = self.new_attr(elem, val)
202 self.attrs[attr.name] = attr
203 self.attrs_by_val[attr.value] = attr
206 real_set = family.attr_sets[self.subset_of]
207 for elem in self.yaml['attributes']:
209 self.attrs[attr.name] = attr
210 self.attrs_by_val[attr.value] = attr
212 def new_attr(self, elem, value): argument
213 return SpecAttr(self.family, self, elem, value)
215 def __getitem__(self, key): argument
216 return self.attrs[key]
218 def __contains__(self, key): argument
219 return key in self.attrs
221 def __iter__(self): argument
222 yield from self.attrs
224 def items(self): argument
225 return self.attrs.items()
241 def __init__(self, family, yaml): argument
243 self.type = yaml['type']
244 self.byte_order = yaml.get('byte-order')
245 self.enum = yaml.get('enum')
246 self.len = yaml.get('len')
247 self.display_hint = yaml.get('display-hint')
258 def __init__(self, family, yaml): argument
261 self.members = []
263 self.members.append(self.new_member(family, member))
265 def new_member(self, family, elem): argument
268 def __iter__(self): argument
269 yield from self.members
271 def items(self): argument
272 return self.members.items()
283 req_value numerical ID when serialized, user -> kernel
284 rsp_value numerical ID when serialized, user <- kernel
293 def __init__(self, family, yaml, req_value, rsp_value): argument
296 self.value = req_value if req_value == rsp_value else None
297 self.req_value = req_value
298 self.rsp_value = rsp_value
300 self.is_call = 'do' in yaml or 'dump' in yaml
301 self.is_async = 'notify' in yaml or 'event' in yaml
302 self.is_resv = not self.is_async and not self.is_call
303 self.fixed_header = self.yaml.get('fixed-header', family.fixed_header)
306 self.attr_set = None
307 delattr(self, "attr_set")
309 def resolve(self): argument
310 self.resolve_up(super())
312 if 'attribute-set' in self.yaml:
313 attr_set_name = self.yaml['attribute-set']
314 elif 'notify' in self.yaml:
315 msg = self.family.msgs[self.yaml['notify']]
316 attr_set_name = msg['attribute-set']
317 elif self.is_resv:
320 raise Exception(f"Can't resolve attribute set for op '{self.name}'")
322 self.attr_set = self.family.attr_sets[attr_set_name]
331 netlink-raw schema. Genetlink families use dynamic ID allocation
337 value integer id of this multicast group for netlink-raw or None
340 def __init__(self, family, yaml): argument
342 self.value = self.yaml.get('value')
357 msg_id_model enum-model for operations (unified, directional etc.)
368 def __init__(self, spec_path, schema_path=None, exclude_ops=None): argument
370 prefix = '# SPDX-License-Identifier: '
374 self.license = first[len(prefix):]
379 self._resolution_list = []
381 super().__init__(self, spec)
383 self._exclude_ops = exclude_ops if exclude_ops else []
385 self.proto = self.yaml.get('protocol', 'genetlink')
386 self.msg_id_model = self.yaml['operations'].get('enum-model', 'unified')
389 schema_path = os.path.dirname(os.path.dirname(spec_path)) + f'/{self.proto}.yaml'
399 jsonschema.validate(self.yaml, schema)
401 self.attr_sets = collections.OrderedDict()
402 self.msgs = collections.OrderedDict()
403 self.req_by_value = collections.OrderedDict()
404 self.rsp_by_value = collections.OrderedDict()
405 self.ops = collections.OrderedDict()
406 self.ntfs = collections.OrderedDict()
407 self.consts = collections.OrderedDict()
408 self.mcast_groups = collections.OrderedDict()
411 while len(self._resolution_list) > 0:
413 unresolved = self._resolution_list
414 self._resolution_list = []
420 self._resolution_list.append(elem)
429 def new_enum(self, elem): argument
430 return SpecEnumSet(self, elem)
432 def new_attr_set(self, elem): argument
433 return SpecAttrSet(self, elem)
435 def new_struct(self, elem): argument
436 return SpecStruct(self, elem)
438 def new_operation(self, elem, req_val, rsp_val): argument
439 return SpecOperation(self, elem, req_val, rsp_val)
441 def new_mcast_group(self, elem): argument
442 return SpecMcastGroup(self, elem)
444 def add_unresolved(self, elem): argument
445 self._resolution_list.append(elem)
447 def _dictify_ops_unified(self): argument
448 self.fixed_header = self.yaml['operations'].get('fixed-header')
450 for elem in self.yaml['operations']['list']:
454 op = self.new_operation(elem, val, val)
457 self.msgs[op.name] = op
459 def _dictify_ops_directional(self): argument
460 self.fixed_header = self.yaml['operations'].get('fixed-header')
462 for elem in self.yaml['operations']['list']:
491 for exclude in self._exclude_ops:
494 op = self.new_operation(elem, req_val, rsp_val)
499 self.msgs[op.name] = op
501 def find_operation(self, name): argument
505 for op in self.yaml['operations']['list']:
510 def resolve(self): argument
511 self.resolve_up(super())
513 definitions = self.yaml.get('definitions', [])
516 self.consts[elem['name']] = self.new_enum(elem)
518 self.consts[elem['name']] = self.new_struct(elem)
520 self.consts[elem['name']] = elem
522 for elem in self.yaml['attribute-sets']:
523 attr_set = self.new_attr_set(elem)
524 self.attr_sets[elem['name']] = attr_set
526 if self.msg_id_model == 'unified':
527 self._dictify_ops_unified()
528 elif self.msg_id_model == 'directional':
529 self._dictify_ops_directional()
531 for op in self.msgs.values():
533 self.req_by_value[op.req_value] = op
535 self.rsp_by_value[op.rsp_value] = op
536 if not op.is_async and 'attribute-set' in op:
537 self.ops[op.name] = op
539 self.ntfs[op.name] = op
541 mcgs = self.yaml.get('mcast-groups')
544 mcg = self.new_mcast_group(elem)
545 self.mcast_groups[elem['name']] = mcg