Kurs:Programmieren in Oberon/Kapitel 1

Dieses Kapitel gehoert zum Kurs Programmieren in Oberon des Fachbereichs Informatik.

Hallo, Niklaus!

So, jetzt geht's los. Jeder von euch, der schon mal ein Programmier-Lehrbuch in den Händen gehabt hat, kennt das omnipräsente "Hello World!"-Programm. Das ist doch langweilig. Wir machen was anderes, ja, revolutionäres: ein "Hallo Niklaus"-Programm!

Oberon-Programme allgemein

Wie ihr wahrscheinlich der Vorlesung und den Übungsstunden entnommen habt, gibt es in Oberon keine Programme sondern MODULE. Ein Modul ist nichts anderes als ein Baustein des Systems, welches im Speicher darauf wartet, dass jemand (ein Benutzer oder ein anderes Modul) etwas von ihm will. Ein Modul ist nicht dazu verdammt, nur eine einzige Aufgabe auszuführen, sondern kann mehrere PROCEDUREs enthalten, die aufgerufen werden können.

Kompliziert? Ok, ein Vergleich: wenn man unter UNIX z.B. den Befehl "ping" ausführt, so wird nur gepingt und nichts mehr. In Oberon jedoch kann man ein Modul schreiben, welches z.B. die Befehle "SagHallo", "ZaehlMal" und andere ausführen kann, alles im gleichen Modul. Andere Programme können dann auch direkt auf diese Befehle und andere Prozeduren zugreifen (vorausgesetzt sie sind freigegeben worden). Wie dies geht (eigentlich recht einfach) wird noch im Text erklärt.

Struktur eines Moduls

Na gut, wir wissen jetzt was MODULE sind und was sie können, aber wie ist ein Modul aufgebaut? Folgendermassen:

MODULE MeinModul;

    IMPORT
        Out;

    PROCEDURE SagHallo*;
        BEGIN
            Out.String("Hallo, Niklaus!");
            Out.Ln;
        END SagHallo;

    BEGIN
        Out.Open;
    END MeinModul.

Das Obige ist ziemlich einfach zu verstehen. Ein Modul fängt immer mit der Anweisung

MODULE MeinModul;

an, welche dem Compiler sagt: «Hier beginnt ein Modul mit dem Namen MeinModul». Es hört auf mit einem

END MeinModul.

Bitte beachtet, dass das Ganze mit einem Punkt und nicht mit einem Strichpunkt aufhört. Ab dieser Anweisung liest der Compiler nichts mehr, also kann man die .Mod-Datei ab da mit beliebigem Müll füllen.

Auf die Moduldeklaration, folgt (naja, wie soll man dem eigentlich sagen?) Information zum Modul. In unserem Beispiel ist dies jetzt nur die Anweisung

IMPORT
    Out;

Diese sagt dem Compiler, das wir die Prozeduren des Moduls Out in Anspruch nehmen wollen. Dieses Out-Modul wird später näher erklärt.

Danach kommen die verschiedenen Prozeduren des Moduls. Auch wie bei den Modulen sind Anfang und Ende klar definiert:

PROCEDURE SagHallo*;
    BEGIN
    ...
    END SagHallo;

Diese werden auch später erklärt (jetzt geht es ja nur ums Modul, bitte ein wenig Geduld!). Am Schluss des Moduls, also vor der END-Anweisung, kann man noch ein BEGIN und irgendwelche Befehle einfügen. In unserem Beispiel sah das etwa so aus:

BEGIN
    Out.Open;
END MeinModul.

Die Befehle, die zwischen diesem BEGIN und END kommen, werden nur beim Laden des Moduls ausgeführt, das heisst wenn man das Modul zum ersten Mal braucht oder wenn man es nach einer Neucompilierung zuerst mit System.Free aus dem Arbeitsspeicher gelöscht hat und neu laden muss. Dort haben wir jetzt die Anweisung Out.Open reingestopft, dessen Bedeutung ich später erklären werde.

Die wunderbare Welt der `PROCEDURE`-Anweisung

Das Wichtigste in einem Modul werden fast immer die PROCEDUREs sein, denn sie sind es, die für die Funktionalität sorgen. Die Struktur einer Prozedur sieht wie folgt aus:

PROCEDURE SagHallo*;
    BEGIN
        ...
    END SagHallo;

Sie fängt, wie beim Modul, mit dem Wort PROCEDURE und den Namen der Prozedur an. Das Wort BEGIN gibt den Anfang der Anweisungen an und END beendet das Ganze mit dem am Anfang gegebenen Namen.

Zwischen dem PROCEDURE und dem BEGIN kann man noch Konstanten und Variablen deklarieren, die brauchen wir jedoch jetzt noch nicht – darum erkläre ich’s auch noch nicht. :-)

Alle Anweisungen, die in der Prozedur ausgeführt werden sollen, müssen zwischen dem BEGIN und dem END stehen.

Neben dem Prozedurnamen steht ein Asterisk. Dieser sagt dem Compiler, dass die Prozedur für den Zugriff von aussen freigegeben werden soll, d.h. wir können die Prozedur dann mit MeinModul.SagHallo von aussen (als Benutzer) nach dem Compilieren aufrufen.

Die `Out`-gabe

Ok, wir können jetzt Module mit von aussen erreichbaren Prozeduren schreiben, die irgendwas machen, aber was bringt uns das? Um ihre Existenz irgendwie rechtfertigen zu können, muss das Modul mit uns sprechen können. Dies erreichen wir mit den Befehlen des Moduls Out.

Das Modul Out ist einfach eine äusserst simple Schnittstelle zur Aussenwelt. Ihre wohl wichtigste Prozedur ist:

Out.Open;

Wobei zuerst das "Out." dem Compiler sagt, dass er die Prozedur, deren Name nach dem Punkt folgt, aus dem Modul Out nehmen soll. Diese Anweisung öffnet ein neues Ausgabefenster, und zwar jedesmal, wenn man es aufruft. In unserem Beispiel geschieht dies beim Laden des Moduls. Würde man es hingegen in die Prozedur SagHallo reinschieben, so würde es bei jedem Aufruf dieser Prozedur ein neues Fenster aufmachen. Lässt man es aber im Modul-Körper und schliesst das Ausgabefenster nach der ersten Ausführung der Prozedur SagHallo, und man ruft es nochmals auf, so sieht man nix mehr, denn das Fenster ist weg und niemand erweckt es wieder zum Leben. Die Plazierung der Out.Open Anweisung ist dem Programmierer überlassen.

Wir können jetzt ein Fenster öffnen, jetzt müssen wir nur noch drin schreiben können. Dazu gibt es einige sehr hilfreiche Prozeduren:

Out.String("text"): schreibt text.
Out.Char("c"): schreibt ein einziges Zeichen c.
Out.Int(i,n): schreibt eine ganze Zahl i und lässt Platz fuer n Stellen.
Out.Real(r,n): gleich wie Out.Int, einfach mit reellen Zahlen.
Out.Ln: öffnet eine neue Zeile.

In unserer Prozedur SagHallo machen wir also nix anderes als die Zeichenkette "Hallo, Niklaus!" (mit anschliessendem Zeilenumbruch) an die Ausgabe zu schicken.

Und jetzt alle zusammen …

Wir haben jetzt ein Modul namens MeinModul, welches das Modul Out importiert und eine von aussen zugängliche Prozedur SagHallo enthält, welche eine Zeichenkette Hallo, Niklaus! und einen Zeilenumbruch ausspuckt .

Wenn man jetzt das Ganze eintippt, kompiliert und mit dem Befehl MeinModul.SagHallo ausführt, sollte ein neues Fenster aufgehen und die Worte Hallo, Niklaus! erscheinen, gefolgt von einem Zeilenumbruch.