Lines Matching refs:self
102 def __init__(self, parent: Node, name: str, *, name_is_safe: bool = False) -> None:
103 self.parent = parent
105 self.name = name
107 self.name = safe_name(name)
110 def full_name(self) -> str:
111 if self.name[0] == "_":
112 return self.parent.prefix + self.name.upper()
114 return self.parent.prefix + "_" + self.name.upper()
117 def prefix(self) -> str:
118 return self.parent.prefix
120 def add(self, element: Node) -> None:
122 % (type(self).__name__.lower(), type(element).__name__))
134 def __init__(self, name: str, prefix: str, filename: str) -> None:
136 self.prefix_field = safe_name(prefix.upper())
137 self.filename = filename
139 self._defines = []
140 self._enums = {}
141 self._structs = {}
144 def full_name(self) -> str:
145 return self.name + "_" + self.prefix_field
148 def prefix(self) -> str:
149 return self.full_name
151 def add(self, element: Node) -> None:
153 if element.name in self._enums:
156 self._enums[element.name] = element
158 if element.name in self._structs:
161 self._structs[element.name] = element
163 define_names = [d.full_name for d in self._defines]
167 self._defines.append(element)
171 def _gen_guard(self) -> str:
172 return os.path.basename(self.filename).replace(".xml", "_h").upper()
174 def emit(self) -> None:
177 "platform": self.name,
178 "guard": self._gen_guard(),
181 for define in self._defines:
186 for enum in self._enums.values():
189 for struct in self._structs.values():
190 struct.emit(self)
192 print("#endif /* %s */" % self._gen_guard())
194 def is_known_struct(self, struct_name: str) -> bool:
195 return struct_name in self._structs.keys()
197 def is_known_enum(self, enum_name: str) -> bool:
198 return enum_name in self._enums.keys()
200 def get_enum(self, enum_name: str) -> Enum:
201 return self._enums[enum_name]
203 def get_struct(self, struct_name: str) -> Struct:
204 return self._structs[struct_name]
212 def __init__(self, parent: Node, name: str) -> None:
215 self._values = {}
217 self.parent.add(self)
221 def prefix(self) -> str:
222 return self.full_name
224 def get_value(self, value_name: str) -> Value:
225 return self._values[value_name]
227 def add(self, element: Node) -> None:
231 if element.name in self._values:
234 self._values[element.name] = element
236 def emit(self) -> None:
238 if not self._values.values():
239 raise RuntimeError("Enum definition is empty. Enum: '%s'" % self.full_name)
241 print("enum %s {" % self.full_name)
242 for value in self._values.values():
252 def __init__(self, parent: Node, name: str, value: int) -> None:
255 self.value = value
257 self.parent.add(self)
259 def emit(self):
260 print(" %-36s = %6d," % (self.full_name, self.value))
270 def __init__(self, parent: Node, name: str, length: int) -> None:
273 self.length = length
274 self.size = self.length * 32
276 if self.length <= 0:
277 raise ValueError("Struct length must be greater than 0. Struct: '%s'." % self.full_name)
279 self._children = {}
281 self.parent.add(self)
284 def fields(self) -> t.List[Field]:
288 for child in self._children.values():
297 def prefix(self) -> str:
298 return self.full_name
300 def add(self, element: Node) -> None:
303 if element.name in self._children.keys():
305 % (element.name, self.full_name))
307 self._children[element.name] = element
314 self._children[element.name] = element
316 if element.name not in self._children.keys():
322 def _emit_header(self, root: Csbgen) -> None:
324 for field in (f for f in self.fields if f.default is not None):
345 print("#define %-40s\\" % (self.full_name + "_header"))
349 def _emit_helper_macros(self) -> None:
350 for field in (f for f in self.fields if f.defines):
358 def _emit_pack_function(self, root: Csbgen) -> None:
363 {""") % (self.full_name, ' ' * len(self.full_name), self.full_name))
365 group = Group(0, 1, self.size, self.fields)
375 def _emit_unpack_function(self, root: Csbgen) -> None:
380 {""") % (self.full_name, ' ' * len(self.full_name), self.full_name))
382 group = Group(0, 1, self.size, self.fields)
392 def emit(self, root: Csbgen) -> None:
393 print("#define %-33s %6d" % (self.full_name + "_length", self.length))
395 self._emit_header(root)
397 self._emit_helper_macros()
399 print("struct %s {" % self.full_name)
400 for child in self._children.values():
404 self._emit_pack_function(root)
405 self._emit_unpack_function(root)
418 def __init__(self, parent: Node, name: str, start: int, end: int, ty: str, *,
422 self.start = start
423 self.end = end
424 self.type = ty
426 self._defines = {}
428 self.parent.add(self)
430 if self.start > self.end:
432 % (self.start, self.end, self.name))
434 if self.type == "bool" and self.end != self.start:
435 raise ValueError("Bool field can only be 1 bit long. Field '%s'" % self.name)
438 if not self.is_builtin_type:
440 self.default = safe_name(default)
442 self.default = num_from_str(default)
444 self.default = None
447 if self.type != "address":
448 raise RuntimeError("Only address fields can have a shift attribute. Field: '%s'" % self.name)
450 self.shift = int(shift)
452 Define(self, "ALIGNMENT", 2**self.shift)
454 if self.type == "address":
455 raise RuntimeError("Field of address type requires a shift attribute. Field '%s'" % self.name)
457 self.shift = None
460 def defines(self) -> t.Iterator[Define]:
461 return self._defines.values()
465 def prefix(self) -> str:
466 return self.full_name
469 def is_builtin_type(self) -> bool:
471 return self.type in builtins
473 def _get_c_type(self, root: Csbgen) -> str:
474 if self.type == "address":
476 elif self.type == "bool":
478 elif self.type == "float":
480 elif self.type == "offset":
482 elif self.type == "int":
484 elif self.type == "uint":
485 if self.end - self.start < 32:
487 elif self.end - self.start < 64:
491 % (self.end - self.start, self.name))
492 elif root.is_known_struct(self.type):
493 return "struct " + self.type
494 elif root.is_known_enum(self.type):
495 return "enum " + root.get_enum(self.type).full_name
496 raise RuntimeError("Unknown type. Type: '%s', Field: '%s'" % (self.type, self.name))
498 def add(self, element: Node) -> None:
499 if self.type == "mbo":
501 % (type(element).__name__, self.name))
504 if element.name in self._defines:
507 self._defines[element.name] = element
511 def emit(self, root: Csbgen) -> None:
512 if self.type == "mbo":
515 print(" %-36s %s;" % (self._get_c_type(root), self.name))
523 def __init__(self, parent: Node, name: str, value: int) -> None:
526 self.value = value
528 self.parent.add(self)
530 def emit(self) -> None:
531 print("#define %-40s %d" % (self.full_name, self.value))
541 def __init__(self, parent: Node, name: str, ty: str) -> None:
544 self.type = ty
545 if not Condition._is_valid_type(self.type):
546 raise RuntimeError("Unknown type: '%s'" % self.name)
548 self._children = {}
553 self._child_branch = None
555 self.parent.add(self)
558 def fields(self) -> t.List[Field]:
567 for child in self._children.values():
573 if self._child_branch is not None:
574 fields += self._child_branch.fields
583 def _is_compatible_child_branch(self, branch):
585 idx = types.index(self.type)
587 self.type == "elif" and branch.type == "elif")
589 def _add_branch(self, branch: Condition) -> None:
590 if branch.type == "elif" and branch.name == self.name:
593 if not self._is_compatible_child_branch(branch):
596 self._child_branch = branch
608 def _top_branch_name(self) -> str:
609 if self.type == "if":
610 return self.name
613 assert isinstance(self.parent, Condition)
614 return self.parent._top_branch_name()
616 def add(self, element: Node) -> None:
618 if element.name in self._children.keys():
621 self._children[element.name] = element
623 if element.type == "elif" or self._top_branch_name() == element.name:
624 self._add_branch(element)
650 if element.name == self.name:
653 self._children[element.name] = element
657 def emit(self, root: Csbgen) -> None:
658 if self.type == "if":
659 print("/* if %s is supported use: */" % self.name)
660 elif self.type == "elif":
661 print("/* else if %s is supported use: */" % self.name)
662 elif self.type == "else":
663 print("/* else %s is not-supported use: */" % self.name)
664 elif self.type == "endif":
665 print("/* endif %s */" % self.name)
670 for child in self._children.values():
673 self._child_branch.emit(root)
684 def __init__(self, start: int, count: int, size: int, fields) -> None:
685 self.start = start
686 self.count = count
687 self.size = size
688 self.fields = fields
697 def __init__(self) -> None:
698 self.size = 32
699 self.fields = []
700 self.addresses = []
702 def collect_dwords(self, dwords: t.Dict[int, Group.DWord], start: int) -> None:
703 for field in self.fields:
706 dwords[index] = self.DWord()
729 def collect_dwords_and_length(self) -> t.Tuple[t.Dict[int, Group.DWord], int]:
731 self.collect_dwords(dwords, 0)
737 if self.size > 0:
738 length = self.size // 32
746 def emit_pack_function(self, root: Csbgen, dwords: t.Dict[int, Group.DWord], length: int) -> None:
770 % (self.parser.gen_prefix(safe_name(field.type)), index, field.name))
781 % (self.parser.gen_prefix(safe_name(field.type)), index, field_index, field.name))
863 def emit_unpack_function(self, root: Csbgen, dwords: t.Dict[int, Group.DWord], length: int) -> None:
938 def __init__(self) -> None:
939 self.parser = expat.ParserCreate()
940 self.parser.StartElementHandler = self.start_element
941 self.parser.EndElementHandler = self.end_element
943 self.context = []
944 self.filename = ""
946 def start_element(self, name: str, attrs: t.Dict[str, str]) -> None:
948 if self.context:
954 csbgen = Csbgen(attrs["name"], attrs["prefix"], self.filename)
955 self.context.append(csbgen)
958 parent = self.context[-1]
962 self.context.append(struct)
975 self.context.append(field)
979 self.context.append(enum)
983 self.context.append(value)
987 self.context.append(define)
1002 self.context.pop()
1009 self.context.append(condition)
1014 def end_element(self, name: str) -> None:
1016 element = self.context[-1]
1022 element = self.context.pop()
1047 def parse(self, filename: str) -> None:
1049 self.filename = filename
1050 self.parser.ParseFile(file)