diff options
27 files changed, 1186 insertions, 627 deletions
diff --git a/pyGHDL/cli/DOM.py b/pyGHDL/cli/DOM.py index 2feb6aecd..dceafc629 100755 --- a/pyGHDL/cli/DOM.py +++ b/pyGHDL/cli/DOM.py @@ -9,8 +9,8 @@ from pydecor import export from pyGHDL import GHDLBaseException from pyGHDL.libghdl import LibGHDLException -from pyGHDL.dom import NonStandard from pyGHDL.dom.Common import DOMException +from pyGHDL.dom.NonStandard import Design, Document from pyGHDL.dom.formatting.prettyprint import PrettyPrint, PrettyPrintException __all__ = [] @@ -19,14 +19,16 @@ __api__ = __all__ @export class Application: - _design: NonStandard.Design + _design: Design def __init__(self): - self._design = NonStandard.Design() + self._design = Design() def addFile(self, filename: Path, library: str): - document = NonStandard.Document(filename) - self._design.Documents.append(document) + lib = self._design.GetLibrary(library) + + document = Document(filename) + self._design.AddDocument(document, lib) def prettyPrint(self): PP = PrettyPrint() @@ -43,12 +45,18 @@ class Application: def handleException(ex): if isinstance(ex, PrettyPrintException): print("PP:", ex) - return 5 + return 0 elif isinstance(ex, DOMException): print("DOM:", ex) + ex2 = ex.__cause__ + if ex2 is not None: + for message in ex2.InternalErrors: + print("libghdl: {message}".format(message=message)) return 4 elif isinstance(ex, LibGHDLException): print("LIB:", ex) + for message in ex.InternalErrors: + print(" {message}".format(message=message)) return 3 elif isinstance(ex, GHDLBaseException): print("GHDL:", ex) diff --git a/pyGHDL/dom/Common.py b/pyGHDL/dom/Common.py index 984f06e86..43e8ce497 100644 --- a/pyGHDL/dom/Common.py +++ b/pyGHDL/dom/Common.py @@ -51,16 +51,3 @@ class DOMException(GHDLBaseException): @export class GHDLException(GHDLBaseException): pass - - -@export -class GHDLMixin: - def CheckForErrors(self) -> None: - errorCount = errorout_memory.Get_Nbr_Messages() - if errorCount != 0: - for i in range(errorCount): - print(errorout_memory.Get_Error_Message(i + 1)) - - raise DOMException("Error in libghdl.") from LibGHDLException( - "libghdl: Internal error 2." - ) diff --git a/pyGHDL/dom/DesignUnit.py b/pyGHDL/dom/DesignUnit.py index ce93bda3e..bf16b5c4b 100644 --- a/pyGHDL/dom/DesignUnit.py +++ b/pyGHDL/dom/DesignUnit.py @@ -61,54 +61,39 @@ from pyGHDL.dom._Translate import ( GetDeclaredItemsFromChainedNodes, ) from pyGHDL.dom.Symbol import EntitySymbol -from pyGHDL.dom.Common import GHDLMixin __all__ = [] @export -class Entity(VHDLModel_Entity, GHDLMixin): +class Entity(VHDLModel_Entity): @classmethod def parse(cls, entityNode: Iir): name = GetNameOfNode(entityNode) - entity = cls(name) - - for generic in GetGenericsFromChainedNodes(nodes.Get_Generic_Chain(entityNode)): - entity.GenericItems.append(generic) - - for port in GetPortsFromChainedNodes(nodes.Get_Port_Chain(entityNode)): - entity.PortItems.append(port) - - for item in GetDeclaredItemsFromChainedNodes( + generics = GetGenericsFromChainedNodes(nodes.Get_Generic_Chain(entityNode)) + ports = GetPortsFromChainedNodes(nodes.Get_Port_Chain(entityNode)) + declaredItems = GetDeclaredItemsFromChainedNodes( nodes.Get_Declaration_Chain(entityNode), "entity", name - ): - entity.DeclaredItems.append(item) + ) + bodyItems = [] - return entity + return cls(name, generics, ports, declaredItems, bodyItems) @export -class Architecture(VHDLModel_Architecture, GHDLMixin): - def __init__(self, name: str, entity: EntityOrSymbol): - super().__init__(name) - - self._entity = entity - +class Architecture(VHDLModel_Architecture): @classmethod def parse(cls, architectureNode: Iir): name = GetNameOfNode(architectureNode) entityName = GetNameOfNode(nodes.Get_Entity_Name(architectureNode)) entity = EntitySymbol(entityName) - - architecture = cls(name, entity) - - for item in GetDeclaredItemsFromChainedNodes( + declaredItems = GetDeclaredItemsFromChainedNodes( nodes.Get_Declaration_Chain(architectureNode), "architecture", name - ): - architecture.DeclaredItems.append(item) + ) + bodyItems = [] - return architecture + return cls(name, entity, declaredItems, bodyItems) def resolve(self): pass @@ -119,54 +104,41 @@ class Component(VHDLModel_Component): @classmethod def parse(cls, componentNode: Iir): name = GetNameOfNode(componentNode) + generics = GetGenericsFromChainedNodes(nodes.Get_Generic_Chain(componentNode)) + ports = GetPortsFromChainedNodes(nodes.Get_Port_Chain(componentNode)) - component = cls(name) - - for generic in GetGenericsFromChainedNodes( - nodes.Get_Generic_Chain(componentNode) - ): - component.GenericItems.append(generic) - - for port in GetPortsFromChainedNodes(nodes.Get_Port_Chain(componentNode)): - component.PortItems.append(port) - - return component + return cls(name, generics, ports) @export -class Package(VHDLModel_Package, GHDLMixin): +class Package(VHDLModel_Package): @classmethod - def parse(cls, libraryUnit: Iir): - name = GetNameOfNode(libraryUnit) - - package = cls(name) + def parse(cls, packageNode: Iir): + name = GetNameOfNode(packageNode) + generics = ( + None # GetGenericsFromChainedNodes(nodes.Get_Generic_Chain(packageNode)) + ) + declaredItems = GetDeclaredItemsFromChainedNodes( + nodes.Get_Declaration_Chain(packageNode), "package", name + ) - for item in GetDeclaredItemsFromChainedNodes( - nodes.Get_Declaration_Chain(libraryUnit), "package", name - ): - package.DeclaredItems.append(item) - - return package + return cls(name, generics, declaredItems) @export -class PackageBody(VHDLModel_PackageBody, GHDLMixin): +class PackageBody(VHDLModel_PackageBody): @classmethod - def parse(cls, libraryUnit: Iir): - name = GetNameOfNode(libraryUnit) - - packageBody = cls(name) - - for item in GetDeclaredItemsFromChainedNodes( - nodes.Get_Declaration_Chain(libraryUnit), "package body", name - ): - packageBody.DeclaredItems.append(item) + def parse(cls, packageBodyNode: Iir): + name = GetNameOfNode(packageBodyNode) + declaredItems = GetDeclaredItemsFromChainedNodes( + nodes.Get_Declaration_Chain(packageBodyNode), "package", name + ) - return packageBody + return cls(name, declaredItems) @export -class Context(VHDLModel_Context, GHDLMixin): +class Context(VHDLModel_Context): @classmethod def parse(cls, libraryUnit: Iir): name = GetNameOfNode(libraryUnit) @@ -174,8 +146,8 @@ class Context(VHDLModel_Context, GHDLMixin): @export -class Configuration(VHDLModel_Configuration, GHDLMixin): +class Configuration(VHDLModel_Configuration): @classmethod - def parse(cls, libraryUnit: Iir): - name = GetNameOfNode(libraryUnit) + def parse(cls, configuration: Iir): + name = GetNameOfNode(configuration) return cls(name) diff --git a/pyGHDL/dom/InterfaceItem.py b/pyGHDL/dom/InterfaceItem.py index eac92c8a6..f720e69b4 100644 --- a/pyGHDL/dom/InterfaceItem.py +++ b/pyGHDL/dom/InterfaceItem.py @@ -46,7 +46,7 @@ from pyVHDLModel.VHDLModel import ( from pyGHDL.libghdl.vhdl import nodes from pyGHDL.libghdl.vhdl.nodes import Null_Iir from pyGHDL.dom._Utils import GetNameOfNode, GetModeOfNode -from pyGHDL.dom._Translate import GetSubtypeIndicationFromNode, GetExpressionFromNode +from pyGHDL.dom._Translate import GetSubTypeIndicationFromNode, GetExpressionFromNode __all__ = [] @@ -58,13 +58,11 @@ class GenericConstantInterfaceItem(VHDLModel_GenericConstantInterfaceItem): def parse(cls, generic): name = GetNameOfNode(generic) mode = GetModeOfNode(generic) - subTypeIndication = GetSubtypeIndicationFromNode(generic, "generic", name) + subTypeIndication = GetSubTypeIndicationFromNode(generic, "generic", name) default = nodes.Get_Default_Value(generic) value = GetExpressionFromNode(default) if default else None - g = cls(name, mode, subTypeIndication, value) - - return g + return cls(name, mode, subTypeIndication, value) def __init__( self, @@ -84,16 +82,14 @@ class PortSignalInterfaceItem(VHDLModel_PortSignalInterfaceItem): def parse(cls, port): name = GetNameOfNode(port) mode = GetModeOfNode(port) - subTypeIndication = GetSubtypeIndicationFromNode(port, "port", name) + subTypeIndication = GetSubTypeIndicationFromNode(port, "port", name) defaultValue = nodes.Get_Default_Value(port) value = ( GetExpressionFromNode(defaultValue) if defaultValue != Null_Iir else None ) - p = cls(name, mode, subTypeIndication, value) - - return p + return cls(name, mode, subTypeIndication, value) def __init__( self, @@ -113,16 +109,14 @@ class ParameterConstantInterfaceItem(VHDLModel_ParameterConstantInterfaceItem): def parse(cls, parameter): name = GetNameOfNode(parameter) mode = GetModeOfNode(parameter) - subTypeIndication = GetSubtypeIndicationFromNode(parameter, "parameter", name) + subTypeIndication = GetSubTypeIndicationFromNode(parameter, "parameter", name) defaultValue = nodes.Get_Default_Value(parameter) value = ( GetExpressionFromNode(defaultValue) if defaultValue != Null_Iir else None ) - param = cls(name, mode, subTypeIndication, value) - - return param + return cls(name, mode, subTypeIndication, value) def __init__( self, @@ -142,16 +136,14 @@ class ParameterVariableInterfaceItem(VHDLModel_ParameterVariableInterfaceItem): def parse(cls, parameter): name = GetNameOfNode(parameter) mode = GetModeOfNode(parameter) - subTypeIndication = GetSubtypeIndicationFromNode(parameter, "parameter", name) + subTypeIndication = GetSubTypeIndicationFromNode(parameter, "parameter", name) defaultValue = nodes.Get_Default_Value(parameter) value = ( GetExpressionFromNode(defaultValue) if defaultValue != Null_Iir else None ) - param = cls(name, mode, subTypeIndication, value) - - return param + return cls(name, mode, subTypeIndication, value) def __init__( self, @@ -171,16 +163,14 @@ class ParameterSignalInterfaceItem(VHDLModel_ParameterSignalInterfaceItem): def parse(cls, parameter): name = GetNameOfNode(parameter) mode = GetModeOfNode(parameter) - subTypeIndication = GetSubtypeIndicationFromNode(parameter, "parameter", name) + subTypeIndication = GetSubTypeIndicationFromNode(parameter, "parameter", name) defaultValue = nodes.Get_Default_Value(parameter) value = ( GetExpressionFromNode(defaultValue) if defaultValue != Null_Iir else None ) - param = cls(name, mode, subTypeIndication, value) - - return param + return cls(name, mode, subTypeIndication, value) def __init__( self, diff --git a/pyGHDL/dom/Literal.py b/pyGHDL/dom/Literal.py index 209712ba3..a2e86b389 100644 --- a/pyGHDL/dom/Literal.py +++ b/pyGHDL/dom/Literal.py @@ -30,9 +30,11 @@ # # SPDX-License-Identifier: GPL-2.0-or-later # ============================================================================ +from pyGHDL.libghdl._types import Iir from pydecor import export from pyVHDLModel.VHDLModel import ( + EnumerationLiteral as VHDLModel_EnumerationLiteral, IntegerLiteral as VHDLModel_IntegerLiteral, FloatingPointLiteral as VHDLModel_FloatingPointLiteral, PhysicalIntegerLiteral as VHDLModel_PhysicalIntegerLiteral, @@ -48,9 +50,17 @@ __all__ = [] @export +class EnumerationLiteral(VHDLModel_EnumerationLiteral): + @classmethod + def parse(cls, literalNode: Iir) -> "EnumerationLiteral": + literalName = GetNameOfNode(literalNode) + return cls(literalName) + + +@export class IntegerLiteral(VHDLModel_IntegerLiteral): @classmethod - def parse(cls, node): + def parse(cls, node: Iir) -> "IntegerLiteral": value = nodes.Get_Value(node) return cls(value) @@ -58,7 +68,7 @@ class IntegerLiteral(VHDLModel_IntegerLiteral): @export class FloatingPointLiteral(VHDLModel_FloatingPointLiteral): @classmethod - def parse(cls, node): + def parse(cls, node: Iir) -> "FloatingPointLiteral": value = nodes.Get_Fp_Value(node) return cls(value) @@ -66,7 +76,7 @@ class FloatingPointLiteral(VHDLModel_FloatingPointLiteral): @export class PhysicalIntegerLiteral(VHDLModel_PhysicalIntegerLiteral): @classmethod - def parse(cls, node): + def parse(cls, node: Iir) -> "PhysicalIntegerLiteral": value = nodes.Get_Value(node) unit = nodes.Get_Unit_Name(node) unitName = GetNameOfNode(unit) @@ -77,7 +87,7 @@ class PhysicalIntegerLiteral(VHDLModel_PhysicalIntegerLiteral): @export class PhysicalFloatingLiteral(VHDLModel_PhysicalFloatingLiteral): @classmethod - def parse(cls, node): + def parse(cls, node: Iir) -> "PhysicalFloatingLiteral": value = nodes.Get_Fp_Value(node) unit = nodes.Get_Unit_Name(node) unitName = GetNameOfNode(unit) @@ -88,7 +98,7 @@ class PhysicalFloatingLiteral(VHDLModel_PhysicalFloatingLiteral): @export class CharacterLiteral(VHDLModel_CharacterLiteral): @classmethod - def parse(cls, node): + def parse(cls, node: Iir) -> "CharacterLiteral": identifier = nodes.Get_Identifier(node) value = name_table.Get_Character(identifier) return cls(value) @@ -97,7 +107,7 @@ class CharacterLiteral(VHDLModel_CharacterLiteral): @export class StringLiteral(VHDLModel_StringLiteral): @classmethod - def parse(cls, node): + def parse(cls, node: Iir) -> "StringLiteral": stringID = nodes.Get_String8_Id(node) value = name_table.Get_Name_Ptr(stringID) return cls(value) diff --git a/pyGHDL/dom/NonStandard.py b/pyGHDL/dom/NonStandard.py index 63a35dc7f..9e2950f03 100644 --- a/pyGHDL/dom/NonStandard.py +++ b/pyGHDL/dom/NonStandard.py @@ -58,8 +58,8 @@ from pyGHDL.libghdl import ( utils, ) from pyGHDL.libghdl.vhdl import nodes, sem_lib, parse -from pyGHDL.dom._Utils import GetIirKindOfNode -from pyGHDL.dom.Common import DOMException, GHDLMixin +from pyGHDL.dom._Utils import GetIirKindOfNode, CheckForErrors +from pyGHDL.dom.Common import DOMException from pyGHDL.dom.DesignUnit import ( Entity, Architecture, @@ -103,14 +103,13 @@ class Library(VHDLModel_Library): @export -class Document(VHDLModel_Document, GHDLMixin): +class Document(VHDLModel_Document): __ghdlFileID: Any __ghdlSourceFileEntry: Any __ghdlFile: Any def __init__(self, path: Path = None, dontParse: bool = False): super().__init__(path) - GHDLMixin.__init__(self) self.__ghdl_init() if dontParse == False: @@ -125,12 +124,11 @@ class Document(VHDLModel_Document, GHDLMixin): if self.__ghdlSourceFileEntry == files_map.No_Source_File_Entry: raise LibGHDLException("Cannot load file '{!s}'".format(self.Path)) - self.CheckForErrors() + CheckForErrors() # Parse input file self.__ghdlFile = sem_lib.Load_File(self.__ghdlSourceFileEntry) - - self.CheckForErrors() + CheckForErrors() def parse(self): firstUnit = nodes.Get_First_Design_Unit(self.__ghdlFile) diff --git a/pyGHDL/dom/Object.py b/pyGHDL/dom/Object.py index 1f1f8f6d9..a5ea4b1ff 100644 --- a/pyGHDL/dom/Object.py +++ b/pyGHDL/dom/Object.py @@ -33,11 +33,13 @@ from pyGHDL.libghdl.vhdl import nodes from pydecor import export -from pyGHDL.dom._Translate import GetSubtypeIndicationFromNode, GetExpressionFromNode +from pyGHDL.dom._Translate import GetSubTypeIndicationFromNode, GetExpressionFromNode from pyGHDL.dom._Utils import GetNameOfNode from pyVHDLModel.VHDLModel import ( Constant as VHDLModel_Constant, + DeferredConstant as VHDLModel_DeferredConstant, Variable as VHDLModel_Variable, + SharedVariable as VHDLModel_SharedVariable, Signal as VHDLModel_Signal, Expression, SubTypeOrSymbol, @@ -60,12 +62,28 @@ class Constant(VHDLModel_Constant): @classmethod def parse(cls, node): name = GetNameOfNode(node) - subTypeIndication = GetSubtypeIndicationFromNode(node, "constant", name) + subTypeIndication = GetSubTypeIndicationFromNode(node, "constant", name) defaultExpression = GetExpressionFromNode(nodes.Get_Default_Value(node)) - constant = cls(name, subTypeIndication, defaultExpression) + return cls(name, subTypeIndication, defaultExpression) - return constant + +@export +class DeferredConstant(VHDLModel_DeferredConstant): + def __init__(self, name: str, subType: SubTypeOrSymbol): + super().__init__(name) + + self._name = name + self._subType = subType + + @classmethod + def parse(cls, node): + name = GetNameOfNode(node) + subTypeIndication = GetSubTypeIndicationFromNode( + node, "deferred constant", name + ) + + return cls(name, subTypeIndication) @export @@ -82,12 +100,26 @@ class Variable(VHDLModel_Variable): @classmethod def parse(cls, node): name = GetNameOfNode(node) - subTypeIndication = GetSubtypeIndicationFromNode(node, "variable", name) + subTypeIndication = GetSubTypeIndicationFromNode(node, "variable", name) defaultExpression = GetExpressionFromNode(nodes.Get_Default_Value(node)) - variable = cls(name, subTypeIndication, defaultExpression) + return cls(name, subTypeIndication, defaultExpression) - return variable + +@export +class SharedVariable(VHDLModel_SharedVariable): + def __init__(self, name: str, subType: SubTypeOrSymbol): + super().__init__(name) + + self._name = name + self._subType = subType + + @classmethod + def parse(cls, node): + name = GetNameOfNode(node) + subTypeIndication = GetSubTypeIndicationFromNode(node, "variable", name) + + return cls(name, subTypeIndication) @export @@ -104,10 +136,8 @@ class Signal(VHDLModel_Signal): @classmethod def parse(cls, node): name = GetNameOfNode(node) - subTypeIndication = GetSubtypeIndicationFromNode(node, "signal", name) + subTypeIndication = GetSubTypeIndicationFromNode(node, "signal", name) default = nodes.Get_Default_Value(node) defaultExpression = GetExpressionFromNode(default) if default else None - signal = cls(name, subTypeIndication, defaultExpression) - - return signal + return cls(name, subTypeIndication, defaultExpression) diff --git a/pyGHDL/dom/Subprogram.py b/pyGHDL/dom/Subprogram.py index b3c47bfe5..0f10ebf62 100644 --- a/pyGHDL/dom/Subprogram.py +++ b/pyGHDL/dom/Subprogram.py @@ -30,6 +30,8 @@ # # SPDX-License-Identifier: GPL-2.0-or-later # ============================================================================ +from typing import List + from pyGHDL.dom.Symbol import SimpleSubTypeSymbol from pyGHDL.libghdl.vhdl import nodes from pydecor import export @@ -39,14 +41,27 @@ from pyVHDLModel.VHDLModel import ( Function as VHDLModel_Function, Procedure as VHDLModel_Procedure, SubTypeOrSymbol, + GenericInterfaceItem, + ParameterInterfaceItem, ) from pyGHDL.libghdl._types import Iir @export class Function(VHDLModel_Function): - def __init__(self, functionName: str, returnType: SubTypeOrSymbol): + def __init__( + self, + functionName: str, + returnType: SubTypeOrSymbol, + genericItems: List[GenericInterfaceItem] = None, + parameterItems: List[ParameterInterfaceItem] = None, + ): super().__init__(functionName) + + self._genericItems = [] if genericItems is None else [g for g in genericItems] + self._parameterItems = ( + [] if parameterItems is None else [p for p in parameterItems] + ) self._returnType = returnType @classmethod @@ -57,27 +72,34 @@ class Function(VHDLModel_Function): ) functionName = GetNameOfNode(node) + + generics = GetGenericsFromChainedNodes(nodes.Get_Generic_Chain(node)) + parameters = GetParameterFromChainedNodes( + nodes.Get_Interface_Declaration_Chain(node) + ) + returnType = nodes.Get_Return_Type_Mark(node) returnTypeName = GetNameOfNode(returnType) - returnTypeSymbol = SimpleSubTypeSymbol(returnTypeName) - function = cls(functionName, returnTypeSymbol) - - for generic in GetGenericsFromChainedNodes(nodes.Get_Generic_Chain(node)): - function.GenericItems.append(generic) - for port in GetParameterFromChainedNodes( - nodes.Get_Interface_Declaration_Chain(node) - ): - function.ParameterItems.append(port) - return function + return cls(functionName, returnTypeSymbol, generics, parameters) @export class Procedure(VHDLModel_Procedure): - def __init__(self, procedureName: str): + def __init__( + self, + procedureName: str, + genericItems: List[GenericInterfaceItem] = None, + parameterItems: List[ParameterInterfaceItem] = None, + ): super().__init__(procedureName) + self._genericItems = [] if genericItems is None else [g for g in genericItems] + self._parameterItems = ( + [] if parameterItems is None else [p for p in parameterItems] + ) + @classmethod def parse(cls, node: Iir): from pyGHDL.dom._Translate import ( @@ -87,13 +109,9 @@ class Procedure(VHDLModel_Procedure): procedureName = GetNameOfNode(node) - procedure = cls(procedureName) - - for generic in GetGenericsFromChainedNodes(nodes.Get_Generic_Chain(node)): - procedure.GenericItems.append(generic) - for port in GetParameterFromChainedNodes( + generics = GetGenericsFromChainedNodes(nodes.Get_Generic_Chain(node)) + parameters = GetParameterFromChainedNodes( nodes.Get_Interface_Declaration_Chain(node) - ): - procedure.ParameterItems.append(port) + ) - return procedure + return cls(procedureName, generics, parameters) diff --git a/pyGHDL/dom/Symbol.py b/pyGHDL/dom/Symbol.py index 1865e4481..d6d348f14 100644 --- a/pyGHDL/dom/Symbol.py +++ b/pyGHDL/dom/Symbol.py @@ -30,13 +30,15 @@ # # SPDX-License-Identifier: GPL-2.0-or-later # ============================================================================ -from typing import List +from typing import List, Iterator from pydecor import export +from pyGHDL.dom.Range import Range from pyVHDLModel.VHDLModel import ( EntitySymbol as VHDLModel_EntitySymbol, SimpleSubTypeSymbol as VHDLModel_SimpleSubTypeSymbol, - ConstrainedSubTypeSymbol as VHDLModel_ConstrainedSubTypeSymbol, + ConstrainedScalarSubTypeSymbol as VHDLModel_ConstrainedScalarSubTypeSymbol, + ConstrainedCompositeSubTypeSymbol as VHDLModel_ConstrainedCompositeSubTypeSymbol, EnumerationLiteralSymbol as VHDLModel_EnumerationLiteralSymbol, SimpleObjectOrFunctionCallSymbol as VHDLModel_SimpleObjectOrFunctionCallSymbol, IndexedObjectOrFunctionCallSymbol as VHDLModel_IndexedObjectOrFunctionCallSymbol, @@ -66,15 +68,24 @@ class EnumerationLiteralSymbol(VHDLModel_EnumerationLiteralSymbol): @export class SimpleSubTypeSymbol(VHDLModel_SimpleSubTypeSymbol): def __init__(self, subTypeName: str): + if isinstance(subTypeName, (List, Iterator)): + subTypeName = ".".join(subTypeName) + super().__init__(subTypeName=subTypeName) + +@export +class ConstrainedScalarSubTypeSymbol(VHDLModel_ConstrainedScalarSubTypeSymbol): + def __init__(self, subTypeName: str, range: Range = None): + super().__init__(subTypeName=subTypeName, range=range) + @classmethod def parse(cls, node): pass @export -class ConstrainedSubTypeSymbol(VHDLModel_ConstrainedSubTypeSymbol): +class ConstrainedCompositeSubTypeSymbol(VHDLModel_ConstrainedCompositeSubTypeSymbol): def __init__(self, subTypeName: str, constraints: List[Constraint] = None): super().__init__(subTypeName=subTypeName, constraints=constraints) diff --git a/pyGHDL/dom/Type.py b/pyGHDL/dom/Type.py index c276387c7..2875f1bc2 100644 --- a/pyGHDL/dom/Type.py +++ b/pyGHDL/dom/Type.py @@ -30,21 +30,123 @@ # # SPDX-License-Identifier: GPL-2.0-or-later # ============================================================================ +from pyGHDL.dom.Common import DOMException +from pyGHDL.dom.Literal import EnumerationLiteral +from pyGHDL.dom._Utils import GetNameOfNode, GetIirKindOfNode +from pyGHDL.libghdl import utils + +from pyGHDL.libghdl.vhdl import nodes + +from pyGHDL.libghdl._types import Iir from pydecor import export +from pyGHDL.dom.Range import Range from pyVHDLModel.VHDLModel import ( IntegerType as VHDLModel_IntegerType, + EnumeratedType as VHDLModel_EnumeratedType, + ArrayType as VHDLModel_ArrayType, + RecordTypeElement as VHDLModel_RecordTypeElement, + RecordType as VHDLModel_RecordType, + AccessType as VHDLModel_AccessType, SubType as VHDLModel_SubType, - Expression, ) @export class IntegerType(VHDLModel_IntegerType): - def __init__(self, typeName: str, leftBound: Expression, rightBound: Expression): + def __init__(self, typeName: str, range: Range): super().__init__(typeName) - self._leftBound = leftBound - self._rightBound = rightBound + self._leftBound = range.LeftBound + self._rightBound = range.RightBound + + +@export +class EnumeratedType(VHDLModel_EnumeratedType): + @classmethod + def parse(cls, typeName: str, typeDefinitionNode: Iir) -> "EnumeratedType": + literals = [] + enumerationLiterals = nodes.Get_Enumeration_Literal_List(typeDefinitionNode) + for enumerationLiteral in utils.flist_iter(enumerationLiterals): + literal = EnumerationLiteral.parse(enumerationLiteral) + literals.append(literal) + + return cls(typeName, literals) + + +@export +class ArrayType(VHDLModel_ArrayType): + @classmethod + def parse(cls, typeName: str, typeDefinitionNode: Iir) -> "ArrayType": + from pyGHDL.dom._Translate import ( + GetSimpleTypeFromNode, + GetSubTypeIndicationFromIndicationNode, + ) + + indices = [] + indexDefinitions = nodes.Get_Index_Subtype_Definition_List(typeDefinitionNode) + for index in utils.flist_iter(indexDefinitions): + indexKind = GetIirKindOfNode(index) + if indexKind == nodes.Iir_Kind.Simple_Name: + indexSubType = GetSimpleTypeFromNode(index) + indices.append(indexSubType) + else: + raise DOMException( + "Unknown kind '{kind}' for an index in the array definition of `{typeName}`.".format( + kind=indexKind.name, typeName=typeName + ) + ) + + elementSubTypeIndication = nodes.Get_Element_Subtype_Indication( + typeDefinitionNode + ) + elementSubType = GetSubTypeIndicationFromIndicationNode( + elementSubTypeIndication, "array declaration", typeName + ) + + return cls(typeName, indices, elementSubType) + + +@export +class RecordTypeElement(VHDLModel_RecordTypeElement): + @classmethod + def parse(cls, elementDeclarationNode: Iir) -> "RecordTypeElement": + from pyGHDL.dom._Translate import GetSubTypeIndicationFromNode + + elementName = GetNameOfNode(elementDeclarationNode) + elementType = GetSubTypeIndicationFromNode( + elementDeclarationNode, "record element", elementName + ) + + return cls(elementName, elementType) + + +@export +class RecordType(VHDLModel_RecordType): + @classmethod + def parse(cls, typeName: str, typeDefinitionNode: Iir) -> "RecordType": + elements = [] + elementDeclarations = nodes.Get_Elements_Declaration_List(typeDefinitionNode) + for elementDeclaration in utils.flist_iter(elementDeclarations): + element = RecordTypeElement.parse(elementDeclaration) + elements.append(element) + + return cls(typeName, elements) + + +@export +class AccessType(VHDLModel_AccessType): + @classmethod + def parse(cls, typeName: str, typeDefinitionNode: Iir) -> "AccessType": + from pyGHDL.dom._Translate import GetSubTypeIndicationFromIndicationNode + + designatedSubtypeIndication = nodes.Get_Designated_Subtype_Indication( + typeDefinitionNode + ) + designatedSubType = GetSubTypeIndicationFromIndicationNode( + designatedSubtypeIndication, "access type", typeName + ) + + return cls(typeName, designatedSubType) @export diff --git a/pyGHDL/dom/_Translate.py b/pyGHDL/dom/_Translate.py index 2b2a44e60..cb9448f09 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,20 +40,38 @@ from pyVHDLModel.VHDLModel import ( Expression, SubTypeOrSymbol, BaseType, + GenericInterfaceItem, + PortInterfaceItem, + ParameterInterfaceItem, + ModelEntity, ) 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, SimpleSubTypeSymbol, - ConstrainedSubTypeSymbol, + ConstrainedCompositeSubTypeSymbol, IndexedObjectOrFunctionCallSymbol, + ConstrainedScalarSubTypeSymbol, +) +from pyGHDL.dom.Type import ( + IntegerType, + SubType, + ArrayType, + RecordType, + EnumeratedType, + RecordTypeElement, + AccessType, ) -from pyGHDL.dom.Type import IntegerType, SubType from pyGHDL.dom.Range import Range, RangeExpression from pyGHDL.dom.Literal import ( IntegerLiteral, @@ -62,6 +80,7 @@ from pyGHDL.dom.Literal import ( StringLiteral, PhysicalIntegerLiteral, PhysicalFloatingLiteral, + EnumerationLiteral, ) from pyGHDL.dom.Expression import ( SubtractionExpression, @@ -104,46 +123,6 @@ __all__ = [] @export -def GetSubtypeIndicationFromNode(node: Iir, entity: str, name: str) -> SubTypeOrSymbol: - subTypeIndication = nodes.Get_Subtype_Indication(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, ) -> List[Constraint]: @@ -155,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.") @@ -177,14 +162,98 @@ 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.parse(typeName, typeDefinition) + elif kind == nodes.Iir_Kind.Array_Type_Definition: + return ArrayType.parse(typeName, typeDefinition) + elif kind == nodes.Iir_Kind.Array_Subtype_Definition: + print("Array_Subtype_Definition") + + return ArrayType + elif kind == nodes.Iir_Kind.Record_Type_Definition: + return RecordType.parse(typeName, typeDefinition) + elif kind == nodes.Iir_Kind.Access_Type_Definition: + return AccessType.parse(typeName, typeDefinition) + 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 +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) + 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.Subtype_Definition: + return GetScalarConstrainedSubTypeFromNode(subTypeIndicationNode) + elif kind == nodes.Iir_Kind.Array_Subtype_Definition: + return GetCompositeConstrainedSubTypeFromNode(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 = GetSelectedName(subTypeIndicationNode) + return SimpleSubTypeSymbol(subTypeName) + + +@export +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, +) -> ConstrainedCompositeSubTypeSymbol: + typeMark = nodes.Get_Subtype_Type_Mark(subTypeIndicationNode) + typeMarkName = GetNameOfNode(typeMark) - return IntegerType(typeName, leftBound, rightBound) + constraints = GetArrayConstraintsFromSubtypeIndication(subTypeIndicationNode) + return ConstrainedCompositeSubTypeSymbol(typeMarkName, constraints) @export -def GetSubTypeFromNode(node: Iir) -> BaseType: +def GetSubTypeFromNode(node: Iir) -> SubTypeOrSymbol: subTypeName = GetNameOfNode(node) return SubType(subTypeName) @@ -268,10 +337,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 +348,7 @@ def GetGenericsFromChainedNodes(nodeChain: Iir): genericConstant = GenericConstantInterfaceItem.parse(generic) - result.append(genericConstant) + yield genericConstant else: position = GetPositionOfNode(generic) raise DOMException( @@ -293,13 +362,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 +374,7 @@ def GetPortsFromChainedNodes(nodeChain: Iir): portSignal = PortSignalInterfaceItem.parse(port) - result.append(portSignal) + yield portSignal else: position = GetPositionOfNode(port) raise DOMException( @@ -321,27 +388,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,43 +420,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): + 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( @@ -406,8 +478,6 @@ def GetDeclaredItemsFromChainedNodes(nodeChain: Iir, entity: str, name: str): ) ) - return result - def GetAliasFromNode(node: Iir): aliasName = GetNameOfNode(node) diff --git a/pyGHDL/dom/_Utils.py b/pyGHDL/dom/_Utils.py index e75c5f36a..1c109c9dc 100644 --- a/pyGHDL/dom/_Utils.py +++ b/pyGHDL/dom/_Utils.py @@ -30,13 +30,15 @@ # # SPDX-License-Identifier: GPL-2.0-or-later # ============================================================================ -from pyGHDL.libghdl._types import Iir from pydecor import export +from pyGHDL.dom.Common import DOMException from pyVHDLModel.VHDLModel import Mode -from pyGHDL.libghdl import LibGHDLException, name_table, files_map +from pyGHDL.libghdl import LibGHDLException, name_table, files_map, errorout_memory from pyGHDL.libghdl.vhdl import nodes +from pyGHDL.libghdl.vhdl.nodes import Null_Iir +from pyGHDL.libghdl._types import Iir from pyGHDL.dom.Misc import Position @@ -52,9 +54,33 @@ __MODE_TRANSLATION = { @export +def CheckForErrors() -> None: + errorCount = errorout_memory.Get_Nbr_Messages() + errors = [] + if errorCount != 0: + for i in range(errorCount): + rec = errorout_memory.Get_Error_Record(i + 1) + fileName = name_table.Get_Name_Ptr(files_map.Get_File_Name(rec.file)) + message = errorout_memory.Get_Error_Message(i + 1) + + errors.append( + "{file}:{line}:{column}: {msg}".format( + file=fileName, line=rec.line, column=rec.offset, msg=message + ) + ) + + raise DOMException("Error raised in libghdl.") from LibGHDLException( + "libghdl: Internal error.", errors + ) + + +@export def GetIirKindOfNode(node: Iir) -> nodes.Iir_Kind: - # This function is the most likely to be called on a Null_Iir node - assert node != 0 + """Return the kind of a node in the IIR tree.""" + + if node == Null_Iir: + raise ValueError("Parameter 'node' must not be 'Null_iir'.") + kind: int = nodes.Get_Kind(node) return nodes.Iir_Kind(kind) @@ -62,13 +88,38 @@ def GetIirKindOfNode(node: Iir) -> nodes.Iir_Kind: @export def GetNameOfNode(node: Iir) -> str: """Return the python string from node :obj:`node` identifier.""" + + if node == Null_Iir: + raise ValueError("Parameter 'node' must not be 'Null_iir'.") + identifier = nodes.Get_Identifier(node) return name_table.Get_Name_Ptr(identifier) @export +def GetSelectedName(node: Iir): + names = [] + kind = GetIirKindOfNode(node) + if kind == nodes.Iir_Kind.Simple_Name: + return GetNameOfNode(node) + + while kind != nodes.Iir_Kind.Simple_Name: + names.append(GetNameOfNode(node)) + node = nodes.Get_Prefix(node) + kind = GetIirKindOfNode(node) + + names.append(GetNameOfNode(node)) + + return reversed(names) + + +@export def GetModeOfNode(node: Iir) -> Mode: - """Return the mode of a :obj:`port`.""" + """Return the mode of a :obj:`node`.""" + + if node == Null_Iir: + raise ValueError("Parameter 'node' must not be 'Null_iir'.") + try: return __MODE_TRANSLATION[nodes.Get_Mode(node)] except KeyError: @@ -77,6 +128,11 @@ def GetModeOfNode(node: Iir) -> Mode: @export def GetPositionOfNode(node: Iir) -> Position: + """Return the source code position of a IIR node.""" + + if node == Null_Iir: + raise ValueError("Parameter 'node' must not be 'Null_iir'.") + location = nodes.Get_Location(node) file = files_map.Location_To_File(location) fileName = name_table.Get_Name_Ptr(files_map.Get_File_Name(file)) diff --git a/pyGHDL/dom/formatting/prettyprint.py b/pyGHDL/dom/formatting/prettyprint.py index f19125811..10def8503 100644 --- a/pyGHDL/dom/formatting/prettyprint.py +++ b/pyGHDL/dom/formatting/prettyprint.py @@ -4,13 +4,22 @@ from pydecor import export from pyGHDL.dom.Misc import Alias from pyGHDL.dom.Subprogram import Procedure -from pyGHDL.dom.Type import IntegerType, SubType +from pyGHDL.dom.Type import ( + IntegerType, + SubType, + ArrayType, + RecordType, + AccessType, + EnumeratedType, +) from pyVHDLModel.VHDLModel import ( GenericInterfaceItem, NamedEntity, PortInterfaceItem, WithDefaultExpression, Function, + BaseType, + Type, ) from pyGHDL import GHDLBaseException @@ -24,14 +33,14 @@ from pyGHDL.dom.DesignUnit import ( Context, Component, ) -from pyGHDL.dom.Object import Constant, Signal +from pyGHDL.dom.Object import Constant, Signal, SharedVariable from pyGHDL.dom.InterfaceItem import ( GenericConstantInterfaceItem, PortSignalInterfaceItem, ) from pyGHDL.dom.Symbol import ( SimpleSubTypeSymbol, - ConstrainedSubTypeSymbol, + ConstrainedCompositeSubTypeSymbol, ) @@ -54,7 +63,7 @@ class PrettyPrint: buffer = [] prefix = " " * level buffer.append("{prefix}Libraries:".format(prefix=prefix)) - for library in design.Libraries: + for library in design.Libraries.values(): for line in self.formatLibrary(library, level + 1): buffer.append(line) buffer.append("{prefix}Documents:".format(prefix=prefix)) @@ -74,18 +83,18 @@ class PrettyPrint: 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}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}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): @@ -302,6 +311,16 @@ class PrettyPrint: expr=str(item.DefaultExpression), ) ) + elif isinstance(item, SharedVariable): + buffer.append( + "{prefix}- shared variable {name} : {subtype}".format( + prefix=prefix, + name=item.Name, + subtype=self.formatSubtypeIndication( + item.SubType, "shared variable", item.Name + ), + ) + ) elif isinstance(item, Signal): buffer.append( "{prefix}- signal {name} : {subtype}{initValue}".format( @@ -315,15 +334,9 @@ class PrettyPrint: else "", ) ) - elif isinstance(item, IntegerType): + elif isinstance(item, Type): 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 - ), - ) + "{prefix}- {type}".format(prefix=prefix, type=self.formatType(item)) ) elif isinstance(item, SubType): buffer.append( @@ -364,10 +377,31 @@ class PrettyPrint: return buffer + def formatType(self, item: BaseType) -> str: + result = "type {name} is ".format(name=item.Name) + if isinstance(item, IntegerType): + result += "range {left!s} to {right!s}".format( + left=item.LeftBound, right=item.RightBound + ) + elif isinstance(item, EnumeratedType): + result += "(........)" + elif isinstance(item, ArrayType): + result += "array(........) of ....." + elif isinstance(item, RecordType): + result += "record ..... end record" + elif isinstance(item, AccessType): + result += "access ....." + else: + raise PrettyPrintException( + "Unknown type '{name}'".format(name=item.__class__.__name__) + ) + + return result + def formatSubtypeIndication(self, subTypeIndication, entity: str, name: str) -> str: if isinstance(subTypeIndication, SimpleSubTypeSymbol): return "{type}".format(type=subTypeIndication.SymbolName) - elif isinstance(subTypeIndication, ConstrainedSubTypeSymbol): + elif isinstance(subTypeIndication, ConstrainedCompositeSubTypeSymbol): ranges = [str(c.Range) for c in subTypeIndication.Constraints] constraints = ", ".join(ranges) @@ -376,8 +410,8 @@ class PrettyPrint: ) else: raise PrettyPrintException( - "Unhandled constraint kind for {entity} '{name}'.".format( - entity=entity, name=name + "Unhandled subtype kind '{type}' for {entity} '{name}'.".format( + type=subTypeIndication.__class__.__name__, entity=entity, name=name ) ) diff --git a/pyGHDL/libghdl/__init__.py b/pyGHDL/libghdl/__init__.py index 0d3c75fa1..525710590 100644 --- a/pyGHDL/libghdl/__init__.py +++ b/pyGHDL/libghdl/__init__.py @@ -37,6 +37,7 @@ import os import sys from pathlib import Path from shutil import which +from typing import List from pydecor import export @@ -48,7 +49,15 @@ from pyGHDL.libghdl.version import __version__ class LibGHDLException(GHDLBaseException): - pass + _internalErrors: List[str] + + def __init__(self, message: str, errors: List[str]): + super().__init__(message) + self._internalErrors = errors + + @property + def InternalErrors(self): + return self._internalErrors def _get_libghdl_name() -> Path: diff --git a/pyGHDL/libghdl/_decorator.py b/pyGHDL/libghdl/_decorator.py index 2001cb37e..a680cc9d1 100644 --- a/pyGHDL/libghdl/_decorator.py +++ b/pyGHDL/libghdl/_decorator.py @@ -93,7 +93,7 @@ def BindToLibGHDL(subprogramName): return None elif typ is int: return c_int32 - elif type is float: + elif typ is float: return c_double elif typ is bool: return c_bool diff --git a/pyGHDL/requirements.txt b/pyGHDL/requirements.txt index e6070f92e..6198d8044 100644 --- a/pyGHDL/requirements.txt +++ b/pyGHDL/requirements.txt @@ -1,2 +1,3 @@ pydecor>=2.0.1 -pyVHDLModel==0.10.2 +pyVHDLModel==0.10.3 +#https://github.com/VHDL/pyVHDLModel/archive/dev.zip#pyVHDLModel @@ -33,89 +33,112 @@ # SPDX-License-Identifier: GPL-2.0-or-later # ============================================================================ -from pathlib import Path -from re import compile as re_compile -from setuptools import setup as setuptools_setup, find_packages as setuptools_find_packages +from pathlib import Path +from re import compile as re_compile +from typing import List + +from setuptools import ( + setup as setuptools_setup, + find_packages as setuptools_find_packages, +) gitHubNamespace = "ghdl" projectName = "ghdl" packageName = "pyGHDL" packagePath = Path(packageName) -# Read (local) README for upload to PyPI readmeFile = packagePath / "README.md" -with readmeFile.open("r") as file: - long_description = file.read() +requirementsFile = packagePath / "requirements.txt" + +# Read (local) README for upload to PyPI +def get_description(file: Path) -> str: + with file.open("r") as fh: + description = fh.read() + return description + # Read requirements file and add them to package dependency list -requirementsFile = packagePath / "requirements.txt" -with requirementsFile.open("r") as file: - requirements = [line for line in file.readlines()] +def get_requirements(file: Path) -> List[str]: + requirements = [] + with file.open("r") as fh: + for line in fh.readlines(): + if line.startswith("#"): + continue + elif line.startswith("https"): + _splitItems = line.strip().split("#") + requirements.append("{} @ {}".format(_splitItems[1], _splitItems[0])) + else: + requirements.append(line.strip()) + return requirements + def get_version(): - # Try from version.py. Reads it to avoid loading the shared library. - pattern = re_compile('^__version__ = "(.*)"\n') - try: - line = open("pyGHDL/libghdl/version.py").read() - match = pattern.match(line) - if match: - return match.group(1) - except: - pass + # Try from version.py. Reads it to avoid loading the shared library. + pattern = re_compile('^__version__ = "(.*)"\n') + try: + line = open("pyGHDL/libghdl/version.py").read() + match = pattern.match(line) + if match: + return match.group(1) + except: + pass + + raise Exception("Cannot find version") - raise Exception("Cannot find version") # Derive URLs -sourceCodeURL = "https://github.com/{namespace}/{projectName}".format(namespace=gitHubNamespace, projectName=projectName) -documentationURL = "https://{namespace}.github.io/{projectName}/using/py/index.html".format(namespace=gitHubNamespace, projectName=projectName) +sourceCodeURL = "https://github.com/{namespace}/{projectName}".format( + namespace=gitHubNamespace, projectName=projectName +) +documentationURL = ( + "https://{namespace}.github.io/{projectName}/using/py/index.html".format( + namespace=gitHubNamespace, projectName=projectName + ) +) # Assemble all package information setuptools_setup( - name=packageName, - version=get_version(), - - author="Tristan Gingold", - author_email="tgingold@free.fr", - license="GPL-2.0-or-later", - description="Python binding for GHDL and high-level APIs (incl. LSP).", - long_description=long_description, - long_description_content_type="text/markdown", - - url=sourceCodeURL, - project_urls={ - 'Documentation': documentationURL, - 'Source Code': sourceCodeURL, - 'Issue Tracker': sourceCodeURL + "/issues" - }, - - python_requires='>=3.6', - install_requires=requirements, - packages=setuptools_find_packages(exclude=("tests",)), - entry_points={ - 'console_scripts': [ - "ghdl-ls = pyGHDL.cli.lsp:main", - "ghdl-dom = pyGHDL.cli.DOM:main" - ] - }, - - keywords="Python3 VHDL Parser Compiler Simulator GHDL", - classifiers=[ - "License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)", - "Operating System :: MacOS", - "Operating System :: Microsoft :: Windows :: Windows 10", - "Operating System :: POSIX :: Linux", - "Programming Language :: Python :: 3 :: Only", - "Programming Language :: Python :: 3.6", - "Programming Language :: Python :: 3.7", - "Programming Language :: Python :: 3.8", - "Programming Language :: Python :: 3.9", - "Development Status :: 4 - Beta", -# "Development Status :: 5 - Production/Stable", - "Intended Audience :: Developers", - "Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)", - "Topic :: Software Development :: Code Generators", - "Topic :: Software Development :: Compilers", - "Topic :: Software Development :: Testing", - "Topic :: Utilities", - ] + name=packageName, + version=get_version(), + author="Tristan Gingold", + author_email="tgingold@free.fr", + license="GPL-2.0-or-later", + description="Python binding for GHDL and high-level APIs (incl. LSP).", + long_description=get_description(readmeFile), + long_description_content_type="text/markdown", + url=sourceCodeURL, + project_urls={ + "Documentation": documentationURL, + "Source Code": sourceCodeURL, + "Issue Tracker": sourceCodeURL + "/issues", + }, + python_requires=">=3.6", + install_requires=get_requirements(requirementsFile), + packages=setuptools_find_packages(exclude=("tests",)), + entry_points={ + "console_scripts": [ + "ghdl-ls = pyGHDL.cli.lsp:main", + "ghdl-dom = pyGHDL.cli.DOM:main", + ] + }, + keywords="Python3 VHDL Parser Compiler Simulator GHDL", + classifiers=[ + "License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)", + "Operating System :: MacOS", + "Operating System :: Microsoft :: Windows :: Windows 10", + "Operating System :: POSIX :: Linux", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: 3.6", + "Programming Language :: Python :: 3.7", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Development Status :: 4 - Beta", + # "Development Status :: 5 - Production/Stable", + "Intended Audience :: Developers", + "Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)", + "Topic :: Software Development :: Code Generators", + "Topic :: Software Development :: Compilers", + "Topic :: Software Development :: Testing", + "Topic :: Utilities", + ], ) diff --git a/testsuite/pyunit/Current.vhdl b/testsuite/pyunit/Current.vhdl index 8653cb088..ff03e1d04 100644 --- a/testsuite/pyunit/Current.vhdl +++ b/testsuite/pyunit/Current.vhdl @@ -20,16 +20,36 @@ end entity entity_1; architecture behav of entity_1 is constant MAX : positive := -25; - signal rst : std_logic := foo'('U'); + signal rst : std_logic := foo('U'); +-- signal vec : bit_vector(pack.input'bar'range); type newInt is range -4 to 3; + type newFp is range 4.3 downto -3.9; + type arr is array(natural range <>, enum range <>) of integer(3 downto 0); + type rec is record + elem1 : bit; + elem2 : boolean; + elem3 : integer_vector(3 downto 0); + elem4 : natural range 7 to 8; + end record; + type enum is (e1, e2, e3); + type acc is access bar; subtype uint8 is integer range 0 to 255; - function foo(a : integer; b : boolean) return bit is +-- file f : text; + + function func (a : integer; b : boolean) return bit is begin end function; + shared variable pt_var : lib.pack.prot; + + procedure proc(spam : egg) is + begin + + end procedure; + alias bar is boolean; begin process(Clock) @@ -46,6 +66,12 @@ end architecture behav; package package_1 is constant ghdl : float := (3, 5, 0 to 2 => 5, 3 => 4, name => 10); -- 2.3; + + component comp is + port ( + clk : std + ); + end component; end package; package body package_1 is diff --git a/testsuite/pyunit/dom/AllSources.py b/testsuite/pyunit/dom/AllSources.py deleted file mode 100644 index 7dabf1b10..000000000 --- a/testsuite/pyunit/dom/AllSources.py +++ /dev/null @@ -1,23 +0,0 @@ -from sys import executable -from subprocess import check_call, STDOUT -from pathlib import Path -from glob import glob -from pytest import mark - -if __name__ == "__main__": - print("ERROR: you called a testcase declaration file as an executable module.") - print("Use: 'python -m unitest <testcase module>'") - exit(1) - - -@mark.parametrize( - "file", - glob(str(Path(__file__).resolve().parent.parent.parent / 'sanity' / '*' / '*.vhdl'), recursive=True) -) -@mark.xfail -def test_AllVHDLSources(file): - check_call([ - executable, - str(Path(__file__).resolve().parent.parent.parent.parent / 'pyGHDL' / 'cli' / 'DOM.py'), - file - ], stderr=STDOUT) diff --git a/testsuite/pyunit/dom/Expressions.py b/testsuite/pyunit/dom/Expressions.py index a7afb30ba..f9c066f52 100644 --- a/testsuite/pyunit/dom/Expressions.py +++ b/testsuite/pyunit/dom/Expressions.py @@ -1,11 +1,43 @@ -from pathlib import Path +# ============================================================================= +# ____ _ _ ____ _ _ +# _ __ _ _ / ___| | | | _ \| | __| | ___ _ __ ___ +# | '_ \| | | | | _| |_| | | | | | / _` |/ _ \| '_ ` _ \ +# | |_) | |_| | |_| | _ | |_| | |___ | (_| | (_) | | | | | | +# | .__/ \__, |\____|_| |_|____/|_____(_)__,_|\___/|_| |_| |_| +# |_| |___/ +# ============================================================================= +# Authors: +# Patrick Lehmann +# +# Testsuite: Check libghdl IIR translation to DOM for expressions. +# +# 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 +# ============================================================================ +from pathlib import Path from textwrap import dedent from unittest import TestCase from pyGHDL.dom.DesignUnit import Package from pyGHDL.dom import Expression -from pyGHDL.dom.NonStandard import Design, Document +from pyGHDL.dom.NonStandard import Design, Document from pyGHDL.dom.Symbol import SimpleObjectOrFunctionCallSymbol from pyGHDL.dom.Object import Constant from pyGHDL.dom.Expression import InverseExpression @@ -20,13 +52,17 @@ class Expressions(TestCase): _root = Path(__file__).resolve().parent.parent def test_NotExpression(self): - self._filename: Path = self._root / "{className}.vhdl".format(className=self.__class__.__name__) + self._filename: Path = self._root / "{className}.vhdl".format( + className=self.__class__.__name__ + ) - sourceCode = dedent("""\ + sourceCode = dedent( + """\ package package_1 is constant c0 : boolean := not true; end package; - """) + """ + ) with self._filename.open(mode="w", encoding="utf-8") as file: file.write(sourceCode) diff --git a/testsuite/pyunit/dom/Literals.py b/testsuite/pyunit/dom/Literals.py index c542ebfe5..ebd702f5e 100644 --- a/testsuite/pyunit/dom/Literals.py +++ b/testsuite/pyunit/dom/Literals.py @@ -1,8 +1,40 @@ -from pathlib import Path +# ============================================================================= +# ____ _ _ ____ _ _ +# _ __ _ _ / ___| | | | _ \| | __| | ___ _ __ ___ +# | '_ \| | | | | _| |_| | | | | | / _` |/ _ \| '_ ` _ \ +# | |_) | |_| | |_| | _ | |_| | |___ | (_| | (_) | | | | | | +# | .__/ \__, |\____|_| |_|____/|_____(_)__,_|\___/|_| |_| |_| +# |_| |___/ +# ============================================================================= +# Authors: +# Patrick Lehmann +# +# Testsuite: Check libghdl IIR translation to DOM for literals. +# +# 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 +# ============================================================================ +from pathlib import Path from textwrap import dedent from unittest import TestCase -from pyGHDL.dom.NonStandard import Design, Document +from pyGHDL.dom.NonStandard import Design, Document from pyGHDL.dom.Object import Constant from pyGHDL.dom.Literal import IntegerLiteral @@ -17,16 +49,20 @@ class Literals(TestCase): _root = Path(__file__).resolve().parent.parent def test_IntegerLiteral(self): - self._filename: Path = self._root / "{className}.vhdl".format(className=self.__class__.__name__) + self._filename: Path = self._root / "{className}.vhdl".format( + className=self.__class__.__name__ + ) - sourceCode = dedent("""\ + sourceCode = dedent( + """\ package package_1 is constant c0 : integer := 0; constant c1 : integer := 1; constant c2 : integer := 1024; constant c3 : integer := 1048576; end package; - """) + """ + ) expected = (0, 1, 1024, 1048576) with self._filename.open(mode="w", encoding="utf-8") as file: diff --git a/testsuite/pyunit/dom/Sanity.py b/testsuite/pyunit/dom/Sanity.py new file mode 100644 index 000000000..10258c38c --- /dev/null +++ b/testsuite/pyunit/dom/Sanity.py @@ -0,0 +1,50 @@ +# ============================================================================= +# ____ _ _ ____ _ _ +# _ __ _ _ / ___| | | | _ \| | __| | ___ _ __ ___ +# | '_ \| | | | | _| |_| | | | | | / _` |/ _ \| '_ ` _ \ +# | |_) | |_| | |_| | _ | |_| | |___ | (_| | (_) | | | | | | +# | .__/ \__, |\____|_| |_|____/|_____(_)__,_|\___/|_| |_| |_| +# |_| |___/ +# ============================================================================= +# Authors: +# Unai Martinez-Corral +# +# Testsuite: Parse files from sanity checks +# +# 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 +# ============================================================================ +from sys import executable +from subprocess import check_call, STDOUT +from pathlib import Path +from pytest import mark + +if __name__ == "__main__": + print("ERROR: you called a testcase declaration file as an executable module.") + print("Use: 'python -m unitest <testcase module>'") + exit(1) + +_TESTSUITE_ROOT = Path(__file__).parent.parent.parent.resolve() +_GHDL_ROOT = _TESTSUITE_ROOT.parent + + +@mark.xfail +@mark.parametrize("file", [str(f) for f in _TESTSUITE_ROOT.glob("sanity/**/*.vhdl")]) +def test_AllVHDLSources(file): + check_call([executable, _GHDL_ROOT / "pyGHDL/cli/DOM.py", file], stderr=STDOUT) diff --git a/testsuite/pyunit/dom/SimpleEntity.py b/testsuite/pyunit/dom/SimpleEntity.py index 8199fe7cc..9ee55508c 100644 --- a/testsuite/pyunit/dom/SimpleEntity.py +++ b/testsuite/pyunit/dom/SimpleEntity.py @@ -1,46 +1,78 @@ -from pathlib import Path +# ============================================================================= +# ____ _ _ ____ _ _ +# _ __ _ _ / ___| | | | _ \| | __| | ___ _ __ ___ +# | '_ \| | | | | _| |_| | | | | | / _` |/ _ \| '_ ` _ \ +# | |_) | |_| | |_| | _ | |_| | |___ | (_| | (_) | | | | | | +# | .__/ \__, |\____|_| |_|____/|_____(_)__,_|\___/|_| |_| |_| +# |_| |___/ +# ============================================================================= +# Authors: +# Patrick Lehmann +# +# Testsuite: Check libghdl IIR translation with a simple entity. +# +# 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 +# ============================================================================ +from pathlib import Path from unittest import TestCase -from pyGHDL.dom.NonStandard import Design, Document +from pyGHDL.dom.NonStandard import Design, Document if __name__ == "__main__": - print("ERROR: you called a testcase declaration file as an executable module.") - print("Use: 'python -m unitest <testcase module>'") - exit(1) + print("ERROR: you called a testcase declaration file as an executable module.") + print("Use: 'python -m unitest <testcase module>'") + exit(1) class SimpleEntity(TestCase): - _root = Path(__file__).resolve().parent.parent - _filename : Path = _root / "SimpleEntity.vhdl" + _root = Path(__file__).resolve().parent.parent + _filename: Path = _root / "SimpleEntity.vhdl" - def test_Design(self): - design = Design() + def test_Design(self): + design = Design() - self.assertIsNotNone(design) + self.assertIsNotNone(design) - # def test_Library(self): - # library = Library() + # def test_Library(self): + # library = Library() - def test_Document(self): - design = Design() - document = Document(self._filename) - design.Documents.append(document) + def test_Document(self): + design = Design() + document = Document(self._filename) + design.Documents.append(document) - self.assertTrue(len(design.Documents) == 1) + self.assertTrue(len(design.Documents) == 1) - def test_Entity(self): - design = Design() - document = Document(self._filename) - design.Documents.append(document) + def test_Entity(self): + design = Design() + document = Document(self._filename) + design.Documents.append(document) - self.assertEqual(len(design.Documents[0].Entities), 1) - self.assertTrue(design.Documents[0].Entities[0].Name == "entity_1") + self.assertEqual(len(design.Documents[0].Entities), 1) + self.assertTrue(design.Documents[0].Entities[0].Name == "entity_1") - def test_Architecture(self): - design = Design() - document = Document(self._filename) - design.Documents.append(document) + def test_Architecture(self): + design = Design() + document = Document(self._filename) + design.Documents.append(document) - self.assertEqual(len(design.Documents[0].Architectures), 1) - self.assertTrue(design.Documents[0].Architectures[0].Name == "behav") + self.assertEqual(len(design.Documents[0].Architectures), 1) + self.assertTrue(design.Documents[0].Architectures[0].Name == "behav") diff --git a/testsuite/pyunit/dom/SimplePackage.py b/testsuite/pyunit/dom/SimplePackage.py index 5b16e74b8..399a676b4 100644 --- a/testsuite/pyunit/dom/SimplePackage.py +++ b/testsuite/pyunit/dom/SimplePackage.py @@ -1,31 +1,63 @@ -from pathlib import Path +# ============================================================================= +# ____ _ _ ____ _ _ +# _ __ _ _ / ___| | | | _ \| | __| | ___ _ __ ___ +# | '_ \| | | | | _| |_| | | | | | / _` |/ _ \| '_ ` _ \ +# | |_) | |_| | |_| | _ | |_| | |___ | (_| | (_) | | | | | | +# | .__/ \__, |\____|_| |_|____/|_____(_)__,_|\___/|_| |_| |_| +# |_| |___/ +# ============================================================================= +# Authors: +# Patrick Lehmann +# +# Testsuite: Check libghdl IIR translation with a simple 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 +# ============================================================================ +from pathlib import Path from unittest import TestCase -from pyGHDL.dom.NonStandard import Design, Document +from pyGHDL.dom.NonStandard import Design, Document if __name__ == "__main__": - print("ERROR: you called a testcase declaration file as an executable module.") - print("Use: 'python -m unitest <testcase module>'") - exit(1) + print("ERROR: you called a testcase declaration file as an executable module.") + print("Use: 'python -m unitest <testcase module>'") + exit(1) class SimplePackage(TestCase): - _root = Path(__file__).resolve().parent.parent - _filename : Path = _root / "SimplePackage.vhdl" + _root = Path(__file__).resolve().parent.parent + _filename: Path = _root / "SimplePackage.vhdl" - def test_Package(self): - design = Design() - document = Document(self._filename) - design.Documents.append(document) + def test_Package(self): + design = Design() + document = Document(self._filename) + design.Documents.append(document) - self.assertEqual(len(design.Documents[0].Packages), 1) - self.assertTrue(design.Documents[0].Packages[0].Name == "pack_1") + self.assertEqual(len(design.Documents[0].Packages), 1) + self.assertTrue(design.Documents[0].Packages[0].Name == "pack_1") - def test_PackageBody(self): - design = Design() - document = Document(self._filename) - design.Documents.append(document) + def test_PackageBody(self): + design = Design() + document = Document(self._filename) + design.Documents.append(document) - self.assertEqual(len(design.Documents[0].PackageBodies), 1) - self.assertTrue(design.Documents[0].PackageBodies[0].Name == "pack_1") + self.assertEqual(len(design.Documents[0].PackageBodies), 1) + self.assertTrue(design.Documents[0].PackageBodies[0].Name == "pack_1") diff --git a/testsuite/pyunit/dom/__init__.py b/testsuite/pyunit/dom/__init__.py index e69de29bb..4991df255 100644 --- a/testsuite/pyunit/dom/__init__.py +++ b/testsuite/pyunit/dom/__init__.py @@ -0,0 +1,32 @@ +# ============================================================================= +# ____ _ _ ____ _ _ +# _ __ _ _ / ___| | | | _ \| | __| | ___ _ __ ___ +# | '_ \| | | | | _| |_| | | | | | / _` |/ _ \| '_ ` _ \ +# | |_) | |_| | |_| | _ | |_| | |___ | (_| | (_) | | | | | | +# | .__/ \__, |\____|_| |_|____/|_____(_)__,_|\___/|_| |_| |_| +# |_| |___/ +# ============================================================================= +# Authors: +# Patrick Lehmann +# +# Testsuite: Check libghdl IIR translation to DOM. +# +# 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 +# ============================================================================ diff --git a/testsuite/pyunit/libghdl/Initialize.py b/testsuite/pyunit/libghdl/Initialize.py index 369faee07..2fd09965b 100644 --- a/testsuite/pyunit/libghdl/Initialize.py +++ b/testsuite/pyunit/libghdl/Initialize.py @@ -1,63 +1,73 @@ -from pathlib import Path -from unittest import TestCase +from pathlib import Path +from unittest import TestCase -import pyGHDL.libghdl as libghdl -from pyGHDL.libghdl import name_table, files_map, errorout_console -from pyGHDL.libghdl.vhdl import nodes, sem_lib +import pyGHDL.libghdl as libghdl +from pyGHDL.libghdl import name_table, files_map, errorout_console +from pyGHDL.libghdl.vhdl import nodes, sem_lib if __name__ == "__main__": - print("ERROR: you called a testcase declaration file as an executable module.") - print("Use: 'python -m unitest <testcase module>'") - exit(1) + print("ERROR: you called a testcase declaration file as an executable module.") + print("Use: 'python -m unitest <testcase module>'") + exit(1) class Instantiate(TestCase): - _root = Path(__file__).resolve().parent.parent - _filename : Path = _root / "SimpleEntity.vhdl" - - @staticmethod - def getIdentifier(node): - """Return the Python string from node :obj:`node` identifier.""" - return name_table.Get_Name_Ptr(nodes.Get_Identifier(node)) - - def test_InitializeGHDL(self) -> None: - """Initialization: set options and then load libaries.""" - libghdl.initialize() - - # Print error messages on the console. - errorout_console.Install_Handler() - - # Set options. This must be done before analyze_init() - libghdl.set_option("--std=08") - - # Finish initialization. This will load the standard package. - if libghdl.analyze_init_status() != 0: - self.fail("libghdl initialization error") - - # Load the file - file_id = name_table.Get_Identifier(str(self._filename)) - sfe = files_map.Read_Source_File(name_table.Null_Identifier, file_id) - if sfe == files_map.No_Source_File_Entry: - self.fail("Cannot read file '{!s}'".format(self._filename)) - - # Parse - file = sem_lib.Load_File(sfe) - - # Display all design units - designUnit = nodes.Get_First_Design_Unit(file) - while designUnit != nodes.Null_Iir: - libraryUnit = nodes.Get_Library_Unit(designUnit) - - if nodes.Get_Kind(libraryUnit) == nodes.Iir_Kind.Entity_Declaration: - entityName = self.getIdentifier(libraryUnit) - self.assertEqual(entityName, "entity_1", "expected entity name 'e1', got '{}'".format(entityName)) - - elif nodes.Get_Kind(libraryUnit) == nodes.Iir_Kind.Architecture_Body: - architectureName = self.getIdentifier(libraryUnit) - self.assertEqual(architectureName, "behav", "expected architecture name 'behav', got '{}'".format(architectureName)) - - else: - self.fail("Unknown unit.") - - designUnit = nodes.Get_Chain(designUnit) + _root = Path(__file__).resolve().parent.parent + _filename: Path = _root / "SimpleEntity.vhdl" + + @staticmethod + def getIdentifier(node): + """Return the Python string from node :obj:`node` identifier.""" + return name_table.Get_Name_Ptr(nodes.Get_Identifier(node)) + + def test_InitializeGHDL(self) -> None: + """Initialization: set options and then load libaries.""" + libghdl.initialize() + + # Print error messages on the console. + errorout_console.Install_Handler() + + # Set options. This must be done before analyze_init() + libghdl.set_option("--std=08") + + # Finish initialization. This will load the standard package. + if libghdl.analyze_init_status() != 0: + self.fail("libghdl initialization error") + + # Load the file + file_id = name_table.Get_Identifier(str(self._filename)) + sfe = files_map.Read_Source_File(name_table.Null_Identifier, file_id) + if sfe == files_map.No_Source_File_Entry: + self.fail("Cannot read file '{!s}'".format(self._filename)) + + # Parse + file = sem_lib.Load_File(sfe) + + # Display all design units + designUnit = nodes.Get_First_Design_Unit(file) + while designUnit != nodes.Null_Iir: + libraryUnit = nodes.Get_Library_Unit(designUnit) + + if nodes.Get_Kind(libraryUnit) == nodes.Iir_Kind.Entity_Declaration: + entityName = self.getIdentifier(libraryUnit) + self.assertEqual( + entityName, + "entity_1", + "expected entity name 'e1', got '{}'".format(entityName), + ) + + elif nodes.Get_Kind(libraryUnit) == nodes.Iir_Kind.Architecture_Body: + architectureName = self.getIdentifier(libraryUnit) + self.assertEqual( + architectureName, + "behav", + "expected architecture name 'behav', got '{}'".format( + architectureName + ), + ) + + else: + self.fail("Unknown unit.") + + designUnit = nodes.Get_Chain(designUnit) diff --git a/testsuite/pyunit/lsp/LanguageServer.py b/testsuite/pyunit/lsp/LanguageServer.py index c1bcf1898..a406dce91 100644 --- a/testsuite/pyunit/lsp/LanguageServer.py +++ b/testsuite/pyunit/lsp/LanguageServer.py @@ -14,207 +14,216 @@ is_windows = os.name == "nt" class StrConn: - __res: str + __res: str - def __init__(self): - self.__res = '' + def __init__(self): + self.__res = "" - def write(self, s): - self.__res += s + def write(self, s): + self.__res += s - @property - def res(self): - return self.__res + @property + def res(self): + return self.__res def show_diffs(name, ref, res): - if isinstance(ref, dict) and isinstance(res, dict): - for k in ref: - if k not in res: - print('{}.{} not in the result'.format(name, k)) - else: - show_diffs('{}.{}'.format(name, k), ref[k], res[k]) - for k in res: - if k not in ref: - print('{}.{} unexpected in the result'.format(name, k)) - elif isinstance(ref, str) and isinstance(res, str): - if res != ref: - print('{}: mismatch (ref: {}, result: {})'.format(name, ref, res)) - elif isinstance(ref, int) and isinstance(res, int): - if res != ref: - print('{}: mismatch (ref: {}, result: {})'.format(name, ref, res)) - elif isinstance(ref, list) and isinstance(res, list): - for i in range(max(len(ref), len(res))): - if i >= len(ref): - print('{}[{}]: missing element:'.format(name, i)) - print(' {}'.format(res[i])) - elif i >= len(res): - print('{}[{}]: extra elements'.format(name, i)) - else: - show_diffs('{}[{}]'.format(name, i), ref[i], res[i]) - else: - print('unhandle type {} in {}'.format(type(ref), name)) + if isinstance(ref, dict) and isinstance(res, dict): + for k in ref: + if k not in res: + print("{}.{} not in the result".format(name, k)) + else: + show_diffs("{}.{}".format(name, k), ref[k], res[k]) + for k in res: + if k not in ref: + print("{}.{} unexpected in the result".format(name, k)) + elif isinstance(ref, str) and isinstance(res, str): + if res != ref: + print("{}: mismatch (ref: {}, result: {})".format(name, ref, res)) + elif isinstance(ref, int) and isinstance(res, int): + if res != ref: + print("{}: mismatch (ref: {}, result: {})".format(name, ref, res)) + elif isinstance(ref, list) and isinstance(res, list): + for i in range(max(len(ref), len(res))): + if i >= len(ref): + print("{}[{}]: missing element:".format(name, i)) + print(" {}".format(res[i])) + elif i >= len(res): + print("{}[{}]: extra elements".format(name, i)) + else: + show_diffs("{}[{}]".format(name, i), ref[i], res[i]) + else: + print("unhandle type {} in {}".format(type(ref), name)) def root_subst(obj, path, uri): - """Substitute in all strings of :param obj: @ROOT@ with :param root: + """Substitute in all strings of :param obj: @ROOT@ with :param root: URI in LSP are supposed to contain an absolute path. But putting an hard absolute path would make the test suite not portable. So we use the metaname @ROOT@ which should be replaced by the root path of the test suite. Also we need to deal with the windows particularity about URI.""" - if isinstance(obj, dict): - for k, v in obj.items(): - if isinstance(v, str): - if k in ('rootUri', 'uri'): - assert v.startswith("file://@ROOT@/") - obj[k] = "file://" + quote(uri + v[13:]) - elif k in ('rootPath', 'message'): - obj[k] = v.replace('@ROOT@', path) - else: - obj[k] = root_subst(v, path, uri) - return obj - elif obj is None or isinstance(obj, (str, int)): - return obj - elif isinstance(obj, list): - res = [] - for v in obj: - res.append(root_subst(v, path, uri)) - return res - else: - raise AssertionError("root_subst: unhandled type {}".format(type(obj))) + if isinstance(obj, dict): + for k, v in obj.items(): + if isinstance(v, str): + if k in ("rootUri", "uri"): + assert v.startswith("file://@ROOT@/") + obj[k] = "file://" + quote(uri + v[13:]) + elif k in ("rootPath", "message"): + obj[k] = v.replace("@ROOT@", path) + else: + obj[k] = root_subst(v, path, uri) + return obj + elif obj is None or isinstance(obj, (str, int)): + return obj + elif isinstance(obj, list): + res = [] + for v in obj: + res.append(root_subst(v, path, uri)) + return res + else: + raise AssertionError("root_subst: unhandled type {}".format(type(obj))) class JSONTest(TestCase): - _LSPTestDirectory = Path(__file__).parent.resolve() - - subdir = None - - def _RequestResponse(self, requestName: str, responseName: Optional[str] = None): - root = str(self._LSPTestDirectory) - root_uri = self._LSPTestDirectory.as_uri() - assert(root_uri.startswith("file://")) - root_uri = root_uri[7:] - requestFile = self._LSPTestDirectory / self.subdir / requestName - # Convert the JSON input file to an LSP string. - with requestFile.open('r') as file: - res = json_load(file) - res = root_subst(res, root, root_uri) - - conn = StrConn() - ls = LanguageProtocolServer(None, conn) - for req in res: - ls.write_output(req) - - # Run - p = subprocess_run( - [executable, '-m', 'pyGHDL.cli.lsp'], - input=conn.res.encode('utf-8'), - stdout=PIPE) - self.assertEqual(p.returncode, 0, "Language server executable exit with a non-zero return code.") - - if responseName is None: - return - responseFile = self._LSPTestDirectory / self.subdir / responseName - - # Check output - in_io = BytesIO(p.stdout) - conn = LSPConn(in_io, None) - ls = LanguageProtocolServer(None, conn) - with responseFile.open('r') as file: - ref = json_load(file) - ref = root_subst(ref, root, root_uri) - - errs = 0 - json_res = [] - for i, r in enumerate(ref): - rep = ls.read_request() - if rep is None: - print('FAIL: number of reply does not match') - errs += 1 - break - - rep = json_loads(rep) - json_res.append(rep) -# self.assertEqual(rep, r, "reply does not match for {!s}".format(requestFile)) - if rep != r: - print(self.__class__.__name__) - show_diffs("[{}]".format(i), r, rep) - errs += 1 - - rep = ls.read_request() - self.assertIsNone(rep, "Too many replies.") - - if errs != 0: - print('FAILURE between output and {!s} (for {!s})'.format(responseFile, requestFile)) - print('Writing result output to result.json') - with open('result.json', 'w') as f: - f.write(json_dumps(json_res, indent=2)) - f.write('\n') - with open('request.json', 'w') as f: - f.write(json_dumps(res, indent=2)) - f.write('\n') - - self.fail() + _LSPTestDirectory = Path(__file__).parent.resolve() + + subdir = None + + def _RequestResponse(self, requestName: str, responseName: Optional[str] = None): + root = str(self._LSPTestDirectory) + root_uri = self._LSPTestDirectory.as_uri() + assert root_uri.startswith("file://") + root_uri = root_uri[7:] + requestFile = self._LSPTestDirectory / self.subdir / requestName + # Convert the JSON input file to an LSP string. + with requestFile.open("r") as file: + res = json_load(file) + res = root_subst(res, root, root_uri) + + conn = StrConn() + ls = LanguageProtocolServer(None, conn) + for req in res: + ls.write_output(req) + + # Run + p = subprocess_run( + [executable, "-m", "pyGHDL.cli.lsp"], + input=conn.res.encode("utf-8"), + stdout=PIPE, + ) + self.assertEqual( + p.returncode, + 0, + "Language server executable exit with a non-zero return code.", + ) + + if responseName is None: + return + responseFile = self._LSPTestDirectory / self.subdir / responseName + + # Check output + in_io = BytesIO(p.stdout) + conn = LSPConn(in_io, None) + ls = LanguageProtocolServer(None, conn) + with responseFile.open("r") as file: + ref = json_load(file) + ref = root_subst(ref, root, root_uri) + + errs = 0 + json_res = [] + for i, r in enumerate(ref): + rep = ls.read_request() + if rep is None: + print("FAIL: number of reply does not match") + errs += 1 + break + + rep = json_loads(rep) + json_res.append(rep) + # self.assertEqual(rep, r, "reply does not match for {!s}".format(requestFile)) + if rep != r: + print(self.__class__.__name__) + show_diffs("[{}]".format(i), r, rep) + errs += 1 + + rep = ls.read_request() + self.assertIsNone(rep, "Too many replies.") + + if errs != 0: + print( + "FAILURE between output and {!s} (for {!s})".format( + responseFile, requestFile + ) + ) + print("Writing result output to result.json") + with open("result.json", "w") as f: + f.write(json_dumps(json_res, indent=2)) + f.write("\n") + with open("request.json", "w") as f: + f.write(json_dumps(res, indent=2)) + f.write("\n") + + self.fail() class Test001_Simple(JSONTest): - subdir = Path("001simple") + subdir = Path("001simple") - def test_Request_Response(self): - self._RequestResponse("cmds.json", "replies.json") + def test_Request_Response(self): + self._RequestResponse("cmds.json", "replies.json") class Test002_Coverage(JSONTest): - subdir = Path("002coverage") + subdir = Path("002coverage") - def test_Request_Response(self): - self._RequestResponse("cmds.json", "replies.json") + def test_Request_Response(self): + self._RequestResponse("cmds.json", "replies.json") class Test003_Errors(JSONTest): - subdir = Path("003errors") + subdir = Path("003errors") - def test_Crash1(self): - self._RequestResponse("crash1.json") + def test_Crash1(self): + self._RequestResponse("crash1.json") - def test_Crash2(self): - self._RequestResponse("crash2.json") + def test_Crash2(self): + self._RequestResponse("crash2.json") - def test_Request_Response(self): - self._RequestResponse("cmds.json", "replies.json") + def test_Request_Response(self): + self._RequestResponse("cmds.json", "replies.json") class Test004_Error_Project(JSONTest): - subdir = Path("004errprj") + subdir = Path("004errprj") - def test_Request_Response(self): - self._RequestResponse("cmds.json", "replies.json") + def test_Request_Response(self): + self._RequestResponse("cmds.json", "replies.json") class Test005_Create(JSONTest): - subdir = Path("005create") + subdir = Path("005create") - def test_Request_Response(self): - self._RequestResponse("cmds.json", "replies.json") + def test_Request_Response(self): + self._RequestResponse("cmds.json", "replies.json") class Test006_Option_Error(JSONTest): - subdir = Path("006opterr") + subdir = Path("006opterr") - def test_Request_Response(self): - self._RequestResponse("cmds.json", "replies.json") + def test_Request_Response(self): + self._RequestResponse("cmds.json", "replies.json") class Test007_Error_Project(JSONTest): - subdir = Path("007errprj") + subdir = Path("007errprj") - def test_Request_Response(self): - self._RequestResponse("cmds.json", "replies.json") + def test_Request_Response(self): + self._RequestResponse("cmds.json", "replies.json") class Test008_Error_NoFile(JSONTest): - subdir = Path("008errnofile") + subdir = Path("008errnofile") - def test_Request_Response(self): - self._RequestResponse("cmds.json", "replies.json") + def test_Request_Response(self): + self._RequestResponse("cmds.json", "replies.json") |