def deparse_text(co, name, last_i): text = [] try: deparsed = code_deparse(co) nodeInfo = deparsed_find((name, last_i), deparsed, co) if not nodeInfo: # FIXME: change deparse_code_around_offset() so we # don't need py_str2float from xdis.magics import py_str2float float_version = py_str2float() deparsed = deparse_code_around_offset(co.co_name, last_i, float_version, co) except: return None if not nodeInfo: nodeInfo = deparsed_find((name, last_i), deparsed, co) if nodeInfo: extractInfo = deparsed.extract_node_info(nodeInfo) if extractInfo: text.append(" instruction: %s" % (nodeInfo.node)) text.append(extractInfo.selectedLine) text.append(extractInfo.markerLine + "\n") pass return text
def get_scanner(version, is_pypy=False, show_asm=None): # If version is a string, turn that into the corresponding float. if isinstance(version, str): version = py_str2float(version) # Pick up appropriate scanner if version in PYTHON_VERSIONS: v_str = "%s" % (int(version * 10)) if PYTHON3: import importlib if is_pypy: scan = importlib.import_module("uncompyle6.scanners.pypy%s" % v_str) else: scan = importlib.import_module("uncompyle6.scanners.scanner%s" % v_str) if False: print(scan) # Avoid unused scan else: if is_pypy: exec("import uncompyle6.scanners.pypy%s as scan" % v_str) else: exec("import uncompyle6.scanners.scanner%s as scan" % v_str) if is_pypy: scanner = eval("scan.ScannerPyPy%s(show_asm=show_asm)" % v_str) else: scanner = eval("scan.Scanner%s(show_asm=show_asm)" % v_str) else: raise RuntimeError("Unsupported Python version %s" % version) return scanner
def get_python_parser( version, debug_parser=PARSER_DEFAULT_DEBUG, compile_mode="exec", is_pypy=False ): """Returns parser object for Python version 3.7, 3.8, etc., depending on the parameters passed. *compile_mode* is either "exec", "eval", or "single" or "lambda". "lambda" is for the grammar that can appear in lambda statements. "eval" is for eval kinds of expressions. For the others, see https://docs.python.org/3/library/functions.html#compile for an explanation of the different modes. """ # If version is a string, turn that into the corresponding float. if isinstance(version, str): version = py_str2float(version) # FIXME: there has to be a better way... # We could do this as a table lookup, but that would force us # in import all of the parsers all of the time. Perhaps there is # a lazy way of doing the import? if version < 3.7: raise RuntimeError(f"Unsupported Python version {version}") elif version == 3.7: import decompyle3.parsers.p37 as parse37 if compile_mode == "exec": p = parse37.Python37Parser(debug_parser) elif compile_mode == "lambda": p = parse37.Python37LambdaParser(debug_parser, compile_mode=compile_mode) ## If the above gives a parse error, use the below to debug what grammar rule(s) ## need to get added # p = parse37.Python37ParserSingle(debug_parser, compile_mode=compile_mode) elif compile_mode == "eval": p = parse37.Python37ParserEval(debug_parser, compile_mode="eval_expr") else: p = parse37.Python37ParserSingle(debug_parser, compile_mode=compile_mode) elif version == 3.8: import decompyle3.parsers.p38 as parse38 if compile_mode == "exec": p = parse38.Python38Parser(debug_parser) elif compile_mode == "lambda": p = parse38.Python38LambdaParser(debug_parser, compile_mode=compile_mode) ## If the above gives a parse error, use the below to debug what grammar rule(s) ## need to get added # p = parse38.Python38ParserSingle(debug_parser, compile_mode=compile_mode) elif compile_mode == "eval": p = parse38.Python38ParserEval(debug_parser, compile_mode="eval_expr") else: p = parse38.Python38ParserSingle(debug_parser, compile_mode=compile_mode) p.version = version # p.dump_grammar() # debug return p
def get_python_parser(version, debug_parser=PARSER_DEFAULT_DEBUG, compile_mode="exec", is_pypy=False): """Returns parser object for Python version 3.7, 3.8, etc., depending on the parameters passed. *compile_mode* is either 'exec', 'eval', or 'single'. See https://docs.python.org/3.6/library/functions.html#compile for an explanation of the different modes. """ # If version is a string, turn that into the corresponding float. if isinstance(version, str): version = py_str2float(version) # FIXME: there has to be a better way... # We could do this as a table lookup, but that would force us # in import all of the parsers all of the time. Perhaps there is # a lazy way of doing the import? if version < 3.7: raise RuntimeError(f"Unsupported Python version {version}") elif version == 3.7: import decompyle3.parsers.parse37 as parse37 if compile_mode == "exec": p = parse37.Python37Parser(debug_parser) else: p = parse37.Python37ParserSingle(debug_parser) elif version == 3.8: import decompyle3.parsers.parse38 as parse38 if compile_mode == "exec": p = parse38.Python38Parser(debug_parser) else: p = parse38.Python38ParserSingle(debug_parser) p.version = version # p.dump_grammar() # debug return p
def get_python_parser( version, debug_parser=PARSER_DEFAULT_DEBUG, compile_mode='exec', is_pypy = False): """Returns parser object for Python version 2 or 3, 3.2, 3.5on, etc., depending on the parameters passed. *compile_mode* is either 'exec', 'eval', or 'single'. See https://docs.python.org/3.6/library/functions.html#compile for an explanation of the different modes. """ # If version is a string, turn that into the corresponding float. if isinstance(version, str): version = py_str2float(version) # FIXME: there has to be a better way... # We could do this as a table lookup, but that would force us # in import all of the parsers all of the time. Perhaps there is # a lazy way of doing the import? if version < 3.0: if version < 2.2: if version == 1.0: import uncompyle6.parsers.parse10 as parse10 if compile_mode == 'exec': p = parse10.Python10Parser(debug_parser) else: p = parse10.Python01ParserSingle(debug_parser) elif version == 1.1: import uncompyle6.parsers.parse11 as parse11 if compile_mode == 'exec': p = parse11.Python11Parser(debug_parser) else: p = parse11.Python11ParserSingle(debug_parser) if version == 1.2: import uncompyle6.parsers.parse12 as parse12 if compile_mode == 'exec': p = parse12.Python12Parser(debug_parser) else: p = parse12.Python12ParserSingle(debug_parser) if version == 1.3: import uncompyle6.parsers.parse13 as parse13 if compile_mode == 'exec': p = parse13.Python13Parser(debug_parser) else: p = parse13.Python13ParserSingle(debug_parser) elif version == 1.4: import uncompyle6.parsers.parse14 as parse14 if compile_mode == 'exec': p = parse14.Python14Parser(debug_parser) else: p = parse14.Python14ParserSingle(debug_parser) elif version == 1.5: import uncompyle6.parsers.parse15 as parse15 if compile_mode == 'exec': p = parse15.Python15Parser(debug_parser) else: p = parse15.Python15ParserSingle(debug_parser) elif version == 1.6: import uncompyle6.parsers.parse16 as parse16 if compile_mode == 'exec': p = parse16.Python16Parser(debug_parser) else: p = parse16.Python16ParserSingle(debug_parser) elif version == 2.1: import uncompyle6.parsers.parse21 as parse21 if compile_mode == 'exec': p = parse21.Python21Parser(debug_parser) else: p = parse21.Python21ParserSingle(debug_parser) elif version == 2.2: import uncompyle6.parsers.parse22 as parse22 if compile_mode == 'exec': p = parse22.Python22Parser(debug_parser) else: p = parse22.Python22ParserSingle(debug_parser) elif version == 2.3: import uncompyle6.parsers.parse23 as parse23 if compile_mode == 'exec': p = parse23.Python23Parser(debug_parser) else: p = parse23.Python23ParserSingle(debug_parser) elif version == 2.4: import uncompyle6.parsers.parse24 as parse24 if compile_mode == 'exec': p = parse24.Python24Parser(debug_parser) else: p = parse24.Python24ParserSingle(debug_parser) elif version == 2.5: import uncompyle6.parsers.parse25 as parse25 if compile_mode == 'exec': p = parse25.Python25Parser(debug_parser) else: p = parse25.Python25ParserSingle(debug_parser) elif version == 2.6: import uncompyle6.parsers.parse26 as parse26 if compile_mode == 'exec': p = parse26.Python26Parser(debug_parser) else: p = parse26.Python26ParserSingle(debug_parser) elif version == 2.7: import uncompyle6.parsers.parse27 as parse27 if compile_mode == 'exec': p = parse27.Python27Parser(debug_parser) else: p = parse27.Python27ParserSingle(debug_parser) else: import uncompyle6.parsers.parse2 as parse2 if compile_mode == 'exec': p = parse2.Python2Parser(debug_parser) else: p = parse2.Python2ParserSingle(debug_parser) pass pass pass else: import uncompyle6.parsers.parse3 as parse3 if version == 3.0: import uncompyle6.parsers.parse30 as parse30 if compile_mode == 'exec': p = parse30.Python30Parser(debug_parser) else: p = parse30.Python30ParserSingle(debug_parser) elif version == 3.1: import uncompyle6.parsers.parse31 as parse31 if compile_mode == 'exec': p = parse31.Python31Parser(debug_parser) else: p = parse31.Python31ParserSingle(debug_parser) elif version == 3.2: import uncompyle6.parsers.parse32 as parse32 if compile_mode == 'exec': p = parse32.Python32Parser(debug_parser) else: p = parse32.Python32ParserSingle(debug_parser) elif version == 3.3: import uncompyle6.parsers.parse33 as parse33 if compile_mode == 'exec': p = parse33.Python33Parser(debug_parser) else: p = parse33.Python33ParserSingle(debug_parser) elif version == 3.4: import uncompyle6.parsers.parse34 as parse34 if compile_mode == 'exec': p = parse34.Python34Parser(debug_parser) else: p = parse34.Python34ParserSingle(debug_parser) elif version == 3.5: import uncompyle6.parsers.parse35 as parse35 if compile_mode == 'exec': p = parse35.Python35Parser(debug_parser) else: p = parse35.Python35ParserSingle(debug_parser) elif version == 3.6: import uncompyle6.parsers.parse36 as parse36 if compile_mode == 'exec': p = parse36.Python36Parser(debug_parser) else: p = parse36.Python36ParserSingle(debug_parser) elif version == 3.7: import uncompyle6.parsers.parse37 as parse37 if compile_mode == 'exec': p = parse37.Python37Parser(debug_parser) else: p = parse37.Python37ParserSingle(debug_parser) elif version == 3.8: import uncompyle6.parsers.parse38 as parse38 if compile_mode == 'exec': p = parse38.Python38Parser(debug_parser) else: p = parse38.Python38ParserSingle(debug_parser) else: if compile_mode == 'exec': p = parse3.Python3Parser(debug_parser) else: p = parse3.Python3ParserSingle(debug_parser) p.version = version # p.dump_grammar() # debug return p
def walk( self ) -> Iterator[AbstractInjectionWalker]: try: co_argcount_inj_walker = self._read_co_argcount() yield co_argcount_inj_walker co_kwonlyargcount_inj_walker = self._read_co_kwonlyargcount() yield co_kwonlyargcount_inj_walker co_nlocals_inj_walker = self._read_co_nlocals() yield co_nlocals_inj_walker co_stacksize_inj_walker = self._read_co_stacksize() yield co_stacksize_inj_walker co_flags_inj_walker = self._read_co_flags() yield co_flags_inj_walker co_code_inj_walker = self._read_co_code() yield co_code_inj_walker co_consts_inj_walker: AbstractInjectionWalker for walker in self._read_co_consts(): yield walker co_consts_inj_walker = walker if not isinstance(co_consts_inj_walker, CodeObjectFieldInjectionWalker): yield FailedInjectionWalker.msg( f'Received unexpected type {type(co_consts_inj_walker)} ' 'when expecting a field injection walker') return co_names_inj_walker = self._read_co_names() yield co_names_inj_walker co_varnames_inj_walker = self._read_co_varnames() yield co_varnames_inj_walker co_filename_inj_walker = self._read_co_filename() yield co_filename_inj_walker co_name_inj_walker = self._read_co_name() yield co_name_inj_walker co_firstlineno_inj_walker = self._read_co_firstlineno() yield co_firstlineno_inj_walker co_lnotab_inj_walker = self._read_co_lnotab() yield co_lnotab_inj_walker co_freevars_inj_walker = self._read_co_freevars() yield co_freevars_inj_walker co_cellvars_inj_walker = self._read_co_cellvars() yield co_cellvars_inj_walker except ValueError as e: yield FailedInjectionWalker.msg(str(e)) return self._code_obj = CodeType( co_argcount_inj_walker.value, co_kwonlyargcount_inj_walker.value, co_nlocals_inj_walker.value, co_stacksize_inj_walker.value, co_flags_inj_walker.value, co_code_inj_walker.value, co_consts_inj_walker.value, co_names_inj_walker.value, co_varnames_inj_walker.value, co_filename_inj_walker.value, co_name_inj_walker.value, co_firstlineno_inj_walker.value, co_lnotab_inj_walker.value, co_freevars_inj_walker.value, co_cellvars_inj_walker.value) bytecode_version_float = py_str2float(self._bytecode_version) with StringIO() as f: decompile(bytecode_version_float, self._code_obj, out=f) raw_decompiled_src_body = f.getvalue() decompiled_src_body = raw_decompiled_src_body.replace( '\n\n\n', '\n\n') lines = [ line for line in decompiled_src_body.splitlines() if not line.lstrip().startswith('# ')] self._src_code = '\n'.join(lines) yield self