Befehle - Maschinenprogramme

RudiRüssel · 9. Dez 2020

Kann mir jemand erklären was ich mir genau unter den diversen Befehlen wie "IFGOTO,CSUB;MULT" usw vorstellen kann?

MoxxiManagarm · 9. Dez 2020

In welchem Zusammenhang? Was hat diese Frage mit Java zu tun?

RudiRüssel · 9. Dez 2020

Das ist die Aufgabenstellung (Angegeben wurde vom Prof ein JavaSkript welches es ermöglicht den Code unten zur Ausführung zu bringen).
Die Datei wurde mit %load geladen.

Entwerfen Sie ein Maschinenprogramm, das bei Eingabe einer natürlichen Zahlen im Register C1 die Fakultät
in C1 ausgibt. Auf Basis des Entwurfs, implementieren Sie dieses Maschinenprogramm für die Registermaschinenimplementierung im Anhang.

Stellen Sie in Ihrer Implementierung außerdem folgende Bedingung (assertion) sicher, für n = 5:
assert machine.getConfiguration().getRegister(1) == 120; /* C1 */
Natürlich muss Ihr Programm für beliebige n funktionieren (auch für n = 0)! Nutzen Sie die Methode setRegister(1, /* n */) um das gewünschte nvor Ausführung zu setzen.

Lösung:

Java:

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;

Ausgabe: icounter = 16, c[0] = 0, c[1] = 120, c[2] = 1, c[3] = 1, c[4] = 0, c[5] = 0, c[6] = 0, c[7] = 0, c[8] = 0, c[9] = 0

RudiRüssel · 9. Dez 2020

Ich möchte einfach verstehen wie ich dies ohne Hilfe lösen kann. Ich bin kompletter Anfänger und verstehe die Befehle teilweise nicht, welche unter "new" angeführt sind.

MoxxiManagarm · 9. Dez 2020

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.

Java:

class LOAD implements Instruction {

Diese Klassen verändern wieder auf irgendeine Weise das Register.

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?

RudiRüssel · 9. Dez 2020

MoxxiManagarm hat gesagt.:
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.

Java:

class LOAD implements Instruction {

Diese Klassen verändern wieder auf irgendeine Weise das Register.

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?

Ich kann hier auch mal fürs Verständnis die Datei reinschicken.

Java:

/* 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;
    }
}

MoxxiManagarm · 9. Dez 2020

Die fertigen Klassen sind doch mehr als selbsterklärend. Was genau verstehst du an denen nicht?

Befehle - Maschinenprogramme

RudiRüssel

Mitglied

MoxxiManagarm

Top Contributor

RudiRüssel

Mitglied

RudiRüssel

Mitglied

MoxxiManagarm

Top Contributor

RudiRüssel

Mitglied

MoxxiManagarm

Top Contributor

Aktuelle Jobs

Neue Themen

Ähnliche Themen