Add support for enums and attributes

src/cfile/core.py

@@ -136,7 +136,7 @@ class DataType(Element):
     """
     Base class for all data types
     """
-    def __init__(self, name: str | None) -> None:
+    def __init__(self, name: str = "") -> None:
         self.name = name
 
 
@@ -150,7 +150,7 @@ def __init__(self,
                  pointer: bool = False,
                  volatile: bool = False,
                  array: int | None = None) -> None:  # Only used for typedefs to other array types
-        super().__init__(None)
+        super().__init__("")
         self.base_type = base_type
         self.const = const
         self.volatile = volatile
@@ -168,6 +168,45 @@ def qualifier(self, name) -> bool:
         else:
             raise KeyError(name)
 
+class EnumMember(Element):
+    """
+    Enum element.
+    """
+
+    def __init__(self,
+                 name: str,
+                 value: int | None) -> None:
+        self.name = name
+        self.value = value
+
+
+class Enum(DataType):
+    """
+    A enum definition
+    """
+
+    def __init__(self, name: str, members: list[EnumMember] = [], attributes: list[str] = []) -> None:
+        super().__init__(name)
+        if isinstance(members, list):
+            self.members: list[EnumMember] = members.copy()
+            enumValue = -1
+            for enum in self.members:
+                if enum.value == None:
+                    enumValue += 1
+                    enum.value = enumValue
+                else:
+                    enumValue = enum.value
+        else:
+            raise TypeError('Invalid argument type for "elements"')
+        self.attributes = attributes.copy()
+
+    def append(self, member: EnumMember) -> None:
+        """
+        Appends new element to the struct definition
+        """
+        if not isinstance(member, EnumMember):
+            raise TypeError(f'Invalid type, expected "EnumMember", got {str(type(member))}')
+        self.members.append(member)
 
 class StructMember(Element):
     """
@@ -197,17 +236,13 @@ class Struct(DataType):
     """
     A struct definition
     """
-    def __init__(self, name: str | None, members: StructMember | list[StructMember] | None = None) -> None:
+    def __init__(self, name: str = "", members: list[StructMember] = [], attributes: list[str] = []) -> None:
         super().__init__(name)
-        self.members: list[StructMember] = []
-        if members is not None:
-            if isinstance(members, StructMember):
-                self.append(members)
-            elif isinstance(members, list):
-                for member in members:
-                    self.append(member)
-            else:
-                raise TypeError('Invalid argument type for "elements"')
+        if isinstance(members, list):
+            self.members: list[StructMember] = members.copy()
+        else:
+            raise TypeError('Invalid argument type for "elements"')
+        self.attributes = attributes.copy()
 
     def append(self, member: StructMember) -> None:
         """
@@ -322,7 +357,7 @@ def __init__(self,
                  static: bool = False,
                  const: bool = False,  # const function (as seen in C++)
                  extern: bool = False,
-                 params: Variable | list[Variable] | None = None) -> None:
+                 params: list[Variable] = []) -> None:
         self.name = name
         self.static = static
         self.const = const
@@ -335,13 +370,7 @@ def __init__(self,
             self.return_type = Type("void")
         else:
             raise TypeError(str(type(return_type)))
-        self.params: list[Variable] = []
-        if params is not None:
-            if isinstance(params, Variable):
-                self.append(params)
-            elif isinstance(params, list):
-                for param in params:
-                    self.append(param)
+        self.params = params.copy()
 
     def append(self, param: Variable) -> "Function":
         """
@@ -511,3 +540,22 @@ class Block(Sequence):
     """
     A sequence wrapped in braces
     """
+
+
+class ConditionType(Enum):
+    IF = 0
+    ELSE_IF = 1
+    ELSE = 2
+
+
+class Condition(Block):
+    """
+    A condition wrapped in braces
+    """
+    def __init__(self, condition: str = "", type: ConditionType = ConditionType.ELSE):
+        super().__init__()
+        self.condition = condition
+        self.type = type
+
+        if (condition and type == ConditionType.ELSE) or (not condition and type != ConditionType.ELSE):
+            raise Exception("Condition and type didn't match")

src/cfile/factory.py

@@ -120,7 +120,7 @@ def function(self,
                  static: bool = False,
                  const: bool = False,  # This is not const of the return type
                  extern: bool = False,
-                 params: core.Variable | list[core.Variable] | None = None) -> core.Function:
+                 params: list[core.Variable] = []) -> core.Function:
         """
         New function
         """
@@ -137,6 +137,23 @@ def type(self,
         """
         return core.Type(type_ref, const, pointer, volatile, array)
 
+    def enum_member(self,
+                    name: str,
+                    value: int | None = None):
+        """
+        New EnumMember
+        """
+        return core.EnumMember(name, value)
+
+    def enum(self,
+             name: str,
+             members: list[core.EnumMember] = [],
+             attributes: list[str] = []):
+        """
+        New Enum
+        """
+        return core.Enum(name, members, attributes)
+
     def struct_member(self,
                       name: str,
                       data_type: str | core.Type | core.Struct,
@@ -150,12 +167,13 @@ def struct_member(self,
 
     def struct(self,
                name: str,
-               members: core.StructMember | list[core.StructMember] | None = None
+               members: list[core.StructMember] = [],
+               attributes: list[str] = []
                ) -> core.Struct:
         """
         New Struct
         """
-        return core.Struct(name, members)
+        return core.Struct(name, members, attributes)
 
     def variable(self,
                  name: str,
@@ -224,6 +242,13 @@ def func_return(self, expression: int | float | str | core.Element) -> core.Func
     def declaration(self,
                     element: Union[core.Variable, core.Function, core.DataType],
                     init_value: Any | None = None) -> core.Declaration:
-
-        """New declaration"""
+        """
+        New declaration
+        """
         return core.Declaration(element, init_value)
+
+    def condition(self, condition:str, type:core.ConditionType):
+        """
+        New condition
+        """
+        return core.Condition(condition, type)