third_party/cython/src/Cython/Utility/Exceptions.c - mojo-tools - Git at Google

 // Exception raising code
 //
 // Exceptions are raised by __Pyx_Raise() and stored as plain
 // type/value/tb in PyThreadState->curexc_*.  When being caught by an
 // 'except' statement, curexc_* is moved over to exc_* by
 // __Pyx_GetException()

 /////////////// PyErrFetchRestore.proto ///////////////

 static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); /*proto*/
 static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); /*proto*/

 /////////////// PyErrFetchRestore ///////////////

 static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) {
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject *tmp_type, *tmp_value, *tmp_tb;
     PyThreadState *tstate = PyThreadState_GET();

     tmp_type = tstate->curexc_type;
     tmp_value = tstate->curexc_value;
     tmp_tb = tstate->curexc_traceback;
     tstate->curexc_type = type;
     tstate->curexc_value = value;
     tstate->curexc_traceback = tb;
     Py_XDECREF(tmp_type);
     Py_XDECREF(tmp_value);
     Py_XDECREF(tmp_tb);
 #else
     PyErr_Restore(type, value, tb);
 #endif
 }

 static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) {
 #if CYTHON_COMPILING_IN_CPYTHON
     PyThreadState *tstate = PyThreadState_GET();
     *type = tstate->curexc_type;
     *value = tstate->curexc_value;
     *tb = tstate->curexc_traceback;

     tstate->curexc_type = 0;
     tstate->curexc_value = 0;
     tstate->curexc_traceback = 0;
 #else
     PyErr_Fetch(type, value, tb);
 #endif
 }

 /////////////// RaiseException.proto ///////////////

 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /*proto*/

 /////////////// RaiseException ///////////////
 //@requires: PyErrFetchRestore

 // The following function is based on do_raise() from ceval.c. There
 // are separate versions for Python2 and Python3 as exception handling
 // has changed quite a lot between the two versions.

 #if PY_MAJOR_VERSION < 3
 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
                         CYTHON_UNUSED PyObject *cause) {
     /* 'cause' is only used in Py3 */
     Py_XINCREF(type);
     if (!value || value == Py_None)
         value = NULL;
     else
         Py_INCREF(value);

     if (!tb || tb == Py_None)
         tb = NULL;
     else {
         Py_INCREF(tb);
         if (!PyTraceBack_Check(tb)) {
             PyErr_SetString(PyExc_TypeError,
                 "raise: arg 3 must be a traceback or None");
             goto raise_error;
         }
     }

     #if PY_VERSION_HEX < 0x02050000
     if (PyClass_Check(type)) {
     #else
     if (PyType_Check(type)) {
     #endif
         /* instantiate the type now (we don't know when and how it will be caught) */
 #if CYTHON_COMPILING_IN_PYPY
         /* PyPy can't handle value == NULL */
         if (!value) {
             Py_INCREF(Py_None);
             value = Py_None;
         }
 #endif
         PyErr_NormalizeException(&type, &value, &tb);

     } else {
         /* Raising an instance.  The value should be a dummy. */
         if (value) {
             PyErr_SetString(PyExc_TypeError,
                 "instance exception may not have a separate value");
             goto raise_error;
         }
         /* Normalize to raise <class>, <instance> */
         value = type;
         #if PY_VERSION_HEX < 0x02050000
         if (PyInstance_Check(type)) {
             type = (PyObject*) ((PyInstanceObject*)type)->in_class;
             Py_INCREF(type);
         } else {
             type = 0;
             PyErr_SetString(PyExc_TypeError,
                 "raise: exception must be an old-style class or instance");
             goto raise_error;
         }
         #else
         type = (PyObject*) Py_TYPE(type);
         Py_INCREF(type);
         if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
             PyErr_SetString(PyExc_TypeError,
                 "raise: exception class must be a subclass of BaseException");
             goto raise_error;
         }
         #endif
     }

     __Pyx_ErrRestore(type, value, tb);
     return;
 raise_error:
     Py_XDECREF(value);
     Py_XDECREF(type);
     Py_XDECREF(tb);
     return;
 }

 #else /* Python 3+ */

 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
     PyObject* owned_instance = NULL;
     if (tb == Py_None) {
         tb = 0;
     } else if (tb && !PyTraceBack_Check(tb)) {
         PyErr_SetString(PyExc_TypeError,
             "raise: arg 3 must be a traceback or None");
         goto bad;
     }
     if (value == Py_None)
         value = 0;

     if (PyExceptionInstance_Check(type)) {
         if (value) {
             PyErr_SetString(PyExc_TypeError,
                 "instance exception may not have a separate value");
             goto bad;
         }
         value = type;
         type = (PyObject*) Py_TYPE(value);
     } else if (PyExceptionClass_Check(type)) {
         // make sure value is an exception instance of type
         PyObject *instance_class = NULL;
         if (value && PyExceptionInstance_Check(value)) {
             instance_class = (PyObject*) Py_TYPE(value);
             if (instance_class != type) {
                 if (PyObject_IsSubclass(instance_class, type)) {
                     // believe the instance
                     type = instance_class;
                 } else {
                     instance_class = NULL;
                 }
             }
         }
         if (!instance_class) {
             // instantiate the type now (we don't know when and how it will be caught)
             // assuming that 'value' is an argument to the type's constructor
             // not using PyErr_NormalizeException() to avoid ref-counting problems
             PyObject *args;
             if (!value)
                 args = PyTuple_New(0);
             else if (PyTuple_Check(value)) {
                 Py_INCREF(value);
                 args = value;
             } else
                 args = PyTuple_Pack(1, value);
             if (!args)
                 goto bad;
             owned_instance = PyObject_Call(type, args, NULL);
             Py_DECREF(args);
             if (!owned_instance)
                 goto bad;
             value = owned_instance;
             if (!PyExceptionInstance_Check(value)) {
                 PyErr_Format(PyExc_TypeError,
                              "calling %R should have returned an instance of "
                              "BaseException, not %R",
                              type, Py_TYPE(value));
                 goto bad;
             }
         }
     } else {
         PyErr_SetString(PyExc_TypeError,
             "raise: exception class must be a subclass of BaseException");
         goto bad;
     }

 #if PY_VERSION_HEX >= 0x03030000
     if (cause) {
 #else
     if (cause && cause != Py_None) {
 #endif
         PyObject *fixed_cause;
         if (cause == Py_None) {
             // raise ... from None
             fixed_cause = NULL;
         } else if (PyExceptionClass_Check(cause)) {
             fixed_cause = PyObject_CallObject(cause, NULL);
             if (fixed_cause == NULL)
                 goto bad;
         } else if (PyExceptionInstance_Check(cause)) {
             fixed_cause = cause;
             Py_INCREF(fixed_cause);
         } else {
             PyErr_SetString(PyExc_TypeError,
                             "exception causes must derive from "
                             "BaseException");
             goto bad;
         }
         PyException_SetCause(value, fixed_cause);
     }

     PyErr_SetObject(type, value);

     if (tb) {
         PyThreadState *tstate = PyThreadState_GET();
         PyObject* tmp_tb = tstate->curexc_traceback;
         if (tb != tmp_tb) {
             Py_INCREF(tb);
             tstate->curexc_traceback = tb;
             Py_XDECREF(tmp_tb);
         }
     }

 bad:
     Py_XDECREF(owned_instance);
     return;
 }
 #endif

 /////////////// GetException.proto ///////////////

 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); /*proto*/

 /////////////// GetException ///////////////

 static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) {
     PyObject *local_type, *local_value, *local_tb;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject *tmp_type, *tmp_value, *tmp_tb;
     PyThreadState *tstate = PyThreadState_GET();
     local_type = tstate->curexc_type;
     local_value = tstate->curexc_value;
     local_tb = tstate->curexc_traceback;
     tstate->curexc_type = 0;
     tstate->curexc_value = 0;
     tstate->curexc_traceback = 0;
 #else
     PyErr_Fetch(&local_type, &local_value, &local_tb);
 #endif
     PyErr_NormalizeException(&local_type, &local_value, &local_tb);
 #if CYTHON_COMPILING_IN_CPYTHON
     if (unlikely(tstate->curexc_type))
 #else
     if (unlikely(PyErr_Occurred()))
 #endif
         goto bad;
     #if PY_MAJOR_VERSION >= 3
     if (local_tb) {
         if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
             goto bad;
     }
     #endif
     // traceback may be NULL for freshly raised exceptions
     Py_XINCREF(local_tb);
     // exception state may be temporarily empty in parallel loops (race condition)
     Py_XINCREF(local_type);
     Py_XINCREF(local_value);
     *type = local_type;
     *value = local_value;
     *tb = local_tb;
 #if CYTHON_COMPILING_IN_CPYTHON
     tmp_type = tstate->exc_type;
     tmp_value = tstate->exc_value;
     tmp_tb = tstate->exc_traceback;
     tstate->exc_type = local_type;
     tstate->exc_value = local_value;
     tstate->exc_traceback = local_tb;
     // Make sure tstate is in a consistent state when we XDECREF
     // these objects (DECREF may run arbitrary code).
     Py_XDECREF(tmp_type);
     Py_XDECREF(tmp_value);
     Py_XDECREF(tmp_tb);
 #else
     PyErr_SetExcInfo(local_type, local_value, local_tb);
 #endif
     return 0;
 bad:
     *type = 0;
     *value = 0;
     *tb = 0;
     Py_XDECREF(local_type);
     Py_XDECREF(local_value);
     Py_XDECREF(local_tb);
     return -1;
 }

 /////////////// ReRaiseException.proto ///////////////

 static CYTHON_INLINE void __Pyx_ReraiseException(void); /*proto*/

 /////////////// ReRaiseException.proto ///////////////

 static CYTHON_INLINE void __Pyx_ReraiseException(void) {
     PyObject *type = NULL, *value = NULL, *tb = NULL;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyThreadState *tstate = PyThreadState_GET();
     type = tstate->exc_type;
     value = tstate->exc_value;
     tb = tstate->exc_traceback;
 #else
     PyErr_GetExcInfo(&type, &value, &tb);
 #endif
     if (!type || type == Py_None) {
 #if !CYTHON_COMPILING_IN_CPYTHON
         Py_XDECREF(type);
         Py_XDECREF(value);
         Py_XDECREF(tb);
 #endif
         // message copied from Py3
         PyErr_SetString(PyExc_RuntimeError,
             "No active exception to reraise");
     } else {
 #if CYTHON_COMPILING_IN_CPYTHON
         Py_INCREF(type);
         Py_XINCREF(value);
         Py_XINCREF(tb);

 #endif
         PyErr_Restore(type, value, tb);
     }
 }

 /////////////// SaveResetException.proto ///////////////

 static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
 static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb); /*proto*/

 /////////////// SaveResetException ///////////////

 static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject **type, PyObject **value, PyObject **tb) {
 #if CYTHON_COMPILING_IN_CPYTHON
     PyThreadState *tstate = PyThreadState_GET();
     *type = tstate->exc_type;
     *value = tstate->exc_value;
     *tb = tstate->exc_traceback;
     Py_XINCREF(*type);
     Py_XINCREF(*value);
     Py_XINCREF(*tb);
 #else
     PyErr_GetExcInfo(type, value, tb);
 #endif
 }

 static void __Pyx_ExceptionReset(PyObject *type, PyObject *value, PyObject *tb) {
 #if CYTHON_COMPILING_IN_CPYTHON
     PyObject *tmp_type, *tmp_value, *tmp_tb;
     PyThreadState *tstate = PyThreadState_GET();
     tmp_type = tstate->exc_type;
     tmp_value = tstate->exc_value;
     tmp_tb = tstate->exc_traceback;
     tstate->exc_type = type;
     tstate->exc_value = value;
     tstate->exc_traceback = tb;
     Py_XDECREF(tmp_type);
     Py_XDECREF(tmp_value);
     Py_XDECREF(tmp_tb);
 #else
     PyErr_SetExcInfo(type, value, tb);
 #endif
 }

 /////////////// SwapException.proto ///////////////

 static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); /*proto*/

 /////////////// SwapException ///////////////

 static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) {
     PyObject *tmp_type, *tmp_value, *tmp_tb;
 #if CYTHON_COMPILING_IN_CPYTHON
     PyThreadState *tstate = PyThreadState_GET();

     tmp_type = tstate->exc_type;
     tmp_value = tstate->exc_value;
     tmp_tb = tstate->exc_traceback;

     tstate->exc_type = *type;
     tstate->exc_value = *value;
     tstate->exc_traceback = *tb;
 #else
     PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb);
     PyErr_SetExcInfo(*type, *value, *tb);
 #endif

     *type = tmp_type;
     *value = tmp_value;
     *tb = tmp_tb;
 }

 /////////////// WriteUnraisableException.proto ///////////////

 static void __Pyx_WriteUnraisable(const char *name, int clineno,
                                   int lineno, const char *filename,
                                   int full_traceback); /*proto*/

 /////////////// WriteUnraisableException ///////////////
 //@requires: PyErrFetchRestore

 static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno,
                                   CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename,
                                   int full_traceback) {
     PyObject *old_exc, *old_val, *old_tb;
     PyObject *ctx;
     __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
     if (full_traceback) {
         Py_XINCREF(old_exc);
         Py_XINCREF(old_val);
         Py_XINCREF(old_tb);
         __Pyx_ErrRestore(old_exc, old_val, old_tb);
         PyErr_PrintEx(1);
     }
     #if PY_MAJOR_VERSION < 3
     ctx = PyString_FromString(name);
     #else
     ctx = PyUnicode_FromString(name);
     #endif
     __Pyx_ErrRestore(old_exc, old_val, old_tb);
     if (!ctx) {
         PyErr_WriteUnraisable(Py_None);
     } else {
         PyErr_WriteUnraisable(ctx);
         Py_DECREF(ctx);
     }
 }

 /////////////// AddTraceback.proto ///////////////

 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename); /*proto*/

 /////////////// AddTraceback ///////////////
 //@requires: ModuleSetupCode.c::CodeObjectCache
 //@substitute: naming

 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"

 static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
             const char *funcname, int c_line,
             int py_line, const char *filename) {
     PyCodeObject *py_code = 0;
     PyObject *py_srcfile = 0;
     PyObject *py_funcname = 0;

     #if PY_MAJOR_VERSION < 3
     py_srcfile = PyString_FromString(filename);
     #else
     py_srcfile = PyUnicode_FromString(filename);
     #endif
     if (!py_srcfile) goto bad;
     if (c_line) {
         #if PY_MAJOR_VERSION < 3
         py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, $cfilenm_cname, c_line);
         #else
         py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, $cfilenm_cname, c_line);
         #endif
     }
     else {
         #if PY_MAJOR_VERSION < 3
         py_funcname = PyString_FromString(funcname);
         #else
         py_funcname = PyUnicode_FromString(funcname);
         #endif
     }
     if (!py_funcname) goto bad;
     py_code = __Pyx_PyCode_New(
         0,            /*int argcount,*/
         0,            /*int kwonlyargcount,*/
         0,            /*int nlocals,*/
         0,            /*int stacksize,*/
         0,            /*int flags,*/
         $empty_bytes, /*PyObject *code,*/
         $empty_tuple, /*PyObject *consts,*/
         $empty_tuple, /*PyObject *names,*/
         $empty_tuple, /*PyObject *varnames,*/
         $empty_tuple, /*PyObject *freevars,*/
         $empty_tuple, /*PyObject *cellvars,*/
         py_srcfile,   /*PyObject *filename,*/
         py_funcname,  /*PyObject *name,*/
         py_line,      /*int firstlineno,*/
         $empty_bytes  /*PyObject *lnotab*/
     );
     Py_DECREF(py_srcfile);
     Py_DECREF(py_funcname);
     return py_code;
 bad:
     Py_XDECREF(py_srcfile);
     Py_XDECREF(py_funcname);
     return NULL;
 }

 static void __Pyx_AddTraceback(const char *funcname, int c_line,
                                int py_line, const char *filename) {
     PyCodeObject *py_code = 0;
     PyObject *py_globals = 0;
     PyFrameObject *py_frame = 0;

     py_code = $global_code_object_cache_find(c_line ? c_line : py_line);
     if (!py_code) {
         py_code = __Pyx_CreateCodeObjectForTraceback(
             funcname, c_line, py_line, filename);
         if (!py_code) goto bad;
         $global_code_object_cache_insert(c_line ? c_line : py_line, py_code);
     }
     py_globals = PyModule_GetDict($module_cname);
     if (!py_globals) goto bad;
     py_frame = PyFrame_New(
         PyThreadState_GET(), /*PyThreadState *tstate,*/
         py_code,             /*PyCodeObject *code,*/
         py_globals,          /*PyObject *globals,*/
         0                    /*PyObject *locals*/
     );
     if (!py_frame) goto bad;
     py_frame->f_lineno = py_line;
     PyTraceBack_Here(py_frame);
 bad:
     Py_XDECREF(py_code);
     Py_XDECREF(py_frame);
 }
	// Exception raising code
	//
	// Exceptions are raised by __Pyx_Raise() and stored as plain
	// type/value/tb in PyThreadState->curexc_*. When being caught by an
	// 'except' statement, curexc_* is moved over to exc_* by
	// __Pyx_GetException()

	/////////////// PyErrFetchRestore.proto ///////////////

	static CYTHON_INLINE void __Pyx_ErrRestore(PyObject type, PyObject value, PyObject tb); /proto*/
	static CYTHON_INLINE void __Pyx_ErrFetch(PyObject type, PyObject value, PyObject *tb); /proto*/

	/////////////// PyErrFetchRestore ///////////////

	static CYTHON_INLINE void __Pyx_ErrRestore(PyObject type, PyObject value, PyObject *tb) {
	#if CYTHON_COMPILING_IN_CPYTHON
	PyObject tmp_type, tmp_value, *tmp_tb;
	PyThreadState *tstate = PyThreadState_GET();

	tmp_type = tstate->curexc_type;
	tmp_value = tstate->curexc_value;
	tmp_tb = tstate->curexc_traceback;
	tstate->curexc_type = type;
	tstate->curexc_value = value;
	tstate->curexc_traceback = tb;
	Py_XDECREF(tmp_type);
	Py_XDECREF(tmp_value);
	Py_XDECREF(tmp_tb);
	#else
	PyErr_Restore(type, value, tb);
	#endif
	}

	static CYTHON_INLINE void __Pyx_ErrFetch(PyObject type, PyObject value, PyObject **tb) {
	#if CYTHON_COMPILING_IN_CPYTHON
	PyThreadState *tstate = PyThreadState_GET();
	*type = tstate->curexc_type;
	*value = tstate->curexc_value;
	*tb = tstate->curexc_traceback;

	tstate->curexc_type = 0;
	tstate->curexc_value = 0;
	tstate->curexc_traceback = 0;
	#else
	PyErr_Fetch(type, value, tb);
	#endif
	}

	/////////////// RaiseException.proto ///////////////

	static void __Pyx_Raise(PyObject type, PyObject value, PyObject tb, PyObject cause); /proto/

	/////////////// RaiseException ///////////////
	//@requires: PyErrFetchRestore

	// The following function is based on do_raise() from ceval.c. There
	// are separate versions for Python2 and Python3 as exception handling
	// has changed quite a lot between the two versions.

	#if PY_MAJOR_VERSION < 3
	static void __Pyx_Raise(PyObject type, PyObject value, PyObject *tb,
	CYTHON_UNUSED PyObject *cause) {
	/* 'cause' is only used in Py3 */
	Py_XINCREF(type);
	if (!value \|\| value == Py_None)
	value = NULL;
	else
	Py_INCREF(value);

	if (!tb \|\| tb == Py_None)
	tb = NULL;
	else {
	Py_INCREF(tb);
	if (!PyTraceBack_Check(tb)) {
	PyErr_SetString(PyExc_TypeError,
	"raise: arg 3 must be a traceback or None");
	goto raise_error;
	}
	}

	#if PY_VERSION_HEX < 0x02050000
	if (PyClass_Check(type)) {
	#else
	if (PyType_Check(type)) {
	#endif
	/* instantiate the type now (we don't know when and how it will be caught) */
	#if CYTHON_COMPILING_IN_PYPY
	/* PyPy can't handle value == NULL */
	if (!value) {
	Py_INCREF(Py_None);
	value = Py_None;
	}
	#endif
	PyErr_NormalizeException(&type, &value, &tb);

	} else {
	/* Raising an instance. The value should be a dummy. */
	if (value) {
	PyErr_SetString(PyExc_TypeError,
	"instance exception may not have a separate value");
	goto raise_error;
	}
	/* Normalize to raise <class>, <instance> */
	value = type;
	#if PY_VERSION_HEX < 0x02050000
	if (PyInstance_Check(type)) {
	type = (PyObject) ((PyInstanceObject)type)->in_class;
	Py_INCREF(type);
	} else {
	type = 0;
	PyErr_SetString(PyExc_TypeError,
	"raise: exception must be an old-style class or instance");
	goto raise_error;
	}
	#else
	type = (PyObject*) Py_TYPE(type);
	Py_INCREF(type);
	if (!PyType_IsSubtype((PyTypeObject )type, (PyTypeObject )PyExc_BaseException)) {
	PyErr_SetString(PyExc_TypeError,
	"raise: exception class must be a subclass of BaseException");
	goto raise_error;
	}
	#endif
	}

	__Pyx_ErrRestore(type, value, tb);
	return;
	raise_error:
	Py_XDECREF(value);
	Py_XDECREF(type);
	Py_XDECREF(tb);
	return;
	}

	#else /* Python 3+ */

	static void __Pyx_Raise(PyObject type, PyObject value, PyObject tb, PyObject cause) {
	PyObject* owned_instance = NULL;
	if (tb == Py_None) {
	tb = 0;
	} else if (tb && !PyTraceBack_Check(tb)) {
	PyErr_SetString(PyExc_TypeError,
	"raise: arg 3 must be a traceback or None");
	goto bad;
	}
	if (value == Py_None)
	value = 0;

	if (PyExceptionInstance_Check(type)) {
	if (value) {
	PyErr_SetString(PyExc_TypeError,
	"instance exception may not have a separate value");
	goto bad;
	}
	value = type;
	type = (PyObject*) Py_TYPE(value);
	} else if (PyExceptionClass_Check(type)) {
	// make sure value is an exception instance of type
	PyObject *instance_class = NULL;
	if (value && PyExceptionInstance_Check(value)) {
	instance_class = (PyObject*) Py_TYPE(value);
	if (instance_class != type) {
	if (PyObject_IsSubclass(instance_class, type)) {
	// believe the instance
	type = instance_class;
	} else {
	instance_class = NULL;
	}
	}
	}
	if (!instance_class) {
	// instantiate the type now (we don't know when and how it will be caught)
	// assuming that 'value' is an argument to the type's constructor
	// not using PyErr_NormalizeException() to avoid ref-counting problems
	PyObject *args;
	if (!value)
	args = PyTuple_New(0);
	else if (PyTuple_Check(value)) {
	Py_INCREF(value);
	args = value;
	} else
	args = PyTuple_Pack(1, value);
	if (!args)
	goto bad;
	owned_instance = PyObject_Call(type, args, NULL);
	Py_DECREF(args);
	if (!owned_instance)
	goto bad;
	value = owned_instance;
	if (!PyExceptionInstance_Check(value)) {
	PyErr_Format(PyExc_TypeError,
	"calling %R should have returned an instance of "
	"BaseException, not %R",
	type, Py_TYPE(value));
	goto bad;
	}
	}
	} else {
	PyErr_SetString(PyExc_TypeError,
	"raise: exception class must be a subclass of BaseException");
	goto bad;
	}

	#if PY_VERSION_HEX >= 0x03030000
	if (cause) {
	#else
	if (cause && cause != Py_None) {
	#endif
	PyObject *fixed_cause;
	if (cause == Py_None) {
	// raise ... from None
	fixed_cause = NULL;
	} else if (PyExceptionClass_Check(cause)) {
	fixed_cause = PyObject_CallObject(cause, NULL);
	if (fixed_cause == NULL)
	goto bad;
	} else if (PyExceptionInstance_Check(cause)) {
	fixed_cause = cause;
	Py_INCREF(fixed_cause);
	} else {
	PyErr_SetString(PyExc_TypeError,
	"exception causes must derive from "
	"BaseException");
	goto bad;
	}
	PyException_SetCause(value, fixed_cause);
	}

	PyErr_SetObject(type, value);

	if (tb) {
	PyThreadState *tstate = PyThreadState_GET();
	PyObject* tmp_tb = tstate->curexc_traceback;
	if (tb != tmp_tb) {
	Py_INCREF(tb);
	tstate->curexc_traceback = tb;
	Py_XDECREF(tmp_tb);
	}
	}

	bad:
	Py_XDECREF(owned_instance);
	return;
	}
	#endif

	/////////////// GetException.proto ///////////////

	static int __Pyx_GetException(PyObject type, PyObject value, PyObject *tb); /proto*/

	/////////////// GetException ///////////////

	static int __Pyx_GetException(PyObject type, PyObject value, PyObject **tb) {
	PyObject local_type, local_value, *local_tb;
	#if CYTHON_COMPILING_IN_CPYTHON
	PyObject tmp_type, tmp_value, *tmp_tb;
	PyThreadState *tstate = PyThreadState_GET();
	local_type = tstate->curexc_type;
	local_value = tstate->curexc_value;
	local_tb = tstate->curexc_traceback;
	tstate->curexc_type = 0;
	tstate->curexc_value = 0;
	tstate->curexc_traceback = 0;
	#else
	PyErr_Fetch(&local_type, &local_value, &local_tb);
	#endif
	PyErr_NormalizeException(&local_type, &local_value, &local_tb);
	#if CYTHON_COMPILING_IN_CPYTHON
	if (unlikely(tstate->curexc_type))
	#else
	if (unlikely(PyErr_Occurred()))
	#endif
	goto bad;
	#if PY_MAJOR_VERSION >= 3
	if (local_tb) {
	if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
	goto bad;
	}
	#endif
	// traceback may be NULL for freshly raised exceptions
	Py_XINCREF(local_tb);
	// exception state may be temporarily empty in parallel loops (race condition)
	Py_XINCREF(local_type);
	Py_XINCREF(local_value);
	*type = local_type;
	*value = local_value;
	*tb = local_tb;
	#if CYTHON_COMPILING_IN_CPYTHON
	tmp_type = tstate->exc_type;
	tmp_value = tstate->exc_value;
	tmp_tb = tstate->exc_traceback;
	tstate->exc_type = local_type;
	tstate->exc_value = local_value;
	tstate->exc_traceback = local_tb;
	// Make sure tstate is in a consistent state when we XDECREF
	// these objects (DECREF may run arbitrary code).
	Py_XDECREF(tmp_type);
	Py_XDECREF(tmp_value);
	Py_XDECREF(tmp_tb);
	#else
	PyErr_SetExcInfo(local_type, local_value, local_tb);
	#endif
	return 0;
	bad:
	*type = 0;
	*value = 0;
	*tb = 0;
	Py_XDECREF(local_type);
	Py_XDECREF(local_value);
	Py_XDECREF(local_tb);
	return -1;
	}

	/////////////// ReRaiseException.proto ///////////////

	static CYTHON_INLINE void __Pyx_ReraiseException(void); /proto/

	/////////////// ReRaiseException.proto ///////////////

	static CYTHON_INLINE void __Pyx_ReraiseException(void) {
	PyObject type = NULL, value = NULL, *tb = NULL;
	#if CYTHON_COMPILING_IN_CPYTHON
	PyThreadState *tstate = PyThreadState_GET();
	type = tstate->exc_type;
	value = tstate->exc_value;
	tb = tstate->exc_traceback;
	#else
	PyErr_GetExcInfo(&type, &value, &tb);
	#endif
	if (!type \|\| type == Py_None) {
	#if !CYTHON_COMPILING_IN_CPYTHON
	Py_XDECREF(type);
	Py_XDECREF(value);
	Py_XDECREF(tb);
	#endif
	// message copied from Py3
	PyErr_SetString(PyExc_RuntimeError,
	"No active exception to reraise");
	} else {
	#if CYTHON_COMPILING_IN_CPYTHON
	Py_INCREF(type);
	Py_XINCREF(value);
	Py_XINCREF(tb);

	#endif
	PyErr_Restore(type, value, tb);
	}
	}

	/////////////// SaveResetException.proto ///////////////

	static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject type, PyObject value, PyObject *tb); /proto*/
	static void __Pyx_ExceptionReset(PyObject type, PyObject value, PyObject tb); /proto*/

	/////////////// SaveResetException ///////////////

	static CYTHON_INLINE void __Pyx_ExceptionSave(PyObject type, PyObject value, PyObject **tb) {
	#if CYTHON_COMPILING_IN_CPYTHON
	PyThreadState *tstate = PyThreadState_GET();
	*type = tstate->exc_type;
	*value = tstate->exc_value;
	*tb = tstate->exc_traceback;
	Py_XINCREF(*type);
	Py_XINCREF(*value);
	Py_XINCREF(*tb);
	#else
	PyErr_GetExcInfo(type, value, tb);
	#endif
	}

	static void __Pyx_ExceptionReset(PyObject type, PyObject value, PyObject *tb) {
	#if CYTHON_COMPILING_IN_CPYTHON
	PyObject tmp_type, tmp_value, *tmp_tb;
	PyThreadState *tstate = PyThreadState_GET();
	tmp_type = tstate->exc_type;
	tmp_value = tstate->exc_value;
	tmp_tb = tstate->exc_traceback;
	tstate->exc_type = type;
	tstate->exc_value = value;
	tstate->exc_traceback = tb;
	Py_XDECREF(tmp_type);
	Py_XDECREF(tmp_value);
	Py_XDECREF(tmp_tb);
	#else
	PyErr_SetExcInfo(type, value, tb);
	#endif
	}

	/////////////// SwapException.proto ///////////////

	static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject type, PyObject value, PyObject *tb); /proto*/

	/////////////// SwapException ///////////////

	static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject type, PyObject value, PyObject **tb) {
	PyObject tmp_type, tmp_value, *tmp_tb;
	#if CYTHON_COMPILING_IN_CPYTHON
	PyThreadState *tstate = PyThreadState_GET();

	tmp_type = tstate->exc_type;
	tmp_value = tstate->exc_value;
	tmp_tb = tstate->exc_traceback;

	tstate->exc_type = *type;
	tstate->exc_value = *value;
	tstate->exc_traceback = *tb;
	#else
	PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb);
	PyErr_SetExcInfo(type, value, *tb);
	#endif

	*type = tmp_type;
	*value = tmp_value;
	*tb = tmp_tb;
	}

	/////////////// WriteUnraisableException.proto ///////////////

	static void __Pyx_WriteUnraisable(const char *name, int clineno,
	int lineno, const char *filename,
	int full_traceback); /proto/

	/////////////// WriteUnraisableException ///////////////
	//@requires: PyErrFetchRestore

	static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno,
	CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename,
	int full_traceback) {
	PyObject old_exc, old_val, *old_tb;
	PyObject *ctx;
	__Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
	if (full_traceback) {
	Py_XINCREF(old_exc);
	Py_XINCREF(old_val);
	Py_XINCREF(old_tb);
	__Pyx_ErrRestore(old_exc, old_val, old_tb);
	PyErr_PrintEx(1);
	}
	#if PY_MAJOR_VERSION < 3
	ctx = PyString_FromString(name);
	#else
	ctx = PyUnicode_FromString(name);
	#endif
	__Pyx_ErrRestore(old_exc, old_val, old_tb);
	if (!ctx) {
	PyErr_WriteUnraisable(Py_None);
	} else {
	PyErr_WriteUnraisable(ctx);
	Py_DECREF(ctx);
	}
	}

	/////////////// AddTraceback.proto ///////////////

	static void __Pyx_AddTraceback(const char *funcname, int c_line,
	int py_line, const char filename); /proto*/

	/////////////// AddTraceback ///////////////
	//@requires: ModuleSetupCode.c::CodeObjectCache
	//@substitute: naming

	#include "compile.h"
	#include "frameobject.h"
	#include "traceback.h"

	static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
	const char *funcname, int c_line,
	int py_line, const char *filename) {
	PyCodeObject *py_code = 0;
	PyObject *py_srcfile = 0;
	PyObject *py_funcname = 0;

	#if PY_MAJOR_VERSION < 3
	py_srcfile = PyString_FromString(filename);
	#else
	py_srcfile = PyUnicode_FromString(filename);
	#endif
	if (!py_srcfile) goto bad;
	if (c_line) {
	#if PY_MAJOR_VERSION < 3
	py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, $cfilenm_cname, c_line);
	#else
	py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, $cfilenm_cname, c_line);
	#endif
	}
	else {
	#if PY_MAJOR_VERSION < 3
	py_funcname = PyString_FromString(funcname);
	#else
	py_funcname = PyUnicode_FromString(funcname);
	#endif
	}
	if (!py_funcname) goto bad;
	py_code = __Pyx_PyCode_New(
	0, /int argcount,/
	0, /int kwonlyargcount,/
	0, /int nlocals,/
	0, /int stacksize,/
	0, /int flags,/
	$empty_bytes, /PyObject code,*/
	$empty_tuple, /PyObject consts,*/
	$empty_tuple, /PyObject names,*/
	$empty_tuple, /PyObject varnames,*/
	$empty_tuple, /PyObject freevars,*/
	$empty_tuple, /PyObject cellvars,*/
	py_srcfile, /PyObject filename,*/
	py_funcname, /PyObject name,*/
	py_line, /int firstlineno,/
	$empty_bytes /PyObject lnotab*/
	);
	Py_DECREF(py_srcfile);
	Py_DECREF(py_funcname);
	return py_code;
	bad:
	Py_XDECREF(py_srcfile);
	Py_XDECREF(py_funcname);
	return NULL;
	}

	static void __Pyx_AddTraceback(const char *funcname, int c_line,
	int py_line, const char *filename) {
	PyCodeObject *py_code = 0;
	PyObject *py_globals = 0;
	PyFrameObject *py_frame = 0;

	py_code = $global_code_object_cache_find(c_line ? c_line : py_line);
	if (!py_code) {
	py_code = __Pyx_CreateCodeObjectForTraceback(
	funcname, c_line, py_line, filename);
	if (!py_code) goto bad;
	$global_code_object_cache_insert(c_line ? c_line : py_line, py_code);
	}
	py_globals = PyModule_GetDict($module_cname);
	if (!py_globals) goto bad;
	py_frame = PyFrame_New(
	PyThreadState_GET(), /PyThreadState tstate,*/
	py_code, /PyCodeObject code,*/
	py_globals, /PyObject globals,*/
	0 /PyObject locals*/
	);
	if (!py_frame) goto bad;
	py_frame->f_lineno = py_line;
	PyTraceBack_Here(py_frame);
	bad:
	Py_XDECREF(py_code);
	Py_XDECREF(py_frame);
	}