static void
FutureObj_finalize(FutureObj *fut)
{
- PyObject *error_type, *error_value, *error_traceback;
PyObject *context;
PyObject *message = NULL;
PyObject *func;
fut->fut_log_tb = 0;
/* Save the current exception, if any. */
- PyErr_Fetch(&error_type, &error_value, &error_traceback);
+ PyObject *exc = PyErr_GetRaisedException();
context = PyDict_New();
if (context == NULL) {
Py_XDECREF(message);
/* Restore the saved exception. */
- PyErr_Restore(error_type, error_value, error_traceback);
+ PyErr_SetRaisedException(exc);
}
static PyMethodDef FutureType_methods[] = {
PyObject *context;
PyObject *message = NULL;
PyObject *func;
- PyObject *error_type, *error_value, *error_traceback;
if (task->task_state != STATE_PENDING || !task->task_log_destroy_pending) {
goto done;
}
/* Save the current exception, if any. */
- PyErr_Fetch(&error_type, &error_value, &error_traceback);
+ PyObject *exc = PyErr_GetRaisedException();
context = PyDict_New();
if (context == NULL) {
Py_XDECREF(message);
/* Restore the saved exception. */
- PyErr_Restore(error_type, error_value, error_traceback);
+ PyErr_SetRaisedException(exc);
done:
FutureObj_finalize((FutureObj*)task);
}
if (gen_status == PYGEN_RETURN || gen_status == PYGEN_ERROR) {
- PyObject *et, *ev, *tb;
-
if (result != NULL) {
/* The error is StopIteration and that means that
the underlying coroutine has resolved */
if (PyErr_ExceptionMatches(state->asyncio_CancelledError)) {
/* CancelledError */
- PyErr_Fetch(&et, &ev, &tb);
- assert(et);
- PyErr_NormalizeException(&et, &ev, &tb);
- if (tb != NULL) {
- PyException_SetTraceback(ev, tb);
- Py_DECREF(tb);
- }
- Py_XDECREF(et);
+
+ PyObject *exc = PyErr_GetRaisedException();
+ assert(exc);
FutureObj *fut = (FutureObj*)task;
/* transfer ownership */
- fut->fut_cancelled_exc = ev;
+ fut->fut_cancelled_exc = exc;
return future_cancel(state, fut, NULL);
}
/* Some other exception; pop it and call Task.set_exception() */
- PyErr_Fetch(&et, &ev, &tb);
- assert(et);
- PyErr_NormalizeException(&et, &ev, &tb);
- if (tb != NULL) {
- PyException_SetTraceback(ev, tb);
- }
+ PyObject *exc = PyErr_GetRaisedException();
+ assert(exc);
- o = future_set_exception(state, (FutureObj*)task, ev);
+ o = future_set_exception(state, (FutureObj*)task, exc);
if (!o) {
/* An exception in Task.set_exception() */
- Py_DECREF(et);
- Py_XDECREF(tb);
- Py_XDECREF(ev);
+ Py_DECREF(exc);
goto fail;
}
assert(o == Py_None);
Py_DECREF(o);
- if (PyErr_GivenExceptionMatches(et, PyExc_KeyboardInterrupt) ||
- PyErr_GivenExceptionMatches(et, PyExc_SystemExit))
+ if (PyErr_GivenExceptionMatches(exc, PyExc_KeyboardInterrupt) ||
+ PyErr_GivenExceptionMatches(exc, PyExc_SystemExit))
{
/* We've got a KeyboardInterrupt or a SystemError; re-raise it */
- PyErr_Restore(et, ev, tb);
+ PyErr_SetRaisedException(exc);
goto fail;
}
- Py_DECREF(et);
- Py_XDECREF(tb);
- Py_XDECREF(ev);
+ Py_DECREF(exc);
Py_RETURN_NONE;
}
res = task_step_impl(state, task, exc);
if (res == NULL) {
- PyObject *et, *ev, *tb;
- PyErr_Fetch(&et, &ev, &tb);
+ PyObject *exc = PyErr_GetRaisedException();
leave_task(state, task->task_loop, (PyObject*)task);
- _PyErr_ChainExceptions(et, ev, tb); /* Normalizes (et, ev, tb) */
+ _PyErr_ChainExceptions1(exc);
return NULL;
}
else {
static PyObject *
task_wakeup(TaskObj *task, PyObject *o)
{
- PyObject *et, *ev, *tb;
PyObject *result;
assert(o);
/* exception raised */
}
- PyErr_Fetch(&et, &ev, &tb);
- assert(et);
- PyErr_NormalizeException(&et, &ev, &tb);
- if (tb != NULL) {
- PyException_SetTraceback(ev, tb);
- }
+ PyObject *exc = PyErr_GetRaisedException();
+ assert(exc);
- result = task_step(state, task, ev);
+ result = task_step(state, task, exc);
- Py_DECREF(et);
- Py_XDECREF(tb);
- Py_XDECREF(ev);
+ Py_DECREF(exc);
return result;
}
error:
if (result != NULL) {
- PyObject *exc, *val, *tb, *close_result;
- PyErr_Fetch(&exc, &val, &tb);
- close_result = PyObject_CallMethodNoArgs(result, &_Py_ID(close));
- _PyErr_ChainExceptions(exc, val, tb);
+ PyObject *exc = PyErr_GetRaisedException();
+ PyObject *close_result = PyObject_CallMethodNoArgs(result, &_Py_ID(close));
+ _PyErr_ChainExceptions1(exc);
Py_XDECREF(close_result);
Py_DECREF(result);
}
static PyObject *
buffered_close(buffered *self, PyObject *args)
{
- PyObject *res = NULL, *exc = NULL, *val, *tb;
+ PyObject *res = NULL;
int r;
CHECK_INITIALIZED(self)
- if (!ENTER_BUFFERED(self))
+ if (!ENTER_BUFFERED(self)) {
return NULL;
+ }
r = buffered_closed(self);
if (r < 0)
/* flush() will most probably re-take the lock, so drop it first */
LEAVE_BUFFERED(self)
res = PyObject_CallMethodNoArgs((PyObject *)self, &_Py_ID(flush));
- if (!ENTER_BUFFERED(self))
+ if (!ENTER_BUFFERED(self)) {
return NULL;
- if (res == NULL)
- PyErr_Fetch(&exc, &val, &tb);
- else
+ }
+ PyObject *exc = NULL;
+ if (res == NULL) {
+ exc = PyErr_GetRaisedException();
+ }
+ else {
Py_DECREF(res);
+ }
res = PyObject_CallMethodNoArgs(self->raw, &_Py_ID(close));
}
if (exc != NULL) {
- _PyErr_ChainExceptions(exc, val, tb);
+ _PyErr_ChainExceptions1(exc);
Py_CLEAR(res);
}
static Py_ssize_t *
_buffered_check_blocking_error(void)
{
- PyObject *t, *v, *tb;
- PyOSErrorObject *err;
-
- PyErr_Fetch(&t, &v, &tb);
- if (v == NULL || !PyErr_GivenExceptionMatches(v, PyExc_BlockingIOError)) {
- PyErr_Restore(t, v, tb);
+ PyObject *exc = PyErr_GetRaisedException();
+ if (exc == NULL || !PyErr_GivenExceptionMatches(exc, PyExc_BlockingIOError)) {
+ PyErr_SetRaisedException(exc);
return NULL;
}
- err = (PyOSErrorObject *) v;
+ PyOSErrorObject *err = (PyOSErrorObject *)exc;
/* TODO: sanity check (err->written >= 0) */
- PyErr_Restore(t, v, tb);
+ PyErr_SetRaisedException(exc);
return &err->written;
}
int
_PyIO_trap_eintr(void)
{
- PyObject *typ, *val, *tb;
- PyOSErrorObject *env_err;
- if (!PyErr_ExceptionMatches(PyExc_OSError))
+ if (!PyErr_ExceptionMatches(PyExc_OSError)) {
return 0;
- PyErr_Fetch(&typ, &val, &tb);
- PyErr_NormalizeException(&typ, &val, &tb);
- env_err = (PyOSErrorObject *) val;
+ }
+ PyObject *exc = PyErr_GetRaisedException();
+ PyOSErrorObject *env_err = (PyOSErrorObject *)exc;
assert(env_err != NULL);
if (env_err->myerrno != NULL) {
assert(EINTR > 0 && EINTR < INT_MAX);
int myerrno = PyLong_AsLongAndOverflow(env_err->myerrno, &overflow);
PyErr_Clear();
if (myerrno == EINTR) {
- Py_DECREF(typ);
- Py_DECREF(val);
- Py_XDECREF(tb);
+ Py_DECREF(exc);
return 1;
}
}
/* This silences any error set by PyObject_RichCompareBool() */
- PyErr_Restore(typ, val, tb);
+ PyErr_SetRaisedException(exc);
return 0;
}
static PyObject *
bufferedrwpair_close(rwpair *self, PyObject *Py_UNUSED(ignored))
{
- PyObject *exc = NULL, *val, *tb;
+ PyObject *exc = NULL;
PyObject *ret = _forward_call(self->writer, &_Py_ID(close), NULL);
- if (ret == NULL)
- PyErr_Fetch(&exc, &val, &tb);
- else
+ if (ret == NULL) {
+ exc = PyErr_GetRaisedException();
+ }
+ else {
Py_DECREF(ret);
+ }
ret = _forward_call(self->reader, &_Py_ID(close), NULL);
if (exc != NULL) {
- _PyErr_ChainExceptions(exc, val, tb);
+ _PyErr_ChainExceptions1(exc);
Py_CLEAR(ret);
}
return ret;
fileio_dealloc_warn(fileio *self, PyObject *source)
{
if (self->fd >= 0 && self->closefd) {
- PyObject *exc, *val, *tb;
- PyErr_Fetch(&exc, &val, &tb);
+ PyObject *exc = PyErr_GetRaisedException();
if (PyErr_ResourceWarning(source, 1, "unclosed file %R", source)) {
/* Spurious errors can appear at shutdown */
if (PyErr_ExceptionMatches(PyExc_Warning))
PyErr_WriteUnraisable((PyObject *) self);
}
- PyErr_Restore(exc, val, tb);
+ PyErr_SetRaisedException(exc);
}
Py_RETURN_NONE;
}
/*[clinic end generated code: output=7737a319ef3bad0b input=f35231760d54a522]*/
{
PyObject *res;
- PyObject *exc, *val, *tb;
+ PyObject *exc;
int rc;
res = PyObject_CallMethodOneArg((PyObject*)&PyRawIOBase_Type,
&_Py_ID(close), (PyObject *)self);
self->fd = -1;
return res;
}
- if (res == NULL)
- PyErr_Fetch(&exc, &val, &tb);
+ if (res == NULL) {
+ exc = PyErr_GetRaisedException();
+ }
if (self->finalizing) {
PyObject *r = fileio_dealloc_warn(self, (PyObject *) self);
- if (r)
+ if (r) {
Py_DECREF(r);
- else
+ }
+ else {
PyErr_Clear();
+ }
}
rc = internal_close(self);
- if (res == NULL)
- _PyErr_ChainExceptions(exc, val, tb);
- if (rc < 0)
+ if (res == NULL) {
+ _PyErr_ChainExceptions1(exc);
+ }
+ if (rc < 0) {
Py_CLEAR(res);
+ }
return res;
}
if (!fd_is_own)
self->fd = -1;
if (self->fd >= 0) {
- PyObject *exc, *val, *tb;
- PyErr_Fetch(&exc, &val, &tb);
+ PyObject *exc = PyErr_GetRaisedException();
internal_close(self);
- _PyErr_ChainExceptions(exc, val, tb);
+ _PyErr_ChainExceptions1(exc);
}
done:
_io__IOBase_close_impl(PyObject *self)
/*[clinic end generated code: output=63c6a6f57d783d6d input=f4494d5c31dbc6b7]*/
{
- PyObject *res, *exc, *val, *tb;
int rc, closed = iobase_is_closed(self);
if (closed < 0) {
Py_RETURN_NONE;
}
- res = PyObject_CallMethodNoArgs(self, &_Py_ID(flush));
+ PyObject *res = PyObject_CallMethodNoArgs(self, &_Py_ID(flush));
- PyErr_Fetch(&exc, &val, &tb);
+ PyObject *exc = PyErr_GetRaisedException();
rc = PyObject_SetAttr(self, &_Py_ID(__IOBase_closed), Py_True);
- _PyErr_ChainExceptions(exc, val, tb);
+ _PyErr_ChainExceptions1(exc);
if (rc < 0) {
Py_CLEAR(res);
}
iobase_finalize(PyObject *self)
{
PyObject *res;
- PyObject *error_type, *error_value, *error_traceback;
int closed;
/* Save the current exception, if any. */
- PyErr_Fetch(&error_type, &error_value, &error_traceback);
+ PyObject *exc = PyErr_GetRaisedException();
/* If `closed` doesn't exist or can't be evaluated as bool, then the
object is probably in an unusable state, so ignore. */
}
/* Restore the saved exception. */
- PyErr_Restore(error_type, error_value, error_traceback);
+ PyErr_SetRaisedException(exc);
}
int
fail:
if (saved_state) {
- PyObject *type, *value, *traceback;
- PyErr_Fetch(&type, &value, &traceback);
+ PyObject *exc = PyErr_GetRaisedException();
res = PyObject_CallMethodOneArg(
self->decoder, &_Py_ID(setstate), saved_state);
- _PyErr_ChainExceptions(type, value, traceback);
+ _PyErr_ChainExceptions1(exc);
Py_DECREF(saved_state);
Py_XDECREF(res);
}
Py_RETURN_NONE; /* stream already closed */
}
else {
- PyObject *exc = NULL, *val, *tb;
+ PyObject *exc = NULL;
if (self->finalizing) {
res = PyObject_CallMethodOneArg(self->buffer, &_Py_ID(_dealloc_warn),
(PyObject *)self);
- if (res)
+ if (res) {
Py_DECREF(res);
- else
+ }
+ else {
PyErr_Clear();
+ }
}
res = PyObject_CallMethodNoArgs((PyObject *)self, &_Py_ID(flush));
- if (res == NULL)
- PyErr_Fetch(&exc, &val, &tb);
- else
+ if (res == NULL) {
+ exc = PyErr_GetRaisedException();
+ }
+ else {
Py_DECREF(res);
+ }
res = PyObject_CallMethodNoArgs(self->buffer, &_Py_ID(close));
if (exc != NULL) {
- _PyErr_ChainExceptions(exc, val, tb);
+ _PyErr_ChainExceptions1(exc);
Py_CLEAR(res);
}
return res;
/*[clinic end generated code: output=27ef95b66c29057b input=68c4e5754f8136c2]*/
{
PyObject *res;
- PyObject *exc, *val, *tb;
+ PyObject *exc;
int rc;
res = PyObject_CallMethodOneArg((PyObject*)&PyRawIOBase_Type,
&_Py_ID(close), (PyObject*)self);
self->fd = -1;
return res;
}
- if (res == NULL)
- PyErr_Fetch(&exc, &val, &tb);
+ if (res == NULL) {
+ exc = PyErr_GetRaisedException();
+ }
rc = internal_close(self);
- if (res == NULL)
- _PyErr_ChainExceptions(exc, val, tb);
- if (rc < 0)
+ if (res == NULL) {
+ _PyErr_ChainExceptions1(exc);
+ }
+ if (rc < 0) {
Py_CLEAR(res);
+ }
return res;
}
* exception, and some of the code under here assumes that
* PyErr_* is its own to mess around with, so we have to
* save and restore any current exception. */
- PyObject *last_type, *last_value, *last_tb;
- PyErr_Fetch(&last_type, &last_value, &last_tb);
+ PyObject *exc = PyErr_GetRaisedException();
profEntry = getEntry(pObj, key);
if (profEntry == NULL) {
initContext(pObj, pContext, profEntry);
restorePyerr:
- PyErr_Restore(last_type, last_value, last_tb);
+ PyErr_SetRaisedException(exc);
}
static void
PyObject* function_result;
PyObject** aggregate_instance;
int ok;
- PyObject *exception, *value, *tb;
aggregate_instance = (PyObject**)sqlite3_aggregate_context(context, 0);
if (aggregate_instance == NULL) {
}
// Keep the exception (if any) of the last call to step, value, or inverse
- PyErr_Fetch(&exception, &value, &tb);
+ PyObject *exc = PyErr_GetRaisedException();
callback_context *ctx = (callback_context *)sqlite3_user_data(context);
assert(ctx != NULL);
}
if (!ok) {
int attr_err = PyErr_ExceptionMatches(PyExc_AttributeError);
- _PyErr_ChainExceptions(exception, value, tb);
+ _PyErr_ChainExceptions1(exc);
/* Note: contrary to the step, value, and inverse callbacks, SQLite
* does _not_, as of SQLite 3.38.0, propagate errors to sqlite3_step()
: "user-defined aggregate's 'finalize' method raised error");
}
else {
- PyErr_Restore(exception, value, tb);
+ PyErr_SetRaisedException(exc);
}
error:
if (commit) {
/* Commit failed; try to rollback in order to unlock the database.
* If rollback also fails, chain the exceptions. */
- PyObject *exc, *val, *tb;
- PyErr_Fetch(&exc, &val, &tb);
+ PyObject *exc = PyErr_GetRaisedException();
result = pysqlite_connection_rollback_impl(self);
if (result == NULL) {
- _PyErr_ChainExceptions(exc, val, tb);
+ _PyErr_ChainExceptions1(exc);
}
else {
Py_DECREF(result);
- PyErr_Restore(exc, val, tb);
+ PyErr_SetRaisedException(exc);
}
}
return NULL;
Py_DECREF(adapted);
if (rc != SQLITE_OK) {
- PyObject *exc, *val, *tb;
- PyErr_Fetch(&exc, &val, &tb);
+ PyObject *exc = PyErr_GetRaisedException();
sqlite3 *db = sqlite3_db_handle(self->st);
_pysqlite_seterror(state, db);
- _PyErr_ChainExceptions(exc, val, tb);
+ _PyErr_ChainExceptions1(exc);
return;
}
}
Py_DECREF(adapted);
if (rc != SQLITE_OK) {
- PyObject *exc, *val, *tb;
- PyErr_Fetch(&exc, &val, &tb);
+ PyObject *exc = PyErr_GetRaisedException();
sqlite3 *db = sqlite3_db_handle(self->st);
_pysqlite_seterror(state, db);
- _PyErr_ChainExceptions(exc, val, tb);
+ _PyErr_ChainExceptions1(exc);
return;
}
}
static void
heapctypesubclasswithfinalizer_finalize(PyObject *self)
{
- PyObject *error_type, *error_value, *error_traceback, *m;
PyObject *oldtype = NULL, *newtype = NULL, *refcnt = NULL;
/* Save the current exception, if any. */
- PyErr_Fetch(&error_type, &error_value, &error_traceback);
+ PyObject *exc = PyErr_GetRaisedException();
if (_testcapimodule == NULL) {
goto cleanup_finalize;
}
- m = PyState_FindModule(_testcapimodule);
+ PyObject *m = PyState_FindModule(_testcapimodule);
if (m == NULL) {
goto cleanup_finalize;
}
Py_XDECREF(refcnt);
/* Restore the saved exception. */
- PyErr_Restore(error_type, error_value, error_traceback);
+ PyErr_SetRaisedException(exc);
}
static PyType_Slot HeapCTypeSubclassWithFinalizer_slots[] = {
watcher_ids[i] = watcher_id;
num_watchers++;
}
- PyObject *type, *value, *traceback;
- PyErr_Fetch(&type, &value, &traceback);
+ PyObject *exc = PyErr_GetRaisedException();
for (int i = 0; i < num_watchers; i++) {
if (PyCode_ClearWatcher(watcher_ids[i]) < 0) {
PyErr_WriteUnraisable(Py_None);
break;
}
}
- if (type) {
- PyErr_Restore(type, value, traceback);
+ if (exc) {
+ PyErr_SetRaisedException(exc);
return NULL;
}
else if (PyErr_Occurred()) {
watcher_ids[i] = watcher_id;
num_watchers++;
}
- PyObject *type, *value, *traceback;
- PyErr_Fetch(&type, &value, &traceback);
+ PyObject *exc = PyErr_GetRaisedException();
for (int i = 0; i < num_watchers; i++) {
if (PyFunction_ClearWatcher(watcher_ids[i]) < 0) {
PyErr_WriteUnraisable(Py_None);
break;
}
}
- if (type) {
- PyErr_Restore(type, value, traceback);
+ if (exc) {
+ PyErr_SetRaisedException(exc);
return NULL;
}
else if (PyErr_Occurred()) {
slot_tp_del(PyObject *self)
{
PyObject *del, *res;
- PyObject *error_type, *error_value, *error_traceback;
/* Temporarily resurrect the object. */
assert(Py_REFCNT(self) == 0);
Py_SET_REFCNT(self, 1);
/* Save the current exception, if any. */
- PyErr_Fetch(&error_type, &error_value, &error_traceback);
+ PyObject *exc = PyErr_GetRaisedException();
PyObject *tp_del = PyUnicode_InternFromString("__tp_del__");
if (tp_del == NULL) {
PyErr_WriteUnraisable(NULL);
- PyErr_Restore(error_type, error_value, error_traceback);
+ PyErr_SetRaisedException(exc);
return;
}
/* Execute __del__ method, if any. */
}
/* Restore the saved exception. */
- PyErr_Restore(error_type, error_value, error_traceback);
+ PyErr_SetRaisedException(exc);
/* Undo the temporary resurrection; can't use DECREF here, it would
* cause a recursive call.
static int
_release_xid_data(_PyCrossInterpreterData *data, int ignoreexc)
{
- PyObject *exctype, *excval, *exctb;
+ PyObject *exc;
if (ignoreexc) {
- PyErr_Fetch(&exctype, &excval, &exctb);
+ exc = PyErr_GetRaisedException();
}
int res = _PyCrossInterpreterData_Release(data);
if (res < 0) {
}
}
if (ignoreexc) {
- PyErr_Restore(exctype, excval, exctb);
+ PyErr_SetRaisedException(exc);
}
return res;
}
Py_CLEAR(self);
cleanup:
if (file_obj != NULL) {
- PyObject *exc, *val, *tb;
- PyErr_Fetch(&exc, &val, &tb);
+ PyObject *exc = PyErr_GetRaisedException();
PyObject *tmp = PyObject_CallMethod(file_obj, "close", NULL);
- _PyErr_ChainExceptions(exc, val, tb);
+ _PyErr_ChainExceptions1(exc);
if (tmp == NULL) {
Py_CLEAR(self);
}
static void
ScandirIterator_finalize(ScandirIterator *iterator)
{
- PyObject *error_type, *error_value, *error_traceback;
/* Save the current exception, if any. */
- PyErr_Fetch(&error_type, &error_value, &error_traceback);
+ PyObject *exc = PyErr_GetRaisedException();
if (!ScandirIterator_is_closed(iterator)) {
ScandirIterator_closedir(iterator);
path_cleanup(&iterator->path);
/* Restore the saved exception. */
- PyErr_Restore(error_type, error_value, error_traceback);
+ PyErr_SetRaisedException(exc);
}
static void
static int
report_wakeup_write_error(void *data)
{
- PyObject *exc, *val, *tb;
int save_errno = errno;
errno = (int) (intptr_t) data;
- PyErr_Fetch(&exc, &val, &tb);
+ PyObject *exc = PyErr_GetRaisedException();
PyErr_SetFromErrno(PyExc_OSError);
_PyErr_WriteUnraisableMsg("when trying to write to the signal wakeup fd",
NULL);
- PyErr_Restore(exc, val, tb);
+ PyErr_SetRaisedException(exc);
errno = save_errno;
return 0;
}
{
int send_errno = (int) (intptr_t) data;
- PyObject *exc, *val, *tb;
- PyErr_Fetch(&exc, &val, &tb);
+ PyObject *exc = PyErr_GetRaisedException();
/* PyErr_SetExcFromWindowsErr() invokes FormatMessage() which
recognizes the error codes used by both GetLastError() and
WSAGetLastError */
PyErr_SetExcFromWindowsErr(PyExc_OSError, send_errno);
_PyErr_WriteUnraisableMsg("when trying to send to the signal wakeup fd", NULL);
- PyErr_Restore(exc, val, tb);
+ PyErr_SetRaisedException(exc);
return 0;
}
#endif /* MS_WINDOWS */
sock_finalize(PySocketSockObject *s)
{
SOCKET_T fd;
- PyObject *error_type, *error_value, *error_traceback;
/* Save the current exception, if any. */
- PyErr_Fetch(&error_type, &error_value, &error_traceback);
+ PyObject *exc = PyErr_GetRaisedException();
if (s->sock_fd != INVALID_SOCKET) {
if (PyErr_ResourceWarning((PyObject *)s, 1, "unclosed %R", s)) {
}
/* Restore the saved exception. */
- PyErr_Restore(error_type, error_value, error_traceback);
+ PyErr_SetRaisedException(exc);
}
static void
projects / thirdparty / Python / cpython.git / commitdiff
