50     def __init__(self, name, node):  argument
51         self._node = node
52         self._name = name
53         self._size = None
54         self._align_size = None
55         self._pad_before = 0
56         self._pad_after = 0
57         self._pad_byte = 0
58         self._filename = '%s.bin' % self._name
59         self._sort = False
60         self._skip_at_start = 0
61         self._end_4gb = False
62         self._entries = OrderedDict()
64         self._ReadNode()
65         self._ReadEntries()
67     def _ReadNode(self):  argument
69         self._size = fdt_util.GetInt(self._node, 'size')
70         self._align_size = fdt_util.GetInt(self._node, 'align-size')
71         if tools.NotPowerOfTwo(self._align_size):
72             self._Raise("Alignment size %s must be a power of two" %
73                         self._align_size)
74         self._pad_before = fdt_util.GetInt(self._node, 'pad-before', 0)
75         self._pad_after = fdt_util.GetInt(self._node, 'pad-after', 0)
76         self._pad_byte = fdt_util.GetInt(self._node, 'pad-byte', 0)
77         filename = fdt_util.GetString(self._node, 'filename')
79             self._filename = filename
80         self._sort = fdt_util.GetBool(self._node, 'sort-by-pos')
81         self._end_4gb = fdt_util.GetBool(self._node, 'end-at-4gb')
82         if self._end_4gb and not self._size:
83             self._Raise("Image size must be provided when using end-at-4gb")
84         if self._end_4gb:
85             self._skip_at_start = 0x100000000 - self._size
87     def CheckSize(self):  argument
90         for entry in self._entries.values():
93         contents_size -= self._skip_at_start
95         size = self._size
97             size = self._pad_before + contents_size + self._pad_after
98             size = tools.Align(size, self._align_size)
100         if self._size and contents_size > self._size:
101             self._Raise("contents size %#x (%d) exceeds image size %#x (%d)" %
102                        (contents_size, contents_size, self._size, self._size))
103         if not self._size:
104             self._size = size
105         if self._size != tools.Align(self._size, self._align_size):
106             self._Raise("Size %#x (%d) does not match align-size %#x (%d)" %
107                   (self._size, self._size, self._align_size, self._align_size))
109     def _Raise(self, msg):  argument
117         raise ValueError("Image '%s': %s" % (self._node.path, msg))
119     def _ReadEntries(self):  argument
120         for node in self._node.subnodes:
121             self._entries[node.name] = Entry.Create(self, node)
123     def FindEntryType(self, etype):  argument
131         for entry in self._entries.values():
136     def GetEntryContents(self):  argument
145         todo = self._entries.values()
155     def _SetEntryPosSize(self, name, pos, size):  argument
163         entry = self._entries.get(name)
165             self._Raise("Unable to set pos/size for unknown entry '%s'" % name)
166         entry.SetPositionSize(self._skip_at_start + pos, size)
168     def GetEntryPositions(self):  argument
174         for entry in self._entries.values():
177                 self._SetEntryPosSize(name, *info)
179     def PackEntries(self):  argument
181         pos = self._skip_at_start
182         for entry in self._entries.values():
185     def _SortEntries(self):  argument
187         entries = sorted(self._entries.values(), key=lambda entry: entry.pos)
188         self._entries.clear()
190             self._entries[entry._node.name] = entry
192     def CheckEntries(self):  argument
194         if self._sort:
195             self._SortEntries()
198         for entry in self._entries.values():
199             if (entry.pos < self._skip_at_start or
200                 entry.pos >= self._skip_at_start + self._size):
203                             (entry.pos, entry.pos, self._skip_at_start,
204                              self._skip_at_start))
212     def ProcessEntryContents(self):  argument
217         for entry in self._entries.values():
220     def BuildImage(self):  argument
222         fname = tools.GetOutputFilename(self._filename)
224             fd.write(chr(self._pad_byte) * self._size)
226             for entry in self._entries.values():
228                 fd.seek(self._pad_before + entry.pos - self._skip_at_start)