Add templatelib module & clean-up types/objects etc.

lysnikolaou · lysnikolaou · commit 499d70caaa9e · 2024-10-21T00:23:17.000+02:00
diff --git a/Include/internal/pycore_interpolation.h b/Include/internal/pycore_interpolation.h
@@ -9,21 +9,12 @@ extern "C" {
 #  error "this header requires Py_BUILD_CORE define"
 #endif
 
-typedef struct {
-    PyObject_HEAD
-    PyObject *value;
-    PyObject *expr;
-    PyObject *conv;
-    PyObject *format_spec;
-} PyInterpolationObject;
+#include "pycore_stackref.h"    // _PyStackRef
 
-extern PyTypeObject PyInterpolation_Type;
+extern PyTypeObject _PyInterpolation_Type;
 
 PyAPI_FUNC(PyObject *) _PyInterpolation_FromStackRefSteal(_PyStackRef *values);
 
-extern PyStatus _PyInterpolation_InitTypes(PyInterpreterState *);
-extern void _PyInterpolation_FiniTypes(PyInterpreterState *);
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/Include/internal/pycore_template.h b/Include/internal/pycore_template.h
@@ -9,18 +9,10 @@ extern "C" {
 #  error "this header requires Py_BUILD_CORE define"
 #endif
 
-typedef struct {
-    PyObject_HEAD
-    PyObject *args;
-} PyTemplateObject;
-
-extern PyTypeObject PyTemplate_Type;
+extern PyTypeObject _PyTemplate_Type;
 
 PyAPI_FUNC(PyObject *) _PyTemplate_Create(PyObject **values, Py_ssize_t n);
 
-extern PyStatus _PyTemplate_InitTypes(PyInterpreterState *);
-extern void _PyTemplate_FiniTypes(PyInterpreterState *);
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/Lib/templatelib.py b/Lib/templatelib.py
@@ -0,0 +1,3 @@
+from _templatelib import Template, Interpolation
+
+__all__ = ['Template', 'Interpolation']
diff --git a/Modules/Setup.bootstrap.in b/Modules/Setup.bootstrap.in
@@ -25,6 +25,7 @@ _thread _threadmodule.c
 time timemodule.c
 _typing _typingmodule.c
 _weakref _weakref.c
+_templatelib _templatelibmodule.c
 
 # commonly used core modules
 _abc _abc.c
diff --git a/Modules/_templatelibmodule.c b/Modules/_templatelibmodule.c
@@ -0,0 +1,49 @@
+/* interpreter-internal types for templatelib */
+
+#ifndef Py_BUILD_CORE
+#define Py_BUILD_CORE
+#endif
+
+#include "Python.h"
+#include "pycore_template.h"
+#include "pycore_interpolation.h"
+
+static int
+_templatelib_exec(PyObject *m)
+{
+    if (PyModule_AddObjectRef(m, "Template", (PyObject *)&_PyTemplate_Type) < 0) {
+        return -1;
+    }
+    if (PyModule_AddObjectRef(m, "Interpolation", (PyObject *)&_PyInterpolation_Type) < 0) {
+        return -1;
+    }
+    return 0;
+}
+
+PyDoc_STRVAR(_templatelib_doc,
+"Interpreter-internal types for t-string templates.\n");
+
+static struct PyModuleDef_Slot _templatelib_slots[] = {
+    {Py_mod_exec, _templatelib_exec},
+    {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+    {0, NULL}
+};
+
+static struct PyModuleDef _templatemodule = {
+    PyModuleDef_HEAD_INIT,
+    "_templatelib",
+    _templatelib_doc,
+    0,
+    NULL,
+    _templatelib_slots,
+    NULL,
+    NULL,
+    NULL
+};
+
+PyMODINIT_FUNC
+PyInit__templatelib(void)
+{
+    return PyModuleDef_Init(&_templatemodule);
+}
diff --git a/Objects/interpolationobject.c b/Objects/interpolationobject.c
@@ -11,10 +11,18 @@
 
 #include "pycore_interpolation.h"
 
-static PyInterpolationObject *
+typedef struct {
+    PyObject_HEAD
+    PyObject *value;
+    PyObject *expr;
+    PyObject *conv;
+    PyObject *format_spec;
+} interpolationobject;
+
+static interpolationobject *
 interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
-    PyInterpolationObject *self = (PyInterpolationObject *) type->tp_alloc(type, 0);
+    interpolationobject *self = (interpolationobject *) type->tp_alloc(type, 0);
     if (!self) {
         return NULL;
     }
@@ -40,7 +48,7 @@ interpolation_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 }
 
 static void
-interpolation_dealloc(PyInterpolationObject *self)
+interpolation_dealloc(interpolationobject *self)
 {
     Py_CLEAR(self->value);
     Py_CLEAR(self->expr);
@@ -50,7 +58,7 @@ interpolation_dealloc(PyInterpolationObject *self)
 }
 
 static PyObject *
-interpolation_repr(PyInterpolationObject *self)
+interpolation_repr(interpolationobject *self)
 {
     return PyUnicode_FromFormat("%s(%R, %R, %R, %R)",
                                 _PyType_Name(Py_TYPE(self)),
@@ -59,18 +67,18 @@ interpolation_repr(PyInterpolationObject *self)
 }
 
 static PyMemberDef interpolation_members[] = {
-    {"value", Py_T_OBJECT_EX, offsetof(PyInterpolationObject, value), Py_READONLY, "Value"},
-    {"expr", Py_T_OBJECT_EX, offsetof(PyInterpolationObject, expr), Py_READONLY, "Expr"},
-    {"conv", Py_T_OBJECT_EX, offsetof(PyInterpolationObject, conv), Py_READONLY, "Conversion"},
-    {"format_spec", Py_T_OBJECT_EX, offsetof(PyInterpolationObject, format_spec), Py_READONLY, "Format specifier"},
+    {"value", Py_T_OBJECT_EX, offsetof(interpolationobject, value), Py_READONLY, "Value"},
+    {"expr", Py_T_OBJECT_EX, offsetof(interpolationobject, expr), Py_READONLY, "Expr"},
+    {"conv", Py_T_OBJECT_EX, offsetof(interpolationobject, conv), Py_READONLY, "Conversion"},
+    {"format_spec", Py_T_OBJECT_EX, offsetof(interpolationobject, format_spec), Py_READONLY, "Format specifier"},
     {NULL}
 };
 
-PyTypeObject PyInterpolation_Type = {
+PyTypeObject _PyInterpolation_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
-    .tp_name = "Interpolation",
+    .tp_name = "templatelib.Interpolation",
     .tp_doc = PyDoc_STR("Interpolation object"),
-    .tp_basicsize = sizeof(PyInterpolationObject),
+    .tp_basicsize = sizeof(interpolationobject),
     .tp_itemsize = 0,
     .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | _Py_TPFLAGS_MATCH_SELF,
     .tp_new = (newfunc) interpolation_new,
@@ -79,21 +87,6 @@ PyTypeObject PyInterpolation_Type = {
     .tp_members = interpolation_members,
 };
 
-PyStatus
-_PyInterpolation_InitTypes(PyInterpreterState *interp)
-{
-    if (_PyStaticType_InitBuiltin(interp, &PyInterpolation_Type) < 0) {
-        return _PyStatus_ERR("Can't initialize builtin type");
-    }
-    return _PyStatus_OK();
-}
-
-void
-_PyInterpolation_FiniTypes(PyInterpreterState *interp)
-{
-    _PyStaticType_FiniBuiltin(interp, &PyInterpolation_Type);
-}
-
 PyObject *
 _PyInterpolation_FromStackRefSteal(_PyStackRef *values)
 {
@@ -111,7 +104,7 @@ _PyInterpolation_FromStackRefSteal(_PyStackRef *values)
     PyObject *format_spec = PyStackRef_AsPyObjectSteal(values[3]);
     PyTuple_SET_ITEM(args, 3, format_spec ? format_spec : &_Py_STR(empty));
 
-    PyObject *interpolation = PyObject_CallObject((PyObject *) &PyInterpolation_Type, args);
+    PyObject *interpolation = PyObject_CallObject((PyObject *) &_PyInterpolation_Type, args);
     if (!interpolation) {
         Py_DECREF(args);
         goto error;
diff --git a/Objects/object.c b/Objects/object.c
@@ -13,6 +13,7 @@
 #include "pycore_freelist.h"      // _PyObject_ClearFreeLists()
 #include "pycore_initconfig.h"    // _PyStatus_EXCEPTION()
 #include "pycore_instruction_sequence.h" // _PyInstructionSequence_Type
+#include "pycore_interpolation.h" // _PyInterpolation_Type
 #include "pycore_hashtable.h"     // _Py_hashtable_new()
 #include "pycore_memoryobject.h"  // _PyManagedBuffer_Type
 #include "pycore_namespace.h"     // _PyNamespace_Type
@@ -24,6 +25,7 @@
 #include "pycore_pymem.h"         // _PyMem_IsPtrFreed()
 #include "pycore_pystate.h"       // _PyThreadState_GET()
 #include "pycore_symtable.h"      // PySTEntry_Type
+#include "pycore_template.h"      // _PyTemplate_Type
 #include "pycore_typeobject.h"    // _PyBufferWrapper_Type
 #include "pycore_typevarobject.h" // _PyTypeAlias_Type, _Py_initialize_generic
 #include "pycore_unionobject.h"   // _PyUnion_Type
@@ -2345,6 +2347,8 @@ static PyTypeObject* static_types[] = {
     &_PyWeakref_RefType,
     &_PyTypeAlias_Type,
     &_PyNoDefault_Type,
+    &_PyInterpolation_Type,
+    &_PyTemplate_Type,
 
     // subclasses: _PyTypes_FiniTypes() deallocates them before their base
     // class
diff --git a/Objects/templateobject.c b/Objects/templateobject.c
@@ -9,10 +9,15 @@
 
 #include "pycore_template.h"
 
-static PyTemplateObject *
+typedef struct {
+    PyObject_HEAD
+    PyObject *args;
+} templateobject;
+
+static templateobject *
 template_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
-    PyTemplateObject *self = (PyTemplateObject *) type->tp_alloc(type, 0);
+    templateobject *self = (templateobject *) type->tp_alloc(type, 0);
     if (!self) {
         return NULL;
     }
@@ -31,30 +36,30 @@ template_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 }
 
 static void
-template_dealloc(PyTemplateObject *self)
+template_dealloc(templateobject *self)
 {
     Py_CLEAR(self->args);
     Py_TYPE(self)->tp_free(self);
 }
 
 static PyObject *
-template_repr(PyTemplateObject *self)
+template_repr(templateobject *self)
 {
     return PyUnicode_FromFormat("%s(%R)",
                                 _PyType_Name(Py_TYPE(self)),
                                 self->args);
 }
 
 static PyMemberDef template_members[] = {
-    {"args", Py_T_OBJECT_EX, offsetof(PyTemplateObject, args), Py_READONLY, "Args"},
+    {"args", Py_T_OBJECT_EX, offsetof(templateobject, args), Py_READONLY, "Args"},
     {NULL}
 };
 
-PyTypeObject PyTemplate_Type = {
+PyTypeObject _PyTemplate_Type = {
     PyVarObject_HEAD_INIT(NULL, 0)
-    .tp_name = "Template",
+    .tp_name = "templatelib.Template",
     .tp_doc = PyDoc_STR("Template object"),
-    .tp_basicsize = sizeof(PyTemplateObject),
+    .tp_basicsize = sizeof(templateobject),
     .tp_itemsize = 0,
     .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | _Py_TPFLAGS_MATCH_SELF,
     .tp_new = (newfunc) template_new,
@@ -63,21 +68,6 @@ PyTypeObject PyTemplate_Type = {
     .tp_members = template_members,
 };
 
-PyStatus
-_PyTemplate_InitTypes(PyInterpreterState *interp)
-{
-    if (_PyStaticType_InitBuiltin(interp, &PyTemplate_Type) < 0) {
-        return _PyStatus_ERR("Can't initialize builtin type");
-    }
-    return _PyStatus_OK();
-}
-
-void
-_PyTemplate_FiniTypes(PyInterpreterState *interp)
-{
-    _PyStaticType_FiniBuiltin(interp, &PyTemplate_Type);
-}
-
 PyObject *
 _PyTemplate_Create(PyObject **values, Py_ssize_t oparg)
 {
@@ -90,7 +80,7 @@ _PyTemplate_Create(PyObject **values, Py_ssize_t oparg)
         PyTuple_SET_ITEM(tuple, i, Py_NewRef(values[i]));
     }
 
-    PyObject *template = PyObject_CallOneArg((PyObject *) &PyTemplate_Type, tuple);
+    PyObject *template = PyObject_CallOneArg((PyObject *) &_PyTemplate_Type, tuple);
     Py_DECREF(tuple);
     return template;
 }
diff --git a/Python/pylifecycle.c b/Python/pylifecycle.c
@@ -774,16 +774,6 @@ pycore_init_types(PyInterpreterState *interp)
         return status;
     }
 
-    status = _PyInterpolation_InitTypes(interp);
-    if (_PyStatus_EXCEPTION(status)) {
-        return status;
-    }
-
-    status = _PyTemplate_InitTypes(interp);
-    if (_PyStatus_EXCEPTION(status)) {
-        return status;
-    }
-
     return _PyStatus_OK();
 }
 
@@ -1842,8 +1832,6 @@ finalize_interp_types(PyInterpreterState *interp)
     _PyFloat_FiniType(interp);
     _PyLong_FiniTypes(interp);
     _PyThread_FiniType(interp);
-    _PyInterpolation_FiniTypes(interp);
-    _PyTemplate_FiniTypes(interp);
     // XXX fini collections module static types (_PyStaticType_Dealloc())
     // XXX fini IO module static types (_PyStaticType_Dealloc())
     _PyErr_FiniTypes(interp);

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+from _templatelib import Template, Interpolation`
	`2`	`+`
	`3`	`+__all__ = ['Template', 'Interpolation']`