def GetNameOfNode(node: Iir) -> str:
"""Return the python string from node :obj:`node` identifier."""
if node == Null_Iir:
raise ValueError("GetNameOfNode: Parameter 'node' must not be 'Null_iir'.")
identifier = utils.Get_Source_Identifier(node)
return name_table.Get_Name_Ptr(identifier)
def create_interfaces(inters):
res = []
while inters != nodes.Null_Iir:
res.append({
"name":
name_table.Get_Name_Ptr(nodes.Get_Identifier(inters))
})
inters = nodes.Get_Chain(inters)
return res
def goto_definition(n, loc):
"Return the declaration (as a node) under :param loc: or None"
ref = find_def(n, loc)
log.debug("for loc %u found node %s", loc, ref)
if ref is None:
return None
log.debug(
"for loc %u id=%s",
loc,
name_table.Get_Name_Ptr(nodes.Get_Identifier(ref)),
)
ent = nodes.Get_Named_Entity(ref)
return None if ent == nodes.Null_Iir else ent
def parse(cls, node: Iir) -> "Position":
"""Return the source code position of a IIR node."""
if node == nodes.Null_Iir:
raise ValueError(
"Position.parse(): Parameter 'node' must not be 'Null_iir'.")
location = nodes.Get_Location(node)
file = files_map.Location_To_File(location)
fileNameId = files_map.Get_File_Name(file)
fileName = name_table.Get_Name_Ptr(fileNameId)
line = files_map.Location_File_To_Line(location, file)
column = files_map.Location_File_Line_To_Offset(location, file, line)
return cls(Path(fileName), line, column)
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 _ghdlNodeToName(cls, node):
"""Return the python string from node :obj:`node` identifier"""
return name_table.Get_Name_Ptr(nodes.Get_Identifier(node)).decode("utf-8")
def name_image(Id: NameId) -> str:
"""Lookup a :obj:`Id` and return its string."""
return name_table.Get_Name_Ptr(Id)
def name_image(nameid) -> str:
"""Lookup a :param:`nameid` and return its string."""
return name_table.Get_Name_Ptr(nameid).decode("utf-8")
def getIdentifier(node):
"""Return the Python string from node :obj:`node` identifier."""
return name_table.Get_Name_Ptr(nodes.Get_Identifier(node))
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,
))
def getIdentifier(node):
"""Return the Python string from node :param:`node` identifier"""
return name_table.Get_Name_Ptr(
nodes.Get_Identifier(node)).decode("utf-8")
