compat.fhdl.{module,structure}: import/wrap Migen code (WIP).

nmigen/compat/fhdl/module.py

@@ -0,0 +1,132 @@
+from collections import Iterable
+
+from ...tools import flatten, deprecated
+from ...fhdl import dsl
+
+
+__all__ = ["Module", "FinalizeError"]
+
+
+def _flat_list(e):
+    if isinstance(e, Iterable):
+        return list(flatten(e))
+    else:
+        return [e]
+
+
+class CompatFinalizeError(Exception):
+    pass
+
+
+FinalizeError = CompatFinalizeError
+
+
+class _CompatModuleProxy:
+    def __init__(self, cm):
+        object.__setattr__(self, "_cm", cm)
+
+
+class _CompatModuleComb(_CompatModuleProxy):
+    @deprecated("instead of `self.comb +=`, use `m.d.comb +=`")
+    def __iadd__(self, assigns):
+        self._cm._module._add_statement(assigns, cd_name=None, depth=0, compat_mode=True)
+        return self
+
+
+class _CompatModuleSyncCD:
+    def __init__(self, cm, cd):
+        self._cm = cm
+        self._cd = cd
+
+    @deprecated("instead of `self.sync.<domain> +=`, use `m.d.<domain> +=`")
+    def __iadd__(self, assigns):
+        self._cm._module._add_statement(assigns, cd_name=self._cd, depth=0, compat_mode=True)
+        return self
+
+
+class _CompatModuleSync(_CompatModuleProxy):
+    @deprecated("instead of `self.sync +=`, use `m.d.sync +=`")
+    def __iadd__(self, assigns):
+        self._cm._module._add_statement(assigns, cd_name="sync", depth=0, compat_mode=True)
+        return self
+
+    def __getattr__(self, name):
+        return _CompatModuleSyncCD(self._cm, name)
+
+    def __setattr__(self, name, value):
+        if not isinstance(value, _ModuleSyncCD):
+            raise AttributeError("Attempted to assign sync property - use += instead")
+
+
+class _CompatModuleForwardAttr:
+    @deprecated("TODO")
+    def __setattr__(self, name, value):
+        self.__iadd__(value)
+        setattr(self._cm, name, value)
+
+
+class _CompatModuleSpecials(_CompatModuleProxy, _CompatModuleForwardAttr):
+    @deprecated("TODO")
+    def __iadd__(self, other):
+        self._cm._fragment.specials |= set(_flat_list(other))
+        return self
+
+
+class _CompatModuleSubmodules(_CompatModuleProxy):
+    @deprecated("TODO")
+    def __setattr__(self, name, value):
+        self._cm._submodules += [(name, e) for e in _flat_list(value)]
+        setattr(self._cm, name, value)
+
+    @deprecated("TODO")
+    def __iadd__(self, other):
+        self._cm._submodules += [(None, e) for e in _flat_list(other)]
+        return self
+
+
+class _CompatModuleClockDomains(_CompatModuleProxy, _CompatModuleForwardAttr):
+    @deprecated("TODO")
+    def __iadd__(self, other):
+        self._cm._fragment.clock_domains += _flat_list(other)
+        return self
+
+
+class CompatModule:
+    def get_fragment(self):
+        assert not self.get_fragment_called
+        self.get_fragment_called = True
+        self.finalize()
+        return self._fragment
+
+    def __getattr__(self, name):
+        if name == "comb":
+            return _CompatModuleComb(self)
+        elif name == "sync":
+            return _CompatModuleSync(self)
+        elif name == "specials":
+            return _CompatModuleSpecials(self)
+        elif name == "submodules":
+            return _CompatModuleSubmodules(self)
+        elif name == "clock_domains":
+            return _CompatModuleClockDomains(self)
+        elif name == "finalized":
+            self.finalized = False
+            return self.finalized
+        elif name == "_module":
+            self._module = dsl.Module()
+            return self._module
+        elif name == "_submodules":
+            self._submodules = []
+            return self._submodules
+        elif name == "_clock_domains":
+            self._clock_domains = []
+            return self._clock_domains
+        elif name == "get_fragment_called":
+            self.get_fragment_called = False
+            return self.get_fragment_called
+        else:
+            raise AttributeError("'{}' object has no attribute '{}'"
+                                 .format(type(self).__name__, name))
+
+
+Module = CompatModule

nmigen/compat/fhdl/structure.py

@@ -0,0 +1,65 @@
+from collections import OrderedDict
+
+from ...tools import deprecated
+from ...fhdl import ast
+from ...fhdl.ast import DUID, Value, Signal, Mux, Cat, Repl, Const, C, ClockSignal, ResetSignal
+from ...fhdl.cd import ClockDomain
+
+
+__all__ = ["DUID", "wrap", "Mux", "Cat", "Replicate", "Constant", "C", "Signal", "ClockSignal",
+           "ResetSignal", "If", "Case", "Array", "ClockDomain",
+           "SPECIAL_INPUT", "SPECIAL_OUTPUT", "SPECIAL_INOUT"]
+
+
+@deprecated("instead of `wrap`, use `Value.wrap`")
+def wrap(v):
+    return Value.wrap(v)
+
+
+@deprecated("instead of `Replicate`, use `Repl`")
+def Replicate(v, n):
+    return Repl(v, n)
+
+
+@deprecated("instead of `Constant`, use `Const`")
+def Constant(value, bits_sign=None):
+    return Const(value, bits_sign)
+
+
+class If(ast.Switch):
+    @deprecated("instead of `If(cond, ...)`, use `with m.If(cond): ...`")
+    def __init__(self, cond, *stmts):
+        super().__init__(cond, {"1": ast.Statement.wrap(stmts)})
+
+    @deprecated("instead of `.Elif(cond, ...)`, use `with m.Elif(cond): ...`")
+    def Elif(self, cond, *stmts):
+        self.cases = OrderedDict(("-" + k, v) for k, v in self.cases.items())
+        self.cases["1" + "-" * len(self.test)] = ast.Statement.wrap(stmts)
+        self.test = Cat(self.test, cond)
+        return self
+
+    @deprecated("instead of `.Else(...)`, use `with m.Else(): ...`")
+    def Else(self, *stmts):
+        self.cases["-" * len(self.test)] = ast.Statement.wrap(stmts)
+        return self
+
+
+class Case(ast.Switch):
+    @deprecated("instead of `Case(test, ...)`, use `with m.Case(test, ...):`")
+    def __init__(self, test, cases):
+        new_cases = []
+        for k, v in cases.items():
+            if k == "default":
+                k = "-" * len(ast.Value.wrap(test))
+            new_cases.append((k, v))
+        super().__init__(test, OrderedDict(new_cases))
+
+    def makedefault(self, key=None):
+        raise NotImplementedError
+
+
+def Array(*args):
+    raise NotImplementedError
+
+
+(SPECIAL_INPUT, SPECIAL_OUTPUT, SPECIAL_INOUT) = range(3)