ynl/lib/nlspec.py

31     def __init__(self, family, yaml):
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):
43         return self.yaml[key]
45     def __contains__(self, key):
46         return key in self.yaml
48     def get(self, key, default=None):
49         return self.yaml.get(key, default)
51     def resolve_up(self, up):
52         if not self._super_resolved:
54             self._super_resolved = True
56     def resolve(self):
72     def __init__(self, enum_set, yaml, prev, value_start):
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):
88         return bool(self.doc)
90     def raw_value(self):
91         return self.value
93     def user_value(self, as_flags=None):
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):
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):
129         return SpecEnumEntry(self, entry, prev_entry, value_start)
131     def has_doc(self):
132         if 'doc' in self.yaml:
134         for entry in self.entries.values():
139     def get_mask(self, as_flags=None):
141         for e in self.entries.values():
167     def __init__(self, family, attr_set, yaml, value):
170         self.type = yaml['type']
171         self.value = value
172         self.attr_set = attr_set
173         self.is_multi = yaml.get('multi-attr', False)
174         self.struct_name = yaml.get('struct')
175         self.sub_type = yaml.get('sub-type')
176         self.byte_order = yaml.get('byte-order')
177         self.len = yaml.get('len')
178         self.display_hint = yaml.get('display-hint')
179         self.sub_message = yaml.get('sub-message')
180         self.selector = yaml.get('selector')
182         self.is_auto_scalar = self.type == "sint" or self.type == "uint"
198     def __init__(self, family, yaml):
201         self.subset_of = self.yaml.get('subset-of', None)
203         self.attrs = collections.OrderedDict()
204         self.attrs_by_val = collections.OrderedDict()
206         if self.subset_of is None:
208             for elem in self.yaml['attributes']:
212                 attr = self.new_attr(elem, val)
213                 self.attrs[attr.name] = attr
214                 self.attrs_by_val[attr.value] = attr
217             real_set = family.attr_sets[self.subset_of]
218             for elem in self.yaml['attributes']:
220                 self.attrs[attr.name] = attr
221                 self.attrs_by_val[attr.value] = attr
223     def new_attr(self, elem, value):
224         return SpecAttr(self.family, self, elem, value)
226     def __getitem__(self, key):
227         return self.attrs[key]
229     def __contains__(self, key):
230         return key in self.attrs
232     def __iter__(self):
233         yield from self.attrs
235     def items(self):
236         return self.attrs.items()
253     def __init__(self, family, yaml):
255         self.type = yaml['type']
256         self.byte_order = yaml.get('byte-order')
257         self.enum = yaml.get('enum')
258         self.len = yaml.get('len')
259         self.display_hint = yaml.get('display-hint')
260         self.struct = yaml.get('struct')
271     def __init__(self, family, yaml):
274         self.members = []
276             self.members.append(self.new_member(family, member))
278     def new_member(self, family, elem):
281     def __iter__(self):
282         yield from self.members
284     def items(self):
285         return self.members.items()
298     def __init__(self, family, yaml):
301         self.formats = collections.OrderedDict()
302         for elem in self.yaml['formats']:
303             format = self.new_format(family, elem)
304             self.formats[format.value] = format
306     def new_format(self, family, format):
320     def __init__(self, family, yaml):
323         self.value = yaml.get('value')
324         self.fixed_header = yaml.get('fixed-header')
325         self.attr_set = yaml.get('attribute-set')
346     def __init__(self, family, yaml, req_value, rsp_value):
349         self.value = req_value if req_value == rsp_value else None
350         self.req_value = req_value
351         self.rsp_value = rsp_value
353         self.is_call = 'do' in yaml or 'dump' in yaml
354         self.is_async = 'notify' in yaml or 'event' in yaml
355         self.is_resv = not self.is_async and not self.is_call
356         self.fixed_header = self.yaml.get('fixed-header', family.fixed_header)
359         self.attr_set = None
360         delattr(self, "attr_set")
362     def resolve(self):
363         self.resolve_up(super())
365         if 'attribute-set' in self.yaml:
366             attr_set_name = self.yaml['attribute-set']
367         elif 'notify' in self.yaml:
368             msg = self.family.msgs[self.yaml['notify']]
370         elif self.is_resv:
373             raise Exception(f"Can't resolve attribute set for op '{self.name}'")
375             self.attr_set = self.family.attr_sets[attr_set_name]
393     def __init__(self, family, yaml):
395         self.value = self.yaml.get('value')
423     def __init__(self, spec_path, schema_path=None, exclude_ops=None):
429             self.license = first[len(prefix):]
434         self._resolution_list = []
436         super().__init__(self, spec)
438         self._exclude_ops = exclude_ops if exclude_ops else []
440         self.proto = self.yaml.get('protocol', 'genetlink')
441         self.msg_id_model = self.yaml['operations'].get('enum-model', 'unified')
444             schema_path = os.path.dirname(os.path.dirname(spec_path)) + f'/{self.proto}.yaml'
454             jsonschema.validate(self.yaml, schema)
456         self.attr_sets = collections.OrderedDict()
457         self.sub_msgs = collections.OrderedDict()
458         self.msgs = collections.OrderedDict()
459         self.req_by_value = collections.OrderedDict()
460         self.rsp_by_value = collections.OrderedDict()
461         self.ops = collections.OrderedDict()
462         self.ntfs = collections.OrderedDict()
463         self.consts = collections.OrderedDict()
464         self.mcast_groups = collections.OrderedDict()
465         self.kernel_family = collections.OrderedDict(self.yaml.get('kernel-family', {}))
468         while len(self._resolution_list) > 0:
470             unresolved = self._resolution_list
471             self._resolution_list = []
477                     self._resolution_list.append(elem)
486     def new_enum(self, elem):
487         return SpecEnumSet(self, elem)
489     def new_attr_set(self, elem):
490         return SpecAttrSet(self, elem)
492     def new_struct(self, elem):
493         return SpecStruct(self, elem)
495     def new_sub_message(self, elem):
496         return SpecSubMessage(self, elem);
498     def new_operation(self, elem, req_val, rsp_val):
499         return SpecOperation(self, elem, req_val, rsp_val)
501     def new_mcast_group(self, elem):
502         return SpecMcastGroup(self, elem)
504     def add_unresolved(self, elem):
505         self._resolution_list.append(elem)
507     def _dictify_ops_unified(self):
508         self.fixed_header = self.yaml['operations'].get('fixed-header')
510         for elem in self.yaml['operations']['list']:
514             op = self.new_operation(elem, val, val)
517             self.msgs[op.name] = op
519     def _dictify_ops_directional(self):
520         self.fixed_header = self.yaml['operations'].get('fixed-header')
522         for elem in self.yaml['operations']['list']:
551             for exclude in self._exclude_ops:
554                 op = self.new_operation(elem, req_val, rsp_val)
559             self.msgs[op.name] = op
561     def find_operation(self, name):
565       for op in self.yaml['operations']['list']:
570     def resolve(self):
571         self.resolve_up(super())
573         definitions = self.yaml.get('definitions', [])
576                 self.consts[elem['name']] = self.new_enum(elem)
578                 self.consts[elem['name']] = self.new_struct(elem)
580                 self.consts[elem['name']] = elem
582         for elem in self.yaml['attribute-sets']:
583             attr_set = self.new_attr_set(elem)
584             self.attr_sets[elem['name']] = attr_set
586         for elem in self.yaml.get('sub-messages', []):
587             sub_message = self.new_sub_message(elem)
588             self.sub_msgs[sub_message.name] = sub_message
590         if self.msg_id_model == 'unified':
591             self._dictify_ops_unified()
592         elif self.msg_id_model == 'directional':
593             self._dictify_ops_directional()
595         for op in self.msgs.values():
597                 self.req_by_value[op.req_value] = op
599                 self.rsp_by_value[op.rsp_value] = op
601                 self.ops[op.name] = op
603                 self.ntfs[op.name] = op
605         mcgs = self.yaml.get('mcast-groups')
608                 mcg = self.new_mcast_group(elem)
609                 self.mcast_groups[elem['name']] = mcg