Arbeitsmaterial:

• DCManual.pdf - Beschreibung der Prozessor-Simulation DC
• DCKurz.pdf - Kurzfassung der Beschreibung von DC
• DC.EXE - DOS-Programm DC zum Download
• DC_und_Dosbox.pdf

Rechnerinterne Vorgänge:

Informationen: Methoden bzw. Unterprogramme

Das folgende Mini-Java-Programm berechnet das Produkt der beiden Faktoren faktor1 und faktor2, indem es den faktor1 so oft addiert, wie es faktor2 vorgibt. Die 23 wird im Beispiel 3 Mal addiert.

class Vielfaches
{ int faktor1;
  int faktor2;
  int produkt=0;

  public void multipliziere()
  {  do { produkt = produkt + faktor1;
          faktor2 = faktor2 - 1;
        } while (faktor2 > 0);
  }

  public void action() // Hauptprogramm
  { faktor1 = 23;
    faktor2 =  3;
    multipliziere();
    System.out.println("Das Ergebnis ist " + produkt + ".");
  } // Ende von action
} // Ende von class Vielfaches

Übersetzt man das Java-Programm in DCL-Code, erhält man Folgendes:

; Multiplikation von zwei natuerlichen Zahlen
         JMP Anfang
                        ;
bspZahl1 DEF 23         ; Beispielzahlen
bspZahl2 DEF 3
faktor1  DEF 0          ; int faktor1;
faktor2  DEF 0          ; int faktor2;
produkt  DEF 0          ; int produkt;

                        ; public void action(...)
Anfang                  ; {
         LDA bspZahl1
         STA faktor1    ; faktor1 = bspZahl1
         LDA bspZahl2
         STA faktor2    ; faktor2 = bspZahl2
         JSR Addiere    ; addiere();
         OUT produkt    ; System.out.print(produkt);
         END            ; } // Ende von action()

Addiere                 ; public void addiere()
                        ; {  // Anfang der Methode
DO_Anfang
         LDA produkt    ;   do {
         ADD faktor1    ;
         STA produkt    ;        produkt = produkt + faktor1;
         LDA faktor2    ;
         DEC            ;
         STA faktor2    ;        faktor2 = faktor2 - 1;
         JPL DO_Anfang  ;      } while (faktor2 > 0);
         RTN            ; }  // Ende der Methode

Zwei Befehle sind neu:
JSR: JUMP SUBROUTINE = Springe zum Unterprogramm
Es gibt einen Sprung zum Unterprogramm (in Java Methode), hier an der Stelle Addiere. Der Unterschied zum JMP-Befehl ist der, dass vor dem Sprung die Adresse des folgenden Befehls (hier OUT) auf einen Stack gepusht wird, so dass das Programm nach der Rückkehr vom Unterprogramm dort weitermachen kann. Beim normalen JMP-Befehl geht die Information verloren, wo die nächste Programmzeile ist.

RTN: RETURN FROM SUBROUTINE = Rückkehr vom Unterprogramm
Der mit dem Befehl JSR auf den Stack gepushte Wert für die Speicherstelle mit dem nächsten auszuführenden Befehl wird vom Stack gepoppt und dann in das PC-Register geladen. Dort geht es mit der Programmausführung weiter. Besonders interessant dabei ist, dass durch die Stackstruktur mehrere Aufrufe von Methoden und Rekursion möglich werden.

Auftrag 1:

Teste das oben angegebene DCL-Programm mit dem Programm DC. Beobachte dabei auch die Vorgänge auf dem Stack.

Auftrag 2:

Das folgende kleine Mini-Java-Programm berechnet in einer Methode das Doppelte einer Zahl.

class Doppeltes
{ int zahl;
  int ergebnis = 0;

  public void berechneDasDoppelte()
  { ergebnis = zahl + zahl;
  }

  public void action() // Hauptprogramm
  { zahl = 23;
    berechneDasDoppelte();
    System.out.println("Das Ergebnis ist " + ergebnis + ".");
  } // Ende von action
} // Ende von class Doppeltes

Übersetze das Mini-Java-Programm in ein entsprechendes DCL-Programm und teste das Programm aus. Vervollständige den DCL-Code:

Auftrag 3:

Nimm das DCL-Programm von oben zur Multiplikation als Vorlage und schreibe es so um, dass eine Methode quadriere() aufgerufen wird. Es wird also am Ende das Quadrat einer ganzen Zahl ausgegeben. Teste das Programm mit DC aus. Vervollständige den DCL-Code: