Funktionen und Prozeduren

Funktionsaufruf
```
      erg = Funktion(Para1, Para2);
      Funktion2(Para1, Funktion(Para2));
      erg= 1 + Fubktion()
   
```
Dies sind alles gebräuchliche Aufrufe von Funktionen. Der Aufruf einer Funktion geschieht also mit dem Namen der Funktion direkt gefolgt von zwei runden Klammern, in denen Argumente übergeben werden können. Die Funktion liefert dann einen Rückgabewert.
Prozeduraufruf
```
      CALL Subroutine
      CALL Subroutine Para1, Para2, Para3
   
```
Ein Prozeduraufruf geschieht mit dem Schlüsselwort CALL. Hier werden die Parameter als eine durch Kommata getrennte Liste übergeben.
In Rexx entscheidet daher allein die Art des Aufrufes, ob es sich um einen prozedualen oder einen Funktionsaufruf handelt. Dabei kann man jede Funktion, also auch die Rexx-Funktionen, auf beide Weisen aufrufen.
```
      SAY Center(' Ueberschrift ',40, '*')
      CALL Center ' Ueberschrift ', 40, '*'
      SAY RESULT
   
```
Will die Prozedur (im 2. Fall) jedoch etwas zurückliefern, so wird dieser Wert in der vordefinierten Variablen RESULT geschrieben.
Rekursive Aufrufe von Funktionen sind erlaubt.
Definition einer Subroutine
```
      Name:
         ...
         RETURN rueckgabewert;
   
```
Eine Funktions- bzw. Prozedurdefinition beginnt mit einem Label. Dies sieht genauso aus wie auch das Label von SIGNAL. Danach folgen die Klauseln, und abgeschlossen wird sie mit RETURN mit einem otionalen Rückgabewert.
In Rexx kann man alle Datentypen zurückgeben. Will man eine Compound Variable x. zurückgeben, so wird hier nur der Rumpf, also der Wert für x. zurückgegeben.
```
      Echo:
         PARSE ARG argument;
         SAY argument;
         RETURN;
   
```
Die übergebenen Argumente werden wie auch in der Hauptroutine mit PARSE ARG oder Arg() abgerufen.
Sichtbarkeit und Lebensdauer von Variablen
- Grundsäzlich ist jede Variable von jeder Ecke eines Programms aus erreichbar! Die Lebensdauer der Variablen geht bis zum Ende des Programms. Somit ist auch eine Variable, die in einer Funktion angelegt wurde weiter später im Hauptprogramm und anderen Prozeduren sichtbar.
- Will man diese gigantische Fehlerquelle abschalten, muß man bei Prozeduren bzw. Funktionen das Schlüsselwort PROCEDURE verwenden.
```
        Prozedur: PROCEDURE
           ...
           RETURN;
	 
```
- Jetzt kann man von außen auf keine der Variablen in der Prozedur zugreifen. Jedoch kann man auch in der Prozedur auf keine äußere Variable zugreifen. (Motto: Alles oder Nichts!).
  Auch hier ist die Lebensdauer einer Variable in einer Prozedur auf die Zeit des Programms und nicht der Prozedur beschränkt.
- Will man jedoch in einer Prozedur auch auf äußere Variablen zugreifen, so muß man diese in der Prozedur mit EXPOSE freigeben.
```
        Prozedur: PROCEDURE EXPOSE cv.
           cv.1='Hallo'
           RETURN;
	 
```
  Hier wird die Compount Variable cv. freigegeben. Die Veränderungen an der CV sind somit auch in der Hauptroutine zu sehen.
Funktionen und Prozeduren sollten immer nach dem Hauptprogramm definiert werden, da sonst Rexx beim Ausführen des Programms beim ersten Auffinde eines RETURNs das Programm sofort verlassen würde. Allgemein beendet RETURN die aktuelle Aufrufebene (z.B. eine Funktion), wogegen EXIT gleich das ganze Programm beendet.
Selbstdefinierte externe Funktionen
- Wenn man auf einem Dateisystem wie FAT arbeitet, darf der Name der Funktion nicht länger als 8 Zeichen sein. Bei einem HPFS-Dateisystem sind es entsprechend 255 Zeichen.
- Bei der Suche nach externen Subroutinen versucht Rexx den Namen der Funktion mit dem Dateinamen gleichzusetzen.
```
          CALL Prozedur;
          SAY Funktion();
          CALL Prozedur.CMD;
          SAY Funktion.CMD();

          CALL 'Prozedur.CMD;
          SAY 'Funktion.CMD'();
          CALL 'C:\REXX\Prozedur.CMD';
          SAY 'C:\REXX\Funktion.CMD'();
      
```
  Diese Aufrufformen sind möglich. Hinweis: Unter OS/2 haben Rexx-Programme die Erweiterung CMD. Auf anderen Betriebsystem ist es normalerweise eine andere, bzw. beliebig frei wählbare z.B. rexx.
- Reihengfolge, in der Rexx eine aufzurufende Routine sucht:
  - selbstgeschriebene Subroutine in der gleichen Datei
  - eingebaute Subroutine von Rexx
  - externe Subroutine in einer eigenen Datei
- will man eine eigene externe Subroutine aufrufen, die den gleichen Namen hat wie eine in Rexx eingebaute Funktion, so muß man sie wie im obigen Beispiel den Namen in Hochkommata setzen.
eigene Bibliotheken
- Rexx kann auf Bibliotheken, die z.B. in C/C++ geschrieben sind, zugreifen. Unter OS/2 sind die Bibliotheken DLL-Dateien, Dynamik Link Libraries, z.B. REXXUtil.
- Die Bibliotheken haben u.a. den Vorteil, daß sie wesentlich schneller sind, als wenn man sie in Rexx implementieren würde.
- Die Registrierung einer Bibliothek geschieht mit der Funktion RXFuncAdd
```
         erg= RXFuncAdd(Funktionsname, Modul, Einsprungspunkt)
	  
```
  Der Rückgabewert ist im Fehlerfall 0 , und wenn alles funktioniert hat 1.
- Mit der Bibliothek RexxUtil unter OS/2 stehen dann dem Programmierer vielfältige Tools zum Bearbeiten rund um den WPS (grafische Oberfläche von OS/2) und dem Dateisystem sowie Konfigurationsdateien zur Verfügung.