@Override
public final void update(LogicObservable initiator)
+ {
+ update();
+ }
+
+ public void update()
{
TimelineEventHandler delayedUpdates = compute();
if (delayedUpdates != null)
*/
public int getSize();
- public static MicroInstruction create(MicroInstructionParameter... parameters)
+ public static MicroInstruction create(Runnable updateCallback, MicroInstructionParameter... parameters)
{
- return new StandardMicroInstruction(parameters);
+ return new StandardMicroInstruction(updateCallback, parameters);
}
default BitVector toBitVector()
import net.mograsim.machine.mi.parameters.IntegerClassification;
import net.mograsim.machine.mi.parameters.IntegerImmediate;
import net.mograsim.machine.mi.parameters.MicroInstructionParameter;
+import net.mograsim.machine.mi.parameters.MicroInstructionParameter.ParameterType;
import net.mograsim.machine.mi.parameters.MnemonicFamily;
import net.mograsim.machine.mi.parameters.ParameterClassification;
-import net.mograsim.machine.mi.parameters.MicroInstructionParameter.ParameterType;
public interface MicroInstructionDefinition
{
return Arrays.stream(getParameterClassifications()).mapToInt(e -> e.getExpectedBits()).reduce(0, (a, b) -> a + b);
}
- public default MicroInstruction createDefaultInstruction()
+ public default MicroInstruction createDefaultInstruction(Runnable updateCallback)
{
int size = size();
MicroInstructionParameter[] params = new MicroInstructionParameter[size];
}
params[i] = newParam;
}
- return new StandardMicroInstruction(params);
+ return new StandardMicroInstruction(updateCallback, params);
}
public Optional<String> getParameterDescription(int index);
try
{
for (; i <= maxAddr && input.ready() && !"".equals((line = input.readLine())); i++)
- memory.setCell(i, parse(miDef, line));
+ {
+ long iFinal = i;
+ memory.setCell(i, parse(() -> memory.notifyObservers(iFinal), miDef, line));
+ }
}
catch (IOException e)
{
}
for (; i <= maxAddr; i++)
- memory.setCell(i, miDef.createDefaultInstruction());
+ {
+ long iFinal = i;
+ memory.setCell(i, miDef.createDefaultInstruction(() -> memory.notifyObservers(iFinal)));
+ }
}
- public static MicroInstruction parse(MicroInstructionDefinition definition, String toParse)
+ public static MicroInstruction parse(Runnable updateCallback, MicroInstructionDefinition definition, String toParse)
{
int size = definition.size();
String[] strings = toParse.split(",");
{
params[i] = classes[i].parse(strings[i]);
}
- return new StandardMicroInstruction(params);
+ return new StandardMicroInstruction(updateCallback, params);
}
catch (Exception e)
{
class StandardMicroInstruction implements MicroInstruction
{
+ private final Runnable updateCallback;
private MicroInstructionParameter[] parameters;
- StandardMicroInstruction(MicroInstructionParameter... parameters)
+ StandardMicroInstruction(Runnable updateCallback, MicroInstructionParameter... parameters)
{
+ this.updateCallback = updateCallback;
this.parameters = parameters;
}
public void setParameter(int index, MicroInstructionParameter param)
{
parameters[index] = param;
+ updateCallback.run();
}
}
int translatedAddress = translate(address);
MicroInstruction actual = data[translatedAddress];
if (actual == null)
- actual = data[translatedAddress] = definition.getMicroInstructionDefinition().createDefaultInstruction();
+ actual = data[translatedAddress] = definition.getMicroInstructionDefinition()
+ .createDefaultInstruction(() -> notifyObservers(address));
return actual;
}
this.memory = memory;
this.data = data;
this.address = address;
+ memory.registerObserver(a -> update());
address.registerObserver(this);
}
throw new IllegalArgumentException(
String.format("Bit width of address wire does not match main memory definition. Expected: %d Actual: %d",
definition.getMemoryAddressBits(), address.width()));
+ this.memory = memory;
this.data = data;
this.rWBit = rWBit;
this.address = address;
+ memory.registerObserver(a -> update());
data.registerObserver(this);
rWBit.registerObserver(this);
address.registerObserver(this);
-
- this.memory = memory;
}
@Override