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

gh-106869: Use new PyMemberDef constant names (#106871) 

* Remove '#include "structmember.h"'.
* If needed, add <stddef.h> 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)
This commit is contained in:
Victor Stinner 2023-07-25 15:28:30 +02:00 committed by GitHub
parent ed08238327
commit 1a3faba9f1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
78 changed files with 472 additions and 464 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Include/internal/pycore_frame.h
View File

@ -5,7 +5,7 @@ extern "C" {
#endif
#include <stdbool.h>
#include <stddef.h>
#include <stddef.h> // offsetof()
#include "pycore_code.h" // STATS
/* See Objects/frame_layout.md for an explanation of the frame stack

2
Modules/_asynciomodule.c
View File

@ -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 <stddef.h> // offsetof()

14
Modules/_bz2module.c
View File

@ -1,10 +1,10 @@
/* _bz2 - Low-level Python interface to libbzip2. */
#include "Python.h"
#include "structmember.h" // PyMemberDef
#include <bzlib.h>
#include <stdio.h>
#include <stddef.h> // 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}
};

8
Modules/_collectionsmodule.c
View File

@ -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 <stddef.h>
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}
};

15
Modules/_csv.c
View File

@ -11,7 +11,8 @@ module instead.
#define MODULE_VERSION "1.0"
#include "Python.h"
#include "structmember.h" // PyMemberDef
#include <stddef.h> // offsetof()
#include <stdbool.h>
/*[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 }
};

14
Modules/_ctypes/_ctypes.c
View File

@ -110,7 +110,7 @@ bytes(cdata)
#include "pycore_call.h" // _PyObject_CallNoArgs()
#include "pycore_ceval.h" // _Py_EnterRecursiveCall()
#include "structmember.h" // PyMemberDef
#include <ffi.h>
#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 },
};

6
Modules/_ctypes/callproc.c
View File

@ -59,7 +59,7 @@
#endif
#include "Python.h"
#include "structmember.h" // PyMemberDef
#include <stdbool.h>
@ -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 },
};

8
Modules/_datetimemodule.c
View File

@ -15,7 +15,7 @@
#include "pycore_long.h" // _PyLong_GetOne()
#include "pycore_object.h" // _PyObject_Init()
#include "datetime.h"
#include "structmember.h" // PyMemberDef
#include <time.h>
@ -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}
};

9
Modules/_elementtree.c
View File

@ -18,7 +18,8 @@
#include "Python.h"
#include "pycore_import.h" // _PyImport_GetModuleAttrString()
#include "pycore_pyhash.h" // _Py_HashSecret
#include "structmember.h" // PyMemberDef
#include <stddef.h> // 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},
};

30
Modules/_functoolsmodule.c
View File

@ -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 */
};

30
Modules/_io/bufferedio.c
View File

@ -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}
};

4
Modules/_io/bytesio.c
View File

@ -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}
};

10
Modules/_io/fileio.c
View File

@ -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 <stdbool.h>
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
@ -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}
};

4
Modules/_io/iobase.c
View File

@ -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},
};

4
Modules/_io/stringio.c
View File

@ -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},
};

16
Modules/_io/textio.c
View File

@ -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}
};

10
Modules/_io/winconsoleio.c
View File

@ -12,7 +12,7 @@
#ifdef HAVE_WINDOWS_CONSOLE_IO
#include "structmember.h" // PyMemberDef
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#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}
};

30
Modules/_json.c
View File

@ -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 <stdbool.h> // 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}
};

10
Modules/_lzmamodule.c
View File

@ -6,7 +6,7 @@
*/
#include "Python.h"
#include "structmember.h" // PyMemberDef
#include <stdlib.h> // free()
#include <string.h>
@ -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}
};

8
Modules/_multiprocessing/semaphore.c
View File

@ -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}
};

6
Modules/_operator.c
View File

@ -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*/
};

8
Modules/_pickle.c
View File

@ -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 <stdlib.h> // 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}
};

4
Modules/_queuemodule.c
View File

@ -5,7 +5,7 @@
#include "Python.h"
#include "pycore_moduleobject.h" // _PyModule_GetState()
#include "pycore_time.h" // _PyTime_t
#include "structmember.h" // PyMemberDef
#include <stddef.h> // 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},
};

2
Modules/_sqlite/blob.c
View File

@ -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},
};

26
Modules/_sqlite/connection.c
View File

@ -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}
};

14
Modules/_sqlite/cursor.c
View File

@ -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}
};

20
Modules/_sre/sre.c
View File

@ -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 */
};

5
Modules/_struct.c
View File

@ -10,8 +10,9 @@
#include "Python.h"
#include "pycore_bytesobject.h" // _PyBytesWriter
#include "pycore_moduleobject.h" // _PyModule_GetState()
#include "structmember.h" // PyMemberDef
#include <ctype.h>
#include <stddef.h> // 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 */
};

4
Modules/_testcapi/buffer.c
View File

@ -2,7 +2,7 @@
#include "parts.h"
#include "structmember.h" // PyMemberDef
#include <stddef.h> // 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},
};

25
Modules/_testcapi/heaptype.c
View File

@ -1,5 +1,6 @@
#include "parts.h"
#include "structmember.h" // PyMemberDef
#include <stddef.h> // 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 */
};

4
Modules/_testcapi/vectorcall.c
View File

@ -1,7 +1,7 @@
#include "parts.h"
#include "clinic/vectorcall.c.h"
#include "structmember.h" // PyMemberDef
#include <stddef.h> // 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}
};

4
Modules/_testcapi/vectorcall_limited.c
View File

@ -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}
};

5
Modules/_testcapimodule.c
View File

@ -20,9 +20,10 @@
#include "Python.h"
#include "frameobject.h" // PyFrame_New
#include "marshal.h" // PyMarshal_WriteLongToFile
#include "structmember.h" // for offsetof(), T_OBJECT
#include <float.h> // FLT_MAX
#include <signal.h>
#include <stddef.h> // offsetof()
#ifndef MS_WINDOWS
# include <unistd.h>
#endif
@ -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}
};

10
Modules/_threadmodule.c
View File

@ -9,7 +9,7 @@
#include "pycore_pystate.h" // _PyThreadState_SetCurrent()
#include "pycore_weakref.h" // _PyWeakref_GET_REF()
#include <stddef.h> // offsetof()
#include "structmember.h" // PyMemberDef
#ifdef HAVE_SIGNAL_H
# include <signal.h> // 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},
};

8
Modules/_winapi.c
View File

@ -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}
};

10
Modules/_zoneinfo.c
View File

@ -4,7 +4,7 @@
#include "Python.h"
#include "pycore_long.h" // _PyLong_GetOne()
#include "structmember.h"
#include <ctype.h>
#include <stddef.h>
@ -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 */
};

4
Modules/arraymodule.c
View File

@ -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 <stddef.h> // offsetof()
#include <stdbool.h>
@ -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},
};

12
Modules/cjkcodecs/multibytecodec.c
View File

@ -9,10 +9,12 @@
#endif
#include "Python.h"
#include "structmember.h" // PyMemberDef
#include "multibytecodec.h"
#include "clinic/multibytecodec.c.h"
#include <stddef.h> // 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,}
};

4
Modules/itertoolsmodule.c
View File

@ -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 <stddef.h> // 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},
};

4
Modules/mmapmodule.c
View File

@ -25,7 +25,7 @@
#include <Python.h>
#include "pycore_bytesobject.h" // _PyBytes_Find()
#include "pycore_fileutils.h" // _Py_stat_struct
#include "structmember.h" // PyMemberDef
#include <stddef.h> // 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},
};

12
Modules/overlapped.c
View File

@ -8,7 +8,7 @@
Check itemsize */
#include "Python.h"
#include "structmember.h" // PyMemberDef
#define WINDOWS_LEAN_AND_MEAN
#include <winsock2.h>
@ -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}
};

6
Modules/posixmodule.c
View File

@ -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}
};

7
Modules/pyexpat.c
View File

@ -5,11 +5,10 @@
#include "Python.h"
#include "pycore_import.h" // _PyImport_SetModule()
#include "pycore_pyhash.h" // _Py_HashSecret
#include <ctype.h>
#include "structmember.h" // PyMemberDef
#include <stddef.h> // 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}
};

35
Modules/selectmodule.c
View File

@ -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 <stddef.h> // offsetof()
#ifdef HAVE_SYS_DEVPOLL_H
#include <sys/resource.h>
@ -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 */

2
Modules/sha2module.c
View File

@ -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]

8
Modules/socketmodule.c
View File

@ -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 <sanitizer/msan_interface.h>
@ -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},
};

4
Modules/unicodedata.c
View File

@ -18,9 +18,9 @@
#include "Python.h"
#include "pycore_ucnhash.h" // _PyUnicode_Name_CAPI
#include "structmember.h" // PyMemberDef
#include <stdbool.h>
#include <stddef.h> // 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}
};

5
Modules/xxsubtype.c
View File

@ -1,5 +1,6 @@
#include "Python.h"
#include "structmember.h" // PyMemberDef
#include <stddef.h> // 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}
};

20
Modules/zlibmodule.c
View File

@ -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},
};

8
Objects/classobject.c
View File

@ -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 */
};

30
Objects/codeobject.c
View File

@ -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 */
};

6
Objects/complexobject.c
View File

@ -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},
};

18
Objects/descrobject.c
View File

@ -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}
};

62
Objects/exceptions.c
View File

@ -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 */
};

4
Objects/frameobject.c
View File

@ -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 */
};

20
Objects/funcobject.c
View File

@ -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 */
};

8
Objects/genericaliasobject.c
View File

@ -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 <stdbool.h>
@ -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}
};

8
Objects/genobject.c
View File

@ -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 */
};

4
Objects/methodobject.c
View File

@ -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}
};

4
Objects/moduleobject.c
View File

@ -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}
};

6
Objects/namespaceobject.c
View File

@ -2,7 +2,9 @@
#include "Python.h"
#include "pycore_namespace.h" // _PyNamespace_Type
#include "structmember.h" // PyMemberDef
#include <stddef.h> // 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}
};

8
Objects/rangeobject.c
View File

@ -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}
};

8
Objects/sliceobject.c
View File

@ -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}
};

6
Objects/structseq.c
View File

@ -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++;
}

42
Objects/typeobject.c
View File

@ -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 <ctype.h>
#include <stddef.h> // 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}
};

26
Objects/typevarobject.c
View File

@ -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}
};

4
Objects/unionobject.c
View File

@ -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}
};

4
Objects/weakrefobject.c
View File

@ -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 */
};

4
PC/winreg.c
View File

@ -15,7 +15,7 @@
#include "Python.h"
#include "pycore_object.h" // _PyObject_Init()
#include "pycore_moduleobject.h"
#include "structmember.h" // PyMemberDef
#include <windows.h>
#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 */
};

3
Parser/asdl_c.py
View File

@ -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 <stddef.h>
// Forward declaration

3
Python/Python-ast.c generated
View File

@ -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 <stddef.h>
// 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 */
};

2
Python/bytecodes.c
View File

@ -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"

2
Python/ceval.c
View File

@ -34,7 +34,7 @@
#include "opcode.h"
#include "pydtrace.h"
#include "setobject.h"
#include "structmember.h" // struct PyMemberDef, T_OFFSET_EX
#include <ctype.h>
#include <stdbool.h>

4
Python/context.c
View File

@ -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}
};

12
Python/specialize.c
View File

@ -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 <stdlib.h> // 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);

86
Python/structmember.c
View File

@ -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 ??? */

18
Python/symtable.c
View File

@ -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}
};

8
Python/traceback.c
View File

@ -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 <fcntl.h>
@ -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 */
};