def throw(self, w_type, w_val, w_tb): from pypy.interpreter.pytraceback import check_traceback space = self.space if w_val is None: w_val = space.w_None msg = "throw() third argument must be a traceback object" if space.is_none(w_tb): tb = None else: tb = check_traceback(space, w_tb, msg) operr = OperationError(w_type, w_val, tb) operr.normalize_exception(space) # note: w_yielded_from is always None if 'self.running' if (self.w_yielded_from is not None and operr.match(space, space.w_GeneratorExit)): try: self._gen_close_iter(space) except OperationError as e: return self.send_error(e) if tb is None: tb = space.getattr(operr.get_w_value(space), space.newtext('__traceback__')) if not space.is_w(tb, space.w_None): operr.set_traceback(tb) return self.send_error(operr)
def RAISE_VARARGS(f, nbargs, *ignored): space = f.space if nbargs == 0: operror = space.getexecutioncontext().sys_exc_info() if operror is None: raise OperationError(space.w_TypeError, space.wrap("raise: no active exception to re-raise")) # re-raise, no new traceback obj will be attached f.last_exception = operror raise Reraise w_value = w_traceback = space.w_None if nbargs >= 3: w_traceback = f.popvalue() if nbargs >= 2: w_value = f.popvalue() if 1: w_type = f.popvalue() operror = OperationError(w_type, w_value) operror.normalize_exception(space) if not space.full_exceptions or space.is_w(w_traceback, space.w_None): # common case raise operror else: from pypy.interpreter.pytraceback import check_traceback msg = "raise: arg 3 must be a traceback or None" tb = check_traceback(space, w_traceback, msg) operror.application_traceback = tb # special 3-arguments raise, no new traceback obj will be attached raise RaiseWithExplicitTraceback(operror)
def RAISE_VARARGS(f, nbargs, *ignored): space = f.space if nbargs == 0: operror = space.getexecutioncontext().sys_exc_info() if operror is None: raise OperationError( space.w_TypeError, space.wrap("raise: no active exception to re-raise")) # re-raise, no new traceback obj will be attached f.last_exception = operror raise Reraise w_value = w_traceback = space.w_None if nbargs >= 3: w_traceback = f.popvalue() if nbargs >= 2: w_value = f.popvalue() if 1: w_type = f.popvalue() operror = OperationError(w_type, w_value) operror.normalize_exception(space) if not space.full_exceptions or space.is_w(w_traceback, space.w_None): # common case raise operror else: tb = space.interpclass_w(w_traceback) if tb is None or not space.is_true( space.isinstance( tb, space.gettypeobject( pytraceback.PyTraceback.typedef))): raise OperationError( space.w_TypeError, space.wrap("raise: arg 3 must be a traceback or None")) operror.application_traceback = tb # re-raise, no new traceback obj will be attached f.last_exception = operror raise Reraise
def RAISE_VARARGS(f, nbargs, *ignored): space = f.space if nbargs == 0: operror = space.getexecutioncontext().sys_exc_info() if operror is None: raise OperationError(space.w_TypeError, space.wrap("raise: no active exception to re-raise")) # re-raise, no new traceback obj will be attached f.last_exception = operror raise Reraise w_value = w_traceback = space.w_None if nbargs >= 3: w_traceback = f.popvalue() if nbargs >= 2: w_value = f.popvalue() if 1: w_type = f.popvalue() operror = OperationError(w_type, w_value) operror.normalize_exception(space) if not space.full_exceptions or space.is_w(w_traceback, space.w_None): # common case raise operror else: tb = space.interpclass_w(w_traceback) if tb is None or not space.is_true(space.isinstance(tb, space.gettypeobject(pytraceback.PyTraceback.typedef))): raise OperationError(space.w_TypeError, space.wrap("raise: arg 3 must be a traceback or None")) operror.application_traceback = tb # re-raise, no new traceback obj will be attached f.last_exception = operror raise Reraise
def w_throw(self, w_type=None, w_value=None, w_traceback=None): space = self.space if space.is_w(w_type, space.w_None): w_type = self.costate.w_GreenletExit # Code copied from RAISE_VARARGS but slightly modified. Not too nice. operror = OperationError(w_type, w_value) operror.normalize_exception(space) if not space.is_w(w_traceback, space.w_None): from pypy.interpreter import pytraceback tb = space.interpclass_w(w_traceback) if tb is None or not space.is_true( space.isinstance( tb, space.gettypeobject( pytraceback.PyTraceback.typedef))): raise OperationError( space.w_TypeError, space.wrap("throw: arg 3 must be a traceback or None")) operror.application_traceback = tb # Dead greenlet: turn GreenletExit into a regular return if self.isdead() and operror.match(space, self.costate.w_GreenletExit): args_w = [operror.get_w_value(space)] else: syncstate.push_exception(operror) args_w = None return self.w_switch(args_w)
def throw(self, w_type, w_val, w_tb): from pypy.interpreter.pytraceback import check_traceback space = self.space msg = "throw() third argument must be a traceback object" if space.is_none(w_tb): tb = None else: tb = check_traceback(space, w_tb, msg) operr = OperationError(w_type, w_val, tb) operr.normalize_exception(space) return self.send_ex(space.w_None, operr)
def throw(self, w_type, w_val, w_tb): from pypy.interpreter.pytraceback import check_traceback space = self.space msg = "throw() third argument must be a traceback object" if space.is_w(w_tb, space.w_None): tb = None else: tb = check_traceback(space, w_tb, msg) operr = OperationError(w_type, w_val, tb) operr.normalize_exception(space) return self.send_ex(space.w_None, operr)
def PyErr_NormalizeException(space, exc_p, val_p, tb_p): """Under certain circumstances, the values returned by PyErr_Fetch() below can be "unnormalized", meaning that *exc is a class object but *val is not an instance of the same class. This function can be used to instantiate the class in that case. If the values are already normalized, nothing happens. The delayed normalization is implemented to improve performance.""" operr = OperationError(from_ref(space, exc_p[0]), from_ref(space, val_p[0])) operr.normalize_exception(space) Py_DecRef(space, exc_p[0]) Py_DecRef(space, val_p[0]) exc_p[0] = make_ref(space, operr.w_type) val_p[0] = make_ref(space, operr.get_w_value(space))
def descr_throw(self, w_type, w_val=None, w_tb=None, w_to=None): from pypy.interpreter.pytraceback import check_traceback space = self.space # msg = "throw() third argument must be a traceback object" if space.is_none(w_tb): tb = None else: tb = check_traceback(space, w_tb, msg) # operr = OperationError(w_type, w_val, tb) operr.normalize_exception(space) global_state.w_value = None global_state.propagate_exception = operr return self.switch(w_to)
def w_throw(self, w_type, w_value=None, w_traceback=None): space = self.space operror = OperationError(w_type, w_value) operror.normalize_exception(space) if not space.is_w(w_traceback, space.w_None): from pypy.interpreter import pytraceback tb = space.interpclass_w(w_traceback) if tb is None or not space.is_true(space.isinstance(tb, space.gettypeobject(pytraceback.PyTraceback.typedef))): raise OperationError(space.w_TypeError, space.wrap("throw: arg 3 must be a traceback or None")) operror.set_traceback(tb) self._kill(operror)
def unpackiterable(self, w_iterable, expected_length=None): if not isinstance(w_iterable, Variable): l = list(self.unwrap(w_iterable)) if expected_length is not None and len(l) != expected_length: raise ValueError return [self.wrap(x) for x in l] if isinstance(w_iterable, Variable) and expected_length is None: raise UnwrapException, ("cannot unpack a Variable iterable" "without knowing its length") elif expected_length is not None: w_len = self.len(w_iterable) w_correct = self.eq(w_len, self.wrap(expected_length)) if not self.is_true(w_correct): e = OperationError(self.w_ValueError, self.w_None) e.normalize_exception(self) raise e return [self.do_operation("getitem", w_iterable, self.wrap(i)) for i in range(expected_length)] return ObjSpace.unpackiterable(self, w_iterable, expected_length)
def throw(self, w_type, w_val, w_tb): from pypy.interpreter.pytraceback import check_traceback space = self.space msg = "throw() third argument must be a traceback object" if space.is_none(w_tb): tb = None else: tb = check_traceback(space, w_tb, msg) operr = OperationError(w_type, w_val, tb) operr.normalize_exception(space) if tb is None: tb = space.getattr(operr.get_w_value(space), space.wrap('__traceback__')) if not space.is_w(tb, space.w_None): operr.set_traceback(tb) return self.send_ex(space.w_None, operr)
def throw(self, w_type, w_val, w_tb): from pypy.interpreter.pytraceback import check_traceback space = self.space msg = "throw() third argument must be a traceback object" if space.is_w(w_tb, space.w_None): tb = None else: tb = check_traceback(space, w_tb, msg) operr = OperationError(w_type, w_val, tb) operr.normalize_exception(space) ec = space.getexecutioncontext() next_instr = self.frame.handle_operation_error(ec, operr) self.frame.last_instr = intmask(next_instr - 1) return self.send_ex(space.w_None, True)
def unpackiterable(self, w_iterable, expected_length=None): if not isinstance(w_iterable, Variable): l = list(self.unwrap(w_iterable)) if expected_length is not None and len(l) != expected_length: raise ValueError return [self.wrap(x) for x in l] if isinstance(w_iterable, Variable) and expected_length is None: raise UnwrapException, ("cannot unpack a Variable iterable" "without knowing its length") elif expected_length is not None: w_len = self.len(w_iterable) w_correct = self.eq(w_len, self.wrap(expected_length)) if not self.is_true(w_correct): e = OperationError(self.w_ValueError, self.w_None) e.normalize_exception(self) raise e return [self.do_operation('getitem', w_iterable, self.wrap(i)) for i in range(expected_length)] return ObjSpace.unpackiterable(self, w_iterable, expected_length)
def unpackiterable(self, w_iterable, expected_length=None): if not isinstance(w_iterable, Variable): l = list(self.unwrap(w_iterable)) if expected_length is not None and len(l) != expected_length: raise ValueError return [self.wrap(x) for x in l] if isinstance(w_iterable, Variable) and expected_length is None: raise UnwrapException, ("cannot unpack a Variable iterable" "without knowing its length") ## # XXX TEMPORARY HACK XXX TEMPORARY HACK XXX TEMPORARY HACK ## print ("*** cannot unpack a Variable iterable " ## "without knowing its length,") ## print " assuming a list or tuple with up to 7 items" ## items = [] ## w_len = self.len(w_iterable) ## i = 0 ## while True: ## w_i = self.wrap(i) ## w_cond = self.eq(w_len, w_i) ## if self.is_true(w_cond): ## break # done ## if i == 7: ## # too many values ## raise OperationError(self.w_AssertionError, self.w_None) ## w_item = self.do_operation('getitem', w_iterable, w_i) ## items.append(w_item) ## i += 1 ## return items ## # XXX TEMPORARY HACK XXX TEMPORARY HACK XXX TEMPORARY HACK elif expected_length is not None: w_len = self.len(w_iterable) w_correct = self.eq(w_len, self.wrap(expected_length)) if not self.is_true(w_correct): e = OperationError(self.w_ValueError, self.w_None) e.normalize_exception(self) raise e return [ self.do_operation('getitem', w_iterable, self.wrap(i)) for i in range(expected_length) ] return ObjSpace.unpackiterable(self, w_iterable, expected_length)
def unpackiterable(self, w_iterable, expected_length=None): if not isinstance(w_iterable, Variable): l = list(self.unwrap(w_iterable)) if expected_length is not None and len(l) != expected_length: raise ValueError return [self.wrap(x) for x in l] if isinstance(w_iterable, Variable) and expected_length is None: raise UnwrapException, ("cannot unpack a Variable iterable" "without knowing its length") ## # XXX TEMPORARY HACK XXX TEMPORARY HACK XXX TEMPORARY HACK ## print ("*** cannot unpack a Variable iterable " ## "without knowing its length,") ## print " assuming a list or tuple with up to 7 items" ## items = [] ## w_len = self.len(w_iterable) ## i = 0 ## while True: ## w_i = self.wrap(i) ## w_cond = self.eq(w_len, w_i) ## if self.is_true(w_cond): ## break # done ## if i == 7: ## # too many values ## raise OperationError(self.w_AssertionError, self.w_None) ## w_item = self.do_operation('getitem', w_iterable, w_i) ## items.append(w_item) ## i += 1 ## return items ## # XXX TEMPORARY HACK XXX TEMPORARY HACK XXX TEMPORARY HACK elif expected_length is not None: w_len = self.len(w_iterable) w_correct = self.eq(w_len, self.wrap(expected_length)) if not self.is_true(w_correct): e = OperationError(self.w_ValueError, self.w_None) e.normalize_exception(self) raise e return [self.do_operation('getitem', w_iterable, self.wrap(i)) for i in range(expected_length)] return ObjSpace.unpackiterable(self, w_iterable, expected_length)
def w_throw(self, w_type=None, w_value=None, w_traceback=None): space = self.space if space.is_w(w_type, space.w_None): w_type = self.costate.w_GreenletExit # Code copied from RAISE_VARARGS but slightly modified. Not too nice. operror = OperationError(w_type, w_value) operror.normalize_exception(space) if not space.is_w(w_traceback, space.w_None): from pypy.interpreter import pytraceback tb = space.interpclass_w(w_traceback) if tb is None or not space.is_true(space.isinstance(tb, space.gettypeobject(pytraceback.PyTraceback.typedef))): raise OperationError(space.w_TypeError, space.wrap("throw: arg 3 must be a traceback or None")) operror.set_traceback(tb) # Dead greenlet: turn GreenletExit into a regular return if self.isdead() and operror.match(space, self.costate.w_GreenletExit): args_w = [operror.get_w_value(space)] else: syncstate.push_exception(operror) args_w = None return self.w_switch(args_w)
def PyErr_NormalizeException(space, exc_p, val_p, tb_p): """Under certain circumstances, the values returned by PyErr_Fetch() below can be "unnormalized", meaning that *exc is a class object but *val is not an instance of the same class. This function can be used to instantiate the class in that case. If the values are already normalized, nothing happens. The delayed normalization is implemented to improve performance.""" if exc_p[0]: w_etype = from_ref(space, exc_p[0]) else: # There is no exception, so nothing to do return if val_p[0]: w_evalue = from_ref(space, val_p[0]) else: # On CPython, PyErr_SetNone actually sets val to NULL. # Sensible code should probably never trigger this path on PyPy, but... w_evalue = space.w_None operr = OperationError(w_etype, w_evalue) operr.normalize_exception(space) decref(space, exc_p[0]) decref(space, val_p[0]) exc_p[0] = make_ref(space, operr.w_type) val_p[0] = make_ref(space, operr.get_w_value(space))
def normalize_exc(space, w_type, w_value=None, w_tb=None): operr = OperationError(w_type, w_value, w_tb) operr.normalize_exception(space) return operr.get_w_value(space)