fix: add missing support for c_float and c_double

Author: MrIndeciso

docs/basics/types.md

@@ -11,6 +11,8 @@ libdestruct provides Python equivalents for common C primitive types. All types
 | `c_long` | `long` / `int64_t` | 8 | Yes |
 | `c_ulong` | `unsigned long` / `uint64_t` | 8 | No |
 | `c_char` | `char` | 1 | — |
+| `c_float` | `float` | 4 | — |
+| `c_double` | `double` | 8 | — |
 | `c_str` | `char[]` | variable | — |
 
 ## Usage
@@ -56,6 +58,29 @@ x = c_int.from_bytes(b"\x2a\x00\x00\x00")
 print(x.value)  # 42
 ```
 
+## Floating-Point Types
+
+`c_float` and `c_double` represent IEEE 754 single-precision (32-bit) and double-precision (64-bit) floating-point numbers.
+
+```python
+import struct as pystruct
+from libdestruct import c_float, c_double, inflater
+
+# Read a float from bytes
+data = pystruct.pack("<f", 3.14)
+f = c_float.from_bytes(data)
+print(f.value)   # 3.140000104904175
+print(float(f))  # same — c_float supports the __float__ protocol
+
+# Write a double to mutable memory
+memory = bytearray(8)
+lib = inflater(memory)
+d = lib.inflate(c_double, 0)
+d.value = 2.718281828
+```
+
+Both types support special values like `NaN`, `inf`, and `-inf`, and respect endianness settings.
+
 ## Strings
 
 `c_str` represents a null-terminated C string. It behaves like an array of characters:

libdestruct/__init__.py

@@ -12,7 +12,7 @@
     pass
 
 from libdestruct.backing.resolver import Resolver
-from libdestruct.c import c_int, c_long, c_str, c_uint, c_ulong
+from libdestruct.c import c_double, c_float, c_int, c_long, c_str, c_uint, c_ulong
 from libdestruct.common.array import array, array_of
 from libdestruct.common.attributes import offset
 from libdestruct.common.bitfield import bitfield_of
@@ -26,6 +26,8 @@
     "array",
     "array_of",
     "bitfield_of",
+    "c_double",
+    "c_float",
     "c_int",
     "c_long",
     "c_str",

libdestruct/c/__init__.py

@@ -4,10 +4,14 @@
 # Licensed under the MIT license. See LICENSE file in the project root for details.
 #
 
+from libdestruct.c.c_float_types import c_double, c_float
 from libdestruct.c.c_integer_types import c_char, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort
 from libdestruct.c.c_str import c_str
 
-__all__ = ["c_char", "c_int", "c_long", "c_short", "c_str", "c_uchar", "c_uint", "c_ulong", "c_ushort"]
+__all__ = [
+    "c_char", "c_double", "c_float", "c_int", "c_long", "c_short",
+    "c_str", "c_uchar", "c_uint", "c_ulong", "c_ushort",
+]
 
 import libdestruct.c.base_type_inflater
 import libdestruct.c.ctypes_generic_field  # noqa: F401

libdestruct/c/base_type_inflater.py

@@ -6,6 +6,7 @@
 
 from __future__ import annotations
 
+from libdestruct.c.c_float_types import c_double, c_float
 from libdestruct.c.c_integer_types import _c_integer, c_char, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort
 from libdestruct.c.c_str import c_str
 from libdestruct.common.type_registry import TypeRegistry
@@ -22,4 +23,6 @@
 registry.register_mapping(c_uint, c_uint)
 registry.register_mapping(c_long, c_long)
 registry.register_mapping(c_ulong, c_ulong)
+registry.register_mapping(c_float, c_float)
+registry.register_mapping(c_double, c_double)
 registry.register_mapping(c_str, c_str)

libdestruct/c/c_float_types.py

@@ -0,0 +1,73 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2026 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+from __future__ import annotations
+
+import struct
+
+from libdestruct.common.obj import obj
+
+
+class c_float(obj):
+    """A C float (IEEE 754 single-precision, 32-bit)."""
+
+    size: int = 4
+    """The size of a float in bytes."""
+
+    _frozen_value: float | None = None
+    """The frozen value of the float."""
+
+    def _format_char(self: c_float) -> str:
+        return "<f" if self.endianness == "little" else ">f"
+
+    def get(self: c_float) -> float:
+        """Return the value of the float."""
+        return struct.unpack(self._format_char(), self.resolver.resolve(self.size, 0))[0]
+
+    def _set(self: c_float, value: float) -> None:
+        """Set the value of the float."""
+        self.resolver.modify(self.size, 0, struct.pack(self._format_char(), value))
+
+    def to_bytes(self: c_float) -> bytes:
+        """Return the serialized representation of the float."""
+        if self._frozen:
+            return struct.pack(self._format_char(), self._frozen_value)
+        return self.resolver.resolve(self.size, 0)
+
+    def __float__(self: c_float) -> float:
+        """Return the value as a Python float."""
+        return self.get()
+
+
+class c_double(obj):
+    """A C double (IEEE 754 double-precision, 64-bit)."""
+
+    size: int = 8
+    """The size of a double in bytes."""
+
+    _frozen_value: float | None = None
+    """The frozen value of the double."""
+
+    def _format_char(self: c_double) -> str:
+        return "<d" if self.endianness == "little" else ">d"
+
+    def get(self: c_double) -> float:
+        """Return the value of the double."""
+        return struct.unpack(self._format_char(), self.resolver.resolve(self.size, 0))[0]
+
+    def _set(self: c_double, value: float) -> None:
+        """Set the value of the double."""
+        self.resolver.modify(self.size, 0, struct.pack(self._format_char(), value))
+
+    def to_bytes(self: c_double) -> bytes:
+        """Return the serialized representation of the double."""
+        if self._frozen:
+            return struct.pack(self._format_char(), self._frozen_value)
+        return self.resolver.resolve(self.size, 0)
+
+    def __float__(self: c_double) -> float:
+        """Return the value as a Python float."""
+        return self.get()

libdestruct/c/struct_parser.py

@@ -14,6 +14,7 @@
 
 from pycparser import c_ast, c_parser
 
+from libdestruct.c.c_float_types import c_double, c_float
 from libdestruct.c.c_integer_types import c_char, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort
 from libdestruct.common.array.array_of import array_of
 from libdestruct.common.bitfield.bitfield_of import bitfield_of
@@ -253,6 +254,11 @@ def identifier_to_type(identifier: c_ast.IdentifierType) -> type[obj]:
 
     identifier_name = "".join(identifier.names)
 
+    # Native float/double types (before ctypes fallback, so we get libdestruct types)
+    native_float_types = {"float": c_float, "double": c_double}
+    if identifier_name in native_float_types:
+        return native_float_types[identifier_name]
+
     ctypes_name = "c_" + identifier_name
 
     if hasattr(ctypes, ctypes_name):