broken as of now

Author: ZeroIntensity

src/pointers/__init__.py

@@ -9,8 +9,7 @@
 from .decay import decay
 from .exceptions import (
     AllocationError, DereferenceError, FreedMemoryError,
-    InvalidBindingParameter, InvalidSizeError, IsFrozenError,
-    IsMallocPointerError, NotEnoughChunks
+    InvalidBindingParameter, InvalidSizeError
 )
 from .magic import _
 from .malloc import AllocatedPointer, free, malloc, realloc

src/pointers/_cstd.py

@@ -1,4 +1,5 @@
 import ctypes
+from ctypes.util import find_library
 from platform import system
 from typing import Dict, Type
 
@@ -27,7 +28,7 @@
     "Lconv",
 )
 
-dll = ctypes.CDLL(platforms[system().lower()])
+dll = ctypes.CDLL(platforms.get(system().lower()) or find_library("c"))
 
 
 class tm(ctypes.Structure):

src/pointers/_pointer.py

@@ -177,7 +177,12 @@ def _make_stream_and_ptr(
         ...
 
 
-class BaseObjectPointer(Typed[T], BasePointer[T], ABC):
+class BaseObjectPointer(
+    IterDereferencable[T],
+    Typed[T],
+    BasePointer[T],
+    ABC,
+):
     def __init__(
         self,
         address: int,
@@ -348,6 +353,7 @@ def move(
         data: Union[BasePointer[T], T],
         unsafe: bool = False,
     ) -> None:
+        self.ensure_valid()
         from .object_pointer import to_ptr
 
         data_ptr = data if isinstance(data, BasePointer) else to_ptr(data)
@@ -394,3 +400,23 @@ def _make_stream_and_ptr(
 
         bytes_a = (ctypes.c_ubyte * size).from_address(address)  # fmt: off
         return self.make_ct_pointer(), bytes(bytes_a)
+
+    @abstractmethod
+    def free(self) -> None:
+        """Free the memory."""
+        ...
+
+    def ensure_valid(self) -> None:
+        """Ensure the memory has not been freed."""
+        if self.freed:
+            raise FreedMemoryError(
+                f"{self} has been freed",
+            )
+
+    @property
+    def size(self) -> int:
+        return self._size
+
+    @size.setter
+    def size(self, value: int) -> None:
+        self._size = value

src/pointers/bindings.py

@@ -195,7 +195,12 @@ def _decode_type(
         )  # fmt: off
 
         res = (
-            TypedCPointer(ctypes.addressof(res), res_typ, ctypes.sizeof(res))
+            TypedCPointer(
+                ctypes.addressof(res),
+                res_typ,
+                ctypes.sizeof(res),
+                alt=True,
+            )
             if not issubclass(type(res.contents), ctypes.Structure)
             else StructPointer(id(struct), type(_not_null(struct)), struct)
         )
@@ -366,7 +371,9 @@ def _make_char_pointer(data: StringLike) -> Union[bytes, ctypes.c_char_p]:
                 f"{data} does not point to bytes",
             )
 
-        return ctypes.c_char_p(data.address)
+        if is_typed_ptr and (not data.alt):  # type: ignore
+            return ctypes.c_char_p.from_address(data.ensure())
+        return ctypes.c_char_p(data.ensure())
 
     if isinstance(data, str):
         return data.encode()

src/pointers/c_pointer.py

@@ -75,11 +75,18 @@ def __init__(
         size: int,
         void_p: bool = True,
         decref: bool = True,
+        alt: bool = False,
     ):
         self._void_p = void_p
         super().__init__(address, size)
         self._type = data_type
         self._decref = decref
+        self._alt = alt
+
+    @property
+    def alt(self) -> bool:
+        """Whether to use the alternative method for dereferencing."""
+        return self._alt
 
     @property
     def size(self) -> int:
@@ -137,8 +144,10 @@ def dereference(self) -> T:
         """Dereference the pointer."""
         ctype = get_mapped(self.type)
 
-        if ctype is ctypes.c_char_p:
-            return ctypes.c_char_p(self.ensure()).value  # type: ignore
+        if (ctype is ctypes.c_char_p) and (self._alt):
+            res = ctypes.c_char_p(self.ensure()).value
+            assert res
+            return res  # type: ignore
 
         ptr = (
             ctype.from_address(self.ensure())
@@ -212,6 +221,7 @@ def cast(ptr: VoidPointer, data_type: Type[T]) -> TypedCPointer[T]:
         ptr.size,
         decref=False,
         void_p=True,
+        alt=True,
     )
 
 

src/pointers/calloc.py

@@ -1,14 +1,23 @@
 from typing import Dict, Iterator, Optional, TypeVar
 
-from ._cstd import c_calloc
+from ._cstd import c_calloc, c_free
 from ._pointer import BaseAllocatedPointer
-from .exceptions import AllocationError, NotEnoughChunks
+from .exceptions import AllocationError
 
 __all__ = ("AllocatedArrayPointer", "calloc")
 
 
 T = TypeVar("T")
 
+"""
+FOR FUTURE REFERENCE:
+
+_chunk_store is needed to hold each index in the pointer array accordingly.
+We can't just lookup each index via a memory offset, since we can't verify that the memory actually contains something.
+
+If the memory is empty, then Python will segfault as it can't convert it to a PyObject*.
+"""  # noqa
+
 
 class AllocatedArrayPointer(BaseAllocatedPointer[T]):
     """Class representing memory created by calloc()"""
@@ -20,19 +29,23 @@ def __init__(
         chunk_size: int,
         current_index: int,
         chunk_cache: Optional[Dict[int, "AllocatedArrayPointer[T]"]] = None,
+        freed: bool = False,
+        origin_address: Optional[int] = None,
     ) -> None:
+        self._origin_address = origin_address or address
         self._address = address
-        self._chunk_size = chunk_size
+        self._size = chunk_size
         self._current_index = current_index
         self._chunks = chunks
-        self._chunk_cache = chunk_cache or {0: self}
+        self._chunk_store = chunk_cache or {0: self}
         self._assigned = True
         self._tracked = False
-        self._freed = False
+        self._freed = freed
 
         if chunk_cache:
-            self._chunk_cache[self.current_index] = self
+            self._chunk_store[self.current_index] = self
 
+    # https://github.com/python/mypy/issues/4125
     @property  # type: ignore
     def address(self) -> Optional[int]:
         return self._address
@@ -47,41 +60,31 @@ def chunks(self) -> int:
         """Number of allocated chunks."""
         return self._chunks
 
-    @property
-    def chunk_size(self) -> int:
-        """Size of each chunk."""
-        return self._chunk_size
-
-    @property
-    def size(self) -> int:
-        """Size of the current chunk."""
-        return self._chunk_size
-
-    @size.setter
-    def size(self, value: int) -> None:
-        self._chunk_size = value  # this might break things but idk
-
-    def __add__(self, amount: int) -> "AllocatedArrayPointer[T]":
-        index: int = self.current_index + amount
-
+    def _get_chunk_at(self, index: int) -> "AllocatedArrayPointer[T]":
         if index > self.chunks:
-            raise NotEnoughChunks(
-                f"chunk index is {index}, while allocation is {self.chunks}"
+            raise IndexError(
+                f"index is {index}, while allocation is {self.chunks}",
             )
 
         if index < 0:  # for handling __sub__
-            raise IndexError("chunk index is below zero")
+            raise IndexError("index is below zero")
 
-        if index not in self._chunk_cache:
-            self._chunk_cache[index] = AllocatedArrayPointer(
-                self.ensure() + (amount * self.size),
+        if index not in self._chunk_store:
+            self._chunk_store[index] = AllocatedArrayPointer(
+                self._origin_address + (index * self.size),
                 self.chunks,
-                self.chunk_size,
+                self.size,
                 index,
-                self._chunk_cache,
+                self._chunk_store,
+                self._freed,
+                self._origin_address,
             )
 
-        return self._chunk_cache[index]
+        return self._chunk_store[index]
+
+    def __add__(self, amount: int) -> "AllocatedArrayPointer[T]":
+        self.ensure_valid()
+        return self._get_chunk_at(self._current_index + amount)
 
     def __sub__(self, amount: int) -> "AllocatedArrayPointer[T]":
         return self.__add__(-amount)
@@ -96,9 +99,22 @@ def __iter__(self) -> Iterator["AllocatedArrayPointer[T]"]:
         for i in range(self.current_index, self.chunks):
             yield self + i
 
+    def __getitem__(self, index: int) -> "AllocatedArrayPointer[T]":
+        return self._get_chunk_at(index)
+
     def __del__(self):
         pass
 
+    def free(self) -> None:
+        first = self[0]
+        first.ensure_valid()
+
+        for i in range(self._chunks):  # using __iter__ breaks here
+            chunk = self._get_chunk_at(i)
+            chunk.freed = True
+
+        c_free(first.make_ct_pointer())
+
 
 def calloc(num: int, size: int) -> AllocatedArrayPointer:
     """Allocate a number of blocks with a given size."""

src/pointers/exceptions.py

@@ -1,8 +1,5 @@
 __all__ = (
-    "IsMallocPointerError",
     "AllocationError",
-    "NotEnoughChunks",
-    "IsFrozenError",
     "DereferenceError",
     "FreedMemoryError",
     "InvalidSizeError",
@@ -11,30 +8,12 @@
 )
 
 
-class IsMallocPointerError(Exception):
-    """Raised when trying perform an operation on a malloc pointer that isn't supported."""  # noqa
-
-    pass
-
-
 class AllocationError(Exception):
     """Raised when a memory allocation fails."""
 
     pass
 
 
-class NotEnoughChunks(Exception):
-    """Raised when there aren't enough chunks in a CallocPointer."""
-
-    pass
-
-
-class IsFrozenError(Exception):
-    """Raised when trying to move the address of a frozen pointer."""
-
-    pass
-
-
 class DereferenceError(Exception):
     """Raised when dereferencing an address fails."""  # noqa
 

src/pointers/malloc.py

@@ -8,6 +8,7 @@
 
 
 T = TypeVar("T")
+A = TypeVar("A", bound=BaseAllocatedPointer)
 
 
 class AllocatedPointer(IterDereferencable[T], BaseAllocatedPointer[T]):
@@ -25,14 +26,6 @@ def __init__(
         self._assigned = assigned
         self._tracked = False
 
-    @property
-    def size(self) -> int:
-        return self._size
-
-    @size.setter
-    def size(self, value: int) -> None:
-        self._size = value
-
     @property
     def address(self) -> Optional[int]:
         return self._address
@@ -61,6 +54,11 @@ def __sub__(self, amount: int):
             self.assigned,
         )
 
+    def free(self) -> None:
+        self.ensure_valid()
+        c_free(self.make_ct_pointer())
+        self.freed = True
+
 
 def malloc(size: int) -> AllocatedPointer[Any]:
     """Allocate memory for a given size."""
@@ -74,17 +72,10 @@ def malloc(size: int) -> AllocatedPointer[Any]:
 
 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
+    target.free()
 
 
-def realloc(target: AllocatedPointer, size: int) -> None:
+def realloc(target: A, size: int) -> A:
     """Resize a memory block created by malloc."""
     addr = c_realloc(target.address, size)
 
@@ -93,3 +84,4 @@ def realloc(target: AllocatedPointer, size: int) -> None:
 
     target.size = size
     target.address = addr
+    return target