Interpretation von Assemblerbefehlen

[kajal]

Interpretation von Assemblerbefehlen
Gegeben ist folgende Liste vom Assemblerbefehlen.
LOAD x Lade den Inhalt von Adresse x in den Akkumulator
LOADA Lade den Inhalt der Adresse, deren Wert im Akkumulator steht, in den Akkumulator
STORE x Speichere den Inhalt des Akkumulators in der Speicherzelle mit der Adresse x
ADD x Addiere den Wert an Adresse x zum Inhalt des Akkumulators
SUB x Subtrahiere den Wert von Adresse x vom Inhalt des Akkumulators
MULT x Multipliziert den Wert von Adresse x mit dem Inhalt des Akkumulators
JMPNEG x Springe zur Marke x, wenn der Inhalt des Akkumulators < 0
JMPEQ x Springe zur Marke x, wenn der Inhalt des Akkumulators = 0
JLE x Springe zur Marke x, wenn der Inhalt des Akkumulators <= 0
JMP x Springe zur Marke x
NOT logische Negation - bitweises Komplement des Wertes im Akkumulator
NEG unäres Minus angewendet auf den Wert im Akkumulator.
HALT Beendet das Programm
Mit jedem Assemblerbefehl ist eine Semantikregel assoziiert, die angibt, wie der aktuelle Zustand verändert wird, so ist beispielsweise
[LOAD x]] () =   {Akk 7! (Mem[x]), pc 7! (pc) + 1}

Akk sei dabei die Variable, die den Akkumulatorinhalt bezeichnet, Mem das Speicherarray,
pc der Programmzähler).
a) Gebt f¨ur jeden Befehl die entsprechende semantische Transformation an.
b) Der obige Befehlssatz wird um den Befehl
PRINT x Gebe den Inhalt von Adresse x aus
ergänzt, für den keine Semantikregel definiert werden soll.
Schreibt ein JAVA Programm, mit dem ein Assemblerprogramm, das diesen Befehlssatz
verwendet, ausgef¨uhrt werden kann. Dabei soll der Speicher als int [] Array modelliert
werden. Um die Zustandsübergänge zu veranschaulichen, soll zu jedem Befehl der aktuelle
Zustand ausgegeben werden.


c) Gebt eine kurze Beschreibung des Verhaltens des Pseudo-Assemblerprogramms.

class AsmInterpreter {


/* 
 * Bisher enthält diese Klasse nur ein Pseudo-Assemblerprogramm
 * und das auch noch unkommentiert ;)
 */

/*
 * Zunächst einige Konstanten für Adressbezeichner
 * - damit das Assemblerprogramm besser lesbar ist
 */

    static final int zero = 41;
    static final int one = 44;
    static final int fourty = 42;
    static final int idx = 43;
    static final int myArray = 0;
    static final int theResult = 40;
    static final int L0 = 5;
    static final int L1 = 12;
    static final int empty = 1000;


/*
 * Die einzelnen Befehle...
 */

    static final int LOAD = 0;
    static final int LOADA = 1;
    static final int STORE = 2;
    static final int ADD = 3;
    static final int SUB = 4;
    static final int MULT = 5;
    static final int JMPNEG = 6;
    static final int JMPEQ = 7;
    static final int JMP = 8;
    static final int NOT = 9;
    static final int NEG = 10;
    static final int HALT = 11;
    static final int JLE = 12;
    static final int PRINT = 13;

    /* Datenspeicher
     * Magical Mystery Data
     */

    static int m[] = {
	10,        
	111,
	20,
	230,
	50,
	1111,
	561,
	360,
	341,
	12431,
	40,
	41,
	4440,
	51,
	50,
	1456,
	1456234,
	1231,
	123,
	1231,
	1231,
	132,
	1230,
	1230,
	3450,
	270,
	5461,
	45670,
	2340,
	32451,
	231,
	231,
	231,
	550,
	9991,
	34220,
	343420,
	344520,
	34520,
	320,        
        0,          // Adresse 40: Ergebnisspeicher theResult
        0,          // Adresse 41: Konstante 0
        40,         // Adresse 42: Konstante 40
        0,          // 
        1,          // Adresse 44: Konstante 1
        1,          // 
    };

    // Programmspeicher
     
    static int p[][] = {
	{ LOAD, myArray },          // Programmzähler adresse 0
	{ STORE, theResult },       // Programmzähler adresse 1
	{ LOAD, zero }, 
	{ STORE, idx },
	{ JMP, L1 },
/*L0:*/	{ LOAD,idx },               // Programmzähler adresse 5
	{ LOADA, },
	{ SUB, theResult },
	{ JLE, L1  },
        { LOAD,idx },
	{ LOADA,  },
	{ STORE, theResult },
/*L1:*/	{ LOAD ,idx  },             // Programmzähler adresse 12
	{ ADD ,one  },
        { STORE, idx },
	{ SUB ,fourty  },
	{ JMPNEG ,L0  },
        { PRINT, theResult},
	{ HALT,  }
    };

/* 
 * Und ab hier dürft Ihr Euren Interpreter 
 * programmieren...
 */

    public static void interpreter() {
    }
}

Bitte bitte hilf mir etwas!

danke

 

[Marco13]

Hm. Ich find die Aufgabe eigentlich cool. Für einen Anfänger schon nicht so leicht, aber vermittelt einige wichtige Grundlagen.
Zur Frage an sich...was erwartest du? Eine Komplettlösung wohl nicht.
a) Bei dem Beispiel sind einige Zeichen kaputtgegeanden. Poste ggf. mal das Beipiel neu, und auch gleich deinen Lösungsvorschlag für ALLE anderen Befehle. Dann kann man weiter sehen.
b) Deine Klasse hätte dann die genannten Variablen
Akk sei dabei die Variable, die den Akkumulatorinhalt bezeichnet, Mem das Speicherarray,
pc der Programmzähler).
und würde von vorne bis hinten durch den "p"-Array laufen, und immer den Befehl ausführen, der dort gerade steht. WAS bei jedem einzelnen Befehl zu tun ist, hast du dir ja in a) erarbeitet :wink:
Stell ggf. mal konkretere Fragen, damit man sieht, dass du dir darüber Gedanken gemacht hast.

 

[L-ectron-X]

*Titel geändert*
(Brauche Tipsss Bitte um Hilfeeeeee)

Von "außen" konnte man nicht erkennen, wobei... :roll: