diff --git a/Modules/Setup.stdlib.in b/Modules/Setup.stdlib.in
--- a/Modules/Setup.stdlib.in
+++ b/Modules/Setup.stdlib.in
@@ -176,7 +176,7 @@
@MODULE__TESTBUFFER_TRUE@_testbuffer _testbuffer.c
@MODULE__TESTINTERNALCAPI_TRUE@_testinternalcapi _testinternalcapi.c _testinternalcapi/test_lock.c _testinternalcapi/pytime.c _testinternalcapi/set.c _testinternalcapi/test_critical_sections.c _testinternalcapi/complex.c _testinternalcapi/interpreter.c _testinternalcapi/tuple.c
@MODULE__TESTCAPI_TRUE@_testcapi _testcapimodule.c _testcapi/vectorcall.c _testcapi/heaptype.c _testcapi/abstract.c _testcapi/unicode.c _testcapi/dict.c _testcapi/set.c _testcapi/list.c _testcapi/tuple.c _testcapi/getargs.c _testcapi/datetime.c _testcapi/docstring.c _testcapi/mem.c _testcapi/watchers.c _testcapi/long.c _testcapi/float.c _testcapi/complex.c _testcapi/numbers.c _testcapi/structmember.c _testcapi/exceptions.c _testcapi/code.c _testcapi/buffer.c _testcapi/pyatomic.c _testcapi/run.c _testcapi/file.c _testcapi/codec.c _testcapi/immortal.c _testcapi/gc.c _testcapi/hash.c _testcapi/time.c _testcapi/bytes.c _testcapi/object.c _testcapi/modsupport.c _testcapi/monitoring.c _testcapi/config.c _testcapi/import.c _testcapi/frame.c _testcapi/type.c _testcapi/function.c _testcapi/module.c
-@MODULE__TESTLIMITEDCAPI_TRUE@_testlimitedcapi _testlimitedcapi.c _testlimitedcapi/abstract.c _testlimitedcapi/bytearray.c _testlimitedcapi/bytes.c _testlimitedcapi/codec.c _testlimitedcapi/complex.c _testlimitedcapi/dict.c _testlimitedcapi/eval.c _testlimitedcapi/float.c _testlimitedcapi/heaptype_relative.c _testlimitedcapi/import.c _testlimitedcapi/list.c _testlimitedcapi/long.c _testlimitedcapi/object.c _testlimitedcapi/pyos.c _testlimitedcapi/set.c _testlimitedcapi/sys.c _testlimitedcapi/threadstate.c _testlimitedcapi/tuple.c _testlimitedcapi/unicode.c _testlimitedcapi/vectorcall_limited.c _testlimitedcapi/version.c _testlimitedcapi/file.c
+@MODULE__TESTLIMITEDCAPI_TRUE@_testlimitedcapi _testlimitedcapi.c _testlimitedcapi/abstract.c _testlimitedcapi/bytearray.c _testlimitedcapi/bytes.c _testlimitedcapi/codec.c _testlimitedcapi/complex.c _testlimitedcapi/dict.c _testlimitedcapi/eval.c _testlimitedcapi/float.c _testlimitedcapi/heaptype_relative.c _testlimitedcapi/import.c _testlimitedcapi/list.c _testlimitedcapi/long.c _testlimitedcapi/object.c _testlimitedcapi/pyos.c _testlimitedcapi/set.c _testlimitedcapi/slots.c _testlimitedcapi/sys.c _testlimitedcapi/threadstate.c _testlimitedcapi/tuple.c _testlimitedcapi/unicode.c _testlimitedcapi/vectorcall_limited.c _testlimitedcapi/version.c _testlimitedcapi/file.c
@MODULE__TESTCLINIC_TRUE@_testclinic _testclinic.c
@MODULE__TESTCLINIC_LIMITED_TRUE@_testclinic_limited _testclinic_limited.c
diff --git a/Modules/_testcapi/module.c b/Modules/_testcapi/module.c
--- a/Modules/_testcapi/module.c
+++ b/Modules/_testcapi/module.c
@@ -13,18 +13,18 @@ PyABIInfo_VAR(abi_info);
static PyObject *
module_from_slots_empty(PyObject *self, PyObject *spec)
{
- PyModuleDef_Slot slots[] = {
- {0},
+ PySlot slots[] = {
+ PySlot_END,
};
return PyModule_FromSlotsAndSpec(slots, spec);
}
static PyObject *
module_from_slots_minimal(PyObject *self, PyObject *spec)
{
- PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {0},
+ PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_END,
};
return PyModule_FromSlotsAndSpec(slots, spec);
}
@@ -38,38 +38,38 @@ module_from_slots_null(PyObject *self, PyObject *spec)
static PyObject *
module_from_slots_name(PyObject *self, PyObject *spec)
{
- PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_name, "currently ignored..."},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_DATA(Py_mod_name, "currently ignored..."),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
return PyModule_FromSlotsAndSpec(slots, spec);
}
static PyObject *
module_from_slots_doc(PyObject *self, PyObject *spec)
{
- PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_doc, "the docstring"},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_DATA(Py_mod_doc, "the docstring"),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
return PyModule_FromSlotsAndSpec(slots, spec);
}
static PyObject *
module_from_slots_size(PyObject *self, PyObject *spec)
{
- PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_state_size, (void*)123},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_SIZE(Py_mod_state_size, (void*)123),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
PyObject *mod = PyModule_FromSlotsAndSpec(slots, spec);
if (!mod) {
@@ -92,12 +92,12 @@ static PyMethodDef a_methoddef_array[] = {
static PyObject *
module_from_slots_methods(PyObject *self, PyObject *spec)
{
- PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_methods, a_methoddef_array},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_STATIC_DATA(Py_mod_methods, a_methoddef_array),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
return PyModule_FromSlotsAndSpec(slots, spec);
}
@@ -111,14 +111,14 @@ static void noop_free(void *self) { }
static PyObject *
module_from_slots_gc(PyObject *self, PyObject *spec)
{
- PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_state_traverse, noop_traverse},
- {Py_mod_state_clear, noop_clear},
- {Py_mod_state_free, noop_free},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_FUNC(Py_mod_state_traverse, noop_traverse),
+ PySlot_FUNC(Py_mod_state_clear, noop_clear),
+ PySlot_FUNC(Py_mod_state_free, noop_free),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
PyObject *mod = PyModule_FromSlotsAndSpec(slots, spec);
if (!mod) {
@@ -144,12 +144,12 @@ static const char test_token;
static PyObject *
module_from_slots_token(PyObject *self, PyObject *spec)
{
- PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_token, (void*)&test_token},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_DATA(Py_mod_token, (void*)&test_token),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
PyObject *mod = PyModule_FromSlotsAndSpec(slots, spec);
if (!mod) {
@@ -175,12 +175,12 @@ simple_exec(PyObject *module)
static PyObject *
module_from_slots_exec(PyObject *self, PyObject *spec)
{
- PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_exec, simple_exec},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_FUNC(Py_mod_exec, simple_exec),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
PyObject *mod = PyModule_FromSlotsAndSpec(slots, spec);
if (!mod) {
@@ -209,12 +209,12 @@ create_attr_from_spec(PyObject *spec, PyModuleDef *def)
static PyObject *
module_from_slots_create(PyObject *self, PyObject *spec)
{
- PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_create, create_attr_from_spec},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ const PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_FUNC(Py_mod_create, create_attr_from_spec),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
return PyModule_FromSlotsAndSpec(slots, spec);
}
@@ -241,13 +241,13 @@ module_from_slots_repeat_slot(PyObject *self, PyObject *spec)
if (slot_id < 0) {
return NULL;
}
- PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {slot_id, "anything"},
- {slot_id, "anything else"},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ const PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_PTR_STATIC(slot_id, "anything"),
+ PySlot_PTR_STATIC(slot_id, "anything_else"),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
return PyModule_FromSlotsAndSpec(slots, spec);
}
@@ -259,12 +259,12 @@ module_from_slots_null_slot(PyObject *self, PyObject *spec)
if (slot_id < 0) {
return NULL;
}
- PyModuleDef_Slot slots[] = {
- {slot_id, NULL},
- {Py_mod_abi, &abi_info},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ const PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_PTR_STATIC(slot_id, NULL),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
return PyModule_FromSlotsAndSpec(slots, spec);
}
@@ -347,12 +347,12 @@ module_from_bad_abiinfo(PyObject *self, PyObject *spec)
1, 0,
.abi_version=0x02080000,
};
- PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_abi, &bad_abi_info},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_DATA(Py_mod_abi, &bad_abi_info),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
return PyModule_FromSlotsAndSpec(slots, spec);
}
@@ -365,14 +365,14 @@ module_from_multiple_abiinfo(PyObject *self, PyObject *spec)
.flags=PyABIInfo_STABLE | PyABIInfo_FREETHREADING_AGNOSTIC,
.abi_version=0x03040000,
};
- PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_abi, &abi_info},
- {Py_mod_abi, &extra_abi_info},
- {Py_mod_abi, &extra_abi_info},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_DATA(Py_mod_abi, &extra_abi_info),
+ PySlot_DATA(Py_mod_abi, &extra_abi_info),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
return PyModule_FromSlotsAndSpec(slots, spec);
}
@@ -466,6 +466,53 @@ pymodule_get_state_size(PyObject *self, PyObject *module)
return PyLong_FromSsize_t(size);
}
+static PyObject *
+module_from_null_def_slot(PyObject* Py_UNUSED(module), PyObject *args)
+{
+ long slot_number;
+ PyObject *spec;
+ if (!PyArg_ParseTuple(args, "lO", &slot_number, &spec)) {
+ return NULL;
+ }
+ static PyModuleDef_Slot slots[] = {
+ {0, NULL},
+ {0},
+ };
+ static PyModuleDef def = {
+ PyModuleDef_HEAD_INIT,
+ .m_name = "mymod",
+ .m_slots = slots,
+ };
+ // hack: def is supposed to be constant.
+ // Don't do this at home; use PyModule_FromSlotsAndSpec throwaway
+ // definitions!
+ slots[0].slot = slot_number;
+ return PyModule_FromDefAndSpec(&def, spec);
+}
+
+static PyObject *
+module_from_def_nonstatic_nested(PyObject* Py_UNUSED(module), PyObject *spec)
+{
+ static PyModuleDef_Slot subsubslots[] = {
+ {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+ {0},
+ };
+ static PySlot subslots[] = {
+ PySlot_DATA(Py_mod_slots, subsubslots),
+ PySlot_END,
+ };
+ static PyModuleDef_Slot slots[] = {
+ {Py_slot_subslots, subslots},
+ {0},
+ };
+ static PyModuleDef def = {
+ PyModuleDef_HEAD_INIT,
+ .m_name = "mymod",
+ .m_slots = slots,
+ };
+ return PyModule_FromDefAndSpec(&def, spec);
+}
+
static PyMethodDef test_methods[] = {
{"module_from_slots_empty", module_from_slots_empty, METH_O},
{"module_from_slots_minimal", module_from_slots_minimal, METH_O},
@@ -489,6 +536,8 @@ static PyMethodDef test_methods[] = {
{"pymodule_get_def", pymodule_get_def, METH_O},
{"pymodule_get_state_size", pymodule_get_state_size, METH_O},
{"pymodule_exec", pymodule_exec, METH_O},
+ {"module_from_null_def_slot", module_from_null_def_slot, METH_VARARGS},
+ {"module_from_def_nonstatic_nested", module_from_def_nonstatic_nested, METH_O},
{NULL},
};
diff --git a/Modules/_testcapi/type.c b/Modules/_testcapi/type.c
--- a/Modules/_testcapi/type.c
+++ b/Modules/_testcapi/type.c
@@ -110,9 +110,9 @@ test_get_statictype_slots(PyObject *self, PyObject *Py_UNUSED(ignored))
return NULL;
}
- void *over_value = PyType_GetSlot(&PyLong_Type, Py_bf_releasebuffer + 1);
+ void *over_value = PyType_GetSlot(&PyLong_Type, Py_mod_name + 1);
if (over_value != NULL) {
- PyErr_SetString(PyExc_AssertionError, "mismatch: max+1 of long");
+ PyErr_SetString(PyExc_AssertionError, "mismatch: mod_name of long");
return NULL;
}
diff --git a/Modules/_testlimitedcapi.c b/Modules/_testlimitedcapi.c
--- a/Modules/_testlimitedcapi.c
+++ b/Modules/_testlimitedcapi.c
@@ -74,6 +74,9 @@ PyInit__testlimitedcapi(void)
if (_PyTestLimitedCAPI_Init_Set(mod) < 0) {
return NULL;
}
+ if (_PyTestLimitedCAPI_Init_Slots(mod) < 0) {
+ return NULL;
+ }
if (_PyTestLimitedCAPI_Init_Sys(mod) < 0) {
return NULL;
}
diff --git a/Modules/_testlimitedcapi/parts.h b/Modules/_testlimitedcapi/parts.h
--- a/Modules/_testlimitedcapi/parts.h
+++ b/Modules/_testlimitedcapi/parts.h
@@ -37,6 +37,7 @@ int _PyTestLimitedCAPI_Init_List(PyObject *module);
int _PyTestLimitedCAPI_Init_Long(PyObject *module);
int _PyTestLimitedCAPI_Init_PyOS(PyObject *module);
int _PyTestLimitedCAPI_Init_Set(PyObject *module);
+int _PyTestLimitedCAPI_Init_Slots(PyObject *module);
int _PyTestLimitedCAPI_Init_Sys(PyObject *module);
int _PyTestLimitedCAPI_Init_ThreadState(PyObject *module);
int _PyTestLimitedCAPI_Init_Tuple(PyObject *module);
diff --git a/Modules/_testlimitedcapi/slots.c b/Modules/_testlimitedcapi/slots.c
new file mode 100644
--- /dev/null
+++ b/Modules/_testlimitedcapi/slots.c
@@ -0,0 +1,629 @@
+#define Py_LIMITED_API 0x030f0000
+
+#include "parts.h"
+
+PyABIInfo_VAR(abi_info);
+
+/* Define a bunch of (mostly nonsensical) functions to put in slots, so
+ * Lib/test/test_capi/test_slots.py can verify they've been assigned to
+ * the right slots.
+
+ * This module is full of "magic constants" which simply need to match
+ * between the C and Python part of the tests.
+ */
+
+// getbufferproc: export buffer; increment a counter
+static int
+demo_getbuffer(PyObject *exporter, Py_buffer *view, int flags)
+{
+ Py_INCREF(exporter);
+ // PyObject_GetTypeData & Py_TYPE: safe on non-subclassable type
+ int *data = PyObject_GetTypeData(exporter, Py_TYPE(exporter));
+ if (!data) {
+ return -1;
+ }
+ (*data)++;
+ return PyBuffer_FillInfo(view, exporter, "buf", 4, 1, flags);
+}
+
+// releasebufferproc: release buffer; decrement a counter
+static void
+demo_releasebuffer(PyObject *exporter, Py_buffer *view)
+{
+ Py_DECREF(exporter);
+ // PyObject_GetTypeData & Py_TYPE: safe on non-subclassable type
+ int *data = PyObject_GetTypeData(exporter, Py_TYPE(exporter));
+ if (!data) {
+ PyErr_WriteUnraisable(exporter);
+ return;
+ }
+ (*data)--;
+ return;
+}
+
+// objobjargproc: raise KeyError
+static int
+demo_ass_subscript(PyObject *o, PyObject *key, PyObject *v)
+{
+ PyErr_Format(PyExc_KeyError, "I don't like that key");
+ return -1;
+}
+
+// lenfunc: report 456
+static Py_ssize_t
+demo_length(PyObject *o)
+{
+ return (Py_ssize_t)456;
+}
+
+// binaryfunc; return constant value
+static PyObject *binop_123(PyObject* a, PyObject *b) { return PyLong_FromLong(123); }
+static PyObject *binop_234(PyObject* a, PyObject *b) { return PyLong_FromLong(234); }
+static PyObject *binop_345(PyObject* a, PyObject *b) { return PyLong_FromLong(345); }
+static PyObject *binop_456(PyObject* a, PyObject *b) { return PyLong_FromLong(456); }
+static PyObject *binop_567(PyObject* a, PyObject *b) { return PyLong_FromLong(567); }
+static PyObject *binop_678(PyObject* a, PyObject *b) { return PyLong_FromLong(678); }
+
+static PyObject *
+type_from_slots(PyObject* module, PyObject *args)
+{
+ char *case_name;
+ if (!PyArg_ParseTuple(args, "s", &case_name)) {
+ return NULL;
+ }
+#define CASE(NAME) \
+ if (strcmp(case_name, NAME) == 0) { \
+ return PyType_FromSlots((PySlot[]) { \
+ PySlot_DATA(Py_tp_name, "_testlimitedcapi.MyType"), \
+ PySlot_DATA(Py_tp_module, module), \
+ /////////////////////////////////////////////////////////////////////////
+#define ENDCASE() \
+ PySlot_END \
+ }); \
+ } \
+ /////////////////////////////////////////////////////////////////////////
+
+ CASE("basic")
+ ENDCASE()
+ CASE("foreign_slot")
+ PySlot_DATA(Py_mod_name, "this is not a module"),
+ ENDCASE()
+ CASE("basicsize")
+ PySlot_SIZE(Py_tp_basicsize, 256),
+ ENDCASE()
+ CASE("extra_basicsize")
+ PySlot_SIZE(Py_tp_extra_basicsize, 256),
+ ENDCASE()
+ CASE("itemsize")
+ PySlot_SIZE(Py_tp_itemsize, 16),
+ ENDCASE()
+ CASE("flags")
+ PySlot_UINT64(Py_tp_flags,
+ Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_BASETYPE),
+ ENDCASE()
+ CASE("matmul_123")
+ PySlot_FUNC(Py_nb_matrix_multiply, binop_123),
+ ENDCASE()
+ CASE("optional_end")
+ {.sl_flags=PySlot_OPTIONAL},
+ ENDCASE()
+ CASE("invalid")
+ {.sl_id=Py_slot_invalid},
+ ENDCASE()
+ CASE("invalid_fbad")
+ {.sl_id=0xfbad},
+ ENDCASE()
+ CASE("optional_invalid")
+ {.sl_id=Py_slot_invalid, .sl_flags=PySlot_OPTIONAL},
+ PySlot_SIZE(Py_tp_extra_basicsize, 256),
+ ENDCASE()
+ CASE("optional_invalid_fbad")
+ {.sl_id=0xfbad, .sl_flags=PySlot_OPTIONAL},
+ PySlot_SIZE(Py_tp_extra_basicsize, 256),
+ ENDCASE()
+ CASE("old_slot_numbers")
+ PySlot_FUNC(1, demo_getbuffer),
+ PySlot_FUNC(2, demo_releasebuffer),
+ PySlot_FUNC(3, demo_ass_subscript),
+ PySlot_FUNC(4, demo_length),
+ PySlot_SIZE(Py_tp_extra_basicsize, sizeof(int)),
+ PySlot_STATIC_DATA(Py_tp_members, ((PyMemberDef[]) {
+ {"buf_counter", Py_T_INT, 0, Py_READONLY | Py_RELATIVE_OFFSET},
+ {NULL},
+ })),
+ ENDCASE()
+ CASE("new_slot_numbers")
+ PySlot_FUNC(88, demo_getbuffer),
+ PySlot_FUNC(89, demo_releasebuffer),
+ PySlot_FUNC(90, demo_ass_subscript),
+ PySlot_FUNC(91, demo_length),
+ PySlot_SIZE(Py_tp_extra_basicsize, sizeof(int)),
+ PySlot_STATIC_DATA(Py_tp_members, ((PyMemberDef[]) {
+ {"buf_counter", Py_T_INT, 0, Py_READONLY | Py_RELATIVE_OFFSET},
+ {NULL},
+ })),
+ ENDCASE()
+ CASE("nonstatic_tp_members")
+ PySlot_SIZE(Py_tp_extra_basicsize, sizeof(int)),
+ PySlot_DATA(Py_tp_members, ((PyMemberDef[]) {
+ {"buf_counter", Py_T_INT, 0, Py_READONLY | Py_RELATIVE_OFFSET},
+ {NULL},
+ })),
+ ENDCASE()
+ CASE("intptr_flags_macro")
+ PySlot_PTR(Py_tp_flags, (void*)(intptr_t)Py_TPFLAGS_IMMUTABLETYPE),
+ ENDCASE()
+ CASE("intptr_flags_struct")
+ {.sl_id=Py_tp_flags,
+ .sl_flags=PySlot_INTPTR,
+ .sl_ptr=(void*)(intptr_t)Py_TPFLAGS_IMMUTABLETYPE,
+ },
+ ENDCASE()
+ CASE("intptr_static")
+ PySlot_SIZE(Py_tp_extra_basicsize, sizeof(int)),
+ PySlot_PTR_STATIC(Py_tp_members, ((PyMemberDef[]) {
+ {"attribute", Py_T_INT, 0, Py_READONLY | Py_RELATIVE_OFFSET},
+ {NULL},
+ })),
+ ENDCASE()
+ CASE("nested")
+ PySlot_FUNC(Py_nb_add, binop_123),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_FUNC(Py_nb_subtract, binop_234),
+ PySlot_END,
+ })),
+ ENDCASE()
+ CASE("nested_max")
+ PySlot_FUNC(Py_nb_add, binop_123),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_FUNC(Py_nb_subtract, binop_234),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_FUNC(Py_nb_multiply, binop_345),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_FUNC(Py_nb_true_divide, binop_456),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_FUNC(Py_nb_remainder, binop_567),
+ PySlot_END
+ })),
+ PySlot_END,
+ })),
+ PySlot_END,
+ })),
+ PySlot_END,
+ })),
+ ENDCASE()
+ CASE("nested_over_limit")
+ PySlot_FUNC(Py_nb_add, binop_123),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_FUNC(Py_nb_subtract, binop_234),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_FUNC(Py_nb_multiply, binop_345),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_FUNC(Py_nb_true_divide, binop_456),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_FUNC(Py_nb_remainder, binop_567),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_FUNC(Py_nb_xor, binop_678),
+ PySlot_END
+ })),
+ PySlot_END
+ })),
+ PySlot_END,
+ })),
+ PySlot_END,
+ })),
+ PySlot_END,
+ })),
+ ENDCASE()
+ CASE("nested_old")
+ PySlot_FUNC(Py_nb_add, binop_123),
+ PySlot_DATA(Py_tp_slots, ((PyType_Slot[]) {
+ {Py_nb_subtract, binop_234},
+ {0},
+ })),
+ ENDCASE()
+ CASE("nested_old_max")
+ PySlot_FUNC(Py_nb_add, binop_123),
+ PySlot_DATA(Py_tp_slots, ((PyType_Slot[]) {
+ {Py_nb_subtract, binop_234},
+ {Py_tp_slots, ((PyType_Slot[]) {
+ {Py_nb_multiply, binop_345},
+ {Py_tp_slots, ((PyType_Slot[]) {
+ {Py_nb_true_divide, binop_456},
+ {Py_tp_slots, ((PyType_Slot[]) {
+ {Py_nb_remainder, binop_567},
+ {0},
+ })},
+ {0},
+ })},
+ {0},
+ })},
+ {0},
+ })),
+ ENDCASE()
+ CASE("nested_old_over_limit")
+ PySlot_FUNC(Py_nb_add, binop_123),
+ PySlot_DATA(Py_tp_slots, ((PyType_Slot[]) {
+ {Py_nb_subtract, binop_234},
+ {Py_tp_slots, ((PyType_Slot[]) {
+ {Py_nb_multiply, binop_345},
+ {Py_tp_slots, ((PyType_Slot[]) {
+ {Py_nb_true_divide, binop_456},
+ {Py_tp_slots, ((PyType_Slot[]) {
+ {Py_nb_remainder, binop_567},
+ {Py_tp_slots, ((PyType_Slot[]) {
+ {Py_nb_xor, binop_678},
+ {0},
+ })},
+ {0},
+ })},
+ {0},
+ })},
+ {0},
+ })},
+ {0},
+ })),
+ ENDCASE()
+ CASE("nested_pingpong")
+ PySlot_FUNC(Py_nb_add, binop_123),
+ PySlot_DATA(Py_tp_slots, ((PyType_Slot[]) {
+ {Py_nb_subtract, binop_234},
+ {Py_slot_subslots, ((PySlot[]) {
+ PySlot_FUNC(Py_nb_multiply, binop_345),
+ PySlot_DATA(Py_tp_slots, ((PyType_Slot[]) {
+ {Py_nb_true_divide, binop_456},
+ {Py_slot_subslots, ((PySlot[]) {
+ PySlot_FUNC(Py_nb_remainder, binop_567),
+ PySlot_END
+ })},
+ {0},
+ })),
+ PySlot_END,
+ })},
+ {0},
+ })),
+ ENDCASE()
+ CASE("repeat_add")
+ PySlot_FUNC(Py_nb_add, binop_123),
+ PySlot_FUNC(Py_nb_add, binop_456),
+ ENDCASE()
+ CASE("repeat_module")
+ PySlot_DATA(Py_tp_module, Py_True),
+ PySlot_DATA(Py_tp_module, Py_False),
+ ENDCASE()
+
+#undef CASE
+#undef ENDCASE
+ PyErr_Format(PyExc_SystemError, "bad case: %s", case_name);
+ return NULL;
+}
+
+static PyObject *
+type_from_null_slot(PyObject* module, PyObject *args)
+{
+ long slot_number;
+ if (!PyArg_ParseTuple(args, "l", &slot_number)) {
+ return NULL;
+ }
+ return PyType_FromSlots((PySlot[]) {
+ PySlot_DATA(Py_tp_name, "_testlimitedcapi.MyType"),
+ PySlot_DATA(Py_tp_module, module),
+ PySlot_PTR_STATIC((uint16_t)slot_number, NULL),
+ PySlot_END
+ });
+}
+
+static PyObject *
+type_from_null_spec_slot(PyObject* Py_UNUSED(module), PyObject *args)
+{
+ long slot_number;
+ if (!PyArg_ParseTuple(args, "l", &slot_number)) {
+ return NULL;
+ }
+ return PyType_FromSpec(&(PyType_Spec) {
+ .name = "_testlimitedcapi.MyType",
+ .slots = (PyType_Slot[]) {
+ {slot_number, NULL},
+ {0},
+ },
+ });
+}
+
+static PyObject *
+demo_create(PyObject *spec, PyModuleDef *def)
+{
+ assert(def == NULL);
+ return Py_NewRef(spec);
+}
+
+static int
+demo_exec(PyObject *mod)
+{
+ return PyModule_AddStringConstant(mod, "exec_done", "yes");
+}
+
+static PyMethodDef *TestMethods;
+
+static PyObject *
+module_from_slots(PyObject* Py_UNUSED(module), PyObject *args)
+{
+ PyObject *spec;
+ char *case_name;
+ if (!PyArg_ParseTuple(args, "sO", &case_name, &spec)) {
+ return NULL;
+ }
+ PyObject *mod = NULL;
+#define CASE(NAME) \
+ if (strcmp(case_name, NAME) == 0) { \
+ mod = PyModule_FromSlotsAndSpec((PySlot[]) { \
+ PySlot_DATA(Py_mod_abi, &abi_info), \
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED), \
+ /////////////////////////////////////////////////////////////////////////
+#define ENDCASE() \
+ PySlot_END \
+ }, spec); \
+ } \
+ /////////////////////////////////////////////////////////////////////////
+
+ CASE("basic")
+ ENDCASE()
+ CASE("foreign_slot")
+ PySlot_DATA(Py_tp_name, "this is not a type"),
+ ENDCASE()
+ CASE("state_size")
+ PySlot_SIZE(Py_mod_state_size, 42),
+ ENDCASE()
+ CASE("multi_interp")
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ ENDCASE()
+ CASE("exec")
+ PySlot_FUNC(Py_mod_exec, demo_exec),
+ ENDCASE()
+ CASE("optional_end")
+ {.sl_flags=PySlot_OPTIONAL},
+ ENDCASE()
+ CASE("invalid")
+ {.sl_id=Py_slot_invalid},
+ ENDCASE()
+ CASE("invalid_fbad")
+ {.sl_id=0xfbad},
+ ENDCASE()
+ CASE("optional_invalid")
+ {.sl_id=Py_slot_invalid, .sl_flags=PySlot_OPTIONAL},
+ PySlot_SIZE(Py_mod_exec, demo_exec),
+ ENDCASE()
+ CASE("optional_invalid_fbad")
+ {.sl_id=0xfbad, .sl_flags=PySlot_OPTIONAL},
+ PySlot_SIZE(Py_mod_exec, demo_exec),
+ ENDCASE()
+ CASE("old_slot_numbers")
+ // 1: see old_slot_number_create case
+ PySlot_FUNC(2, demo_exec),
+ PySlot_DATA(3, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ // 4: see module_from_gil_slot function
+ ENDCASE()
+ CASE("new_slot_numbers")
+ // 84: see new_slot_number_create case
+ PySlot_FUNC(85, demo_exec),
+ PySlot_FUNC(86, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ // 87: see module_from_gil_slot function
+ ENDCASE()
+ CASE("old_slot_number_create")
+ PySlot_FUNC(1, demo_create),
+ ENDCASE()
+ CASE("new_slot_number_create")
+ PySlot_FUNC(84, demo_create),
+ ENDCASE()
+ CASE("nonstatic_mod_methods")
+ PySlot_DATA(Py_mod_methods, TestMethods),
+ ENDCASE()
+ CASE("intptr_methods")
+ PySlot_PTR_STATIC(Py_mod_methods, TestMethods),
+ ENDCASE()
+ CASE("nested")
+ PySlot_FUNC(Py_mod_exec, demo_exec),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_DATA(Py_mod_doc, "doc"),
+ PySlot_END,
+ })),
+ ENDCASE()
+ CASE("nested_max")
+ PySlot_FUNC(Py_mod_exec, demo_exec),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_SIZE(Py_mod_state_size, 53),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_DATA(Py_mod_doc, "doc"),
+ PySlot_END
+ })),
+ PySlot_END,
+ })),
+ PySlot_END,
+ })),
+ PySlot_END,
+ })),
+ ENDCASE()
+ CASE("nested_over_limit")
+ PySlot_FUNC(Py_mod_exec, demo_exec),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_SIZE(Py_mod_state_size, 53),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_DATA(Py_mod_doc, "doc"),
+ PySlot_DATA(Py_slot_subslots, ((PySlot[]) {
+ PySlot_END
+ })),
+ PySlot_END
+ })),
+ PySlot_END,
+ })),
+ PySlot_END,
+ })),
+ PySlot_END,
+ })),
+ ENDCASE()
+ CASE("nested_old")
+ PySlot_FUNC(Py_mod_exec, demo_exec),
+ PySlot_DATA(Py_mod_slots, ((PyModuleDef_Slot[]) {
+ {Py_mod_doc, "doc"},
+ {0},
+ })),
+ ENDCASE()
+ CASE("nested_old_max")
+ PySlot_FUNC(Py_mod_exec, demo_exec),
+ PySlot_DATA(Py_mod_slots, ((PyModuleDef_Slot[]) {
+ {Py_mod_slots, ((PyModuleDef_Slot[]) {
+ {Py_mod_state_size, (void*)(intptr_t)53},
+ {Py_mod_slots, ((PyModuleDef_Slot[]) {
+ {Py_mod_slots, ((PyModuleDef_Slot[]) {
+ {Py_mod_doc, "doc"},
+ {0},
+ })},
+ {0},
+ })},
+ {0},
+ })},
+ {0},
+ })),
+ ENDCASE()
+ CASE("nested_old_over_limit")
+ PySlot_FUNC(Py_mod_exec, demo_exec),
+ PySlot_DATA(Py_mod_slots, ((PyModuleDef_Slot[]) {
+ {Py_mod_slots, ((PyModuleDef_Slot[]) {
+ {Py_mod_state_size, (void*)(intptr_t)53},
+ {Py_mod_slots, ((PyModuleDef_Slot[]) {
+ {Py_mod_slots, ((PyModuleDef_Slot[]) {
+ {Py_mod_slots, ((PyModuleDef_Slot[]) {
+ {Py_mod_doc, "doc"},
+ {0},
+ })},
+ {0},
+ })},
+ {0},
+ })},
+ {0},
+ })},
+ {0},
+ })),
+ ENDCASE()
+ CASE("nested_pingpong")
+ PySlot_FUNC(Py_mod_exec, demo_exec),
+ PySlot_DATA(Py_mod_slots, ((PyModuleDef_Slot[]) {
+ {Py_slot_subslots, ((PySlot[]) {
+ PySlot_DATA(Py_mod_slots, ((PyModuleDef_Slot[]) {
+ {Py_mod_state_size, (void*)(intptr_t)53},
+ {Py_slot_subslots, ((PySlot[]) {
+ PySlot_DATA(Py_mod_doc, "doc"),
+ PySlot_END
+ })},
+ {0},
+ })),
+ PySlot_END,
+ })},
+ {0},
+ })),
+ ENDCASE()
+ CASE("repeat_create")
+ PySlot_DATA(Py_mod_create, demo_create),
+ PySlot_DATA(Py_mod_create, demo_create),
+ PySlot_DATA(Py_mod_create, demo_create),
+ ENDCASE()
+ CASE("repeat_gil")
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ ENDCASE()
+ CASE("repeat_exec")
+ PySlot_FUNC(Py_mod_exec, demo_exec),
+ PySlot_FUNC(Py_mod_exec, demo_exec),
+ ENDCASE()
+
+#undef CASE
+#undef ENDCASE
+ if (!mod) {
+ if (!PyErr_Occurred()) {
+ PyErr_Format(PyExc_SystemError, "bad case: %s", case_name);
+ return NULL;
+ }
+ return NULL;
+ }
+ if (PyModule_Check(mod)) {
+ Py_ssize_t size;
+ if (PyModule_GetStateSize(mod, &size) < 0) {
+ Py_DECREF(mod);
+ return NULL;
+ }
+ if (PyModule_AddIntConstant(mod, "state_size", (long)size) < 0) {
+ Py_DECREF(mod);
+ return NULL;
+ }
+ if (PyModule_Exec(mod) < 0) {
+ return NULL;
+ }
+ }
+ return mod;
+}
+
+static PyObject *
+module_from_gil_slot(PyObject* Py_UNUSED(module), PyObject *args)
+{
+ long slot_number;
+ PyObject *spec;
+ if (!PyArg_ParseTuple(args, "lO", &slot_number, &spec)) {
+ return NULL;
+ }
+ return PyModule_FromSlotsAndSpec((PySlot[]) {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_PTR_STATIC((uint16_t)slot_number, Py_MOD_GIL_NOT_USED),
+ PySlot_END
+ }, spec);
+}
+
+static PyObject *
+module_from_null_slot(PyObject* Py_UNUSED(module), PyObject *args)
+{
+ long slot_number;
+ PyObject *spec;
+ if (!PyArg_ParseTuple(args, "lO", &slot_number, &spec)) {
+ return NULL;
+ }
+ uint16_t maybe_gil_slot = Py_mod_gil;
+ if ((slot_number == 4) || (slot_number == 87)) {
+ // Do not repeat the GIL slot
+ maybe_gil_slot = Py_slot_invalid;
+ }
+ return PyModule_FromSlotsAndSpec((PySlot[]) {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_DATA(Py_mod_name, "mymod"),
+ PySlot_PTR_STATIC((uint16_t)slot_number, NULL),
+ {
+ .sl_id=maybe_gil_slot,
+ .sl_flags=PySlot_OPTIONAL,
+ .sl_ptr=Py_MOD_GIL_NOT_USED,
+ },
+ PySlot_END
+ }, spec);
+}
+
+static PyMethodDef _TestMethods[] = {
+ {"type_from_slots", type_from_slots, METH_VARARGS},
+ {"module_from_gil_slot", module_from_gil_slot, METH_VARARGS},
+ {"type_from_null_slot", type_from_null_slot, METH_VARARGS},
+ {"type_from_null_spec_slot", type_from_null_spec_slot, METH_VARARGS},
+ {"module_from_slots", module_from_slots, METH_VARARGS},
+ {"module_from_null_slot", module_from_null_slot, METH_VARARGS},
+ {NULL},
+};
+static PyMethodDef *TestMethods = _TestMethods;
+
+int
+_PyTestLimitedCAPI_Init_Slots(PyObject *m)
+{
+ if (PyModule_AddFunctions(m, TestMethods) < 0) {
+ return -1;
+ }
+
+ return 0;
+}
diff --git a/Modules/_testmultiphase.c b/Modules/_testmultiphase.c
--- a/Modules/_testmultiphase.c
+++ b/Modules/_testmultiphase.c
@@ -603,7 +603,7 @@ PyInit__testmultiphase_null_slots(void)
/**** Problematic modules ****/
static PyModuleDef_Slot slots_bad_large[] = {
- {_Py_mod_LAST_SLOT + 1, NULL},
+ {Py_slot_invalid, NULL},
{0, NULL},
};
@@ -1051,25 +1051,25 @@ PyABIInfo_VAR(abi_info);
PyMODEXPORT_FUNC
PyModExport__test_from_modexport(void)
{
- static PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_name, "_test_from_modexport"},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ static PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_DATA(Py_mod_name, "_test_from_modexport"),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
return slots;
}
PyMODEXPORT_FUNC
PyModExport__test_from_modexport_gil_used(void)
{
- static PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_name, "_test_from_modexport_gil_used"},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_USED},
- {0},
+ static PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_DATA(Py_mod_name, "_test_from_modexport_gil_used"),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_USED),
+ PySlot_END,
};
return slots;
}
@@ -1115,33 +1115,33 @@ modexport_create_string(PyObject *spec, PyModuleDef *def)
PyMODEXPORT_FUNC
PyModExport__test_from_modexport_create_nonmodule(void)
{
- static PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_name, "_test_from_modexport_create_nonmodule"},
- {Py_mod_create, modexport_create_string},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ static PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_DATA(Py_mod_name, "_test_from_modexport_create_nonmodule"),
+ PySlot_FUNC(Py_mod_create, modexport_create_string),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
return slots;
}
PyMODEXPORT_FUNC
PyModExport__test_from_modexport_create_nonmodule_gil_used(void)
{
- static PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_name, "_test_from_modexport_create_nonmodule"},
- {Py_mod_create, modexport_create_string},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_USED},
- {0},
+ static PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_DATA(Py_mod_name, "_test_from_modexport_create_nonmodule"),
+ PySlot_FUNC(Py_mod_create, modexport_create_string),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_USED),
+ PySlot_END,
};
return slots;
}
-static PyModuleDef_Slot modexport_empty_slots[] = {
- {0},
+static PySlot modexport_empty_slots[] = {
+ PySlot_END,
};
PyMODEXPORT_FUNC
@@ -1151,9 +1151,9 @@ PyModExport__test_from_modexport_empty_slots(void)
}
-static PyModuleDef_Slot modexport_minimal_slots[] = {
- {Py_mod_abi, &abi_info},
- {0},
+static PySlot modexport_minimal_slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_END,
};
PyMODEXPORT_FUNC
@@ -1234,18 +1234,18 @@ PyModExport__test_from_modexport_smoke(void)
{"get_modexport_minimal_slots", modexport_get_minimal_slots, METH_NOARGS},
{0},
};
- static PyModuleDef_Slot slots[] = {
- {Py_mod_abi, &abi_info},
- {Py_mod_name, "_test_from_modexport_smoke"},
- {Py_mod_doc, "the expected docstring"},
- {Py_mod_exec, modexport_smoke_exec},
- {Py_mod_state_size, (void*)sizeof(int)},
- {Py_mod_methods, methods},
- {Py_mod_state_free, modexport_smoke_free},
- {Py_mod_token, (void*)&modexport_smoke_test_token},
- {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
- {Py_mod_gil, Py_MOD_GIL_NOT_USED},
- {0},
+ static PySlot slots[] = {
+ PySlot_DATA(Py_mod_abi, &abi_info),
+ PySlot_DATA(Py_mod_name, "_test_from_modexport_smoke"),
+ PySlot_DATA(Py_mod_doc, "the expected docstring"),
+ PySlot_FUNC(Py_mod_exec, modexport_smoke_exec),
+ PySlot_SIZE(Py_mod_state_size, (void*)sizeof(int)),
+ PySlot_STATIC_DATA(Py_mod_methods, methods),
+ PySlot_FUNC(Py_mod_state_free, modexport_smoke_free),
+ PySlot_DATA(Py_mod_token, (void*)&modexport_smoke_test_token),
+ PySlot_DATA(Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED),
+ PySlot_DATA(Py_mod_gil, Py_MOD_GIL_NOT_USED),
+ PySlot_END,
};
return slots;
}
diff --git a/PCbuild/_testlimitedcapi.vcxproj b/PCbuild/_testlimitedcapi.vcxproj
--- a/PCbuild/_testlimitedcapi.vcxproj
+++ b/PCbuild/_testlimitedcapi.vcxproj
@@ -109,6 +109,7 @@
+
diff --git a/PCbuild/_testlimitedcapi.vcxproj.filters b/PCbuild/_testlimitedcapi.vcxproj.filters
--- a/PCbuild/_testlimitedcapi.vcxproj.filters
+++ b/PCbuild/_testlimitedcapi.vcxproj.filters
@@ -24,6 +24,7 @@
+