PK¤´IŽhY+ + xdis/wordcode.py"""Python disassembly functions specific to wordcode from python 3.6 """ from xdis import PYTHON3 from xdis.bytecode import op_has_argument def _unpack_opargs(code, opc): # enumerate() is not an option, since we sometimes process # multiple elements on a single pass through the loop extended_arg = 0 n = len(code) i = 0 while i < n: if PYTHON3: op = code[i] else: op = ord(code[i]) offset = i i += 1 arg = None if op_has_argument(op, opc): if PYTHON3: arg = code[i] + code[i+1]*256 + extended_arg else: arg = ord(code[i]) + ord(code[i+1])*256 + extended_arg extended_arg = 0 i += 2 if op == opc.EXTENDED_ARG: extended_arg = arg*65536 yield (offset, op, arg) def findlinestarts(code): """Find the offsets in a byte code which are start of lines in the source. Generate pairs (offset, lineno) as described in Python/compile.c. """ if PYTHON3: byte_increments = code.co_lnotab[0::2] line_increments = code.co_lnotab[1::2] else: byte_increments = [ord(c) for c in code.co_lnotab[0::2]] line_increments = [ord(c) for c in code.co_lnotab[1::2]] lastlineno = None lineno = code.co_firstlineno addr = 0 for byte_incr, line_incr in zip(byte_increments, line_increments): if byte_incr: if lineno != lastlineno: yield (addr, lineno) lastlineno = lineno addr += byte_incr if line_incr >= 0x80: # line_increments is an array of 8-bit signed integers line_incr -= 0x100 lineno += line_incr if lineno != lastlineno: yield (addr, lineno) def findlabels(code, opc): """Detect all offsets in a byte code which are jump targets. Return the list of offsets. """ labels = [] for offset, op, arg in _unpack_opargs(code, opc): if arg is not None: label = -1 if op in opc.hasjrel: label = offset + 3 + arg elif op in opc.hasjabs: label = arg if label >= 0: if label not in labels: labels.append(label) return labels PK¤´IŽÜJ“ÓÓ xdis/load.py# Copyright (c) 2015-2016 by Rocky Bernstein import imp, marshal, os, py_compile, sys, tempfile from struct import unpack, pack import xdis.unmarshal from xdis import PYTHON3, PYTHON_VERSION from xdis import magics from xdis.dropbox.decrypt25 import fix_dropbox_pyc def check_object_path(path): if path.endswith(".py"): try: import importlib return importlib.util.cache_from_source(path, optimization='') except: try: import imp imp.cache_from_source(path, debug_override=False) except: pass pass basename = os.path.basename(path)[0:-3] if PYTHON3: spath = path else: spath = path.decode('utf-8') path = tempfile.mkstemp(prefix=basename + '-', suffix='.pyc', text=False)[1] py_compile.compile(spath, cfile=path, doraise=True) if not path.endswith(".pyc") and not path.endswith(".pyo"): raise ValueError("path %s must point to a .py or .pyc file\n" % path) return path def is_pypy(magic_int): return magic_int in (62211+7, 3180+7) def load_file(filename): """ load a Python source file and compile it to byte-code _load_file(filename: string): code_object filename: name of file containing Python source code (normally a .py) code_object: code_object compiled from this source code This function does NOT write any file! """ fp = open(filename, 'rb') try: source = fp.read().decode('utf-8') + '\n' except UnicodeDecodeError: fp.seek(0) source = fp.read() + '\n' try: if PYTHON_VERSION < 2.6: co = compile(source, filename, 'exec') else: co = compile(source, filename, 'exec', dont_inherit=True) except SyntaxError: sys.stderr.write('>>Syntax error in %s\n' % filename) fp.close() raise fp.close() return co def load_module(filename, code_objects={}, fast_load=False, get_code=True): """load a module without importing it. load_module(filename: string): version, magic_int, code_object filename: name of file containing Python byte-code object (normally a .pyc) code_object: code_object from this file version: Python major/minor value e.g. 2.7. or 3.4 magic_int: more specific than version. The actual byte code version of the code object Parsing the code object takes a bit of parsing time, but sometimes all you want is the module info, time string, code size, python version, etc. For that, set get_code=False. """ timestamp = 0 fp = open(filename, 'rb') magic = fp.read(4) magic_int = magics.magic2int(magic) # For reasons I don't understand PyPy 3.2 stores a magic # of '0'... The two values below are for Python 2.x and 3.x respectively if magic[0:1] in ['0', chr(0)]: magic = magics.int2magic(3180+7) try: version = float(magics.versions[magic][:3]) except KeyError: if len(magic) >= 2: fp.close() raise ImportError("Unknown magic number %s in %s" % (ord(magic[0])+256*ord(magic[1]), filename)) else: fp.close() raise ImportError("Bad magic number: '%s'" % magic) if magic_int in (3361,): fp.close() raise ImportError("%s is interim Python %s (%d) bytecode which is not " "supported.\nFinal released versions are supported." % (filename, magics.versions[magic], magics.magic2int(magic))) elif magic_int == 62135: fp.seek(0) return fix_dropbox_pyc(fp) elif magic_int == 62215: fp.close() raise ImportError("%s is a dropbox-hacked Python %s (bytecode %d).\nSee " "https://github.com/kholia/dedrop " "for how to decrypt." % (filename, version, magics.magic2int(magic))) # print version ts = fp.read(4) timestamp = unpack("I", ts)[0] my_magic_int = magics.magic2int(imp.get_magic()) magic_int = magics.magic2int(magic) # Note: a higher magic number doesn't necessarily mean a later # release. At Python 3.0 the magic number decreased # significantly. Hence the range below. Also note inclusion of # the size info, occurred within a Python major/minor # release. Hence the test on the magic value rather than # PYTHON_VERSION, although PYTHON_VERSION would probably work. if 3200 <= magic_int < 20121: source_size = unpack("I", fp.read(4))[0] # size mod 2**32 else: source_size = None if get_code: if my_magic_int == magic_int: bytecode = fp.read() co = marshal.loads(bytecode) elif fast_load: co = xdis.marsh.load(fp, magic_int, code_objects) else: co = xdis.unmarshal.load_code(fp, magic_int, code_objects) pass else: co = None fp.close() return version, timestamp, magic_int, co, is_pypy(magic_int), source_size def write_bytecode_file(bytecode_path, code, magic_int, filesize=0): """Write bytecode file _bytecode_path_, with code for having Python magic_int (i.e. bytecode associated with some version of Python) """ fp = open(bytecode_path, 'w') fp.write(pack('Hcc', magic_int, '\r', '\n')) import time fp.write(pack('I', int(time.time()))) if (3000 <= magic_int < 20121): # In Python 3 you need to write out the size mod 2**32 here fp.write(pack('I', filesize)) fp.write(marshal.dumps(code)) fp.close() return # if __name__ == '__main__': # co = load_file(__file__) # obj_path = check_object_path(__file__) # version, timestamp, magic_int, co2, pypy, source_size = load_module(obj_path) # print("version", version, "magic int", magic_int, 'is_pypy', pypy) # import datetime # print(datetime.datetime.fromtimestamp(timestamp)) # if source_size: # print("source size mod 2**32: %d" % source_size) # assert co == co2 PK¤´I—#"Z88 xdis/main.py# Copyright (c) 2016 by Rocky Bernstein """ CPython independent disassembly routines There are two reasons we can't use Python's built-in routines from dis. First, the bytecode we are extracting may be from a different version of Python (different magic number) than the version of Python that is doing the extraction. Second, we need structured instruction information for the (de)-parsing step. Python 3.4 and up provides this, but we still do want to run on Python 2.7. """ # Note: we tend to eschew new Python 3 things, and even future # imports so this can run on older Pythons. This is # intended to be a more cross-version Python program import datetime, sys from collections import deque import xdis from xdis import IS_PYPY from xdis.bytecode import Bytecode from xdis.code import iscode from xdis.load import check_object_path, load_module from xdis.util import format_code_info from xdis.version import VERSION def get_opcode(version, is_pypy): # Set up disassembler with the right opcodes # Is there a better way? if version < 3.0: if version <= 2.3: if version == 1.5: from xdis.opcodes import opcode_15 return opcode_15 elif version == 2.0: from xdis.opcodes import opcode_20 return opcode_20 elif version == 2.1: from xdis.opcodes import opcode_21 return opcode_21 elif version == 2.2: from xdis.opcodes import opcode_22 return opcode_22 elif version == 2.3: from xdis.opcodes import opcode_23 return opcode_23 pass else: if version == 2.4: from xdis.opcodes import opcode_24 return opcode_24 elif version == 2.5: from xdis.opcodes import opcode_25 return opcode_25 elif version == 2.6: if is_pypy: from xdis.opcodes import opcode_pypy26 return opcode_pypy26 else: from xdis.opcodes import opcode_26 return opcode_26 elif version == 2.7: if is_pypy: from xdis.opcodes import opcode_pypy27 return opcode_pypy27 else: from xdis.opcodes import opcode_27 return opcode_27 pass pass else: if version < 3.3: if version == 3.0: from xdis.opcodes import opcode_30 return opcode_30 elif version == 3.1: from xdis.opcodes import opcode_31 return opcode_31 elif version == 3.2: from xdis.opcodes import opcode_32 return opcode_32 else: if version == 3.3: from xdis.opcodes import opcode_33 return opcode_33 elif version == 3.4: from xdis.opcodes import opcode_34 return opcode_34 elif version == 3.5: from xdis.opcodes import opcode_35 return opcode_35 elif version == 3.6: from xdis.opcodes import opcode_36 return opcode_36 raise TypeError("%s is not a Python version I know about" % version) def disco(bytecode_version, co, timestamp, out=sys.stdout, is_pypy=False, magic_int=None, source_size=None): """ diassembles and deparses a given code block 'co' """ assert iscode(co) # store final output stream for case of error real_out = out or sys.stdout if is_pypy: co_pypy_str = 'PyPy ' else: co_pypy_str = '' if IS_PYPY: run_pypy_str = 'PyPy ' else: run_pypy_str = '' if magic_int: m = str(magic_int) else: m = "" out.write(('# pydisasm version %s\n# %sPython bytecode %s%s' '\n# Disassembled from %sPython %s\n') % (VERSION, co_pypy_str, bytecode_version, " (%s)" % m, run_pypy_str, '\n# '.join(sys.version.split('\n')))) if timestamp > 0: value = datetime.datetime.fromtimestamp(timestamp) out.write(value.strftime('# Timestamp in code: ' '%Y-%m-%d %H:%M:%S\n')) if source_size: out.write(value.strftime('# Source code size mod 2**32: %d bytes\n' % source_size)) if co.co_filename: out.write(format_code_info(co, bytecode_version) + "\n") pass opc = get_opcode(bytecode_version, is_pypy) queue = deque([co]) disco_loop(opc, bytecode_version, queue, real_out) def disco_loop(opc, version, queue, real_out): while len(queue) > 0: co = queue.popleft() if co.co_name != '': real_out.write("\n" + format_code_info(co, version) + "\n") bytecode = Bytecode(co, opc) real_out.write(bytecode.dis() + "\n") for instr in bytecode.get_instructions(co): if iscode(instr.argval): queue.append(instr.argval) pass pass def disassemble_file(filename, outstream=sys.stdout): """ disassemble Python byte-code file (.pyc) If given a Python source file (".py") file, we'll try to find the corresponding compiled object. """ filename = check_object_path(filename) version, timestamp, magic_int, co, is_pypy, source_size = load_module(filename) disco(version, co, timestamp, outstream, is_pypy, magic_int, source_size) # print co.co_filename return filename, co, version, timestamp, magic_int def _test(): """Simple test program to disassemble a file.""" argc = len(sys.argv) if argc != 2: if argc == 1 and xdis.PYTHON3: fn = __file__ else: sys.stderr.write("usage: %s [-|CPython compiled file]\n" % __file__) sys.exit(2) else: fn = sys.argv[1] disassemble_file(fn) if __name__ == "__main__": _test() PKñ1uI¿Ê0˜˜ xdis/util.pyfrom xdis import PYTHON3 if PYTHON3: def code2num(code, i): return code[i] else: def code2num(code, i): return ord(code[i]) def num2code(num): return (num & 0xff, num >> 8) # The inspect module interrogates this dictionary to build its # list of CO_* constants. It is also used by pretty_flags to # turn the co_flags field into a human readable list. COMPILER_FLAG_NAMES = { 0x0001: "OPTIMIZED", 0x0002: "NEWLOCALS", 0x0004: "VARARGS", 0x0008: "VARKEYWORDS", 0x0010: "NESTED", 0x0020: "GENERATOR", 0x0040: "NOFREE", # These are in Python 3.x 0x0080: "COROUTINE", 0x0100: "ITERABLE_COROUTINE", # These are used only in Python 2.x */ 0x01000: "GENERATOR_ALLOWED", 0x02000: "FUTURE_DIVISION", 0x04000: "ABSOLUTE_IMPORT", 0x08000: "FUTURE_WITH_STATEMENT", 0x10000: "FUTURE_PRINT_FUNCTION", 0x20000: "FUTURE_UNICODE_LITERALS", 0x40000: "FUTURE_BARRY_AS_DBFL", # These are PYPY specific 0x100000: "KILL_DOCSTRING", 0x200000: "YIELD_INSIDE_TRY", 0x0100: "PYPY_SOURCE_IS_UTF8", 0x0200: "PYPY_DONT_IMPLY_DEDENT", 0x0400: "PYPY_ONLY_AST", 0x10000000 :"PYPY_ACCEPT_NULL_BYTES" } # Invert above dictionary so we can look up a bit value # from the compile flag name COMPILER_FLAG_BIT = dict([v, k] for (k, v) in COMPILER_FLAG_NAMES.items()) # Allow us to access by just name, prefixed with CO. e.g # CO_OPTIMIZED, CO_NOFREE globals().update(dict(['CO_'+k, v] for (k, v) in COMPILER_FLAG_BIT.items())) def pretty_flags(flags): """Return pretty representation of code flags.""" names = [] result = "0x%08x" % flags for i in range(32): flag = 1<= 3.0: lines.append("# Kw-only arguments: %s" % co.co_kwonlyargcount) pos_argc = co.co_argcount lines.append("# Number of locals: %s" % co.co_nlocals) lines.append("# Stack size: %s" % co.co_stacksize) lines.append("# Flags: %s" % pretty_flags(co.co_flags)) if co.co_consts: lines.append("# Constants:") for i_c in enumerate(co.co_consts): lines.append("# %4d: %r" % i_c) if co.co_names: lines.append("# Names:") for i_n in enumerate(co.co_names): lines.append("# %4d: %s" % i_n) if pos_argc > 0: lines.append("# Positional arguments:") lines.append("#\t%s" % ", ".join(co.co_varnames[:pos_argc])) pass if len(co.co_varnames) > pos_argc: lines.append("# Local variables:") for i, n in enumerate(co.co_varnames[pos_argc:]): lines.append("# %4d: %s" % (pos_argc+i, n)) if co.co_freevars: lines.append("# Free variables:") for i_n in enumerate(co.co_freevars): lines.append("# %4d: %s" % i_n) if co.co_cellvars: lines.append("# Cell variables:") for i_n in enumerate(co.co_cellvars): lines.append("# %4d: %s" % i_n) return "\n".join(lines) def _try_compile(source, name): """Attempts to compile the given source, first as an expression and then as a statement if the first approach fails. Utility function to accept strings in functions that otherwise expect code objects """ try: c = compile(source, name, 'eval') except SyntaxError: c = compile(source, name, 'exec') return c def get_code_object(x): """Helper to handle methods, functions, generators, strings and raw code objects""" if hasattr(x, '__func__'): # Method x = x.__func__ if hasattr(x, '__code__'): # Function x = x.__code__ if hasattr(x, 'gi_code'): # Generator x = x.gi_code if isinstance(x, str): # Source code x = _try_compile(x, "") if hasattr(x, 'co_code'): # Code object return x raise TypeError("don't know how to disassemble %s objects" % type(x).__name__) def code_info(x): """Formatted details of methods, functions, or code.""" return format_code_info(get_code_object(x)) def show_code(co): """Print details of methods, functions, or code to *file*. If *file* is not provided, the output is printed on stdout. """ print(code_info(co)) PK¤´I»4é—»»xdis/namedtuple25.pyfrom operator import itemgetter as _itemgetter from keyword import iskeyword as _iskeyword import sys as _sys def namedtuple(typename, field_names, verbose=False, rename=False): """Returns a new subclass of tuple with named fields. >>> Point = namedtuple('Point', 'x y') >>> Point.__doc__ # docstring for the new class 'Point(x, y)' >>> p = Point(11, y=22) # instantiate with positional args or keywords >>> p[0] + p[1] # indexable like a plain tuple 33 >>> x, y = p # unpack like a regular tuple >>> x, y (11, 22) >>> p.x + p.y # fields also accessable by name 33 >>> d = p._asdict() # convert to a dictionary >>> d['x'] 11 >>> Point(**d) # convert from a dictionary Point(x=11, y=22) >>> p._replace(x=100) # _replace() is like str.replace() but targets named fields Point(x=100, y=22) """ # Parse and validate the field names. Validation serves two purposes, # generating informative error messages and preventing template injection attacks. if isinstance(field_names, basestring): field_names = field_names.replace(',', ' ').split() # names separated by whitespace and/or commas field_names = tuple(map(str, field_names)) if rename: names = list(field_names) seen = set() for i, name in enumerate(names): if (not min(c.isalnum() or c=='_' for c in name) or _iskeyword(name) or not name or name[0].isdigit() or name.startswith('_') or name in seen): names[i] = '_%d' % i seen.add(name) field_names = tuple(names) for name in (typename,) + field_names: if not min(c.isalnum() or c=='_' for c in name): raise ValueError('Type names and field names can only contain alphanumeric characters and underscores: %r' % name) if _iskeyword(name): raise ValueError('Type names and field names cannot be a keyword: %r' % name) if name[0].isdigit(): raise ValueError('Type names and field names cannot start with a number: %r' % name) seen_names = set() for name in field_names: if name.startswith('_') and not rename: raise ValueError('Field names cannot start with an underscore: %r' % name) if name in seen_names: raise ValueError('Encountered duplicate field name: %r' % name) seen_names.add(name) # Create and fill-in the class template numfields = len(field_names) argtxt = repr(field_names).replace("'", "")[1:-1] # tuple repr without parens or quotes reprtxt = ', '.join('%s=%%r' % name for name in field_names) template = '''class %(typename)s(tuple): '%(typename)s(%(argtxt)s)' \n __slots__ = () \n _fields = %(field_names)r \n def __new__(_cls, %(argtxt)s): return _tuple.__new__(_cls, (%(argtxt)s)) \n @classmethod def _make(cls, iterable, new=tuple.__new__, len=len): 'Make a new %(typename)s object from a sequence or iterable' result = new(cls, iterable) if len(result) != %(numfields)d: raise TypeError('Expected %(numfields)d arguments, got %%d' %% len(result)) return result \n def __repr__(self): return '%(typename)s(%(reprtxt)s)' %% self \n def _asdict(self): 'Return a new dict which maps field names to their values' return dict(zip(self._fields, self)) \n def _replace(_self, **kwds): 'Return a new %(typename)s object replacing specified fields with new values' result = _self._make(map(kwds.pop, %(field_names)r, _self)) if kwds: raise ValueError('Got unexpected field names: %%r' %% kwds.keys()) return result \n def __getnewargs__(self): return tuple(self) \n\n''' % locals() for i, name in enumerate(field_names): template += ' %s = _property(_itemgetter(%d))\n' % (name, i) if verbose: print template # Execute the template string in a temporary namespace namespace = dict(_itemgetter=_itemgetter, __name__='namedtuple_%s' % typename, _property=property, _tuple=tuple) try: exec template in namespace except SyntaxError, e: raise SyntaxError(e.message + ':\n' + template) result = namespace[typename] # For pickling to work, the __module__ variable needs to be set to the frame # where the named tuple is created. Bypass this step in enviroments where # sys._getframe is not defined (Jython for example) or sys._getframe is not # defined for arguments greater than 0 (IronPython). try: result.__module__ = _sys._getframe(1).f_globals.get('__name__', '__main__') except (AttributeError, ValueError): pass return result PK°´I”œÛ*ÚÚ xdis/main.pyc;ò å²TXc@sàdZdkZdkZdklZdkZdklZdklZdk l Z dk l Z l Z dklZdklZd „Zeieeed „Zd „Zeid „Zd „Zedjo eƒndS(s° CPython independent disassembly routines There are two reasons we can't use Python's built-in routines from dis. First, the bytecode we are extracting may be from a different version of Python (different magic number) than the version of Python that is doing the extraction. Second, we need structured instruction information for the (de)-parsing step. Python 3.4 and up provides this, but we still do want to run on Python 2.7. N(sdeque(sIS_PYPY(sBytecode(siscode(scheck_object_paths load_module(sformat_code_info(sVERSIONcCsŸ|djo|djo®|djodkl}|Sqˆ|djodkl} | Sqˆ|djodkl}|Sqˆ|d jod kl}|Sqˆ|djod kl}|Sqˆq‹|d jod kl}|Sq‹|djodkl} | Sq‹|djo1|odkl }|Sqˆdkl }|Sq‹|djo1|odkl }|Sqˆdkl }|Sq‹n|djoj|djodkl}|Sq‹|djodkl}|Sq‹|djodkl} | Sq‹n‰|djodkl}|Sng|djodkl}|SnE|djod kl} | Sn#|d!jod"kl} | Sntd#|ƒ‚dS($Nf3.0f2.2999999999999998f1.5(s opcode_15f2.0(s opcode_20f2.1000000000000001(s opcode_21f2.2000000000000002(s opcode_22(s opcode_23f2.3999999999999999(s opcode_24f2.5(s opcode_25f2.6000000000000001(s opcode_pypy26(s opcode_26f2.7000000000000002(s opcode_pypy27(s opcode_27f3.2999999999999998(s opcode_30f3.1000000000000001(s opcode_31f3.2000000000000002(s opcode_32(s opcode_33f3.3999999999999999(s opcode_34f3.5(s opcode_35f3.6000000000000001(s opcode_36s'%s is not a Python version I know about(sversions xdis.opcodess opcode_15s opcode_20s opcode_21s opcode_22s opcode_23s opcode_24s opcode_25sis_pypys opcode_pypy26s opcode_26s opcode_pypy27s opcode_27s opcode_30s opcode_31s opcode_32s opcode_33s opcode_34s opcode_35s opcode_36s TypeError(sversionsis_pypys opcode_22s opcode_23s opcode_15s opcode_21s opcode_26s opcode_27s opcode_24s opcode_25s opcode_36s opcode_20s opcode_35s opcode_32s opcode_33s opcode_30s opcode_31s opcode_pypy26s opcode_pypy27s opcode_34((s)build/bdist.linux-x86_64/egg/xdis/main.pys get_opcodesz                                      c Csft|ƒpt‚|pti}|o d} nd} t o d} nd} |ot |ƒ} nd} |idt| |d| | ditiidƒƒfƒ|djo,tii|ƒ} |i| idƒƒn|o|i| id |ƒƒn|io|it||ƒdƒnt||ƒ}t|gƒ} t ||| |ƒd S( s: diassembles and deparses a given code block 'co' sPyPy ssO# pydisasm version %s # %sPython bytecode %s%s # Disassembled from %sPython %s s (%s)s # s is'# Timestamp in code: %Y-%m-%d %H:%M:%S s'# Source code size mod 2**32: %d bytes N(!siscodescosAssertionErrorsoutssyssstdoutsreal_outsis_pypys co_pypy_strsIS_PYPYs run_pypy_strs magic_intsstrsmswritesVERSIONsbytecode_versionsjoinsversionssplits timestampsdatetimes fromtimestampsvaluesstrftimes source_sizes co_filenamesformat_code_infos get_opcodesopcsdequesqueues disco_loop(sbytecode_versionscos timestampsoutsis_pypys magic_ints source_sizesreal_outsopcs run_pypy_strsmsvaluesqueues co_pypy_str((s)build/bdist.linux-x86_64/egg/xdis/main.pysdiscoes0  <  cCsÁxºt|ƒdjo¦|iƒ}|idjo"|idt||ƒdƒnt ||ƒ}|i|i ƒdƒx;|i |ƒD]*}t|iƒo|i|iƒqŠqŠWqWdS(Niss (slensqueuespopleftscosco_namesreal_outswritesformat_code_infosversionsBytecodesopcsbytecodesdissget_instructionssinstrsiscodesargvalsappend(sopcsversionsqueuesreal_outscosinstrsbytecode((s)build/bdist.linux-x86_64/egg/xdis/main.pys disco_loop“s "cCs]t|ƒ}t|ƒ\}}}}}}t |||||||ƒ|||||fSdS(sœ disassemble Python byte-code file (.pyc) If given a Python source file (".py") file, we'll try to find the corresponding compiled object. N( scheck_object_pathsfilenames load_modulesversions timestamps magic_intscosis_pypys source_sizesdiscos outstream(sfilenames outstreamscosis_pypys source_sizesversions magic_ints timestamp((s)build/bdist.linux-x86_64/egg/xdis/main.pysdisassemble_file¢s  cCs}ttiƒ}|djoF|djotio t}qotii dtƒti dƒntid}t |ƒdS(s*Simple test program to disassemble a file.iis$usage: %s [-|CPython compiled file] N( slenssyssargvsargcsxdissPYTHON3s__file__sfnsstderrswritesexitsdisassemble_file(sargcsfn((s)build/bdist.linux-x86_64/egg/xdis/main.pys_test¯s   s__main__(s__doc__sdatetimessyss collectionssdequesxdissIS_PYPYs xdis.bytecodesBytecodes xdis.codesiscodes xdis.loadscheck_object_paths load_modules xdis.utilsformat_code_infos xdis.versionsVERSIONs get_opcodesstdoutsFalsesNonesdiscos disco_loopsdisassemble_files_tests__name__(sdeques disco_loopsIS_PYPYscheck_object_paths_tests load_modulesdisassemble_filesdatetimessyssVERSIONsBytecodesformat_code_infos get_opcodesxdissiscodesdisco((s)build/bdist.linux-x86_64/egg/xdis/main.pys? s         F.  PK°´I"ì«££xdis/verify.pyc;ò å²TXc@s¨dkZdkZdkZdkZdklZlZlZlZdk l Z ei ƒZ d„Z d„Zd„Zd„Zd„ZedjoeeƒndS( N(smagicssPYTHON3sPYTHON_VERSIONsIS_PYPY(s load_modulecCsëtox|it|d@gƒƒ|it|d?d@gƒƒ|it|d?d@gƒƒ|it|d?d@gƒƒni|it|d@ƒƒ|it|d?d@ƒƒ|it|d?d@ƒƒ|it|d?d@ƒƒdS(s>Internal; write a 32-bit int to a file in little-endian order.iÿiiiN(sPYTHON3sfswritesbytessxschr(sfsx((s+build/bdist.linux-x86_64/egg/xdis/verify.pyswr_longs"cCsd|t|ƒf}t}y¨t|dƒ}to#|itddddgƒƒn|idƒt ||ƒt i ||ƒ|iƒ|iddƒ|i|ƒ|iƒti||ƒWn=tj o1yti|ƒWntj onX‚nX|o|iƒndS(sÇWrite code object as a byte-compiled file Arguments: codeobject: code object filefile: bytecode file to write timestamp: timestamp to put in file magic: Pyton bytecode magic s%s.%sswbisN(sfilenamesidspath_tmpsNonesfcsopensPYTHON3swritesbytesswr_longs timestampsmarshalsdumps codeobjectsflushsseeksmagicsclosesossrenamesOSErrorsunlink(s codeobjectsfilenames timestampsmagicspath_tmpsfc((s+build/bdist.linux-x86_64/egg/xdis/verify.pys dump_compiles.#     cCsA|i|ijpt‚t|iƒt|iƒjptd|i|if‚|i|ijpt‚|i|ijpt‚|i|ijpt‚|i |i jpt‚|i |i jpt‚|i |i jpt‚|i |i jpt‚|i |i jpt‚|i|ijpt‚dS(Nsconsts: %s vs. %s(sc1s co_argcountsc2sAssertionErrorslens co_constss co_filenamesco_firstlinenosco_flagss co_lnotabsco_namesco_namess co_nlocalss co_stacksizes co_varnames(sc1sc2((s+build/bdist.linux-x86_64/egg/xdis/verify.pys compare_code6s9cCs²t|dƒ}|iƒ}|it|dƒ}|iƒ}|itdjot o5|d|djpt d|d|df‚n"||jpt d||f‚dS(Nsrbf3.2000000000000002isbyteode: %s vs %s( sopensbc_file1sfsreadsbytes1sclosesbc_file2sbytes2sPYTHON_VERSIONsIS_PYPYsAssertionError(sbc_file1sbc_file2sfsbytes1sbytes2((s+build/bdist.linux-x86_64/egg/xdis/verify.pyscompare_bytecode_filesEs  5cCs‘tiƒ}tii|dƒ}tii|ƒ odSnyt |dƒ} Wn dSnX| i ƒ}| i ƒt||dƒ}t|ƒ\}}}} } }|ddjo d}ntti|ƒjp)td|titƒtiƒ|f‚tii|d ƒ}t|||tƒt|d | ƒ\}}}} } }tii|d ƒ} t|| |ti|ƒƒt"|| ƒdSdS( s‰Compile *real_source_filename* using the running Python interpreter. Then write bytecode out to a new place again using Python's routines. Next load it in using two of our routines. Compare that the code objects there are equal. Next write out the bytecode (using the same Python bytecode writin routine as in step 1. Finally compare the bytecode files. s testing.pyNsUsexecil ii0smagic_int %d vs %d in %s/%ss testing1.pycs fast_loads testing2.pyc(#stempfiles gettempdirstempdirsosspathsjoinssource_filenamesexistssreal_source_filenamesopensfsreads codestringsclosescompiles codeobject1s load_modulesreal_bytecode_filenamesversions timestamps magic_ints codeobject2sis_pypys source_sizesMAGICsmagicss int2magicsAssertionErrors magic2intsgetcwdsbytecode_filename1s dump_compiles codeobject3sbytecode_filename2scompare_bytecode_files(sreal_source_filenamesreal_bytecode_filenames magic_ints source_sizesversionstempdirs timestampssource_filenames codeobject1s codeobject3s codeobject2sfsis_pypysbytecode_filename2sbytecode_filename1s codestring((s+build/bdist.linux-x86_64/egg/xdis/verify.pys verify_fileTs.     ?% s__main__(simpsossmarshalstempfilesxdissmagicssPYTHON3sPYTHON_VERSIONsIS_PYPYs xdis.loads load_modules get_magicsMAGICswr_longs dump_compiles compare_codescompare_bytecode_filess verify_files__name__s__file__(scompare_bytecode_filessMAGICsPYTHON_VERSIONstempfiles verify_files load_modulesimps dump_compilesmagicssIS_PYPYs compare_codesossmarshalsPYTHON3swr_long((s+build/bdist.linux-x86_64/egg/xdis/verify.pys?s$   "   4 PK¤´I†•ÜdN6N6xdis/unmarshal.py""" CPython magic- and version-independent Python object deserialization (unmarshal). This is needed when the bytecode extracted is from a different version than the currently-running Python. When the two are the same, you can simply use Python's built-in marshal.loads() to produce a code object """ # Copyright (c) 2015-2016 by Rocky Bernstein # Copyright (c) 2000-2002 by hartmut Goebel import sys, types from struct import unpack from xdis.magics import PYTHON_MAGIC_INT from xdis.code import Code3 from xdis import PYTHON3, PYTHON_VERSION internStrings = [] internObjects = [] if PYTHON3: def long(n): return n else: import unicodedata def compat_str(s): if PYTHON_VERSION > 3.2: return s.decode('utf-8', errors='ignore') elif PYTHON3: return s.decode() else: return str(s) def compat_u2s(u): if PYTHON_VERSION < 3.0: # See also unaccent.py which can be found using google. I # found it and this code via # https://www.peterbe.com/plog/unicode-to-ascii where it is a # dead link. That can potentially do better job in converting accents. return unicodedata.normalize('NFKD', u).encode('ascii', 'ignore') else: return str(u) def load_code(fp, magic_int, code_objects={}): """ marshal.load() written in Python. When the Python bytecode magic loaded is the same magic for the running Python interpreter, we can simply use the Python-supplied mashal.load(). However we need to use this when versions are different since the internal code structures are different. Sigh. """ global internStrings, internObjects internStrings = [] internObjects = [] seek_pos = fp.tell() # Do a sanity check. Is this a code type? b = ord(fp.read(1)) if (b & 0x80): b = b & 0x7f c = chr(b) if c != 'c': raise TypeError("File %s doesn't smell like Python bytecode" % fp.name) fp.seek(seek_pos) return load_code_internal(fp, magic_int, code_objects=code_objects) def load_code_type(fp, magic_int, bytes_for_s=False, code_objects={}): # Python [1.3 .. 2.2) # FIXME: find out what magics were for 1.3 v13_to_22 = magic_int in (11913, 5892, 20121, 50428, 50823, 60202, 60717) # Python [1.5 .. 2.2) v15_to_22 = magic_int in (20121, 50428, 50823, 60202, 60717) v15_to_20 = magic_int in (20121, 50428, 50823) v13_to_20 = magic_int in (11913, 5892, 20121, 50428, 50823) if v13_to_22: co_argcount = unpack('h', fp.read(2))[0] else: co_argcount = unpack('i', fp.read(4))[0] if 3020 < magic_int < 20121: kwonlyargcount = unpack('i', fp.read(4))[0] else: kwonlyargcount = 0 if v13_to_22: co_nlocals = unpack('h', fp.read(2))[0] else: co_nlocals = unpack('i', fp.read(4))[0] if v15_to_22: co_stacksize = unpack('h', fp.read(2))[0] else: co_stacksize = unpack('i', fp.read(4))[0] if v13_to_22: co_flags = unpack('h', fp.read(2))[0] else: co_flags = unpack('i', fp.read(4))[0] co_code = load_code_internal(fp, magic_int, bytes_for_s=True, code_objects=code_objects) co_consts = load_code_internal(fp, magic_int, code_objects=code_objects) co_names = load_code_internal(fp, magic_int, code_objects=code_objects) # FIXME: only if >= 1.3 co_varnames = load_code_internal(fp, magic_int, code_objects=code_objects) if not v13_to_20: co_freevars = load_code_internal(fp, magic_int, code_objects=code_objects) co_cellvars = load_code_internal(fp, magic_int, code_objects=code_objects) else: co_freevars = tuple() co_cellvars = tuple() co_filename = load_code_internal(fp, magic_int, code_objects=code_objects) co_name = load_code_internal(fp, magic_int) if v15_to_22: co_firstlineno = unpack('h', fp.read(2))[0] else: co_firstlineno = unpack('i', fp.read(4))[0] # FIXME: only if >= 1.5 co_lnotab = load_code_internal(fp, magic_int, code_objects=code_objects) # The Python3 code object is different than Python2's which # we are reading if we get here. # Also various parameters which were strings are now # bytes (which is probably more logical). if PYTHON3: Code = types.CodeType if PYTHON_MAGIC_INT > 3020: # In later Python3 magic_ints, there is a # kwonlyargcount parameter which we set to 0. if v15_to_20: code = Code(co_argcount, kwonlyargcount, co_nlocals, co_stacksize, co_flags, co_code, co_consts, co_names, co_varnames, co_filename, co_name, co_firstlineno, bytes(co_lnotab, encoding='utf-8'), co_freevars, co_cellvars) else: code = Code(co_argcount, kwonlyargcount, co_nlocals, co_stacksize, co_flags, co_code, co_consts, co_names, co_varnames, co_filename, co_name, co_firstlineno, bytes(co_lnotab, encoding='utf-8'), co_freevars, co_cellvars) else: code = Code(co_argcount, kwonlyargcount, co_nlocals, co_stacksize, co_flags, co_code, co_consts, co_names, co_varnames, co_filename, co_name, co_firstlineno, bytes(co_lnotab, encoding='utf-8'), co_freevars, co_cellvars) else: if (3000 <= magic_int < 20121): # Python 3 encodes some fields as Unicode while Python2 # requires the corresponding field to have string values for s in co_consts: if isinstance(s, unicode): s = compat_u2s(s) for s in co_names: if isinstance(s, unicode): s = compat_u2s(s) for s in co_varnames: if isinstance(s, unicode): s = compat_u2s(s) co_filename = str(co_filename) co_name = str(co_name) if 3020 < magic_int <= 20121: code = Code3(co_argcount, kwonlyargcount, co_nlocals, co_stacksize, co_flags, co_code, co_consts, co_names, co_varnames, co_filename, co_name, co_firstlineno, co_lnotab, co_freevars, co_cellvars) else: Code = types.CodeType code = Code(co_argcount, co_nlocals, co_stacksize, co_flags, co_code, co_consts, co_names, co_varnames, co_filename, co_name, co_firstlineno, co_lnotab, co_freevars, co_cellvars) pass pass code_objects[str(code)] = code return code # Python 3.4+ support for reference objects. # The names follow marshal.c def r_ref_reserve(obj, flag): i = None if flag: i = len(internObjects) internObjects.append(obj) return obj, i def r_ref_insert(obj, i): if i is not None: internObjects[i] = obj return obj def r_ref(obj, flag): if flag: internObjects.append(obj) return obj # Bit set on marshalType if we should # add obj to internObjects. # FLAG_REF is the marchal.c name FLAG_REF = 0x80 # FIXME: redo with a dispatch table same as # marshal. # In marshal.c this method is called r_object() def load_code_internal(fp, magic_int, bytes_for_s=False, code_objects={}): global internStrings, internObjects b1 = ord(fp.read(1)) flag = False if b1 & FLAG_REF: # Since 3.4, "flag" is the marshal.c name flag = True b1 = b1 & (FLAG_REF-1) marshalType = chr(b1) # print(marshalType) # debug if marshalType == '0': # In C this NULL. Not sure what it should # translate here. Note NULL != None which is below return None elif marshalType == 'N': return None elif marshalType == 'S': return StopIteration elif marshalType == '.': return Ellipsis elif marshalType == 'F': return False elif marshalType == 'T': return True elif marshalType == 'i': # int32 return r_ref(int(unpack('i', fp.read(4))[0]), flag) elif marshalType == 'l': # long n = unpack('i', fp.read(4))[0] if n == 0: return long(0) size = abs(n) d = long(0) for j in range(0, size): md = int(unpack('h', fp.read(2))[0]) d += md << j*15 if n < 0: d = long(d*-1) return r_ref(d, flag) elif marshalType == 'I': # int64. Python 3.4 removed this. return unpack('q', fp.read(8))[0] elif marshalType == 'f': # float - Seems not in use after Python 2.4 strsize = unpack('B', fp.read(1))[0] s = fp.read(strsize) return r_ref(float(s), flag) elif marshalType == 'g': # binary float return r_ref(float(unpack('d', fp.read(8))[0]), flag) elif marshalType == 'x': # complex if magic_int <= 62061: get_float = lambda: float(fp.read(unpack('B', fp.read(1))[0])) else: get_float = lambda: float(fp.read(unpack('i', fp.read(4))[0])) real = get_float() imag = get_float() return r_ref(complex(real, imag), flag) elif marshalType == 'y': # binary complex real = unpack('d', fp.read(8))[0] imag = unpack('d', fp.read(8))[0] return r_ref(complex(real, imag), flag) elif marshalType == 's': # string # Note: could mean bytes in Python3 processing Python2 bytecode strsize = unpack('i', fp.read(4))[0] s = fp.read(strsize) if not bytes_for_s: s = compat_str(s) return r_ref(s, flag) elif marshalType == 'A': # ascii interned - Python3 3.4 # FIXME: check strsize = unpack('i', fp.read(4))[0] interned = compat_str(fp.read(strsize)) internStrings.append(interned) return r_ref(interned, flag) elif marshalType == 'a': # ascii. Since Python 3.4 strsize = unpack('i', fp.read(4))[0] s = fp.read(strsize) s = compat_str(s) return r_ref(s, flag) elif marshalType == 'z': # short ascii - since Python 3.4 strsize = unpack('B', fp.read(1))[0] return r_ref(compat_str(fp.read(strsize)), flag) elif marshalType == 'Z': # short ascii interned - since Python 3.4 # FIXME: check strsize = unpack('B', fp.read(1))[0] interned = compat_str(fp.read(strsize)) internStrings.append(interned) return r_ref(interned, flag) elif marshalType == 't': # interned - since Python 3.4 strsize = unpack('i', fp.read(4))[0] interned = compat_str(fp.read(strsize)) internStrings.append(interned) return r_ref(interned, flag) elif marshalType == 'u': strsize = unpack('i', fp.read(4))[0] unicodestring = fp.read(strsize) return r_ref(unicodestring.decode('utf-8'), flag) elif marshalType == ')': # small tuple - since Python 3.4 tuplesize = unpack('B', fp.read(1))[0] ret, i = r_ref_reserve(tuple(), flag) while tuplesize > 0: ret += load_code_internal(fp, magic_int, code_objects=code_objects), tuplesize -= 1 pass return r_ref_insert(ret, i) elif marshalType == '(': # tuple tuplesize = unpack('i', fp.read(4))[0] ret = r_ref(tuple(), flag) while tuplesize > 0: ret += load_code_internal(fp, magic_int, code_objects=code_objects), tuplesize -= 1 return ret elif marshalType == '[': # list. FIXME: check me n = unpack('i', fp.read(4))[0] ret = r_ref(list(), flag) while n > 0: ret += load_code_internal(fp, magic_int, code_objects=code_objects), tuplesize -= 1 return ret elif marshalType == '{': ret = r_ref(dict(), flag) # dictionary # while True: # key = load_code_internal(fp, magic_int, code_objects=code_objects) # if key is NULL: # break # val = load_code_internal(fp, magic_int, code_objects=code_objects) # if val is NULL: # break # ret[key] = val # pass raise KeyError(marshalType) elif marshalType in ['<', '>']: # set and frozenset setsize = unpack('i', fp.read(4))[0] ret, i = r_ref_reserve(tuple(), flag) while setsize > 0: ret += load_code_internal(fp, magic_int, code_objects=code_objects), setsize -= 1 if marshalType == '>': return r_ref_insert(frozenset(ret), i) else: return r_ref_insert(set(ret), i) elif marshalType == 'R': # Python 2 string reference refnum = unpack('i', fp.read(4))[0] return internStrings[refnum] elif marshalType == 'c': return load_code_type(fp, magic_int, bytes_for_s=False, code_objects=code_objects) elif marshalType == 'C': # code type used in Python 1.0 - 1.2 raise KeyError("C code is Python 1.0 - 1.2; can't handle yet") elif marshalType == 'r': # object reference - since Python 3.4 refnum = unpack('i', fp.read(4))[0] o = internObjects[refnum-1] return o elif marshalType == '?': # unknown raise KeyError(marshalType) else: sys.stderr.write("Unknown type %i (hex %x) %c\n" % (ord(marshalType), ord(marshalType), ord(marshalType))) return PK°´IB ÏW%+%+xdis/unmarshal.pyc;ò å²TXc@sÜdZdkZdkZdklZdklZdklZdk l Z l Z ga ga e o d„Zn dkZd„Zd„Zhd „Zehd „Zd „Zd „Zd „ZdZehd„ZdS(s( CPython magic- and version-independent Python object deserialization (unmarshal). This is needed when the bytecode extracted is from a different version than the currently-running Python. When the two are the same, you can simply use Python's built-in marshal.loads() to produce a code object N(sunpack(sPYTHON_MAGIC_INT(sCode3(sPYTHON3sPYTHON_VERSIONcCs|SdS(N(sn(sn((s.build/bdist.linux-x86_64/egg/xdis/unmarshal.pyslongscCsGtdjo|idddƒSn to|iƒSn t|ƒSdS(Nf3.2000000000000002sutf-8serrorssignore(sPYTHON_VERSIONsssdecodesPYTHON3sstr(ss((s.build/bdist.linux-x86_64/egg/xdis/unmarshal.pys compat_strs  cCs;tdjo tid|ƒiddƒSn t|ƒSdS(Nf3.0sNFKDsasciisignore(sPYTHON_VERSIONs unicodedatas normalizesusencodesstr(su((s.build/bdist.linux-x86_64/egg/xdis/unmarshal.pys compat_u2s&s  cCsšgaga|iƒ}t|idƒƒ}|d@o|d@}nt|ƒ}|djot d|i ƒ‚n|i |ƒt ||d|ƒSdS(s= marshal.load() written in Python. When the Python bytecode magic loaded is the same magic for the running Python interpreter, we can simply use the Python-supplied mashal.load(). However we need to use this when versions are different since the internal code structures are different. Sigh. ii€iscs*File %s doesn't smell like Python bytecodes code_objectsN(s internStringss internObjectssfpstellsseek_possordsreadsbschrscs TypeErrorsnamesseeksload_code_internals magic_ints code_objects(sfps magic_ints code_objectsscsseek_possb((s.build/bdist.linux-x86_64/egg/xdis/unmarshal.pys load_code0s     cCsI|dddddddfj} |dddddfj}|dddfj}|dddddfj} | o td|id ƒƒd } ntd |id ƒƒd } d |jo djno td |id ƒƒd }nd }| o td|id ƒƒd }ntd |id ƒƒd }|o td|id ƒƒd }ntd |id ƒƒd }| o td|id ƒƒd }ntd |id ƒƒd }t ||dtd|ƒ}t ||d|ƒ}t ||d|ƒ}t ||d|ƒ}| o.t ||d|ƒ}t ||d|ƒ}ntƒ}tƒ}t ||d|ƒ}t ||ƒ} |o td|id ƒƒd } ntd |id ƒƒd } t ||d|ƒ}toïti}td jo“|oF|| |||||||||| | t |ddƒ||ƒ}qÌ|| |||||||||| | t |ddƒ||ƒ}q1|| |||||||||| | t |ddƒ||ƒ}nbd|jo djno¯x.|D]&}t#|t$ƒot%|ƒ}qõqõWx.|D]&}t#|t$ƒot%|ƒ}q&q&Wx.|D]&}t#|t$ƒot%|ƒ}qWqWWt&|ƒ}t&| ƒ} nd |jo djno:t'| |||||||||| | |||ƒ}n=ti}|| ||||||||| | |||ƒ}||t&|ƒ<|SdS(Ni‰.ii™NiüÄi‡Æi*ëi-íshiisiiiÌ s bytes_for_ss code_objectssencodingsutf-8i¸ ((s magic_ints v13_to_22s v15_to_22s v15_to_20s v13_to_20sunpacksfpsreads co_argcountskwonlyargcounts co_nlocalss co_stacksizesco_flagssload_code_internalsTrues code_objectssco_codes co_constssco_namess co_varnamess co_freevarss co_cellvarsstuples co_filenamesco_namesco_firstlinenos co_lnotabsPYTHON3stypessCodeTypesCodesPYTHON_MAGIC_INTsbytesscodesss isinstancesunicodes compat_u2ssstrsCode3(sfps magic_ints bytes_for_ss code_objectsscodes co_freevarsskwonlyargcounts co_cellvarss co_varnamessco_firstlinenos v13_to_22s v13_to_20sco_names co_argcountsco_codes co_lnotabsco_flagss v15_to_20s v15_to_22sCodes co_filenames co_constssss co_nlocalss co_stacksizesco_names((s.build/bdist.linux-x86_64/egg/xdis/unmarshal.pysload_code_typeJsž!               cCs8t}|ottƒ}ti|ƒn||fSdS(N(sNonesisflagslens internObjectssappendsobj(sobjsflagsi((s.build/bdist.linux-x86_64/egg/xdis/unmarshal.pys r_ref_reserveÀs  cCs#|tj o|t|7}qnW|d jot|dƒ}nt ||ƒSnW| djotdˆidƒƒd Sn,| djoBtdˆidƒƒd }ˆi|ƒ} t t| ƒ|ƒSnÝ| djo-t ttdˆidƒƒd ƒ|ƒSn£| djoU|djo‡d†}n ‡d†}|ƒ}|ƒ} t t|| ƒ|ƒSnA| djoRtdˆidƒƒd }tdˆidƒƒd } t t|| ƒ|ƒSnâ| djoTtdˆid ƒƒd }ˆi|ƒ} | ot!| ƒ} nt | |ƒSn| djoOtdˆid ƒƒd }t!ˆi|ƒƒ} t#i$| ƒt | |ƒSn%| djoHtdˆid ƒƒd }ˆi|ƒ} t!| ƒ} t | |ƒSnÐ| djo<tdˆidƒƒd }t t!ˆi|ƒƒ|ƒSn‡| d joOtdˆidƒƒd }t!ˆi|ƒƒ} t#i$| ƒt | |ƒSn+| d!joOtdˆid ƒƒd }t!ˆi|ƒƒ} t#i$| ƒt | |ƒSnÏ| d"joEtdˆid ƒƒd }ˆi|ƒ} t | i&d#ƒ|ƒSn}| d$jo€tdˆidƒƒd }t(t)ƒ|ƒ\}}x8|d jo*|t,ˆ|d%|ƒf7}|d8}qüWt.||ƒSnð| d&joqtdˆid ƒƒd }t t)ƒ|ƒ}x8|d jo*|t,ˆ|d%|ƒf7}|d8}qƒW|Snr| d'joqtdˆid ƒƒd }t t/ƒ|ƒ}x8|d jo*|t,ˆ|d%|ƒf7}|d8}qW|Snô| d(jo"t t0ƒ|ƒ}t1| ƒ‚nÅ| d)d*gjoªtdˆid ƒƒd }t(t)ƒ|ƒ\}}x8|d jo*|t,ˆ|d%|ƒf7}|d8}qºW| d*jot.t3|ƒ|ƒSq4 t.t4|ƒ|ƒSn| d+jo(tdˆid ƒƒd }t#|SnÓ| d,jot6ˆ|d-td%|ƒSn©| d.jot1d/ƒ‚nŒ| d0jo2tdˆid ƒƒd }t7|d}|SnM| d1jot1| ƒ‚n0t9i:i;d2t| ƒt| ƒt| ƒfƒdSdS(3Nis0sNsSs.sFsTsiiislshiiiÿÿÿÿsIsqisfsBsgsdsximòcs)tˆitdˆidƒƒdƒƒS(NsBii(sfloatsfpsreadsunpack((sfp(s.build/bdist.linux-x86_64/egg/xdis/unmarshal.pysscs)tˆitdˆidƒƒdƒƒS(Nsiii(sfloatsfpsreadsunpack((sfp(s.build/bdist.linux-x86_64/egg/xdis/unmarshal.pysssysssAsaszsZstsusutf-8s)s code_objectss(s[s{ssRscs bytes_for_ssCs,C code is Python 1.0 - 1.2; can't handle yetsrs?sUnknown type %i (hex %x) %c (<sordsfpsreadsb1sFalsesflagsFLAG_REFsTrueschrs marshalTypesNones StopIterationsEllipsissr_refsintsunpacksnslongsabsssizesdsrangesjsmdsstrsizesssfloats magic_ints get_floatsrealsimagscomplexs bytes_for_ss compat_strsinterneds internStringssappends unicodestringsdecodes tuplesizes r_ref_reservestuplesretsisload_code_internals code_objectss r_ref_insertslistsdictsKeyErrorssetsizes frozensetssetsrefnumsload_code_types internObjectssossyssstderrswrite(sfps magic_ints bytes_for_ss code_objectssreals get_floatsb1ssetsizessizesinterneds marshalTypes unicodestringsssimagsrefnumsflagsrets tuplesizesdsmdsisjsosnsstrsize((sfps.build/bdist.linux-x86_64/egg/xdis/unmarshal.pysload_code_internalÙs         -    "    -                                   /(s__doc__ssysstypessstructsunpacks xdis.magicssPYTHON_MAGIC_INTs xdis.codesCode3sxdissPYTHON3sPYTHON_VERSIONs internStringss internObjectsslongs unicodedatas compat_strs compat_u2ss load_codesFalsesload_code_types r_ref_reserves r_ref_insertsr_refsFLAG_REFsload_code_internal(sPYTHON_MAGIC_INTs compat_strs unicodedatasCode3sPYTHON_VERSIONs r_ref_insertsr_refslongssyssFLAG_REFstypessload_code_types r_ref_reserves load_codesload_code_internals compat_u2ssunpacksPYTHON3((s.build/bdist.linux-x86_64/egg/xdis/unmarshal.pys? s&       v   PK°´Iuž©xdis/magics.pyc;ò ç²TXc@sÔdkZdkZdkZd„Zd„ZeeiƒƒZhZhZd„Z hedƒd<edƒd<edƒd <edƒd <ed ƒd <ed ƒd <edƒd<edƒd<edƒd<edƒd<edƒd<edƒd<edƒd<edƒd<edƒd<edƒd<edƒd<ed ƒd!<ed"ƒd!<ed#ƒd$<ed%ƒd&<ed'ƒd(<ed)ƒd*<ed+ƒd,<ed-ƒd.<ed/ƒd0<ed1ƒd2<ed3ƒd4<ed5ƒd6<ed7ƒd8<ed5d9ƒd:<ed;ƒd<<ed=ƒd><ed?ƒd@<edAƒdB<edCƒdD<edEƒdF<edGƒdH<edIƒdJ<edKƒdL<edMƒdN<edOƒdP<edQƒdR<edSƒdT<edUƒdV<edWƒdX<edYƒdZ<ed[ƒd\<ed]ƒd^<ed_ƒd`<edaƒdb<edad9ƒdc<eddƒde<edfƒdg<edhƒdi<edjƒdk<edlƒdm<ednƒdo<edpƒdq<edrƒds<edtƒdu<edvƒdw<edxƒdy<edzƒd{<ed|ƒd}<ed~ƒd<ed€ƒd<ed€ƒd‚<edƒƒd„<ed…ƒd†<ed‡ƒdˆ<ed‰ƒdŠ}nd}|d7}nWt||ƒt||dƒd|} |d7}||ijo| d}nd}| } ||ijot| |ƒ\} }qI||ijot| |ƒ\} }qI||i!jo|| } d t"| ƒ}qI||i#jo| } d t"| ƒ}qI||i$jot| |ƒ\} }qI||i&jo|i'| } | }qI||i(jot| |ƒ\} }qI||i*jo:| o.d t||dƒt||dƒf}q0qI|o ||i+jot,| ƒ}qIn|o|d7}n|i-|} t.| || | ||||| ƒ VqVWd S( s&Iterate over the instructions in a bytecode string. Generates a sequence of Instruction namedtuples giving the details of each opcode. Additional information about the code's runtime environment (e.g. variable names, constants) can be specified using optional arguments. if3.6000000000000001isiiiisto s%d positional, %d keyword pairN(/s findlabelsscodesopcslabelss extended_argspython_versionsTrues python_36sFalsesNones starts_lineslensnsiscode2numsopsoffsets linestartssgets line_offsetsis_jump_targetsargsargvalsargreprsop_has_argumentshas_args EXTENDED_ARGshasconsts_get_const_infos constantsshasnames_get_name_infosnamesshasjrelsreprshasjabsshaslocalsvarnamess hascomparescmp_opshasfreescellsshasnargss FORMAT_VALUEspretty_format_value_flagssopnames Instruction(scodesopcsvarnamessnamess constantsscellss linestartss line_offsets extended_argsargvalslabelssargsopnamesis_jump_targets starts_linesoffsetshas_argsargreprsisns python_36sop((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pysget_instructions_bytes“s€        (    2 cCs||ijSdS(N(sopsopcs HAVE_ARGUMENT(sopsopc((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pysop_has_argumentïss _InstructionsJopname opcode arg argval argrepr has_arg offset starts_line is_jump_targetcCs8x|io |i}qW||iid|iƒSdS(s/ Construct a Bytecode from the given traceback scurrent_offsetN(stbstb_nextsclsstb_framesf_codestb_lasti(sclsstb((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pysfrom_tracebackõs  s InstructioncBstZdZded„ZRS(sJDetails for a bytecode operation Defined fields: opname - human readable name for operation opcode - numeric code for operation arg - numeric argument to operation (if any), otherwise None argval - resolved arg value (if known), otherwise same as arg argrepr - human readable description of operation argument has_arg - True opcode takes an argument. In that case, argval and argepr will have that value. False if this opcode doesn't take an argument. In that case, don't look at argval or ardrepr. offset - start index of operation within bytecode sequence starts_line - line started by this opcode (if any), otherwise None is_jump_target - True if other code jumps to here, otherwise False icCsIg}|oG|itj o"d|}|i||iƒqT|id|ƒn|o|idƒn|idƒ|io|idƒn|idƒ|it |i ƒi dƒƒ|i|i i dƒƒ|itj oI|it |iƒi d ƒƒ|io|id |id ƒq2ndi|ƒiƒSd S( sßFormat instruction details for inclusion in disassembly output *lineno_width* sets the width of the line number field (0 omits it) *mark_as_current* inserts a '-->' marker arrow as part of the line s%%%dds s-->s s>>s iiis(s)N(sfieldss lineno_widthsselfs starts_linesNones lineno_fmtsappendsmark_as_currentsis_jump_targetsreprsoffsetsrjustsopnamesljustsargsargreprsjoinsrstrip(sselfs lineno_widthsmark_as_currentsfieldss lineno_fmt((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pys _disassemble s(      (s__name__s __module__s__doc__sFalses _disassemble(((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pys Instructionûs sBytecodec BsqtZdZeed„Zd„Zd„Zd„Zd„Zdeeeeee i dd„Z ed „Z RS( sñThe bytecode operations of a piece of code Instantiate this with a function, method, string of code, or a code object (as returned by compile()). Iterating over this yields the bytecode operations as Instruction instances. cCs¨t|ƒ|_}|tjo|i|_d|_n||_||i|_|i |i |_ t |i|ƒƒ|_||_||_ |i|_||_dS(Ni(sget_code_objectsxsselfscodeobjscos first_linesNonesco_firstlinenos _line_offsets co_cellvarss co_freevarss _cell_namessdictsopcsfindlinestartss _linestartss_original_objectsopnamesopnamesscurrent_offset(sselfsxsopcs first_linescurrent_offsetsco((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pys__init__;s       c CsG|i}t|i|i|i|i|i|i |i d|i ƒSdS(Ns line_offset( sselfscodeobjscosget_instructions_bytessco_codesopcs co_varnamessco_namess co_constss _cell_namess _linestartss _line_offset(sselfsco((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pys__iter__Js   cCsdi|ii|iƒSdS(Ns{}({!r})(sformatsselfs __class__s__name__s_original_object(sself((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pys__repr__QscCst|iƒSdS(s3Return formatted information about the code object.N(sformat_code_infosselfscodeobj(sself((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pysinfoUscCs•|i}|itj o |i}nd}tƒ}|i|i d|i d|i d|i d|i d|id|id|d |ƒ|iƒSd S( s3Return a formatted view of the bytecode operations.iÿÿÿÿsvarnamessnamess constantsscellss linestartss line_offsetsfileslastiN(sselfscodeobjscoscurrent_offsetsNonesoffsetsStringIOsoutputsdisassemble_bytessco_codes co_varnamessco_namess co_constss _cell_namess _linestartss _line_offsetsgetvalue(sselfscosoffsetsoutput((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pysdisYs       iÿÿÿÿic  CsÇ|tj } | o d} nd} x™t||i|||||d| ƒD]p}| o|itj o |idj} | o|idƒn|i|j} |i|i| | ƒdƒqKWdSdS(Niis line_offsets (s linestartssNones show_linenos lineno_widthsget_instructions_bytesscodesselfsopcsvarnamessnamess constantsscellss line_offsetsinstrs starts_linesoffsetsnew_source_linesfileswriteslastisis_current_instrs _disassemble(sselfscodeslastisvarnamessnamess constantsscellss linestartssfiles line_offsetsis_current_instrs show_linenosnew_source_lines lineno_widthsinstr((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pysdisassemble_bytesjs    &c CsŠt|ƒ}|i|i}t|ii |ƒƒ}|t j o||i }nd}t|i|i|i|i|i|||ƒSdS(sÇIterator for the opcodes in methods, functions or code Generates a series of Instruction named tuples giving the details of each operations in the supplied code. If *first_line* is not None, it indicates the line number that should be reported for the first source line in the disassembled code. Otherwise, the source line information (if any) is taken directly from the disassembled code object. iN(sget_code_objectsxscos co_cellvarss co_freevarss cell_namessdictsselfsopcsfindlinestartss linestartss first_linesNonesco_firstlinenos line_offsetsget_instructions_bytessco_codes co_varnamessco_namess co_consts(sselfsxs first_lines linestartsscos line_offsets cell_names((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pysget_instructionss   ( s__name__s __module__s__doc__sNones__init__s__iter__s__repr__sinfosdisssyssstdoutsdisassemble_bytessget_instructions(((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pysBytecode3s     $cCs…g}x,t|ƒD]\} }|d}|d}||ijotd| ||fƒ‚n|i |}|i |ƒ||fGHgi } |D]} |o| | ƒq“q“~ }xw|D]o} ||ijo |} n|} | i| ƒ} | djotd| ||fƒ‚q¾|t| ƒ7}q¾WqW|idjotd„|dƒSn&tot|ƒSntt|ƒƒSd S( s^Convert list/tuple of list/tuples to bytecode _names_ contains a list of name objects iis+error at item %d [%s, %s], opcode not validiÿÿÿÿs'operand %s [%s, %s], not found in namesf3.0cCs|t|ƒS(N(saschrsb(sasb((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pys·ssN(sbcs enumerateslsisopcodessopnamesoperandssopcs TypeErrorsopmapsopcodesappends_[1]sjsgenshasconstsconstssthingsvarnamessindexsksnum2codespython_versionsreducesPYTHON3sbytess bytearray(slsopcsvarnamessconstssopnamesopcodessbcsgensoperandssisksjs_[1]sthingsopcode((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pys list2bytecode—s:      2  s__main__isas LOAD_CONSTs STORE_FASTs LOAD_FASTs RETURN_VALUEcCsd}|SdS(Ni(sa(sa((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pysfÊs(1s__doc__ssysstypessxdissPYTHON3sxdis.namedtuple25s namedtuples xdis.utilsget_code_objectscode2numsnum2codesformat_code_infosiosStringIOs functoolssreduces MethodTypes FunctionTypesCodeTypestypes _have_codespretty_format_value_flagssfindlinestartss offset2lines findlabelss_get_const_infos_get_name_infosNonesget_instructions_bytessop_has_arguments _Instructionsfrom_tracebacks InstructionsBytecodes list2bytecodes__name__sxdis.opcodes.opcode_27sopcodess opcode_27sxdis.opcodes.opcode_34s opcode_34sconstssvarnamess instructionssfs__code__sco_codes func_codesbc(s _have_codes opcode_34s list2bytecodesnum2codesfrom_tracebacksreducesformat_code_infosPYTHON3s_get_name_infosvarnamesstypessget_instructions_bytess namedtuples opcode_27sbcscode2nums findlabelss Instructionssysspretty_format_value_flagssop_has_argumentsconstssfindlinestartss instructionss _Instructionsfs_get_const_infos offset2linesget_code_objectsStringIOsBytecode((s-build/bdist.linux-x86_64/egg/xdis/bytecode.pys?sJ         \   8d (  '  PK°´IѰòûûxdis/__init__.pyc;ò dqÕWc@s—dZdkZdZeiddfjZeideiddZdeideidfZdeijZei d ƒd k l Z l Z dS( s Copyright (c) 2015-2016 by Rocky Bernstein Copyright (c) 2000 by hartmut Goebel Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. NB. This is not a masterpiece of software, but became more like a hack. Probably a complete rewrite would be sensefull. hG/2000-12-27 Nsrestructuredtextiiif10.0s%s.%ss__pypy__iˆ(s load_modules load_file( s__doc__ssyss __docformat__s version_infosPYTHON3sPYTHON_VERSIONsPYTHON_VERSION_STRsbuiltin_module_namessIS_PYPYssetrecursionlimits xdis.loads load_modules load_file(s load_modulesPYTHON_VERSIONsIS_PYPYsPYTHON_VERSION_STRs __docformat__ssyss load_filesPYTHON3((s-build/bdist.linux-x86_64/egg/xdis/__init__.pys?s  PK¤´I;B£-A-Axdis/bytecode.py"""Python bytecode and instruction classes Extracted from Python 3 dis module but generalized to allow running on Python 2. """ import sys, types from xdis import PYTHON3 from xdis.namedtuple25 import namedtuple from xdis.util import get_code_object, code2num, num2code, format_code_info if PYTHON3: from io import StringIO from functools import reduce else: from StringIO import StringIO _have_code = (types.MethodType, types.FunctionType, types.CodeType, type) def pretty_format_value_flags(flags): if (flags & 0x03) == 0x00: return '' elif (flags & 0x03) == 0x01: return '!s' elif (flags & 0x03) == 0x02: return '!r' elif (flags & 0x03) == 0x03: return '!a' elif (flags & 0x04) == 0x04: # pop fmt_spec from the stack and use it, else use an # empty fmt_spec. return '' def findlinestarts(code): """Find the offsets in a byte code which are start of lines in the source. Generate pairs (offset, lineno) as described in Python/compile.c. """ if PYTHON3: byte_increments = list(code.co_lnotab[0::2]) line_increments = list(code.co_lnotab[1::2]) else: byte_increments = [ord(c) for c in code.co_lnotab[0::2]] line_increments = [ord(c) for c in code.co_lnotab[1::2]] lastlineno = None lineno = code.co_firstlineno addr = 0 for byte_incr, line_incr in zip(byte_increments, line_increments): if byte_incr: if lineno != lastlineno: yield (addr, lineno) lastlineno = lineno addr += byte_incr lineno += line_incr if lineno != lastlineno: yield (addr, lineno) def offset2line(offset, linestarts): """linestarts is expected to be a *list) of (offset, line number) where both offset and line number are in increasing order. Return the closes line number at or below the offset. If offset is less than the first line number given in linestarts, return line number 0. """ if len(linestarts) == 0 or offset < linestarts[0][0]: return 0 low = 0 high = len(linestarts) - 1 mid = (low + high + 1) // 2 while low <= high: if linestarts[mid][0] > offset: high = mid - 1 elif linestarts[mid][0] < offset: low = mid + 1 else: return linestarts[mid][1] mid = (low + high + 1) // 2 pass # Not found. Return closest position below if mid >= len(linestarts): return linestarts[len(linestarts)-1][1] return linestarts[high][1] def findlabels(code, opc): """Detect all offsets in a byte code which are jump targets. Return the list of offsets. """ labels = [] # enumerate() is not an option, since we sometimes process # multiple elements on a single pass through the loop n = len(code) i = 0 while i < n: op = code2num(code, i) i = i+1 if op >= opc.HAVE_ARGUMENT: arg = code2num(code, i) + code2num(code, i+1)*256 i = i+2 label = -1 if op in opc.hasjrel: label = i+arg elif op in opc.hasjabs: label = arg if label >= 0: if label not in labels: labels.append(label) return labels def _get_const_info(const_index, const_list): """Helper to get optional details about const references Returns the dereferenced constant and its repr if the constant list is defined. Otherwise returns the constant index and its repr(). """ argval = const_index if const_list is not None: argval = const_list[const_index] return argval, repr(argval) def _get_name_info(name_index, name_list): """Helper to get optional details about named references Returns the dereferenced name as both value and repr if the name list is defined. Otherwise returns the name index and its repr(). """ argval = name_index if (name_list is not None # PyPY seems to "optimize" out constant names, # so we need for that: and name_index < len(name_list)): argval = name_list[name_index] argrepr = argval else: argrepr = repr(argval) return argval, argrepr def get_instructions_bytes(code, opc, varnames=None, names=None, constants=None, cells=None, linestarts=None, line_offset=0): """Iterate over the instructions in a bytecode string. Generates a sequence of Instruction namedtuples giving the details of each opcode. Additional information about the code's runtime environment (e.g. variable names, constants) can be specified using optional arguments. """ labels = findlabels(code, opc) extended_arg = 0 # FIXME: We really need to distinguish 3.6.0a1 from 3.6.a3. # See below FIXME if opc.python_version >= 3.6: python_36 = True else: python_36 = False starts_line = None # enumerate() is not an option, since we sometimes process # multiple elements on a single pass through the loop n = len(code) i = 0 extended_arg = 0 while i < n: op = code2num(code, i) offset = i if linestarts is not None: starts_line = linestarts.get(i, None) if starts_line is not None: starts_line += line_offset is_jump_target = i in labels i = i+1 arg = None argval = None argrepr = '' has_arg = op_has_argument(op, opc) if has_arg: if python_36: arg = code2num(code, i) | extended_arg if opc == opc.EXTENDED_ARG: extended_arg = (arg << 8) else: extended_arg = 0 # FIXME: Python 3.6.0a1 is 2, for 3.6.a3 we have 1 i += 1 else: arg = code2num(code, i) + code2num(code, i+1)*256 + extended_arg i += 2 if op == opc.EXTENDED_ARG: extended_arg = arg*65536 else: extended_arg = 0 # Set argval to the dereferenced value of the argument when # availabe, and argrepr to the string representation of argval. # _disassemble_bytes needs the string repr of the # raw name index for LOAD_GLOBAL, LOAD_CONST, etc. argval = arg if op in opc.hasconst: argval, argrepr = _get_const_info(arg, constants) elif op in opc.hasname: argval, argrepr = _get_name_info(arg, names) elif op in opc.hasjrel: argval = i + arg argrepr = "to " + repr(argval) elif op in opc.hasjabs: argval = arg argrepr = "to " + repr(argval) elif op in opc.haslocal: argval, argrepr = _get_name_info(arg, varnames) elif op in opc.hascompare: argval = opc.cmp_op[arg] argrepr = argval elif op in opc.hasfree: argval, argrepr = _get_name_info(arg, cells) elif op in opc.hasnargs: if not python_36: argrepr = ("%d positional, %d keyword pair" % (code2num(code, i-2), code2num(code, i-1))) elif python_36 and op == opc.FORMAT_VALUE: argrepr = pretty_format_value_flags(arg) elif python_36: i += 1 opname = opc.opname[op] yield Instruction(opname, op, arg, argval, argrepr, has_arg, offset, starts_line, is_jump_target) def op_has_argument(op, opc): return op >= opc.HAVE_ARGUMENT _Instruction = namedtuple("_Instruction", "opname opcode arg argval argrepr has_arg offset starts_line is_jump_target") def from_traceback(cls, tb): """ Construct a Bytecode from the given traceback """ while tb.tb_next: tb = tb.tb_next return cls(tb.tb_frame.f_code, current_offset=tb.tb_lasti) class Instruction(_Instruction): """Details for a bytecode operation Defined fields: opname - human readable name for operation opcode - numeric code for operation arg - numeric argument to operation (if any), otherwise None argval - resolved arg value (if known), otherwise same as arg argrepr - human readable description of operation argument has_arg - True opcode takes an argument. In that case, argval and argepr will have that value. False if this opcode doesn't take an argument. In that case, don't look at argval or ardrepr. offset - start index of operation within bytecode sequence starts_line - line started by this opcode (if any), otherwise None is_jump_target - True if other code jumps to here, otherwise False """ def _disassemble(self, lineno_width=3, mark_as_current=False): """Format instruction details for inclusion in disassembly output *lineno_width* sets the width of the line number field (0 omits it) *mark_as_current* inserts a '-->' marker arrow as part of the line """ fields = [] # Column: Source code line number if lineno_width: if self.starts_line is not None: lineno_fmt = "%%%dd" % lineno_width fields.append(lineno_fmt % self.starts_line) else: fields.append(' ' * lineno_width) # Column: Current instruction indicator if mark_as_current: fields.append('-->') else: fields.append(' ') # Column: Jump target marker if self.is_jump_target: fields.append('>>') else: fields.append(' ') # Column: Instruction offset from start of code sequence fields.append(repr(self.offset).rjust(4)) # Column: Opcode name fields.append(self.opname.ljust(20)) # Column: Opcode argument if self.arg is not None: fields.append(repr(self.arg).rjust(5)) # Column: Opcode argument details if self.argrepr: fields.append('(' + self.argrepr + ')') return ' '.join(fields).rstrip() ## FIXME: figure out how to do _disassemble passing in opnames class Bytecode: """The bytecode operations of a piece of code Instantiate this with a function, method, string of code, or a code object (as returned by compile()). Iterating over this yields the bytecode operations as Instruction instances. """ def __init__(self, x, opc, first_line=None, current_offset=None): self.codeobj = co = get_code_object(x) if first_line is None: self.first_line = co.co_firstlineno self._line_offset = 0 else: self.first_line = first_line self._line_offset = first_line - co.co_firstlineno self._cell_names = co.co_cellvars + co.co_freevars self._linestarts = dict(opc.findlinestarts(co)) self._original_object = x self.opc = opc self.opnames = opc.opname self.current_offset = current_offset def __iter__(self): co = self.codeobj return get_instructions_bytes(co.co_code, self.opc, co.co_varnames, co.co_names, co.co_consts, self._cell_names, self._linestarts, line_offset=self._line_offset) def __repr__(self): return "{}({!r})".format(self.__class__.__name__, self._original_object) def info(self): """Return formatted information about the code object.""" return format_code_info(self.codeobj) def dis(self): """Return a formatted view of the bytecode operations.""" co = self.codeobj if self.current_offset is not None: offset = self.current_offset else: offset = -1 output = StringIO() self.disassemble_bytes(co.co_code, varnames=co.co_varnames, names=co.co_names, constants=co.co_consts, cells=self._cell_names, linestarts=self._linestarts, line_offset=self._line_offset, file=output, lasti=offset) return output.getvalue() def disassemble_bytes(self, code, lasti=-1, varnames=None, names=None, constants=None, cells=None, linestarts=None, file=sys.stdout, line_offset=0): # Omit the line number column entirely if we have no line number info show_lineno = linestarts is not None # TODO?: Adjust width upwards if max(linestarts.values()) >= 1000? if show_lineno: lineno_width = 3 else: lineno_width = 0 for instr in get_instructions_bytes(code, self.opc, varnames, names, constants, cells, linestarts, line_offset=line_offset): new_source_line = (show_lineno and instr.starts_line is not None and instr.offset > 0) if new_source_line: file.write("\n") is_current_instr = instr.offset == lasti file.write(instr._disassemble(lineno_width, is_current_instr) + "\n") pass return def get_instructions(self, x, first_line=None): """Iterator for the opcodes in methods, functions or code Generates a series of Instruction named tuples giving the details of each operations in the supplied code. If *first_line* is not None, it indicates the line number that should be reported for the first source line in the disassembled code. Otherwise, the source line information (if any) is taken directly from the disassembled code object. """ co = get_code_object(x) cell_names = co.co_cellvars + co.co_freevars linestarts = dict(self.opc.findlinestarts(co)) if first_line is not None: line_offset = first_line - co.co_firstlineno else: line_offset = 0 return get_instructions_bytes(co.co_code, self.opc, co.co_varnames, co.co_names, co.co_consts, cell_names, linestarts, line_offset) def list2bytecode(l, opc, varnames, consts): """Convert list/tuple of list/tuples to bytecode _names_ contains a list of name objects """ bc = [] for i, opcodes in enumerate(l): opname = opcodes[0] operands = opcodes[1:] if opname not in opc.opname: raise TypeError( "error at item %d [%s, %s], opcode not valid" % (i, opname, operands)) opcode = opc.opmap[opname] bc.append(opcode) print(opname, operands) gen = [j for j in operands if operands] for j in gen: if opcode in opc.hasconst: thing = consts else: thing = varnames k = thing.index(j) if k == -1: raise TypeError( "operand %s [%s, %s], not found in names" % (i, opname, operands)) else: bc += num2code(k) pass pass pass if opc.python_version < 3.0: return reduce(lambda a, b: a + chr(b), bc, '') else: if PYTHON3: return bytes(bc) else: return bytes(bytearray(bc)) if __name__ == '__main__': import xdis.opcodes.opcode_27 as opcode_27 import xdis.opcodes.opcode_34 as opcode_34 consts = (None, 2) varnames = ('a') instructions = [ ('LOAD_CONST', 2), ('STORE_FAST', 'a'), ('LOAD_FAST', 'a'), ('RETURN_VALUE',) ] def f(): a = 2 return a if PYTHON3: print(f.__code__.co_code) else: print(f.func_code.co_code) bc = list2bytecode(instructions, opcode_27, varnames, consts) print(bc) bc = list2bytecode(instructions, opcode_34, varnames, consts) print(bc) PK°´I`m*æG G xdis/code.pyc;ò 1HGWc@s<dkZdfd„ƒYZdfd„ƒYZd„ZdS(NsCode3cBstZdZd„ZRS(srClass for a Python3 code object used when a Python interpreter less than 3 is working on Python3 bytecode cCs‹||_||_||_||_||_||_||_||_| |_ | |_ | |_ | |_ | |_ ||_||_dS(N(s co_argcountsselfsco_kwonlyargcounts co_nlocalss co_stacksizesco_flagssco_codes co_constssco_namess co_varnamess co_filenamesco_namesco_firstlinenos co_lnotabs co_freevarss co_cellvars(sselfs co_argcountsco_kwonlyargcounts co_nlocalss co_stacksizesco_flagssco_codes co_constssco_namess co_varnamess co_filenamesco_namesco_firstlinenos co_lnotabs co_freevarss co_cellvars((s)build/bdist.linux-x86_64/egg/xdis/code.pys__init__s              (s__name__s __module__s__doc__s__init__(((s)build/bdist.linux-x86_64/egg/xdis/code.pysCode3s sCode2cBstZdZd„ZRS(srClass for a Python2 code object used when a Python interpreter less than 3 is working on Python3 bytecode cCs‹||_||_||_||_||_||_||_||_| |_ | |_ | |_ | |_ | |_ ||_||_dS(N(s co_argcountsselfsco_kwonlyargcounts co_nlocalss co_stacksizesco_flagssco_codes co_constssco_namess co_varnamess co_filenamesco_namesco_firstlinenos co_lnotabs co_freevarss co_cellvars(sselfs co_argcountsco_kwonlyargcounts co_nlocalss co_stacksizesco_flagssco_codes co_constssco_namess co_varnamess co_filenamesco_namesco_firstlinenos co_lnotabs co_freevarss co_cellvars((s)build/bdist.linux-x86_64/egg/xdis/code.pys__init__s              (s__name__s __module__s__doc__s__init__(((s)build/bdist.linux-x86_64/egg/xdis/code.pysCode2s cCs!ti|ƒp t|tƒSdS(sâA replacement for inspect.iscode() which we can't used because we may be using a different version of Python than the version of Python used in creating the byte-compiled objects. Here, he code types may mismatch. N(sinspectsiscodesobjs isinstancesCode3(sobj((s)build/bdist.linux-x86_64/egg/xdis/code.pysiscode0s(sinspectsCode3sCode2siscode(siscodesCode2sinspectsCode3((s)build/bdist.linux-x86_64/egg/xdis/code.pys?s PKDxºH2ŸÆQ°° xdis/code.pyimport inspect class Code3: """Class for a Python3 code object used when a Python interpreter less than 3 is working on Python3 bytecode """ def __init__(self, co_argcount, co_kwonlyargcount,co_nlocals, co_stacksize, co_flags, co_code, co_consts, co_names, co_varnames, co_filename, co_name, co_firstlineno, co_lnotab, co_freevars, co_cellvars): self.co_argcount = co_argcount self.co_kwonlyargcount = co_kwonlyargcount self.co_nlocals = co_nlocals self.co_stacksize = co_stacksize self.co_flags = co_flags self.co_code = co_code self.co_consts = co_consts self.co_names = co_names self.co_varnames = co_varnames self.co_filename = co_filename self.co_name = co_name self.co_firstlineno = co_firstlineno self.co_lnotab = co_lnotab self.co_freevars = co_freevars self.co_cellvars = co_cellvars class Code2: """Class for a Python2 code object used when a Python interpreter less than 3 is working on Python3 bytecode """ def __init__(self, co_argcount, co_kwonlyargcount,co_nlocals, co_stacksize, co_flags, co_code, co_consts, co_names, co_varnames, co_filename, co_name, co_firstlineno, co_lnotab, co_freevars, co_cellvars): self.co_argcount = co_argcount self.co_kwonlyargcount = co_kwonlyargcount self.co_nlocals = co_nlocals self.co_stacksize = co_stacksize self.co_flags = co_flags self.co_code = co_code self.co_consts = co_consts self.co_names = co_names self.co_varnames = co_varnames self.co_filename = co_filename self.co_name = co_name self.co_firstlineno = co_firstlineno self.co_lnotab = co_lnotab self.co_freevars = co_freevars self.co_cellvars = co_cellvars def iscode(obj): """A replacement for inspect.iscode() which we can't used because we may be using a different version of Python than the version of Python used in creating the byte-compiled objects. Here, he code types may mismatch. """ return inspect.iscode(obj) or isinstance(obj, Code3) PK¥´I´Æze  xdis/magics.pyimport imp, struct, sys def int2magic(magic): if (sys.version_info >= (3, 0)): return struct.pack('Hcc', magic, bytes('\r', 'utf-8'), bytes('\n', 'utf-8')) else: return struct.pack('Hcc', magic, '\r', '\n') def magic2int(magic): return struct.unpack('Hcc', magic)[0] PYTHON_MAGIC_INT = magic2int(imp.get_magic()) by_magic = {} by_version = {} def __by_version(magics): for m, v in list(magics.items()): by_magic[m] = v by_version[v] = m return by_version versions = { # taken from from Python/import.c # or importlib/_bootstrap.py # magic, version int2magic(11913): '1.3', # int2magic(5892): '1.4', # int2magic(20121): '1.5', # 1.5, 1.5.1, 1.5.2 int2magic(20121): '1.5', # 1.5, 1.5.1, 1.5.2 int2magic(50428): '1.6', # 1.6 int2magic(50823): '2.0', # 2.0, 2.0.1 int2magic(60202): '2.1', # 2.1, 2.1.1, 2.1.2 int2magic(60717): '2.2', # 2.2 int2magic(62011): '2.3a0', int2magic(62021): '2.3a0', int2magic(62041): '2.4a0', int2magic(62051): '2.4a3', int2magic(62061): '2.4b1', int2magic(62071): '2.5a0', int2magic(62081): '2.5a0', # ast-branch int2magic(62091): '2.5a0', # with int2magic(62092): '2.5a0', # changed WITH_CLEANUP opcode int2magic(62101): '2.5b3', # fix wrong code: for x, in ... int2magic(62111): '2.5b3', # fix wrong code: x += yield int2magic(62121): '2.5c1', # fix wrong lnotab with for loops and # storing constants that should have been removed int2magic(62131): '2.5c2', # fix wrong code: for x, in ... in # listcomp/genexp) int2magic(62135): '2.5dropbox', # Dropbox-modified Python 2.5 # used in versions 1.1x and before of Dropbox int2magic(62151): '2.6a0', # peephole optimizations & STORE_MAP int2magic(62161): '2.6a1', # WITH_CLEANUP optimization int2magic(62171): '2.7a0', # optimize list comprehensions/change # LIST_APPEND int2magic(62181): '2.7a0+1', # optimize conditional branches: # introduce POP_JUMP_IF_FALSE and # POP_JUMP_IF_TRUE int2magic(62191): '2.7a0+2', # introduce SETUP_WITH int2magic(62201): '2.7a0+3', # introduce BUILD_SET int2magic(62211): '2.7', # introduce MAP_ADD and SET_ADD int2magic(62215): '2.7dropbox', # Dropbox-modified Python 2.7 # used in versions 1.2-1.6 or so of # Dropbox int2magic(62211+7): '2.7pypy', # PyPy including pypy-2.6.1, pypy-5.0.1 # PyPy adds 7 to the corresponding CPython nmber int2magic(3000): '3.000', int2magic(3010): '3.000+1', # removed UNARY_CONVERT int2magic(3020): '3.000+2', # added BUILD_SET int2magic(3030): '3.000+3', # added keyword-only parameters int2magic(3040): '3.000+4', # added signature annotations int2magic(3050): '3.000+5', # print becomes a function int2magic(3060): '3.000+6', # PEP 3115 metaclass syntax int2magic(3061): '3.000+7', # string literals become unicode int2magic(3071): '3.000+8', # PEP 3109 raise changes int2magic(3081): '3.000+9', # PEP 3137 make __file__ and __name__ unicode int2magic(3091): '3.000+10', # kill str8 interning int2magic(3101): '3.000+11', # merge from 2.6a0, see 62151 int2magic(3103): '3.000+12', # __file__ points to source file int2magic(3111): '3.0a4', # WITH_CLEANUP optimization int2magic(3131): '3.0a5', # lexical exception stacking, including POP_EXCEPT) int2magic(3141): '3.1a0', # optimize list, set and dict comprehensions int2magic(3151): '3.1a0+', # optimize conditional branches int2magic(3160): '3.2a0', # add SETUP_WITH int2magic(3170): '3.2a1', # add DUP_TOP_TWO, remove DUP_TOPX and ROT_FOUR int2magic(3180): '3.2a2', # 3.2a2 (add DELETE_DEREF) int2magic(3180+7): '3.2pypy', # Python 3.2.5 - PyPy 2.3.4 # PyPy adds 7 to the corresponding CPython number int2magic(3190): '3.3a0', # __class__ super closure changed int2magic(3200): '3.3a0+', # __qualname__ added int2magic(3210): '3.3', # added size modulo 2**32 to the pyc header int2magic(3220): '3.3a1', # changed PEP 380 implementation int2magic(3230): '3.3a4', # revert changes to implicit __class__ closure int2magic(3250): '3.4a1', # evaluate positional default arg # keyword-only defaults) int2magic(3260): '3.4a1+1', # add LOAD_CLASSDEREF; # allow locals of class to override free vars int2magic(3270): '3.4a1+2', # various tweaks to the __class__ closure int2magic(3280): '3.4a1+3', # remove implicit class argument int2magic(3290): '3.4a4', # changes to __qualname__ computation int2magic(3300): '3.4a4+', # more changes to __qualname__ computation int2magic(3310): '3.4rc2', # alter __qualname__ computation int2magic(3350): '3.5', # 3.5.0, 3.5.1, 3.5.2 int2magic(3361): '3.6.0a1', # 3.6.0a1 int2magic(3370): '3.6.0a1+1', # 3.6.0a? int2magic(3370): '3.6.0a1+2', # int2magic(3372): '3.6.0a3', # int2magic(3378): '3.6.0b2', # int2magic(3379): '3.6.0rc1', # # A weird one int2magic(48): '3.2', # WTF? Python 3.2.5 - PyPy 2.3.4 # This doesn't follow the rule below } magics = __by_version(versions) def __show(text, magic): print(text, struct.unpack('BBBB', magic), struct.unpack('HBB', magic)) def test(): magic_20 = magics['2.0'] current = imp.get_magic() magic_current = by_magic[ current ] print(type(magic_20), len(magic_20), repr(magic_20)) print() print('This Python interpreter has version', magic_current) print('Magic code: ', PYTHON_MAGIC_INT) print(type(magic_20), len(magic_20), repr(magic_20)) if __name__ == '__main__': test() PK°´Ii­m)¤¤xdis/version.pyc;ò ç²TXc@s dZdS(s3.2.4N(sVERSION(sVERSION((s,build/bdist.linux-x86_64/egg/xdis/version.pys?sPK¤´I=o» ]]xdis/verify.pyimport imp, os, marshal, tempfile from xdis import magics, PYTHON3, PYTHON_VERSION, IS_PYPY from xdis.load import load_module MAGIC = imp.get_magic() def wr_long(f, x): """Internal; write a 32-bit int to a file in little-endian order.""" if PYTHON3: f.write(bytes([x & 0xff])) f.write(bytes([(x >> 8) & 0xff])) f.write(bytes([(x >> 16) & 0xff])) f.write(bytes([(x >> 24) & 0xff])) else: f.write(chr( x & 0xff)) f.write(chr((x >> 8) & 0xff)) f.write(chr((x >> 16) & 0xff)) f.write(chr((x >> 24) & 0xff)) def dump_compile(codeobject, filename, timestamp, magic): """Write code object as a byte-compiled file Arguments: codeobject: code object filefile: bytecode file to write timestamp: timestamp to put in file magic: Pyton bytecode magic """ # Atomically write the pyc/pyo file. Issue #13146. # id() is used to generate a pseudo-random filename. path_tmp = '%s.%s' % (filename, id(filename)) fc = None try: fc = open(path_tmp, 'wb') if PYTHON3: fc.write(bytes([0, 0, 0, 0])) else: fc.write('\0\0\0\0') wr_long(fc, timestamp) marshal.dump(codeobject, fc) fc.flush() fc.seek(0, 0) fc.write(magic) fc.close() os.rename(path_tmp, filename) except OSError: try: os.unlink(path_tmp) except OSError: pass raise if fc: fc.close() def compare_code(c1, c2): # assert c1.co_code == c2.co_code, ("code %s vs. %s" % (c1.co_code, c2.co_code)) assert c1.co_argcount == c2.co_argcount assert len(c1.co_consts) == len(c2.co_consts), \ ("consts:\n%s\nvs.\n%s" % (c1.co_consts, c2.co_consts)) assert c1.co_filename == c2.co_filename assert c1.co_firstlineno == c2.co_firstlineno assert c1.co_flags == c2.co_flags assert c1.co_lnotab == c2.co_lnotab assert c1.co_name == c2.co_name assert c1.co_names == c2.co_names assert c1.co_nlocals == c2.co_nlocals assert c1.co_stacksize == c2.co_stacksize assert c1.co_varnames == c2.co_varnames def compare_bytecode_files(bc_file1, bc_file2): # Now compare bytes in bytecode files f = open(bc_file1, 'rb') bytes1 = f.read() f.close f = open(bc_file2, 'rb') bytes2 = f.read() f.close if PYTHON_VERSION == 3.2 and IS_PYPY: assert bytes1[4:] == bytes2[4:], ("byteode:\n%s\nvs\n%s" % (bytes1[4:], bytes2[4:])) else: assert bytes1 == bytes2, ("byteode:\n%s\nvs\n%s" % (bytes1, bytes2)) def verify_file(real_source_filename, real_bytecode_filename): """Compile *real_source_filename* using the running Python interpreter. Then write bytecode out to a new place again using Python's routines. Next load it in using two of our routines. Compare that the code objects there are equal. Next write out the bytecode (using the same Python bytecode writin routine as in step 1. Finally compare the bytecode files. """ tempdir = tempfile.gettempdir() source_filename = os.path.join(tempdir, "testing.py") if not os.path.exists(real_source_filename): return try: f = open(real_source_filename, 'U') except: return codestring = f.read() f.close() codeobject1 = compile(codestring, source_filename,'exec') (version, timestamp, magic_int, codeobject2, is_pypy, source_size) = load_module(real_bytecode_filename) # A hack for PyPy 3.2 if magic_int == 3180+7: magic_int = 48 assert MAGIC == magics.int2magic(magic_int), \ ("magic_int %d vs %d in %s/%s" % (magic_int, magics.magic2int(MAGIC), os.getcwd(), real_bytecode_filename)) bytecode_filename1 = os.path.join(tempdir, "testing1.pyc") dump_compile(codeobject1, bytecode_filename1, timestamp, MAGIC) (version, timestamp, magic_int, codeobject3, is_pypy, source_size) = load_module(real_bytecode_filename, fast_load=not is_pypy) # compare_code(codeobject1, codeobject2) # compare_code(codeobject2, codeobject3) bytecode_filename2 = os.path.join(tempdir, "testing2.pyc") dump_compile(codeobject1, bytecode_filename2, timestamp, magics.int2magic(magic_int)) compare_bytecode_files(bytecode_filename1, bytecode_filename2) return if __name__ == '__main__': verify_file(__file__) PK¤´IY¦n£¥F¥F xdis/marsh.py"""Internal Python object serialization This module contains functions that can read and write Python values in a binary format. The format is specific to Python, but independent of machine architecture issues (e.g., you can write a Python value to a file on a PC, transport the file to a Sun, and read it back there). Details of the format may change between Python versions. """ # NOTE: This module is used in the Python3 interpreter, but also by # the "sandboxed" process. It must work for Python2 as well. import types, struct from xdis import PYTHON_VERSION, PYTHON3 try: intern except NameError: from sys import intern def Ord(c): if PYTHON3: return c else: return ord(c) TYPE_NULL = '0' TYPE_NONE = 'N' TYPE_FALSE = 'F' TYPE_TRUE = 'T' TYPE_STOPITER = 'S' TYPE_ELLIPSIS = '.' TYPE_INT = 'i' TYPE_INT64 = 'I' TYPE_FLOAT = 'f' TYPE_BINARY_FLOAT = 'g' TYPE_COMPLEX = 'x' TYPE_LONG = 'l' TYPE_STRING = 's' TYPE_INTERNED = 't' TYPE_STRINGREF= 'R' TYPE_TUPLE = '(' TYPE_LIST = '[' TYPE_DICT = '{' TYPE_CODE = 'c' TYPE_UNICODE = 'u' TYPE_UNKNOWN = '?' TYPE_SET = '<' TYPE_FROZENSET= '>' class _Marshaller: dispatch = {} def __init__(self, writefunc): self._write = writefunc def dump(self, x): try: self.dispatch[type(x)](self, x) except KeyError: for tp in type(x).mro(): func = self.dispatch.get(tp) if func: break else: raise ValueError("unmarshallable object") func(self, x) def w_long64(self, x): self.w_long(x) self.w_long(x>>32) def w_long(self, x): a = chr(x & 0xff) x >>= 8 b = chr(x & 0xff) x >>= 8 c = chr(x & 0xff) x >>= 8 d = chr(x & 0xff) self._write(a + b + c + d) def w_short(self, x): self._write(chr((x) & 0xff)) self._write(chr((x>> 8) & 0xff)) def dump_none(self, x): self._write(TYPE_NONE) dispatch[type(None)] = dump_none def dump_bool(self, x): if x: self._write(TYPE_TRUE) else: self._write(TYPE_FALSE) dispatch[bool] = dump_bool def dump_stopiter(self, x): if x is not StopIteration: raise ValueError("unmarshallable object") self._write(TYPE_STOPITER) dispatch[type(StopIteration)] = dump_stopiter def dump_ellipsis(self, x): self._write(TYPE_ELLIPSIS) try: dispatch[type(Ellipsis)] = dump_ellipsis except NameError: pass # In Python3, this function is not used; see dump_long() below. def dump_int(self, x): y = x>>31 if y and y != -1: self._write(TYPE_INT64) self.w_long64(x) else: self._write(TYPE_INT) self.w_long(x) dispatch[int] = dump_int def dump_long(self, x): self._write(TYPE_LONG) sign = 1 if x < 0: sign = -1 x = -x digits = [] while x: digits.append(x & 0x7FFF) x = x>>15 self.w_long(len(digits) * sign) for d in digits: self.w_short(d) try: long except NameError: dispatch[int] = dump_long else: dispatch[long] = dump_long def dump_float(self, x): write = self._write write(TYPE_FLOAT) s = repr(x) write(chr(len(s))) write(s) dispatch[float] = dump_float def dump_binary_float(self, x): write = self._write write(TYPE_BINARY_FLOAT) write(struct.pack('d', x)) dispatch[TYPE_BINARY_FLOAT] = dump_float def dump_complex(self, x): write = self._write write(TYPE_COMPLEX) s = repr(x.real) write(chr(len(s))) write(s) s = repr(x.imag) write(chr(len(s))) write(s) try: dispatch[complex] = dump_complex except NameError: pass def dump_string(self, x): # XXX we can't check for interned strings, yet, # so we (for now) never create TYPE_INTERNED or TYPE_STRINGREF self._write(TYPE_STRING) self.w_long(len(x)) self._write(x) if PYTHON_VERSION > 2.5: dispatch[bytes] = dump_string def dump_unicode(self, x): self._write(TYPE_UNICODE) s = x.encode('utf8') self.w_long(len(s)) self._write(s) try: unicode except NameError: dispatch[str] = dump_unicode else: dispatch[unicode] = dump_unicode def dump_tuple(self, x): self._write(TYPE_TUPLE) self.w_long(len(x)) for item in x: self.dump(item) dispatch[tuple] = dump_tuple def dump_list(self, x): self._write(TYPE_LIST) self.w_long(len(x)) for item in x: self.dump(item) dispatch[list] = dump_list def dump_dict(self, x): self._write(TYPE_DICT) for key, value in x.items(): self.dump(key) self.dump(value) self._write(TYPE_NULL) dispatch[dict] = dump_dict def dump_code(self, x): self._write(TYPE_CODE) self.w_long(x.co_argcount) self.w_long(x.co_nlocals) self.w_long(x.co_stacksize) self.w_long(x.co_flags) self.dump(x.co_code) self.dump(x.co_consts) self.dump(x.co_names) self.dump(x.co_varnames) self.dump(x.co_freevars) self.dump(x.co_cellvars) self.dump(x.co_filename) self.dump(x.co_name) self.w_long(x.co_firstlineno) self.dump(x.co_lnotab) try: dispatch[types.CodeType] = dump_code except NameError: pass def dump_set(self, x): self._write(TYPE_SET) self.w_long(len(x)) for each in x: self.dump(each) try: dispatch[set] = dump_set except NameError: pass def dump_frozenset(self, x): self._write(TYPE_FROZENSET) self.w_long(len(x)) for each in x: self.dump(each) try: dispatch[frozenset] = dump_frozenset except NameError: pass class _NULL: pass class _StringBuffer: def __init__(self, value): self.bufstr = value self.bufpos = 0 def read(self, n): pos = self.bufpos newpos = pos + n ret = self.bufstr[pos : newpos] self.bufpos = newpos return ret class _Unmarshaller: dispatch = {} def __init__(self, readfunc): self._read = readfunc self._stringtable = [] def load(self): c = self._read(1) if not c: raise EOFError try: return self.dispatch[c](self) except KeyError: raise ValueError("bad marshal code: %c (%d)" % (c, Ord(c))) def r_short(self): lo = Ord(self._read(1)) hi = Ord(self._read(1)) x = lo | (hi<<8) if x & 0x8000: x = x - 0x10000 return x def r_long(self): s = self._read(4) a = Ord(s[0]) b = Ord(s[1]) c = Ord(s[2]) d = Ord(s[3]) x = a | (b<<8) | (c<<16) | (d<<24) if d & 0x80 and x > 0: x = -((1<<32) - x) return int(x) else: return x def r_long64(self): a = Ord(self._read(1)) b = Ord(self._read(1)) c = Ord(self._read(1)) d = Ord(self._read(1)) e = Ord(self._read(1)) f = Ord(self._read(1)) g = Ord(self._read(1)) h = Ord(self._read(1)) x = a | (b<<8) | (c<<16) | (d<<24) x = x | (e<<32) | (f<<40) | (g<<48) | (h<<56) if h & 0x80 and x > 0: x = -((1<<64) - x) return x def load_null(self): return _NULL dispatch[TYPE_NULL] = load_null def load_none(self): return None dispatch[TYPE_NONE] = load_none def load_true(self): return True dispatch[TYPE_TRUE] = load_true def load_false(self): return False dispatch[TYPE_FALSE] = load_false def load_stopiter(self): return StopIteration dispatch[TYPE_STOPITER] = load_stopiter def load_ellipsis(self): return Ellipsis dispatch[TYPE_ELLIPSIS] = load_ellipsis dispatch[TYPE_INT] = r_long dispatch[TYPE_INT64] = r_long64 def load_long(self): size = self.r_long() sign = 1 if size < 0: sign = -1 size = -size x = 0 for i in range(size): d = self.r_short() x = x | (d<<(i*15)) return x * sign dispatch[TYPE_LONG] = load_long def load_float(self): n = Ord(self._read(1)) s = self._read(n) return float(s) dispatch[TYPE_FLOAT] = load_float def load_binary_float(self): f = self._read(8) return float(struct.unpack('d', f)[0]) dispatch[TYPE_BINARY_FLOAT] = load_binary_float def load_complex(self): n = Ord(self._read(1)) s = self._read(n) real = float(s) n = Ord(self._read(1)) s = self._read(n) imag = float(s) return complex(real, imag) dispatch[TYPE_COMPLEX] = load_complex def load_string(self): n = self.r_long() return self._read(n) dispatch[TYPE_STRING] = load_string def load_interned(self): n = self.r_long() ret = intern(self._read(n)) self._stringtable.append(ret) return ret dispatch[TYPE_INTERNED] = load_interned def load_stringref(self): n = self.r_long() return self._stringtable[n] dispatch[TYPE_STRINGREF] = load_stringref def load_unicode(self): n = self.r_long() s = self._read(n) ret = s.decode('utf8') return ret dispatch[TYPE_UNICODE] = load_unicode def load_tuple(self): return tuple(self.load_list()) dispatch[TYPE_TUPLE] = load_tuple def load_list(self): n = self.r_long() list = [self.load() for i in range(n)] return list dispatch[TYPE_LIST] = load_list def load_dict(self): d = {} while 1: key = self.load() if key is _NULL: break value = self.load() d[key] = value return d dispatch[TYPE_DICT] = load_dict def load_code(self): argcount = self.r_long() nlocals = self.r_long() stacksize = self.r_long() flags = self.r_long() code = self.load() consts = self.load() names = self.load() varnames = self.load() freevars = self.load() cellvars = self.load() filename = self.load() name = self.load() firstlineno = self.r_long() lnotab = self.load() return types.CodeType(argcount, nlocals, stacksize, flags, code, consts, names, varnames, filename, name, firstlineno, lnotab, freevars, cellvars) dispatch[TYPE_CODE] = load_code def load_set(self): n = self.r_long() args = [self.load() for i in range(n)] return set(args) dispatch[TYPE_SET] = load_set def load_frozenset(self): n = self.r_long() args = [self.load() for i in range(n)] return frozenset(args) dispatch[TYPE_FROZENSET] = load_frozenset # ________________________________________________________________ def _read(self, n): pos = self.bufpos newpos = pos + n if newpos > len(self.bufstr): raise EOFError ret = self.bufstr[pos : newpos] self.bufpos = newpos return ret def _read1(self): ret = self.bufstr[self.bufpos] self.bufpos += 1 return ret def _r_short(self): lo = Ord(_read1(self)) hi = Ord(_read1(self)) x = lo | (hi<<8) if x & 0x8000: x = x - 0x10000 return x def _r_long(self): # inlined this most common case p = self.bufpos s = self.bufstr a = Ord(s[p]) b = Ord(s[p+1]) c = Ord(s[p+2]) d = Ord(s[p+3]) self.bufpos += 4 x = a | (b<<8) | (c<<16) | (d<<24) if d & 0x80 and x > 0: x = -((1<<32) - x) return int(x) else: return x def _r_long64(self): a = Ord(_read1(self)) b = Ord(_read1(self)) c = Ord(_read1(self)) d = Ord(_read1(self)) e = Ord(_read1(self)) f = Ord(_read1(self)) g = Ord(_read1(self)) h = Ord(_read1(self)) x = a | (b<<8) | (c<<16) | (d<<24) x = x | (e<<32) | (f<<40) | (g<<48) | (h<<56) if h & 0x80 and x > 0: x = -((1<<64) - x) return x _load_dispatch = {} class _FastUnmarshaller: dispatch = {} def __init__(self, buffer): self.bufstr = buffer self.bufpos = 0 self._stringtable = [] def load(self): # make flow space happy c = '?' try: c = self.bufstr[self.bufpos] if PYTHON3: c = chr(c) self.bufpos += 1 return _load_dispatch[c](self) except KeyError: raise ValueError("bad marshal code: %c (%d)" % (c, Ord(c))) except IndexError: raise EOFError def load_null(self): return _NULL dispatch[TYPE_NULL] = load_null def load_none(self): return None dispatch[TYPE_NONE] = load_none def load_true(self): return True dispatch[TYPE_TRUE] = load_true def load_false(self): return False dispatch[TYPE_FALSE] = load_false def load_stopiter(self): return StopIteration dispatch[TYPE_STOPITER] = load_stopiter def load_ellipsis(self): return Ellipsis dispatch[TYPE_ELLIPSIS] = load_ellipsis def load_int(self): return _r_long(self) dispatch[TYPE_INT] = load_int def load_int64(self): return _r_long64(self) dispatch[TYPE_INT64] = load_int64 def load_long(self): size = _r_long(self) sign = 1 if size < 0: sign = -1 size = -size x = 0 for i in range(size): d = _r_short(self) x = x | (d<<(i*15)) return x * sign dispatch[TYPE_LONG] = load_long def load_float(self): n = Ord(_read1(self)) s = _read(self, n) return float(s) dispatch[TYPE_FLOAT] = load_float def load_complex(self): n = Ord(_read1(self)) s = _read(self, n) real = float(s) n = Ord(_read1(self)) s = _read(self, n) imag = float(s) return complex(real, imag) dispatch[TYPE_COMPLEX] = load_complex def load_string(self): n = _r_long(self) return _read(self, n) dispatch[TYPE_STRING] = load_string def load_interned(self): n = _r_long(self) s = _read(self, n) if PYTHON3: s = s.decode('utf8') ret = intern(s) self._stringtable.append(ret) return ret dispatch[TYPE_INTERNED] = load_interned def load_stringref(self): n = _r_long(self) return self._stringtable[n] dispatch[TYPE_STRINGREF] = load_stringref def load_unicode(self): n = _r_long(self) s = _read(self, n) ret = s.decode('utf8') return ret dispatch[TYPE_UNICODE] = load_unicode def load_tuple(self): return tuple(self.load_list()) dispatch[TYPE_TUPLE] = load_tuple def load_list(self): n = _r_long(self) list = [] for i in range(n): list.append(self.load()) return list dispatch[TYPE_LIST] = load_list def load_dict(self): d = {} while 1: key = self.load() if key is _NULL: break value = self.load() d[key] = value return d dispatch[TYPE_DICT] = load_dict def load_code(self): argcount = _r_long(self) nlocals = _r_long(self) stacksize = _r_long(self) flags = _r_long(self) code = self.load() consts = self.load() names = self.load() varnames = self.load() freevars = self.load() cellvars = self.load() filename = self.load() name = self.load() firstlineno = _r_long(self) lnotab = self.load() if PYTHON3: if isinstance(name, bytes): name = 'foo' return types.CodeType(argcount, 0, nlocals, stacksize, flags, code, consts, names, varnames, filename.decode(), name, firstlineno, lnotab, freevars, cellvars) else: return types.CodeType(argcount, nlocals, stacksize, flags, code, consts, names, varnames, filename, name, firstlineno, lnotab, freevars, cellvars) dispatch[TYPE_CODE] = load_code def load_set(self): n = _r_long(self) args = [self.load() for i in range(n)] return set(args) dispatch[TYPE_SET] = load_set def load_frozenset(self): n = _r_long(self) args = [self.load() for i in range(n)] return frozenset(args) dispatch[TYPE_FROZENSET] = load_frozenset _load_dispatch = _FastUnmarshaller.dispatch # _________________________________________________________________ # # user interface version = 1 def dump(x, f, version=version): # XXX 'version' is ignored, we always dump in a version-0-compatible format m = _Marshaller(f.write) m.dump(x) def load(f): um = _Unmarshaller(f.read) return um.load() def dumps(x, version=version): # XXX 'version' is ignored, we always dump in a version-0-compatible format buffer = [] m = _Marshaller(buffer.append) m.dump(x) return ''.join(buffer) def loads(s): um = _FastUnmarshaller(s) return um.load() PK°´Iˆ•?±0 0 xdis/wordcode.pyc;ò å²TXc@s?dZdklZdklZd„Zd„Zd„ZdS(sBPython disassembly functions specific to wordcode from python 3.6 (sPYTHON3(sop_has_argumentccsd}t|ƒ}d}xï||joáto||}nt||ƒ}|}|d7}t }t ||ƒo…to"||||dd|}n+t||ƒt||dƒd|}d}|d7}||i jo|d}qøn|||fVqWdS(Niiiii(s extended_argslenscodesnsisPYTHON3sopsordsoffsetsNonesargsop_has_argumentsopcs EXTENDED_ARG(scodesopcs extended_argsisoffsetsnsargsop((s-build/bdist.linux-x86_64/egg/xdis/wordcode.pys_unpack_opargss(   "* c cs`to0|iddd…}|iddd…}n{gi}|iddd…D]}|t|ƒƒqU~}gi}|iddd…D]}|t|ƒƒq’~}t } |i }d}xxt||ƒD]g\}}|o/|| jo||fV|} n||7}n|djo|d8}n||7}qÖW|| jo||fVndS(s”Find the offsets in a byte code which are start of lines in the source. Generate pairs (offset, lineno) as described in Python/compile.c. iNiii€i(sPYTHON3scodes co_lnotabsbyte_incrementssline_incrementssappends_[1]scsordsNones lastlinenosco_firstlinenoslinenosaddrszips byte_incrs line_incr( scodescsaddrs byte_incrs_[1]sline_incrementss line_incrslinenosbyte_incrementss lastlineno((s-build/bdist.linux-x86_64/egg/xdis/wordcode.pysfindlinestarts s*==       cCs³g}x¢t||ƒD]‘\}}}|tj oud}||i jo|d|}n||i jo |}n|djo"||jo|i |ƒq£q§qqW|SdS(s`Detect all offsets in a byte code which are jump targets. Return the list of offsets. iÿÿÿÿiiN( slabelss_unpack_opargsscodesopcsoffsetsopsargsNoneslabelshasjrelshasjabssappend(scodesopcslabelssoffsetslabelsargsop((s-build/bdist.linux-x86_64/egg/xdis/wordcode.pys findlabels>s    N(s__doc__sxdissPYTHON3s xdis.bytecodesop_has_arguments_unpack_opargssfindlinestartss findlabels(sfindlinestartss findlabelss_unpack_opargssop_has_argumentsPYTHON3((s-build/bdist.linux-x86_64/egg/xdis/wordcode.pys?s     PK¥´I%ÔÞddxdis/version.py# This file is suitable for sourcing inside bash as # well as importing into Python VERSION='3.2.4' PK°´Iñä xdis/load.pyc;ò å²TXc@s¼dkZdkZdkZdkZdkZdkZdklZlZdk Z dk l Z l Z dk l Z dklZd„Zd„Zd„Zheed„Zd d „ZdS( N(sunpackspack(sPYTHON3sPYTHON_VERSION(smagics(sfix_dropbox_pyccCs!|idƒoÓy#dk}|ii|ddƒSWn1y dk}|i|dtƒWqgqgXnXtii|ƒdd!}t o |}n|i dƒ}t i d|d d d d tƒd }ti|d|dtƒn|id ƒ o|idƒ otd|ƒ‚n|SdS(Ns.pys optimizationssdebug_overrideiiýÿÿÿsutf-8sprefixs-ssuffixs.pycstextiscfilesdoraises.pyos)path %s must point to a .py or .pyc file (spathsendswiths importlibsutilscache_from_sourcesimpsFalsesossbasenamesPYTHON3sspathsdecodestempfilesmkstemps py_compilescompilesTrues ValueError(spathsspaths importlibsbasenamesimp((s)build/bdist.linux-x86_64/egg/xdis/load.pyscheck_object_path s,    "cCs|ddddfjSdS(Nióiil (s magic_int(s magic_int((s)build/bdist.linux-x86_64/egg/xdis/load.pysis_pypy&scCsçt|dƒ}y|iƒidƒd}Wn0tj o$|idƒ|iƒd}nXy?tdjot ||dƒ}nt ||ddt ƒ}Wn4t j o(t iid|ƒ|iƒ‚nX|iƒ|Sd S( s. load a Python source file and compile it to byte-code _load_file(filename: string): code_object filename: name of file containing Python source code (normally a .py) code_object: code_object compiled from this source code This function does NOT write any file! srbsutf-8s if2.6000000000000001sexecs dont_inherits>>Syntax error in %s N(sopensfilenamesfpsreadsdecodessourcesUnicodeDecodeErrorsseeksPYTHON_VERSIONscompilescosTrues SyntaxErrorssyssstderrswritesclose(sfilenamesfpscossource((s)build/bdist.linux-x86_64/egg/xdis/load.pys load_file)s"    cCsàd} t|dƒ} | idƒ} ti| ƒ}| dd!dt dƒgjoti ddƒ} nyt ti | d ƒ} Wn€tj ott| ƒd jo@| iƒtd t| dƒd t| dƒ|fƒ‚q| iƒtd | ƒ‚nX|d fjo7| iƒtd|ti | ti| ƒfƒ‚nf|djo| idƒt| ƒSn>|djo0| iƒtd|| ti| ƒfƒ‚n| idƒ}td|ƒd} titiƒƒ} ti| ƒ}d|jo djno td| idƒƒd}nt}|ok| |jo| iƒ}ti|ƒ}q¶|ot"i#i$| ||ƒ}q¶t"i&i'| ||ƒ}nt}| iƒ| | ||t(|ƒ|fSdS(sWload a module without importing it. load_module(filename: string): version, magic_int, code_object filename: name of file containing Python byte-code object (normally a .pyc) code_object: code_object from this file version: Python major/minor value e.g. 2.7. or 3.4 magic_int: more specific than version. The actual byte code version of the code object Parsing the code object takes a bit of parsing time, but sometimes all you want is the module info, time string, code size, python version, etc. For that, set get_code=False. isrbiis0il iiisUnknown magic number %s in %sisBad magic number: '%s'i! sd%s is interim Python %s (%d) bytecode which is not supported. Final released versions are supported.i·òiósh%s is a dropbox-hacked Python %s (bytecode %d). See https://github.com/kholia/dedrop for how to decrypt.sIi€ i™NN()s timestampsopensfilenamesfpsreadsmagicsmagicss magic2ints magic_intschrs int2magicsfloatsversionssversionsKeyErrorslenscloses ImportErrorsordsseeksfix_dropbox_pycstssunpacksimps get_magics my_magic_ints source_sizesNonesget_codesbytecodesmarshalsloadsscos fast_loadsxdissmarshsloads code_objectss unmarshals load_codesis_pypy(sfilenames code_objectss fast_loadsget_codescos magic_intsbytecodestss source_sizesversionsfps timestamps my_magic_intsmagic((s)build/bdist.linux-x86_64/egg/xdis/load.pys load_moduleEsT  6  -    &    icCs¶t|dƒ}|itd|ddƒƒdk}|itdt|iƒƒƒƒd|jo djno|itd|ƒƒn|it i |ƒƒ|i ƒdSdS( sŠWrite bytecode file _bytecode_path_, with code for having Python magic_int (i.e. bytecode associated with some version of Python) swsHccs s NsIi¸ i™N( sopens bytecode_pathsfpswritespacks magic_intstimesintsfilesizesmarshalsdumpsscodesclose(s bytecode_pathscodes magic_intsfilesizesfpstime((s)build/bdist.linux-x86_64/egg/xdis/load.pyswrite_bytecode_fileœs " (simpsmarshalsoss py_compilessysstempfilesstructsunpackspacksxdis.unmarshalsxdissPYTHON3sPYTHON_VERSIONsmagicssxdis.dropbox.decrypt25sfix_dropbox_pycscheck_object_pathsis_pypys load_filesFalsesTrues load_moduleswrite_bytecode_file(sxdiss load_filesfix_dropbox_pycsPYTHON_VERSIONstempfiles py_compilesis_pypys load_modulessyssimpsmagicsscheck_object_pathsunpackswrite_bytecode_filesossmarshalsPYTHON3spack((s)build/bdist.linux-x86_64/egg/xdis/load.pys?s6      WPKxW+IOs‹CCxdis/__init__.py""" Copyright (c) 2015-2016 by Rocky Bernstein Copyright (c) 2000 by hartmut Goebel Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. NB. This is not a masterpiece of software, but became more like a hack. Probably a complete rewrite would be sensefull. hG/2000-12-27 """ import sys __docformat__ = 'restructuredtext' PYTHON3 = (sys.version_info >= (3, 0)) # We do this crazy way to support Python 2.6 which # doesn't support version_major, and has a bug in # floating point so we can't divide 26 by 10 and get # 2.6 PYTHON_VERSION = sys.version_info[0] + (sys.version_info[1] / 10.0) PYTHON_VERSION_STR = "%s.%s" % (sys.version_info[0], sys.version_info[1]) IS_PYPY = '__pypy__' in sys.builtin_module_names sys.setrecursionlimit(5000) # Export some functions from xdis.load import load_module, load_file PK°´I^cõ‚¦{¦{xdis/marsh.pyc;ò å²TXc@s¸dZdkZdkZdklZlZyeWn ej odklZnXd„Z dZ dZ dZ dZ d Zd Zd Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dfd„ƒYZ!dfd„ƒYZ"d fd!„ƒYZ#d"fd#„ƒYZ$d$„Z%d%„Z&d&„Z'd'„Z(d(„Z)hZ*d)fd*„ƒYZ+e+i,Z*d+Z-e-d,„Z.d-„Z/e-d.„Z0d/„Z1dS(0sxInternal Python object serialization This module contains functions that can read and write Python values in a binary format. The format is specific to Python, but independent of machine architecture issues (e.g., you can write a Python value to a file on a PC, transport the file to a Sun, and read it back there). Details of the format may change between Python versions. N(sPYTHON_VERSIONsPYTHON3(sinterncCsto|Sn t|ƒSdS(N(sPYTHON3scsord(sc((s*build/bdist.linux-x86_64/egg/xdis/marsh.pysOrdss0sNsFsTsSs.sisIsfsgsxslssstsRs(s[s{scsus?ss _MarshallercBsvtZhZd„Zd„Zd„Zd„Zd„Zd„Zeee e ƒB}|d@o|d}n|SdS(Niii€i(sOrdsselfs_readsloshisx(sselfsloshisx((s*build/bdist.linux-x86_64/egg/xdis/marsh.pysr_short#s  cCsª|idƒ}t|dƒ}t|dƒ}t|dƒ}t|dƒ}||d>B|d>B|d>B}|d @o |djodd >| }t |ƒSn|SdS( Niiiiiiiii€i ( sselfs_readsssOrdsasbscsdsxsint(sselfsascsbsdsssx((s*build/bdist.linux-x86_64/egg/xdis/marsh.pysr_long+sc Cst|idƒƒ}t|idƒƒ}t|idƒƒ}t|idƒƒ}t|idƒƒ}t|idƒƒ}t|idƒƒ}t|idƒƒ}||d>B|d>B|d>B} | |d>B|d>B|d>B|d>B} |d @o | d jodd >|  } n| SdS( Niiiii i(i0i8i€ii@( sOrdsselfs_readsasbscsdsesfsgshsx( sselfsascsbsesdsgsfshsx((s*build/bdist.linux-x86_64/egg/xdis/marsh.pysr_long648s&cCstSdS(N(s_NULL(sself((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_nullGscCstSdS(N(sNone(sself((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_noneKscCstSdS(N(sTrue(sself((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_trueOscCstSdS(N(sFalse(sself((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_falseSscCstSdS(N(s StopIteration(sself((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_stopiterWscCstSdS(N(sEllipsis(sself((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_ellipsis[scCsw|iƒ}d}|djod}| }nd}x2t|ƒD]$}|iƒ}|||d>B}qCW||SdS(Niiiÿÿÿÿi( sselfsr_longssizessignsxsrangesisr_shortsd(sselfsdsissignsxssize((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_longcs     cCs2t|idƒƒ}|i|ƒ}t|ƒSdS(Ni(sOrdsselfs_readsnsssfloat(sselfsssn((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_floatpscCs-|idƒ}ttid|ƒdƒSdS(Nisdi(sselfs_readsfsfloatsstructsunpack(sselfsf((s*build/bdist.linux-x86_64/egg/xdis/marsh.pysload_binary_floatvscCsqt|idƒƒ}|i|ƒ}t|ƒ}t|idƒƒ}|i|ƒ}t|ƒ}t||ƒSdS(Ni( sOrdsselfs_readsnsssfloatsrealsimagscomplex(sselfsrealsnsssimag((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_complex{s  cCs|iƒ}|i|ƒSdS(N(sselfsr_longsns_read(sselfsn((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_string…s cCs9|iƒ}t|i|ƒƒ}|ii|ƒ|SdS(N(sselfsr_longsnsinterns_readsrets _stringtablesappend(sselfsretsn((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_internedŠs cCs|iƒ}|i|SdS(N(sselfsr_longsns _stringtable(sselfsn((s*build/bdist.linux-x86_64/egg/xdis/marsh.pysload_stringref‘s cCs2|iƒ}|i|ƒ}|idƒ}|SdS(Nsutf8(sselfsr_longsns_readsssdecodesret(sselfsssretsn((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_unicode–s cCst|iƒƒSdS(N(stuplesselfs load_list(sself((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_tuplescCsG|iƒ}gi}t|ƒD]}||iƒƒq ~}|SdS(N( sselfsr_longsnsappends_[1]srangesisloadslist(sselfsislistsns_[1]((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_list¡s 3cCsQh}x@no8|iƒ}|tjoPn|iƒ}|||B}|d@o|d}n|SdS(Nii€i(sOrds_read1sselfsloshisx(sselfsloshisx((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys_r_shortás  cCsÈ|i}|i}t||ƒ}t||dƒ}t||dƒ}t||dƒ}|id7_||d>B|d>B|d>B}|d@o |d jodd >| }t |ƒSn|SdS( Niiiiiiii€ii ( sselfsbufposspsbufstrsssOrdsasbscsdsxsint(sselfsascsbsdspsssx((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys_r_longés  c Cstt|ƒƒ}tt|ƒƒ}tt|ƒƒ}tt|ƒƒ}tt|ƒƒ}tt|ƒƒ}tt|ƒƒ}tt|ƒƒ}||d>B|d>B|d>B} | |d>B|d>B|d>B|d>B} |d@o | d jod d >|  } n| SdS( Niiii i(i0i8i€iii@( sOrds_read1sselfsasbscsdsesfsgshsx( sselfsascsbsesdsgsfshsx((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys _r_long64ùs&s_FastUnmarshallercBs¯tZhZd„Zd„Zd„ZeeeB}qCW||SdS(Niiiÿÿÿÿi( s_r_longsselfssizessignsxsrangesis_r_shortsd(sselfsdsissignsxssize((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_longAs     cCs/tt|ƒƒ}t||ƒ}t|ƒSdS(N(sOrds_read1sselfsns_readsssfloat(sselfsnss((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_floatNscCsktt|ƒƒ}t||ƒ}t|ƒ}tt|ƒƒ}t||ƒ}t|ƒ}t ||ƒSdS(N( sOrds_read1sselfsns_readsssfloatsrealsimagscomplex(sselfsrealsnsssimag((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_complexTs  cCst|ƒ}t||ƒSdS(N(s_r_longsselfsns_read(sselfsn((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_string^s cCsYt|ƒ}t||ƒ}to|idƒ}nt|ƒ}|i i |ƒ|SdS(Nsutf8( s_r_longsselfsns_readsssPYTHON3sdecodesinternsrets _stringtablesappend(sselfsretsnss((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_internedcs  cCst|ƒ}|i|SdS(N(s_r_longsselfsns _stringtable(sselfsn((s*build/bdist.linux-x86_64/egg/xdis/marsh.pysload_stringrefms cCs2t|ƒ}t||ƒ}|idƒ}|SdS(Nsutf8(s_r_longsselfsns_readsssdecodesret(sselfsretsnss((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_unicoders cCst|iƒƒSdS(N(stuplesselfs load_list(sself((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_tupleyscCsDt|ƒ}g}x't|ƒD]}|i|iƒƒqW|SdS(N(s_r_longsselfsnslistsrangesisappendsload(sselfsislistsn((s*build/bdist.linux-x86_64/egg/xdis/marsh.pys load_list}s   cCsQh}x@no8|iƒ}|tjoPn|iƒ}|||', '>=', 'in', 'not in', 'is', 'is not', 'exception match', 'BAD') hasconst = [] hasname = [] hasjrel = [] hasjabs = [] haslocal = [] hascompare = [] hasfree = [] hasnargs = [] # For function-like calls hasvargs = [] # Similar but for operators BUILD_xxx # opmap[opcode_name] => opcode_number opmap = {} # opcode[i] => opcode name opname = [''] * 256 # oppush[op] => number of stack entries pushed oppush = [0] * 256 # oppop[op] => number of stack entries popped oppop = [0] * 256 for op in range(256): opname[op] = '<%r>' % (op,) del op def _def_op(name, op, pop=-2, push=-2): opname[op] = name opmap[name] = op oppush[op] = push oppop[op] = pop def compare_op(name, op, pop=2, push=1): _def_op(name, op, pop, push) hascompare.append(op) def const_op(name, op, pop=0, push=1): _def_op(name, op, pop, push) hasconst.append(op) def free_op(name, op, pop=0, push=1): _def_op(name, op, pop, push) hasfree.append(op) def jabs_op(name, op, pop=0, push=0): _def_op(name, op, pop, push) hasjabs.append(op) def jrel_op(name, op, pop=0, push=0): _def_op(name, op, pop, push) hasjrel.append(op) def local_op(name, op, pop=0, push=1): _def_op(name, op, pop, push) haslocal.append(op) def name_op(name, op, pop=-2, push=-2): _def_op(name, op, pop, push) hasname.append(op) def nargs_op(name, op, pop=-2, push=-2): _def_op(name, op, pop, push) hasnargs.append(op) def varargs_op(name, op, pop=-1, push=1): _def_op(name, op, pop, push) hasvargs.append(op) # Instruction opcodes for compiled code # Blank lines correspond to available opcodes # OP NAME OPCODE POP PUSH #----------------------------------------- _def_op('STOP_CODE', 0, 0, 0) _def_op('POP_TOP', 1, 1, 0) _def_op('ROT_TWO', 2, 2, 2) _def_op('ROT_THREE', 3, 3, 3) _def_op('DUP_TOP', 4, 0, 1) _def_op('ROT_FOUR', 5, 4, 4) _def_op('UNARY_POSITIVE', 10, 1, 1) _def_op('UNARY_NEGATIVE', 11, 1, 1) _def_op('UNARY_NOT', 12, 1, 1) _def_op('UNARY_CONVERT', 13, 1, 1) _def_op('UNARY_INVERT', 15, 1, 1) _def_op('BINARY_POWER', 19, 2, 1) _def_op('BINARY_MULTIPLY', 20, 2, 1) _def_op('BINARY_DIVIDE', 21, 2, 1) _def_op('BINARY_MODULO', 22, 2, 1) _def_op('BINARY_ADD', 23, 2, 1) _def_op('BINARY_SUBTRACT', 24, 2, 1) _def_op('BINARY_SUBSCR', 25, 2, 1) _def_op('BINARY_FLOOR_DIVIDE', 26, 2, 1) _def_op('BINARY_TRUE_DIVIDE', 27, 2, 1) _def_op('INPLACE_FLOOR_DIVIDE', 28, 2, 1) _def_op('INPLACE_TRUE_DIVIDE', 29, 2, 1) _def_op('SLICE+0', 30, 1, 1) _def_op('SLICE+1', 31, 2, 1) _def_op('SLICE+2', 32, 2, 1) _def_op('SLICE+3', 33, 3, 1) _def_op('STORE_SLICE+0', 40, 2, 0) _def_op('STORE_SLICE+1', 41, 3, 0) _def_op('STORE_SLICE+2', 42, 3, 0) _def_op('STORE_SLICE+3', 43, 4, 0) _def_op('DELETE_SLICE+0', 50, 1, 0) _def_op('DELETE_SLICE+1', 51, 2, 0) _def_op('DELETE_SLICE+2', 52, 2, 0) _def_op('DELETE_SLICE+3', 53, 3, 0) _def_op('INPLACE_ADD', 55, 2, 1) _def_op('INPLACE_SUBTRACT', 56, 2, 1) _def_op('INPLACE_MULTIPLY', 57, 2, 1) _def_op('INPLACE_DIVIDE', 58, 2, 1) _def_op('INPLACE_MODULO', 59, 2, 1) _def_op('STORE_SUBSCR', 60, 2, 1) _def_op('DELETE_SUBSCR', 61, 2, 0) _def_op('BINARY_LSHIFT', 62, 2, 1) _def_op('BINARY_RSHIFT', 63, 2, 1) _def_op('BINARY_AND', 64, 2, 1) _def_op('BINARY_XOR', 65, 2, 1) _def_op('BINARY_OR', 66, 2, 1) _def_op('INPLACE_POWER', 67, 2, 1) _def_op('GET_ITER', 68, 1, 1) _def_op('PRINT_EXPR', 70, 1, 0) _def_op('PRINT_ITEM', 71, 1, 0) _def_op('PRINT_NEWLINE', 72, 1, 0) _def_op('PRINT_ITEM_TO', 73, 1, 0) _def_op('PRINT_NEWLINE_TO', 74, 1, 0) _def_op('INPLACE_LSHIFT', 75, 2, 1) _def_op('INPLACE_RSHIFT', 76, 2, 1) _def_op('INPLACE_AND', 77, 2, 1) _def_op('INPLACE_XOR', 78, 2, 1) _def_op('INPLACE_OR', 79, 2, 1) _def_op('BREAK_LOOP', 80, 0, 0) _def_op('LOAD_LOCALS', 82, 0, 1) _def_op('RETURN_VALUE', 83, 1, 0) _def_op('IMPORT_STAR', 84, 1, 0) _def_op('EXEC_STMT', 85, 3, 0) _def_op('YIELD_VALUE', 86, 1, 1) _def_op('POP_BLOCK', 87, 0, 0) _def_op('END_FINALLY', 88, 1, 0) _def_op('BUILD_CLASS', 89, 3, 0) HAVE_ARGUMENT = 90 # Opcodes from here have an argument: name_op('STORE_NAME', 90, 1, 0) # Operand is in name list name_op('DELETE_NAME', 91, 0, 0) # "" varargs_op('UNPACK_SEQUENCE', 92, -1, 1) # Number of tuple items jrel_op('FOR_ITER', 93, -1, -1) name_op('STORE_ATTR', 95, 2, 0) # Operand is in name list name_op('DELETE_ATTR', 96, 1, 0) # "" name_op('STORE_GLOBAL', 97, 1, 0) # "" name_op('DELETE_GLOBAL', 98, 0, 0) # "" _def_op('DUP_TOPX', 99, 1, -1) # number of items to duplicate const_op('LOAD_CONST', 100, 0, 1) # Operand is in const list name_op('LOAD_NAME', 101, 0, 1) # Operand is in name list varargs_op('BUILD_TUPLE', 102, -1, 1) # Number of tuple items varargs_op('BUILD_LIST', 103, -1, 1) # Number of list items varargs_op('BUILD_MAP', 104, -1, 1) # Always zero for now name_op('LOAD_ATTR', 105, 1, 1) # Operand is in name list compare_op('COMPARE_OP', 106, 2, 1) # Comparison operator name_op('IMPORT_NAME', 107, 2, 1) # Operand is in name list name_op('IMPORT_FROM', 108, 0, 1) # Operand is in name list jrel_op('JUMP_FORWARD', 110, 0, 0) # Number of bytes to skip jrel_op('JUMP_IF_FALSE', 111, 1, 1) # "" jrel_op('JUMP_IF_TRUE', 112, 1, 1) # "" jabs_op('JUMP_ABSOLUTE', 113, 0, 0) # Target byte offset from beginning of code name_op('LOAD_GLOBAL', 116, 0, 1) # Operand is in name list jabs_op('CONTINUE_LOOP', 119, 0, 0) # Target address jrel_op('SETUP_LOOP', 120, 0, 0) # Distance to target address jrel_op('SETUP_EXCEPT', 121, 0, 0) # "" jrel_op('SETUP_FINALLY', 122, 0, 0) # "" local_op('LOAD_FAST', 124, 0, 1) # Local variable number local_op('STORE_FAST', 125, 1, 0) # Local variable number local_op('DELETE_FAST', 126) # Local variable number _def_op('RAISE_VARARGS', 130, -1, 0) # Number of raise arguments (1, 2, or 3) nargs_op('CALL_FUNCTION', 131, -1, 1) # #args + (#kwargs << 8) _def_op('MAKE_FUNCTION', 132, -1, 1) # Number of args with default values varargs_op('BUILD_SLICE', 133, -1, 1) # Number of items _def_op('MAKE_CLOSURE', 134, -1, 1) free_op('LOAD_CLOSURE', 135, 0, 1) free_op('LOAD_DEREF', 136, 0, 1) free_op('STORE_DEREF', 137, 1, 0) nargs_op('CALL_FUNCTION_VAR', 140, -1, 1) # #args + (#kwargs << 8) nargs_op('CALL_FUNCTION_KW', 141, -1, 1) # #args + (#kwargs << 8) nargs_op('CALL_FUNCTION_VAR_KW', 142, -1, 1) # #args + (#kwargs << 8) _def_op('EXTENDED_ARG', 143) EXTENDED_ARG = 143 fields2copy = """cmp_op hasjabs""".split() def def_op(opname, opmap, name, op, pop=-2, push=-2): opname[op] = name opmap[name] = op oppush[op] = push oppop[op] = pop def rm_op(name, op, l): # opname is an array, so we need to keep the position in there. l['opname'][op] = '' if op in l['hasconst']: l['hasconst'].remove(op) if op in l['hascompare']: l['hascompare'].remove(op) if op in l['hasfree']: l['hasfree'].remove(op) if op in l['hasjabs']: l['hasjabs'].remove(op) if op in l['hasname']: l['hasname'].remove(op) if op in l['hasjrel']: l['hasjrel'].remove(op) if op in l['haslocal']: l['haslocal'].remove(op) if op in l['hasname']: l['hasname'].remove(op) if op in l['hasnargs']: l['hasnargs'].remove(op) if op in l['hasvargs']: l['hasvargs'].remove(op) assert l['opmap'][name] == op del l['opmap'][name] def dump_opcodes(opmap): """Utility for dumping opcodes""" op2name = {} for k in opmap.keys(): op2name[opmap[k]] = k for i in sorted(op2name.keys()): print("%-3s %s" % (str(i), op2name[i])) PK°´I… åíŸ#Ÿ#xdis/opcodes/opcode_15.pyc;ò ÿ Xc @shdZdklZlZdddddddd d d d d f ZgZgZgZgZgZ gZ gZ gZ gZ hZdgdZx%edƒD]Zdefeeƒed?d@ƒedAdBƒedCdDƒedEdFƒedGdHƒedIdJƒedKdLƒedMdNƒedOdPƒedQdRƒedSdTƒedUdVƒedWdXƒedYdZƒed[d\ƒed]d^ƒed_d`ƒedadbƒedcddƒededfƒedgdhƒedidjƒedkdlƒedmdnƒedodpƒedqdrƒedsdtƒedudvƒdwZedxdwƒedydzƒed{d|ƒed}d~ƒedd€ƒedd‚ƒedƒd„ƒed…d†ƒed‡dˆƒed‰dŠƒed‹dŒƒeddŽƒeddƒed‘d’ƒed“d”ƒed•d–ƒed—d˜ƒed™dšƒed›dœƒeddžƒedŸd ƒed¡d¢ƒed£d¤ƒed¥d¦ƒed§d¨ƒed©dªƒed«d¬ƒed­d®ƒed¯d°ƒed±d²ƒed³d´ƒedµd¶ƒed·d¸ƒed¹dºƒd»Zd¼iƒZd½„Zd¾„Z d¿„Z!e!ƒdÀ„Z"dÁS(Âs€ CPython 1.5 bytecode opcodes This is used in bytecode disassembly. This is similar to the opcodes in Python's dis.py library. (s findlabelssfindlinestartsss>=sinsnot insissis notsexception matchsBADsis<%r>cCs|t|<|t|s BINARY_RSHIFTi?s BINARY_ANDi@s BINARY_XORiAs BINARY_ORiBs PRINT_EXPRiFs PRINT_ITEMiGs PRINT_NEWLINEiHs BREAK_LOOPiPs LOAD_LOCALSiRs RETURN_VALUEiSs EXEC_STMTiUs POP_BLOCKiWs END_FINALLYiXs BUILD_CLASSiYiZs STORE_NAMEs DELETE_NAMEi[s UNPACK_TUPLEi\s UNPACK_LISTi]s STORE_ATTRi_s DELETE_ATTRi`s STORE_GLOBALias DELETE_GLOBALibs LOAD_CONSTids LOAD_NAMEies BUILD_TUPLEifs BUILD_LISTigs BUILD_MAPihs LOAD_ATTRiis COMPARE_OPijs IMPORT_NAMEiks IMPORT_FROMils JUMP_FORWARDins JUMP_IF_FALSEios JUMP_IF_TRUEips JUMP_ABSOLUTEiqsFOR_LOOPirs LOAD_GLOBALits SETUP_LOOPixs SETUP_EXCEPTiys SETUP_FINALLYizs LOAD_FASTi|s STORE_FASTi}s DELETE_FASTi~s SET_LINENOis RAISE_VARARGSi‚s CALL_FUNCTIONiƒs MAKE_FUNCTIONi„s BUILD_SLICEi…iscmp_op hasjabscCs|||<|||ßss+s_( sglobalssupdatesopmapsmapshasjrelshasjabssdictsappends_[1]sitemssksvsreplace(sks_[1]sv((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_15.pys updateGlobalÙsUcCseh}x"|iƒD]}||||WdS(sUtility for dumping opcodess%-3s %sN(sop2namesopmapskeysskssortedsisstr(sopmapsop2namesisk((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_15.pys dump_opcodesæs N(#s__doc__s xdis.bytecodes findlabelssfindlinestartsscmp_opshasconstshasnameshasjrelshasjabsshaslocals hascompareshasfreeshasnargsshasvargssopmapsopnamesrangesopsdef_ops compare_opsconst_opsfree_opsjabs_opsjrel_opslocal_opsname_opsnargs_ops varargs_ops HAVE_ARGUMENTs EXTENDED_ARGssplits fields2copysrm_ops updateGlobals dump_opcodes(s HAVE_ARGUMENTshasnargsshaslocalsopnames varargs_opsrm_ops dump_opcodesshasfreesname_ops hascompareshasjabssdef_opsjrel_ops fields2copyshasjrelshasconsts findlabelss updateGlobalsnargs_opsjabs_opsfindlinestartsslocal_ops EXTENDED_ARGsconst_ops compare_opsfree_opsopmapscmp_opshasvargsshasnamesop((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_15.pys?sæ*                                                                                                PK°´IÁÊô½  xdis/opcodes/opcode_23.pyc;ò å²TXc@sédZdklZdklZlZdkiiZei Z e ei ƒZ e ei ƒZ e ei ƒZ e eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZeeiƒZeeiƒZe eiƒZe eiƒZeiZx-eiD]"Zeeeeƒƒeƒe.ss+s_(sglobalssupdatesopmapsmaps opcode_2xshasjrelshasjabssdictsappends_[1]sitemssksvsreplace(s_[1]svsk((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_23.pys updateGlobal(sX(sPYTHON_VERSIONf2.2999999999999998(%s__doc__scopysdeepcopys xdis.bytecodesfindlinestartss findlabelssxdis.opcodes.opcode_2xsopcodess opcode_2xs HAVE_ARGUMENTslistscmp_opshasconsts hascompareshasfreeshasjabsshasjrelshaslocalshasnameshasnargsshasvargssopmapsopnamesoppushsoppops EXTENDED_ARGs fields2copysobjectsgetattrsglobalss updateGlobalsxdissPYTHON_VERSIONsdissitemssitemsAssertionError(s HAVE_ARGUMENTshasnargss opcode_2xsdeepcopyshaslocalsopnamesoppopshasfrees hascompareshasvargsshasjrelshasconsts findlabelssobjects updateGlobalsoppushsfindlinestartssPYTHON_VERSIONs EXTENDED_ARGsitemsopmapscmp_opshasjabsshasnamesdis((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_23.pys?sB          PKs4VIvíëÞxdis/opcodes/opcode_26.py""" CPython 2.6 bytecode opcodes This is used in bytecode disassembly. This is equivalent to the opcodes in Python's opcode.py library. """ from copy import deepcopy # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels from xdis.opcodes.opcode_2x import def_op import xdis.opcodes.opcode_25 as opcode_25 # FIXME: can we DRY this even more? # Make a *copy* of opcode_2x values so we don't pollute 2x HAVE_ARGUMENT = opcode_25.HAVE_ARGUMENT cmp_op = list(opcode_25.cmp_op) hasconst = list(opcode_25.hasconst) hascompare = list(opcode_25.hascompare) hasfree = list(opcode_25.hasfree) hasjabs = list(opcode_25.hasjabs) hasjrel = list(opcode_25.hasjrel) haslocal = list(opcode_25.haslocal) hasname = list(opcode_25.hasname) hasnargs = list(opcode_25.hasnargs) hasvargs = list(opcode_25.hasvargs) opmap = deepcopy(opcode_25.opmap) opname = deepcopy(opcode_25.opname) oppush = list(opcode_25.oppush) oppop = list(opcode_25.oppop) EXTENDED_ARG = opcode_25.EXTENDED_ARG def updateGlobal(): globals().update({'python_version': 2.6}) # This makes things look more like 2.7 globals().update({'PJIF': opmap['JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['JUMP_IF_TRUE']}) globals().update({'JUMP_OPs': map(lambda op: opname[op], hasjrel + hasjabs)}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opmap.items()])) return # 2.6 def_op(opname, opmap, 'STORE_MAP', 54, 3, 2) updateGlobal() from xdis import PYTHON_VERSION if PYTHON_VERSION == 2.6: import dis # print(set(dis.opmap.items()) - set(opmap.items())) # print(set(opmap.items()) - set(dis.opmap.items())) assert all(item in opmap.items() for item in dis.opmap.items()) assert all(item in dis.opmap.items() for item in opmap.items()) PKX¡UIþUiŒððxdis/opcodes/opcode_21.py""" CPython 2.1 bytecode opcodes This is used in bytecode disassembly. This is equivalent to the opcodes in Python's dis.py library. """ from copy import deepcopy import sys # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels import xdis.opcodes.opcode_2x as opcode_2x from xdis.opcodes.opcode_2x import def_op # FIXME: can we DRY this even more? # Make a *copy* of opcode_2x values so we don't pollute 2x HAVE_ARGUMENT = opcode_2x.HAVE_ARGUMENT cmp_op = list(opcode_2x.cmp_op) hasconst = list(opcode_2x.hasconst) hascompare = list(opcode_2x.hascompare) hasfree = list(opcode_2x.hasfree) hasjabs = list(opcode_2x.hasjabs) hasjrel = list(opcode_2x.hasjrel) haslocal = list(opcode_2x.haslocal) hasname = list(opcode_2x.hasname) hasnargs = list(opcode_2x.hasnargs) hasvargs = list(opcode_2x.hasvargs) opmap = deepcopy(opcode_2x.opmap) opname = deepcopy(opcode_2x.opname) oppush = list(opcode_2x.oppush) oppop = list(opcode_2x.oppop) EXTENDED_ARG = opcode_2x.EXTENDED_ARG def rm_op(name, op): # opname is an array, so we need to keep the position in there. opname[op] = '<%s>' % op # 2.3 Bytecodes not in 2.1 rm_op('BINARY_FLOOR_DIVIDE', 26) rm_op('BINARY_TRUE_DIVIDE', 27) rm_op('BINARY_INPLACE_DIVIDE', 28) rm_op('INPLACE_TURE_DIVIDE', 29) rm_op('GET_ITER', 68) rm_op('YIELD_VALUE', 86) rm_op('FOR_ITER', 93) # 2.1 Bytecodes not in 2.3 def_op(opname, opmap, 'FOR_LOOP', 114) def_op(opname, opmap, 'SET_LINENO', 127) for object in opcode_2x.fields2copy: globals()[object] = deepcopy(getattr(opcode_2x, object)) def updateGlobal(): globals().update({'python_version': 2.1}) # Canonicalize to PJIx: JUMP_IF_y and POP_JUMP_IF_y globals().update({'PJIF': opmap['JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['JUMP_IF_TRUE']}) globals().update({'JUMP_OPs': map(lambda op: opcode_2x.opname[op], opcode_2x.hasjrel + opcode_2x.hasjabs)}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opcode_2x.opmap.items()])) return updateGlobal() if sys.version_info[0:2] == (2,1): import dis assert len(opname) == len(dis.opname) for i in range(len(dis.opname)): assert dis.opname[i] == opname[i], [i, dis.opname[i], opname[i]] PKó>fIÌÈ÷'#'#xdis/opcodes/opcode_3x.py""" CPython 3.2 bytecode opcodes to be used as a base for other opcodes including 3.2. This is used in bytecode disassembly among other things. This is similar to the opcodes in Python's opcode.py library. If this file changes the other opcode files may have to a adjusted accordingly. """ # FIXME: DRY with opcode2x.py cmp_op = ('<', '<=', '==', '!=', '>', '>=', 'in', 'not in', 'is', 'is not', 'exception match', 'BAD') hasconst = [] hasname = [] hasjrel = [] hasjabs = [] haslocal = [] hascompare = [] hasfree = [] hasnargs = [] # For function-like calls hasvargs = [] # Similar but for operators BUILD_xxx # opmap[opcode_name] => opcode_number opmap = {} # opcode[i] => opcode name opname = [''] * 256 # oppush[op] => number of stack entries pushed oppush = [0] * 256 # oppop[op] => number of stack entries popped oppop = [0] * 256 for op in range(256): opname[op] = '<%r>' % (op,) del op def _def_op(name, op, pop=-2, push=-2): opname[op] = name opmap[name] = op oppush[op] = push oppop[op] = pop def compare_op(name, op, pop=2, push=1): _def_op(name, op, pop, push) hascompare.append(op) def const_op(name, op, pop=0, push=1): _def_op(name, op, pop, push) hasconst.append(op) def free_op(name, op, pop=0, push=1): _def_op(name, op, pop, push) hasfree.append(op) def jabs_op(name, op, pop=0, push=0): _def_op(name, op, pop, push) hasjabs.append(op) def jrel_op(name, op, pop=0, push=0): _def_op(name, op, pop, push) hasjrel.append(op) def local_op(name, op, pop=0, push=1): _def_op(name, op, pop, push) haslocal.append(op) def name_op(name, op, pop=-2, push=-2): _def_op(name, op, pop, push) hasname.append(op) def nargs_op(name, op, pop=-2, push=-2): _def_op(name, op, pop, push) hasnargs.append(op) def varargs_op(name, op, pop=-1, push=1): _def_op(name, op, pop, push) hasvargs.append(op) # Instruction opcodes for compiled code # Blank lines correspond to available opcodes # OP NAME OPCODE POP PUSH #----------------------------------------- _def_op('STOP_CODE', 0, 0, 0) _def_op('POP_TOP', 1, 1, 0) _def_op('ROT_TWO', 2, 2, 2) _def_op('ROT_THREE', 3, 3, 3) _def_op('DUP_TOP', 4, 0, 1) # Python 3.2+ _def_op('DUP_TOP_TWO', 5, 0, 2) _def_op('NOP', 9) _def_op('UNARY_POSITIVE', 10, 1, 1) _def_op('UNARY_NEGATIVE', 11, 1, 1) _def_op('UNARY_NOT', 12, 1, 1) _def_op('UNARY_INVERT', 15, 1, 1) _def_op('BINARY_POWER', 19, 2, 1) _def_op('BINARY_MULTIPLY', 20, 2, 1) _def_op('BINARY_MODULO', 22, 2, 1) _def_op('BINARY_ADD', 23, 2, 1) _def_op('BINARY_SUBTRACT', 24, 2, 1) _def_op('BINARY_SUBSCR', 25, 2, 1) _def_op('BINARY_FLOOR_DIVIDE', 26, 2, 1) _def_op('BINARY_TRUE_DIVIDE', 27, 2, 1) _def_op('INPLACE_FLOOR_DIVIDE', 28, 2, 1) _def_op('INPLACE_TRUE_DIVIDE', 29, 2, 1) # Gone from Python 3 are Python2's # SLICE+0 .. SLICE+3 # STORE_SLICE+0 .. STORE_SLICE+3 # DELETE_SLICE+0 .. DELETE_SLICE+3 _def_op('STORE_MAP', 54) _def_op('INPLACE_ADD', 55, 2, 1) _def_op('INPLACE_SUBTRACT', 56, 2, 1) _def_op('INPLACE_MULTIPLY', 57, 2, 1) _def_op('INPLACE_MODULO', 59, 2, 1) _def_op('STORE_SUBSCR', 60, 2, 1) _def_op('DELETE_SUBSCR', 61, 2, 0) _def_op('BINARY_LSHIFT', 62, 2, 1) _def_op('BINARY_RSHIFT', 63, 2, 1) _def_op('BINARY_AND', 64, 2, 1) _def_op('BINARY_XOR', 65, 2, 1) _def_op('BINARY_OR', 66, 2, 1) _def_op('INPLACE_POWER', 67, 2, 1) _def_op('GET_ITER', 68, 1, 1) _def_op('STORE_LOCALS', 69) _def_op('PRINT_EXPR', 70, 1, 0) _def_op('LOAD_BUILD_CLASS', 71, 0, 1) # Python3 drops/changes: # _def_op('PRINT_ITEM', 71) # _def_op('PRINT_NEWLINE', 72) # _def_op('PRINT_ITEM_TO', 73) # _def_op('PRINT_NEWLINE_TO', 74) _def_op('INPLACE_LSHIFT', 75, 2, 1) _def_op('INPLACE_RSHIFT', 76, 2, 1) _def_op('INPLACE_AND', 77, 2, 1) _def_op('INPLACE_XOR', 78, 2, 1) _def_op('INPLACE_OR', 79, 2, 1) _def_op('BREAK_LOOP', 80, 0, 0) _def_op('WITH_CLEANUP', 81) _def_op('RETURN_VALUE', 83, 1, 0) _def_op('IMPORT_STAR', 84, 1, 0) _def_op('YIELD_VALUE', 86, 1, 1) _def_op('POP_BLOCK', 87, 0, 0) _def_op('END_FINALLY', 88, 1, 0) _def_op('POP_EXCEPT', 89, 1, -1) HAVE_ARGUMENT = 90 # Opcodes from here have an argument: name_op('STORE_NAME', 90, 1, 0) # Operand is in name list name_op('DELETE_NAME', 91, 0, 0) # "" varargs_op('UNPACK_SEQUENCE', 92, -1, 1) # Number of tuple items jrel_op('FOR_ITER', 93, -1, -1) _def_op('UNPACK_EX', 94) name_op('STORE_ATTR', 95, 2, 0) # Operand is in name list name_op('DELETE_ATTR', 96, 1, 0) # "" name_op('STORE_GLOBAL', 97, 1, 0) # "" name_op('DELETE_GLOBAL', 98, 0, 0) # "" # Python 2's DUP_TOPX is gone starting in Python 3.2 const_op('LOAD_CONST', 100, 0, 1) # Operand is in const list name_op('LOAD_NAME', 101, 0, 1) # Operand is in name list varargs_op('BUILD_TUPLE', 102, -1, 1) # Number of tuple items varargs_op('BUILD_LIST', 103, -1, 1) # Number of list items varargs_op('BUILD_SET', 104, -1, 1) # Number of set items varargs_op('BUILD_MAP', 105, -1, 1) # Always zero for now name_op('LOAD_ATTR', 106, 1, 1) # Operand is in name list compare_op('COMPARE_OP', 107, 2, 1) # Comparison operator name_op('IMPORT_NAME', 108, 1, 1) # Operand is in name list name_op('IMPORT_FROM', 109, 0, 1) # Operand is in name list jrel_op('JUMP_FORWARD', 110, 0, 0) # Number of bytes to skip jabs_op('JUMP_IF_FALSE_OR_POP', 111) # Target byte offset from beginning of code jabs_op('JUMP_IF_TRUE_OR_POP', 112) # "" jabs_op('JUMP_ABSOLUTE', 113, 0, 0) # Target byte offset from beginning of code jabs_op('POP_JUMP_IF_FALSE', 114) # "" jabs_op('POP_JUMP_IF_TRUE', 115) # "" name_op('LOAD_GLOBAL', 116, 0, 1) # Operand is in name list jabs_op('CONTINUE_LOOP', 119, 0, 0) # Target address jrel_op('SETUP_LOOP', 120, 0, 0) # Distance to target address jrel_op('SETUP_EXCEPT', 121, 0, 0) # "" jrel_op('SETUP_FINALLY', 122, 0, 0) # "" local_op('LOAD_FAST', 124, 0, 1) # Local variable number local_op('STORE_FAST', 125, 1, 0) # Local variable number local_op('DELETE_FAST', 126, 0, 0) # Local variable number _def_op('RAISE_VARARGS', 130, -1, 0) # Number of raise arguments (1, 2, or 3) nargs_op('CALL_FUNCTION', 131, -1, 1) # #args + (#kwargs << 8) _def_op('MAKE_FUNCTION', 132, -1, 1) # Number of args with default values varargs_op('BUILD_SLICE', 133, -1, 1) # Number of items _def_op('MAKE_CLOSURE', 134, -1, 1) free_op('LOAD_CLOSURE', 135, 0, 1) free_op('LOAD_DEREF', 136, 0, 1) free_op('STORE_DEREF', 137, 1, 0) free_op('DELETE_DEREF', 138, 0, 0) nargs_op('CALL_FUNCTION_VAR', 140, -1, 1) # #args + (#kwargs << 8) nargs_op('CALL_FUNCTION_KW', 141, -1, 1) # #args + (#kwargs << 8) nargs_op('CALL_FUNCTION_VAR_KW', 142, -1, 1) # #args + (#kwargs << 8) jrel_op('SETUP_WITH', 143, 0, 2) _def_op('LIST_APPEND', 145, 2, 1) # Calls list.append(TOS[-i], TOS). # Used to implement list comprehensions. _def_op('SET_ADD', 146, 1, 0) _def_op('MAP_ADD', 147, 2, 1) _def_op('EXTENDED_ARG', 144) EXTENDED_ARG = 144 fields2copy = """cmp_op hasconst hasname hasjrel hasjabs haslocal hascompare hasfree hasnargs opmap opname HAVE_ARGUMENT EXTENDED_ARG""".split() def rm_op(name, op, l): # opname is an array, so we need to keep the position in there. l['opname'][op] = '' if op in l['hasconst']: l['hasconst'].remove(op) if op in l['hascompare']: l['hascompare'].remove(op) if op in l['hasfree']: l['hasfree'].remove(op) if op in l['hasjabs']: l['hasjabs'].remove(op) if op in l['hasname']: l['hasname'].remove(op) if op in l['hasjrel']: l['hasjrel'].remove(op) if op in l['haslocal']: l['haslocal'].remove(op) if op in l['hasname']: l['hasname'].remove(op) if op in l['hasnargs']: l['hasnargs'].remove(op) if op in l['hasvargs']: l['hasvargs'].remove(op) assert l['opmap'][name] == op del l['opmap'][name] def dump_opcodes(opmap): """Utility for dumping opcodes""" op2name = {} for k in opmap.keys(): op2name[opmap[k]] = k for i in sorted(op2name.keys()): print("%-3s %s" % (str(i), op2name[i])) PK°´I=¦Ò’'’'xdis/opcodes/opcode_3x.pyc;ò K(Xc @sÅdZddddddddd d d d f ZgZgZgZgZgZgZgZgZ gZ hZ d gdZ dgdZ dgdZx%edƒD]Zdefe ed?ddƒed@dAddƒedBdCddƒedDdEddƒedFdGƒedHdIddƒedJdKddƒedLdMddƒedNdOddƒedPdQddƒedRdSddƒedTdUddƒedVdWddƒedXdYddƒedZd[ddƒed\d]ddƒed^d_ddƒed`daddƒedbdcƒedddeddƒedfdgddƒedhdiddƒedjdkddƒedldmddƒedndoddƒedpdqddƒedrdsddƒedtduƒedvdwddƒedxdyddƒedzd{ddƒed|d}ddƒed~dddƒed€dddƒd‚Zedƒd‚ddƒed„d…ddƒed†d‡ddƒedˆd‰ddƒedŠd‹ƒedŒdddƒedŽdddƒedd‘ddƒed’d“ddƒed”d•ddƒed–d—ddƒed˜d™ddƒedšd›ddƒedœdddƒedždŸddƒed d¡ddƒed¢d£ddƒed¤d¥ddƒed¦d§ddƒed¨d©ddƒedªd«ƒed¬d­ƒed®d¯ddƒed°d±ƒed²d³ƒed´dµddƒed¶d·ddƒed¸d¹ddƒedºd»ddƒed¼d½ddƒed¾d¿ddƒedÀdÁddƒedÂdÃddƒedÄdÅddƒedÆdÇddƒedÈdÉddƒedÊdËddƒedÌdÍddƒedÎdÏddƒedÐdÑddƒedÒdÓddƒedÔdÕddƒedÖd×ddƒedØdÙddƒedÚdÛddƒedÜdÝddƒedÞdßddƒedàdáddƒedâdãddƒedädåƒdåZdæiƒZdç„Zdè„Z déS(ês CPython 3.2 bytecode opcodes to be used as a base for other opcodes including 3.2. This is used in bytecode disassembly among other things. This is similar to the opcodes in Python's opcode.py library. If this file changes the other opcode files may have to a adjusted accordingly. ss>=sinsnot insissis notsexception matchsBADsiis<%r>iþÿÿÿcCs,|t|<|t|<|t|<|t|scCs$t||||ƒti|ƒdS(N(s_def_opsnamesopspopspushshaslocalsappend(snamesopspopspush((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_3x.pyslocal_opBscCs$t||||ƒti|ƒdS(N(s_def_opsnamesopspopspushshasnamesappend(snamesopspopspush((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_3x.pysname_opFscCs$t||||ƒti|ƒdS(N(s_def_opsnamesopspopspushshasnargssappend(snamesopspopspush((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_3x.pysnargs_opJsiÿÿÿÿcCs$t||||ƒti|ƒdS(N(s_def_opsnamesopspopspushshasvargssappend(snamesopspopspush((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_3x.pys varargs_opNss STOP_CODEsPOP_TOPsROT_TWOs ROT_THREEisDUP_TOPis DUP_TOP_TWOisNOPi sUNARY_POSITIVEi sUNARY_NEGATIVEi s UNARY_NOTi s UNARY_INVERTis BINARY_POWERisBINARY_MULTIPLYis BINARY_MODULOis BINARY_ADDisBINARY_SUBTRACTis BINARY_SUBSCRisBINARY_FLOOR_DIVIDEisBINARY_TRUE_DIVIDEisINPLACE_FLOOR_DIVIDEisINPLACE_TRUE_DIVIDEis STORE_MAPi6s INPLACE_ADDi7sINPLACE_SUBTRACTi8sINPLACE_MULTIPLYi9sINPLACE_MODULOi;s STORE_SUBSCRi<s DELETE_SUBSCRi=s BINARY_LSHIFTi>s BINARY_RSHIFTi?s BINARY_ANDi@s BINARY_XORiAs BINARY_ORiBs INPLACE_POWERiCsGET_ITERiDs STORE_LOCALSiEs PRINT_EXPRiFsLOAD_BUILD_CLASSiGsINPLACE_LSHIFTiKsINPLACE_RSHIFTiLs INPLACE_ANDiMs INPLACE_XORiNs INPLACE_ORiOs BREAK_LOOPiPs WITH_CLEANUPiQs RETURN_VALUEiSs IMPORT_STARiTs YIELD_VALUEiVs POP_BLOCKiWs END_FINALLYiXs POP_EXCEPTiYiZs STORE_NAMEs DELETE_NAMEi[sUNPACK_SEQUENCEi\sFOR_ITERi]s UNPACK_EXi^s STORE_ATTRi_s DELETE_ATTRi`s STORE_GLOBALias DELETE_GLOBALibs LOAD_CONSTids LOAD_NAMEies BUILD_TUPLEifs BUILD_LISTigs BUILD_SETihs BUILD_MAPiis LOAD_ATTRijs COMPARE_OPiks IMPORT_NAMEils IMPORT_FROMims JUMP_FORWARDinsJUMP_IF_FALSE_OR_POPiosJUMP_IF_TRUE_OR_POPips JUMP_ABSOLUTEiqsPOP_JUMP_IF_FALSEirsPOP_JUMP_IF_TRUEiss LOAD_GLOBALits CONTINUE_LOOPiws SETUP_LOOPixs SETUP_EXCEPTiys SETUP_FINALLYizs LOAD_FASTi|s STORE_FASTi}s DELETE_FASTi~s RAISE_VARARGSi‚s CALL_FUNCTIONiƒs MAKE_FUNCTIONi„s BUILD_SLICEi…s MAKE_CLOSUREi†s LOAD_CLOSUREi‡s LOAD_DEREFiˆs STORE_DEREFi‰s DELETE_DEREFiŠsCALL_FUNCTION_VARiŒsCALL_FUNCTION_KWisCALL_FUNCTION_VAR_KWiŽs SETUP_WITHis LIST_APPENDi‘sSET_ADDi’sMAP_ADDi“s EXTENDED_ARGistcmp_op hasconst hasname hasjrel hasjabs haslocal hascompare hasfree hasnargs opmap opname HAVE_ARGUMENT EXTENDED_ARGcCsµd|d|<||djo|di|ƒn||djo|di|ƒn||djo|di|ƒn||djo|di|ƒn||djo|di|ƒn||djo|di|ƒn||d jo|d i|ƒn||djo|di|ƒn||d jo|d i|ƒn||d jo|d i|ƒn|d ||jpt‚|d |=dS( Nssopnameshasconsts hascompareshasfreeshasjabsshasnameshasjrelshaslocalshasnargsshasvargssopmap(slsopsremovesnamesAssertionError(snamesopsl((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_3x.pysrm_opës.cCseh}x"|iƒD]}||||WdS(sUtility for dumping opcodess%-3s %sN(sop2namesopmapskeysskssortedsisstr(sopmapsop2namesisk((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_3x.pys dump_opcodess N(!s__doc__scmp_opshasconstshasnameshasjrelshasjabsshaslocals hascompareshasfreeshasnargsshasvargssopmapsopnamesoppushsoppopsrangesops_def_ops compare_opsconst_opsfree_opsjabs_opsjrel_opslocal_opsname_opsnargs_ops varargs_ops HAVE_ARGUMENTs EXTENDED_ARGssplits fields2copysrm_ops dump_opcodes(s HAVE_ARGUMENTshasnargsshaslocalsopnamesoppops varargs_opsrm_ops dump_opcodesshasfreesname_ops hascompares_def_opshasjabssjrel_ops fields2copyshasjrelshasconstsnargs_opsoppushsjabs_opslocal_ops EXTENDED_ARGsconst_ops compare_opsfree_opsopmapscmp_opshasvargsshasnamesop((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_3x.pys?s *                 PKÔ!RIî%¿ iixdis/opcodes/opcode_33.py""" CPython 3.3 bytecode opcodes This is used in disassembly This is a superset of Python 3.3's opcode.py with some opcodes that simplify parsing and semantic interpretation. """ from copy import deepcopy # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels import xdis.opcodes.opcode_3x as opcode_3x from xdis.opcodes.opcode_3x import fields2copy, rm_op # FIXME: can we DRY this even more? opmap = {} opname = [''] * 256 hasconst = list(opcode_3x.hasconst) hascompare = list(opcode_3x.hascompare) hasfree = list(opcode_3x.hasfree) hasjabs = list(opcode_3x.hasjabs) hasjrel = list(opcode_3x.hasjrel) haslocal = list(opcode_3x.haslocal) hasname = list(opcode_3x.hasname) hasnargs = list(opcode_3x.hasnargs) hasvargs = list(opcode_3x.hasvargs) def def_op(name, op): opname[op] = name opmap[name] = op for object in fields2copy: globals()[object] = deepcopy(getattr(opcode_3x, object)) # Below are opcodes since Python 3.2 rm_op('STOP_CODE', 0, locals()) def_op('YIELD_FROM', 72) def updateGlobal(): # JUMP_OPs are used in verification are set in the scanner # and used in the parser grammar globals().update({'python_version': 3.3}) globals().update({'PJIF': opmap['POP_JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['POP_JUMP_IF_TRUE']}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opmap.items()])) globals().update({'JUMP_OPs': map(lambda op: opname[op], hasjrel + hasjabs)}) updateGlobal() # FIXME: turn into pytest test from xdis import PYTHON_VERSION if PYTHON_VERSION == 3.3: import dis # print(set(dis.opmap.items()) - set(opmap.items())) # print(set(opmap.items()) - set(dis.opmap.items())) assert all(item in dis.opmap.items() for item in opmap.items()) assert all(item in opmap.items() for item in dis.opmap.items()) # opcode33.dump_opcodes(opmap) PK°´IÈ,Qd©©xdis/opcodes/opcode_pypy32.pyc;ò å²TXc@s8dZdklZdklZlZdkiiZdkl Z hZ dgdZ dgdZ dgdZ eeiƒZgZeeiƒZeeiƒZx%edƒD]Zdefe eiþÿÿÿcCs,|||<|||<|t|<|t|Ps( sglobalssupdatesopmapsdictsappends_[1]sitemssksvsreplacesmapshasjrelshasjabs(sks_[1]sv((s:build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_pypy32.pys updateGlobalHs U(sPYTHON_VERSIONsIS_PYPYf3.2000000000000002($s__doc__scopysdeepcopys xdis.bytecodesfindlinestartss findlabelssxdis.opcodes.opcode_3xsopcodess opcode_3xs fields2copysopmapsopnamesoppushsoppopslistshasjrelshasjabsshasnameshasnargssrangesopsobjectsgetattrsglobalssdef_opsname_opsjrel_opsappends updateGlobalsxdissPYTHON_VERSIONsIS_PYPYsdissitemssitemsAssertionError(shasnargssdeepcopysopnamesoppopsPYTHON_VERSIONsname_opshasjabssdef_opsjrel_ops fields2copyshasjrels opcode_3xs findlabelssobjectsoppushsfindlinestartss updateGlobalsIS_PYPYsitemsopmapsdisshasnamesop((s:build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_pypy32.pys?sN            PKÔ!RI‚¢°ØIIxdis/opcodes/opcode_32.py""" CPython 3.2 bytecode opcodes This is used in scanner (bytecode disassembly) and parser (Python grammar). This is a superset of Python 3.2's opcode.py with some opcodes that simplify parsing and semantic interpretation. """ from copy import deepcopy # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels import xdis.opcodes.opcode_3x as opcode_3x from xdis.opcodes.opcode_3x import fields2copy # FIXME: can we DRY this even more? opmap = {} opname = [''] * 256 hasconst = list(opcode_3x.hasconst) hascompare = list(opcode_3x.hascompare) hasfree = list(opcode_3x.hasfree) hasjabs = list(opcode_3x.hasjabs) hasjrel = list(opcode_3x.hasjrel) haslocal = list(opcode_3x.haslocal) hasname = list(opcode_3x.hasname) hasnargs = list(opcode_3x.hasnargs) hasvargs = list(opcode_3x.hasvargs) for object in fields2copy: globals()[object] = deepcopy(getattr(opcode_3x, object)) # There are no opcodes to add or change. # If there were, they'd be listed below. def updateGlobal(): # JUMP_OPs are used in verification are set in the scanner # and used in the parser grammar globals().update({'python_version': 3.2}) globals().update({'PJIF': opmap['POP_JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['POP_JUMP_IF_TRUE']}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opmap.items()])) globals().update({'JUMP_OPs': map(lambda op: opname[op], hasjrel + hasjabs)}) updateGlobal() from xdis import PYTHON_VERSION, IS_PYPY if PYTHON_VERSION == 3.2: import dis # print(set(dis.opmap.items()) - set(opmap.items())) # print(set(opmap.items()) - set(dis.opmap.items())) if not IS_PYPY: assert all(item in opmap.items() for item in dis.opmap.items()) assert all(item in dis.opmap.items() for item in opmap.items()) # opcode_3x.dump_opcodes(opmap) PK°´ItÛÌ;;xdis/opcodes/opcode_35.pyc;ò å²TXc@sádZdklZdklZlZdkiiZdkl Z l Z l Z hZ dgdZ eeiƒZeeiƒZeeiƒZeeiƒZeeiƒZeeiƒZeeiƒZeeiƒZd„Zd„Zx*e D]"ZeeeeƒƒeƒeKssPJIFsPOP_JUMP_IF_FALSEsPJITsPOP_JUMP_IF_TRUEsJFs JUMP_FORWARDs+s_( sglobalssupdatesmapshasjrelshasjabssopmapsdictsappends_[1]sitemssksvsreplace(sks_[1]sv((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_35.pys updateGlobalIs )(sPYTHON_VERSIONf3.5($s__doc__scopysdeepcopys xdis.bytecodesfindlinestartss findlabelssxdis.opcodes.opcode_3xsopcodess opcode_3xs fields2copyshasfreesrm_opsopmapsopnameslistshasconsts hascompareshasjabsshasjrelshaslocalshasnameshasnargsshasvargssdef_opsfree_opsobjectsgetattrsglobalsslocalss updateGlobalsxdissPYTHON_VERSIONsdissitemssitemsAssertionError(shasnargssdeepcopyshaslocalsrm_opsopnameshasfrees hascompareshasvargssdef_ops fields2copyshasjrelshasconsts opcode_3xs findlabelssobjectsfindlinestartssPYTHON_VERSIONs updateGlobalsitemsfree_opsopmapshasjabsshasnamesdis((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_35.pys? sf                           PK°´IW;(æ……xdis/opcodes/__init__.pyc;ò 1HGWc@sdS(N((((s5build/bdist.linux-x86_64/egg/xdis/opcodes/__init__.pys?sPKK=UIëvü3ÜÜxdis/opcodes/opcode_15.py""" CPython 1.5 bytecode opcodes This is used in bytecode disassembly. This is similar to the opcodes in Python's dis.py library. """ # These are used from outside this module from xdis.bytecode import findlabels, findlinestarts # FIXME: can we DRY this even more? cmp_op = ('<', '<=', '==', '!=', '>', '>=', 'in', 'not in', 'is', 'is not', 'exception match', 'BAD') hasconst = [] hasname = [] hasjrel = [] hasjabs = [] haslocal = [] hascompare = [] hasfree = [] hasnargs = [] # For function-like calls hasvargs = [] # Similar but for operators BUILD_xxx opmap = {} opname = [''] * 256 for op in range(256): opname[op] = '<%r>' % (op,) del op def def_op(name, op): opname[op] = name opmap[name] = op def compare_op(name, op): def_op(name, op) hascompare.append(op) def const_op(name, op): def_op(name, op) hasconst.append(op) def free_op(name, op): def_op(name, op) hasfree.append(op) def jabs_op(name, op): def_op(name, op) hasjabs.append(op) def jrel_op(name, op): def_op(name, op) hasjrel.append(op) def local_op(name, op): def_op(name, op) haslocal.append(op) def name_op(name, op): def_op(name, op) hasname.append(op) def nargs_op(name, op): def_op(name, op) hasnargs.append(op) def varargs_op(name, op): def_op(name, op) hasvargs.append(op) # Instruction opcodes for compiled code # Blank lines correspond to available opcodes def_op('STOP_CODE', 0) def_op('POP_TOP', 1) def_op('ROT_TWO', 2) def_op('ROT_THREE', 3) def_op('DUP_TOP', 4) def_op('UNARY_POSITIVE', 10) def_op('UNARY_NEGATIVE', 11) def_op('UNARY_NOT', 12) def_op('UNARY_CONVERT', 13) def_op('UNARY_INVERT', 15) def_op('BINARY_POWER', 19) def_op('BINARY_MULTIPLY', 20) def_op('BINARY_DIVIDE', 21) def_op('BINARY_MODULO', 22) def_op('BINARY_ADD', 23) def_op('BINARY_SUBTRACT', 24) def_op('BINARY_SUBSCR', 25) def_op('SLICE+0', 30) def_op('SLICE+1', 31) def_op('SLICE+2', 32) def_op('SLICE+3', 33) def_op('STORE_SLICE+0', 40) def_op('STORE_SLICE+1', 41) def_op('STORE_SLICE+2', 42) def_op('STORE_SLICE+3', 43) def_op('DELETE_SLICE+0', 50) def_op('DELETE_SLICE+1', 51) def_op('DELETE_SLICE+2', 52) def_op('DELETE_SLICE+3', 53) def_op('STORE_SUBSCR', 60) def_op('DELETE_SUBSCR', 61) def_op('BINARY_LSHIFT', 62) def_op('BINARY_RSHIFT', 63) def_op('BINARY_AND', 64) def_op('BINARY_XOR', 65) def_op('BINARY_OR', 66) def_op('PRINT_EXPR', 70) def_op('PRINT_ITEM', 71) def_op('PRINT_NEWLINE', 72) def_op('BREAK_LOOP', 80) def_op('LOAD_LOCALS', 82) def_op('RETURN_VALUE', 83) def_op('EXEC_STMT', 85) def_op('POP_BLOCK', 87) def_op('END_FINALLY', 88) def_op('BUILD_CLASS', 89) HAVE_ARGUMENT = 90 # Opcodes from here have an argument: name_op('STORE_NAME', 90) # Index in name list name_op('DELETE_NAME', 91) # "" varargs_op('UNPACK_TUPLE', 92) # Number of tuple items def_op('UNPACK_LIST', 93) # Number of list items name_op('STORE_ATTR', 95) # Index in name list name_op('DELETE_ATTR', 96) # "" name_op('STORE_GLOBAL', 97) # "" name_op('DELETE_GLOBAL', 98) # "" const_op('LOAD_CONST', 100) # Index in const list name_op('LOAD_NAME', 101) # Index in name list varargs_op('BUILD_TUPLE', 102) # Number of tuple items varargs_op('BUILD_LIST', 103) # Number of list items varargs_op('BUILD_MAP', 104) # Always zero for now name_op('LOAD_ATTR', 105) # Index in name list compare_op('COMPARE_OP', 106) # Comparison operator name_op('IMPORT_NAME', 107) # Index in name list name_op('IMPORT_FROM', 108) # Index in name list jrel_op('JUMP_FORWARD', 110) # Number of bytes to skip jrel_op('JUMP_IF_FALSE', 111) # "" jrel_op('JUMP_IF_TRUE', 112) # "" jabs_op('JUMP_ABSOLUTE', 113) # Target byte offset from beginning of code def_op('FOR_LOOP', 114) # Number of bytes to skip name_op('LOAD_GLOBAL', 116) # Index in name list jrel_op('SETUP_LOOP', 120) # Distance to target address jrel_op('SETUP_EXCEPT', 121) # "" jrel_op('SETUP_FINALLY', 122) # "" local_op('LOAD_FAST', 124) # Local variable number local_op('STORE_FAST', 125) # Local variable number local_op('DELETE_FAST', 126) # Local variable number def_op('SET_LINENO', 127) # Current line number def_op('RAISE_VARARGS', 130) # Number of raise arguments (1, 2, or 3) nargs_op('CALL_FUNCTION', 131) # #args + (#kwargs << 8) def_op('MAKE_FUNCTION', 132) # Number of args with default values varargs_op('BUILD_SLICE', 133) # Number of items EXTENDED_ARG = 143 fields2copy = """cmp_op hasjabs""".split() def def_op(opname, opmap, name, op): opname[op] = name opmap[name] = op def rm_op(name, op, l): # opname is an array, so we need to keep the position in there. l['opname'][op] = '' if op in l['hasconst']: l['hasconst'].remove(op) if op in l['hascompare']: l['hascompare'].remove(op) if op in l['hasfree']: l['hasfree'].remove(op) if op in l['hasjabs']: l['hasjabs'].remove(op) if op in l['hasname']: l['hasname'].remove(op) if op in l['hasjrel']: l['hasjrel'].remove(op) if op in l['haslocal']: l['haslocal'].remove(op) if op in l['hasname']: l['hasname'].remove(op) if op in l['hasnargs']: l['hasnargs'].remove(op) if op in l['hasvargs']: l['hasvargs'].remove(op) assert l['opmap'][name] == op del l['opmap'][name] def updateGlobal(): globals().update({'python_version': 1.5}) # Canonicalize to PJIx: JUMP_IF_y and POP_JUMP_IF_y globals().update({'PJIF': opmap['JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['JUMP_IF_TRUE']}) globals().update({'JUMP_OPs': map(lambda op: opname[op], hasjrel + hasjabs)}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opmap.items()])) return updateGlobal() def dump_opcodes(opmap): """Utility for dumping opcodes""" op2name = {} for k in opmap.keys(): op2name[opmap[k]] = k for i in sorted(op2name.keys()): print("%-3s %s" % (str(i), op2name[i])) PK¤´Iá쬜 œ xdis/opcodes/opcode_30.py""" CPython 3.0 bytecode opcodes This is used in scanner (bytecode disassembly) and parser (Python grammar). This is a superset of Python 3.0's opcode.py with some opcodes that simplify parsing and semantic interpretation. """ from copy import deepcopy # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels import xdis.opcodes.opcode_3x as opcode_3x from xdis.opcodes.opcode_3x import fields2copy, rm_op # FIXME: can we DRY this even more? opmap = {} opname = [''] * 256 cmp_op = list(opcode_3x.cmp_op) hasconst = list(opcode_3x.hasconst) hascompare = list(opcode_3x.hascompare) hasfree = list(opcode_3x.hasfree) hasjabs = list(opcode_3x.hasjabs) hasjrel = list(opcode_3x.hasjrel) haslocal = list(opcode_3x.haslocal) hasname = list(opcode_3x.hasname) hasnargs = list(opcode_3x.hasnargs) hasvargs = list(opcode_3x.hasvargs) opmap = deepcopy(opcode_3x.opmap) oppush = list(opcode_3x.oppush) oppop = list(opcode_3x.oppop) for object in fields2copy: globals()[object] = deepcopy(getattr(opcode_3x, object)) # These are in Python 3.x but not in Python 3.0 rm_op('DUP_TOP_TWO', 5, locals()) rm_op('JUMP_IF_FALSE_OR_POP', 111, locals()) rm_op('JUMP_IF_TRUE_OR_POP', 112, locals()) rm_op('POP_JUMP_IF_FALSE', 114, locals()) rm_op('POP_JUMP_IF_TRUE', 115, locals()) rm_op('DELETE_DEREF', 138, locals()) rm_op('SETUP_WITH', 143, locals()) rm_op('LIST_APPEND', 145, locals()) rm_op('MAP_ADD', 147, locals()) def def_op(name, op, pop=-2, push=-2): opname[op] = name opmap[name] = op oppush[op] = push oppop[op] = pop def jrel_op(name, op, pop=0, push=0): def_op(name, op, pop, push) hasjrel.append(op) # These are are in 3.0 but are not in 3.x or in 3.x they have # different opcode numbers. Note: As a result of opcode value # changes, these have to be applied *after* removing ops (with # the same name). def_op('ROT_FOUR', 5, 4, 4) def_op('SET_ADD', 17, 1, 0) def_op('LIST_APPEND', 18, 2, 1) def_op('DUP_TOPX', 99) jrel_op('JUMP_IF_FALSE', 111, 1, 1) jrel_op('JUMP_IF_TRUE', 112, 1, 1) # This op is in 3.x but its opcode is a 144 instead def_op('EXTENDED_ARG', 143) def updateGlobal(): # JUMP_OPs are used in verification are set in the scanner # and used in the parser grammar globals().update({'python_version': 3.0}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opmap.items()])) globals().update({'JUMP_OPs': map(lambda op: opname[op], hasjrel + hasjabs)}) updateGlobal() from xdis import PYTHON_VERSION if PYTHON_VERSION == 3.0: import dis # print(set(dis.opmap.items()) - set(opmap.items())) # print(set(opmap.items()) - set(dis.opmap.items())) for item in dis.opmap.items(): assert item in opmap.items() for item in opmap.items(): assert item in opmap.items() # opcode_30.dump_opcodes(opmap) PK[¡UI-phéxdis/opcodes/opcode_22.py""" CPython 2.2 bytecode opcodes This is used in bytecode disassembly. This is equivalent to the opcodes in Python's dis.py library. """ from copy import deepcopy # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels import xdis.opcodes.opcode_2x as opcode_2x from xdis.opcodes.opcode_2x import def_op # FIXME: can we DRY this even more? # Make a *copy* of opcode_2x values so we don't pollute 2x HAVE_ARGUMENT = opcode_2x.HAVE_ARGUMENT cmp_op = list(opcode_2x.cmp_op) hasconst = list(opcode_2x.hasconst) hascompare = list(opcode_2x.hascompare) hasfree = list(opcode_2x.hasfree) hasjabs = list(opcode_2x.hasjabs) hasjrel = list(opcode_2x.hasjrel) haslocal = list(opcode_2x.haslocal) hasname = list(opcode_2x.hasname) hasnargs = list(opcode_2x.hasnargs) hasvargs = list(opcode_2x.hasvargs) opmap = deepcopy(opcode_2x.opmap) opname = deepcopy(opcode_2x.opname) oppush = list(opcode_2x.oppush) oppop = list(opcode_2x.oppop) EXTENDED_ARG = opcode_2x.EXTENDED_ARG # 2.2 Bytecodes not in 2.3 def_op(opname, opmap, 'FOR_LOOP', 114) def_op(opname, opmap, 'SET_LINENO', 127) for object in opcode_2x.fields2copy: globals()[object] = deepcopy(getattr(opcode_2x, object)) def updateGlobal(): globals().update({'python_version': 2.2}) # Canonicalize to PJIx: JUMP_IF_y and POP_JUMP_IF_y globals().update({'PJIF': opmap['JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['JUMP_IF_TRUE']}) globals().update({'JUMP_OPs': map(lambda op: opcode_2x.opname[op], opcode_2x.hasjrel + opcode_2x.hasjabs)}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opcode_2x.opmap.items()])) return updateGlobal() from xdis import PYTHON_VERSION if PYTHON_VERSION == 2.2: import dis # print(set(dis.opmap.items()) - set(opmap.items())) # print(set(opmap.items()) - set(dis.opmap.items())) assert all(item in opmap.items() for item in dis.opmap.items()) assert all(item in dis.opmap.items() for item in opmap.items()) PK°´I½Gjg g xdis/opcodes/opcode_24.pyc;ò å²TXc@sdZdklZdklZlZdkiiZdkl Z ei Z e ei ƒZ e ei ƒZ e eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZeeiƒZeeiƒZe eiƒZe eiƒZeiZd„Ze eeddddƒe eed d d d ƒe eed dd dƒeƒdklZedjordkZx1eiiƒD] Z e eiƒjpt!‚q´Wx2eiƒD] Z e eiƒjpt!‚qåWndS(s­ CPython 2.4 bytecode opcodes This is used in bytecode disassembly. This is used in bytecode disassembly. This is equivalent to the opcodes in Python's opcode.py library. (sdeepcopy(sfindlinestartss findlabelsN(sdef_opcCsÙtƒihdd<ƒtƒihdtd<ƒtƒihdtd<ƒtƒihdtd„ttƒ<ƒtƒitgi}ti ƒD](\}}||i d d ƒ|fƒqœ~ƒƒdSdS( Nspython_versionf2.3999999999999999sPJIFs JUMP_IF_FALSEsPJITs JUMP_IF_TRUEsJUMP_OPscCst|S(N(sopnamesop(sop((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_24.pys,ss+s_( sglobalssupdatesopmapsmapshasjrelshasjabssdictsappends_[1]sitemssksvsreplace(sks_[1]sv((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_24.pys updateGlobal&s )UsNOPi is LIST_APPENDiiis YIELD_VALUEiV(sPYTHON_VERSIONf2.3999999999999999("s__doc__scopysdeepcopys xdis.bytecodesfindlinestartss findlabelssxdis.opcodes.opcode_2xsopcodess opcode_2xsdef_ops HAVE_ARGUMENTslistscmp_opshasconsts hascompareshasfreeshasjabsshasjrelshaslocalshasnameshasnargsshasvargssopmapsopnamesoppushsoppops EXTENDED_ARGs updateGlobalsxdissPYTHON_VERSIONsdissitemssitemsAssertionError(s HAVE_ARGUMENTshasnargss opcode_2xsdeepcopyshaslocalsopnamesoppopshasfrees hascompareshasvargssdef_opshasjrelshasconsts findlabelss updateGlobalsoppushsfindlinestartssPYTHON_VERSIONs EXTENDED_ARGsitemsopmapscmp_opshasjabsshasnamesdis((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_24.pys?sD         PK¤´I„j*±½½xdis/opcodes/opcode_31.py""" CPython 3.1 bytecode opcodes This is used in scanner (bytecode disassembly) and parser (Python grammar). This is a superset of Python 3.1's opcode.py with some opcodes that simplify parsing and semantic interpretation. """ from copy import deepcopy # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels import xdis.opcodes.opcode_3x as opcode_3x from xdis.opcodes.opcode_3x import fields2copy, rm_op # FIXME: can we DRY this even more? opmap = {} opname = [''] * 256 hasconst = list(opcode_3x.hasconst) hascompare = list(opcode_3x.hascompare) hasfree = list(opcode_3x.hasfree) hasjabs = list(opcode_3x.hasjabs) hasjrel = list(opcode_3x.hasjrel) haslocal = list(opcode_3x.haslocal) hasname = list(opcode_3x.hasname) hasnargs = list(opcode_3x.hasnargs) hasvargs = list(opcode_3x.hasvargs) for object in fields2copy: globals()[object] = deepcopy(getattr(opcode_3x, object)) def def_op(name, op): opname[op] = name opmap[name] = op # These are in Python 3.x but not in Python 3.1 rm_op('DUP_TOP_TWO', 5, locals()) rm_op('DELETE_DEREF', 138, locals()) rm_op('SETUP_WITH', 143, locals()) # These are in Python 3.1 but not Python 3.x def_op('ROT_FOUR', 5) def_op('DUP_TOPX', 99) # This op is in 3.x but its opcode is a 144 instead def_op('EXTENDED_ARG', 143) # There are no opcodes to add or change. # If there were, they'd be listed below. def updateGlobal(): # JUMP_OPs are used in verification are set in the scanner # and used in the parser grammar globals().update({'python_version': 3.1}) globals().update({'PJIF': opmap['POP_JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['POP_JUMP_IF_TRUE']}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opmap.items()])) globals().update({'JUMP_OPs': map(lambda op: opname[op], hasjrel + hasjabs)}) updateGlobal() from xdis import PYTHON_VERSION if PYTHON_VERSION == 3.1: import dis # print(set(dis.opmap.items()) - set(opmap.items())) # print(set(opmap.items()) - set(dis.opmap.items())) for item in dis.opmap.items(): assert item in opmap.items() for item in opmap.items(): assert item in opmap.items() # opcode_31.dump_opcodes(opmap) PK°´I&wHoŽŽxdis/opcodes/opcode_pypy26.pyc;ò å²TXc@s dZdklZdklZlZdkiiZei Z e ei ƒZ e ei ƒZ e ei ƒZ e eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZeeiƒZeeiƒZeiZddd„Zeeedddd ƒeieed d ƒeieed d ƒeieeddƒeiƒdklZlZedjoeordkZx1eiiƒD] Z e eiƒjpt!‚q¯Wx2eiƒD] Z e eiƒjpt!‚qàWndS(s‹ CPython PYPY 2.6 bytecode opcodes This is used in bytecode disassembly. This is equivalent to the opcodes in Python's opcode.py library. (sdeepcopy(sfindlinestartss findlabelsNiþÿÿÿcCs-ti||||||ƒti |ƒdS(N( s opcode_26sdef_opsopnamesopmapsnamesopspopspushshasnamesappend(sopnamesopmapsnamesopspopspush((s:build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_pypy26.pysname_op"ss LOOKUP_METHODiÉiis CALL_METHODiÊsBUILD_LIST_FROM_ARGiËsJUMP_IF_NOT_DEBUGiÌ(sPYTHON_VERSIONsIS_PYPYf2.6000000000000001("s__doc__scopysdeepcopys xdis.bytecodesfindlinestartss findlabelssxdis.opcodes.opcode_26sopcodess opcode_26s HAVE_ARGUMENTslistscmp_opshasconsts hascompareshasfreeshasjabsshasjrelshaslocalshasnameshasnargsshasvargssopmapsopnames EXTENDED_ARGsname_opsdef_ops updateGlobalsxdissPYTHON_VERSIONsIS_PYPYsdissitemssitemsAssertionError(s HAVE_ARGUMENTshasnargssdeepcopyshaslocalsopnamesPYTHON_VERSIONsname_ops hascompareshasjabsshasjrelshasconsts opcode_26s findlabelssfindlinestartsshasfrees EXTENDED_ARGsIS_PYPYsitemsopmapscmp_opshasvargsshasnamesdis((s:build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_pypy26.pys?s@      PK°´IÙ`èlž ž xdis/opcodes/opcode_31.pyc;ò å²TXc@sdZdklZdklZlZdkiiZdkl Z l Z hZ dgdZ e eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZx*e D]"Zeeeeƒƒeƒe=s( sglobalssupdatesopmapsdictsappends_[1]sitemssksvsreplacesmapshasjrelshasjabs(sks_[1]sv((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_31.pys updateGlobal6s U(sPYTHON_VERSIONf3.1000000000000001(#s__doc__scopysdeepcopys xdis.bytecodesfindlinestartss findlabelssxdis.opcodes.opcode_3xsopcodess opcode_3xs fields2copysrm_opsopmapsopnameslistshasconsts hascompareshasfreeshasjabsshasjrelshaslocalshasnameshasnargsshasvargssobjectsgetattrsglobalssdef_opslocalss updateGlobalsxdissPYTHON_VERSIONsdissitemssitemsAssertionError(shasnargssdeepcopyshaslocalsrm_opsopnameshasfrees hascompareshasvargssdef_ops fields2copyshasjrelshasconsts opcode_3xs findlabelssobjectsfindlinestartssPYTHON_VERSIONs updateGlobalsitemsopmapshasjabsshasnamesdis((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_31.pys?sH            PKÔ!RIxã¢ø77xdis/opcodes/opcode_34.py""" CPython 3.4 bytecode opcodes used in scanner (bytecode disassembly) and parser (Python grammar) This is a superset of Python 3.4's opcode.py with some opcodes that simplify parsing and semantic interpretation. """ from copy import deepcopy # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels import xdis.opcodes.opcode_3x as opcode_3x from xdis.opcodes.opcode_3x import fields2copy, rm_op # FIXME: can we DRY this even more? opmap = {} opname = [''] * 256 hasconst = list(opcode_3x.hasconst) hascompare = list(opcode_3x.hascompare) hasfree = list(opcode_3x.hasfree) hasjabs = list(opcode_3x.hasjabs) hasjrel = list(opcode_3x.hasjrel) haslocal = list(opcode_3x.haslocal) hasname = list(opcode_3x.hasname) hasnargs = list(opcode_3x.hasnargs) hasvargs = list(opcode_3x.hasvargs) def def_op(name, op): opname[op] = name opmap[name] = op def free_op(name, op): def_op(name, op) hasfree.append(op) for object in fields2copy: globals()[object] = deepcopy(getattr(opcode_3x, object)) # Below are opcodes changes since Python 3.2 rm_op('STOP_CODE', 0, locals()) rm_op('STORE_LOCALS', 69, locals()) # These are new since Python 3.3 def_op('YIELD_FROM', 72) free_op('LOAD_CLASSDEREF', 148) def updateGlobal(): # JUMP_OPs are used in verification are set in the scanner # and used in the parser grammar globals().update({'python_version': 3.4}) globals().update({'PJIF': opmap['POP_JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['POP_JUMP_IF_TRUE']}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opmap.items()])) globals().update({'JUMP_OPs': map(lambda op: opname[op], hasjrel + hasjabs)}) updateGlobal() # FIXME: turn into pytest test from xdis import PYTHON_VERSION if PYTHON_VERSION == 3.4: import dis # for item in dis.opmap.items(): # if item not in opmap.items(): # print(item) assert all(item in opmap.items() for item in dis.opmap.items()) assert all(item in dis.opmap.items() for item in opmap.items()) # opcode_34.dump_opcodes(opmap) PK¤´I€žZ } } xdis/opcodes/opcode_pypy32.py""" CPython 3.2 bytecode opcodes This is used in scanner (bytecode disassembly) and parser (Python grammar). This is a superset of Python 3.2's opcode.py with some opcodes that simplify parsing and semantic interpretation. """ from copy import deepcopy # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels import xdis.opcodes.opcode_3x as opcode_3x from xdis.opcodes.opcode_3x import fields2copy # FIXME: can we DRY this even more? # opmap[opcode_name] => opcode_number opmap = {} # opcode[i] => opcode name opname = [''] * 256 # oppush[op] => number of stack entries pushed oppush = [0] * 256 # oppop[op] => number of stack entries popped oppop = [0] * 256 hasjrel = list(opcode_3x.hasjrel) hasjabs = [] hasname = list(opcode_3x.hasname) hasnargs = list(opcode_3x.hasnargs) for op in range(256): opname[op] = '<%r>' % (op,) del op for object in fields2copy: globals()[object] = deepcopy(getattr(opcode_3x, object)) def def_op(opname, opmap, name, op, pop=-2, push=-2): opname[op] = name opmap[name] = op oppush[op] = push oppop[op] = pop def name_op(opname, opmap, name, op, pop=-2, push=-2): def_op(opname, opmap, name, op, pop, push) hasname.append(op) def jrel_op(name, op, pop=-2, push=-2): def_op(opname, opmap, name, op, pop, push) hasjrel.append(op) # PyPy only # ---------- name_op(opname, opmap, 'LOOKUP_METHOD', 201, 1, 2) def_op(opname, opmap, 'CALL_METHOD', 202) hasnargs.append(202) # Used only in single-mode compilation list-comprehension generators def_op(opname, opmap, 'BUILD_LIST_FROM_ARG', 203) # Used only in assert statements jrel_op('JUMP_IF_NOT_DEBUG', 204) # There are no opcodes to remove or change. # If there were, they'd be listed below. def updateGlobal(): globals().update({'python_version': 3.2}) # JUMP_OPs are used in verification are set in the scanner # and used in the parser grammar globals().update({'PJIF': opmap['POP_JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['POP_JUMP_IF_TRUE']}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opmap.items()])) globals().update({'JUMP_OPs': map(lambda op: opname[op], hasjrel + hasjabs)}) updateGlobal() from xdis import PYTHON_VERSION, IS_PYPY if PYTHON_VERSION == 3.2 and IS_PYPY: import dis # print(set(dis.opmap.items()) - set(opmap.items())) # print(set(opmap.items()) - set(dis.opmap.items())) # for item in dis.opmap.items(): if IS_PYPY: for item in dis.opmap.items(): assert item in opmap.items() for item in opmap.items(): assert item in opmap.items() # opcode_3x.dump_opcodes(opmap) PK°´I5_ò, , xdis/opcodes/opcode_20.pyc;ò j® Xc@sádZdklZdkZdklZlZdkii Z dkl Z e i Z e e i ƒZ e e iƒZe e iƒZe e iƒZe e iƒZe e iƒZe e iƒZe e iƒZe e iƒZe e iƒZee iƒZee iƒZe e iƒZe e iƒZe iZd„Zeddƒedd ƒed d ƒed d ƒeddƒeddƒeddƒeddƒeddƒeddƒeddƒeddƒe eeddƒe eed d!ƒx-e iD]"Zeee eƒƒe ƒe(sopsopname(snamesop((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_20.pysrm_op'ssBINARY_FLOOR_DIVIDEisBINARY_TRUE_DIVIDEisBINARY_INPLACE_DIVIDEisINPLACE_TURE_DIVIDEisGET_ITERiDs YIELD_VALUEiVsFOR_ITERi]s CONTINUE_LOOPiws MAKE_CLOSUREi†s LOAD_CLOSUREi‡s LOAD_DEREFiˆs STORE_DEREFi‰sFOR_LOOPirs SET_LINENOicCsâtƒihdd<ƒtƒihdtd<ƒtƒihdtd<ƒtƒihdtd„titiƒ<ƒtƒitgi}tii ƒD](\}}||i d d ƒ|fƒq¥~ƒƒdSdS( Nspython_versionf2.1000000000000001sPJIFs JUMP_IF_FALSEsPJITs JUMP_IF_TRUEsJUMP_OPscCs ti|S(N(s opcode_2xsopnamesop(sop((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_20.pysIss+s_(sglobalssupdatesopmapsmaps opcode_2xshasjrelshasjabssdictsappends_[1]sitemssksvsreplace(s_[1]svsk((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_20.pys updateGlobalCsXii((s__doc__scopysdeepcopyssyss xdis.bytecodesfindlinestartss findlabelssxdis.opcodes.opcode_2xsopcodess opcode_2xsdef_ops HAVE_ARGUMENTslistscmp_opshasconsts hascompareshasfreeshasjabsshasjrelshaslocalshasnameshasnargsshasvargssopmapsopnamesoppushsoppops EXTENDED_ARGsrm_ops fields2copysobjectsgetattrsglobalss updateGlobals version_infosdisslensAssertionErrorsrangesi(s HAVE_ARGUMENTshasnargss opcode_2xsdeepcopyshaslocalsopnamesoppopsrm_opshasfrees hascompareshasvargssdef_opshasjrelshasconsts findlabelssobjects updateGlobalssyssoppushsfindlinestartss EXTENDED_ARGsisopmapscmp_opshasjabsshasnamesdis((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_20.pys?s^                      #PKNaIéPz z xdis/opcodes/opcode_pypy27.py""" CPython PYPY 2.7 bytecode opcodes This is used in bytecode disassembly. This is equivalent to the opcodes in Python's opcode.py library. """ from copy import deepcopy # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels import xdis.opcodes.opcode_27 as opcode_27 from xdis.opcodes.opcode_2x import def_op, rm_op # FIXME: can we DRY this even more? # Make a *copy* of opcode_2x values so we don't pollute 2x HAVE_ARGUMENT = opcode_27.HAVE_ARGUMENT cmp_op = list(opcode_27.cmp_op) hasconst = list(opcode_27.hasconst) hascompare = list(opcode_27.hascompare) hasfree = list(opcode_27.hasfree) hasjabs = list(opcode_27.hasjabs) hasjrel = list(opcode_27.hasjrel) haslocal = list(opcode_27.haslocal) hasname = list(opcode_27.hasname) hasnargs = list(opcode_27.hasnargs) hasvargs = list(opcode_27.hasvargs) opmap = deepcopy(opcode_27.opmap) opname = deepcopy(opcode_27.opname) EXTENDED_ARG = opcode_27.EXTENDED_ARG def updateGlobal(version): globals().update({'python_version': version}) # Canonicalize to PJIx: JUMP_IF_y and POP_JUMP_IF_y globals().update({'PJIF': opmap['POP_JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['POP_JUMP_IF_TRUE']}) globals().update({'JUMP_OPs': map(lambda op: opname[op], hasjrel + hasjabs)}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opmap.items()])) def jrel_op(name, op, pop=-2, push=-2): def_op(opname, opmap, name, op, pop, push) hasjrel.append(op) def jabs_op(name, op, pop=-2, push=-2): def_op(opname, opmap, name, op, pop, push) hasjabs.append(op) def name_op(opname, opmap, name, op, pop=-2, push=-2): opcode_27.def_op(opname, opmap, name, op, pop, push) hasname.append(op) # PyPy only # ---------- name_op(opname, opmap, 'LOOKUP_METHOD', 201, 1, 2) opcode_27.def_op(opname, opmap, 'CALL_METHOD', 202) hasnargs.append(202) # Used only in single-mode compilation list-comprehension generators def_op(opname, opmap, 'BUILD_LIST_FROM_ARG', 203) # Used only in assert statements jrel_op('JUMP_IF_NOT_DEBUG', 204) # There are no opcodes to remove or change. # If there were, they'd be listed below. updateGlobal(2.7) from xdis import PYTHON_VERSION, IS_PYPY if PYTHON_VERSION == 2.7 and IS_PYPY: import dis # print(set(dis.opmap.items()) - set(opmap.items())) # print(set(opmap.items()) - set(dis.opmap.items())) assert all(item in opmap.items() for item in dis.opmap.items()) assert all(item in dis.opmap.items() for item in opmap.items()) # Remove methods so importers aren't tempted to use it. del name_op, jrel_op, jabs_op PK°´Iõ‡üÓÓxdis/opcodes/opcode_30.pyc;ò å²TXc@s-dZdklZdklZlZdkiiZdkl Z l Z hZ dgdZ e eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZeei ƒZ e eiƒZe eiƒZx*e D]"ZeeeeƒƒeƒeUs( sglobalssupdatesdictsappends_[1]sopmapsitemssksvsreplacesmapshasjrelshasjabs(sks_[1]sv((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_30.pys updateGlobalPsU(sPYTHON_VERSIONf3.0('s__doc__scopysdeepcopys xdis.bytecodesfindlinestartss findlabelssxdis.opcodes.opcode_3xsopcodess opcode_3xs fields2copysrm_opsopmapsopnameslistscmp_opshasconsts hascompareshasfreeshasjabsshasjrelshaslocalshasnameshasnargsshasvargssoppushsoppopsobjectsgetattrsglobalsslocalssdef_opsjrel_ops updateGlobalsxdissPYTHON_VERSIONsdissitemssitemsAssertionError(shasnargssdeepcopyshaslocalsrm_opsoppopsopnameshasfrees hascompareshasvargssdef_opsjrel_ops fields2copyshasjrelshasconsts opcode_3xs findlabelssobjectsoppushsfindlinestartssPYTHON_VERSIONs updateGlobalsitemsopmapscmp_opshasjabsshasnamesdis((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_30.pys?sf           PK°´I“ <ï)ï)xdis/opcodes/opcode_2x.pyc;ò ¤CXc @sœ dZddddddddd d d d f ZgZgZgZgZgZgZgZgZ gZ hZ d gdZ dgdZ dgdZx%edƒD]Zdefe ed?ddƒed@dAddƒedBdCddƒedDdEddƒedFdGddƒedHdIddƒedJdKddƒedLdMddƒedNdOd#dƒedPdQddƒedRdSd#dƒedTdUd#dƒedVdWd%dƒedXdYddƒedZd[ddƒed\d]ddƒed^d_d#dƒed`daddƒedbdcddƒedddeddƒedfdgddƒedhdiddƒedjdkddƒedldmddƒedndoddƒedpdqddƒedrdsddƒedtduddƒedvdwddƒedxdyddƒedzd{ddƒed|d}ddƒed~dddƒed€dddƒed‚dƒddƒed„d…ddƒed†d‡ddƒedˆd‰ddƒedŠd‹ddƒedŒdddƒedŽdddƒedd‘ddƒed’d“ddƒed”d•ddƒed–d—ddƒed˜d™d#dƒedšd›ddƒedœdddƒedždŸddƒed d¡d#dƒd¢Zed£d¢ddƒed¤d¥ddƒed¦d§ddƒed¨d©ddƒedªd«ddƒed¬d­ddƒed®d¯ddƒed°d±ddƒed²d³ddƒed´dµddƒed¶d·ddƒed¸d¹ddƒedºd»ddƒed¼d½ddƒed¾d¿ddƒedÀdÁddƒedÂdÃddƒedÄdÅddƒedÆdÇddƒedÈdÉddƒedÊdËddƒedÌdÍddƒedÎdÏddƒedÐdÑddƒedÒdÓddƒedÔdÕddƒedÖd×ddƒedØdÙddƒedÚdÛddƒedÜd݃edÞdßddƒedàdáddƒedâdãddƒedädåddƒedædçddƒedèdéddƒedêdëddƒedìdíddƒedîdïddƒedðdñddƒedòdóddƒedôdõƒdõZdöiƒZddd÷„Zdø„Z dù„Z!dúS(ûsCPython core set of bytecode opcodes based on version 2.3 This is used in bytecode disassembly among other things. This is similar to the opcodes in Python's opcode.py library. If this file changes the other opcode files may have to a adjusted accordingly. ss>=sinsnot insissis notsexception matchsBADsiis<%r>iþÿÿÿcCs,|t|<|t|<|t|<|t|s BINARY_RSHIFTi?s BINARY_ANDi@s BINARY_XORiAs BINARY_ORiBs INPLACE_POWERiCsGET_ITERiDs PRINT_EXPRiFs PRINT_ITEMiGs PRINT_NEWLINEiHs PRINT_ITEM_TOiIsPRINT_NEWLINE_TOiJsINPLACE_LSHIFTiKsINPLACE_RSHIFTiLs INPLACE_ANDiMs INPLACE_XORiNs INPLACE_ORiOs BREAK_LOOPiPs LOAD_LOCALSiRs RETURN_VALUEiSs IMPORT_STARiTs EXEC_STMTiUs YIELD_VALUEiVs POP_BLOCKiWs END_FINALLYiXs BUILD_CLASSiYiZs STORE_NAMEs DELETE_NAMEi[sUNPACK_SEQUENCEi\sFOR_ITERi]s STORE_ATTRi_s DELETE_ATTRi`s STORE_GLOBALias DELETE_GLOBALibsDUP_TOPXics LOAD_CONSTids LOAD_NAMEies BUILD_TUPLEifs BUILD_LISTigs BUILD_MAPihs LOAD_ATTRiis COMPARE_OPijs IMPORT_NAMEiks IMPORT_FROMils JUMP_FORWARDins JUMP_IF_FALSEios JUMP_IF_TRUEips JUMP_ABSOLUTEiqs LOAD_GLOBALits CONTINUE_LOOPiws SETUP_LOOPixs SETUP_EXCEPTiys SETUP_FINALLYizs LOAD_FASTi|s STORE_FASTi}s DELETE_FASTi~s RAISE_VARARGSi‚s CALL_FUNCTIONiƒs MAKE_FUNCTIONi„s BUILD_SLICEi…s MAKE_CLOSUREi†s LOAD_CLOSUREi‡s LOAD_DEREFiˆs STORE_DEREFi‰sCALL_FUNCTION_VARiŒsCALL_FUNCTION_KWisCALL_FUNCTION_VAR_KWiŽs EXTENDED_ARGiscmp_op hasjabscCs,|||<|||<|t|<|t|WdS(sUtility for dumping opcodess%-3s %sN(sop2namesopmapskeysskssortedsisstr(sopmapsop2namesisk((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_2x.pys dump_opcodess N("s__doc__scmp_opshasconstshasnameshasjrelshasjabsshaslocals hascompareshasfreeshasnargsshasvargssopmapsopnamesoppushsoppopsrangesops_def_ops compare_opsconst_opsfree_opsjabs_opsjrel_opslocal_opsname_opsnargs_ops varargs_ops HAVE_ARGUMENTs EXTENDED_ARGssplits fields2copysdef_opsrm_ops dump_opcodes(s HAVE_ARGUMENTshasnargsshaslocalsopnamesoppops varargs_opsrm_ops dump_opcodesshasfreesname_ops hascompares_def_opshasjabssdef_opsjrel_ops fields2copyshasjrelshasconstsnargs_opsoppushsjabs_opslocal_ops EXTENDED_ARGsconst_ops compare_opsfree_opsopmapscmp_opshasvargsshasnamesop((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_2x.pys?s*         PK°´I8%Álxdis/opcodes/opcode_27.pyc;ò å²TXc@sdZdklZdklZlZdkiiZdkl Z l Z ei Z e ei ƒZ e eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZe eiƒZeeiƒZeeiƒZe eiƒZe eiƒZeiZd„Zddd„Zddd„Zd „Zd „Z e eed d d d ƒe eedddd ƒe eeddddƒe eeddddƒe dde!ƒƒe dde!ƒƒe dde!ƒƒe dde!ƒƒe d d!e!ƒƒe d"d#e!ƒƒe d$d%e!ƒƒe d&d'e!ƒƒe eed(d)ddƒe eed*dƒe eeddƒeddƒe ddƒedd!ddƒed d+d dƒed,d#ƒed-d'ƒed.d/ƒed0d1ƒed2d%d dƒe eed$d3ƒe eed4d5ƒe eed6d7ƒed8ƒd9k"l#Z#l$Z$e#d8joe$ ordk%Z%x1e%ii&ƒD] Z'e'ei&ƒjpt(‚q«Wx2ei&ƒD] Z'e'ei&ƒjpt(‚qÜWn[[[dS(:s† CPython 2.7 bytecode opcodes This is used in bytecode disassembly. This is equivalent to the opcodes in Python's opcode.py library. (sdeepcopy(sfindlinestartss findlabelsN(sdef_opsrm_opcCsÕtƒihd|<ƒtƒihdtd<ƒtƒihdtd<ƒtƒihdtd„ttƒ<ƒtƒitgi}ti ƒD](\}}||i dd ƒ|fƒqœ~ƒƒdS( Nspython_versionsPJIFsPOP_JUMP_IF_FALSEsPJITsPOP_JUMP_IF_TRUEsJUMP_OPscCst|S(N(sopnamesop(sop((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_27.pys-ss+s_(sglobalssupdatesversionsopmapsmapshasjrelshasjabssdictsappends_[1]sitemssksvsreplace(sversionsks_[1]sv((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_27.pys updateGlobal&s )iþÿÿÿcCs*ttt||||ƒti|ƒdS(N( sdef_opsopnamesopmapsnamesopspopspushshasnamesappend(snamesopspopspush((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_27.pysname_op0scCs*ttt||||ƒti|ƒdS(N( sdef_opsopnamesopmapsnamesopspopspushshasjrelsappend(snamesopspopspush((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_27.pysjrel_op4scCs$ttt||ƒti|ƒdS(N(sdef_opsopnamesopmapsnamesopshasjabssappend(snamesop((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_27.pysjabs_op8scCs$ttt||ƒti|ƒdS(N(sdef_opsopnamesopmapsnamesops hascomparesappend(snamesop((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_27.pys compare_op<ssNOPi is YIELD_VALUEiVis WITH_CLEANUPiQiÿÿÿÿs STORE_MAPi6iis BUILD_MAPihs LOAD_ATTRiis COMPARE_OPijs IMPORT_NAMEiks IMPORT_FROMils JUMP_IF_FALSEios EXTENDED_ARGis JUMP_IF_TRUEips LIST_APPENDi^s BUILD_SETimsJUMP_IF_FALSE_OR_POPsJUMP_IF_TRUE_OR_POPsPOP_JUMP_IF_FALSEirsPOP_JUMP_IF_TRUEiss SETUP_WITHi‘sSET_ADDi’sMAP_ADDi“f2.7000000000000002(sPYTHON_VERSIONsIS_PYPY()s__doc__scopysdeepcopys xdis.bytecodesfindlinestartss findlabelssxdis.opcodes.opcode_2xsopcodess opcode_2xsdef_opsrm_ops HAVE_ARGUMENTslistscmp_opshasconsts hascompareshasfreeshasjabsshasjrelshaslocalshasnameshasnargsshasvargssopmapsopnamesoppushsoppops EXTENDED_ARGs updateGlobalsname_opsjrel_opsjabs_ops compare_opslocalssxdissPYTHON_VERSIONsIS_PYPYsdissitemssitemsAssertionError(s HAVE_ARGUMENTshasnargss opcode_2xs compare_opsdeepcopyshaslocalsopnamesoppopsrm_opshasfreesname_ops hascompareshasvargssdef_opsjrel_opshasjrelshasconsts findlabelss updateGlobalsoppushsfindlinestartssPYTHON_VERSIONs EXTENDED_ARGsIS_PYPYsjabs_opsitemsopmapscmp_opshasjabsshasnamesdis((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_27.pys?s~               "PKI¡UIÔ#&c‘ ‘ xdis/opcodes/opcode_20.py""" CPython 2.0 bytecode opcodes This is used in bytecode disassembly. This is equivalent to the opcodes in Python's dis.py library. """ from copy import deepcopy import sys # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels import xdis.opcodes.opcode_2x as opcode_2x from xdis.opcodes.opcode_2x import def_op # FIXME: can we DRY this even more? # Make a *copy* of opcode_2x values so we don't pollute 2x HAVE_ARGUMENT = opcode_2x.HAVE_ARGUMENT cmp_op = list(opcode_2x.cmp_op) hasconst = list(opcode_2x.hasconst) hascompare = list(opcode_2x.hascompare) hasfree = list(opcode_2x.hasfree) hasjabs = list(opcode_2x.hasjabs) hasjrel = list(opcode_2x.hasjrel) haslocal = list(opcode_2x.haslocal) hasname = list(opcode_2x.hasname) hasnargs = list(opcode_2x.hasnargs) hasvargs = list(opcode_2x.hasvargs) opmap = deepcopy(opcode_2x.opmap) opname = deepcopy(opcode_2x.opname) oppush = list(opcode_2x.oppush) oppop = list(opcode_2x.oppop) EXTENDED_ARG = opcode_2x.EXTENDED_ARG def rm_op(name, op): # opname is an array, so we need to keep the position in there. opname[op] = '<%s>' % op # 2.3 Bytecodes not in 2.0 rm_op('BINARY_FLOOR_DIVIDE', 26) rm_op('BINARY_TRUE_DIVIDE', 27) rm_op('BINARY_INPLACE_DIVIDE', 28) rm_op('INPLACE_TURE_DIVIDE', 29) rm_op('GET_ITER', 68) rm_op('YIELD_VALUE', 86) rm_op('FOR_ITER', 93) # 2.1 Bytecodes not in 2.0 rm_op('CONTINUE_LOOP', 119) rm_op('MAKE_CLOSURE', 134) rm_op('LOAD_CLOSURE', 135) rm_op('LOAD_DEREF', 136) rm_op('STORE_DEREF', 137) # 2.0 Bytecodes not in 2.3 def_op(opname, opmap, 'FOR_LOOP', 114) def_op(opname, opmap, 'SET_LINENO', 127) for object in opcode_2x.fields2copy: globals()[object] = deepcopy(getattr(opcode_2x, object)) def updateGlobal(): globals().update({'python_version': 2.1}) # Canonicalize to PJIx: JUMP_IF_y and POP_JUMP_IF_y globals().update({'PJIF': opmap['JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['JUMP_IF_TRUE']}) globals().update({'JUMP_OPs': map(lambda op: opcode_2x.opname[op], opcode_2x.hasjrel + opcode_2x.hasjabs)}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opcode_2x.opmap.items()])) return updateGlobal() if sys.version_info[0:2] == (2,0): import dis assert len(opname) == len(dis.opname) for i in range(len(dis.opname)): assert dis.opname[i] == opname[i], [i, dis.opname[i], opname[i]] PK¤´IÌ ‹$YYxdis/opcodes/opcode_27.py""" CPython 2.7 bytecode opcodes This is used in bytecode disassembly. This is equivalent to the opcodes in Python's opcode.py library. """ from copy import deepcopy # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels import xdis.opcodes.opcode_2x as opcode_2x from xdis.opcodes.opcode_2x import def_op, rm_op # FIXME: can we DRY this even more? # Make a *copy* of opcode_2x values so we don't pollute 2x HAVE_ARGUMENT = opcode_2x.HAVE_ARGUMENT cmp_op = list(opcode_2x.cmp_op) hasconst = list(opcode_2x.hasconst) hascompare = list(opcode_2x.hascompare) hasfree = list(opcode_2x.hasfree) hasjabs = list(opcode_2x.hasjabs) hasjrel = list(opcode_2x.hasjrel) haslocal = list(opcode_2x.haslocal) hasname = list(opcode_2x.hasname) hasnargs = list(opcode_2x.hasnargs) hasvargs = list(opcode_2x.hasvargs) opmap = deepcopy(opcode_2x.opmap) opname = deepcopy(opcode_2x.opname) oppush = list(opcode_2x.oppush) oppop = list(opcode_2x.oppop) EXTENDED_ARG = opcode_2x.EXTENDED_ARG def updateGlobal(version): globals().update({'python_version': version}) # Canonicalize to PJIx: JUMP_IF_y and POP_JUMP_IF_y globals().update({'PJIF': opmap['POP_JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['POP_JUMP_IF_TRUE']}) globals().update({'JUMP_OPs': map(lambda op: opname[op], hasjrel + hasjabs)}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opmap.items()])) def name_op(name, op, pop=-2, push=-2): def_op(opname, opmap, name, op, pop, push) hasname.append(op) def jrel_op(name, op, pop=-2, push=-2): def_op(opname, opmap, name, op, pop, push) hasjrel.append(op) def jabs_op(name, op): def_op(opname, opmap, name, op) hasjabs.append(op) def compare_op(name, op): def_op(opname, opmap, name, op) hascompare.append(op) # Bytecodes added since 2.3. # 2.4 def_op(opname, opmap, 'NOP', 9, 0, 0) def_op(opname, opmap, 'YIELD_VALUE', 86, 1, 0) # 2.5 def_op(opname, opmap, 'WITH_CLEANUP', 81, -1, -1) # 2.6 def_op(opname, opmap, 'STORE_MAP', 54, 3, 2) # 2.7 rm_op('BUILD_MAP', 104, locals()) rm_op('LOAD_ATTR', 105, locals()) rm_op('COMPARE_OP', 106, locals()) rm_op('IMPORT_NAME', 107, locals()) rm_op('IMPORT_FROM', 108, locals()) rm_op('JUMP_IF_FALSE', 111, locals()) rm_op('EXTENDED_ARG', 143, locals()) rm_op('JUMP_IF_TRUE', 112, locals()) def_op(opname, opmap, 'LIST_APPEND', 94, 2, 1) # Calls list.append(TOS[-i], TOS). # Used to implement list comprehensions. def_op(opname, opmap, 'BUILD_SET', 104) # Number of set items def_op(opname, opmap, 'BUILD_MAP', 105) name_op('LOAD_ATTR', 106) compare_op('COMPARE_OP', 107) name_op('IMPORT_NAME', 108, 2, 1) # Index in name list name_op('IMPORT_FROM', 109, 0, 1) jabs_op('JUMP_IF_FALSE_OR_POP', 111) # Target byte offset from beginning of code jabs_op('JUMP_IF_TRUE_OR_POP', 112) # "" jabs_op('POP_JUMP_IF_FALSE', 114) # "" jabs_op('POP_JUMP_IF_TRUE', 115) # "" jrel_op('SETUP_WITH', 143, 0, 2) def_op(opname, opmap, 'EXTENDED_ARG', 145) def_op(opname, opmap, 'SET_ADD', 146) def_op(opname, opmap, 'MAP_ADD', 147) updateGlobal(2.7) from xdis import PYTHON_VERSION, IS_PYPY if PYTHON_VERSION == 2.7 and not IS_PYPY: import dis # print(set(dis.opmap.items()) - set(opmap.items())) # print(set(opmap.items()) - set(dis.opmap.items())) for item in dis.opmap.items(): assert item in opmap.items() for item in opmap.items(): assert item in opmap.items() # Remove methods so importers aren't tempted to use it. del name_op, jrel_op, jabs_op PK¤´IþÆ»nnxdis/opcodes/opcode_23.py""" CPython 2.3 bytecode opcodes This is used in bytecode disassembly. This is equivalent to the opcodes in Python's dis.py library. """ from copy import deepcopy # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels import xdis.opcodes.opcode_2x as opcode_2x # FIXME: can we DRY this even more? # Make a *copy* of opcode_2x values so we don't pollute 2x HAVE_ARGUMENT = opcode_2x.HAVE_ARGUMENT cmp_op = list(opcode_2x.cmp_op) hasconst = list(opcode_2x.hasconst) hascompare = list(opcode_2x.hascompare) hasfree = list(opcode_2x.hasfree) hasjabs = list(opcode_2x.hasjabs) hasjrel = list(opcode_2x.hasjrel) haslocal = list(opcode_2x.haslocal) hasname = list(opcode_2x.hasname) hasnargs = list(opcode_2x.hasnargs) hasvargs = list(opcode_2x.hasvargs) opmap = deepcopy(opcode_2x.opmap) opname = deepcopy(opcode_2x.opname) oppush = list(opcode_2x.oppush) oppop = list(opcode_2x.oppop) EXTENDED_ARG = opcode_2x.EXTENDED_ARG for object in opcode_2x.fields2copy: globals()[object] = deepcopy(getattr(opcode_2x, object)) def updateGlobal(): globals().update({'python_version': 2.3}) # Canonicalize to PJIx: JUMP_IF_y and POP_JUMP_IF_y globals().update({'PJIF': opmap['JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['JUMP_IF_TRUE']}) globals().update({'JUMP_OPs': map(lambda op: opcode_2x.opname[op], opcode_2x.hasjrel + opcode_2x.hasjabs)}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opcode_2x.opmap.items()])) return updateGlobal() from xdis import PYTHON_VERSION if PYTHON_VERSION == 2.3: import dis # print(set(dis.opmap.items()) - set(opmap.items())) # print(set(opmap.items()) - set(dis.opmap.items())) for item in dis.opmap.items(): assert item in opmap.items() for item in opmap.items(): assert item in opmap.items() PKDxºHxdis/opcodes/__init__.pyPK¥´I)'cÙ Ù xdis/opcodes/opcode_36.py# (C) Copyright 2016 by Rocky Bernstein """ CPython 3.6 bytecode opcodes used in scanner (bytecode disassembly) and parser (Python grammar) This is a superset of Python 3.6's opcode.py with some opcodes that simplify parsing and semantic interpretation. """ from copy import deepcopy # These are used from outside this module from xdis.wordcode import findlinestarts, findlabels import xdis.opcodes.opcode_3x as opcode_3x from xdis.opcodes.opcode_3x import fields2copy, rm_op # FIXME: can we DRY this even more? opmap = {} opname = [''] * 256 hasfree = list(opcode_3x.hasfree) hasjabs = list(opcode_3x.hasjabs) hasjrel = list(opcode_3x.hasjrel) haslocal = list(opcode_3x.haslocal) hasname = list(opcode_3x.hasname) hasnargs = list(opcode_3x.hasnargs) hasvargs = list(opcode_3x.hasvargs) # oppush[op] => number of stack entries pushed oppush = [0] * 256 # oppop[op] => number of stack entries popped oppop = [0] * 256 def def_op(name, op, pop=-2, push=-2): opname[op] = name opmap[name] = op oppush[op] = push oppop[op] = pop def nargs_op(name, op, pop=-2, push=-2): def_op(name, op, pop, push) hasnargs.append(op) for object in fields2copy: globals()[object] = deepcopy(getattr(opcode_3x, object)) # Below are opcodes changes since Python 3.2 rm_op('STOP_CODE', 0, locals()) rm_op('STORE_LOCALS', 69, locals()) # These are new since Python 3.3 def_op('YIELD_FROM', 72) def_op('LOAD_CLASSDEREF', 148) hasfree.append(148) # These are removed since Python 3.4 rm_op('WITH_CLEANUP', 81, locals()) # These are new since Python 3.5 def_op('BINARY_MATRIX_MULTIPLY', 16) def_op('INPLACE_MATRIX_MULTIPLY', 17) def_op('GET_AITER', 50) def_op('GET_ANEXT', 51) def_op('BEFORE_ASYNC_WITH', 52) def_op('GET_YIELD_FROM_ITER', 69) def_op('GET_AWAITABLE', 73) def_op('WITH_CLEANUP_START', 81) def_op('WITH_CLEANUP_FINISH', 82) def_op('BUILD_LIST_UNPACK', 149) def_op('BUILD_MAP_UNPACK', 150) def_op('BUILD_MAP_UNPACK_WITH_CALL', 151) def_op('BUILD_TUPLE_UNPACK', 152) def_op('BUILD_SET_UNPACK', 153) def_op('SETUP_ASYNC_WITH', 154) rm_op('STORE_MAP', 54, locals()) # These are removed since Python 3.6 rm_op('MAKE_CLOSURE', 134, locals()) rm_op('CALL_FUNCTION_VAR', 140, locals()) rm_op('CALL_FUNCTION_VAR_KW', 142, locals()) # These are new since Python 3.6 def_op('FORMAT_VALUE', 155) def_op('BUILD_CONST_KEY_MAP', 156) def_op('STORE_ANNOTATION', 127) nargs_op('CALL_FUNCTION_EX', 142, -1, 1) def_op('SETUP_ANNOTATIONS', 85) def_op('BUILD_STRING', 157) def_op('BUILD_TUPLE_UNPACK_WITH_CALL', 158) def updateGlobal(): globals().update({'python_version': 3.6}) globals().update({'JUMP_OPs': map(lambda op: opname[op], hasjrel + hasjabs)}) globals().update({'PJIF': opmap['POP_JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['POP_JUMP_IF_TRUE']}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opmap.items()])) updateGlobal() # FIXME: turn into pytest test from xdis import PYTHON_VERSION if PYTHON_VERSION == 3.6: import dis # print(set(dis.opmap.items()) - set(opmap.items())) # print(set(opmap.items()) - set(dis.opmap.items())) assert all(item in opmap.items() for item in dis.opmap.items()) assert all(item in dis.opmap.items() for item in opmap.items()) # opcode_36x.dump_opcodes(opmap) PK°´I 4ª){ { xdis/opcodes/opcode_21.pyc;ò ‰® Xc@s dZdklZdkZdklZlZdkii Z dkl Z e i Z e e i ƒZ e e iƒZe e iƒZe e iƒZe e iƒZe e iƒZe e iƒZe e iƒZe e iƒZe e iƒZee iƒZee iƒZe e iƒZe e iƒZe iZd„Zeddƒedd ƒed d ƒed d ƒeddƒeddƒeddƒe eeddƒe eeddƒx-e iD]"Zeee eƒƒe ƒe(sopsopname(snamesop((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_21.pysrm_op(ssBINARY_FLOOR_DIVIDEisBINARY_TRUE_DIVIDEisBINARY_INPLACE_DIVIDEisINPLACE_TURE_DIVIDEisGET_ITERiDs YIELD_VALUEiVsFOR_ITERi]sFOR_LOOPirs SET_LINENOicCsâtƒihdd<ƒtƒihdtd<ƒtƒihdtd<ƒtƒihdtd„titiƒ<ƒtƒitgi}tii ƒD](\}}||i d d ƒ|fƒq¥~ƒƒdSdS( Nspython_versionf2.1000000000000001sPJIFs JUMP_IF_FALSEsPJITs JUMP_IF_TRUEsJUMP_OPscCs ti|S(N(s opcode_2xsopnamesop(sop((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_21.pysBss+s_(sglobalssupdatesopmapsmaps opcode_2xshasjrelshasjabssdictsappends_[1]sitemssksvsreplace(s_[1]svsk((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_21.pys updateGlobal<sXiii((s__doc__scopysdeepcopyssyss xdis.bytecodesfindlinestartss findlabelssxdis.opcodes.opcode_2xsopcodess opcode_2xsdef_ops HAVE_ARGUMENTslistscmp_opshasconsts hascompareshasfreeshasjabsshasjrelshaslocalshasnameshasnargsshasvargssopmapsopnamesoppushsoppops EXTENDED_ARGsrm_ops fields2copysobjectsgetattrsglobalss updateGlobals version_infosdisslensAssertionErrorsrangesi(s HAVE_ARGUMENTshasnargss opcode_2xsdeepcopyshaslocalsopnamesoppopsrm_opshasfrees hascompareshasvargssdef_opshasjrelshasconsts findlabelssobjects updateGlobalssyssoppushsfindlinestartss EXTENDED_ARGsisopmapscmp_opshasjabsshasnamesdis((s6build/bdist.linux-x86_64/egg/xdis/opcodes/opcode_21.pys?sT                 #PKm¡UIY‚Î$xdis/opcodes/opcode_25.py""" CPython 2.5 bytecode opcodes This is used in bytecode disassembly. This is used in bytecode disassembly. This is equivalent to the opcodes in Python's opcode.py library. """ from copy import deepcopy # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels from xdis.opcodes.opcode_2x import def_op import xdis.opcodes.opcode_24 as opcode_24 # Make a *copy* of opcode_2x values so we don't pollute 2x HAVE_ARGUMENT = opcode_24.HAVE_ARGUMENT cmp_op = list(opcode_24.cmp_op) hasconst = list(opcode_24.hasconst) hascompare = list(opcode_24.hascompare) hasfree = list(opcode_24.hasfree) hasjabs = list(opcode_24.hasjabs) hasjrel = list(opcode_24.hasjrel) haslocal = list(opcode_24.haslocal) hasname = list(opcode_24.hasname) hasnargs = list(opcode_24.hasnargs) hasvargs = list(opcode_24.hasvargs) opmap = deepcopy(opcode_24.opmap) opname = deepcopy(opcode_24.opname) oppush = list(opcode_24.oppush) oppop = list(opcode_24.oppop) EXTENDED_ARG = opcode_24.EXTENDED_ARG def updateGlobal(): globals().update({'python_version': 2.5}) # This makes things look more like 2.7 globals().update({'PJIF': opmap['JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['JUMP_IF_TRUE']}) globals().update({'JUMP_OPs': map(lambda op: opname[op], hasjrel + hasjabs)}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opmap.items()])) return # 2.5 def_op(opname, opmap, 'WITH_CLEANUP', 81) updateGlobal() from xdis import PYTHON_VERSION if PYTHON_VERSION == 2.5: import dis # print(set(dis.opmap.items()) - set(opmap.items())) # print(set(opmap.items()) - set(dis.opmap.items())) assert all(item in opmap.items() for item in dis.opmap.items()) assert all(item in dis.opmap.items() for item in opmap.items()) PK¤´IJP©ö  xdis/opcodes/opcode_24.py""" CPython 2.4 bytecode opcodes This is used in bytecode disassembly. This is used in bytecode disassembly. This is equivalent to the opcodes in Python's opcode.py library. """ from copy import deepcopy # These are used from outside this module from xdis.bytecode import findlinestarts, findlabels import xdis.opcodes.opcode_2x as opcode_2x from xdis.opcodes.opcode_2x import def_op # Make a *copy* of opcode_2x values so we don't pollute 2x HAVE_ARGUMENT = opcode_2x.HAVE_ARGUMENT cmp_op = list(opcode_2x.cmp_op) hasconst = list(opcode_2x.hasconst) hascompare = list(opcode_2x.hascompare) hasfree = list(opcode_2x.hasfree) hasjabs = list(opcode_2x.hasjabs) hasjrel = list(opcode_2x.hasjrel) haslocal = list(opcode_2x.haslocal) hasname = list(opcode_2x.hasname) hasnargs = list(opcode_2x.hasnargs) hasvargs = list(opcode_2x.hasvargs) opmap = deepcopy(opcode_2x.opmap) opname = deepcopy(opcode_2x.opname) oppush = list(opcode_2x.oppush) oppop = list(opcode_2x.oppop) EXTENDED_ARG = opcode_2x.EXTENDED_ARG def updateGlobal(): globals().update({'python_version': 2.4}) # This makes things look more like 2.7 globals().update({'PJIF': opmap['JUMP_IF_FALSE']}) globals().update({'PJIT': opmap['JUMP_IF_TRUE']}) globals().update({'JUMP_OPs': map(lambda op: opname[op], hasjrel + hasjabs)}) globals().update(dict([(k.replace('+', '_'), v) for (k, v) in opmap.items()])) return # Bytecodes added since 2.3 def_op(opname, opmap, 'NOP', 9, 0, 0) def_op(opname, opmap, 'LIST_APPEND', 18, 2, 1) # Calls list.append(TOS[-i], TOS). # Used to implement list comprehensions. def_op(opname, opmap, 'YIELD_VALUE', 86, 1, 0) updateGlobal() from xdis import PYTHON_VERSION if PYTHON_VERSION == 2.4: import dis # print(set(dis.opmap.items()) - set(opmap.items())) # print(set(opmap.items()) - set(dis.opmap.items())) for item in dis.opmap.items(): assert item in opmap.items() for item in opmap.items(): assert item in opmap.items() PK¥´I&,ýåë"ë"xdis/dropbox/decrypt25.py#!/usr/bin/env python # Copyright Hagen Fritsch, 2012, License: GPL-2.0 # Adaption and generalization for xdis use by Rocky Bernstein # Dropbox Python bytecode decryption tool for Dropbox versions of 1.1x # (and possibly earlier) which uses Python bytecode 2.5. import types import struct from xdis import PYTHON3 import xdis.marsh as xmarshal def rng(a, b): b = ((b << 13) ^ b) & 0xffffffff c = (b ^ (b >> 17)) c = (c ^ (c << 5)) return (a * 69069 + c + 0x6611CB3B) & 0xffffffff # this is replaced by mersenne in newer versions def get_keys(a, b): ka = rng(a,b) kb = rng(ka, a) kc = rng(kb, ka) kd = rng(kc, kb) ke = rng(kd, kc) return (kb,kc,kd,ke) def MX(z, y, sum, key, p, e): return (((z>>5^y<<2) + (y>>3^z<<4)) ^ ((sum^y) + (key[(p&3)^e] ^ z))) def tea_decipher(v, key): """ Tiny Decryption Algorithm decription (TEA) See https://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm """ DELTA = 0x9e3779b9 n = len(v) rounds = 6 + 52//n sum = (rounds*DELTA) y = v[0] while sum != 0: e = (sum >> 2) & 3 for p in range(n-1, -1, -1): z = v[(n+p-1)%n] v[p] = (v[p] - MX(z,y,sum,key,p,e)) & 0xffffffff y = v[p] sum -= DELTA return v def load_code(self): """ Returns a Python code object like xdis.unmarshal.load_code(), but in we decrypt the data in self.bufstr. That is: * calculate the TEA key, * decrypt self.bufstr * create and return a Python code-object """ a = self.load_int() b = self.load_int() key = get_keys(a, b) padsize = (b + 15) & ~0xf intsize = padsize/4 data = self.bufstr[self.bufpos:self.bufpos+padsize] # print("%d: %d (%d=%d)" % (self.bufpos, b, padsize, len(data))) data = list(struct.unpack('<%dL' % intsize, data)) tea_decipher(data, key) self.bufpos += padsize obj = xmarshal._FastUnmarshaller(struct.pack('<%dL' % intsize, *data)) code = obj.load_code() co_code = patch(code.co_code) if PYTHON3: return types.CodeType(code.co_argcount, 0, code.co_nlocals, code.co_stacksize, code.co_flags, co_code, code.co_consts, code.co_names, code.co_varnames, code.co_filename, code.co_name, code.co_firstlineno, code.co_lnotab, code.co_freevars, code.co_cellvars) else: return types.CodeType(code.co_argcount, code.co_nlocals, code.co_stacksize, code.co_flags, co_code, code.co_consts, code.co_names, code.co_varnames, code.co_filename, code.co_name, code.co_firstlineno, code.co_lnotab, code.co_freevars, code.co_cellvars) try: a = bytearray() except: class bytearray(object): def __init__(self, s): self.l = map(ord, s) def __setitem__(self, idx, val): self.l[idx] = val def __getitem__(self, idx): return self.l[idx] def __str__(self): return ''.join(map(chr, self.l)) def __len__(self): return len(self.l) # Automatically generated opcode substitution table for v1 # A different dropbox table for v.2 table is at # https://github.com/kholia/dedrop/blob/master/src/dedrop-v2/dedrop-v2.py # They are similar but not the same. table = { 0: 0, 1: 87, 2: 66, 4: 25, 6: 55, 7: 62, 9: 71, 10: 79, 12: 21, 13: 4, 14: 72, 15: 1, 16: 30, 17: 31, 18: 32, 19: 33, 22: 63, 26: 86, 29: 56, 31: 60, 33: 73, 34: 15, 35: 74, 36: 20, 38: 12, 39: 68, 40: 80, 41: 22, 42: 89, 43: 26, 50: 64, 51: 82, 52: 23, 54: 11, 55: 24, 56: 84, 59: 2, 60: 3, 61: 40, 62: 41, 63: 42, 64: 43, 65: 85, 66: 83, 67: 88, 68: 18, 69: 61, 70: 116, 71: 126, 72: 100, 73: 110, 74: 120, 75: 122, 76: 132, 77: 133, 78: 104, 79: 101, 80: 102, 81: 93, 82: 125, 83: 111, 84: 95, 85: 134, 86: 105, 88: 107, 89: 108, 90: 112, 91: 130, 92: 124, 93: 92, 94: 91, 95: 90, 97: 135, 99: 136, 100: 137, 101: 106, 102: 131, 103: 113, 104: 99, 105: 97, 106: 121, 107: 103, 111: 140, 112: 141, 113: 142} # manual mapping of the rest table[37] = 81 table[28] = 19 table[87] = 96 table[21] = 65 table[96] = 119 table[8] = 57 table[32] = 28 table[44] = 50 table[45] = 51 table[46] = 52 table[47] = 53 table[23] = 78 table[24] = 77 table[3] = 59 table[11] = 75 table[58] = 76 misses = {} def patch(code): code = bytearray(code) i = 0 n = len(code) while i < n: op = code[i] if not op in table: print("missing opcode %d. code: " % op, repr(str(code))) misses[op] = misses.get(op, 0) + 1 code[i] = table.get(op,op) i += 1 if table.get(op,op) >= 90: #opcode.HAVE_ARGUMENT: i += 2 if PYTHON3: return bytes(code) else: return str(code) def loads(s): """ xdis.marshal.load() but with its dispatch load_code() function replaced with our decoding version. """ um = xmarshal._FastUnmarshaller(s) um.dispatch[xmarshal.TYPE_CODE] = load_code return um.load() def fix_dropbox_pyc(fp, fixed_pyc='/tmp/test.pyc'): source_size = struct.unpack("I", fp.read(4))[0] # size mod 2**32 ts = fp.read(4) timestamp = struct.unpack("I", ts)[0] b = fp.read() co = loads(b) return 2.5, timestamp, 62131, co, False, source_size def fix_dir(path): import os for root, dirs, files in os.walk(path): for name in files: if not name.endswith('pyc'): continue name = os.path.join(root, name) print("fixing", name) data = open(name).read() try: c = xmarshal.loads(data[8:]) except Exception(e): print("error", e, repr(e)) # print repr(data[8:]) continue # fix the version indicator and save open(name, "w").write( "\xb3\xf2\r\n" + data[4:8] + xmarshal.dumps(c)) if __name__ == '__main__': import os, sys if sys.argv != 2: print("Usage: %s python-file" % os.path.basename(sys.argv[0])) sys.exit(1) fix_dir(sys.argv[1]) # for the sake of completeness, here are the code-fragments to automatically generate # the opcode substitution table if 0: import marshal def fill(c, d): if len(c.co_code) != len(d.co_code): print("len mismatch", c, d) return for i, j in zip(c.co_code, d.co_code): # if i in m and not table[i] == j: # print "mismatch %c (%x) => %c (%x)" % (ord(i),ord(i),ord(j),ord(j)) v = table.setdefault(i, {}) v[j] = v.get(j, 0) + 1 pass return for root, dirs, files in os.walk('library'): for name in files: name = os.path.join(root, name) if not name.endswith('pyc'): continue f2 = os.path.join('/tmp/python-defaults-2.7.2/Python-2.5.4/Lib', name[8:]) if not os.path.exists(f2): continue print("loading", name) try: c = xmarshal.loads(open(name).read()[8:]) except: print("error", name) continue d = marshal.loads(open(f2).read()[8:]) fill(c, d) codes_c = filter(lambda x: type(x) == type(c), c.co_consts) codes_d = filter(lambda x: type(x) == type(c), d.co_consts) for i,j in zip(codes_c, codes_d): fill(i,j) pass pass def print_table(m): k = m.keys() k.sort() table = {} for i in k: print "%c (%02x %s) =>" % \ (ord(i), ord(i), bin(ord(i))), for j,count in m[i].iteritems(): if j == i: continue table[ord(i)] = ord(j) print "\t%c (%02x %s) [%d]" % \ (ord(j), ord(j), bin(ord(j)), count), # print("%c (%02x %s) => %c (%02x %s)\t%d\t%s" % (ord(i),ord(i),bin(ord(i)),ord(j),ord(j),bin(ord(j)),ord(j)-ord(i),bin(ord(i)^ord(j)|0x100).replace('0', ' '))) print() return table import re re.compile('offset loc_(\w+)').findall('dd offset loc_8096DC4, offset loc_8096963, offset loc_8095462') def load(name): a = re.compile('offset loc_(\w+)').findall(open(name).read()) a = [int(i,16) for i in a] c = a[:] c.sort() c = [(i, c.index(i)) for i in a] d = {} for i, (addr, pos) in enumerate(c): d[addr] = (i, pos) return c, d PK°´IÛÌHÀ $ $xdis/dropbox/decrypt25.pyc;ò ç²TXc@sÊdkZdkZdklZdkiZd„Zd„Zd„Z d„Z d„Z y e ƒZ Wndefd„ƒYZ nXhd d <d d <d d <dd<dd<dd<dd<dd<dd<dd<dd<dd <dd<d d!<d"d#<d$d%<d&d'<d(d)<d*d+<d!d,<d%d-<d.d<d/d0<d1d2<d3d<d4d5<d6d7<d8d&<d9d:<d;d(<d<d=<d>d?<d@dA<dBdC<ddD<d+dE<dFd <d,dG<dHd6<dd8<d'd9<d=d;<dIdJ<d dK<dLdM<d5d"<dNdH<dOdP<ddQ<ddR<d-dS<d0dT<dUdV<dWdX<dYdZ<d[d\<dd]<d7d^<d_d`<d?da<dKdb<dEdc<dJdd<d)de<dMdf<d:dg<dhdi<djdk<dldm<d`dl<dndj<dcdh<dodp<dqdr<dRds<d]dt<d^du<dvdw<d\dq<dedo<dtdx<dfdv<dbdy<didz<dwd{edƒ|Ad@}||d?A}||d>A}|d|dd@SdS(Ni IÿÿÿÿiiiÍ i;Ëf(sbscsa(sasbsc((s6build/bdist.linux-x86_64/egg/xdis/dropbox/decrypt25.pysrngscCs_t||ƒ}t||ƒ}t||ƒ}t||ƒ}t||ƒ}||||fSdS(N(srngsasbskaskbskcskdske(sasbskbskaskcskeskd((s6build/bdist.linux-x86_64/egg/xdis/dropbox/decrypt25.pysget_keyss cCs@|d?|d>A|d?|d>A||A||d@|A|AASdS(Niiii(szsyssumskeyspse(szsyssumskeyspse((s6build/bdist.linux-x86_64/egg/xdis/dropbox/decrypt25.pysMXsc CsÕd}t|ƒ}dd|} | |}|d}x–|djoˆ|d?d@}xit|dddƒD]Q}|||d|}||t ||||||ƒd @||<||}qiW||8}q7W|Sd S( st Tiny Decryption Algorithm decription (TEA) See https://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm I¹y7žii4iiiiiÿÿÿÿIÿÿÿÿN( sDELTAslensvsnsroundsssumsysesrangespszsMXskey( svskeysessumsnspsDELTAsyszsrounds((s6build/bdist.linux-x86_64/egg/xdis/dropbox/decrypt25.pys tea_decipher s     +c Cs“|iƒ}|iƒ}t||ƒ}|dd@}|d}|i|i |i |!}t t i d||ƒƒ}t||ƒ|i |7_ tit id||Œƒ}|iƒ}t|iƒ} tobti|id|i|i|i| |i|i|i |i!|i"|i#|i$|i%|i&ƒSn\ti|i|i|i|i| |i|i|i |i!|i"|i#|i$|i%|i&ƒSdS(sî Returns a Python code object like xdis.unmarshal.load_code(), but in we decrypt the data in self.bufstr. That is: * calculate the TEA key, * decrypt self.bufstr * create and return a Python code-object iiðÿÿÿis<%dLiN('sselfsload_intsasbsget_keysskeyspadsizesintsizesbufstrsbufpossdataslistsstructsunpacks tea_deciphersxmarshals_FastUnmarshallerspacksobjs load_codescodespatchsco_codesPYTHON3stypessCodeTypes co_argcounts co_nlocalss co_stacksizesco_flagss co_constssco_namess co_varnamess co_filenamesco_namesco_firstlinenos co_lnotabs co_freevarss co_cellvars( sselfsasbsobjscodespadsizeskeysintsizesdatasco_code((s6build/bdist.linux-x86_64/egg/xdis/dropbox/decrypt25.pys load_code3s.      s bytearraycBs5tZd„Zd„Zd„Zd„Zd„ZRS(NcCstt|ƒ|_dS(N(smapsordsssselfsl(sselfss((s6build/bdist.linux-x86_64/egg/xdis/dropbox/decrypt25.pys__init__ZscCs||i|i iGi iOi ii iiHiiiiiii ii!ii?iiVii8i<iIi"i#iJi$ii&i'iDi(iPi)i*iYi+i2i@i3iRi4ii6i iiTi;ii=iAiUiSiCiXiEiFiti~idinixiKiziLi„iMi…iNihieifiQi]i}ioi_i†iiikiliZipi[i‚i\i|i^iai‡iciˆi‰ijiƒigiqiyiŒiiŽi%ii`iwi9ii,i-i.i5i/i:cCsît|ƒ}d}t|ƒ}xª||joœ||}|tj o9d|tt|ƒƒfGHt i |dƒdt | # import sys, os, getopt from xdis.version import VERSION from xdis import PYTHON_VERSION from xdis.main import disassemble_file program, ext = os.path.splitext(os.path.basename(__file__)) __doc__ = """ Usage: pydisasm [OPTIONS]... FILE pydisasm [--help | -h | -V | --version] Examples: pydisasm foo.pyc pydisasm foo.py # same thing as above but find the file pydisasm foo.pyc bar.pyc # disassemble foo.pyc and bar.pyc Options: -V | --version show version and stop -h | --help show this message """ PATTERNS = ('*.pyc', '*.pyo') def main(): Usage_short = """usage: %s FILE... Type -h for for full help.""" % program if not (2.4 <= PYTHON_VERSION <= 3.6): sys.stderr.write("This works on Python version 2.4..3.6; have %s\n" % PYTHON_VERSION) if len(sys.argv) == 1: sys.stderr.write("No file(s) given\n") sys.stderr.write(Usage_short) sys.exit(1) try: opts, files = getopt.getopt(sys.argv[1:], 'hVU', ['help', 'version']) except getopt.GetoptError(e): sys.stderr.write('%s: %s\n' % (os.path.basename(sys.argv[0]), e)) sys.exit(-1) for opt, val in opts: if opt in ('-h', '--help'): print(__doc__) sys.exit(1) elif opt in ('-V', '--version'): print("%s %s" % (program, VERSION)) sys.exit(0) else: print(opt) sys.stderr.write(Usage_short) sys.exit(1) for file in files: if os.path.exists(files[0]): disassemble_file(file, sys.stdout) else: sys.stderr.write("Can't read %s - skipping\n" % files[0]) pass pass return if __name__ == '__main__': main() PK°´IIS¸~xdis/bin/__init__.pyc;ò 1HGWc@sdS(N((((s1build/bdist.linux-x86_64/egg/xdis/bin/__init__.pys?sPK°´I¯àì8€ € xdis/bin/pydisassemble.pyc;ò å²TXc@sdkZdkZdkZdklZdklZdklZei i ei i e ƒƒ\Z ZdZddfZd„Zedjo eƒndS( N(sVERSION(sPYTHON_VERSION(sdisassemble_filesE Usage: pydisasm [OPTIONS]... FILE pydisasm [--help | -h | -V | --version] Examples: pydisasm foo.pyc pydisasm foo.py # same thing as above but find the file pydisasm foo.pyc bar.pyc # disassemble foo.pyc and bar.pyc Options: -V | --version show version and stop -h | --help show this message s*.pycs*.pyocCsþdt}dtjo djn otiidtƒnttiƒdjo1tiidƒtii|ƒtidƒny,t i tidddd gƒ\}}WnVt i t ƒj oAtiid tiitid ƒt fƒtid ƒnXx’|D]Š\}}|d dfjotGHtidƒq|ddfjo dttfGHtid ƒq|GHtii|ƒtidƒqWxQ|D]I}tii|d ƒot|tiƒq©tiid|d ƒq©WdSdS(Ns,usage: %s FILE... Type -h for for full help.f2.3999999999999999f3.6000000000000001s/This works on Python version 2.4..3.6; have %s isNo file(s) given shVUshelpsversions%s: %s iiÿÿÿÿs-hs--helps-Vs --versions%s %ssCan't read %s - skipping (sprograms Usage_shortsPYTHON_VERSIONssyssstderrswriteslensargvsexitsgetoptsoptssfiless GetoptErrorsesosspathsbasenamesoptsvals__doc__sVERSIONsfilesexistssdisassemble_filesstdout(sfilessoptsvals Usage_shortsfilesopts((s6build/bdist.linux-x86_64/egg/xdis/bin/pydisassemble.pysmain s@ - s__main__(ssyssossgetopts xdis.versionsVERSIONsxdissPYTHON_VERSIONs xdis.mainsdisassemble_filespathssplitextsbasenames__file__sprogramsexts__doc__sPATTERNSsmains__name__( sprogramsPYTHON_VERSIONsdisassemble_filessyssPATTERNSsextsVERSIONsgetoptsmainsoss__doc__((s6build/bdist.linux-x86_64/egg/xdis/bin/pydisassemble.pys?s   $  * PKDxºHxdis/bin/__init__.pyPK°´I˜tõ õ EGG-INFO/PKG-INFOMetadata-Version: 1.0 Name: xdis Version: 3.2.4 Summary: Python cross-version byte-code disassembler and marshal routines Home-page: https://github.com/rocky/python-xdis/ Author: Rocky Bernstein, Hartmut Goebel and others Author-email: rb@dustyfeet.com License: GPL-2.0 Description: |buildstatus| |Supported Python Versions| xdis ========== Cross-Python bytecode Disassembler and Marshal routines Introduction ------------ The Python `dis` module allows you to disassemble bytecode from the same version of Python that you are running on. But what about bytecode from different versions? That's what this package is for. It can "marshal load" Python bytecodes from different versions of Python. The command-line routine *pydisasm* will show disassembly output using Python 3.5 disassembly conventions. It accepts bytecodes from Python version 1.5 to 3.6 or so. The code requires Python 2.6 or later and has been tested on Python running versions 2.6, pypy-2.6.1 2.7, pypy-5.0.1, pypy-5.3.1, 3.2, 3.3, 3.4, 3.5 and 3.6. Installation ------------ This uses setup.py, so it follows the standard Python routine: :: pip install -r requirements.txt pip install -r requirements-dev.txt python setup.py install # may need sudo # or if you have pyenv: python setup.py develop A GNU makefile is also provided so :code:`make install` (possibly as root or sudo) will do the steps above. Testing ------- :: make check A GNU makefile has been added to smooth over setting running the right command, and running tests from fastest to slowest. If you have remake_ installed, you can see the list of all tasks including tests via :code:`remake --tasks`. Usage ----- Run :: ./bin/pydisasm -h for usage help. See Also -------- * https://github.com/rocky/python-uncompyle6 : python bytecode deparsing .. |downloads| image:: https://img.shields.io/pypi/dd/xdis.svg .. _trepan: https://pypi.python.org/pypi/trepan .. _debuggers: https://pypi.python.org/pypi/trepan3k .. _remake: https://bashdb.sf.net/remake .. |buildstatus| image:: https://travis-ci.org/rocky/python-xdis.svg :target: https://travis-ci.org/rocky/python-xdis .. |Supported Python Versions| image:: https://img.shields.io/pypi/pyversions/xdis.svg Platform: UNKNOWN Classifier: Development Status :: 4 - Beta Classifier: Intended Audience :: Developers Classifier: Operating System :: OS Independent Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 2.4 Classifier: Programming Language :: Python :: 2.5 Classifier: Programming Language :: Python :: 2.6 Classifier: Programming Language :: Python :: 2.7 Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.3 Classifier: Programming Language :: Python :: 3.4 Classifier: Programming Language :: Python :: 3.5 Classifier: Topic :: Software Development :: Debuggers Classifier: Topic :: Software Development :: Libraries :: Python Modules PK°´IÃEGG-INFO/top_level.txtxdis PK°´IÑEU¥ÊÊEGG-INFO/SOURCES.txtCOPYING.txt ChangeLog LICENSE.gpl2 LICENSE.mit MANIFEST.in README.rst __pkginfo__.py setup.cfg setup.py bin/pydisasm doc/bytecode-history.md doc/opcode-history.md test/add-test.py test/test_pyenvlib.py test/test_pythonlib.py test/test_pythonlib_old.py test/__pycache__/test_pyenvlib.cpython-26-PYTEST.pyc test/__pycache__/test_pyenvlib.cpython-27-PYTEST.pyc test/__pycache__/test_pyenvlib.cpython-34-PYTEST.pyc test/__pycache__/test_pyenvlib.cpython-35-PYTEST.pyc test/__pycache__/test_pyenvlib.cpython-36-PYTEST.pyc test/__pycache__/test_pythonlib.cpython-26-PYTEST.pyc test/__pycache__/test_pythonlib.cpython-27-PYTEST.pyc test/__pycache__/test_pythonlib.cpython-34-PYTEST.pyc test/__pycache__/test_pythonlib.cpython-35-PYTEST.pyc test/__pycache__/test_pythonlib.cpython-36-PYTEST.pyc test/__pycache__/test_pythonlib_old.cpython-26-PYTEST.pyc test/__pycache__/test_pythonlib_old.cpython-27-PYTEST.pyc test/__pycache__/test_pythonlib_old.cpython-34-PYTEST.pyc test/__pycache__/test_pythonlib_old.cpython-35-PYTEST.pyc test/__pycache__/test_pythonlib_old.cpython-36-PYTEST.pyc test/bug3.1/03_extendedarg.py test/bytecode_1.5/docstring.pyc test/bytecode_1.5/exceptions.pyc test/bytecode_1.5/exec.pyc test/bytecode_1.5/expressions.pyc test/bytecode_1.5/globals.pyc test/bytecode_1.5/import.pyc test/bytecode_1.5/lambda.pyc test/bytecode_1.5/misc.pyc test/bytecode_1.5/nested_elif.pyc test/bytecode_1.5/print.pyc test/bytecode_1.5/slices.pyc test/bytecode_1.5/test_class.pyc test/bytecode_1.5/test_del.pyc test/bytecode_1.5/test_docstring.pyc test/bytecode_1.5/test_empty.pyc test/bytecode_1.5/test_exceptions.pyc test/bytecode_1.5/test_exec.pyc test/bytecode_1.5/test_expressions.pyc test/bytecode_1.5/test_functions.pyc test/bytecode_1.5/test_global.pyc test/bytecode_1.5/test_globals.pyc test/bytecode_1.5/test_import.pyc test/bytecode_1.5/test_integers.pyc test/bytecode_1.5/test_lambda.pyc test/bytecode_1.5/test_loops.pyc test/bytecode_1.5/test_misc.pyc test/bytecode_1.5/test_nested_elif.pyc test/bytecode_1.5/test_prettyprint.pyc test/bytecode_1.5/test_print.pyc test/bytecode_1.5/test_single_stmt.pyc test/bytecode_1.5/test_slices.pyc test/bytecode_1.5/test_tuples.pyc test/bytecode_1.5/tuple_params.pyc test/bytecode_2.1/applyEquiv.pyc test/bytecode_2.1/augmentedAssign.pyc test/bytecode_2.1/docstring.pyc test/bytecode_2.1/exceptions.pyc test/bytecode_2.1/exec.pyc test/bytecode_2.1/expressions.pyc test/bytecode_2.1/extendedImport.pyc test/bytecode_2.1/extendedPrint.pyc test/bytecode_2.1/globals.pyc test/bytecode_2.1/import.pyc test/bytecode_2.1/lambda.pyc test/bytecode_2.1/listComprehensions.pyc test/bytecode_2.1/misc.pyc test/bytecode_2.1/nested_elif.pyc test/bytecode_2.1/print.pyc test/bytecode_2.1/slices.pyc test/bytecode_2.1/test_applyEquiv.pyc test/bytecode_2.1/test_augmentedAssign.pyc test/bytecode_2.1/test_class.pyc test/bytecode_2.1/test_del.pyc test/bytecode_2.1/test_docstring.pyc test/bytecode_2.1/test_empty.pyc test/bytecode_2.1/test_exceptions.pyc test/bytecode_2.1/test_exec.pyc test/bytecode_2.1/test_expressions.pyc test/bytecode_2.1/test_extendedImport.pyc test/bytecode_2.1/test_extendedPrint.pyc test/bytecode_2.1/test_functions.pyc test/bytecode_2.1/test_global.pyc test/bytecode_2.1/test_globals.pyc test/bytecode_2.1/test_import.pyc test/bytecode_2.1/test_import_as.pyc test/bytecode_2.1/test_integers.pyc test/bytecode_2.1/test_lambda.pyc test/bytecode_2.1/test_listComprehensions.pyc test/bytecode_2.1/test_loops.pyc test/bytecode_2.1/test_loops2.pyc test/bytecode_2.1/test_misc.pyc test/bytecode_2.1/test_nested_elif.pyc test/bytecode_2.1/test_nested_scopes.pyc test/bytecode_2.1/test_prettyprint.pyc test/bytecode_2.1/test_print.pyc test/bytecode_2.1/test_print_to.pyc test/bytecode_2.1/test_single_stmt.pyc test/bytecode_2.1/test_slices.pyc test/bytecode_2.1/test_tuple_params.pyc test/bytecode_2.1/test_tuples.pyc test/bytecode_2.1/tuple_params.pyc test/bytecode_2.2/22_test_yield.pyc test/bytecode_2.3/01_unicode.pyc test/bytecode_2.3/03_build_map.pyc test/bytecode_2.3/05_24_float.pyc test/bytecode_2.4/05_24_float.pyc test/bytecode_2.5/02_complex.pyc test/bytecode_2.5dropbox/codeop.pyc test/bytecode_2.6/00_assign.pyc test/bytecode_2.7/01_unicode.pyc test/bytecode_2.7/02_complex.pyc test/bytecode_2.7/05_24_float.pyc test/bytecode_2.7/06_py34_ref.pyc test/bytecode_3.0/04_raise.pyc test/bytecode_3.1/03_extendedarg.pyc test/bytecode_3.2/01_unicode.pyc test/bytecode_3.2/06_frozenset.pyc test/bytecode_3.3/06_frozenset.pyc test/bytecode_3.4/06_py34_ref.pyc test/bytecode_3.5/01_unicode.pyc test/bytecode_3.6/01_build_string.pyc test/bytecode_3.6/01_fstring.pyc test/bytecode_3.6/01_unicode.pyc test/bytecode_3.6/02_complex.pyc test/bytecode_3.6/03_build_map.pyc test/bytecode_3.6/05_24_float.pyc test/bytecode_3.6/06_frozenset.pyc test/bytecode_3.6/06_py34_ref.pyc test/bytecode_pypy2.7/01_unicode.pyc test/bytecode_pypy2.7/02_complex.pyc test/bytecode_pypy2.7/04_pypy_lambda.pyc test/bytecode_pypy2.7/05_24_float.pyc test/bytecode_pypy3.2/01_unicode.pyc test/bytecode_pypy3.2/02_complex.pyc test/bytecode_pypy3.2/05_24_float.pyc test/simple_2.7/06_frozenset.py test/simple_2.7/__pycache__/06_frozenset.cpython-36.pyc test/simple_source/01_unicode.py test/simple_source/02_complex.py test/simple_source/03_build_map.py test/simple_source/04_pypy_lambda.py test/simple_source/04_raise.py test/simple_source/05_24_float.py test/simple_source/06_py34_ref.py test/simple_source/__pycache__/01_fstring.pyc test/simple_source/__pycache__/01_unicode.cpython-36.pyc test/simple_source/__pycache__/01_unicode.pyc test/simple_source/__pycache__/02_complex.cpython-36.pyc test/simple_source/__pycache__/02_complex.pyc test/simple_source/__pycache__/03_build_map.cpython-36.pyc test/simple_source/__pycache__/05_24_float.cpython-36.pyc test/simple_source/__pycache__/06_py34_ref.cpython-36.pyc test/version_specific/bug36/01_build_string.py test/version_specific/bug36/01_fstring.py test_unit/test-dis.py test_unit/test_load.py test_unit/test_magic.py test_unit/test_marsh.py test_unit/test_opcode.py test_unit/2.7/test-dis.py xdis/__init__.py xdis/bytecode.py xdis/code.py xdis/load.py xdis/magics.py xdis/main.py xdis/marsh.py xdis/namedtuple25.py xdis/unmarshal.py xdis/util.py xdis/verify.py xdis/version.py xdis/wordcode.py xdis.egg-info/PKG-INFO xdis.egg-info/SOURCES.txt xdis.egg-info/dependency_links.txt xdis.egg-info/entry_points.txt xdis.egg-info/top_level.txt xdis.egg-info/zip-safe xdis/bin/__init__.py xdis/bin/pydisassemble.py xdis/dropbox/__init__.py xdis/dropbox/decrypt25.py xdis/opcodes/__init__.py xdis/opcodes/opcode_15.py xdis/opcodes/opcode_20.py xdis/opcodes/opcode_21.py xdis/opcodes/opcode_22.py xdis/opcodes/opcode_23.py xdis/opcodes/opcode_24.py xdis/opcodes/opcode_25.py xdis/opcodes/opcode_26.py xdis/opcodes/opcode_27.py xdis/opcodes/opcode_2x.py xdis/opcodes/opcode_30.py xdis/opcodes/opcode_31.py xdis/opcodes/opcode_32.py xdis/opcodes/opcode_33.py xdis/opcodes/opcode_34.py xdis/opcodes/opcode_35.py xdis/opcodes/opcode_36.py xdis/opcodes/opcode_3x.py xdis/opcodes/opcode_pypy26.py xdis/opcodes/opcode_pypy27.py xdis/opcodes/opcode_pypy32.pyPK°´I“×2EGG-INFO/dependency_links.txt PK£¼½H“×2EGG-INFO/zip-safe PK°´IÒeª¶::EGG-INFO/entry_points.txt[console_scripts] pydisasm = xdis.bin.pydisassemble:main PK¤´IŽhY+ + ´xdis/wordcode.pyPK¤´IŽÜJ“ÓÓ ´Y xdis/load.pyPK¤´I—#"Z88 ´V"xdis/main.pyPKñ1uI¿Ê0˜˜ ´¸:xdis/util.pyPK¤´I»4é—»»´zMxdis/namedtuple25.pyPK°´I”œÛ*ÚÚ ´gaxdis/main.pycPK°´I"ì«££´l|xdis/verify.pycPK¤´I†•ÜdN6N6´<’xdis/unmarshal.pyPK°´IB ÏW%+%+´¹Èxdis/unmarshal.pycPK°´Iuž©´ôxdis/magics.pycPK°´Inþl¯xFxF´Oxdis/bytecode.pycPK°´IѰòûû´öKxdis/__init__.pycPK¤´I;B£-A-A´ Txdis/bytecode.pyPK°´I`m*æG G ´{•xdis/code.pycPKDxºH2ŸÆQ°° ´í xdis/code.pyPK¥´I´Æze  ´Ç©xdis/magics.pyPK°´Ii­m)¤¤´“Áxdis/version.pycPK¤´I=o» ]]´eÂxdis/verify.pyPK¤´IY¦n£¥F¥F ´îÓxdis/marsh.pyPK°´Iˆ•?±0 0 ´¾xdis/wordcode.pycPK¥´I%ÔÞdd´&xdis/version.pyPK°´Iñä ´®&xdis/load.pycPKxW+IOs‹CC´Ù?xdis/__init__.pyPK°´I^cõ‚¦{¦{´JGxdis/marsh.pycPK¤´Ilw¯™åå´Ãxdis/opcodes/opcode_pypy26.pyPK¤´IŽA › › ´<Êxdis/opcodes/opcode_35.pyPKNaI£õ##´Õxdis/opcodes/opcode_2x.pyPK°´I… åíŸ#Ÿ#´Høxdis/opcodes/opcode_15.pycPK°´IÁÊô½  ´xdis/opcodes/opcode_23.pycPKs4VIvíëÞ´g&xdis/opcodes/opcode_26.pyPKX¡UIþUiŒðð´¦-xdis/opcodes/opcode_21.pyPKó>fIÌÈ÷'#'#´Í6xdis/opcodes/opcode_3x.pyPK°´I=¦Ò’'’'´+Zxdis/opcodes/opcode_3x.pycPKÔ!RIî%¿ ii´õxdis/opcodes/opcode_33.pyPK°´IÈ,Qd©©´•‰xdis/opcodes/opcode_pypy32.pycPKÔ!RI‚¢°ØII´z˜xdis/opcodes/opcode_32.pyPK°´ItÛÌ;;´úŸxdis/opcodes/opcode_35.pycPK°´IW;(æ……´m¯xdis/opcodes/__init__.pycPKK=UIëvü3ÜÜ´)°xdis/opcodes/opcode_15.pyPK¤´Iá쬜 œ ´<Èxdis/opcodes/opcode_30.pyPK[¡UI-phé´Ôxdis/opcodes/opcode_22.pyPK°´I½Gjg g ´FÜxdis/opcodes/opcode_24.pycPK¤´I„j*±½½´åæxdis/opcodes/opcode_31.pyPK°´I&wHoŽŽ´Ùïxdis/opcodes/opcode_pypy26.pycPK°´IÙ`èlž ž ´£øxdis/opcodes/opcode_31.pycPKÔ!RIxã¢ø77´yxdis/opcodes/opcode_34.pyPK¤´I€žZ } } ´ç xdis/opcodes/opcode_pypy32.pyPK°´I5_ò, , ´Ÿxdis/opcodes/opcode_20.pycPKNaIéPz z ´%xdis/opcodes/opcode_pypy27.pyPK°´Iõ‡üÓÓ´¸/xdis/opcodes/opcode_30.pycPK°´I“ <ï)ï)´Ã>xdis/opcodes/opcode_2x.pycPK°´I8%Ál´êhxdis/opcodes/opcode_27.pycPKI¡UIÔ#&c‘ ‘ ´5|xdis/opcodes/opcode_20.pyPK¤´IÌ ‹$YY´ý…xdis/opcodes/opcode_27.pyPK¤´IþÆ»nn´”xdis/opcodes/opcode_23.pyPKDxºH´2œxdis/opcodes/__init__.pyPK¥´I)'cÙ Ù ´hœxdis/opcodes/opcode_36.pyPK°´I 4ª){ { ´x©xdis/opcodes/opcode_21.pycPKm¡UIY‚Î$´+¶xdis/opcodes/opcode_25.pyPK¤´IJP©ö  ´h½xdis/opcodes/opcode_24.pyPK¥´I&,ýåë"ë"´¬Åxdis/dropbox/decrypt25.pyPK°´IÛÌHÀ $ $´Îèxdis/dropbox/decrypt25.pycPK°´IìûYJ||´ xdis/dropbox/__init__.pycPK‘+I¼©sÊÊ´Âxdis/dropbox/__init__.pyPK¤´Is•ÿhh´Âxdis/bin/pydisassemble.pyPK°´IIS¸~´axdis/bin/__init__.pycPK°´I¯àì8€ € ´xdis/bin/pydisassemble.pycPKDxºH´Í!xdis/bin/__init__.pyPK°´I˜tõ õ ´ÿ!EGG-INFO/PKG-INFOPK°´Iô#0EGG-INFO/top_level.txtPK°´IÑEU¥ÊÊ´\0EGG-INFO/SOURCES.txtPK°´I“×2´XLEGG-INFO/dependency_links.txtPK£¼½H“×2´”LEGG-INFO/zip-safePK°´IÒeª¶::´ÄLEGG-INFO/entry_points.txtPKJJ—5M