patches with bindings

Author: ZeroIntensity

src/pointers/_cstd.py

@@ -523,7 +523,7 @@ class lconv(ctypes.Structure):
 dll.difftime.argtypes = (ctypes.c_int, ctypes.c_int)
 dll.difftime.restype = ctypes.c_double
 # struct tm* gmtime(const time_t* timer)
-dll.gmtime.argtypes = (ctypes.c_int,)
+dll.gmtime.argtypes = (ctypes.POINTER(ctypes.c_int),)
 dll.gmtime.restype = ctypes.POINTER(tm)
 # struct tm* localtime(const time_t* timer)
 dll.localtime.argtypes = (ctypes.c_int,)

src/pointers/bindings.py

@@ -37,7 +37,7 @@
 
 T = TypeVar("T")
 PointerLike = Union[TypedCPointer[Any], VoidPointer]
-StringLike = Union[str, bytes, VoidPointer]
+StringLike = Union[str, bytes, VoidPointer, TypedCPointer[bytes]]
 Format = Union[str, bytes, PointerLike]
 
 __all__ = (
@@ -149,6 +149,7 @@
     "c_calloc",
     "c_realloc",
     "c_free",
+    "gmtime",
 )
 
 
@@ -176,7 +177,7 @@ def _decode_response(
         res = (
             TypedCPointer(ctypes.addressof(res), res_typ, ctypes.sizeof(res))
             if not issubclass(type(res.contents), ctypes.Structure)
-            else StructPointer(id(struct), type(_not_null(struct)))
+            else StructPointer(id(struct), type(_not_null(struct)), struct)
         )
     # type safety gets mad if i dont use elif here
     elif fn.restype is ctypes.c_void_p:
@@ -229,15 +230,22 @@ def _base(
 
 
 def _make_char_pointer(data: StringLike) -> Union[bytes, ctypes.c_char_p]:
-    if type(data) not in {VoidPointer, str, bytes}:
+    if type(data) not in {VoidPointer, str, bytes, TypedCPointer}:
         raise InvalidBindingParameter(
             f"expected a string-like object, got {repr(data)}"  # noqa
         )
 
     if isinstance(data, bytes):
         return data
 
-    if isinstance(data, VoidPointer):
+    is_typed_ptr: bool = isinstance(data, TypedCPointer)
+
+    if isinstance(data, VoidPointer) or is_typed_ptr:
+        if is_typed_ptr and (data.type is not bytes):
+            raise InvalidBindingParameter(
+                f"{data} does not point to bytes",
+            )
+
         return ctypes.c_char_p(data.address)
 
     return data.encode()
@@ -809,12 +817,18 @@ def mktime(timeptr: StructPointer[Tm]) -> int:
 
 
 def strftime(
-    string: str,
+    string: StringLike,
     maxsize: int,
-    fmt: TypedCPointer[str],
+    fmt: StringLike,
     timeptr: StructPointer[Tm],
 ) -> int:
-    return _base(dll.strftime, string, maxsize, fmt, timeptr)
+    return _base(
+        dll.strftime,
+        _make_char_pointer(string),
+        maxsize,
+        _make_char_pointer(fmt),
+        timeptr,
+    )
 
 
 def time(timer: TypedCPointer[int]) -> int:
@@ -851,3 +865,7 @@ def c_realloc(ptr: PointerLike, size: int) -> VoidPointer:
 
 def c_free(ptr: PointerLike) -> None:
     return _base(_free, ptr)
+
+
+def gmtime(timer: PointerLike) -> StructPointer[Tm]:
+    return _base(dll.gmtime, timer)

src/pointers/c_pointer.py

@@ -62,13 +62,27 @@ def attempt_decode(data: bytes) -> Union[str, bytes]:
 class StructPointer(Pointer[A]):
     """Class representing a pointer to a struct."""
 
-    def __init__(self, address: int, data_type: Type[A]):
+    def __init__(
+        self,
+        address: int,
+        data_type: Type[A],
+        existing: Optional["Struct"] = None,
+    ):
         super().__init__(address, data_type, True)
+        self._existing = existing
 
     @property
-    def _as_parameter_(self):
+    def _as_parameter_(self) -> Union[int, ctypes.pointer]:
+        existing = self._existing
+
+        if existing:
+            return ctypes.pointer(existing.struct)
+
         return self._address
 
+    def __repr__(self) -> str:
+        return f"<pointer to struct at {hex(self.address)}>"
+
 
 class _BaseCPointer(Pointer[Any], Generic[T]):
     def __init__(self, address: int, size: int):
@@ -80,6 +94,11 @@ def size(self):
         """Size of the pointer."""
         return self._size
 
+    @property
+    def type(self) -> T:
+        """Type of the pointer."""
+        return self._type
+
     # i need to repeat these for type safety
     def __iter__(self) -> Iterator[T]:
         """Dereference the pointer."""
@@ -147,8 +166,13 @@ def is_mappable(cls, typ: Any) -> bool:
             return False
 
     @staticmethod
-    def get_py(data: Type["ctypes._CData"]) -> type:
+    def get_py(
+        data: Type["ctypes._CData"],
+    ) -> Type[Any]:
         """Map the specified C type to a Python type."""
+        if data.__name__.startswith("LP_"):
+            return Pointer
+
         types: Dict[Type["ctypes._CData"], type] = {
             ctypes.c_bool: bool,
             ctypes.c_char: bytes,

src/pointers/struct.py

@@ -58,3 +58,8 @@ def _sync(self):
 
     def __repr__(self) -> str:
         return f"<struct {self.__class__.__name__} at {hex(ctypes.addressof(self._struct))}>"  # noqa
+
+    @property
+    def struct(self) -> ctypes.Structure:
+        """Raw internal Structure object."""
+        return self._struct