Kommunikation zwischen Programmeinheiten

Der Informationsaustausch zwischen Programmeinheiten kann über gemeinsame Speicherbereiche (COMMON-Blöcke) und/oder über Parameterlisten stattfinden. COMMON-Blöcke können jedoch nicht zur Übertragung von Werten an interne und Formel-Funktionen benutzt werden; dies geht nur über Parameterlisten. Namen von Unterprogrammen können ebenfalls nur über Parameterlisten übergeben werden. Die Parameterübergabe über Parameterlisten ist bereits in Kapitel 4.2.20 ,,Speicherplatzzuordnung und Einbettung von Programmzeilen`` beschrieben worden. Zur Übergabe von Feldern durch Angabe des Feldnamens ist noch zu bemerken, daß dabei lediglich die Speicheradresse des ersten Feldelements übergeben wird. Die Informationen für Zugriffe auf beliebige Feldelemente werden durch die Feldvereinbarung (Typ-, COMMON- oder DIMENSION-Anweisung) geliefert. Felder als Formalparameter in Unterprogrammen können mit variablen Dimensionen vereinbart werden, wenn die Elementanzahl einfach über die Parameterliste übergeben wird und man die Deklaration im Unterprogramm in Abhängigkeit dieser Größe durchführt:

             SUBROUTINE Subb (X, N)
             INTEGER :: N
             REAL :: X(N)
               :
             END

Allgemein wird die Speicheradresse eines Feldelements anhand des Indexes dieses Elements relativ zum ersten Feldelement ermittelt, im allgemeinen ohne daß Feldgrenzenüberprüfung stattfindet. Dies wird gerne für trickreiche Programmierung verwendet. Außerdem birgt dies die schon in Abschnitt 4.2.3.3 ,,Felder`` erwähnte Gefahr des Zugriffs auf falsche Speicherplätze bei der Übergabe mehrdimensionaler Felder, die nicht genau wie im rufenden Programm definiert sind. In 4.2.3.4 wurde schon beispielhaft die Speicherung eines Feldes A(3,4) erläutert. Die Reihenfolge im Speicher ist dann

A(1,1); A(2,1); A(3,1); A(1,2); A(2,2); A(3,2)...A(2,4); A(3,4),

und das Element A(2,2) befindet sich auf dem 5. Speicherplatz. Wird das Feld im gerufenen Unterprogramm mit A(4,3) dimensioniert, so ist die dort lokal wirksame Speicherplatzzuordnung

A(1,1); A(2,1); A(3,1); A(4,1); A(1,2); A(2,2)...A(3,3); A(4,3),

und für das Element A(2,2) wird jetzt auf den 6. Speicherplatz zugegriffen, der aber das Element A(3,2) des übergebenen Feldes enthält. Felder sollten daher stets genau wie im rufenden Programm dimensioniert werden.

Neben Variablen können auch Namen von Unterprogrammen als Parameter über die Parameterliste übergeben werden. Dazu muß in der rufenden Programmeinheit der Name einer externen (benutzereigenen) Subroutine oder Funktion mit der EXTERNAL-Anweisung

EXTERNAL $funnam$

und der Name einer internen (eingebauten) Funktion mit der INTRINSIC-Anweisung

INTRINSIC $funnam$

deklariert werden, damit die Subroutine oder Funktion $funnam$ als Aktualparameter übergeben werden kann. Von den eingebauten Funktionen dürfen nicht als Aktualparameter verwendet werden: die Funktionen für Typkonvertierung und für lexikalische Vergleiche sowie die Minimum-/Maximumfunktionen. Von den übrigen dürfen nur die spezifischen, nicht die generischen Namen verwendet werden (z.B. ALOG statt LOG für natürlichen Logarithmus von reellen Zahlen).

Beispiel:

             SUBROUTINE What
             REAL :: Wert1, Wert2, Wert3, Wert4
             REAL :: Ergeb1, Ergeb2, Ergeb3, Ergeb4
             INTRINSIC ALOG, SQRT
             EXTERNAL Quad, Halb
               :
             CALL Who (ALOG, Wert1, Ergeb1)
             CALL Who (Quad, Wert2, Ergeb2)
             CALL Who (SQRT, Wert3, Ergeb3)
             CALL Who (Halb, Wert4, Ergeb4)
               :
             END SUBROUTINE

             SUBROUTINE Who (Func, Argum, Result)
             REAL :: Argum, Result
               :
             Result = Func (Argum)
               :
             END SUBROUTINE

             REAL FUNCTION Quad (X)
             REAL :: X
             Quad = X*X
             END FUNCTION

             REAL FUNCTION Halb (X)
             REAL :: X
             Halb = X / 2.
             END FUNCTION

Die EXTERNAL- und INTRINSIC-Anweisungen können aber auch verwendet werden, wenn man eine benutzerdefienierte Funktion oder Unterroutine schreiben möchte, die den gleichen Namen besitzt, wie eine vom Compiler vordefinierte. In diesem Fall kann der Compiler nicht entscheiden, ob das eigene (EXTERNAL) oder das vorgegebene (INTRINSIC) Unterprogramm benutzt werden soll. Dieses muß in dem aufrufendem Modul explizit angegeben werden:

             SUBROUTINE vordefiniert
             INTRINSIC SQRT
               :
             zahl1 = SQRT(wert1)       ! Hier wird die Compilerfkt. verwendet!!
               :
             END SUBROUTINE

             SUBROUTINE eigene
             EXTERNAL SQRT
               :
             zahl2 = SQRT(wert2)       ! Hier wird die eigene Fkt. verwendet!!
               :
             END SUBROUTINE


             REAL FUNCTION sqrt(wert)  ! Definition der eigenen Funktion
               :                       ! zur Wurzel-Berechnung
             END FUNCTION

Die Ausführung einer END- oder RETURN-Anweisung bewirkt normalerweise, daß alle lokalen Datenelemente eines Unterprogramms undefiniert werden. Ausgenommen sind die Fälle, in denen Datenelemente

• mit SAVE-Attribut deklariert werden,
• im unbenannten COMMON-Block stehen,
• (mittels DATA-Anweisung) initialisiert und nicht verändert worden sind,
• in benannten COMMON-Blöcken stehen, welche sowohl im Unterprogramm als auch in einer direkt oder indirekt übergeordneten Programmeinheit auftreten. Insbesondere bleiben die Werte aller im Hauptprogramm aufgeführten COMMON-Blöcke definiert.