update tests and some patches

Author: ZeroIntensity

pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
 dependencies = [
     "typing_extensions",
 ]
-version="2.0.0"
+version="2.0.0-alpha"
 
 [project.urls]
 Documentation = "https://pointers.zintensity.dev"

src/pointers/__init__.py

@@ -3,6 +3,7 @@
     StructPointer, TypedCPointer, VoidPointer, array, cast, to_c_ptr,
     to_struct_ptr
 )
+from .c_utils import force_set_attr
 from .calloc import AllocatedArrayPointer, calloc
 from .custom_binding import binding, binds
 from .decay import decay
@@ -11,8 +12,8 @@
     InvalidBindingParameter, InvalidSizeError, IsFrozenError,
     IsMallocPointerError, NotEnoughChunks
 )
+from .magic import _
 from .malloc import AllocatedPointer, free, malloc, realloc
 from .object_pointer import Pointer, to_ptr
 from .struct import Struct
-from .utils import _, force_set_attr
 from .version import __version__

src/pointers/_pointer.py

@@ -10,9 +10,8 @@
 
 from _pointers import add_ref, remove_ref
 
-from .c_utils import move_to_mem
+from .c_utils import deref, force_set_attr, move_to_mem
 from .exceptions import DereferenceError, FreedMemoryError, NullPointerError
-from .utils import force_set_attr
 
 __all__ = (
     "BasePointer",
@@ -231,13 +230,14 @@ def address(self) -> Optional[int]:
         return self._address
 
     def dereference(self) -> T:
-        return ctypes.cast(self.ensure(), ctypes.py_object).value
+        return deref(self.ensure())
 
     def __irshift__(
         self,
         value: Optional[Union["BaseObjectPointer[T]", T]],
-    ) -> None:
+    ):
         self.assign(value)
+        return self
 
     @classmethod
     @abstractmethod
@@ -321,6 +321,10 @@ class BaseAllocatedPointer(BasePointer[T], Sized, ABC):
     def address(self) -> Optional[int]:
         ...
 
+    @address.setter
+    def address(self, value: int) -> None:
+        ...
+
     @property
     def freed(self) -> bool:
         """Whether the allocated memory has been freed."""
@@ -348,11 +352,6 @@ def move(
 
         data_ptr = data if isinstance(data, BasePointer) else to_ptr(data)
 
-        if not isinstance(data_ptr, BaseAllocatedPointer):
-            raise ValueError(
-                f"{data_ptr} does not point to allocated memory",
-            )
-
         ptr, byte_stream = self._make_stream_and_ptr(
             sys.getsizeof(~data_ptr),
             data_ptr.ensure(),
@@ -372,7 +371,7 @@ def dereference(self):
                 "cannot dereference allocated memory that has no value",
             )
 
-        return super().dereference()
+        return deref(self.ensure())
 
     @abstractmethod
     def __add__(self, amount: int) -> "BaseAllocatedPointer[Any]":

src/pointers/bindings.py

@@ -994,7 +994,7 @@ def gmtime(timer: PointerLike) -> StructPointer[Tm]:
     return _base(dll.gmtime, timer)
 
 
-def signal(signum: int, func: Callable[[int, None], int]) -> None:
+def signal(signum: int, func: Callable[[int], Any]) -> None:
     return _base(dll.signal, signum, func)
 
 

src/pointers/c_utils.py

@@ -1,6 +1,8 @@
 import ctypes
 from typing import Any, Dict, Type, Union
 
+from _pointers import force_set_attr as _force_set_attr
+
 from .exceptions import InvalidSizeError
 
 __all__ = (
@@ -22,15 +24,16 @@ def move_to_mem(
     target: str = "memory allocation",
 ):
     """Move data to a C pointer."""
-    try:
-        if not unsafe:
-            ptr.contents[:] = stream
-        else:
-            ctypes.memmove(ptr, stream, len(stream))
-    except ValueError as e:
+
+    slen = len(stream)
+    plen = len(ptr.contents)
+
+    if slen > plen:
         raise InvalidSizeError(
-            f"object is of size {len(stream)}, while {target} is {len(ptr.contents)}"  # noqa
-        ) from e
+            f"object is of size {slen}, while {target} is {plen}",
+        )
+
+    ctypes.memmove(ptr, stream, slen)
 
 
 def attempt_decode(data: bytes) -> Union[str, bytes]:
@@ -78,10 +81,10 @@ def get_py(
     data: Type["ctypes._CData"],
 ) -> Type[Any]:
     """Map the specified C type to a Python type."""
-    from ._pointer import BasePointer
+    from ._pointer import BaseCPointer
 
     if data.__name__.startswith("LP_"):
-        return BasePointer
+        return BaseCPointer
 
     types: Dict[Type["ctypes._CData"], type] = {
         ctypes.c_bool: bool,
@@ -122,3 +125,19 @@ def make_py(data: "ctypes._CData"):
         res = attempt_decode(res)
 
     return res
+
+
+def force_set_attr(typ: Type[Any], key: str, value: Any) -> None:
+    """Force setting an attribute on the target type."""
+
+    if not isinstance(typ, type):
+        raise ValueError(
+            f"{typ} does not derive from type (did you pass an instance and not a class)?",  # noqa
+        )
+
+    _force_set_attr(typ, key, value)
+
+
+def deref(address: int) -> Any:
+    """Get the value at the target address."""
+    return ctypes.cast(address, ctypes.py_object).value

src/pointers/calloc.py

@@ -33,7 +33,7 @@ def __init__(
         if chunk_cache:
             self._chunk_cache[self.current_index] = self
 
-    @property
+    @property  # type: ignore
     def address(self) -> Optional[int]:
         return self._address
 

src/pointers/magic.py

@@ -0,0 +1,22 @@
+from typing import TYPE_CHECKING, TypeVar
+
+if TYPE_CHECKING:
+    from ._pointer import BasePointer
+    from .object_pointer import Pointer
+
+from .object_pointer import to_ptr
+
+__all__ = ("_",)
+
+T = TypeVar("T")
+
+
+class _PointerOperatorMagic:
+    def __and__(self, obj: T) -> "Pointer[T]":
+        return to_ptr(obj)
+
+    def __mul__(self, ptr: "BasePointer[T]") -> T:
+        return ~ptr
+
+
+_ = _PointerOperatorMagic()

src/pointers/malloc.py

@@ -37,6 +37,10 @@ def size(self, value: int) -> None:
     def address(self) -> Optional[int]:
         return self._address
 
+    @address.setter
+    def address(self, value: int) -> None:
+        self._address = value
+
     def __repr__(self) -> str:
         return f"<pointer to {self.size} bytes of memory at {str(self)}>"
 
@@ -68,18 +72,24 @@ def malloc(size: int) -> AllocatedPointer[Any]:
     return AllocatedPointer(mem, size)
 
 
-def free(target: AllocatedPointer):
+def free(target: BaseAllocatedPointer):
     """Free allocated memory."""
+    if target.freed:
+        raise ValueError(
+            f"{target} has already been freed",
+        )
+
     ct_ptr = target.make_ct_pointer()
     c_free(ct_ptr)
     target.freed = True
 
 
 def realloc(target: AllocatedPointer, size: int) -> None:
     """Resize a memory block created by malloc."""
-    mem = c_realloc(target.address, size)
+    addr = c_realloc(target.address, size)
 
-    if not mem:
+    if not addr:
         raise AllocationError("failed to resize memory")
 
     target.size = size
+    target.address = addr

src/pointers/utils.py

@@ -1 +1 @@
-__version__ = "1.5.0"
+__version__ = "2.0.0-alpha"