Lines Matching refs:self
214 def __init__(self, enabled=True): argument
217 self.enabled = enabled
219 def reset(self): argument
221 if self.enabled:
225 def bold(self, on=True): argument
227 if self.enabled:
234 def italics(self, on=True): argument
236 if self.enabled:
243 def underline(self, on=True): argument
245 if self.enabled:
252 def inverse(self, on=True): argument
254 if self.enabled:
261 def strike(self, on=True): argument
263 if self.enabled:
270 def black(self, fg=True): argument
273 if self.enabled:
280 def red(self, fg=True): argument
283 if self.enabled:
290 def green(self, fg=True): argument
293 if self.enabled:
300 def yellow(self, fg=True): argument
303 if self.enabled:
310 def blue(self, fg=True): argument
313 if self.enabled:
320 def magenta(self, fg=True): argument
323 if self.enabled:
330 def cyan(self, fg=True): argument
333 if self.enabled:
340 def white(self, fg=True): argument
343 if self.enabled:
350 def default(self, fg=True): argument
353 if self.enabled:
425 def __init__(self, c=0, s=0): argument
426 self.cpu = c
427 self.sub = s
429 def set_cpu_type(self, c): argument
430 self.cpu = c
432 def set_cpu_subtype(self, s): argument
433 self.sub = s
435 def set_arch(self, c, s): argument
436 self.cpu = c
437 self.sub = s
439 def is_64_bit(self): argument
440 return (self.cpu & CPU_ARCH_ABI64) != 0
479 def __str__(self): argument
480 for info in self.cpu_infos:
481 if self.cpu == info[1] and (self.sub & 0x00ffffff) == info[2]:
483 return "{0}.{1}".format(self.cpu, self.sub)
496 def __init__(self, initial_value=0): argument
497 dict_utils.Enum.__init__(self, initial_value, self.enum)
499 def is_skinny_mach_file(self): argument
500 …return self.value == MH_MAGIC or self.value == MH_CIGAM or self.value == MH_MAGIC_64 or self.value…
502 def is_universal_mach_file(self): argument
503 return self.value == FAT_MAGIC or self.value == FAT_CIGAM
505 def unpack(self, data): argument
507 self.value = data.get_uint32()
509 def get_byte_order(self): argument
510 if self.value == MH_CIGAM or self.value == MH_CIGAM_64 or self.value == FAT_CIGAM:
515 def is_64_bit(self): argument
516 return self.value == MH_MAGIC_64 or self.value == MH_CIGAM_64
518 def __init__(self): argument
519 self.magic = Mach.Magic()
520 self.content = None
521 self.path = None
523 def extract(self, path, extractor): argument
524 self.path = path
525 self.unpack(extractor)
527 def parse(self, path): argument
528 self.path = path
530 f = open(self.path)
532 self.unpack(file_extractor)
543 def compare(self, rhs): argument
544 self.content.compare(rhs.content)
546 def dump(self, options=None): argument
547 self.content.dump(options)
549 def dump_header(self, dump_description=True, options=None): argument
550 self.content.dump_header(dump_description, options)
552 def dump_load_commands(self, dump_description=True, options=None): argument
553 self.content.dump_load_commands(dump_description, options)
555 def dump_sections(self, dump_description=True, options=None): argument
556 self.content.dump_sections(dump_description, options)
558 def dump_section_contents(self, options): argument
559 self.content.dump_section_contents(options)
561 def dump_symtab(self, dump_description=True, options=None): argument
562 self.content.dump_symtab(dump_description, options)
564 def dump_symbol_names_matching_regex(self, regex, file=None): argument
565 self.content.dump_symbol_names_matching_regex(regex, file)
567 def description(self): argument
568 return self.content.description()
570 def unpack(self, data): argument
571 self.magic.unpack(data)
572 if self.magic.is_skinny_mach_file():
573 self.content = Mach.Skinny(self.path)
574 elif self.magic.is_universal_mach_file():
575 self.content = Mach.Universal(self.path)
577 self.content = None
579 if self.content is not None:
580 self.content.unpack(data, self.magic)
582 def is_valid(self): argument
583 return self.content is not None
587 def __init__(self, path): argument
588 self.path = path
589 self.type = 'universal'
590 self.file_off = 0
591 self.magic = None
592 self.nfat_arch = 0
593 self.archs = list()
595 def description(self): argument
596 s = '%#8.8x: %s (' % (self.file_off, self.path)
598 for arch in self.archs:
606 def unpack(self, data, magic=None): argument
607 self.file_off = data.tell()
609 self.magic = Mach.Magic()
610 self.magic.unpack(data)
612 self.magic = magic
613 self.file_off = self.file_off - 4
616 self.nfat_arch = data.get_uint32()
617 for i in range(self.nfat_arch):
618 self.archs.append(Mach.Universal.ArchInfo())
619 self.archs[i].unpack(data)
620 for i in range(self.nfat_arch):
621 self.archs[i].mach = Mach.Skinny(self.path)
622 data.seek(self.archs[i].offset, 0)
625 self.archs[i].mach.unpack(data, skinny_magic)
627 def compare(self, rhs): argument
631 def dump(self, options): argument
634 … print("Universal Mach File: magic = %s, nfat_arch = %u" % (self.magic, self.nfat_arch))
636 if self.nfat_arch > 0:
638 self.archs[0].dump_header(True, options)
639 for i in range(self.nfat_arch):
640 self.archs[i].dump_flat(options)
643 for i in range(self.nfat_arch):
644 self.archs[i].mach.dump(options)
646 def dump_header(self, dump_description=True, options=None): argument
648 print(self.description())
649 for i in range(self.nfat_arch):
650 self.archs[i].mach.dump_header(True, options)
653 def dump_load_commands(self, dump_description=True, options=None): argument
655 print(self.description())
656 for i in range(self.nfat_arch):
657 self.archs[i].mach.dump_load_commands(True, options)
660 def dump_sections(self, dump_description=True, options=None): argument
662 print(self.description())
663 for i in range(self.nfat_arch):
664 self.archs[i].mach.dump_sections(True, options)
667 def dump_section_contents(self, options): argument
668 for i in range(self.nfat_arch):
669 self.archs[i].mach.dump_section_contents(options)
672 def dump_symtab(self, dump_description=True, options=None): argument
674 print(self.description())
675 for i in range(self.nfat_arch):
676 self.archs[i].mach.dump_symtab(True, options)
679 def dump_symbol_names_matching_regex(self, regex, file=None): argument
680 for i in range(self.nfat_arch):
681 self.archs[i].mach.dump_symbol_names_matching_regex(
686 def __init__(self): argument
687 self.arch = Mach.Arch(0, 0)
688 self.offset = 0
689 self.size = 0
690 self.align = 0
691 self.mach = None
693 def unpack(self, data): argument
696 … self.arch.cpu, self.arch.sub, self.offset, self.size, self.align = data.get_n_uint32(
699 def dump_header(self, dump_description=True, options=None): argument
707 def dump_flat(self, options): argument
709 …print("%#8.8x %#8.8x %#8.8x %#8.8x %#8.8x" % (self.arch.cpu, self.arch.sub, self.offset, self.size…
711 … print("%-10s %#8.8x %#8.8x %#8.8x" % (self.arch, self.offset, self.size, self.align))
713 def dump(self): argument
714 print(" cputype: %#8.8x" % self.arch.cpu)
715 print("cpusubtype: %#8.8x" % self.arch.sub)
716 print(" offset: %#8.8x" % self.offset)
717 print(" size: %#8.8x" % self.size)
718 print(" align: %#8.8x" % self.align)
720 def __str__(self): argument
722 self.arch.cpu, self.arch.sub, self.offset, self.size, self.align)
724 def __repr__(self): argument
726 self.arch.cpu, self.arch.sub, self.offset, self.size, self.align)
730 def __init__(self, b): argument
731 self.bits = b
733 def __str__(self): argument
735 if self.bits & MH_NOUNDEFS:
737 if self.bits & MH_INCRLINK:
739 if self.bits & MH_DYLDLINK:
741 if self.bits & MH_BINDATLOAD:
743 if self.bits & MH_PREBOUND:
745 if self.bits & MH_SPLIT_SEGS:
747 if self.bits & MH_LAZY_INIT:
749 if self.bits & MH_TWOLEVEL:
751 if self.bits & MH_FORCE_FLAT:
753 if self.bits & MH_NOMULTIDEFS:
755 if self.bits & MH_NOFIXPREBINDING:
757 if self.bits & MH_PREBINDABLE:
759 if self.bits & MH_ALLMODSBOUND:
761 if self.bits & MH_SUBSECTIONS_VIA_SYMBOLS:
763 if self.bits & MH_CANONICAL:
765 if self.bits & MH_WEAK_DEFINES:
767 if self.bits & MH_BINDS_TO_WEAK:
769 if self.bits & MH_ALLOW_STACK_EXECUTION:
771 if self.bits & MH_ROOT_SAFE:
773 if self.bits & MH_SETUID_SAFE:
775 if self.bits & MH_NO_REEXPORTED_DYLIBS:
777 if self.bits & MH_PIE:
779 if self.bits & MH_DEAD_STRIPPABLE_DYLIB:
781 if self.bits & MH_HAS_TLV_DESCRIPTORS:
783 if self.bits & MH_NO_HEAP_EXECUTION:
806 def __init__(self, initial_value=0): argument
807 dict_utils.Enum.__init__(self, initial_value, self.enum)
811 def __init__(self, path): argument
812 self.path = path
813 self.type = 'skinny'
814 self.data = None
815 self.file_off = 0
816 self.magic = 0
817 self.arch = Mach.Arch(0, 0)
818 self.filetype = Mach.FileType(0)
819 self.ncmds = 0
820 self.sizeofcmds = 0
821 self.flags = Mach.Flags(0)
822 self.uuid = None
823 self.commands = list()
824 self.segments = list()
825 self.sections = list()
826 self.symbols = list()
827 self.sections.append(Mach.Section())
829 def description(self): argument
830 return '%#8.8x: %s (%s)' % (self.file_off, self.path, self.arch)
832 def unpack(self, data, magic=None): argument
833 self.data = data
834 self.file_off = data.tell()
836 self.magic = Mach.Magic()
837 self.magic.unpack(data)
839 self.magic = magic
840 self.file_off = self.file_off - 4
841 data.set_byte_order(self.magic.get_byte_order())
842 …self.arch.cpu, self.arch.sub, self.filetype.value, self.ncmds, self.sizeofcmds, bits = data.get_n_…
844 self.flags.bits = bits
846 if self.is_64_bit():
849 for i in range(0, self.ncmds):
850 lc = self.unpack_load_command(data)
851 self.commands.append(lc)
853 def get_data(self): argument
854 if self.data:
855 self.data.set_byte_order(self.magic.get_byte_order())
856 return self.data
859 def unpack_load_command(self, data): argument
861 lc.unpack(self, data)
866 lc.unpack(self, data)
872 lc.unpack(self, data)
881 lc.unpack(self, data)
884 lc.unpack(self, data)
887 lc.unpack(self, data)
890 lc.unpack(self, data)
893 lc.unpack(self, data)
898 lc.unpack(self, data)
901 lc.unpack(self, data)
904 lc.unpack(self, data)
908 def compare(self, rhs): argument
910 print("a) %s %s" % (self.arch, self.path))
913 if self.type == rhs.type:
914 for lhs_section in self.sections[1:]:
919 lhs_data = lhs_section.get_contents(self)
967 …'error: comparing a %s mach-o file with a %s mach-o file is not supported' % (self.type, rhs.type))
973 def dump_header(self, dump_description=True, options=None): argument
981 def dump_flat(self, options): argument
983 …8.8x %#8u %#8.8x %#8.8x" % (self.magic, self.arch.cpu, self.arch.sub, self.filetype.value, self.nc…
985 …nt("%-12s %-10s %-14s %#8u %#8.8x %s" % (self.magic, self.arch, self.filetype, self.ncmds, self.si…
987 def dump(self, options): argument
989 self.dump_header(True, options)
991 self.dump_load_commands(False, options)
993 self.dump_sections(False, options)
995 self.dump_section_contents(options)
997 self.get_symtab()
998 if len(self.symbols):
999 self.dump_sections(False, options)
1003 self.dump_symbol_names_matching_regex(re.compile('^_?_Z'))
1005 def dump_header(self, dump_description=True, options=None): argument
1007 print(self.description())
1009 print(" magic: %#8.8x %s" % (self.magic.value, self.magic))
1010 print(" cputype: %#8.8x %s" % (self.arch.cpu, self.arch))
1011 print(" cpusubtype: %#8.8x" % self.arch.sub)
1012 … print(" filetype: %#8.8x %s" % (self.filetype.get_enum_value(), self.filetype.get_enum_name()))
1013 print(" ncmds: %#8.8x %u" % (self.ncmds, self.ncmds))
1014 print(" sizeofcmds: %#8.8x" % self.sizeofcmds)
1015 print(" flags: %#8.8x %s" % (self.flags.bits, self.flags))
1017 def dump_load_commands(self, dump_description=True, options=None): argument
1019 print(self.description())
1020 for lc in self.commands:
1023 def get_section_by_name(self, name): argument
1024 for section in self.sections:
1029 def get_section_by_section(self, other_section): argument
1030 for section in self.sections:
1035 def dump_sections(self, dump_description=True, options=None): argument
1037 print(self.description())
1038 num_sections = len(self.sections)
1040 self.sections[1].dump_header()
1042 print("%s" % self.sections[sect_idx])
1044 def dump_section_contents(self, options): argument
1047 section = self.get_section_by_name(sectname)
1049 sect_bytes = section.get_contents(self)
1056 io.BytesIO(sect_bytes), self.data.byte_order)
1092 def get_segment(self, segname): argument
1093 if len(self.segments) == 1 and self.segments[0].segname == '':
1094 return self.segments[0]
1095 for segment in self.segments:
1100 def get_first_load_command(self, lc_enum_value): argument
1101 for lc in self.commands:
1106 def get_symtab(self): argument
1107 if self.data and not self.symbols:
1108 lc_symtab = self.get_first_load_command(LC_SYMTAB)
1110 symtab_offset = self.file_off
1111 if self.data.is_in_memory():
1112 linkedit_segment = self.get_segment('__LINKEDIT')
1121 self.data.seek(symtab_offset)
1122 is_64 = self.is_64_bit()
1125 nlist.unpack(self, self.data, lc_symtab)
1126 self.symbols.append(nlist)
1130 def dump_symtab(self, dump_description=True, options=None): argument
1131 self.get_symtab()
1133 print(self.description())
1134 for i, symbol in enumerate(self.symbols):
1137 def dump_symbol_names_matching_regex(self, regex, file=None): argument
1138 self.get_symtab()
1139 for symbol in self.symbols:
1145 def is_64_bit(self): argument
1146 return self.magic.is_64_bit()
1194 def __init__(self, initial_value=0): argument
1195 dict_utils.Enum.__init__(self, initial_value, self.enum)
1197 def __init__(self, c=None, l=0, o=0): argument
1199 self.command = c
1201 self.command = Mach.LoadCommand.Command(0)
1202 self.length = l
1203 self.file_off = o
1205 def unpack(self, mach_file, data): argument
1206 self.file_off = data.tell()
1207 self.command.value, self.length = data.get_n_uint32(2)
1209 def skip(self, data): argument
1210 data.seek(self.file_off + self.length, 0)
1212 def __str__(self): argument
1213 lc_name = self.command.get_enum_name()
1214 return '%#8.8x: <%#4.4x> %-24s' % (self.file_off,
1215 self.length, lc_name)
1219 def __init__(self): argument
1220 self.index = 0
1221 self.is_64 = False
1222 self.sectname = None
1223 self.segname = None
1224 self.addr = 0
1225 self.size = 0
1226 self.offset = 0
1227 self.align = 0
1228 self.reloff = 0
1229 self.nreloc = 0
1230 self.flags = 0
1231 self.reserved1 = 0
1232 self.reserved2 = 0
1233 self.reserved3 = 0
1235 def unpack(self, is_64, data): argument
1236 self.is_64 = is_64
1237 self.sectname = data.get_fixed_length_c_string(16, '', True)
1238 self.segname = data.get_fixed_length_c_string(16, '', True)
1239 if self.is_64:
1240 self.addr, self.size = data.get_n_uint64(2)
1241 …self.offset, self.align, self.reloff, self.nreloc, self.flags, self.reserved1, self.reserved2, sel…
1244 self.addr, self.size = data.get_n_uint32(2)
1245 …self.offset, self.align, self.reloff, self.nreloc, self.flags, self.reserved1, self.reserved2 = da…
1248 def dump_header(self): argument
1249 if self.is_64:
1256 def __str__(self): argument
1257 if self.is_64:
1259 …self.index, self.addr, self.size, self.offset, self.align, self.reloff, self.nreloc, self.flags, s…
1262 …self.index, self.addr, self.size, self.offset, self.align, self.reloff, self.nreloc, self.flags, s…
1264 def get_contents(self, mach_file): argument
1266 if self.size > 0 and mach_file.get_segment(
1267 self.segname).filesize > 0:
1270 section_data_offset = mach_file.file_off + self.offset
1275 bytes = data.read_size(self.size)
1282 def __init__(self, lc): argument
1283 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1284 self.name = None
1285 self.timestamp = 0
1286 self.current_version = 0
1287 self.compatibility_version = 0
1289 def unpack(self, mach_file, data): argument
1291 … name_offset, self.timestamp, self.current_version, self.compatibility_version = data.get_n_uint32(
1293 data.seek(self.file_off + name_offset, 0)
1294 self.name = data.get_fixed_length_c_string(self.length - 24)
1296 def __str__(self): argument
1297 s = Mach.LoadCommand.__str__(self)
1298 s += "%#8.8x %#8.8x %#8.8x " % (self.timestamp,
1299 self.current_version,
1300 self.compatibility_version)
1301 s += self.name
1306 def __init__(self, lc): argument
1307 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1308 self.name = None
1310 def unpack(self, mach_file, data): argument
1312 self.name = data.get_fixed_length_c_string(self.length - 12)
1314 def __str__(self): argument
1315 s = Mach.LoadCommand.__str__(self)
1316 s += "%s" % self.name
1323 def __init__(self): argument
1324 self.flavor = 0
1325 self.count = 0
1326 self.register_values = list()
1328 def unpack(self, data): argument
1329 self.flavor, self.count = data.get_n_uint32(2)
1330 self.register_values = data.get_n_uint32(self.count)
1332 def __str__(self): argument
1334 self.flavor, self.count)
1336 for register_value in self.register_values:
1343 def __init__(self, lc): argument
1344 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1345 self.reg_sets = list()
1347 def unpack(self, mach_file, data): argument
1350 self.reg_sets.append(reg_set)
1352 def __str__(self): argument
1353 s = Mach.LoadCommand.__str__(self)
1354 for reg_set in self.reg_sets:
1360 def __init__(self, lc): argument
1361 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1362 self.rebase_off = 0
1363 self.rebase_size = 0
1364 self.bind_off = 0
1365 self.bind_size = 0
1366 self.weak_bind_off = 0
1367 self.weak_bind_size = 0
1368 self.lazy_bind_off = 0
1369 self.lazy_bind_size = 0
1370 self.export_off = 0
1371 self.export_size = 0
1373 def unpack(self, mach_file, data): argument
1375 …self.rebase_off, self.rebase_size, self.bind_off, self.bind_size, self.weak_bind_off, self.weak_bi…
1378 def __str__(self): argument
1379 s = Mach.LoadCommand.__str__(self)
1381 self.rebase_off, self.rebase_size)
1383 self.bind_off, self.bind_size)
1385 self.weak_bind_off, self.weak_bind_size)
1387 self.lazy_bind_off, self.lazy_bind_size)
1389 self.export_off, self.export_size)
1394 def __init__(self, lc): argument
1395 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1396 self.ilocalsym = 0
1397 self.nlocalsym = 0
1398 self.iextdefsym = 0
1399 self.nextdefsym = 0
1400 self.iundefsym = 0
1401 self.nundefsym = 0
1402 self.tocoff = 0
1403 self.ntoc = 0
1404 self.modtaboff = 0
1405 self.nmodtab = 0
1406 self.extrefsymoff = 0
1407 self.nextrefsyms = 0
1408 self.indirectsymoff = 0
1409 self.nindirectsyms = 0
1410 self.extreloff = 0
1411 self.nextrel = 0
1412 self.locreloff = 0
1413 self.nlocrel = 0
1415 def unpack(self, mach_file, data): argument
1417 …self.ilocalsym, self.nlocalsym, self.iextdefsym, self.nextdefsym, self.iundefsym, self.nundefsym, …
1420 def __str__(self): argument
1421 s = Mach.LoadCommand.__str__(self)
1433 self.ilocalsym, self.nlocalsym)
1435 self.iextdefsym, self.nextdefsym)
1437 self.iundefsym, self.nundefsym)
1439 self.tocoff, self.ntoc)
1441 self.modtaboff, self.nmodtab)
1443 self.extrefsymoff, self.nextrefsyms)
1445 self.indirectsymoff, self.nindirectsyms)
1447 self.extreloff, self.nextrel)
1449 self.locreloff, self.nlocrel)
1454 def __init__(self, lc): argument
1455 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1456 self.symoff = 0
1457 self.nsyms = 0
1458 self.stroff = 0
1459 self.strsize = 0
1461 def unpack(self, mach_file, data): argument
1463 self.symoff, self.nsyms, self.stroff, self.strsize = data.get_n_uint32(
1466 def __str__(self): argument
1467 s = Mach.LoadCommand.__str__(self)
1469 self.symoff, self.nsyms, self.stroff, self.strsize)
1474 def __init__(self, lc): argument
1475 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1476 self.uuid = None
1478 def unpack(self, mach_file, data): argument
1483 self.uuid = uuid.UUID(uuid_str)
1484 mach_file.uuid = self.uuid
1486 def __str__(self): argument
1487 s = Mach.LoadCommand.__str__(self)
1488 s += self.uuid.__str__()
1493 def __init__(self, lc): argument
1494 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1495 self.dataoff = 0
1496 self.datasize = 0
1498 def unpack(self, mach_file, data): argument
1500 self.dataoff, self.datasize = data.get_n_uint32(2)
1502 def __str__(self): argument
1503 s = Mach.LoadCommand.__str__(self)
1505 self.dataoff, self.datasize)
1510 def __init__(self, lc): argument
1511 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1512 self.cryptoff = 0
1513 self.cryptsize = 0
1514 self.cryptid = 0
1516 def unpack(self, mach_file, data): argument
1518 self.cryptoff, self.cryptsize, self.cryptid = data.get_n_uint32(3)
1520 def __str__(self): argument
1521 s = Mach.LoadCommand.__str__(self)
1523 self.cryptoff, self.cryptoff + self.cryptsize, self.cryptsize, self.cryptid)
1528 def __init__(self, lc): argument
1529 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1530 self.segname = None
1531 self.vmaddr = 0
1532 self.vmsize = 0
1533 self.fileoff = 0
1534 self.filesize = 0
1535 self.maxprot = 0
1536 self.initprot = 0
1537 self.nsects = 0
1538 self.flags = 0
1540 def unpack(self, mach_file, data): argument
1541 is_64 = self.command.get_enum_value() == LC_SEGMENT_64
1542 self.segname = data.get_fixed_length_c_string(16, '', True)
1544 self.vmaddr, self.vmsize, self.fileoff, self.filesize = data.get_n_uint64(
1547 self.vmaddr, self.vmsize, self.fileoff, self.filesize = data.get_n_uint32(
1549 self.maxprot, self.initprot, self.nsects, self.flags = data.get_n_uint32(
1551 mach_file.segments.append(self)
1552 for i in range(self.nsects):
1558 def __str__(self): argument
1559 s = Mach.LoadCommand.__str__(self)
1560 if self.command.get_enum_value() == LC_SEGMENT:
1562 self.vmaddr, self.vmsize, self.fileoff, self.filesize)
1565 self.vmaddr, self.vmsize, self.fileoff, self.filesize)
1566 s += "%s %s %3u %#8.8x" % (vm_prot_names[self.maxprot], vm_prot_names[
1567 self.initprot], self.nsects, self.flags)
1568 s += ' ' + self.segname
1608 def __init__(self, magic=0): argument
1609 dict_utils.Enum.__init__(self, magic, self.enum)
1611 def __init__(self, t=0): argument
1612 self.value = t
1614 def __str__(self): argument
1615 n_type = self.value
1617 stab = Mach.NList.Type.Stab(self.value)
1620 type = self.value & N_TYPE
1640 def __init__(self): argument
1641 self.index = 0
1642 self.name_offset = 0
1643 self.name = 0
1644 self.type = Mach.NList.Type()
1645 self.sect_idx = 0
1646 self.desc = 0
1647 self.value = 0
1649 def unpack(self, mach_file, data, symtab_lc): argument
1650 self.index = len(mach_file.symbols)
1651 self.name_offset = data.get_uint32()
1652 self.type.value, self.sect_idx = data.get_n_uint8(2)
1653 self.desc = data.get_uint16()
1655 self.value = data.get_uint64()
1657 self.value = data.get_uint32()
1661 self.name_offset)
1663 self.name = data.get_c_string()
1666 def __str__(self): argument
1668 if len(self.name):
1669 name_display = ' "%s"' % self.name
1670 return '%#8.8x %#2.2x (%-20s) %#2.2x %#4.4x %16.16x%s' % (self.name_offset,
1671 … self.type.value, self.type, self.sect_idx, self.desc, self.value, name_display)
1676 def __init__(self, mach, options): argument
1677 cmd.Cmd.__init__(self)
1678 self.intro = 'Interactive mach-o command interpreter'
1679 self.prompt = 'mach-o: %s %% ' % mach.path
1680 self.mach = mach
1681 self.options = options
1683 def default(self, line): argument
1688 def do_q(self, line): argument
1692 def do_quit(self, line): argument
1696 def do_header(self, line): argument
1698 self.mach.dump_header(True, self.options)
1701 def do_load(self, line): argument
1703 self.mach.dump_load_commands(True, self.options)
1706 def do_sections(self, line): argument
1708 self.mach.dump_sections(True, self.options)
1711 def do_symtab(self, line): argument
1713 self.mach.dump_symtab(True, self.options)