i dont have a good way to test features on other os's

Author: ZeroIntensity

src/_pointers.pyi

@@ -1,6 +1,11 @@
-from typing import Any, Type
+from typing import Any, Callable, TypeVar
+
+_T = TypeVar("_T")
 
 def add_ref(obj: Any) -> None: ...
 def remove_ref(obj: Any) -> None: ...
-def force_set_attr(typ: Type[Any], key: str, value: Any) -> None: ...
+def force_set_attr(typ: type[Any], key: str, value: Any) -> None: ...
 def set_ref(obj: Any, count: int) -> None: ...
+def handle(
+    func: Callable[..., _T], args: tuple[Any, ...], kwargs: dict[str, Any]
+) -> _T: ...

src/mod.c

@@ -1,6 +1,9 @@
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
+#include <signal.h>
+#include <setjmp.h>
 #define GETOBJ PyObject* obj; if (!PyArg_ParseTuple(args, "O", &obj)) return NULL
+static jmp_buf buf;
 
 static PyObject* add_ref(PyObject* self, PyObject* args) {
     GETOBJ;
@@ -35,13 +38,47 @@ static PyObject* force_set_attr(PyObject* self, PyObject* args) {
     Py_RETURN_NONE;
 }
 
+void handler(int signum) {
+    longjmp(buf, 1);
+}
+
+static PyObject* handle(PyObject* self, PyObject* args) {
+    PyObject* func;
+    PyObject* params;
+    PyObject* kwargs;
+
+    if (!PyArg_ParseTuple(
+            args,
+            "O!O!O!",
+            &PyFunction_Type,
+            &func,
+            &PyTuple_Type,
+            &params,
+            &PyDict_Type,
+            &kwargs
+        )
+    ) return NULL;
+    int val = setjmp(buf);
 
+    if (setjmp(buf)) {
+        PyErr_Format(
+            PyExc_RuntimeError,
+            "segment violation occured during execution of %S",
+            PyObject_GetAttrString(func, "__name__")
+        );
+        return NULL;
+    }
+
+    PyObject* result = PyObject_Call(func, params, kwargs);
+    return result;
+}
 
 static PyMethodDef methods[] = {
     {"add_ref", add_ref, METH_VARARGS, "Increment the reference count on the target object."},
     {"remove_ref", remove_ref, METH_VARARGS, "Decrement the reference count on the target object."},
     {"force_set_attr", force_set_attr, METH_VARARGS, "Force setting an attribute on the target type."},
     {"set_ref", set_ref, METH_VARARGS, "Set the reference count on the target object."},
+    {"handle", handle, METH_VARARGS, "Enable the SIGSEGV handler."},
     {NULL, NULL, 0, NULL}
 };
 
@@ -54,5 +91,10 @@ static struct PyModuleDef module = {
 };
 
 PyMODINIT_FUNC PyInit__pointers(void) {
+    if (signal(SIGSEGV, handler) == SIG_ERR) {
+        PyErr_SetString(PyExc_RuntimeError, "failed to setup SIGSEGV handler");
+        return NULL;
+    }
+
     return PyModule_Create(&module);
 }

src/pointers/object_pointer.py

@@ -1,5 +1,4 @@
 import ctypes
-import struct
 import sys
 from typing import TypeVar, Union
 
@@ -42,23 +41,25 @@ def move(
 
         size_a: int = sys.getsizeof(deref_a)
         size_b: int = sys.getsizeof(deref_b)
+        refcnt = sys.getrefcount(deref_b)
 
         if (self._origin_size < size_a) and (not unsafe):
             raise InvalidSizeError(
                 f"target size may not exceed current size ({size_a} < {size_b})",  # noqa
             )
 
+        if type(deref_a) is not type(deref_b):
+            raise TypeError(
+                "cannot move object of a different type",
+            )
+
         current_address: int = self.ensure()
         bytes_a = (ctypes.c_ubyte * size_a).from_address(data.ensure())
-        (refcnt,) = struct.unpack(
-            "q", ctypes.string_at(current_address, 8)
-        )  # this might be overkill
-
         bytes_b = (ctypes.c_ubyte * size_b).from_address(current_address)
-        set_ref(deref_a, sys.getrefcount(deref_a) - 1 + refcnt)
 
         self.assign(~data)
         ctypes.memmove(bytes_b, bytes_a, len(bytes_a))
+        set_ref(deref_b, refcnt - 1)
 
     @classmethod
     def make_from(cls, obj: Nullable[T]) -> "Pointer[T]":

tests/test_pointer.py

@@ -1,5 +1,8 @@
+import ctypes
+
 from ward import raises, test
 
+from _pointers import handle
 from pointers import NULL, InvalidSizeError, Pointer
 from pointers import _ as m
 from pointers import strlen, to_c_ptr, to_ptr
@@ -86,3 +89,11 @@ def _():
     ptr = m & "test"
     assert type(ptr) is Pointer
     assert m * ptr == "test"
+
+
+@test("segfault handler")
+def _():
+    def segfault():
+        ctypes.string_at(0)
+
+    handle(segfault, (), {})