Lines Matching refs:self
215 def __init__(self, enabled=True): argument
218 self.enabled = enabled
220 def reset(self): argument
222 if self.enabled:
226 def bold(self, on=True): argument
228 if self.enabled:
235 def italics(self, on=True): argument
237 if self.enabled:
244 def underline(self, on=True): argument
246 if self.enabled:
253 def inverse(self, on=True): argument
255 if self.enabled:
262 def strike(self, on=True): argument
264 if self.enabled:
271 def black(self, fg=True): argument
274 if self.enabled:
281 def red(self, fg=True): argument
284 if self.enabled:
291 def green(self, fg=True): argument
294 if self.enabled:
301 def yellow(self, fg=True): argument
304 if self.enabled:
311 def blue(self, fg=True): argument
314 if self.enabled:
321 def magenta(self, fg=True): argument
324 if self.enabled:
331 def cyan(self, fg=True): argument
334 if self.enabled:
341 def white(self, fg=True): argument
344 if self.enabled:
351 def default(self, fg=True): argument
354 if self.enabled:
426 def __init__(self, c=0, s=0): argument
427 self.cpu = c
428 self.sub = s
430 def set_cpu_type(self, c): argument
431 self.cpu = c
433 def set_cpu_subtype(self, s): argument
434 self.sub = s
436 def set_arch(self, c, s): argument
437 self.cpu = c
438 self.sub = s
440 def is_64_bit(self): argument
441 return (self.cpu & CPU_ARCH_ABI64) != 0
480 def __str__(self): argument
481 for info in self.cpu_infos:
482 if self.cpu == info[1] and (self.sub & 0x00ffffff) == info[2]:
484 return "{0}.{1}".format(self.cpu, self.sub)
497 def __init__(self, initial_value=0): argument
498 dict_utils.Enum.__init__(self, initial_value, self.enum)
500 def is_skinny_mach_file(self): argument
501 …return self.value == MH_MAGIC or self.value == MH_CIGAM or self.value == MH_MAGIC_64 or self.value…
503 def is_universal_mach_file(self): argument
504 return self.value == FAT_MAGIC or self.value == FAT_CIGAM
506 def unpack(self, data): argument
508 self.value = data.get_uint32()
510 def get_byte_order(self): argument
511 if self.value == MH_CIGAM or self.value == MH_CIGAM_64 or self.value == FAT_CIGAM:
516 def is_64_bit(self): argument
517 return self.value == MH_MAGIC_64 or self.value == MH_CIGAM_64
519 def __init__(self): argument
520 self.magic = Mach.Magic()
521 self.content = None
522 self.path = None
524 def extract(self, path, extractor): argument
525 self.path = path
526 self.unpack(extractor)
528 def parse(self, path): argument
529 self.path = path
531 f = open(self.path)
533 self.unpack(file_extractor)
544 def compare(self, rhs): argument
545 self.content.compare(rhs.content)
547 def dump(self, options=None): argument
548 self.content.dump(options)
550 def dump_header(self, dump_description=True, options=None): argument
551 self.content.dump_header(dump_description, options)
553 def dump_load_commands(self, dump_description=True, options=None): argument
554 self.content.dump_load_commands(dump_description, options)
556 def dump_sections(self, dump_description=True, options=None): argument
557 self.content.dump_sections(dump_description, options)
559 def dump_section_contents(self, options): argument
560 self.content.dump_section_contents(options)
562 def dump_symtab(self, dump_description=True, options=None): argument
563 self.content.dump_symtab(dump_description, options)
565 def dump_symbol_names_matching_regex(self, regex, file=None): argument
566 self.content.dump_symbol_names_matching_regex(regex, file)
568 def description(self): argument
569 return self.content.description()
571 def unpack(self, data): argument
572 self.magic.unpack(data)
573 if self.magic.is_skinny_mach_file():
574 self.content = Mach.Skinny(self.path)
575 elif self.magic.is_universal_mach_file():
576 self.content = Mach.Universal(self.path)
578 self.content = None
580 if self.content is not None:
581 self.content.unpack(data, self.magic)
583 def is_valid(self): argument
584 return self.content is not None
588 def __init__(self, path): argument
589 self.path = path
590 self.type = 'universal'
591 self.file_off = 0
592 self.magic = None
593 self.nfat_arch = 0
594 self.archs = list()
596 def description(self): argument
597 s = '%#8.8x: %s (' % (self.file_off, self.path)
599 for arch in self.archs:
607 def unpack(self, data, magic=None): argument
608 self.file_off = data.tell()
610 self.magic = Mach.Magic()
611 self.magic.unpack(data)
613 self.magic = magic
614 self.file_off = self.file_off - 4
617 self.nfat_arch = data.get_uint32()
618 for i in range(self.nfat_arch):
619 self.archs.append(Mach.Universal.ArchInfo())
620 self.archs[i].unpack(data)
621 for i in range(self.nfat_arch):
622 self.archs[i].mach = Mach.Skinny(self.path)
623 data.seek(self.archs[i].offset, 0)
626 self.archs[i].mach.unpack(data, skinny_magic)
628 def compare(self, rhs): argument
632 def dump(self, options): argument
635 … print("Universal Mach File: magic = %s, nfat_arch = %u" % (self.magic, self.nfat_arch))
637 if self.nfat_arch > 0:
639 self.archs[0].dump_header(True, options)
640 for i in range(self.nfat_arch):
641 self.archs[i].dump_flat(options)
644 for i in range(self.nfat_arch):
645 self.archs[i].mach.dump(options)
647 def dump_header(self, dump_description=True, options=None): argument
649 print(self.description())
650 for i in range(self.nfat_arch):
651 self.archs[i].mach.dump_header(True, options)
654 def dump_load_commands(self, dump_description=True, options=None): argument
656 print(self.description())
657 for i in range(self.nfat_arch):
658 self.archs[i].mach.dump_load_commands(True, options)
661 def dump_sections(self, dump_description=True, options=None): argument
663 print(self.description())
664 for i in range(self.nfat_arch):
665 self.archs[i].mach.dump_sections(True, options)
668 def dump_section_contents(self, options): argument
669 for i in range(self.nfat_arch):
670 self.archs[i].mach.dump_section_contents(options)
673 def dump_symtab(self, dump_description=True, options=None): argument
675 print(self.description())
676 for i in range(self.nfat_arch):
677 self.archs[i].mach.dump_symtab(True, options)
680 def dump_symbol_names_matching_regex(self, regex, file=None): argument
681 for i in range(self.nfat_arch):
682 self.archs[i].mach.dump_symbol_names_matching_regex(
687 def __init__(self): argument
688 self.arch = Mach.Arch(0, 0)
689 self.offset = 0
690 self.size = 0
691 self.align = 0
692 self.mach = None
694 def unpack(self, data): argument
697 … self.arch.cpu, self.arch.sub, self.offset, self.size, self.align = data.get_n_uint32(
700 def dump_header(self, dump_description=True, options=None): argument
708 def dump_flat(self, options): argument
710 …print("%#8.8x %#8.8x %#8.8x %#8.8x %#8.8x" % (self.arch.cpu, self.arch.sub, self.offset, self.size…
712 … print("%-10s %#8.8x %#8.8x %#8.8x" % (self.arch, self.offset, self.size, self.align))
714 def dump(self): argument
715 print(" cputype: %#8.8x" % self.arch.cpu)
716 print("cpusubtype: %#8.8x" % self.arch.sub)
717 print(" offset: %#8.8x" % self.offset)
718 print(" size: %#8.8x" % self.size)
719 print(" align: %#8.8x" % self.align)
721 def __str__(self): argument
723 self.arch.cpu, self.arch.sub, self.offset, self.size, self.align)
725 def __repr__(self): argument
727 self.arch.cpu, self.arch.sub, self.offset, self.size, self.align)
731 def __init__(self, b): argument
732 self.bits = b
734 def __str__(self): argument
736 if self.bits & MH_NOUNDEFS:
738 if self.bits & MH_INCRLINK:
740 if self.bits & MH_DYLDLINK:
742 if self.bits & MH_BINDATLOAD:
744 if self.bits & MH_PREBOUND:
746 if self.bits & MH_SPLIT_SEGS:
748 if self.bits & MH_LAZY_INIT:
750 if self.bits & MH_TWOLEVEL:
752 if self.bits & MH_FORCE_FLAT:
754 if self.bits & MH_NOMULTIDEFS:
756 if self.bits & MH_NOFIXPREBINDING:
758 if self.bits & MH_PREBINDABLE:
760 if self.bits & MH_ALLMODSBOUND:
762 if self.bits & MH_SUBSECTIONS_VIA_SYMBOLS:
764 if self.bits & MH_CANONICAL:
766 if self.bits & MH_WEAK_DEFINES:
768 if self.bits & MH_BINDS_TO_WEAK:
770 if self.bits & MH_ALLOW_STACK_EXECUTION:
772 if self.bits & MH_ROOT_SAFE:
774 if self.bits & MH_SETUID_SAFE:
776 if self.bits & MH_NO_REEXPORTED_DYLIBS:
778 if self.bits & MH_PIE:
780 if self.bits & MH_DEAD_STRIPPABLE_DYLIB:
782 if self.bits & MH_HAS_TLV_DESCRIPTORS:
784 if self.bits & MH_NO_HEAP_EXECUTION:
807 def __init__(self, initial_value=0): argument
808 dict_utils.Enum.__init__(self, initial_value, self.enum)
812 def __init__(self, path): argument
813 self.path = path
814 self.type = 'skinny'
815 self.data = None
816 self.file_off = 0
817 self.magic = 0
818 self.arch = Mach.Arch(0, 0)
819 self.filetype = Mach.FileType(0)
820 self.ncmds = 0
821 self.sizeofcmds = 0
822 self.flags = Mach.Flags(0)
823 self.uuid = None
824 self.commands = list()
825 self.segments = list()
826 self.sections = list()
827 self.symbols = list()
828 self.sections.append(Mach.Section())
830 def description(self): argument
831 return '%#8.8x: %s (%s)' % (self.file_off, self.path, self.arch)
833 def unpack(self, data, magic=None): argument
834 self.data = data
835 self.file_off = data.tell()
837 self.magic = Mach.Magic()
838 self.magic.unpack(data)
840 self.magic = magic
841 self.file_off = self.file_off - 4
842 data.set_byte_order(self.magic.get_byte_order())
843 …self.arch.cpu, self.arch.sub, self.filetype.value, self.ncmds, self.sizeofcmds, bits = data.get_n_…
845 self.flags.bits = bits
847 if self.is_64_bit():
850 for i in range(0, self.ncmds):
851 lc = self.unpack_load_command(data)
852 self.commands.append(lc)
854 def get_data(self): argument
855 if self.data:
856 self.data.set_byte_order(self.magic.get_byte_order())
857 return self.data
860 def unpack_load_command(self, data): argument
862 lc.unpack(self, data)
867 lc.unpack(self, data)
873 lc.unpack(self, data)
882 lc.unpack(self, data)
885 lc.unpack(self, data)
888 lc.unpack(self, data)
891 lc.unpack(self, data)
894 lc.unpack(self, data)
899 lc.unpack(self, data)
902 lc.unpack(self, data)
905 lc.unpack(self, data)
909 def compare(self, rhs): argument
911 print("a) %s %s" % (self.arch, self.path))
914 if self.type == rhs.type:
915 for lhs_section in self.sections[1:]:
920 lhs_data = lhs_section.get_contents(self)
968 …'error: comparing a %s mach-o file with a %s mach-o file is not supported' % (self.type, rhs.type))
974 def dump_header(self, dump_description=True, options=None): argument
982 def dump_flat(self, options): argument
984 …8.8x %#8u %#8.8x %#8.8x" % (self.magic, self.arch.cpu, self.arch.sub, self.filetype.value, self.nc…
986 …nt("%-12s %-10s %-14s %#8u %#8.8x %s" % (self.magic, self.arch, self.filetype, self.ncmds, self.si…
988 def dump(self, options): argument
990 self.dump_header(True, options)
992 self.dump_load_commands(False, options)
994 self.dump_sections(False, options)
996 self.dump_section_contents(options)
998 self.get_symtab()
999 if len(self.symbols):
1000 self.dump_sections(False, options)
1004 self.dump_symbol_names_matching_regex(re.compile('^_?_Z'))
1006 def dump_header(self, dump_description=True, options=None): argument
1008 print(self.description())
1010 print(" magic: %#8.8x %s" % (self.magic.value, self.magic))
1011 print(" cputype: %#8.8x %s" % (self.arch.cpu, self.arch))
1012 print(" cpusubtype: %#8.8x" % self.arch.sub)
1013 … print(" filetype: %#8.8x %s" % (self.filetype.get_enum_value(), self.filetype.get_enum_name()))
1014 print(" ncmds: %#8.8x %u" % (self.ncmds, self.ncmds))
1015 print(" sizeofcmds: %#8.8x" % self.sizeofcmds)
1016 print(" flags: %#8.8x %s" % (self.flags.bits, self.flags))
1018 def dump_load_commands(self, dump_description=True, options=None): argument
1020 print(self.description())
1021 for lc in self.commands:
1024 def get_section_by_name(self, name): argument
1025 for section in self.sections:
1030 def get_section_by_section(self, other_section): argument
1031 for section in self.sections:
1036 def dump_sections(self, dump_description=True, options=None): argument
1038 print(self.description())
1039 num_sections = len(self.sections)
1041 self.sections[1].dump_header()
1043 print("%s" % self.sections[sect_idx])
1045 def dump_section_contents(self, options): argument
1048 section = self.get_section_by_name(sectname)
1050 sect_bytes = section.get_contents(self)
1057 io.BytesIO(sect_bytes), self.data.byte_order)
1093 def get_segment(self, segname): argument
1094 if len(self.segments) == 1 and self.segments[0].segname == '':
1095 return self.segments[0]
1096 for segment in self.segments:
1101 def get_first_load_command(self, lc_enum_value): argument
1102 for lc in self.commands:
1107 def get_symtab(self): argument
1108 if self.data and not self.symbols:
1109 lc_symtab = self.get_first_load_command(LC_SYMTAB)
1111 symtab_offset = self.file_off
1112 if self.data.is_in_memory():
1113 linkedit_segment = self.get_segment('__LINKEDIT')
1122 self.data.seek(symtab_offset)
1123 is_64 = self.is_64_bit()
1126 nlist.unpack(self, self.data, lc_symtab)
1127 self.symbols.append(nlist)
1131 def dump_symtab(self, dump_description=True, options=None): argument
1132 self.get_symtab()
1134 print(self.description())
1135 for i, symbol in enumerate(self.symbols):
1138 def dump_symbol_names_matching_regex(self, regex, file=None): argument
1139 self.get_symtab()
1140 for symbol in self.symbols:
1146 def is_64_bit(self): argument
1147 return self.magic.is_64_bit()
1195 def __init__(self, initial_value=0): argument
1196 dict_utils.Enum.__init__(self, initial_value, self.enum)
1198 def __init__(self, c=None, l=0, o=0): argument
1200 self.command = c
1202 self.command = Mach.LoadCommand.Command(0)
1203 self.length = l
1204 self.file_off = o
1206 def unpack(self, mach_file, data): argument
1207 self.file_off = data.tell()
1208 self.command.value, self.length = data.get_n_uint32(2)
1210 def skip(self, data): argument
1211 data.seek(self.file_off + self.length, 0)
1213 def __str__(self): argument
1214 lc_name = self.command.get_enum_name()
1215 return '%#8.8x: <%#4.4x> %-24s' % (self.file_off,
1216 self.length, lc_name)
1220 def __init__(self): argument
1221 self.index = 0
1222 self.is_64 = False
1223 self.sectname = None
1224 self.segname = None
1225 self.addr = 0
1226 self.size = 0
1227 self.offset = 0
1228 self.align = 0
1229 self.reloff = 0
1230 self.nreloc = 0
1231 self.flags = 0
1232 self.reserved1 = 0
1233 self.reserved2 = 0
1234 self.reserved3 = 0
1236 def unpack(self, is_64, data): argument
1237 self.is_64 = is_64
1238 self.sectname = data.get_fixed_length_c_string(16, '', True)
1239 self.segname = data.get_fixed_length_c_string(16, '', True)
1240 if self.is_64:
1241 self.addr, self.size = data.get_n_uint64(2)
1242 …self.offset, self.align, self.reloff, self.nreloc, self.flags, self.reserved1, self.reserved2, sel…
1245 self.addr, self.size = data.get_n_uint32(2)
1246 …self.offset, self.align, self.reloff, self.nreloc, self.flags, self.reserved1, self.reserved2 = da…
1249 def dump_header(self): argument
1250 if self.is_64:
1257 def __str__(self): argument
1258 if self.is_64:
1260 …self.index, self.addr, self.size, self.offset, self.align, self.reloff, self.nreloc, self.flags, s…
1263 …self.index, self.addr, self.size, self.offset, self.align, self.reloff, self.nreloc, self.flags, s…
1265 def get_contents(self, mach_file): argument
1267 if self.size > 0 and mach_file.get_segment(
1268 self.segname).filesize > 0:
1271 section_data_offset = mach_file.file_off + self.offset
1276 bytes = data.read_size(self.size)
1283 def __init__(self, lc): argument
1284 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1285 self.name = None
1286 self.timestamp = 0
1287 self.current_version = 0
1288 self.compatibility_version = 0
1290 def unpack(self, mach_file, data): argument
1292 … name_offset, self.timestamp, self.current_version, self.compatibility_version = data.get_n_uint32(
1294 data.seek(self.file_off + name_offset, 0)
1295 self.name = data.get_fixed_length_c_string(self.length - 24)
1297 def __str__(self): argument
1298 s = Mach.LoadCommand.__str__(self)
1299 s += "%#8.8x %#8.8x %#8.8x " % (self.timestamp,
1300 self.current_version,
1301 self.compatibility_version)
1302 s += self.name
1307 def __init__(self, lc): argument
1308 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1309 self.name = None
1311 def unpack(self, mach_file, data): argument
1313 self.name = data.get_fixed_length_c_string(self.length - 12)
1315 def __str__(self): argument
1316 s = Mach.LoadCommand.__str__(self)
1317 s += "%s" % self.name
1324 def __init__(self): argument
1325 self.flavor = 0
1326 self.count = 0
1327 self.register_values = list()
1329 def unpack(self, data): argument
1330 self.flavor, self.count = data.get_n_uint32(2)
1331 self.register_values = data.get_n_uint32(self.count)
1333 def __str__(self): argument
1335 self.flavor, self.count)
1337 for register_value in self.register_values:
1344 def __init__(self, lc): argument
1345 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1346 self.reg_sets = list()
1348 def unpack(self, mach_file, data): argument
1351 self.reg_sets.append(reg_set)
1353 def __str__(self): argument
1354 s = Mach.LoadCommand.__str__(self)
1355 for reg_set in self.reg_sets:
1361 def __init__(self, lc): argument
1362 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1363 self.rebase_off = 0
1364 self.rebase_size = 0
1365 self.bind_off = 0
1366 self.bind_size = 0
1367 self.weak_bind_off = 0
1368 self.weak_bind_size = 0
1369 self.lazy_bind_off = 0
1370 self.lazy_bind_size = 0
1371 self.export_off = 0
1372 self.export_size = 0
1374 def unpack(self, mach_file, data): argument
1376 …self.rebase_off, self.rebase_size, self.bind_off, self.bind_size, self.weak_bind_off, self.weak_bi…
1379 def __str__(self): argument
1380 s = Mach.LoadCommand.__str__(self)
1382 self.rebase_off, self.rebase_size)
1384 self.bind_off, self.bind_size)
1386 self.weak_bind_off, self.weak_bind_size)
1388 self.lazy_bind_off, self.lazy_bind_size)
1390 self.export_off, self.export_size)
1395 def __init__(self, lc): argument
1396 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1397 self.ilocalsym = 0
1398 self.nlocalsym = 0
1399 self.iextdefsym = 0
1400 self.nextdefsym = 0
1401 self.iundefsym = 0
1402 self.nundefsym = 0
1403 self.tocoff = 0
1404 self.ntoc = 0
1405 self.modtaboff = 0
1406 self.nmodtab = 0
1407 self.extrefsymoff = 0
1408 self.nextrefsyms = 0
1409 self.indirectsymoff = 0
1410 self.nindirectsyms = 0
1411 self.extreloff = 0
1412 self.nextrel = 0
1413 self.locreloff = 0
1414 self.nlocrel = 0
1416 def unpack(self, mach_file, data): argument
1418 …self.ilocalsym, self.nlocalsym, self.iextdefsym, self.nextdefsym, self.iundefsym, self.nundefsym, …
1421 def __str__(self): argument
1422 s = Mach.LoadCommand.__str__(self)
1434 self.ilocalsym, self.nlocalsym)
1436 self.iextdefsym, self.nextdefsym)
1438 self.iundefsym, self.nundefsym)
1440 self.tocoff, self.ntoc)
1442 self.modtaboff, self.nmodtab)
1444 self.extrefsymoff, self.nextrefsyms)
1446 self.indirectsymoff, self.nindirectsyms)
1448 self.extreloff, self.nextrel)
1450 self.locreloff, self.nlocrel)
1455 def __init__(self, lc): argument
1456 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1457 self.symoff = 0
1458 self.nsyms = 0
1459 self.stroff = 0
1460 self.strsize = 0
1462 def unpack(self, mach_file, data): argument
1464 self.symoff, self.nsyms, self.stroff, self.strsize = data.get_n_uint32(
1467 def __str__(self): argument
1468 s = Mach.LoadCommand.__str__(self)
1470 self.symoff, self.nsyms, self.stroff, self.strsize)
1475 def __init__(self, lc): argument
1476 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1477 self.uuid = None
1479 def unpack(self, mach_file, data): argument
1484 self.uuid = uuid.UUID(uuid_str)
1485 mach_file.uuid = self.uuid
1487 def __str__(self): argument
1488 s = Mach.LoadCommand.__str__(self)
1489 s += self.uuid.__str__()
1494 def __init__(self, lc): argument
1495 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1496 self.dataoff = 0
1497 self.datasize = 0
1499 def unpack(self, mach_file, data): argument
1501 self.dataoff, self.datasize = data.get_n_uint32(2)
1503 def __str__(self): argument
1504 s = Mach.LoadCommand.__str__(self)
1506 self.dataoff, self.datasize)
1511 def __init__(self, lc): argument
1512 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1513 self.cryptoff = 0
1514 self.cryptsize = 0
1515 self.cryptid = 0
1517 def unpack(self, mach_file, data): argument
1519 self.cryptoff, self.cryptsize, self.cryptid = data.get_n_uint32(3)
1521 def __str__(self): argument
1522 s = Mach.LoadCommand.__str__(self)
1524 self.cryptoff, self.cryptoff + self.cryptsize, self.cryptsize, self.cryptid)
1529 def __init__(self, lc): argument
1530 Mach.LoadCommand.__init__(self, lc.command, lc.length, lc.file_off)
1531 self.segname = None
1532 self.vmaddr = 0
1533 self.vmsize = 0
1534 self.fileoff = 0
1535 self.filesize = 0
1536 self.maxprot = 0
1537 self.initprot = 0
1538 self.nsects = 0
1539 self.flags = 0
1541 def unpack(self, mach_file, data): argument
1542 is_64 = self.command.get_enum_value() == LC_SEGMENT_64
1543 self.segname = data.get_fixed_length_c_string(16, '', True)
1545 self.vmaddr, self.vmsize, self.fileoff, self.filesize = data.get_n_uint64(
1548 self.vmaddr, self.vmsize, self.fileoff, self.filesize = data.get_n_uint32(
1550 self.maxprot, self.initprot, self.nsects, self.flags = data.get_n_uint32(
1552 mach_file.segments.append(self)
1553 for i in range(self.nsects):
1559 def __str__(self): argument
1560 s = Mach.LoadCommand.__str__(self)
1561 if self.command.get_enum_value() == LC_SEGMENT:
1563 self.vmaddr, self.vmsize, self.fileoff, self.filesize)
1566 self.vmaddr, self.vmsize, self.fileoff, self.filesize)
1567 s += "%s %s %3u %#8.8x" % (vm_prot_names[self.maxprot], vm_prot_names[
1568 self.initprot], self.nsects, self.flags)
1569 s += ' ' + self.segname
1609 def __init__(self, magic=0): argument
1610 dict_utils.Enum.__init__(self, magic, self.enum)
1612 def __init__(self, t=0): argument
1613 self.value = t
1615 def __str__(self): argument
1616 n_type = self.value
1618 stab = Mach.NList.Type.Stab(self.value)
1621 type = self.value & N_TYPE
1641 def __init__(self): argument
1642 self.index = 0
1643 self.name_offset = 0
1644 self.name = 0
1645 self.type = Mach.NList.Type()
1646 self.sect_idx = 0
1647 self.desc = 0
1648 self.value = 0
1650 def unpack(self, mach_file, data, symtab_lc): argument
1651 self.index = len(mach_file.symbols)
1652 self.name_offset = data.get_uint32()
1653 self.type.value, self.sect_idx = data.get_n_uint8(2)
1654 self.desc = data.get_uint16()
1656 self.value = data.get_uint64()
1658 self.value = data.get_uint32()
1662 self.name_offset)
1664 self.name = data.get_c_string()
1667 def __str__(self): argument
1669 if len(self.name):
1670 name_display = ' "%s"' % self.name
1671 return '%#8.8x %#2.2x (%-20s) %#2.2x %#4.4x %16.16x%s' % (self.name_offset,
1672 … self.type.value, self.type, self.sect_idx, self.desc, self.value, name_display)
1677 def __init__(self, mach, options): argument
1678 cmd.Cmd.__init__(self)
1679 self.intro = 'Interactive mach-o command interpreter'
1680 self.prompt = 'mach-o: %s %% ' % mach.path
1681 self.mach = mach
1682 self.options = options
1684 def default(self, line): argument
1689 def do_q(self, line): argument
1693 def do_quit(self, line): argument
1697 def do_header(self, line): argument
1699 self.mach.dump_header(True, self.options)
1702 def do_load(self, line): argument
1704 self.mach.dump_load_commands(True, self.options)
1707 def do_sections(self, line): argument
1709 self.mach.dump_sections(True, self.options)
1712 def do_symtab(self, line): argument
1714 self.mach.dump_symtab(True, self.options)