updates/patches with c pointers

Author: ZeroIntensity

pyproject.toml

@@ -23,4 +23,4 @@ classifiers = [
 dependencies = [
     "typing_extensions",
 ]
-version = "2.2.0-a"
+version = "2.2.0-a2"

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-a"
+__version__ = "2.2.0-a2"

src/pointers/_utils.py

@@ -21,7 +21,6 @@
     int: ctypes.c_int,
     float: ctypes.c_float,
     bool: ctypes.c_bool,
-    Any: ctypes.c_void_p,  # type: ignore
 }
 
 _PY_TYPES: Dict[Type["ctypes._CData"], type] = {
@@ -84,7 +83,11 @@ def map_type(data: Any) -> "ctypes._CData":
 
 def get_mapped(typ: Any) -> "Type[ctypes._CData]":
     """Get the C mapped value of the given type."""
-    return _C_TYPES.get(typ) or ctypes.py_object
+    from .c_pointer import VoidPointer
+
+    return {**_C_TYPES, VoidPointer: ctypes.c_void_p}.get(  # type: ignore
+        typ,
+    ) or ctypes.py_object
 
 
 def is_mappable(typ: Any) -> bool:

src/pointers/c_pointer.py

@@ -142,6 +142,11 @@ def address(self) -> Optional[int]:
     def _as_parameter_(self):
         ctype = get_mapped(self.type)
         deref = ctype.from_address(self.ensure())
+        value = deref.value  # type: ignore
+
+        if isinstance(value, (TypedCPointer, VoidPointer)):
+            return ctypes.pointer(value._as_parameter_)
+
         return ctypes.pointer(deref)
 
     def dereference(self) -> T:

src/pointers/std_structs.py

@@ -1,9 +1,12 @@
 import ctypes
-from typing import Any, Dict, Type
+from typing import TYPE_CHECKING, Dict, Type
 
 from ._cstd import div_t, lconv, ldiv_t, tm
-from ._pyapi import PyType_Slot
-from .structure import Struct
+from ._pyapi import PyType_Slot, PyType_Spec
+from .structure import Struct, StructPointer
+
+if TYPE_CHECKING:
+    from .c_pointer import VoidPointer
 
 __all__ = (
     "Tm",
@@ -56,7 +59,15 @@ class Lconv(Struct):
 
 class PyTypeSlot(Struct):
     slot: int
-    pfunc: Any
+    pfunc: "VoidPointer"
+
+
+class PyTypeSpec(Struct):
+    name: bytes
+    basic_size: int
+    itemsize: int
+    flags: int
+    slots: StructPointer[PyTypeSlot]
 
 
 STRUCT_MAP: Dict[Type[ctypes.Structure], Type[Struct]] = {
@@ -65,4 +76,5 @@ class PyTypeSlot(Struct):
     ldiv_t: LDivT,
     lconv: Lconv,
     PyType_Slot: PyTypeSlot,
+    PyType_Spec: PyTypeSpec,
 }

src/pointers/structure.py

@@ -1,9 +1,12 @@
 import ctypes
 from contextlib import suppress
-from typing import Any, Optional, Type, TypeVar, Union, get_type_hints
+from typing import Any, List, Optional, Type, TypeVar, Union, get_type_hints
 
-from ._utils import attempt_decode, get_mapped
-from .c_pointer import BaseCPointer
+from _pointers import add_ref
+
+from ._utils import attempt_decode, get_mapped, get_py
+from .base_pointers import BaseCPointer
+from .c_pointer import TypedCPointer, VoidPointer
 from .constants import RawType
 from .object_pointer import Pointer
 
@@ -15,21 +18,40 @@
 )
 
 
-def _get_type(
-    class_: Type["Struct"],
-    ct: Type["ctypes._CData"],
-    name: str,
-) -> Type["ctypes._CData"]:
-    attr = getattr(class_, name, None)
+class Struct:
+    """Abstract class representing a struct."""
 
-    if isinstance(attr, RawType):
-        return attr.tp
+    def _convert_tc_ptr(self, typ: Any, name: str):
+        if typ is TypedCPointer:
+            raise TypeError(
+                "cannot instantiate: TypedCPointer has no type argument",
+            )
 
-    return ct
+        if getattr(typ, "__origin__", None) is TypedCPointer:
+            setattr(
+                type(self),
+                name,
+                RawType(
+                    ctypes.POINTER(get_mapped(typ.__args__[0])),
+                ),
+            )
 
+        return typ
 
-class Struct:
-    """Abstract class representing a struct."""
+    def _get_type(
+        self,
+        ct: Type["ctypes._CData"],
+        name: str,
+    ) -> Type["ctypes._CData"]:
+        attr = getattr(type(self), name, None)
+
+        if isinstance(attr, RawType):
+            return attr.tp
+
+        if ct is ctypes.c_void_p:
+            self._void_p.append(name)
+
+        return ct
 
     def __init__(self, *args: Any, do_sync: bool = True):
         class_typ: Type[Struct] = type(self)
@@ -40,15 +62,16 @@ def __init__(self, *args: Any, do_sync: bool = True):
             )
 
         hints = get_type_hints(class_typ)
-        self._hints = hints
+        self._void_p: List[str] = []
+        self._hints = {k: self._convert_tc_ptr(v, k) for k, v in hints.items()}
 
         class _InternalStruct(ctypes.Structure):
             _fields_ = [
                 (
                     name,
-                    _get_type(class_typ, get_mapped(typ), name),
+                    self._get_type(get_mapped(typ), name),
                 )
-                for name, typ in hints.items()  # fmt: off
+                for name, typ in self._hints.items()  # fmt: off
             ]
 
         self._struct = _InternalStruct(
@@ -91,6 +114,29 @@ def __getattribute__(self, name: str):
             if (name in hints) and (type(attr)) is bytes:
                 attr = attempt_decode(attr)
 
+        if isinstance(attr, ctypes._Pointer):  # type: ignore
+            value = attr.contents
+            ct = type(value)
+
+            if ct is ctypes.c_void_p:
+                add_ref(ct)
+                return VoidPointer(
+                    ctypes.addressof(value),
+                    ctypes.sizeof(value),
+                )
+
+            py_type = get_py(ct)
+            return TypedCPointer(
+                ctypes.addressof(value),
+                py_type,
+                ctypes.sizeof(value),
+                False,
+            )
+
+        if name in super().__getattribute__("_void_p"):
+            ct = ctypes.c_void_p(attr)  # type: ignore
+            return VoidPointer(attr, ctypes.sizeof(ct))  # type: ignore
+
         return attr
 
     def __setattr__(self, name: str, value: Any):

tests/test_bindings.py

@@ -1,12 +1,14 @@
 from ward import raises, test
 
-from pointers import InvalidBindingParameter
+from pointers import (
+    InvalidBindingParameter, Struct, StructPointer, TypedCPointer, VoidPointer
+)
 from pointers import _cstd as std
 from pointers import (
     binds, c_free, c_malloc, cast, div, isspace, signal, sprintf, strcpy,
-    strlen, toupper
+    strlen, to_c_ptr, to_struct_ptr, to_voidp, toupper
 )
-from pointers._cstd import DivT
+from pointers.std_structs import DivT
 
 
 @test("c strings")
@@ -55,12 +57,44 @@ def _():
     assert type(res) is DivT
     assert res.quot == 10
 
+    class A(Struct):
+        one: int
+        two: int
 
-@test("struct pointers")
-def _():
-    res = div(10, 1)
-    assert type(res) is DivT
-    assert res.quot == 10
+    a = A(1, 2)
+
+    class MyStruct(Struct):
+        a: str
+        b: str
+        c: StructPointer[A]
+        d: TypedCPointer[int]
+        e: VoidPointer
+
+    s = MyStruct(
+        "a",
+        "b",
+        to_struct_ptr(a),
+        to_c_ptr(1),
+        to_voidp(
+            to_c_ptr("hello"),
+        ),
+    )
+
+    assert s.a == "a"
+    assert type(s.c) is StructPointer
+    assert type(s.d) is TypedCPointer
+    assert type(s.e) is VoidPointer
+
+    assert (~s.c) is a
+    assert (~s.c).one == a.one
+    assert ~s.d == 1
+    assert ~cast(s.e, str) == "hello"
+
+    class Foo(Struct):
+        bar: TypedCPointer
+
+    with raises(TypeError):
+        Foo()
 
 
 @test("custom bindings")
@@ -87,3 +121,20 @@ def _():
         isspace("")
 
     assert isspace(" ") != 0
+
+
+@test("c pointers")
+def _():
+    ptr = to_c_ptr(1)
+    ptr2 = to_c_ptr("hi")
+
+    assert ~ptr == 1
+    assert ~ptr2 == "hi"
+
+    double_ptr = to_c_ptr(to_c_ptr(1))
+    assert type(~double_ptr) is TypedCPointer
+    assert ~(~double_ptr) == 1
+    voidp = to_voidp(to_c_ptr(1))
+    assert type(voidp) is VoidPointer
+
+    assert ~cast(voidp, int) == 1