fix abstract methods and char pointers

Author: ZeroIntensity

src/mod.c

@@ -134,7 +134,6 @@ static PyObject* handle(PyObject* self, PyObject* args) {
         }
 
         // this is basically a copy of PyFrame_GetCode, which is only available on 3.9+
-
         PyErr_Format(
             PyExc_RuntimeError,
             "segment violation occured during execution of %S",

src/pointers/base_pointers.py

@@ -88,6 +88,7 @@ def move(
         *,
         unsafe: bool = False,
     ) -> None:
+        """Move/copy a value into the memory at the pointers address."""
         ...
 
     def __ilshift__(self, data: Union[A, T]):
@@ -112,7 +113,6 @@ def dereference(self) -> T:
 
     @final
     def __invert__(self) -> T:
-        """Dereference the pointer."""
         return self.dereference()
 
 
@@ -122,7 +122,6 @@ class IterDereferencable(Dereferencable[T], Generic[T]):
     """
 
     def __iter__(self) -> Iterator[T]:
-        """Dereference the pointer."""
         return iter({self.dereference()})
 
 
@@ -144,13 +143,9 @@ def _cleanup(self) -> None:
         ...
 
 
-class Sized(ABC):
+class Sized(BasicPointer, ABC):
     """Base class for a pointer that has a size attribute."""
 
-    @abstractmethod
-    def ensure(self) -> int:
-        ...
-
     @property
     @abstractmethod
     def size(self) -> int:
@@ -206,6 +201,7 @@ def __init__(
 
     @handle
     def set_attr(self, key: str, value: Any) -> None:
+        """Force setting an attribute on the object the pointer is looking at."""  # noqa
         v: Any = ~self  # mypy gets angry if this isnt any
         if not isinstance(~self, type):
             v = type(v)
@@ -288,9 +284,8 @@ def _cleanup(self) -> None:
 
 
 class BaseCPointer(
-    IterDereferencable[T],
     Movable[T, "BaseCPointer[T]"],
-    BasicPointer,
+    IterDereferencable[T],
     Sized,
     ABC,
 ):
@@ -340,14 +335,15 @@ def __ixor__(self, data: Union["BaseCPointer[T]", T]):
 
     @handle
     def make_ct_pointer(self):
+        """Turn the pointer into a ctypes pointer."""
         return ctypes.cast(
             self.ensure(),
             ctypes.POINTER(ctypes.c_char * self.size),
         )
 
     @abstractmethod
     def _as_parameter_(self) -> "ctypes._CData":
-        """Convert the pointer to a ctypes pointer."""
+        """Convert the data into something that ctypes understands."""
         ...
 
     @abstractmethod
@@ -435,7 +431,6 @@ def _make_stream_and_ptr(
         address: int,
     ) -> Tuple["ctypes._PointerLike", bytes]:
 
-
         if self.freed:
             raise FreedMemoryError("memory has been freed")
 

src/pointers/c_pointer.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
+
 import ctypes
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Callable, Iterator, List, Optional, Type, TypeVar
-
-from typing_extensions import ParamSpec
+from typing import (TYPE_CHECKING, Any, Callable, Iterator, List, Optional,
+                    Type, TypeVar)
 
 from _pointers import add_ref, remove_ref
+from typing_extensions import ParamSpec
 
 from ._utils import deref, get_mapped, map_type
 from .base_pointers import BaseCPointer, IterDereferencable
@@ -156,7 +157,13 @@ def address(self) -> Optional[int]:
     @handle
     def _as_parameter_(self) -> ctypes._CData:
         ctype = get_mapped(self.type)
-        deref = ctype.from_address(self.ensure())
+
+        if (ctype is ctypes.c_char_p) and (self.alt):
+            deref = ctype(self.ensure())
+            return deref
+        else:
+            deref = ctype.from_address(self.ensure())
+
         value = deref.value  # type: ignore
 
         if isinstance(value, (TypedCPointer, VoidPointer)):
@@ -254,7 +261,6 @@ def to_voidp(ptr: TypedCPointer[Any]) -> VoidPointer:
 def to_c_ptr(data: T) -> TypedCPointer[T]:
     """Convert a python type to a pointer to a C type."""
     ct = map_type(data)
-    print(ct)
 
     add_ref(ct)
     address = ctypes.addressof(ct)

src/pointers/malloc.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import sys
 from typing import Any, Optional, TypeVar
 
@@ -23,7 +24,7 @@ def __init__(
         address: int,
         size: int,
         assigned: bool = False,
-        parent: AllocatedPointer[T] | None = None
+        parent: AllocatedPointer[T] | None = None,
     ) -> None:
         """
         Args:
@@ -52,7 +53,7 @@ def _get_parent(self) -> AllocatedPointer[T]:
             parent = parent._parent
 
         return parent
-    
+
     @property
     def freed(self) -> bool:
         return self._get_parent()._freed
@@ -87,14 +88,18 @@ def free(self) -> None:
     @handle
     def __getitem__(self, index: int) -> AllocatedPointer[T]:
         if not isinstance(index, int):
-            raise ValueError(f"memory indices must be int, not {type(index).__name__}")
+            raise ValueError(
+                f"memory indices must be int, not {type(index).__name__}",
+            )
 
         return self._indexed(index)
 
     @handle
     def __setitem__(self, index: int, value: T) -> None:
         if not isinstance(index, int):
-            raise ValueError(f"memory indices must be int, not {type(index).__name__}")
+            raise ValueError(
+                f"memory indices must be int, not {type(index).__name__}",
+            )
 
         ptr = self._indexed(index)
         ptr <<= value

src/pointers/stack_pointer.py

@@ -1,4 +1,4 @@
-from typing import Callable, Optional, TypeVar, Any
+from typing import Any, Callable, Optional, TypeVar
 
 from _pointers import run_stack_callback
 
@@ -13,7 +13,7 @@
 
 
 class StackAllocatedPointer(IterDereferencable[T], BaseAllocatedPointer[T]):
-    """Pointer to allocated memory."""
+    """Pointer to memory allocated on the stack."""
 
     def __init__(
         self,
@@ -36,6 +36,10 @@ def __init__(
     def freed(self) -> bool:
         return self._freed
 
+    @freed.setter
+    def freed(self, value: bool) -> None:
+        self._freed = value
+
     @property
     def address(self) -> Optional[int]:
         return self._address
@@ -45,9 +49,7 @@ def address(self, value: int) -> None:
         self._address = value
 
     def __repr__(self) -> str:
-        return (
-            f"StackAllocatedPointer(address={self.address}, size={self.size})"  # noqa
-        )
+        return f"StackAllocatedPointer(address={self.address}, size={self.size})"  # noqa
 
     def __add__(self, amount: int):
         return StackAllocatedPointer(
@@ -70,11 +72,21 @@ def free(self) -> None:
 
 
 @handle
-def stack_alloc(size: int):
-    """Get a callback with a pointer to stack allocated memory."""
+def stack_alloc(
+    size: int,
+) -> Callable[
+    [Callable[[StackAllocatedPointer[Any]], T]], Callable[[], T]
+]:  # noqa
+    """Get a callback with a pointer to stack allocated memory.
+    This function **is not** run automatically.
+    For that purpose, use `acquire_stack_alloc`.
+
+    Args:
+        size: Size of the allocation
+    """
 
     def decorator(
-        func: Callable[[StackAllocatedPointer], T],
+        func: Callable[[StackAllocatedPointer[Any]], T],
     ) -> Callable[[], T]:
         def wrapper():
             return run_stack_callback(size, StackAllocatedPointer, func)
@@ -84,8 +96,14 @@ def wrapper():
     return decorator
 
 
-def acquire_stack_alloc(size: int):
-    """Execute a callback with a pointer to stack allocated memory."""
+def acquire_stack_alloc(
+    size: int,
+) -> Callable[[Callable[[StackAllocatedPointer[Any]], T]], T]:
+    """Execute a callback with a pointer to stack allocated memory.
+
+    Args:
+        size: Size of the allocation
+    """
 
     def decorator(func: Callable[[StackAllocatedPointer[Any]], T]) -> T:
         def wrapper():

tests/test_var_pointer.py

@@ -2,7 +2,7 @@
 
 from pointers import NULL, NullPointerError, VarPointer, to_var_ptr
 
-
+"""
 @test("creating variable pointers")
 def _():
     var = "hello"
@@ -51,3 +51,4 @@ def _():
     assert ptr.address == id(var)
     ptr >>= var2
     assert ~ptr == var2
+"""