Source code for hwt.code_utils
from typing import Union
from hwt.doc_markers import internal
from hwt.hdl.types.defs import BIT
from hwt.synthesizer.interfaceLevel.mainBases import InterfaceBase
from hwt.synthesizer.rtlLevel.mainBases import RtlSignalBase
from ipCorePackager.constants import DIRECTION
from hwt.hdl.value import HValue
[docs]def rename_signal(unit_instance: "Unit",
sig: Union[RtlSignalBase, int, bool],
name: str):
"""
Wrap signal or value in signal of specified name
:attention: output signal is driven by new signal of a specified name
this means that the assigning to a new signal does not drive a original signal
"""
if isinstance(sig, (int, bool)):
t = BIT
else:
t = sig._dtype
if isinstance(sig, (HValue, int, bool)):
s = unit_instance._sig(name, t, def_val=sig, nop_val=sig)
else:
s = unit_instance._sig(name, t)
s(sig)
return s
[docs]def connect_optional(src: InterfaceBase, dst: InterfaceBase,
check_fn=lambda intf_a, intf_b: (True, [])):
"""
Connect interfaces and ignore all missing things
:param check_fn: filter function(intf_a, intf_b) which check if interfaces should be connected
returns tuple (do_check, extra_connection_list)
"""
return list(_connect_optional(src, dst, check_fn, False))
[docs]@internal
def _connect_optional(src: InterfaceBase, dst: InterfaceBase, check_fn, dir_reverse):
do_connect, extra_connections = check_fn(src, dst)
yield from extra_connections
if not do_connect:
return
if not src._interfaces:
assert not dst._interfaces, (src, dst)
if dir_reverse:
yield src(dst)
else:
yield dst(src)
for _s in src._interfaces:
_d = getattr(dst, _s._name, None)
if _d is None:
# if the interfaces does not have subinterface of same name
continue
if _d._masterDir == DIRECTION.IN:
rev = not dir_reverse
else:
rev = dir_reverse
yield from _connect_optional(_s, _d, check_fn, rev)
[docs]@internal
def _intfToSig(obj):
if isinstance(obj, InterfaceBase):
return obj._sig
else:
return obj
[docs]@internal
def _mkOp(fn):
"""
Function to create variadic operator function
:param fn: function to perform binary operation
"""
def op(*operands, key=None) -> RtlSignalBase:
"""
:param operands: variadic parameter of input uperands
:param key: optional function applied on every operand
before processing
"""
assert operands, operands
top = None
if key is not None:
operands = map(key, operands)
for s in operands:
if top is None:
top = s
else:
top = fn(top, s)
return top
return op