Lines Matching refs:self
75 def __init__(self, section, etype, node, name_prefix=''): argument
80 self.section = section
81 self.etype = etype
82 self._node = node
83 self.name = node and (name_prefix + node.name) or 'none'
84 self.offset = None
85 self.size = None
86 self.pre_reset_size = None
87 self.uncomp_size = None
88 self.data = None
89 self.uncomp_data = None
90 self.contents_size = 0
91 self.align = None
92 self.align_size = None
93 self.align_end = None
94 self.pad_before = 0
95 self.pad_after = 0
96 self.offset_unset = False
97 self.image_pos = None
98 self._expand_size = False
99 self.compress = 'none'
100 self.missing = False
101 self.external = False
102 self.allow_missing = False
157 def ReadNode(self): argument
164 if 'pos' in self._node.props:
165 self.Raise("Please use 'offset' instead of 'pos'")
166 self.offset = fdt_util.GetInt(self._node, 'offset')
167 self.size = fdt_util.GetInt(self._node, 'size')
168 self.orig_offset = fdt_util.GetInt(self._node, 'orig-offset')
169 self.orig_size = fdt_util.GetInt(self._node, 'orig-size')
170 if self.GetImage().copy_to_orig:
171 self.orig_offset = self.offset
172 self.orig_size = self.size
176 self.image_pos = fdt_util.GetInt(self._node, 'image-pos')
177 self.uncomp_size = fdt_util.GetInt(self._node, 'uncomp-size')
179 self.align = fdt_util.GetInt(self._node, 'align')
180 if tools.NotPowerOfTwo(self.align):
182 (self._node.path, self.align))
183 self.pad_before = fdt_util.GetInt(self._node, 'pad-before', 0)
184 self.pad_after = fdt_util.GetInt(self._node, 'pad-after', 0)
185 self.align_size = fdt_util.GetInt(self._node, 'align-size')
186 if tools.NotPowerOfTwo(self.align_size):
187 self.Raise("Alignment size %s must be a power of two" %
188 self.align_size)
189 self.align_end = fdt_util.GetInt(self._node, 'align-end')
190 self.offset_unset = fdt_util.GetBool(self._node, 'offset-unset')
191 self.expand_size = fdt_util.GetBool(self._node, 'expand-size')
192 self.missing_msg = fdt_util.GetString(self._node, 'missing-msg')
195 self.compress = fdt_util.GetString(self._node, 'compress', 'none')
197 def GetDefaultFilename(self): argument
200 def GetFdts(self): argument
213 def ExpandEntries(self): argument
216 def AddMissingProperties(self, have_image_pos): argument
226 if not prop in self._node.props:
227 state.AddZeroProp(self._node, prop)
228 if have_image_pos and 'image-pos' not in self._node.props:
229 state.AddZeroProp(self._node, 'image-pos')
230 if self.GetImage().allow_repack:
231 if self.orig_offset is not None:
232 state.AddZeroProp(self._node, 'orig-offset', True)
233 if self.orig_size is not None:
234 state.AddZeroProp(self._node, 'orig-size', True)
236 if self.compress != 'none':
237 state.AddZeroProp(self._node, 'uncomp-size')
238 err = state.CheckAddHashProp(self._node)
240 self.Raise(err)
242 def SetCalculatedProperties(self): argument
244 state.SetInt(self._node, 'offset', self.offset)
245 state.SetInt(self._node, 'size', self.size)
246 base = self.section.GetRootSkipAtStart() if self.section else 0
247 if self.image_pos is not None:
248 state.SetInt(self._node, 'image-pos', self.image_pos - base)
249 if self.GetImage().allow_repack:
250 if self.orig_offset is not None:
251 state.SetInt(self._node, 'orig-offset', self.orig_offset, True)
252 if self.orig_size is not None:
253 state.SetInt(self._node, 'orig-size', self.orig_size, True)
254 if self.uncomp_size is not None:
255 state.SetInt(self._node, 'uncomp-size', self.uncomp_size)
256 state.CheckSetHashValue(self._node, self.GetData)
258 def ProcessFdt(self, fdt): argument
272 def SetPrefix(self, prefix): argument
279 self.name = prefix + self.name
281 def SetContents(self, data): argument
289 self.data = data
290 self.contents_size = len(self.data)
292 def ProcessContentsUpdate(self, data): argument
306 if state.AllowEntryExpansion() and new_size > self.contents_size:
309 elif state.AllowEntryContraction() and new_size < self.contents_size:
314 if new_size > self.contents_size:
315 self.Raise('Cannot update entry size from %d to %d' %
316 (self.contents_size, new_size))
319 if size_ok and new_size < self.contents_size:
320 data += tools.GetBytes(0, self.contents_size - new_size)
324 self._node.path, ToHex(self.contents_size),
326 self.SetContents(data)
329 def ObtainContents(self): argument
339 def ResetForPack(self): argument
341 self.Detail('ResetForPack: offset %s->%s, size %s->%s' %
342 (ToHex(self.offset), ToHex(self.orig_offset),
343 ToHex(self.size), ToHex(self.orig_size)))
344 self.pre_reset_size = self.size
345 self.offset = self.orig_offset
346 self.size = self.orig_size
348 def Pack(self, offset): argument
366 self.Detail('Packing: offset=%s, size=%s, content_size=%x' %
367 (ToHex(self.offset), ToHex(self.size),
368 self.contents_size))
369 if self.offset is None:
370 if self.offset_unset:
371 self.Raise('No offset set with offset-unset: should another '
373 self.offset = tools.Align(offset, self.align)
374 needed = self.pad_before + self.contents_size + self.pad_after
375 needed = tools.Align(needed, self.align_size)
376 size = self.size
379 new_offset = self.offset + size
380 aligned_offset = tools.Align(new_offset, self.align_end)
382 size = aligned_offset - self.offset
385 if not self.size:
386 self.size = size
388 if self.size < needed:
389 self.Raise("Entry contents size is %#x (%d) but entry size is "
390 "%#x (%d)" % (needed, needed, self.size, self.size))
394 if self.size != tools.Align(self.size, self.align_size):
395 self.Raise("Size %#x (%d) does not match align-size %#x (%d)" %
396 (self.size, self.size, self.align_size, self.align_size))
397 if self.offset != tools.Align(self.offset, self.align):
398 self.Raise("Offset %#x (%d) does not match align %#x (%d)" %
399 (self.offset, self.offset, self.align, self.align))
400 self.Detail(' - packed: offset=%#x, size=%#x, content_size=%#x, next_offset=%x' %
401 (self.offset, self.size, self.contents_size, new_offset))
405 def Raise(self, msg): argument
407 raise ValueError("Node '%s': %s" % (self._node.path, msg))
409 def Detail(self, msg): argument
411 tag = "Node '%s'" % self._node.path
414 def GetEntryArgsOrProps(self, props, required=False): argument
427 if hasattr(self, python_prop):
428 value = getattr(self, python_prop)
432 value = self.GetArg(prop.name, prop.datatype)
437 self.GetImage().MissingArgs(self, missing)
440 def GetPath(self): argument
446 return self._node.path
448 def GetData(self): argument
455 self.Detail('GetData: size %s' % ToHexSize(self.data))
456 return self.data
458 def GetPaddedData(self, data=None): argument
471 data = self.GetData()
472 return self.section.GetPaddedDataForEntry(self, data)
474 def GetOffsets(self): argument
492 def SetOffsetSize(self, offset, size): argument
500 self.offset = offset
502 self.size = size
504 def SetImagePos(self, image_pos): argument
510 self.image_pos = image_pos + self.offset
512 def ProcessContents(self): argument
530 def WriteSymbols(self, section): argument
538 def CheckEntries(self): argument
559 def WriteMap(self, fd, indent): argument
566 self.WriteMapLine(fd, indent, self.name, self.offset, self.size,
567 self.image_pos)
569 def GetEntries(self): argument
578 def GetArg(self, name, datatype=str): argument
600 self.Raise("Cannot convert entry arg '%s' (value '%s') to integer" %
608 value = fdt_util.GetDatatype(self._node, name, datatype)
661 def GetUniqueName(self): argument
670 name = self.name
671 node = self._node
679 def ExpandToLimit(self, limit): argument
681 if self.offset + self.size < limit:
682 self.size = limit - self.offset
685 if not self.ObtainContents():
686 self.Raise('Cannot obtain contents when expanding entry')
688 def HasSibling(self, name): argument
695 return name in self.section.GetEntries()
697 def GetSiblingImagePos(self, name): argument
704 if not self.HasSibling(name):
706 return self.section.GetEntries()[name].image_pos
728 def ListEntries(self, entries, indent): argument
737 self.AddEntryInfo(entries, indent, self.name, self.etype, self.size,
738 self.image_pos, self.uncomp_size, self.offset, self)
740 def ReadData(self, decomp=True): argument
756 (self.section.GetPath(), self.GetPath()))
757 data = self.section.ReadChildData(self, decomp)
760 def ReadChildData(self, child, decomp=True): argument
776 def LoadData(self, decomp=True): argument
777 data = self.ReadData(decomp)
778 self.contents_size = len(data)
779 self.ProcessContentsUpdate(data)
780 self.Detail('Loaded data size %x' % len(data))
782 def GetImage(self): argument
788 return self.section.GetImage()
790 def WriteData(self, data, decomp=True): argument
807 if self.size is not None:
808 self.contents_size = self.size
810 self.contents_size = self.pre_reset_size
811 ok = self.ProcessContentsUpdate(data)
812 self.Detail('WriteData: size=%x, ok=%s' % (len(data), ok))
813 section_ok = self.section.WriteChildData(self)
816 def WriteChildData(self, child): argument
834 def GetSiblingOrder(self): argument
841 entries = list(self.section.GetEntries().values())
843 if self == entries[0]:
845 elif self == entries[-1]:
849 def SetAllowMissing(self, allow_missing): argument
858 def CheckMissing(self, missing_list): argument
866 if self.missing:
867 missing_list.append(self)
869 def GetAllowMissing(self): argument
875 return self.allow_missing
877 def GetHelpTags(self): argument
883 return list(filter(None, [self.missing_msg, self.name, self.etype]))
885 def CompressData(self, indata): argument
894 self.uncomp_data = indata
895 if self.compress != 'none':
896 self.uncomp_size = len(indata)
897 data = tools.Compress(indata, self.compress)