cstruct.native_types and get_type added

Author: andreax79

cstruct/__init__.py

@@ -27,23 +27,23 @@
 __version__ = '4.0'
 __date__ = '15 August 2013'
 
-import struct
 from typing import Any, Dict, Optional, Type, Union
 from .base import (
     LITTLE_ENDIAN,
     BIG_ENDIAN,
     NATIVE_ORDER,
     STRUCTS,
+    ENUMS,
     DEFINES,
     TYPEDEFS,
-    C_TYPE_TO_FORMAT,
     CHAR_ZERO,
 )
 from .abstract import CStructMeta, AbstractCStruct, AbstractCEnum
 from .cstruct import CStruct
 from .c_parser import parse_struct_def
 from .mem_cstruct import MemCStruct
 from .cenum import CEnum
+from .native_types import get_native_type
 
 __all__ = [
     'LITTLE_ENDIAN',
@@ -57,6 +57,7 @@
     'undef',
     'getdef',
     'typedef',
+    'get_type',
     'sizeof',
     'parse',
 ]
@@ -104,33 +105,62 @@ def typedef(type_: str, alias: str) -> None:
     TYPEDEFS[alias] = type_
 
 
-def sizeof(type_: str) -> int:
+def get_type(type_: str) -> Any:
     """
-    Return the size of the type.
+    Get a data type (struct, union, enum) by name
+
+    Examples:
+        >>> get_type("struct Position")
+        <class 'abc.Position'>
+        >>> get_type("enum htmlfont")
+        <enum 'htmlfont'>
 
     Args:
-        type_: C type, struct or union (e.g. 'short int' or 'struct ZYZ')
+        type_: C type, struct or union (e.g. 'short int' or 'struct ZYZ'), enum or native type
 
     Returns:
-        size: size in bytes
+        class: data type class
     """
     while type_ in TYPEDEFS:
         type_ = TYPEDEFS[type_]
     if isinstance(type_, CStructMeta):
-        return len(type_)
+        return type_
     elif type_.startswith('struct ') or type_.startswith('union '):
         kind, type_ = type_.split(' ', 1)
-        t = STRUCTS.get(type_, None)
-        if t is None:
-            raise KeyError("Unknow %s \"%s\"" % (kind, type_))
-        else:
-            return t.sizeof()
+        try:
+            return STRUCTS[type_]
+        except KeyError:
+            raise KeyError(f"Unknown {kind} `{type_}`")
+    elif type_.startswith('enum '):
+        kind, type_ = type_.split(' ', 1)
+        try:
+            return ENUMS[type_]
+        except KeyError:
+            raise KeyError(f"Unknown {kind} `{type_}`")
     else:
-        ttype = C_TYPE_TO_FORMAT.get(type_, None)
-        if ttype is None:
-            raise KeyError("Unknow type \"" + type_ + "\"")
-        else:
-            return struct.calcsize(ttype)
+        return get_native_type(type_)
+
+
+def sizeof(type_: str) -> int:
+    """
+    Return the size of the type.
+
+    Examples:
+        >>> sizeof("struct Position")
+        16
+        >>> sizeof("int")
+        4
+
+    Args:
+        type_: C type, struct or union (e.g. 'short int' or 'struct ZYZ'), enum or native type
+
+    Returns:
+        size: size in bytes
+    """
+    while type_ in TYPEDEFS:
+        type_ = TYPEDEFS[type_]
+    data_type = get_type(type_)
+    return data_type.sizeof()
 
 
 def parse(

cstruct/base.py

@@ -35,8 +35,8 @@
     'STRUCTS',
     'DEFINES',
     'TYPEDEFS',
-    'C_TYPE_TO_FORMAT',
     'CHAR_ZERO',
+    'DEFAULT_ENUM_SIZE',
 ]
 
 LITTLE_ENDIAN = '<'
@@ -68,32 +68,8 @@
     'uint64_t': 'uint64',
 }
 
-C_TYPE_TO_FORMAT: Dict[str, str] = {
-    'char': 's',
-    'signed char': 'b',
-    'unsigned char': 'B',
-    'short': 'h',
-    'unsigned short': 'H',
-    'int': 'i',
-    'unsigned int': 'I',
-    'long': 'l',
-    'unsigned long': 'L',
-    'long long': 'q',
-    'unsigned long long': 'Q',
-    'float': 'f',
-    'double': 'd',
-    'void *': 'P',
-    'int8': 'b',
-    'uint8': 'B',
-    'int16': 'h',
-    'uint16': 'H',
-    'int32': 'i',
-    'uint32': 'I',
-    'int64': 'q',
-    'uint64': 'Q',
-}
-
 ENUM_SIZE_TO_C_TYPE: Dict[int, str] = {1: 'int8', 2: 'int16', 4: 'int32', 8: 'int64'}
 
 CHAR_ZERO = bytes('\0', 'ascii')
+
 DEFAULT_ENUM_SIZE = 4

cstruct/field.py

@@ -26,7 +26,8 @@
 import struct
 from enum import Enum
 from typing import Optional, Any, List, Type, TYPE_CHECKING
-from .base import NATIVE_ORDER, C_TYPE_TO_FORMAT, ENUM_SIZE_TO_C_TYPE
+from .base import NATIVE_ORDER, ENUM_SIZE_TO_C_TYPE
+from .native_types import get_native_type
 from .exceptions import ParserError
 
 if TYPE_CHECKING:
@@ -188,12 +189,12 @@ def native_format(self) -> str:
         "Field format (struct library format)"
         if self.is_native:
             try:
-                return C_TYPE_TO_FORMAT[self.c_type]
+                return get_native_type(self.c_type).native_format
             except KeyError:
-                raise ParserError("Unknow type {}".format(self.c_type))
+                raise ParserError(f"Unknow type `{self.c_type}`")
         elif self.is_enum:
             try:
-                return C_TYPE_TO_FORMAT[ENUM_SIZE_TO_C_TYPE[self.ref.size]]
+                return get_native_type(ENUM_SIZE_TO_C_TYPE[self.ref.size]).native_format
             except KeyError:
                 raise ParserError(f"Enum has invalid size. Needs to be in {ENUM_SIZE_TO_C_TYPE.keys()}")
         else: