remove TAPL, improve Instruction.toString(), add convenience constructors to Instruction

diff --git a/src/edu/berkeley/fleet/api/Instruction.java b/src/edu/berkeley/fleet/api/Instruction.java
index 963e57b..26191a2 100644 (file)
--- a/src/edu/berkeley/fleet/api/Instruction.java
+++ b/src/edu/berkeley/fleet/api/Instruction.java
@@ -21,10 +21,14 @@ public abstract class Instruction {
         this.predicate = predicate;
     }
 
+    //public abstract Instruction withLooping(boolean newLooping);
+    //public abstract Instruction withPredicate(Predicate newPredicate);
+
     public String toString() {
         String s = predicate.toString();
         if (s.length()>0) s = "["+s+"] ";
-        return s+dock+": ";
+        if (looping) s += "[L] ";
+        return dock+": "+s;
     }
 
     /**
@@ -48,9 +52,6 @@ public abstract class Instruction {
         /** if <tt>source</tt> is <tt>Immediate</tt>, this is the immediate value; an integer */
         public final long           immediate;
 
-        /** if <tt>source</tt> is <tt>ImmediatePath</tt>, this is the immediate path */
-        public final Path           path;
-
         /** if <tt>dest</tt> is <tt>Flags</tt>, this is the truth table to update flag "a" */
         public final FlagFunction   newFlagA;
 
@@ -58,6 +59,7 @@ public abstract class Instruction {
         public final FlagFunction   newFlagB;
 
         /** basic constructor */
+        public Set(Dock dock, SetDest dest, SetSource source) { this(dock, false, Predicate.Default, dest, source); }
         public Set(Dock dock, boolean looping, Predicate predicate, SetDest dest, SetSource source) {
             super(dock, looping, predicate);
             OUTER: switch(dest) {
@@ -78,12 +80,12 @@ public abstract class Instruction {
             this.source = source;
             this.dest = dest;
             this.immediate = 0;
-            this.path = null;
             this.newFlagA = null;
             this.newFlagB = null;
         }
 
         /** constructor for set instructions with immediates */
+        public Set(Dock dock, SetDest dest, long immediate) { this(dock, false, Predicate.Default, dest, immediate); }
         public Set(Dock dock, boolean looping, Predicate predicate, SetDest dest, long immediate) {
             super(dock, looping, predicate);
             if (dest!=SetDest.InnerLoopCounter && dest!=SetDest.OuterLoopCounter && dest!=SetDest.DataLatch)
@@ -91,42 +93,28 @@ public abstract class Instruction {
             this.source = SetSource.Immediate;
             this.dest = dest;
             this.immediate = immediate;
-            this.path = null;
-            this.newFlagA = null;
-            this.newFlagB = null;
-        }
-
-        /** constructor for set instructions with immediate paths */
-        public Set(Dock dock, boolean looping, Predicate predicate, SetDest dest, Path path) {
-            super(dock, looping, predicate);
-            if (dest!=SetDest.TAPL)
-                throw new RuntimeException("a set instruction with dest="+dest+" may not take an immediate path");
-            this.source = SetSource.ImmediatePath;
-            this.dest = dest;
-            this.immediate = 0;
-            this.path = path;
             this.newFlagA = null;
             this.newFlagB = null;
         }
 
         /** constructor for <tt>set flags</tt> instructions */
+        public Set(Dock dock, FlagFunction newFlagA, FlagFunction newFlagB) { this(dock, false, Predicate.Default, newFlagA, newFlagB); }
         public Set(Dock dock, boolean looping, Predicate predicate, FlagFunction newFlagA, FlagFunction newFlagB) {
             super(dock, looping, predicate);
             this.source = SetSource.Immediate;
             this.dest = SetDest.Flags;
             this.immediate = 0;
-            this.path = null;
             this.newFlagA = newFlagA;
             this.newFlagB = newFlagB;
         }
 
         /** possible sources for the Set instruction */
         public static enum SetSource {
-            Infinity, DataLatch, Immediate, ImmediatePath, Decrement;
+            Infinity, DataLatch, Immediate, Decrement;
         }
         /** possible destinations for the Set instruction */
         public static enum SetDest {
-            InnerLoopCounter, OuterLoopCounter, TAPL, Flags, DataLatch;
+            InnerLoopCounter, OuterLoopCounter, Flags, DataLatch;
         }
 
         /**
@@ -205,19 +193,28 @@ public abstract class Instruction {
             switch(dest) {
                 case InnerLoopCounter:
                     switch(source) {
+                        /*
                         case Infinity: return super.toString()+"set ilc=*";
                         case DataLatch: return super.toString()+"set ilc=data";
                         case Immediate: return super.toString()+"set ilc="+immediate;
+                        */
+                        case Infinity: return super.toString()+"load repeat counter with *;";
+                        case DataLatch: return super.toString()+"set ilc=data";
+                        case Immediate: return super.toString()+"load repeat counter with "+immediate+";";
                     }
                 case OuterLoopCounter:
                     switch(source) {
+                        /*
                         case Decrement: return super.toString()+"set olc--";
                         case DataLatch: return super.toString()+"set olc=data";
                         case Immediate: return super.toString()+"set olc="+immediate;
+                        */
+                        case Decrement: return super.toString()+"decrement loop counter;";
+                        case DataLatch: return super.toString()+"set olc=data;";
+                        case Immediate: return super.toString()+"load loop counter with "+immediate+";";
                     }
-                case TAPL: return super.toString()+"set tapl="+path;
                 case Flags: return super.toString()+"set flags a="+newFlagA+" b="+newFlagB;
-                case DataLatch: return super.toString()+"set data="+immediate;
+                case DataLatch: return super.toString()+"literal "+immediate+";";
             }
             throw new Error("impossible");
         }
@@ -226,6 +223,7 @@ public abstract class Instruction {
     /** shifts an immediate into the low-order bits of the data latch */
     public static class Shift extends Instruction {
         public final BitVector immediate;
+        public Shift(Dock dock, BitVector immediate) { this(dock, false, Predicate.Default, immediate); }
         public Shift(Dock dock, boolean looping, Predicate predicate, BitVector immediate) {
             super(dock, looping, predicate);
             this.immediate = immediate;
@@ -262,6 +260,16 @@ public abstract class Instruction {
         public final boolean     tokenOut;
 
         public Move(Dock        dock,
+                    Path        path,
+                    boolean     tokenIn,
+                    boolean     dataIn,
+                    boolean     latchData,
+                    boolean     latchPath,
+                    boolean     dataOut,
+                    boolean     tokenOut
+                    ) {
+            this(dock, false, Predicate.Default, false, path, tokenIn, dataIn, latchData, latchPath, dataOut, tokenOut); }
+        public Move(Dock        dock,
                     boolean     looping,
                     Predicate   predicate,
                     boolean     interruptible,
@@ -298,17 +306,17 @@ public abstract class Instruction {
             StringBuffer ret = new StringBuffer();
             if (tokenIn)                        ret.append(", wait");
             if (dataIn) {
-                if (latchPath)                  ret.append(dock.isInputDock() ? ", collect path" : ", recv path");
-                if (latchData)                  ret.append(dock.isInputDock() ? ", collect"      : ", recv");
+                if (latchPath)                  ret.append(!dock.isInputDock() ? ", collect path" : ", recv path");
+                if (latchData)                  ret.append(!dock.isInputDock() ? ", collect"      : ", recv");
                 if (!latchPath && !latchData)   ret.append(", discard");
             }
             if (dataOut && dock.isInputDock())  ret.append(", deliver");
-            if (dataOut && !dock.isInputDock()) ret.append(path==null ? ", send"  : "sendto "  + path);
-            if (tokenOut)                       ret.append(path==null ? ", token" : "tokento " + path);
+            if (dataOut && !dock.isInputDock()) ret.append(path==null ? ", send"  : ", sendto "  + path.getDestination().getDock());
+            if (tokenOut)                       ret.append(path==null ? ", token" : ", notify " + path.getDestination().getDock());
             String s = ret.toString();
             s = s.equals("") ? "nop" : s.substring(2);
             if (interruptible) s = "[i] " + s;
-            return super.toString()+s;
+            return super.toString()+s+";";
         }
     }
 

diff --git a/src/edu/berkeley/fleet/assembler/Parser.java b/src/edu/berkeley/fleet/assembler/Parser.java
index c4dc3c3..91368ea 100644 (file)
--- a/src/edu/berkeley/fleet/assembler/Parser.java
+++ b/src/edu/berkeley/fleet/assembler/Parser.java
@@ -393,9 +393,6 @@ public class Parser {
                 } else if ("setflags".equals(tt.head()))    {
                     cb.add(new Set(dock, looping, predicate, parseFlags(tt.child(0)), parseFlags(tt.child(1))));
                     continue;
-                } else if ("tapl".equals(tt.head()))    {
-                    cb.add(new Set(dock, looping, predicate, SetDest.TAPL, path(dock, tt.child(0))));
-                    continue;
                 } else if ("load".equals(tt.head()) && "loop".equals(tt.child(0).head()))    {
                     cb.add(new Set(dock, looping, predicate, SetDest.OuterLoopCounter, SetSource.DataLatch));
                     continue;

diff --git a/src/edu/berkeley/fleet/interpreter/InterpreterDock.java b/src/edu/berkeley/fleet/interpreter/InterpreterDock.java
index 2ff5213..400a968 100644 (file)
--- a/src/edu/berkeley/fleet/interpreter/InterpreterDock.java
+++ b/src/edu/berkeley/fleet/interpreter/InterpreterDock.java
@@ -215,10 +215,6 @@ class InterpreterDock extends FleetTwoDock {
                     }
                     break;
 
-                case TAPL:
-                    tapl = (InterpreterPath)set.path;
-                    break;
-
                 case Flags: {
                     boolean new_flag_a = false;
                     boolean new_flag_b = false;

diff --git a/src/edu/berkeley/fleet/two/FleetTwoFleet.java b/src/edu/berkeley/fleet/two/FleetTwoFleet.java
index 1ee63ea..2b7a9cd 100644 (file)
--- a/src/edu/berkeley/fleet/two/FleetTwoFleet.java
+++ b/src/edu/berkeley/fleet/two/FleetTwoFleet.java
@@ -69,8 +69,6 @@ public abstract class FleetTwoFleet extends Fleet {
     public static final Mask SET_FLAGS_VALUE_C          = new Mask("....1.");
     public static final Mask SET_FLAGS_VALUE_NOT_C      = new Mask(".....1");
 
-    public static final Mask SET_TAPL_FROM_IMMEDIATE    = new Mask("................1000001.vvvvvvvvvvvvv");
-
     // Misc //////////////////////////////////////////////////////////////////////////////
 
     public static final long DataLatch_WIDTH = SET_IMMEDIATE.valmaskmax-SET_IMMEDIATE.valmaskmin+1;  // FIXME: this is an abstraction breakage
@@ -181,8 +179,6 @@ public abstract class FleetTwoFleet extends Fleet {
             if (SET_FLAGS_VALUE_NOT_C.get(flag_b)) bp = bp.add(NotFlagC );
             return new Set(dock, looping, predicate, ap, bp);
         }
-        if (SET_TAPL_FROM_IMMEDIATE.get(inst))
-            return new Set(dock, looping, predicate, SetDest.TAPL, getPathByAddr(dock, SET_TAPL_FROM_IMMEDIATE.getval(inst)));
         if (MOVE.get(inst))
             return new Move(dock,
                             looping,
@@ -254,11 +250,6 @@ public abstract class FleetTwoFleet extends Fleet {
                             break;
                     }
                     break;
-                case TAPL: {
-                    instr = SET_TAPL_FROM_IMMEDIATE.set(instr);
-                    instr = SET_TAPL_FROM_IMMEDIATE.setval(instr, getDestAddr(s.path));
-                    break;
-                }
                 case Flags: {
                     instr = SET_FLAGS.set(instr);
                     instr = SET_FLAGS_A.setval(instr, flagFunctionToLong(s.newFlagA));