finish sigsegv handling

Author: ZeroIntensity

src/_pointers.pyi

@@ -7,5 +7,7 @@ def remove_ref(obj: 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]
+    func: Callable[..., _T],
+    args: tuple[Any, ...] | None = None,
+    kwargs: dict[str, Any] | None = None,
 ) -> _T: ...

src/mod.c

@@ -2,7 +2,9 @@
 #include <Python.h>
 #include <signal.h>
 #include <setjmp.h>
+#include <stdbool.h>
 #define GETOBJ PyObject* obj; if (!PyArg_ParseTuple(args, "O", &obj)) return NULL
+#define CALL_ATTR(ob, attr) PyObject_Call(PyObject_GetAttrString(ob, attr), PyTuple_New(0), NULL)
 static jmp_buf buf;
 
 static PyObject* add_ref(PyObject* self, PyObject* args) {
@@ -44,32 +46,46 @@ void handler(int signum) {
 
 static PyObject* handle(PyObject* self, PyObject* args) {
     PyObject* func;
-    PyObject* params;
-    PyObject* kwargs;
+    PyObject* params = NULL;
+    PyObject* kwargs = NULL;
+    PyObject* faulthandler = PyImport_ImportModule("faulthandler");
 
     if (!PyArg_ParseTuple(
             args,
-            "O!O!O!",
-            &PyFunction_Type,
+            "O|O!O!",
             &func,
             &PyTuple_Type,
             &params,
             &PyDict_Type,
             &kwargs
         )
     ) return NULL;
+
+    if (!params) params = PyTuple_New(0);
+    if (!kwargs) kwargs = PyDict_New();
+
     int val = setjmp(buf);
 
+    CALL_ATTR(faulthandler, "disable");
+    // faulthandler needs to be shut off in case of a segfault or its message will still print
+
     if (setjmp(buf)) {
+        CALL_ATTR(faulthandler, "enable");
+        PyCodeObject* code = PyFrame_GetCode(PyEval_GetFrame());
+
         PyErr_Format(
             PyExc_RuntimeError,
             "segment violation occured during execution of %S",
-            PyObject_GetAttrString(func, "__name__")
+            code->co_name
         );
         return NULL;
     }
 
     PyObject* result = PyObject_Call(func, params, kwargs);
+
+    if (!result) return NULL;
+
+    CALL_ATTR(faulthandler, "enable");
     return result;
 }
 

src/pointers/__init__.py

@@ -27,4 +27,4 @@
 from .std_structs import DivT, Lconv, LDivT, Tm
 from .structure import Struct, StructPointer
 
-__version__ = "2.2.0-a3"
+__version__ = "2.2.0-a4"

src/pointers/base_pointers.py

@@ -10,7 +10,9 @@
     Any, Generic, Iterator, Optional, Tuple, Type, TypeVar, Union
 )
 
-from _pointers import add_ref, remove_ref
+from typing_extensions import final
+
+from _pointers import add_ref, handle, remove_ref
 
 from ._utils import deref, force_set_attr, move_to_mem
 from .constants import NULL, Nullable
@@ -54,19 +56,22 @@ def __repr__(self) -> str:
     def __rich__(self):
         ...
 
+    @final
     def __str__(self) -> str:
         return hex(self.address or 0)
 
     @abstractmethod
     def _cleanup(self) -> None:
         ...
 
+    @final
     def __eq__(self, data: object) -> bool:
         if not isinstance(data, BasePointer):
             return False
 
         return data.address == self.address
 
+    @final
     def ensure(self) -> int:
         """Ensure that the pointer is not null.
 
@@ -91,20 +96,23 @@ def ensure(self) -> int:
 
 class Movable(ABC, Generic[T, A]):
     @abstractmethod
-    def move(
+    def _move(
         self,
         data: Union[A, T],
         *,
         unsafe: bool = False,
     ) -> None:
-        """Move data to the target address.
-
-        Args:
-            data: Pointer or object to move into the current data.
-            unsafe: Should buffer overflows be allowed.
-        """
         ...
 
+    @final
+    def move(
+        self,
+        data: Union[A, T],
+        *,
+        unsafe: bool = False,
+    ) -> None:
+        handle(self._move, (data,), {"unsafe": unsafe})
+
     def __ilshift__(self, data: Union[A, T]):
         self.move(data)
         return self
@@ -118,13 +126,18 @@ class Dereferencable(ABC, Generic[T]):
     """Abstract class for an object that may be dereferenced."""
 
     @abstractmethod
+    def _dereference(self) -> T:
+        ...
+
+    @final
     def dereference(self) -> T:
         """Dereference the pointer.
 
         Returns:
             Value at the pointers address."""
-        ...
+        return handle(self._dereference)
 
+    @final
     def __invert__(self) -> T:
         """Dereference the pointer."""
         return self.dereference()
@@ -163,19 +176,10 @@ def __repr__(self) -> str:
     def __rich__(self):
         ...
 
-    def __str__(self) -> str:
-        return hex(self.address or 0)
-
     @abstractmethod
     def _cleanup(self) -> None:
         ...
 
-    def __eq__(self, data: object) -> bool:
-        if not isinstance(data, BasePointer):
-            return False
-
-        return data.address == self.address
-
 
 class Typed(ABC, Generic[T]):
     """Base class for a pointer that has a type attribute."""
@@ -295,7 +299,7 @@ def assign(
     def address(self) -> Optional[int]:
         return self._address
 
-    def dereference(self) -> T:
+    def _dereference(self) -> T:
         return deref(self.ensure())
 
     def __irshift__(
@@ -362,7 +366,7 @@ def _make_stream_and_ptr(
         bytes_a = (ctypes.c_ubyte * size).from_address(address)
         return self.make_ct_pointer(), bytes(bytes_a)
 
-    def move(
+    def _move(
         self,
         data: Union["BaseCPointer[T]", T],
         *,
@@ -432,7 +436,7 @@ def assigned(self) -> bool:
     def assigned(self, value: bool) -> None:
         self._assigned = value
 
-    def move(
+    def _move(
         self,
         data: Union[BasePointer[T], T],
         unsafe: bool = False,
@@ -452,7 +456,7 @@ def move(
         self.assigned = True
         remove_ref(data)
 
-    def dereference(self) -> T:
+    def _dereference(self) -> T:
         if self.freed:
             raise FreedMemoryError(
                 "cannot dereference memory that has been freed",

src/pointers/c_pointer.py

@@ -35,7 +35,7 @@ def size(self) -> int:
     def _as_parameter_(self) -> ctypes.c_void_p:
         return ctypes.c_void_p(self.address)
 
-    def dereference(self) -> Optional[int]:
+    def _dereference(self) -> Optional[int]:
         """Dereference the pointer."""
         deref = ctypes.c_void_p.from_address(self.ensure())
         return deref.value
@@ -131,7 +131,7 @@ def _as_parameter_(self):
 
         return ctypes.pointer(deref)
 
-    def dereference(self) -> T:
+    def _dereference(self) -> T:
         """Dereference the pointer."""
         ctype = get_mapped(self.type)
 
@@ -153,10 +153,6 @@ def __iter__(self) -> Iterator[T]:
         """Dereference the pointer."""
         return iter({self.dereference()})
 
-    def __invert__(self) -> T:
-        """Dereference the pointer."""
-        return self.dereference()
-
 
 class CArrayPointer(_CDeref[List[T]], Typed[Type[T]], BaseCPointer[List[T]]):
     """Class representing a pointer to a C array."""
@@ -188,7 +184,7 @@ def _as_parameter_(self) -> "ctypes.Array[ctypes._CData]":
         deref = (ctype * self._length).from_address(self.ensure())
         return deref
 
-    def dereference(self) -> List[T]:
+    def _dereference(self) -> List[T]:
         """Dereference the pointer."""
         array = self._as_parameter_
         return [array[i] for i in range(self._length)]  # type: ignore

src/pointers/object_pointer.py

@@ -23,7 +23,7 @@ def __repr__(self) -> str:
     def __rich__(self):
         return f"<pointer to [bold green]{self._get_tp_name()}[/] object at [cyan]{self}[/cyan]>"  # noqa
 
-    def move(
+    def _move(
         self,
         target: Union[T, "BasePointer[T]"],
         *,

tests/test_pointer.py

@@ -96,4 +96,5 @@ def _():
     def segfault():
         ctypes.string_at(0)
 
-    handle(segfault, (), {})
+    with raises(RuntimeError):
+        handle(segfault)