In FSM and Seq, Else is realized as a property, and actual Else operation is synthesized when add() is called. So FSM.goto() and related methods can use Else condition, as well as value assignment.

Author: shtaxxx

tests/extension/fsm_/as_module/fsm_as_module.py

@@ -33,7 +33,8 @@ def mkLed():
     fsm.goto_next()
 
     # jump by using label "init"
-    fsm.goto(dst=init, cond=(count < 1024), else_dst=fsm.next).inc()
+    fsm.goto(dst=init, cond=(count < 1024), else_dst=fsm.next)
+    fsm.inc()
 
     fsm(led(led + 1))
     # jump by using label "here"

tests/extension/fsm_/branch/fsm_branch.py

@@ -23,7 +23,8 @@ def add_if_else(fsm, ifelse):
     index_merge = fsm.current + len(ifelse.true_statements) + len(ifelse.false_statements) + 1
     index_true = fsm.current + 1 if ifelse.true_statements else index_merge
 
-    fsm.goto( dst=index_true, cond=ifelse.condition, else_dst=index_else ).inc()
+    fsm.goto( dst=index_true, cond=ifelse.condition, else_dst=index_else )
+    fsm.inc()
 
     # then
     for i, s in enumerate(ifelse.true_statements):
@@ -32,7 +33,8 @@ def add_if_else(fsm, ifelse):
             fsm.goto_next()
         else:
             fsm( *s )
-            fsm.goto(index_merge).inc()
+            fsm.goto(index_merge)
+            fsm.inc()
 
     # else
     for i, s in enumerate(ifelse.false_statements):

veriloggen/__init__.py

@@ -43,7 +43,7 @@
 
 # Abstract Extension
 from .seq.seq import Seq, TmpSeq, make_condition
-from .fsm.fsm import FSM, TmpFSM
+from .fsm.fsm import FSM, TmpFSM, State
 from .pipeline.pipeline import Pipeline
 
 # Extension reset

veriloggen/fsm/fsm.py

@@ -75,6 +75,7 @@ def __init__(self, m, name, clk, rst, width=32, initname='init',
         self.last_cond = []
         self.last_kwargs = {}
         self.last_if_statement = None
+        self.next_else = False
         self.elif_cond = None
         self.next_kwargs = {}
 
@@ -85,61 +86,111 @@ def __init__(self, m, name, clk, rst, width=32, initname='init',
 
     # -------------------------------------------------------------------------
     def goto(self, dst, cond=None, else_dst=None):
+        if isinstance(dst, State):
+            dst = dst.index
+
         if cond is None and 'cond' in self.next_kwargs:
             cond = self.next_kwargs['cond']
+
+        if 'index' in self.next_kwargs:
+            index = self.next_kwargs['index']
+        else:
+            index = None
+
         self._clear_next_kwargs()
-        self._clear_last_if_statement()
-        self._clear_last_cond()
+        # self._clear_last_if_statement()
+        # self._clear_last_cond()
+        # self._clear_elif_cond()
 
-        src = self.current
-        return self._go(src, dst, cond, else_dst)
+        if index is None:
+            src = self.current
+        else:
+            src = index
+
+        self._go(src, dst, cond, else_dst)
+        return State(self, dst)
 
     def goto_init(self, cond=None):
         if cond is None and 'cond' in self.next_kwargs:
             cond = self.next_kwargs['cond']
+
+        if 'index' in self.next_kwargs:
+            index = self.next_kwargs['index']
+        else:
+            index = None
+
         self._clear_next_kwargs()
-        self._clear_last_if_statement()
-        self._clear_last_cond()
+        # self._clear_last_if_statement()
+        # self._clear_last_cond()
+        # self._clear_elif_cond()
+
+        if index is None:
+            src = self.current
+        else:
+            src = index
 
-        src = self.current
         dst = 0
-        return self._go(src, dst, cond)
+        self._go(src, dst, cond)
+        return State(self, dst)
 
     def goto_next(self, cond=None):
         if cond is None and 'cond' in self.next_kwargs:
             cond = self.next_kwargs['cond']
+
+        if 'index' in self.next_kwargs:
+            index = self.next_kwargs['index']
+        else:
+            index = None
+
         self._clear_next_kwargs()
-        self._clear_last_if_statement()
-        self._clear_last_cond()
+        # self._clear_last_if_statement()
+        # self._clear_last_cond()
+        # self._clear_elif_cond()
+
+        if index is None:
+            src = self.current
+        else:
+            src = index
 
-        src = self.current
-        dst = self.current + 1
-        ret = self._go(src, dst, cond=cond)
+        dst = src + 1
+        self._go(src, dst, cond=cond)
         self.inc()
-        return ret
+        return State(self, dst)
 
     def goto_from(self, src, dst, cond=None, else_dst=None):
+        if isinstance(src, State):
+            src = src.index
+
+        if isinstance(dst, State):
+            dst = dst.index
+
         if cond is None and 'cond' in self.next_kwargs:
             cond = self.next_kwargs['cond']
+
         self._clear_next_kwargs()
-        self._clear_last_if_statement()
-        self._clear_last_cond()
+        # self._clear_last_if_statement()
+        # self._clear_last_cond()
+        # self._clear_elif_cond()
 
-        return self._go(src, dst, cond, else_dst)
+        self._go(src, dst, cond, else_dst)
+        return State(self, dst)
 
     def inc(self):
-        self._set_index(None)
+        return self._set_index(None)
 
     # -------------------------------------------------------------------------
     def add(self, *statement, **kwargs):
-        """ add new assignments """
+        """ Adding new assignments. This method is usually called via __call__(). """
         kwargs.update(self.next_kwargs)
         self.last_kwargs = kwargs
         self._clear_next_kwargs()
 
         # if there is no attributes, Elif object is reused.
         has_args = not (len(kwargs) == 0 or  # has no args
-                        (len(kwargs) == 1 and 'cond' in kwargs))  # has only 'cond'
+                        (len(kwargs) == 1 and 'cond' in kwargs) or  # has only 'cond'
+                        (len(kwargs) == 1 and 'index' in kwargs) or  # has only 'index'
+                        (len(kwargs) == 2 and
+                         'cond' in kwargs and 'index' in kwargs))  # has only 'cond' and 'index'
 
         if self.elif_cond is not None and not has_args:
             next_call = self.last_if_statement.Elif(self.elif_cond)
@@ -149,6 +200,14 @@ def add(self, *statement, **kwargs):
             self._clear_elif_cond()
             return self
 
+        if self.next_else and not has_args:
+            next_call = self.last_if_statement.Else
+            next_call(*statement)
+            self._add_dst_var(statement)
+            self._clear_last_if_statement()
+            self._clear_elif_cond()
+            return self
+
         self._clear_last_if_statement()
         return self._add_statement(statement, **kwargs)
 
@@ -179,7 +238,8 @@ def If(self, *cond):
 
         return self
 
-    def Else(self, *statement, **kwargs):
+    @property
+    def Else(self):
         self._clear_elif_cond()
 
         if len(self.last_cond) == 0:
@@ -192,25 +252,20 @@ def Else(self, *statement, **kwargs):
         # Else statement is separated.
         if 'delay' in self.last_kwargs and self.last_kwargs['delay'] > 0:
             prev_cond = self.last_cond
-            ret = self.Then()(*statement)
+            ret = self.Then()
             self.last_cond = prev_cond
             return ret
 
-        # if there is additional attribute, Else statement is separated.
-        has_args = not (len(self.next_kwargs) == 0 or  # has no args
-                        (len(self.next_kwargs) == 1 and 'cond' in kwargs))  # has only 'cond'
+        # if not isinstance(self.last_if_statement, vtypes.If):
+        #     raise ValueError("Last if-statement is not If")
 
-        if has_args:
-            prev_cond = self.last_cond
-            ret = self.Then()(*statement)
-            self.last_cond = prev_cond
-            return ret
+        # self.next_else = True
 
-        if not isinstance(self.last_if_statement, vtypes.If):
-            raise ValueError("Last if-statement is not If")
+        if isinstance(self.last_if_statement, vtypes.If):
+            self.next_else = True
 
-        self.last_if_statement.Else(*statement)
-        self._add_dst_var(statement)
+        cond = self._make_cond(self.last_cond)
+        self.next_kwargs['cond'] = cond
 
         return self
 
@@ -224,18 +279,21 @@ def Elif(self, *cond):
         self.last_cond.append(vtypes.Not(old))
         self.last_cond.append(cond)
 
-        # if the true-statement has delay attributes, Else statement is
-        # separated.
+        # if the true-statement has delay attributes,
+        # Else statement is separated.
         if 'delay' in self.last_kwargs and self.last_kwargs['delay'] > 0:
             prev_cond = self.last_cond
             ret = self.Then()
             self.last_cond = prev_cond
             return ret
 
-        if not isinstance(self.last_if_statement, vtypes.If):
-            raise ValueError("Last if-statement is not If")
+        # if not isinstance(self.last_if_statement, vtypes.If):
+        #     raise ValueError("Last if-statement is not If")
 
-        self.elif_cond = cond
+        # self.elif_cond = cond
+
+        if isinstance(self.last_if_statement, vtypes.If):
+            self.elif_cond = cond
 
         cond = self._make_cond(self.last_cond)
         self.next_kwargs['cond'] = cond
@@ -264,6 +322,10 @@ def EagerVal(self, value=True):
         self.next_kwargs['eager_val'] = value
         return self
 
+    def When(self, index):
+        self.next_kwargs['index'] = index
+        return self
+
     def Clear(self):
         self._clear_next_kwargs()
         self._clear_last_if_statement()
@@ -272,13 +334,21 @@ def Clear(self):
         return self
 
     # -------------------------------------------------------------------------
+    @property
+    def Always(self):
+        return self.seq
+
+    @property
+    def init(self):
+        return State(self, 0)
+
     @property
     def current(self):
-        return self.state_count
+        return State(self, self.state_count)
 
     @property
     def next(self):
-        return self.current + 1
+        return State(self, self.state_count + 1)
 
     @property
     def current_delay(self):
@@ -806,6 +876,7 @@ def _clear_next_kwargs(self):
 
     def _clear_last_if_statement(self):
         self.last_if_statement = None
+        self.next_else = False
 
     def _clear_last_cond(self):
         self.last_cond = []
@@ -824,9 +895,15 @@ def _make_cond(self, condlist):
 
     # -------------------------------------------------------------------------
     def _set_index(self, index=None):
+        self._clear_next_kwargs()
+        self._clear_last_if_statement()
+        self._clear_last_cond()
+        self._clear_elif_cond()
+
         if index is None:
             self.state_count += 1
             return self.state_count
+
         self.state_count = index
         return self.state_count
 
@@ -970,3 +1047,43 @@ def __getitem__(self, index):
 
     def __len__(self):
         return self.state_count + 1
+
+
+class State(vtypes.VeriloggenNode):
+    """ FSM with a specic state index """
+
+    def __init__(self, fsm, index):
+        while isinstance(fsm, State):
+            fsm = fsm.fsm
+
+        while isinstance(index, State):
+            index = index.index
+
+        if not isinstance(fsm, FSM):
+            raise TypeError("'fsm' must be FSM, not '%s'" % str(type(fsm)))
+
+        if not isinstance(index, int):
+            raise TypeError("'index' must be int, not '%s'" % str(type(index)))
+
+        self.fsm = fsm
+        self.index = index
+
+    def __getattr__(self, attr):
+        self.fsm.When(self.index)
+        return getattr(self.fsm, attr)
+
+    def __call__(self, *statement, **kwargs):
+        self.fsm.When(self.index)
+        return self.fsm.__call__(*statement, **kwargs)
+
+    def __add__(self, r):
+        if isinstance(r, State):
+            r = r.index
+
+        return self.index + r
+
+    def __sub__(self, r):
+        if isinstance(r, State):
+            r = r.index
+
+        return self.index - r