Lines Matching full:self
40 def get_family_id(self): argument
45 def __init__(self, family, attr_set, attr, value): argument
48 self.attr = attr
49 self.attr_set = attr_set
50 self.type = attr['type']
51 self.checks = attr.get('checks', {})
53 self.request = False
54 self.reply = False
57 self.len = attr['len']
60 self.nested_attrs = attr['nested-attributes']
61 if self.nested_attrs == family.name:
62 self.nested_render_name = c_lower(f"{family.ident_name}")
64 self.nested_render_name = c_lower(f"{family.ident_name}_{self.nested_attrs}")
66 if self.nested_attrs in self.family.consts:
67 self.nested_struct_type = 'struct ' + self.nested_render_name + '_'
69 self.nested_struct_type = 'struct ' + self.nested_render_name
71 self.c_name = c_lower(self.name)
72 if self.c_name in _C_KW:
73 self.c_name += '_'
76 self.enum_name = None
77 delattr(self, "enum_name")
79 def get_limit(self, limit, default=None): argument
80 value = self.checks.get(limit, default)
83 elif value in self.family.consts:
84 return c_upper(f"{self.family['name']}-{value}")
89 def resolve(self): argument
90 if 'name-prefix' in self.attr:
91 enum_name = f"{self.attr['name-prefix']}{self.name}"
93 enum_name = f"{self.attr_set.name_prefix}{self.name}"
94 self.enum_name = c_upper(enum_name)
96 def is_multi_val(self): argument
99 def is_scalar(self): argument
100 return self.type in {'u8', 'u16', 'u32', 'u64', 's32', 's64'}
102 def is_recursive(self): argument
105 def is_recursive_for_op(self, ri): argument
106 return self.is_recursive() and not ri.op
108 def presence_type(self): argument
111 def presence_member(self, space, type_filter): argument
112 if self.presence_type() != type_filter:
115 if self.presence_type() == 'bit':
117 return f"{pfx}u32 {self.c_name}:1;"
119 if self.presence_type() == 'len':
121 return f"{pfx}u32 {self.c_name}_len;"
123 def _complex_member_type(self, ri): argument
126 def free_needs_iter(self): argument
129 def free(self, ri, var, ref): argument
130 if self.is_multi_val() or self.presence_type() == 'len':
131 ri.cw.p(f'free({var}->{ref}{self.c_name});')
133 def arg_member(self, ri): argument
134 member = self._complex_member_type(ri)
136 arg = [member + ' *' + self.c_name]
137 if self.presence_type() == 'count':
138 arg += ['unsigned int n_' + self.c_name]
140 raise Exception(f"Struct member not implemented for class type {self.type}")
142 def struct_member(self, ri): argument
143 if self.is_multi_val():
144 ri.cw.p(f"unsigned int n_{self.c_name};")
145 member = self._complex_member_type(ri)
147 ptr = '*' if self.is_multi_val() else ''
148 if self.is_recursive_for_op(ri):
150 ri.cw.p(f"{member} {ptr}{self.c_name};")
152 members = self.arg_member(ri)
156 def _attr_policy(self, policy): argument
159 def attr_policy(self, cw): argument
160 policy = c_upper('nla-' + self.attr['type'])
162 spec = self._attr_policy(policy)
163 cw.p(f"\t[{self.enum_name}] = {spec},")
165 def _attr_typol(self): argument
166 raise Exception(f"Type policy not implemented for class type {self.type}")
168 def attr_typol(self, cw): argument
169 typol = self._attr_typol()
170 cw.p(f'[{self.enum_name}] = {"{"} .name = "{self.name}", {typol}{"}"},')
172 def _attr_put_line(self, ri, var, line): argument
173 if self.presence_type() == 'bit':
174 ri.cw.p(f"if ({var}->_present.{self.c_name})")
175 elif self.presence_type() == 'len':
176 ri.cw.p(f"if ({var}->_present.{self.c_name}_len)")
179 def _attr_put_simple(self, ri, var, put_type): argument
180 line = f"ynl_attr_put_{put_type}(nlh, {self.enum_name}, {var}->{self.c_name})"
181 self._attr_put_line(ri, var, line)
183 def attr_put(self, ri, var): argument
184 raise Exception(f"Put not implemented for class type {self.type}")
186 def _attr_get(self, ri, var): argument
187 raise Exception(f"Attr get not implemented for class type {self.type}")
189 def attr_get(self, ri, var, first): argument
190 lines, init_lines, local_vars = self._attr_get(ri, var)
197 ri.cw.block_start(line=f"{kw} (type == {self.enum_name})")
203 if not self.is_multi_val():
206 if self.presence_type() == 'bit':
207 ri.cw.p(f"{var}->_present.{self.c_name} = 1;")
219 def _setter_lines(self, ri, member, presence): argument
220 raise Exception(f"Setter not implemented for class type {self.type}")
222 def setter(self, ri, space, direction, deref=False, ref=None): argument
223 ref = (ref if ref else []) + [self.c_name]
232 # last layer is "self" and may be a complex type
233 if i == len(ref) - 1 and self.presence_type() != 'bit':
236 code += self._setter_lines(ri, member, presence)
244 … args=[f'{type_name(ri, direction, deref=deref)} *{var}'] + self.arg_member(ri))
248 def presence_type(self): argument
251 def arg_member(self, ri): argument
254 def _attr_get(self, ri, var): argument
257 def _attr_typol(self): argument
260 def attr_policy(self, cw): argument
263 def attr_put(self, ri, var): argument
266 def attr_get(self, ri, var, first): argument
269 def setter(self, ri, space, direction, deref=False, ref=None): argument
274 def presence_type(self): argument
277 def arg_member(self, ri): argument
280 def _attr_typol(self): argument
283 def attr_put(self, ri, var): argument
286 def attr_get(self, ri, var, first): argument
289 def attr_policy(self, cw): argument
292 def setter(self, ri, space, direction, deref=False, ref=None): argument
297 def __init__(self, family, attr_set, attr, value): argument
300 self.byte_order_comment = ''
302 self.byte_order_comment = f" /* {attr['byte-order']} */"
304 if 'enum' in self.attr:
305 enum = self.family.consts[self.attr['enum']]
307 if 'min' not in self.checks:
308 if low != 0 or self.type[0] == 's':
309 self.checks['min'] = low
310 if 'max' not in self.checks:
311 self.checks['max'] = high
313 if 'min' in self.checks and 'max' in self.checks:
314 if self.get_limit('min') > self.get_limit('max'):
315 …raise Exception(f'Invalid limit for "{self.name}" min: {self.get_limit("min")} max: {self.get_limi…
316 self.checks['range'] = True
318 low = min(self.get_limit('min', 0), self.get_limit('max', 0))
319 high = max(self.get_limit('min', 0), self.get_limit('max', 0))
320 if low < 0 and self.type[0] == 'u':
321 raise Exception(f'Invalid limit for "{self.name}" negative limit for unsigned type')
323 self.checks['full-range'] = True
326 self.is_bitfield = None
327 delattr(self, "is_bitfield")
328 self.type_name = None
329 delattr(self, "type_name")
331 def resolve(self): argument
332 self.resolve_up(super())
334 if 'enum-as-flags' in self.attr and self.attr['enum-as-flags']:
335 self.is_bitfield = True
336 elif 'enum' in self.attr:
337 self.is_bitfield = self.family.consts[self.attr['enum']]['type'] == 'flags'
339 self.is_bitfield = False
341 if not self.is_bitfield and 'enum' in self.attr:
342 self.type_name = self.family.consts[self.attr['enum']].user_type
343 elif self.is_auto_scalar:
344 self.type_name = '__' + self.type[0] + '64'
346 self.type_name = '__' + self.type
348 def _attr_policy(self, policy): argument
349 if 'flags-mask' in self.checks or self.is_bitfield:
350 if self.is_bitfield:
351 enum = self.family.consts[self.attr['enum']]
354 flags = self.family.consts[self.checks['flags-mask']]
358 elif 'full-range' in self.checks:
359 return f"NLA_POLICY_FULL_RANGE({policy}, &{c_lower(self.enum_name)}_range)"
360 elif 'range' in self.checks:
361 return f"NLA_POLICY_RANGE({policy}, {self.get_limit('min')}, {self.get_limit('max')})"
362 elif 'min' in self.checks:
363 return f"NLA_POLICY_MIN({policy}, {self.get_limit('min')})"
364 elif 'max' in self.checks:
365 return f"NLA_POLICY_MAX({policy}, {self.get_limit('max')})"
368 def _attr_typol(self): argument
369 return f'.type = YNL_PT_U{c_upper(self.type[1:])}, '
371 def arg_member(self, ri): argument
372 return [f'{self.type_name} {self.c_name}{self.byte_order_comment}']
374 def attr_put(self, ri, var): argument
375 self._attr_put_simple(ri, var, self.type)
377 def _attr_get(self, ri, var): argument
378 return f"{var}->{self.c_name} = ynl_attr_get_{self.type}(attr);", None, None
380 def _setter_lines(self, ri, member, presence): argument
381 return [f"{member} = {self.c_name};"]
385 def arg_member(self, ri): argument
388 def _attr_typol(self): argument
391 def attr_put(self, ri, var): argument
392 self._attr_put_line(ri, var, f"ynl_attr_put(nlh, {self.enum_name}, NULL, 0)")
394 def _attr_get(self, ri, var): argument
397 def _setter_lines(self, ri, member, presence): argument
402 def arg_member(self, ri): argument
403 return [f"const char *{self.c_name}"]
405 def presence_type(self): argument
408 def struct_member(self, ri): argument
409 ri.cw.p(f"char *{self.c_name};")
411 def _attr_typol(self): argument
414 def _attr_policy(self, policy): argument
415 if 'exact-len' in self.checks:
416 mem = 'NLA_POLICY_EXACT_LEN(' + str(self.get_limit('exact-len')) + ')'
419 if 'max-len' in self.checks:
420 mem += ', .len = ' + str(self.get_limit('max-len'))
424 def attr_policy(self, cw): argument
425 if self.checks.get('unterminated-ok', False):
430 spec = self._attr_policy(policy)
431 cw.p(f"\t[{self.enum_name}] = {spec},")
433 def attr_put(self, ri, var): argument
434 self._attr_put_simple(ri, var, 'str')
436 def _attr_get(self, ri, var): argument
437 len_mem = var + '->_present.' + self.c_name + '_len'
439 f"{var}->{self.c_name} = malloc(len + 1);",
440 f"memcpy({var}->{self.c_name}, ynl_attr_get_str(attr), len);",
441 f"{var}->{self.c_name}[len] = 0;"], \
445 def _setter_lines(self, ri, member, presence): argument
447 f"{presence}_len = strlen({self.c_name});",
449 f'memcpy({member}, {self.c_name}, {presence}_len);',
454 def arg_member(self, ri): argument
455 return [f"const void *{self.c_name}", 'size_t len']
457 def presence_type(self): argument
460 def struct_member(self, ri): argument
461 ri.cw.p(f"void *{self.c_name};")
463 def _attr_typol(self): argument
466 def _attr_policy(self, policy): argument
467 if 'exact-len' in self.checks:
468 mem = 'NLA_POLICY_EXACT_LEN(' + str(self.get_limit('exact-len')) + ')'
471 if len(self.checks) == 1 and 'min-len' in self.checks:
472 mem += '.len = ' + str(self.get_limit('min-len'))
473 elif len(self.checks) == 0:
480 def attr_put(self, ri, var): argument
481 self._attr_put_line(ri, var, f"ynl_attr_put(nlh, {self.enum_name}, " +
482 f"{var}->{self.c_name}, {var}->_present.{self.c_name}_len)")
484 def _attr_get(self, ri, var): argument
485 len_mem = var + '->_present.' + self.c_name + '_len'
487 f"{var}->{self.c_name} = malloc(len);",
488 f"memcpy({var}->{self.c_name}, ynl_attr_data(attr), len);"], \
492 def _setter_lines(self, ri, member, presence): argument
496 f'memcpy({member}, {self.c_name}, {presence}_len);']
500 def _complex_member_type(self, ri): argument
503 def _attr_typol(self): argument
506 def _attr_policy(self, policy): argument
507 if not 'enum' in self.attr:
509 enum = self.family.consts[self.attr['enum']]
513 def attr_put(self, ri, var): argument
514 …line = f"ynl_attr_put(nlh, {self.enum_name}, &{var}->{self.c_name}, sizeof(struct nla_bitfield32))"
515 self._attr_put_line(ri, var, line)
517 def _attr_get(self, ri, var): argument
518 …return f"memcpy(&{var}->{self.c_name}, ynl_attr_data(attr), sizeof(struct nla_bitfield32));", None…
520 def _setter_lines(self, ri, member, presence): argument
521 return [f"memcpy(&{member}, {self.c_name}, sizeof(struct nla_bitfield32));"]
525 def is_recursive(self): argument
526 return self.family.pure_nested_structs[self.nested_attrs].recursive
528 def _complex_member_type(self, ri): argument
529 return self.nested_struct_type
531 def free(self, ri, var, ref): argument
533 if self.is_recursive_for_op(ri):
535 ri.cw.p(f'if ({var}->{ref}{self.c_name})')
536 ri.cw.p(f'{self.nested_render_name}_free({at}{var}->{ref}{self.c_name});')
538 def _attr_typol(self): argument
539 return f'.type = YNL_PT_NEST, .nest = &{self.nested_render_name}_nest, '
541 def _attr_policy(self, policy): argument
542 return 'NLA_POLICY_NESTED(' + self.nested_render_name + '_nl_policy)'
544 def attr_put(self, ri, var): argument
545 at = '' if self.is_recursive_for_op(ri) else '&'
546 self._attr_put_line(ri, var, f"{self.nested_render_name}_put(nlh, " +
547 f"{self.enum_name}, {at}{var}->{self.c_name})")
549 def _attr_get(self, ri, var): argument
550 get_lines = [f"if ({self.nested_render_name}_parse(&parg, attr))",
552 init_lines = [f"parg.rsp_policy = &{self.nested_render_name}_nest;",
553 f"parg.data = &{var}->{self.c_name};"]
556 def setter(self, ri, space, direction, deref=False, ref=None): argument
557 ref = (ref if ref else []) + [self.c_name]
559 for _, attr in ri.family.pure_nested_structs[self.nested_attrs].member_list():
562 attr.setter(ri, self.nested_attrs, direction, deref=deref, ref=ref)
566 def __init__(self, family, attr_set, attr, value, base_type): argument
569 self.base_type = base_type
571 def is_multi_val(self): argument
574 def presence_type(self): argument
577 def _complex_member_type(self, ri): argument
578 if 'type' not in self.attr or self.attr['type'] == 'nest':
579 return self.nested_struct_type
580 elif self.attr['type'] in scalars:
582 return scalar_pfx + self.attr['type']
584 raise Exception(f"Sub-type {self.attr['type']} not supported yet")
586 def free_needs_iter(self): argument
587 return 'type' not in self.attr or self.attr['type'] == 'nest'
589 def free(self, ri, var, ref): argument
590 if self.attr['type'] in scalars:
591 ri.cw.p(f"free({var}->{ref}{self.c_name});")
592 elif 'type' not in self.attr or self.attr['type'] == 'nest':
593 ri.cw.p(f"for (i = 0; i < {var}->{ref}n_{self.c_name}; i++)")
594 ri.cw.p(f'{self.nested_render_name}_free(&{var}->{ref}{self.c_name}[i]);')
595 ri.cw.p(f"free({var}->{ref}{self.c_name});")
597 raise Exception(f"Free of MultiAttr sub-type {self.attr['type']} not supported yet")
599 def _attr_policy(self, policy): argument
600 return self.base_type._attr_policy(policy)
602 def _attr_typol(self): argument
603 return self.base_type._attr_typol()
605 def _attr_get(self, ri, var): argument
606 return f'n_{self.c_name}++;', None, None
608 def attr_put(self, ri, var): argument
609 if self.attr['type'] in scalars:
610 put_type = self.type
611 ri.cw.p(f"for (unsigned int i = 0; i < {var}->n_{self.c_name}; i++)")
612 ri.cw.p(f"ynl_attr_put_{put_type}(nlh, {self.enum_name}, {var}->{self.c_name}[i]);")
613 elif 'type' not in self.attr or self.attr['type'] == 'nest':
614 ri.cw.p(f"for (unsigned int i = 0; i < {var}->n_{self.c_name}; i++)")
615 self._attr_put_line(ri, var, f"{self.nested_render_name}_put(nlh, " +
616 f"{self.enum_name}, &{var}->{self.c_name}[i])")
618 raise Exception(f"Put of MultiAttr sub-type {self.attr['type']} not supported yet")
620 def _setter_lines(self, ri, member, presence): argument
622 presence = presence[:-(len('_present.') + len(self.c_name))] + "n_" + self.c_name
624 f"{member} = {self.c_name};",
625 f"{presence} = n_{self.c_name};"]
629 def is_multi_val(self): argument
632 def presence_type(self): argument
635 def _complex_member_type(self, ri): argument
636 if 'sub-type' not in self.attr or self.attr['sub-type'] == 'nest':
637 return self.nested_struct_type
638 elif self.attr['sub-type'] in scalars:
640 return scalar_pfx + self.attr['sub-type']
642 raise Exception(f"Sub-type {self.attr['sub-type']} not supported yet")
644 def _attr_typol(self): argument
645 return f'.type = YNL_PT_NEST, .nest = &{self.nested_render_name}_nest, '
647 def _attr_get(self, ri, var): argument
649 get_lines = [f'attr_{self.c_name} = attr;',
651 f'\t{var}->n_{self.c_name}++;']
656 def _complex_member_type(self, ri): argument
657 return self.nested_struct_type
659 def _attr_typol(self): argument
660 return f'.type = YNL_PT_NEST, .nest = &{self.nested_render_name}_nest, '
662 def _attr_get(self, ri, var): argument
667 init_lines = [f"parg.rsp_policy = &{self.nested_render_name}_nest;",
668 f"parg.data = &{var}->{self.c_name};"]
669 if 'type-value' in self.attr:
670 tv_names = [c_lower(x) for x in self.attr["type-value"]]
673 for level in self.attr["type-value"]:
681 get_lines += [f"{self.nested_render_name}_parse(&parg, {prev}{tv_args});"]
686 def __init__(self, family, space_name, type_list=None, inherited=None): argument
687 self.family = family
688 self.space_name = space_name
689 self.attr_set = family.attr_sets[space_name]
691 self._inherited = inherited if inherited is not None else []
692 self.inherited = []
694 self.nested = type_list is None
696 self.render_name = c_lower(family.ident_name)
698 self.render_name = c_lower(family.ident_name + '-' + space_name)
699 self.struct_name = 'struct ' + self.render_name
700 if self.nested and space_name in family.consts:
701 self.struct_name += '_'
702 self.ptr_name = self.struct_name + ' *'
704 self.child_nests = set()
706 self.request = False
707 self.reply = False
708 self.recursive = False
710 self.attr_list = []
711 self.attrs = dict()
714 self.attr_list.append((t, self.attr_set[t]),)
716 for t in self.attr_set:
717 self.attr_list.append((t, self.attr_set[t]),)
720 self.attr_max_val = None
721 for name, attr in self.attr_list:
724 self.attr_max_val = attr
725 self.attrs[name] = attr
727 def __iter__(self): argument
728 yield from self.attrs
730 def __getitem__(self, key): argument
731 return self.attrs[key]
733 def member_list(self): argument
734 return self.attr_list
736 def set_inherited(self, new_inherited): argument
737 if self._inherited != new_inherited:
739 self.inherited = [c_lower(x) for x in sorted(self._inherited)]
743 def __init__(self, enum_set, yaml, prev, value_start): argument
747 self.value_change = (self.value != prev.value + 1)
749 self.value_change = (self.value != 0)
750 self.value_change = self.value_change or self.enum_set['type'] == 'flags'
753 self.c_name = None
754 delattr(self, "c_name")
756 def resolve(self): argument
757 self.resolve_up(super())
759 self.c_name = c_upper(self.enum_set.value_pfx + self.name)
763 def __init__(self, family, yaml): argument
764 self.render_name = c_lower(family.ident_name + '-' + yaml['name'])
768 self.enum_name = 'enum ' + c_lower(yaml['enum-name'])
769 self.user_type = self.enum_name
771 self.enum_name = None
773 self.enum_name = 'enum ' + self.render_name
775 if self.enum_name:
776 self.user_type = self.enum_name
778 self.user_type = 'int'
780 self.value_pfx = yaml.get('name-prefix', f"{family.ident_name}-{yaml['name']}-")
784 def new_entry(self, entry, prev_entry, value_start): argument
785 return EnumEntry(self, entry, prev_entry, value_start)
787 def value_range(self): argument
788 low = min([x.value for x in self.entries.values()])
789 high = max([x.value for x in self.entries.values()])
791 if high - low + 1 != len(self.entries):
798 def __init__(self, family, yaml): argument
801 if self.subset_of is None:
804 elif self.name == family.name:
807 pfx = f"{family.ident_name}-a-{self.name}-"
808 self.name_prefix = c_upper(pfx)
809 self.max_name = c_upper(self.yaml.get('attr-max-name', f"{self.name_prefix}max"))
810 self.cnt_name = c_upper(self.yaml.get('attr-cnt-name', f"__{self.name_prefix}max"))
812 self.name_prefix = family.attr_sets[self.subset_of].name_prefix
813 self.max_name = family.attr_sets[self.subset_of].max_name
814 self.cnt_name = family.attr_sets[self.subset_of].cnt_name
817 self.c_name = None
818 delattr(self, "c_name")
820 def resolve(self): argument
821 self.c_name = c_lower(self.name)
822 if self.c_name in _C_KW:
823 self.c_name += '_'
824 if self.c_name == self.family.c_name:
825 self.c_name = ''
827 def new_attr(self, elem, value): argument
829 t = TypeScalar(self.family, self, elem, value)
831 t = TypeUnused(self.family, self, elem, value)
833 t = TypePad(self.family, self, elem, value)
835 t = TypeFlag(self.family, self, elem, value)
837 t = TypeString(self.family, self, elem, value)
839 t = TypeBinary(self.family, self, elem, value)
841 t = TypeBitfield32(self.family, self, elem, value)
843 t = TypeNest(self.family, self, elem, value)
846 t = TypeArrayNest(self.family, self, elem, value)
850 t = TypeNestTypeValue(self.family, self, elem, value)
855 t = TypeMultiAttr(self.family, self, elem, value, t)
861 def __init__(self, family, yaml, req_value, rsp_value): argument
864 self.render_name = c_lower(family.ident_name + '_' + self.name)
866 self.dual_policy = ('do' in yaml and 'request' in yaml['do']) and \
869 self.has_ntf = False
872 self.enum_name = None
873 delattr(self, "enum_name")
875 def resolve(self): argument
876 self.resolve_up(super())
878 if not self.is_async:
879 self.enum_name = self.family.op_prefix + c_upper(self.name)
881 self.enum_name = self.family.async_op_prefix + c_upper(self.name)
883 def mark_has_ntf(self): argument
884 self.has_ntf = True
888 def __init__(self, file_name, exclude_ops): argument
890 self.c_name = None
891 delattr(self, "c_name")
892 self.op_prefix = None
893 delattr(self, "op_prefix")
894 self.async_op_prefix = None
895 delattr(self, "async_op_prefix")
896 self.mcgrps = None
897 delattr(self, "mcgrps")
898 self.consts = None
899 delattr(self, "consts")
900 self.hooks = None
901 delattr(self, "hooks")
905 self.fam_key = c_upper(self.yaml.get('c-family-name', self.yaml["name"] + '_FAMILY_NAME'))
906 … self.ver_key = c_upper(self.yaml.get('c-version-name', self.yaml["name"] + '_FAMILY_VERSION'))
908 if 'definitions' not in self.yaml:
909 self.yaml['definitions'] = []
911 if 'uapi-header' in self.yaml:
912 self.uapi_header = self.yaml['uapi-header']
914 self.uapi_header = f"linux/{self.ident_name}.h"
915 if self.uapi_header.startswith("linux/") and self.uapi_header.endswith('.h'):
916 self.uapi_header_name = self.uapi_header[6:-2]
918 self.uapi_header_name = self.ident_name
920 def resolve(self): argument
921 self.resolve_up(super())
923 … if self.yaml.get('protocol', 'genetlink') not in {'genetlink', 'genetlink-c', 'genetlink-legacy'}:
926 self.c_name = c_lower(self.ident_name)
927 if 'name-prefix' in self.yaml['operations']:
928 self.op_prefix = c_upper(self.yaml['operations']['name-prefix'])
930 self.op_prefix = c_upper(self.yaml['name'] + '-cmd-')
931 if 'async-prefix' in self.yaml['operations']:
932 self.async_op_prefix = c_upper(self.yaml['operations']['async-prefix'])
934 self.async_op_prefix = self.op_prefix
936 self.mcgrps = self.yaml.get('mcast-groups', {'list': []})
938 self.hooks = dict()
940 self.hooks[when] = dict()
942 self.hooks[when][op_mode] = dict()
943 self.hooks[when][op_mode]['set'] = set()
944 self.hooks[when][op_mode]['list'] = []
947 self.root_sets = dict()
949 self.pure_nested_structs = dict()
951 self._mark_notify()
952 self._mock_up_events()
954 self._load_root_sets()
955 self._load_nested_sets()
956 self._load_attr_use()
957 self._load_hooks()
959 self.kernel_policy = self.yaml.get('kernel-policy', 'split')
960 if self.kernel_policy == 'global':
961 self._load_global_policy()
963 def new_enum(self, elem): argument
964 return EnumSet(self, elem)
966 def new_attr_set(self, elem): argument
967 return AttrSet(self, elem)
969 def new_operation(self, elem, req_value, rsp_value): argument
970 return Operation(self, elem, req_value, rsp_value)
972 def _mark_notify(self): argument
973 for op in self.msgs.values():
975 self.ops[op['notify']].mark_has_ntf()
978 def _mock_up_events(self): argument
979 for op in self.yaml['operations']['list']:
987 def _load_root_sets(self): argument
988 for op_name, op in self.msgs.items():
1002 if op['attribute-set'] not in self.root_sets:
1003 self.root_sets[op['attribute-set']] = {'request': req_attrs, 'reply': rsp_attrs}
1005 self.root_sets[op['attribute-set']]['request'].update(req_attrs)
1006 self.root_sets[op['attribute-set']]['reply'].update(rsp_attrs)
1008 def _sort_pure_types(self): argument
1010 pns_key_list = list(self.pure_nested_structs.keys())
1018 for _, spec in self.attr_sets[name].items():
1022 if self.pure_nested_structs[nested].recursive:
1026 struct = self.pure_nested_structs.pop(name)
1027 self.pure_nested_structs[name] = struct
1035 def _load_nested_sets(self): argument
1036 attr_set_queue = list(self.root_sets.keys())
1037 attr_set_seen = set(self.root_sets.keys())
1041 for attr, spec in self.attr_sets[a_set].items():
1051 if nested not in self.root_sets:
1052 if nested not in self.pure_nested_structs:
1053 self.pure_nested_structs[nested] = Struct(self, nested, inherited=inherit)
1058 if nested in self.root_sets:
1063 self.pure_nested_structs[nested].set_inherited(inherit)
1065 for root_set, rs_members in self.root_sets.items():
1066 for attr, spec in self.attr_sets[root_set].items():
1070 self.pure_nested_structs[nested].request = True
1072 self.pure_nested_structs[nested].reply = True
1074 self._sort_pure_types()
1077 for attr_set, struct in reversed(self.pure_nested_structs.items()):
1078 for _, spec in self.attr_sets[attr_set].items():
1082 child = self.pure_nested_structs.get(child_name)
1091 self._sort_pure_types()
1093 def _load_attr_use(self): argument
1094 for _, struct in self.pure_nested_structs.items():
1102 for root_set, rs_members in self.root_sets.items():
1103 for attr, spec in self.attr_sets[root_set].items():
1109 def _load_global_policy(self): argument
1112 for op_name, op in self.ops.items():
1129 self.global_policy = []
1130 self.global_policy_set = attr_set_name
1131 for attr in self.attr_sets[attr_set_name]:
1133 self.global_policy.append(attr)
1135 def _load_hooks(self): argument
1136 for op in self.ops.values():
1144 if name in self.hooks[when][op_mode]['set']:
1146 self.hooks[when][op_mode]['set'].add(name)
1147 self.hooks[when][op_mode]['list'].append(name)
1151 def __init__(self, cw, family, ku_space, op, op_mode, attr_set=None): argument
1152 self.family = family
1153 self.nl = cw.nlib
1154 self.ku_space = ku_space
1155 self.op_mode = op_mode
1156 self.op = op
1158 self.fixed_hdr = None
1160 self.fixed_hdr = 'struct ' + c_lower(op.fixed_header)
1163 self.type_consistent = True
1167 self.type_consistent = False
1169 self.type_consistent = False
1171 self.type_consistent = False
1173 self.attr_set = attr_set
1174 if not self.attr_set:
1175 self.attr_set = op['attribute-set']
1177 self.type_name_conflict = False
1179 self.type_name = c_lower(op.name)
1181 self.type_name = c_lower(attr_set)
1183 self.type_name_conflict = True
1185 self.cw = cw
1187 self.struct = dict()
1195 self.struct[op_dir] = Struct(family, self.attr_set, type_list=type_list)
1197 … self.struct['reply'] = Struct(family, self.attr_set, type_list=op['event']['attributes'])
1201 def __init__(self, nlib, out_file=None, overwrite=True): argument
1202 self.nlib = nlib
1203 self._overwrite = overwrite
1205 self._nl = False
1206 self._block_end = False
1207 self._silent_block = False
1208 self._ind = 0
1209 self._ifdef_block = None
1211 self._out = os.sys.stdout
1213 self._out = tempfile.NamedTemporaryFile('w+')
1214 self._out_file = out_file
1216 def __del__(self): argument
1217 self.close_out_file()
1219 def close_out_file(self): argument
1220 if self._out == os.sys.stdout:
1223 self._out.flush()
1224 if not self._overwrite and os.path.isfile(self._out_file):
1225 if filecmp.cmp(self._out.name, self._out_file, shallow=False):
1227 with open(self._out_file, 'w+') as out_file:
1228 self._out.seek(0)
1229 shutil.copyfileobj(self._out, out_file)
1230 self._out.close()
1231 self._out = os.sys.stdout
1237 def p(self, line, add_ind=0): argument
1238 if self._block_end:
1239 self._block_end = False
1243 self._out.write('\t' * self._ind + '}\n')
1245 if self._nl:
1246 self._out.write('\n')
1247 self._nl = False
1249 ind = self._ind
1252 if self._silent_block:
1254 self._silent_block = line.endswith(')') and CodeWriter._is_cond(line)
1259 self._out.write('\t' * ind + line + '\n')
1261 def nl(self): argument
1262 self._nl = True
1264 def block_start(self, line=''): argument
1267 self.p(line + '{')
1268 self._ind += 1
1270 def block_end(self, line=''): argument
1273 self._ind -= 1
1274 self._nl = False
1277 if self._block_end:
1278 self._out.write('\t' * (self._ind + 1) + '}\n')
1279 self._block_end = True
1281 self.p('}' + line)
1283 def write_doc_line(self, doc, indent=True): argument
1288 self.p(line)
1293 self.p(line)
1295 def write_func_prot(self, qual_ret, name, args=None, doc=None, suffix=''): argument
1300 self.p('/*')
1301 self.p(' * ' + doc)
1302 self.p(' */')
1310 self.p(oneline)
1315 self.p(v)
1329 self.p(v + ',')
1335 self.p(v + ')' + suffix)
1337 def write_func_lvar(self, local_vars): argument
1346 self.p(var)
1347 self.nl()
1349 def write_func(self, qual_ret, name, body, args=None, local_vars=None): argument
1350 self.write_func_prot(qual_ret=qual_ret, name=name, args=args)
1351 self.write_func_lvar(local_vars=local_vars)
1353 self.block_start()
1355 self.p(line)
1356 self.block_end()
1358 def writes_defines(self, defines): argument
1371 self.p(line)
1373 def write_struct_init(self, members): argument
1381 self.p(line)
1383 def ifdef_block(self, config): argument
1387 if self._ifdef_block == config_option:
1390 if self._ifdef_block:
1391 self.p('#endif /* ' + self._ifdef_block + ' */')
1393 self.p('#ifdef ' + config_option)
1394 self._ifdef_block = config_option