# ==================================================================================================================== #
# __ ___ _ ____ _ __ __ _ _ #
# _ __ _ \ \ / / | | | _ \| | | \/ | ___ __| | ___| | #
# | '_ \| | | \ \ / /| |_| | | | | | | |\/| |/ _ \ / _` |/ _ \ | #
# | |_) | |_| |\ V / | _ | |_| | |___| | | | (_) | (_| | __/ | #
# | .__/ \__, | \_/ |_| |_|____/|_____|_| |_|\___/ \__,_|\___|_| #
# |_| |___/ #
# ==================================================================================================================== #
# Authors: #
# Patrick Lehmann #
# #
# License: #
# ==================================================================================================================== #
# Copyright 2017-2026 Patrick Lehmann - Boetzingen, Germany #
# Copyright 2016-2017 Patrick Lehmann - Dresden, Germany #
# #
# Licensed under the Apache License, Version 2.0 (the "License"); #
# you may not use this file except in compliance with the License. #
# You may obtain a copy of the License at #
# #
# http://www.apache.org/licenses/LICENSE-2.0 #
# #
# Unless required by applicable law or agreed to in writing, software #
# distributed under the License is distributed on an "AS IS" BASIS, #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
# See the License for the specific language governing permissions and #
# limitations under the License. #
# #
# SPDX-License-Identifier: Apache-2.0 #
# ==================================================================================================================== #
#
"""
This module contains parts of an abstract document language model for VHDL.
Declarations for sequential statements.
"""
from __future__ import annotations
from typing import TYPE_CHECKING, ClassVar, Generator, Iterable, Optional as Nullable
from pyTooling.Common import getFullyQualifiedName, getTypeName
from pyTooling.Decorators import export, readonly
from pyTooling.MetaClasses import ExtendedType, abstractclass
from pyVHDLModel.Base import ModelEntity, ExpressionUnion, Range, BaseChoice, BaseCase, ConditionalMixin, \
IfBranchMixin, ElsifBranchMixin, ElseBranchMixin, ReportStatementMixin, \
AssertStatementMixin, WaveformElement, ChoicesMixin, LabeledEntityMixin, \
DocumentedEntityMixin, ReservedWord
from pyVHDLModel.Exception import AlreadyInDesignError, DuplicateLabelError, NotAChildError
from pyVHDLModel.Symbol import Symbol, SignalSymbol, VariableSymbol, LoopSymbol
from pyVHDLModel.Common import Statement, ProcedureCallMixin, AssignmentMixin, SignalAssignmentMixin, \
VariableAssignmentMixin, ConditionalWaveform, ConditionalExpression, \
ConditionalWaveformsMixin, WaveformMixin, ExpressionMixin, SelectedWaveformsMixin, \
SelectedExpressionsMixin, SelectedWaveform, SelectedExpression
from pyVHDLModel.Association import ParameterAssociationItem
if TYPE_CHECKING:
from pyVHDLModel.Regions import DeclarativeRegionMixin
from pyVHDLModel.Visitor import Visitor
@export
@abstractclass
class SequentialStatement(Statement):
"""
Represents the base-class of all sequential statements.
Sequential statements appear in a process or a subprogram body.
"""
@export
class SequentialStatementsMixin(metaclass=ExtendedType, mixin=True, expects=("_LabelRegion", )):
"""
A mixin-class for language constructs containing sequential statements.
The statements are available in declaration order as :data:`Statements`.
.. seealso::
* :class:`Process statement <pyVHDLModel.Concurrent.ProcessStatement>`
* :class:`Branch <pyVHDLModel.Sequential.Branch>`
* :class:`Sequential case <pyVHDLModel.Sequential.SequentialCase>`
* :class:`Loop statement <pyVHDLModel.Sequential.LoopStatement>`
* :class:`Subprogram <pyVHDLModel.Subprogram.Subprogram>`
"""
_statements: list[SequentialStatement] #: List of all sequential statements in this construct.
def __init__(self, statements: Nullable[Iterable[SequentialStatement]] = None) -> None:
# TODO: extract to mixin
"""
Initializes sequential statements.
:param statements: Optional, list of all sequential statements in this construct. Default: ``None``, no statements.
"""
self._statements = statementList = []
if statements is not None:
for item in statements:
statementList.append(item)
item.Parent = self
@readonly
def Statements(self) -> list[SequentialStatement]:
"""
Read-only property to access the list of sequential statements (:attr:`_statements`).
:returns: A list of sequential statements.
"""
return self._statements
def _VisitStatements(self, visitor: Visitor) -> None:
"""
Walk the sequential statements in statement order with a visitor.
:param visitor: The visitor receiving the events.
"""
for statement in self._statements:
statement.Visit(visitor)
def _Labels(self) -> tuple[SequentialStatement, ...]:
"""
Return the labeled statements of this construct, including the statements nested in compound statements.
Every label of a process or subprogram body is declared in the process' or subprogram's declarative region, also
a label inside an if branch, a case alternative or a loop.
:returns: Tuple of labeled statements, depth-first in statement order.
"""
return tuple(label for statement in self._statements for label in self._LabelsOf(statement))
def _IterateStatementRegions(self) -> Generator[DeclarativeRegionMixin, None, None]:
"""
Iterate the declarative regions nested in the sequential statements of this construct.
:returns: An empty generator: a sequential statement has no declarative region.
"""
yield from ()
@staticmethod
def _LabelsOf(statement: SequentialStatement) -> tuple[SequentialStatement, ...]:
"""
Return a statement, if it's labeled, and the labeled statements nested in it.
:param statement: The sequential statement.
:returns: Tuple of labeled statements, depth-first in statement order.
"""
labels: list[SequentialStatement] = [] if statement._normalizedLabel is None else [statement]
if isinstance(statement, SequentialStatementsMixin):
labels.extend(statement._Labels())
elif isinstance(statement, IfStatement):
labels.extend(statement._ifBranch._Labels())
for branch in statement._elsifBranches:
labels.extend(branch._Labels())
if statement._elseBranch is not None:
labels.extend(statement._elseBranch._Labels())
elif isinstance(statement, CaseStatement):
for case in statement._cases:
labels.extend(case._Labels())
return tuple(labels)
def AddStatement(self, statement: SequentialStatement) -> None:
"""
Add a sequential statement at the end of this construct.
The statement's parent is set to this construct.
:param statement: The sequential statement to add.
:raises ValueError: If parameter 'statement' is ``None``.
:raises TypeError: If parameter 'statement' is not of type :class:`SequentialStatement`.
:raises AlreadyInDesignError: If parameter 'statement' already has a parent.
:raises DuplicateLabelError: If the declarative region already declares a label of the statement.
.. seealso::
:meth:`InsertStatement`
|rarr| Insert a sequential statement at a position of this construct.
:meth:`RemoveStatement`
|rarr| Remove a sequential statement from this construct.
"""
self.InsertStatement(len(self._statements), statement)
def InsertStatement(self, index: int, statement: SequentialStatement) -> None:
"""
Insert a sequential statement at a position of this construct.
The statement's parent is set to this construct.
Every label of a process or subprogram body is declared in the process' or subprogram's declarative region: the
statement's label and the labels of statements nested in it (in branches, case alternatives and loops) may neither
repeat another label of the body, nor an identifier declared in the region. A construct not in a process or
subprogram (yet) checks the labels of its own statements. An unlabeled statement declares nothing.
:param index: Position, from ``0`` (first) to the number of statements (append). A negative index
counts from the end, as for :meth:`list.insert`: ``-1`` inserts before the last
statement.
:param statement: The sequential statement to insert.
:raises ValueError: If parameter 'index' is ``None``.
:raises TypeError: If parameter 'index' is not of type :class:`int`.
:raises ValueError: If parameter 'index' is out of range.
:raises ValueError: If parameter 'statement' is ``None``.
:raises TypeError: If parameter 'statement' is not of type :class:`SequentialStatement`.
:raises AlreadyInDesignError: If parameter 'statement' already has a parent.
:raises DuplicateLabelError: If the declarative region already declares a label of the statement.
.. seealso::
:meth:`AddStatement`
|rarr| Add a sequential statement at the end of this construct.
:meth:`InsertStatementBefore`
|rarr| Insert a sequential statement before another statement.
:meth:`InsertStatementAfter`
|rarr| Insert a sequential statement after another statement.
:meth:`RemoveStatement`
|rarr| Remove a sequential statement from this construct.
:meth:`MoveStatement`
|rarr| Move a sequential statement to a position of this construct.
"""
if index is None:
raise ValueError("Parameter 'index' is None.")
elif not isinstance(index, int):
ex = TypeError("Parameter 'index' is not of type 'int'.")
ex.add_note(f"Got type '{getFullyQualifiedName(index)}'.")
raise ex
elif not (-len(self._statements) <= index <= len(self._statements)):
ex = ValueError(f"Parameter 'index' is out of range {-len(self._statements)}..{len(self._statements)}.")
ex.add_note(f"Got value '{index}'.")
raise ex
if statement is None:
raise ValueError("Parameter 'statement' is None.")
elif not isinstance(statement, SequentialStatement):
ex = TypeError("Parameter 'statement' is not of type 'SequentialStatement'.")
ex.add_note(f"Got type '{getFullyQualifiedName(statement)}'.")
raise ex
elif statement._parent is not None:
label = "" if statement._label is None else f" '{statement._label}'"
ex = AlreadyInDesignError(
f"{getTypeName(statement)}{label} already has a parent.",
element=statement,
parent=statement._parent
)
ex.add_note(f"Remove it from its {getTypeName(statement._parent)} first.")
raise ex
region = self._LabelRegion()
for labeled in self._LabelsOf(statement):
if region is None:
clashes = tuple(item for item in self._Labels() if item._normalizedLabel == labeled._normalizedLabel)
else:
clashes = region._ClashingDeclarations(labeled)
if len(clashes) > 0:
construct = self if region is None else region
ex = DuplicateLabelError(
f"{getTypeName(construct)} already declares '{labeled._label}'.",
identifier=labeled._label,
namespace=None if region is None else region._namespace,
element=labeled,
existing=clashes[0]
)
ex.add_note(f"Existing declaration is of type '{getFullyQualifiedName(clashes[0])}'.")
raise ex
self._statements.insert(index, statement)
statement.Parent = self
def InsertStatementBefore(self, statement: SequentialStatement, before: SequentialStatement) -> None:
"""
Insert a sequential statement before another statement of this construct.
The statement's parent is set to this construct.
:param statement: The sequential statement to insert.
:param before: The statement of this construct to insert before.
:raises ValueError: If parameter 'statement' is ``None``.
:raises TypeError: If parameter 'statement' is not of type :class:`SequentialStatement`.
:raises AlreadyInDesignError: If parameter 'statement' already has a parent.
:raises ValueError: If parameter 'before' is ``None``.
:raises TypeError: If parameter 'before' is not of type :class:`~pyVHDLModel.Base.ModelEntity`.
:raises NotAChildError: If parameter 'before' is not a statement of this construct.
:raises DuplicateLabelError: If the declarative region already declares a label of the statement.
.. seealso::
:meth:`InsertStatement`
|rarr| Insert a sequential statement at a position of this construct.
:meth:`InsertStatementAfter`
|rarr| Insert a sequential statement after another statement.
"""
if before is None:
raise ValueError("Parameter 'before' is None.")
elif not isinstance(before, ModelEntity):
ex = TypeError("Parameter 'before' is not of type 'ModelEntity'.")
ex.add_note(f"Got type '{getFullyQualifiedName(before)}'.")
raise ex
for index, item in enumerate(self._statements):
if item is before:
break
else:
label = ""
if isinstance(before, LabeledEntityMixin) and before._label is not None:
label = f" '{before._label}'"
raise NotAChildError(
f"{getTypeName(before)}{label} is not a statement of this {getTypeName(self)}.",
element=before,
parent=self
)
self.InsertStatement(index, statement)
def InsertStatementAfter(self, statement: SequentialStatement, after: SequentialStatement) -> None:
"""
Insert a sequential statement after another statement of this construct.
The statement's parent is set to this construct.
:param statement: The sequential statement to insert.
:param after: The statement of this construct to insert after.
:raises ValueError: If parameter 'statement' is ``None``.
:raises TypeError: If parameter 'statement' is not of type :class:`SequentialStatement`.
:raises AlreadyInDesignError: If parameter 'statement' already has a parent.
:raises ValueError: If parameter 'after' is ``None``.
:raises TypeError: If parameter 'after' is not of type :class:`~pyVHDLModel.Base.ModelEntity`.
:raises NotAChildError: If parameter 'after' is not a statement of this construct.
:raises DuplicateLabelError: If the declarative region already declares a label of the statement.
.. seealso::
:meth:`InsertStatement`
|rarr| Insert a sequential statement at a position of this construct.
:meth:`InsertStatementBefore`
|rarr| Insert a sequential statement before another statement.
"""
if after is None:
raise ValueError("Parameter 'after' is None.")
elif not isinstance(after, ModelEntity):
ex = TypeError("Parameter 'after' is not of type 'ModelEntity'.")
ex.add_note(f"Got type '{getFullyQualifiedName(after)}'.")
raise ex
for index, item in enumerate(self._statements):
if item is after:
break
else:
label = ""
if isinstance(after, LabeledEntityMixin) and after._label is not None:
label = f" '{after._label}'"
raise NotAChildError(
f"{getTypeName(after)}{label} is not a statement of this {getTypeName(self)}.",
element=after,
parent=self
)
self.InsertStatement(index + 1, statement)
def RemoveStatement(self, statement: SequentialStatement) -> None:
"""
Remove a sequential statement from this construct.
The statement is detached: its parent is cleared. The statement itself is unchanged and can be added to another
construct, or inserted at another position; its labels are free again in this construct's declarative region.
:param statement: The sequential statement to remove.
:raises ValueError: If parameter 'statement' is ``None``.
:raises TypeError: If parameter 'statement' is not of type :class:`~pyVHDLModel.Base.ModelEntity`.
:raises NotAChildError: If parameter 'statement' is not a statement of this construct.
.. seealso::
:meth:`AddStatement`
|rarr| Add a sequential statement at the end of this construct.
:meth:`InsertStatement`
|rarr| Insert a sequential statement at a position of this construct.
:meth:`MoveStatement`
|rarr| Move a sequential statement to a position of this construct.
"""
if statement is None:
raise ValueError("Parameter 'statement' is None.")
elif not isinstance(statement, ModelEntity):
ex = TypeError("Parameter 'statement' is not of type 'ModelEntity'.")
ex.add_note(f"Got type '{getFullyQualifiedName(statement)}'.")
raise ex
for index, item in enumerate(self._statements):
if item is statement:
break
else:
label = ""
if isinstance(statement, LabeledEntityMixin) and statement._label is not None:
label = f" '{statement._label}'"
raise NotAChildError(
f"{getTypeName(statement)}{label} is not a statement of this {getTypeName(self)}.",
element=statement,
parent=self
)
del self._statements[index]
statement._parent = None
def MoveStatement(self, statement: SequentialStatement, index: int) -> None:
"""
Move a sequential statement to a position of this construct.
The statement stays a statement of this construct: only the order of the statements changes.
:param statement: The sequential statement to move.
:param index: Position of the statement after the move, from ``0`` (first) to the number of statements
minus one (last). A negative index counts from the end, as for a :class:`list` index: ``-1``
moves the statement to the end.
:raises ValueError: If parameter 'statement' is ``None``.
:raises TypeError: If parameter 'statement' is not of type :class:`~pyVHDLModel.Base.ModelEntity`.
:raises NotAChildError: If parameter 'statement' is not a statement of this construct.
:raises ValueError: If parameter 'index' is ``None``.
:raises TypeError: If parameter 'index' is not of type :class:`int`.
:raises ValueError: If parameter 'index' is out of range.
.. seealso::
:meth:`MoveStatementBefore`
|rarr| Move a sequential statement before another statement.
:meth:`MoveStatementAfter`
|rarr| Move a sequential statement after another statement.
:meth:`InsertStatement`
|rarr| Insert a sequential statement at a position of this construct.
:meth:`RemoveStatement`
|rarr| Remove a sequential statement from this construct.
"""
if statement is None:
raise ValueError("Parameter 'statement' is None.")
elif not isinstance(statement, ModelEntity):
ex = TypeError("Parameter 'statement' is not of type 'ModelEntity'.")
ex.add_note(f"Got type '{getFullyQualifiedName(statement)}'.")
raise ex
for currentIndex, item in enumerate(self._statements):
if item is statement:
break
else:
label = ""
if isinstance(statement, LabeledEntityMixin) and statement._label is not None:
label = f" '{statement._label}'"
raise NotAChildError(
f"{getTypeName(statement)}{label} is not a statement of this {getTypeName(self)}.",
element=statement,
parent=self
)
if index is None:
raise ValueError("Parameter 'index' is None.")
elif not isinstance(index, int):
ex = TypeError("Parameter 'index' is not of type 'int'.")
ex.add_note(f"Got type '{getFullyQualifiedName(index)}'.")
raise ex
elif not (-len(self._statements) <= index < len(self._statements)):
ex = ValueError(f"Parameter 'index' is out of range {-len(self._statements)}..{len(self._statements) - 1}.")
ex.add_note(f"Got value '{index}'.")
raise ex
newIndex = index if index >= 0 else len(self._statements) + index
del self._statements[currentIndex]
self._statements.insert(newIndex, statement)
def MoveStatementBefore(self, statement: SequentialStatement, before: SequentialStatement) -> None:
"""
Move a sequential statement before another statement of this construct.
The statement stays a statement of this construct: only the order of the statements changes, as for
:meth:`MoveStatement`. Moving a statement before itself keeps it in place.
:param statement: The sequential statement to move.
:param before: The statement of this construct to move before.
:raises ValueError: If parameter 'statement' is ``None``.
:raises TypeError: If parameter 'statement' is not of type :class:`~pyVHDLModel.Base.ModelEntity`.
:raises NotAChildError: If parameter 'statement' is not a statement of this construct.
:raises ValueError: If parameter 'before' is ``None``.
:raises TypeError: If parameter 'before' is not of type :class:`~pyVHDLModel.Base.ModelEntity`.
:raises NotAChildError: If parameter 'before' is not a statement of this construct.
.. seealso::
:meth:`MoveStatement`
|rarr| Move a sequential statement to a position of this construct.
:meth:`MoveStatementAfter`
|rarr| Move a sequential statement after another statement.
"""
if before is None:
raise ValueError("Parameter 'before' is None.")
elif not isinstance(before, ModelEntity):
ex = TypeError("Parameter 'before' is not of type 'ModelEntity'.")
ex.add_note(f"Got type '{getFullyQualifiedName(before)}'.")
raise ex
for index, item in enumerate(self._statements):
if item is before:
break
else:
label = ""
if isinstance(before, LabeledEntityMixin) and before._label is not None:
label = f" '{before._label}'"
raise NotAChildError(
f"{getTypeName(before)}{label} is not a statement of this {getTypeName(self)}.",
element=before,
parent=self
)
precedes = any(item is statement for item in self._statements[:index])
self.MoveStatement(statement, index - 1 if precedes else index)
def MoveStatementAfter(self, statement: SequentialStatement, after: SequentialStatement) -> None:
"""
Move a sequential statement after another statement of this construct.
The statement stays a statement of this construct: only the order of the statements changes, as for
:meth:`MoveStatement`. Moving a statement after itself keeps it in place.
:param statement: The sequential statement to move.
:param after: The statement of this construct to move after.
:raises ValueError: If parameter 'statement' is ``None``.
:raises TypeError: If parameter 'statement' is not of type :class:`~pyVHDLModel.Base.ModelEntity`.
:raises NotAChildError: If parameter 'statement' is not a statement of this construct.
:raises ValueError: If parameter 'after' is ``None``.
:raises TypeError: If parameter 'after' is not of type :class:`~pyVHDLModel.Base.ModelEntity`.
:raises NotAChildError: If parameter 'after' is not a statement of this construct.
.. seealso::
:meth:`MoveStatement`
|rarr| Move a sequential statement to a position of this construct.
:meth:`MoveStatementBefore`
|rarr| Move a sequential statement before another statement.
"""
if after is None:
raise ValueError("Parameter 'after' is None.")
elif not isinstance(after, ModelEntity):
ex = TypeError("Parameter 'after' is not of type 'ModelEntity'.")
ex.add_note(f"Got type '{getFullyQualifiedName(after)}'.")
raise ex
for index, item in enumerate(self._statements):
if item is after:
break
else:
label = ""
if isinstance(after, LabeledEntityMixin) and after._label is not None:
label = f" '{after._label}'"
raise NotAChildError(
f"{getTypeName(after)}{label} is not a statement of this {getTypeName(self)}.",
element=after,
parent=self
)
precedes = any(item is statement for item in self._statements[:index + 1])
self.MoveStatement(statement, index if precedes else index + 1)
@export
class SequentialProcedureCall(SequentialStatement, ProcedureCallMixin):
"""
Represents a procedure call as a sequential statement.
Like every sequential statement, it can carry an optional label (:data:`Label`).
.. admonition:: Example
.. code-block:: VHDL
lbl : log("hello");
--^^^ <- optional Label
-- ^^^^^^^^^^^^ <- the call
.. seealso::
* :class:`Concurrent counterpart <pyVHDLModel.Concurrent.ConcurrentProcedureCall>`
"""
def __init__(
self,
procedureName: Symbol,
parameterAssociationItems: Nullable[Iterable[ParameterAssociationItem]] = None,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a procedure call as a sequential statement.
:param procedureName: Reference to the called procedure.
:param parameterAssociationItems: Optional, list of all parameter associations of the call.
Default: ``None``, no parameter associations.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
ProcedureCallMixin.__init__(self, procedureName, parameterAssociationItems)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this procedure call, its procedure and its parameters with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitSequentialProcedureCall(self)
self._VisitProcedureCall(visitor)
visitor.VisitTerminator(self)
visitor.DepartSequentialProcedureCall(self)
@export
class SequentialSignalAssignment(SequentialStatement, SignalAssignmentMixin):
"""
Represents the base-class of all sequential signal assignments.
.. seealso::
* :class:`Sequential simple signal assignment <pyVHDLModel.Sequential.SequentialSimpleSignalAssignment>`
"""
def __init__(
self,
target: SignalSymbol,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a sequential signal assignment.
:param target: Reference to the assignment's destination.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
SignalAssignmentMixin.__init__(self, target)
@export
class SequentialSimpleSignalAssignment(SequentialSignalAssignment, WaveformMixin):
"""
Represents a simple sequential signal assignment.
The assignment's destination is available as :data:`Target`, its value as :data:`Waveform`.
.. admonition:: Example
.. code-block:: VHDL
lbl : s <= '1';
--^^^ <- optional Label
-- ^ <- Target
-- ^^^ <- Waveform
.. seealso::
* :class:`Concurrent counterpart <pyVHDLModel.Concurrent.ConcurrentSimpleSignalAssignment>`
"""
def __init__(
self,
target: SignalSymbol,
waveform: Iterable[WaveformElement],
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a simple sequential signal assignment.
:param target: Reference to the assignment's destination.
:param waveform: List of all waveform elements, in the order they were written.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(target, label, documentation, parent)
WaveformMixin.__init__(self, waveform)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this signal assignment, its target and its waveform with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitSequentialSimpleSignalAssignment(self)
self._target.Visit(visitor)
visitor.VisitSignalAssignment(self)
self._VisitWaveform(visitor)
visitor.VisitTerminator(self)
visitor.DepartSequentialSimpleSignalAssignment(self)
@export
class SequentialVariableAssignment(SequentialStatement, VariableAssignmentMixin):
"""
Represents a simple sequential variable assignment.
The assignment's destination is available as :data:`Target`, its value as :data:`Expression`.
.. admonition:: Example
.. code-block:: VHDL
lbl : v := '1';
--^^^ <- optional Label
-- ^ <- Target
-- ^^^ <- Expression
"""
def __init__(
self,
target: VariableSymbol,
expression: ExpressionUnion,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a simple sequential variable assignment.
:param target: Reference to the assignment's destination.
:param expression: The assigned expression.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
VariableAssignmentMixin.__init__(self, target, expression)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this variable assignment, its target and its expression with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitSequentialVariableAssignment(self)
self._target.Visit(visitor)
visitor.VisitVariableAssignment(self)
self._expression.Visit(visitor)
visitor.VisitTerminator(self)
visitor.DepartSequentialVariableAssignment(self)
@export
class SequentialConditionalVariableAssignment(SequentialStatement, AssignmentMixin):
"""
Represents a conditional sequential variable assignment.
The alternatives are available as :data:`ConditionalExpressions`, a list of
:class:`~pyVHDLModel.Common.ConditionalExpression`. The model holds them in a list and has no
distinct field per alternative, so the markers below name list elements.
.. admonition:: Example
.. code-block:: VHDL
lbl : v := '1' when sel = '0' else '0';
--^^^ <- optional Label
-- ^ <- Target
-- ^^^^^^^^^^^^^^^^^^ <- ConditionalExpressions[0]
-- ^^^ <- ConditionalExpressions[1]
.. seealso::
* :class:`Conditional expression <pyVHDLModel.Common.ConditionalExpression>`
"""
_conditionalExpressions: list[ConditionalExpression] #: List of all alternatives, in the order they were written.
def __init__(
self,
target: VariableSymbol,
conditionalExpressions: Iterable[ConditionalExpression],
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a conditional sequential variable assignment.
:param target: Reference to the assignment's destination.
:param conditionalExpressions: List of all alternatives, in the order they were written.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
AssignmentMixin.__init__(self, target)
self._conditionalExpressions = conditionalExpressionList = []
for conditionalExpression in conditionalExpressions:
conditionalExpressionList.append(conditionalExpression)
conditionalExpression.Parent = self
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this conditional variable assignment, its target and its alternatives with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitSequentialConditionalVariableAssignment(self)
self._target.Visit(visitor)
visitor.VisitVariableAssignment(self)
for index, conditionalExpression in enumerate(self._conditionalExpressions):
if index > 0:
visitor.VisitElse(self)
conditionalExpression.Visit(visitor)
visitor.VisitTerminator(self)
visitor.DepartSequentialConditionalVariableAssignment(self)
@readonly
def ConditionalExpressions(self) -> list[ConditionalExpression]:
"""
Read-only property to access the conditional expressions (:attr:`_conditionalExpressions`).
:returns: List of conditional expressions.
"""
return self._conditionalExpressions
@export
class SequentialConditionalSignalAssignment(SequentialStatement, SignalAssignmentMixin, ConditionalWaveformsMixin):
"""
Represents a conditional sequential signal assignment.
The alternatives are available as :data:`ConditionalWaveforms`, a list of
:class:`~pyVHDLModel.Common.ConditionalWaveform`. The model holds them in a list and has no
distinct field per alternative, so the markers below name list elements.
.. admonition:: Example
.. code-block:: VHDL
lbl : s <= '1' when sel = '0' else '0';
--^^^ <- optional Label
-- ^ <- Target
-- ^^^^^^^^^^^^^^^^^^ <- ConditionalWaveforms[0]
-- ^^^ <- ConditionalWaveforms[1]
.. seealso::
* :class:`Concurrent counterpart <pyVHDLModel.Concurrent.ConcurrentConditionalSignalAssignment>`
* :class:`Conditional waveform <pyVHDLModel.Common.ConditionalWaveform>`
"""
def __init__(
self,
target: SignalSymbol,
conditionalWaveforms: Iterable[ConditionalWaveform],
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a conditional sequential signal assignment.
:param target: Reference to the assignment's destination.
:param conditionalWaveforms: All alternatives, in order.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
SignalAssignmentMixin.__init__(self, target)
ConditionalWaveformsMixin.__init__(self, conditionalWaveforms)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this conditional signal assignment, its target and its alternatives with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitSequentialConditionalSignalAssignment(self)
self._target.Visit(visitor)
visitor.VisitSignalAssignment(self)
self._VisitConditionalWaveforms(visitor)
visitor.VisitTerminator(self)
visitor.DepartSequentialConditionalSignalAssignment(self)
@export
class SequentialSelectedVariableAssignment(SequentialStatement, AssignmentMixin, ExpressionMixin, SelectedExpressionsMixin):
"""
Represents a selected sequential variable assignment.
The selector is available as :data:`Expression`, the alternatives as :data:`SelectedExpressions`,
a list of :class:`~pyVHDLModel.Common.SelectedExpression`. The model holds them in a list and has
no distinct field per alternative, so the markers below name list elements.
.. admonition:: Example
.. code-block:: VHDL
lbl : with sel select v := '1' when '0', '0' when others;
--^^^ <- optional Label
-- ^^^ <- Expression
-- ^ <- Target
-- ^^^^^^^^^^^^ <- SelectedExpressions[0]
-- ^^^^^^^^^^^^^^^ <- SelectedExpressions[1]
.. seealso::
* :class:`Selected expression <pyVHDLModel.Common.SelectedExpression>`
"""
def __init__(
self,
target: VariableSymbol,
expression: ExpressionUnion,
selectedExpressions: Iterable[SelectedExpression],
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a selected sequential variable assignment.
:param target: Reference to the assignment's destination.
:param expression: The selector expression.
:param selectedExpressions: All alternatives, in order.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
AssignmentMixin.__init__(self, target)
ExpressionMixin.__init__(self, expression)
SelectedExpressionsMixin.__init__(self, selectedExpressions)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this selected variable assignment, its selector, its target and its alternatives with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitSequentialSelectedVariableAssignment(self)
self._expression.Visit(visitor)
visitor.VisitSelect(self)
self._target.Visit(visitor)
visitor.VisitVariableAssignment(self)
self._VisitSelectedExpressions(visitor)
visitor.VisitTerminator(self)
visitor.DepartSequentialSelectedVariableAssignment(self)
@export
class SequentialSelectedSignalAssignment(SequentialStatement, SignalAssignmentMixin, ExpressionMixin, SelectedWaveformsMixin):
"""
Represents a selected sequential signal assignment.
The selector is available as :data:`Expression`, the alternatives as :data:`SelectedWaveforms`,
a list of :class:`~pyVHDLModel.Common.SelectedWaveform`. The model holds them in a list and has
no distinct field per alternative, so the markers below name list elements.
.. admonition:: Example
.. code-block:: VHDL
lbl : with sel select s <= '1' when '0', '0' when others;
--^^^ <- optional Label
-- ^^^ <- Expression
-- ^ <- Target
-- ^^^^^^^^^^^^ <- SelectedWaveforms[0]
-- ^^^^^^^^^^^^^^^ <- SelectedWaveforms[1]
.. seealso::
* :class:`Concurrent counterpart <pyVHDLModel.Concurrent.ConcurrentSelectedSignalAssignment>`
* :class:`Selected waveform <pyVHDLModel.Common.SelectedWaveform>`
"""
def __init__(
self,
target: SignalSymbol,
expression: ExpressionUnion,
selectedWaveforms: Iterable[SelectedWaveform],
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a selected sequential signal assignment.
:param target: Reference to the assignment's destination.
:param expression: The selector expression.
:param selectedWaveforms: All alternatives, in order.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
SignalAssignmentMixin.__init__(self, target)
ExpressionMixin.__init__(self, expression)
SelectedWaveformsMixin.__init__(self, selectedWaveforms)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this selected signal assignment, its selector, its target and its alternatives with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitSequentialSelectedSignalAssignment(self)
self._expression.Visit(visitor)
visitor.VisitSelect(self)
self._target.Visit(visitor)
visitor.VisitSignalAssignment(self)
self._VisitSelectedWaveforms(visitor)
visitor.VisitTerminator(self)
visitor.DepartSequentialSelectedSignalAssignment(self)
@export
class SignalForceAssignment(SequentialStatement, SignalAssignmentMixin, ExpressionMixin):
"""
Represents a signal force assignment.
A force assignment overrides a signal's driver until it is released.
.. admonition:: Example
.. code-block:: VHDL
lbl : s <= force '1';
--^^^ <- optional Label
-- ^ <- Target
-- ^^^ <- Expression
"""
def __init__(
self,
target: SignalSymbol,
expression: ExpressionUnion,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a signal force assignment.
:param target: Reference to the assignment's destination.
:param expression: The value forced onto the signal.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
SignalAssignmentMixin.__init__(self, target)
ExpressionMixin.__init__(self, expression)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this force assignment, its target and its expression with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitSignalForceAssignment(self)
self._target.Visit(visitor)
visitor.VisitSignalAssignment(self)
self._expression.Visit(visitor)
visitor.VisitTerminator(self)
visitor.DepartSignalForceAssignment(self)
@export
class SignalReleaseAssignment(SequentialStatement, SignalAssignmentMixin):
"""
Represents a signal release assignment.
A release assignment ends a previously applied force.
.. admonition:: Example
.. code-block:: VHDL
lbl : s <= release;
--^^^ <- optional Label
-- ^ <- Target
"""
def __init__(
self,
target: SignalSymbol,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a signal release assignment.
:param target: Reference to the assignment's destination.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
SignalAssignmentMixin.__init__(self, target)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this release assignment and its target with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitSignalReleaseAssignment(self)
self._target.Visit(visitor)
visitor.VisitSignalAssignment(self)
visitor.VisitTerminator(self)
visitor.DepartSignalReleaseAssignment(self)
@export
class SequentialReportStatement(SequentialStatement, ReportStatementMixin):
"""
Represents a sequential report statement.
The report string is available as :data:`Message`, the optional severity as :data:`Severity`.
.. admonition:: Example
.. code-block:: VHDL
lbl : report "message" severity note;
--^^^ <- optional Label
-- ^^^^^^^^^ <- Message
-- ^^^^ <- optional Severity
"""
def __init__(
self,
message: ExpressionUnion,
severity: Nullable[ExpressionUnion] = None,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a sequential report statement.
:param message: The reported message, or ``None`` if none was given.
:param severity: Optional, the reported severity level. Default: ``None``, no severity level.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
ReportStatementMixin.__init__(self, message, severity)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this report statement, its message and its severity with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitSequentialReportStatement(self)
self._VisitReportAndSeverity(visitor)
visitor.VisitTerminator(self)
visitor.DepartSequentialReportStatement(self)
@export
class SequentialAssertStatement(SequentialStatement, AssertStatementMixin):
"""
Represents a sequential assertion statement.
The checked condition is available as :data:`Condition`, the optional report string as
:data:`Message` and the optional severity as :data:`Severity`.
.. admonition:: Example
.. code-block:: VHDL
lbl : assert sel = '0' report "bad" severity error;
--^^^ <- optional Label
-- ^^^^^^^^^ <- Condition
-- ^^^^^ <- optional Message
-- ^^^^^ <- optional Severity
.. seealso::
* :class:`Concurrent counterpart <pyVHDLModel.Concurrent.ConcurrentAssertStatement>`
"""
def __init__(
self,
condition: ExpressionUnion,
message: Nullable[ExpressionUnion] = None,
severity: Nullable[ExpressionUnion] = None,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a sequential assertion statement.
:param condition: The condition guarding this statement.
:param message: Optional, the reported message. Default: ``None``, no message.
:param severity: Optional, the reported severity level. Default: ``None``, no severity level.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
AssertStatementMixin.__init__(self, condition, message, severity)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this assertion, its condition, its message and its severity with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitSequentialAssertStatement(self)
self._VisitAssertion(visitor)
visitor.VisitTerminator(self)
visitor.DepartSequentialAssertStatement(self)
@export
@abstractclass
class CompoundStatement(SequentialStatement):
"""
Represents the base-class of all compound statements.
A compound statement contains further sequential statements: if, case and loop statements.
.. seealso::
* :class:`If statement <pyVHDLModel.Sequential.IfStatement>`
* :class:`Case statement <pyVHDLModel.Sequential.CaseStatement>`
* :class:`Loop statement <pyVHDLModel.Sequential.LoopStatement>`
"""
@export
@abstractclass
class Branch(ModelEntity, SequentialStatementsMixin, DocumentedEntityMixin):
"""
Represents the base-class of all branches of an if statement.
.. seealso::
* :class:`If branch <pyVHDLModel.Sequential.IfBranch>`
* :class:`Elsif branch <pyVHDLModel.Sequential.ElsifBranch>`
* :class:`Else branch <pyVHDLModel.Sequential.ElseBranch>`
"""
def __init__(
self,
statements: Nullable[Iterable[SequentialStatement]] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a branch.
:param statements: Optional, list of all sequential statements in this construct.
Default: ``None``, no statements.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(parent)
SequentialStatementsMixin.__init__(self, statements)
DocumentedEntityMixin.__init__(self, documentation)
def _LabelRegion(self) -> Nullable[ModelEntity]:
"""
Return the process or subprogram declaring the labels of this branch's statements.
It's the region of the construct holding the if statement.
:returns: The process or subprogram, or ``None`` if the branch isn't part of one (yet).
"""
ifStatement = self._parent
if ifStatement is None or ifStatement._parent is None:
return None
return ifStatement._parent._LabelRegion()
@export
class IfBranch(Branch, IfBranchMixin):
"""
Represents the ``if`` branch of an if statement.
The branch's condition is available as :data:`Condition`, its body as :data:`Statements`.
.. admonition:: Example
The whole if statement is shown; the bracket marks the part this class represents.
.. code-block:: VHDL
if sel = '0' then -- ┐ IfBranch
-- ^^^^^^^^^ -- │ <- Condition
s <= '0'; -- │
--^^^^^^^^^ -- ┘ <- Statements
elsif sel = '1' then
s <= '1';
else
s <= '0';
end if;
"""
def __init__(
self,
condition: ExpressionUnion,
statements: Nullable[Iterable[SequentialStatement]] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes an if branch.
:param condition: The condition guarding this statement.
:param statements: Optional, list of all sequential statements in this construct.
Default: ``None``, no statements.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(statements, documentation, parent)
IfBranchMixin.__init__(self, condition)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this if branch, its condition and its statements with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitIfBranch(self)
self._condition.Visit(visitor)
visitor.VisitThen(self)
self._VisitStatements(visitor)
visitor.DepartIfBranch(self)
@export
class ElsifBranch(Branch, ElsifBranchMixin):
"""
Represents an ``elsif`` branch of an if statement.
The branch's condition is available as :data:`Condition`, its body as :data:`Statements`.
An if statement may have any number of them.
.. admonition:: Example
The whole if statement is shown; the bracket marks the part this class represents.
.. code-block:: VHDL
if sel = '0' then
s <= '0';
elsif sel = '1' then -- ┐ ElsifBranch
-- ^^^^^^^^^ -- │ <- Condition
s <= '1'; -- │
--^^^^^^^^^ -- ┘ <- Statements
else
s <= '0';
end if;
"""
def __init__(
self,
condition: ExpressionUnion,
statements: Nullable[Iterable[SequentialStatement]] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes an ``elsif`` branch of an if statement.
:param condition: The condition guarding this statement.
:param statements: Optional, list of all sequential statements in this construct.
Default: ``None``, no statements.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(statements, documentation, parent)
ElsifBranchMixin.__init__(self, condition)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this elsif branch, its condition and its statements with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitElsifBranch(self)
self._condition.Visit(visitor)
visitor.VisitThen(self)
self._VisitStatements(visitor)
visitor.DepartElsifBranch(self)
@export
class ElseBranch(Branch, ElseBranchMixin):
"""
Represents the ``else`` branch of an if statement.
Unlike the other branches, an else branch has no condition; it only has a body
(:data:`Statements`). An if statement has at most one.
.. admonition:: Example
The whole if statement is shown; the bracket marks the part this class represents.
.. code-block:: VHDL
if sel = '0' then
s <= '0';
elsif sel = '1' then
s <= '1';
else -- ┐ ElseBranch
s <= '0'; -- │
--^^^^^^^^^ -- ┘ <- Statements
end if;
"""
def __init__(
self,
statements: Nullable[Iterable[SequentialStatement]] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes an else branch.
:param statements: Optional, list of all sequential statements in this construct.
Default: ``None``, no statements.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(statements, documentation, parent)
ElseBranchMixin.__init__(self)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this else branch and its statements with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitElseBranch(self)
self._VisitStatements(visitor)
visitor.DepartElseBranch(self)
@export
class IfStatement(CompoundStatement):
"""
Represents an if statement.
An if statement has one ``if`` branch (:data:`IfBranch`), any number of ``elsif`` branches
(:data:`ElsIfBranches`) and an optional ``else`` branch (:data:`ElseBranch`).
.. admonition:: Example
Only an ``if`` branch:
.. code-block:: VHDL
lbl : if sel = '0' then
--^^^ <- optional Label
s <= '0';
end if;
With ``elsif`` and ``else`` branches:
.. code-block:: VHDL
lbl : if sel = '0' then
--^^^ <- optional Label
-- ^^^^^^^^^^^^^^^^^ <- IfBranch
s <= '0';
elsif sel = '1' then
--^^^^^^^^^^^^^^^^^^^^ <- ElsIfBranches[0]
s <= '1';
else
--^^^^ <- ElseBranch
s <= '0';
end if;
.. seealso::
* :class:`If-generate statement <pyVHDLModel.Concurrent.IfGenerateStatement>`
"""
_END_KEYWORDS: ClassVar[tuple[ReservedWord, ...]] = (ReservedWord.If,) #: Reserved words after ``end``.
_END_KEYWORDS_OPTIONAL: ClassVar[bool] = False #: The reserved words after ``end`` are optional.
_ifBranch: IfBranch #: The mandatory ``if`` branch.
_elsifBranches: list[ElsifBranch] #: List of all ``elsif`` branches, in the order they were written.
_elseBranch: Nullable[ElseBranch] #: The optional ``else`` branch, or ``None`` if none was given.
def __init__(
self,
ifBranch: IfBranch,
elsifBranches: Nullable[Iterable[ElsifBranch]] = None,
elseBranch: Nullable[ElseBranch] = None,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes an if statement.
:param ifBranch: The mandatory ``if`` branch.
:param elsifBranches: Optional, list of all ``elsif`` branches, in the order they were written.
Default: ``None``, no ``elsif`` branches.
:param elseBranch: Optional, the ``else`` branch. Default: ``None``, no ``else`` branch.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
self._ifBranch = ifBranch
ifBranch.Parent = self
self._elsifBranches = elsifBranchList = []
if elsifBranches is not None:
for branch in elsifBranches:
elsifBranchList.append(branch)
branch.Parent = self
if elseBranch is not None:
self._elseBranch = elseBranch
elseBranch.Parent = self
else:
self._elseBranch = None
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this if statement and its branches with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitIfStatement(self)
self._ifBranch.Visit(visitor)
for branch in self._elsifBranches:
branch.Visit(visitor)
if self._elseBranch is not None:
self._elseBranch.Visit(visitor)
visitor.VisitEnd(self)
visitor.VisitTerminator(self)
visitor.DepartIfStatement(self)
@readonly
def IfBranch(self) -> IfBranch:
"""
Read-only property to access the if-branch of the if-statement (:attr:`_ifBranch`).
:returns: The if-branch.
"""
return self._ifBranch
@readonly
def ElsIfBranches(self) -> list[ElsifBranch]:
"""
Read-only property to access the elsif-branches of the if-statement (:attr:`_elsifBranches`).
:returns: List of elsif-branches, in the order they were written.
"""
return self._elsifBranches
@readonly
def ElseBranch(self) -> Nullable[ElseBranch]:
"""
Read-only property to access the else-branch of the if-statement (:attr:`_elseBranch`).
:returns: The else-branch.
"""
return self._elseBranch
@export
@abstractclass
class SequentialChoice(BaseChoice):
"""
Represents the base-class of all choices in a sequential case statement.
.. seealso::
* :class:`Indexed choice <pyVHDLModel.Sequential.IndexedChoice>`
* :class:`Ranged choice <pyVHDLModel.Sequential.RangedChoice>`
"""
@export
class IndexedChoice(SequentialChoice):
"""
Represents a case choice given by a single value.
The value is available as :data:`Expression`.
.. admonition:: Example
.. code-block:: VHDL
when 0 => v := '1';
-- ^ <- Expression
"""
_expression: ExpressionUnion #: The expression this choice selects on.
def __init__(self, expression: ExpressionUnion, parent: Nullable[ModelEntity] = None) -> None:
"""
Initializes a case choice given by a single value.
:param expression: The expression this choice selects on.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(parent)
self._expression = expression
expression.Parent = self
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this choice and its value with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitIndexedChoice(self)
self._expression.Visit(visitor)
visitor.DepartIndexedChoice(self)
@readonly
def Expression(self) -> ExpressionUnion:
"""
Read-only property to access the expression (:attr:`_expression`).
:returns: The expression.
"""
return self._expression
[docs]
def __str__(self) -> str:
"""
Formats the indexed case choice.
**Format:** ``0``
:returns: Formatted indexed case choice.
"""
return str(self._expression)
@export
class RangedChoice(SequentialChoice):
"""
Represents a case choice given by a range.
The range is available as :data:`Range`.
.. admonition:: Example
.. code-block:: VHDL
when 1 to 2 => v := '0';
-- ^^^^^^ <- Range
"""
_range: Range #: The range this choice selects on.
def __init__(self, rng: Range, parent: Nullable[ModelEntity] = None) -> None:
"""
Initializes a case choice given by a range.
:param rng: The range this choice selects on.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(parent)
self._range = rng
rng.Parent = self
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this choice and its range with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitRangedChoice(self)
self._range.Visit(visitor)
visitor.DepartRangedChoice(self)
@readonly
def Range(self) -> Range:
"""
Read-only property to access the range (:attr:`_range`).
:returns: The range.
"""
return self._range
[docs]
def __str__(self) -> str:
"""
Formats the ranged case choice.
**Format:** ``0 to 3``
:returns: Formatted ranged case choice.
"""
return str(self._range)
@export
class SequentialCase(BaseCase, SequentialStatementsMixin, ChoicesMixin, DocumentedEntityMixin):
"""
Represents the base-class of all alternatives of a sequential case statement.
.. seealso::
* :class:`Case <pyVHDLModel.Sequential.Case>`
* :class:`Others case <pyVHDLModel.Sequential.OthersCase>`
"""
def __init__(
self,
statements: Nullable[Iterable[SequentialStatement]] = None,
choices: Nullable[Iterable[BaseChoice]] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a sequential case.
:param statements: Optional, list of all sequential statements in this construct.
Default: ``None``, no statements.
:param choices: Optional, list of all choices selecting this alternative. Default: ``None``, no choices.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(parent)
SequentialStatementsMixin.__init__(self, statements)
ChoicesMixin.__init__(self, choices)
DocumentedEntityMixin.__init__(self, documentation)
def _LabelRegion(self) -> Nullable[ModelEntity]:
"""
Return the process or subprogram declaring the labels of this case alternative's statements.
It's the region of the construct holding the case statement.
:returns: The process or subprogram, or ``None`` if the case alternative isn't part of one (yet).
"""
caseStatement = self._parent
if caseStatement is None or caseStatement._parent is None:
return None
return caseStatement._parent._LabelRegion()
@export
class Case(SequentialCase):
"""
Represents one alternative of a case statement, selected by its choices.
.. admonition:: Example
.. code-block:: VHDL
when 1 to 2 => v := '0';
-- ^^^^^^ <- Choices
-- ^^^^^^^^^ <- the statements
"""
def __init__(
self,
choices: Iterable[SequentialChoice],
statements: Nullable[Iterable[SequentialStatement]] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a case.
:param choices: List of all choices selecting this alternative.
:param statements: Optional, list of all sequential statements in this construct.
Default: ``None``, no statements.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(statements, choices, documentation, parent)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this case alternative, its choices and its statements with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitCase(self)
for index, choice in enumerate(self._choices):
if index > 0:
visitor.VisitBar(self)
choice.Visit(visitor)
visitor.VisitArrow(self)
self._VisitStatements(visitor)
visitor.DepartCase(self)
[docs]
def __str__(self) -> str:
"""
Formats the case alternative.
**Format:** ``when 0 | 1 =>``
:returns: Formatted case alternative.
"""
return "when {choices} =>".format(choices=" | ".join(str(c) for c in self._choices))
@export
class OthersCase(SequentialCase):
"""
Represents the ``others`` alternative of a case statement.
It covers every choice not named explicitly.
.. admonition:: Example
.. code-block:: VHDL
when others => null;
-- ^^^^^^ <- the choice
"""
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this ``others`` case alternative and its statements with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitOthersCase(self)
visitor.VisitArrow(self)
self._VisitStatements(visitor)
visitor.DepartOthersCase(self)
[docs]
def __str__(self) -> str:
"""
Formats the ``others`` case alternative.
**Format:** ``when others =>``
:returns: Formatted ``others`` case alternative.
"""
return "when others =>"
@export
class CaseStatement(CompoundStatement):
"""
Represents a case statement.
The expression being tested is available as :data:`SelectExpression`, the alternatives as
:data:`Cases`.
.. admonition:: Example
.. code-block:: VHDL
lbl : case sel is
--^^^ <- optional Label
-- ^^^ <- SelectExpression
when '0' => s <= '1';
-- ^^^^^^^^^^^^^^^^^^^^^^^^ <- Cases[0]
when others => null;
-- ^^^^^^^^^^^^^^^^^^^^ <- Cases[1]
end case;
.. seealso::
* :class:`Case-generate statement <pyVHDLModel.Concurrent.CaseGenerateStatement>`
"""
_END_KEYWORDS: ClassVar[tuple[ReservedWord, ...]] = (ReservedWord.Case,) #: Reserved words after ``end``.
_END_KEYWORDS_OPTIONAL: ClassVar[bool] = False #: The reserved words after ``end`` are optional.
_expression: ExpressionUnion #: The expression being tested.
_cases: list[SequentialCase] #: List of all alternatives, in the order they were written.
def __init__(
self,
expression: ExpressionUnion,
cases: Iterable[SequentialCase],
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a case statement.
:param expression: The expression being tested.
:param cases: List of all alternatives, in the order they were written.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
self._expression = expression
expression.Parent = self
self._cases = caseList = []
if cases is not None:
for case in cases:
caseList.append(case)
case.Parent = self
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this case statement, its selector and its alternatives with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitCaseStatement(self)
self._expression.Visit(visitor)
visitor.VisitIs(self)
for case in self._cases:
case.Visit(visitor)
visitor.VisitEnd(self)
visitor.VisitTerminator(self)
visitor.DepartCaseStatement(self)
@readonly
def SelectExpression(self) -> ExpressionUnion:
"""
Read-only property to access the select expression (:attr:`_expression`).
:returns: The select expression.
"""
return self._expression
@readonly
def Cases(self) -> list[SequentialCase]:
"""
Read-only property to access the cases (:attr:`_cases`).
:returns: List of cases.
"""
return self._cases
@export
@abstractclass
class LoopStatement(CompoundStatement, SequentialStatementsMixin):
"""
Represents the base-class of all loop statements.
.. seealso::
* :class:`Endless loop statement <pyVHDLModel.Sequential.EndlessLoopStatement>`
* :class:`For loop statement <pyVHDLModel.Sequential.ForLoopStatement>`
* :class:`While loop statement <pyVHDLModel.Sequential.WhileLoopStatement>`
"""
_END_KEYWORDS: ClassVar[tuple[ReservedWord, ...]] = (ReservedWord.Loop,) #: Reserved words after ``end``.
_END_KEYWORDS_OPTIONAL: ClassVar[bool] = False #: The reserved words after ``end`` are optional.
def __init__(
self,
statements: Nullable[Iterable[SequentialStatement]] = None,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a loop statement.
:param statements: Optional, list of all sequential statements in this construct.
Default: ``None``, no statements.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
SequentialStatementsMixin.__init__(self, statements)
def _LabelRegion(self) -> Nullable[ModelEntity]:
"""
Return the process or subprogram declaring the labels of this loop's statements.
It's the region of the construct holding the loop.
:returns: The process or subprogram, or ``None`` if the loop isn't part of one (yet).
"""
return None if self._parent is None else self._parent._LabelRegion()
@export
class EndlessLoopStatement(LoopStatement):
"""
Represents an endless loop statement.
The loop body is available as :data:`Statements`. The loop has no iteration scheme, so it is
left with an exit or return statement.
.. admonition:: Example
.. code-block:: VHDL
lbl : loop
--^^^ <- optional Label
exit;
-- ^^^^^ <- Statements
end loop;
.. seealso::
* :class:`For loop statement <pyVHDLModel.Sequential.ForLoopStatement>`
* :class:`While loop statement <pyVHDLModel.Sequential.WhileLoopStatement>`
"""
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this loop and its statements with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitEndlessLoopStatement(self)
visitor.VisitLoop(self)
self._VisitStatements(visitor)
visitor.VisitEnd(self)
visitor.VisitTerminator(self)
visitor.DepartEndlessLoopStatement(self)
@export
class ForLoopStatement(LoopStatement):
"""
Represents a for-loop statement.
The loop index is available as :data:`LoopIndex`, the iteration range as :data:`Range` and the
loop body as :data:`Statements`.
.. admonition:: Example
.. code-block:: VHDL
lbl : for k in 0 to 3 loop
--^^^ <- optional Label
-- ^ <- LoopIndex
-- ^^^^^^ <- Range
null;
-- ^^^^^ <- Statements
end loop;
.. seealso::
* :class:`Endless loop statement <pyVHDLModel.Sequential.EndlessLoopStatement>`
* :class:`While loop statement <pyVHDLModel.Sequential.WhileLoopStatement>`
* :class:`For-generate statement <pyVHDLModel.Concurrent.ForGenerateStatement>`
"""
_loopIndex: str #: The name of the loop's index.
_range: Range #: The range the loop iterates over.
def __init__(
self,
loopIndex: str,
rng: Range,
statements: Nullable[Iterable[SequentialStatement]] = None,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a for-loop statement.
:param loopIndex: The name of the loop's index.
:param rng: The range the loop iterates over.
:param statements: Optional, list of all sequential statements in this construct.
Default: ``None``, no statements.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(statements, label, documentation, parent)
self._loopIndex = loopIndex
self._range = rng
rng.Parent = self
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this for-loop, its range and its statements with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitForLoopStatement(self)
self._range.Visit(visitor)
visitor.VisitLoop(self)
self._VisitStatements(visitor)
visitor.VisitEnd(self)
visitor.VisitTerminator(self)
visitor.DepartForLoopStatement(self)
@readonly
def LoopIndex(self) -> str:
"""
Read-only property to access the loop index (:attr:`_loopIndex`).
:returns: The loop index.
"""
return self._loopIndex
@readonly
def Range(self) -> Range:
"""
Read-only property to access the range (:attr:`_range`).
:returns: The range.
"""
return self._range
@export
class WhileLoopStatement(LoopStatement, ConditionalMixin):
"""
Represents a while-loop statement.
The loop condition is available as :data:`Condition`, the loop body as :data:`Statements`.
.. admonition:: Example
.. code-block:: VHDL
lbl : while i < 4 loop
--^^^ <- optional Label
-- ^^^^^ <- Condition
null;
-- ^^^^^ <- Statements
end loop;
.. seealso::
* :class:`Endless loop statement <pyVHDLModel.Sequential.EndlessLoopStatement>`
* :class:`For loop statement <pyVHDLModel.Sequential.ForLoopStatement>`
"""
def __init__(
self,
condition: ExpressionUnion,
statements: Nullable[Iterable[SequentialStatement]] = None,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a while-loop statement.
:param condition: The condition guarding this statement.
:param statements: Optional, list of all sequential statements in this construct.
Default: ``None``, no statements.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(statements, label, documentation, parent)
ConditionalMixin.__init__(self, condition)
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this while-loop, its condition and its statements with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitWhileLoopStatement(self)
self._condition.Visit(visitor)
visitor.VisitLoop(self)
self._VisitStatements(visitor)
visitor.VisitEnd(self)
visitor.VisitTerminator(self)
visitor.DepartWhileLoopStatement(self)
@export
@abstractclass
class LoopControlStatement(SequentialStatement, ConditionalMixin):
"""
Represents the base-class of the loop control statements ``next`` and ``exit``.
An optional loop label (:data:`LoopReference`) selects which enclosing loop is affected.
.. seealso::
* :class:`Next statement <pyVHDLModel.Sequential.NextStatement>`
* :class:`Exit statement <pyVHDLModel.Sequential.ExitStatement>`
"""
_loopReference: Nullable[LoopSymbol] #: Reference to the controlled loop, or ``None`` for the innermost loop.
def __init__(
self,
condition: Nullable[ExpressionUnion] = None,
loopLabel: Nullable[LoopSymbol] = None,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a loop control statement.
:param condition: Optional, the condition guarding this statement.
Default: ``None``, an unconditional ``next`` or ``exit``.
:param loopLabel: Optional, reference to the controlled loop by its label.
Default: ``None``, the innermost loop.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
:raises TypeError: If parameter 'loopLabel' is not of type :class:`~pyVHDLModel.Symbol.LoopSymbol`.
"""
super().__init__(label, documentation, parent)
ConditionalMixin.__init__(self, condition)
if loopLabel is not None and not isinstance(loopLabel, LoopSymbol):
ex = TypeError("Parameter 'loopLabel' is not of type 'LoopSymbol'.")
ex.add_note(f"Got type '{getFullyQualifiedName(loopLabel)}'.")
raise ex
self._loopReference = loopLabel
if loopLabel is not None:
loopLabel.Parent = self
@readonly
def LoopReference(self) -> Nullable[LoopSymbol]:
"""
Read-only property to access the reference to the controlled loop (:attr:`_loopReference`).
:returns: The reference to the controlled loop, or ``None`` if not set (the innermost loop).
"""
return self._loopReference
@export
class NextStatement(LoopControlStatement):
"""
Represents a next statement.
A next statement skips to the next iteration of the named loop (:data:`LoopReference`),
optionally only when a condition (:data:`Condition`) holds.
.. admonition:: Example
.. code-block:: VHDL
lbl : next outer when k = 1;
--^^^ <- optional Label
-- ^^^^^ <- optional LoopReference
-- ^^^^^ <- optional Condition
"""
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this next statement, its loop label (if any) and its condition (if any) with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitNextStatement(self)
if self._loopReference is not None:
self._loopReference.Visit(visitor)
if self._condition is not None:
visitor.VisitWhen(self)
self._condition.Visit(visitor)
visitor.VisitTerminator(self)
visitor.DepartNextStatement(self)
@export
class ExitStatement(LoopControlStatement):
"""
Represents an exit statement.
An exit statement leaves the named loop (:data:`LoopReference`), optionally only when a
condition (:data:`Condition`) holds.
.. admonition:: Example
.. code-block:: VHDL
lbl : exit outer when k = 1;
--^^^ <- optional Label
-- ^^^^^ <- optional LoopReference
-- ^^^^^ <- optional Condition
"""
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this exit statement, its loop label (if any) and its condition (if any) with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitExitStatement(self)
if self._loopReference is not None:
self._loopReference.Visit(visitor)
if self._condition is not None:
visitor.VisitWhen(self)
self._condition.Visit(visitor)
visitor.VisitTerminator(self)
visitor.DepartExitStatement(self)
@export
class NullStatement(SequentialStatement):
"""
Represents a null statement.
A null statement does nothing. Like every sequential statement, it can carry an optional label
(:data:`Label`).
.. admonition:: Example
.. code-block:: VHDL
lbl : null;
--^^^ <- optional Label
-- ^^^^ <- the statement
"""
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this null statement with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitNullStatement(self)
visitor.VisitTerminator(self)
visitor.DepartNullStatement(self)
@export
class ReturnStatement(SequentialStatement):
"""
Represents a return statement.
The optionally returned value is available as :data:`ReturnValue`; a procedure returns nothing.
.. admonition:: Example
.. code-block:: VHDL
lbl : return x;
--^^^ <- optional Label
-- ^ <- optional ReturnValue
"""
_returnValue: Nullable[ExpressionUnion] #: The returned expression, or ``None`` for a procedure.
def __init__(
self,
returnValue: Nullable[ExpressionUnion] = None,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a return statement.
:param returnValue: Optional, the returned expression. Default: ``None``, a return from a procedure.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
self._returnValue = returnValue
if returnValue is not None:
returnValue.Parent = self
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this return statement and its value (if any) with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitReturnStatement(self)
if self._returnValue is not None:
self._returnValue.Visit(visitor)
visitor.VisitTerminator(self)
visitor.DepartReturnStatement(self)
@readonly
def ReturnValue(self) -> Nullable[ExpressionUnion]:
"""
Read-only property to access the return value (:attr:`_returnValue`).
:returns: The return value, or ``None`` if not set.
"""
return self._returnValue
@export
class WaitStatement(SequentialStatement, ConditionalMixin):
"""
Represents a wait statement.
A wait statement may name a sensitivity list (:data:`SensitivityList`), a condition
(:data:`Condition`) and a timeout (:data:`Timeout`); all three are optional.
.. admonition:: Example
.. code-block:: VHDL
lbl : wait until clock = '1' for 10 ns;
--^^^ <- optional Label
-- ^^^^^^^^^^^ <- optional Condition
-- ^^^^^ <- optional Timeout
"""
_sensitivityList: Nullable[list[Symbol]] #: List of all signal names to wait on, or ``None`` if none was given.
_timeout: ExpressionUnion #: The timeout expression, or ``None`` if none was given.
def __init__(
self,
sensitivityList: Nullable[Iterable[Symbol]] = None,
condition: Nullable[ExpressionUnion] = None,
timeout: Nullable[ExpressionUnion] = None,
label: Nullable[str] = None,
documentation: Nullable[str] = None,
parent: Nullable[ModelEntity] = None
) -> None:
"""
Initializes a wait statement.
:param sensitivityList: Optional, list of all signal names to wait on. Default: ``None``, no sensitivity clause.
:param condition: Optional, the condition guarding this statement. Default: ``None``, no condition clause.
:param timeout: Optional, the timeout expression. Default: ``None``, no timeout.
:param label: Optional, the label of a model entity. Default: ``None``, no label.
:param documentation: Optional, the documentation comment associated with this declaration.
Default: ``None``, no documentation.
:param parent: Optional, the parent model entity of this entity. Default: ``None``, no parent.
"""
super().__init__(label, documentation, parent)
ConditionalMixin.__init__(self, condition)
if sensitivityList is None:
self._sensitivityList = None
else:
self._sensitivityList = signalSymbols = [] # TODO: convert to dict
for signalSymbol in sensitivityList:
signalSymbols.append(signalSymbol)
signalSymbol.Parent = self
self._timeout = timeout
if timeout is not None:
timeout.Parent = self
[docs]
def Visit(self, visitor: Visitor) -> None:
"""
Walk this wait statement, its sensitivity clause, its condition clause and its timeout clause with a visitor.
:param visitor: The visitor receiving the events.
"""
visitor.VisitWaitStatement(self)
if self._sensitivityList is not None:
visitor.VisitOn(self)
for index, name in enumerate(self._sensitivityList):
if index > 0:
visitor.VisitNameListSeparator(self)
name.Visit(visitor)
if self._condition is not None:
visitor.VisitUntil(self)
self._condition.Visit(visitor)
if self._timeout is not None:
visitor.VisitFor(self)
self._timeout.Visit(visitor)
visitor.VisitTerminator(self)
visitor.DepartWaitStatement(self)
@readonly
def SensitivityList(self) -> list[Symbol]:
"""
Read-only property to access the sensitivity list (:attr:`_sensitivityList`).
:returns: List of sensitivity list.
"""
return self._sensitivityList
@readonly
def Timeout(self) -> ExpressionUnion:
"""
Read-only property to access the timeout (:attr:`_timeout`).
:returns: The timeout.
"""
return self._timeout