usb-tools/amaranth
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

hdl.ast: deprecate shapes like (1, True) in favor of signed(1).

Browse source 
This is a great improvement in clarity.
This commit is contained in:
whitequark 2019-10-11 13:22:08 +00:00
parent 706bfaf5e1
commit a658cb2bbf
6 changed files with 189 additions and 171 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
nmigen/back/rtlil.py
View file

@ -464,7 +464,7 @@ class _RHSValueCompiler(_ValueCompiler):
def match_shape(self, value, new_bits, new_sign):
if isinstance(value, ast.Const):
return self(ast.Const(value.value, (new_bits, new_sign)))
return self(ast.Const(value.value, ast.Shape(new_bits, new_sign)))
value_bits, value_sign = value.shape()
if new_bits <= value_bits:
@ -511,7 +511,7 @@ class _RHSValueCompiler(_ValueCompiler):
res = self.s.rtlil.wire(width=res_bits, src=src(value.src_loc))
self.s.rtlil.cell("$mux", ports={
"\\A": divmod_res,
"\\B": self(ast.Const(0, (res_bits, res_sign))),
"\\B": self(ast.Const(0, ast.Shape(res_bits, res_sign))),
"\\S": self(lhs == 0),
"\\Y": res,
}, params={

19
nmigen/hdl/ast.py
View file

@ -59,11 +59,18 @@ class Shape(typing.NamedTuple):
signed: bool = False
@staticmethod
def cast(obj):
def cast(obj, *, src_loc_at=0):
if isinstance(obj, Shape):
return obj
if isinstance(obj, int):
return Shape(obj)
if isinstance(obj, tuple):
return Shape(*obj)
width, signed = obj
warnings.warn("instead of `{tuple}`, use `{constructor}({width})`"
.format(constructor="signed" if signed else "unsigned", width=width,
tuple=obj),
DeprecationWarning, stacklevel=2 + src_loc_at)
return Shape(width, signed)
if isinstance(obj, range):
if len(obj) == 0:
return Shape(0, obj.start < 0)
@ -446,7 +453,7 @@ class Const(Value):
value |= ~mask
return value
def __init__(self, value, shape=None):
def __init__(self, value, shape=None, *, src_loc_at=0):
# We deliberately do not call Value.__init__ here.
self.value = int(value)
if shape is None:
@ -454,7 +461,7 @@ class Const(Value):
elif isinstance(shape, int):
shape = Shape(shape, signed=self.value < 0)
else:
shape = Shape.cast(shape)
shape = Shape.cast(shape, src_loc_at=1 + src_loc_at)
self.width, self.signed = shape
self.value = self.normalize(self.value, shape)
@ -483,7 +490,7 @@ C = Const # shorthand
class AnyValue(Value, DUID):
def __init__(self, shape, *, src_loc_at=0):
super().__init__(src_loc_at=src_loc_at)
self.width, self.signed = Shape.cast(shape)
self.width, self.signed = Shape.cast(shape, src_loc_at=1 + src_loc_at)
if not isinstance(self.width, int) or self.width < 0:
raise TypeError("Width must be a non-negative integer, not {!r}"
.format(self.width))
@ -848,7 +855,7 @@ class Signal(Value, DUID):
else:
if not (min is None and max is None):
raise ValueError("Only one of bits/signedness or bounds may be specified")
self.width, self.signed = Shape.cast(shape)
self.width, self.signed = Shape.cast(shape, src_loc_at=1 + src_loc_at)
reset_width = bits_for(reset, self.signed)
if reset != 0 and reset_width > self.width:

10
nmigen/hdl/rec.py
View file

@ -19,12 +19,12 @@ DIR_FANIN = Direction.FANIN
class Layout:
@staticmethod
def wrap(obj):
def wrap(obj, src_loc_at=0):
if isinstance(obj, Layout):
return obj
return Layout(obj)
return Layout(obj, src_loc_at=1 + src_loc_at)
def __init__(self, fields):
def __init__(self, fields, *, src_loc_at=0):
self.fields = OrderedDict()
for field in fields:
if not isinstance(field, tuple) or len(field) not in (2, 3):
@ -47,7 +47,7 @@ class Layout:
.format(field))
if not isinstance(shape, Layout):
try:
shape = Shape.cast(shape)
shape = Shape.cast(shape, src_loc_at=1 + src_loc_at)
except Exception as error:
raise TypeError("Field {!r} has invalid shape: should be castable to Shape "
"or a list of fields of a nested record"
@ -115,7 +115,7 @@ class Record(Value):
return b
return "{}__{}".format(a, b)
self.layout = Layout.wrap(layout)
self.layout = Layout.wrap(layout, src_loc_at=1 + src_loc_at)
self.fields = OrderedDict()
for field_name, field_shape, field_dir in self.layout:
if fields is not None and field_name in fields:

4
nmigen/test/compat/test_size.py
View file

@ -1,5 +1,6 @@
import unittest
from ...tools import _ignore_deprecated
from ...compat import *
@ -11,7 +12,8 @@ class SignalSizeCase(unittest.TestCase):
def setUp(self):
self.i = C(0xaa)
self.j = C(-127)
self.s = Signal((13, True))
with _ignore_deprecated():
self.s = Signal((13, True))
def test_len(self):
self.assertEqual(len(self.s), 13)

321
nmigen/test/test_hdl_ast.py
View file

@ -56,6 +56,14 @@ class ShapeTestCase(FHDLTestCase):
self.assertEqual(s1.width, 2)
self.assertEqual(s1.signed, True)
def test_cast_shape(self):
s1 = Shape.cast(unsigned(1))
self.assertEqual(s1.width, 1)
self.assertEqual(s1.signed, False)
s2 = Shape.cast(signed(3))
self.assertEqual(s2.width, 3)
self.assertEqual(s2.signed, True)
def test_cast_int(self):
s1 = Shape.cast(2)
self.assertEqual(s1.width, 2)
@ -67,17 +75,18 @@ class ShapeTestCase(FHDLTestCase):
Shape.cast(-1)
def test_cast_tuple(self):
s1 = Shape.cast((1, False))
self.assertEqual(s1.width, 1)
self.assertEqual(s1.signed, False)
s2 = Shape.cast((3, True))
self.assertEqual(s2.width, 3)
self.assertEqual(s2.signed, True)
with warnings.catch_warnings():
warnings.filterwarnings(action="ignore", category=DeprecationWarning)
s1 = Shape.cast((1, True))
self.assertEqual(s1.width, 1)
self.assertEqual(s1.signed, True)
def test_cast_tuple_wrong(self):
with self.assertRaises(TypeError,
msg="Width must be a non-negative integer, not -1"):
Shape.cast((-1, True))
with warnings.catch_warnings():
warnings.filterwarnings(action="ignore", category=DeprecationWarning)
with self.assertRaises(TypeError,
msg="Width must be a non-negative integer, not -1"):
Shape.cast((-1, True))
def test_cast_range(self):
s1 = Shape.cast(range(0, 8))
@ -134,10 +143,10 @@ class ValueTestCase(FHDLTestCase):
def test_cast_enum(self):
e1 = Value.cast(UnsignedEnum.FOO)
self.assertIsInstance(e1, Const)
self.assertEqual(e1.shape(), (2, False))
self.assertEqual(e1.shape(), unsigned(2))
e2 = Value.cast(SignedEnum.FOO)
self.assertIsInstance(e2, Const)
self.assertEqual(e2.shape(), (2, True))
self.assertEqual(e2.shape(), signed(2))
def test_cast_enum_wrong(self):
with self.assertRaises(TypeError,
@ -195,16 +204,16 @@ class ValueTestCase(FHDLTestCase):
class ConstTestCase(FHDLTestCase):
def test_shape(self):
self.assertEqual(Const(0).shape(), (1, False))
self.assertEqual(Const(0).shape(), unsigned(1))
self.assertIsInstance(Const(0).shape(), Shape)
self.assertEqual(Const(1).shape(), (1, False))
self.assertEqual(Const(10).shape(), (4, False))
self.assertEqual(Const(-10).shape(), (5, True))
self.assertEqual(Const(1).shape(), unsigned(1))
self.assertEqual(Const(10).shape(), unsigned(4))
self.assertEqual(Const(-10).shape(), signed(5))
self.assertEqual(Const(1, 4).shape(), (4, False))
self.assertEqual(Const(-1, 4).shape(), (4, True))
self.assertEqual(Const(1, (4, True)).shape(), (4, True))
self.assertEqual(Const(0, (0, False)).shape(), (0, False))
self.assertEqual(Const(1, 4).shape(), unsigned(4))
self.assertEqual(Const(-1, 4).shape(), signed(4))
self.assertEqual(Const(1, signed(4)).shape(), signed(4))
self.assertEqual(Const(0, unsigned(0)).shape(), unsigned(0))
def test_shape_wrong(self):
with self.assertRaises(TypeError,
@ -212,7 +221,7 @@ class ConstTestCase(FHDLTestCase):
Const(1, -1)
def test_normalization(self):
self.assertEqual(Const(0b10110, (5, True)).value, -10)
self.assertEqual(Const(0b10110, signed(5)).value, -10)
def test_value(self):
self.assertEqual(Const(10).value, 10)
@ -230,184 +239,184 @@ class OperatorTestCase(FHDLTestCase):
def test_bool(self):
v = Const(0, 4).bool()
self.assertEqual(repr(v), "(b (const 4'd0))")
self.assertEqual(v.shape(), (1, False))
self.assertEqual(v.shape(), unsigned(1))
def test_invert(self):
v = ~Const(0, 4)
self.assertEqual(repr(v), "(~ (const 4'd0))")
self.assertEqual(v.shape(), (4, False))
self.assertEqual(v.shape(), unsigned(4))
def test_neg(self):
v1 = -Const(0, (4, False))
v1 = -Const(0, unsigned(4))
self.assertEqual(repr(v1), "(- (const 4'd0))")
self.assertEqual(v1.shape(), (5, True))
v2 = -Const(0, (4, True))
self.assertEqual(v1.shape(), signed(5))
v2 = -Const(0, signed(4))
self.assertEqual(repr(v2), "(- (const 4'sd0))")
self.assertEqual(v2.shape(), (4, True))
self.assertEqual(v2.shape(), signed(4))
def test_add(self):
v1 = Const(0, (4, False)) + Const(0, (6, False))
v1 = Const(0, unsigned(4)) + Const(0, unsigned(6))
self.assertEqual(repr(v1), "(+ (const 4'd0) (const 6'd0))")
self.assertEqual(v1.shape(), (7, False))
v2 = Const(0, (4, True)) + Const(0, (6, True))
self.assertEqual(v2.shape(), (7, True))
v3 = Const(0, (4, True)) + Const(0, (4, False))
self.assertEqual(v3.shape(), (6, True))
v4 = Const(0, (4, False)) + Const(0, (4, True))
self.assertEqual(v4.shape(), (6, True))
self.assertEqual(v1.shape(), unsigned(7))
v2 = Const(0, signed(4)) + Const(0, signed(6))
self.assertEqual(v2.shape(), signed(7))
v3 = Const(0, signed(4)) + Const(0, unsigned(4))
self.assertEqual(v3.shape(), signed(6))
v4 = Const(0, unsigned(4)) + Const(0, signed(4))
self.assertEqual(v4.shape(), signed(6))
v5 = 10 + Const(0, 4)
self.assertEqual(v5.shape(), (5, False))
self.assertEqual(v5.shape(), unsigned(5))
def test_sub(self):
v1 = Const(0, (4, False)) - Const(0, (6, False))
v1 = Const(0, unsigned(4)) - Const(0, unsigned(6))
self.assertEqual(repr(v1), "(- (const 4'd0) (const 6'd0))")
self.assertEqual(v1.shape(), (7, False))
v2 = Const(0, (4, True)) - Const(0, (6, True))
self.assertEqual(v2.shape(), (7, True))
v3 = Const(0, (4, True)) - Const(0, (4, False))
self.assertEqual(v3.shape(), (6, True))
v4 = Const(0, (4, False)) - Const(0, (4, True))
self.assertEqual(v4.shape(), (6, True))
self.assertEqual(v1.shape(), unsigned(7))
v2 = Const(0, signed(4)) - Const(0, signed(6))
self.assertEqual(v2.shape(), signed(7))
v3 = Const(0, signed(4)) - Const(0, unsigned(4))
self.assertEqual(v3.shape(), signed(6))
v4 = Const(0, unsigned(4)) - Const(0, signed(4))
self.assertEqual(v4.shape(), signed(6))
v5 = 10 - Const(0, 4)
self.assertEqual(v5.shape(), (5, False))
self.assertEqual(v5.shape(), unsigned(5))
def test_mul(self):
v1 = Const(0, (4, False)) * Const(0, (6, False))
v1 = Const(0, unsigned(4)) * Const(0, unsigned(6))
self.assertEqual(repr(v1), "(* (const 4'd0) (const 6'd0))")
self.assertEqual(v1.shape(), (10, False))
v2 = Const(0, (4, True)) * Const(0, (6, True))
self.assertEqual(v2.shape(), (10, True))
v3 = Const(0, (4, True)) * Const(0, (4, False))
self.assertEqual(v3.shape(), (8, True))
self.assertEqual(v1.shape(), unsigned(10))
v2 = Const(0, signed(4)) * Const(0, signed(6))
self.assertEqual(v2.shape(), signed(10))
v3 = Const(0, signed(4)) * Const(0, unsigned(4))
self.assertEqual(v3.shape(), signed(8))
v5 = 10 * Const(0, 4)
self.assertEqual(v5.shape(), (8, False))
self.assertEqual(v5.shape(), unsigned(8))
def test_mod(self):
v1 = Const(0, (4, False)) % Const(0, (6, False))
v1 = Const(0, unsigned(4)) % Const(0, unsigned(6))
self.assertEqual(repr(v1), "(% (const 4'd0) (const 6'd0))")
self.assertEqual(v1.shape(), (4, False))
v3 = Const(0, (4, True)) % Const(0, (4, False))
self.assertEqual(v3.shape(), (4, True))
self.assertEqual(v1.shape(), unsigned(4))
v3 = Const(0, signed(4)) % Const(0, unsigned(4))
self.assertEqual(v3.shape(), signed(4))
v5 = 10 % Const(0, 4)
self.assertEqual(v5.shape(), (4, False))
self.assertEqual(v5.shape(), unsigned(4))
def test_mod_wrong(self):
with self.assertRaises(NotImplementedError,
msg="Division by a signed value is not supported"):
Const(0, (4, True)) % Const(0, (6, True))
Const(0, signed(4)) % Const(0, signed(6))
def test_floordiv(self):
v1 = Const(0, (4, False)) // Const(0, (6, False))
v1 = Const(0, unsigned(4)) // Const(0, unsigned(6))
self.assertEqual(repr(v1), "(// (const 4'd0) (const 6'd0))")
self.assertEqual(v1.shape(), (4, False))
v3 = Const(0, (4, True)) // Const(0, (4, False))
self.assertEqual(v3.shape(), (4, True))
self.assertEqual(v1.shape(), unsigned(4))
v3 = Const(0, signed(4)) // Const(0, unsigned(4))
self.assertEqual(v3.shape(), signed(4))
v5 = 10 // Const(0, 4)
self.assertEqual(v5.shape(), (4, False))
self.assertEqual(v5.shape(), unsigned(4))
def test_floordiv_wrong(self):
with self.assertRaises(NotImplementedError,
msg="Division by a signed value is not supported"):
Const(0, (4, True)) // Const(0, (6, True))
Const(0, signed(4)) // Const(0, signed(6))
def test_and(self):
v1 = Const(0, (4, False)) & Const(0, (6, False))
v1 = Const(0, unsigned(4)) & Const(0, unsigned(6))
self.assertEqual(repr(v1), "(& (const 4'd0) (const 6'd0))")
self.assertEqual(v1.shape(), (6, False))
v2 = Const(0, (4, True)) & Const(0, (6, True))
self.assertEqual(v2.shape(), (6, True))
v3 = Const(0, (4, True)) & Const(0, (4, False))
self.assertEqual(v3.shape(), (5, True))
v4 = Const(0, (4, False)) & Const(0, (4, True))
self.assertEqual(v4.shape(), (5, True))
self.assertEqual(v1.shape(), unsigned(6))
v2 = Const(0, signed(4)) & Const(0, signed(6))
self.assertEqual(v2.shape(), signed(6))
v3 = Const(0, signed(4)) & Const(0, unsigned(4))
self.assertEqual(v3.shape(), signed(5))
v4 = Const(0, unsigned(4)) & Const(0, signed(4))
self.assertEqual(v4.shape(), signed(5))
v5 = 10 & Const(0, 4)
self.assertEqual(v5.shape(), (4, False))
self.assertEqual(v5.shape(), unsigned(4))
def test_or(self):
v1 = Const(0, (4, False)) | Const(0, (6, False))
v1 = Const(0, unsigned(4)) | Const(0, unsigned(6))
self.assertEqual(repr(v1), "(| (const 4'd0) (const 6'd0))")
self.assertEqual(v1.shape(), (6, False))
v2 = Const(0, (4, True)) | Const(0, (6, True))
self.assertEqual(v2.shape(), (6, True))
v3 = Const(0, (4, True)) | Const(0, (4, False))
self.assertEqual(v3.shape(), (5, True))
v4 = Const(0, (4, False)) | Const(0, (4, True))
self.assertEqual(v4.shape(), (5, True))
self.assertEqual(v1.shape(), unsigned(6))
v2 = Const(0, signed(4)) | Const(0, signed(6))
self.assertEqual(v2.shape(), signed(6))
v3 = Const(0, signed(4)) | Const(0, unsigned(4))
self.assertEqual(v3.shape(), signed(5))
v4 = Const(0, unsigned(4)) | Const(0, signed(4))
self.assertEqual(v4.shape(), signed(5))
v5 = 10 | Const(0, 4)
self.assertEqual(v5.shape(), (4, False))
self.assertEqual(v5.shape(), unsigned(4))
def test_xor(self):
v1 = Const(0, (4, False)) ^ Const(0, (6, False))
v1 = Const(0, unsigned(4)) ^ Const(0, unsigned(6))
self.assertEqual(repr(v1), "(^ (const 4'd0) (const 6'd0))")
self.assertEqual(v1.shape(), (6, False))
v2 = Const(0, (4, True)) ^ Const(0, (6, True))
self.assertEqual(v2.shape(), (6, True))
v3 = Const(0, (4, True)) ^ Const(0, (4, False))
self.assertEqual(v3.shape(), (5, True))
v4 = Const(0, (4, False)) ^ Const(0, (4, True))
self.assertEqual(v4.shape(), (5, True))
self.assertEqual(v1.shape(), unsigned(6))
v2 = Const(0, signed(4)) ^ Const(0, signed(6))
self.assertEqual(v2.shape(), signed(6))
v3 = Const(0, signed(4)) ^ Const(0, unsigned(4))
self.assertEqual(v3.shape(), signed(5))
v4 = Const(0, unsigned(4)) ^ Const(0, signed(4))
self.assertEqual(v4.shape(), signed(5))
v5 = 10 ^ Const(0, 4)
self.assertEqual(v5.shape(), (4, False))
self.assertEqual(v5.shape(), unsigned(4))
def test_shl(self):
v1 = Const(1, 4) << Const(4)
self.assertEqual(repr(v1), "(<< (const 4'd1) (const 3'd4))")
self.assertEqual(v1.shape(), (11, False))
self.assertEqual(v1.shape(), unsigned(11))
v2 = Const(1, 4) << Const(-3)
self.assertEqual(v2.shape(), (7, False))
self.assertEqual(v2.shape(), unsigned(7))
def test_shr(self):
v1 = Const(1, 4) >> Const(4)
self.assertEqual(repr(v1), "(>> (const 4'd1) (const 3'd4))")
self.assertEqual(v1.shape(), (4, False))
self.assertEqual(v1.shape(), unsigned(4))
v2 = Const(1, 4) >> Const(-3)
self.assertEqual(v2.shape(), (8, False))
self.assertEqual(v2.shape(), unsigned(8))
def test_lt(self):
v = Const(0, 4) < Const(0, 6)
self.assertEqual(repr(v), "(< (const 4'd0) (const 6'd0))")
self.assertEqual(v.shape(), (1, False))
self.assertEqual(v.shape(), unsigned(1))
def test_le(self):
v = Const(0, 4) <= Const(0, 6)
self.assertEqual(repr(v), "(<= (const 4'd0) (const 6'd0))")
self.assertEqual(v.shape(), (1, False))
self.assertEqual(v.shape(), unsigned(1))
def test_gt(self):
v = Const(0, 4) > Const(0, 6)
self.assertEqual(repr(v), "(> (const 4'd0) (const 6'd0))")
self.assertEqual(v.shape(), (1, False))
self.assertEqual(v.shape(), unsigned(1))
def test_ge(self):
v = Const(0, 4) >= Const(0, 6)
self.assertEqual(repr(v), "(>= (const 4'd0) (const 6'd0))")
self.assertEqual(v.shape(), (1, False))
self.assertEqual(v.shape(), unsigned(1))
def test_eq(self):
v = Const(0, 4) == Const(0, 6)
self.assertEqual(repr(v), "(== (const 4'd0) (const 6'd0))")
self.assertEqual(v.shape(), (1, False))
self.assertEqual(v.shape(), unsigned(1))
def test_ne(self):
v = Const(0, 4) != Const(0, 6)
self.assertEqual(repr(v), "(!= (const 4'd0) (const 6'd0))")
self.assertEqual(v.shape(), (1, False))
self.assertEqual(v.shape(), unsigned(1))
def test_mux(self):
s = Const(0)
v1 = Mux(s, Const(0, (4, False)), Const(0, (6, False)))
v1 = Mux(s, Const(0, unsigned(4)), Const(0, unsigned(6)))
self.assertEqual(repr(v1), "(m (const 1'd0) (const 4'd0) (const 6'd0))")
self.assertEqual(v1.shape(), (6, False))
v2 = Mux(s, Const(0, (4, True)), Const(0, (6, True)))
self.assertEqual(v2.shape(), (6, True))
v3 = Mux(s, Const(0, (4, True)), Const(0, (4, False)))
self.assertEqual(v3.shape(), (5, True))
v4 = Mux(s, Const(0, (4, False)), Const(0, (4, True)))
self.assertEqual(v4.shape(), (5, True))
self.assertEqual(v1.shape(), unsigned(6))
v2 = Mux(s, Const(0, signed(4)), Const(0, signed(6)))
self.assertEqual(v2.shape(), signed(6))
v3 = Mux(s, Const(0, signed(4)), Const(0, unsigned(4)))
self.assertEqual(v3.shape(), signed(5))
v4 = Mux(s, Const(0, unsigned(4)), Const(0, signed(4)))
self.assertEqual(v4.shape(), signed(5))
def test_mux_wide(self):
s = Const(0b100)
v = Mux(s, Const(0, (4, False)), Const(0, (6, False)))
v = Mux(s, Const(0, unsigned(4)), Const(0, unsigned(6)))
self.assertEqual(repr(v), "(m (b (const 3'd4)) (const 4'd0) (const 6'd0))")
def test_mux_bool(self):
@ -417,7 +426,7 @@ class OperatorTestCase(FHDLTestCase):
def test_bool(self):
v = Const(0).bool()
self.assertEqual(repr(v), "(b (const 1'd0))")
self.assertEqual(v.shape(), (1, False))
self.assertEqual(v.shape(), unsigned(1))
def test_any(self):
v = Const(0b101).any()
@ -480,10 +489,10 @@ class OperatorTestCase(FHDLTestCase):
class SliceTestCase(FHDLTestCase):
def test_shape(self):
s1 = Const(10)[2]
self.assertEqual(s1.shape(), (1, False))
self.assertEqual(s1.shape(), unsigned(1))
self.assertIsInstance(s1.shape(), Shape)
s2 = Const(-10)[0:2]
self.assertEqual(s2.shape(), (2, False))
self.assertEqual(s2.shape(), unsigned(2))
def test_start_end_negative(self):
c = Const(0, 8)
@ -524,10 +533,10 @@ class BitSelectTestCase(FHDLTestCase):
def test_shape(self):
s1 = self.c.bit_select(self.s, 2)
self.assertEqual(s1.shape(), (2, False))
self.assertEqual(s1.shape(), unsigned(2))
self.assertIsInstance(s1.shape(), Shape)
s2 = self.c.bit_select(self.s, 0)
self.assertEqual(s2.shape(), (0, False))
self.assertEqual(s2.shape(), unsigned(0))
def test_stride(self):
s1 = self.c.bit_select(self.s, 2)
@ -549,7 +558,7 @@ class WordSelectTestCase(FHDLTestCase):
def test_shape(self):
s1 = self.c.word_select(self.s, 2)
self.assertEqual(s1.shape(), (2, False))
self.assertEqual(s1.shape(), unsigned(2))
self.assertIsInstance(s1.shape(), Shape)
def test_stride(self):
@ -570,14 +579,14 @@ class WordSelectTestCase(FHDLTestCase):
class CatTestCase(FHDLTestCase):
def test_shape(self):
c0 = Cat()
self.assertEqual(c0.shape(), (0, False))
self.assertEqual(c0.shape(), unsigned(0))
self.assertIsInstance(c0.shape(), Shape)
c1 = Cat(Const(10))
self.assertEqual(c1.shape(), (4, False))
self.assertEqual(c1.shape(), unsigned(4))
c2 = Cat(Const(10), Const(1))
self.assertEqual(c2.shape(), (5, False))
self.assertEqual(c2.shape(), unsigned(5))
c3 = Cat(Const(10), Const(1), Const(0))
self.assertEqual(c3.shape(), (6, False))
self.assertEqual(c3.shape(), unsigned(6))
def test_repr(self):
c1 = Cat(Const(10), Const(1))
@ -587,10 +596,10 @@ class CatTestCase(FHDLTestCase):
class ReplTestCase(FHDLTestCase):
def test_shape(self):
s1 = Repl(Const(10), 3)
self.assertEqual(s1.shape(), (12, False))
self.assertEqual(s1.shape(), unsigned(12))
self.assertIsInstance(s1.shape(), Shape)
s2 = Repl(Const(10), 0)
self.assertEqual(s2.shape(), (0, False))
self.assertEqual(s2.shape(), unsigned(0))
def test_count_wrong(self):
with self.assertRaises(TypeError):
@ -645,7 +654,7 @@ class ArrayProxyTestCase(FHDLTestCase):
a = Signal(range(3))
b = Signal(range(3))
v = m[a][b]
self.assertEqual(v.shape(), (4, False))
self.assertEqual(v.shape(), unsigned(4))
def test_attr_shape(self):
from collections import namedtuple
@ -653,8 +662,8 @@ class ArrayProxyTestCase(FHDLTestCase):
a = Array(pair(i, -i) for i in range(10))
s = Signal(range(len(a)))
v = a[s]
self.assertEqual(v.p.shape(), (4, False))
self.assertEqual(v.n.shape(), (6, True))
self.assertEqual(v.p.shape(), unsigned(4))
self.assertEqual(v.n.shape(), signed(6))
def test_repr(self):
a = Array([1, 2, 3])
@ -666,41 +675,41 @@ class ArrayProxyTestCase(FHDLTestCase):
class SignalTestCase(FHDLTestCase):
def test_shape(self):
s1 = Signal()
self.assertEqual(s1.shape(), (1, False))
self.assertEqual(s1.shape(), unsigned(1))
self.assertIsInstance(s1.shape(), Shape)
s2 = Signal(2)
self.assertEqual(s2.shape(), (2, False))
s3 = Signal((2, False))
self.assertEqual(s3.shape(), (2, False))
s4 = Signal((2, True))
self.assertEqual(s4.shape(), (2, True))
self.assertEqual(s2.shape(), unsigned(2))
s3 = Signal(unsigned(2))
self.assertEqual(s3.shape(), unsigned(2))
s4 = Signal(signed(2))
self.assertEqual(s4.shape(), signed(2))
s5 = Signal(0)
self.assertEqual(s5.shape(), (0, False))
self.assertEqual(s5.shape(), unsigned(0))
s6 = Signal(range(16))
self.assertEqual(s6.shape(), (4, False))
self.assertEqual(s6.shape(), unsigned(4))
s7 = Signal(range(4, 16))
self.assertEqual(s7.shape(), (4, False))
self.assertEqual(s7.shape(), unsigned(4))
s8 = Signal(range(-4, 16))
self.assertEqual(s8.shape(), (5, True))
self.assertEqual(s8.shape(), signed(5))
s9 = Signal(range(-20, 16))
self.assertEqual(s9.shape(), (6, True))
self.assertEqual(s9.shape(), signed(6))
s10 = Signal(range(0))
self.assertEqual(s10.shape(), (0, False))
self.assertEqual(s10.shape(), unsigned(0))
s11 = Signal(range(1))
self.assertEqual(s11.shape(), (1, False))
self.assertEqual(s11.shape(), unsigned(1))
# deprecated
with warnings.catch_warnings():
warnings.filterwarnings(action="ignore", category=DeprecationWarning)
d6 = Signal(max=16)
self.assertEqual(d6.shape(), (4, False))
self.assertEqual(d6.shape(), unsigned(4))
d7 = Signal(min=4, max=16)
self.assertEqual(d7.shape(), (4, False))
self.assertEqual(d7.shape(), unsigned(4))
d8 = Signal(min=-4, max=16)
self.assertEqual(d8.shape(), (5, True))
self.assertEqual(d8.shape(), signed(5))
d9 = Signal(min=-20, max=16)
self.assertEqual(d9.shape(), (6, True))
self.assertEqual(d9.shape(), signed(6))
d10 = Signal(max=1)
self.assertEqual(d10.shape(), (0, False))
self.assertEqual(d10.shape(), unsigned(0))
def test_shape_wrong(self):
with self.assertRaises(TypeError,
@ -737,10 +746,10 @@ class SignalTestCase(FHDLTestCase):
Signal(3, reset=8)
with self.assertWarns(SyntaxWarning,
msg="Reset value 4 requires 4 bits to represent, but the signal only has 3 bits"):
Signal((3, True), reset=4)
Signal(signed(3), reset=4)
with self.assertWarns(SyntaxWarning,
msg="Reset value -5 requires 4 bits to represent, but the signal only has 3 bits"):
Signal((3, True), reset=-5)
Signal(signed(3), reset=-5)
def test_attrs(self):
s1 = Signal()
@ -754,9 +763,9 @@ class SignalTestCase(FHDLTestCase):
def test_like(self):
s1 = Signal.like(Signal(4))
self.assertEqual(s1.shape(), (4, False))
self.assertEqual(s1.shape(), unsigned(4))
s2 = Signal.like(Signal(range(-15, 1)))
self.assertEqual(s2.shape(), (5, True))
self.assertEqual(s2.shape(), signed(5))
s3 = Signal.like(Signal(4, reset=0b111, reset_less=True))
self.assertEqual(s3.reset, 0b111)
self.assertEqual(s3.reset_less, True)
@ -765,7 +774,7 @@ class SignalTestCase(FHDLTestCase):
s5 = Signal.like(Signal(decoder=str))
self.assertEqual(s5.decoder, str)
s6 = Signal.like(10)
self.assertEqual(s6.shape(), (4, False))
self.assertEqual(s6.shape(), unsigned(4))
s7 = [Signal.like(Signal(4))][0]
self.assertEqual(s7.name, "$like")
s8 = Signal.like(s1, name_suffix="_ff")
@ -781,9 +790,9 @@ class SignalTestCase(FHDLTestCase):
def test_enum(self):
s1 = Signal(UnsignedEnum)
self.assertEqual(s1.shape(), (2, False))
self.assertEqual(s1.shape(), unsigned(2))
s2 = Signal(SignedEnum)
self.assertEqual(s2.shape(), (2, True))
self.assertEqual(s2.shape(), signed(2))
self.assertEqual(s2.decoder(SignedEnum.FOO), "FOO/-1")
@ -800,7 +809,7 @@ class ClockSignalTestCase(FHDLTestCase):
def test_shape(self):
s1 = ClockSignal()
self.assertEqual(s1.shape(), (1, False))
self.assertEqual(s1.shape(), unsigned(1))
self.assertIsInstance(s1.shape(), Shape)
def test_repr(self):
@ -826,7 +835,7 @@ class ResetSignalTestCase(FHDLTestCase):
def test_shape(self):
s1 = ResetSignal()
self.assertEqual(s1.shape(), (1, False))
self.assertEqual(s1.shape(), unsigned(1))
self.assertIsInstance(s1.shape(), Shape)
def test_repr(self):
@ -853,21 +862,21 @@ class MockUserValue(UserValue):
class UserValueTestCase(FHDLTestCase):
def test_shape(self):
uv = MockUserValue(1)
self.assertEqual(uv.shape(), (1, False))
self.assertEqual(uv.shape(), unsigned(1))
self.assertIsInstance(uv.shape(), Shape)
uv.lowered = 2
self.assertEqual(uv.shape(), (1, False))
self.assertEqual(uv.shape(), unsigned(1))
self.assertEqual(uv.lower_count, 1)
class SampleTestCase(FHDLTestCase):
def test_const(self):
s = Sample(1, 1, "sync")
self.assertEqual(s.shape(), (1, False))
self.assertEqual(s.shape(), unsigned(1))
def test_signal(self):
s1 = Sample(Signal(2), 1, "sync")
self.assertEqual(s1.shape(), (2, False))
self.assertEqual(s1.shape(), unsigned(2))
s2 = Sample(ClockSignal(), 1, "sync")
s3 = Sample(ResetSignal(), 1, "sync")
@ -891,4 +900,4 @@ class SampleTestCase(FHDLTestCase):
class InitialTestCase(FHDLTestCase):
def test_initial(self):
i = Initial()
self.assertEqual(i.shape(), (1, False))
self.assertEqual(i.shape(), unsigned(1))

2
nmigen/test/test_hdl_rec.py
View file

@ -15,7 +15,7 @@ class LayoutTestCase(FHDLTestCase):
def test_fields(self):
layout = Layout.wrap([
("cyc", 1),
("data", (32, True)),
("data", signed(32)),
("stb", 1, DIR_FANOUT),
("ack", 1, DIR_FANIN),
("info", [