Minimal handling of types and subtypes.

4 files changed, 93 insertions, 22 deletions

diff --git a/pyGHDL/dom/Symbol.py b/pyGHDL/dom/Symbol.py
index c82c39729..047fd624f 100644
--- a/pyGHDL/dom/Symbol.py
+++ b/pyGHDL/dom/Symbol.py
@@ -30,15 +30,9 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 # ============================================================================
-from pyGHDL.dom.Common import DOMException
-from pyGHDL.libghdl import utils
-
-from pyGHDL.libghdl.vhdl import nodes
-from pydecor import export
-
 from typing import List
+from pydecor import export
 
-from pyGHDL.dom._Utils import GetNameOfNode, GetIirKindOfNode
 from pyVHDLModel.VHDLModel import (
     EntitySymbol as VHDLModel_EntitySymbol,
     SimpleSubTypeSymbol as VHDLModel_SimpleSubTypeSymbol,
@@ -49,6 +43,11 @@ from pyVHDLModel.VHDLModel import (
     Constraint,
 )
 
+from pyGHDL.libghdl import utils
+from pyGHDL.libghdl.vhdl import nodes
+from pyGHDL.dom._Utils import GetIirKindOfNode, GetNameOfNode
+from pyGHDL.dom.Common import DOMException
+
 __all__ = []
 
 
@@ -94,21 +93,29 @@ class SimpleObjectOrFunctionCallSymbol(VHDLModel_SimpleObjectOrFunctionCallSymbo
 
 @export
 class IndexedObjectOrFunctionCallSymbol(VHDLModel_IndexedObjectOrFunctionCallSymbol):
+    def __init__(self, name: str, associations: List):
+        super().__init__(objectName=name)
+
     @classmethod
     def parse(cls, node):
+        from pyGHDL.dom._Translate import GetExpressionFromNode
+
         prefix = nodes.Get_Prefix(node)
         name = GetNameOfNode(prefix)
 
+        associations = []
         for item in utils.chain_iter(nodes.Get_Association_Chain(node)):
             kind = GetIirKindOfNode(item)
 
             if kind == nodes.Iir_Kind.Association_Element_By_Expression:
-                pass
+                expr = None  # GetExpressionFromNode(nodes.Get_Associated_Expr(item))
+
+                associations.append(expr)
             else:
                 raise DOMException(
-                    "Unknown association kind '{kindName}'({kind}) in array index or function call '{node}'.".format(
+                    "Unknown association kind '{kindName}'({kind}) in array index/slice or function call '{node}'.".format(
                         kind=kind, kindName=kind.name, node=node
                     )
                 )
 
-        return cls(name)
+        return cls(name, associations)
diff --git a/pyGHDL/dom/Type.py b/pyGHDL/dom/Type.py
new file mode 100644
index 000000000..df143b4d0
--- /dev/null
+++ b/pyGHDL/dom/Type.py
@@ -0,0 +1,21 @@
+from pydecor import export
+
+from pyVHDLModel.VHDLModel import (
+    IntegerType as VHDLModel_IntegerType,
+    SubType as VHDLModel_SubType,
+    Expression,
+)
+
+
+@export
+class IntegerType(VHDLModel_IntegerType):
+    def __init__(self, typeName: str, leftBound: Expression, rightBound: Expression):
+        super().__init__(typeName)
+        self._leftBound = leftBound
+        self._rightBound = rightBound
+
+
+@export
+class SubType(VHDLModel_SubType):
+    def __init__(self, subtypeName: str):
+        super().__init__(subtypeName)
diff --git a/pyGHDL/dom/_Translate.py b/pyGHDL/dom/_Translate.py
index af6e5420f..cd2a3e53e 100644
--- a/pyGHDL/dom/_Translate.py
+++ b/pyGHDL/dom/_Translate.py
@@ -33,9 +33,18 @@
 from typing import List
 
 from pydecor import export
-from pyVHDLModel.VHDLModel import Constraint, Direction, Expression, SubTypeOrSymbol
+
+from pyGHDL.dom.Type import IntegerType, SubType
+from pyVHDLModel.VHDLModel import (
+    Constraint,
+    Direction,
+    Expression,
+    SubTypeOrSymbol,
+    BaseType,
+)
 
 from pyGHDL.libghdl import utils
+from pyGHDL.libghdl._types import Iir
 from pyGHDL.libghdl.utils import flist_iter
 from pyGHDL.libghdl.vhdl import nodes
 from pyGHDL.dom._Utils import GetNameOfNode, GetIirKindOfNode
@@ -91,7 +100,7 @@ __all__ = []
 
 
 @export
-def GetSubtypeIndicationFromNode(node, entity: str, name: str) -> SubTypeOrSymbol:
+def GetSubtypeIndicationFromNode(node: Iir, entity: str, name: str) -> SubTypeOrSymbol:
     subTypeIndication = nodes.Get_Subtype_Indication(node)
     if subTypeIndication is nodes.Null_Iir:
         return None
@@ -124,7 +133,9 @@ def GetSubtypeIndicationFromNode(node, entity: str, name: str) -> SubTypeOrSymbo
 
 
 @export
-def GetArrayConstraintsFromSubtypeIndication(subTypeIndication) -> List[Constraint]:
+def GetArrayConstraintsFromSubtypeIndication(
+    subTypeIndication: Iir,
+) -> List[Constraint]:
     constraints = []
     for constraint in flist_iter(nodes.Get_Index_Constraint_List(subTypeIndication)):
         constraintKind = GetIirKindOfNode(constraint)
@@ -147,7 +158,23 @@ def GetArrayConstraintsFromSubtypeIndication(subTypeIndication) -> List[Constrai
 
 
 @export
-def GetRangeFromNode(node) -> Range:
+def GetTypeFromNode(node: Iir) -> BaseType:
+    typeName = GetNameOfNode(node)
+    leftBound = IntegerLiteral(0)
+    rightBound = IntegerLiteral(15)
+
+    return IntegerType(typeName, leftBound, rightBound)
+
+
+@export
+def GetSubTypeFromNode(node: Iir) -> BaseType:
+    subTypeName = GetNameOfNode(node)
+
+    return SubType(subTypeName)
+
+
+@export
+def GetRangeFromNode(node: Iir) -> Range:
     direction = nodes.Get_Direction(node)
     leftBound = nodes.Get_Left_Limit_Expr(node)
     rightBound = nodes.Get_Right_Limit_Expr(node)
@@ -201,7 +228,7 @@ __EXPRESSION_TRANSLATION = {
 
 
 @export
-def GetExpressionFromNode(node) -> Expression:
+def GetExpressionFromNode(node: Iir) -> Expression:
     kind = GetIirKindOfNode(node)
 
     try:
@@ -218,7 +245,7 @@ def GetExpressionFromNode(node) -> Expression:
 
 # FIXME: rewrite to generator
 @export
-def GetGenericsFromChainedNodes(nodeChain):
+def GetGenericsFromChainedNodes(nodeChain: Iir):
     result = []
     for generic in utils.chain_iter(nodeChain):
         kind = GetIirKindOfNode(generic)
@@ -240,7 +267,7 @@ def GetGenericsFromChainedNodes(nodeChain):
 
 # FIXME: rewrite to generator
 @export
-def GetPortsFromChainedNodes(nodeChain):
+def GetPortsFromChainedNodes(nodeChain: Iir):
     result = []
     for port in utils.chain_iter(nodeChain):
         kind = GetIirKindOfNode(port)
@@ -260,7 +287,7 @@ def GetPortsFromChainedNodes(nodeChain):
     return result
 
 
-def GetDeclaredItemsFromChainedNodes(nodeChain, entity: str, name: str):
+def GetDeclaredItemsFromChainedNodes(nodeChain: Iir, entity: str, name: str):
     result = []
     for item in utils.chain_iter(nodeChain):
         kind = GetIirKindOfNode(item)
@@ -273,11 +300,9 @@ def GetDeclaredItemsFromChainedNodes(nodeChain, entity: str, name: str):
 
             result.append(Signal.parse(item))
         elif kind == nodes.Iir_Kind.Anonymous_Type_Declaration:
-            typeName = GetNameOfNode(item)
-            print("found type '{name}'".format(name=typeName))
+            result.append(GetTypeFromNode(item))
         elif kind == nodes.Iir_Kind.Subtype_Declaration:
-            subTypeName = GetNameOfNode(item)
-            print("found subtype '{name}'".format(name=subTypeName))
+            result.append(GetSubTypeFromNode(item))
         elif kind == nodes.Iir_Kind.Function_Declaration:
             functionName = GetNameOfNode(item)
             print("found function '{name}'".format(name=functionName))
diff --git a/pyGHDL/dom/formatting/prettyprint.py b/pyGHDL/dom/formatting/prettyprint.py
index 1577edca0..8f95a412e 100644
--- a/pyGHDL/dom/formatting/prettyprint.py
+++ b/pyGHDL/dom/formatting/prettyprint.py
@@ -2,6 +2,7 @@ from typing import List, Union
 
 from pydecor import export
 
+from pyGHDL.dom.Type import IntegerType, SubType
 from pyVHDLModel.VHDLModel import (
     GenericInterfaceItem,
     NamedEntity,
@@ -293,6 +294,23 @@ class PrettyPrint:
                     else "",
                 )
             )
+        elif isinstance(item, IntegerType):
+            buffer.append(
+                "{prefix}- type {name} is range {range}".format(
+                    prefix=prefix,
+                    name=item.Name,
+                    range="{left!s} to {right!s}".format(
+                        left=item.LeftBound, right=item.RightBound
+                    ),
+                )
+            )
+        elif isinstance(item, SubType):
+            buffer.append(
+                "{prefix}- subtype {name} is ?????".format(
+                    prefix=prefix,
+                    name=item.Name,
+                )
+            )
         else:
             raise PrettyPrintException("Unhandled declared item kind.")