Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

bpo-39968: Convert extension modules' macros of get_module_state() to inline functions (GH-19017)

This commit is contained in:
Hai Shi 2020-03-16 21:15:01 +08:00 committed by GitHub
parent 4ab362cec6
commit f707d94af6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 279 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Misc/NEWS.d/next/Core and Builtins/2020-03-15-13-51-10.bpo-39968.f-Xi39.rst Normal file
View File

@ -0,0 +1 @@
Use inline function to replace extension modules' get_module_state macros.

34
Modules/_csv.c
View File

@ -21,21 +21,27 @@ typedef struct {
long field_limit; /* max parsed field size */
} _csvstate;
#define _csvstate(o) ((_csvstate *)PyModule_GetState(o))
static inline _csvstate*
get_csv_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (_csvstate *)state;
}
static int
_csv_clear(PyObject *m)
{
Py_CLEAR(_csvstate(m)->error_obj);
Py_CLEAR(_csvstate(m)->dialects);
Py_CLEAR(get_csv_state(m)->error_obj);
Py_CLEAR(get_csv_state(m)->dialects);
return 0;
}
static int
_csv_traverse(PyObject *m, visitproc visit, void *arg)
{
Py_VISIT(_csvstate(m)->error_obj);
Py_VISIT(_csvstate(m)->dialects);
Py_VISIT(get_csv_state(m)->error_obj);
Py_VISIT(get_csv_state(m)->dialects);
return 0;
}
@ -1647,15 +1653,15 @@ PyInit__csv(void)
return NULL;
/* Set the field limit */
_csvstate(module)->field_limit = 128 * 1024;
get_csv_state(module)->field_limit = 128 * 1024;
/* Do I still need to add this var to the Module Dict? */
/* Add _dialects dictionary */
_csvstate(module)->dialects = PyDict_New();
if (_csvstate(module)->dialects == NULL)
get_csv_state(module)->dialects = PyDict_New();
if (get_csv_state(module)->dialects == NULL)
return NULL;
Py_INCREF(_csvstate(module)->dialects);
if (PyModule_AddObject(module, "_dialects", _csvstate(module)->dialects))
Py_INCREF(get_csv_state(module)->dialects);
if (PyModule_AddObject(module, "_dialects", get_csv_state(module)->dialects))
return NULL;
/* Add quote styles into dictionary */
@ -1671,10 +1677,10 @@ PyInit__csv(void)
return NULL;
/* Add the CSV exception object to the module. */
_csvstate(module)->error_obj = PyErr_NewException("_csv.Error", NULL, NULL);
if (_csvstate(module)->error_obj == NULL)
get_csv_state(module)->error_obj = PyErr_NewException("_csv.Error", NULL, NULL);
if (get_csv_state(module)->error_obj == NULL)
return NULL;
Py_INCREF(_csvstate(module)->error_obj);
PyModule_AddObject(module, "Error", _csvstate(module)->error_obj);
Py_INCREF(get_csv_state(module)->error_obj);
PyModule_AddObject(module, "Error", get_csv_state(module)->error_obj);
return module;
}

23
Modules/_curses_panel.c
View File

@ -21,19 +21,25 @@ typedef struct {
PyObject *PyCursesPanel_Type;
} _curses_panelstate;
#define _curses_panelstate(o) ((_curses_panelstate *)PyModule_GetState(o))
static inline _curses_panelstate*
get_curses_panelstate(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (_curses_panelstate *)state;
}
static int
_curses_panel_clear(PyObject *m)
{
Py_CLEAR(_curses_panelstate(m)->PyCursesError);
Py_CLEAR(get_curses_panelstate(m)->PyCursesError);
return 0;
}
static int
_curses_panel_traverse(PyObject *m, visitproc visit, void *arg)
{
Py_VISIT(_curses_panelstate(m)->PyCursesError);
Py_VISIT(get_curses_panelstate(m)->PyCursesError);
return 0;
}
@ -645,15 +651,15 @@ PyInit__curses_panel(void)
if (v == NULL)
goto fail;
((PyTypeObject *)v)->tp_new = NULL;
_curses_panelstate(m)->PyCursesPanel_Type = v;
get_curses_panelstate(m)->PyCursesPanel_Type = v;
import_curses();
if (PyErr_Occurred())
goto fail;
/* For exception _curses_panel.error */
_curses_panelstate(m)->PyCursesError = PyErr_NewException("_curses_panel.error", NULL, NULL);
PyDict_SetItemString(d, "error", _curses_panelstate(m)->PyCursesError);
get_curses_panelstate(m)->PyCursesError = PyErr_NewException("_curses_panel.error", NULL, NULL);
PyDict_SetItemString(d, "error", get_curses_panelstate(m)->PyCursesError);
/* Make the version available */
v = PyUnicode_FromString(PyCursesVersion);
@ -661,8 +667,9 @@ PyInit__curses_panel(void)
PyDict_SetItemString(d, "__version__", v);
Py_DECREF(v);
Py_INCREF(_curses_panelstate(m)->PyCursesPanel_Type);
PyModule_AddObject(m, "panel", (PyObject *)_curses_panelstate(m)->PyCursesPanel_Type);
Py_INCREF(get_curses_panelstate(m)->PyCursesPanel_Type);
PyModule_AddObject(m, "panel",
(PyObject *)get_curses_panelstate(m)->PyCursesPanel_Type);
return m;
fail:
Py_XDECREF(m);

14
Modules/_elementtree.c
View File

@ -101,7 +101,13 @@ static struct PyModuleDef elementtreemodule;
/* Given a module object (assumed to be _elementtree), get its per-module
* state.
*/
#define ET_STATE(mod) ((elementtreestate *) PyModule_GetState(mod))
static inline elementtreestate*
get_elementtree_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (elementtreestate *)state;
}
/* Find the module instance imported in the currently running sub-interpreter
* and get its state.
@ -112,7 +118,7 @@ static struct PyModuleDef elementtreemodule;
static int
elementtree_clear(PyObject *m)
{
elementtreestate *st = ET_STATE(m);
elementtreestate *st = get_elementtree_state(m);
Py_CLEAR(st->parseerror_obj);
Py_CLEAR(st->deepcopy_obj);
Py_CLEAR(st->elementpath_obj);
@ -124,7 +130,7 @@ elementtree_clear(PyObject *m)
static int
elementtree_traverse(PyObject *m, visitproc visit, void *arg)
{
elementtreestate *st = ET_STATE(m);
elementtreestate *st = get_elementtree_state(m);
Py_VISIT(st->parseerror_obj);
Py_VISIT(st->deepcopy_obj);
Py_VISIT(st->elementpath_obj);
@ -4377,7 +4383,7 @@ PyInit__elementtree(void)
m = PyModule_Create(&elementtreemodule);
if (!m)
return NULL;
st = ET_STATE(m);
st = get_elementtree_state(m);
if (!(temp = PyImport_ImportModule("copy")))
return NULL;

19
Modules/_hashopenssl.c
View File

@ -52,7 +52,14 @@ typedef struct {
PyTypeObject *EVPtype;
} _hashlibstate;
#define _hashlibstate(o) ((_hashlibstate *)PyModule_GetState(o))
static inline _hashlibstate*
get_hashlib_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (_hashlibstate *)state;
}
#define _hashlibstate_global ((_hashlibstate *)PyModule_GetState(PyState_FindModule(&_hashlibmodule)))
@ -1112,7 +1119,7 @@ static struct PyMethodDef EVP_functions[] = {
static int
hashlib_traverse(PyObject *m, visitproc visit, void *arg)
{
_hashlibstate *state = _hashlibstate(m);
_hashlibstate *state = get_hashlib_state(m);
Py_VISIT(state->EVPtype);
return 0;
}
@ -1120,7 +1127,7 @@ hashlib_traverse(PyObject *m, visitproc visit, void *arg)
static int
hashlib_clear(PyObject *m)
{
_hashlibstate *state = _hashlibstate(m);
_hashlibstate *state = get_hashlib_state(m);
Py_CLEAR(state->EVPtype);
return 0;
}
@ -1168,7 +1175,7 @@ PyInit__hashlib(void)
PyTypeObject *EVPtype = (PyTypeObject *)PyType_FromSpec(&EVPtype_spec);
if (EVPtype == NULL)
return NULL;
_hashlibstate(m)->EVPtype = EVPtype;
get_hashlib_state(m)->EVPtype = EVPtype;
openssl_md_meth_names = generate_hash_name_list();
if (openssl_md_meth_names == NULL) {
@ -1180,8 +1187,8 @@ PyInit__hashlib(void)
return NULL;
}
Py_INCREF((PyObject *)_hashlibstate(m)->EVPtype);
PyModule_AddObject(m, "HASH", (PyObject *)_hashlibstate(m)->EVPtype);
Py_INCREF((PyObject *)get_hashlib_state(m)->EVPtype);
PyModule_AddObject(m, "HASH", (PyObject *)get_hashlib_state(m)->EVPtype);
PyState_AddModule(m, &_hashlibmodule);
return m;

15
Modules/_io/_iomodule.c
View File

@ -573,13 +573,20 @@ PyNumber_AsOff_t(PyObject *item, PyObject *err)
return result;
}
static inline _PyIO_State*
get_io_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (_PyIO_State *)state;
}
_PyIO_State *
_PyIO_get_module_state(void)
{
PyObject *mod = PyState_FindModule(&_PyIO_Module);
_PyIO_State *state;
if (mod == NULL || (state = IO_MOD_STATE(mod)) == NULL) {
if (mod == NULL || (state = get_io_state(mod)) == NULL) {
PyErr_SetString(PyExc_RuntimeError,
"could not find io module state "
"(interpreter shutdown?)");
@ -615,7 +622,7 @@ _PyIO_get_locale_module(_PyIO_State *state)
static int
iomodule_traverse(PyObject *mod, visitproc visit, void *arg) {
_PyIO_State *state = IO_MOD_STATE(mod);
_PyIO_State *state = get_io_state(mod);
if (!state->initialized)
return 0;
if (state->locale_module != NULL) {
@ -628,7 +635,7 @@ iomodule_traverse(PyObject *mod, visitproc visit, void *arg) {
static int
iomodule_clear(PyObject *mod) {
_PyIO_State *state = IO_MOD_STATE(mod);
_PyIO_State *state = get_io_state(mod);
if (!state->initialized)
return 0;
if (state->locale_module != NULL)
@ -674,7 +681,7 @@ PyInit__io(void)
_PyIO_State *state = NULL;
if (m == NULL)
return NULL;
state = IO_MOD_STATE(m);
state = get_io_state(m);
state->initialized = 0;
#define ADD_TYPE(type, name) \

29
Modules/_posixsubprocess.c
View File

@ -68,8 +68,15 @@ typedef struct {
static struct PyModuleDef _posixsubprocessmodule;
#define _posixsubprocessstate(o) ((_posixsubprocessstate *)PyModule_GetState(o))
#define _posixsubprocessstate_global _posixsubprocessstate(PyState_FindModule(&_posixsubprocessmodule))
static inline _posixsubprocessstate*
get_posixsubprocess_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (_posixsubprocessstate *)state;
}
#define _posixsubprocessstate_global get_posixsubprocess_state(PyState_FindModule(&_posixsubprocessmodule))
/* If gc was disabled, call gc.enable(). Return 0 on success. */
static int
@ -944,16 +951,16 @@ static PyMethodDef module_methods[] = {
static int _posixsubprocess_traverse(PyObject *m, visitproc visit, void *arg) {
Py_VISIT(_posixsubprocessstate(m)->disable);
Py_VISIT(_posixsubprocessstate(m)->enable);
Py_VISIT(_posixsubprocessstate(m)->isenabled);
Py_VISIT(get_posixsubprocess_state(m)->disable);
Py_VISIT(get_posixsubprocess_state(m)->enable);
Py_VISIT(get_posixsubprocess_state(m)->isenabled);
return 0;
}
static int _posixsubprocess_clear(PyObject *m) {
Py_CLEAR(_posixsubprocessstate(m)->disable);
Py_CLEAR(_posixsubprocessstate(m)->enable);
Py_CLEAR(_posixsubprocessstate(m)->isenabled);
Py_CLEAR(get_posixsubprocess_state(m)->disable);
Py_CLEAR(get_posixsubprocess_state(m)->enable);
Py_CLEAR(get_posixsubprocess_state(m)->isenabled);
return 0;
}
@ -989,9 +996,9 @@ PyInit__posixsubprocess(void)
return NULL;
}
_posixsubprocessstate(m)->disable = PyUnicode_InternFromString("disable");
_posixsubprocessstate(m)->enable = PyUnicode_InternFromString("enable");
_posixsubprocessstate(m)->isenabled = PyUnicode_InternFromString("isenabled");
get_posixsubprocess_state(m)->disable = PyUnicode_InternFromString("disable");
get_posixsubprocess_state(m)->enable = PyUnicode_InternFromString("enable");
get_posixsubprocess_state(m)->isenabled = PyUnicode_InternFromString("isenabled");
PyState_AddModule(m, &_posixsubprocessmodule);
return m;

20
Modules/_randommodule.c
View File

@ -84,11 +84,17 @@ typedef struct {
PyObject *Long___abs__;
} _randomstate;
#define _randomstate(o) ((_randomstate *)PyModule_GetState(o))
static inline _randomstate*
get_random_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (_randomstate *)state;
}
static struct PyModuleDef _randommodule;
#define _randomstate_global _randomstate(PyState_FindModule(&_randommodule))
#define _randomstate_global get_random_state(PyState_FindModule(&_randommodule))
typedef struct {
PyObject_HEAD
@ -561,15 +567,15 @@ PyDoc_STRVAR(module_doc,
static int
_random_traverse(PyObject *module, visitproc visit, void *arg)
{
Py_VISIT(_randomstate(module)->Random_Type);
Py_VISIT(get_random_state(module)->Random_Type);
return 0;
}
static int
_random_clear(PyObject *module)
{
Py_CLEAR(_randomstate(module)->Random_Type);
Py_CLEAR(_randomstate(module)->Long___abs__);
Py_CLEAR(get_random_state(module)->Random_Type);
Py_CLEAR(get_random_state(module)->Long___abs__);
return 0;
}
@ -606,7 +612,7 @@ PyInit__random(void)
Py_DECREF(Random_Type);
return NULL;
}
_randomstate(m)->Random_Type = Random_Type;
get_random_state(m)->Random_Type = Random_Type;
Py_INCREF(Random_Type);
PyModule_AddObject(m, "Random", Random_Type);
@ -624,7 +630,7 @@ PyInit__random(void)
Py_DECREF(longtype);
Py_DECREF(longval);
_randomstate(m)->Long___abs__ = abs;
get_random_state(m)->Long___abs__ = abs;
return m;

34
Modules/_struct.c
View File

@ -20,11 +20,17 @@ typedef struct {
PyObject *StructError;
} _structmodulestate;
#define _structmodulestate(o) ((_structmodulestate *)PyModule_GetState(o))
static inline _structmodulestate*
get_struct_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (_structmodulestate *)state;
}
static struct PyModuleDef _structmodule;
#define _structmodulestate_global _structmodulestate(PyState_FindModule(&_structmodule))
#define _structmodulestate_global get_struct_state(PyState_FindModule(&_structmodule))
/* The translation function for each format character is table driven */
typedef struct _formatdef {
@ -2310,18 +2316,24 @@ The variable struct.error is an exception raised on errors.\n");
static int
_structmodule_traverse(PyObject *module, visitproc visit, void *arg)
{
Py_VISIT(_structmodulestate(module)->PyStructType);
Py_VISIT(_structmodulestate(module)->unpackiter_type);
Py_VISIT(_structmodulestate(module)->StructError);
_structmodulestate *state = (_structmodulestate *)PyModule_GetState(module);
if (state) {
Py_VISIT(state->PyStructType);
Py_VISIT(state->unpackiter_type);
Py_VISIT(state->StructError);
}
return 0;
}
static int
_structmodule_clear(PyObject *module)
{
Py_CLEAR(_structmodulestate(module)->PyStructType);
Py_CLEAR(_structmodulestate(module)->unpackiter_type);
Py_CLEAR(_structmodulestate(module)->StructError);
_structmodulestate *state = (_structmodulestate *)PyModule_GetState(module);
if (state) {
Py_CLEAR(state->PyStructType);
Py_CLEAR(state->unpackiter_type);
Py_CLEAR(state->StructError);
}
return 0;
}
@ -2358,13 +2370,13 @@ PyInit__struct(void)
}
Py_INCREF(PyStructType);
PyModule_AddObject(m, "Struct", PyStructType);
_structmodulestate(m)->PyStructType = PyStructType;
get_struct_state(m)->PyStructType = PyStructType;
PyObject *unpackiter_type = PyType_FromSpec(&unpackiter_type_spec);
if (unpackiter_type == NULL) {
return NULL;
}
_structmodulestate(m)->unpackiter_type = unpackiter_type;
get_struct_state(m)->unpackiter_type = unpackiter_type;
/* Check endian and swap in faster functions */
{
@ -2411,7 +2423,7 @@ PyInit__struct(void)
return NULL;
Py_INCREF(StructError);
PyModule_AddObject(m, "error", StructError);
_structmodulestate(m)->StructError = StructError;
get_struct_state(m)->StructError = StructError;
return m;
}

26
Modules/atexitmodule.c
View File

@ -28,7 +28,13 @@ typedef struct {
int callback_len;
} atexitmodule_state;
#define GET_ATEXIT_STATE(mod) ((atexitmodule_state*)PyModule_GetState(mod))
static inline atexitmodule_state*
get_atexit_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (atexitmodule_state *)state;
}
static void
@ -72,7 +78,7 @@ atexit_callfuncs(PyObject *module)
if (module == NULL)
return;
modstate = GET_ATEXIT_STATE(module);
modstate = get_atexit_state(module);
if (modstate->ncallbacks == 0)
return;
@ -130,7 +136,7 @@ atexit_register(PyObject *self, PyObject *args, PyObject *kwargs)
atexit_callback *new_callback;
PyObject *func = NULL;
modstate = GET_ATEXIT_STATE(self);
modstate = get_atexit_state(self);
if (modstate->ncallbacks >= modstate->callback_len) {
atexit_callback **r;
@ -197,7 +203,7 @@ Clear the list of previously registered exit functions.");
static PyObject *
atexit_clear(PyObject *self, PyObject *unused)
{
atexit_cleanup(GET_ATEXIT_STATE(self));
atexit_cleanup(get_atexit_state(self));
Py_RETURN_NONE;
}
@ -211,7 +217,7 @@ atexit_ncallbacks(PyObject *self, PyObject *unused)
{
atexitmodule_state *modstate;
modstate = GET_ATEXIT_STATE(self);
modstate = get_atexit_state(self);
return PyLong_FromSsize_t(modstate->ncallbacks);
}
@ -222,7 +228,7 @@ atexit_m_traverse(PyObject *self, visitproc visit, void *arg)
int i;
atexitmodule_state *modstate;
modstate = GET_ATEXIT_STATE(self);
modstate = (atexitmodule_state *)PyModule_GetState(self);
if (modstate != NULL) {
for (i = 0; i < modstate->ncallbacks; i++) {
atexit_callback *cb = modstate->atexit_callbacks[i];
@ -240,7 +246,7 @@ static int
atexit_m_clear(PyObject *self)
{
atexitmodule_state *modstate;
modstate = GET_ATEXIT_STATE(self);
modstate = (atexitmodule_state *)PyModule_GetState(self);
if (modstate != NULL) {
atexit_cleanup(modstate);
}
@ -251,7 +257,7 @@ static void
atexit_free(PyObject *m)
{
atexitmodule_state *modstate;
modstate = GET_ATEXIT_STATE(m);
modstate = (atexitmodule_state *)PyModule_GetState(m);
if (modstate != NULL) {
atexit_cleanup(modstate);
PyMem_Free(modstate->atexit_callbacks);
@ -273,7 +279,7 @@ atexit_unregister(PyObject *self, PyObject *func)
atexit_callback *cb;
int i, eq;
modstate = GET_ATEXIT_STATE(self);
modstate = get_atexit_state(self);
for (i = 0; i < modstate->ncallbacks; i++)
{
@ -318,7 +324,7 @@ static int
atexit_exec(PyObject *m) {
atexitmodule_state *modstate;
modstate = GET_ATEXIT_STATE(m);
modstate = get_atexit_state(m);
modstate->callback_len = 32;
modstate->ncallbacks = 0;
modstate->atexit_callbacks = PyMem_New(atexit_callback*,

16
Modules/grpmodule.c
View File

@ -37,8 +37,16 @@ static PyStructSequence_Desc struct_group_type_desc = {
typedef struct {
PyTypeObject *StructGrpType;
} grpmodulestate;
#define modulestate(o) ((grpmodulestate *)PyModule_GetState(o))
#define modulestate_global modulestate(PyState_FindModule(&grpmodule))
static inline grpmodulestate*
get_grp_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (grpmodulestate *)state;
}
#define modulestate_global get_grp_state(PyState_FindModule(&grpmodule))
static struct PyModuleDef grpmodule;
@ -320,12 +328,12 @@ according to the password database. Check both databases to get\n\
complete membership information.)");
static int grpmodule_traverse(PyObject *m, visitproc visit, void *arg) {
Py_VISIT(modulestate(m)->StructGrpType);
Py_VISIT(get_grp_state(m)->StructGrpType);
return 0;
}
static int grpmodule_clear(PyObject *m) {
Py_CLEAR(modulestate(m)->StructGrpType);
Py_CLEAR(get_grp_state(m)->StructGrpType);
return 0;
}

93
Modules/posixmodule.c
View File

@ -842,7 +842,14 @@ typedef struct {
static struct PyModuleDef posixmodule;
#define _posixstate(o) ((_posixstate *)PyModule_GetState(o))
static inline _posixstate*
get_posix_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (_posixstate *)state;
}
#define _posixstate_global ((_posixstate *)PyModule_GetState(PyState_FindModule(&posixmodule)))
/*
@ -2103,48 +2110,48 @@ statresult_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
static int
_posix_clear(PyObject *module)
{
Py_CLEAR(_posixstate(module)->billion);
Py_CLEAR(_posixstate(module)->DirEntryType);
Py_CLEAR(_posixstate(module)->ScandirIteratorType);
Py_CLEAR(get_posix_state(module)->billion);
Py_CLEAR(get_posix_state(module)->DirEntryType);
Py_CLEAR(get_posix_state(module)->ScandirIteratorType);
#if defined(HAVE_SCHED_SETPARAM) || defined(HAVE_SCHED_SETSCHEDULER) || defined(POSIX_SPAWN_SETSCHEDULER) || defined(POSIX_SPAWN_SETSCHEDPARAM)
Py_CLEAR(_posixstate(module)->SchedParamType);
Py_CLEAR(get_posix_state(module)->SchedParamType);
#endif
Py_CLEAR(_posixstate(module)->StatResultType);
Py_CLEAR(_posixstate(module)->StatVFSResultType);
Py_CLEAR(_posixstate(module)->TerminalSizeType);
Py_CLEAR(_posixstate(module)->TimesResultType);
Py_CLEAR(_posixstate(module)->UnameResultType);
Py_CLEAR(get_posix_state(module)->StatResultType);
Py_CLEAR(get_posix_state(module)->StatVFSResultType);
Py_CLEAR(get_posix_state(module)->TerminalSizeType);
Py_CLEAR(get_posix_state(module)->TimesResultType);
Py_CLEAR(get_posix_state(module)->UnameResultType);
#if defined(HAVE_WAITID) && !defined(__APPLE__)
Py_CLEAR(_posixstate(module)->WaitidResultType);
Py_CLEAR(get_posix_state(module)->WaitidResultType);
#endif
#if defined(HAVE_WAIT3) || defined(HAVE_WAIT4)
Py_CLEAR(_posixstate(module)->struct_rusage);
Py_CLEAR(get_posix_state(module)->struct_rusage);
#endif
Py_CLEAR(_posixstate(module)->st_mode);
Py_CLEAR(get_posix_state(module)->st_mode);
return 0;
}
static int
_posix_traverse(PyObject *module, visitproc visit, void *arg)
{
Py_VISIT(_posixstate(module)->billion);
Py_VISIT(_posixstate(module)->DirEntryType);
Py_VISIT(_posixstate(module)->ScandirIteratorType);
Py_VISIT(get_posix_state(module)->billion);
Py_VISIT(get_posix_state(module)->DirEntryType);
Py_VISIT(get_posix_state(module)->ScandirIteratorType);
#if defined(HAVE_SCHED_SETPARAM) || defined(HAVE_SCHED_SETSCHEDULER) || defined(POSIX_SPAWN_SETSCHEDULER) || defined(POSIX_SPAWN_SETSCHEDPARAM)
Py_VISIT(_posixstate(module)->SchedParamType);
Py_VISIT(get_posix_state(module)->SchedParamType);
#endif
Py_VISIT(_posixstate(module)->StatResultType);
Py_VISIT(_posixstate(module)->StatVFSResultType);
Py_VISIT(_posixstate(module)->TerminalSizeType);
Py_VISIT(_posixstate(module)->TimesResultType);
Py_VISIT(_posixstate(module)->UnameResultType);
Py_VISIT(get_posix_state(module)->StatResultType);
Py_VISIT(get_posix_state(module)->StatVFSResultType);
Py_VISIT(get_posix_state(module)->TerminalSizeType);
Py_VISIT(get_posix_state(module)->TimesResultType);
Py_VISIT(get_posix_state(module)->UnameResultType);
#if defined(HAVE_WAITID) && !defined(__APPLE__)
Py_VISIT(_posixstate(module)->WaitidResultType);
Py_VISIT(get_posix_state(module)->WaitidResultType);
#endif
#if defined(HAVE_WAIT3) || defined(HAVE_WAIT4)
Py_VISIT(_posixstate(module)->struct_rusage);
Py_VISIT(get_posix_state(module)->struct_rusage);
#endif
Py_VISIT(_posixstate(module)->st_mode);
Py_VISIT(get_posix_state(module)->st_mode);
return 0;
}
@ -4673,7 +4680,7 @@ os_uname_impl(PyObject *module)
if (res < 0)
return posix_error();
PyObject *UnameResultType = _posixstate(module)->UnameResultType;
PyObject *UnameResultType = get_posix_state(module)->UnameResultType;
value = PyStructSequence_New((PyTypeObject *)UnameResultType);
if (value == NULL)
return NULL;
@ -7840,7 +7847,7 @@ os_waitid_impl(PyObject *module, idtype_t idtype, id_t id, int options)
if (si.si_pid == 0)
Py_RETURN_NONE;
PyObject *WaitidResultType = _posixstate(module)->WaitidResultType;
PyObject *WaitidResultType = get_posix_state(module)->WaitidResultType;
result = PyStructSequence_New((PyTypeObject *)WaitidResultType);
if (!result)
return NULL;
@ -12407,7 +12414,7 @@ get_terminal_size(PyObject *self, PyObject *args)
}
#endif /* TERMSIZE_USE_CONIO */
PyObject *TerminalSizeType = _posixstate(self)->TerminalSizeType;
PyObject *TerminalSizeType = get_posix_state(self)->TerminalSizeType;
termsize = PyStructSequence_New((PyTypeObject *)TerminalSizeType);
if (termsize == NULL)
return NULL;
@ -13425,7 +13432,7 @@ os_scandir_impl(PyObject *module, path_t *path)
return NULL;
}
PyObject *ScandirIteratorType = _posixstate(module)->ScandirIteratorType;
PyObject *ScandirIteratorType = get_posix_state(module)->ScandirIteratorType;
iterator = PyObject_New(ScandirIterator, (PyTypeObject *)ScandirIteratorType);
if (!iterator)
return NULL;
@ -14643,7 +14650,7 @@ INITFUNC(void)
}
Py_INCREF(WaitidResultType);
PyModule_AddObject(m, "waitid_result", WaitidResultType);
_posixstate(m)->WaitidResultType = WaitidResultType;
get_posix_state(m)->WaitidResultType = WaitidResultType;
#endif
stat_result_desc.name = "os.stat_result"; /* see issue #19209 */
@ -14656,7 +14663,7 @@ INITFUNC(void)
}
Py_INCREF(StatResultType);
PyModule_AddObject(m, "stat_result", StatResultType);
_posixstate(m)->StatResultType = StatResultType;
get_posix_state(m)->StatResultType = StatResultType;
structseq_new = ((PyTypeObject *)StatResultType)->tp_new;
((PyTypeObject *)StatResultType)->tp_new = statresult_new;
@ -14667,7 +14674,7 @@ INITFUNC(void)
}
Py_INCREF(StatVFSResultType);
PyModule_AddObject(m, "statvfs_result", StatVFSResultType);
_posixstate(m)->StatVFSResultType = StatVFSResultType;
get_posix_state(m)->StatVFSResultType = StatVFSResultType;
#ifdef NEED_TICKS_PER_SECOND
# if defined(HAVE_SYSCONF) && defined(_SC_CLK_TCK)
ticks_per_second = sysconf(_SC_CLK_TCK);
@ -14686,7 +14693,7 @@ INITFUNC(void)
}
Py_INCREF(SchedParamType);
PyModule_AddObject(m, "sched_param", SchedParamType);
_posixstate(m)->SchedParamType = SchedParamType;
get_posix_state(m)->SchedParamType = SchedParamType;
((PyTypeObject *)SchedParamType)->tp_new = os_sched_param;
#endif
@ -14697,14 +14704,14 @@ INITFUNC(void)
}
Py_INCREF(TerminalSizeType);
PyModule_AddObject(m, "terminal_size", TerminalSizeType);
_posixstate(m)->TerminalSizeType = TerminalSizeType;
get_posix_state(m)->TerminalSizeType = TerminalSizeType;
/* initialize scandir types */
PyObject *ScandirIteratorType = PyType_FromSpec(&ScandirIteratorType_spec);
if (ScandirIteratorType == NULL) {
return NULL;
}
_posixstate(m)->ScandirIteratorType = ScandirIteratorType;
get_posix_state(m)->ScandirIteratorType = ScandirIteratorType;
PyObject *DirEntryType = PyType_FromSpec(&DirEntryType_spec);
if (DirEntryType == NULL) {
@ -14712,7 +14719,7 @@ INITFUNC(void)
}
Py_INCREF(DirEntryType);
PyModule_AddObject(m, "DirEntry", DirEntryType);
_posixstate(m)->DirEntryType = DirEntryType;
get_posix_state(m)->DirEntryType = DirEntryType;
times_result_desc.name = MODNAME ".times_result";
PyObject *TimesResultType = (PyObject *)PyStructSequence_NewType(&times_result_desc);
@ -14721,7 +14728,7 @@ INITFUNC(void)
}
Py_INCREF(TimesResultType);
PyModule_AddObject(m, "times_result", TimesResultType);
_posixstate(m)->TimesResultType = TimesResultType;
get_posix_state(m)->TimesResultType = TimesResultType;
PyTypeObject *UnameResultType = PyStructSequence_NewType(&uname_result_desc);
if (UnameResultType == NULL) {
@ -14729,7 +14736,7 @@ INITFUNC(void)
}
Py_INCREF(UnameResultType);
PyModule_AddObject(m, "uname_result", (PyObject *)UnameResultType);
_posixstate(m)->UnameResultType = (PyObject *)UnameResultType;
get_posix_state(m)->UnameResultType = (PyObject *)UnameResultType;
#ifdef __APPLE__
/*
@ -14769,15 +14776,15 @@ INITFUNC(void)
#endif /* __APPLE__ */
if ((_posixstate(m)->billion = PyLong_FromLong(1000000000)) == NULL)
if ((get_posix_state(m)->billion = PyLong_FromLong(1000000000)) == NULL)
return NULL;
#if defined(HAVE_WAIT3) || defined(HAVE_WAIT4)
_posixstate(m)->struct_rusage = PyUnicode_InternFromString("struct_rusage");
if (_posixstate(m)->struct_rusage == NULL)
get_posix_state(m)->struct_rusage = PyUnicode_InternFromString("struct_rusage");
if (get_posix_state(m)->struct_rusage == NULL)
return NULL;
#endif
_posixstate(m)->st_mode = PyUnicode_InternFromString("st_mode");
if (_posixstate(m)->st_mode == NULL)
get_posix_state(m)->st_mode = PyUnicode_InternFromString("st_mode");
if (get_posix_state(m)->st_mode == NULL)
return NULL;
/* suppress "function not used" warnings */

16
Modules/pwdmodule.c
View File

@ -50,8 +50,16 @@ exception is raised if the entry asked for cannot be found.");
typedef struct {
PyTypeObject *StructPwdType;
} pwdmodulestate;
#define modulestate(o) ((pwdmodulestate *)PyModule_GetState(o))
#define modulestate_global modulestate(PyState_FindModule(&pwdmodule))
static inline pwdmodulestate*
get_pwd_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (pwdmodulestate *)state;
}
#define modulestate_global get_pwd_state(PyState_FindModule(&pwdmodule))
static struct PyModuleDef pwdmodule;
@ -316,11 +324,11 @@ static PyMethodDef pwd_methods[] = {
};
static int pwdmodule_traverse(PyObject *m, visitproc visit, void *arg) {
Py_VISIT(modulestate(m)->StructPwdType);
Py_VISIT(get_pwd_state(m)->StructPwdType);
return 0;
}
static int pwdmodule_clear(PyObject *m) {
Py_CLEAR(modulestate(m)->StructPwdType);
Py_CLEAR(get_pwd_state(m)->StructPwdType);
return 0;
}
static void pwdmodule_free(void *m) {

13
Modules/readline.c
View File

@ -86,13 +86,18 @@ typedef struct {
PyObject *endidx;
} readlinestate;
#define readline_state(o) ((readlinestate *)PyModule_GetState(o))
static inline readlinestate*
get_readline_state(PyModule *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (readlinestate *)state;
}
static int
readline_clear(PyObject *m)
{
readlinestate *state = readline_state(m);
readlinestate *state = get_readline_state(m);
Py_CLEAR(state->completion_display_matches_hook);
Py_CLEAR(state->startup_hook);
Py_CLEAR(state->pre_input_hook);
@ -105,7 +110,7 @@ readline_clear(PyObject *m)
static int
readline_traverse(PyObject *m, visitproc visit, void *arg)
{
readlinestate *state = readline_state(m);
readlinestate *state = get_readline_state(m);
Py_VISIT(state->completion_display_matches_hook);
Py_VISIT(state->startup_hook);
Py_VISIT(state->pre_input_hook);

53
Modules/selectmodule.c
View File

@ -69,8 +69,15 @@ typedef struct {
static struct PyModuleDef selectmodule;
#define _selectstate(o) ((_selectstate *)PyModule_GetState(o))
#define _selectstate_global _selectstate(PyState_FindModule(&selectmodule))
static inline _selectstate*
get_select_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (_selectstate *)state;
}
#define _selectstate_global get_select_state(PyState_FindModule(&selectmodule))
/*[clinic input]
module select
@ -2399,24 +2406,24 @@ On Windows, only sockets are supported; on Unix, all file descriptors.");
static int
_select_traverse(PyObject *module, visitproc visit, void *arg)
{
Py_VISIT(_selectstate(module)->close);
Py_VISIT(_selectstate(module)->poll_Type);
Py_VISIT(_selectstate(module)->devpoll_Type);
Py_VISIT(_selectstate(module)->pyEpoll_Type);
Py_VISIT(_selectstate(module)->kqueue_event_Type);
Py_VISIT(_selectstate(module)->kqueue_queue_Type);
Py_VISIT(get_select_state(module)->close);
Py_VISIT(get_select_state(module)->poll_Type);
Py_VISIT(get_select_state(module)->devpoll_Type);
Py_VISIT(get_select_state(module)->pyEpoll_Type);
Py_VISIT(get_select_state(module)->kqueue_event_Type);
Py_VISIT(get_select_state(module)->kqueue_queue_Type);
return 0;
}
static int
_select_clear(PyObject *module)
{
Py_CLEAR(_selectstate(module)->close);
Py_CLEAR(_selectstate(module)->poll_Type);
Py_CLEAR(_selectstate(module)->devpoll_Type);
Py_CLEAR(_selectstate(module)->pyEpoll_Type);
Py_CLEAR(_selectstate(module)->kqueue_event_Type);
Py_CLEAR(_selectstate(module)->kqueue_queue_Type);
Py_CLEAR(get_select_state(module)->close);
Py_CLEAR(get_select_state(module)->poll_Type);
Py_CLEAR(get_select_state(module)->devpoll_Type);
Py_CLEAR(get_select_state(module)->pyEpoll_Type);
Py_CLEAR(get_select_state(module)->kqueue_event_Type);
Py_CLEAR(get_select_state(module)->kqueue_queue_Type);
return 0;
}
@ -2446,7 +2453,7 @@ PyInit_select(void)
if (m == NULL)
return NULL;
_selectstate(m)->close = PyUnicode_InternFromString("close");
get_select_state(m)->close = PyUnicode_InternFromString("close");
Py_INCREF(PyExc_OSError);
PyModule_AddObject(m, "error", PyExc_OSError);
@ -2472,7 +2479,7 @@ PyInit_select(void)
PyObject *poll_Type = PyType_FromSpec(&poll_Type_spec);
if (poll_Type == NULL)
return NULL;
_selectstate(m)->poll_Type = (PyTypeObject *)poll_Type;
get_select_state(m)->poll_Type = (PyTypeObject *)poll_Type;
Py_INCREF(poll_Type);
PyModule_AddIntMacro(m, POLLIN);
@ -2508,7 +2515,7 @@ PyInit_select(void)
PyObject *devpoll_Type = PyType_FromSpec(&devpoll_Type_spec);
if (devpoll_Type == NULL)
return NULL;
_selectstate(m)->devpoll_Type = (PyTypeObject *)devpoll_Type;
get_select_state(m)->devpoll_Type = (PyTypeObject *)devpoll_Type;
Py_INCREF(devpoll_Type);
#endif
@ -2516,9 +2523,9 @@ PyInit_select(void)
PyObject *pyEpoll_Type = PyType_FromSpec(&pyEpoll_Type_spec);
if (pyEpoll_Type == NULL)
return NULL;
_selectstate(m)->pyEpoll_Type = (PyTypeObject *)pyEpoll_Type;
get_select_state(m)->pyEpoll_Type = (PyTypeObject *)pyEpoll_Type;
Py_INCREF(pyEpoll_Type);
PyModule_AddObject(m, "epoll", (PyObject *)_selectstate(m)->pyEpoll_Type);
PyModule_AddObject(m, "epoll", (PyObject *)get_select_state(m)->pyEpoll_Type);
PyModule_AddIntMacro(m, EPOLLIN);
PyModule_AddIntMacro(m, EPOLLOUT);
@ -2563,15 +2570,15 @@ PyInit_select(void)
PyObject *kqueue_event_Type = PyType_FromSpec(&kqueue_event_Type_spec);
if (kqueue_event_Type == NULL)
return NULL;
_selectstate(m)->kqueue_event_Type = (PyTypeObject *)kqueue_event_Type;
Py_INCREF(_selectstate(m)->kqueue_event_Type);
get_select_state(m)->kqueue_event_Type = (PyTypeObject *)kqueue_event_Type;
Py_INCREF(get_select_state(m)->kqueue_event_Type);
PyModule_AddObject(m, "kevent", kqueue_event_Type);
PyObject *kqueue_queue_Type = PyType_FromSpec(&kqueue_queue_Type_spec);
if (kqueue_queue_Type == NULL)
return NULL;
_selectstate(m)->kqueue_queue_Type = (PyTypeObject *)kqueue_queue_Type;
Py_INCREF(_selectstate(m)->kqueue_queue_Type);
get_select_state(m)->kqueue_queue_Type = (PyTypeObject *)kqueue_queue_Type;
Py_INCREF(get_select_state(m)->kqueue_queue_Type);
PyModule_AddObject(m, "kqueue", kqueue_queue_Type);
/* event filters */

18
Modules/termios.c
View File

@ -42,8 +42,16 @@ sys.stdin.fileno(), or a file object, such as sys.stdin itself.");
typedef struct {
PyObject *TermiosError;
} termiosmodulestate;
#define modulestate(o) ((termiosmodulestate *)PyModule_GetState(o))
#define modulestate_global modulestate(PyState_FindModule(&termiosmodule))
static inline termiosmodulestate*
get_termios_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (termiosmodulestate *)state;
}
#define modulestate_global get_termios_state(PyState_FindModule(&termiosmodule))
static int fdconv(PyObject* obj, void* p)
{
@ -976,12 +984,12 @@ static struct constant {
};
static int termiosmodule_traverse(PyObject *m, visitproc visit, void *arg) {
Py_VISIT(modulestate(m)->TermiosError);
Py_VISIT(get_termios_state(m)->TermiosError);
return 0;
}
static int termiosmodule_clear(PyObject *m) {
Py_CLEAR(modulestate(m)->TermiosError);
Py_CLEAR(get_termios_state(m)->TermiosError);
return 0;
}
@ -1016,7 +1024,7 @@ PyInit_termios(void)
return NULL;
}
termiosmodulestate *state = PyModule_GetState(m);
termiosmodulestate *state = get_termios_state(m);
state->TermiosError = PyErr_NewException("termios.error", NULL, NULL);
if (state->TermiosError == NULL) {
return NULL;

19
Modules/zlibmodule.c
View File

@ -40,7 +40,14 @@ typedef struct {
PyObject *ZlibError;
} _zlibstate;
#define _zlibstate(o) ((_zlibstate *)PyModule_GetState(o))
static inline _zlibstate*
get_zlib_state(PyObject *module)
{
void *state = PyModule_GetState(module);
assert(state != NULL);
return (_zlibstate *)state;
}
#define _zlibstate_global ((_zlibstate *)PyModule_GetState(PyState_FindModule(&zlibmodule)))
typedef struct
@ -1364,7 +1371,7 @@ PyDoc_STRVAR(zlib_module_documentation,
static int
zlib_clear(PyObject *m)
{
_zlibstate *state = _zlibstate(m);
_zlibstate *state = get_zlib_state(m);
Py_CLEAR(state->Comptype);
Py_CLEAR(state->Decomptype);
Py_CLEAR(state->ZlibError);
@ -1374,7 +1381,7 @@ zlib_clear(PyObject *m)
static int
zlib_traverse(PyObject *m, visitproc visit, void *arg)
{
_zlibstate *state = _zlibstate(m);
_zlibstate *state = get_zlib_state(m);
Py_VISIT(state->Comptype);
Py_VISIT(state->Decomptype);
Py_VISIT(state->ZlibError);
@ -1415,18 +1422,18 @@ PyInit_zlib(void)
PyTypeObject *Comptype = (PyTypeObject *)PyType_FromSpec(&Comptype_spec);
if (Comptype == NULL)
return NULL;
_zlibstate(m)->Comptype = Comptype;
get_zlib_state(m)->Comptype = Comptype;
PyTypeObject *Decomptype = (PyTypeObject *)PyType_FromSpec(&Decomptype_spec);
if (Decomptype == NULL)
return NULL;
_zlibstate(m)->Decomptype = Decomptype;
get_zlib_state(m)->Decomptype = Decomptype;
PyObject *ZlibError = PyErr_NewException("zlib.error", NULL, NULL);
if (ZlibError != NULL) {
Py_INCREF(ZlibError);
PyModule_AddObject(m, "error", ZlibError);
_zlibstate(m)->ZlibError = ZlibError;
get_zlib_state(m)->ZlibError = ZlibError;
}
PyModule_AddIntMacro(m, MAX_WBITS);
PyModule_AddIntMacro(m, DEFLATED);