def parse(cls, reportNode: Iir, label: str) -> "SequentialReportStatement":
from pyGHDL.dom._Translate import GetExpressionFromNode
message = GetExpressionFromNode(nodes.Get_Report_Expression(reportNode))
severityNode = nodes.Get_Severity_Expression(reportNode)
severity = None if severityNode is nodes.Null_Iir else GetExpressionFromNode(severityNode)
return cls(reportNode, message, severity, label)
def parse(cls, assertNode: Iir, label: str) -> "SequentialAssertStatement":
from pyGHDL.dom._Translate import GetExpressionFromNode
condition = GetExpressionFromNode(nodes.Get_Assertion_Condition(assertNode))
messageNode = nodes.Get_Report_Expression(assertNode)
message = None if messageNode is nodes.Null_Iir else GetExpressionFromNode(messageNode)
severityNode = nodes.Get_Severity_Expression(assertNode)
severity = None if severityNode is nodes.Null_Iir else GetExpressionFromNode(severityNode)
return cls(assertNode, condition, message, severity, label)
def parse(cls, node: Iir) -> Union["AscendingRangeExpression", "DescendingRangeExpression"]:
from pyGHDL.dom._Translate import GetExpressionFromNode
direction = nodes.Get_Direction(node)
leftBound = GetExpressionFromNode(nodes.Get_Left_Limit_Expr(node))
rightBound = GetExpressionFromNode(nodes.Get_Right_Limit_Expr(node))
if not direction: # ascending
return AscendingRangeExpression(node, leftBound, rightBound)
else:
return DescendingRangeExpression(node, leftBound, rightBound)
def parse(cls, waveNode: Iir):
from pyGHDL.dom._Translate import GetExpressionFromNode
value = GetExpressionFromNode(nodes.Get_We_Value(waveNode))
timeNode = nodes.Get_Time(waveNode)
if timeNode is nodes.Null_Iir:
time = None
else:
time = GetExpressionFromNode(timeNode)
return cls(waveNode, value, time)
def parse(cls, assertNode: Iir, label: str) -> "ConcurrentAssertStatement":
from pyGHDL.dom._Translate import GetExpressionFromNode
# FIXME: how to get the condition?
# assertNode is a Psl_Assert_Directive
condition = None # GetExpressionFromNode(nodes.Get_Assertion_Condition(assertNode))
messageNode = nodes.Get_Report_Expression(assertNode)
message = None if messageNode is nodes.Null_Iir else GetExpressionFromNode(messageNode)
severityNode = nodes.Get_Severity_Expression(assertNode)
severity = None if severityNode is nodes.Null_Iir else GetExpressionFromNode(severityNode)
return cls(assertNode, condition, message, severity, 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, node: Iir) -> "QualifiedExpression":
from pyGHDL.dom._Translate import GetExpressionFromNode, GetNameOfNode
typeMarkName = GetNameOfNode(nodes.Get_Type_Mark(node))
subtype = SimpleSubtypeSymbol(node, typeMarkName)
operand = GetExpressionFromNode(nodes.Get_Expression(node))
return cls(node, subtype, operand)
def parse(cls, constantNode: Iir) -> Union["Constant", "DeferredConstant"]:
from pyGHDL.dom._Translate import (
GetSubtypeIndicationFromNode,
GetExpressionFromNode,
)
name = GetNameOfNode(constantNode)
subtypeIndication = GetSubtypeIndicationFromNode(constantNode, "constant", name)
defaultValue = nodes.Get_Default_Value(constantNode)
if defaultValue != nodes.Null_Iir:
defaultExpression = GetExpressionFromNode(defaultValue)
return cls(
constantNode,
[
name,
],
subtypeIndication,
defaultExpression,
)
else:
return DeferredConstant(
constantNode,
[
name,
],
subtypeIndication,
)
def parse(cls, waitNode: Iir, label: str) -> "WaitStatement":
from pyGHDL.dom._Utils import GetIirKindOfNode
from pyGHDL.dom._Translate import GetExpressionFromNode
sensitivityList = None
sensitivityListNode = nodes.Get_Sensitivity_List(waitNode)
if sensitivityListNode is not nodes.Null_Iir:
print(GetIirKindOfNode(sensitivityListNode))
conditionNode = nodes.Get_Condition_Clause(waitNode)
condition = None if conditionNode is nodes.Null_Iir else GetExpressionFromNode(conditionNode)
timeoutNode = nodes.Get_Timeout_Clause(waitNode)
timeout = None if timeoutNode is nodes.Null_Iir else GetExpressionFromNode(timeoutNode)
return cls(waitNode, sensitivityList, condition, timeout, label)
def parse(cls, branchNode: Iir, label: str) -> "IfBranch":
from pyGHDL.dom._Translate import (
GetSequentialStatementsFromChainedNodes,
GetExpressionFromNode,
)
condition = GetExpressionFromNode(nodes.Get_Condition(branchNode))
statementChain = nodes.Get_Sequential_Statement_Chain(branchNode)
statements = GetSequentialStatementsFromChainedNodes(statementChain, "if branch", label)
return cls(branchNode, condition, statements)
def parse(cls, genericNode: Iir) -> "GenericConstantInterfaceItem":
name = GetNameOfNode(genericNode)
mode = GetModeOfNode(genericNode)
subtypeIndication = GetSubtypeIndicationFromNode(genericNode, "generic", name)
default = nodes.Get_Default_Value(genericNode)
value = GetExpressionFromNode(default) if default else None
return cls(
genericNode,
[
name,
],
mode,
subtypeIndication,
value,
)
def parse(cls, parameterNode: Iir) -> "ParameterSignalInterfaceItem":
name = GetNameOfNode(parameterNode)
mode = GetModeOfNode(parameterNode)
subtypeIndication = GetSubtypeIndicationFromNode(parameterNode, "parameter", name)
defaultValue = nodes.Get_Default_Value(parameterNode)
value = GetExpressionFromNode(defaultValue) if defaultValue != nodes.Null_Iir else None
return cls(
parameterNode,
[
name,
],
mode,
subtypeIndication,
value,
)
def parse(cls, attributeNode: Iir) -> "AttributeSpecification":
attributeDesignator = nodes.Get_Attribute_Designator(attributeNode)
attributeName = GetNameFromNode(attributeDesignator)
names = []
entityNameList = nodes.Get_Entity_Name_List(attributeNode)
for name in utils.flist_iter(entityNameList):
nameKind = GetIirKindOfNode(name)
if nameKind == nodes.Iir_Kind.Simple_Name:
names.append(SimpleName(name, GetNameOfNode(name)))
elif nameKind == nodes.Iir_Kind.Signature:
print(
"[NOT IMPLEMENTED] Signature name in attribute specifications."
)
else:
position = Position.parse(name)
raise DOMException(
"Unknown name kind '{kind}' in attribute specification '{attr}' at {file}:{line}:{column}."
.format(
kind=nameKind.name,
attr=attributeNode,
file=position.Filename,
line=position.Line,
column=position.Column,
))
entityClassToken = nodes.Get_Entity_Class(attributeNode)
try:
entityClass = _TOKEN_TRANSLATION[entityClassToken]
except KeyError:
position = Position.parse(attributeNode)
raise DOMException(
"Unknown token '{token}' in attribute specification for entity class '{entityClass}' at {file}:{line}:{column}."
.format(
token=entityClassToken.name,
entityClass=attributeNode,
file=position.Filename,
line=position.Line,
column=position.Column,
))
expression = GetExpressionFromNode(nodes.Get_Expression(attributeNode))
return cls(attributeNode, names, attributeName, entityClass,
expression)
def parse(cls, signalNode: Iir) -> "Signal":
from pyGHDL.dom._Translate import (
GetSubtypeIndicationFromNode,
GetExpressionFromNode,
)
name = GetNameOfNode(signalNode)
subtypeIndication = GetSubtypeIndicationFromNode(signalNode, "signal", name)
default = nodes.Get_Default_Value(signalNode)
defaultExpression = GetExpressionFromNode(default) if default else None
return cls(
signalNode,
[
name,
],
subtypeIndication,
defaultExpression,
)
def parse(cls, variableNode: Iir) -> "Variable":
from pyGHDL.dom._Translate import (
GetSubtypeIndicationFromNode,
GetExpressionFromNode,
)
name = GetNameOfNode(variableNode)
subtypeIndication = GetSubtypeIndicationFromNode(variableNode, "variable", name)
defaultValue = nodes.Get_Default_Value(variableNode)
defaultExpression = None
if defaultValue != nodes.Null_Iir:
defaultExpression = GetExpressionFromNode(defaultValue)
return cls(
variableNode,
[
name,
],
subtypeIndication,
defaultExpression,
)
def parse(cls, generateNode: Iir, condition: Iir) -> "ElsifGenerateBranch":
from pyGHDL.dom._Translate import (
GetDeclaredItemsFromChainedNodes,
GetConcurrentStatementsFromChainedNodes,
GetExpressionFromNode,
)
condition = GetExpressionFromNode(condition)
body = nodes.Get_Generate_Statement_Body(generateNode)
# TODO: alternative label
# alternativeLabelId = nodes.Get_Alternative_Label(body)
alternativeLabel = ""
declarationChain = nodes.Get_Declaration_Chain(body)
declaredItems = GetDeclaredItemsFromChainedNodes(declarationChain, "elsif-generate branch", alternativeLabel)
statementChain = nodes.Get_Concurrent_Statement_Chain(body)
statements = GetConcurrentStatementsFromChainedNodes(statementChain, "elsif-generate branch", alternativeLabel)
return cls(generateNode, condition, declaredItems, statements, alternativeLabel)
def parse(cls, node: Iir) -> VHDLModel_UnaryExpression:
from pyGHDL.dom._Translate import GetExpressionFromNode
operand = GetExpressionFromNode(nodes.Get_Operand(node))
return cls(node, operand)
def parse(cls, node: Iir) -> "ParenthesisExpression":
from pyGHDL.dom._Translate import GetExpressionFromNode
operand = GetExpressionFromNode(nodes.Get_Expression(node))
return cls(node, operand)
def parse(cls, node: Iir) -> "QualifiedExpressionAllocation":
from pyGHDL.dom._Translate import GetExpressionFromNode
expression = GetExpressionFromNode(nodes.Get_Expression(node))
return cls(node, expression)
def parse(cls, caseNode: Iir, label: str) -> "CaseStatement":
from pyGHDL.dom._Utils import GetIirKindOfNode
from pyGHDL.dom._Translate import (
GetExpressionFromNode,
GetRangeFromNode,
GetNameFromNode,
)
expression = GetExpressionFromNode(nodes.Get_Expression(caseNode))
cases = []
choices = None
alternative = nodes.Get_Case_Statement_Alternative_Chain(caseNode)
cNode = alternative
while alternative != nodes.Null_Iir:
choiceKind = GetIirKindOfNode(alternative)
sameAlternative = nodes.Get_Same_Alternative_Flag(alternative)
if choiceKind in (
nodes.Iir_Kind.Choice_By_Name,
nodes.Iir_Kind.Choice_By_Expression,
):
choiceExpression = GetExpressionFromNode(nodes.Get_Choice_Expression(alternative))
choice = IndexedChoice(alternative, choiceExpression)
if sameAlternative:
choices.append(choice)
alternative = nodes.Get_Chain(alternative)
continue
elif choiceKind is nodes.Iir_Kind.Choice_By_Range:
choiceRange = nodes.Get_Choice_Range(alternative)
choiceRangeKind = GetIirKindOfNode(choiceRange)
if choiceRangeKind == nodes.Iir_Kind.Range_Expression:
rng = GetRangeFromNode(choiceRange)
elif choiceRangeKind in (
nodes.Iir_Kind.Attribute_Name,
nodes.Iir_Kind.Parenthesis_Name,
):
rng = GetNameFromNode(choiceRange)
else:
pos = Position.parse(alternative)
raise DOMException(
"Unknown choice range kind '{kind}' in case statement at line {line}.".format(
kind=choiceRangeKind.name, line=pos.Line
)
)
choice = RangedChoice(alternative, rng)
if sameAlternative:
choices.append(choice)
alternative = nodes.Get_Chain(alternative)
continue
elif choiceKind is nodes.Iir_Kind.Choice_By_Others:
if choices is not None:
cases.append(Case.parse(alternative, choices, label))
choices = None
cases.append(OthersCase.parse(alternative, label))
alternative = nodes.Get_Chain(alternative)
cNode = alternative
continue
else:
pos = Position.parse(alternative)
raise DOMException(
"Unknown choice kind '{kind}' in case statement at line {line}.".format(
kind=choiceKind.name, line=pos.Line
)
)
if choices is not None:
cases.append(Case.parse(cNode, choices, label))
cNode = alternative
choices = [
choice,
]
alternative = nodes.Get_Chain(alternative)
if choices is not None:
cases.append(Case.parse(cNode, choices, label))
return cls(caseNode, label, expression, cases)
def parse(cls, node: Iir) -> VHDLModel_BinaryExpression:
from pyGHDL.dom._Translate import GetExpressionFromNode
left = GetExpressionFromNode(nodes.Get_Left(node))
right = GetExpressionFromNode(nodes.Get_Right(node))
return cls(node, left, right)