static void Struct_tp_dealloc(PyObject *self) { PyObject *et, *ev, *etb, *key; dbus_py_variant_level_clear(self); PyErr_Fetch(&et, &ev, &etb); key = PyLong_FromVoidPtr(self); if (key) { if (PyDict_GetItem(struct_signatures, key)) { if (PyDict_DelItem(struct_signatures, key) < 0) { /* should never happen */ PyErr_WriteUnraisable(self); } } Py_CLEAR(key); } else { /* not enough memory to free all the memory... leak the signature, * there's not much else we could do here */ PyErr_WriteUnraisable(self); } PyErr_Restore(et, ev, etb); (PyTuple_Type.tp_dealloc)(self); }
static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback, CYTHON_UNUSED int nogil) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; #ifdef WITH_THREAD PyGILState_STATE state; if (nogil) state = PyGILState_Ensure(); #endif __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); } #ifdef WITH_THREAD if (nogil) PyGILState_Release(state); #endif }
void _PyGC_Fini(void) { if (!(debug & DEBUG_SAVEALL) && garbage != NULL && PyList_GET_SIZE(garbage) > 0) { char *message; if (debug & DEBUG_UNCOLLECTABLE) message = "gc: %zd uncollectable objects at " \ "shutdown"; else message = "gc: %zd uncollectable objects at " \ "shutdown; use gc.set_debug(gc.DEBUG_UNCOLLECTABLE) to list them"; if (PyErr_WarnFormat(PyExc_ResourceWarning, 0, message, PyList_GET_SIZE(garbage)) < 0) PyErr_WriteUnraisable(NULL); if (debug & DEBUG_UNCOLLECTABLE) { PyObject *repr = NULL, *bytes = NULL; repr = PyObject_Repr(garbage); if (!repr || !(bytes = PyUnicode_EncodeFSDefault(repr))) PyErr_WriteUnraisable(garbage); else { PySys_WriteStderr( " %s\n", PyBytes_AS_STRING(bytes) ); } Py_XDECREF(repr); Py_XDECREF(bytes); } } }
static PY_LONG_LONG CallExternalTimer(ProfilerObject *pObj) { PY_LONG_LONG result; PyObject *o = PyObject_Call(pObj->externalTimer, empty_tuple, NULL); if (o == NULL) { PyErr_WriteUnraisable(pObj->externalTimer); return 0; } if (pObj->externalTimerUnit > 0.0) { /* interpret the result as an integer that will be scaled in profiler_getstats() */ result = PyLong_AsLongLong(o); } else { /* interpret the result as a double measured in seconds. As the profiler works with PY_LONG_LONG internally we convert it to a large integer */ double val = PyFloat_AsDouble(o); /* error handling delayed to the code below */ result = (PY_LONG_LONG) (val * DOUBLE_TIMER_PRECISION); } Py_DECREF(o); if (PyErr_Occurred()) { PyErr_WriteUnraisable(pObj->externalTimer); return 0; } return result; }
long Call_GetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) { PyObject *mod, *func, *result; long retval; static PyObject *context; if (context == NULL) context = PyUnicode_InternFromString("_ctypes.DllGetClassObject"); mod = PyImport_ImportModuleNoBlock("ctypes"); if (!mod) { PyErr_WriteUnraisable(context ? context : Py_None); /* There has been a warning before about this already */ return E_FAIL; } func = PyObject_GetAttrString(mod, "DllGetClassObject"); Py_DECREF(mod); if (!func) { PyErr_WriteUnraisable(context ? context : Py_None); return E_FAIL; } { PyObject *py_rclsid = PyLong_FromVoidPtr((void *)rclsid); PyObject *py_riid = PyLong_FromVoidPtr((void *)riid); PyObject *py_ppv = PyLong_FromVoidPtr(ppv); if (!py_rclsid || !py_riid || !py_ppv) { Py_XDECREF(py_rclsid); Py_XDECREF(py_riid); Py_XDECREF(py_ppv); Py_DECREF(func); PyErr_WriteUnraisable(context ? context : Py_None); return E_FAIL; } result = PyObject_CallFunctionObjArgs(func, py_rclsid, py_riid, py_ppv, NULL); Py_DECREF(py_rclsid); Py_DECREF(py_riid); Py_DECREF(py_ppv); } Py_DECREF(func); if (!result) { PyErr_WriteUnraisable(context ? context : Py_None); return E_FAIL; } retval = PyLong_AsLong(result); if (PyErr_Occurred()) { PyErr_WriteUnraisable(context ? context : Py_None); retval = E_FAIL; } Py_DECREF(result); return retval; }
static void query_cname_cb(void *arg, int status,int timeouts, unsigned char *answer_buf, int answer_len) { PyGILState_STATE gstate = PyGILState_Ensure(); int parse_status; struct hostent *hostent = NULL; PyObject *dns_result, *errorno, *tmp, *result, *callback; callback = (PyObject *)arg; ASSERT(callback); if (status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } parse_status = ares_parse_a_reply(answer_buf, answer_len, &hostent, NULL, NULL); if (parse_status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)parse_status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } dns_result = PyList_New(0); if (!dns_result) { PyErr_NoMemory(); PyErr_WriteUnraisable(Py_None); errorno = PyInt_FromLong((long)ARES_ENOMEM); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } tmp = Py_BuildValue("s", hostent->h_name); PyList_Append(dns_result, tmp); Py_DECREF(tmp); errorno = Py_None; Py_INCREF(Py_None); callback: result = PyObject_CallFunctionObjArgs(callback, dns_result, errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(callback); } Py_XDECREF(result); Py_DECREF(dns_result); Py_DECREF(errorno); if (hostent) { ares_free_hostent(hostent); } Py_DECREF(callback); PyGILState_Release(gstate); }
static void nameinfo_cb(void *arg, int status, int timeouts, char *node, char *service) { PyGILState_STATE gstate = PyGILState_Ensure(); PyObject *callback, *errorno, *dns_node, *dns_service, *dns_result, *result; callback = (PyObject *)arg; ASSERT(callback); if (status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } dns_result = PyStructSequence_New(&AresNameinfoResultType); if (!dns_result) { PyErr_NoMemory(); PyErr_WriteUnraisable(Py_None); errorno = PyInt_FromLong((long)ARES_ENOMEM); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } dns_node = Py_BuildValue("s", node); if (service) { dns_service = Py_BuildValue("s", service); } else { dns_service = Py_None; Py_INCREF(Py_None); } PyStructSequence_SET_ITEM(dns_result, 0, dns_node); PyStructSequence_SET_ITEM(dns_result, 1, dns_service); errorno = Py_None; Py_INCREF(Py_None); callback: result = PyObject_CallFunctionObjArgs(callback, dns_result, errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(callback); } Py_XDECREF(result); Py_DECREF(dns_result); Py_DECREF(errorno); Py_DECREF(callback); PyGILState_Release(gstate); }
static int music_delivery(sp_session * session, const sp_audioformat * format, const void *frames, int num_frames) { /* TODO: This is called _all_ the time, make it faster? */ // Note that we do not try to shoe horn this into session_callback as it is // quite different in that this needs to handle return values and much more // complicated arguments. debug_printf(">> music_delivery called: frames %d", num_frames); int consumed = num_frames; // assume all consumed int size = frame_size(format); PyObject *callback, *client, *py_frames, *py_session, *result; PyGILState_STATE gstate = PyGILState_Ensure(); /* TODO: check if session creations succeeds. */ py_frames = PyBuffer_FromMemory((void *)frames, num_frames * size); py_session = Session_FromSpotify(session); /* TODO: check if callback get succeeds. */ client = (PyObject *)sp_session_userdata(session); callback = PyObject_GetAttrString(client, "music_delivery"); result = PyObject_CallFunction(callback, "NNiiiii", py_session, py_frames, size, num_frames, format->sample_type, format->sample_rate, format->channels); if (result == NULL) PyErr_WriteUnraisable(callback); else { if (PyInt_Check(result)) consumed = (int)PyInt_AsLong(result); else if (PyLong_Check(result)) consumed = (int)PyLong_AsLong(result); else { PyErr_SetString(PyExc_TypeError, "music_delivery must return an integer"); PyErr_WriteUnraisable(callback); } Py_DECREF(result); } Py_XDECREF(callback); PyGILState_Release(gstate); return consumed; }
NUITKA_MAY_BE_UNUSED static bool EXCEPTION_MATCH_GENERATOR( PyObject *exception_value ) { CHECK_OBJECT( exception_value ); // We need to check the class. if ( PyExceptionInstance_Check( exception_value ) ) { exception_value = PyExceptionInstance_Class( exception_value ); } // Lets be optimistic. If it matches, we would be wasting our time. if ( exception_value == PyExc_GeneratorExit || exception_value == PyExc_StopIteration ) { return true; } if ( PyExceptionClass_Check( exception_value ) ) { // Save the current exception, if any, we must preserve it. PyObject *save_exception_type, *save_exception_value; PyTracebackObject *save_exception_tb; FETCH_ERROR_OCCURRED( &save_exception_type, &save_exception_value, &save_exception_tb ); int res = PyObject_IsSubclass( exception_value, PyExc_GeneratorExit ); // This function must not fail, so print the error here */ if (unlikely( res == -1 )) { PyErr_WriteUnraisable( exception_value ); } if (res == 1) return true; res = PyObject_IsSubclass( exception_value, PyExc_StopIteration ); // This function must not fail, so print the error here */ if (unlikely( res == -1 )) { PyErr_WriteUnraisable( exception_value ); } RESTORE_ERROR_OCCURRED( save_exception_type, save_exception_value, save_exception_tb ); return res == 1; } return false; }
static int flush_std_files(void) { PyObject *fout = _PySys_GetObjectId(&PyId_stdout); PyObject *ferr = _PySys_GetObjectId(&PyId_stderr); PyObject *tmp; int status = 0; if (fout != NULL && fout != Py_None && !file_is_closed(fout)) { tmp = _PyObject_CallMethodId(fout, &PyId_flush, ""); if (tmp == NULL) { PyErr_WriteUnraisable(fout); status = -1; } else Py_DECREF(tmp); } if (ferr != NULL && ferr != Py_None && !file_is_closed(ferr)) { tmp = _PyObject_CallMethodId(ferr, &PyId_flush, ""); if (tmp == NULL) { PyErr_Clear(); status = -1; } else Py_DECREF(tmp); } return status; }
// This helper function is used by gen_close and gen_throw to // close a subiterator being delegated to by yield-from. static int __Pyx_Generator_CloseIter(__pyx_GeneratorObject *gen, PyObject *yf) { PyObject *retval = NULL; int err = 0; if (__Pyx_Generator_CheckExact(yf)) { retval = __Pyx_Generator_Close(yf); if (!retval) return -1; } else { PyObject *meth; gen->is_running = 1; meth = PyObject_GetAttrString(yf, "close"); if (unlikely(!meth)) { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_WriteUnraisable(yf); } PyErr_Clear(); } else { retval = PyObject_CallFunction(meth, NULL); Py_DECREF(meth); if (!retval) err = -1; } gen->is_running = 0; } Py_XDECREF(retval); return err; }
/** * \ingroup python_interface_filehandle * \brief Destroys the file handle object. */ void igraphmodule_filehandle_destroy(igraphmodule_filehandle_t* handle) { PyObject *exc_type = 0, *exc_value = 0, *exc_traceback = 0; if (handle->fp != 0) { fflush(handle->fp); if (handle->need_close && !handle->object) { fclose(handle->fp); } } handle->fp = 0; if (handle->object != 0) { /* PyFile_Close might mess up the stored exception, so let's * store the current exception state and restore it */ PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); if (handle->need_close) { if (PyFile_Close(handle->object)) { PyErr_WriteUnraisable(Py_None); } } Py_DECREF(handle->object); PyErr_Restore(exc_type, exc_value, exc_traceback); exc_type = exc_value = exc_traceback = 0; handle->object = 0; } handle->need_close = 0; }
static void notify_main_thread(sp_session * session) { PyGILState_STATE gstate; PyObject *res, *method; #ifdef DEBUG fprintf(stderr, "[DEBUG]-session- >> notify_main_thread called\n"); #endif if (!session_constructed) return; gstate = PyGILState_Ensure(); Session *psession = (Session *) PyObject_CallObject((PyObject *)&SessionType, NULL); psession->_session = session; PyObject *client = (PyObject *)sp_session_userdata(session); if (client != NULL) { method = PyObject_GetAttrString(client, "wake"); res = PyObject_CallFunctionObjArgs(method, psession, NULL); if (!res) PyErr_WriteUnraisable(method); Py_XDECREF(res); Py_DECREF(method); } Py_DECREF(psession); PyGILState_Release(gstate); }
static int gen_close_iter(PyObject *yf) { PyObject *retval = NULL; _Py_IDENTIFIER(close); if (PyGen_CheckExact(yf)) { retval = gen_close((PyGenObject *)yf, NULL); if (retval == NULL) return -1; } else { PyObject *meth = _PyObject_GetAttrId(yf, &PyId_close); if (meth == NULL) { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) PyErr_WriteUnraisable(yf); PyErr_Clear(); } else { retval = PyObject_CallFunction(meth, ""); Py_DECREF(meth); if (retval == NULL) return -1; } } Py_XDECREF(retval); return 0; }
static void ares__sock_state_cb(void *data, ares_socket_t socket_fd, int readable, int writable) { PyGILState_STATE gstate = PyGILState_Ensure(); Channel *self; PyObject *result, *fd, *py_readable, *py_writable; self = (Channel *)data; ASSERT(self); /* Object could go out of scope in the callback, increase refcount to avoid it */ Py_INCREF(self); fd = PyInt_FromLong((long)socket_fd); py_readable = PyBool_FromLong((long)readable); py_writable = PyBool_FromLong((long)writable); result = PyObject_CallFunctionObjArgs(self->sock_state_cb, fd, py_readable, py_writable, NULL); if (result == NULL) { PyErr_WriteUnraisable(self->sock_state_cb); } Py_XDECREF(result); Py_DECREF(fd); Py_DECREF(py_readable); Py_DECREF(py_writable); Py_DECREF(self); PyGILState_Release(gstate); }
DEFINEFN void psyco_flog(char* msg, ...) { va_list vargs; PyObject* s; PyObject* r; PyObject *etype, *evalue, *etb; extra_assert(psyco_logger != NULL); PyErr_Fetch(&etype, &evalue, &etb); #ifdef HAVE_STDARG_PROTOTYPES va_start(vargs, msg); #else va_start(vargs); #endif s = PyString_FromFormatV(msg, vargs); va_end(vargs); if (s == NULL) OUT_OF_MEMORY(); r = PyObject_CallFunction(psyco_logger, "O", s); if (r == NULL) PyErr_WriteUnraisable(psyco_logger); else Py_DECREF(r); Py_DECREF(s); PyErr_Restore(etype, evalue, etb); }
static int publickey_sign_callback(LIBSSH2_SESSION *session, unsigned char **sig, size_t *sig_len, const unsigned char *data, size_t data_len, void **abstract) { PyObject *callback = (PyObject *) *abstract; PyObject *rv; PyGILState_STATE gstate = PyGILState_Ensure(); char *s; int ret = -1; #if PY_MAJOR_VERSION < 3 rv = PyObject_CallFunction(callback, "s#", data, data_len); #else rv = PyObject_CallFunction(callback, "y#", data, data_len); #endif if (rv == NULL) goto failure; ret = PyBytes_AsStringAndSize(rv, &s, (Py_ssize_t *) sig_len); Py_DECREF(rv); if (ret == 0) { *sig = (unsigned char*) strndup(s, *sig_len); goto exit; } failure: PyErr_WriteUnraisable(callback); exit: PyGILState_Release(gstate); return ret; }
static void log_message(sp_session * session, const char *data) { PyGILState_STATE gstate; PyObject *res, *method, *msg; #ifdef DEBUG fprintf(stderr, "[DEBUG]-session- >> log message: %s\n", data); #endif gstate = PyGILState_Ensure(); Session *psession = (Session *) PyObject_CallObject((PyObject *)&SessionType, NULL); psession->_session = session; PyObject *client = (PyObject *)sp_session_userdata(session); msg = PyUnicode_FromString(data); method = PyObject_GetAttrString(client, "log_message"); res = PyObject_CallFunctionObjArgs(method, psession, msg, NULL); if (!res) PyErr_WriteUnraisable(method); Py_DECREF(psession); Py_XDECREF(res); Py_DECREF(msg); Py_DECREF(method); PyGILState_Release(gstate); }
static void gen_del(PyObject *self) { PyObject *res; PyObject *error_type, *error_value, *error_traceback; PyGenObject *gen = (PyGenObject *)self; if (gen->gi_frame == NULL || gen->gi_frame->f_stacktop == NULL) /* Generator isn't paused, so no need to close */ return; /* Temporarily resurrect the object. */ assert(self->ob_refcnt == 0); self->ob_refcnt = 1; /* Save the current exception, if any. */ PyErr_Fetch(&error_type, &error_value, &error_traceback); res = gen_close(gen, NULL); if (res == NULL) PyErr_WriteUnraisable(self); else Py_DECREF(res); /* Restore the saved exception. */ PyErr_Restore(error_type, error_value, error_traceback); /* Undo the temporary resurrection; can't use DECREF here, it would * cause a recursive call. */ assert(self->ob_refcnt > 0); if (--self->ob_refcnt == 0) return; /* this is the normal path out */ /* close() resurrected it! Make it look like the original Py_DECREF * never happened. */ { Py_ssize_t refcnt = self->ob_refcnt; _Py_NewReference(self); self->ob_refcnt = refcnt; } assert(PyType_IS_GC(self->ob_type) && _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so * we need to undo that. */ _Py_DEC_REFTOTAL; /* If Py_TRACE_REFS, _Py_NewReference re-added self to the object * chain, so no more to do there. * If COUNT_ALLOCS, the original decref bumped tp_frees, and * _Py_NewReference bumped tp_allocs: both of those need to be * undone. */ #ifdef COUNT_ALLOCS --self->ob_type->tp_frees; --self->ob_type->tp_allocs; #endif }
static void Nuitka_Generator_tp_del( struct Nuitka_GeneratorObject *generator ) { if ( generator->m_status != status_Running ) { return; } PyObject *error_type, *error_value; PyTracebackObject *error_traceback; FETCH_ERROR_OCCURRED( &error_type, &error_value, &error_traceback ); PyObject *close_result = Nuitka_Generator_close( generator, NULL ); if (unlikely( close_result == NULL )) { PyErr_WriteUnraisable( (PyObject *)generator ); } else { Py_DECREF( close_result ); } /* Restore the saved exception if any. */ RESTORE_ERROR_OCCURRED( error_type, error_value, error_traceback ); }
static void on_pipe_connection(uv_stream_t* server, int status) { PyGILState_STATE gstate = PyGILState_Ensure(); Pipe *self; PyObject *result, *py_errorno; ASSERT(server); self = (Pipe *)server->data; ASSERT(self); /* Object could go out of scope in the callback, increase refcount to avoid it */ Py_INCREF(self); if (status != 0) { uv_err_t err = uv_last_error(UV_HANDLE_LOOP(self)); py_errorno = PyInt_FromLong((long)err.code); } else { py_errorno = Py_None; Py_INCREF(Py_None); } result = PyObject_CallFunctionObjArgs(self->on_new_connection_cb, self, py_errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(self->on_new_connection_cb); } Py_XDECREF(result); Py_DECREF(py_errorno); Py_DECREF(self); PyGILState_Release(gstate); }
static void connection_error(sp_session * session, sp_error error) { PyGILState_STATE gstate; PyObject *res, *err, *method; #ifdef DEBUG fprintf(stderr, "[DEBUG]-session- >> connection_error called\n"); #endif gstate = PyGILState_Ensure(); Session *psession = (Session *) PyObject_CallObject((PyObject *)&SessionType, NULL); psession->_session = session; PyObject *client = (PyObject *)sp_session_userdata(session); err = error_message(error); method = PyObject_GetAttrString(client, "connection_error"); res = PyObject_CallFunctionObjArgs(method, psession, err, NULL); if (!res) PyErr_WriteUnraisable(method); Py_DECREF(psession); Py_DECREF(err); Py_XDECREF(res); Py_DECREF(method); PyGILState_Release(gstate); }
static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); #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); } }
static void __Pyx_WriteUnraisable(char *name) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; PyErr_Fetch(&old_exc, &old_val, &old_tb); ctx = PyString_FromString(name); PyErr_Restore(old_exc, old_val, old_tb); if (!ctx) ctx = Py_None; PyErr_WriteUnraisable(ctx); }
/* Note that there's an inlined copy-paste of handle_callback() in gcmodule.c's * handle_weakrefs(). */ static void handle_callback(PyWeakReference *ref, PyObject *callback) { PyObject *cbresult = PyObject_CallFunction(callback, "O", ref); if (cbresult == NULL) PyErr_WriteUnraisable(callback); else Py_DECREF(cbresult); }
static int music_delivery(sp_session * session, const sp_audioformat * format, const void *frames, int num_frames) { PyGILState_STATE gstate; PyObject *res, *method; #ifdef DEBUG fprintf(stderr, "[DEBUG]-session- >> music_delivery called\n"); #endif gstate = PyGILState_Ensure(); int siz = frame_size(format); PyObject *pyframes = PyBuffer_FromMemory((void *)frames, num_frames * siz); Session *psession = (Session *) PyObject_CallObject((PyObject *)&SessionType, NULL); psession->_session = session; PyObject *client = (PyObject *)sp_session_userdata(session); method = PyObject_GetAttrString(client, "music_delivery"); res = PyObject_CallFunction(method, "OOiiiii", psession, pyframes, siz, num_frames, format->sample_type, format->sample_rate, format->channels); int consumed = num_frames; // assume all consumed if (!res) PyErr_WriteUnraisable(method); if (PyInt_Check(res)) consumed = (int)PyInt_AsLong(res); else if (PyLong_Check(res)) consumed = (int)PyLong_AsLong(res); else { PyErr_SetString(PyExc_TypeError, "music_delivery must return an integer"); PyErr_WriteUnraisable(method); } Py_DECREF(pyframes); Py_DECREF(psession); Py_XDECREF(res); Py_DECREF(method); PyGILState_Release(gstate); return consumed; }
static void __pyx_tp_dealloc_17_pymfclib_winhttp_WinHTTPSession(PyObject *o) { { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); ++o->ob_refcnt; __pyx_f_17_pymfclib_winhttp_14WinHTTPSession___dealloc__(o); if (PyErr_Occurred()) PyErr_WriteUnraisable(o); --o->ob_refcnt; PyErr_Restore(etype, eval, etb); } (*o->ob_type->tp_free)(o); }
static void __pyx_tp_dealloc_10pyk8055lib_K8055LibClass(PyObject *o) { { PyObject *etype, *eval, *etb; PyErr_Fetch(&etype, &eval, &etb); ++o->ob_refcnt; __pyx_f_10pyk8055lib_13K8055LibClass___dealloc__(o); if (PyErr_Occurred()) PyErr_WriteUnraisable(o); --o->ob_refcnt; PyErr_Restore(etype, eval, etb); } (*o->ob_type->tp_free)(o); }
long Call_CanUnloadNow(void) { PyObject *mod, *func, *result; long retval; static PyObject *context; if (context == NULL) context = PyUnicode_InternFromString("_ctypes.DllCanUnloadNow"); mod = PyImport_ImportModuleNoBlock("ctypes"); if (!mod) { /* OutputDebugString("Could not import ctypes"); */ /* We assume that this error can only occur when shutting down, so we silently ignore it */ PyErr_Clear(); return E_FAIL; } /* Other errors cannot be raised, but are printed to stderr */ func = PyObject_GetAttrString(mod, "DllCanUnloadNow"); Py_DECREF(mod); if (!func) { PyErr_WriteUnraisable(context ? context : Py_None); return E_FAIL; } result = PyObject_CallFunction(func, NULL); Py_DECREF(func); if (!result) { PyErr_WriteUnraisable(context ? context : Py_None); return E_FAIL; } retval = PyLong_AsLong(result); if (PyErr_Occurred()) { PyErr_WriteUnraisable(context ? context : Py_None); retval = E_FAIL; } Py_DECREF(result); return retval; }
static void Nuitka_Generator_tp_dealloc( struct Nuitka_GeneratorObject *generator ) { // Revive temporarily. assert( Py_REFCNT( generator ) == 0 ); Py_REFCNT( generator ) = 1; // Save the current exception, if any, we must preserve it. PyObject *save_exception_type, *save_exception_value; PyTracebackObject *save_exception_tb; FETCH_ERROR_OCCURRED( &save_exception_type, &save_exception_value, &save_exception_tb ); if ( generator->m_status == status_Running ) { PyObject *close_result = Nuitka_Generator_close( generator, NULL ); if (unlikely( close_result == NULL )) { PyErr_WriteUnraisable( (PyObject *)generator ); } else { Py_DECREF( close_result ); } } Nuitka_Generator_release_closure( generator ); Py_XDECREF( generator->m_frame ); assert( Py_REFCNT( generator ) == 1 ); Py_REFCNT( generator ) = 0; releaseFiber( &generator->m_yielder_context ); // Now it is safe to release references and memory for it. Nuitka_GC_UnTrack( generator ); if ( generator->m_weakrefs != NULL ) { PyObject_ClearWeakRefs( (PyObject *)generator ); assert( !ERROR_OCCURRED() ); } Py_DECREF( generator->m_name ); #if PYTHON_VERSION >= 350 Py_DECREF( generator->m_qualname ); #endif PyObject_GC_Del( generator ); RESTORE_ERROR_OCCURRED( save_exception_type, save_exception_value, save_exception_tb ); }