From 6b5e08c5373607115cb0fec38b67a76e2f7f8927 Mon Sep 17 00:00:00 2001 From: Patrick Lehmann Date: Tue, 22 Jun 2021 23:30:06 +0200 Subject: Handle shared variables. --- pyGHDL/dom/_Translate.py | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'pyGHDL/dom/_Translate.py') diff --git a/pyGHDL/dom/_Translate.py b/pyGHDL/dom/_Translate.py index 2b2a44e60..18b4160b8 100644 --- a/pyGHDL/dom/_Translate.py +++ b/pyGHDL/dom/_Translate.py @@ -366,6 +366,14 @@ def GetDeclaredItemsFromChainedNodes(nodeChain: Iir, entity: str, name: str): from pyGHDL.dom.Object import Constant result.append(Constant.parse(item)) + + elif kind == nodes.Iir_Kind.Variable_Declaration: + from pyGHDL.dom.Object import SharedVariable + + if nodes.Get_Shared_Flag(item): + result.append(SharedVariable.parse(item)) + else: + raise DOMException("Found non-shared variable.") elif kind == nodes.Iir_Kind.Signal_Declaration: from pyGHDL.dom.Object import Signal -- cgit v1.2.3 From ab736d2fd0259d3c674882296b8c233c25dc848a Mon Sep 17 00:00:00 2001 From: Patrick Lehmann Date: Wed, 23 Jun 2021 00:23:38 +0200 Subject: Changed translate functions retuning lists to generators. --- pyGHDL/dom/_Translate.py | 67 +++++++++++++++++++++++------------------------- 1 file changed, 32 insertions(+), 35 deletions(-) (limited to 'pyGHDL/dom/_Translate.py') diff --git a/pyGHDL/dom/_Translate.py b/pyGHDL/dom/_Translate.py index 18b4160b8..3771b57f5 100644 --- a/pyGHDL/dom/_Translate.py +++ b/pyGHDL/dom/_Translate.py @@ -30,7 +30,7 @@ # # SPDX-License-Identifier: GPL-2.0-or-later # ============================================================================ -from typing import List +from typing import List, Generator from pydecor import export @@ -40,6 +40,10 @@ from pyVHDLModel.VHDLModel import ( Expression, SubTypeOrSymbol, BaseType, + GenericInterfaceItem, + PortInterfaceItem, + ParameterInterfaceItem, + ModelEntity, ) from pyGHDL.libghdl import utils @@ -268,10 +272,10 @@ def GetExpressionFromNode(node: Iir) -> Expression: return cls.parse(node) -# FIXME: rewrite to generator @export -def GetGenericsFromChainedNodes(nodeChain: Iir): - result = [] +def GetGenericsFromChainedNodes( + nodeChain: Iir, +) -> Generator[GenericInterfaceItem, None, None]: for generic in utils.chain_iter(nodeChain): kind = GetIirKindOfNode(generic) if kind == nodes.Iir_Kind.Interface_Constant_Declaration: @@ -279,7 +283,7 @@ def GetGenericsFromChainedNodes(nodeChain: Iir): genericConstant = GenericConstantInterfaceItem.parse(generic) - result.append(genericConstant) + yield genericConstant else: position = GetPositionOfNode(generic) raise DOMException( @@ -293,13 +297,11 @@ def GetGenericsFromChainedNodes(nodeChain: Iir): ) ) - return result - -# FIXME: rewrite to generator @export -def GetPortsFromChainedNodes(nodeChain: Iir): - result = [] +def GetPortsFromChainedNodes( + nodeChain: Iir, +) -> Generator[PortInterfaceItem, None, None]: for port in utils.chain_iter(nodeChain): kind = GetIirKindOfNode(port) if kind == nodes.Iir_Kind.Interface_Signal_Declaration: @@ -307,7 +309,7 @@ def GetPortsFromChainedNodes(nodeChain: Iir): portSignal = PortSignalInterfaceItem.parse(port) - result.append(portSignal) + yield portSignal else: position = GetPositionOfNode(port) raise DOMException( @@ -321,27 +323,25 @@ def GetPortsFromChainedNodes(nodeChain: Iir): ) ) - return result - -# FIXME: rewrite to generator @export -def GetParameterFromChainedNodes(nodeChain: Iir): - result = [] +def GetParameterFromChainedNodes( + nodeChain: Iir, +) -> Generator[ParameterInterfaceItem, None, None]: for parameter in utils.chain_iter(nodeChain): kind = GetIirKindOfNode(parameter) if kind == nodes.Iir_Kind.Interface_Constant_Declaration: from pyGHDL.dom.InterfaceItem import ParameterConstantInterfaceItem - result.append(ParameterConstantInterfaceItem.parse(parameter)) + yield ParameterConstantInterfaceItem.parse(parameter) elif kind == nodes.Iir_Kind.Interface_Variable_Declaration: from pyGHDL.dom.InterfaceItem import ParameterVariableInterfaceItem - result.append(ParameterVariableInterfaceItem.parse(parameter)) + yield ParameterVariableInterfaceItem.parse(parameter) elif kind == nodes.Iir_Kind.Interface_Signal_Declaration: from pyGHDL.dom.InterfaceItem import ParameterSignalInterfaceItem - result.append(ParameterSignalInterfaceItem.parse(parameter)) + yield ParameterSignalInterfaceItem.parse(parameter) else: position = GetPositionOfNode(parameter) raise DOMException( @@ -355,51 +355,50 @@ def GetParameterFromChainedNodes(nodeChain: Iir): ) ) - return result - -def GetDeclaredItemsFromChainedNodes(nodeChain: Iir, entity: str, name: str): - result = [] +def GetDeclaredItemsFromChainedNodes( + nodeChain: Iir, entity: str, name: str +) -> Generator[ModelEntity, None, None]: for item in utils.chain_iter(nodeChain): kind = GetIirKindOfNode(item) if kind == nodes.Iir_Kind.Constant_Declaration: from pyGHDL.dom.Object import Constant - result.append(Constant.parse(item)) + yield Constant.parse(item) elif kind == nodes.Iir_Kind.Variable_Declaration: from pyGHDL.dom.Object import SharedVariable if nodes.Get_Shared_Flag(item): - result.append(SharedVariable.parse(item)) + yield SharedVariable.parse(item) else: raise DOMException("Found non-shared variable.") elif kind == nodes.Iir_Kind.Signal_Declaration: from pyGHDL.dom.Object import Signal - result.append(Signal.parse(item)) + yield Signal.parse(item) elif kind == nodes.Iir_Kind.Type_Declaration: - result.append(GetTypeFromNode(item)) + yield GetTypeFromNode(item) elif kind == nodes.Iir_Kind.Anonymous_Type_Declaration: - result.append(GetTypeFromNode(item)) + yield GetTypeFromNode(item) elif kind == nodes.Iir_Kind.Subtype_Declaration: - result.append(GetSubTypeFromNode(item)) + yield GetSubTypeFromNode(item) elif kind == nodes.Iir_Kind.Function_Declaration: - result.append(Function.parse(item)) + yield Function.parse(item) elif kind == nodes.Iir_Kind.Function_Body: # procedureName = NodeToName(item) print("found function body '{name}'".format(name="????")) elif kind == nodes.Iir_Kind.Procedure_Declaration: - result.append(Procedure.parse(item)) + yield Procedure.parse(item) elif kind == nodes.Iir_Kind.Procedure_Body: # procedureName = NodeToName(item) print("found procedure body '{name}'".format(name="????")) elif kind == nodes.Iir_Kind.Object_Alias_Declaration: - result.append(GetAliasFromNode(item)) + yield GetAliasFromNode(item) elif kind == nodes.Iir_Kind.Component_Declaration: from pyGHDL.dom.DesignUnit import Component - result.append(Component.parse(item)) + yield Component.parse(item) else: position = GetPositionOfNode(item) raise DOMException( @@ -414,8 +413,6 @@ def GetDeclaredItemsFromChainedNodes(nodeChain: Iir, entity: str, name: str): ) ) - return result - def GetAliasFromNode(node: Iir): aliasName = GetNameOfNode(node) -- cgit v1.2.3 From 66425e5257c9cec2bdc428b761d59d887564daf6 Mon Sep 17 00:00:00 2001 From: Patrick Lehmann Date: Wed, 23 Jun 2021 01:18:13 +0200 Subject: Better type handling. --- pyGHDL/dom/_Translate.py | 35 +++++++++++++++++++++++++++++++---- 1 file changed, 31 insertions(+), 4 deletions(-) (limited to 'pyGHDL/dom/_Translate.py') diff --git a/pyGHDL/dom/_Translate.py b/pyGHDL/dom/_Translate.py index 3771b57f5..7239da77c 100644 --- a/pyGHDL/dom/_Translate.py +++ b/pyGHDL/dom/_Translate.py @@ -57,7 +57,7 @@ from pyGHDL.dom.Symbol import ( ConstrainedSubTypeSymbol, IndexedObjectOrFunctionCallSymbol, ) -from pyGHDL.dom.Type import IntegerType, SubType +from pyGHDL.dom.Type import IntegerType, SubType, ArrayType, RecordType, EnumeratedType from pyGHDL.dom.Range import Range, RangeExpression from pyGHDL.dom.Literal import ( IntegerLiteral, @@ -181,10 +181,37 @@ def GetArrayConstraintsFromSubtypeIndication( @export def GetTypeFromNode(node: Iir) -> BaseType: typeName = GetNameOfNode(node) - leftBound = IntegerLiteral(0) - rightBound = IntegerLiteral(15) + typeDefinition = nodes.Get_Type_Definition(node) + kind = GetIirKindOfNode(typeDefinition) + if kind == nodes.Iir_Kind.Range_Expression: + r = GetRangeFromNode(typeDefinition) + + return IntegerType(typeName, r) + elif kind == nodes.Iir_Kind.Enumeration_Type_Definition: + + return EnumeratedType(typeName) + elif kind == nodes.Iir_Kind.Array_Type_Definition: + indexSubTypeDefinitionList = nodes.Get_Index_Subtype_Definition_List( + typeDefinition + ) + elementSubTypeIndication = nodes.Get_Element_Subtype_Indication(typeDefinition) + + return ArrayType(typeName) + elif kind == nodes.Iir_Kind.Record_Type_Definition: - return IntegerType(typeName, leftBound, rightBound) + return RecordType(typeName) + else: + position = GetPositionOfNode(typeDefinition) + raise DOMException( + "Unknown type definition kind '{kindName}'({kind}) for type '{name}' at {file}:{line}:{column}.".format( + kind=kind, + kindName=kind.name, + name=typeName, + file=position.Filename, + line=position.Line, + column=position.Column, + ) + ) @export -- cgit v1.2.3 From 1173ddab8255781e0e2bff2b92e8d07b7bf1c26d Mon Sep 17 00:00:00 2001 From: Patrick Lehmann Date: Wed, 23 Jun 2021 02:03:20 +0200 Subject: Extract record type elements. --- pyGHDL/dom/_Translate.py | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) (limited to 'pyGHDL/dom/_Translate.py') diff --git a/pyGHDL/dom/_Translate.py b/pyGHDL/dom/_Translate.py index 7239da77c..a3e3a7c96 100644 --- a/pyGHDL/dom/_Translate.py +++ b/pyGHDL/dom/_Translate.py @@ -57,7 +57,14 @@ from pyGHDL.dom.Symbol import ( ConstrainedSubTypeSymbol, IndexedObjectOrFunctionCallSymbol, ) -from pyGHDL.dom.Type import IntegerType, SubType, ArrayType, RecordType, EnumeratedType +from pyGHDL.dom.Type import ( + IntegerType, + SubType, + ArrayType, + RecordType, + EnumeratedType, + RecordTypeElement, +) from pyGHDL.dom.Range import Range, RangeExpression from pyGHDL.dom.Literal import ( IntegerLiteral, @@ -198,8 +205,15 @@ def GetTypeFromNode(node: Iir) -> BaseType: return ArrayType(typeName) elif kind == nodes.Iir_Kind.Record_Type_Definition: + elements = [] + elementDeclarations = nodes.Get_Elements_Declaration_List(typeDefinition) + for element in utils.flist_iter(elementDeclarations): + elementName = GetNameOfNode(element) + elementType = None # GetSubtypeIndicationFromNode(element) + + elements.append(RecordTypeElement(elementName, elementType)) - return RecordType(typeName) + return RecordType(typeName, elements) else: position = GetPositionOfNode(typeDefinition) raise DOMException( -- cgit v1.2.3 From 9fca189af9677e435a42eaae1edd91e1098596ac Mon Sep 17 00:00:00 2001 From: Patrick Lehmann Date: Wed, 23 Jun 2021 10:06:39 +0200 Subject: Added handling of enumeration, array and record types. --- pyGHDL/dom/_Translate.py | 57 +++++++++++++++++++++++++++++++++--------------- 1 file changed, 39 insertions(+), 18 deletions(-) (limited to 'pyGHDL/dom/_Translate.py') diff --git a/pyGHDL/dom/_Translate.py b/pyGHDL/dom/_Translate.py index a3e3a7c96..8cb1639fd 100644 --- a/pyGHDL/dom/_Translate.py +++ b/pyGHDL/dom/_Translate.py @@ -64,6 +64,7 @@ from pyGHDL.dom.Type import ( RecordType, EnumeratedType, RecordTypeElement, + AccessType, ) from pyGHDL.dom.Range import Range, RangeExpression from pyGHDL.dom.Literal import ( @@ -72,7 +73,7 @@ from pyGHDL.dom.Literal import ( FloatingPointLiteral, StringLiteral, PhysicalIntegerLiteral, - PhysicalFloatingLiteral, + PhysicalFloatingLiteral, EnumerationLiteral, ) from pyGHDL.dom.Expression import ( SubtractionExpression, @@ -195,25 +196,19 @@ def GetTypeFromNode(node: Iir) -> BaseType: return IntegerType(typeName, r) elif kind == nodes.Iir_Kind.Enumeration_Type_Definition: - - return EnumeratedType(typeName) + return EnumeratedType.parse(typeName, typeDefinition) elif kind == nodes.Iir_Kind.Array_Type_Definition: - indexSubTypeDefinitionList = nodes.Get_Index_Subtype_Definition_List( - typeDefinition - ) - elementSubTypeIndication = nodes.Get_Element_Subtype_Indication(typeDefinition) + return ArrayType.parse(typeName, typeDefinition) + elif kind == nodes.Iir_Kind.Array_Subtype_Definition: + print("Array_Subtype_Definition") - return ArrayType(typeName) + return ArrayType elif kind == nodes.Iir_Kind.Record_Type_Definition: - elements = [] - elementDeclarations = nodes.Get_Elements_Declaration_List(typeDefinition) - for element in utils.flist_iter(elementDeclarations): - elementName = GetNameOfNode(element) - elementType = None # GetSubtypeIndicationFromNode(element) + return RecordType.parse(typeName, typeDefinition) + elif kind == nodes.Iir_Kind.Access_Type_Definition: + designatedType = nodes.Get_Designated_Type(typeDefinition) - elements.append(RecordTypeElement(elementName, elementType)) - - return RecordType(typeName, elements) + return AccessType(typeName, designatedType) else: position = GetPositionOfNode(typeDefinition) raise DOMException( @@ -229,12 +224,38 @@ def GetTypeFromNode(node: Iir) -> BaseType: @export -def GetSubTypeFromNode(node: Iir) -> BaseType: +def GetSubTypeIndicationFromNode(subTypeIndicationNode: Iir, entity: str, name: str) -> SubTypeOrSymbol: + kind = GetIirKindOfNode(subTypeIndicationNode) + if kind == nodes.Iir_Kind.Simple_Name: + return GetSimpleTypeFromNode(subTypeIndicationNode) + elif kind == nodes.Iir_Kind.Array_Subtype_Definition: + return GetConstrainedSubTypeFromNode(subTypeIndicationNode) + else: + raise DOMException( + "Unknown kind '{kind}' for an subtype indication in a {entity} of `{name}`.".format( + kind=kind.name, entity=entity, name=name + ) + ) + +@export +def GetSimpleTypeFromNode(subTypeIndicationNode: Iir) -> SimpleSubTypeSymbol: + subTypeName = GetNameOfNode(subTypeIndicationNode) + return SimpleSubTypeSymbol(subTypeName) + +@export +def GetConstrainedSubTypeFromNode(subTypeIndicationNode: Iir) -> ConstrainedSubTypeSymbol: + typeMark = nodes.Get_Subtype_Type_Mark(subTypeIndicationNode) + typeMarkName = GetNameOfNode(typeMark) + + constraints = GetArrayConstraintsFromSubtypeIndication(subTypeIndicationNode) + return ConstrainedSubTypeSymbol(typeMarkName, constraints) + +@export +def GetSubTypeFromNode(node: Iir) -> SubTypeOrSymbol: subTypeName = GetNameOfNode(node) return SubType(subTypeName) - @export def GetRangeFromNode(node: Iir) -> Range: direction = nodes.Get_Direction(node) -- cgit v1.2.3 From d4e3bf7941e6826c0175f4768c31155bd5d98b0e Mon Sep 17 00:00:00 2001 From: Patrick Lehmann Date: Wed, 23 Jun 2021 10:23:23 +0200 Subject: Handle access types. --- pyGHDL/dom/_Translate.py | 29 +++++++++++++++++++++-------- 1 file changed, 21 insertions(+), 8 deletions(-) (limited to 'pyGHDL/dom/_Translate.py') diff --git a/pyGHDL/dom/_Translate.py b/pyGHDL/dom/_Translate.py index 8cb1639fd..8627fd5cb 100644 --- a/pyGHDL/dom/_Translate.py +++ b/pyGHDL/dom/_Translate.py @@ -73,7 +73,8 @@ from pyGHDL.dom.Literal import ( FloatingPointLiteral, StringLiteral, PhysicalIntegerLiteral, - PhysicalFloatingLiteral, EnumerationLiteral, + PhysicalFloatingLiteral, + EnumerationLiteral, ) from pyGHDL.dom.Expression import ( SubtractionExpression, @@ -116,8 +117,13 @@ __all__ = [] @export -def GetSubtypeIndicationFromNode(node: Iir, entity: str, name: str) -> SubTypeOrSymbol: - subTypeIndication = nodes.Get_Subtype_Indication(node) +def GetSubtypeIndicationFromNode( + node: Iir, entity: str, name: str, do=True +) -> SubTypeOrSymbol: + if do: + subTypeIndication = nodes.Get_Subtype_Indication(node) + else: + subTypeIndication = node if subTypeIndication is nodes.Null_Iir: return None subTypeKind = GetIirKindOfNode(subTypeIndication) @@ -190,6 +196,7 @@ def GetArrayConstraintsFromSubtypeIndication( def GetTypeFromNode(node: Iir) -> BaseType: typeName = GetNameOfNode(node) typeDefinition = nodes.Get_Type_Definition(node) + kind = GetIirKindOfNode(typeDefinition) if kind == nodes.Iir_Kind.Range_Expression: r = GetRangeFromNode(typeDefinition) @@ -206,9 +213,7 @@ def GetTypeFromNode(node: Iir) -> BaseType: elif kind == nodes.Iir_Kind.Record_Type_Definition: return RecordType.parse(typeName, typeDefinition) elif kind == nodes.Iir_Kind.Access_Type_Definition: - designatedType = nodes.Get_Designated_Type(typeDefinition) - - return AccessType(typeName, designatedType) + return AccessType.parse(typeName, typeDefinition) else: position = GetPositionOfNode(typeDefinition) raise DOMException( @@ -224,7 +229,9 @@ def GetTypeFromNode(node: Iir) -> BaseType: @export -def GetSubTypeIndicationFromNode(subTypeIndicationNode: Iir, entity: str, name: str) -> SubTypeOrSymbol: +def GetSubTypeIndicationFromNode( + subTypeIndicationNode: Iir, entity: str, name: str +) -> SubTypeOrSymbol: kind = GetIirKindOfNode(subTypeIndicationNode) if kind == nodes.Iir_Kind.Simple_Name: return GetSimpleTypeFromNode(subTypeIndicationNode) @@ -237,25 +244,31 @@ def GetSubTypeIndicationFromNode(subTypeIndicationNode: Iir, entity: str, name: ) ) + @export def GetSimpleTypeFromNode(subTypeIndicationNode: Iir) -> SimpleSubTypeSymbol: subTypeName = GetNameOfNode(subTypeIndicationNode) return SimpleSubTypeSymbol(subTypeName) + @export -def GetConstrainedSubTypeFromNode(subTypeIndicationNode: Iir) -> ConstrainedSubTypeSymbol: +def GetConstrainedSubTypeFromNode( + subTypeIndicationNode: Iir, +) -> ConstrainedSubTypeSymbol: typeMark = nodes.Get_Subtype_Type_Mark(subTypeIndicationNode) typeMarkName = GetNameOfNode(typeMark) constraints = GetArrayConstraintsFromSubtypeIndication(subTypeIndicationNode) return ConstrainedSubTypeSymbol(typeMarkName, constraints) + @export def GetSubTypeFromNode(node: Iir) -> SubTypeOrSymbol: subTypeName = GetNameOfNode(node) return SubType(subTypeName) + @export def GetRangeFromNode(node: Iir) -> Range: direction = nodes.Get_Direction(node) -- cgit v1.2.3 From 95d5cb9329ee335a64e444ed0fd93bb0950edc5a Mon Sep 17 00:00:00 2001 From: Patrick Lehmann Date: Wed, 23 Jun 2021 10:52:13 +0200 Subject: Removed duplicate function. --- pyGHDL/dom/_Translate.py | 55 ++++++++---------------------------------------- 1 file changed, 9 insertions(+), 46 deletions(-) (limited to 'pyGHDL/dom/_Translate.py') diff --git a/pyGHDL/dom/_Translate.py b/pyGHDL/dom/_Translate.py index 8627fd5cb..beb13a11c 100644 --- a/pyGHDL/dom/_Translate.py +++ b/pyGHDL/dom/_Translate.py @@ -116,51 +116,6 @@ from pyGHDL.dom.Misc import Alias __all__ = [] -@export -def GetSubtypeIndicationFromNode( - node: Iir, entity: str, name: str, do=True -) -> SubTypeOrSymbol: - if do: - subTypeIndication = nodes.Get_Subtype_Indication(node) - else: - subTypeIndication = node - if subTypeIndication is nodes.Null_Iir: - return None - subTypeKind = GetIirKindOfNode(subTypeIndication) - - if subTypeKind == nodes.Iir_Kind.Simple_Name: - subTypeName = GetNameOfNode(subTypeIndication) - - subType = SimpleSubTypeSymbol(subTypeName) - elif subTypeKind == nodes.Iir_Kind.Array_Subtype_Definition: - typeMark = nodes.Get_Subtype_Type_Mark(subTypeIndication) - typeMarkName = GetNameOfNode(typeMark) - - constraints = GetArrayConstraintsFromSubtypeIndication(subTypeIndication) - subType = ConstrainedSubTypeSymbol(typeMarkName, constraints) - elif subTypeKind == nodes.Iir_Kind.Subtype_Definition: - raise DOMException( - "Unknown handling of subtype kind '{kind}' of subtype indication '{indication}' while parsing {entity} '{name}'.".format( - kind=subTypeKind, indication=subTypeIndication, entity=entity, name=name - ) - ) - else: - position = GetPositionOfNode(node) - raise DOMException( - "Unknown subtype kind '{kind}' of subtype indication '{indication}' while parsing {entity} '{name}' at {file}:{line}:{column}.".format( - kind=subTypeKind, - indication=subTypeIndication, - entity=entity, - name=name, - file=position.Filename, - line=position.Line, - column=position.Column, - ) - ) - - return subType - - @export def GetArrayConstraintsFromSubtypeIndication( subTypeIndication: Iir, @@ -229,7 +184,15 @@ def GetTypeFromNode(node: Iir) -> BaseType: @export -def GetSubTypeIndicationFromNode( +def GetSubTypeIndicationFromNode(node: Iir, entity: str, name: str) -> SubTypeOrSymbol: + subTypeIndicationNode = nodes.Get_Subtype_Indication(node) + # if subTypeIndicationNode is nodes.Null_Iir: + # return None + return GetSubTypeIndicationFromIndicationNode(subTypeIndicationNode, entity, name) + + +@export +def GetSubTypeIndicationFromIndicationNode( subTypeIndicationNode: Iir, entity: str, name: str ) -> SubTypeOrSymbol: kind = GetIirKindOfNode(subTypeIndicationNode) -- cgit v1.2.3 From 700a2e85da31c53067b4b4139b1a0c2f78818c68 Mon Sep 17 00:00:00 2001 From: Patrick Lehmann Date: Wed, 23 Jun 2021 11:52:41 +0200 Subject: First primitive handling of selected names. --- pyGHDL/dom/_Translate.py | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) (limited to 'pyGHDL/dom/_Translate.py') diff --git a/pyGHDL/dom/_Translate.py b/pyGHDL/dom/_Translate.py index beb13a11c..47d8c0b75 100644 --- a/pyGHDL/dom/_Translate.py +++ b/pyGHDL/dom/_Translate.py @@ -49,7 +49,12 @@ from pyVHDLModel.VHDLModel import ( from pyGHDL.libghdl import utils from pyGHDL.libghdl._types import Iir from pyGHDL.libghdl.vhdl import nodes -from pyGHDL.dom._Utils import GetNameOfNode, GetIirKindOfNode, GetPositionOfNode +from pyGHDL.dom._Utils import ( + GetNameOfNode, + GetIirKindOfNode, + GetPositionOfNode, + GetSelectedName, +) from pyGHDL.dom.Common import DOMException from pyGHDL.dom.Symbol import ( SimpleObjectOrFunctionCallSymbol, @@ -198,6 +203,8 @@ def GetSubTypeIndicationFromIndicationNode( kind = GetIirKindOfNode(subTypeIndicationNode) if kind == nodes.Iir_Kind.Simple_Name: return GetSimpleTypeFromNode(subTypeIndicationNode) + elif kind == nodes.Iir_Kind.Selected_Name: + return GetSimpleTypeFromNode(subTypeIndicationNode) elif kind == nodes.Iir_Kind.Array_Subtype_Definition: return GetConstrainedSubTypeFromNode(subTypeIndicationNode) else: @@ -210,7 +217,7 @@ def GetSubTypeIndicationFromIndicationNode( @export def GetSimpleTypeFromNode(subTypeIndicationNode: Iir) -> SimpleSubTypeSymbol: - subTypeName = GetNameOfNode(subTypeIndicationNode) + subTypeName = GetSelectedName(subTypeIndicationNode) return SimpleSubTypeSymbol(subTypeName) -- cgit v1.2.3 From 11f1ebbc80250555474cfe22e1db10553e112a11 Mon Sep 17 00:00:00 2001 From: Patrick Lehmann Date: Wed, 23 Jun 2021 13:29:23 +0200 Subject: Handle 'Subtype_Definition' in record definitions. --- pyGHDL/dom/_Translate.py | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-) (limited to 'pyGHDL/dom/_Translate.py') diff --git a/pyGHDL/dom/_Translate.py b/pyGHDL/dom/_Translate.py index 47d8c0b75..cb9448f09 100644 --- a/pyGHDL/dom/_Translate.py +++ b/pyGHDL/dom/_Translate.py @@ -59,8 +59,9 @@ from pyGHDL.dom.Common import DOMException from pyGHDL.dom.Symbol import ( SimpleObjectOrFunctionCallSymbol, SimpleSubTypeSymbol, - ConstrainedSubTypeSymbol, + ConstrainedCompositeSubTypeSymbol, IndexedObjectOrFunctionCallSymbol, + ConstrainedScalarSubTypeSymbol, ) from pyGHDL.dom.Type import ( IntegerType, @@ -133,6 +134,12 @@ def GetArrayConstraintsFromSubtypeIndication( if constraintKind == nodes.Iir_Kind.Range_Expression: constraints.append(RangeExpression(GetRangeFromNode(constraint))) elif constraintKind == nodes.Iir_Kind.Attribute_Name: + name = GetNameOfNode(constraint) + prefix = nodes.Get_Prefix(constraint) + name2 = GetNameOfNode(prefix) + kind2 = GetIirKindOfNode(prefix) + print(name2, kind2, name) + raise DOMException("[NOT IMPLEMENTED] Attribute name as range.") elif constraintKind == nodes.Iir_Kind.Simple_Name: raise DOMException("[NOT IMPLEMENTED] Subtype as range.") @@ -205,8 +212,10 @@ def GetSubTypeIndicationFromIndicationNode( return GetSimpleTypeFromNode(subTypeIndicationNode) elif kind == nodes.Iir_Kind.Selected_Name: return GetSimpleTypeFromNode(subTypeIndicationNode) + elif kind == nodes.Iir_Kind.Subtype_Definition: + return GetScalarConstrainedSubTypeFromNode(subTypeIndicationNode) elif kind == nodes.Iir_Kind.Array_Subtype_Definition: - return GetConstrainedSubTypeFromNode(subTypeIndicationNode) + return GetCompositeConstrainedSubTypeFromNode(subTypeIndicationNode) else: raise DOMException( "Unknown kind '{kind}' for an subtype indication in a {entity} of `{name}`.".format( @@ -222,14 +231,25 @@ def GetSimpleTypeFromNode(subTypeIndicationNode: Iir) -> SimpleSubTypeSymbol: @export -def GetConstrainedSubTypeFromNode( +def GetScalarConstrainedSubTypeFromNode( + subTypeIndicationNode: Iir, +) -> ConstrainedScalarSubTypeSymbol: + typeMark = nodes.Get_Subtype_Type_Mark(subTypeIndicationNode) + typeMarkName = GetNameOfNode(typeMark) + rangeConstraint = nodes.Get_Range_Constraint(subTypeIndicationNode) + r = GetRangeFromNode(rangeConstraint) + return ConstrainedScalarSubTypeSymbol(typeMarkName, r) + + +@export +def GetCompositeConstrainedSubTypeFromNode( subTypeIndicationNode: Iir, -) -> ConstrainedSubTypeSymbol: +) -> ConstrainedCompositeSubTypeSymbol: typeMark = nodes.Get_Subtype_Type_Mark(subTypeIndicationNode) typeMarkName = GetNameOfNode(typeMark) constraints = GetArrayConstraintsFromSubtypeIndication(subTypeIndicationNode) - return ConstrainedSubTypeSymbol(typeMarkName, constraints) + return ConstrainedCompositeSubTypeSymbol(typeMarkName, constraints) @export -- cgit v1.2.3