1 // Exception raising code
2 //
3 // Exceptions are raised by __Pyx_Raise() and stored as plain
4 // type/value/tb in PyThreadState->curexc_*. When being caught by an
5 // 'except' statement, curexc_* is moved over to exc_* by
6 // __Pyx_GetException()
7
8 /////////////// PyErrFetchRestore.proto ///////////////
9
10 static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
11 static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
12
13 /////////////// PyErrFetchRestore ///////////////
14
__Pyx_ErrRestore(PyObject * type,PyObject * value,PyObject * tb)15 static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) {
16 #if CYTHON_COMPILING_IN_CPYTHON
17 PyObject *tmp_type, *tmp_value, *tmp_tb;
18 PyThreadState *tstate = PyThreadState_GET();
19
20 tmp_type = tstate->curexc_type;
21 tmp_value = tstate->curexc_value;
22 tmp_tb = tstate->curexc_traceback;
23 tstate->curexc_type = type;
24 tstate->curexc_value = value;
25 tstate->curexc_traceback = tb;
26 Py_XDECREF(tmp_type);
27 Py_XDECREF(tmp_value);
28 Py_XDECREF(tmp_tb);
29 #else
30 PyErr_Restore(type, value, tb);
31 #endif
32 }
33
__Pyx_ErrFetch(PyObject ** type,PyObject ** value,PyObject ** tb)34 static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) {
35 #if CYTHON_COMPILING_IN_CPYTHON
36 PyThreadState *tstate = PyThreadState_GET();
37 *type = tstate->curexc_type;
38 *value = tstate->curexc_value;
39 *tb = tstate->curexc_traceback;
40
41 tstate->curexc_type = 0;
42 tstate->curexc_value = 0;
43 tstate->curexc_traceback = 0;
44 #else
45 PyErr_Fetch(type, value, tb);
46 #endif
47 }
48
49 /////////////// RaiseException.proto ///////////////
50
51 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /*proto*/
52
53 /////////////// RaiseException ///////////////
54 //@requires: PyErrFetchRestore
55
56 // The following function is based on do_raise() from ceval.c. There
57 // are separate versions for Python2 and Python3 as exception handling
58 // has changed quite a lot between the two versions.
59
60 #if PY_MAJOR_VERSION < 3
__Pyx_Raise(PyObject * type,PyObject * value,PyObject * tb,CYTHON_UNUSED PyObject * cause)61 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
62 CYTHON_UNUSED PyObject *cause) {
63 /* 'cause' is only used in Py3 */
64 Py_XINCREF(type);
65 if (!value || value == Py_None)
66 value = NULL;
67 else
68 Py_INCREF(value);
69
70 if (!tb || tb == Py_None)
71 tb = NULL;
72 else {
73 Py_INCREF(tb);
74 if (!PyTraceBack_Check(tb)) {
75 PyErr_SetString(PyExc_TypeError,
76 "raise: arg 3 must be a traceback or None");
77 goto raise_error;
78 }
79 }
80
81 #if PY_VERSION_HEX < 0x02050000
82 if (PyClass_Check(type)) {
83 #else
84 if (PyType_Check(type)) {
85 #endif
86 /* instantiate the type now (we don't know when and how it will be caught) */
87 #if CYTHON_COMPILING_IN_PYPY
88 /* PyPy can't handle value == NULL */
89 if (!value) {
90 Py_INCREF(Py_None);
91 value = Py_None;
92 }
93 #endif
94 PyErr_NormalizeException(&type, &value, &tb);
95
96 } else {
97 /* Raising an instance. The value should be a dummy. */
98 if (value) {
99 PyErr_SetString(PyExc_TypeError,
100 "instance exception may not have a separate value");
101 goto raise_error;
102 }
103 /* Normalize to raise <class>, <instance> */
104 value = type;
105 #if PY_VERSION_HEX < 0x02050000
106 if (PyInstance_Check(type)) {
107 type = (PyObject*) ((PyInstanceObject*)type)->in_class;
108 Py_INCREF(type);
109 } else {
110 type = 0;
111 PyErr_SetString(PyExc_TypeError,
112 "raise: exception must be an old-style class or instance");
113 goto raise_error;
114 }
115 #else
116 type = (PyObject*) Py_TYPE(type);
117 Py_INCREF(type);
118 if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
119 PyErr_SetString(PyExc_TypeError,
120 "raise: exception class must be a subclass of BaseException");
121 goto raise_error;
122 }
123 #endif
124 }
125
126 __Pyx_ErrRestore(type, value, tb);
127 return;
128 raise_error:
129 Py_XDECREF(value);
130 Py_XDECREF(type);
131 Py_XDECREF(tb);
132 return;
133 }
134
135 #else /* Python 3+ */
136
137 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
138 PyObject* owned_instance = NULL;
139 if (tb == Py_None) {
140 tb = 0;
141 } else if (tb && !PyTraceBack_Check(tb)) {
142 PyErr_SetString(PyExc_TypeError,
143 "raise: arg 3 must be a traceback or None");
144 goto bad;
145 }
146 if (value == Py_None)
147 value = 0;
148
149 if (PyExceptionInstance_Check(type)) {
150 if (value) {
151 PyErr_SetString(PyExc_TypeError,
152 "instance exception may not have a separate value");
153 goto bad;
154 }
155 value = type;
156 type = (PyObject*) Py_TYPE(value);
157 } else if (PyExceptionClass_Check(type)) {
158 // make sure value is an exception instance of type
159 PyObject *instance_class = NULL;
160 if (value && PyExceptionInstance_Check(value)) {
161 instance_class = (PyObject*) Py_TYPE(value);
162 if (instance_class != type) {
163 if (PyObject_IsSubclass(instance_class, type)) {
164 // believe the instance
165 type = instance_class;
166 } else {
167 instance_class = NULL;
168 }
169 }
170 }
171 if (!instance_class) {
172 // instantiate the type now (we don't know when and how it will be caught)
173 // assuming that 'value' is an argument to the type's constructor
174 // not using PyErr_NormalizeException() to avoid ref-counting problems
175 PyObject *args;
176 if (!value)
177 args = PyTuple_New(0);
178 else if (PyTuple_Check(value)) {
179 Py_INCREF(value);
180 args = value;
181 } else
182 args = PyTuple_Pack(1, value);
183 if (!args)
184 goto bad;
185 owned_instance = PyObject_Call(type, args, NULL);
186 Py_DECREF(args);
187 if (!owned_instance)
188 goto bad;
189 value = owned_instance;
190 if (!PyExceptionInstance_Check(value)) {
191 PyErr_Format(PyExc_TypeError,
192 "calling %R should have returned an instance of "
193 "BaseException, not %R",
194 type, Py_TYPE(value));
195 goto bad;
196 }
197 }
198 } else {
199 PyErr_SetString(PyExc_TypeError,
200 "raise: exception class must be a subclass of BaseException");
201 goto bad;
202 }
203
204 #if PY_VERSION_HEX >= 0x03030000
205 if (cause) {
206 #else
207 if (cause && cause != Py_None) {
208 #endif
209 PyObject *fixed_cause;
210 if (cause == Py_None) {
211 // raise ... from None
212 fixed_cause = NULL;
213 } else if (PyExceptionClass_Check(cause)) {
214 fixed_cause = PyObject_CallObject(cause, NULL);
215 if (fixed_cause == NULL)
216 goto bad;
217 } else if (PyExceptionInstance_Check(cause)) {
218 fixed_cause = cause;
219 Py_INCREF(fixed_cause);
220 } else {
221 PyErr_SetString(PyExc_TypeError,
222 "exception causes must derive from "
223 "BaseException");
224 goto bad;
225 }
226 PyException_SetCause(value, fixed_cause);
227 }
228
229 PyErr_SetObject(type, value);
230
231 if (tb) {
232 PyThreadState *tstate = PyThreadState_GET();
233 PyObject* tmp_tb = tstate->curexc_traceback;
234 if (tb != tmp_tb) {
235 Py_INCREF(tb);
236 tstate->curexc_traceback = tb;
237 Py_XDECREF(tmp_tb);
238 }
239 }
240
241 bad:
242 Py_XDECREF(owned_instance);
243 return;
244 }
245 #endif
246
247 /////////////// GetException.proto ///////////////
248
249 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
250
251 /////////////// GetException ///////////////
252
253 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) {
254 PyObject *local_type, *local_value, *local_tb;
255 #if CYTHON_COMPILING_IN_CPYTHON
256 PyObject *tmp_type, *tmp_value, *tmp_tb;
257 PyThreadState *tstate = PyThreadState_GET();
258 local_type = tstate->curexc_type;
259 local_value = tstate->curexc_value;
260 local_tb = tstate->curexc_traceback;
261 tstate->curexc_type = 0;
262 tstate->curexc_value = 0;
263 tstate->curexc_traceback = 0;
264 #else
265 PyErr_Fetch(&local_type, &local_value, &local_tb);
266 #endif
267 PyErr_NormalizeException(&local_type, &local_value, &local_tb);
268 #if CYTHON_COMPILING_IN_CPYTHON
269 if (unlikely(tstate->curexc_type))
270 #else
271 if (unlikely(PyErr_Occurred()))
272 #endif
273 goto bad;
274 #if PY_MAJOR_VERSION >= 3
275 if (local_tb) {
276 if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
277 goto bad;
278 }
279 #endif
280 // traceback may be NULL for freshly raised exceptions
281 Py_XINCREF(local_tb);
282 // exception state may be temporarily empty in parallel loops (race condition)
283 Py_XINCREF(local_type);
284 Py_XINCREF(local_value);
285 *type = local_type;
286 *value = local_value;
287 *tb = local_tb;
288 #if CYTHON_COMPILING_IN_CPYTHON
289 tmp_type = tstate->exc_type;
290 tmp_value = tstate->exc_value;
291 tmp_tb = tstate->exc_traceback;
292 tstate->exc_type = local_type;
293 tstate->exc_value = local_value;
294 tstate->exc_traceback = local_tb;
295 // Make sure tstate is in a consistent state when we XDECREF
296 // these objects (DECREF may run arbitrary code).
297 Py_XDECREF(tmp_type);
298 Py_XDECREF(tmp_value);
299 Py_XDECREF(tmp_tb);
300 #else
301 PyErr_SetExcInfo(local_type, local_value, local_tb);
302 #endif
303 return 0;
304 bad:
305 *type = 0;
306 *value = 0;
307 *tb = 0;
308 Py_XDECREF(local_type);
309 Py_XDECREF(local_value);
310 Py_XDECREF(local_tb);
311 return -1;
312 }
313
314 /////////////// ReRaiseException.proto ///////////////
315
316 static CYTHON_INLINE void __Pyx_ReraiseException(void); /*proto*/
317
318 /////////////// ReRaiseException.proto ///////////////
319
320 static CYTHON_INLINE void __Pyx_ReraiseException(void) {
321 PyObject *type = NULL, *value = NULL, *tb = NULL;
322 #if CYTHON_COMPILING_IN_CPYTHON
323 PyThreadState *tstate = PyThreadState_GET();
324 type = tstate->exc_type;
325 value = tstate->exc_value;
326 tb = tstate->exc_traceback;
327 #else
328 PyErr_GetExcInfo(&type, &value, &tb);
329 #endif
330 if (!type || type == Py_None) {
331 #if !CYTHON_COMPILING_IN_CPYTHON
332 Py_XDECREF(type);
333 Py_XDECREF(value);
334 Py_XDECREF(tb);
335 #endif
336 // message copied from Py3
337 PyErr_SetString(PyExc_RuntimeError,
338 "No active exception to reraise");
339 } else {
340 #if CYTHON_COMPILING_IN_CPYTHON
341 Py_INCREF(type);
342 Py_XINCREF(value);
343 Py_XINCREF(tb);
344
345 #endif
346 PyErr_Restore(type, value, tb);
347 }
348 }
349
350 /////////////// SaveResetException.proto ///////////////
351
352 static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
353 static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
354
355 /////////////// SaveResetException ///////////////
356
357 static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb) {
358 #if CYTHON_COMPILING_IN_CPYTHON
359 PyThreadState *tstate = PyThreadState_GET();
360 *type = tstate->exc_type;
361 *value = tstate->exc_value;
362 *tb = tstate->exc_traceback;
363 Py_XINCREF(*type);
364 Py_XINCREF(*value);
365 Py_XINCREF(*tb);
366 #else
367 PyErr_GetExcInfo(type, value, tb);
368 #endif
369 }
370
371 static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb) {
372 #if CYTHON_COMPILING_IN_CPYTHON
373 PyObject *tmp_type, *tmp_value, *tmp_tb;
374 PyThreadState *tstate = PyThreadState_GET();
375 tmp_type = tstate->exc_type;
376 tmp_value = tstate->exc_value;
377 tmp_tb = tstate->exc_traceback;
378 tstate->exc_type = type;
379 tstate->exc_value = value;
380 tstate->exc_traceback = tb;
381 Py_XDECREF(tmp_type);
382 Py_XDECREF(tmp_value);
383 Py_XDECREF(tmp_tb);
384 #else
385 PyErr_SetExcInfo(type, value, tb);
386 #endif
387 }
388
389 /////////////// SwapException.proto ///////////////
390
391 static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
392
393 /////////////// SwapException ///////////////
394
395 static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) {
396 PyObject *tmp_type, *tmp_value, *tmp_tb;
397 #if CYTHON_COMPILING_IN_CPYTHON
398 PyThreadState *tstate = PyThreadState_GET();
399
400 tmp_type = tstate->exc_type;
401 tmp_value = tstate->exc_value;
402 tmp_tb = tstate->exc_traceback;
403
404 tstate->exc_type = *type;
405 tstate->exc_value = *value;
406 tstate->exc_traceback = *tb;
407 #else
408 PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb);
409 PyErr_SetExcInfo(*type, *value, *tb);
410 #endif
411
412 *type = tmp_type;
413 *value = tmp_value;
414 *tb = tmp_tb;
415 }
416
417 /////////////// WriteUnraisableException.proto ///////////////
418
419 static void __Pyx_WriteUnraisable(const char *name, int clineno,
420 int lineno, const char *filename,
421 int full_traceback); /*proto*/
422
423 /////////////// WriteUnraisableException ///////////////
424 //@requires: PyErrFetchRestore
425
426 static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno,
427 CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename,
428 int full_traceback) {
429 PyObject *old_exc, *old_val, *old_tb;
430 PyObject *ctx;
431 __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
432 if (full_traceback) {
433 Py_XINCREF(old_exc);
434 Py_XINCREF(old_val);
435 Py_XINCREF(old_tb);
436 __Pyx_ErrRestore(old_exc, old_val, old_tb);
437 PyErr_PrintEx(1);
438 }
439 #if PY_MAJOR_VERSION < 3
440 ctx = PyString_FromString(name);
441 #else
442 ctx = PyUnicode_FromString(name);
443 #endif
444 __Pyx_ErrRestore(old_exc, old_val, old_tb);
445 if (!ctx) {
446 PyErr_WriteUnraisable(Py_None);
447 } else {
448 PyErr_WriteUnraisable(ctx);
449 Py_DECREF(ctx);
450 }
451 }
452
453 /////////////// AddTraceback.proto ///////////////
454
455 static void __Pyx_AddTraceback(const char *funcname, int c_line,
456 int py_line, const char *filename); /*proto*/
457
458 /////////////// AddTraceback ///////////////
459 //@requires: ModuleSetupCode.c::CodeObjectCache
460 //@substitute: naming
461
462 #include "compile.h"
463 #include "frameobject.h"
464 #include "traceback.h"
465
466 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
467 const char *funcname, int c_line,
468 int py_line, const char *filename) {
469 PyCodeObject *py_code = 0;
470 PyObject *py_srcfile = 0;
471 PyObject *py_funcname = 0;
472
473 #if PY_MAJOR_VERSION < 3
474 py_srcfile = PyString_FromString(filename);
475 #else
476 py_srcfile = PyUnicode_FromString(filename);
477 #endif
478 if (!py_srcfile) goto bad;
479 if (c_line) {
480 #if PY_MAJOR_VERSION < 3
481 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, $cfilenm_cname, c_line);
482 #else
483 py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, $cfilenm_cname, c_line);
484 #endif
485 }
486 else {
487 #if PY_MAJOR_VERSION < 3
488 py_funcname = PyString_FromString(funcname);
489 #else
490 py_funcname = PyUnicode_FromString(funcname);
491 #endif
492 }
493 if (!py_funcname) goto bad;
494 py_code = __Pyx_PyCode_New(
495 0, /*int argcount,*/
496 0, /*int kwonlyargcount,*/
497 0, /*int nlocals,*/
498 0, /*int stacksize,*/
499 0, /*int flags,*/
500 $empty_bytes, /*PyObject *code,*/
501 $empty_tuple, /*PyObject *consts,*/
502 $empty_tuple, /*PyObject *names,*/
503 $empty_tuple, /*PyObject *varnames,*/
504 $empty_tuple, /*PyObject *freevars,*/
505 $empty_tuple, /*PyObject *cellvars,*/
506 py_srcfile, /*PyObject *filename,*/
507 py_funcname, /*PyObject *name,*/
508 py_line, /*int firstlineno,*/
509 $empty_bytes /*PyObject *lnotab*/
510 );
511 Py_DECREF(py_srcfile);
512 Py_DECREF(py_funcname);
513 return py_code;
514 bad:
515 Py_XDECREF(py_srcfile);
516 Py_XDECREF(py_funcname);
517 return NULL;
518 }
519
520 static void __Pyx_AddTraceback(const char *funcname, int c_line,
521 int py_line, const char *filename) {
522 PyCodeObject *py_code = 0;
523 PyObject *py_globals = 0;
524 PyFrameObject *py_frame = 0;
525
526 py_code = $global_code_object_cache_find(c_line ? c_line : py_line);
527 if (!py_code) {
528 py_code = __Pyx_CreateCodeObjectForTraceback(
529 funcname, c_line, py_line, filename);
530 if (!py_code) goto bad;
531 $global_code_object_cache_insert(c_line ? c_line : py_line, py_code);
532 }
533 py_globals = PyModule_GetDict($module_cname);
534 if (!py_globals) goto bad;
535 py_frame = PyFrame_New(
536 PyThreadState_GET(), /*PyThreadState *tstate,*/
537 py_code, /*PyCodeObject *code,*/
538 py_globals, /*PyObject *globals,*/
539 0 /*PyObject *locals*/
540 );
541 if (!py_frame) goto bad;
542 py_frame->f_lineno = py_line;
543 PyTraceBack_Here(py_frame);
544 bad:
545 Py_XDECREF(py_code);
546 Py_XDECREF(py_frame);
547 }
548