net.mograsim.logic.model.examples
Bundle-RequiredExecutionEnvironment: JavaSE-11
Require-Bundle: org.eclipse.osgi,
- net.mograsim.machine;bundle-version="0.1.0";visibility:=reexport
+ net.mograsim.machine;bundle-version="0.1.0";visibility:=reexport,
+ net.mograsim.logic.core
Automatic-Module-Name: net.mograsim.logic.model.am2900
Bundle-Vendor: Mograsim Team
Bundle-Activator: net.mograsim.logic.model.am2900.Am2900Loader
import net.mograsim.logic.model.serializing.IndirectModelComponentCreator;
import net.mograsim.machine.Machine;
import net.mograsim.machine.MachineDefinition;
+import net.mograsim.machine.MainMemory;
import net.mograsim.machine.Register;
+import net.mograsim.machine.mi.MicroInstructionMemory;
+import net.mograsim.machine.mi.StandardMicroInstructionMemory;
+import net.mograsim.machine.standard.memory.WordAddressableMemory;
public class Am2900Machine implements Machine
{
private Am2900MachineDefinition machineDefinition;
private LogicModelModifiable logicModel;
private Timeline timeline;
+ private MainMemory mainMemory;
+ private MicroInstructionMemory instMemory;
private CoreClock clock;
public Am2900Machine(Am2900MachineDefinition am2900MachineDefinition)
this.machineDefinition = am2900MachineDefinition;
logicModel = new LogicModelModifiable();
IndirectModelComponentCreator.createComponent(logicModel,
- "resloader:Am2900Loader:jsonres:net/mograsim/logic/model/am2900/components/ModelAm2900.json");
+ "resloader:Am2900Loader:jsonres:net/mograsim/logic/model/am2900/components/Am2900.json");
CoreModelParameters params = new CoreModelParameters();
params.gateProcessTime = 50;
params.wireTravelTime = 10;
+ mainMemory = new WordAddressableMemory(am2900MachineDefinition.getMainMemoryDefinition());
+ instMemory = new StandardMicroInstructionMemory(am2900MachineDefinition.getMicroInstructionMemoryDefinition());
timeline = LogicCoreAdapter.convert(logicModel, params);
}
}
+ @Override
+ public MainMemory getMainMemory()
+ {
+ return mainMemory;
+ }
+
+ @Override
+ public MicroInstructionMemory getMicroInstructionMemory()
+ {
+ return instMemory;
+ }
+
}
import net.mograsim.machine.MachineDefinition;
import net.mograsim.machine.MainMemoryDefinition;
import net.mograsim.machine.Register;
+import net.mograsim.machine.mi.MicroInstructionMemoryDefinition;
public class Am2900MachineDefinition implements MachineDefinition
{
private MainMemoryDefinition memoryDefinition = new Am2900MainMemoryDefinition();
+ private MicroInstructionMemoryDefinition microInstMemoryDefinition = new Am2900MicroInstructionMemoryDefinition();
@Override
public Machine createNew()
return memoryDefinition;
}
+ @Override
+ public MicroInstructionMemoryDefinition getMicroInstructionMemoryDefinition()
+ {
+ return microInstMemoryDefinition;
+ }
}
--- /dev/null
+package net.mograsim.logic.model.am2900.machine;
+
+import net.mograsim.logic.core.types.Bit;
+import net.mograsim.logic.core.types.BitVector;
+import net.mograsim.machine.mi.MicroInstructionDefinition;
+import net.mograsim.machine.mi.parameters.BooleanClassification;
+import net.mograsim.machine.mi.parameters.IntegerClassification;
+import net.mograsim.machine.mi.parameters.MnemonicFamily;
+import net.mograsim.machine.mi.parameters.MnemonicFamily.MnemonicPair;
+import net.mograsim.machine.mi.parameters.ParameterClassification;
+
+public class Am2900MicroInstructionDefinition implements MicroInstructionDefinition
+{
+ private final static MnemonicFamily am2910Instructions = new MnemonicFamily(new MnemonicPair("X", BitVector.of(Bit.ZERO, 4))/* TODO */);
+ private final static MnemonicFamily am2904StatusInstructions = new MnemonicFamily(
+ new MnemonicPair("X", BitVector.of(Bit.ZERO, 4))/* TODO */);
+ private final static MnemonicFamily am2904ShiftInstructions = new MnemonicFamily(
+ new MnemonicPair("X", BitVector.of(Bit.ZERO, 4))/* TODO */);
+ private final static MnemonicFamily am2904CarryInstructions = new MnemonicFamily(
+ new MnemonicPair("X", BitVector.of(Bit.ZERO, 4))/* TODO */);
+ private final static MnemonicFamily am2901DestInstructions = new MnemonicFamily(
+ new MnemonicPair("X", BitVector.of(Bit.ZERO, 4))/* TODO */);
+ private final static MnemonicFamily am2901FuncInstructions = new MnemonicFamily(
+ new MnemonicPair("X", BitVector.of(Bit.ZERO, 4))/* TODO */);
+ private final static MnemonicFamily am2901SrcInstructions = new MnemonicFamily(
+ new MnemonicPair("X", BitVector.of(Bit.ZERO, 4))/* TODO */);
+ private final static MnemonicFamily interruptInstructions = new MnemonicFamily(
+ new MnemonicPair("X", BitVector.of(Bit.ZERO, 4))/* TODO */);
+ private final static BooleanClassification hL = new BooleanClassification("H", "L");
+ private final static BooleanClassification registerSelect = new BooleanClassification("MR", "IR");
+ private final static IntegerClassification register = new IntegerClassification(4);
+
+ private final static ParameterClassification[] classes = { new BooleanClassification("R", "W"), hL, new BooleanClassification("H", "E"),
+ new BooleanClassification("H", "I"), new BooleanClassification("H", "E"), hL, new IntegerClassification(11), am2910Instructions,
+ new BooleanClassification("PS", "C"), am2904StatusInstructions, hL, hL, am2904ShiftInstructions, am2904CarryInstructions,
+ new BooleanClassification("H", "DB"), new BooleanClassification("H", "AB"), registerSelect, register, registerSelect, register,
+ am2901DestInstructions, am2901FuncInstructions, am2901SrcInstructions, new IntegerClassification(16),
+ new BooleanClassification("D", "K"), interruptInstructions, new BooleanClassification("Dis", "IE") };
+
+ @Override
+ public ParameterClassification[] getParameterClassifications()
+ {
+ return classes;
+ }
+
+ @Override
+ public ParameterClassification getParameterClassification(int index)
+ {
+ return classes[index];
+ }
+
+}
--- /dev/null
+package net.mograsim.logic.model.am2900.machine;
+
+import net.mograsim.machine.mi.MicroInstructionDefinition;
+import net.mograsim.machine.mi.MicroInstructionMemoryDefinition;
+
+public class Am2900MicroInstructionMemoryDefinition implements MicroInstructionMemoryDefinition
+{
+
+ @Override
+ public int getMemoryAddressBits()
+ {
+ return 12;
+ }
+
+ @Override
+ public long getMinimalAddress()
+ {
+ return 0;
+ }
+
+ @Override
+ public long getMaximalAddress()
+ {
+ return 4096;
+ }
+
+ @Override
+ public MicroInstructionDefinition getMicroInstructionDefinition()
+ {
+ return new Am2900MicroInstructionDefinition();
+ }
+}
import net.mograsim.logic.core.components.CoreClock;
import net.mograsim.logic.core.timeline.Timeline;
import net.mograsim.logic.core.types.BitVector;
+import net.mograsim.machine.mi.MicroInstructionMemory;
import net.mograsim.logic.model.model.LogicModel;
public interface Machine {
void setRegister(Register r, BitVector value);
Timeline getTimeline();
+
+ MainMemory getMainMemory();
+
+ MicroInstructionMemory getMicroInstructionMemory();
+
}
import java.util.Set;
+import net.mograsim.machine.mi.MicroInstructionMemoryDefinition;
+
public interface MachineDefinition {
/**
* @author Christian Femers
*/
MainMemoryDefinition getMainMemoryDefinition();
+
+ /**
+ * Returns the definition of the machines instruction memory.
+ *
+ * @return the {@link InstructionMemoryDefinition} that defines the instruction memory.
+ */
+ MicroInstructionMemoryDefinition getMicroInstructionMemoryDefinition();
+
}
public default long size()
{
MemoryDefinition def = getDefinition();
- return Long.max(0, def.getMaximalAddress() - def.getMinimalAddress());
+ return Long.max(0, def.getMaximalAddress() - def.getMinimalAddress() + 1);
}
/**
package net.mograsim.machine.mi;
+import java.math.BigInteger;
+
+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.MnemonicFamily;
import net.mograsim.machine.mi.parameters.ParameterClassification;
+import net.mograsim.machine.mi.parameters.MicroInstructionParameter.ParameterType;
public interface MicroInstructionDefinition
{
return getParameterClassifications().length;
}
+ public default MicroInstruction createDefaultInstruction()
+ {
+ int size = size();
+ MicroInstructionParameter[] params = new MicroInstructionParameter[size];
+ ParameterClassification[] classes = getParameterClassifications();
+ for(int i = 0; i < size; i++)
+ {
+ MicroInstructionParameter newParam;
+ ParameterClassification classification = classes[i];
+ ParameterType type = classification.getExpectedType();
+ switch(type)
+ {
+ case BOOLEAN_IMMEDIATE:
+ case MNEMONIC:
+ newParam = ((MnemonicFamily) classification).get(0);
+ break;
+ case INTEGER_IMMEDIATE:
+ newParam = new IntegerImmediate(BigInteger.valueOf(0), ((IntegerClassification) classification).getExpectedBits());
+ break;
+ default:
+ throw new IllegalStateException("Unknown ParameterType " + type);
+ }
+ params[i] = newParam;
+ }
+ return new StandardMicroInstruction(params);
+ }
+
public static MicroInstructionDefinition create(ParameterClassification... classes)
{
return new StandardMicroInstructionDefinition(classes);
--- /dev/null
+package net.mograsim.machine.mi;
+
+import net.mograsim.machine.Memory;
+
+public interface MicroInstructionMemory extends Memory<MicroInstruction>
+{
+ public MicroInstructionMemoryDefinition getDefinition();
+}
--- /dev/null
+package net.mograsim.machine.mi;
+
+import net.mograsim.machine.MemoryDefinition;
+
+public interface MicroInstructionMemoryDefinition extends MemoryDefinition
+{
+ MicroInstructionDefinition getMicroInstructionDefinition();
+}
--- /dev/null
+package net.mograsim.machine.mi;
+
+import net.mograsim.machine.MachineException;
+
+public class MicroInstructionMemoryParseException extends MachineException
+{
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 6820101808901789906L;
+
+ public MicroInstructionMemoryParseException()
+ {
+ super();
+ }
+
+ public MicroInstructionMemoryParseException(String message)
+ {
+ super(message);
+ }
+
+ public MicroInstructionMemoryParseException(Throwable cause)
+ {
+ super(cause);
+ }
+
+}
--- /dev/null
+package net.mograsim.machine.mi;
+
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+
+import net.mograsim.machine.MemoryDefinition;
+import net.mograsim.machine.mi.parameters.MicroInstructionParameter;
+import net.mograsim.machine.mi.parameters.ParameterClassification;
+
+public class MicroInstructionMemoryParser
+{
+ public static void parseMemory(final MicroInstructionMemory memory, String inputPath) throws IOException
+ {
+ try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(inputPath))))
+ {
+ parseMemory(memory, reader);
+ }
+ }
+
+ public static void parseMemory(final MicroInstructionMemory memory, BufferedReader input)
+ {
+ MicroInstructionMemoryDefinition def = memory.getDefinition();
+ MicroInstructionDefinition miDef = def.getMicroInstructionDefinition();
+
+ long minAddr = def.getMinimalAddress();
+ long maxAddr = def.getMaximalAddress();
+
+ String line;
+ long i = minAddr;
+ try
+ {
+ for (; i <= maxAddr && input.ready() && !"".equals((line = input.readLine())); i++)
+ memory.setCell(i, parse(miDef, line));
+ } catch (IOException e)
+ {
+ e.printStackTrace();
+ }
+
+ for(; i <= maxAddr; i++)
+ memory.setCell(i, miDef.createDefaultInstruction());
+ }
+
+ public static MicroInstruction parse(MicroInstructionDefinition definition, String toParse)
+ {
+ int size = definition.size();
+ String[] strings = toParse.split(",");
+ if (size != strings.length)
+ throw new MicroInstructionMemoryParseException(
+ "String does not match definition! The number of parameters does not match.");
+ MicroInstructionParameter[] params = new MicroInstructionParameter[size];
+ ParameterClassification[] classes = definition.getParameterClassifications();
+ try
+ {
+ for (int i = 0; i < size; i++)
+ {
+ params[i] = classes[i].parse(strings[i]);
+ }
+ return new StandardMicroInstruction(params);
+ } catch (Exception e)
+ {
+ throw new MicroInstructionMemoryParseException(e.getCause());
+ }
+ }
+
+ public static void write(MicroInstructionMemory memory, String outputPath) throws IOException
+ {
+ try (OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(outputPath)))
+ {
+ write(memory, writer);
+ }
+ }
+
+ public static void write(MicroInstructionMemory memory, OutputStreamWriter output) throws IOException
+ {
+ MemoryDefinition def = memory.getDefinition();
+ long min = def.getMinimalAddress(), max = def.getMaximalAddress() + 1;
+ for (long i = min; i < max; i++)
+ {
+ output.write(toCSV(memory.getCell(i)) + "\n");
+ }
+ }
+
+ private static String toCSV(MicroInstruction inst)
+ {
+ int max = inst.getSize() - 1;
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < max; i++)
+ {
+ sb.append(inst.getParameter(i).toString());
+ sb.append(",");
+ }
+ sb.append(inst.getParameter(max).toString());
+ return sb.toString();
+ }
+}
+++ /dev/null
-package net.mograsim.machine.mi;
-
-import net.mograsim.machine.Memory;
-import net.mograsim.machine.MemoryDefinition;
-
-public interface MicroprogramMemory extends Memory<MicroInstruction>
-{
- public static MicroprogramMemory create(MemoryDefinition def)
- {
- return new StandardMicroprogramMemory(def);
- }
-}
+++ /dev/null
-package net.mograsim.machine.mi;
-
-import net.mograsim.machine.MachineException;
-
-public class MicroprogramMemoryParseException extends MachineException
-{
-
- /**
- *
- */
- private static final long serialVersionUID = 6820101808901789906L;
-
- public MicroprogramMemoryParseException()
- {
- super();
- }
-
- public MicroprogramMemoryParseException(String message)
- {
- super(message);
- }
-
- public MicroprogramMemoryParseException(Throwable cause)
- {
- super(cause);
- }
-
-}
+++ /dev/null
-package net.mograsim.machine.mi;
-
-import java.io.BufferedReader;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.List;
-
-import net.mograsim.logic.core.types.BitVector;
-import net.mograsim.machine.MemoryDefinition;
-import net.mograsim.machine.mi.parameters.BooleanClassification;
-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.MnemonicFamily;
-import net.mograsim.machine.mi.parameters.MnemonicFamily.MnemonicPair;
-import net.mograsim.machine.mi.parameters.ParameterClassification;
-
-public class MicroprogramMemoryParser
-{
- public static MicroprogramMemory parseMemory(MicroInstructionDefinition definition, String input) throws IOException
- {
- try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(input))))
- {
- return parseMemory(definition, reader);
- }
- }
-
- public static MicroprogramMemory parseMemory(MicroInstructionDefinition definition, BufferedReader input)
- {
- List<MicroInstruction> instructions = new ArrayList<>();
- try
- {
- String line;
- while (input.ready() && !"".equals((line = input.readLine())))
- instructions.add(parse(definition, line));
- } catch (IOException e)
- {
- e.printStackTrace();
- }
-
- int maxAddress = instructions.size() - 1;
- MicroprogramMemory memory = MicroprogramMemory
- .create(MemoryDefinition.create((int) Math.ceil(Math.log(maxAddress)), 0, maxAddress));
- int i = 0;
- for (MicroInstruction inst : instructions)
- memory.setCell(i++, inst);
- return memory;
- }
-
- public static MicroInstruction parse(MicroInstructionDefinition definition, String toParse)
- {
- int size = definition.size();
- String[] strings = toParse.split(",");
- if (size != strings.length)
- throw new MicroprogramMemoryParseException(
- "String does not match definition! The number of parameters does not match.");
- MicroInstructionParameter[] params = new MicroInstructionParameter[size];
- ParameterClassification[] classes = definition.getParameterClassifications();
- try
- {
- for (int i = 0; i < size; i++)
- {
- params[i] = classes[i].parse(strings[i]);
- }
- return new StandardMicroInstruction(params);
- } catch (Exception e)
- {
- throw new MicroprogramMemoryParseException(e.getCause());
- }
- }
-
- public static void write(MicroprogramMemory memory, String output) throws IOException
- {
- try (OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(output)))
- {
- write(memory, writer);
- }
- }
-
- public static void write(MicroprogramMemory memory, OutputStreamWriter output) throws IOException
- {
- MemoryDefinition def = memory.getDefinition();
- long min = def.getMinimalAddress(), max = def.getMaximalAddress() + 1;
- for (long i = min; i < max; i++)
- {
- output.write(toCSV(memory.getCell(i)) + "\n");
- }
- }
-
- private static String toCSV(MicroInstruction inst)
- {
- int max = inst.getSize() - 1;
- StringBuilder sb = new StringBuilder();
- for (int i = 0; i < max; i++)
- {
- sb.append(inst.getParameter(i).toString());
- sb.append(",");
- }
- sb.append(inst.getParameter(max).toString());
- return sb.toString();
- }
-
- public static void main(String[] args)
- {
- MnemonicFamily family = new MnemonicFamily(new MnemonicPair("ZERO", BitVector.SINGLE_0),
- new MnemonicPair("ONE", BitVector.SINGLE_1));
- BooleanClassification boolClass = new BooleanClassification("H", "L");
- MicroInstructionDefinition def = MicroInstructionDefinition.create(boolClass,
- new IntegerClassification(8), family);
- MicroprogramMemory memory = new StandardMicroprogramMemory(MemoryDefinition.create(4, 0, 16));
- for (int i = 0; i < 17; i++)
- memory.setCell(i, new StandardMicroInstruction(boolClass.get(false),
- new IntegerImmediate(BigInteger.valueOf(i), 8), family.get(i % 2)));
- try
- {
- write(memory, "test.txt");
- MicroprogramMemory newMemory = parseMemory(def, "test.txt");
- write(newMemory, "test2.txt");
- } catch (IOException e)
- {
- e.printStackTrace();
- }
-
- }
-}
--- /dev/null
+package net.mograsim.machine.mi;
+
+import java.util.HashSet;
+
+import net.mograsim.machine.MemoryObserver;
+import net.mograsim.machine.standard.memory.MemoryException;
+
+public class StandardMicroInstructionMemory implements MicroInstructionMemory
+{
+ private MicroInstruction[] data;
+ private MicroInstructionMemoryDefinition definition;
+ private HashSet<MemoryObserver> observers = new HashSet<>();
+
+ public StandardMicroInstructionMemory(MicroInstructionMemoryDefinition definition)
+ {
+ if(definition.size() > Integer.MAX_VALUE)
+ throw new MemoryException("Size of MicroInstructionMemory must be an int, not a long");
+ this.definition = definition;
+ data = new MicroInstruction[(int) definition.size()];
+ }
+
+ private int translate(long address)
+ {
+ return (int) (address - definition.getMinimalAddress());
+ }
+
+ @Override
+ public MicroInstruction getCell(long address)
+ {
+ int translatedAddress = translate(address);
+ MicroInstruction actual = data[translatedAddress];
+ if(actual == null)
+ actual = data[translatedAddress] = definition.getMicroInstructionDefinition().createDefaultInstruction();
+ return actual;
+ }
+
+ @Override
+ public void setCell(long address, MicroInstruction data)
+ {
+ this.data[translate(address)] = data;
+ }
+
+ @Override
+ public void registerObserver(MemoryObserver ob)
+ {
+ observers.add(ob);
+ }
+
+ @Override
+ public void deregisterObserver(MemoryObserver ob)
+ {
+ observers.remove(ob);
+ }
+
+ @Override
+ public void notifyObservers(long address)
+ {
+ observers.forEach(ob -> ob.update(address));
+ }
+
+ @Override
+ public MicroInstructionMemoryDefinition getDefinition()
+ {
+ return definition;
+ }
+
+}
+++ /dev/null
-package net.mograsim.machine.mi;
-
-import java.util.HashSet;
-
-import net.mograsim.machine.MemoryDefinition;
-import net.mograsim.machine.MemoryObserver;
-import net.mograsim.machine.standard.memory.MemoryException;
-
-class StandardMicroprogramMemory implements MicroprogramMemory
-{
- private MicroInstruction[] data;
- private MemoryDefinition definition;
- private HashSet<MemoryObserver> observers = new HashSet<>();
-
- StandardMicroprogramMemory(MemoryDefinition definition)
- {
- if(definition.size() > Integer.MAX_VALUE)
- throw new MemoryException("Size of MicroprogramMemory must be an int, not a long");
- this.definition = definition;
- data = new MicroInstruction[(int) definition.size()];
- }
-
- private int translate(long address)
- {
- return (int) (address - definition.getMinimalAddress());
- }
-
- @Override
- public MicroInstruction getCell(long address)
- {
- return data[translate(address)];
- }
-
- @Override
- public void setCell(long address, MicroInstruction data)
- {
- this.data[translate(address)] = data;
- }
-
- @Override
- public void registerObserver(MemoryObserver ob)
- {
- observers.add(ob);
- }
-
- @Override
- public void deregisterObserver(MemoryObserver ob)
- {
- observers.remove(ob);
- }
-
- @Override
- public void notifyObservers(long address)
- {
- observers.forEach(ob -> ob.update(address));
- }
-
- @Override
- public MemoryDefinition getDefinition()
- {
- return definition;
- }
-
-}
--- /dev/null
+package net.mograsim.plugin;
+
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+
+import net.mograsim.logic.model.am2900.machine.Am2900Machine;
+import net.mograsim.logic.model.am2900.machine.Am2900MachineDefinition;
+import net.mograsim.machine.Machine;
+import net.mograsim.machine.MachineRegistry;
+
+public class MachineContext
+{
+ private Machine machine;
+ private Set<ContextObserver> observers;
+ private static MachineContext instance;
+
+ private MachineContext()
+ {
+ observers = new HashSet<>();
+ }
+
+ public static MachineContext getInstance()
+ {
+ if (instance == null)
+ {
+ instance = new MachineContext();
+ instance.setMachine(new Am2900Machine((Am2900MachineDefinition) MachineRegistry.getinstalledMachines().get("Am2900")));
+ }
+ return instance;
+ }
+
+ public Machine getMachine()
+ {
+ return machine;
+ }
+
+ public void setMachine(Machine machine)
+ {
+ this.machine = machine;
+ notifyObservers(machine);
+ }
+
+ public void registerObserver(ContextObserver ob)
+ {
+ observers.add(ob);
+ ob.setMachine(Optional.ofNullable(machine));
+ }
+
+ public void deregisterObserver(ContextObserver ob)
+ {
+ observers.remove(ob);
+ }
+
+ private void notifyObservers(Machine machine)
+ {
+ observers.forEach(ob -> ob.setMachine(Optional.ofNullable(machine)));
+ }
+
+ @FunctionalInterface
+ public static interface ContextObserver
+ {
+ void setMachine(Optional<Machine> machine);
+ }
+}
package net.mograsim.plugin.tables.memory;
import java.math.BigInteger;
+import java.util.Optional;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.part.ViewPart;
+import net.mograsim.machine.Machine;
import net.mograsim.machine.MainMemory;
import net.mograsim.machine.MainMemoryDefinition;
import net.mograsim.machine.standard.memory.WordAddressableMemory;
+import net.mograsim.plugin.MachineContext;
+import net.mograsim.plugin.MachineContext.ContextObserver;
import net.mograsim.plugin.asm.AsmNumberUtil;
import net.mograsim.plugin.tables.DisplaySettings;
import net.mograsim.plugin.tables.NumberColumnLabelProvider;
import net.mograsim.plugin.tables.RadixSelector;
-public class MemoryView extends ViewPart
+public class MemoryView extends ViewPart implements ContextObserver
{
private TableViewer viewer;
private MemoryTableContentProvider provider;
private DisplaySettings displaySettings;
private String addressFormat;
- @SuppressWarnings("unused")
@Override
public void createPartControl(Composite parent)
{
GridLayout layout = new GridLayout(6, false);
parent.setLayout(layout);
+
+ createHeader(parent);
+ createViewer(parent);
+
+ displaySettings.addObserver(() -> viewer.refresh());
+
+ setupContextBinding();
+ }
+
+ @SuppressWarnings("unused")
+ private void createHeader(Composite parent)
+ {
Label fromLabel = new Label(parent, SWT.NONE);
fromLabel.setText("Address: ");
Text fromText = new Text(parent, SWT.BORDER | SWT.SEARCH);
}
});
new RadixSelector(parent, displaySettings);
- createViewer(parent);
-
- displaySettings.addObserver(() -> viewer.refresh());
}
private void createViewer(Composite parent)
table.setLinesVisible(true);
viewer.setUseHashlookup(true);
viewer.setContentProvider(provider);
- setMemoryBinding(new WordAddressableMemory(MainMemoryDefinition.create(8, 8, 8L, Long.MAX_VALUE)));
+ bindMainMemory(new WordAddressableMemory(MainMemoryDefinition.create(8, 8, 8L, Long.MAX_VALUE)));
getSite().setSelectionProvider(viewer);
GridData gd = new GridData();
viewer.getControl().setFocus();
}
- public void setMemoryBinding(MainMemory m)
+ private void bindMainMemory(MainMemory m)
{
int hexAddressLength = Long.toUnsignedString(m.getDefinition().getMaximalAddress(), 16).length();
addressFormat = "0x%0" + hexAddressLength + "X";
viewer.setInput(m);
}
+
+ private void setupContextBinding()
+ {
+ MachineContext.getInstance().registerObserver(this);
+ }
+
+ @Override
+ public void setMachine(Optional<Machine> machine)
+ {
+ if (machine.isPresent())
+ bindMainMemory(machine.get().getMainMemory());
+ }
}
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
-import net.mograsim.machine.mi.MicroprogramMemory;
+import net.mograsim.machine.mi.MicroInstructionMemory;
public class InstructionTableContentProvider implements ILazyContentProvider
{
private TableViewer viewer;
- private MicroprogramMemory memory;
+ private MicroInstructionMemory memory;
@Override
public void updateElement(int index)
public void inputChanged(Viewer viewer, Object oldInput, Object newInput)
{
this.viewer = (TableViewer) viewer;
- this.memory = (MicroprogramMemory) newInput;
+ this.memory = (MicroInstructionMemory) newInput;
if (this.memory != null)
this.viewer.setItemCount((int) memory.size());
}
import java.io.File;
import java.io.IOException;
+import java.util.Optional;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.ui.part.ViewPart;
+import net.mograsim.machine.Machine;
import net.mograsim.machine.mi.MicroInstructionDefinition;
-import net.mograsim.machine.mi.MicroprogramMemory;
-import net.mograsim.machine.mi.MicroprogramMemoryParseException;
-import net.mograsim.machine.mi.MicroprogramMemoryParser;
+import net.mograsim.machine.mi.MicroInstructionMemory;
+import net.mograsim.machine.mi.MicroInstructionMemoryParseException;
+import net.mograsim.machine.mi.MicroInstructionMemoryParser;
import net.mograsim.machine.mi.parameters.ParameterClassification;
+import net.mograsim.plugin.MachineContext;
+import net.mograsim.plugin.MachineContext.ContextObserver;
import net.mograsim.plugin.asm.AsmNumberUtil.NumberType;
import net.mograsim.plugin.tables.DisplaySettings;
import net.mograsim.plugin.tables.RadixSelector;
import net.mograsim.plugin.util.DropDownMenu;
import net.mograsim.plugin.util.DropDownMenu.DropDownEntry;
-public class InstructionView extends ViewPart
+public class InstructionView extends ViewPart implements ContextObserver
{
private String saveLoc = null;
private TableViewer viewer;
private TableViewerColumn[] columns = new TableViewerColumn[0];
private MicroInstructionDefinition miDef;
- private MicroprogramMemory memory;
+ private MicroInstructionMemory memory;
private DisplaySettings displaySettings;
@SuppressWarnings("unused")
viewer.getTable().setLayoutData(viewerData);
displaySettings.addObserver(() -> viewer.refresh());
+ MachineContext.getInstance().registerObserver(this);
}
@SuppressWarnings("unused")
saveLoc = d.getFilterPath() + File.separator + filename;
}
- public void bindMicroprogramMemory(MicroprogramMemory memory)
+ public void bindMicroInstructionMemory(MicroInstructionMemory memory)
{
+ deleteColumns();
this.memory = memory;
viewer.setInput(memory);
+ this.miDef = memory.getDefinition().getMicroInstructionDefinition();
+ createColumns();
}
- public void bindMicroInstructionDef(MicroInstructionDefinition miDef)
+ private void deleteColumns()
{
- this.miDef = miDef;
- createColumns();
+ for (TableViewerColumn col : columns)
+ col.getColumn().dispose();
}
private void createColumns()
{
- for (TableViewerColumn col : columns)
- col.getColumn().dispose();
int size = miDef.size();
int bit = 0;
columns = new TableViewerColumn[size];
}
try
{
- MicroprogramMemory newMemory = MicroprogramMemoryParser.parseMemory(miDef, file);
- bindMicroprogramMemory(newMemory);
+ MicroInstructionMemoryParser.parseMemory(memory, file);
+ viewer.refresh();
saveLoc = file;
}
- catch (IOException | MicroprogramMemoryParseException e)
+ catch (IOException | MicroInstructionMemoryParseException e)
{
e.printStackTrace();
}
{
try
{
- MicroprogramMemoryParser.write(memory, file);
+ MicroInstructionMemoryParser.write(memory, file);
}
catch (IOException e)
{
{
viewer.getControl().setFocus();
}
+
+ @Override
+ public void setMachine(Optional<Machine> machine)
+ {
+ if (machine.isPresent())
+ {
+ Machine actualMachine = machine.get();
+ bindMicroInstructionMemory(actualMachine.getMicroInstructionMemory());
+ }
+ }
}
projects / Mograsim.git / commitdiff