def parse(cls, contextNode: Iir): from pyGHDL.dom._Utils import GetIirKindOfNode name = GetNameOfNode(contextNode) items = [] names = [] for item in utils.chain_iter(nodes.Get_Context_Items(contextNode)): kind = GetIirKindOfNode(item) if kind is nodes.Iir_Kind.Library_Clause: names.append(SimpleName(item, GetNameOfNode(item))) if nodes.Get_Has_Identifier_List(item): continue items.append(LibraryClause(item, names)) names = [] elif kind is nodes.Iir_Kind.Use_Clause: items.append(UseClause.parse(item)) else: pos = Position.parse(item) raise DOMException( "Unknown context item kind '{kind}' in context at line {line}." .format(kind=kind.name, line=pos.Line)) return cls(contextNode, name, items)
def GetMapAspect(mapAspect: Iir, cls: Type, entity: str) -> Generator[AssociationItem, None, None]: for generic in utils.chain_iter(mapAspect): kind = GetIirKindOfNode(generic) if kind is nodes.Iir_Kind.Association_Element_By_Expression: formalNode = nodes.Get_Formal(generic) if formalNode is nodes.Null_Iir: formal = None else: formal = GetNameFromNode(formalNode) actual = GetExpressionFromNode(nodes.Get_Actual(generic)) yield cls(generic, actual, formal) elif kind is nodes.Iir_Kind.Association_Element_Open: formalNode = nodes.Get_Formal(generic) if formalNode is nodes.Null_Iir: formal = None else: formal = GetNameFromNode(formalNode) yield cls(generic, OpenName(generic), formal) else: pos = Position.parse(generic) raise DOMException( "Unknown association kind '{kind}' in {entity} map at line {line}." .format(kind=kind.name, entity=entity, line=pos.Line))
def parse(cls, typeName: str, typeDefinitionNode: Iir) -> "PhysicalType": from pyGHDL.dom._Utils import GetIirKindOfNode, GetNameOfNode from pyGHDL.dom._Translate import GetRangeFromNode, GetNameFromNode rangeConstraint = nodes.Get_Range_Constraint(typeDefinitionNode) rangeKind = GetIirKindOfNode(rangeConstraint) if rangeKind == nodes.Iir_Kind.Range_Expression: rng = GetRangeFromNode(rangeConstraint) elif rangeKind in ( nodes.Iir_Kind.Attribute_Name, nodes.Iir_Kind.Parenthesis_Name, ): rng = GetNameFromNode(rangeConstraint) else: pos = Position.parse(typeDefinitionNode) raise DOMException( "Unknown range kind '{kind}' in physical type definition at line {line}." .format(kind=rangeKind.name, line=pos.Line)) primaryUnit = nodes.Get_Primary_Unit(typeDefinitionNode) primaryUnitName = GetNameOfNode(primaryUnit) units = [] for secondaryUnit in utils.chain_iter( nodes.Get_Unit_Chain(typeDefinitionNode)): secondaryUnitName = GetNameOfNode(secondaryUnit) if secondaryUnit == primaryUnit: continue physicalLiteral = PhysicalIntegerLiteral.parse( nodes.Get_Physical_Literal(secondaryUnit)) units.append((secondaryUnitName, physicalLiteral)) return cls(typeDefinitionNode, typeName, rng, primaryUnitName, units)
def parse(cls, useNode: Iir): from pyGHDL.dom._Translate import GetNameFromNode uses = [GetNameFromNode(nodes.Get_Selected_Name(useNode))] for use in utils.chain_iter(nodes.Get_Use_Clause_Chain(useNode)): uses.append(GetNameFromNode(nodes.Get_Selected_Name(use))) return cls(useNode, uses)
def parse(cls, contextNode: Iir): from pyGHDL.dom._Translate import GetNameFromNode contexts = [GetNameFromNode(nodes.Get_Selected_Name(contextNode))] for context in utils.chain_iter( nodes.Get_Context_Reference_Chain(contextNode)): contexts.append(GetNameFromNode(nodes.Get_Selected_Name(context))) return cls(contextNode, contexts)
def GetParameterFromChainedNodes( nodeChain: Iir, ) -> Generator[ParameterInterfaceItem, None, None]: parameter = nodeChain while parameter != nodes.Null_Iir: kind = GetIirKindOfNode(parameter) if kind == nodes.Iir_Kind.Interface_Constant_Declaration: from pyGHDL.dom.InterfaceItem import ParameterConstantInterfaceItem param = ParameterConstantInterfaceItem.parse(parameter) elif kind == nodes.Iir_Kind.Interface_Variable_Declaration: from pyGHDL.dom.InterfaceItem import ParameterVariableInterfaceItem param = ParameterVariableInterfaceItem.parse(parameter) elif kind == nodes.Iir_Kind.Interface_Signal_Declaration: from pyGHDL.dom.InterfaceItem import ParameterSignalInterfaceItem param = ParameterSignalInterfaceItem.parse(parameter) elif kind == nodes.Iir_Kind.Interface_File_Declaration: from pyGHDL.dom.InterfaceItem import ParameterFileInterfaceItem param = ParameterFileInterfaceItem.parse(parameter) else: position = Position.parse(parameter) raise DOMException( "Unknown parameter kind '{kind}' in parameter '{param}' at {file}:{line}:{column}." .format( kind=kind.name, param=parameter, file=position.Filename, line=position.Line, column=position.Column, )) # Lookahead for parameters with multiple identifiers at once if nodes.Get_Has_Identifier_List(parameter): nextNode = nodes.Get_Chain(parameter) for nextParameter in utils.chain_iter(nextNode): # Consecutive identifiers are found, if the subtype indication is Null if nodes.Get_Subtype_Indication( nextParameter) == nodes.Null_Iir: param.Identifiers.append(GetNameOfNode(nextParameter)) else: parameter = nextParameter break # The last consecutive identifiers has no Identifier_List flag if not nodes.Get_Has_Identifier_List(nextParameter): parameter = nodes.Get_Chain(nextParameter) break else: parameter = nodes.Null_Iir else: parameter = nodes.Get_Chain(parameter) yield param
def parse(cls, assignmentNode: Iir, label: str = None) -> "SequentialSimpleSignalAssignment": from pyGHDL.dom._Translate import GetNameFromNode target = nodes.Get_Target(assignmentNode) targetName = GetNameFromNode(target) waveform = [] for wave in utils.chain_iter(nodes.Get_Waveform_Chain(assignmentNode)): waveform.append(WaveformElement.parse(wave)) return cls(assignmentNode, targetName, waveform, label)
def parse(cls, node: Iir) -> "Aggregate": from pyGHDL.dom._Translate import ( GetExpressionFromNode, GetRangeFromNode, GetNameFromNode, ) choices = [] choicesChain = nodes.Get_Association_Choices_Chain(node) for item in utils.chain_iter(choicesChain): kind = GetIirKindOfNode(item) value = GetExpressionFromNode(nodes.Get_Associated_Expr(item)) if kind == nodes.Iir_Kind.Choice_By_None: choices.append(SimpleAggregateElement(item, value)) elif kind == nodes.Iir_Kind.Choice_By_Expression: index = GetExpressionFromNode(nodes.Get_Choice_Expression(item)) choices.append(IndexedAggregateElement(item, index, value)) elif kind == nodes.Iir_Kind.Choice_By_Range: choiceRange = nodes.Get_Choice_Range(item) rangeKind = GetIirKindOfNode(choiceRange) if rangeKind == nodes.Iir_Kind.Range_Expression: rng = GetRangeFromNode(choiceRange) elif rangeKind in ( nodes.Iir_Kind.Attribute_Name, nodes.Iir_Kind.Parenthesis_Name, ): rng = GetNameFromNode(choiceRange) else: pos = Position.parse(item) raise DOMException( "Unknown discete range kind '{kind}' in for...generate statement at line {line}.".format( kind=rangeKind.name, line=pos.Line ) ) choices.append(RangedAggregateElement(item, rng, value)) elif kind == nodes.Iir_Kind.Choice_By_Name: name = GetNameFromNode(nodes.Get_Choice_Name(item)) symbol = Symbol(item, name) choices.append(NamedAggregateElement(item, symbol, value)) elif kind == nodes.Iir_Kind.Choice_By_Others: choices.append(OthersAggregateElement(item, value)) else: raise DOMException( "Unknown choice kind '{kind}' in aggregate '{aggr}'.".format(kind=kind.name, aggr=node) ) return cls(node, choices)
def parse(cls, typeName: str, typeDefinitionNode: Iir) -> "ProtectedType": from pyGHDL.dom._Utils import GetIirKindOfNode # FIXME: change this to a generator methods = [] for item in utils.chain_iter( nodes.Get_Declaration_Chain(typeDefinitionNode)): kind = GetIirKindOfNode(item) if kind == nodes.Iir_Kind.Function_Declaration: methods.append(Function.parse(item)) elif kind == nodes.Iir_Kind.Procedure_Declaration: methods.append(Procedure.parse(item)) return cls(typeDefinitionNode, typeName, methods)
def GetSequentialStatementsFromChainedNodes( nodeChain: Iir, entity: str, name: str) -> Generator[SequentialStatement, None, None]: for statement in utils.chain_iter(nodeChain): label = nodes.Get_Label(statement) label = name_table.Get_Name_Ptr( label) if label != nodes.Null_Iir else None pos = Position.parse(statement) kind = GetIirKindOfNode(statement) if kind == nodes.Iir_Kind.If_Statement: yield IfStatement.parse(statement, label) elif kind == nodes.Iir_Kind.For_Loop_Statement: yield ForLoopStatement.parse(statement, label) elif kind == nodes.Iir_Kind.Case_Statement: yield CaseStatement.parse(statement, label) elif kind == nodes.Iir_Kind.Simple_Signal_Assignment_Statement: yield SequentialSimpleSignalAssignment.parse(statement, label) elif kind in ( nodes.Iir_Kind.Variable_Assignment_Statement, nodes.Iir_Kind.Conditional_Variable_Assignment_Statement, ): print( "[NOT IMPLEMENTED] Variable assignment (label: '{label}') at line {line}" .format(label=label, line=pos.Line)) elif kind == nodes.Iir_Kind.Wait_Statement: yield WaitStatement.parse(statement, label) elif kind == nodes.Iir_Kind.Procedure_Call_Statement: yield SequentialProcedureCall.parse(statement, label) elif kind == nodes.Iir_Kind.Report_Statement: yield SequentialReportStatement.parse(statement, label) elif kind == nodes.Iir_Kind.Assertion_Statement: yield SequentialAssertStatement.parse(statement, label) elif kind == nodes.Iir_Kind.Null_Statement: yield NullStatement(statement, label) else: raise DOMException( "Unknown statement of kind '{kind}' in {entity} '{name}' at {file}:{line}:{column}." .format( kind=kind.name, entity=entity, name=name, file=pos.Filename, line=pos.Line, column=pos.Column, ))
def GetPortsFromChainedNodes( nodeChain: Iir, ) -> Generator[PortInterfaceItem, None, None]: port = nodeChain while port != nodes.Null_Iir: kind = GetIirKindOfNode(port) if kind == nodes.Iir_Kind.Interface_Signal_Declaration: from pyGHDL.dom.InterfaceItem import PortSignalInterfaceItem portSignal = PortSignalInterfaceItem.parse(port) # Lookahead for ports with multiple identifiers at once if nodes.Get_Has_Identifier_List(port): nextNode = nodes.Get_Chain(port) for nextPort in utils.chain_iter(nextNode): # Consecutive identifiers are found, if the subtype indication is Null if nodes.Get_Subtype_Indication( nextPort) == nodes.Null_Iir: portSignal.Identifiers.append(GetNameOfNode(nextPort)) else: port = nextPort break # The last consecutive identifiers has no Identifier_List flag if not nodes.Get_Has_Identifier_List(nextPort): port = nodes.Get_Chain(nextPort) break else: port = nodes.Null_Iir else: port = nodes.Get_Chain(port) yield portSignal continue else: position = Position.parse(port) raise DOMException( "Unknown port kind '{kind}' in port '{port}' at {file}:{line}:{column}." .format( kind=kind.name, port=port, file=position.Filename, line=position.Line, column=position.Column, ))
def GetAssociations(node: Iir) -> List: associations = [] for item in utils.chain_iter(nodes.Get_Association_Chain(node)): kind = GetIirKindOfNode(item) if kind in ( nodes.Iir_Kind.Association_Element_By_Expression, nodes.Iir_Kind.Association_Element_By_Name, ): actual = nodes.Get_Actual(item) expr = GetExpressionFromNode(actual) associations.append(expr) else: raise DOMException( "Unknown association kind '{kind}' in array index/slice or function call '{node}'." .format(kind=kind.name, node=node)) return associations
def get_symbols_chain(fe, n): res = [get_symbols(fe, el) for el in pyutils.chain_iter(n)] return [e for e in res if e is not None]
def __ghdlGetPorts(cls, entity): return pyutils.chain_iter(nodes.Get_Port_Chain(entity))
def __ghdlGetGenerics(cls, entity): return pyutils.chain_iter(nodes.Get_Generic_Chain(entity))
def GetGenericsFromChainedNodes( nodeChain: Iir, ) -> Generator[GenericInterfaceItem, None, None]: from pyGHDL.dom.InterfaceItem import ( GenericTypeInterfaceItem, GenericPackageInterfaceItem, GenericProcedureInterfaceItem, GenericFunctionInterfaceItem, ) generic = nodeChain while generic != nodes.Null_Iir: kind = GetIirKindOfNode(generic) if kind == nodes.Iir_Kind.Interface_Constant_Declaration: from pyGHDL.dom.InterfaceItem import GenericConstantInterfaceItem genericConstant = GenericConstantInterfaceItem.parse(generic) # Lookahead for generics with multiple identifiers at once if nodes.Get_Has_Identifier_List(generic): nextNode = nodes.Get_Chain(generic) for nextGeneric in utils.chain_iter(nextNode): # Consecutive identifiers are found, if the subtype indication is Null if nodes.Get_Subtype_Indication( nextGeneric) == nodes.Null_Iir: genericConstant.Identifiers.append( GetNameOfNode(nextGeneric)) else: generic = nextGeneric break # The last consecutive identifiers has no Identifier_List flag if not nodes.Get_Has_Identifier_List(nextGeneric): generic = nodes.Get_Chain(nextGeneric) break else: generic = nodes.Null_Iir else: generic = nodes.Get_Chain(generic) yield genericConstant continue else: if kind == nodes.Iir_Kind.Interface_Type_Declaration: yield GenericTypeInterfaceItem.parse(generic) elif kind == nodes.Iir_Kind.Interface_Package_Declaration: yield GenericPackageInterfaceItem.parse(generic) elif kind == nodes.Iir_Kind.Interface_Procedure_Declaration: yield GenericProcedureInterfaceItem.parse(generic) elif kind == nodes.Iir_Kind.Interface_Function_Declaration: yield GenericFunctionInterfaceItem.parse(generic) else: position = Position.parse(generic) raise DOMException( "Unknown generic kind '{kind}' in generic '{generic}' at {file}:{line}:{column}." .format( kind=kind.name, generic=generic, file=position.Filename, line=position.Line, column=position.Column, )) generic = nodes.Get_Chain(generic)
def GetDeclaredItemsFromChainedNodes( nodeChain: Iir, entity: str, name: str) -> Generator[ModelEntity, None, None]: item = nodeChain lastKind = None while item != nodes.Null_Iir: kind = GetIirKindOfNode(item) if kind == nodes.Iir_Kind.Constant_Declaration: from pyGHDL.dom.Object import Constant obj = Constant.parse(item) elif kind == nodes.Iir_Kind.Variable_Declaration: from pyGHDL.dom.Object import SharedVariable if nodes.Get_Shared_Flag(item): obj = SharedVariable.parse(item) else: obj = Variable.parse(item) elif kind == nodes.Iir_Kind.Signal_Declaration: from pyGHDL.dom.Object import Signal obj = Signal.parse(item) elif kind == nodes.Iir_Kind.File_Declaration: from pyGHDL.dom.Object import File obj = File.parse(item) else: if kind == nodes.Iir_Kind.Type_Declaration: yield GetTypeFromNode(item) elif kind == nodes.Iir_Kind.Anonymous_Type_Declaration: yield GetAnonymousTypeFromNode(item) elif kind == nodes.Iir_Kind.Subtype_Declaration: yield GetSubtypeFromNode(item) elif kind == nodes.Iir_Kind.Function_Declaration: if nodes.Get_Has_Body(item): yield Function.parse(item) else: print( "[NOT IMPLEMENTED] function declaration without body") lastKind = kind item = nodes.Get_Chain(item) continue elif kind == nodes.Iir_Kind.Function_Body: if lastKind is nodes.Iir_Kind.Function_Declaration: pass else: position = Position.parse(item) raise DOMException( "Found unexpected function body '{functionName}' in {entity} '{name}' at {file}:{line}:{column}." .format( functionName=GetNameOfNode(item), entity=entity, name=name, file=position.Filename, line=position.Line, column=position.Column, )) elif kind == nodes.Iir_Kind.Procedure_Declaration: if nodes.Get_Has_Body(item): yield Procedure.parse(item) else: print( "[NOT IMPLEMENTED] procedure declaration without body") lastKind = kind item = nodes.Get_Chain(item) continue elif kind == nodes.Iir_Kind.Procedure_Body: if lastKind is nodes.Iir_Kind.Procedure_Declaration: pass else: position = Position.parse(item) raise DOMException( "Found unexpected procedure body '{functionName}' in {entity} '{name}' at {file}:{line}:{column}." .format( functionName=GetNameOfNode(item), entity=entity, name=name, file=position.Filename, line=position.Line, column=position.Column, )) elif kind == nodes.Iir_Kind.Protected_Type_Body: yield ProtectedTypeBody.parse(item) elif kind == nodes.Iir_Kind.Object_Alias_Declaration: yield GetAliasFromNode(item) elif kind == nodes.Iir_Kind.Component_Declaration: from pyGHDL.dom.DesignUnit import Component yield Component.parse(item) elif kind == nodes.Iir_Kind.Attribute_Declaration: from pyGHDL.dom.Attribute import Attribute yield Attribute.parse(item) elif kind == nodes.Iir_Kind.Attribute_Specification: from pyGHDL.dom.Attribute import AttributeSpecification yield AttributeSpecification.parse(item) elif kind == nodes.Iir_Kind.Use_Clause: from pyGHDL.dom.DesignUnit import UseClause yield UseClause.parse(item) elif kind == nodes.Iir_Kind.Package_Declaration: from pyGHDL.dom.DesignUnit import Package yield Package.parse(item, None) # TODO: Can it have a context? elif kind == nodes.Iir_Kind.Package_Instantiation_Declaration: from pyGHDL.dom.DesignUnit import PackageInstantiation yield PackageInstantiation.parse(item) elif kind == nodes.Iir_Kind.Configuration_Specification: print( "[NOT IMPLEMENTED] Configuration specification in {name}". format(name=name)) elif kind == nodes.Iir_Kind.Psl_Default_Clock: yield DefaultClock.parse(item) elif kind == nodes.Iir_Kind.Group_Declaration: print("[NOT IMPLEMENTED] Group declaration in {name}".format( name=name)) elif kind == nodes.Iir_Kind.Group_Template_Declaration: print("[NOT IMPLEMENTED] Group template declaration in {name}". format(name=name)) elif kind == nodes.Iir_Kind.Disconnection_Specification: print("[NOT IMPLEMENTED] Disconnect specification in {name}". format(name=name)) else: position = Position.parse(item) raise DOMException( "Unknown declared item kind '{kind}' in {entity} '{name}' at {file}:{line}:{column}." .format( kind=kind.name, entity=entity, name=name, file=position.Filename, line=position.Line, column=position.Column, )) lastKind = None item = nodes.Get_Chain(item) continue # Lookahead for objects with multiple identifiers at once if nodes.Get_Has_Identifier_List(item): nextNode = nodes.Get_Chain(item) for nextItem in utils.chain_iter(nextNode): # Consecutive identifiers are found, if the subtype indication is Null if nodes.Get_Subtype_Indication(nextItem) == nodes.Null_Iir: obj.Identifiers.append(GetNameOfNode(nextItem)) else: item = nextItem break # The last consecutive identifiers has no Identifier_List flag if not nodes.Get_Has_Identifier_List(nextItem): item = nodes.Get_Chain(nextItem) break else: item = nodes.Null_Iir else: item = nodes.Get_Chain(item) yield obj
def translate(self): firstUnit = nodes.Get_First_Design_Unit(self.__ghdlFile) for unit in utils.chain_iter(firstUnit): libraryUnit = nodes.Get_Library_Unit(unit) nodeKind = GetIirKindOfNode(libraryUnit) contextItems = [] contextNames = [] context = nodes.Get_Context_Items(unit) if context is not nodes.Null_Iir: for item in utils.chain_iter(context): itemKind = GetIirKindOfNode(item) if itemKind is nodes.Iir_Kind.Library_Clause: contextNames.append( SimpleName(item, GetNameOfNode(item))) if nodes.Get_Has_Identifier_List(item): continue contextItems.append(LibraryClause(item, contextNames)) contextNames = [] elif itemKind is nodes.Iir_Kind.Use_Clause: contextItems.append(UseClause.parse(item)) elif itemKind is nodes.Iir_Kind.Context_Reference: contextItems.append(ContextReference.parse(item)) else: pos = Position.parse(item) raise DOMException( "Unknown context item kind '{kind}' in context at line {line}." .format(kind=itemKind.name, line=pos.Line)) if nodeKind == nodes.Iir_Kind.Entity_Declaration: entity = Entity.parse(libraryUnit, contextItems) self.Entities.append(entity) elif nodeKind == nodes.Iir_Kind.Architecture_Body: architecture = Architecture.parse(libraryUnit, contextItems) self.Architectures.append(architecture) elif nodeKind == nodes.Iir_Kind.Package_Declaration: package = Package.parse(libraryUnit, contextItems) self.Packages.append(package) elif nodeKind == nodes.Iir_Kind.Package_Body: packageBody = PackageBody.parse(libraryUnit, contextItems) self.PackageBodies.append(packageBody) elif nodeKind == nodes.Iir_Kind.Package_Instantiation_Declaration: package = PackageInstantiation.parse(libraryUnit) self.Packages.append(package) elif nodeKind == nodes.Iir_Kind.Context_Declaration: context = Context.parse(libraryUnit) self.Contexts.append(context) elif nodeKind == nodes.Iir_Kind.Configuration_Declaration: configuration = Configuration.parse(libraryUnit, contextItems) self.Configurations.append(configuration) elif nodeKind == nodes.Iir_Kind.Vunit_Declaration: vunit = VerificationUnit.parse(libraryUnit) self.VerificationUnits.append(vunit) elif nodeKind == nodes.Iir_Kind.Vprop_Declaration: vprop = VerificationProperty.parse(libraryUnit) self.VerificationProperties.append(vprop) elif nodeKind == nodes.Iir_Kind.Vmode_Declaration: vmod = VerificationMode.parse(libraryUnit) self.VerificationModes.append(vmod) else: raise DOMException("Unknown design unit kind '{kind}'.".format( kind=nodeKind.name))
def GetConcurrentStatementsFromChainedNodes( nodeChain: Iir, entity: str, name: str) -> Generator[ConcurrentStatement, None, None]: for statement in utils.chain_iter(nodeChain): label = nodes.Get_Label(statement) label = name_table.Get_Name_Ptr( label) if label != nodes.Null_Iir else None pos = Position.parse(statement) kind = GetIirKindOfNode(statement) if kind == nodes.Iir_Kind.Sensitized_Process_Statement: yield ProcessStatement.parse(statement, label, True) elif kind == nodes.Iir_Kind.Process_Statement: yield ProcessStatement.parse(statement, label, False) elif kind == nodes.Iir_Kind.Concurrent_Simple_Signal_Assignment: yield ConcurrentSimpleSignalAssignment.parse(statement, label) elif kind == nodes.Iir_Kind.Concurrent_Conditional_Signal_Assignment: print( "[NOT IMPLEMENTED] Concurrent (conditional) signal assignment (label: '{label}') at line {line}" .format(label=label, line=pos.Line)) elif kind == nodes.Iir_Kind.Concurrent_Selected_Signal_Assignment: print( "[NOT IMPLEMENTED] Concurrent (selected) signal assignment (label: '{label}') at line {line}" .format(label=label, line=pos.Line)) elif kind == nodes.Iir_Kind.Concurrent_Procedure_Call_Statement: yield ConcurrentProcedureCall.parse(statement, label) elif kind == nodes.Iir_Kind.Component_Instantiation_Statement: instantiatedUnit = nodes.Get_Instantiated_Unit(statement) instantiatedUnitKind = GetIirKindOfNode(instantiatedUnit) if instantiatedUnitKind == nodes.Iir_Kind.Entity_Aspect_Entity: yield EntityInstantiation.parse(statement, instantiatedUnit, label) elif instantiatedUnitKind == nodes.Iir_Kind.Entity_Aspect_Configuration: yield ConfigurationInstantiation.parse(statement, instantiatedUnit, label) elif instantiatedUnitKind == nodes.Iir_Kind.Simple_Name: yield ComponentInstantiation.parse(statement, instantiatedUnit, label) else: raise DOMException( "Unknown instantiation kind '{kind}' in instantiation of label {label} at {file}:{line}:{column}." .format( kind=instantiatedUnitKind.name, label=label, file=pos.Filename, line=pos.Line, column=pos.Column, )) elif kind == nodes.Iir_Kind.Block_Statement: yield ConcurrentBlockStatement.parse(statement, label) elif kind == nodes.Iir_Kind.If_Generate_Statement: yield IfGenerateStatement.parse(statement, label) elif kind == nodes.Iir_Kind.Case_Generate_Statement: yield CaseGenerateStatement.parse(statement, label) elif kind == nodes.Iir_Kind.For_Generate_Statement: yield ForGenerateStatement.parse(statement, label) elif kind == nodes.Iir_Kind.Psl_Assert_Directive: yield ConcurrentAssertStatement.parse(statement, label) else: raise DOMException( "Unknown statement of kind '{kind}' in {entity} '{name}' at {file}:{line}:{column}." .format( kind=kind.name, entity=entity, name=name, file=pos.Filename, line=pos.Line, column=pos.Column, ))