Fleshed out Am2900MicroInstructionDefinition

[Mograsim.git] / net.mograsim.machine / src / net / mograsim / machine / mi / parameters / MnemonicFamily.java

diff --git a/net.mograsim.machine/src/net/mograsim/machine/mi/parameters/MnemonicFamily.java b/net.mograsim.machine/src/net/mograsim/machine/mi/parameters/MnemonicFamily.java
index b9c1373..f4343bd 100644 (file)
--- a/net.mograsim.machine/src/net/mograsim/machine/mi/parameters/MnemonicFamily.java
+++ b/net.mograsim.machine/src/net/mograsim/machine/mi/parameters/MnemonicFamily.java
@@ -11,14 +11,96 @@ public class MnemonicFamily implements ParameterClassification
 {
        private final Mnemonic[] values;
        private final String[] stringValues;
-       private final Map<String, Mnemonic> byText;
-       private final int vectorLength;
+       private Map<String, Mnemonic> byText;
+       private int vectorLength;
+       
+       public MnemonicFamily(String... names)
+       {
+               this(false, (int) Math.round(Math.ceil(Math.log(names.length) / Math.log(2))), names);
+       }
+       
+       public MnemonicFamily(boolean reverse, String... names)
+       {
+               this(reverse, (int) Math.round(Math.ceil(Math.log(names.length) / Math.log(2))), names);
+       }
+       
+       public MnemonicFamily(int bits, String... names)
+       {
+               this(false, bits, names);
+       }
+       
+       public MnemonicFamily(boolean reverse, int bits, String... names)
+       {
+               this.values = new Mnemonic[names.length];
+               this.stringValues = new String[names.length];
+               BitVector[] values = new BitVector[names.length];
+               for(int i = 0; i < names.length; i++)
+               {
+                       values[i] = BitVector.from(i, bits);
+               }
+               
+               setup(names, values, reverse);
+       }
+       
+       public MnemonicFamily(String[] names, long[] values, int bits)
+       {
+               this(false, names, values, bits);
+       }
+       
+       public MnemonicFamily(boolean reverse, String[] names, long[] values, int bits)
+       {
+               if(names.length != values.length)
+                       throw new IllegalArgumentException();
+               this.values = new Mnemonic[values.length];
+               this.stringValues = new String[values.length];
+               BitVector[] vectors = new BitVector[values.length];
+               
+               for(int i = 0; i < vectors.length; i++)
+               {
+                       vectors[i] = BitVector.from(values[i], bits);
+               }
+               
+               setup(names, vectors, reverse);
+       }
+       
+       public MnemonicFamily(String[] names, BitVector[] values)
+       {
+               this(false, names, values);
+       }
+       
+       public MnemonicFamily(boolean reverse, String[] names, BitVector[] values)
+       {
+               if(names.length != values.length)
+                       throw new IllegalArgumentException();
+               this.values = new Mnemonic[values.length];
+               this.stringValues = new String[values.length];
+               
+               setup(names, values, reverse);
+       }
        
        public MnemonicFamily(MnemonicPair... values)
+       {
+               this(false, values);
+       }
+       
+       public MnemonicFamily(boolean reverse, MnemonicPair... values)
        {
                this.values = new Mnemonic[values.length];
                this.stringValues = new String[values.length];
                
+               setup(values);
+       }
+       
+       private void setup(String[] names, BitVector[] values, boolean reverse)
+       {
+               MnemonicPair[] mnemonics = new MnemonicPair[values.length];
+               for(int i = 0; i < values.length; i++)
+                       mnemonics[i] = new MnemonicPair(names[i], reverse ? values[i].reverse() : values[i]);
+               setup(mnemonics);
+       }
+       
+       private void setup(MnemonicPair[] values)
+       {
                for(int i = 0; i < values.length; i++)
                {
                        this.values[i] = createMnemonic(values[i], i);
@@ -37,7 +119,7 @@ public class MnemonicFamily implements ParameterClassification
                if(values.length != byText.keySet().size())
                        throw new IllegalArgumentException("MnemonicFamily contains multiple Mnemonics with the same name!");
        }
-       
+
        private Mnemonic createMnemonic(MnemonicPair mnemonicPair, int ordinal)
        {
                return new Mnemonic(mnemonicPair.name, mnemonicPair.value, this, ordinal);
@@ -104,8 +186,6 @@ public class MnemonicFamily implements ParameterClassification
                return stringValues.clone();
        }
        
-       
-       
        @Override
        public int hashCode()
        {
@@ -120,8 +200,15 @@ public class MnemonicFamily implements ParameterClassification
        {
                return this == obj;
        }
-
-
+       
+       @Override
+       public Mnemonic parse(String toParse)
+       {
+               Mnemonic parsed = get(toParse);
+               if(parsed == null)
+                       throw new UnknownMnemonicException(toParse);
+               return parsed;
+       }
 
        public static class MnemonicPair
        {