Lines Matching full:self
43 def get_family_id(self):
48 def __init__(self, family, attr_set, attr, value):
51 self.attr = attr
52 self.attr_set = attr_set
53 self.type = attr['type']
54 self.checks = attr.get('checks', {})
56 self.request = False
57 self.reply = False
59 self.is_selector = False
62 self.len = attr['len']
72 self.nested_attrs = nested
73 if self.nested_attrs == family.name:
74 self.nested_render_name = c_lower(f"{family.ident_name}")
76 self.nested_render_name = c_lower(f"{family.ident_name}_{self.nested_attrs}")
78 if self.nested_attrs in self.family.consts:
79 self.nested_struct_type = 'struct ' + self.nested_render_name + '_'
81 self.nested_struct_type = 'struct ' + self.nested_render_name
83 self.c_name = c_lower(self.name)
84 if self.c_name in _C_KW:
85 self.c_name += '_'
86 if self.c_name[0].isdigit():
87 self.c_name = '_' + self.c_name
90 self.enum_name = None
91 delattr(self, "enum_name")
93 def _get_real_attr(self):
95 return self.family.attr_sets[self.attr_set.subset_of][self.name]
97 def set_request(self):
98 self.request = True
99 if self.attr_set.subset_of:
100 self._get_real_attr().set_request()
102 def set_reply(self):
103 self.reply = True
104 if self.attr_set.subset_of:
105 self._get_real_attr().set_reply()
107 def get_limit(self, limit, default=None):
108 value = self.checks.get(limit, default)
113 if value in self.family.consts:
114 return self.family.consts[value]["value"]
117 def get_limit_str(self, limit, default=None, suffix=''):
118 value = self.checks.get(limit, default)
123 if value in self.family.consts:
124 const = self.family.consts[value]
127 return c_upper(f"{self.family['name']}-{value}")
130 def resolve(self):
131 if 'parent-sub-message' in self.attr:
132 enum_name = self.attr['parent-sub-message'].enum_name
133 elif 'name-prefix' in self.attr:
134 enum_name = f"{self.attr['name-prefix']}{self.name}"
136 enum_name = f"{self.attr_set.name_prefix}{self.name}"
137 self.enum_name = c_upper(enum_name)
139 if self.attr_set.subset_of:
140 if self.checks != self._get_real_attr().checks:
143 def is_multi_val(self):
146 def is_scalar(self):
147 return self.type in {'u8', 'u16', 'u32', 'u64', 's32', 's64'}
149 def is_recursive(self):
152 def is_recursive_for_op(self, ri):
153 return self.is_recursive() and not ri.op
155 def presence_type(self):
158 def presence_member(self, space, type_filter):
159 if self.presence_type() != type_filter:
162 if self.presence_type() == 'present':
164 return f"{pfx}u32 {self.c_name}:1;"
166 if self.presence_type() in {'len', 'count'}:
168 return f"{pfx}u32 {self.c_name};"
170 def _complex_member_type(self, ri):
173 def free_needs_iter(self):
176 def _free_lines(self, ri, var, ref):
177 if self.is_multi_val() or self.presence_type() in {'count', 'len'}:
178 return [f'free({var}->{ref}{self.c_name});']
181 def free(self, ri, var, ref):
182 lines = self._free_lines(ri, var, ref)
186 def arg_member(self, ri):
187 member = self._complex_member_type(ri)
190 arg = [member + spc + '*' + self.c_name]
191 if self.presence_type() == 'count':
192 arg += ['unsigned int n_' + self.c_name]
194 raise Exception(f"Struct member not implemented for class type {self.type}")
196 def struct_member(self, ri):
197 member = self._complex_member_type(ri)
199 ptr = '*' if self.is_multi_val() else ''
200 if self.is_recursive_for_op(ri):
203 ri.cw.p(f"{member}{spc}{ptr}{self.c_name};")
205 members = self.arg_member(ri)
209 def _attr_policy(self, policy):
212 def attr_policy(self, cw):
213 policy = f'NLA_{c_upper(self.type)}'
214 if self.attr.get('byte-order') == 'big-endian':
215 if self.type in {'u16', 'u32'}:
216 policy = f'NLA_BE{self.type[1:]}'
218 spec = self._attr_policy(policy)
219 cw.p(f"\t[{self.enum_name}] = {spec},")
221 def _attr_typol(self):
222 raise Exception(f"Type policy not implemented for class type {self.type}")
224 def attr_typol(self, cw):
225 typol = self._attr_typol()
226 cw.p(f'[{self.enum_name}] = {"{"} .name = "{self.name}", {typol}{"}"},')
228 def _attr_put_line(self, ri, var, line):
229 presence = self.presence_type()
231 ri.cw.p(f"if ({var}->_{presence}.{self.c_name})")
234 def _attr_put_simple(self, ri, var, put_type):
235 line = f"ynl_attr_put_{put_type}(nlh, {self.enum_name}, {var}->{self.c_name})"
236 self._attr_put_line(ri, var, line)
238 def attr_put(self, ri, var):
239 raise Exception(f"Put not implemented for class type {self.type}")
241 def _attr_get(self, ri, var):
242 raise Exception(f"Attr get not implemented for class type {self.type}")
244 def attr_get(self, ri, var, first):
245 lines, init_lines, _ = self._attr_get(ri, var)
252 ri.cw.block_start(line=f"{kw} (type == {self.enum_name})")
254 if not self.is_multi_val():
257 if self.presence_type() == 'present':
258 ri.cw.p(f"{var}->_present.{self.c_name} = 1;")
270 def _setter_lines(self, ri, member, presence):
271 raise Exception(f"Setter not implemented for class type {self.type}")
273 def setter(self, ri, space, direction, deref=False, ref=None, var="req"):
274 ref = (ref if ref else []) + [self.c_name]
278 if self.free_needs_iter():
286 # last layer is "self" and may be a complex type
287 if i == len(ref) - 1 and self.presence_type() != 'present':
288 presence = f"{var}->{'.'.join(ref[:i] + [''])}_{self.presence_type()}.{ref[i]}"
294 code += self._free_lines(ri, var, ref_path)
295 code += self._setter_lines(ri, member, presence)
304 args=[f'{type_name(ri, direction, deref=deref)} *{var}'] + self.arg_member(ri))
308 def presence_type(self):
311 def arg_member(self, ri):
314 def _attr_get(self, ri, var):
317 def _attr_typol(self):
320 def attr_policy(self, cw):
323 def attr_put(self, ri, var):
326 def attr_get(self, ri, var, first):
329 def setter(self, ri, space, direction, deref=False, ref=None, var=None):
334 def presence_type(self):
337 def arg_member(self, ri):
340 def _attr_typol(self):
343 def attr_put(self, ri, var):
346 def attr_get(self, ri, var, first):
349 def attr_policy(self, cw):
352 def setter(self, ri, space, direction, deref=False, ref=None, var=None):
357 def __init__(self, family, attr_set, attr, value):
360 self.byte_order_comment = ''
362 self.byte_order_comment = f" /* {attr['byte-order']} */"
367 self._init_checks()
370 self.is_bitfield = None
371 delattr(self, "is_bitfield")
372 self.type_name = None
373 delattr(self, "type_name")
375 def resolve(self):
376 self.resolve_up(super())
378 if 'enum-as-flags' in self.attr and self.attr['enum-as-flags']:
379 self.is_bitfield = True
380 elif 'enum' in self.attr:
381 self.is_bitfield = self.family.consts[self.attr['enum']]['type'] == 'flags'
383 self.is_bitfield = False
385 if not self.is_bitfield and 'enum' in self.attr:
386 self.type_name = self.family.consts[self.attr['enum']].user_type
387 elif self.is_auto_scalar:
388 self.type_name = '__' + self.type[0] + '64'
390 self.type_name = '__' + self.type
392 def _init_checks(self):
393 if 'enum' in self.attr:
394 enum = self.family.consts[self.attr['enum']]
397 self.checks['sparse'] = True
399 if 'min' not in self.checks:
400 if low != 0 or self.type[0] == 's':
401 self.checks['min'] = low
402 if 'max' not in self.checks:
403 self.checks['max'] = high
405 if 'min' in self.checks and 'max' in self.checks:
406 if self.get_limit('min') > self.get_limit('max'):
407 raise Exception(f'Invalid limit for "{self.name}" min: {self.get_limit("min")} max: {self.get_limit("max")}')
408 self.checks['range'] = True
410 low = min(self.get_limit('min', 0), self.get_limit('max', 0))
411 high = max(self.get_limit('min', 0), self.get_limit('max', 0))
412 if low < 0 and self.type[0] == 'u':
413 raise Exception(f'Invalid limit for "{self.name}" negative limit for unsigned type')
415 self.checks['full-range'] = True
417 def _attr_policy(self, policy):
418 if 'flags-mask' in self.checks or self.is_bitfield:
419 if self.is_bitfield:
420 enum = self.family.consts[self.attr['enum']]
423 flags = self.family.consts[self.checks['flags-mask']]
427 elif 'full-range' in self.checks:
428 return f"NLA_POLICY_FULL_RANGE({policy}, &{c_lower(self.enum_name)}_range)"
429 elif 'range' in self.checks:
430 return f"NLA_POLICY_RANGE({policy}, {self.get_limit_str('min')}, {self.get_limit_str('max')})"
431 elif 'min' in self.checks:
432 return f"NLA_POLICY_MIN({policy}, {self.get_limit_str('min')})"
433 elif 'max' in self.checks:
434 return f"NLA_POLICY_MAX({policy}, {self.get_limit_str('max')})"
435 elif 'sparse' in self.checks:
436 return f"NLA_POLICY_VALIDATE_FN({policy}, &{c_lower(self.enum_name)}_validate)"
439 def _attr_typol(self):
440 return f'.type = YNL_PT_U{c_upper(self.type[1:])}, '
442 def arg_member(self, ri):
443 return [f'{self.type_name} {self.c_name}{self.byte_order_comment}']
445 def attr_put(self, ri, var):
446 self._attr_put_simple(ri, var, self.type)
448 def _attr_get(self, ri, var):
449 return f"{var}->{self.c_name} = ynl_attr_get_{self.type}(attr);", None, None
451 def _setter_lines(self, ri, member, presence):
452 return [f"{member} = {self.c_name};"]
456 def arg_member(self, ri):
459 def _attr_typol(self):
462 def attr_put(self, ri, var):
463 self._attr_put_line(ri, var, f"ynl_attr_put(nlh, {self.enum_name}, NULL, 0)")
465 def _attr_get(self, ri, var):
468 def _setter_lines(self, ri, member, presence):
473 def arg_member(self, ri):
474 return [f"const char *{self.c_name}"]
476 def presence_type(self):
479 def struct_member(self, ri):
480 ri.cw.p(f"char *{self.c_name};")
482 def _attr_typol(self):
484 if self.is_selector:
488 def _attr_policy(self, policy):
489 if 'exact-len' in self.checks:
490 mem = 'NLA_POLICY_EXACT_LEN(' + self.get_limit_str('exact-len') + ')'
493 if 'max-len' in self.checks:
494 mem += ', .len = ' + self.get_limit_str('max-len')
498 def attr_policy(self, cw):
499 if self.checks.get('unterminated-ok', False):
504 spec = self._attr_policy(policy)
505 cw.p(f"\t[{self.enum_name}] = {spec},")
507 def attr_put(self, ri, var):
508 self._attr_put_simple(ri, var, 'str')
510 def _attr_get(self, ri, var):
511 len_mem = var + '->_len.' + self.c_name
513 f"{var}->{self.c_name} = malloc(len + 1);",
514 f"memcpy({var}->{self.c_name}, ynl_attr_get_str(attr), len);",
515 f"{var}->{self.c_name}[len] = 0;"], \
519 def _setter_lines(self, ri, member, presence):
520 return [f"{presence} = strlen({self.c_name});",
522 f'memcpy({member}, {self.c_name}, {presence});',
527 def arg_member(self, ri):
528 return [f"const void *{self.c_name}", 'size_t len']
530 def presence_type(self):
533 def struct_member(self, ri):
534 ri.cw.p(f"void *{self.c_name};")
536 def _attr_typol(self):
539 def _attr_policy(self, policy):
540 if len(self.checks) == 0:
542 elif len(self.checks) == 1:
543 check_name = list(self.checks)[0]
549 if len(self.checks) == 0:
551 elif 'exact-len' in self.checks:
552 mem = 'NLA_POLICY_EXACT_LEN(' + self.get_limit_str('exact-len') + ')'
553 elif 'min-len' in self.checks:
554 mem = 'NLA_POLICY_MIN_LEN(' + self.get_limit_str('min-len') + ')'
555 elif 'max-len' in self.checks:
556 mem = 'NLA_POLICY_MAX_LEN(' + self.get_limit_str('max-len') + ')'
560 def attr_put(self, ri, var):
561 self._attr_put_line(ri, var, f"ynl_attr_put(nlh, {self.enum_name}, " +
562 f"{var}->{self.c_name}, {var}->_len.{self.c_name})")
564 def _attr_get(self, ri, var):
565 len_mem = var + '->_len.' + self.c_name
567 f"{var}->{self.c_name} = malloc(len);",
568 f"memcpy({var}->{self.c_name}, ynl_attr_data(attr), len);"], \
572 def _setter_lines(self, ri, member, presence):
575 f'memcpy({member}, {self.c_name}, {presence});']
579 def struct_member(self, ri):
580 ri.cw.p(f'struct {c_lower(self.get("struct"))} *{self.c_name};')
582 def _attr_get(self, ri, var):
583 struct_sz = 'sizeof(struct ' + c_lower(self.get("struct")) + ')'
584 len_mem = var + '->_' + self.presence_type() + '.' + self.c_name
587 f"{var}->{self.c_name} = calloc(1, {struct_sz});",
589 f"{var}->{self.c_name} = malloc(len);",
590 f"memcpy({var}->{self.c_name}, ynl_attr_data(attr), len);"], \
596 def arg_member(self, ri):
597 return [f'__{self.get("sub-type")} *{self.c_name}', 'size_t count']
599 def presence_type(self):
602 def struct_member(self, ri):
603 ri.cw.p(f'__{self.get("sub-type")} *{self.c_name};')
605 def attr_put(self, ri, var):
606 presence = self.presence_type()
607 ri.cw.block_start(line=f"if ({var}->_{presence}.{self.c_name})")
608 ri.cw.p(f"i = {var}->_{presence}.{self.c_name} * sizeof(__{self.get('sub-type')});")
609 ri.cw.p(f"ynl_attr_put(nlh, {self.enum_name}, " +
610 f"{var}->{self.c_name}, i);")
613 def _attr_get(self, ri, var):
614 len_mem = var + '->_count.' + self.c_name
615 return [f"{len_mem} = len / sizeof(__{self.get('sub-type')});",
616 f"len = {len_mem} * sizeof(__{self.get('sub-type')});",
617 f"{var}->{self.c_name} = malloc(len);",
618 f"memcpy({var}->{self.c_name}, ynl_attr_data(attr), len);"], \
622 def _setter_lines(self, ri, member, presence):
624 f"count *= sizeof(__{self.get('sub-type')});",
626 f'memcpy({member}, {self.c_name}, count);']
630 def _complex_member_type(self, ri):
633 def _attr_typol(self):
636 def _attr_policy(self, policy):
637 if 'enum' not in self.attr:
639 enum = self.family.consts[self.attr['enum']]
643 def attr_put(self, ri, var):
644 line = f"ynl_attr_put(nlh, {self.enum_name}, &{var}->{self.c_name}, sizeof(struct nla_bitfield32))"
645 self._attr_put_line(ri, var, line)
647 def _attr_get(self, ri, var):
648 return f"memcpy(&{var}->{self.c_name}, ynl_attr_data(attr), sizeof(struct nla_bitfield32));", None, None
650 def _setter_lines(self, ri, member, presence):
651 return [f"memcpy(&{member}, {self.c_name}, sizeof(struct nla_bitfield32));"]
655 def is_recursive(self):
656 return self.family.pure_nested_structs[self.nested_attrs].recursive
658 def _complex_member_type(self, ri):
659 return self.nested_struct_type
661 def _free_lines(self, ri, var, ref):
664 if self.is_recursive_for_op(ri):
666 lines += [f'if ({var}->{ref}{self.c_name})']
667 lines += [f'{self.nested_render_name}_free({at}{var}->{ref}{self.c_name});']
670 def _attr_typol(self):
671 return f'.type = YNL_PT_NEST, .nest = &{self.nested_render_name}_nest, '
673 def _attr_policy(self, policy):
674 return 'NLA_POLICY_NESTED(' + self.nested_render_name + '_nl_policy)'
676 def attr_put(self, ri, var):
677 at = '' if self.is_recursive_for_op(ri) else '&'
678 self._attr_put_line(ri, var, f"{self.nested_render_name}_put(nlh, " +
679 f"{self.enum_name}, {at}{var}->{self.c_name})")
681 def _attr_get(self, ri, var):
682 pns = self.family.pure_nested_structs[self.nested_attrs]
686 get_lines = [f"if ({self.nested_render_name}_parse({', '.join(args)}))",
688 init_lines = [f"parg.rsp_policy = &{self.nested_render_name}_nest;",
689 f"parg.data = &{var}->{self.c_name};"]
692 def setter(self, ri, space, direction, deref=False, ref=None, var="req"):
693 ref = (ref if ref else []) + [self.c_name]
695 for _, attr in ri.family.pure_nested_structs[self.nested_attrs].member_list():
698 attr.setter(ri, self.nested_attrs, direction, deref=deref, ref=ref,
703 def __init__(self, family, attr_set, attr, value, base_type):
706 self.base_type = base_type
708 def is_multi_val(self):
711 def presence_type(self):
714 def _complex_member_type(self, ri):
715 if 'type' not in self.attr or self.attr['type'] == 'nest':
716 return self.nested_struct_type
717 elif self.attr['type'] == 'binary' and 'struct' in self.attr:
719 elif self.attr['type'] == 'string':
721 elif self.attr['type'] in scalars:
723 if self.is_auto_scalar:
724 name = self.type[0] + '64'
726 name = self.attr['type']
729 raise Exception(f"Sub-type {self.attr['type']} not supported yet")
731 def arg_member(self, ri):
732 if self.type == 'binary' and 'struct' in self.attr:
733 return [f'struct {c_lower(self.attr["struct"])} *{self.c_name}',
734 f'unsigned int n_{self.c_name}']
737 def free_needs_iter(self):
738 return self.attr['type'] in {'nest', 'string'}
740 def _free_lines(self, ri, var, ref):
742 if self.attr['type'] in scalars:
743 lines += [f"free({var}->{ref}{self.c_name});"]
744 elif self.attr['type'] == 'binary':
745 lines += [f"free({var}->{ref}{self.c_name});"]
746 elif self.attr['type'] == 'string':
748 f"for (i = 0; i < {var}->{ref}_count.{self.c_name}; i++)",
749 f"free({var}->{ref}{self.c_name}[i]);",
750 f"free({var}->{ref}{self.c_name});",
752 elif 'type' not in self.attr or self.attr['type'] == 'nest':
754 f"for (i = 0; i < {var}->{ref}_count.{self.c_name}; i++)",
755 f'{self.nested_render_name}_free(&{var}->{ref}{self.c_name}[i]);',
756 f"free({var}->{ref}{self.c_name});",
759 raise Exception(f"Free of MultiAttr sub-type {self.attr['type']} not supported yet")
762 def _attr_policy(self, policy):
763 return self.base_type._attr_policy(policy)
765 def _attr_typol(self):
766 return self.base_type._attr_typol()
768 def _attr_get(self, ri, var):
769 return f'n_{self.c_name}++;', None, None
771 def attr_put(self, ri, var):
772 if self.attr['type'] in scalars:
773 put_type = self.type
774 ri.cw.p(f"for (i = 0; i < {var}->_count.{self.c_name}; i++)")
775 ri.cw.p(f"ynl_attr_put_{put_type}(nlh, {self.enum_name}, {var}->{self.c_name}[i]);")
776 elif self.attr['type'] == 'binary' and 'struct' in self.attr:
777 ri.cw.p(f"for (i = 0; i < {var}->_count.{self.c_name}; i++)")
778 ri.cw.p(f"ynl_attr_put(nlh, {self.enum_name}, &{var}->{self.c_name}[i], sizeof(struct {c_lower(self.attr['struct'])}));")
779 elif self.attr['type'] == 'string':
780 ri.cw.p(f"for (i = 0; i < {var}->_count.{self.c_name}; i++)")
781 ri.cw.p(f"ynl_attr_put_str(nlh, {self.enum_name}, {var}->{self.c_name}[i]->str);")
782 elif 'type' not in self.attr or self.attr['type'] == 'nest':
783 ri.cw.p(f"for (i = 0; i < {var}->_count.{self.c_name}; i++)")
784 self._attr_put_line(ri, var, f"{self.nested_render_name}_put(nlh, " +
785 f"{self.enum_name}, &{var}->{self.c_name}[i])")
787 raise Exception(f"Put of MultiAttr sub-type {self.attr['type']} not supported yet")
789 def _setter_lines(self, ri, member, presence):
790 return [f"{member} = {self.c_name};",
791 f"{presence} = n_{self.c_name};"]
795 def is_multi_val(self):
798 def presence_type(self):
801 def _complex_member_type(self, ri):
802 if 'sub-type' not in self.attr or self.attr['sub-type'] == 'nest':
803 return self.nested_struct_type
804 elif self.attr['sub-type'] in scalars:
806 return scalar_pfx + self.attr['sub-type']
807 elif self.attr['sub-type'] == 'binary' and 'exact-len' in self.checks:
810 raise Exception(f"Sub-type {self.attr['sub-type']} not supported yet")
812 def arg_member(self, ri):
813 if self.sub_type == 'binary' and 'exact-len' in self.checks:
814 return [f'unsigned char (*{self.c_name})[{self.checks["exact-len"]}]',
815 f'unsigned int n_{self.c_name}']
818 def _attr_policy(self, policy):
819 if self.attr['sub-type'] == 'nest':
820 return f'NLA_POLICY_NESTED_ARRAY({self.nested_render_name}_nl_policy)'
823 def _attr_typol(self):
824 if self.attr['sub-type'] in scalars:
825 return f'.type = YNL_PT_U{c_upper(self.sub_type[1:])}, '
826 elif self.attr['sub-type'] == 'binary' and 'exact-len' in self.checks:
827 return f'.type = YNL_PT_BINARY, .len = {self.checks["exact-len"]}, '
828 elif self.attr['sub-type'] == 'nest':
829 return f'.type = YNL_PT_NEST, .nest = &{self.nested_render_name}_nest, '
831 raise Exception(f"Typol for IndexedArray sub-type {self.attr['sub-type']} not supported, yet")
833 def _attr_get(self, ri, var):
835 get_lines = [f'attr_{self.c_name} = attr;',
839 f'\tn_{self.c_name}++;',
843 def attr_put(self, ri, var):
844 ri.cw.p(f'array = ynl_attr_nest_start(nlh, {self.enum_name});')
845 if self.sub_type in scalars:
846 put_type = self.sub_type
847 ri.cw.block_start(line=f'for (i = 0; i < {var}->_count.{self.c_name}; i++)')
848 ri.cw.p(f"ynl_attr_put_{put_type}(nlh, i, {var}->{self.c_name}[i]);")
850 elif self.sub_type == 'binary' and 'exact-len' in self.checks:
851 ri.cw.p(f'for (i = 0; i < {var}->_count.{self.c_name}; i++)')
852 ri.cw.p(f"ynl_attr_put(nlh, i, {var}->{self.c_name}[i], {self.checks['exact-len']});")
853 elif self.sub_type == 'nest':
854 ri.cw.p(f'for (i = 0; i < {var}->_count.{self.c_name}; i++)')
855 ri.cw.p(f"{self.nested_render_name}_put(nlh, i, &{var}->{self.c_name}[i]);")
857 raise Exception(f"Put for IndexedArray sub-type {self.attr['sub-type']} not supported, yet")
860 def _setter_lines(self, ri, member, presence):
861 return [f"{member} = {self.c_name};",
862 f"{presence} = n_{self.c_name};"]
866 def _complex_member_type(self, ri):
867 return self.nested_struct_type
869 def _attr_typol(self):
870 return f'.type = YNL_PT_NEST, .nest = &{self.nested_render_name}_nest, '
872 def _attr_get(self, ri, var):
877 init_lines = [f"parg.rsp_policy = &{self.nested_render_name}_nest;",
878 f"parg.data = &{var}->{self.c_name};"]
879 if 'type-value' in self.attr:
880 tv_names = [c_lower(x) for x in self.attr["type-value"]]
883 for level in self.attr["type-value"]:
891 get_lines += [f"{self.nested_render_name}_parse(&parg, {prev}{tv_args});"]
896 def __init__(self, family, attr_set, attr, value):
899 self.selector = Selector(attr, attr_set)
901 def _attr_typol(self):
902 typol = f'.type = YNL_PT_NEST, .nest = &{self.nested_render_name}_nest, '
907 if not self.selector.is_external():
908 typol += f'.selector_type = {self.attr_set[self["selector"]].value} '
911 def _attr_get(self, ri, var):
912 sel = c_lower(self['selector'])
913 if self.selector.is_external():
919 (self.name, self['selector']),
920 f"if ({self.nested_render_name}_parse(&parg, {sel_var}, attr))",
922 init_lines = [f"parg.rsp_policy = &{self.nested_render_name}_nest;",
923 f"parg.data = &{var}->{self.c_name};"]
928 def __init__(self, msg_attr, attr_set):
929 self.name = msg_attr["selector"]
931 if self.name in attr_set:
932 self.attr = attr_set[self.name]
933 self.attr.is_selector = True
934 self._external = False
937 self.attr = None
938 self._external = True
940 def set_attr(self, attr):
941 self.attr = attr
943 def is_external(self):
944 return self._external
948 def __init__(self, family, space_name, type_list=None, fixed_header=None,
950 self.family = family
951 self.space_name = space_name
952 self.attr_set = family.attr_sets[space_name]
954 self._inherited = inherited if inherited is not None else []
955 self.inherited = []
956 self.fixed_header = None
958 self.fixed_header = 'struct ' + c_lower(fixed_header)
959 self.submsg = submsg
961 self.nested = type_list is None
963 self.render_name = c_lower(family.ident_name)
965 self.render_name = c_lower(family.ident_name + '-' + space_name)
966 self.struct_name = 'struct ' + self.render_name
967 if self.nested and space_name in family.consts:
968 self.struct_name += '_'
969 self.ptr_name = self.struct_name + ' *'
971 self.child_nests = set()
973 self.request = False
974 self.reply = False
975 self.recursive = False
976 self.in_multi_val = False # used by a MultiAttr or and legacy arrays
978 self.attr_list = []
979 self.attrs = dict()
982 self.attr_list.append((t, self.attr_set[t]),)
984 for t in self.attr_set:
985 self.attr_list.append((t, self.attr_set[t]),)
988 self.attr_max_val = None
989 for name, attr in self.attr_list:
992 self.attr_max_val = attr
993 self.attrs[name] = attr
995 def __iter__(self):
996 yield from self.attrs
998 def __getitem__(self, key):
999 return self.attrs[key]
1001 def member_list(self):
1002 return self.attr_list
1004 def set_inherited(self, new_inherited):
1005 if self._inherited != new_inherited:
1007 self.inherited = [c_lower(x) for x in sorted(self._inherited)]
1009 def external_selectors(self):
1011 for name, attr in self.attr_list:
1016 def free_needs_iter(self):
1017 for _, attr in self.attr_list:
1024 def __init__(self, enum_set, yaml, prev, value_start):
1028 self.value_change = (self.value != prev.value + 1)
1030 self.value_change = (self.value != 0)
1031 self.value_change = self.value_change or self.enum_set['type'] == 'flags'
1034 self.c_name = None
1035 delattr(self, "c_name")
1037 def resolve(self):
1038 self.resolve_up(super())
1040 self.c_name = c_upper(self.enum_set.value_pfx + self.name)
1044 def __init__(self, family, yaml):
1045 self.render_name = c_lower(family.ident_name + '-' + yaml['name'])
1049 self.enum_name = 'enum ' + c_lower(yaml['enum-name'])
1050 self.user_type = self.enum_name
1052 self.enum_name = None
1054 self.enum_name = 'enum ' + self.render_name
1056 if self.enum_name:
1057 self.user_type = self.enum_name
1059 self.user_type = 'int'
1061 self.value_pfx = yaml.get('name-prefix', f"{family.ident_name}-{yaml['name']}-")
1062 self.header = yaml.get('header', None)
1063 self.enum_cnt_name = yaml.get('enum-cnt-name', None)
1067 def new_entry(self, entry, prev_entry, value_start):
1068 return EnumEntry(self, entry, prev_entry, value_start)
1070 def value_range(self):
1071 low = min([x.value for x in self.entries.values()])
1072 high = max([x.value for x in self.entries.values()])
1074 if high - low + 1 != len(self.entries):
1081 def __init__(self, family, yaml):
1084 if self.subset_of is None:
1087 elif self.name == family.name:
1090 pfx = f"{family.ident_name}-a-{self.name}-"
1091 self.name_prefix = c_upper(pfx)
1092 self.max_name = c_upper(self.yaml.get('attr-max-name', f"{self.name_prefix}max"))
1093 self.cnt_name = c_upper(self.yaml.get('attr-cnt-name', f"__{self.name_prefix}max"))
1095 self.name_prefix = family.attr_sets[self.subset_of].name_prefix
1096 self.max_name = family.attr_sets[self.subset_of].max_name
1097 self.cnt_name = family.attr_sets[self.subset_of].cnt_name
1100 self.c_name = None
1101 delattr(self, "c_name")
1103 def resolve(self):
1104 self.c_name = c_lower(self.name)
1105 if self.c_name in _C_KW:
1106 self.c_name += '_'
1107 if self.c_name == self.family.c_name:
1108 self.c_name = ''
1110 def new_attr(self, elem, value):
1112 t = TypeScalar(self.family, self, elem, value)
1114 t = TypeUnused(self.family, self, elem, value)
1116 t = TypePad(self.family, self, elem, value)
1118 t = TypeFlag(self.family, self, elem, value)
1120 t = TypeString(self.family, self, elem, value)
1123 t = TypeBinaryStruct(self.family, self, elem, value)
1125 t = TypeBinaryScalarArray(self.family, self, elem, value)
1127 t = TypeBinary(self.family, self, elem, value)
1129 t = TypeBitfield32(self.family, self, elem, value)
1131 t = TypeNest(self.family, self, elem, value)
1134 t = TypeIndexedArray(self.family, self, elem, value)
1138 t = TypeNestTypeValue(self.family, self, elem, value)
1140 t = TypeSubMessage(self.family, self, elem, value)
1145 t = TypeMultiAttr(self.family, self, elem, value, t)
1151 def __init__(self, family, yaml, req_value, rsp_value):
1162 self.render_name = c_lower(family.ident_name + '_' + self.name)
1164 self.dual_policy = ('do' in yaml and 'request' in yaml['do']) and \
1167 self.has_ntf = False
1170 self.enum_name = None
1171 delattr(self, "enum_name")
1173 def resolve(self):
1174 self.resolve_up(super())
1176 if not self.is_async:
1177 self.enum_name = self.family.op_prefix + c_upper(self.name)
1179 self.enum_name = self.family.async_op_prefix + c_upper(self.name)
1181 def mark_has_ntf(self):
1182 self.has_ntf = True
1186 def __init__(self, family, yaml):
1189 self.render_name = c_lower(family.ident_name + '-' + yaml['name'])
1191 def resolve(self):
1192 self.resolve_up(super())
1196 def __init__(self, file_name, exclude_ops):
1198 self.c_name = None
1199 delattr(self, "c_name")
1200 self.op_prefix = None
1201 delattr(self, "op_prefix")
1202 self.async_op_prefix = None
1203 delattr(self, "async_op_prefix")
1204 self.mcgrps = None
1205 delattr(self, "mcgrps")
1206 self.consts = None
1207 delattr(self, "consts")
1208 self.hooks = None
1209 delattr(self, "hooks")
1213 self.fam_key = c_upper(self.yaml.get('c-family-name', self.yaml["name"] + '_FAMILY_NAME'))
1214 self.ver_key = c_upper(self.yaml.get('c-version-name', self.yaml["name"] + '_FAMILY_VERSION'))
1216 if 'definitions' not in self.yaml:
1217 self.yaml['definitions'] = []
1219 if 'uapi-header' in self.yaml:
1220 self.uapi_header = self.yaml['uapi-header']
1222 self.uapi_header = f"linux/{self.ident_name}.h"
1223 if self.uapi_header.startswith("linux/") and self.uapi_header.endswith('.h'):
1224 self.uapi_header_name = self.uapi_header[6:-2]
1226 self.uapi_header_name = self.ident_name
1228 def resolve(self):
1229 self.resolve_up(super())
1231 self.c_name = c_lower(self.ident_name)
1232 if 'name-prefix' in self.yaml['operations']:
1233 self.op_prefix = c_upper(self.yaml['operations']['name-prefix'])
1235 self.op_prefix = c_upper(self.yaml['name'] + '-cmd-')
1236 if 'async-prefix' in self.yaml['operations']:
1237 self.async_op_prefix = c_upper(self.yaml['operations']['async-prefix'])
1239 self.async_op_prefix = self.op_prefix
1241 self.mcgrps = self.yaml.get('mcast-groups', {'list': []})
1243 self.hooks = dict()
1245 self.hooks[when] = dict()
1247 self.hooks[when][op_mode] = dict()
1248 self.hooks[when][op_mode]['set'] = set()
1249 self.hooks[when][op_mode]['list'] = []
1252 self.root_sets = dict()
1254 self.pure_nested_structs = dict()
1256 self._mark_notify()
1257 self._mock_up_events()
1259 self._load_root_sets()
1260 self._load_nested_sets()
1261 self._load_attr_use()
1262 self._load_selector_passing()
1263 self._load_hooks()
1265 self.kernel_policy = self.yaml.get('kernel-policy', 'split')
1266 if self.kernel_policy == 'global':
1267 self._load_global_policy()
1269 def new_enum(self, elem):
1270 return EnumSet(self, elem)
1272 def new_attr_set(self, elem):
1273 return AttrSet(self, elem)
1275 def new_operation(self, elem, req_value, rsp_value):
1276 return Operation(self, elem, req_value, rsp_value)
1278 def new_sub_message(self, elem):
1279 return SubMessage(self, elem)
1281 def is_classic(self):
1282 return self.proto == 'netlink-raw'
1284 def _mark_notify(self):
1285 for op in self.msgs.values():
1287 self.ops[op['notify']].mark_has_ntf()
1290 def _mock_up_events(self):
1291 for op in self.yaml['operations']['list']:
1299 def _load_root_sets(self):
1300 for op_name, op in self.msgs.items():
1314 if op['attribute-set'] not in self.root_sets:
1315 self.root_sets[op['attribute-set']] = {'request': req_attrs, 'reply': rsp_attrs}
1317 self.root_sets[op['attribute-set']]['request'].update(req_attrs)
1318 self.root_sets[op['attribute-set']]['reply'].update(rsp_attrs)
1320 def _sort_pure_types(self):
1322 pns_key_list = list(self.pure_nested_structs.keys())
1330 for _, spec in self.attr_sets[name].items():
1339 if self.pure_nested_structs[nested].recursive:
1343 struct = self.pure_nested_structs.pop(name)
1344 self.pure_nested_structs[name] = struct
1352 def _load_nested_set_nest(self, spec):
1355 if nested not in self.root_sets:
1356 if nested not in self.pure_nested_structs:
1357 self.pure_nested_structs[nested] = \
1358 Struct(self, nested, inherited=inherit,
1364 if nested in self.root_sets:
1369 self.pure_nested_structs[nested].set_inherited(inherit)
1373 def _load_nested_set_submsg(self, spec):
1376 submsg = self.sub_msgs[spec["sub-message"]]
1401 self.attr_sets[nested] = AttrSet(self, {
1403 "name-pfx": self.name + '-' + spec.name + '-',
1407 if nested not in self.pure_nested_structs:
1408 self.pure_nested_structs[nested] = Struct(self, nested, submsg=submsg)
1412 def _load_nested_sets(self):
1413 attr_set_queue = list(self.root_sets.keys())
1414 attr_set_seen = set(self.root_sets.keys())
1418 for attr, spec in self.attr_sets[a_set].items():
1420 nested = self._load_nested_set_nest(spec)
1422 nested = self._load_nested_set_submsg(spec)
1430 for root_set, rs_members in self.root_sets.items():
1431 for attr, spec in self.attr_sets[root_set].items():
1441 self.pure_nested_structs[nested].request = True
1443 self.pure_nested_structs[nested].reply = True
1446 child = self.pure_nested_structs.get(nested)
1449 self._sort_pure_types()
1452 for attr_set, struct in reversed(self.pure_nested_structs.items()):
1453 for _, spec in self.attr_sets[attr_set].items():
1465 child = self.pure_nested_structs.get(child_name)
1474 self._sort_pure_types()
1476 def _load_attr_use(self):
1477 for _, struct in self.pure_nested_structs.items():
1485 for root_set, rs_members in self.root_sets.items():
1486 for attr, spec in self.attr_sets[root_set].items():
1492 def _load_selector_passing(self):
1494 for k, v in reversed(self.pure_nested_structs.items()):
1496 for k, _ in self.root_sets.items():
1500 for _, spec in self.attr_sets[attr_set].items():
1508 child = self.pure_nested_structs.get(child_name)
1510 if selector.name in self.attr_sets[attr_set]:
1511 sel_attr = self.attr_sets[attr_set][selector.name]
1516 def _load_global_policy(self):
1519 for op_name, op in self.ops.items():
1536 self.global_policy = []
1537 self.global_policy_set = attr_set_name
1538 for attr in self.attr_sets[attr_set_name]:
1540 self.global_policy.append(attr)
1542 def _load_hooks(self):
1543 for op in self.ops.values():
1551 if name in self.hooks[when][op_mode]['set']:
1553 self.hooks[when][op_mode]['set'].add(name)
1554 self.hooks[when][op_mode]['list'].append(name)
1558 def __init__(self, cw, family, ku_space, op, op_mode, attr_set=None):
1559 self.family = family
1560 self.nl = cw.nlib
1561 self.ku_space = ku_space
1562 self.op_mode = op_mode
1563 self.op = op
1566 self.fixed_hdr_len = 'ys->family->hdr_len'
1570 self.fixed_hdr_len = f"sizeof(struct {c_lower(fixed_hdr)})"
1576 self.type_consistent = True
1577 self.type_oneside = False
1581 self.type_consistent = False
1583 self.type_consistent = False
1585 self.type_consistent = True
1586 self.type_oneside = True
1588 self.attr_set = attr_set
1589 if not self.attr_set:
1590 self.attr_set = op['attribute-set']
1592 self.type_name_conflict = False
1594 self.type_name = c_lower(op.name)
1596 self.type_name = c_lower(attr_set)
1598 self.type_name_conflict = True
1600 self.cw = cw
1602 self.struct = dict()
1610 self.struct[op_dir] = Struct(family, self.attr_set,
1614 self.struct['reply'] = Struct(family, self.attr_set,
1618 def type_empty(self, key):
1619 return len(self.struct[key].attr_list) == 0 and \
1620 self.struct['request'].fixed_header is None
1622 def needs_nlflags(self, direction):
1623 return self.op_mode == 'do' and direction == 'request' and self.family.is_classic()
1627 def __init__(self, nlib, out_file=None, overwrite=True):
1628 self.nlib = nlib
1629 self._overwrite = overwrite
1631 self._nl = False
1632 self._block_end = False
1633 self._silent_block = False
1634 self._ind = 0
1635 self._ifdef_block = None
1637 self._out = os.sys.stdout
1639 self._out = tempfile.NamedTemporaryFile('w+')
1640 self._out_file = out_file
1642 def __del__(self):
1643 self.close_out_file()
1645 def close_out_file(self):
1646 if self._out == os.sys.stdout:
1649 self._out.flush()
1650 if not self._overwrite and os.path.isfile(self._out_file):
1651 if filecmp.cmp(self._out.name, self._out_file, shallow=False):
1653 with open(self._out_file, 'w+') as out_file:
1654 self._out.seek(0)
1655 shutil.copyfileobj(self._out, out_file)
1656 self._out.close()
1657 self._out = os.sys.stdout
1663 def p(self, line, add_ind=0):
1664 if self._block_end:
1665 self._block_end = False
1669 self._out.write('\t' * self._ind + '}\n')
1671 if self._nl:
1672 self._out.write('\n')
1673 self._nl = False
1675 ind = self._ind
1678 if self._silent_block:
1680 self._silent_block = line.endswith(')') and CodeWriter._is_cond(line)
1681 self._silent_block |= line.strip() == 'else'
1686 self._out.write('\t' * ind + line + '\n')
1688 def nl(self):
1689 self._nl = True
1691 def block_start(self, line=''):
1694 self.p(line + '{')
1695 self._ind += 1
1697 def block_end(self, line=''):
1700 self._ind -= 1
1701 self._nl = False
1704 if self._block_end:
1705 self._out.write('\t' * (self._ind + 1) + '}\n')
1706 self._block_end = True
1708 self.p('}' + line)
1710 def write_doc_line(self, doc, indent=True):
1715 self.p(line)
1720 self.p(line)
1722 def write_func_prot(self, qual_ret, name, args=None, doc=None, suffix=''):
1727 self.p('/*')
1728 self.p(' * ' + doc)
1729 self.p(' */')
1737 self.p(oneline)
1742 self.p(v)
1756 self.p(v + ',')
1762 self.p(v + ')' + suffix)
1764 def write_func_lvar(self, local_vars):
1773 self.p(var)
1774 self.nl()
1776 def write_func(self, qual_ret, name, body, args=None, local_vars=None):
1777 self.write_func_prot(qual_ret=qual_ret, name=name, args=args)
1778 self.block_start()
1779 self.write_func_lvar(local_vars=local_vars)
1782 self.p(line)
1783 self.block_end()
1785 def writes_defines(self, defines):
1798 self.p(line)
1800 def write_struct_init(self, members):
1808 self.p(line)
1810 def ifdef_block(self, config):
1814 if self._ifdef_block == config_option:
1817 if self._ifdef_block:
1818 self.p('#endif /* ' + self._ifdef_block + ' */')
1820 self.p('#ifdef ' + config_option)
1821 self._ifdef_block = config_option