Merge pull request #1798 from Paebbels/paebbels/aggregates

Python-C/Ada Bindings - Updated decorator

8 files changed, 290 insertions, 159 deletions

diff --git a/pyGHDL/dom/Aggregates.py b/pyGHDL/dom/Aggregates.py
new file mode 100644
index 000000000..ac8ecbca8
--- /dev/null
+++ b/pyGHDL/dom/Aggregates.py
@@ -0,0 +1,94 @@
+# =============================================================================
+#               ____ _   _ ____  _          _
+#  _ __  _   _ / ___| | | |  _ \| |      __| | ___  _ __ ___
+# | '_ \| | | | |  _| |_| | | | | |     / _` |/ _ \| '_ ` _ \
+# | |_) | |_| | |_| |  _  | |_| | |___ | (_| | (_) | | | | | |
+# | .__/ \__, |\____|_| |_|____/|_____(_)__,_|\___/|_| |_| |_|
+# |_|    |___/
+# =============================================================================
+# Authors:
+#   Patrick Lehmann
+#
+# Package module:   DOM: VHDL design units (e.g. context or package).
+#
+# License:
+# ============================================================================
+#  Copyright (C) 2019-2021 Tristan Gingold
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <gnu.org/licenses>.
+#
+# SPDX-License-Identifier: GPL-2.0-or-later
+# ============================================================================
+
+"""
+This module contains all DOM classes for VHDL's design units (:class:`context <Entity>`,
+:class:`architecture <Architecture>`, :class:`package <Package>`,
+:class:`package body <PackageBody>`, :class:`context <Context>` and
+:class:`configuration <Configuration>`.
+
+
+"""
+from pydecor import export
+
+from pyGHDL.dom.Range import Range
+from pyGHDL.dom.Symbol import EnumerationLiteralSymbol
+from pyVHDLModel.VHDLModel import (
+    SimpleAggregateElement as VHDLModel_SimpleAggregateElement,
+    IndexedAggregateElement as VHDLModel_IndexedAggregateElement,
+    RangedAggregateElement as VHDLModel_RangedAggregateElement,
+    NamedAggregateElement as VHDLModel_NamedAggregateElement,
+    OthersAggregateElement as VHDLModel_OthersAggregateElement,
+    Expression,
+)
+
+
+__all__ = []
+
+
+@export
+class SimpleAggregateElement(VHDLModel_SimpleAggregateElement):
+    def __init__(self, expression: Expression):
+        super().__init__()
+        self._expression = expression
+
+
+@export
+class IndexedAggregateElement(VHDLModel_IndexedAggregateElement):
+    def __init__(self, index: Expression, expression: Expression):
+        super().__init__()
+        self._index = index
+        self._expression = expression
+
+
+@export
+class RangedAggregateElement(VHDLModel_RangedAggregateElement):
+    def __init__(self, r: Range, expression: Expression):
+        super().__init__()
+        self._range = r
+        self._expression = expression
+
+
+@export
+class NamedAggregateElement(VHDLModel_NamedAggregateElement):
+    def __init__(self, name: EnumerationLiteralSymbol, expression: Expression):
+        super().__init__()
+        self._name = name
+        self._expression = expression
+
+
+@export
+class OthersAggregateElement(VHDLModel_OthersAggregateElement):
+    def __init__(self, expression: Expression):
+        super().__init__()
+        self._expression = expression
diff --git a/pyGHDL/dom/DesignUnit.py b/pyGHDL/dom/DesignUnit.py
index 3619c47c5..534149677 100644
--- a/pyGHDL/dom/DesignUnit.py
+++ b/pyGHDL/dom/DesignUnit.py
@@ -41,7 +41,8 @@ This module contains all DOM classes for VHDL's design units (:class:`context <E
 """
 from pydecor import export
 
-from pyVHDLModel.VHDLModel import Entity as VHDLModel_Entity
+from pyGHDL.dom.Symbol import EntitySymbol
+from pyVHDLModel.VHDLModel import Entity as VHDLModel_Entity, EntityOrSymbol
 from pyVHDLModel.VHDLModel import Architecture as VHDLModel_Architecture
 from pyVHDLModel.VHDLModel import Package as VHDLModel_Package
 from pyVHDLModel.VHDLModel import PackageBody as VHDLModel_PackageBody
@@ -87,17 +88,18 @@ class Entity(VHDLModel_Entity, GHDLMixin):
 
 @export
 class Architecture(VHDLModel_Architecture, GHDLMixin):
-    def __init__(self, name: str, entityName: str):
+    def __init__(self, name: str, entity: EntityOrSymbol):
         super().__init__(name)
 
-        self.__entityName = entityName
+        self._entity = entity
 
     @classmethod
     def parse(cls, libraryUnit):
         name = NodeToName(libraryUnit)
         entityName = NodeToName(nodes.Get_Entity_Name(libraryUnit))
+        entity = EntitySymbol(entityName)
 
-        architecture = cls(name, entityName)
+        architecture = cls(name, entity)
 
         for item in GetDeclaredItemsFromChainedNodes(
             nodes.Get_Declaration_Chain(libraryUnit), "architecture", name
diff --git a/pyGHDL/dom/Expression.py b/pyGHDL/dom/Expression.py
index 80ef2823c..fec347b57 100644
--- a/pyGHDL/dom/Expression.py
+++ b/pyGHDL/dom/Expression.py
@@ -30,6 +30,20 @@
 #
 # SPDX-License-Identifier: GPL-2.0-or-later
 # ============================================================================
+from typing import List
+
+from pyGHDL.dom.Aggregates import (
+    OthersAggregateElement,
+    SimpleAggregateElement,
+    RangedAggregateElement,
+    IndexedAggregateElement,
+    NamedAggregateElement,
+)
+from pyGHDL.dom.Symbol import EnumerationLiteralSymbol
+from pyGHDL.libghdl import utils
+
+from pyGHDL.dom.Common import DOMException
+from pyGHDL.dom._Utils import GetIirKindOfNode
 from pyGHDL.libghdl.vhdl import nodes
 from pydecor import export
 
@@ -38,6 +52,7 @@ from pyVHDLModel.VHDLModel import (
     IdentityExpression as VHDLModel_IdentityExpression,
     NegationExpression as VHDLModel_NegationExpression,
     AbsoluteExpression as VHDLModel_AbsoluteExpression,
+    ParenthesisExpression as VHDLModel_ParenthesisExpression,
     TypeConversion as VHDLModel_TypeConversion,
     FunctionCall as VHDLModel_FunctionCall,
     QualifiedExpression as VHDLModel_QualifiedExpression,
@@ -66,7 +81,9 @@ from pyVHDLModel.VHDLModel import (
     ShiftLeftArithmeticExpression as VHDLModel_ShiftLeftArithmeticExpression,
     RotateRightExpression as VHDLModel_RotateRightExpression,
     RotateLeftExpression as VHDLModel_RotateLeftExpression,
+    Aggregate as VHDLModel_Aggregate,
     Expression,
+    AggregateElement,
 )
 
 __all__ = []
@@ -120,6 +137,20 @@ class AbsoluteExpression(VHDLModel_AbsoluteExpression, _ParseUnaryExpression):
 
 
 @export
+class ParenthesisExpression(VHDLModel_ParenthesisExpression, _ParseUnaryExpression):
+    def __init__(self, operand: Expression):
+        super().__init__()
+        self._operand = operand
+
+    @classmethod
+    def parse(cls, node):
+        from pyGHDL.dom._Translate import GetExpressionFromNode
+
+        operand = GetExpressionFromNode(nodes.Get_Expression(node))
+        return cls(operand)
+
+
+@export
 class TypeConversion(VHDLModel_TypeConversion):
     def __init__(self, operand: Expression):
         super().__init__()
@@ -350,3 +381,46 @@ class RotateLeftExpression(VHDLModel_RotateLeftExpression, _ParseBinaryExpressio
         super().__init__()
         self._leftOperand = left
         self._rightOperand = right
+
+
+@export
+class Aggregate(VHDLModel_Aggregate):
+    def __init__(self, elements: List[AggregateElement]):
+        super().__init__()
+        self._elements = elements
+
+    @classmethod
+    def parse(cls, node):
+        from pyGHDL.dom._Translate import GetExpressionFromNode
+
+        choices = []
+
+        choicesChain = nodes.Get_Association_Choices_Chain(node)
+        for item in utils.chain_iter(choicesChain):
+            kind = GetIirKindOfNode(item)
+            if kind == nodes.Iir_Kind.Choice_By_None:
+                value = GetExpressionFromNode(nodes.Get_Associated_Expr(item))
+                choices.append(SimpleAggregateElement(value))
+            elif kind == nodes.Iir_Kind.Choice_By_Expression:
+                index = GetExpressionFromNode(nodes.Get_Choice_Expression(item))
+                value = GetExpressionFromNode(nodes.Get_Associated_Expr(item))
+                choices.append(IndexedAggregateElement(index, value))
+            elif kind == nodes.Iir_Kind.Choice_By_Range:
+                r = GetExpressionFromNode(nodes.Get_Choice_Range(item))
+                value = GetExpressionFromNode(nodes.Get_Associated_Expr(item))
+                choices.append(RangedAggregateElement(r, value))
+            elif kind == nodes.Iir_Kind.Choice_By_Name:
+                name = EnumerationLiteralSymbol(nodes.Get_Choice_Name(item))
+                value = GetExpressionFromNode(nodes.Get_Associated_Expr(item))
+                choices.append(NamedAggregateElement(name, value))
+            elif kind == nodes.Iir_Kind.Choice_By_Others:
+                expression = None
+                choices.append(OthersAggregateElement(expression))
+            else:
+                raise DOMException(
+                    "Unknown choice kind '{kindName}'({kind}) in aggregate '{aggr}'.".format(
+                        kind=kind, kindName=kind.name, aggr=node
+                    )
+                )
+
+        return cls(choices)
diff --git a/pyGHDL/dom/Literal.py b/pyGHDL/dom/Literal.py
index 8b32d7163..7c722583b 100644
--- a/pyGHDL/dom/Literal.py
+++ b/pyGHDL/dom/Literal.py
@@ -57,7 +57,7 @@ class FloatingPointLiteral(VHDLModel_FloatingPointLiteral):
     @classmethod
     def parse(cls, node):
         value = nodes.Get_Fp_Value(node)
-        return cls(float(value))
+        return cls(value)
 
 
 @export
diff --git a/pyGHDL/dom/Misc.py b/pyGHDL/dom/Misc.py
index 6ef66fcf0..7bee2ec7b 100644
--- a/pyGHDL/dom/Misc.py
+++ b/pyGHDL/dom/Misc.py
@@ -52,7 +52,7 @@ from pyGHDL.libghdl import (
     LibGHDLException,
     utils,
 )
-from pyGHDL.libghdl.vhdl import nodes, sem_lib
+from pyGHDL.libghdl.vhdl import nodes, sem_lib, parse
 
 from pyGHDL.dom._Utils import GetIirKindOfNode
 from pyGHDL.dom.Common import DOMException, GHDLMixin
@@ -86,6 +86,8 @@ class Design(VHDLModel_Design):
 
         libghdl.set_option("--std=08")
 
+        parse.Flag_Parse_Parenthesis.value = True
+
         # Finish initialization. This will load the standard package.
         if libghdl.analyze_init_status() != 0:
             raise LibGHDLException("Error initializing 'libghdl'.")
diff --git a/pyGHDL/dom/Symbol.py b/pyGHDL/dom/Symbol.py
index c7b681595..020f9fbc7 100644
--- a/pyGHDL/dom/Symbol.py
+++ b/pyGHDL/dom/Symbol.py
@@ -36,8 +36,10 @@ from typing import List
 
 from pyGHDL.dom._Utils import NodeToName
 from pyVHDLModel.VHDLModel import (
+    EntitySymbol as VHDLModel_EntitySymbol,
     SimpleSubTypeSymbol as VHDLModel_SimpleSubTypeSymbol,
     ConstrainedSubTypeSymbol as VHDLModel_ConstrainedSubTypeSymbol,
+    EnumerationLiteralSymbol as VHDLModel_EnumerationLiteralSymbol,
     SimpleObjectSymbol as VHDLModel_SimpleObjectSymbol,
     Constraint,
 )
@@ -46,6 +48,18 @@ __all__ = []
 
 
 @export
+class EntitySymbol(VHDLModel_EntitySymbol):
+    def __init__(self, entityName: str):
+        super().__init__(entityName)
+
+
+@export
+class EnumerationLiteralSymbol(VHDLModel_EnumerationLiteralSymbol):
+    def __init__(self, literalName: str):
+        super().__init__(symbolName=literalName)
+
+
+@export
 class SimpleSubTypeSymbol(VHDLModel_SimpleSubTypeSymbol):
     def __init__(self, subTypeName: str):
         super().__init__(subTypeName=subTypeName)
@@ -67,9 +81,6 @@ class ConstrainedSubTypeSymbol(VHDLModel_ConstrainedSubTypeSymbol):
 
 @export
 class SimpleObjectSymbol(VHDLModel_SimpleObjectSymbol):
-    def __init__(self, symbolName: str):
-        super().__init__(symbolName)
-
     @classmethod
     def parse(cls, node):
         name = NodeToName(node)
diff --git a/pyGHDL/dom/_Translate.py b/pyGHDL/dom/_Translate.py
index 9eb4937ec..24f056f33 100644
--- a/pyGHDL/dom/_Translate.py
+++ b/pyGHDL/dom/_Translate.py
@@ -54,6 +54,9 @@ from pyGHDL.dom.Expression import (
     DivisionExpression,
     InverseExpression,
     ExponentiationExpression,
+    Aggregate,
+    NegationExpression,
+    ParenthesisExpression,
 )
 
 __all__ = []
@@ -129,13 +132,15 @@ __EXPRESSION_TRANSLATION = {
     nodes.Iir_Kind.Integer_Literal: IntegerLiteral,
     nodes.Iir_Kind.Floating_Point_Literal: FloatingPointLiteral,
     nodes.Iir_Kind.Character_Literal: CharacterLiteral,
-    nodes.Iir_Kind.Negation_Operator: InverseExpression,
+    nodes.Iir_Kind.Negation_Operator: NegationExpression,
     nodes.Iir_Kind.Addition_Operator: AdditionExpression,
+    nodes.Iir_Kind.Not_Operator: InverseExpression,
+    nodes.Iir_Kind.Parenthesis_Expression: ParenthesisExpression,
     nodes.Iir_Kind.Substraction_Operator: SubtractionExpression,
     nodes.Iir_Kind.Multiplication_Operator: MultiplyExpression,
     nodes.Iir_Kind.Division_Operator: DivisionExpression,
     nodes.Iir_Kind.Exponentiation_Operator: ExponentiationExpression,
-    #    nodes.Iir_Kind.Aggregate: Aggregate
+    nodes.Iir_Kind.Aggregate: Aggregate,
 }
 
 
diff --git a/pyGHDL/dom/formatting/prettyprint.py b/pyGHDL/dom/formatting/prettyprint.py
index 59fdd485b..1577edca0 100644
--- a/pyGHDL/dom/formatting/prettyprint.py
+++ b/pyGHDL/dom/formatting/prettyprint.py
@@ -2,22 +2,15 @@ from typing import List, Union
 
 from pydecor import export
 
-from pyGHDL.dom.Object import Constant, Signal
 from pyVHDLModel.VHDLModel import (
     GenericInterfaceItem,
-    Expression,
-    Direction,
-    Mode,
     NamedEntity,
     PortInterfaceItem,
-    BinaryExpression,
-    IdentityExpression,
-    UnaryExpression,
     WithDefaultExpression,
 )
 
 from pyGHDL import GHDLBaseException
-from pyGHDL.dom.Misc import Document
+from pyGHDL.dom.Misc import Document, Design, Library
 from pyGHDL.dom.DesignUnit import (
     Entity,
     Architecture,
@@ -26,6 +19,7 @@ from pyGHDL.dom.DesignUnit import (
     Configuration,
     Context,
 )
+from pyGHDL.dom.Object import Constant, Signal
 from pyGHDL.dom.InterfaceItem import (
     GenericConstantInterfaceItem,
     PortSignalInterfaceItem,
@@ -33,47 +27,10 @@ from pyGHDL.dom.InterfaceItem import (
 from pyGHDL.dom.Symbol import (
     SimpleSubTypeSymbol,
     ConstrainedSubTypeSymbol,
-    SimpleObjectSymbol,
-)
-from pyGHDL.dom.Literal import IntegerLiteral, CharacterLiteral, FloatingPointLiteral
-
-from pyGHDL.dom.Expression import (
-    SubtractionExpression,
-    AdditionExpression,
-    MultiplyExpression,
-    DivisionExpression,
-    InverseExpression,
-    AbsoluteExpression,
-    NegationExpression,
-    ExponentiationExpression,
 )
 
-StringBuffer = List[str]
-
-DirectionTranslation = {Direction.To: "to", Direction.DownTo: "downto"}
 
-ModeTranslation = {
-    Mode.In: "in",
-    Mode.Out: "out",
-    Mode.InOut: "inout",
-    Mode.Buffer: "buffer",
-    Mode.Linkage: "linkage",
-}
-
-UnaryExpressionTranslation = {
-    IdentityExpression: " +",
-    NegationExpression: " -",
-    InverseExpression: "not ",
-    AbsoluteExpression: "abs ",
-}
-
-BinaryExpressionTranslation = {
-    AdditionExpression: " + ",
-    SubtractionExpression: " - ",
-    MultiplyExpression: " * ",
-    DivisionExpression: " / ",
-    ExponentiationExpression: "**",
-}
+StringBuffer = List[str]
 
 
 @export
@@ -88,33 +45,77 @@ class PrettyPrint:
     # def __init__(self):
     #     self._buffer = []
 
+    def formatDesign(self, design: Design, level: int = 0) -> StringBuffer:
+        buffer = []
+        prefix = "  " * level
+        buffer.append("{prefix}Libraries:".format(prefix=prefix))
+        for library in design.Libraries:
+            for line in self.formatLibrary(library, level + 1):
+                buffer.append(line)
+        buffer.append("{prefix}Documents:".format(prefix=prefix))
+        for document in design.Documents:
+            buffer.append(
+                "{prefix}- Path: '{doc!s}':".format(doc=document.Path, prefix=prefix)
+            )
+            for line in self.formatDocument(document, level + 1):
+                buffer.append(line)
+
+        return buffer
+
+    def formatLibrary(self, library: Library, level: int = 0) -> StringBuffer:
+        buffer = []
+        prefix = "  " * level
+        buffer.append("{prefix}Entities:".format(prefix=prefix))
+        for entity in library.Entities:
+            for line in self.formatEntity(entity, level + 1):
+                buffer.append(line)
+        buffer.append("{prefix}Architectures:".format(prefix=prefix))
+        for architecture in library.Architectures:
+            for line in self.formatArchitecture(architecture, level + 1):
+                buffer.append(line)
+        buffer.append("{prefix}Packages:".format(prefix=prefix))
+        for package in library.Packages:
+            for line in self.formatPackage(package, level + 1):
+                buffer.append(line)
+        buffer.append("{prefix}PackageBodies:".format(prefix=prefix))
+        for packageBodies in library.PackageBodies:
+            for line in self.formatPackageBody(packageBodies, level + 1):
+                buffer.append(line)
+        buffer.append("{prefix}Configurations:".format(prefix=prefix))
+        for configuration in library.Configurations:
+            for line in self.formatConfiguration(configuration, level + 1):
+                buffer.append(line)
+        buffer.append("{prefix}Contexts:".format(prefix=prefix))
+        for context in library.Contexts:
+            for line in self.formatContext(context, level + 1):
+                buffer.append(line)
+
+        return buffer
+
     def formatDocument(self, document: Document, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append(
-            "{prefix}Document '{doc!s}':".format(doc=document.Path, prefix=prefix)
-        )
-        buffer.append("{prefix}  Entities:".format(prefix=prefix))
+        buffer.append("{prefix}Entities:".format(prefix=prefix))
         for entity in document.Entities:
             for line in self.formatEntity(entity, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}  Architectures:".format(prefix=prefix))
+        buffer.append("{prefix}Architectures:".format(prefix=prefix))
         for architecture in document.Architectures:
             for line in self.formatArchitecture(architecture, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}  Packages:".format(prefix=prefix))
+        buffer.append("{prefix}Packages:".format(prefix=prefix))
         for package in document.Packages:
             for line in self.formatPackage(package, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}  PackageBodies:".format(prefix=prefix))
+        buffer.append("{prefix}PackageBodies:".format(prefix=prefix))
         for packageBodies in document.PackageBodies:
             for line in self.formatPackageBody(packageBodies, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}  Configurations:".format(prefix=prefix))
+        buffer.append("{prefix}Configurations:".format(prefix=prefix))
         for configuration in document.Configurations:
             for line in self.formatConfiguration(configuration, level + 1):
                 buffer.append(line)
-        buffer.append("{prefix}  Contexts:".format(prefix=prefix))
+        buffer.append("{prefix}Contexts:".format(prefix=prefix))
         for context in document.Contexts:
             for line in self.formatContext(context, level + 1):
                 buffer.append(line)
@@ -124,7 +125,7 @@ class PrettyPrint:
     def formatEntity(self, entity: Entity, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}- {name}".format(name=entity.Name, prefix=prefix))
+        buffer.append("{prefix}- Name: {name}".format(name=entity.Name, prefix=prefix))
         buffer.append("{prefix}  Generics:".format(prefix=prefix))
         for generic in entity.GenericItems:
             for line in self.formatGeneric(generic, level + 1):
@@ -145,7 +146,14 @@ class PrettyPrint:
     ) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}- {name}".format(name=architecture.Name, prefix=prefix))
+        buffer.append(
+            "{prefix}- Name: {name}".format(name=architecture.Name, prefix=prefix)
+        )
+        buffer.append(
+            "{prefix}  Entity: {entity}".format(
+                entity=architecture.Entity.SymbolName, prefix=prefix
+            )
+        )
         buffer.append("{prefix}  Declared:".format(prefix=prefix))
         for item in architecture.DeclaredItems:
             for line in self.formatDeclaredItems(item, level + 2):
@@ -156,7 +164,7 @@ class PrettyPrint:
     def formatPackage(self, package: Package, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}- {name}".format(name=package.Name, prefix=prefix))
+        buffer.append("{prefix}- Name: {name}".format(name=package.Name, prefix=prefix))
         buffer.append("{prefix}  Declared:".format(prefix=prefix))
         for item in package.DeclaredItems:
             for line in self.formatDeclaredItems(item, level + 1):
@@ -169,7 +177,9 @@ class PrettyPrint:
     ) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}- {name}".format(name=packageBody.Name, prefix=prefix))
+        buffer.append(
+            "{prefix}- Name: {name}".format(name=packageBody.Name, prefix=prefix)
+        )
         buffer.append("{prefix}  Declared:".format(prefix=prefix))
         for item in packageBody.DeclaredItems:
             for line in self.formatDeclaredItems(item, level + 1):
@@ -182,14 +192,16 @@ class PrettyPrint:
     ) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}- {name}".format(name=configuration.Name, prefix=prefix))
+        buffer.append(
+            "{prefix}- Name: {name}".format(name=configuration.Name, prefix=prefix)
+        )
 
         return buffer
 
     def formatContext(self, context: Context, level: int = 0) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        buffer.append("{prefix}- {name}".format(name=context.Name, prefix=prefix))
+        buffer.append("{prefix}- Name: {name}".format(name=context.Name, prefix=prefix))
 
         return buffer
 
@@ -218,45 +230,18 @@ class PrettyPrint:
     ) -> StringBuffer:
         buffer = []
         prefix = "  " * level
-        subType = generic.SubType
-        if isinstance(subType, SimpleSubTypeSymbol):
-            buffer.append(
-                "{prefix}  - {name} : {mode} {type}{initialValue}".format(
-                    prefix=prefix,
-                    name=generic.Name,
-                    mode=ModeTranslation[generic.Mode],
-                    type=subType.SymbolName,
-                    initialValue=self.formatInitialValue(generic),
-                )
-            )
-        elif isinstance(subType, ConstrainedSubTypeSymbol):
-            buffer.append(
-                "{prefix}  - {name} : {mode} {type}({constraints}){initialValue}".format(
-                    prefix=prefix,
-                    name=generic.Name,
-                    mode=ModeTranslation[generic.Mode],
-                    type=subType.SymbolName,
-                    constraints=", ".join(
-                        [
-                            "{left} {dir} {right}".format(
-                                left=self.formatExpression(constraint.Range.LeftBound),
-                                right=self.formatExpression(
-                                    constraint.Range.RightBound
-                                ),
-                                dir=DirectionTranslation[constraint.Range.Direction],
-                            )
-                            for constraint in subType.Constraints
-                        ]
-                    ),
-                    initialValue=self.formatInitialValue(generic),
-                )
-            )
-        else:
-            raise PrettyPrintException(
-                "Unhandled constraint kind for generic '{name}'.".format(
-                    name=generic.Name
-                )
+
+        buffer.append(
+            "{prefix}  - {name} : {mode!s} {subtypeindication}{initialValue}".format(
+                prefix=prefix,
+                name=generic.Name,
+                mode=generic.Mode,
+                subtypeindication=self.formatSubtypeIndication(
+                    generic.SubType, "generic", generic.Name
+                ),
+                initialValue=self.formatInitialValue(generic),
             )
+        )
 
         return buffer
 
@@ -267,10 +252,10 @@ class PrettyPrint:
         prefix = "  " * level
 
         buffer.append(
-            "{prefix}  - {name} : {mode} {subtypeindication}{initialValue}".format(
+            "{prefix}  - {name} : {mode!s} {subtypeindication}{initialValue}".format(
                 prefix=prefix,
                 name=port.Name,
-                mode=ModeTranslation[port.Mode],
+                mode=port.Mode,
                 subtypeindication=self.formatSubtypeIndication(
                     port.SubType, "port", port.Name
                 ),
@@ -292,7 +277,7 @@ class PrettyPrint:
                     subtype=self.formatSubtypeIndication(
                         item.SubType, "constant", item.Name
                     ),
-                    expr=self.formatExpression(item.DefaultExpression),
+                    expr=str(item.DefaultExpression),
                 )
             )
         elif isinstance(item, Signal):
@@ -303,9 +288,7 @@ class PrettyPrint:
                     subtype=self.formatSubtypeIndication(
                         item.SubType, "signal", item.Name
                     ),
-                    initValue=" := {expr}".format(
-                        expr=self.formatExpression(item.DefaultExpression)
-                    )
+                    initValue=" := {expr}".format(expr=str(item.DefaultExpression))
                     if item.DefaultExpression is not None
                     else "",
                 )
@@ -319,16 +302,8 @@ class PrettyPrint:
         if isinstance(subTypeIndication, SimpleSubTypeSymbol):
             return "{type}".format(type=subTypeIndication.SymbolName)
         elif isinstance(subTypeIndication, ConstrainedSubTypeSymbol):
-            constraints = ", ".join(
-                [
-                    "{left} {dir} {right}".format(
-                        left=self.formatExpression(constraint.Range.LeftBound),
-                        right=self.formatExpression(constraint.Range.RightBound),
-                        dir=DirectionTranslation[constraint.Range.Direction],
-                    )
-                    for constraint in subTypeIndication.Constraints
-                ]
-            )
+            ranges = [str(c.Range) for c in subTypeIndication.Constraints]
+            constraints = ", ".join(ranges)
 
             return "{type}({constraints})".format(
                 type=subTypeIndication.SymbolName, constraints=constraints
@@ -344,36 +319,4 @@ class PrettyPrint:
         if item.DefaultExpression is None:
             return ""
 
-        return " := {expr}".format(expr=self.formatExpression(item.DefaultExpression))
-
-    def formatExpression(self, expression: Expression) -> str:
-        if isinstance(expression, SimpleObjectSymbol):
-            return "{name}".format(name=expression.SymbolName)
-        elif isinstance(expression, IntegerLiteral):
-            return "{value}".format(value=expression.Value)
-        elif isinstance(expression, FloatingPointLiteral):
-            return "{value}".format(value=expression.Value)
-        elif isinstance(expression, CharacterLiteral):
-            return "'{value}'".format(value=expression.Value)
-        elif isinstance(expression, UnaryExpression):
-            try:
-                operator = UnaryExpressionTranslation[type(expression)]
-            except KeyError:
-                raise PrettyPrintException("Unhandled operator for unary expression.")
-
-            return "{operator}{operand}".format(
-                operand=self.formatExpression(expression.Operand), operator=operator
-            )
-        elif isinstance(expression, BinaryExpression):
-            try:
-                operator = BinaryExpressionTranslation[type(expression)]
-            except KeyError:
-                raise PrettyPrintException("Unhandled operator for binary expression.")
-
-            return "{left}{operator}{right}".format(
-                left=self.formatExpression(expression.LeftOperand),
-                right=self.formatExpression(expression.RightOperand),
-                operator=operator,
-            )
-        else:
-            raise PrettyPrintException("Unhandled expression kind.")
+        return " := {expr!s}".format(expr=item.DefaultExpression)