feat: extend the struct parser a bit more

Author: MrIndeciso

libdestruct/c/ctypes_generic_field.py

@@ -11,6 +11,8 @@
 from libdestruct.c.ctypes_generic import _ctypes_generic
 from libdestruct.common.type_registry import TypeRegistry
 
+registry = TypeRegistry()
+
 
 def ctypes_type_handler(obj_type: type) -> type[_ctypes_generic]:
     """Return the ctypes type handler for the given object type.
@@ -21,11 +23,15 @@ def ctypes_type_handler(obj_type: type) -> type[_ctypes_generic]:
     if not issubclass(obj_type, _SimpleCData):
         raise TypeError(f"Unsupported object type: {obj_type}.")
 
-    return type(
+    typ = type(
         f"ctypes_{obj_type.__name__}",
         (_ctypes_generic,),
         {"backing_type": obj_type, "size": sizeof(obj_type)},
     )
 
+    registry.register_mapping(typ, typ)
+
+    return typ
+
 
-TypeRegistry().register_type_handler(_SimpleCData, ctypes_type_handler)
+registry.register_type_handler(_SimpleCData, ctypes_type_handler)

libdestruct/c/struct_parser.py

@@ -14,6 +14,8 @@
 
 from pycparser import c_ast, c_parser
 
+from libdestruct.common.array.array_of import array_of
+from libdestruct.common.ptr.ptr_factory import ptr_to, ptr_to_self
 from libdestruct.common.struct import struct
 
 if TYPE_CHECKING:
@@ -60,19 +62,57 @@ def struct_to_type(struct_node: c_ast.Struct) -> type[struct]:
 
     for decl in struct_node.decls:
         name = decl.name
-        typ = type_decl_to_type(decl.type)
+        typ = type_decl_to_type(decl.type, struct_node)
         fields[name] = typ
 
     type_name = struct_node.name if struct_node.name else "anon_struct"
 
     return type(type_name, (struct,), {"__annotations__": fields})
 
 
-def type_decl_to_type(decl: c_ast.TypeDecl) -> type[obj]:
+def ptr_to_type(ptr: c_ast.PtrDecl, parent: c_ast.Struct | None = None) -> type[obj]:
+    """Converts a C pointer to a type."""
+    if not isinstance(ptr, c_ast.PtrDecl):
+        raise TypeError("Definition must be a pointer.")
+
+    if not isinstance(ptr.type, c_ast.TypeDecl):
+        raise TypeError("Definition must be a type declaration.")
+
+    # Special case: this is a pointer to self
+    # Note that ptr can either be a struct or an identifier.
+    ptr_name = ptr.type.type.name if isinstance(ptr.type.type, c_ast.Struct) else ptr.type.type.names[0]
+    if parent and ptr_name == parent.name:
+        return ptr_to_self()
+
+    typ = type_decl_to_type(ptr.type)
+
+    return ptr_to(typ)
+
+
+def arr_to_type(arr: c_ast.ArrayDecl) -> type[obj]:
+    """Converts a C array to a type."""
+    if not isinstance(arr, c_ast.ArrayDecl):
+        raise TypeError("Definition must be an array.")
+
+    if not isinstance(arr.type, c_ast.TypeDecl) and not isinstance(arr.type, c_ast.PtrDecl):
+        raise TypeError("Definition must be a type declaration.")
+
+    typ = ptr_to_type(arr.type) if isinstance(arr.type, c_ast.PtrDecl) else type_decl_to_type(arr.type)
+
+    return array_of(typ, int(arr.dim.value))
+
+
+def type_decl_to_type(decl: c_ast.TypeDecl, parent: c_ast.Struct | None = None) -> type[obj]:
     """Converts a C type declaration to a type."""
-    if not isinstance(decl, c_ast.TypeDecl):
+    if not isinstance(decl, c_ast.TypeDecl) and not isinstance(decl, c_ast.PtrDecl) and not isinstance(decl, c_ast.ArrayDecl):
         raise TypeError("Definition must be a type declaration.")
 
+    if isinstance(decl, c_ast.PtrDecl):
+        return ptr_to_type(decl, parent)
+
+    if isinstance(decl, c_ast.ArrayDecl):
+        return arr_to_type(decl)
+
     if isinstance(decl.type, c_ast.Struct):
         return struct_to_type(decl.type)
 
@@ -95,6 +135,9 @@ def to_uniform_name(name: str) -> str:
     name = name.replace("int32_t", "int")
     name = name.replace("int64_t", "longlong")
 
+    # We have to convert uintptr_t
+    name = name.replace("uintptr_t", "ulonglong")
+
     # Only size_t, ssize_t and time_t can end with _t
     if not any(x in name for x in ["size", "ssize", "time"]):
         name = name.replace("_t", "")

libdestruct/common/array/array_field.py

@@ -9,16 +9,19 @@
 from abc import abstractmethod
 from typing import TYPE_CHECKING
 
+from libdestruct.common.array import array
 from libdestruct.common.field import Field
 
 if TYPE_CHECKING: # pragma: no cover
     from libdestruct.backing.resolver import Resolver
-    from libdestruct.common.array import array
+    from libdestruct.common.obj import obj
 
 
 class ArrayField(Field):
     """A generator for an array of items."""
 
+    base_type: type[obj] = array
+
     @abstractmethod
     def inflate(self: ArrayField, resolver: Resolver) -> array:
         """Inflate the field.

libdestruct/common/array/array_impl.py

@@ -8,15 +8,16 @@
 
 from typing import TYPE_CHECKING
 
+from libdestruct.c.ctypes_generic import _ctypes_generic
 from libdestruct.common.array.array import array
+from libdestruct.common.field import Field
 from libdestruct.common.obj import obj
 from libdestruct.common.struct.struct import struct
 
 if TYPE_CHECKING: # pragma: no cover
     from collections.abc import Generator
 
     from libdestruct.backing.resolver import Resolver
-    from libdestruct.common.obj import obj
 
 
 class array_impl(array):
@@ -36,15 +37,23 @@ def __init__(
 
         self.backing_type = backing_type
         self._count = count
-        self.size = self.backing_type.size * self._count
+
+        if hasattr(backing_type, "size"):
+            self.size = self.backing_type.size * self._count
+            self.item_size = self.backing_type.size
+        elif callable(backing_type):
+            self.size = 8 * self._count
+            self.item_size = 8
+        else:
+            raise NotImplementedError("Unsupported backing type.")
 
     def count(self: array_impl) -> int:
         """Get the size of the array."""
         return self._count
 
     def get(self: array, index: int) -> object:
         """Return the element at the given index."""
-        return self.backing_type(self.resolver.relative_from_own(index * self.backing_type.size, 0))
+        return self.backing_type(self.resolver.relative_from_own(index * self.item_size, 0))
 
     def _set(self: array_impl, _: list[obj]) -> None:
         """Set the array from a list."""
@@ -64,7 +73,7 @@ def to_str(self: array_impl, indent: int = 0) -> str:
             return "[]"
 
         # If the backing type is a struct, we need to indent the output differently
-        if issubclass(self.backing_type, struct):
+        if isinstance(self.backing_type, type) and issubclass(self.backing_type, struct):
             padding = ",\n" + " " * (indent + 4)
             spacing = " " * (indent + 4)
             return "[\n" + spacing + padding.join(x.to_str(indent + 4) for x in self) + "\n" + " " * (indent) + "]"

libdestruct/common/enum/enum_field.py

@@ -9,16 +9,19 @@
 from abc import abstractmethod
 from typing import TYPE_CHECKING
 
+from libdestruct.common.enum import enum
 from libdestruct.common.field import Field
 
 if TYPE_CHECKING: # pragma: no cover
     from libdestruct.backing.resolver import Resolver
-    from libdestruct.common.enum import enum
+    from libdestruct.common.obj import obj
 
 
 class EnumField(Field):
     """A generator for an enum."""
 
+    base_type: type[obj] = enum
+
     @abstractmethod
     def inflate(self: EnumField, resolver: Resolver) -> enum:
         """Inflate the field.

libdestruct/common/field.py

@@ -17,6 +17,8 @@
 class Field(ABC):
     """A generator for a generic field."""
 
+    base_type: type[obj]
+
     @abstractmethod
     def inflate(self: Field, resolver: Resolver) -> obj:
         """Inflate the field.

libdestruct/common/ptr/__init__.py

@@ -8,7 +8,7 @@
 
 from typing import TYPE_CHECKING
 
-from libdestruct.common.struct.ptr_struct_field import PtrStructField
+from libdestruct.common.ptr.ptr_struct_field import PtrStructField
 
 if TYPE_CHECKING: # pragma: no cover
     from libdestruct.common.field import Field

libdestruct/common/ptr.py libdestruct/common/ptr/ptr.pylibdestruct/common/ptr.py renamed to libdestruct/common/ptr/ptr.py

@@ -9,7 +9,7 @@
 from typing import TYPE_CHECKING
 
 from libdestruct.common.field import Field
-from libdestruct.common.ptr import ptr
+from libdestruct.common.ptr.ptr import ptr
 from libdestruct.common.struct.struct_field import StructField
 
 if TYPE_CHECKING: # pragma: no cover
@@ -20,6 +20,8 @@
 class PtrStructField(StructField):
     """A generator for a field of a struct."""
 
+    base_type: type[obj] = ptr
+
     def __init__(self: PtrStructField, backing_type: type | Field) -> None:
         """Initialize a pointer field.