new WireEnds as in/outputs are now initialized with U again

[Mograsim.git] / era.mi / src / era / mi / logic / Bit.java

diff --git a/era.mi/src/era/mi/logic/Bit.java b/era.mi/src/era/mi/logic/Bit.java
index b18c597..da9a227 100644 (file)
--- a/era.mi/src/era/mi/logic/Bit.java
+++ b/era.mi/src/era/mi/logic/Bit.java
@@ -1,62 +1,108 @@
 package era.mi.logic;
 
+import java.util.Arrays;
 
+/**
+ * stdlogic according to IEEE 1164
+ */
 public enum Bit
 {
-       ONE, ZERO, Z, X;
-       
+       U, X, ZERO, ONE, Z;
+
        public static Bit and(Bit a, Bit b)
        {
                return a.and(b);
        }
-       
+
        public Bit and(Bit other)
        {
-               if(equals(Bit.ZERO) || other.equals(Bit.ZERO))
-                       return Bit.ZERO;
-               else if(equals(other) && equals(Bit.ONE))
-                       return Bit.ONE;
-               else
-                       return Bit.X;
+               return fromTable(AND_TABLE, this, other);
        }
-       
+
        public static Bit or(Bit a, Bit b)
        {
                return a.or(b);
        }
-       
+
        public Bit or(Bit other)
        {
-               if(equals(Bit.ONE) || other.equals(Bit.ONE))
-                       return Bit.ONE;
-               else if(equals(other) && equals(Bit.ZERO))
-                       return Bit.ZERO;
-               else
-                       return Bit.X;
+               return fromTable(OR_TABLE, this, other);
        }
-       
+
        public static Bit xor(Bit a, Bit b)
        {
                return a.xor(b);
        }
-       
+
        public Bit xor(Bit other)
        {
-               //I'm uncertain how this should behave for cases where one value is neither 1 nor 0.
-               //TODO: Implement xor
-               return Bit.X;
+               return fromTable(XOR_TABLE, this, other);
        }
-       
+
        public Bit not()
        {
-               switch(this)
+               switch (this)
                {
+               case U:
+                       return U;
                case ONE:
-                       return Bit.ZERO;
+                       return ZERO;
                case ZERO:
-                       return Bit.ONE;
+                       return ONE;
                default:
-                       return Bit.X;
+                       return X;
                }
        }
-}
+
+       public Bit[] makeArray(int length)
+       {
+               Bit[] bits = new Bit[length];
+               Arrays.fill(bits, this);
+               return bits;
+       }
+
+       public Bit combineWith(Bit other)
+       {
+               return fromTable(JOIN_TABLE, this, other);
+       }
+
+       public static Bit combine(Bit a, Bit b)
+       {
+               return a.combineWith(b);
+       }
+
+       private static Bit fromTable(Bit[][] table, Bit a, Bit b)
+       {
+               return table[a.ordinal()][b.ordinal()];
+       }
+
+       // @formatter:off
+       private static Bit[][] JOIN_TABLE = 
+               { { U, U, U,    U,   U    }, 
+                 { U, X, X,    X,   X    }, 
+                 { U, X, ZERO, X,   ZERO },
+                 { U, X, X,    ONE, ONE  }, 
+                 { U, X, ZERO, ONE, Z    } };
+
+       private static Bit[][] AND_TABLE = 
+               { { U,    U,    ZERO, U,    U    }, 
+                 { U,    X,    ZERO, X,    X    },
+                 { ZERO, ZERO, ZERO, ZERO, ZERO }, 
+                 { U,    X,    ZERO, ONE,  X    }, 
+                 { U,    X,    ZERO, X,    X    } };
+
+       private static Bit[][] OR_TABLE =
+       { { U,   U,   U,    ONE, U    },    
+         { U,   X,   X,    ONE, X    },    
+         { U,   X,   ZERO, ONE, X    },    
+         { ONE, ONE, ONE,  ONE, ONE  },    
+         { U,   X,   X,    ONE, X    } };
+       
+       private static Bit[][] XOR_TABLE =
+       { { U, U, U,    U,    U },    
+         { U, X, X,    X,    X },    
+         { U, X, ZERO, ONE,  X },    
+         { U, X, ONE,  ZERO, X },    
+         { U, X, X,    X,    X } }; 
+       // @formatter:on
+}
\ No newline at end of file