net.mograsim.logic.core/src/net/mograsim/logic/core/types/Bit.java

   1 package net.mograsim.logic.core.types;
   2
   3 import java.util.Arrays;
   4 import java.util.Map;
   5 import java.util.Objects;
   6
   7 /**
   8  * stdlogic according to IEEE 1164
   9  */
  10 public enum Bit implements StrictLogicType<Bit>
  11 {
  12         U("U"), X("X"), ZERO("0"), ONE("1"), Z("Z");
  13
  14         private final String symbol;
  15
  16         private Bit(String symbol)
  17         {
  18                 this.symbol = symbol;
  19         }
  20
  21         @Override
  22         public Bit and(Bit other)
  23         {
  24                 return fromTable(AND_TABLE, this, other);
  25         }
  26
  27         @Override
  28         public Bit or(Bit other)
  29         {
  30                 return fromTable(OR_TABLE, this, other);
  31         }
  32
  33         @Override
  34         public Bit xor(Bit other)
  35         {
  36                 return fromTable(XOR_TABLE, this, other);
  37         }
  38
  39         @Override
  40         public Bit not()
  41         {
  42                 switch (this)
  43                 {
  44                 case U:
  45                         return U;
  46                 case ONE:
  47                         return ZERO;
  48                 case ZERO:
  49                         return ONE;
  50                 default:
  51                         return X;
  52                 }
  53         }
  54
  55         public Bit[] makeArray(int length)
  56         {
  57                 Bit[] bits = new Bit[length];
  58                 Arrays.fill(bits, this);
  59                 return bits;
  60         }
  61
  62         public BitVector toVector(int length)
  63         {
  64                 return BitVector.of(this, length);
  65         }
  66
  67         @Override
  68         public Bit join(Bit other)
  69         {
  70                 return fromTable(JOIN_TABLE, this, other);
  71         }
  72
  73         @Override
  74         public String toString()
  75         {
  76                 return getSymbol();
  77         }
  78
  79         public String getSymbol()
  80         {
  81                 return symbol;
  82         }
  83
  84         public static Bit parse(String s)
  85         {
  86                 Bit bit = SYMBOL_MAP.get(s);
  87                 Objects.requireNonNull(bit, "No Bit found for symbol " + s);
  88                 return bit;
  89         }
  90
  91         public static Bit parse(String s, int symbolPosition)
  92         {
  93                 return parse(s.substring(symbolPosition, symbolPosition + 1));
  94         }
  95
  96         private static Bit fromTable(Bit[][] table, Bit a, Bit b)
  97         {
  98                 return table[a.ordinal()][b.ordinal()];
  99         }
 100
 101         static final Map<String, Bit> SYMBOL_MAP = Map.of(U.symbol, U, X.symbol, X, ZERO.symbol, ZERO, ONE.symbol, ONE, Z.symbol, Z);
 102
 103         // @formatter:off
 104         private static final Bit[][] JOIN_TABLE =
 105                 { { U, U, U,    U,   U    },
 106                   { U, X, X,    X,   X    },
 107                   { U, X, ZERO, X,   ZERO },
 108                   { U, X, X,    ONE, ONE  },
 109                   { U, X, ZERO, ONE, Z    } };
 110
 111         private static final Bit[][] AND_TABLE =
 112                 { { U,    U,    ZERO, U,    U    },
 113                   { U,    X,    ZERO, X,    X    },
 114                   { ZERO, ZERO, ZERO, ZERO, ZERO },
 115                   { U,    X,    ZERO, ONE,  X    },
 116                   { U,    X,    ZERO, X,    X    } };
 117
 118         private static final Bit[][] OR_TABLE =
 119         { { U,   U,   U,    ONE, U    },
 120           { U,   X,   X,    ONE, X    },
 121           { U,   X,   ZERO, ONE, X    },
 122           { ONE, ONE, ONE,  ONE, ONE  },
 123           { U,   X,   X,    ONE, X    } };
 124
 125         private static final Bit[][] XOR_TABLE =
 126         { { U, U, U,    U,    U },
 127           { U, X, X,    X,    X },
 128           { U, X, ZERO, ONE,  X },
 129           { U, X, ONE,  ZERO, X },
 130           { U, X, X,    X,    X } };
 131         // @formatter:on
 132 }