Kann mir jemand erklären was ich mir genau unter den diversen Befehlen wie "IFGOTO,CSUB;MULT" usw vorstellen kann?
int n = 5;
var Aufgabe = new Machine();
Instruction[] program = {
new LOAD (1),
new IFGOTO (14),
new CSUB (1),
new STORE (2),
new LOAD (1),
new MULT (2),
new STORE (1),
new LOAD (2),
new CSUB (1),
new IFGOTO (16),
new STORE (2),
new LOAD (1),
new GOTO (6),
new LOAD (3),
new STORE (1),
new END ( )
};
Aufgabe.setProgram(program);
Aufgabe.getConfiguration().init();
Aufgabe.getConfiguration().setRegister(1,n);
Aufgabe.getConfiguration().setRegister(3,1);
Aufgabe.run();
Aufgabe.printConfiguration();
//assert Aufgabe.getConfiguration() . getRegister(1) == 120;
class LOAD implements Instruction {
Ich kann hier auch mal fürs Verständnis die Datei reinschicken.Ich denke du musst dich von dem Gedanken mit den Befehlen lösen. Betrachte die Vorgabe als Java Programm und schau dir an, was du hast.
Offensichtlich hat deine Aufgabe ein int Array (Register) der Länge 10. Mit setRegister kannst du Werte im Register speichern. Mit getRegister kannst du Werte von diesem Array lesen.
Dann hat deine Aufgabe ein "Programm". Ein "Programm" ist eine Abfolge von Instructions, welche in einem Array gespeichert sind. Jede Instruction ist eine Implementierung des Interface Instruction. Also ist LOAD z.B. eine solche Klasse.
Diese Klassen verändern wieder auf irgendeine Weise das Register.Java:class LOAD implements Instruction {
Was die Zahlen in den Instructions sagen kann ich mir auch nur bei einigen Befehlen vorstellen, aber nicht bei allen. Gibt es keine Beschreibung dazu?
/* Bitte in dieser Zelle nichts verändern */
public class Configuration {
public final static int NUM_REGISTERS = 10;
int ic;
int registers[ ] = new int[NUM_REGISTERS];
public Configuration() { init(); } // Initialisierung der Register und des Befehlszählers
public void init() { ic = 0; for (int i = 0; i < registers.length; i++) registers[i] = 0; }
// Lesen und Setzen des Befehlszählers
public int getICounter() { return ic; }
public void setICounter (int nic) { ic = nic; } // Befehlszähler inkrementieren
public void incICounter() { ic++; } // Register belegen und auslesen
public void setRegister (int i, int val) { registers [i] = val; }
public int getRegister (int i) { return registers[i]; } // Aktuelle Konfiguration als String ausgeben
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("icounter = " + (ic + 1));
for (int i = 0; i < registers.length; i++) sb.append(", c[" + i + "] = " + registers[i]);
return sb.toString();
}
}
public interface Instruction {
// Befehl auf der aktuellen Konfiguration ausführen.
void eval(Configuration config);
}
public class Load implements Instruction {
private int reg; // Register
public Load (int i) { reg = i; }
// Befehl LOAD ausführen
public void eval(Configuration config) {
// Akkumulator laden
config.setRegister (0, config.getRegister(reg));
// Befehlszähler inkrementieren
config.incICounter ();
}
// Textuelle Repräsentation des Befehls
public String toString() {
return "LOAD " + reg;
}
}
public class Machine {
// Konfiguration
private Configuration config = null;
// Programm
private Instruction[ ] program = null;
public Machine () {
// Konfiguration erzeugen
config = new Configuration ();
}
// Programm initialisieren
public void setProgram (Instruction[ ] prog) {
program = new Instruction [prog.length];
System.arraycopy (prog, 0, program, 0, prog.length); }
// Ausführung des Programms
public void run () {
// solange nicht der END-Befehl erreicht ist...
while (!program[config.getICounter()].toString ().equals ("END")) {
// aktuellen Befehl ausführen
program[config.getICounter()].eval(config);
}
}
// Ausgabe der Konfiguration
public void printConfiguration () {
System.out.println (config);
}
// Liefert die aktuelle Konfiguration
public Configuration getConfiguration () {
return config;
}
}
public class IFGOTO implements Instruction {
private int pos; // Sprungziel
public IFGOTO(int p) {
pos = p;
}
// Befehl IF c[0]=0 GOTO pos ausführen
public void eval(Configuration config) {
// Inhalt des Akkumulators prüfen
if (config.getRegister(0) == 0) {
// Sprung ausführen
config.setICounter(pos - 1);
} else {
// sonst zum nächsten Befehl
config.incICounter();
}
}
// Textuelle Repräsentation des Befehls
public String toString() {
return "IF c[0] = 0 GOTO " + pos;
}
}
public class GOTO implements Instruction {
private int pos; // Sprungziel
public GOTO(int p) {
pos = p;
}
public void eval(Configuration config) {
// Sprung ausführen
config.setICounter(pos - 1);
}
// Textuelle Repräsentation des Befehls
public String toString() {
return "GOTO " + pos;
}
}
public class STORE implements Instruction {
private int reg; // Sprungziel
public STORE(int i) {
reg = i;
}
public void eval(Configuration config) {
config.setRegister (reg, config.getRegister(0));
config.incICounter();
}
// Textuelle Repräsentation des Befehls
public String toString() {
return "STORE " + reg;
}
}
public class LOAD implements Instruction {
private int reg;
public LOAD(int i) {
reg = i;
}
public void eval(Configuration config) {
config.setRegister (0, config.getRegister(reg));
config.incICounter();
}
// Textuelle Repräsentation des Befehls
public String toString() {
return "LOAD " + reg;
}
}
public class CLOAD implements Instruction {
private int c;
public CLOAD(int v) {
c = v;
}
public void eval(Configuration config) {
config.setRegister (0, c);
config.incICounter();
}
// Textuelle Repräsentation des Befehls
public String toString() {
return "CLOAD " + c;
}
}
public class END implements Instruction {
public END () {
}
public void eval (Configuration config) {
// nichts tun
}
public String toString () {
return "END";
}
}
public class SUB implements Instruction {
private int reg;
public SUB (int i) {
reg = i;
}
public void eval (Configuration config) {
config.setRegister (0, config.getRegister (0) - config.getRegister (reg));
config.incICounter ();
}
public String toString () {
return "SUB " + reg;
}
}
public class CSUB implements Instruction {
private int c;
public CSUB (int v) {
c = v;
}
public void eval (Configuration config) {
config.setRegister (0, config.getRegister (0) - c);
config.incICounter ();
}
public String toString () {
return "CSUB " + c;
}
}
public class INDSUB implements Instruction {
private int c;
public INDSUB (int v) {
reg = v;
}
public void eval (Configuration config) {
config.setRegister (0, config.getRegister (0) - config.getRegister(config.getRegister (reg)));
config.incICounter ();
}
public String toString () {
return "INDSUB " + reg;
}
}
public class ADD implements Instruction {
private int reg;
public ADD (int i) {
reg = i;
}
public void eval (Configuration config) {
config.setRegister (0, config.getRegister (0) + config.getRegister (reg));
config.incICounter ();
}
public String toString () {
return "ADD " + reg;
}
}
public class CADD implements Instruction {
private int c;
public CADD (int v) {
c = v;
}
public void eval (Configuration config) {
config.setRegister (0, config.getRegister (0) + c);
config.incICounter ();
}
public String toString () {
return "CADD " + c;
}
}
public class INDADD implements Instruction {
private int reg;
public INDADD (int i) {
reg = i;
}
public void eval (Configuration config) {
config.setRegister (0, config.getRegister (0) + config.getRegister (config.getRegister (reg)));
config.incICounter ();
}
public String toString () {
return "INDADD " + reg;
}
}
public class MULT implements Instruction {
private int reg;
public MULT (int i) {
reg = i;
}
public void eval (Configuration config) {
config.setRegister (0, config.getRegister (0) * config.getRegister (reg));
config.incICounter ();
}
public String toString () {
return "MULT " + reg;
}
}
public class CMULT implements Instruction {
private int c;
public CMULT (int i) {
c = i;
}
public void eval (Configuration config) {
config.setRegister (0, config.getRegister (0) * c);
config.incICounter ();
}
public String toString () {
return "CMULT " + c;
}
}
public class INDMULT implements Instruction {
private int reg;
public INDMULT (int i) {
reg = i;
}
public void eval (Configuration config) {
config.setRegister (0, config.getRegister (0) * config.getRegister (config.getRegister (reg)));
config.incICounter ();
}
public String toString () {
return "INDMULT " + reg;
}
}
public class DIV implements Instruction {
private int reg;
public DIV (int i) {
reg = i;
}
public void eval (Configuration config) {
if (config.getRegister (reg)==0) {
config.setRegister (0, 0);
}
else {
config.setRegister (0, (int) (config.getRegister (0) / config.getRegister (reg)));
}
config.incICounter ();
}
public String toString () {
return "DIV " + reg;
}
}
public class CDIV implements Instruction {
private int c;
public CDIV (int i) {
c = i;
}
public void eval (Configuration config) {
if (c==0) {
config.setRegister (0, 0);
}
else {
config.setRegister (0, (int) (config.getRegister (0) / c));
}
config.incICounter ();
}
public String toString () {
return "CDIV " + c;
}
}
public class INDDIV implements Instruction {
private int reg;
public INDDIV (int i) {
reg = i;
}
public void eval (Configuration config) {
if (config.getRegister (reg)==0) {
config.setRegister (0, 0);
}
else {
config.setRegister (0, (int) (config.getRegister (0) / config.getRegister (config.getRegister (reg))));
}
config.incICounter ();
}
public String toString () {
return "INDDIV " + reg;
}
}