From a8c93edad3e4fc0651e2d18734ef189c376539a9 Mon Sep 17 00:00:00 2001
From: Fabian Stemmler <stemmler@in.tum.de>
Date: Wed, 28 Aug 2019 14:35:26 +0200
Subject: [PATCH] Mnemonics now exist only as part of a MnemonicFamily

Mnemonics and MnemonicFamilies are now unique.
equals() in Mnemonics and MnemonicFamilies now only tests for equal
references.
Mnemonics have an ordinal to identify them within their family.
---
 .../machine/mi/parameters/Mnemonic.java       | 32 ++++-----
 .../machine/mi/parameters/MnemonicFamily.java | 66 ++++++++++++++++---
 2 files changed, 69 insertions(+), 29 deletions(-)

diff --git a/net.mograsim.machine/src/net/mograsim/machine/mi/parameters/Mnemonic.java b/net.mograsim.machine/src/net/mograsim/machine/mi/parameters/Mnemonic.java
index cca106ed..46338477 100644
--- a/net.mograsim.machine/src/net/mograsim/machine/mi/parameters/Mnemonic.java
+++ b/net.mograsim.machine/src/net/mograsim/machine/mi/parameters/Mnemonic.java
@@ -6,12 +6,16 @@ public final class Mnemonic implements MicroInstructionParameter
 {
 	private final String text;
 	private final BitVector vector;
+	final MnemonicFamily owner;
+	private final int ordinal;
 	
-	public Mnemonic(String text, BitVector vector)
+	Mnemonic(String text, BitVector vector, MnemonicFamily owner, int ordinal)
 	{
 		super();
 		this.text = text;
 		this.vector = vector;
+		this.owner = owner;
+		this.ordinal = ordinal;
 	}
 
 	public String getText()
@@ -38,26 +42,7 @@ public final class Mnemonic implements MicroInstructionParameter
 	@Override
 	public boolean equals(Object obj)
 	{
-		if (this == obj)
-			return true;
-		if (obj == null)
-			return false;
-		if (!(obj instanceof Mnemonic))
-			return false;
-		Mnemonic other = (Mnemonic) obj;
-		if (text == null)
-		{
-			if (other.text != null)
-				return false;
-		} else if (!text.equals(other.text))
-			return false;
-		if (vector == null)
-		{
-			if (other.vector != null)
-				return false;
-		} else if (!vector.equals(other.vector))
-			return false;
-		return true;
+		return this == obj;
 	}
 
 	@Override
@@ -66,6 +51,11 @@ public final class Mnemonic implements MicroInstructionParameter
 		return ParameterType.MNEMONIC;
 	}
 	
+	public int ordinal()
+	{
+		return ordinal;
+	}
+	
 	@Override
 	public String toString()
 	{
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 3deccb09..b9c13738 100644
--- a/net.mograsim.machine/src/net/mograsim/machine/mi/parameters/MnemonicFamily.java
+++ b/net.mograsim.machine/src/net/mograsim/machine/mi/parameters/MnemonicFamily.java
@@ -4,36 +4,55 @@ import java.util.Arrays;
 import java.util.Map;
 import java.util.stream.Collectors;
 
+import net.mograsim.logic.core.types.BitVector;
 import net.mograsim.machine.mi.parameters.MicroInstructionParameter.ParameterType;
 
 public class MnemonicFamily implements ParameterClassification
 {
 	private final Mnemonic[] values;
+	private final String[] stringValues;
 	private final Map<String, Mnemonic> byText;
 	private final int vectorLength;
 	
-	public MnemonicFamily(Mnemonic... values)
+	public MnemonicFamily(MnemonicPair... values)
 	{
-		this.values = values;
+		this.values = new Mnemonic[values.length];
+		this.stringValues = new String[values.length];
+		
+		for(int i = 0; i < values.length; i++)
+		{
+			this.values[i] = createMnemonic(values[i], i);
+			this.stringValues[i] = values[i].name;
+		}
 		if(values.length == 0)
 			vectorLength = 0;
 		else
 		{
-			vectorLength = values[0].getValue().length();
+			vectorLength = values[0].value.length();
 			for(int i = 1; i < values.length; i++)
-				if(values[i].getValue().length() != vectorLength)
+				if(values[i].value.length() != vectorLength)
 					throw new IllegalArgumentException("MnemonicFamily is not of uniform vector length!");
 		}
-		byText = Arrays.stream(values).collect(Collectors.toMap(m -> m.getText(), m -> m));
+		byText = Arrays.stream(this.values).collect(Collectors.toMap(m -> m.getText(), m -> m));
 		if(values.length != byText.keySet().size())
 			throw new IllegalArgumentException("MnemonicFamily contains multiple Mnemonics with the same name!");
 	}
 	
-	public Mnemonic[] getValues()
+	private Mnemonic createMnemonic(MnemonicPair mnemonicPair, int ordinal)
+	{
+		return new Mnemonic(mnemonicPair.name, mnemonicPair.value, this, ordinal);
+	}
+
+	public Mnemonic[] values()
 	{
 		return values.clone();
 	}
 	
+	public Mnemonic get(int ordinal)
+	{
+		return values[ordinal];
+	}
+	
 	public Mnemonic get(String text)
 	{
 		return byText.get(text);
@@ -42,7 +61,7 @@ public class MnemonicFamily implements ParameterClassification
 	public boolean contains(Mnemonic m)
 	{
 		if(m != null)
-			return m.equals(byText.get(m.getText()));
+			return m.owner == this;
 		else
 			return false;
 	}
@@ -82,6 +101,37 @@ public class MnemonicFamily implements ParameterClassification
 
 	public String[] getStringValues()
 	{
-		return byText.keySet().toArray(new String[values.length]);
+		return stringValues.clone();
+	}
+	
+	
+	
+	@Override
+	public int hashCode()
+	{
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + Arrays.hashCode(values);
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj)
+	{
+		return this == obj;
+	}
+
+
+
+	public static class MnemonicPair
+	{
+		public final String name;
+		public final BitVector value;
+		
+		public MnemonicPair(String name, BitVector value)
+		{
+			this.name = name;
+			this.value = value;
+		}
 	}
 }
-- 
2.17.1