int _PyObject_GetCrossInterpreterData(PyObject *obj, _PyCrossInterpreterData *data) { // _PyInterpreterState_Get() aborts if lookup fails, so we don't need // to check the result for NULL. PyInterpreterState *interp = _PyInterpreterState_Get(); // Reset data before re-populating. *data = (_PyCrossInterpreterData){0}; data->free = PyMem_RawFree; // Set a default that may be overridden. // Call the "getdata" func for the object. Py_INCREF(obj); crossinterpdatafunc getdata = _lookup_getdata(obj); if (getdata == NULL) { Py_DECREF(obj); return -1; } int res = getdata(obj, data); Py_DECREF(obj); if (res != 0) { return -1; } // Fill in the blanks and validate the result. data->interp = interp->id; if (_check_xidata(data) != 0) { _PyCrossInterpreterData_Release(data); return -1; } return 0; }
static int set_main_loader(PyObject *d, const char *filename, const char *loader_name) { PyObject *filename_obj, *bootstrap, *loader_type = NULL, *loader; int result = 0; filename_obj = PyUnicode_DecodeFSDefault(filename); if (filename_obj == NULL) return -1; PyInterpreterState *interp = _PyInterpreterState_Get(); bootstrap = PyObject_GetAttrString(interp->importlib, "_bootstrap_external"); if (bootstrap != NULL) { loader_type = PyObject_GetAttrString(bootstrap, loader_name); Py_DECREF(bootstrap); } if (loader_type == NULL) { Py_DECREF(filename_obj); return -1; } loader = PyObject_CallFunction(loader_type, "sN", "__main__", filename_obj); Py_DECREF(loader_type); if (loader == NULL) { return -1; } if (PyDict_SetItemString(d, "__loader__", loader) < 0) { result = -1; } Py_DECREF(loader); return result; }
/* Register the error handling callback function error under the name name. This function will be called by the codec when it encounters an unencodable characters/undecodable bytes and doesn't know the callback name, when name is specified as the error parameter in the call to the encode/decode function. Return 0 on success, -1 on error */ int PyCodec_RegisterError(const char *name, PyObject *error) { PyInterpreterState *interp = _PyInterpreterState_Get(); if (interp->codec_search_path == NULL && _PyCodecRegistry_Init()) return -1; if (!PyCallable_Check(error)) { PyErr_SetString(PyExc_TypeError, "handler must be callable"); return -1; } return PyDict_SetItemString(interp->codec_error_registry, name, error); }
int PyCodec_Register(PyObject *search_function) { PyInterpreterState *interp = _PyInterpreterState_Get(); if (interp->codec_search_path == NULL && _PyCodecRegistry_Init()) goto onError; if (search_function == NULL) { PyErr_BadArgument(); goto onError; } if (!PyCallable_Check(search_function)) { PyErr_SetString(PyExc_TypeError, "argument must be callable"); goto onError; } return PyList_Append(interp->codec_search_path, search_function); onError: return -1; }
static void _call_in_interpreter(PyInterpreterState *interp, void (*func)(void *), void *arg) { /* We would use Py_AddPendingCall() if it weren't specific to the * main interpreter (see bpo-33608). In the meantime we take a * naive approach. */ PyThreadState *save_tstate = NULL; if (interp != _PyInterpreterState_Get()) { // XXX Using the "head" thread isn't strictly correct. PyThreadState *tstate = PyInterpreterState_ThreadHead(interp); // XXX Possible GILState issues? save_tstate = PyThreadState_Swap(tstate); } func(arg); // Switch back. if (save_tstate != NULL) { PyThreadState_Swap(save_tstate); } }
int _PyCodec_Forget(const char *encoding) { PyObject *v; int result; PyInterpreterState *interp = _PyInterpreterState_Get(); if (interp->codec_search_path == NULL) { return -1; } /* Convert the encoding to a normalized Python string: all characters are converted to lower case, spaces and hyphens are replaced with underscores. */ v = normalizestring(encoding); if (v == NULL) { return -1; } /* Drop the named codec from the internal cache */ result = PyDict_DelItem(interp->codec_search_cache, v); Py_DECREF(v); return result; }
int PyRun_InteractiveLoopFlags(FILE *fp, const char *filename_str, PyCompilerFlags *flags) { PyObject *filename, *v; int ret, err; PyCompilerFlags local_flags; int nomem_count = 0; #ifdef Py_REF_DEBUG int show_ref_count = _PyInterpreterState_Get()->core_config.show_ref_count; #endif filename = PyUnicode_DecodeFSDefault(filename_str); if (filename == NULL) { PyErr_Print(); return -1; } if (flags == NULL) { flags = &local_flags; local_flags.cf_flags = 0; } v = _PySys_GetObjectId(&PyId_ps1); if (v == NULL) { _PySys_SetObjectId(&PyId_ps1, v = PyUnicode_FromString(">>> ")); Py_XDECREF(v); } v = _PySys_GetObjectId(&PyId_ps2); if (v == NULL) { _PySys_SetObjectId(&PyId_ps2, v = PyUnicode_FromString("... ")); Py_XDECREF(v); } err = 0; do { ret = PyRun_InteractiveOneObjectEx(fp, filename, flags); if (ret == -1 && PyErr_Occurred()) { /* Prevent an endless loop after multiple consecutive MemoryErrors * while still allowing an interactive command to fail with a * MemoryError. */ if (PyErr_ExceptionMatches(PyExc_MemoryError)) { if (++nomem_count > 16) { PyErr_Clear(); err = -1; break; } } else { nomem_count = 0; } PyErr_Print(); flush_io(); } else { nomem_count = 0; } #ifdef Py_REF_DEBUG if (show_ref_count) { _PyDebug_PrintTotalRefs(); } #endif } while (ret != E_EOF); Py_DECREF(filename); return err; }
static int dump_config_impl(void) { PyObject *config = NULL; PyObject *dict = NULL; config = PyDict_New(); if (config == NULL) { goto error; } /* global config */ dict = _Py_GetGlobalVariablesAsDict(); if (dict == NULL) { goto error; } if (PyDict_SetItemString(config, "global_config", dict) < 0) { goto error; } Py_CLEAR(dict); /* core config */ PyInterpreterState *interp = _PyInterpreterState_Get(); const _PyCoreConfig *core_config = &interp->core_config; dict = _PyCoreConfig_AsDict(core_config); if (dict == NULL) { goto error; } if (PyDict_SetItemString(config, "core_config", dict) < 0) { goto error; } Py_CLEAR(dict); /* main config */ const _PyMainInterpreterConfig *main_config = &interp->config; dict = _PyMainInterpreterConfig_AsDict(main_config); if (dict == NULL) { goto error; } if (PyDict_SetItemString(config, "main_config", dict) < 0) { goto error; } Py_CLEAR(dict); PyObject *json = PyImport_ImportModule("json"); PyObject *res = PyObject_CallMethod(json, "dumps", "O", config); Py_DECREF(json); Py_CLEAR(config); if (res == NULL) { goto error; } PySys_FormatStdout("%S\n", res); Py_DECREF(res); return 0; error: Py_XDECREF(config); Py_XDECREF(dict); return -1; }