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, 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 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 parse(cls, typeName: str, typeDefinitionNode: Iir) -> "RecordType": from pyGHDL.dom._Utils import GetNameOfNode elements = [] elementDeclarations = nodes.Get_Elements_Declaration_List( typeDefinitionNode) elementCount = flists.Flast(elementDeclarations) + 1 index = 0 while index < elementCount: elementDeclaration = flists.Get_Nth_Element( elementDeclarations, index) element = RecordTypeElement.parse(elementDeclaration) # Lookahead for elements with multiple identifiers at once if nodes.Get_Has_Identifier_List(elementDeclaration): index += 1 while index < elementCount: nextNode: Iir = flists.Get_Nth_Element( elementDeclarations, index) # Consecutive identifiers are found, if the subtype indication is Null if nodes.Get_Subtype_Indication( nextNode) == nodes.Null_Iir: element.Identifiers.append(GetNameOfNode(nextNode)) else: break index += 1 # The last consecutive identifiers has no Identifier_List flag if not nodes.Get_Has_Identifier_List(nextNode): break else: index += 1 elements.append(element) return cls(typeDefinitionNode, typeName, elements)
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 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 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))