""" Implementation of a part of the standard Python opcodes. The rest, dealing with variables in optimized ways, is in nestedscope.py. """ import sys from rpython.rlib import jit, rstackovf, rstring from rpython.rlib.debug import check_nonneg from rpython.rlib.objectmodel import ( we_are_translated, always_inline, dont_inline, not_rpython) from rpython.rlib.rarithmetic import r_uint, intmask from rpython.tool.sourcetools import func_with_new_name from pypy.interpreter import ( gateway, function, eval, pyframe, pytraceback, pycode ) from pypy.interpreter.baseobjspace import W_Root from pypy.interpreter.error import OperationError, oefmt, oefmt_name_error, raise_import_error from pypy.interpreter.nestedscope import Cell from pypy.interpreter.pycode import PyCode, BytecodeCorruption from pypy.tool.stdlib_opcode import bytecode_spec CANNOT_CATCH_MSG = ("catching classes that do not inherit from BaseException " "is not allowed") @not_rpython def unaryoperation(operationname): def opimpl(self, *ignored): operation = getattr(self.space, operationname) w_1 = self.popvalue() w_result = operation(w_1) self.pushvalue(w_result) opimpl.unaryop = operationname return func_with_new_name(opimpl, "opcode_impl_for_%s" % operationname) @not_rpython def binaryoperation(operationname): def opimpl(self, *ignored): operation = getattr(self.space, operationname) w_2 = self.popvalue() w_1 = self.popvalue() w_result = operation(w_1, w_2) self.pushvalue(w_result) opimpl.binop = operationname return func_with_new_name(opimpl, "opcode_impl_for_%s" % operationname) opcodedesc = bytecode_spec.opcodedesc HAVE_ARGUMENT = bytecode_spec.HAVE_ARGUMENT class __extend__(pyframe.PyFrame): """A PyFrame that knows about interpretation of standard Python opcodes minus the ones related to nested scopes.""" ### opcode dispatch ### def dispatch(self, pycode, next_instr, ec): # For the sequel, force 'next_instr' to be unsigned for performance next_instr = r_uint(next_instr) co_code = pycode.co_code try: while True: assert next_instr & 1 == 0 next_instr = self.handle_bytecode(co_code, next_instr, ec) except ExitFrame: return self.popvalue() def handle_bytecode(self, co_code, next_instr, ec): try: next_instr = self.dispatch_bytecode(co_code, next_instr, ec) except OperationError as operr: try: operr.record_context(self.space, ec) except OperationError as operr2: # this should be unreachable! but we don't want to crash if it # still happens w_value = operr.normalize_exception(self.space) w_value2 = operr2.normalize_exception(self.space) # NB: don't *raise* it, it's handled by the # handle_operation_error call below (otherwise some higher up # except block handles it) operr = oefmt( self.space.w_TypeError, "couldn't record exception context for exception '%T', got: %R", w_value, w_value2) next_instr = self.handle_operation_error(ec, operr) except RaiseWithExplicitTraceback as e: next_instr = self.handle_operation_error(ec, e.operr, attach_tb=False) except KeyboardInterrupt: next_instr = self.handle_asynchronous_error(ec, self.space.w_KeyboardInterrupt) except MemoryError: next_instr = self.handle_asynchronous_error(ec, self.space.w_MemoryError) except rstackovf.StackOverflow as e: # Note that this case catches AttributeError! rstackovf.check_stack_overflow() next_instr = self.handle_asynchronous_error(ec, self.space.w_RecursionError, self.space.newtext("maximum recursion depth exceeded")) return next_instr def handle_asynchronous_error(self, ec, w_type, w_value=None): # catch asynchronous exceptions and turn them # into OperationErrors if w_value is None: w_value = self.space.w_None operr = OperationError(w_type, w_value) return self.handle_operation_error(ec, operr) def handle_generator_error(self, operr): # for generator.py ec = self.space.getexecutioncontext() return self.handle_operation_error(ec, operr) def handle_operation_error(self, ec, operr, attach_tb=True): if attach_tb: if 1: # xxx this is a hack. It allows bytecode_trace() to # call a signal handler which raises, and catch the # raised exception immediately. See test_alarm_raise in # pypy/module/signal/test/test_signal.py. Without the # next four lines, if an external call (like # socket.accept()) is interrupted by a signal, it raises # an exception carrying EINTR which arrives here, # entering the next "except" block -- but the signal # handler is then called on the next call to # dispatch_bytecode(), causing the real exception to be # raised after the exception handler block was popped. try: trace = self.get_w_f_trace() if trace is not None: self.getorcreatedebug().w_f_trace = None try: ec.bytecode_trace_after_exception(self) finally: if trace is not None: self.getorcreatedebug().w_f_trace = trace except OperationError as e: operr = e pytraceback.record_application_traceback( self.space, operr, self, self.last_instr) ec.exception_trace(self, operr) block = self.unrollstack() if block is None: # no handler found for the OperationError if we_are_translated(): raise operr else: # try to preserve the CPython-level traceback import sys tb = sys.exc_info()[2] raise OperationError, operr, tb else: unroller = SApplicationException(operr) next_instr = block.handle(self, unroller) return next_instr def call_contextmanager_exit_function(self, w_func, w_typ, w_val, w_tb): return self.space.call_function(w_func, w_typ, w_val, w_tb) @jit.unroll_safe def dispatch_bytecode(self, co_code, next_instr, ec): while True: assert next_instr & 1 == 0 self.last_instr = intmask(next_instr) if jit.we_are_jitted(): ec.bytecode_only_trace(self) else: ec.bytecode_trace(self) next_instr = r_uint(self.last_instr) assert next_instr & 1 == 0 opcode = ord(co_code[next_instr]) oparg = ord(co_code[next_instr + 1]) next_instr += 2 # note: the structure of the code here is such that it makes # (after translation) a big "if/elif" chain, which is then # turned into a switch(). while opcode == opcodedesc.EXTENDED_ARG.index: opcode = ord(co_code[next_instr]) arg = ord(co_code[next_instr + 1]) if opcode < HAVE_ARGUMENT: raise BytecodeCorruption next_instr += 2 oparg = (oparg * 256) | arg if opcode == opcodedesc.RETURN_VALUE.index: assert not self.blockstack_non_empty() self.frame_finished_execution = True # for generators raise Return elif opcode == opcodedesc.JUMP_ABSOLUTE.index: return self.jump_absolute(oparg, next_instr, ec) elif opcode == opcodedesc.RERAISE.index: return self.RERAISE(oparg, next_instr) elif opcode == opcodedesc.FOR_ITER.index: next_instr = self.FOR_ITER(oparg, next_instr) elif opcode == opcodedesc.JUMP_FORWARD.index: next_instr = self.JUMP_FORWARD(oparg, next_instr) elif opcode == opcodedesc.JUMP_IF_FALSE_OR_POP.index: return self.JUMP_IF_FALSE_OR_POP(oparg, next_instr, ec) elif opcode == opcodedesc.JUMP_IF_TRUE_OR_POP.index: return self.JUMP_IF_TRUE_OR_POP(oparg, next_instr, ec) elif opcode == opcodedesc.POP_JUMP_IF_FALSE.index: return self.POP_JUMP_IF_FALSE(oparg, next_instr, ec) elif opcode == opcodedesc.POP_JUMP_IF_TRUE.index: return self.POP_JUMP_IF_TRUE(oparg, next_instr, ec) elif opcode == opcodedesc.JUMP_IF_NOT_EXC_MATCH.index: next_instr = self.JUMP_IF_NOT_EXC_MATCH(oparg, next_instr) elif opcode == opcodedesc.BINARY_ADD.index: self.BINARY_ADD(oparg, next_instr) elif opcode == opcodedesc.BINARY_AND.index: self.BINARY_AND(oparg, next_instr) elif opcode == opcodedesc.BINARY_FLOOR_DIVIDE.index: self.BINARY_FLOOR_DIVIDE(oparg, next_instr) elif opcode == opcodedesc.BINARY_MATRIX_MULTIPLY.index: self.BINARY_MATRIX_MULTIPLY(oparg, next_instr) elif opcode == opcodedesc.BINARY_LSHIFT.index: self.BINARY_LSHIFT(oparg, next_instr) elif opcode == opcodedesc.BINARY_MODULO.index: self.BINARY_MODULO(oparg, next_instr) elif opcode == opcodedesc.BINARY_MULTIPLY.index: self.BINARY_MULTIPLY(oparg, next_instr) elif opcode == opcodedesc.BINARY_OR.index: self.BINARY_OR(oparg, next_instr) elif opcode == opcodedesc.BINARY_POWER.index: self.BINARY_POWER(oparg, next_instr) elif opcode == opcodedesc.BINARY_RSHIFT.index: self.BINARY_RSHIFT(oparg, next_instr) elif opcode == opcodedesc.BINARY_SUBSCR.index: self.BINARY_SUBSCR(oparg, next_instr) elif opcode == opcodedesc.BINARY_SUBTRACT.index: self.BINARY_SUBTRACT(oparg, next_instr) elif opcode == opcodedesc.BINARY_TRUE_DIVIDE.index: self.BINARY_TRUE_DIVIDE(oparg, next_instr) elif opcode == opcodedesc.BINARY_XOR.index: self.BINARY_XOR(oparg, next_instr) elif opcode == opcodedesc.BUILD_CONST_KEY_MAP.index: self.BUILD_CONST_KEY_MAP(oparg, next_instr) elif opcode == opcodedesc.BUILD_LIST.index: self.BUILD_LIST(oparg, next_instr) elif opcode == opcodedesc.BUILD_LIST_FROM_ARG.index: self.BUILD_LIST_FROM_ARG(oparg, next_instr) elif opcode == opcodedesc.BUILD_MAP.index: self.BUILD_MAP(oparg, next_instr) elif opcode == opcodedesc.BUILD_SET.index: self.BUILD_SET(oparg, next_instr) elif opcode == opcodedesc.BUILD_SLICE.index: self.BUILD_SLICE(oparg, next_instr) elif opcode == opcodedesc.BUILD_TUPLE.index: self.BUILD_TUPLE(oparg, next_instr) elif opcode == opcodedesc.CALL_FUNCTION.index: self.CALL_FUNCTION(oparg, next_instr) elif opcode == opcodedesc.CALL_FUNCTION_KW.index: self.CALL_FUNCTION_KW(oparg, next_instr) elif opcode == opcodedesc.CALL_FUNCTION_EX.index: self.CALL_FUNCTION_EX(oparg, next_instr) elif opcode == opcodedesc.CALL_METHOD.index: self.CALL_METHOD(oparg, next_instr) elif opcode == opcodedesc.CALL_METHOD_KW.index: self.CALL_METHOD_KW(oparg, next_instr) elif opcode == opcodedesc.CHECK_EG_MATCH.index: self.CHECK_EG_MATCH(oparg, next_instr) elif opcode == opcodedesc.COMPARE_OP.index: self.COMPARE_OP(oparg, next_instr) elif opcode == opcodedesc.IS_OP.index: self.IS_OP(oparg, next_instr) elif opcode == opcodedesc.CONTAINS_OP.index: self.CONTAINS_OP(oparg, next_instr) elif opcode == opcodedesc.DELETE_ATTR.index: self.DELETE_ATTR(oparg, next_instr) elif opcode == opcodedesc.DELETE_DEREF.index: self.DELETE_DEREF(oparg, next_instr) elif opcode == opcodedesc.DELETE_FAST.index: self.DELETE_FAST(oparg, next_instr) elif opcode == opcodedesc.SETUP_ANNOTATIONS.index: self.SETUP_ANNOTATIONS(oparg, next_instr) elif opcode == opcodedesc.DELETE_GLOBAL.index: self.DELETE_GLOBAL(oparg, next_instr) elif opcode == opcodedesc.DELETE_NAME.index: self.DELETE_NAME(oparg, next_instr) elif opcode == opcodedesc.DELETE_SUBSCR.index: self.DELETE_SUBSCR(oparg, next_instr) elif opcode == opcodedesc.DUP_TOP.index: self.DUP_TOP(oparg, next_instr) elif opcode == opcodedesc.DUP_TOP_TWO.index: self.DUP_TOP_TWO(oparg, next_instr) elif opcode == opcodedesc.GET_ITER.index: self.GET_ITER(oparg, next_instr) elif opcode == opcodedesc.IMPORT_FROM.index: self.IMPORT_FROM(oparg, next_instr) elif opcode == opcodedesc.IMPORT_NAME.index: self.IMPORT_NAME(oparg, next_instr) elif opcode == opcodedesc.IMPORT_STAR.index: self.IMPORT_STAR(oparg, next_instr) elif opcode == opcodedesc.INPLACE_ADD.index: self.INPLACE_ADD(oparg, next_instr) elif opcode == opcodedesc.INPLACE_AND.index: self.INPLACE_AND(oparg, next_instr) elif opcode == opcodedesc.INPLACE_FLOOR_DIVIDE.index: self.INPLACE_FLOOR_DIVIDE(oparg, next_instr) elif opcode == opcodedesc.INPLACE_LSHIFT.index: self.INPLACE_LSHIFT(oparg, next_instr) elif opcode == opcodedesc.INPLACE_MATRIX_MULTIPLY.index: self.INPLACE_MATRIX_MULTIPLY(oparg, next_instr) elif opcode == opcodedesc.INPLACE_MODULO.index: self.INPLACE_MODULO(oparg, next_instr) elif opcode == opcodedesc.INPLACE_MULTIPLY.index: self.INPLACE_MULTIPLY(oparg, next_instr) elif opcode == opcodedesc.INPLACE_OR.index: self.INPLACE_OR(oparg, next_instr) elif opcode == opcodedesc.INPLACE_POWER.index: self.INPLACE_POWER(oparg, next_instr) elif opcode == opcodedesc.INPLACE_RSHIFT.index: self.INPLACE_RSHIFT(oparg, next_instr) elif opcode == opcodedesc.INPLACE_SUBTRACT.index: self.INPLACE_SUBTRACT(oparg, next_instr) elif opcode == opcodedesc.INPLACE_TRUE_DIVIDE.index: self.INPLACE_TRUE_DIVIDE(oparg, next_instr) elif opcode == opcodedesc.INPLACE_XOR.index: self.INPLACE_XOR(oparg, next_instr) elif opcode == opcodedesc.LIST_APPEND.index: self.LIST_APPEND(oparg, next_instr) elif opcode == opcodedesc.LIST_EXTEND.index: self.LIST_EXTEND(oparg, next_instr) elif opcode == opcodedesc.LIST_TO_TUPLE.index: self.LIST_TO_TUPLE(oparg, next_instr) elif opcode == opcodedesc.LOAD_ATTR.index: self.LOAD_ATTR(oparg, next_instr) elif opcode == opcodedesc.LOAD_BUILD_CLASS.index: self.LOAD_BUILD_CLASS(oparg, next_instr) elif opcode == opcodedesc.LOAD_CLOSURE.index: self.LOAD_CLOSURE(oparg, next_instr) elif opcode == opcodedesc.LOAD_CONST.index: self.LOAD_CONST(oparg, next_instr) elif opcode == opcodedesc.LOAD_DEREF.index: self.LOAD_DEREF(oparg, next_instr) elif opcode == opcodedesc.LOAD_CLASSDEREF.index: self.LOAD_CLASSDEREF(oparg, next_instr) elif opcode == opcodedesc.LOAD_FAST.index: self.LOAD_FAST(oparg, next_instr) elif opcode == opcodedesc.LOAD_GLOBAL.index: self.LOAD_GLOBAL(oparg, next_instr) elif opcode == opcodedesc.LOAD_NAME.index: self.LOAD_NAME(oparg, next_instr) elif opcode == opcodedesc.LOAD_METHOD.index: self.LOAD_METHOD(oparg, next_instr) elif opcode == opcodedesc.MAKE_FUNCTION.index: self.MAKE_FUNCTION(oparg, next_instr) elif opcode == opcodedesc.MAP_ADD.index: self.MAP_ADD(oparg, next_instr) elif opcode == opcodedesc.DICT_MERGE.index: self.DICT_MERGE(oparg, next_instr) elif opcode == opcodedesc.DICT_UPDATE.index: self.DICT_UPDATE(oparg, next_instr) elif opcode == opcodedesc.NOP.index: self.NOP(oparg, next_instr) elif opcode == opcodedesc.POP_BLOCK.index: self.POP_BLOCK(oparg, next_instr) elif opcode == opcodedesc.POP_EXCEPT.index: self.POP_EXCEPT(oparg, next_instr) elif opcode == opcodedesc.POP_TOP.index: self.POP_TOP(oparg, next_instr) elif opcode == opcodedesc.PREP_RERAISE_STAR.index: self.PREP_RERAISE_STAR(oparg, next_instr) elif opcode == opcodedesc.PRINT_EXPR.index: self.PRINT_EXPR(oparg, next_instr) elif opcode == opcodedesc.RAISE_VARARGS.index: self.RAISE_VARARGS(oparg, next_instr) elif opcode == opcodedesc.ROT_FOUR.index: self.ROT_FOUR(oparg, next_instr) elif opcode == opcodedesc.ROT_THREE.index: self.ROT_THREE(oparg, next_instr) elif opcode == opcodedesc.ROT_TWO.index: self.ROT_TWO(oparg, next_instr) elif opcode == opcodedesc.SETUP_EXCEPT.index: self.SETUP_EXCEPT(oparg, next_instr) elif opcode == opcodedesc.SETUP_FINALLY.index: self.SETUP_FINALLY(oparg, next_instr) elif opcode == opcodedesc.SETUP_WITH.index: self.SETUP_WITH(oparg, next_instr) elif opcode == opcodedesc.SET_ADD.index: self.SET_ADD(oparg, next_instr) elif opcode == opcodedesc.SET_UPDATE.index: self.SET_UPDATE(oparg, next_instr) elif opcode == opcodedesc.STORE_ATTR.index: self.STORE_ATTR(oparg, next_instr) elif opcode == opcodedesc.STORE_DEREF.index: self.STORE_DEREF(oparg, next_instr) elif opcode == opcodedesc.STORE_FAST.index: self.STORE_FAST(oparg, next_instr) elif opcode == opcodedesc.STORE_GLOBAL.index: self.STORE_GLOBAL(oparg, next_instr) elif opcode == opcodedesc.STORE_NAME.index: self.STORE_NAME(oparg, next_instr) elif opcode == opcodedesc.STORE_SUBSCR.index: self.STORE_SUBSCR(oparg, next_instr) elif opcode == opcodedesc.UNARY_INVERT.index: self.UNARY_INVERT(oparg, next_instr) elif opcode == opcodedesc.UNARY_NEGATIVE.index: self.UNARY_NEGATIVE(oparg, next_instr) elif opcode == opcodedesc.UNARY_NOT.index: self.UNARY_NOT(oparg, next_instr) elif opcode == opcodedesc.UNARY_POSITIVE.index: self.UNARY_POSITIVE(oparg, next_instr) elif opcode == opcodedesc.UNPACK_EX.index: self.UNPACK_EX(oparg, next_instr) elif opcode == opcodedesc.UNPACK_SEQUENCE.index: self.UNPACK_SEQUENCE(oparg, next_instr) elif opcode == opcodedesc.WITH_EXCEPT_START.index: self.WITH_EXCEPT_START(oparg, next_instr) elif opcode == opcodedesc.YIELD_VALUE.index: self.YIELD_VALUE(oparg, next_instr) elif opcode == opcodedesc.YIELD_FROM.index: self.YIELD_FROM(oparg, next_instr) elif opcode == opcodedesc.GET_YIELD_FROM_ITER.index: self.GET_YIELD_FROM_ITER(oparg, next_instr) elif opcode == opcodedesc.LOAD_ASSERTION_ERROR.index: self.LOAD_ASSERTION_ERROR(oparg, next_instr) elif opcode == opcodedesc.GET_AWAITABLE.index: self.GET_AWAITABLE(oparg, next_instr) elif opcode == opcodedesc.SETUP_ASYNC_WITH.index: self.SETUP_ASYNC_WITH(oparg, next_instr) elif opcode == opcodedesc.BEFORE_ASYNC_WITH.index: self.BEFORE_ASYNC_WITH(oparg, next_instr) elif opcode == opcodedesc.GET_AITER.index: self.GET_AITER(oparg, next_instr) elif opcode == opcodedesc.GET_ANEXT.index: self.GET_ANEXT(oparg, next_instr) elif opcode == opcodedesc.END_ASYNC_FOR.index: next_instr = self.END_ASYNC_FOR(oparg, next_instr) elif opcode == opcodedesc.FORMAT_VALUE.index: self.FORMAT_VALUE(oparg, next_instr) elif opcode == opcodedesc.BUILD_STRING.index: self.BUILD_STRING(oparg, next_instr) elif opcode == opcodedesc.LOAD_REVDB_VAR.index: self.LOAD_REVDB_VAR(oparg, next_instr) elif opcode == opcodedesc.GET_LEN.index: self.GET_LEN(oparg, next_instr) elif opcode == opcodedesc.MATCH_MAPPING.index: self.MATCH_MAPPING(oparg, next_instr) elif opcode == opcodedesc.MATCH_SEQUENCE.index: self.MATCH_SEQUENCE(oparg, next_instr) elif opcode == opcodedesc.MATCH_KEYS.index: self.MATCH_KEYS(oparg, next_instr) elif opcode == opcodedesc.MATCH_CLASS.index: self.MATCH_CLASS(oparg, next_instr) elif opcode == opcodedesc.COPY_DICT_WITHOUT_KEYS.index: self.COPY_DICT_WITHOUT_KEYS(oparg, next_instr) elif opcode == opcodedesc.ROT_N.index: self.ROT_N(oparg, next_instr) else: self.MISSING_OPCODE(oparg, next_instr) if jit.we_are_jitted(): return next_instr @jit.unroll_safe def unrollstack(self): while self.blockstack_non_empty(): block = self.pop_block() if not isinstance(block, SysExcInfoRestorer): return block block.cleanupstack(self) self.frame_finished_execution = True # for generators return None ### accessor functions ### def getlocalvarname(self, index): return self.getcode().co_varnames[index] def getconstant_w(self, index): return self.getcode().co_consts_w[index] def getname_u(self, index): return self.space.text_w(self.getname_w(index)) def getname_w(self, index): return self.getcode().co_names_w[index] ################################################################ ## Implementation of the "operational" opcodes ## See also nestedscope.py for the rest. ## def NOP(self, oparg, next_instr): # annotation-time check: if it fails, it means that the decoding # of oparg failed to produce an integer which is annotated as non-neg check_nonneg(oparg) @always_inline def LOAD_FAST(self, varindex, next_instr): # access a local variable directly w_value = self.locals_cells_stack_w[varindex] if w_value is None: self._load_fast_failed(varindex) self.pushvalue(w_value) @dont_inline def _load_fast_failed(self, varindex): varname = self.getlocalvarname(varindex) raise oefmt(self.space.w_UnboundLocalError, "local variable '%s' referenced before assignment", varname) def LOAD_CONST(self, constindex, next_instr): w_const = self.getconstant_w(constindex) self.pushvalue(w_const) def STORE_FAST(self, varindex, next_instr): w_newvalue = self.popvalue() assert w_newvalue is not None self.locals_cells_stack_w[varindex] = w_newvalue def getfreevarname(self, index): pycode = self.pycode if self.iscellvar(index): return pycode.co_cellvars[index] return pycode.co_freevars[index - len(pycode.co_cellvars)] def iscellvar(self, index): # is the variable given by index a cell or a free var? return index < len(self.pycode.co_cellvars) def LOAD_DEREF(self, varindex, next_instr): # nested scopes: access a variable through its cell object cell = self._getcell(varindex) try: w_value = cell.get() except ValueError: self.raise_exc_unbound(varindex) else: self.pushvalue(w_value) def LOAD_CLASSDEREF(self, varindex, next_instr): # like LOAD_DEREF but used in class bodies space = self.space i = varindex - len(self.pycode.co_cellvars) assert i >= 0 name = self.pycode.co_freevars[i] w_value = space.finditem(self.debugdata.w_locals, space.newtext(name)) if w_value is None: self.LOAD_DEREF(varindex, next_instr) else: self.pushvalue(w_value) def STORE_DEREF(self, varindex, next_instr): # nested scopes: access a variable through its cell object w_newvalue = self.popvalue() cell = self._getcell(varindex) cell.set(w_newvalue) def DELETE_DEREF(self, varindex, next_instr): cell = self._getcell(varindex) try: cell.get() except ValueError: self.raise_exc_unbound(varindex) else: cell.set(None) def raise_exc_unbound(self, varindex): varname = self.getfreevarname(varindex) if self.iscellvar(varindex): raise oefmt(self.space.w_UnboundLocalError, "local variable '%s' referenced before assignment", varname) else: raise oefmt(self.space.w_NameError, "free variable '%s' referenced before assignment" " in enclosing scope", varname) def LOAD_CLOSURE(self, varindex, next_instr): # nested scopes: access the cell object w_value = self._getcell(varindex) self.pushvalue(w_value) def POP_TOP(self, oparg, next_instr): self.popvalue() def ROT_TWO(self, oparg, next_instr): w_1 = self.popvalue() w_2 = self.popvalue() self.pushvalue(w_1) self.pushvalue(w_2) def ROT_THREE(self, oparg, next_instr): w_1 = self.popvalue() w_2 = self.popvalue() w_3 = self.popvalue() self.pushvalue(w_1) self.pushvalue(w_3) self.pushvalue(w_2) def ROT_FOUR(self, oparg, next_instr): w_1 = self.popvalue() w_2 = self.popvalue() w_3 = self.popvalue() w_4 = self.popvalue() self.pushvalue(w_1) self.pushvalue(w_4) self.pushvalue(w_3) self.pushvalue(w_2) def DUP_TOP(self, oparg, next_instr): w_1 = self.peekvalue() self.pushvalue(w_1) def DUP_TOP_TWO(self, oparg, next_instr): self.dupvalues(2) def DUP_TOPX(self, itemcount, next_instr): assert 1 <= itemcount <= 5, "limitation of the current interpreter" self.dupvalues(itemcount) UNARY_POSITIVE = unaryoperation("pos") UNARY_NEGATIVE = unaryoperation("neg") UNARY_NOT = unaryoperation("not_") UNARY_CONVERT = unaryoperation("repr") UNARY_INVERT = unaryoperation("invert") def BINARY_POWER(self, oparg, next_instr): w_2 = self.popvalue() w_1 = self.popvalue() w_result = self.space.pow(w_1, w_2, self.space.w_None) self.pushvalue(w_result) BINARY_MULTIPLY = binaryoperation("mul") BINARY_TRUE_DIVIDE = binaryoperation("truediv") BINARY_FLOOR_DIVIDE = binaryoperation("floordiv") BINARY_MODULO = binaryoperation("mod") BINARY_MATRIX_MULTIPLY = binaryoperation("matmul") BINARY_ADD = binaryoperation("add") BINARY_SUBTRACT = binaryoperation("sub") BINARY_SUBSCR = binaryoperation("getitem") BINARY_LSHIFT = binaryoperation("lshift") BINARY_RSHIFT = binaryoperation("rshift") BINARY_AND = binaryoperation("and_") BINARY_XOR = binaryoperation("xor") BINARY_OR = binaryoperation("or_") def INPLACE_POWER(self, oparg, next_instr): w_2 = self.popvalue() w_1 = self.popvalue() w_result = self.space.inplace_pow(w_1, w_2) self.pushvalue(w_result) INPLACE_MULTIPLY = binaryoperation("inplace_mul") INPLACE_TRUE_DIVIDE = binaryoperation("inplace_truediv") INPLACE_FLOOR_DIVIDE = binaryoperation("inplace_floordiv") INPLACE_DIVIDE = binaryoperation("inplace_div") # XXX INPLACE_DIVIDE must fall back to INPLACE_TRUE_DIVIDE with -Qnew INPLACE_MODULO = binaryoperation("inplace_mod") INPLACE_MATRIX_MULTIPLY = binaryoperation("inplace_matmul") INPLACE_ADD = binaryoperation("inplace_add") INPLACE_SUBTRACT = binaryoperation("inplace_sub") INPLACE_LSHIFT = binaryoperation("inplace_lshift") INPLACE_RSHIFT = binaryoperation("inplace_rshift") INPLACE_AND = binaryoperation("inplace_and") INPLACE_XOR = binaryoperation("inplace_xor") INPLACE_OR = binaryoperation("inplace_or") def STORE_SUBSCR(self, oparg, next_instr): "obj[subscr] = newvalue" w_subscr = self.popvalue() w_obj = self.popvalue() w_newvalue = self.popvalue() self.space.setitem(w_obj, w_subscr, w_newvalue) def DELETE_SUBSCR(self, oparg, next_instr): "del obj[subscr]" w_subscr = self.popvalue() w_obj = self.popvalue() self.space.delitem(w_obj, w_subscr) def PRINT_EXPR(self, oparg, next_instr): w_expr = self.popvalue() print_expr(self.space, w_expr) def RAISE_VARARGS(self, nbargs, next_instr): space = self.space if nbargs > 2: raise BytecodeCorruption("bad RAISE_VARARGS oparg") if nbargs == 0: if not self.hide(): last_operr = self.space.getexecutioncontext().sys_exc_info() else: last_operr = self.getorcreatedebug().hidden_operationerr if last_operr is None: raise oefmt(space.w_RuntimeError, "No active exception to reraise") # re-raise, no new traceback obj will be attached raise RaiseWithExplicitTraceback(last_operr) if nbargs == 2: w_cause = self.popvalue() if space.exception_is_valid_obj_as_class_w(w_cause): w_cause = space.call_function(w_cause) else: w_cause = None w_value = self.popvalue() if space.exception_is_valid_obj_as_class_w(w_value): w_type = w_value w_value = space.call_function(w_type) else: w_type = space.type(w_value) operror = OperationError(w_type, w_value) operror.normalize_exception(space) operror.set_cause(space, w_cause) tb = space.getattr(w_value, space.newtext('__traceback__')) if not space.is_w(tb, space.w_None): operror.set_traceback(tb) raise operror def LOAD_LOCALS(self, oparg, next_instr): self.pushvalue(self.getorcreatedebug().w_locals) def exec_(self, w_prog, w_globals, w_locals, w_closure=None): """The builtins.exec function.""" from pypy.interpreter.function import Function space = self.space ec = space.getexecutioncontext() flags = ec.compiler.getcodeflags(self.pycode) outer_func = None if space.isinstance_w(w_prog, space.gettypeobject(PyCode.typedef)): space.audit("exec", [w_prog]) code = space.interp_w(PyCode, w_prog) if code.co_freevars: needed = len(code.co_freevars) if (space.is_none(w_closure) or not space.isinstance_w(w_closure, space.w_tuple) or not space.len_w(w_closure) == needed): raise oefmt( space.w_TypeError, "code object requires a closure of exactly length %d", needed) closure_w = space.fixedview(w_closure, needed) outer_func = Function(space, code, closure=closure_w) else: if not space.is_none(w_closure): raise oefmt( space.w_TypeError, "cannot use a closure with this code object") else: from pypy.interpreter.astcompiler import consts if not space.is_none(w_closure): raise oefmt( space.w_TypeError, "closure can only be used when source is a code object") flags |= consts.PyCF_SOURCE_IS_UTF8 source, flags = source_as_str(space, w_prog, 'exec', "string, bytes or code", flags) code = ec.compiler.compile(source, "", 'exec', flags) w_globals, w_locals = ensure_ns(space, w_globals, w_locals, 'exec', self) space.call_method(w_globals, 'setdefault', space.newtext('__builtins__'), self.get_builtin()) code.exec_code(space, w_globals, w_locals, outer_func) def POP_EXCEPT(self, oparg, next_instr): block = self.pop_block() assert isinstance(block, SysExcInfoRestorer) block.cleanupstack(self) # restores ec.sys_exc_operror def POP_BLOCK(self, oparg, next_instr): self.pop_block() def save_and_change_sys_exc_info(self, operationerr): ec = self.space.getexecutioncontext() last_exception = ec.current_exception() block = SysExcInfoRestorer(last_exception, self.lastblock, self.last_instr) self.lastblock = block if operationerr is not None: # otherwise, don't change sys_exc_info if not self.hide(): ec.set_sys_exc_info(operationerr) else: # for hidden frames, a more limited solution should be # enough: store away the exception on the frame self.getorcreatedebug().hidden_operationerr = operationerr @jit.unroll_safe def _any_except_or_finally_handler(self): block = self.lastblock while block is not None: if isinstance(block, SysExcInfoRestorer): return True block = block.previous return False def LOAD_BUILD_CLASS(self, oparg, next_instr): w_build_class = self.get_builtin().getdictvalue( self.space, '__build_class__') if w_build_class is None: raise oefmt(self.space.w_ImportError, "__build_class__ not found") self.pushvalue(w_build_class) def STORE_NAME(self, varindex, next_instr): varname = self.getname_u(varindex) w_newvalue = self.popvalue() self.space.setitem_str(self.getorcreatedebug().w_locals, varname, w_newvalue) def DELETE_NAME(self, varindex, next_instr): w_varname = self.getname_w(varindex) try: self.space.delitem(self.getorcreatedebug().w_locals, w_varname) except OperationError as e: # catch KeyErrors and turn them into NameErrors if not e.match(self.space, self.space.w_KeyError): raise raise oefmt(self.space.w_NameError, "name %R is not defined", w_varname) def UNPACK_SEQUENCE(self, itemcount, next_instr): w_iterable = self.popvalue() try: items = self.space.fixedview_unroll(w_iterable, itemcount) except OperationError as e: if not e.match(self.space, self.space.w_TypeError): raise raise oefmt(self.space.w_TypeError, "cannot unpack non-iterable %T object", w_iterable) self.pushrevvalues(itemcount, items) @jit.unroll_safe def UNPACK_EX(self, oparg, next_instr): "a, *b, c = range(10)" left = oparg & 0xFF right = (oparg & 0xFF00) >> 8 w_iterable = self.popvalue() try: items = self.space.fixedview(w_iterable) except OperationError as e: if not e.match(self.space, self.space.w_TypeError): raise raise oefmt(self.space.w_TypeError, "cannot unpack non-iterable %T object", w_iterable) itemcount = len(items) count = left + right if count > itemcount: raise oefmt(self.space.w_ValueError, "not enough values to unpack (expected at least %d, got %d)", count, itemcount) right = itemcount - right assert right >= 0 # push values in reverse order i = itemcount - 1 while i >= right: self.pushvalue(items[i]) i -= 1 self.pushvalue(self.space.newlist(items[left:right])) i = left - 1 while i >= 0: self.pushvalue(items[i]) i -= 1 def STORE_ATTR(self, nameindex, next_instr): "obj.attributename = newvalue" w_obj = self.popvalue() w_newvalue = self.popvalue() if not jit.we_are_jitted(): from pypy.objspace.std.mapdict import STORE_ATTR_caching STORE_ATTR_caching(self.getcode(), w_obj, nameindex, w_newvalue) else: w_attributename = self.getname_w(nameindex) self.space.setattr(w_obj, w_attributename, w_newvalue) def DELETE_ATTR(self, nameindex, next_instr): "del obj.attributename" w_attributename = self.getname_w(nameindex) w_obj = self.popvalue() self.space.delattr(w_obj, w_attributename) def STORE_GLOBAL(self, nameindex, next_instr): #varname = self.getname_u(nameindex) #w_newvalue = self.popvalue() #self.space.setitem_str(self.get_w_globals(), varname, w_newvalue) from pypy.objspace.std.celldict import STORE_GLOBAL_cached STORE_GLOBAL_cached(self, nameindex, next_instr) def DELETE_GLOBAL(self, nameindex, next_instr): w_varname = self.getname_w(nameindex) self.space.delitem(self.get_w_globals(), w_varname) def LOAD_NAME(self, nameindex, next_instr): from pypy.objspace.std.celldict import LOAD_GLOBAL_cached if self.getorcreatedebug().w_locals is not self.get_w_globals(): w_varname = self.getname_w(nameindex) varname = self.space.text_w(w_varname) w_value = self.space.finditem_str(self.getorcreatedebug().w_locals, varname) if w_value is not None: self.pushvalue(w_value) return LOAD_GLOBAL_cached(self, nameindex, next_instr) @always_inline def _load_global(self, varname): w_value = self.space.finditem_str(self.get_w_globals(), varname) if w_value is None: # not in the globals, now look in the built-ins w_value = self.get_builtin().getdictvalue(self.space, varname) if w_value is None: # XXX re-wrapping w_varname = self.space.newtext(varname) self._load_global_failed(w_varname) return w_value @dont_inline def _load_global_failed(self, w_varname): # CPython Issue #17032: The "global" in the "NameError: global # name 'x' is not defined" error message has been removed. raise oefmt_name_error(self.space, w_varname, "name %R is not defined") @always_inline def LOAD_GLOBAL(self, nameindex, next_instr): from pypy.objspace.std.celldict import LOAD_GLOBAL_cached LOAD_GLOBAL_cached(self, nameindex, next_instr) def DELETE_FAST(self, varindex, next_instr): if self.locals_cells_stack_w[varindex] is None: varname = self.getlocalvarname(varindex) raise oefmt(self.space.w_UnboundLocalError, "local variable '%s' referenced before assignment", varname) self.locals_cells_stack_w[varindex] = None def SETUP_ANNOTATIONS(self, oparg, next_instr): w_locals = self.getorcreatedebug().w_locals if not self.space.finditem_str(w_locals, '__annotations__'): w_annotations = self.space.newdict() self.space.setitem_str(w_locals, '__annotations__', w_annotations) def BUILD_TUPLE(self, itemcount, next_instr): items = self.popvalues(itemcount) w_tuple = self.space.newtuple(items) self.pushvalue(w_tuple) def BUILD_LIST(self, itemcount, next_instr): items = self.popvalues_mutable(itemcount) w_list = self.space.newlist(items) self.pushvalue(w_list) def BUILD_LIST_FROM_ARG(self, _, next_instr): space = self.space # this is a little dance, because list has to be before the # value last_val = self.popvalue() length_hint = 0 try: length_hint = space.length_hint(last_val, length_hint) except OperationError as e: if e.async(space): raise self.pushvalue(space.newlist([], sizehint=length_hint)) self.pushvalue(last_val) @always_inline def LOAD_ATTR(self, nameindex, next_instr): "obj.attributename" w_obj = self.popvalue() if not jit.we_are_jitted(): from pypy.objspace.std.mapdict import LOAD_ATTR_caching w_value = LOAD_ATTR_caching(self.getcode(), w_obj, nameindex) else: w_attributename = self.getname_w(nameindex) w_value = self.space.getattr(w_obj, w_attributename) self.pushvalue(w_value) @jit.unroll_safe def cmp_exc_match(self, w_1, w_2): space = self.space if space.isinstance_w(w_2, space.w_tuple): for w_type in space.fixedview(w_2): if not space.exception_is_valid_class_w(w_type): raise oefmt(space.w_TypeError, CANNOT_CATCH_MSG) elif not space.exception_is_valid_class_w(w_2): raise oefmt(space.w_TypeError, CANNOT_CATCH_MSG) return space.exception_match(space.type(w_1), w_2) def COMPARE_OP(self, testnum, next_instr): w_2 = self.popvalue() w_1 = self.popvalue() if testnum == 0: w_result = self.space.lt(w_1, w_2) elif testnum == 1: w_result = self.space.le(w_1, w_2) elif testnum == 2: w_result = self.space.eq(w_1, w_2) elif testnum == 3: w_result = self.space.ne(w_1, w_2) elif testnum == 4: w_result = self.space.gt(w_1, w_2) elif testnum == 5: w_result = self.space.ge(w_1, w_2) else: raise BytecodeCorruption self.pushvalue(w_result) def IS_OP(self, oparg, next_instr): space = self.space w_2 = self.popvalue() w_1 = self.popvalue() res = self.space.is_w(w_1, w_2) if oparg: if res: w_res = space.w_False else: w_res = space.w_True else: if res: w_res = space.w_True else: w_res = space.w_False self.pushvalue(w_res) def CONTAINS_OP(self, oparg, next_instr): w_2 = self.popvalue() w_1 = self.popvalue() res = self.space.contains_w(w_2, w_1) ^ oparg self.pushvalue(self.space.newbool(bool(res))) def JUMP_IF_NOT_EXC_MATCH(self, target, next_instr): w_2 = self.popvalue() w_1 = self.popvalue() res = self.cmp_exc_match(w_1, w_2) if res: return next_instr else: return target * 2 def IMPORT_NAME(self, nameindex, next_instr): space = self.space w_modulename = self.getname_w(nameindex) w_fromlist = self.popvalue() w_flag = self.popvalue() w_import = self.get_builtin().getdictvalue(space, '__import__') if w_import is None: raise oefmt(space.w_ImportError, "__import__ not found") d = self.getdebug() if d is None: w_locals = None else: w_locals = d.w_locals if w_locals is None: # CPython does this w_locals = space.w_None w_globals = self.get_w_globals() w_obj = space.call_function(w_import, w_modulename, w_globals, w_locals, w_fromlist, w_flag) self.pushvalue(w_obj) def IMPORT_STAR(self, oparg, next_instr): w_module = self.popvalue() w_locals = self.getdictscope() import_all_from(self.space, w_module, w_locals) self.setdictscope(w_locals) def IMPORT_FROM(self, nameindex, next_instr): w_name = self.getname_w(nameindex) w_module = self.peekvalue() self.pushvalue(self.import_from(w_module, w_name)) def import_from(self, w_module, w_name): space = self.space try: return space.getattr(w_module, w_name) except OperationError as e: if not e.match(space, space.w_AttributeError): raise w_pkgname = space.newtext("") try: w_pkgname = space.getattr( w_module, space.newtext('__name__')) w_fullname = space.newtext(b'%s.%s' % (space.utf8_w(w_pkgname), space.utf8_w(w_name))) return space.getitem(space.sys.get('modules'), w_fullname) except OperationError: from pypy.module.imp.importing import (is_spec_initializing, get_path, get_spec, is_spec_uninitialized_submodule) w_pkgpath = get_path(space, w_module) args = (space.utf8_w(w_name), space.utf8_w(w_pkgname), space.utf8_w(w_pkgpath)) w_spec = get_spec(space, w_module) if is_spec_initializing(space, w_spec): msg = ( "cannot import name '%s' from partially initialized module '%s' " "(most likely due to a circular import) (%s)" % args ) elif is_spec_uninitialized_submodule(space, w_spec, w_pkgname): msg = ( "cannot access submodule '%s' of module '%s' " "(most likely due to a circular import)" % (args[1], args[0]) ) else: msg = "cannot import name '%s' from '%s' (%s)" % args raise_import_error( space, space.newtext(msg), w_pkgname, w_pkgpath, ) def YIELD_VALUE(self, oparg, next_instr): if self.getcode().co_flags & pycode.CO_ASYNC_GENERATOR: from pypy.interpreter.generator import AsyncGenValueWrapper w_value = self.popvalue() w_value = AsyncGenValueWrapper(w_value) self.pushvalue(w_value) raise Yield def next_yield_from(self, w_yf, w_inputvalue_or_err): """Fetch the next item of the current 'yield from', push it on the frame stack, and raises Yield. If there isn't one, push w_stopiteration_value and returns. May also just raise. """ from pypy.interpreter.generator import ( GeneratorOrCoroutine, AsyncGenASend) space = self.space try: if isinstance(w_yf, GeneratorOrCoroutine): w_retval = w_yf.send_ex(w_inputvalue_or_err) elif isinstance(w_yf, AsyncGenASend): # performance only w_retval = w_yf.do_send(w_inputvalue_or_err) elif space.is_w(w_inputvalue_or_err, space.w_None): w_retval = space.next(w_yf) else: w_retval = delegate_to_nongen(space, w_yf, w_inputvalue_or_err) except OperationError as e: if not e.match(space, space.w_StopIteration): raise self._report_stopiteration_sometimes(w_yf, e) try: w_stop_value = space.getattr(e.get_w_value(space), space.newtext("value")) except OperationError as e: if not e.match(space, space.w_AttributeError): raise w_stop_value = space.w_None self.pushvalue(w_stop_value) return else: self.pushvalue(w_retval) self.w_yielding_from = w_yf raise Yield def YIELD_FROM(self, oparg, next_instr): # Unlike CPython, we handle this not by repeating the same # bytecode over and over until the inner iterator is exhausted. # Instead, we set w_yielding_from. # This asks resume_execute_frame() to exhaust that # sub-iterable first before continuing on the next bytecode. w_inputvalue = self.popvalue() # that's always w_None, actually w_gen = self.popvalue() # self.next_yield_from(w_gen, w_inputvalue) # Common case: the call above raises Yield. # If instead the iterable is empty, next_yield_from() pushed the # final result and returns. In that case, we can just continue # with the next bytecode. def _revdb_jump_backward(self, jumpto): # moved in its own function for the import statement from pypy.interpreter.reverse_debugging import jump_backward jump_backward(self, jumpto) def jump_absolute(self, jumpto, next_instr, ec): # this function is overridden by pypy.module.pypyjit.interp_jit check_nonneg(jumpto) if self.space.reverse_debugging: self._revdb_jump_backward(jumpto * 2) return jumpto * 2 def JUMP_FORWARD(self, jumpby, next_instr): next_instr += jumpby * 2 return next_instr def POP_JUMP_IF_FALSE(self, target, next_instr, ec): w_value = self.popvalue() if not self.space.is_true(w_value): return self.jump_absolute(target, next_instr, ec) return next_instr def POP_JUMP_IF_TRUE(self, target, next_instr, ec): w_value = self.popvalue() if self.space.is_true(w_value): return self.jump_absolute(target, next_instr, ec) return next_instr def JUMP_IF_FALSE_OR_POP(self, target, next_instr, ec): w_value = self.peekvalue() if not self.space.is_true(w_value): return self.jump_absolute(target, next_instr, ec) self.popvalue() return next_instr def JUMP_IF_TRUE_OR_POP(self, target, next_instr, ec): w_value = self.peekvalue() if self.space.is_true(w_value): return self.jump_absolute(target, next_instr, ec) self.popvalue() return next_instr def GET_ITER(self, oparg, next_instr): w_iterable = self.popvalue() w_iterator = self.space.iter(w_iterable) self.pushvalue(w_iterator) def FOR_ITER(self, jumpby, next_instr): w_iterator = self.peekvalue() try: w_nextitem = self.space.next(w_iterator) except OperationError as e: if not e.match(self.space, self.space.w_StopIteration): raise # iterator exhausted self._report_stopiteration_sometimes(w_iterator, e) self.popvalue() next_instr += jumpby * 2 else: self.pushvalue(w_nextitem) return next_instr def _report_stopiteration_sometimes(self, w_iterator, operr): # CPython 3.5 calls the exception trace in an ill-defined subset # of cases: only if tp_iternext returned NULL and set a # StopIteration exception, but not if tp_iternext returned NULL # *without* setting an exception. We can't easily emulate that # behavior at this point. For example, the generator's # tp_iternext uses one or other case depending on whether the # generator is already exhausted or just exhausted now. We'll # classify that as a CPython incompatibility and use an # approximative rule: if w_iterator is a generator-iterator, # we always report it; if operr has already a stack trace # attached (likely from a custom __iter__() method), we also # report it; in other cases, we don't. from pypy.interpreter.generator import GeneratorOrCoroutine, AsyncGenASend if (isinstance(w_iterator, GeneratorOrCoroutine) or isinstance(w_iterator, AsyncGenASend) or operr.has_any_traceback()): self.space.getexecutioncontext().exception_trace(self, operr) def SETUP_EXCEPT(self, offsettoend, next_instr): block = ExceptBlock(self.valuestackdepth, next_instr + offsettoend * 2, self.lastblock) self.lastblock = block def SETUP_FINALLY(self, offsettoend, next_instr): block = FinallyBlock(self.valuestackdepth, next_instr + offsettoend * 2, self.lastblock) self.lastblock = block def SETUP_WITH(self, offsettoend, next_instr): w_manager = self.peekvalue() w_enter = self.space.lookup(w_manager, "__enter__") w_descr = self.space.lookup(w_manager, "__exit__") if w_enter is None or w_descr is None: raise oefmt(self.space.w_TypeError, "'%T' object does not support the context manager " "protocol (no __enter__/__exit__ method)", w_manager) w_exit = self.space.get(w_descr, w_manager) self.settopvalue(w_exit) w_result = self.space.get_and_call_function(w_enter, w_manager) block = FinallyBlock(self.valuestackdepth, next_instr + offsettoend * 2, self.lastblock) self.lastblock = block self.pushvalue(w_result) def WITH_EXCEPT_START(self, oparg, next_instr): w_unroller = self.popvalue() w_exitfunc = self.popvalue() self.pushvalue(w_unroller) if isinstance(w_unroller, SApplicationException): operr = w_unroller.operr w_traceback = operr.get_w_traceback(self.space) w_res = self.call_contextmanager_exit_function( w_exitfunc, operr.w_type, operr.get_w_value(self.space), w_traceback) else: assert 0 self.pushvalue(w_res) def RERAISE(self, reset_last_instr, next_instr): unroller = self.popvalue() if not isinstance(unroller, SApplicationException): assert 0 if reset_last_instr: block = self.lastblock assert isinstance(block, SysExcInfoRestorer) self.last_instr = block.last_instr block = self.unrollstack() if block is None: w_result = unroller.reraise() assert 0, "unreachable" else: next_instr = block.handle(self, unroller) return next_instr def CALL_FUNCTION(self, oparg, next_instr): # Only positional arguments nargs = oparg & 0xff w_function = self.peekvalue(nargs) w_result = self.space.call_valuestack(w_function, nargs, self, dropvalues=nargs+1) self.pushvalue(w_result) @jit.unroll_safe def CALL_FUNCTION_KW(self, n_arguments, next_instr): from pypy.objspace.std.tupleobject import W_AbstractTupleObject space = self.space # like in BUILD_CONST_KEY_MAP we can't use space.fixedview because then # the immutability of the tuple is lost w_tup_varnames = space.interp_w(W_AbstractTupleObject, self.popvalue()) n_keywords = space.len_w(w_tup_varnames) keyword_names_w = [None] * n_keywords keywords_w = [None] * n_keywords for i in range(n_keywords): keyword_names_w[i] = w_tup_varnames.getitem(space, i) w_value = self.peekvalue(n_keywords - 1 - i) keywords_w[i] = w_value self.dropvalues(n_keywords) n_arguments -= n_keywords arguments = self.popvalues(n_arguments) w_function = self.popvalue() args = self.argument_factory(arguments, keyword_names_w, keywords_w, None, None, w_function=w_function) if self.get_is_being_profiled() and function.is_builtin_code(w_function): w_result = self.space.call_args_and_c_profile(self, w_function, args) else: w_result = self.space.call_args(w_function, args) self.pushvalue(w_result) def CALL_FUNCTION_EX(self, has_kwarg, next_instr): w_kwargs = None if has_kwarg: w_kwargs = self.popvalue() w_args = self.popvalue() w_function = self.popvalue() args = self.argument_factory( [], None, None, w_star=w_args, w_starstar=w_kwargs, w_function=w_function) if self.get_is_being_profiled() and function.is_builtin_code(w_function): w_result = self.space.call_args_and_c_profile(self, w_function, args) else: w_result = self.space.call_args(w_function, args) self.pushvalue(w_result) @jit.unroll_safe def MAKE_FUNCTION(self, oparg, next_instr): space = self.space w_codeobj = self.popvalue() codeobj = self.space.interp_w(PyCode, w_codeobj) assert 0 <= oparg <= 0x0F if oparg & 0x08: w_freevarstuple = self.popvalue() # XXX this list copy is expensive, it's purely for the annotator freevars = [self.space.interp_w(Cell, cell) for cell in self.space.fixedview(w_freevarstuple)] else: freevars = None if oparg & 0x04: w_ann = self.popvalue() else: w_ann = None if oparg & 0x02: w_kw_defs = self.popvalue() # XXX kw_defs_w = [space.unpackiterable(w_tup) for w_tup in space.fixedview( space.call_method(w_kw_defs, 'items'))] else: kw_defs_w = None if oparg & 0x01: defaultarguments = space.fixedview(self.popvalue()) else: defaultarguments = [] fn = function.Function(space, codeobj, self.get_w_globals(), defaultarguments, kw_defs_w, freevars, w_ann, qualname=codeobj.co_qualname) self.pushvalue(fn) def BUILD_SLICE(self, numargs, next_instr): if numargs == 3: w_step = self.popvalue() elif numargs == 2: w_step = self.space.w_None else: raise BytecodeCorruption w_end = self.popvalue() w_start = self.popvalue() w_slice = self.space.newslice(w_start, w_end, w_step) self.pushvalue(w_slice) def LIST_APPEND(self, oparg, next_instr): w = self.popvalue() v = self.peekvalue(oparg - 1) self.space.call_method(v, 'append', w) def LIST_EXTEND(self, oparg, next_instr): w = self.popvalue() v = self.peekvalue(oparg - 1) space = self.space try: space.call_method(v, 'extend', w) except OperationError as e: if space.is_iterable(w): raise raise oefmt(space.w_TypeError, "Value after * must be an iterable, not %T", w) def LIST_TO_TUPLE(self, oparg, next_instr): w_l = self.popvalue() w_res = self.space.call_function(self.space.w_tuple, w_l) self.pushvalue(w_res) def SET_ADD(self, oparg, next_instr): w_value = self.popvalue() w_set = self.peekvalue(oparg - 1) self.space.call_method(w_set, 'add', w_value) def SET_UPDATE(self, oparg, next_instr): w_update = self.popvalue() w_set = self.peekvalue(oparg - 1) self.space.call_method(w_set, 'update', w_update) def MAP_ADD(self, oparg, next_instr): w_value = self.popvalue() w_key = self.popvalue() w_dict = self.peekvalue(oparg - 1) self.space.setitem(w_dict, w_key, w_value) def DICT_MERGE(self, oparg, next_instr): from pypy.objspace.std.dictmultiobject import W_DictMultiObject space = self.space w_dict = self.peekvalue(1) w_item = self.popvalue() # dict merge happens always in places where the function is on the # stack too w_function = self.peekvalue(oparg+2) _dict_merge(space, w_dict, w_item, w_function) def DICT_UPDATE(self, oparg, next_instr): w_item = self.popvalue() space = self.space if not space.ismapping_w(w_item): raise oefmt(space.w_TypeError, "'%T' object is not a mapping", w_item) w_dict = self.peekvalue() space.call_method(w_dict, "update", w_item) # overridden by faster version in the standard object space. LOAD_METHOD = LOAD_ATTR CALL_METHOD = CALL_FUNCTION CALL_METHOD_KW = CALL_FUNCTION_KW def MISSING_OPCODE(self, oparg, next_instr): ofs = self.last_instr c = self.pycode.co_code[ofs] name = self.pycode.co_name raise BytecodeCorruption("unknown opcode, ofs=%d, code=%d, name=%s" % (ofs, ord(c), name) ) @jit.unroll_safe def BUILD_MAP(self, itemcount, next_instr): w_dict = self.space.newdict() for i in range(itemcount-1, -1, -1): w_value = self.peekvalue(2 * i) w_key = self.peekvalue(2 * i + 1) self.space.setitem(w_dict, w_key, w_value) self.dropvalues(2 * itemcount) self.pushvalue(w_dict) @jit.unroll_safe def BUILD_CONST_KEY_MAP(self, itemcount, next_instr): from pypy.objspace.std.tupleobject import W_AbstractTupleObject # the reason why we don't use space.fixedview here is that then the # immutability of the tuple would not propagate into the loop below in # the JIT w_keys = self.space.interp_w(W_AbstractTupleObject, self.popvalue()) w_dict = self.space.newdict() for i in range(itemcount): w_value = self.peekvalue(itemcount - 1 - i) w_key = w_keys.getitem(self.space, i) self.space.setitem(w_dict, w_key, w_value) self.dropvalues(itemcount) self.pushvalue(w_dict) @jit.unroll_safe def BUILD_SET(self, itemcount, next_instr): w_set = self.space.newset() for i in range(itemcount-1, -1, -1): w_item = self.peekvalue(i) self.space.call_method(w_set, 'add', w_item) self.dropvalues(itemcount) self.pushvalue(w_set) def GET_YIELD_FROM_ITER(self, oparg, next_instr): from pypy.interpreter.astcompiler import consts from pypy.interpreter.generator import GeneratorIterator, Coroutine w_iterable = self.peekvalue() if isinstance(w_iterable, Coroutine): if not self.pycode.co_flags & (consts.CO_COROUTINE | consts.CO_ITERABLE_COROUTINE): #'iterable' coroutine is used in a 'yield from' expression #of a regular generator raise oefmt(self.space.w_TypeError, "cannot 'yield from' a coroutine object " "in a non-coroutine generator") elif not isinstance(w_iterable, GeneratorIterator): w_iterator = self.space.iter(w_iterable) self.settopvalue(w_iterator) def LOAD_ASSERTION_ERROR(self, oparg, next_instr): self.pushvalue(self.space.w_AssertionError) def GET_AWAITABLE(self, oparg, next_instr): from pypy.interpreter.generator import get_awaitable_iter from pypy.interpreter.generator import Coroutine w_iterable = self.popvalue() w_iter = get_awaitable_iter(self.space, w_iterable) if isinstance(w_iter, Coroutine): if w_iter.get_delegate() is not None: # 'w_iter' is a coroutine object that is being awaited, # '.w_yielded_from' is the current awaitable being awaited on. raise oefmt(self.space.w_RuntimeError, "coroutine is being awaited already") self.pushvalue(w_iter) def SETUP_ASYNC_WITH(self, offsettoend, next_instr): res = self.popvalue() block = FinallyBlock(self.valuestackdepth, next_instr + offsettoend * 2, self.lastblock) self.lastblock = block self.pushvalue(res) def BEFORE_ASYNC_WITH(self, oparg, next_instr): space = self.space w_manager = self.peekvalue() w_enter = space.lookup(w_manager, "__aenter__") w_descr = space.lookup(w_manager, "__aexit__") if w_enter is None or w_descr is None: raise oefmt(space.w_TypeError, "'%T' object does not support the asynchronous context " "manager protocol (no __aenter__/__aexit__ method)", w_manager) w_exit = space.get(w_descr, w_manager) self.settopvalue(w_exit) w_result = space.get_and_call_function(w_enter, w_manager) self.pushvalue(w_result) def GET_AITER(self, oparg, next_instr): from pypy.interpreter.generator import AIterWrapper, get_awaitable_iter space = self.space w_obj = self.popvalue() w_func = space.lookup(w_obj, "__aiter__") if w_func is None: raise oefmt(space.w_TypeError, "'async for' requires an object with " "__aiter__ method, got %T", w_obj) w_iter = space.get_and_call_function(w_func, w_obj) # If __aiter__() returns an object with a __anext__() method, # wrap it in a awaitable that resolves to 'w_iter'. if space.lookup(w_iter, "__anext__") is not None: self.pushvalue(w_iter) else: new_error = oefmt(space.w_TypeError, "'async for' received a object from __aiter__ that" " does not implement __anext__: %T", w_iter) raise new_error def GET_ANEXT(self, oparg, next_instr): from pypy.interpreter.generator import get_awaitable_iter # XXX add performance shortcut if w_aiter is an AsyncGenerator space = self.space w_aiter = self.peekvalue() w_func = space.lookup(w_aiter, "__anext__") if w_func is None: raise oefmt(space.w_TypeError, "'async for' requires an iterator with " "__anext__ method, got %T", w_aiter) w_next_iter = space.get_and_call_function(w_func, w_aiter) try: w_awaitable = get_awaitable_iter(space, w_next_iter) except OperationError as e: if e.async(space): raise new_error = oefmt(space.w_TypeError, "'async for' received an invalid object " "from __anext__: %T", w_next_iter) w_cause = e.normalize_exception(space) new_error.normalize_exception(space) new_error.set_cause(space, w_cause) raise new_error self.pushvalue(w_awaitable) def END_ASYNC_FOR(self, oparg, next_instr): block = self.pop_block() assert isinstance(block, SysExcInfoRestorer) block.cleanupstack(self) # restores ec.sys_exc_operror w_exc = self.popvalue() if self.space.exception_match(self.space.type(w_exc), self.space.w_StopAsyncIteration): self.popvalue() # unroller self.popvalue() # aiter return next_instr else: unroller = self.peekvalue(0) if not isinstance(unroller, SApplicationException): raise oefmt(self.space.w_RuntimeError, "END_ASYNC_FOR found no exception") block = self.unrollstack() if block is None: w_result = unroller.reraise() assert 0, "unreachable" else: next_instr = block.handle(self, unroller) return next_instr def FORMAT_VALUE(self, oparg, next_instr): from pypy.interpreter.astcompiler import consts space = self.space # if (oparg & consts.FVS_MASK) == consts.FVS_HAVE_SPEC: w_spec = self.popvalue() else: w_spec = space.newtext('') w_value = self.popvalue() # conversion = oparg & consts.FVC_MASK if conversion == consts.FVC_STR: w_value = space.str(w_value) elif conversion == consts.FVC_REPR: w_value = space.repr(w_value) elif conversion == consts.FVC_ASCII: from pypy.objspace.std.unicodeobject import ascii_from_object w_value = ascii_from_object(space, w_value) # w_res = space.format(w_value, w_spec) self.pushvalue(w_res) @jit.unroll_safe def BUILD_STRING(self, itemcount, next_instr): from rpython.rlib import rutf8 space = self.space builder = rutf8.Utf8StringBuilder() for i in range(itemcount-1, -1, -1): w_item = self.peekvalue(i) utf8, length = space.utf8_len_w(w_item) builder.append_utf8(utf8, length) self.dropvalues(itemcount) w_res = space.newutf8(builder.build(), builder.getlength()) self.pushvalue(w_res) def _revdb_load_var(self, oparg): # moved in its own function for the import statement from pypy.interpreter.reverse_debugging import load_metavar w_var = load_metavar(oparg) self.pushvalue(w_var) def LOAD_REVDB_VAR(self, oparg, next_instr): if self.space.reverse_debugging: self._revdb_load_var(oparg) else: self.MISSING_OPCODE(oparg, next_instr) def MATCH_SEQUENCE(self, oparg, next_instr): w_sequence = self.peekvalue() space = self.space flag_patma_collection = space.type(w_sequence).flag_patma_collection if flag_patma_collection == "M": # a mapping! is_sequence = False else: is_sequence = flag_patma_collection == "S" if not is_sequence: is_sequence = space.issequence_w(w_sequence) is_sequence = (is_sequence and not space.isinstance_w(w_sequence, space.w_unicode) and not space.isinstance_w(w_sequence, space.w_bytes) and not space.isinstance_w(w_sequence, space.w_bytearray)) self.pushvalue(space.newbool(is_sequence)) def MATCH_MAPPING(self, oparg, next_instr): w_mapping = self.peekvalue() flag_patma_collection = self.space.type(w_mapping).flag_patma_collection if flag_patma_collection == "S": # sequence is_mapping = False else: is_mapping = flag_patma_collection == "M" if not is_mapping: is_mapping = self.space.ismapping_w(w_mapping) self.pushvalue(self.space.newbool(is_mapping)) def MATCH_CLASS(self, oparg, next_instr): space = self.space nargs = oparg w_names = self.popvalue() w_type = self.popvalue() w_subject = self.popvalue() w_attribute_tuple = _match_class(self.space, nargs, w_names, w_type, w_subject) if w_attribute_tuple is None: self.pushvalue(space.w_None) self.pushvalue(space.w_False) else: self.pushvalue(w_attribute_tuple) self.pushvalue(space.w_True) def GET_LEN(self, oparg, next_instr): w_sequence = self.peekvalue() w_len = self.space.len(w_sequence) self.pushvalue(w_len) @jit.unroll_safe def MATCH_KEYS(self, oparg, next_instr): w_keys = self.peekvalue() w_dict = self.peekvalue(1) length = self.space.len_w(w_keys) values_w = [None] * length w_seen = self.space.newset() w_iter = self.space.iter(w_keys) w_sentinel = self.space.call_method(self.space.builtin, "object") try: i = 0 while True: w_key = self.space.next(w_iter) if self.space.contains_w(w_seen, w_key): raise oefmt(self.space.w_ValueError, "mapping pattern checks duplicate key (%R)", w_key) self.space.call_method(w_seen, "add", w_key) w_value = self.space.call_method(w_dict, 'get', w_key, w_sentinel) if not self.space.is_w(w_value, w_sentinel): values_w[i] = w_value else: self.pushvalue(self.space.w_None) self.pushvalue(self.space.w_False) return i += 1 except OperationError as e: if not e.match(self.space, self.space.w_StopIteration): raise self.pushvalue(self.space.newtuple(values_w)) self.pushvalue(self.space.w_True) def COPY_DICT_WITHOUT_KEYS(self, oparg, next_instr): w_keys = self.popvalue() w_subject = self.peekvalue() w_dict = _copy_dict_without_keys(self.space, w_keys, w_subject) self.pushvalue(w_dict) @jit.unroll_safe def ROT_N(self, oparg, next_instr): w_top = self.peekvalue() for i in range(oparg - 1): self.settopvalue(self.peekvalue(i + 1), i) self.settopvalue(w_top, oparg - 1) def CHECK_EG_MATCH(self, oparg, next_instr): space = self.space w_typ = self.popvalue() check_except_star_type_valid(space, w_typ) w_eg = self.peekvalue() w_match, w_rest = exception_group_match(space, w_eg, w_typ) if space.is_w(w_match, space.w_None): self.pushvalue(w_match) else: self.settopvalue(w_rest) self.pushvalue(w_match) ec = space.getexecutioncontext() ec.set_sys_exc_info3(w_match) def PREP_RERAISE_STAR(self, oparg, next_instr): space = self.space w_res = self.popvalue() w_orig = self.popvalue() w_mod = space.call_method(space.builtin, '__import__', space.newtext('__exceptions__')) w_eg_or_None = space.call_method(w_mod, "_prep_reraise_star", w_orig, w_res) if space.is_w(w_eg_or_None, space.w_None): w_push = space.w_None else: w_push = SApplicationException(OperationError(space.type(w_eg_or_None), w_eg_or_None)) self.pushvalue(w_push) def delegate_to_nongen(space, w_yf, w_inputvalue_or_err): # invoke a "send" or "throw" by method name to a non-generator w_yf if isinstance(w_inputvalue_or_err, SApplicationException): operr = w_inputvalue_or_err.operr try: w_meth = space.getattr(w_yf, space.newtext("throw")) except OperationError as e: if not e.match(space, space.w_AttributeError): raise raise operr # bah, CPython calls here with the exact same arguments as # originally passed to throw(). In our case it is far removed. # Let's hope nobody will complain... w_val = operr.normalize_exception(space) w_exc = operr.w_type w_tb = operr.get_w_traceback(space) return space.call_function(w_meth, w_exc, w_val, w_tb) else: return space.call_method(w_yf, "send", w_inputvalue_or_err) ### ____________________________________________________________ ### class ExitFrame(Exception): pass class Return(ExitFrame): """Raised when exiting a frame via a 'return' statement.""" class Yield(ExitFrame): """Raised when exiting a frame via a 'yield' statement.""" class RaiseWithExplicitTraceback(Exception): """Raised at interp-level by a 0-argument 'raise' statement.""" def __init__(self, operr): self.operr = operr ### Frame Blocks ### class SApplicationException(W_Root): """Signals an application-level exception (i.e. an OperationException).""" _immutable_ = True def __init__(self, operr): self.operr = operr def reraise(self): raise RaiseWithExplicitTraceback(self.operr) class FrameBlock(object): """Abstract base class for frame blocks from the blockstack, used by the SETUP_XXX and POP_BLOCK opcodes.""" _immutable_ = True def __init__(self, valuestackdepth, handlerposition, previous): self.handlerposition = handlerposition self.valuestackdepth = valuestackdepth self.previous = previous # this makes a linked list of blocks def cleanupstack(self, frame): frame.dropvaluesuntil(self.valuestackdepth) # internal pickling interface, not using the standard protocol def _get_state_(self, space): return space.newtuple([space.newtext(self._opname), space.newint(self.handlerposition), space.newint(self.valuestackdepth)]) def handle(self, frame, unroller): """ Purely abstract method """ raise NotImplementedError class SysExcInfoRestorer(FrameBlock): """ This is a special, implicit block type which is created when entering a finally or except handler. It does not belong to any opcode """ _immutable_ = True _opname = 'SYS_EXC_INFO_RESTORER' # it's not associated to any opcode def __init__(self, operr, previous, last_instr): self.operr = operr self.previous = previous self.last_instr = last_instr def handle(self, frame, unroller): assert False # never called def cleanupstack(self, frame): ec = frame.space.getexecutioncontext() ec.set_sys_exc_info(self.operr) class ExceptBlock(FrameBlock): """An try:except: block. Stores the position of the exception handler.""" _immutable_ = True _opname = 'SETUP_EXCEPT' def handle(self, frame, unroller): # push the exception to the value stack for inspection by the # exception handler (the code after the except:) self.cleanupstack(frame) # the stack setup is slightly different than in CPython: # instead of the traceback, we store the unroller object, # wrapped. assert isinstance(unroller, SApplicationException) operationerr = unroller.operr w_value = operationerr.normalize_exception(frame.space) frame.pushvalue(unroller) frame.pushvalue(w_value) # set the current value of sys_exc_info to operationerr, # saving the old value in a custom type of FrameBlock frame.save_and_change_sys_exc_info(operationerr) return r_uint(self.handlerposition) # jump to the handler class FinallyBlock(FrameBlock): """A try:finally: block. Stores the position of the exception handler.""" _immutable_ = True _opname = 'SETUP_FINALLY' def handle(self, frame, unroller): # any abnormal reason for unrolling a finally: triggers the end of # the block unrolling and the entering the finally: handler. # see comments in cleanup(). self.cleanupstack(frame) operationerr = None if isinstance(unroller, SApplicationException): operationerr = unroller.operr operationerr.normalize_exception(frame.space) frame.pushvalue(unroller) # set the current value of sys_exc_info to operationerr, # saving the old value in a custom type of FrameBlock frame.save_and_change_sys_exc_info(operationerr) return r_uint(self.handlerposition) # jump to the handler def pop_block(self, frame): pass def source_as_str(space, w_source, funcname, what, flags): """Return source code as str0 with adjusted compiler flags w_source must be a str or support the buffer interface """ from pypy.interpreter.astcompiler import consts if space.isinstance_w(w_source, space.w_unicode): from pypy.interpreter.unicodehelper import encode w_source = encode(space, w_source) source = space.bytes_w(w_source) flags |= consts.PyCF_IGNORE_COOKIE elif space.isinstance_w(w_source, space.w_bytes): source = space.bytes_w(w_source) else: try: buf = space.buffer_w(w_source, space.BUF_SIMPLE) except OperationError as e: if not e.match(space, space.w_TypeError): raise raise oefmt(space.w_TypeError, "%s() arg 1 must be a %s object", funcname, what) source = buf.as_str() if not (flags & consts.PyCF_ACCEPT_NULL_BYTES): if '\x00' in source: raise oefmt(space.w_ValueError, "source code string cannot contain null bytes") source = rstring.assert_str0(source) return source, flags def ensure_ns(space, w_globals, w_locals, funcname, caller=None): """Ensure globals/locals exist and are of the correct type""" if (not space.is_none(w_globals) and not space.isinstance_w(w_globals, space.w_dict)): raise oefmt(space.w_TypeError, '%s() arg 2 must be a dict, not %T', funcname, w_globals) if (not space.is_none(w_locals) and space.lookup(w_locals, '__getitem__') is None): raise oefmt(space.w_TypeError, '%s() arg 3 must be a mapping or None, not %T', funcname, w_locals) if space.is_none(w_globals): if caller is None: caller = space.getexecutioncontext().gettopframe_nohidden() if caller is None: w_globals = space.newdict(module=True) if space.is_none(w_locals): w_locals = w_globals else: w_globals = caller.get_w_globals() if space.is_none(w_locals): w_locals = caller.getdictscope() elif space.is_none(w_locals): w_locals = w_globals return w_globals, w_locals def _dict_merge(space, w_dict, w_item, w_function): from pypy.objspace.std.dictmultiobject import W_DictMultiObject, update1 l1 = space.len_w(w_dict) unroll_safe = jit.isvirtual(w_dict) and l1 < 10 if not space.isinstance_w(w_dict, space.w_dict): raise oefmt(space.w_RuntimeError, "expected a dict, got %T", w_dict) assert isinstance(w_dict, W_DictMultiObject) if not space.isinstance_w(w_item, space.w_dict): unroll_safe = False if not space.ismapping_w(w_item): raise oefmt(space.w_TypeError, "%s argument after ** must be a mapping, not %T", space.guess_function_name_parens(w_function), w_item) else: l2 = space.len_w(w_item) if l1 == 0: update1(space, w_dict, w_item) return l2 = space.len_w(w_item) if l2 == 0: return unroll_safe = unroll_safe and jit.isvirtual(w_item) and l2 < 10 _dict_merge_loop(space, w_dict, w_item, unroll_safe, w_function) @jit.look_inside_iff(lambda space, w_dict, w_item, unroll_safe, w_function: unroll_safe) def _dict_merge_loop(space, w_dict, w_item, unroll_safe, w_function): try: w_iterator = space.iter(space.call_method(w_item, "keys")) except OperationError as e: if not e.match(space, space.w_AttributeError): raise raise oefmt(space.w_TypeError, "%s argument after ** must be a mapping, not %T", space.guess_function_name_parens(w_function), w_item) while True: try: w_key = space.next(w_iterator) except OperationError as e: if not e.match(space, space.w_StopIteration): raise break w_value = space.getitem(w_item, w_key) if space.contains_w(w_dict, w_key): raise oefmt(space.w_TypeError, "%s got multiple values for keyword argument %R", space.guess_function_name_parens(w_function), w_key) space.setitem(w_dict, w_key, w_value) def _copy_dict_without_keys(space, w_keys, w_subject): w_dict = space.newdict() space.call_method(w_dict, 'update', w_subject) for i in range(space.len_w(w_keys)): w_key = space.getitem(w_keys, space.newint(i)) space.delitem(w_dict, w_key) return w_dict def match_class_attr(space, w_subject, w_name, w_type, seen): name = space.text_w(w_name) if name in seen: raise oefmt(space.w_TypeError, "%N() got multiple sub-patterns for attribute %R", w_type, w_name) seen[name] = None return space.findattr(w_subject, w_name) @jit.unroll_safe def _match_class(space, nargs, w_names, w_type, w_subject): w_res = space.call_method(space.builtin, "isinstance", w_subject, w_type) if not space.is_true(w_res): return None seen = {} attrs_w = [] if nargs: try: w_match_args = space.getattr(w_type, space.newtext('__match_args__')) match_self = False except OperationError as e: if not e.match(space, space.w_AttributeError): raise e w_match_args = space.newtuple([]) match_self = \ space.isinstance_w(w_subject, space.w_float) or \ space.isinstance_w(w_subject, space.w_tuple) or \ space.isinstance_w(w_subject, space.w_dict) or \ space.isinstance_w(w_subject, space.w_long) or \ space.isinstance_w(w_subject, space.w_bytes) or \ space.isinstance_w(w_subject, space.w_list) or \ space.isinstance_w(w_subject, space.w_bytearray) or \ space.isinstance_w(w_subject, space.w_unicode) or \ space.isinstance_w(w_subject, space.w_set) or \ space.isinstance_w(w_subject, space.w_frozenset) if not space.isinstance_w(w_match_args, space.w_tuple): raise oefmt(space.w_TypeError, "%N.__match_args__ must be a tuple (got '%T')", w_type, w_match_args) allowed = 1 if match_self else space.len_w(w_match_args) if allowed < nargs: plural = "" if allowed == 1 else "s"; raise oefmt(space.w_TypeError, "%N() accepts %d positional sub-pattern%s (%d given)", w_type, allowed, plural, nargs) if match_self: attrs_w.append(w_subject) else: for i in range(nargs): w_name = space.getitem(w_match_args, space.newint(i)) if not space.isinstance_w(w_name, space.w_unicode): raise oefmt(space.w_TypeError, "__match_args__ elements must be strings (got '%T')", w_name) w_attr = match_class_attr(space, w_subject, w_name, w_type, seen) if w_attr is None: return None attrs_w.append(w_attr) w_iter = space.iter(w_names) try: while True: w_name = space.next(w_iter) w_attr = match_class_attr(space, w_subject, w_name, w_type, seen) if w_attr is None: return None attrs_w.append(w_attr) except OperationError as e: if not e.match(space, space.w_StopIteration): raise return space.newtuple(attrs_w[:]) # exception group helpers @jit.unroll_safe def check_except_star_type_valid(space, w_typ): def check(space, w_typ, w_BaseExceptionGroup): if not space.exception_is_valid_class_w(w_typ): raise oefmt(space.w_TypeError, CANNOT_CATCH_MSG) if space.issubtype_w(w_typ, w_BaseExceptionGroup): raise oefmt(space.w_TypeError, "catching ExceptionGroup with except* is not allowed. Use except instead.") w_BaseExceptionGroup = space.getattr(space.builtin, space.newtext('BaseExceptionGroup')) if space.isinstance_w(w_typ, space.w_tuple): for w_sub in space.fixedview(w_typ): check(space, w_sub, w_BaseExceptionGroup) else: check(space, w_typ, w_BaseExceptionGroup) def exception_group_match(space, w_eg, w_typ): if space.is_w(w_eg, space.w_None): return space.w_None, space.w_None assert space.isinstance_w(w_eg, space.w_Exception) w_BaseExceptionGroup = space.getattr(space.builtin, space.newtext('BaseExceptionGroup')) w_ExceptionGroup = space.getattr(space.builtin, space.newtext('ExceptionGroup')) if space.exception_match(space.type(w_eg), w_typ): if space.isinstance_w(w_eg, w_BaseExceptionGroup): return w_eg, space.w_None w_list = space.newlist([w_eg]) w_wrapped = space.call_function(w_ExceptionGroup, space.newtext(''), w_list) return w_wrapped, space.w_None elif space.isinstance_w(w_eg, w_BaseExceptionGroup): w_tup = space.call_method(w_eg, 'split', w_typ) w_match, w_rest = space.unpackiterable(w_tup, 2) return w_match, w_rest else: return space.w_None, space.w_None ### helpers written at the application-level ### # Some of these functions are expected to be generally useful if other # parts of the code need to do the same thing as a non-trivial opcode, # like finding out which metaclass a new class should have. # This is why they are not methods of PyFrame. # There are also a couple of helpers that are methods, defined in the # class above. app = gateway.applevel(r''' """ applevel implementation of certain system properties, imports and other helpers""" import sys def print_expr(obj): try: displayhook = sys.displayhook except AttributeError: raise RuntimeError("lost sys.displayhook") displayhook(obj) ''', filename=__file__) print_expr = app.interphook('print_expr') app = gateway.applevel(r''' def import_all_from(module, into_locals): try: all = module.__all__ except AttributeError: try: dict = module.__dict__ except AttributeError: raise ImportError("from-import-* object has no __dict__ " "and no __all__") all = dict.keys() skip_leading_underscores = True else: skip_leading_underscores = False module_name = module.__name__ if not isinstance(module_name, str): raise TypeError("module __name__ must be a string, not %s", type(module_name).__name__) for name in all: if not isinstance(name, str): if skip_leading_underscores: container = "__dict__" accessor = "Key" else: container = "__all__" accessor = "Item" raise TypeError( "%s in %s.%s must be str, not %s" % ( accessor, module_name, container, type(name).__name__ ) ) if skip_leading_underscores and name and name[0] == '_': continue into_locals[name] = getattr(module, name) ''', filename=__file__) import_all_from = app.interphook('import_all_from')