src/third_party/cython/src/Cython/Utility/Exceptions.c

   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
  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
  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
  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 }