Befehle - Maschinenprogramme

RudiRüssel

Mitglied
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
 
Zuletzt bearbeitet:

RudiRüssel

Mitglied
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.
 
Zuletzt bearbeitet:

MoxxiManagarm

Top Contributor
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

Mitglied
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;
    }
}
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
H Befehle in einem Menü aktivieren Java Basics - Anfänger-Themen 1
D import Befehle Java Basics - Anfänger-Themen 3
F Linux Befehle zum Übersetzen Java Basics - Anfänger-Themen 1
L Linux Befehle unter Windows in Eclipse ausführen Java Basics - Anfänger-Themen 3
D Erste Schritte Weitere Befehle implementieren Java Basics - Anfänger-Themen 27
T befehle unterschiedlicher anzahl an strings wiedergeben Java Basics - Anfänger-Themen 2
RowdyN Methoden Befehle in zufälliger Reihenfolge ausführen lassen Java Basics - Anfänger-Themen 5
D Input/Output Mehrere Befehle nacheinander ausführen Java Basics - Anfänger-Themen 20
L Text/Befehle zu Programmen senden Java Basics - Anfänger-Themen 1
C Java und "normale" Befehle Java Basics - Anfänger-Themen 3
M Input/Output Allg. Befehle an die cmd.exe senden Java Basics - Anfänger-Themen 9
N Mit Java Befehle auf Konsole ausführen Java Basics - Anfänger-Themen 4
F alle 100ms Befehle ausführen Java Basics - Anfänger-Themen 26
S Befehle in ProcessBuilder nachschieben Java Basics - Anfänger-Themen 2
J Befehle aus anderen Klassen ausführen Java Basics - Anfänger-Themen 8
F Befehle von Java class ausführen Java Basics - Anfänger-Themen 3
F Befehle wiederholen Java Basics - Anfänger-Themen 7
B Threads Geschwindigkeit der Befehle auf verschiedenen PCs gleich machen Java Basics - Anfänger-Themen 3
G Kombination zweier Befehle (Preis festlegen & Rabatt berechnen) Java Basics - Anfänger-Themen 3
D Input/Output Stringbuffer Befehle bei Konvertierung in String Java Basics - Anfänger-Themen 19
C Nach Java-Installation sind Befehle erfolglos Java Basics - Anfänger-Themen 4
J Unklare Befehle Java Basics - Anfänger-Themen 4
K .bat Dateien starten, Ausgabe einlesen und Befehle übergeben Java Basics - Anfänger-Themen 32
H Befehle an andere Programme Java Basics - Anfänger-Themen 8
M Befehle der Eingabeaufforderung Java Basics - Anfänger-Themen 2
S return(Bedingung) ? [mehrere Befehle] Java Basics - Anfänger-Themen 5
M Umgebungsvariable gesetzt, aber nicht alle Befehle ausführbar Java Basics - Anfänger-Themen 6
M TextWrangler/VIM- Manche Befehle werden nicht farblich hervorgehoben Java Basics - Anfänger-Themen 3
S Mehrere Return-Befehle in einer Methode Java Basics - Anfänger-Themen 23
G Eigene Klasse für externe Befehle - Warten auf Prozesse Java Basics - Anfänger-Themen 6
N 2 Befehle zu einem machen Java Basics - Anfänger-Themen 10
K Shell Befehle mit Java aufrufen Java Basics - Anfänger-Themen 5
G CMD Befehle übergeben Java Basics - Anfänger-Themen 2
J Java Konsolenprogramm Befehle(Optionen) übergeben Java Basics - Anfänger-Themen 7
Blackskyliner Befehle an einen Thread senden? Java Basics - Anfänger-Themen 2
K Wieviele Befehle pro .java Datei Java Basics - Anfänger-Themen 4
C Befehle finden / Befehle richtig suchen Java Basics - Anfänger-Themen 5
E Befehle Java Basics - Anfänger-Themen 3
D MS Dos Befehle mit java Java Basics - Anfänger-Themen 3
G Falsche Java befehle, doch was ist falsch? Java Basics - Anfänger-Themen 9
D Win98 erkennt keine java Befehle.Umgebungsvariablen falsch? Java Basics - Anfänger-Themen 7
B Alt-Befehle Java Basics - Anfänger-Themen 4
C System.exit(int) und andere ähnliche Befehle Java Basics - Anfänger-Themen 5
R MS-DOS-Befehle ausführen Java Basics - Anfänger-Themen 11
S Befehle an externe Programme Java Basics - Anfänger-Themen 4
L Dos Befehle via Java Java Basics - Anfänger-Themen 4

Ähnliche Java Themen

Neue Themen


Oben