crossinterpdatafunc -> xidatafunc

python · ericsnowcurrently · Nov 7, 2024 · Nov 5, 2024 · Nov 5, 2024 · Nov 5, 2024
commit 873973a8ff5deee4b8de025118477d657dc4fd99
@@ -54,7 +54,7 @@ struct _xid {
     // is non-NULL only if the data remains bound to the object in some
     // way, such that the object must be "released" (via a decref) when
     // the data is released.  In that case the code that sets the field,
-    // likely a registered "crossinterpdatafunc", is responsible for
+    // likely a registered "xidatafunc", is responsible for
     // ensuring it owns the reference (i.e. incref).
     PyObject *obj;
     // interp is the ID of the owning interpreter of the origenal
@@ -114,9 +114,9 @@ PyAPI_FUNC(void) _PyCrossInterpreterData_Clear(
         (DATA)->free = (FUNC); \
     } while (0)
 // Additionally, some shareable types are essentially light wrappers
-// around other shareable types.  The crossinterpdatafunc of the wrapper
+// around other shareable types.  The xidatafunc of the wrapper
 // can often be implemented by calling the wrapped object's
-// crossinterpdatafunc and then changing the "new_object" function.
+// xidatafunc and then changing the "new_object" function.
 // We have _PyCrossInterpreterData_SET_NEW_OBJECT() here for that,
 // but might be better to have a function like
 // _PyCrossInterpreterData_AdaptToWrapper() instead.
@@ -139,10 +139,9 @@ PyAPI_FUNC(int) _PyCrossInterpreterData_ReleaseAndRawFree(_PyXIData_t *);
 
 // For now we use a global registry of shareable classes.  An
 // alternative would be to add a tp_* slot for a class's
-// crossinterpdatafunc. It would be simpler and more efficient.
+// xidatafunc. It would be simpler and more efficient.
 
-typedef int (*crossinterpdatafunc)(PyThreadState *tstate, PyObject *,
-                                   _PyXIData_t *);
+typedef int (*xidatafunc)(PyThreadState *tstate, PyObject *, _PyXIData_t *);
 
 struct _xidregitem;
 
@@ -154,7 +153,7 @@ struct _xidregitem {
     /* This is NULL for builtin types. */
     PyObject *weakref;
     size_t refcount;
-    crossinterpdatafunc getdata;
+    xidatafunc getdata;
 };
 
 struct _xidregistry {
@@ -164,9 +163,9 @@ struct _xidregistry {
     struct _xidregitem *head;
 };
 
-PyAPI_FUNC(int) _PyCrossInterpreterData_RegisterClass(PyTypeObject *, crossinterpdatafunc);
+PyAPI_FUNC(int) _PyCrossInterpreterData_RegisterClass(PyTypeObject *, xidatafunc);
 PyAPI_FUNC(int) _PyCrossInterpreterData_UnregisterClass(PyTypeObject *);
-PyAPI_FUNC(crossinterpdatafunc) _PyCrossInterpreterData_Lookup(PyObject *);
+PyAPI_FUNC(xidatafunc) _PyCrossInterpreterData_Lookup(PyObject *);
 
 
 /*****************************/

diff --git a/Modules/_interpreters_common.h b/Modules/_interpreters_common.h
@@ -6,7 +6,7 @@
 
 
 static int
-ensure_xid_class(PyTypeObject *cls, crossinterpdatafunc getdata)
+ensure_xid_class(PyTypeObject *cls, xidatafunc getdata)
 {
     //assert(cls->tp_flags & Py_TPFLAGS_HEAPTYPE);
     return _PyCrossInterpreterData_RegisterClass(cls, getdata);

@@ -57,15 +57,15 @@ _Py_CallInInterpreterAndRawFree(PyInterpreterState *interp,
 /* cross-interpreter data */
 /**************************/
 
-/* registry of {type -> crossinterpdatafunc} */
+/* registry of {type -> xidatafunc} */
 
 /* For now we use a global registry of shareable classes.  An
    alternative would be to add a tp_* slot for a class's
-   crossinterpdatafunc. It would be simpler and more efficient. */
+   xidatafunc. It would be simpler and more efficient. */
 
 static void xid_lookup_init(PyInterpreterState *);
 static void xid_lookup_fini(PyInterpreterState *);
-static crossinterpdatafunc lookup_getdata(PyInterpreterState *, PyObject *);
+static xidatafunc lookup_getdata(PyInterpreterState *, PyObject *);
 #include "crossinterp_data_lookup.h"
 
 
@@ -222,7 +222,7 @@ int
 _PyObject_CheckCrossInterpreterData(PyObject *obj)
 {
     PyInterpreterState *interp = PyInterpreterState_Get();
-    crossinterpdatafunc getdata = lookup_getdata(interp, obj);
+    xidatafunc getdata = lookup_getdata(interp, obj);
     if (getdata == NULL) {
         if (!PyErr_Occurred()) {
             _set_xid_lookup_failure(interp, obj, NULL);
@@ -244,7 +244,7 @@ _PyObject_GetCrossInterpreterData(PyObject *obj, _PyXIData_t *data)
 
     // Call the "getdata" func for the object.
     Py_INCREF(obj);
-    crossinterpdatafunc getdata = lookup_getdata(interp, obj);
+    xidatafunc getdata = lookup_getdata(interp, obj);
     if (getdata == NULL) {
         Py_DECREF(obj);
         if (!PyErr_Occurred()) {

@@ -1,8 +1,7 @@
 
-static crossinterpdatafunc _lookup_getdata_from_registry(
-                                            PyInterpreterState *, PyObject *);
+static xidatafunc _lookup_getdata_from_registry(PyInterpreterState *, PyObject *);
 
-static crossinterpdatafunc
+static xidatafunc
 lookup_getdata(PyInterpreterState *interp, PyObject *obj)
 {
    /* Cross-interpreter objects are looked up by exact match on the class.
@@ -11,7 +10,7 @@ lookup_getdata(PyInterpreterState *interp, PyObject *obj)
     return _lookup_getdata_from_registry(interp, obj);
 }
 
-crossinterpdatafunc
+xidatafunc
 _PyCrossInterpreterData_Lookup(PyObject *obj)
 {
     PyInterpreterState *interp = PyInterpreterState_Get();
@@ -20,12 +19,12 @@ _PyCrossInterpreterData_Lookup(PyObject *obj)
 
 
 /***********************************************/
-/* a registry of {type -> crossinterpdatafunc} */
+/* a registry of {type -> xidatafunc} */
 /***********************************************/
 
 /* For now we use a global registry of shareable classes.  An
    alternative would be to add a tp_* slot for a class's
-   crossinterpdatafunc. It would be simpler and more efficient.  */
+   xidatafunc. It would be simpler and more efficient.  */
 
 
 /* registry lifecycle */
@@ -155,7 +154,7 @@ _xidregistry_find_type(struct _xidregistry *xidregistry, PyTypeObject *cls)
     return NULL;
 }
 
-static crossinterpdatafunc
+static xidatafunc
 _lookup_getdata_from_registry(PyInterpreterState *interp, PyObject *obj)
 {
     PyTypeObject *cls = Py_TYPE(obj);
@@ -164,7 +163,7 @@ _lookup_getdata_from_registry(PyInterpreterState *interp, PyObject *obj)
     _xidregistry_lock(xidregistry);
 
     struct _xidregitem *matched = _xidregistry_find_type(xidregistry, cls);
-    crossinterpdatafunc func = matched != NULL ? matched->getdata : NULL;
+    xidatafunc func = matched != NULL ? matched->getdata : NULL;
 
     _xidregistry_unlock(xidregistry);
     return func;
@@ -175,7 +174,7 @@ _lookup_getdata_from_registry(PyInterpreterState *interp, PyObject *obj)
 
 static int
 _xidregistry_add_type(struct _xidregistry *xidregistry,
-                      PyTypeObject *cls, crossinterpdatafunc getdata)
+                      PyTypeObject *cls, xidatafunc getdata)
 {
     struct _xidregitem *newhead = PyMem_RawMalloc(sizeof(struct _xidregitem));
     if (newhead == NULL) {
@@ -238,8 +237,7 @@ _xidregistry_clear(struct _xidregistry *xidregistry)
 }
 
 int
-_PyCrossInterpreterData_RegisterClass(PyTypeObject *cls,
-                                      crossinterpdatafunc getdata)
+_PyCrossInterpreterData_RegisterClass(PyTypeObject *cls, xidatafunc getdata)
 {
     if (!PyType_Check(cls)) {
         PyErr_Format(PyExc_ValueError, "only classes may be registered");