Giving away

Letzte Woche haben wir uns mit ein paar Beispielen, mit dem Beispiel Digitalrechner beschäftigt.

Wir haben gesehen, wir können Sequenzen von Befehlen ausführen.

Wir haben gesehen, wir können Verzweigungen machen.

Wir haben gesehen, wir können Schleifen machen.

Wir können also mit den drei Konstrukten, nämlich Sequenz von Anweisungen, Programmverzweigungen und Interrationen,

Algorithmus realisieren.

Was wir heute zum Abschluss dieses Bereich der Maschinenahenprogrammierung machen, ist, dass wir ein sehr wichtiges Konstrukt anschauen,

das wir alle benutzen, benutzt haben in Java, nämlich den Aufruf von Unterprogrammen zur Strukturierung von Programmen.

Wir haben zunächst als letztes Mal die Situation kennengelernt, dass wir ein Teil des Programms, das immer wieder verwendet wird,

beim Makro hier eingefügt in den Code des Aufprogrammes, was den Code sehr groß macht und aufbläht.

Die andere Alternative ist, dass wir an der geeigneten Stelle diesen Teil als Unterprogramm aufrufen.

Jetzt müssen wir ihn im Kopf behalten.

Wenn wir jetzt also ein Unterprogramm aufrufen, müssen wir erst einmal wissen, wo geht es hier weiter.

Das heißt, wir müssen uns die Rückstrun-Adresse nähern.

Wenn wir also in dem Unterprogramm diese Register benutzen, müssen wir den Inhalt dieser Register rächen und vor dem Rückprung aus dem Unterprogramm ins Hauptprogramm zurück wieder herstellen.

Drittens müssen wir im Unterprogramm Übergabeparameter mitgeben.

Das werden wir uns jetzt anschauen. Die Parameter, dann den Sprung in das Unterprogramm und dabei müssen wir uns die Rückstrun-Adresse, also die Rückstrun-Adresse muss ich nach der Abarbeitung des Unterprogramms hier her, hier her oder hier her,

das müssen wir uns mehrern. Dann müssen wir die Register oder zumindest alle Register oder zumindest die, die vom Unterprogramm verwendet werden, rächen.

In der Regel haben wir dafür einen Stapelspeiter, einen Stack und tun den auf den Stack.

Am Ende müssen wir dann die Register wieder aus dem Stapelspeiter zurückholen.

Dann müssen wir die verwendeten Märchen ans Hauptprogramm wieder übergeben und dann den Umsprung zu dem Befehl nach dem Befehl, von dem aus wir die Ressourcen bekommen haben.

Ist es soweit klar?

So, wir machen jetzt die Einfachheit, halten wir die mal an, wir wissen die Standardette vom Unterprogramm und die Parameter, die wir übergeben werden,

und dann machen wir auch einen Stack mit ab. Das Jump-Subroutine schreibt von sich aus, wenn das Jump-Subroutine als Befehl kommt und ausgeführt wird,

dann ist ja der nächste Befehl nach dem Jump-Subroutine, die Adresse des nächsten Befehlens, nach dem Jump-Subroutine ein Befehlszähler registriert.

Das heißt, das Jump-Subroutine redet den Inhalt des Befehlszählers auf den Stack.

Dann wird die Adresse des nächsten Befehlens im Hauptprogramm nach dem Jump-Subroutine und dann wird die Startadresse des Unterprogramms in den Befehlszähler geladen und damit wird das Unterprogramm gestartet.

Okay, die benötigten Register werden, dann die Parameter, wir machen das so, dass wir die Parameter in den Stack reinschreiben,

die der Rückgabe bewertet wird im Stack oder in irgendeinem Registergeschäft, wir lassen den im Arbeitsminister drin, dann die Restaurierung der verwendeten Register durch das Unterprogramm,

das ist die Aufgabe des Unterprogramms und dann gibt es eben diesen speziellen Befehl Return-Subroutine, der sich aus dem Stack die Wünschpunktadresse holt und an die gespringt und dann weiterholt.

Und natürlich kann sich ein Unterprogramm selber aufrufen, das heißt, wir werden da auch ein etwas schwereres Beispiel nehmen und werden uns die Rekursionen anschauen.

Und das machen wir mit der ganz einfachen Fakultätsfunktion, die kennt ja jeder. Also wir rufen hier im Hauptprogramm auf Fakultät von N, in dem Fall nr. 3,

im Unterprogramm fragen wir ab, wenn n gleich 0 ist, dann ist Fakultät von n 1 und du springst zurück, ansonsten ist Fakultät von n gleich n mal und jetzt wieder Rekursion Fakultät mit n minus 1.

Und wie wir das jetzt realisieren, als Assemtabote schauen wir uns an. Also hier zunächst, wir müssen also das N irgendwie uns holen und das Y, wie gesagt,

das ist dann der Wert, den wir dann zuweisen mit dem Unterprogramm auf. So, das erste ist, wir holen uns aus dem Speicherplatz für den Parameter N,

den holen wir ins Arbeitsregister. Also move to, move to heißt, hole den Wert an der Adresse N ins Arbeitsregister.

So, N ist der Übergabe Parameter an das Unterprogramm, den übergeben wir dadurch, dass wir nach dem Stabilspeicher schreiben. Also machen wir eine Push-Operation.

Dann schreiten wir auf, Jump Subroutine, rufen das Unterprogramm Fakultät auf. In dem Moment, wo dieser Befehl aufgerufen wird, ist die Adresse des nächsten Befehlers,

das ist das R-Bit-Strick-HP, das Parameter Hauptprogramm, ist im Befehlszähler. Das Jump Subroutine nimmt jetzt diese Adresse und schreibt sie in den Teller Speicher.

Wenn ich von dem Hauptprogramm zurückkomme, dann muss ich das Ergebnis, wenn ich von dem Unterprogramm zurückkomme, muss ich das Ergebnis dem Hauptprogramm mitteilen.

Das machen wir dadurch, dass das Unterprogramm das Ergebnis im Arbeitsregister lässt. Das heißt, wenn ich aus dem Unterprogramm zurückkomme,

steht das Ergebnis Fakultät von N im Arbeitsregister und ich muss es hier an dieser Stelle in meinen Speicherplatz Y, in dem ich den Delivert hier zuweise, da muss ich das allein schreiben.

Das ist der Ausschnitt aus unserem Hauptprogramm, davor irgendwas, danach eben welche weiteren Befehle und ich habe hier noch die Speicherzellen für das N und für das Ergebnis.

Unterprogramm soweit klar? Was passiert?

Okay, gleich zwei. Jetzt gehen wir zum Unterprogramm. Erstmal schauen wir uns den Stapel an.

Wir sehen, dieser Aufruf dieses Unterprogrammes hat zur Folge, dass zwei Werte auf den Stack geschrieben werden.

Nämlich die Rückkommandante und der Übergabelparameter. Jetzt schauen wir uns den Stack an.

Also zu Beginn, dann hier und dann auf 101 und dann wird 3 auf den Stack geschrieben. Dann wird das Hauptprogramm, die Rückkommandante vom Hauptprogramm aufgerufen.

Jetzt ist es Unterprogramm. Jetzt weil eben 3 noch nicht gleich 0 ist, sich selber hochkriegen mit um 1 reduziert, also hier 2 und eine Rückkommandante unterprogramm.