Lines Matching full:self
40 def get_family_id(self): argument
43 def parse_cb_run(self, cb, data, is_dump=False, indent=1): argument
53 def __init__(self, family, attr_set, attr, value): argument
56 self.attr = attr
57 self.attr_set = attr_set
58 self.type = attr['type']
59 self.checks = attr.get('checks', {})
61 self.request = False
62 self.reply = False
65 self.len = attr['len']
68 self.nested_attrs = attr['nested-attributes']
69 if self.nested_attrs == family.name:
70 self.nested_render_name = c_lower(f"{family.name}")
72 self.nested_render_name = c_lower(f"{family.name}_{self.nested_attrs}")
74 if self.nested_attrs in self.family.consts:
75 self.nested_struct_type = 'struct ' + self.nested_render_name + '_'
77 self.nested_struct_type = 'struct ' + self.nested_render_name
79 self.c_name = c_lower(self.name)
80 if self.c_name in _C_KW:
81 self.c_name += '_'
84 self.enum_name = None
85 delattr(self, "enum_name")
87 def get_limit(self, limit, default=None): argument
88 value = self.checks.get(limit, default)
95 def resolve(self): argument
96 if 'name-prefix' in self.attr:
97 enum_name = f"{self.attr['name-prefix']}{self.name}"
99 enum_name = f"{self.attr_set.name_prefix}{self.name}"
100 self.enum_name = c_upper(enum_name)
102 def is_multi_val(self): argument
105 def is_scalar(self): argument
106 return self.type in {'u8', 'u16', 'u32', 'u64', 's32', 's64'}
108 def is_recursive(self): argument
111 def is_recursive_for_op(self, ri): argument
112 return self.is_recursive() and not ri.op
114 def presence_type(self): argument
117 def presence_member(self, space, type_filter): argument
118 if self.presence_type() != type_filter:
121 if self.presence_type() == 'bit':
123 return f"{pfx}u32 {self.c_name}:1;"
125 if self.presence_type() == 'len':
127 return f"{pfx}u32 {self.c_name}_len;"
129 def _complex_member_type(self, ri): argument
132 def free_needs_iter(self): argument
135 def free(self, ri, var, ref): argument
136 if self.is_multi_val() or self.presence_type() == 'len':
137 ri.cw.p(f'free({var}->{ref}{self.c_name});')
139 def arg_member(self, ri): argument
140 member = self._complex_member_type(ri)
142 arg = [member + ' *' + self.c_name]
143 if self.presence_type() == 'count':
144 arg += ['unsigned int n_' + self.c_name]
146 raise Exception(f"Struct member not implemented for class type {self.type}")
148 def struct_member(self, ri): argument
149 if self.is_multi_val():
150 ri.cw.p(f"unsigned int n_{self.c_name};")
151 member = self._complex_member_type(ri)
153 ptr = '*' if self.is_multi_val() else ''
154 if self.is_recursive_for_op(ri):
156 ri.cw.p(f"{member} {ptr}{self.c_name};")
158 members = self.arg_member(ri)
162 def _attr_policy(self, policy): argument
165 def attr_policy(self, cw): argument
166 policy = c_upper('nla-' + self.attr['type'])
168 spec = self._attr_policy(policy)
169 cw.p(f"\t[{self.enum_name}] = {spec},")
171 def _mnl_type(self): argument
175 t = self.type
180 def _attr_typol(self): argument
181 raise Exception(f"Type policy not implemented for class type {self.type}")
183 def attr_typol(self, cw): argument
184 typol = self._attr_typol()
185 cw.p(f'[{self.enum_name}] = {"{"} .name = "{self.name}", {typol}{"}"},')
187 def _attr_put_line(self, ri, var, line): argument
188 if self.presence_type() == 'bit':
189 ri.cw.p(f"if ({var}->_present.{self.c_name})")
190 elif self.presence_type() == 'len':
191 ri.cw.p(f"if ({var}->_present.{self.c_name}_len)")
194 def _attr_put_simple(self, ri, var, put_type): argument
195 line = f"mnl_attr_put_{put_type}(nlh, {self.enum_name}, {var}->{self.c_name})"
196 self._attr_put_line(ri, var, line)
198 def attr_put(self, ri, var): argument
199 raise Exception(f"Put not implemented for class type {self.type}")
201 def _attr_get(self, ri, var): argument
202 raise Exception(f"Attr get not implemented for class type {self.type}")
204 def attr_get(self, ri, var, first): argument
205 lines, init_lines, local_vars = self._attr_get(ri, var)
212 ri.cw.block_start(line=f"{kw} (type == {self.enum_name})")
218 if not self.is_multi_val():
221 if self.presence_type() == 'bit':
222 ri.cw.p(f"{var}->_present.{self.c_name} = 1;")
234 def _setter_lines(self, ri, member, presence): argument
235 raise Exception(f"Setter not implemented for class type {self.type}")
237 def setter(self, ri, space, direction, deref=False, ref=None): argument
238 ref = (ref if ref else []) + [self.c_name]
246 if self.presence_type() == 'bit':
248 code += self._setter_lines(ri, member, presence)
256 … args=[f'{type_name(ri, direction, deref=deref)} *{var}'] + self.arg_member(ri))
260 def presence_type(self): argument
263 def arg_member(self, ri): argument
266 def _attr_get(self, ri, var): argument
269 def _attr_typol(self): argument
272 def attr_policy(self, cw): argument
275 def attr_put(self, ri, var): argument
278 def attr_get(self, ri, var, first): argument
281 def setter(self, ri, space, direction, deref=False, ref=None): argument
286 def presence_type(self): argument
289 def arg_member(self, ri): argument
292 def _attr_typol(self): argument
295 def attr_put(self, ri, var): argument
298 def attr_get(self, ri, var, first): argument
301 def attr_policy(self, cw): argument
304 def setter(self, ri, space, direction, deref=False, ref=None): argument
309 def __init__(self, family, attr_set, attr, value): argument
312 self.byte_order_comment = ''
314 self.byte_order_comment = f" /* {attr['byte-order']} */"
316 if 'enum' in self.attr:
317 enum = self.family.consts[self.attr['enum']]
319 if 'min' not in self.checks:
320 if low != 0 or self.type[0] == 's':
321 self.checks['min'] = low
322 if 'max' not in self.checks:
323 self.checks['max'] = high
325 if 'min' in self.checks and 'max' in self.checks:
326 if self.get_limit('min') > self.get_limit('max'):
327 …raise Exception(f'Invalid limit for "{self.name}" min: {self.get_limit("min")} max: {self.get_limi…
328 self.checks['range'] = True
330 low = min(self.get_limit('min', 0), self.get_limit('max', 0))
331 high = max(self.get_limit('min', 0), self.get_limit('max', 0))
332 if low < 0 and self.type[0] == 'u':
333 raise Exception(f'Invalid limit for "{self.name}" negative limit for unsigned type')
335 self.checks['full-range'] = True
338 self.is_bitfield = None
339 delattr(self, "is_bitfield")
340 self.type_name = None
341 delattr(self, "type_name")
343 def resolve(self): argument
344 self.resolve_up(super())
346 if 'enum-as-flags' in self.attr and self.attr['enum-as-flags']:
347 self.is_bitfield = True
348 elif 'enum' in self.attr:
349 self.is_bitfield = self.family.consts[self.attr['enum']]['type'] == 'flags'
351 self.is_bitfield = False
353 if not self.is_bitfield and 'enum' in self.attr:
354 self.type_name = self.family.consts[self.attr['enum']].user_type
355 elif self.is_auto_scalar:
356 self.type_name = '__' + self.type[0] + '64'
358 self.type_name = '__' + self.type
360 def mnl_type(self): argument
361 return self._mnl_type()
363 def _attr_policy(self, policy): argument
364 if 'flags-mask' in self.checks or self.is_bitfield:
365 if self.is_bitfield:
366 enum = self.family.consts[self.attr['enum']]
369 flags = self.family.consts[self.checks['flags-mask']]
373 elif 'full-range' in self.checks:
374 return f"NLA_POLICY_FULL_RANGE({policy}, &{c_lower(self.enum_name)}_range)"
375 elif 'range' in self.checks:
376 return f"NLA_POLICY_RANGE({policy}, {self.get_limit('min')}, {self.get_limit('max')})"
377 elif 'min' in self.checks:
378 return f"NLA_POLICY_MIN({policy}, {self.get_limit('min')})"
379 elif 'max' in self.checks:
380 return f"NLA_POLICY_MAX({policy}, {self.get_limit('max')})"
383 def _attr_typol(self): argument
384 return f'.type = YNL_PT_U{c_upper(self.type[1:])}, '
386 def arg_member(self, ri): argument
387 return [f'{self.type_name} {self.c_name}{self.byte_order_comment}']
389 def attr_put(self, ri, var): argument
390 self._attr_put_simple(ri, var, self.mnl_type())
392 def _attr_get(self, ri, var): argument
393 return f"{var}->{self.c_name} = mnl_attr_get_{self.mnl_type()}(attr);", None, None
395 def _setter_lines(self, ri, member, presence): argument
396 return [f"{member} = {self.c_name};"]
400 def arg_member(self, ri): argument
403 def _attr_typol(self): argument
406 def attr_put(self, ri, var): argument
407 self._attr_put_line(ri, var, f"mnl_attr_put(nlh, {self.enum_name}, 0, NULL)")
409 def _attr_get(self, ri, var): argument
412 def _setter_lines(self, ri, member, presence): argument
417 def arg_member(self, ri): argument
418 return [f"const char *{self.c_name}"]
420 def presence_type(self): argument
423 def struct_member(self, ri): argument
424 ri.cw.p(f"char *{self.c_name};")
426 def _attr_typol(self): argument
429 def _attr_policy(self, policy): argument
430 if 'exact-len' in self.checks:
431 mem = 'NLA_POLICY_EXACT_LEN(' + str(self.checks['exact-len']) + ')'
434 if 'max-len' in self.checks:
435 mem += ', .len = ' + str(self.get_limit('max-len'))
439 def attr_policy(self, cw): argument
440 if self.checks.get('unterminated-ok', False):
445 spec = self._attr_policy(policy)
446 cw.p(f"\t[{self.enum_name}] = {spec},")
448 def attr_put(self, ri, var): argument
449 self._attr_put_simple(ri, var, 'strz')
451 def _attr_get(self, ri, var): argument
452 len_mem = var + '->_present.' + self.c_name + '_len'
454 f"{var}->{self.c_name} = malloc(len + 1);",
455 f"memcpy({var}->{self.c_name}, mnl_attr_get_str(attr), len);",
456 f"{var}->{self.c_name}[len] = 0;"], \
460 def _setter_lines(self, ri, member, presence): argument
462 f"{presence}_len = strlen({self.c_name});",
464 f'memcpy({member}, {self.c_name}, {presence}_len);',
469 def arg_member(self, ri): argument
470 return [f"const void *{self.c_name}", 'size_t len']
472 def presence_type(self): argument
475 def struct_member(self, ri): argument
476 ri.cw.p(f"void *{self.c_name};")
478 def _attr_typol(self): argument
481 def _attr_policy(self, policy): argument
482 if 'exact-len' in self.checks:
483 mem = 'NLA_POLICY_EXACT_LEN(' + str(self.checks['exact-len']) + ')'
486 if len(self.checks) == 1 and 'min-len' in self.checks:
487 mem += '.len = ' + str(self.get_limit('min-len'))
488 elif len(self.checks) == 0:
495 def attr_put(self, ri, var): argument
496 self._attr_put_line(ri, var, f"mnl_attr_put(nlh, {self.enum_name}, " +
497 f"{var}->_present.{self.c_name}_len, {var}->{self.c_name})")
499 def _attr_get(self, ri, var): argument
500 len_mem = var + '->_present.' + self.c_name + '_len'
502 f"{var}->{self.c_name} = malloc(len);",
503 f"memcpy({var}->{self.c_name}, mnl_attr_get_payload(attr), len);"], \
507 def _setter_lines(self, ri, member, presence): argument
511 f'memcpy({member}, {self.c_name}, {presence}_len);']
515 def _complex_member_type(self, ri): argument
518 def _attr_typol(self): argument
521 def _attr_policy(self, policy): argument
522 if not 'enum' in self.attr:
524 enum = self.family.consts[self.attr['enum']]
528 def attr_put(self, ri, var): argument
529 …line = f"mnl_attr_put(nlh, {self.enum_name}, sizeof(struct nla_bitfield32), &{var}->{self.c_name})"
530 self._attr_put_line(ri, var, line)
532 def _attr_get(self, ri, var): argument
533 …return f"memcpy(&{var}->{self.c_name}, mnl_attr_get_payload(attr), sizeof(struct nla_bitfield32));…
535 def _setter_lines(self, ri, member, presence): argument
536 return [f"memcpy(&{member}, {self.c_name}, sizeof(struct nla_bitfield32));"]
540 def is_recursive(self): argument
541 return self.family.pure_nested_structs[self.nested_attrs].recursive
543 def _complex_member_type(self, ri): argument
544 return self.nested_struct_type
546 def free(self, ri, var, ref): argument
548 if self.is_recursive_for_op(ri):
550 ri.cw.p(f'if ({var}->{ref}{self.c_name})')
551 ri.cw.p(f'{self.nested_render_name}_free({at}{var}->{ref}{self.c_name});')
553 def _attr_typol(self): argument
554 return f'.type = YNL_PT_NEST, .nest = &{self.nested_render_name}_nest, '
556 def _attr_policy(self, policy): argument
557 return 'NLA_POLICY_NESTED(' + self.nested_render_name + '_nl_policy)'
559 def attr_put(self, ri, var): argument
560 at = '' if self.is_recursive_for_op(ri) else '&'
561 self._attr_put_line(ri, var, f"{self.nested_render_name}_put(nlh, " +
562 f"{self.enum_name}, {at}{var}->{self.c_name})")
564 def _attr_get(self, ri, var): argument
565 get_lines = [f"if ({self.nested_render_name}_parse(&parg, attr))",
567 init_lines = [f"parg.rsp_policy = &{self.nested_render_name}_nest;",
568 f"parg.data = &{var}->{self.c_name};"]
571 def setter(self, ri, space, direction, deref=False, ref=None): argument
572 ref = (ref if ref else []) + [self.c_name]
574 for _, attr in ri.family.pure_nested_structs[self.nested_attrs].member_list():
577 attr.setter(ri, self.nested_attrs, direction, deref=deref, ref=ref)
581 def __init__(self, family, attr_set, attr, value, base_type): argument
584 self.base_type = base_type
586 def is_multi_val(self): argument
589 def presence_type(self): argument
592 def mnl_type(self): argument
593 return self._mnl_type()
595 def _complex_member_type(self, ri): argument
596 if 'type' not in self.attr or self.attr['type'] == 'nest':
597 return self.nested_struct_type
598 elif self.attr['type'] in scalars:
600 return scalar_pfx + self.attr['type']
602 raise Exception(f"Sub-type {self.attr['type']} not supported yet")
604 def free_needs_iter(self): argument
605 return 'type' not in self.attr or self.attr['type'] == 'nest'
607 def free(self, ri, var, ref): argument
608 if self.attr['type'] in scalars:
609 ri.cw.p(f"free({var}->{ref}{self.c_name});")
610 elif 'type' not in self.attr or self.attr['type'] == 'nest':
611 ri.cw.p(f"for (i = 0; i < {var}->{ref}n_{self.c_name}; i++)")
612 ri.cw.p(f'{self.nested_render_name}_free(&{var}->{ref}{self.c_name}[i]);')
613 ri.cw.p(f"free({var}->{ref}{self.c_name});")
615 raise Exception(f"Free of MultiAttr sub-type {self.attr['type']} not supported yet")
617 def _attr_policy(self, policy): argument
618 return self.base_type._attr_policy(policy)
620 def _attr_typol(self): argument
621 return self.base_type._attr_typol()
623 def _attr_get(self, ri, var): argument
624 return f'n_{self.c_name}++;', None, None
626 def attr_put(self, ri, var): argument
627 if self.attr['type'] in scalars:
628 put_type = self.mnl_type()
629 ri.cw.p(f"for (unsigned int i = 0; i < {var}->n_{self.c_name}; i++)")
630 ri.cw.p(f"mnl_attr_put_{put_type}(nlh, {self.enum_name}, {var}->{self.c_name}[i]);")
631 elif 'type' not in self.attr or self.attr['type'] == 'nest':
632 ri.cw.p(f"for (unsigned int i = 0; i < {var}->n_{self.c_name}; i++)")
633 self._attr_put_line(ri, var, f"{self.nested_render_name}_put(nlh, " +
634 f"{self.enum_name}, &{var}->{self.c_name}[i])")
636 raise Exception(f"Put of MultiAttr sub-type {self.attr['type']} not supported yet")
638 def _setter_lines(self, ri, member, presence): argument
640 presence = presence[:-(len('_present.') + len(self.c_name))] + "n_" + self.c_name
642 f"{member} = {self.c_name};",
643 f"{presence} = n_{self.c_name};"]
647 def is_multi_val(self): argument
650 def presence_type(self): argument
653 def _complex_member_type(self, ri): argument
654 if 'sub-type' not in self.attr or self.attr['sub-type'] == 'nest':
655 return self.nested_struct_type
656 elif self.attr['sub-type'] in scalars:
658 return scalar_pfx + self.attr['sub-type']
660 raise Exception(f"Sub-type {self.attr['sub-type']} not supported yet")
662 def _attr_typol(self): argument
663 return f'.type = YNL_PT_NEST, .nest = &{self.nested_render_name}_nest, '
665 def _attr_get(self, ri, var): argument
667 get_lines = [f'attr_{self.c_name} = attr;',
669 f'\t{var}->n_{self.c_name}++;']
674 def _complex_member_type(self, ri): argument
675 return self.nested_struct_type
677 def _attr_typol(self): argument
678 return f'.type = YNL_PT_NEST, .nest = &{self.nested_render_name}_nest, '
680 def _attr_get(self, ri, var): argument
685 init_lines = [f"parg.rsp_policy = &{self.nested_render_name}_nest;",
686 f"parg.data = &{var}->{self.c_name};"]
687 if 'type-value' in self.attr:
688 tv_names = [c_lower(x) for x in self.attr["type-value"]]
691 for level in self.attr["type-value"]:
699 get_lines += [f"{self.nested_render_name}_parse(&parg, {prev}{tv_args});"]
704 def __init__(self, family, space_name, type_list=None, inherited=None): argument
705 self.family = family
706 self.space_name = space_name
707 self.attr_set = family.attr_sets[space_name]
709 self._inherited = inherited if inherited is not None else []
710 self.inherited = []
712 self.nested = type_list is None
714 self.render_name = c_lower(family.name)
716 self.render_name = c_lower(family.name + '-' + space_name)
717 self.struct_name = 'struct ' + self.render_name
718 if self.nested and space_name in family.consts:
719 self.struct_name += '_'
720 self.ptr_name = self.struct_name + ' *'
722 self.child_nests = set()
724 self.request = False
725 self.reply = False
726 self.recursive = False
728 self.attr_list = []
729 self.attrs = dict()
732 self.attr_list.append((t, self.attr_set[t]),)
734 for t in self.attr_set:
735 self.attr_list.append((t, self.attr_set[t]),)
738 self.attr_max_val = None
739 for name, attr in self.attr_list:
742 self.attr_max_val = attr
743 self.attrs[name] = attr
745 def __iter__(self): argument
746 yield from self.attrs
748 def __getitem__(self, key): argument
749 return self.attrs[key]
751 def member_list(self): argument
752 return self.attr_list
754 def set_inherited(self, new_inherited): argument
755 if self._inherited != new_inherited:
757 self.inherited = [c_lower(x) for x in sorted(self._inherited)]
761 def __init__(self, enum_set, yaml, prev, value_start): argument
765 self.value_change = (self.value != prev.value + 1)
767 self.value_change = (self.value != 0)
768 self.value_change = self.value_change or self.enum_set['type'] == 'flags'
771 self.c_name = None
772 delattr(self, "c_name")
774 def resolve(self): argument
775 self.resolve_up(super())
777 self.c_name = c_upper(self.enum_set.value_pfx + self.name)
781 def __init__(self, family, yaml): argument
782 self.render_name = c_lower(family.name + '-' + yaml['name'])
786 self.enum_name = 'enum ' + c_lower(yaml['enum-name'])
787 self.user_type = self.enum_name
789 self.enum_name = None
791 self.enum_name = 'enum ' + self.render_name
793 if self.enum_name:
794 self.user_type = self.enum_name
796 self.user_type = 'int'
798 self.value_pfx = yaml.get('name-prefix', f"{family.name}-{yaml['name']}-")
802 def new_entry(self, entry, prev_entry, value_start): argument
803 return EnumEntry(self, entry, prev_entry, value_start)
805 def value_range(self): argument
806 low = min([x.value for x in self.entries.values()])
807 high = max([x.value for x in self.entries.values()])
809 if high - low + 1 != len(self.entries):
816 def __init__(self, family, yaml): argument
819 if self.subset_of is None:
822 elif self.name == family.name:
825 pfx = f"{family.name}-a-{self.name}-"
826 self.name_prefix = c_upper(pfx)
827 self.max_name = c_upper(self.yaml.get('attr-max-name', f"{self.name_prefix}max"))
828 self.cnt_name = c_upper(self.yaml.get('attr-cnt-name', f"__{self.name_prefix}max"))
830 self.name_prefix = family.attr_sets[self.subset_of].name_prefix
831 self.max_name = family.attr_sets[self.subset_of].max_name
832 self.cnt_name = family.attr_sets[self.subset_of].cnt_name
835 self.c_name = None
836 delattr(self, "c_name")
838 def resolve(self): argument
839 self.c_name = c_lower(self.name)
840 if self.c_name in _C_KW:
841 self.c_name += '_'
842 if self.c_name == self.family.c_name:
843 self.c_name = ''
845 def new_attr(self, elem, value): argument
847 t = TypeScalar(self.family, self, elem, value)
849 t = TypeUnused(self.family, self, elem, value)
851 t = TypePad(self.family, self, elem, value)
853 t = TypeFlag(self.family, self, elem, value)
855 t = TypeString(self.family, self, elem, value)
857 t = TypeBinary(self.family, self, elem, value)
859 t = TypeBitfield32(self.family, self, elem, value)
861 t = TypeNest(self.family, self, elem, value)
863 t = TypeArrayNest(self.family, self, elem, value)
865 t = TypeNestTypeValue(self.family, self, elem, value)
870 t = TypeMultiAttr(self.family, self, elem, value, t)
876 def __init__(self, family, yaml, req_value, rsp_value): argument
879 self.render_name = c_lower(family.name + '_' + self.name)
881 self.dual_policy = ('do' in yaml and 'request' in yaml['do']) and \
884 self.has_ntf = False
887 self.enum_name = None
888 delattr(self, "enum_name")
890 def resolve(self): argument
891 self.resolve_up(super())
893 if not self.is_async:
894 self.enum_name = self.family.op_prefix + c_upper(self.name)
896 self.enum_name = self.family.async_op_prefix + c_upper(self.name)
898 def mark_has_ntf(self): argument
899 self.has_ntf = True
903 def __init__(self, file_name, exclude_ops): argument
905 self.c_name = None
906 delattr(self, "c_name")
907 self.op_prefix = None
908 delattr(self, "op_prefix")
909 self.async_op_prefix = None
910 delattr(self, "async_op_prefix")
911 self.mcgrps = None
912 delattr(self, "mcgrps")
913 self.consts = None
914 delattr(self, "consts")
915 self.hooks = None
916 delattr(self, "hooks")
920 self.fam_key = c_upper(self.yaml.get('c-family-name', self.yaml["name"] + '_FAMILY_NAME'))
921 … self.ver_key = c_upper(self.yaml.get('c-version-name', self.yaml["name"] + '_FAMILY_VERSION'))
923 if 'definitions' not in self.yaml:
924 self.yaml['definitions'] = []
926 if 'uapi-header' in self.yaml:
927 self.uapi_header = self.yaml['uapi-header']
929 self.uapi_header = f"linux/{self.name}.h"
930 if self.uapi_header.startswith("linux/") and self.uapi_header.endswith('.h'):
931 self.uapi_header_name = self.uapi_header[6:-2]
933 self.uapi_header_name = self.name
935 def resolve(self): argument
936 self.resolve_up(super())
938 … if self.yaml.get('protocol', 'genetlink') not in {'genetlink', 'genetlink-c', 'genetlink-legacy'}:
941 self.c_name = c_lower(self.name)
942 if 'name-prefix' in self.yaml['operations']:
943 self.op_prefix = c_upper(self.yaml['operations']['name-prefix'])
945 self.op_prefix = c_upper(self.yaml['name'] + '-cmd-')
946 if 'async-prefix' in self.yaml['operations']:
947 self.async_op_prefix = c_upper(self.yaml['operations']['async-prefix'])
949 self.async_op_prefix = self.op_prefix
951 self.mcgrps = self.yaml.get('mcast-groups', {'list': []})
953 self.hooks = dict()
955 self.hooks[when] = dict()
957 self.hooks[when][op_mode] = dict()
958 self.hooks[when][op_mode]['set'] = set()
959 self.hooks[when][op_mode]['list'] = []
962 self.root_sets = dict()
964 self.pure_nested_structs = dict()
966 self._mark_notify()
967 self._mock_up_events()
969 self._load_root_sets()
970 self._load_nested_sets()
971 self._load_attr_use()
972 self._load_hooks()
974 self.kernel_policy = self.yaml.get('kernel-policy', 'split')
975 if self.kernel_policy == 'global':
976 self._load_global_policy()
978 def new_enum(self, elem): argument
979 return EnumSet(self, elem)
981 def new_attr_set(self, elem): argument
982 return AttrSet(self, elem)
984 def new_operation(self, elem, req_value, rsp_value): argument
985 return Operation(self, elem, req_value, rsp_value)
987 def _mark_notify(self): argument
988 for op in self.msgs.values():
990 self.ops[op['notify']].mark_has_ntf()
993 def _mock_up_events(self): argument
994 for op in self.yaml['operations']['list']:
1002 def _load_root_sets(self): argument
1003 for op_name, op in self.msgs.items():
1017 if op['attribute-set'] not in self.root_sets:
1018 self.root_sets[op['attribute-set']] = {'request': req_attrs, 'reply': rsp_attrs}
1020 self.root_sets[op['attribute-set']]['request'].update(req_attrs)
1021 self.root_sets[op['attribute-set']]['reply'].update(rsp_attrs)
1023 def _sort_pure_types(self): argument
1025 pns_key_list = list(self.pure_nested_structs.keys())
1033 for _, spec in self.attr_sets[name].items():
1037 if self.pure_nested_structs[nested].recursive:
1041 struct = self.pure_nested_structs.pop(name)
1042 self.pure_nested_structs[name] = struct
1050 def _load_nested_sets(self): argument
1051 attr_set_queue = list(self.root_sets.keys())
1052 attr_set_seen = set(self.root_sets.keys())
1056 for attr, spec in self.attr_sets[a_set].items():
1066 if nested not in self.root_sets:
1067 if nested not in self.pure_nested_structs:
1068 self.pure_nested_structs[nested] = Struct(self, nested, inherited=inherit)
1073 if nested in self.root_sets:
1078 self.pure_nested_structs[nested].set_inherited(inherit)
1080 for root_set, rs_members in self.root_sets.items():
1081 for attr, spec in self.attr_sets[root_set].items():
1085 self.pure_nested_structs[nested].request = True
1087 self.pure_nested_structs[nested].reply = True
1089 self._sort_pure_types()
1092 for attr_set, struct in reversed(self.pure_nested_structs.items()):
1093 for _, spec in self.attr_sets[attr_set].items():
1097 child = self.pure_nested_structs.get(child_name)
1106 self._sort_pure_types()
1108 def _load_attr_use(self): argument
1109 for _, struct in self.pure_nested_structs.items():
1117 for root_set, rs_members in self.root_sets.items():
1118 for attr, spec in self.attr_sets[root_set].items():
1124 def _load_global_policy(self): argument
1127 for op_name, op in self.ops.items():
1144 self.global_policy = []
1145 self.global_policy_set = attr_set_name
1146 for attr in self.attr_sets[attr_set_name]:
1148 self.global_policy.append(attr)
1150 def _load_hooks(self): argument
1151 for op in self.ops.values():
1159 if name in self.hooks[when][op_mode]['set']:
1161 self.hooks[when][op_mode]['set'].add(name)
1162 self.hooks[when][op_mode]['list'].append(name)
1166 def __init__(self, cw, family, ku_space, op, op_mode, attr_set=None): argument
1167 self.family = family
1168 self.nl = cw.nlib
1169 self.ku_space = ku_space
1170 self.op_mode = op_mode
1171 self.op = op
1173 self.fixed_hdr = None
1175 self.fixed_hdr = 'struct ' + c_lower(op.fixed_header)
1178 self.type_consistent = True
1182 self.type_consistent = False
1184 self.type_consistent = False
1186 self.type_consistent = False
1188 self.attr_set = attr_set
1189 if not self.attr_set:
1190 self.attr_set = op['attribute-set']
1192 self.type_name_conflict = False
1194 self.type_name = c_lower(op.name)
1196 self.type_name = c_lower(attr_set)
1198 self.type_name_conflict = True
1200 self.cw = cw
1202 self.struct = dict()
1210 self.struct[op_dir] = Struct(family, self.attr_set, type_list=type_list)
1212 … self.struct['reply'] = Struct(family, self.attr_set, type_list=op['event']['attributes'])
1216 def __init__(self, nlib, out_file=None, overwrite=True): argument
1217 self.nlib = nlib
1218 self._overwrite = overwrite
1220 self._nl = False
1221 self._block_end = False
1222 self._silent_block = False
1223 self._ind = 0
1224 self._ifdef_block = None
1226 self._out = os.sys.stdout
1228 self._out = tempfile.NamedTemporaryFile('w+')
1229 self._out_file = out_file
1231 def __del__(self): argument
1232 self.close_out_file()
1234 def close_out_file(self): argument
1235 if self._out == os.sys.stdout:
1238 self._out.flush()
1239 if not self._overwrite and os.path.isfile(self._out_file):
1240 if filecmp.cmp(self._out.name, self._out_file, shallow=False):
1242 with open(self._out_file, 'w+') as out_file:
1243 self._out.seek(0)
1244 shutil.copyfileobj(self._out, out_file)
1245 self._out.close()
1246 self._out = os.sys.stdout
1252 def p(self, line, add_ind=0): argument
1253 if self._block_end:
1254 self._block_end = False
1258 self._out.write('\t' * self._ind + '}\n')
1260 if self._nl:
1261 self._out.write('\n')
1262 self._nl = False
1264 ind = self._ind
1267 if self._silent_block:
1269 self._silent_block = line.endswith(')') and CodeWriter._is_cond(line)
1274 self._out.write('\t' * ind + line + '\n')
1276 def nl(self): argument
1277 self._nl = True
1279 def block_start(self, line=''): argument
1282 self.p(line + '{')
1283 self._ind += 1
1285 def block_end(self, line=''): argument
1288 self._ind -= 1
1289 self._nl = False
1292 if self._block_end:
1293 self._out.write('\t' * (self._ind + 1) + '}\n')
1294 self._block_end = True
1296 self.p('}' + line)
1298 def write_doc_line(self, doc, indent=True): argument
1303 self.p(line)
1308 self.p(line)
1310 def write_func_prot(self, qual_ret, name, args=None, doc=None, suffix=''): argument
1315 self.p('/*')
1316 self.p(' * ' + doc)
1317 self.p(' */')
1325 self.p(oneline)
1330 self.p(v)
1344 self.p(v + ',')
1350 self.p(v + ')' + suffix)
1352 def write_func_lvar(self, local_vars): argument
1361 self.p(var)
1362 self.nl()
1364 def write_func(self, qual_ret, name, body, args=None, local_vars=None): argument
1365 self.write_func_prot(qual_ret=qual_ret, name=name, args=args)
1366 self.write_func_lvar(local_vars=local_vars)
1368 self.block_start()
1370 self.p(line)
1371 self.block_end()
1373 def writes_defines(self, defines): argument
1386 self.p(line)
1388 def write_struct_init(self, members): argument
1396 self.p(line)
1398 def ifdef_block(self, config): argument
1402 if self._ifdef_block == config_option:
1405 if self._ifdef_block:
1406 self.p('#endif /* ' + self._ifdef_block + ' */')
1408 self.p('#ifdef ' + config_option)
1409 self._ifdef_block = config_option