int PyStatus_Exception(PyStatus status)
{ return _PyStatus_EXCEPTION(status); }
-PyObject*
+void
_PyErr_SetFromPyStatus(PyStatus status)
{
if (!_PyStatus_IS_ERROR(status)) {
PyErr_Format(PyExc_SystemError,
- "%s() expects an error PyStatus",
- _PyStatus_GET_FUNC());
+ "_PyErr_SetFromPyStatus() status is not an error");
+ return;
}
- else if (status.func) {
- PyErr_Format(PyExc_ValueError, "%s: %s", status.func, status.err_msg);
+
+ const char *err_msg = status.err_msg;
+ if (err_msg == NULL || strlen(err_msg) == 0) {
+ PyErr_Format(PyExc_SystemError,
+ "_PyErr_SetFromPyStatus() status has no error message");
+ return;
+ }
+
+ if (strcmp(err_msg, _PyStatus_NO_MEMORY_ERRMSG) == 0) {
+ PyErr_NoMemory();
+ return;
+ }
+
+ const char *func = status.func;
+ if (func) {
+ PyErr_Format(PyExc_RuntimeError, "%s: %s", func, err_msg);
}
else {
- PyErr_Format(PyExc_ValueError, "%s", status.err_msg);
+ PyErr_Format(PyExc_RuntimeError, "%s", err_msg);
}
- return NULL;
}
Py_ssize_t unicode_next_index,
PyThread_type_lock locks[NUMLOCKS])
{
- if (runtime->_initialized) {
- Py_FatalError("runtime already initialized");
- }
- assert(!runtime->preinitializing &&
- !runtime->preinitialized &&
- !runtime->core_initialized &&
- !runtime->initialized);
+ assert(!runtime->preinitializing);
+ assert(!runtime->preinitialized);
+ assert(!runtime->core_initialized);
+ assert(!runtime->initialized);
+ assert(!runtime->_initialized);
runtime->open_code_hook = open_code_hook;
runtime->open_code_userdata = open_code_userdata;
// Py_Initialize() must be running again.
// Reset to _PyRuntimeState_INIT.
memcpy(runtime, &initial, sizeof(*runtime));
+ assert(!runtime->_initialized);
}
if (gilstate_tss_init(runtime) != 0) {
main interpreter. We fix those fields here, in addition
to the other dynamically initialized fields.
*/
-static void
+static PyStatus
init_interpreter(PyInterpreterState *interp,
_PyRuntimeState *runtime, int64_t id,
PyInterpreterState *next,
PyThread_type_lock pending_lock)
{
if (interp->_initialized) {
- Py_FatalError("interpreter already initialized");
+ return _PyStatus_ERR("interpreter already initialized");
}
assert(runtime != NULL);
memcpy(&interp->obmalloc.pools.used, temp, sizeof(temp));
}
- _PyObject_InitState(interp);
+ PyStatus status = _PyObject_InitState(interp);
+ if (_PyStatus_EXCEPTION(status)) {
+ return status;
+ }
_PyEval_InitState(interp, pending_lock);
_PyGC_InitState(&interp->gc);
}
interp->f_opcode_trace_set = false;
interp->_initialized = 1;
+ return _PyStatus_OK();
}
-PyInterpreterState *
-PyInterpreterState_New(void)
+
+PyStatus
+_PyInterpreterState_New(PyThreadState *tstate, PyInterpreterState **pinterp)
{
- PyInterpreterState *interp;
+ *pinterp = NULL;
+
+ // Don't get runtime from tstate since tstate can be NULL
_PyRuntimeState *runtime = &_PyRuntime;
- PyThreadState *tstate = current_fast_get(runtime);
- /* tstate is NULL when Py_InitializeFromConfig() calls
- PyInterpreterState_New() to create the main interpreter. */
- if (_PySys_Audit(tstate, "cpython.PyInterpreterState_New", NULL) < 0) {
- return NULL;
+ // tstate is NULL when pycore_create_interpreter() calls
+ // _PyInterpreterState_New() to create the main interpreter.
+ if (tstate != NULL) {
+ if (_PySys_Audit(tstate, "cpython.PyInterpreterState_New", NULL) < 0) {
+ return _PyStatus_ERR("sys.audit failed");
+ }
}
PyThread_type_lock pending_lock = PyThread_allocate_lock();
if (pending_lock == NULL) {
- if (tstate != NULL) {
- _PyErr_NoMemory(tstate);
- }
- return NULL;
+ return _PyStatus_NO_MEMORY();
}
- /* Don't get runtime from tstate since tstate can be NULL. */
- struct pyinterpreters *interpreters = &runtime->interpreters;
-
/* We completely serialize creation of multiple interpreters, since
it simplifies things here and blocking concurrent calls isn't a problem.
Regardless, we must fully block subinterpreter creation until
after the main interpreter is created. */
HEAD_LOCK(runtime);
+ struct pyinterpreters *interpreters = &runtime->interpreters;
int64_t id = interpreters->next_id;
interpreters->next_id += 1;
// Allocate the interpreter and add it to the runtime state.
+ PyInterpreterState *interp;
+ PyStatus status;
PyInterpreterState *old_head = interpreters->head;
if (old_head == NULL) {
// We are creating the main interpreter.
interp = alloc_interpreter();
if (interp == NULL) {
+ status = _PyStatus_NO_MEMORY();
goto error;
}
// Set to _PyInterpreterState_INIT.
- memcpy(interp, &initial._main_interpreter,
- sizeof(*interp));
+ memcpy(interp, &initial._main_interpreter, sizeof(*interp));
if (id < 0) {
/* overflow or Py_Initialize() not called yet! */
- if (tstate != NULL) {
- _PyErr_SetString(tstate, PyExc_RuntimeError,
- "failed to get an interpreter ID");
- }
+ status = _PyStatus_ERR("failed to get an interpreter ID");
goto error;
}
}
interpreters->head = interp;
- init_interpreter(interp, runtime, id, old_head, pending_lock);
+ status = init_interpreter(interp, runtime,
+ id, old_head, pending_lock);
+ if (_PyStatus_EXCEPTION(status)) {
+ goto error;
+ }
+ pending_lock = NULL;
HEAD_UNLOCK(runtime);
- return interp;
+
+ assert(interp != NULL);
+ *pinterp = interp;
+ return _PyStatus_OK();
error:
HEAD_UNLOCK(runtime);
- PyThread_free_lock(pending_lock);
+ if (pending_lock != NULL) {
+ PyThread_free_lock(pending_lock);
+ }
if (interp != NULL) {
free_interpreter(interp);
}
- return NULL;
+ return status;
+}
+
+
+PyInterpreterState *
+PyInterpreterState_New(void)
+{
+ // tstate can be NULL
+ PyThreadState *tstate = current_fast_get(&_PyRuntime);
+
+ PyInterpreterState *interp;
+ PyStatus status = _PyInterpreterState_New(tstate, &interp);
+ if (_PyStatus_EXCEPTION(status)) {
+ Py_ExitStatusException(status);
+ }
+ assert(interp != NULL);
+ return interp;
}
projects / thirdparty / Python / cpython.git / commitdiff
