94     def __init__(self, name: str, parent: Optional["Node"], dt: "DT", filename: str, lineno: int):  argument
100         self._name = name
101         self._filename = filename
102         self._lineno = lineno
103         self.props: dict[str, Property] = {}
104         self.nodes: dict[str, Node] = {}
105         self.labels: list[str] = []
106         self.parent = parent
107         self.dt = dt
109         self._omit_if_no_ref = False
110         self._is_referenced = False
121     def name(self) -> str:  argument
127         return self._name
130     def lineno(self) -> int:  argument
134         return self._lineno
137     def filename(self) -> str:  argument
141         return self._filename
144     def unit_addr(self) -> str:  argument
148         return self.name.partition("@")[2]
151     def path(self) -> str:  argument
159         cur = self
166     def node_iter(self) -> Iterable['Node']:  argument
177         yield self
178         for node in self.nodes.values():
181     def _get_prop(self, name: str) -> 'Property':  argument
185         prop = self.props.get(name)
187             prop = Property(self, name)
188             self.props[name] = prop
191     def _del(self) -> None:  argument
195         if self.parent is None:
196             self.nodes.clear()
197             self.props.clear()
199         self.parent.nodes.pop(self.name)  # type: ignore
201     def __str__(self):  argument
206         s = "".join(label + ": " for label in self.labels)
210         for prop in self.props.values():
213         for child in self.nodes.values():
220     def __repr__(self):  argument
332     def __init__(self, node: Node, name: str):  argument
338         self.name = name
339         self.filename = ""
340         self.lineno = -1
341         self.value = b""
342         self.labels: list[str] = []
345         self.offset_labels: dict[str, int] = {}
346         self.node: Node = node
348         self._label_offset_lst: list[tuple[str, int]] = []
356         self._markers: list[list] = []
359     def type(self) -> Type:  argument
365         types = [marker[1] for marker in self._markers
375             return Type.NUM if len(self.value) == 4 else Type.NUMS
388             and len(self.value) == 4):
392             if len(self.value) == 4*types.count(_MarkerType.PHANDLE):
400     def to_num(self, signed=False) -> int:  argument
413         if self.type is not Type.NUM:
418         return int.from_bytes(self.value, "big", signed=signed)
420     def to_nums(self, signed=False) -> list[int]:  argument
433         if self.type not in (Type.NUM, Type.NUMS):
438         return [int.from_bytes(self.value[i:i + 4], "big", signed=signed)
439                 for i in range(0, len(self.value), 4)]
441     def to_bytes(self) -> bytes:  argument
451         if self.type is not Type.BYTES:
456         return self.value
458     def to_string(self) -> str:  argument
470         if self.type is not Type.STRING:
476             ret = self.value.decode("utf-8")[:-1]  # Strip null
484     def to_strings(self) -> list[str]:  argument
495         if self.type not in (Type.STRING, Type.STRINGS):
501             ret = self.value.decode("utf-8").split("\0")[:-1]
509     def to_node(self) -> Node:  argument
518         if self.type is not Type.PHANDLE:
523         return self.node.dt.phandle2node[int.from_bytes(self.value, "big")]
525     def to_nodes(self) -> list[Node]:  argument
538             if self.type in (Type.PHANDLE, Type.PHANDLES):
541             return self.type is Type.NUMS and not self.value
548         return [self.node.dt.phandle2node[int.from_bytes(self.value[i:i + 4],
550                 for i in range(0, len(self.value), 4)]
552     def to_path(self) -> Node:  argument
564         if self.type not in (Type.PATH, Type.STRING):
571             path = self.value.decode("utf-8")[:-1]
578             ret = self.node.dt.get_node(path)
586     def __str__(self):  argument
587         s = "".join(label + ": " for label in self.labels) + self.name
588         if not self.value:
593         for i, (pos, marker_type, ref) in enumerate(self._markers):
594             if i < len(self._markers) - 1:
595                 next_marker = self._markers[i + 1]
600             end = next_marker[0] if next_marker else len(self.value)
605                 if end != len(self.value):
609                 if end != len(self.value):
626                     num = int.from_bytes(self.value[pos:pos + elm_size],
641                     if pos != len(self.value):
646     def __repr__(self):  argument
654     def _add_marker(self, marker_type: _MarkerType, data: Any = None):  argument
663         self._markers.append([len(self.value), marker_type, data])
668             self.value += b"\0\0\0\0"
712     def __repr__(self):  argument
713         id_repr = _T(self.id).name
764     def __init__(self, filename: Optional[str], include_path: Iterable[str] = (),  argument
785         self._root: Optional[Node] = None
786         self.alias2node: dict[str, Node] = {}
787         self.label2node: dict[str, Node] = {}
788         self.label2prop: dict[str, Property] = {}
789         self.label2prop_offset: dict[str, tuple[Property, int]] = {}
790         self.phandle2node: dict[int, Node] = {}
791         self.memreserves: list[tuple[set[str], int, int]] = []
792         self.filename = filename
794         self._force = force
797             self._parse_file(filename, include_path)
799             self._include_path: list[str] = []
802     def root(self) -> Node:  argument
809         return self._root       # type: ignore
811     def get_node(self, path: str) -> Node:  argument
838             return _root_and_path_to_node(self.root, path, path)
842         if alias not in self.alias2node:
846         return _root_and_path_to_node(self.alias2node[alias], rest, path)
848     def has_node(self, path: str) -> bool:  argument
853             self.get_node(path)
858     def move_node(self, node: Node, new_path: str):  argument
870         if node is self.root:
873         if self.has_node(new_path):
892         if not self.has_node(new_parent_path):
895         new_parent = self.get_node(new_parent_path)
905     def node_iter(self) -> Iterable[Node]:  argument
916         yield from self.root.node_iter()
918     def __str__(self):  argument
925         if self.memreserves:
926             for labels, address, offset in self.memreserves:
933         return s + str(self.root)
935     def __repr__(self):  argument
940         if self.filename:
945     def __deepcopy__(self, memo):  argument
952         ret = DT(None, (), self._force)
960             for node in self.node_iter()
970         for node in self.node_iter():
1008             original = getattr(self, attr_name)
1020         for label, prop in self.label2prop.items():
1027         for label, prop_offset in self.label2prop_offset.items():
1036             for memreserve in self.memreserves
1039         ret.filename = self.filename
1047     def _parse_file(self, filename: str, include_path: Iterable[str]):  argument
1048         self._include_path = list(include_path)
1051             self._file_contents = f.read()
1053         self._tok_i = self._tok_end_i = 0
1054         self._filestack: list[_FileStackElt] = []
1056         self._lexer_state: int = _DEFAULT
1057         self._saved_token: Optional[_Token] = None
1059         self._lineno: int = 1
1061         self._parse_header()
1062         self._parse_memreserves()
1063         self._parse_dt()
1065         self._register_phandles()
1066         self._fixup_props()
1067         self._register_aliases()
1068         self._remove_unreferenced()
1069         self._register_labels()
1071     def _parse_header(self):  argument
1077         while self._peek_token().id == _T.DTS_V1:
1079             self._next_token()
1080             self._expect_token(";")
1082             if self._peek_token().id == _T.PLUGIN:
1083                 self._parse_error("/plugin/ is not supported")
1086             self._parse_error("expected '/dts-v1/;' at start of file")
1088     def _parse_memreserves(self):  argument
1094             while self._peek_token().id == _T.LABEL:
1095                 _append_no_dup(labels, self._next_token().val)
1097             if self._peek_token().id == _T.MEMRESERVE:
1098                 self._next_token()
1099                 self.memreserves.append(
1100                     (labels, self._eval_prim(), self._eval_prim()))
1101                 self._expect_token(";")
1103                 self._parse_error("expected /memreserve/ after labels at "
1108     def _parse_dt(self):  argument
1112             tok = self._next_token()
1116                 if not self._root:
1117                     self._root = Node(
1118                         name="/", parent=None, dt=self, filename=self.filename, lineno=self._lineno
1120                 self._parse_node(self.root)
1128                     tok = self._next_token()
1130                         self._parse_error("expected label reference (&foo)")
1135                     node = self._ref2node(tok.val)
1137                     self._parse_error(e)
1138                 self._parse_node(node)
1144                 self._next_ref2node()._del()
1145                 self._expect_token(";")
1148                 self._next_ref2node()._omit_if_no_ref = True
1149                 self._expect_token(";")
1152                 if not self._root:
1153                     self._parse_error("no root node defined")
1157                 self._parse_error("expected '/' or label reference (&foo)")
1159     def _parse_node(self, node):  argument
1166         self._expect_token("{")
1168             labels, omit_if_no_ref = self._parse_propnode_labels()
1169             tok = self._next_token()
1172                 if self._peek_token().val == "{":
1180                             self._parse_error(f'{child.path}: duplicate node name')
1185                             dt=self,
1186                             filename=self.filename,
1187                             lineno=self._lineno,
1198                     self._parse_node(child)
1204                         self._parse_error(
1208                     prop.filename = self.filename
1209                     prop.lineno = self._lineno
1211                     if self._check_token("="):
1212                         self._parse_assignment(prop)
1213                     elif not self._check_token(";"):
1215                         self._parse_error("expected '{', '=', or ';'")
1221                 tok2 = self._next_token()
1223                     self._parse_error("expected node name")
1226                 self._expect_token(";")
1229                 tok2 = self._next_token()
1231                     self._parse_error("expected property name")
1233                 self._expect_token(";")
1236                 self._expect_token(";")
1240                 self._parse_error("expected node name, property name, or '}'")
1242     def _parse_propnode_labels(self):  argument
1250             tok = self._peek_token()
1257                 self._parse_error("expected node or property name")
1261             self._next_token()
1263     def _parse_assignment(self, prop):  argument
1276             self._parse_value_labels(prop)
1278             tok = self._next_token()
1281                 self._parse_cells(prop, 4)
1284                 n_bits = self._expect_num()
1286                     self._parse_error("expected 8, 16, 32, or 64")
1287                 self._expect_token("<")
1288                 self._parse_cells(prop, n_bits//8)
1291                 self._parse_bytes(prop)
1295                 prop.value += self._unescape(tok.val.encode("utf-8")) + b"\0"
1301                 self._parse_incbin(prop)
1304                 self._parse_error("malformed value")
1307             self._parse_value_labels(prop)
1309             tok = self._next_token()
1314             self._parse_error("expected ';' or ','")
1316     def _parse_cells(self, prop, n_bytes):  argument
1322             tok = self._peek_token()
1324                 self._next_token()
1326                     self._parse_error("phandle references are only allowed in "
1332                 self._next_token()
1334             elif self._check_token(">"):
1339                 num = self._eval_prim()
1347                         self._parse_error(
1350     def _parse_bytes(self, prop):  argument
1356             tok = self._next_token()
1367                 self._parse_error("expected two-digit byte or ']'")
1369     def _parse_incbin(self, prop):  argument
1380         self._expect_token("(")
1382         tok = self._next_token()
1384             self._parse_error("expected quoted filename")
1387         tok = self._next_token()
1389             offset = self._eval_prim()
1390             self._expect_token(",")
1391             size = self._eval_prim()
1392             self._expect_token(")")
1395                 self._parse_error("expected ',' or ')'")
1399             with self._open(filename, "rb") as f:
1406             self._parse_error(f"could not read '{filename}': {e}")
1408     def _parse_value_labels(self, prop):  argument
1413             tok = self._peek_token()
1417             self._next_token()
1419     def _node_phandle(self, node):  argument
1435             while phandle_i in self.phandle2node:
1437             self.phandle2node[phandle_i] = node
1446     def _eval_prim(self):  argument
1447         tok = self._peek_token()
1449             return self._next_token().val
1451         tok = self._next_token()
1453             self._parse_error("expected number or parenthesized expression")
1454         val = self._eval_ternary()
1455         self._expect_token(")")
1458     def _eval_ternary(self):  argument
1459         val = self._eval_or()
1460         if self._check_token("?"):
1461             if_val = self._eval_ternary()
1462             self._expect_token(":")
1463             else_val = self._eval_ternary()
1467     def _eval_or(self):  argument
1468         val = self._eval_and()
1469         while self._check_token("||"):
1470             val = 1 if self._eval_and() or val else 0
1473     def _eval_and(self):  argument
1474         val = self._eval_bitor()
1475         while self._check_token("&&"):
1476             val = 1 if self._eval_bitor() and val else 0
1479     def _eval_bitor(self):  argument
1480         val = self._eval_bitxor()
1481         while self._check_token("|"):
1482             val |= self._eval_bitxor()
1485     def _eval_bitxor(self):  argument
1486         val = self._eval_bitand()
1487         while self._check_token("^"):
1488             val ^= self._eval_bitand()
1491     def _eval_bitand(self):  argument
1492         val = self._eval_eq()
1493         while self._check_token("&"):
1494             val &= self._eval_eq()
1497     def _eval_eq(self):  argument
1498         val = self._eval_rela()
1500             if self._check_token("=="):
1501                 val = 1 if val == self._eval_rela() else 0
1502             elif self._check_token("!="):
1503                 val = 1 if val != self._eval_rela() else 0
1507     def _eval_rela(self):  argument
1508         val = self._eval_shift()
1510             if self._check_token("<"):
1511                 val = 1 if val < self._eval_shift() else 0
1512             elif self._check_token(">"):
1513                 val = 1 if val > self._eval_shift() else 0
1514             elif self._check_token("<="):
1515                 val = 1 if val <= self._eval_shift() else 0
1516             elif self._check_token(">="):
1517                 val = 1 if val >= self._eval_shift() else 0
1521     def _eval_shift(self):  argument
1522         val = self._eval_add()
1524             if self._check_token("<<"):
1525                 val <<= self._eval_add()
1526             elif self._check_token(">>"):
1527                 val >>= self._eval_add()
1531     def _eval_add(self):  argument
1532         val = self._eval_mul()
1534             if self._check_token("+"):
1535                 val += self._eval_mul()
1536             elif self._check_token("-"):
1537                 val -= self._eval_mul()
1541     def _eval_mul(self):  argument
1542         val = self._eval_unary()
1544             if self._check_token("*"):
1545                 val *= self._eval_unary()
1546             elif self._check_token("/"):
1547                 denom = self._eval_unary()
1549                     self._parse_error("division by zero")
1551             elif self._check_token("%"):
1552                 denom = self._eval_unary()
1554                     self._parse_error("division by zero")
1559     def _eval_unary(self):  argument
1560         if self._check_token("-"):
1561             return -self._eval_unary()
1562         if self._check_token("~"):
1563             return ~self._eval_unary()
1564         if self._check_token("!"):
1565             return 0 if self._eval_unary() else 1
1566         return self._eval_prim()
1572     def _check_token(self, val):  argument
1573         if self._peek_token().val == val:
1574             self._next_token()
1578     def _peek_token(self):  argument
1579         if not self._saved_token:
1580             self._saved_token = self._next_token()
1581         return self._saved_token
1583     def _next_token(self):  argument
1584         if self._saved_token:
1585             tmp = self._saved_token
1586             self._saved_token = None
1592             match = _token_re.match(self._file_contents, self._tok_end_i)
1596                     val = self._unescape(match.group(tok_id).encode("utf-8"))
1598                         self._parse_error("character literals must be length 1")
1603             elif self._lexer_state is _DEFAULT:
1604                 match = _num_re.match(self._file_contents, self._tok_end_i)
1613             elif self._lexer_state is _EXPECT_PROPNODENAME:
1614                 match = _propnodename_re.match(self._file_contents,
1615                                                self._tok_end_i)
1619                     self._lexer_state = _DEFAULT
1622                 match = _byte_re.match(self._file_contents, self._tok_end_i)
1628                 match = _misc_re.match(self._file_contents, self._tok_end_i)
1633                     self._tok_i = self._tok_end_i
1641             self._tok_i = match.start()
1642             self._tok_end_i = match.end()
1645                 self._lineno += tok_val.count("\n")
1652                 self._lineno += tok_val.count("\n")
1656                 self._enter_file(filename)
1661                 self._lineno = int(tok_val.split()[0]) - 1
1662                 self.filename = tok_val[tok_val.find('"') + 1:-1]
1666                 if self._filestack:
1667                     self._leave_file()
1676                 self._lexer_state = _EXPECT_PROPNODENAME
1679                 self._lexer_state = _EXPECT_BYTE
1682                 self._lexer_state = _DEFAULT
1686     def _expect_token(self, tok_val):  argument
1690         tok = self._next_token()
1692             self._parse_error(f"expected '{tok_val}', not '{tok.val}'")
1696     def _expect_num(self):  argument
1699         tok = self._next_token()
1701             self._parse_error("expected number")
1704     def _parse_error(self, s):  argument
1707         column = self._tok_i - self._file_contents.rfind("\n", 0,
1708                                                          self._tok_i + 1)
1712     def _enter_file(self, filename):  argument
1716         self._filestack.append(
1717             _FileStackElt(self.filename, self._lineno,
1718                           self._file_contents, self._tok_end_i))
1721         filename = self._unescape(filename.encode("utf-8"))
1725             self._parse_error("filename is not valid UTF-8")
1727         with self._open(filename, encoding="utf-8") as f:
1729                 self._file_contents = f.read()
1731                 self._parse_error(e)
1734         for i, parent in enumerate(self._filestack):
1736                 self._parse_error("recursive /include/:\n" + " ->\n".join(
1738                      for parent in self._filestack[i:]] +
1741         self.filename = f.name
1742         self._lineno = 1
1743         self._tok_end_i = 0
1745     def _leave_file(self):  argument
1748         self.filename, self._lineno, self._file_contents, self._tok_end_i = (
1749             self._filestack.pop())
1751     def _next_ref2node(self):  argument
1756         label = self._next_token()
1758             self._parse_error(
1761             return self._ref2node(label.val)
1763             self._parse_error(e)
1765     def _ref2node(self, s):  argument
1774             return _root_and_path_to_node(self.root, path, path)
1780         for node in self.node_iter():
1790     def _register_phandles(self):  argument
1796         for node in self.node_iter():
1808                         if self._ref2node(ref) is node:
1828                     if phandle_val in self.phandle2node:
1833                     self.phandle2node[phandle_val] = node
1835     def _fixup_props(self):  argument
1841         for node in self.node_iter():
1872                             ref_node = self._ref2node(ref)
1882                             res += self._node_phandle(ref_node)
1892     def _register_aliases(self):  argument
1902         aliases = self.root.nodes.get("aliases")
1915                     if self._force:
1919         self.alias2node = alias2node
1921     def _remove_unreferenced(self):  argument
1927         for node in tuple(self.node_iter()):
1931     def _register_labels(self):  argument
1938         for node in self.node_iter():
1941                 self.label2node[label] = node
1946                     self.label2prop[label] = prop
1950                     self.label2prop_offset[label] = (prop, offset)
1980     def _unescape(self, b):  argument
2000                     self._parse_error("octal escape out of range (> 255)")
2011     def _open(self, filename, mode="r", **kwargs):  argument
2021         dirname = os.path.dirname(self.filename)
2026                 self._parse_error(e)
2029             for path in self._include_path:
2034                         self._parse_error(e)
2037             self._parse_error(f"'{filename}' could not be found")