From 1a3faba9f15e0c03c6cc0d225d377b8910b5379f Mon Sep 17 00:00:00 2001 From: Victor Stinner Date: Tue, 25 Jul 2023 15:28:30 +0200 Subject: gh-106869: Use new PyMemberDef constant names (#106871) * Remove '#include "structmember.h"'. * If needed, add to get offsetof() function. * Update Parser/asdl_c.py to regenerate Python/Python-ast.c. * Replace: * T_SHORT => Py_T_SHORT * T_INT => Py_T_INT * T_LONG => Py_T_LONG * T_FLOAT => Py_T_FLOAT * T_DOUBLE => Py_T_DOUBLE * T_STRING => Py_T_STRING * T_OBJECT => _Py_T_OBJECT * T_CHAR => Py_T_CHAR * T_BYTE => Py_T_BYTE * T_UBYTE => Py_T_UBYTE * T_USHORT => Py_T_USHORT * T_UINT => Py_T_UINT * T_ULONG => Py_T_ULONG * T_STRING_INPLACE => Py_T_STRING_INPLACE * T_BOOL => Py_T_BOOL * T_OBJECT_EX => Py_T_OBJECT_EX * T_LONGLONG => Py_T_LONGLONG * T_ULONGLONG => Py_T_ULONGLONG * T_PYSSIZET => Py_T_PYSSIZET * T_NONE => _Py_T_NONE * READONLY => Py_READONLY * PY_AUDIT_READ => Py_AUDIT_READ * READ_RESTRICTED => Py_AUDIT_READ * PY_WRITE_RESTRICTED => _Py_WRITE_RESTRICTED * RESTRICTED => (READ_RESTRICTED | _Py_WRITE_RESTRICTED) --- Include/internal/pycore_frame.h | 4 +- Modules/_asynciomodule.c | 2 +- Modules/_bz2module.c | 14 +++--- Modules/_collectionsmodule.c | 8 ++-- Modules/_csv.c | 15 +++--- Modules/_ctypes/_ctypes.c | 14 +++--- Modules/_ctypes/callproc.c | 6 +-- Modules/_datetimemodule.c | 8 ++-- Modules/_elementtree.c | 9 ++-- Modules/_functoolsmodule.c | 30 ++++++------ Modules/_io/bufferedio.c | 30 ++++++------ Modules/_io/bytesio.c | 4 +- Modules/_io/fileio.c | 10 ++-- Modules/_io/iobase.c | 4 +- Modules/_io/stringio.c | 4 +- Modules/_io/textio.c | 16 +++---- Modules/_io/winconsoleio.c | 10 ++-- Modules/_json.c | 30 ++++++------ Modules/_lzmamodule.c | 10 ++-- Modules/_multiprocessing/semaphore.c | 8 ++-- Modules/_operator.c | 6 +-- Modules/_pickle.c | 8 ++-- Modules/_queuemodule.c | 4 +- Modules/_sqlite/blob.c | 2 +- Modules/_sqlite/connection.c | 26 +++++----- Modules/_sqlite/cursor.c | 14 +++--- Modules/_sre/sre.c | 20 ++++---- Modules/_struct.c | 5 +- Modules/_testcapi/buffer.c | 4 +- Modules/_testcapi/heaptype.c | 25 +++++----- Modules/_testcapi/vectorcall.c | 4 +- Modules/_testcapi/vectorcall_limited.c | 4 +- Modules/_testcapimodule.c | 9 ++-- Modules/_threadmodule.c | 10 ++-- Modules/_winapi.c | 8 ++-- Modules/_zoneinfo.c | 10 ++-- Modules/arraymodule.c | 4 +- Modules/cjkcodecs/multibytecodec.c | 12 +++-- Modules/itertoolsmodule.c | 4 +- Modules/mmapmodule.c | 4 +- Modules/overlapped.c | 12 ++--- Modules/posixmodule.c | 6 +-- Modules/pyexpat.c | 7 ++- Modules/selectmodule.c | 35 +++++++------- Modules/sha2module.c | 2 +- Modules/socketmodule.c | 8 ++-- Modules/unicodedata.c | 4 +- Modules/xxsubtype.c | 5 +- Modules/zlibmodule.c | 20 ++++---- Objects/classobject.c | 8 ++-- Objects/codeobject.c | 30 ++++++------ Objects/complexobject.c | 6 +-- Objects/descrobject.c | 18 +++---- Objects/exceptions.c | 62 ++++++++++++------------ Objects/frameobject.c | 4 +- Objects/funcobject.c | 20 ++++---- Objects/genericaliasobject.c | 8 ++-- Objects/genobject.c | 8 ++-- Objects/methodobject.c | 4 +- Objects/moduleobject.c | 4 +- Objects/namespaceobject.c | 6 ++- Objects/rangeobject.c | 8 ++-- Objects/sliceobject.c | 8 ++-- Objects/structseq.c | 6 +-- Objects/typeobject.c | 42 ++++++++--------- Objects/typevarobject.c | 26 +++++----- Objects/unionobject.c | 4 +- Objects/weakrefobject.c | 4 +- PC/winreg.c | 4 +- Parser/asdl_c.py | 3 +- Python/Python-ast.c | 3 +- Python/bytecodes.c | 2 +- Python/ceval.c | 2 +- Python/context.c | 4 +- Python/specialize.c | 12 ++--- Python/structmember.c | 86 +++++++++++++++++----------------- Python/symtable.c | 18 +++---- Python/traceback.c | 8 ++-- 78 files changed, 472 insertions(+), 464 deletions(-) diff --git a/Include/internal/pycore_frame.h b/Include/internal/pycore_frame.h index efc19e3..5ff20ef 100644 --- a/Include/internal/pycore_frame.h +++ b/Include/internal/pycore_frame.h @@ -5,8 +5,8 @@ extern "C" { #endif #include -#include -#include "pycore_code.h" // STATS +#include // offsetof() +#include "pycore_code.h" // STATS /* See Objects/frame_layout.md for an explanation of the frame stack * including explanation of the PyFrameObject and _PyInterpreterFrame diff --git a/Modules/_asynciomodule.c b/Modules/_asynciomodule.c index ef9f7f8..f5a589b 100644 --- a/Modules/_asynciomodule.c +++ b/Modules/_asynciomodule.c @@ -8,7 +8,7 @@ #include "pycore_pylifecycle.h" // _Py_IsInterpreterFinalizing() #include "pycore_pystate.h" // _PyThreadState_GET() #include "pycore_runtime_init.h" // _Py_ID() -#include "structmember.h" // PyMemberDef + #include // offsetof() diff --git a/Modules/_bz2module.c b/Modules/_bz2module.c index eeefe60..0a84f25 100644 --- a/Modules/_bz2module.c +++ b/Modules/_bz2module.c @@ -1,10 +1,10 @@ /* _bz2 - Low-level Python interface to libbzip2. */ #include "Python.h" -#include "structmember.h" // PyMemberDef #include #include +#include // offsetof() // Blocks output buffer wrappers #include "pycore_blocks_output_buffer.h" @@ -112,7 +112,7 @@ typedef struct { typedef struct { PyObject_HEAD bz_stream bzs; - char eof; /* T_BOOL expects a char */ + char eof; /* Py_T_BOOL expects a char */ PyObject *unused_data; char needs_input; char *input_buffer; @@ -714,11 +714,11 @@ PyDoc_STRVAR(BZ2Decompressor_needs_input_doc, "True if more input is needed before more decompressed data can be produced."); static PyMemberDef BZ2Decompressor_members[] = { - {"eof", T_BOOL, offsetof(BZ2Decompressor, eof), - READONLY, BZ2Decompressor_eof__doc__}, - {"unused_data", T_OBJECT_EX, offsetof(BZ2Decompressor, unused_data), - READONLY, BZ2Decompressor_unused_data__doc__}, - {"needs_input", T_BOOL, offsetof(BZ2Decompressor, needs_input), READONLY, + {"eof", Py_T_BOOL, offsetof(BZ2Decompressor, eof), + Py_READONLY, BZ2Decompressor_eof__doc__}, + {"unused_data", Py_T_OBJECT_EX, offsetof(BZ2Decompressor, unused_data), + Py_READONLY, BZ2Decompressor_unused_data__doc__}, + {"needs_input", Py_T_BOOL, offsetof(BZ2Decompressor, needs_input), Py_READONLY, BZ2Decompressor_needs_input_doc}, {NULL} }; diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c index 9a81531..f2915f8 100644 --- a/Modules/_collectionsmodule.c +++ b/Modules/_collectionsmodule.c @@ -3,7 +3,7 @@ #include "pycore_long.h" // _PyLong_GetZero() #include "pycore_moduleobject.h" // _PyModule_GetState() #include "pycore_typeobject.h" // _PyType_GetModuleState() -#include "structmember.h" // PyMemberDef + #include typedef struct { @@ -1630,7 +1630,7 @@ static PyMethodDef deque_methods[] = { }; static PyMemberDef deque_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(dequeobject, weakreflist), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(dequeobject, weakreflist), Py_READONLY}, {NULL}, }; @@ -2054,7 +2054,7 @@ static PyMethodDef defdict_methods[] = { }; static PyMemberDef defdict_members[] = { - {"default_factory", T_OBJECT, + {"default_factory", _Py_T_OBJECT, offsetof(defdictobject, default_factory), 0, PyDoc_STR("Factory for default value called by __missing__().")}, {NULL} @@ -2466,7 +2466,7 @@ tuplegetter_repr(_tuplegetterobject *self) static PyMemberDef tuplegetter_members[] = { - {"__doc__", T_OBJECT, offsetof(_tuplegetterobject, doc), 0}, + {"__doc__", _Py_T_OBJECT, offsetof(_tuplegetterobject, doc), 0}, {0} }; diff --git a/Modules/_csv.c b/Modules/_csv.c index c36d980..24a57e3 100644 --- a/Modules/_csv.c +++ b/Modules/_csv.c @@ -11,7 +11,8 @@ module instead. #define MODULE_VERSION "1.0" #include "Python.h" -#include "structmember.h" // PyMemberDef + +#include // offsetof() #include /*[clinic input] @@ -336,9 +337,9 @@ dialect_check_quoting(int quoting) #define D_OFF(x) offsetof(DialectObj, x) static struct PyMemberDef Dialect_memberlist[] = { - { "skipinitialspace", T_BOOL, D_OFF(skipinitialspace), READONLY }, - { "doublequote", T_BOOL, D_OFF(doublequote), READONLY }, - { "strict", T_BOOL, D_OFF(strict), READONLY }, + { "skipinitialspace", Py_T_BOOL, D_OFF(skipinitialspace), Py_READONLY }, + { "doublequote", Py_T_BOOL, D_OFF(doublequote), Py_READONLY }, + { "strict", Py_T_BOOL, D_OFF(strict), Py_READONLY }, { NULL } }; @@ -970,8 +971,8 @@ static struct PyMethodDef Reader_methods[] = { #define R_OFF(x) offsetof(ReaderObj, x) static struct PyMemberDef Reader_memberlist[] = { - { "dialect", T_OBJECT, R_OFF(dialect), READONLY }, - { "line_num", T_ULONG, R_OFF(line_num), READONLY }, + { "dialect", _Py_T_OBJECT, R_OFF(dialect), Py_READONLY }, + { "line_num", Py_T_ULONG, R_OFF(line_num), Py_READONLY }, { NULL } }; @@ -1364,7 +1365,7 @@ static struct PyMethodDef Writer_methods[] = { #define W_OFF(x) offsetof(WriterObj, x) static struct PyMemberDef Writer_memberlist[] = { - { "dialect", T_OBJECT, W_OFF(dialect), READONLY }, + { "dialect", _Py_T_OBJECT, W_OFF(dialect), Py_READONLY }, { NULL } }; diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c index 200fd36..c20d6ae 100644 --- a/Modules/_ctypes/_ctypes.c +++ b/Modules/_ctypes/_ctypes.c @@ -110,7 +110,7 @@ bytes(cdata) #include "pycore_call.h" // _PyObject_CallNoArgs() #include "pycore_ceval.h" // _Py_EnterRecursiveCall() -#include "structmember.h" // PyMemberDef + #include #ifdef MS_WIN32 @@ -2759,14 +2759,14 @@ PyCData_dealloc(PyObject *self) } static PyMemberDef PyCData_members[] = { - { "_b_base_", T_OBJECT, - offsetof(CDataObject, b_base), READONLY, + { "_b_base_", _Py_T_OBJECT, + offsetof(CDataObject, b_base), Py_READONLY, "the base object" }, - { "_b_needsfree_", T_INT, - offsetof(CDataObject, b_needsfree), READONLY, + { "_b_needsfree_", Py_T_INT, + offsetof(CDataObject, b_needsfree), Py_READONLY, "whether the object owns the memory or not" }, - { "_objects", T_OBJECT, - offsetof(CDataObject, b_objects), READONLY, + { "_objects", _Py_T_OBJECT, + offsetof(CDataObject, b_objects), Py_READONLY, "internal objects tree (NEVER CHANGE THIS OBJECT!)"}, { NULL }, }; diff --git a/Modules/_ctypes/callproc.c b/Modules/_ctypes/callproc.c index b3831ae..69cf8a9 100644 --- a/Modules/_ctypes/callproc.c +++ b/Modules/_ctypes/callproc.c @@ -59,7 +59,7 @@ #endif #include "Python.h" -#include "structmember.h" // PyMemberDef + #include @@ -581,8 +581,8 @@ PyCArg_repr(PyCArgObject *self) } static PyMemberDef PyCArgType_members[] = { - { "_obj", T_OBJECT, - offsetof(PyCArgObject, obj), READONLY, + { "_obj", _Py_T_OBJECT, + offsetof(PyCArgObject, obj), Py_READONLY, "the wrapped object" }, { NULL }, }; diff --git a/Modules/_datetimemodule.c b/Modules/_datetimemodule.c index e0e34b7..9002a1d 100644 --- a/Modules/_datetimemodule.c +++ b/Modules/_datetimemodule.c @@ -15,7 +15,7 @@ #include "pycore_long.h" // _PyLong_GetOne() #include "pycore_object.h" // _PyObject_Init() #include "datetime.h" -#include "structmember.h" // PyMemberDef + #include @@ -2727,13 +2727,13 @@ delta_reduce(PyDateTime_Delta* self, PyObject *Py_UNUSED(ignored)) static PyMemberDef delta_members[] = { - {"days", T_INT, OFFSET(days), READONLY, + {"days", Py_T_INT, OFFSET(days), Py_READONLY, PyDoc_STR("Number of days.")}, - {"seconds", T_INT, OFFSET(seconds), READONLY, + {"seconds", Py_T_INT, OFFSET(seconds), Py_READONLY, PyDoc_STR("Number of seconds (>= 0 and less than 1 day).")}, - {"microseconds", T_INT, OFFSET(microseconds), READONLY, + {"microseconds", Py_T_INT, OFFSET(microseconds), Py_READONLY, PyDoc_STR("Number of microseconds (>= 0 and less than 1 second).")}, {NULL} }; diff --git a/Modules/_elementtree.c b/Modules/_elementtree.c index 30327e0..8cb57e6 100644 --- a/Modules/_elementtree.c +++ b/Modules/_elementtree.c @@ -18,7 +18,8 @@ #include "Python.h" #include "pycore_import.h" // _PyImport_GetModuleAttrString() #include "pycore_pyhash.h" // _Py_HashSecret -#include "structmember.h" // PyMemberDef + +#include // offsetof() #include "expat.h" #include "pyexpat.h" @@ -4134,8 +4135,8 @@ _elementtree_XMLParser__setevents_impl(XMLParserObject *self, } static PyMemberDef xmlparser_members[] = { - {"entity", T_OBJECT, offsetof(XMLParserObject, entity), READONLY, NULL}, - {"target", T_OBJECT, offsetof(XMLParserObject, target), READONLY, NULL}, + {"entity", _Py_T_OBJECT, offsetof(XMLParserObject, entity), Py_READONLY, NULL}, + {"target", _Py_T_OBJECT, offsetof(XMLParserObject, target), Py_READONLY, NULL}, {NULL} }; @@ -4191,7 +4192,7 @@ static PyMethodDef element_methods[] = { }; static struct PyMemberDef element_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(ElementObject, weakreflist), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(ElementObject, weakreflist), Py_READONLY}, {NULL}, }; diff --git a/Modules/_functoolsmodule.c b/Modules/_functoolsmodule.c index c987485..389ff43 100644 --- a/Modules/_functoolsmodule.c +++ b/Modules/_functoolsmodule.c @@ -6,7 +6,7 @@ #include "pycore_object.h" // _PyObject_GC_TRACK #include "pycore_pystate.h" // _PyThreadState_GET() #include "pycore_tuple.h" // _PyTuple_ITEMS() -#include "structmember.h" // PyMemberDef + #include "clinic/_functoolsmodule.c.h" /*[clinic input] @@ -340,18 +340,18 @@ PyDoc_STRVAR(partial_doc, #define OFF(x) offsetof(partialobject, x) static PyMemberDef partial_memberlist[] = { - {"func", T_OBJECT, OFF(fn), READONLY, + {"func", _Py_T_OBJECT, OFF(fn), Py_READONLY, "function object to use in future partial calls"}, - {"args", T_OBJECT, OFF(args), READONLY, + {"args", _Py_T_OBJECT, OFF(args), Py_READONLY, "tuple of arguments to future partial calls"}, - {"keywords", T_OBJECT, OFF(kw), READONLY, + {"keywords", _Py_T_OBJECT, OFF(kw), Py_READONLY, "dictionary of keyword arguments to future partial calls"}, - {"__weaklistoffset__", T_PYSSIZET, - offsetof(partialobject, weakreflist), READONLY}, - {"__dictoffset__", T_PYSSIZET, - offsetof(partialobject, dict), READONLY}, - {"__vectorcalloffset__", T_PYSSIZET, - offsetof(partialobject, vectorcall), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, + offsetof(partialobject, weakreflist), Py_READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, + offsetof(partialobject, dict), Py_READONLY}, + {"__vectorcalloffset__", Py_T_PYSSIZET, + offsetof(partialobject, vectorcall), Py_READONLY}, {NULL} /* Sentinel */ }; @@ -540,7 +540,7 @@ keyobject_traverse(keyobject *ko, visitproc visit, void *arg) } static PyMemberDef keyobject_members[] = { - {"obj", T_OBJECT, + {"obj", _Py_T_OBJECT, offsetof(keyobject, object), 0, PyDoc_STR("Value wrapped by a key function.")}, {NULL} @@ -1394,10 +1394,10 @@ static PyGetSetDef lru_cache_getsetlist[] = { }; static PyMemberDef lru_cache_memberlist[] = { - {"__dictoffset__", T_PYSSIZET, - offsetof(lru_cache_object, dict), READONLY}, - {"__weaklistoffset__", T_PYSSIZET, - offsetof(lru_cache_object, weakreflist), READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, + offsetof(lru_cache_object, dict), Py_READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, + offsetof(lru_cache_object, weakreflist), Py_READONLY}, {NULL} /* Sentinel */ }; diff --git a/Modules/_io/bufferedio.c b/Modules/_io/bufferedio.c index efc8cb9..0983a7b 100644 --- a/Modules/_io/bufferedio.c +++ b/Modules/_io/bufferedio.c @@ -13,7 +13,7 @@ #include "pycore_object.h" // _PyObject_GC_UNTRACK() #include "pycore_pyerrors.h" // _Py_FatalErrorFormat() #include "pycore_pylifecycle.h" // _Py_IsInterpreterFinalizing() -#include "structmember.h" // PyMemberDef + #include "_iomodule.h" /*[clinic input] @@ -2478,10 +2478,10 @@ static PyMethodDef bufferedreader_methods[] = { }; static PyMemberDef bufferedreader_members[] = { - {"raw", T_OBJECT, offsetof(buffered, raw), READONLY}, - {"_finalizing", T_BOOL, offsetof(buffered, finalizing), 0}, - {"__weaklistoffset__", T_PYSSIZET, offsetof(buffered, weakreflist), READONLY}, - {"__dictoffset__", T_PYSSIZET, offsetof(buffered, dict), READONLY}, + {"raw", _Py_T_OBJECT, offsetof(buffered, raw), Py_READONLY}, + {"_finalizing", Py_T_BOOL, offsetof(buffered, finalizing), 0}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(buffered, weakreflist), Py_READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, offsetof(buffered, dict), Py_READONLY}, {NULL} }; @@ -2538,10 +2538,10 @@ static PyMethodDef bufferedwriter_methods[] = { }; static PyMemberDef bufferedwriter_members[] = { - {"raw", T_OBJECT, offsetof(buffered, raw), READONLY}, - {"_finalizing", T_BOOL, offsetof(buffered, finalizing), 0}, - {"__weaklistoffset__", T_PYSSIZET, offsetof(buffered, weakreflist), READONLY}, - {"__dictoffset__", T_PYSSIZET, offsetof(buffered, dict), READONLY}, + {"raw", _Py_T_OBJECT, offsetof(buffered, raw), Py_READONLY}, + {"_finalizing", Py_T_BOOL, offsetof(buffered, finalizing), 0}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(buffered, weakreflist), Py_READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, offsetof(buffered, dict), Py_READONLY}, {NULL} }; @@ -2594,8 +2594,8 @@ static PyMethodDef bufferedrwpair_methods[] = { }; static PyMemberDef bufferedrwpair_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(rwpair, weakreflist), READONLY}, - {"__dictoffset__", T_PYSSIZET, offsetof(rwpair, dict), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(rwpair, weakreflist), Py_READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, offsetof(rwpair, dict), Py_READONLY}, {NULL} }; @@ -2656,10 +2656,10 @@ static PyMethodDef bufferedrandom_methods[] = { }; static PyMemberDef bufferedrandom_members[] = { - {"raw", T_OBJECT, offsetof(buffered, raw), READONLY}, - {"_finalizing", T_BOOL, offsetof(buffered, finalizing), 0}, - {"__weaklistoffset__", T_PYSSIZET, offsetof(buffered, weakreflist), READONLY}, - {"__dictoffset__", T_PYSSIZET, offsetof(buffered, dict), READONLY}, + {"raw", _Py_T_OBJECT, offsetof(buffered, raw), Py_READONLY}, + {"_finalizing", Py_T_BOOL, offsetof(buffered, finalizing), 0}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(buffered, weakreflist), Py_READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, offsetof(buffered, dict), Py_READONLY}, {NULL} }; diff --git a/Modules/_io/bytesio.c b/Modules/_io/bytesio.c index 8077305..3ab503c 100644 --- a/Modules/_io/bytesio.c +++ b/Modules/_io/bytesio.c @@ -1028,8 +1028,8 @@ static struct PyMethodDef bytesio_methods[] = { }; static PyMemberDef bytesio_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(bytesio, weakreflist), READONLY}, - {"__dictoffset__", T_PYSSIZET, offsetof(bytesio, dict), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(bytesio, weakreflist), Py_READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, offsetof(bytesio, dict), Py_READONLY}, {NULL} }; diff --git a/Modules/_io/fileio.c b/Modules/_io/fileio.c index 39709fd..7fe37ee 100644 --- a/Modules/_io/fileio.c +++ b/Modules/_io/fileio.c @@ -3,7 +3,7 @@ #include "Python.h" #include "pycore_fileutils.h" // _Py_BEGIN_SUPPRESS_IPH #include "pycore_object.h" // _PyObject_GC_UNTRACK() -#include "structmember.h" // PyMemberDef + #include #ifdef HAVE_SYS_TYPES_H #include @@ -1199,10 +1199,10 @@ static PyGetSetDef fileio_getsetlist[] = { }; static PyMemberDef fileio_members[] = { - {"_blksize", T_UINT, offsetof(fileio, blksize), 0}, - {"_finalizing", T_BOOL, offsetof(fileio, finalizing), 0}, - {"__weaklistoffset__", T_PYSSIZET, offsetof(fileio, weakreflist), READONLY}, - {"__dictoffset__", T_PYSSIZET, offsetof(fileio, dict), READONLY}, + {"_blksize", Py_T_UINT, offsetof(fileio, blksize), 0}, + {"_finalizing", Py_T_BOOL, offsetof(fileio, finalizing), 0}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(fileio, weakreflist), Py_READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, offsetof(fileio, dict), Py_READONLY}, {NULL} }; diff --git a/Modules/_io/iobase.c b/Modules/_io/iobase.c index e2e8ef4..5fd1989 100644 --- a/Modules/_io/iobase.c +++ b/Modules/_io/iobase.c @@ -863,8 +863,8 @@ static PyGetSetDef iobase_getset[] = { }; static struct PyMemberDef iobase_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(iobase, weakreflist), READONLY}, - {"__dictoffset__", T_PYSSIZET, offsetof(iobase, dict), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(iobase, weakreflist), Py_READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, offsetof(iobase, dict), Py_READONLY}, {NULL}, }; diff --git a/Modules/_io/stringio.c b/Modules/_io/stringio.c index 1960002..1856b07 100644 --- a/Modules/_io/stringio.c +++ b/Modules/_io/stringio.c @@ -1002,8 +1002,8 @@ static PyGetSetDef stringio_getset[] = { }; static struct PyMemberDef stringio_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(stringio, weakreflist), READONLY}, - {"__dictoffset__", T_PYSSIZET, offsetof(stringio, dict), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(stringio, weakreflist), Py_READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, offsetof(stringio, dict), Py_READONLY}, {NULL}, }; diff --git a/Modules/_io/textio.c b/Modules/_io/textio.c index a5cf9fc..24d846e 100644 --- a/Modules/_io/textio.c +++ b/Modules/_io/textio.c @@ -14,7 +14,7 @@ #include "pycore_fileutils.h" // _Py_GetLocaleEncoding() #include "pycore_object.h" // _PyObject_GC_UNTRACK() #include "pycore_pystate.h" // _PyInterpreterState_GET() -#include "structmember.h" // PyMemberDef + #include "_iomodule.h" /*[clinic input] @@ -3230,13 +3230,13 @@ static PyMethodDef textiowrapper_methods[] = { }; static PyMemberDef textiowrapper_members[] = { - {"encoding", T_OBJECT, offsetof(textio, encoding), READONLY}, - {"buffer", T_OBJECT, offsetof(textio, buffer), READONLY}, - {"line_buffering", T_BOOL, offsetof(textio, line_buffering), READONLY}, - {"write_through", T_BOOL, offsetof(textio, write_through), READONLY}, - {"_finalizing", T_BOOL, offsetof(textio, finalizing), 0}, - {"__weaklistoffset__", T_PYSSIZET, offsetof(textio, weakreflist), READONLY}, - {"__dictoffset__", T_PYSSIZET, offsetof(textio, dict), READONLY}, + {"encoding", _Py_T_OBJECT, offsetof(textio, encoding), Py_READONLY}, + {"buffer", _Py_T_OBJECT, offsetof(textio, buffer), Py_READONLY}, + {"line_buffering", Py_T_BOOL, offsetof(textio, line_buffering), Py_READONLY}, + {"write_through", Py_T_BOOL, offsetof(textio, write_through), Py_READONLY}, + {"_finalizing", Py_T_BOOL, offsetof(textio, finalizing), 0}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(textio, weakreflist), Py_READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, offsetof(textio, dict), Py_READONLY}, {NULL} }; diff --git a/Modules/_io/winconsoleio.c b/Modules/_io/winconsoleio.c index 452b12c..a1ed7eb 100644 --- a/Modules/_io/winconsoleio.c +++ b/Modules/_io/winconsoleio.c @@ -12,7 +12,7 @@ #ifdef HAVE_WINDOWS_CONSOLE_IO -#include "structmember.h" // PyMemberDef + #ifdef HAVE_SYS_TYPES_H #include #endif @@ -1141,10 +1141,10 @@ static PyGetSetDef winconsoleio_getsetlist[] = { }; static PyMemberDef winconsoleio_members[] = { - {"_blksize", T_UINT, offsetof(winconsoleio, blksize), 0}, - {"_finalizing", T_BOOL, offsetof(winconsoleio, finalizing), 0}, - {"__weaklistoffset__", T_PYSSIZET, offsetof(winconsoleio, weakreflist), READONLY}, - {"__dictoffset__", T_PYSSIZET, offsetof(winconsoleio, dict), READONLY}, + {"_blksize", Py_T_UINT, offsetof(winconsoleio, blksize), 0}, + {"_finalizing", Py_T_BOOL, offsetof(winconsoleio, finalizing), 0}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(winconsoleio, weakreflist), Py_READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, offsetof(winconsoleio, dict), Py_READONLY}, {NULL} }; diff --git a/Modules/_json.c b/Modules/_json.c index 2d0e30d..4fcaa07 100644 --- a/Modules/_json.c +++ b/Modules/_json.c @@ -11,7 +11,7 @@ #include "Python.h" #include "pycore_ceval.h" // _Py_EnterRecursiveCall() #include "pycore_runtime.h" // _PyRuntime -#include "structmember.h" // PyMemberDef + #include "pycore_global_objects.h" // _Py_ID() #include // bool @@ -28,12 +28,12 @@ typedef struct _PyScannerObject { } PyScannerObject; static PyMemberDef scanner_members[] = { - {"strict", T_BOOL, offsetof(PyScannerObject, strict), READONLY, "strict"}, - {"object_hook", T_OBJECT, offsetof(PyScannerObject, object_hook), READONLY, "object_hook"}, - {"object_pairs_hook", T_OBJECT, offsetof(PyScannerObject, object_pairs_hook), READONLY}, - {"parse_float", T_OBJECT, offsetof(PyScannerObject, parse_float), READONLY, "parse_float"}, - {"parse_int", T_OBJECT, offsetof(PyScannerObject, parse_int), READONLY, "parse_int"}, - {"parse_constant", T_OBJECT, offsetof(PyScannerObject, parse_constant), READONLY, "parse_constant"}, + {"strict", Py_T_BOOL, offsetof(PyScannerObject, strict), Py_READONLY, "strict"}, + {"object_hook", _Py_T_OBJECT, offsetof(PyScannerObject, object_hook), Py_READONLY, "object_hook"}, + {"object_pairs_hook", _Py_T_OBJECT, offsetof(PyScannerObject, object_pairs_hook), Py_READONLY}, + {"parse_float", _Py_T_OBJECT, offsetof(PyScannerObject, parse_float), Py_READONLY, "parse_float"}, + {"parse_int", _Py_T_OBJECT, offsetof(PyScannerObject, parse_int), Py_READONLY, "parse_int"}, + {"parse_constant", _Py_T_OBJECT, offsetof(PyScannerObject, parse_constant), Py_READONLY, "parse_constant"}, {NULL} }; @@ -52,14 +52,14 @@ typedef struct _PyEncoderObject { } PyEncoderObject; static PyMemberDef encoder_members[] = { - {"markers", T_OBJECT, offsetof(PyEncoderObject, markers), READONLY, "markers"}, - {"default", T_OBJECT, offsetof(PyEncoderObject, defaultfn), READONLY, "default"}, - {"encoder", T_OBJECT, offsetof(PyEncoderObject, encoder), READONLY, "encoder"}, - {"indent", T_OBJECT, offsetof(PyEncoderObject, indent), READONLY, "indent"}, - {"key_separator", T_OBJECT, offsetof(PyEncoderObject, key_separator), READONLY, "key_separator"}, - {"item_separator", T_OBJECT, offsetof(PyEncoderObject, item_separator), READONLY, "item_separator"}, - {"sort_keys", T_BOOL, offsetof(PyEncoderObject, sort_keys), READONLY, "sort_keys"}, - {"skipkeys", T_BOOL, offsetof(PyEncoderObject, skipkeys), READONLY, "skipkeys"}, + {"markers", _Py_T_OBJECT, offsetof(PyEncoderObject, markers), Py_READONLY, "markers"}, + {"default", _Py_T_OBJECT, offsetof(PyEncoderObject, defaultfn), Py_READONLY, "default"}, + {"encoder", _Py_T_OBJECT, offsetof(PyEncoderObject, encoder), Py_READONLY, "encoder"}, + {"indent", _Py_T_OBJECT, offsetof(PyEncoderObject, indent), Py_READONLY, "indent"}, + {"key_separator", _Py_T_OBJECT, offsetof(PyEncoderObject, key_separator), Py_READONLY, "key_separator"}, + {"item_separator", _Py_T_OBJECT, offsetof(PyEncoderObject, item_separator), Py_READONLY, "item_separator"}, + {"sort_keys", Py_T_BOOL, offsetof(PyEncoderObject, sort_keys), Py_READONLY, "sort_keys"}, + {"skipkeys", Py_T_BOOL, offsetof(PyEncoderObject, skipkeys), Py_READONLY, "skipkeys"}, {NULL} }; diff --git a/Modules/_lzmamodule.c b/Modules/_lzmamodule.c index edb2e36..c548f8f 100644 --- a/Modules/_lzmamodule.c +++ b/Modules/_lzmamodule.c @@ -6,7 +6,7 @@ */ #include "Python.h" -#include "structmember.h" // PyMemberDef + #include // free() #include @@ -1338,13 +1338,13 @@ PyDoc_STRVAR(Decompressor_unused_data_doc, "Data found after the end of the compressed stream."); static PyMemberDef Decompressor_members[] = { - {"check", T_INT, offsetof(Decompressor, check), READONLY, + {"check", Py_T_INT, offsetof(Decompressor, check), Py_READONLY, Decompressor_check_doc}, - {"eof", T_BOOL, offsetof(Decompressor, eof), READONLY, + {"eof", Py_T_BOOL, offsetof(Decompressor, eof), Py_READONLY, Decompressor_eof_doc}, - {"needs_input", T_BOOL, offsetof(Decompressor, needs_input), READONLY, + {"needs_input", Py_T_BOOL, offsetof(Decompressor, needs_input), Py_READONLY, Decompressor_needs_input_doc}, - {"unused_data", T_OBJECT_EX, offsetof(Decompressor, unused_data), READONLY, + {"unused_data", Py_T_OBJECT_EX, offsetof(Decompressor, unused_data), Py_READONLY, Decompressor_unused_data_doc}, {NULL} }; diff --git a/Modules/_multiprocessing/semaphore.c b/Modules/_multiprocessing/semaphore.c index 897b8db..771f86e 100644 --- a/Modules/_multiprocessing/semaphore.c +++ b/Modules/_multiprocessing/semaphore.c @@ -734,13 +734,13 @@ static PyMethodDef semlock_methods[] = { */ static PyMemberDef semlock_members[] = { - {"handle", T_SEM_HANDLE, offsetof(SemLockObject, handle), READONLY, + {"handle", T_SEM_HANDLE, offsetof(SemLockObject, handle), Py_READONLY, ""}, - {"kind", T_INT, offsetof(SemLockObject, kind), READONLY, + {"kind", Py_T_INT, offsetof(SemLockObject, kind), Py_READONLY, ""}, - {"maxvalue", T_INT, offsetof(SemLockObject, maxvalue), READONLY, + {"maxvalue", Py_T_INT, offsetof(SemLockObject, maxvalue), Py_READONLY, ""}, - {"name", T_STRING, offsetof(SemLockObject, name), READONLY, + {"name", Py_T_STRING, offsetof(SemLockObject, name), Py_READONLY, ""}, {NULL} }; diff --git a/Modules/_operator.c b/Modules/_operator.c index 108f45f..b59bfe9 100644 --- a/Modules/_operator.c +++ b/Modules/_operator.c @@ -3,7 +3,7 @@ #include "pycore_moduleobject.h" // _PyModule_GetState() #include "pycore_runtime.h" // _Py_ID() -#include "structmember.h" // PyMemberDef + #include "clinic/_operator.c.h" typedef struct { @@ -1153,7 +1153,7 @@ static PyMethodDef itemgetter_methods[] = { }; static PyMemberDef itemgetter_members[] = { - {"__vectorcalloffset__", T_PYSSIZET, offsetof(itemgetterobject, vectorcall), READONLY}, + {"__vectorcalloffset__", Py_T_PYSSIZET, offsetof(itemgetterobject, vectorcall), Py_READONLY}, {NULL} /* Sentinel */ }; @@ -1508,7 +1508,7 @@ static PyMethodDef attrgetter_methods[] = { }; static PyMemberDef attrgetter_members[] = { - {"__vectorcalloffset__", T_PYSSIZET, offsetof(attrgetterobject, vectorcall), READONLY}, + {"__vectorcalloffset__", Py_T_PYSSIZET, offsetof(attrgetterobject, vectorcall), Py_READONLY}, {NULL} /* Sentinel*/ }; diff --git a/Modules/_pickle.c b/Modules/_pickle.c index d9395e3..d4c0be7 100644 --- a/Modules/_pickle.c +++ b/Modules/_pickle.c @@ -16,7 +16,7 @@ #include "pycore_pystate.h" // _PyThreadState_GET() #include "pycore_runtime.h" // _Py_ID() #include "pycore_setobject.h" // _PySet_NextEntry() -#include "structmember.h" // PyMemberDef + #include // strtol() @@ -5074,9 +5074,9 @@ Pickler_set_persid(PicklerObject *self, PyObject *value, void *Py_UNUSED(ignored } static PyMemberDef Pickler_members[] = { - {"bin", T_INT, offsetof(PicklerObject, bin)}, - {"fast", T_INT, offsetof(PicklerObject, fast)}, - {"dispatch_table", T_OBJECT_EX, offsetof(PicklerObject, dispatch_table)}, + {"bin", Py_T_INT, offsetof(PicklerObject, bin)}, + {"fast", Py_T_INT, offsetof(PicklerObject, fast)}, + {"dispatch_table", Py_T_OBJECT_EX, offsetof(PicklerObject, dispatch_table)}, {NULL} }; diff --git a/Modules/_queuemodule.c b/Modules/_queuemodule.c index 69cc051..b0a36f0 100644 --- a/Modules/_queuemodule.c +++ b/Modules/_queuemodule.c @@ -5,7 +5,7 @@ #include "Python.h" #include "pycore_moduleobject.h" // _PyModule_GetState() #include "pycore_time.h" // _PyTime_t -#include "structmember.h" // PyMemberDef + #include // offsetof() typedef struct { @@ -373,7 +373,7 @@ static PyMethodDef simplequeue_methods[] = { }; static struct PyMemberDef simplequeue_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(simplequeueobject, weakreflist), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(simplequeueobject, weakreflist), Py_READONLY}, {NULL}, }; diff --git a/Modules/_sqlite/blob.c b/Modules/_sqlite/blob.c index 989d9a8..f099020 100644 --- a/Modules/_sqlite/blob.c +++ b/Modules/_sqlite/blob.c @@ -577,7 +577,7 @@ static PyMethodDef blob_methods[] = { }; static struct PyMemberDef blob_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(pysqlite_Blob, in_weakreflist), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(pysqlite_Blob, in_weakreflist), Py_READONLY}, {NULL}, }; diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c index bab7436..ddd7ace 100644 --- a/Modules/_sqlite/connection.c +++ b/Modules/_sqlite/connection.c @@ -26,7 +26,7 @@ #endif #include "module.h" -#include "structmember.h" // PyMemberDef + #include "connection.h" #include "statement.h" #include "cursor.h" @@ -2511,18 +2511,18 @@ static PyMethodDef connection_methods[] = { static struct PyMemberDef connection_members[] = { - {"Warning", T_OBJECT, offsetof(pysqlite_Connection, Warning), READONLY}, - {"Error", T_OBJECT, offsetof(pysqlite_Connection, Error), READONLY}, - {"InterfaceError", T_OBJECT, offsetof(pysqlite_Connection, InterfaceError), READONLY}, - {"DatabaseError", T_OBJECT, offsetof(pysqlite_Connection, DatabaseError), READONLY}, - {"DataError", T_OBJECT, offsetof(pysqlite_Connection, DataError), READONLY}, - {"OperationalError", T_OBJECT, offsetof(pysqlite_Connection, OperationalError), READONLY}, - {"IntegrityError", T_OBJECT, offsetof(pysqlite_Connection, IntegrityError), READONLY}, - {"InternalError", T_OBJECT, offsetof(pysqlite_Connection, InternalError), READONLY}, - {"ProgrammingError", T_OBJECT, offsetof(pysqlite_Connection, ProgrammingError), READONLY}, - {"NotSupportedError", T_OBJECT, offsetof(pysqlite_Connection, NotSupportedError), READONLY}, - {"row_factory", T_OBJECT, offsetof(pysqlite_Connection, row_factory)}, - {"text_factory", T_OBJECT, offsetof(pysqlite_Connection, text_factory)}, + {"Warning", _Py_T_OBJECT, offsetof(pysqlite_Connection, Warning), Py_READONLY}, + {"Error", _Py_T_OBJECT, offsetof(pysqlite_Connection, Error), Py_READONLY}, + {"InterfaceError", _Py_T_OBJECT, offsetof(pysqlite_Connection, InterfaceError), Py_READONLY}, + {"DatabaseError", _Py_T_OBJECT, offsetof(pysqlite_Connection, DatabaseError), Py_READONLY}, + {"DataError", _Py_T_OBJECT, offsetof(pysqlite_Connection, DataError), Py_READONLY}, + {"OperationalError", _Py_T_OBJECT, offsetof(pysqlite_Connection, OperationalError), Py_READONLY}, + {"IntegrityError", _Py_T_OBJECT, offsetof(pysqlite_Connection, IntegrityError), Py_READONLY}, + {"InternalError", _Py_T_OBJECT, offsetof(pysqlite_Connection, InternalError), Py_READONLY}, + {"ProgrammingError", _Py_T_OBJECT, offsetof(pysqlite_Connection, ProgrammingError), Py_READONLY}, + {"NotSupportedError", _Py_T_OBJECT, offsetof(pysqlite_Connection, NotSupportedError), Py_READONLY}, + {"row_factory", _Py_T_OBJECT, offsetof(pysqlite_Connection, row_factory)}, + {"text_factory", _Py_T_OBJECT, offsetof(pysqlite_Connection, text_factory)}, {NULL} }; diff --git a/Modules/_sqlite/cursor.c b/Modules/_sqlite/cursor.c index dba8ab6..618ce53 100644 --- a/Modules/_sqlite/cursor.c +++ b/Modules/_sqlite/cursor.c @@ -1325,13 +1325,13 @@ static PyMethodDef cursor_methods[] = { static struct PyMemberDef cursor_members[] = { - {"connection", T_OBJECT, offsetof(pysqlite_Cursor, connection), READONLY}, - {"description", T_OBJECT, offsetof(pysqlite_Cursor, description), READONLY}, - {"arraysize", T_INT, offsetof(pysqlite_Cursor, arraysize), 0}, - {"lastrowid", T_OBJECT, offsetof(pysqlite_Cursor, lastrowid), READONLY}, - {"rowcount", T_LONG, offsetof(pysqlite_Cursor, rowcount), READONLY}, - {"row_factory", T_OBJECT, offsetof(pysqlite_Cursor, row_factory), 0}, - {"__weaklistoffset__", T_PYSSIZET, offsetof(pysqlite_Cursor, in_weakreflist), READONLY}, + {"connection", _Py_T_OBJECT, offsetof(pysqlite_Cursor, connection), Py_READONLY}, + {"description", _Py_T_OBJECT, offsetof(pysqlite_Cursor, description), Py_READONLY}, + {"arraysize", Py_T_INT, offsetof(pysqlite_Cursor, arraysize), 0}, + {"lastrowid", _Py_T_OBJECT, offsetof(pysqlite_Cursor, lastrowid), Py_READONLY}, + {"rowcount", Py_T_LONG, offsetof(pysqlite_Cursor, rowcount), Py_READONLY}, + {"row_factory", _Py_T_OBJECT, offsetof(pysqlite_Cursor, row_factory), 0}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(pysqlite_Cursor, in_weakreflist), Py_READONLY}, {NULL} }; diff --git a/Modules/_sre/sre.c b/Modules/_sre/sre.c index ddbdc9f..c4e43a0 100644 --- a/Modules/_sre/sre.c +++ b/Modules/_sre/sre.c @@ -41,7 +41,7 @@ static const char copyright[] = #include "Python.h" #include "pycore_long.h" // _PyLong_GetZero() #include "pycore_moduleobject.h" // _PyModule_GetState() -#include "structmember.h" // PyMemberDef + #include "sre.h" @@ -2994,13 +2994,13 @@ static PyGetSetDef pattern_getset[] = { #define PAT_OFF(x) offsetof(PatternObject, x) static PyMemberDef pattern_members[] = { - {"pattern", T_OBJECT, PAT_OFF(pattern), READONLY, + {"pattern", _Py_T_OBJECT, PAT_OFF(pattern), Py_READONLY, "The pattern string from which the RE object was compiled."}, - {"flags", T_INT, PAT_OFF(flags), READONLY, + {"flags", Py_T_INT, PAT_OFF(flags), Py_READONLY, "The regex matching flags."}, - {"groups", T_PYSSIZET, PAT_OFF(groups), READONLY, + {"groups", Py_T_PYSSIZET, PAT_OFF(groups), Py_READONLY, "The number of capturing groups in the pattern."}, - {"__weaklistoffset__", T_PYSSIZET, offsetof(PatternObject, weakreflist), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(PatternObject, weakreflist), Py_READONLY}, {NULL} /* Sentinel */ }; @@ -3053,13 +3053,13 @@ static PyGetSetDef match_getset[] = { #define MATCH_OFF(x) offsetof(MatchObject, x) static PyMemberDef match_members[] = { - {"string", T_OBJECT, MATCH_OFF(string), READONLY, + {"string", _Py_T_OBJECT, MATCH_OFF(string), Py_READONLY, "The string passed to match() or search()."}, - {"re", T_OBJECT, MATCH_OFF(pattern), READONLY, + {"re", _Py_T_OBJECT, MATCH_OFF(pattern), Py_READONLY, "The regular expression object."}, - {"pos", T_PYSSIZET, MATCH_OFF(pos), READONLY, + {"pos", Py_T_PYSSIZET, MATCH_OFF(pos), Py_READONLY, "The index into the string at which the RE engine started looking for a match."}, - {"endpos", T_PYSSIZET, MATCH_OFF(endpos), READONLY, + {"endpos", Py_T_PYSSIZET, MATCH_OFF(endpos), Py_READONLY, "The index into the string beyond which the RE engine will not go."}, {NULL} }; @@ -3103,7 +3103,7 @@ static PyMethodDef scanner_methods[] = { #define SCAN_OFF(x) offsetof(ScannerObject, x) static PyMemberDef scanner_members[] = { - {"pattern", T_OBJECT, SCAN_OFF(pattern), READONLY}, + {"pattern", _Py_T_OBJECT, SCAN_OFF(pattern), Py_READONLY}, {NULL} /* Sentinel */ }; diff --git a/Modules/_struct.c b/Modules/_struct.c index 31c9492..425715a 100644 --- a/Modules/_struct.c +++ b/Modules/_struct.c @@ -10,8 +10,9 @@ #include "Python.h" #include "pycore_bytesobject.h" // _PyBytesWriter #include "pycore_moduleobject.h" // _PyModule_GetState() -#include "structmember.h" // PyMemberDef + #include +#include // offsetof() /*[clinic input] class Struct "PyStructObject *" "&PyStructType" @@ -2176,7 +2177,7 @@ static struct PyMethodDef s_methods[] = { }; static PyMemberDef s_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(PyStructObject, weakreflist), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(PyStructObject, weakreflist), Py_READONLY}, {NULL} /* sentinel */ }; diff --git a/Modules/_testcapi/buffer.c b/Modules/_testcapi/buffer.c index aff9a47..9427741 100644 --- a/Modules/_testcapi/buffer.c +++ b/Modules/_testcapi/buffer.c @@ -2,7 +2,7 @@ #include "parts.h" -#include "structmember.h" // PyMemberDef + #include // offsetof typedef struct { @@ -72,7 +72,7 @@ static PyBufferProcs testbuf_as_buffer = { }; static struct PyMemberDef testbuf_members[] = { - {"references", T_PYSSIZET, offsetof(testBufObject, references), READONLY}, + {"references", Py_T_PYSSIZET, offsetof(testBufObject, references), Py_READONLY}, {NULL}, }; diff --git a/Modules/_testcapi/heaptype.c b/Modules/_testcapi/heaptype.c index 2da06f4..d14a176 100644 --- a/Modules/_testcapi/heaptype.c +++ b/Modules/_testcapi/heaptype.c @@ -1,5 +1,6 @@ #include "parts.h" -#include "structmember.h" // PyMemberDef +#include // offsetof() + static struct PyModuleDef *_testcapimodule = NULL; // set at initialization @@ -332,7 +333,7 @@ typedef struct { static struct PyMemberDef members_to_repeat[] = { - {"T_INT", T_INT, offsetof(HeapCTypeWithDataObject, data), 0, NULL}, + {"Py_T_INT", Py_T_INT, offsetof(HeapCTypeWithDataObject, data), 0, NULL}, {NULL} }; @@ -477,7 +478,7 @@ typedef struct { } HeapCTypeObject; static struct PyMemberDef heapctype_members[] = { - {"value", T_INT, offsetof(HeapCTypeObject, value)}, + {"value", Py_T_INT, offsetof(HeapCTypeObject, value)}, {NULL} /* Sentinel */ }; @@ -571,7 +572,7 @@ heapctypesubclass_init(PyObject *self, PyObject *args, PyObject *kwargs) } static struct PyMemberDef heapctypesubclass_members[] = { - {"value2", T_INT, offsetof(HeapCTypeSubclassObject, value2)}, + {"value2", Py_T_INT, offsetof(HeapCTypeSubclassObject, value2)}, {NULL} /* Sentinel */ }; @@ -772,8 +773,8 @@ static PyGetSetDef heapctypewithdict_getsetlist[] = { }; static struct PyMemberDef heapctypewithdict_members[] = { - {"dictobj", T_OBJECT, offsetof(HeapCTypeWithDictObject, dict)}, - {"__dictoffset__", T_PYSSIZET, offsetof(HeapCTypeWithDictObject, dict), READONLY}, + {"dictobj", _Py_T_OBJECT, offsetof(HeapCTypeWithDictObject, dict)}, + {"__dictoffset__", Py_T_PYSSIZET, offsetof(HeapCTypeWithDictObject, dict), Py_READONLY}, {NULL} /* Sentinel */ }; @@ -867,8 +868,8 @@ static PyType_Spec HeapCTypeWithManagedWeakref_spec = { }; static struct PyMemberDef heapctypewithnegativedict_members[] = { - {"dictobj", T_OBJECT, offsetof(HeapCTypeWithDictObject, dict)}, - {"__dictoffset__", T_PYSSIZET, -(Py_ssize_t)sizeof(void*), READONLY}, + {"dictobj", _Py_T_OBJECT, offsetof(HeapCTypeWithDictObject, dict)}, + {"__dictoffset__", Py_T_PYSSIZET, -(Py_ssize_t)sizeof(void*), Py_READONLY}, {NULL} /* Sentinel */ }; @@ -893,9 +894,9 @@ typedef struct { } HeapCTypeWithWeakrefObject; static struct PyMemberDef heapctypewithweakref_members[] = { - {"weakreflist", T_OBJECT, offsetof(HeapCTypeWithWeakrefObject, weakreflist)}, - {"__weaklistoffset__", T_PYSSIZET, - offsetof(HeapCTypeWithWeakrefObject, weakreflist), READONLY}, + {"weakreflist", _Py_T_OBJECT, offsetof(HeapCTypeWithWeakrefObject, weakreflist)}, + {"__weaklistoffset__", Py_T_PYSSIZET, + offsetof(HeapCTypeWithWeakrefObject, weakreflist), Py_READONLY}, {NULL} /* Sentinel */ }; @@ -943,7 +944,7 @@ typedef struct { } HeapCTypeSetattrObject; static struct PyMemberDef heapctypesetattr_members[] = { - {"pvalue", T_LONG, offsetof(HeapCTypeSetattrObject, value)}, + {"pvalue", Py_T_LONG, offsetof(HeapCTypeSetattrObject, value)}, {NULL} /* Sentinel */ }; diff --git a/Modules/_testcapi/vectorcall.c b/Modules/_testcapi/vectorcall.c index 5ee468b..61c6e0f 100644 --- a/Modules/_testcapi/vectorcall.c +++ b/Modules/_testcapi/vectorcall.c @@ -1,7 +1,7 @@ #include "parts.h" #include "clinic/vectorcall.c.h" -#include "structmember.h" // PyMemberDef + #include // offsetof /*[clinic input] @@ -197,7 +197,7 @@ PyMethodDef VectorCallClass_methods[] = { }; PyMemberDef VectorCallClass_members[] = { - {"__vectorcalloffset__", T_PYSSIZET, 0/* set later */, READONLY}, + {"__vectorcalloffset__", Py_T_PYSSIZET, 0/* set later */, Py_READONLY}, {NULL} }; diff --git a/Modules/_testcapi/vectorcall_limited.c b/Modules/_testcapi/vectorcall_limited.c index a69f1d3..a96925e 100644 --- a/Modules/_testcapi/vectorcall_limited.c +++ b/Modules/_testcapi/vectorcall_limited.c @@ -3,7 +3,7 @@ #ifdef LIMITED_API_AVAILABLE -#include "structmember.h" // PyMemberDef + /* Test Vectorcall in the limited API */ @@ -132,7 +132,7 @@ leave: } static PyMemberDef LimitedVectorCallClass_members[] = { - {"__vectorcalloffset__", T_PYSSIZET, sizeof(PyObject), READONLY}, + {"__vectorcalloffset__", Py_T_PYSSIZET, sizeof(PyObject), Py_READONLY}, {NULL} }; diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c index 065a7fb..2286a92 100644 --- a/Modules/_testcapimodule.c +++ b/Modules/_testcapimodule.c @@ -20,15 +20,16 @@ #include "Python.h" #include "frameobject.h" // PyFrame_New #include "marshal.h" // PyMarshal_WriteLongToFile -#include "structmember.h" // for offsetof(), T_OBJECT + #include // FLT_MAX #include +#include // offsetof() #ifndef MS_WINDOWS -#include +# include #endif #ifdef HAVE_SYS_WAIT_H -#include // W_STOPCODE +# include // W_STOPCODE #endif #ifdef Py_BUILD_CORE @@ -4257,7 +4258,7 @@ ContainerNoGC_dealloc(ContainerNoGCobject *self) } static PyMemberDef ContainerNoGC_members[] = { - {"value", T_OBJECT, offsetof(ContainerNoGCobject, value), READONLY, + {"value", _Py_T_OBJECT, offsetof(ContainerNoGCobject, value), Py_READONLY, PyDoc_STR("a container value for test purposes")}, {0} }; diff --git a/Modules/_threadmodule.c b/Modules/_threadmodule.c index d8a797f..52f44d0 100644 --- a/Modules/_threadmodule.c +++ b/Modules/_threadmodule.c @@ -9,7 +9,7 @@ #include "pycore_pystate.h" // _PyThreadState_SetCurrent() #include "pycore_weakref.h" // _PyWeakref_GET_REF() #include // offsetof() -#include "structmember.h" // PyMemberDef + #ifdef HAVE_SIGNAL_H # include // SIGINT @@ -293,7 +293,7 @@ unlock it. A thread attempting to lock a lock that it has already locked\n\ will block until another thread unlocks it. Deadlocks may ensue."); static PyMemberDef lock_type_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(lockobject, in_weakreflist), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(lockobject, in_weakreflist), Py_READONLY}, {NULL}, }; @@ -575,7 +575,7 @@ static PyMethodDef rlock_methods[] = { static PyMemberDef rlock_type_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(rlockobject, in_weakreflist), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(rlockobject, in_weakreflist), Py_READONLY}, {NULL}, }; @@ -679,7 +679,7 @@ localdummy_dealloc(localdummyobject *self) } static PyMemberDef local_dummy_type_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(localdummyobject, weakreflist), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(localdummyobject, weakreflist), Py_READONLY}, {NULL}, }; @@ -959,7 +959,7 @@ local_setattro(localobject *self, PyObject *name, PyObject *v) static PyObject *local_getattro(localobject *, PyObject *); static PyMemberDef local_type_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(localobject, weakreflist), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(localobject, weakreflist), Py_READONLY}, {NULL}, }; diff --git a/Modules/_winapi.c b/Modules/_winapi.c index 313c12a..0edb36d 100644 --- a/Modules/_winapi.c +++ b/Modules/_winapi.c @@ -38,7 +38,7 @@ #include "pycore_moduleobject.h" // _PyModule_GetState() #include "pycore_pylifecycle.h" // _Py_IsInterpreterFinalizing() #include "pycore_pystate.h" // _PyInterpreterState_GET -#include "structmember.h" // PyMemberDef + #ifndef WINDOWS_LEAN_AND_MEAN @@ -54,13 +54,13 @@ PyLong_FromUnsignedLong((unsigned long) handle) #define PYNUM_TO_HANDLE(obj) ((HANDLE)PyLong_AsUnsignedLong(obj)) #define F_POINTER "k" -#define T_POINTER T_ULONG +#define T_POINTER Py_T_ULONG #else #define HANDLE_TO_PYNUM(handle) \ PyLong_FromUnsignedLongLong((unsigned long long) handle) #define PYNUM_TO_HANDLE(obj) ((HANDLE)PyLong_AsUnsignedLongLong(obj)) #define F_POINTER "K" -#define T_POINTER T_ULONGLONG +#define T_POINTER Py_T_ULONGLONG #endif #define F_HANDLE F_POINTER @@ -322,7 +322,7 @@ static PyMethodDef overlapped_methods[] = { static PyMemberDef overlapped_members[] = { {"event", T_HANDLE, offsetof(OverlappedObject, overlapped) + offsetof(OVERLAPPED, hEvent), - READONLY, "overlapped event handle"}, + Py_READONLY, "overlapped event handle"}, {NULL} }; diff --git a/Modules/_zoneinfo.c b/Modules/_zoneinfo.c index 0ced9d0..fb0b4b4 100644 --- a/Modules/_zoneinfo.c +++ b/Modules/_zoneinfo.c @@ -4,7 +4,7 @@ #include "Python.h" #include "pycore_long.h" // _PyLong_GetOne() -#include "structmember.h" + #include #include @@ -2692,13 +2692,13 @@ static PyMethodDef zoneinfo_methods[] = { static PyMemberDef zoneinfo_members[] = { {.name = "key", .offset = offsetof(PyZoneInfo_ZoneInfo, key), - .type = T_OBJECT_EX, - .flags = READONLY, + .type = Py_T_OBJECT_EX, + .flags = Py_READONLY, .doc = NULL}, {.name = "__weaklistoffset__", .offset = offsetof(PyZoneInfo_ZoneInfo, weakreflist), - .type = T_PYSSIZET, - .flags = READONLY}, + .type = Py_T_PYSSIZET, + .flags = Py_READONLY}, {NULL}, /* Sentinel */ }; diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c index 80a9542..a40a5b7 100644 --- a/Modules/arraymodule.c +++ b/Modules/arraymodule.c @@ -11,7 +11,7 @@ #include "pycore_call.h" // _PyObject_CallMethod() #include "pycore_moduleobject.h" // _PyModule_GetState() #include "pycore_bytesobject.h" // _PyBytes_Repeat -#include "structmember.h" // PyMemberDef + #include // offsetof() #include @@ -2895,7 +2895,7 @@ itemsize -- the length in bytes of one array item\n\ static PyObject *array_iter(arrayobject *ao); static struct PyMemberDef array_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(arrayobject, weakreflist), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(arrayobject, weakreflist), Py_READONLY}, {NULL}, }; diff --git a/Modules/cjkcodecs/multibytecodec.c b/Modules/cjkcodecs/multibytecodec.c index 3febd1a..5d3c16a 100644 --- a/Modules/cjkcodecs/multibytecodec.c +++ b/Modules/cjkcodecs/multibytecodec.c @@ -9,10 +9,12 @@ #endif #include "Python.h" -#include "structmember.h" // PyMemberDef + #include "multibytecodec.h" #include "clinic/multibytecodec.c.h" +#include // offsetof() + #define MODULE_NAME "_multibytecodec" typedef struct { @@ -1611,9 +1613,9 @@ static struct PyMethodDef mbstreamreader_methods[] = { }; static PyMemberDef mbstreamreader_members[] = { - {"stream", T_OBJECT, + {"stream", _Py_T_OBJECT, offsetof(MultibyteStreamReaderObject, stream), - READONLY, NULL}, + Py_READONLY, NULL}, {NULL,} }; @@ -1919,9 +1921,9 @@ static struct PyMethodDef mbstreamwriter_methods[] = { }; static PyMemberDef mbstreamwriter_members[] = { - {"stream", T_OBJECT, + {"stream", _Py_T_OBJECT, offsetof(MultibyteStreamWriterObject, stream), - READONLY, NULL}, + Py_READONLY, NULL}, {NULL,} }; diff --git a/Modules/itertoolsmodule.c b/Modules/itertoolsmodule.c index f5f7bf3..0ab6d33 100644 --- a/Modules/itertoolsmodule.c +++ b/Modules/itertoolsmodule.c @@ -5,7 +5,7 @@ #include "pycore_typeobject.h" // _PyType_GetModuleState() #include "pycore_object.h" // _PyObject_GC_TRACK() #include "pycore_tuple.h" // _PyTuple_ITEMS() -#include "structmember.h" // PyMemberDef + #include // offsetof() /* Itertools module written and maintained @@ -1090,7 +1090,7 @@ static PyMethodDef tee_methods[] = { }; static PyMemberDef tee_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(teeobject, weakreflist), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(teeobject, weakreflist), Py_READONLY}, {NULL}, }; diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c index cfbd2f4..5c13157 100644 --- a/Modules/mmapmodule.c +++ b/Modules/mmapmodule.c @@ -25,7 +25,7 @@ #include #include "pycore_bytesobject.h" // _PyBytes_Find() #include "pycore_fileutils.h" // _Py_stat_struct -#include "structmember.h" // PyMemberDef + #include // offsetof() // to support MS_WINDOWS_SYSTEM OpenFileMappingA / CreateFileMappingA @@ -883,7 +883,7 @@ mmap_madvise_method(mmap_object *self, PyObject *args) #endif // HAVE_MADVISE static struct PyMemberDef mmap_object_members[] = { - {"__weaklistoffset__", T_PYSSIZET, offsetof(mmap_object, weakreflist), READONLY}, + {"__weaklistoffset__", Py_T_PYSSIZET, offsetof(mmap_object, weakreflist), Py_READONLY}, {NULL}, }; diff --git a/Modules/overlapped.c b/Modules/overlapped.c index 7d3976f..271f6ce 100644 --- a/Modules/overlapped.c +++ b/Modules/overlapped.c @@ -8,7 +8,7 @@ Check itemsize */ #include "Python.h" -#include "structmember.h" // PyMemberDef + #define WINDOWS_LEAN_AND_MEAN #include @@ -17,10 +17,10 @@ #if defined(MS_WIN32) && !defined(MS_WIN64) # define F_POINTER "k" -# define T_POINTER T_ULONG +# define T_POINTER Py_T_ULONG #else # define F_POINTER "K" -# define T_POINTER T_ULONGLONG +# define T_POINTER Py_T_ULONGLONG #endif #define F_HANDLE F_POINTER @@ -1942,12 +1942,12 @@ static PyMethodDef Overlapped_methods[] = { }; static PyMemberDef Overlapped_members[] = { - {"error", T_ULONG, + {"error", Py_T_ULONG, offsetof(OverlappedObject, error), - READONLY, "Error from last operation"}, + Py_READONLY, "Error from last operation"}, {"event", T_HANDLE, offsetof(OverlappedObject, overlapped) + offsetof(OVERLAPPED, hEvent), - READONLY, "Overlapped event handle"}, + Py_READONLY, "Overlapped event handle"}, {NULL} }; diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c index 7e04d12..bab2ac2 100644 --- a/Modules/posixmodule.c +++ b/Modules/posixmodule.c @@ -36,7 +36,7 @@ # endif /* MS_WINDOWS_DESKTOP | MS_WINDOWS_SYSTEM */ #endif -#include "structmember.h" // PyMemberDef + #ifndef MS_WINDOWS # include "posixmodule.h" #else @@ -14822,9 +14822,9 @@ os_DirEntry___fspath___impl(DirEntry *self) } static PyMemberDef DirEntry_members[] = { - {"name", T_OBJECT_EX, offsetof(DirEntry, name), READONLY, + {"name", Py_T_OBJECT_EX, offsetof(DirEntry, name), Py_READONLY, "the entry's base filename, relative to scandir() \"path\" argument"}, - {"path", T_OBJECT_EX, offsetof(DirEntry, path), READONLY, + {"path", Py_T_OBJECT_EX, offsetof(DirEntry, path), Py_READONLY, "the entry's full path name; equivalent to os.path.join(scandir_path, entry.name)"}, {NULL} }; diff --git a/Modules/pyexpat.c b/Modules/pyexpat.c index d8395e9..a8ce84c 100644 --- a/Modules/pyexpat.c +++ b/Modules/pyexpat.c @@ -5,11 +5,10 @@ #include "Python.h" #include "pycore_import.h" // _PyImport_SetModule() #include "pycore_pyhash.h" // _Py_HashSecret -#include -#include "structmember.h" // PyMemberDef +#include +#include // offsetof() #include "expat.h" - #include "pyexpat.h" /* Do not emit Clinic output to a file as that wreaks havoc with conditionally @@ -1471,7 +1470,7 @@ xmlparse_specified_attributes_setter(xmlparseobject *self, PyObject *v, void *cl } static PyMemberDef xmlparse_members[] = { - {"intern", T_OBJECT, offsetof(xmlparseobject, intern), READONLY, NULL}, + {"intern", _Py_T_OBJECT, offsetof(xmlparseobject, intern), Py_READONLY, NULL}, {NULL} }; diff --git a/Modules/selectmodule.c b/Modules/selectmodule.c index 7ab0804..94d2469 100644 --- a/Modules/selectmodule.c +++ b/Modules/selectmodule.c @@ -15,7 +15,8 @@ #include "Python.h" #include "pycore_fileutils.h" // _Py_set_inheritable() #include "pycore_time.h" // _PyTime_t -#include "structmember.h" // PyMemberDef + +#include // offsetof() #ifdef HAVE_SYS_DEVPOLL_H #include @@ -1758,18 +1759,18 @@ typedef struct { #if (SIZEOF_UINTPTR_T != SIZEOF_VOID_P) # error uintptr_t does not match void *! #elif (SIZEOF_UINTPTR_T == SIZEOF_LONG_LONG) -# define T_UINTPTRT T_ULONGLONG -# define T_INTPTRT T_LONGLONG +# define T_UINTPTRT Py_T_ULONGLONG +# define T_INTPTRT Py_T_LONGLONG # define UINTPTRT_FMT_UNIT "K" # define INTPTRT_FMT_UNIT "L" #elif (SIZEOF_UINTPTR_T == SIZEOF_LONG) -# define T_UINTPTRT T_ULONG -# define T_INTPTRT T_LONG +# define T_UINTPTRT Py_T_ULONG +# define T_INTPTRT Py_T_LONG # define UINTPTRT_FMT_UNIT "k" # define INTPTRT_FMT_UNIT "l" #elif (SIZEOF_UINTPTR_T == SIZEOF_INT) -# define T_UINTPTRT T_UINT -# define T_INTPTRT T_INT +# define T_UINTPTRT Py_T_UINT +# define T_INTPTRT Py_T_INT # define UINTPTRT_FMT_UNIT "I" # define INTPTRT_FMT_UNIT "i" #else @@ -1777,26 +1778,26 @@ typedef struct { #endif #if SIZEOF_LONG_LONG == 8 -# define T_INT64 T_LONGLONG +# define T_INT64 Py_T_LONGLONG # define INT64_FMT_UNIT "L" #elif SIZEOF_LONG == 8 -# define T_INT64 T_LONG +# define T_INT64 Py_T_LONG # define INT64_FMT_UNIT "l" #elif SIZEOF_INT == 8 -# define T_INT64 T_INT +# define T_INT64 Py_T_INT # define INT64_FMT_UNIT "i" #else # define INT64_FMT_UNIT "_" #endif #if SIZEOF_LONG_LONG == 4 -# define T_UINT32 T_ULONGLONG +# define T_UINT32 Py_T_ULONGLONG # define UINT32_FMT_UNIT "K" #elif SIZEOF_LONG == 4 -# define T_UINT32 T_ULONG +# define T_UINT32 Py_T_ULONG # define UINT32_FMT_UNIT "k" #elif SIZEOF_INT == 4 -# define T_UINT32 T_UINT +# define T_UINT32 Py_T_UINT # define UINT32_FMT_UNIT "I" #else # define UINT32_FMT_UNIT "_" @@ -1813,11 +1814,11 @@ typedef struct { # define FFLAGS_TYPE T_UINT32 # define FFLAGS_FMT_UNIT UINT32_FMT_UNIT #else -# define FILTER_TYPE T_SHORT +# define FILTER_TYPE Py_T_SHORT # define FILTER_FMT_UNIT "h" -# define FLAGS_TYPE T_USHORT +# define FLAGS_TYPE Py_T_USHORT # define FLAGS_FMT_UNIT "H" -# define FFLAGS_TYPE T_UINT +# define FFLAGS_TYPE Py_T_UINT # define FFLAGS_FMT_UNIT "I" #endif @@ -1839,7 +1840,7 @@ static struct PyMemberDef kqueue_event_members[] = { {"ident", T_UINTPTRT, KQ_OFF(e.ident)}, {"filter", FILTER_TYPE, KQ_OFF(e.filter)}, {"flags", FLAGS_TYPE, KQ_OFF(e.flags)}, - {"fflags", T_UINT, KQ_OFF(e.fflags)}, + {"fflags", Py_T_UINT, KQ_OFF(e.fflags)}, {"data", DATA_TYPE, KQ_OFF(e.data)}, {"udata", T_UINTPTRT, KQ_OFF(e.udata)}, {NULL} /* Sentinel */ diff --git a/Modules/sha2module.c b/Modules/sha2module.c index db3774c..6ad1ff2 100644 --- a/Modules/sha2module.c +++ b/Modules/sha2module.c @@ -25,7 +25,7 @@ #include "pycore_moduleobject.h" // _PyModule_GetState() #include "pycore_typeobject.h" // _PyType_GetModuleState() #include "pycore_strhex.h" // _Py_strhex() -#include "structmember.h" // PyMemberDef + #include "hashlib.h" /*[clinic input] diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c index 39bbc91..fc6a7f9 100644 --- a/Modules/socketmodule.c +++ b/Modules/socketmodule.c @@ -108,7 +108,7 @@ Local naming conventions: #include "Python.h" #include "pycore_fileutils.h" // _Py_set_inheritable() #include "pycore_moduleobject.h" // _PyModule_GetState -#include "structmember.h" // PyMemberDef + #ifdef _Py_MEMORY_SANITIZER # include @@ -5205,9 +5205,9 @@ static PyMethodDef sock_methods[] = { /* SockObject members */ static PyMemberDef sock_memberlist[] = { - {"family", T_INT, offsetof(PySocketSockObject, sock_family), READONLY, "the socket family"}, - {"type", T_INT, offsetof(PySocketSockObject, sock_type), READONLY, "the socket type"}, - {"proto", T_INT, offsetof(PySocketSockObject, sock_proto), READONLY, "the socket protocol"}, + {"family", Py_T_INT, offsetof(PySocketSockObject, sock_family), Py_READONLY, "the socket family"}, + {"type", Py_T_INT, offsetof(PySocketSockObject, sock_type), Py_READONLY, "the socket type"}, + {"proto", Py_T_INT, offsetof(PySocketSockObject, sock_proto), Py_READONLY, "the socket protocol"}, {0}, }; diff --git a/Modules/unicodedata.c b/Modules/unicodedata.c index 6267c5a..c1e22f3 100644 --- a/Modules/unicodedata.c +++ b/Modules/unicodedata.c @@ -18,9 +18,9 @@ #include "Python.h" #include "pycore_ucnhash.h" // _PyUnicode_Name_CAPI -#include "structmember.h" // PyMemberDef #include +#include // offsetof() /*[clinic input] module unicodedata @@ -82,7 +82,7 @@ typedef struct previous_version { #define get_old_record(self, v) ((((PreviousDBVersion*)self)->getrecord)(v)) static PyMemberDef DB_members[] = { - {"unidata_version", T_STRING, offsetof(PreviousDBVersion, name), READONLY}, + {"unidata_version", Py_T_STRING, offsetof(PreviousDBVersion, name), Py_READONLY}, {NULL} }; diff --git a/Modules/xxsubtype.c b/Modules/xxsubtype.c index 9e4a3d6..63b2226 100644 --- a/Modules/xxsubtype.c +++ b/Modules/xxsubtype.c @@ -1,5 +1,6 @@ #include "Python.h" -#include "structmember.h" // PyMemberDef +#include // offsetof() + PyDoc_STRVAR(xxsubtype__doc__, "xxsubtype is an example module showing how to subtype builtin types from C.\n" @@ -181,7 +182,7 @@ spamdict_init(spamdictobject *self, PyObject *args, PyObject *kwds) } static PyMemberDef spamdict_members[] = { - {"state", T_INT, offsetof(spamdictobject, state), READONLY, + {"state", Py_T_INT, offsetof(spamdictobject, state), Py_READONLY, PyDoc_STR("an int variable for demonstration purposes")}, {0} }; diff --git a/Modules/zlibmodule.c b/Modules/zlibmodule.c index 9970bc9..22da509 100644 --- a/Modules/zlibmodule.c +++ b/Modules/zlibmodule.c @@ -4,7 +4,7 @@ /* Windows users: read Python's PCbuild\readme.txt */ #include "Python.h" -#include "structmember.h" // PyMemberDef + #include "zlib.h" #include "stdbool.h" @@ -1344,7 +1344,7 @@ typedef struct { decompress_buf() */ Py_ssize_t avail_in_real; bool is_initialised; - char eof; /* T_BOOL expects a char */ + char eof; /* Py_T_BOOL expects a char */ char needs_input; } ZlibDecompressor; @@ -1801,9 +1801,9 @@ static PyMethodDef ZlibDecompressor_methods[] = { #define COMP_OFF(x) offsetof(compobject, x) static PyMemberDef Decomp_members[] = { - {"unused_data", T_OBJECT, COMP_OFF(unused_data), READONLY}, - {"unconsumed_tail", T_OBJECT, COMP_OFF(unconsumed_tail), READONLY}, - {"eof", T_BOOL, COMP_OFF(eof), READONLY}, + {"unused_data", _Py_T_OBJECT, COMP_OFF(unused_data), Py_READONLY}, + {"unconsumed_tail", _Py_T_OBJECT, COMP_OFF(unconsumed_tail), Py_READONLY}, + {"eof", Py_T_BOOL, COMP_OFF(eof), Py_READONLY}, {NULL}, }; @@ -1817,11 +1817,11 @@ PyDoc_STRVAR(ZlibDecompressor_needs_input_doc, "True if more input is needed before more decompressed data can be produced."); static PyMemberDef ZlibDecompressor_members[] = { - {"eof", T_BOOL, offsetof(ZlibDecompressor, eof), - READONLY, ZlibDecompressor_eof__doc__}, - {"unused_data", T_OBJECT_EX, offsetof(ZlibDecompressor, unused_data), - READONLY, ZlibDecompressor_unused_data__doc__}, - {"needs_input", T_BOOL, offsetof(ZlibDecompressor, needs_input), READONLY, + {"eof", Py_T_BOOL, offsetof(ZlibDecompressor, eof), + Py_READONLY, ZlibDecompressor_eof__doc__}, + {"unused_data", Py_T_OBJECT_EX, offsetof(ZlibDecompressor, unused_data), + Py_READONLY, ZlibDecompressor_unused_data__doc__}, + {"needs_input", Py_T_BOOL, offsetof(ZlibDecompressor, needs_input), Py_READONLY, ZlibDecompressor_needs_input_doc}, {NULL}, }; diff --git a/Objects/classobject.c b/Objects/classobject.c index 548b867..6f4457d 100644 --- a/Objects/classobject.c +++ b/Objects/classobject.c @@ -5,7 +5,7 @@ #include "pycore_object.h" #include "pycore_pyerrors.h" #include "pycore_pystate.h" // _PyThreadState_GET() -#include "structmember.h" // PyMemberDef + #include "clinic/classobject.c.h" @@ -150,9 +150,9 @@ static PyMethodDef method_methods[] = { #define MO_OFF(x) offsetof(PyMethodObject, x) static PyMemberDef method_memberlist[] = { - {"__func__", T_OBJECT, MO_OFF(im_func), READONLY, + {"__func__", _Py_T_OBJECT, MO_OFF(im_func), Py_READONLY, "the function (or other callable) implementing a method"}, - {"__self__", T_OBJECT, MO_OFF(im_self), READONLY, + {"__self__", _Py_T_OBJECT, MO_OFF(im_self), Py_READONLY, "the instance to which a method is bound"}, {NULL} /* Sentinel */ }; @@ -372,7 +372,7 @@ PyInstanceMethod_Function(PyObject *im) #define IMO_OFF(x) offsetof(PyInstanceMethodObject, x) static PyMemberDef instancemethod_memberlist[] = { - {"__func__", T_OBJECT, IMO_OFF(func), READONLY, + {"__func__", _Py_T_OBJECT, IMO_OFF(func), Py_READONLY, "the function (or other callable) implementing a method"}, {NULL} /* Sentinel */ }; diff --git a/Objects/codeobject.c b/Objects/codeobject.c index 977e5b0..81fa339 100644 --- a/Objects/codeobject.c +++ b/Objects/codeobject.c @@ -2,7 +2,7 @@ #include "Python.h" #include "opcode.h" -#include "structmember.h" // PyMemberDef + #include "pycore_code.h" // _PyCodeConstructor #include "pycore_frame.h" // FRAME_SPECIALS_SIZE #include "pycore_interp.h" // PyInterpreterState.co_extra_freefuncs @@ -1877,20 +1877,20 @@ code_hash(PyCodeObject *co) #define OFF(x) offsetof(PyCodeObject, x) static PyMemberDef code_memberlist[] = { - {"co_argcount", T_INT, OFF(co_argcount), READONLY}, - {"co_posonlyargcount", T_INT, OFF(co_posonlyargcount), READONLY}, - {"co_kwonlyargcount", T_INT, OFF(co_kwonlyargcount), READONLY}, - {"co_stacksize", T_INT, OFF(co_stacksize), READONLY}, - {"co_flags", T_INT, OFF(co_flags), READONLY}, - {"co_nlocals", T_INT, OFF(co_nlocals), READONLY}, - {"co_consts", T_OBJECT, OFF(co_consts), READONLY}, - {"co_names", T_OBJECT, OFF(co_names), READONLY}, - {"co_filename", T_OBJECT, OFF(co_filename), READONLY}, - {"co_name", T_OBJECT, OFF(co_name), READONLY}, - {"co_qualname", T_OBJECT, OFF(co_qualname), READONLY}, - {"co_firstlineno", T_INT, OFF(co_firstlineno), READONLY}, - {"co_linetable", T_OBJECT, OFF(co_linetable), READONLY}, - {"co_exceptiontable", T_OBJECT, OFF(co_exceptiontable), READONLY}, + {"co_argcount", Py_T_INT, OFF(co_argcount), Py_READONLY}, + {"co_posonlyargcount", Py_T_INT, OFF(co_posonlyargcount), Py_READONLY}, + {"co_kwonlyargcount", Py_T_INT, OFF(co_kwonlyargcount), Py_READONLY}, + {"co_stacksize", Py_T_INT, OFF(co_stacksize), Py_READONLY}, + {"co_flags", Py_T_INT, OFF(co_flags), Py_READONLY}, + {"co_nlocals", Py_T_INT, OFF(co_nlocals), Py_READONLY}, + {"co_consts", _Py_T_OBJECT, OFF(co_consts), Py_READONLY}, + {"co_names", _Py_T_OBJECT, OFF(co_names), Py_READONLY}, + {"co_filename", _Py_T_OBJECT, OFF(co_filename), Py_READONLY}, + {"co_name", _Py_T_OBJECT, OFF(co_name), Py_READONLY}, + {"co_qualname", _Py_T_OBJECT, OFF(co_qualname), Py_READONLY}, + {"co_firstlineno", Py_T_INT, OFF(co_firstlineno), Py_READONLY}, + {"co_linetable", _Py_T_OBJECT, OFF(co_linetable), Py_READONLY}, + {"co_exceptiontable", _Py_T_OBJECT, OFF(co_exceptiontable), Py_READONLY}, {NULL} /* Sentinel */ }; diff --git a/Objects/complexobject.c b/Objects/complexobject.c index 12968a6..0e96f54 100644 --- a/Objects/complexobject.c +++ b/Objects/complexobject.c @@ -11,7 +11,7 @@ #include "pycore_long.h" // _PyLong_GetZero() #include "pycore_object.h" // _PyObject_Init() #include "pycore_pymath.h" // _Py_ADJUST_ERANGE2() -#include "structmember.h" // PyMemberDef + /*[clinic input] @@ -720,9 +720,9 @@ static PyMethodDef complex_methods[] = { }; static PyMemberDef complex_members[] = { - {"real", T_DOUBLE, offsetof(PyComplexObject, cval.real), READONLY, + {"real", Py_T_DOUBLE, offsetof(PyComplexObject, cval.real), Py_READONLY, "the real part of a complex number"}, - {"imag", T_DOUBLE, offsetof(PyComplexObject, cval.imag), READONLY, + {"imag", Py_T_DOUBLE, offsetof(PyComplexObject, cval.imag), Py_READONLY, "the imaginary part of a complex number"}, {0}, }; diff --git a/Objects/descrobject.c b/Objects/descrobject.c index 74aa70b..60383dd 100644 --- a/Objects/descrobject.c +++ b/Objects/descrobject.c @@ -8,7 +8,7 @@ #include "pycore_object.h" // _PyObject_GC_UNTRACK() #include "pycore_pystate.h" // _PyThreadState_GET() #include "pycore_tuple.h" // _PyTuple_ITEMS() -#include "structmember.h" // PyMemberDef + /*[clinic input] class mappingproxy "mappingproxyobject *" "&PyDictProxy_Type" @@ -182,7 +182,7 @@ member_get(PyMemberDescrObject *descr, PyObject *obj, PyObject *type) return NULL; } - if (descr->d_member->flags & PY_AUDIT_READ) { + if (descr->d_member->flags & Py_AUDIT_READ) { if (PySys_Audit("object.__getattr__", "Os", obj ? obj : Py_None, descr->d_member->name) < 0) { return NULL; @@ -640,8 +640,8 @@ static PyMethodDef descr_methods[] = { }; static PyMemberDef descr_members[] = { - {"__objclass__", T_OBJECT, offsetof(PyDescrObject, d_type), READONLY}, - {"__name__", T_OBJECT, offsetof(PyDescrObject, d_name), READONLY}, + {"__objclass__", _Py_T_OBJECT, offsetof(PyDescrObject, d_type), Py_READONLY}, + {"__name__", _Py_T_OBJECT, offsetof(PyDescrObject, d_name), Py_READONLY}, {0} }; @@ -1355,7 +1355,7 @@ static PyMethodDef wrapper_methods[] = { }; static PyMemberDef wrapper_members[] = { - {"__self__", T_OBJECT, offsetof(wrapperobject, self), READONLY}, + {"__self__", _Py_T_OBJECT, offsetof(wrapperobject, self), Py_READONLY}, {0} }; @@ -1515,10 +1515,10 @@ static PyObject * property_copy(PyObject *, PyObject *, PyObject *, PyObject *); static PyMemberDef property_members[] = { - {"fget", T_OBJECT, offsetof(propertyobject, prop_get), READONLY}, - {"fset", T_OBJECT, offsetof(propertyobject, prop_set), READONLY}, - {"fdel", T_OBJECT, offsetof(propertyobject, prop_del), READONLY}, - {"__doc__", T_OBJECT, offsetof(propertyobject, prop_doc), 0}, + {"fget", _Py_T_OBJECT, offsetof(propertyobject, prop_get), Py_READONLY}, + {"fset", _Py_T_OBJECT, offsetof(propertyobject, prop_set), Py_READONLY}, + {"fdel", _Py_T_OBJECT, offsetof(propertyobject, prop_del), Py_READONLY}, + {"__doc__", _Py_T_OBJECT, offsetof(propertyobject, prop_doc), 0}, {0} }; diff --git a/Objects/exceptions.c b/Objects/exceptions.c index 42c5317..62a4423 100644 --- a/Objects/exceptions.c +++ b/Objects/exceptions.c @@ -12,7 +12,7 @@ #include "pycore_exceptions.h" // struct _Py_exc_state #include "pycore_initconfig.h" #include "pycore_object.h" -#include "structmember.h" // PyMemberDef + #include "osdefs.h" // SEP @@ -439,7 +439,7 @@ PyExceptionClass_Name(PyObject *ob) } static struct PyMemberDef BaseException_members[] = { - {"__suppress_context__", T_BOOL, + {"__suppress_context__", Py_T_BOOL, offsetof(PyBaseExceptionObject, suppress_context)}, {NULL} }; @@ -569,7 +569,7 @@ SimpleExtendsException(PyExc_Exception, StopAsyncIteration, */ static PyMemberDef StopIteration_members[] = { - {"value", T_OBJECT, offsetof(PyStopIterationObject, value), 0, + {"value", _Py_T_OBJECT, offsetof(PyStopIterationObject, value), 0, PyDoc_STR("generator return value")}, {NULL} /* Sentinel */ }; @@ -671,7 +671,7 @@ SystemExit_traverse(PySystemExitObject *self, visitproc visit, void *arg) } static PyMemberDef SystemExit_members[] = { - {"code", T_OBJECT, offsetof(PySystemExitObject, code), 0, + {"code", _Py_T_OBJECT, offsetof(PySystemExitObject, code), 0, PyDoc_STR("exception code")}, {NULL} /* Sentinel */ }; @@ -1477,9 +1477,9 @@ PyUnstable_Exc_PrepReraiseStar(PyObject *orig, PyObject *excs) } static PyMemberDef BaseExceptionGroup_members[] = { - {"message", T_OBJECT, offsetof(PyBaseExceptionGroupObject, msg), READONLY, + {"message", _Py_T_OBJECT, offsetof(PyBaseExceptionGroupObject, msg), Py_READONLY, PyDoc_STR("exception message")}, - {"exceptions", T_OBJECT, offsetof(PyBaseExceptionGroupObject, excs), READONLY, + {"exceptions", _Py_T_OBJECT, offsetof(PyBaseExceptionGroupObject, excs), Py_READONLY, PyDoc_STR("nested exceptions")}, {NULL} /* Sentinel */ }; @@ -1654,13 +1654,13 @@ ImportError_reduce(PyImportErrorObject *self, PyObject *Py_UNUSED(ignored)) } static PyMemberDef ImportError_members[] = { - {"msg", T_OBJECT, offsetof(PyImportErrorObject, msg), 0, + {"msg", _Py_T_OBJECT, offsetof(PyImportErrorObject, msg), 0, PyDoc_STR("exception message")}, - {"name", T_OBJECT, offsetof(PyImportErrorObject, name), 0, + {"name", _Py_T_OBJECT, offsetof(PyImportErrorObject, name), 0, PyDoc_STR("module name")}, - {"path", T_OBJECT, offsetof(PyImportErrorObject, path), 0, + {"path", _Py_T_OBJECT, offsetof(PyImportErrorObject, path), 0, PyDoc_STR("module path")}, - {"name_from", T_OBJECT, offsetof(PyImportErrorObject, name_from), 0, + {"name_from", _Py_T_OBJECT, offsetof(PyImportErrorObject, name_from), 0, PyDoc_STR("name imported from module")}, {NULL} /* Sentinel */ }; @@ -2103,16 +2103,16 @@ OSError_written_set(PyOSErrorObject *self, PyObject *arg, void *context) } static PyMemberDef OSError_members[] = { - {"errno", T_OBJECT, offsetof(PyOSErrorObject, myerrno), 0, + {"errno", _Py_T_OBJECT, offsetof(PyOSErrorObject, myerrno), 0, PyDoc_STR("POSIX exception code")}, - {"strerror", T_OBJECT, offsetof(PyOSErrorObject, strerror), 0, + {"strerror", _Py_T_OBJECT, offsetof(PyOSErrorObject, strerror), 0, PyDoc_STR("exception strerror")}, - {"filename", T_OBJECT, offsetof(PyOSErrorObject, filename), 0, + {"filename", _Py_T_OBJECT, offsetof(PyOSErrorObject, filename), 0, PyDoc_STR("exception filename")}, - {"filename2", T_OBJECT, offsetof(PyOSErrorObject, filename2), 0, + {"filename2", _Py_T_OBJECT, offsetof(PyOSErrorObject, filename2), 0, PyDoc_STR("second exception filename")}, #ifdef MS_WINDOWS - {"winerror", T_OBJECT, offsetof(PyOSErrorObject, winerror), 0, + {"winerror", _Py_T_OBJECT, offsetof(PyOSErrorObject, winerror), 0, PyDoc_STR("Win32 exception code")}, #endif {NULL} /* Sentinel */ @@ -2249,7 +2249,7 @@ NameError_traverse(PyNameErrorObject *self, visitproc visit, void *arg) } static PyMemberDef NameError_members[] = { - {"name", T_OBJECT, offsetof(PyNameErrorObject, name), 0, PyDoc_STR("name")}, + {"name", _Py_T_OBJECT, offsetof(PyNameErrorObject, name), 0, PyDoc_STR("name")}, {NULL} /* Sentinel */ }; @@ -2368,8 +2368,8 @@ AttributeError_reduce(PyAttributeErrorObject *self, PyObject *Py_UNUSED(ignored) } static PyMemberDef AttributeError_members[] = { - {"name", T_OBJECT, offsetof(PyAttributeErrorObject, name), 0, PyDoc_STR("attribute name")}, - {"obj", T_OBJECT, offsetof(PyAttributeErrorObject, obj), 0, PyDoc_STR("object")}, + {"name", _Py_T_OBJECT, offsetof(PyAttributeErrorObject, name), 0, PyDoc_STR("attribute name")}, + {"obj", _Py_T_OBJECT, offsetof(PyAttributeErrorObject, obj), 0, PyDoc_STR("object")}, {NULL} /* Sentinel */ }; @@ -2541,21 +2541,21 @@ SyntaxError_str(PySyntaxErrorObject *self) } static PyMemberDef SyntaxError_members[] = { - {"msg", T_OBJECT, offsetof(PySyntaxErrorObject, msg), 0, + {"msg", _Py_T_OBJECT, offsetof(PySyntaxErrorObject, msg), 0, PyDoc_STR("exception msg")}, - {"filename", T_OBJECT, offsetof(PySyntaxErrorObject, filename), 0, + {"filename", _Py_T_OBJECT, offsetof(PySyntaxErrorObject, filename), 0, PyDoc_STR("exception filename")}, - {"lineno", T_OBJECT, offsetof(PySyntaxErrorObject, lineno), 0, + {"lineno", _Py_T_OBJECT, offsetof(PySyntaxErrorObject, lineno), 0, PyDoc_STR("exception lineno")}, - {"offset", T_OBJECT, offsetof(PySyntaxErrorObject, offset), 0, + {"offset", _Py_T_OBJECT, offsetof(PySyntaxErrorObject, offset), 0, PyDoc_STR("exception offset")}, - {"text", T_OBJECT, offsetof(PySyntaxErrorObject, text), 0, + {"text", _Py_T_OBJECT, offsetof(PySyntaxErrorObject, text), 0, PyDoc_STR("exception text")}, - {"end_lineno", T_OBJECT, offsetof(PySyntaxErrorObject, end_lineno), 0, + {"end_lineno", _Py_T_OBJECT, offsetof(PySyntaxErrorObject, end_lineno), 0, PyDoc_STR("exception end lineno")}, - {"end_offset", T_OBJECT, offsetof(PySyntaxErrorObject, end_offset), 0, + {"end_offset", _Py_T_OBJECT, offsetof(PySyntaxErrorObject, end_offset), 0, PyDoc_STR("exception end offset")}, - {"print_file_and_line", T_OBJECT, + {"print_file_and_line", _Py_T_OBJECT, offsetof(PySyntaxErrorObject, print_file_and_line), 0, PyDoc_STR("exception print_file_and_line")}, {NULL} /* Sentinel */ @@ -2910,15 +2910,15 @@ UnicodeError_traverse(PyUnicodeErrorObject *self, visitproc visit, void *arg) } static PyMemberDef UnicodeError_members[] = { - {"encoding", T_OBJECT, offsetof(PyUnicodeErrorObject, encoding), 0, + {"encoding", _Py_T_OBJECT, offsetof(PyUnicodeErrorObject, encoding), 0, PyDoc_STR("exception encoding")}, - {"object", T_OBJECT, offsetof(PyUnicodeErrorObject, object), 0, + {"object", _Py_T_OBJECT, offsetof(PyUnicodeErrorObject, object), 0, PyDoc_STR("exception object")}, - {"start", T_PYSSIZET, offsetof(PyUnicodeErrorObject, start), 0, + {"start", Py_T_PYSSIZET, offsetof(PyUnicodeErrorObject, start), 0, PyDoc_STR("exception start")}, - {"end", T_PYSSIZET, offsetof(PyUnicodeErrorObject, end), 0, + {"end", Py_T_PYSSIZET, offsetof(PyUnicodeErrorObject, end), 0, PyDoc_STR("exception end")}, - {"reason", T_OBJECT, offsetof(PyUnicodeErrorObject, reason), 0, + {"reason", _Py_T_OBJECT, offsetof(PyUnicodeErrorObject, reason), 0, PyDoc_STR("exception reason")}, {NULL} /* Sentinel */ }; diff --git a/Objects/frameobject.c b/Objects/frameobject.c index 1882055..cc9ac4b 100644 --- a/Objects/frameobject.c +++ b/Objects/frameobject.c @@ -11,12 +11,12 @@ #include "frameobject.h" // PyFrameObject #include "pycore_frame.h" #include "opcode.h" // EXTENDED_ARG -#include "structmember.h" // PyMemberDef + #define OFF(x) offsetof(PyFrameObject, x) static PyMemberDef frame_memberlist[] = { - {"f_trace_lines", T_BOOL, OFF(f_trace_lines), 0}, + {"f_trace_lines", Py_T_BOOL, OFF(f_trace_lines), 0}, {NULL} /* Sentinel */ }; diff --git a/Objects/funcobject.c b/Objects/funcobject.c index 0c69bf4..7fffa1c 100644 --- a/Objects/funcobject.c +++ b/Objects/funcobject.c @@ -6,7 +6,7 @@ #include "pycore_code.h" // _Py_next_func_version #include "pycore_object.h" // _PyObject_GC_UNTRACK() #include "pycore_pyerrors.h" // _PyErr_Occurred() -#include "structmember.h" // PyMemberDef + static PyObject* func_repr(PyFunctionObject *op); @@ -451,11 +451,11 @@ PyFunction_SetAnnotations(PyObject *op, PyObject *annotations) #define OFF(x) offsetof(PyFunctionObject, x) static PyMemberDef func_memberlist[] = { - {"__closure__", T_OBJECT, OFF(func_closure), READONLY}, - {"__doc__", T_OBJECT, OFF(func_doc), 0}, - {"__globals__", T_OBJECT, OFF(func_globals), READONLY}, - {"__module__", T_OBJECT, OFF(func_module), 0}, - {"__builtins__", T_OBJECT, OFF(func_builtins), READONLY}, + {"__closure__", _Py_T_OBJECT, OFF(func_closure), Py_READONLY}, + {"__doc__", _Py_T_OBJECT, OFF(func_doc), 0}, + {"__globals__", _Py_T_OBJECT, OFF(func_globals), Py_READONLY}, + {"__module__", _Py_T_OBJECT, OFF(func_module), 0}, + {"__builtins__", _Py_T_OBJECT, OFF(func_builtins), Py_READONLY}, {NULL} /* Sentinel */ }; @@ -1063,8 +1063,8 @@ cm_init(PyObject *self, PyObject *args, PyObject *kwds) } static PyMemberDef cm_memberlist[] = { - {"__func__", T_OBJECT, offsetof(classmethod, cm_callable), READONLY}, - {"__wrapped__", T_OBJECT, offsetof(classmethod, cm_callable), READONLY}, + {"__func__", _Py_T_OBJECT, offsetof(classmethod, cm_callable), Py_READONLY}, + {"__wrapped__", _Py_T_OBJECT, offsetof(classmethod, cm_callable), Py_READONLY}, {NULL} /* Sentinel */ }; @@ -1258,8 +1258,8 @@ sm_call(PyObject *callable, PyObject *args, PyObject *kwargs) } static PyMemberDef sm_memberlist[] = { - {"__func__", T_OBJECT, offsetof(staticmethod, sm_callable), READONLY}, - {"__wrapped__", T_OBJECT, offsetof(staticmethod, sm_callable), READONLY}, + {"__func__", _Py_T_OBJECT, offsetof(staticmethod, sm_callable), Py_READONLY}, + {"__wrapped__", _Py_T_OBJECT, offsetof(staticmethod, sm_callable), Py_READONLY}, {NULL} /* Sentinel */ }; diff --git a/Objects/genericaliasobject.c b/Objects/genericaliasobject.c index 0c478f3..df88734 100644 --- a/Objects/genericaliasobject.c +++ b/Objects/genericaliasobject.c @@ -3,7 +3,7 @@ #include "Python.h" #include "pycore_object.h" #include "pycore_unionobject.h" // _Py_union_type_or, _PyGenericAlias_Check -#include "structmember.h" // PyMemberDef + #include @@ -782,9 +782,9 @@ static PyMethodDef ga_methods[] = { }; static PyMemberDef ga_members[] = { - {"__origin__", T_OBJECT, offsetof(gaobject, origin), READONLY}, - {"__args__", T_OBJECT, offsetof(gaobject, args), READONLY}, - {"__unpacked__", T_BOOL, offsetof(gaobject, starred), READONLY}, + {"__origin__", _Py_T_OBJECT, offsetof(gaobject, origin), Py_READONLY}, + {"__args__", _Py_T_OBJECT, offsetof(gaobject, args), Py_READONLY}, + {"__unpacked__", Py_T_BOOL, offsetof(gaobject, starred), Py_READONLY}, {0} }; diff --git a/Objects/genobject.c b/Objects/genobject.c index 103e8b8..a630f84 100644 --- a/Objects/genobject.c +++ b/Objects/genobject.c @@ -10,7 +10,7 @@ #include "pycore_object.h" // _PyObject_GC_UNTRACK() #include "pycore_pyerrors.h" // _PyErr_ClearExcState() #include "pycore_pystate.h" // _PyThreadState_GET() -#include "structmember.h" // PyMemberDef + #include "opcode.h" // SEND #include "frameobject.h" // _PyInterpreterFrame_GetLine #include "pystats.h" @@ -1144,7 +1144,7 @@ static PyGetSetDef coro_getsetlist[] = { }; static PyMemberDef coro_memberlist[] = { - {"cr_origin", T_OBJECT, offsetof(PyCoroObject, cr_origin_or_finalizer), READONLY}, + {"cr_origin", _Py_T_OBJECT, offsetof(PyCoroObject, cr_origin_or_finalizer), Py_READONLY}, {NULL} /* Sentinel */ }; @@ -1558,8 +1558,8 @@ static PyGetSetDef async_gen_getsetlist[] = { }; static PyMemberDef async_gen_memberlist[] = { - {"ag_running", T_BOOL, offsetof(PyAsyncGenObject, ag_running_async), - READONLY}, + {"ag_running", Py_T_BOOL, offsetof(PyAsyncGenObject, ag_running_async), + Py_READONLY}, {NULL} /* Sentinel */ }; diff --git a/Objects/methodobject.c b/Objects/methodobject.c index fe08199..628d227 100644 --- a/Objects/methodobject.c +++ b/Objects/methodobject.c @@ -7,7 +7,7 @@ #include "pycore_object.h" #include "pycore_pyerrors.h" #include "pycore_pystate.h" // _PyThreadState_GET() -#include "structmember.h" // PyMemberDef + /* undefine macro trampoline to PyCFunction_NewEx */ #undef PyCFunction_New @@ -273,7 +273,7 @@ static PyGetSetDef meth_getsets [] = { #define OFF(x) offsetof(PyCFunctionObject, x) static PyMemberDef meth_members[] = { - {"__module__", T_OBJECT, OFF(m_module), 0}, + {"__module__", _Py_T_OBJECT, OFF(m_module), 0}, {NULL} }; diff --git a/Objects/moduleobject.c b/Objects/moduleobject.c index ba20534..7e890d0 100644 --- a/Objects/moduleobject.c +++ b/Objects/moduleobject.c @@ -9,11 +9,11 @@ #include "pycore_object.h" // _PyType_AllocNoTrack #include "pycore_pyerrors.h" // _PyErr_FormatFromCause() #include "pycore_pystate.h" // _PyInterpreterState_GET() -#include "structmember.h" // PyMemberDef + static PyMemberDef module_members[] = { - {"__dict__", T_OBJECT, offsetof(PyModuleObject, md_dict), READONLY}, + {"__dict__", _Py_T_OBJECT, offsetof(PyModuleObject, md_dict), Py_READONLY}, {0} }; diff --git a/Objects/namespaceobject.c b/Objects/namespaceobject.c index 2cc4ddd..11cf859 100644 --- a/Objects/namespaceobject.c +++ b/Objects/namespaceobject.c @@ -2,7 +2,9 @@ #include "Python.h" #include "pycore_namespace.h" // _PyNamespace_Type -#include "structmember.h" // PyMemberDef + +#include // offsetof() + typedef struct { @@ -12,7 +14,7 @@ typedef struct { static PyMemberDef namespace_members[] = { - {"__dict__", T_OBJECT, offsetof(_PyNamespaceObject, ns_dict), READONLY}, + {"__dict__", _Py_T_OBJECT, offsetof(_PyNamespaceObject, ns_dict), Py_READONLY}, {NULL} }; diff --git a/Objects/rangeobject.c b/Objects/rangeobject.c index 6dc41d7..1e3d5ac 100644 --- a/Objects/rangeobject.c +++ b/Objects/rangeobject.c @@ -6,7 +6,7 @@ #include "pycore_modsupport.h" // _PyArg_NoKwnames() #include "pycore_range.h" #include "pycore_tuple.h" // _PyTuple_ITEMS() -#include "structmember.h" // PyMemberDef + /* Support objects whose length is > PY_SSIZE_T_MAX. @@ -757,9 +757,9 @@ static PyMethodDef range_methods[] = { }; static PyMemberDef range_members[] = { - {"start", T_OBJECT_EX, offsetof(rangeobject, start), READONLY}, - {"stop", T_OBJECT_EX, offsetof(rangeobject, stop), READONLY}, - {"step", T_OBJECT_EX, offsetof(rangeobject, step), READONLY}, + {"start", Py_T_OBJECT_EX, offsetof(rangeobject, start), Py_READONLY}, + {"stop", Py_T_OBJECT_EX, offsetof(rangeobject, stop), Py_READONLY}, + {"step", Py_T_OBJECT_EX, offsetof(rangeobject, step), Py_READONLY}, {0} }; diff --git a/Objects/sliceobject.c b/Objects/sliceobject.c index 5a33977..dc3aad1 100644 --- a/Objects/sliceobject.c +++ b/Objects/sliceobject.c @@ -17,7 +17,7 @@ this type and there is exactly one in existence. #include "pycore_abstract.h" // _PyIndex_Check() #include "pycore_long.h" // _PyLong_GetZero() #include "pycore_object.h" // _PyObject_GC_TRACK() -#include "structmember.h" // PyMemberDef + static PyObject * ellipsis_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) @@ -377,9 +377,9 @@ slice_repr(PySliceObject *r) } static PyMemberDef slice_members[] = { - {"start", T_OBJECT, offsetof(PySliceObject, start), READONLY}, - {"stop", T_OBJECT, offsetof(PySliceObject, stop), READONLY}, - {"step", T_OBJECT, offsetof(PySliceObject, step), READONLY}, + {"start", _Py_T_OBJECT, offsetof(PySliceObject, start), Py_READONLY}, + {"stop", _Py_T_OBJECT, offsetof(PySliceObject, stop), Py_READONLY}, + {"step", _Py_T_OBJECT, offsetof(PySliceObject, step), Py_READONLY}, {0} }; diff --git a/Objects/structseq.c b/Objects/structseq.c index 4901113..700f67c 100644 --- a/Objects/structseq.c +++ b/Objects/structseq.c @@ -10,7 +10,7 @@ #include "Python.h" #include "pycore_tuple.h" // _PyTuple_FromArray() #include "pycore_object.h" // _PyObject_GC_TRACK() -#include "structmember.h" // PyMemberDef + #include "pycore_structseq.h" // PyStructSequence_InitType() #include "pycore_initconfig.h" // _PyStatus_OK() @@ -465,10 +465,10 @@ initialize_members(PyStructSequence_Desc *desc, /* The names and docstrings in these MemberDefs are statically */ /* allocated so it is expected that they'll outlive the MemberDef */ members[k].name = desc->fields[i].name; - members[k].type = T_OBJECT; + members[k].type = _Py_T_OBJECT; members[k].offset = offsetof(PyStructSequence, ob_item) + i * sizeof(PyObject*); - members[k].flags = READONLY; + members[k].flags = Py_READONLY; members[k].doc = desc->fields[i].doc; k++; } diff --git a/Objects/typeobject.c b/Objects/typeobject.c index 7e5282c..abe33f1 100644 --- a/Objects/typeobject.c +++ b/Objects/typeobject.c @@ -18,7 +18,7 @@ #include "pycore_unionobject.h" // _Py_union_type_or #include "pycore_weakref.h" // _PyWeakref_GET_REF() #include "opcode.h" // MAKE_CELL -#include "structmember.h" // PyMemberDef + #include #include // ptrdiff_t @@ -935,16 +935,16 @@ int PyUnstable_Type_AssignVersionTag(PyTypeObject *type) static PyMemberDef type_members[] = { - {"__basicsize__", T_PYSSIZET, offsetof(PyTypeObject,tp_basicsize),READONLY}, - {"__itemsize__", T_PYSSIZET, offsetof(PyTypeObject, tp_itemsize), READONLY}, - {"__flags__", T_ULONG, offsetof(PyTypeObject, tp_flags), READONLY}, + {"__basicsize__", Py_T_PYSSIZET, offsetof(PyTypeObject,tp_basicsize),Py_READONLY}, + {"__itemsize__", Py_T_PYSSIZET, offsetof(PyTypeObject, tp_itemsize), Py_READONLY}, + {"__flags__", Py_T_ULONG, offsetof(PyTypeObject, tp_flags), Py_READONLY}, /* Note that this value is misleading for static builtin types, since the memory at this offset will always be NULL. */ - {"__weakrefoffset__", T_PYSSIZET, - offsetof(PyTypeObject, tp_weaklistoffset), READONLY}, - {"__base__", T_OBJECT, offsetof(PyTypeObject, tp_base), READONLY}, - {"__dictoffset__", T_PYSSIZET, - offsetof(PyTypeObject, tp_dictoffset), READONLY}, + {"__weakrefoffset__", Py_T_PYSSIZET, + offsetof(PyTypeObject, tp_weaklistoffset), Py_READONLY}, + {"__base__", _Py_T_OBJECT, offsetof(PyTypeObject, tp_base), Py_READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, + offsetof(PyTypeObject, tp_dictoffset), Py_READONLY}, {0} }; @@ -1775,7 +1775,7 @@ traverse_slots(PyTypeObject *type, PyObject *self, visitproc visit, void *arg) n = Py_SIZE(type); mp = _PyHeapType_GET_MEMBERS((PyHeapTypeObject *)type); for (i = 0; i < n; i++, mp++) { - if (mp->type == T_OBJECT_EX) { + if (mp->type == Py_T_OBJECT_EX) { char *addr = (char *)self + mp->offset; PyObject *obj = *(PyObject **)addr; if (obj != NULL) { @@ -1850,7 +1850,7 @@ clear_slots(PyTypeObject *type, PyObject *self) n = Py_SIZE(type); mp = _PyHeapType_GET_MEMBERS((PyHeapTypeObject *)type); for (i = 0; i < n; i++, mp++) { - if (mp->type == T_OBJECT_EX && !(mp->flags & READONLY)) { + if (mp->type == Py_T_OBJECT_EX && !(mp->flags & Py_READONLY)) { char *addr = (char *)self + mp->offset; PyObject *obj = *(PyObject **)addr; if (obj != NULL) { @@ -3567,7 +3567,7 @@ type_new_descriptors(const type_new_ctx *ctx, PyTypeObject *type) if (mp->name == NULL) { return -1; } - mp->type = T_OBJECT_EX; + mp->type = Py_T_OBJECT_EX; mp->offset = slotoffset; /* __dict__ and __weakref__ are already filtered out */ @@ -4116,20 +4116,20 @@ _PyType_FromMetaclass_impl( nmembers++; if (strcmp(memb->name, "__weaklistoffset__") == 0) { // The PyMemberDef must be a Py_ssize_t and readonly - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); + assert(memb->type == Py_T_PYSSIZET); + assert(memb->flags == Py_READONLY); weaklistoffset = memb->offset; } if (strcmp(memb->name, "__dictoffset__") == 0) { // The PyMemberDef must be a Py_ssize_t and readonly - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); + assert(memb->type == Py_T_PYSSIZET); + assert(memb->flags == Py_READONLY); dictoffset = memb->offset; } if (strcmp(memb->name, "__vectorcalloffset__") == 0) { // The PyMemberDef must be a Py_ssize_t and readonly - assert(memb->type == T_PYSSIZET); - assert(memb->flags == READONLY); + assert(memb->type == Py_T_PYSSIZET); + assert(memb->flags == Py_READONLY); vectorcalloffset = memb->offset; } if (memb->flags & Py_RELATIVE_OFFSET) { @@ -10178,11 +10178,11 @@ typedef struct { } superobject; static PyMemberDef super_members[] = { - {"__thisclass__", T_OBJECT, offsetof(superobject, type), READONLY, + {"__thisclass__", _Py_T_OBJECT, offsetof(superobject, type), Py_READONLY, "the class invoking super()"}, - {"__self__", T_OBJECT, offsetof(superobject, obj), READONLY, + {"__self__", _Py_T_OBJECT, offsetof(superobject, obj), Py_READONLY, "the instance invoking super(); may be None"}, - {"__self_class__", T_OBJECT, offsetof(superobject, obj_type), READONLY, + {"__self_class__", _Py_T_OBJECT, offsetof(superobject, obj_type), Py_READONLY, "the type of the instance invoking super(); may be None"}, {0} }; diff --git a/Objects/typevarobject.c b/Objects/typevarobject.c index 5605662..e09e6a6 100644 --- a/Objects/typevarobject.c +++ b/Objects/typevarobject.c @@ -3,7 +3,7 @@ #include "pycore_object.h" // _PyObject_GC_TRACK/UNTRACK #include "pycore_typevarobject.h" #include "pycore_unionobject.h" // _Py_union_type_or -#include "structmember.h" + /*[clinic input] class typevar "typevarobject *" "&_PyTypeVar_Type" @@ -244,10 +244,10 @@ typevar_repr(PyObject *self) } static PyMemberDef typevar_members[] = { - {"__name__", T_OBJECT, offsetof(typevarobject, name), READONLY}, - {"__covariant__", T_BOOL, offsetof(typevarobject, covariant), READONLY}, - {"__contravariant__", T_BOOL, offsetof(typevarobject, contravariant), READONLY}, - {"__infer_variance__", T_BOOL, offsetof(typevarobject, infer_variance), READONLY}, + {"__name__", _Py_T_OBJECT, offsetof(typevarobject, name), Py_READONLY}, + {"__covariant__", Py_T_BOOL, offsetof(typevarobject, covariant), Py_READONLY}, + {"__contravariant__", Py_T_BOOL, offsetof(typevarobject, contravariant), Py_READONLY}, + {"__infer_variance__", Py_T_BOOL, offsetof(typevarobject, infer_variance), Py_READONLY}, {0} }; @@ -555,7 +555,7 @@ paramspecattr_richcompare(PyObject *a, PyObject *b, int op) } static PyMemberDef paramspecattr_members[] = { - {"__origin__", T_OBJECT, offsetof(paramspecattrobject, __origin__), READONLY}, + {"__origin__", _Py_T_OBJECT, offsetof(paramspecattrobject, __origin__), Py_READONLY}, {0} }; @@ -780,11 +780,11 @@ paramspec_repr(PyObject *self) } static PyMemberDef paramspec_members[] = { - {"__name__", T_OBJECT, offsetof(paramspecobject, name), READONLY}, - {"__bound__", T_OBJECT, offsetof(paramspecobject, bound), READONLY}, - {"__covariant__", T_BOOL, offsetof(paramspecobject, covariant), READONLY}, - {"__contravariant__", T_BOOL, offsetof(paramspecobject, contravariant), READONLY}, - {"__infer_variance__", T_BOOL, offsetof(paramspecobject, infer_variance), READONLY}, + {"__name__", _Py_T_OBJECT, offsetof(paramspecobject, name), Py_READONLY}, + {"__bound__", _Py_T_OBJECT, offsetof(paramspecobject, bound), Py_READONLY}, + {"__covariant__", Py_T_BOOL, offsetof(paramspecobject, covariant), Py_READONLY}, + {"__contravariant__", Py_T_BOOL, offsetof(paramspecobject, contravariant), Py_READONLY}, + {"__infer_variance__", Py_T_BOOL, offsetof(paramspecobject, infer_variance), Py_READONLY}, {0} }; @@ -1054,7 +1054,7 @@ typevartuple_repr(PyObject *self) } static PyMemberDef typevartuple_members[] = { - {"__name__", T_OBJECT, offsetof(typevartupleobject, name), READONLY}, + {"__name__", _Py_T_OBJECT, offsetof(typevartupleobject, name), Py_READONLY}, {0} }; @@ -1292,7 +1292,7 @@ typealias_repr(PyObject *self) } static PyMemberDef typealias_members[] = { - {"__name__", T_OBJECT, offsetof(typealiasobject, name), READONLY}, + {"__name__", _Py_T_OBJECT, offsetof(typealiasobject, name), Py_READONLY}, {0} }; diff --git a/Objects/unionobject.c b/Objects/unionobject.c index 269f469..347945a 100644 --- a/Objects/unionobject.c +++ b/Objects/unionobject.c @@ -3,7 +3,7 @@ #include "pycore_object.h" // _PyObject_GC_TRACK/UNTRACK #include "pycore_typevarobject.h" // _PyTypeAlias_Type #include "pycore_unionobject.h" -#include "structmember.h" + static PyObject *make_union(PyObject *); @@ -273,7 +273,7 @@ error: } static PyMemberDef union_members[] = { - {"__args__", T_OBJECT, offsetof(unionobject, args), READONLY}, + {"__args__", _Py_T_OBJECT, offsetof(unionobject, args), Py_READONLY}, {0} }; diff --git a/Objects/weakrefobject.c b/Objects/weakrefobject.c index e956372..1814c6e 100644 --- a/Objects/weakrefobject.c +++ b/Objects/weakrefobject.c @@ -2,7 +2,7 @@ #include "pycore_modsupport.h" // _PyArg_NoKwnames() #include "pycore_object.h" // _PyObject_GET_WEAKREFS_LISTPTR() #include "pycore_weakref.h" // _PyWeakref_GET_REF() -#include "structmember.h" // PyMemberDef + #define GET_WEAKREFS_LISTPTR(o) \ @@ -351,7 +351,7 @@ weakref___init__(PyObject *self, PyObject *args, PyObject *kwargs) static PyMemberDef weakref_members[] = { - {"__callback__", T_OBJECT, offsetof(PyWeakReference, wr_callback), READONLY}, + {"__callback__", _Py_T_OBJECT, offsetof(PyWeakReference, wr_callback), Py_READONLY}, {NULL} /* Sentinel */ }; diff --git a/PC/winreg.c b/PC/winreg.c index 5252f78..ed6258d 100644 --- a/PC/winreg.c +++ b/PC/winreg.c @@ -15,7 +15,7 @@ #include "Python.h" #include "pycore_object.h" // _PyObject_Init() #include "pycore_moduleobject.h" -#include "structmember.h" // PyMemberDef + #include #if defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM) || defined(MS_WINDOWS_GAMES) @@ -352,7 +352,7 @@ static struct PyMethodDef PyHKEY_methods[] = { #define OFF(e) offsetof(PyHKEYObject, e) static PyMemberDef PyHKEY_memberlist[] = { - {"handle", T_INT, OFF(hkey), READONLY}, + {"handle", Py_T_INT, OFF(hkey), Py_READONLY}, {NULL} /* Sentinel */ }; diff --git a/Parser/asdl_c.py b/Parser/asdl_c.py index e9665dd..f159b57 100755 --- a/Parser/asdl_c.py +++ b/Parser/asdl_c.py @@ -897,7 +897,7 @@ ast_type_reduce(PyObject *self, PyObject *unused) } static PyMemberDef ast_type_members[] = { - {"__dictoffset__", T_PYSSIZET, offsetof(AST_object, dict), READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, offsetof(AST_object, dict), Py_READONLY}, {NULL} /* Sentinel */ }; @@ -1542,7 +1542,6 @@ def generate_module_def(mod, metadata, f, internal_h): #include "pycore_ceval.h" // _Py_EnterRecursiveCall #include "pycore_interp.h" // _PyInterpreterState.ast #include "pycore_pystate.h" // _PyInterpreterState_GET() - #include "structmember.h" #include // Forward declaration diff --git a/Python/Python-ast.c b/Python/Python-ast.c index 55a1370..412de79 100644 --- a/Python/Python-ast.c +++ b/Python/Python-ast.c @@ -6,7 +6,6 @@ #include "pycore_ceval.h" // _Py_EnterRecursiveCall #include "pycore_interp.h" // _PyInterpreterState.ast #include "pycore_pystate.h" // _PyInterpreterState_GET() -#include "structmember.h" #include // Forward declaration @@ -923,7 +922,7 @@ ast_type_reduce(PyObject *self, PyObject *unused) } static PyMemberDef ast_type_members[] = { - {"__dictoffset__", T_PYSSIZET, offsetof(AST_object, dict), READONLY}, + {"__dictoffset__", Py_T_PYSSIZET, offsetof(AST_object, dict), Py_READONLY}, {NULL} /* Sentinel */ }; diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 0705f5b..0f1e007 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -36,7 +36,7 @@ #include "optimizer.h" #include "pydtrace.h" #include "setobject.h" -#include "structmember.h" // struct PyMemberDef, T_OFFSET_EX + #define USE_COMPUTED_GOTOS 0 #include "ceval_macros.h" diff --git a/Python/ceval.c b/Python/ceval.c index a8987ef..688c019 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -34,7 +34,7 @@ #include "opcode.h" #include "pydtrace.h" #include "setobject.h" -#include "structmember.h" // struct PyMemberDef, T_OFFSET_EX + #include #include diff --git a/Python/context.c b/Python/context.c index 1ffae98..9ac5187 100644 --- a/Python/context.c +++ b/Python/context.c @@ -7,7 +7,7 @@ #include "pycore_object.h" #include "pycore_pyerrors.h" #include "pycore_pystate.h" // _PyThreadState_GET() -#include "structmember.h" // PyMemberDef + #include "clinic/context.c.h" @@ -1042,7 +1042,7 @@ _contextvars_ContextVar_reset(PyContextVar *self, PyObject *token) static PyMemberDef PyContextVar_members[] = { - {"name", T_OBJECT, offsetof(PyContextVar, var_name), READONLY}, + {"name", _Py_T_OBJECT, offsetof(PyContextVar, var_name), Py_READONLY}, {NULL} }; diff --git a/Python/specialize.c b/Python/specialize.c index 5892f54..1669ce1 100644 --- a/Python/specialize.c +++ b/Python/specialize.c @@ -9,7 +9,7 @@ #include "pycore_object.h" #include "pycore_opcode.h" // _PyOpcode_Caches #include "pycore_pylifecycle.h" // _PyOS_URandomNonblock() -#include "structmember.h" // struct PyMemberDef, T_OFFSET_EX + #include // rand() @@ -621,7 +621,7 @@ analyze_descriptor(PyTypeObject *type, PyObject *name, PyObject **descr, int sto if (desc_cls == &PyMemberDescr_Type) { PyMemberDescrObject *member = (PyMemberDescrObject *)descriptor; struct PyMemberDef *dmem = member->d_member; - if (dmem->type == T_OBJECT_EX) { + if (dmem->type == Py_T_OBJECT_EX) { return OBJECT_SLOT; } return OTHER_SLOT; @@ -803,7 +803,7 @@ _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name) SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_EXPECTED_ERROR); goto fail; } - if (dmem->flags & PY_AUDIT_READ) { + if (dmem->flags & Py_AUDIT_READ) { SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_ATTR_AUDITED_SLOT); goto fail; } @@ -811,7 +811,7 @@ _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name) SPECIALIZATION_FAIL(LOAD_ATTR, SPEC_FAIL_OUT_OF_RANGE); goto fail; } - assert(dmem->type == T_OBJECT_EX); + assert(dmem->type == Py_T_OBJECT_EX); assert(offset > 0); cache->index = (uint16_t)offset; write_u32(cache->version, type->tp_version_tag); @@ -939,7 +939,7 @@ _Py_Specialize_StoreAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name) SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_EXPECTED_ERROR); goto fail; } - if (dmem->flags & READONLY) { + if (dmem->flags & Py_READONLY) { SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_ATTR_READ_ONLY); goto fail; } @@ -947,7 +947,7 @@ _Py_Specialize_StoreAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name) SPECIALIZATION_FAIL(STORE_ATTR, SPEC_FAIL_OUT_OF_RANGE); goto fail; } - assert(dmem->type == T_OBJECT_EX); + assert(dmem->type == Py_T_OBJECT_EX); assert(offset > 0); cache->index = (uint16_t)offset; write_u32(cache->version, type->tp_version_tag); diff --git a/Python/structmember.c b/Python/structmember.c index 19a7522..7a5a6a4 100644 --- a/Python/structmember.c +++ b/Python/structmember.c @@ -2,7 +2,7 @@ /* Map C struct members to Python object attributes */ #include "Python.h" -#include "structmember.h" // PyMemberDef + PyObject * PyMember_GetOne(const char *obj_addr, PyMemberDef *l) @@ -17,62 +17,62 @@ PyMember_GetOne(const char *obj_addr, PyMemberDef *l) const char* addr = obj_addr + l->offset; switch (l->type) { - case T_BOOL: + case Py_T_BOOL: v = PyBool_FromLong(*(char*)addr); break; - case T_BYTE: + case Py_T_BYTE: v = PyLong_FromLong(*(char*)addr); break; - case T_UBYTE: + case Py_T_UBYTE: v = PyLong_FromUnsignedLong(*(unsigned char*)addr); break; - case T_SHORT: + case Py_T_SHORT: v = PyLong_FromLong(*(short*)addr); break; - case T_USHORT: + case Py_T_USHORT: v = PyLong_FromUnsignedLong(*(unsigned short*)addr); break; - case T_INT: + case Py_T_INT: v = PyLong_FromLong(*(int*)addr); break; - case T_UINT: + case Py_T_UINT: v = PyLong_FromUnsignedLong(*(unsigned int*)addr); break; - case T_LONG: + case Py_T_LONG: v = PyLong_FromLong(*(long*)addr); break; - case T_ULONG: + case Py_T_ULONG: v = PyLong_FromUnsignedLong(*(unsigned long*)addr); break; - case T_PYSSIZET: + case Py_T_PYSSIZET: v = PyLong_FromSsize_t(*(Py_ssize_t*)addr); break; - case T_FLOAT: + case Py_T_FLOAT: v = PyFloat_FromDouble((double)*(float*)addr); break; - case T_DOUBLE: + case Py_T_DOUBLE: v = PyFloat_FromDouble(*(double*)addr); break; - case T_STRING: + case Py_T_STRING: if (*(char**)addr == NULL) { v = Py_NewRef(Py_None); } else v = PyUnicode_FromString(*(char**)addr); break; - case T_STRING_INPLACE: + case Py_T_STRING_INPLACE: v = PyUnicode_FromString((char*)addr); break; - case T_CHAR: + case Py_T_CHAR: v = PyUnicode_FromStringAndSize((char*)addr, 1); break; - case T_OBJECT: + case _Py_T_OBJECT: v = *(PyObject **)addr; if (v == NULL) v = Py_None; Py_INCREF(v); break; - case T_OBJECT_EX: + case Py_T_OBJECT_EX: v = *(PyObject **)addr; if (v == NULL) { PyObject *obj = (PyObject *)obj_addr; @@ -83,13 +83,13 @@ PyMember_GetOne(const char *obj_addr, PyMemberDef *l) } Py_XINCREF(v); break; - case T_LONGLONG: + case Py_T_LONGLONG: v = PyLong_FromLongLong(*(long long *)addr); break; - case T_ULONGLONG: + case Py_T_ULONGLONG: v = PyLong_FromUnsignedLongLong(*(unsigned long long *)addr); break; - case T_NONE: + case _Py_T_NONE: v = Py_NewRef(Py_None); break; default: @@ -118,27 +118,27 @@ PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v) addr += l->offset; - if ((l->flags & READONLY)) + if ((l->flags & Py_READONLY)) { PyErr_SetString(PyExc_AttributeError, "readonly attribute"); return -1; } if (v == NULL) { - if (l->type == T_OBJECT_EX) { + if (l->type == Py_T_OBJECT_EX) { /* Check if the attribute is set. */ if (*(PyObject **)addr == NULL) { PyErr_SetString(PyExc_AttributeError, l->name); return -1; } } - else if (l->type != T_OBJECT) { + else if (l->type != _Py_T_OBJECT) { PyErr_SetString(PyExc_TypeError, "can't delete numeric/char attribute"); return -1; } } switch (l->type) { - case T_BOOL:{ + case Py_T_BOOL:{ if (!PyBool_Check(v)) { PyErr_SetString(PyExc_TypeError, "attribute value type must be bool"); @@ -150,7 +150,7 @@ PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v) *(char*)addr = (char) 0; break; } - case T_BYTE:{ + case Py_T_BYTE:{ long long_val = PyLong_AsLong(v); if ((long_val == -1) && PyErr_Occurred()) return -1; @@ -161,7 +161,7 @@ PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v) WARN("Truncation of value to char"); break; } - case T_UBYTE:{ + case Py_T_UBYTE:{ long long_val = PyLong_AsLong(v); if ((long_val == -1) && PyErr_Occurred()) return -1; @@ -170,7 +170,7 @@ PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v) WARN("Truncation of value to unsigned char"); break; } - case T_SHORT:{ + case Py_T_SHORT:{ long long_val = PyLong_AsLong(v); if ((long_val == -1) && PyErr_Occurred()) return -1; @@ -179,7 +179,7 @@ PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v) WARN("Truncation of value to short"); break; } - case T_USHORT:{ + case Py_T_USHORT:{ long long_val = PyLong_AsLong(v); if ((long_val == -1) && PyErr_Occurred()) return -1; @@ -188,7 +188,7 @@ PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v) WARN("Truncation of value to unsigned short"); break; } - case T_INT:{ + case Py_T_INT:{ long long_val = PyLong_AsLong(v); if ((long_val == -1) && PyErr_Occurred()) return -1; @@ -197,7 +197,7 @@ PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v) WARN("Truncation of value to int"); break; } - case T_UINT:{ + case Py_T_UINT:{ unsigned long ulong_val = PyLong_AsUnsignedLong(v); if ((ulong_val == (unsigned long)-1) && PyErr_Occurred()) { /* XXX: For compatibility, accept negative int values @@ -215,13 +215,13 @@ PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v) WARN("Truncation of value to unsigned int"); break; } - case T_LONG:{ + case Py_T_LONG:{ *(long*)addr = PyLong_AsLong(v); if ((*(long*)addr == -1) && PyErr_Occurred()) return -1; break; } - case T_ULONG:{ + case Py_T_ULONG:{ *(unsigned long*)addr = PyLong_AsUnsignedLong(v); if ((*(unsigned long*)addr == (unsigned long)-1) && PyErr_Occurred()) { @@ -236,32 +236,32 @@ PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v) } break; } - case T_PYSSIZET:{ + case Py_T_PYSSIZET:{ *(Py_ssize_t*)addr = PyLong_AsSsize_t(v); if ((*(Py_ssize_t*)addr == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; break; } - case T_FLOAT:{ + case Py_T_FLOAT:{ double double_val = PyFloat_AsDouble(v); if ((double_val == -1) && PyErr_Occurred()) return -1; *(float*)addr = (float)double_val; break; } - case T_DOUBLE: + case Py_T_DOUBLE: *(double*)addr = PyFloat_AsDouble(v); if ((*(double*)addr == -1) && PyErr_Occurred()) return -1; break; - case T_OBJECT: - case T_OBJECT_EX: + case _Py_T_OBJECT: + case Py_T_OBJECT_EX: oldv = *(PyObject **)addr; *(PyObject **)addr = Py_XNewRef(v); Py_XDECREF(oldv); break; - case T_CHAR: { + case Py_T_CHAR: { const char *string; Py_ssize_t len; @@ -273,18 +273,18 @@ PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v) *(char*)addr = string[0]; break; } - case T_STRING: - case T_STRING_INPLACE: + case Py_T_STRING: + case Py_T_STRING_INPLACE: PyErr_SetString(PyExc_TypeError, "readonly attribute"); return -1; - case T_LONGLONG:{ + case Py_T_LONGLONG:{ long long value; *(long long*)addr = value = PyLong_AsLongLong(v); if ((value == -1) && PyErr_Occurred()) return -1; break; } - case T_ULONGLONG:{ + case Py_T_ULONGLONG:{ unsigned long long value; /* ??? PyLong_AsLongLong accepts an int, but PyLong_AsUnsignedLongLong doesn't ??? */ diff --git a/Python/symtable.c b/Python/symtable.c index 2407367..04be319 100644 --- a/Python/symtable.c +++ b/Python/symtable.c @@ -3,7 +3,7 @@ #include "pycore_parser.h" // _PyParser_ASTFromString() #include "pycore_pystate.h" // _PyThreadState_GET() #include "pycore_symtable.h" // PySTEntryObject -#include "structmember.h" // PyMemberDef + /* error strings used for warnings */ #define GLOBAL_PARAM \ @@ -171,14 +171,14 @@ ste_dealloc(PySTEntryObject *ste) #define OFF(x) offsetof(PySTEntryObject, x) static PyMemberDef ste_memberlist[] = { - {"id", T_OBJECT, OFF(ste_id), READONLY}, - {"name", T_OBJECT, OFF(ste_name), READONLY}, - {"symbols", T_OBJECT, OFF(ste_symbols), READONLY}, - {"varnames", T_OBJECT, OFF(ste_varnames), READONLY}, - {"children", T_OBJECT, OFF(ste_children), READONLY}, - {"nested", T_INT, OFF(ste_nested), READONLY}, - {"type", T_INT, OFF(ste_type), READONLY}, - {"lineno", T_INT, OFF(ste_lineno), READONLY}, + {"id", _Py_T_OBJECT, OFF(ste_id), Py_READONLY}, + {"name", _Py_T_OBJECT, OFF(ste_name), Py_READONLY}, + {"symbols", _Py_T_OBJECT, OFF(ste_symbols), Py_READONLY}, + {"varnames", _Py_T_OBJECT, OFF(ste_varnames), Py_READONLY}, + {"children", _Py_T_OBJECT, OFF(ste_children), Py_READONLY}, + {"nested", Py_T_INT, OFF(ste_nested), Py_READONLY}, + {"type", Py_T_INT, OFF(ste_type), Py_READONLY}, + {"lineno", Py_T_INT, OFF(ste_lineno), Py_READONLY}, {NULL} }; diff --git a/Python/traceback.c b/Python/traceback.c index c5787b5..ca524b1 100644 --- a/Python/traceback.c +++ b/Python/traceback.c @@ -17,7 +17,7 @@ #include "../Parser/pegen.h" // _PyPegen_byte_offset_to_character_offset() #include "frameobject.h" // PyFrame_New() -#include "structmember.h" // PyMemberDef + #include "osdefs.h" // SEP #ifdef HAVE_FCNTL_H # include @@ -148,9 +148,9 @@ static PyMethodDef tb_methods[] = { }; static PyMemberDef tb_memberlist[] = { - {"tb_frame", T_OBJECT, OFF(tb_frame), READONLY|PY_AUDIT_READ}, - {"tb_lasti", T_INT, OFF(tb_lasti), READONLY}, - {"tb_lineno", T_INT, OFF(tb_lineno), READONLY}, + {"tb_frame", _Py_T_OBJECT, OFF(tb_frame), Py_READONLY|Py_AUDIT_READ}, + {"tb_lasti", Py_T_INT, OFF(tb_lasti), Py_READONLY}, + {"tb_lineno", Py_T_INT, OFF(tb_lineno), Py_READONLY}, {NULL} /* Sentinel */ }; -- cgit v0.12