Function Call

#### Search Results

Search

# Function Call

function-name
`(<` [([prototype-clause] [intermediate-result-clause])]
[parameter] [,[parameter]] ... `>)`
[array-index-expression]

Eine Erläuterung der in dem Syntax-Diagramm verwendeten Symbole entnehmen Sie dem Abschnitt Syntax-Symbole.

Verwandte Statements: `DEFINE PROTOTYPE` | `DEFINE FUNCTION`

Dieses Dokument behandelt folgende Themen:

- Verwendung

- Einschränkungen

- Syntax-Beschreibung

- Beispiel

- Function-Ergebnis

- Parameter- und Ergebnisangaben

- Reihenfolge bei der Auswertung von Functions in Statements

- Verwendung einer Function als Statement

## Verwendung

Ein Function Call wird verwendet, um ein Natural-Objekt des Typs Function aufzurufen.

Definiert wird die Function mit dem Natural-Statement `DEFINE FUNCTION`, das Folgendes enthält: die Parameter, lokale und anwendungsunabhängige Variablen, den zu benutzenden Ergebniswert und die Statements, die ausgeführt werden sollen, wenn die Function aufgerufen wird.

Um eine Function aufzurufen können Sie Folgendes angeben:

- entweder den Namen der Function, so wie er im `DEFINE FUNCTION`-Statement definiert ist,

- oder eine alphanumerische Variable, die den Namen der Function zur Laufzeit enthält. In diesem Fall muss die Variable mit dem Schlüsselwort `VARIABLE` in einem `DEFINE PROTOTYPE`-Statement referenziert werden.

Ein Function Call kann anstelle eines schreibgeschützten Operanden in einem Natural-Statement verwendet werden. In diesem Fall muss die Function ein Ergebnis zurückgeben, welches dann von dem Statement wie ein Feld verarbeitet wird, das den gleichen Wert enthält.

Außerdem kann ein Function Call anstelle eines Natural-Statements benutzt werden. In diesem Fall braucht die Function keinen Ergebniswert zurückzugeben; falls doch, wird der Wert des Ergebnisses verworfen.

## Einschränkungen

An folgenden Stellen dürfen keine Function Calls benutzt werden:

- Stellen, an denen der Operand-Wert durch das Natural-Statement geändert wird, zum Beispiel:

  `MOVE 1 TO #FCT(<..>)`;

- in einem `DEFINE DATA`-Statement;

- alle einem Datenbankzugriff-Statement, zum Beispiel `READ`, `FIND`, `SELECT`, `UPDATE` und `STORE`);

- `AT BREAK`-Statement oder `IF BREAK`-Statement;

- als Argument von Natural-Systemfunktionen (zum Beispiel `AVER`, `SUM`, `*TRIM`),

- in einem Array-Index-Ausdruck;

- als Parameter eines Function Call.

Wenn ein Function Call in einem `INPUT`-Statement benutzt wird, dann wird der Rückgabewert wie ein konstanter Wert behandelt. Dies führt zur automatischen Zuweisung des Attributs `AD=O`, damit dieses Feld schreibgeschützt, d.h. nur zur Ausgabe verfügbar gemacht wird.

## Syntax-Beschreibung

Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referenzierung erlaubt | Dynam. Definition
--- | --- | --- | --- | ---
`function-name` |  | S | A |  |  | A | U |  |  |  |  |  |  |  |  |  |  | ja | nein

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`function-name` | Function-Name: Als `function-name` können Sie angeben: entweder den Namen der aufzurufenden Function, so wie er im `DEFINE FUNCTION`-Statement referenziert wird, oder den Namen einer alphanumerischen Variablen, die den Namen der Function zur Laufzeit enthält. Diese Variable muss in einer Prototyp-Definition mit dem Schlüsselwort `VARIABLE` des `DEFINE PROTOTYPE`-Statements referenziert werden. Falls dieser Prototyp nicht die korrekten Parameter- und Ergbnisdefinitionen enthält, kann mit der `prototype-clause` ein anderer Prototyp zugewiesen werden.
`prototype-clause` | Prototype-Klausel: Siehe prototype-clause (PT=).
`intermediate-result-clause` | Intermediate Result-Klausel: Siehe intermediate-result-clause (IR=).
`parameter` | Parameter-Angabe: Siehe `parameter`.
`array-index-expression` | Array-Index-Notation: Wenn das vom Function Call zurückgegebene Ergebnis ein Array ist, muss eine Index-Notation vorgesehen werden, um die angeforderten Array-Ausprägungen zu adressieren. Weitere Informationen siehe Index-Notation in Benutzervariablen.

### prototype-clause (PT=)

`PT=` prototype-name

Um eine Function zur Kompilierungszeit auflösen zu können, benötigt Natural Parameterdefinitionen und das Ergebnis der Function. Wenn kein Prototyp mit dem `function-name`, den Parametern oder dem Ergebnis der Function übereinstimmt, können Sie mit der `prototype-clause` einen passenden Prototyp zuweisen. In diesem Fall wird stattdessen der referenzierte Prototyp benutzt, um die Parameter- und Function-Ergenis-Definitionen aufzulösen. Der in dem referenzierten Prototyp deklarierte `function-name` wird ignoriert.

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`prototype-name` | Prototyp-Name: Als `prototype-name` können Sie angeben: entweder den Namen des Prototyps, dessen Ergebnis- und Parameter-Layouts verwendet werden sollen, den Namen eines alphanumerischen Feldes, der als `function-name` in einem Function Call angegeben ist. Dieses Feld muss den Namen der Funktion enthalten, die zur Aufrufzeit aufgerufen werden soll. Bei dem Feldnamen darf kein Array-Index-Ausdruck angegeben werden.

### intermediate-result-clause (IR=)

`IR=` |  | format-length [/array-definition] |
[(array-definition)] `HANDLE OF OBJECT`
( |  | A U B |  | [/array-definition]) `DYNAMIC`

Diese Klausel kann benutzt werden, um die `format-length`/`array definition` des Ergebniswertes für einen Function Call anzugeben, falls weder das katalogisierte Objekt der Function noch eine Prototyp-Definition zur Verfügung stehen. Wenn für diesen Function Call ein Prototyp verfügbar ist oder wenn ein katalogisiertes Objekt der aufgerufenen Function existiert, wird das mit der `intermediate-result-clause` angegebene Ergebniswertformat auf Datenübertragungskompatibilität geprüft.

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`format-length` | Format/Länge-Definition: Das Format und die Länge des Feldes. Informationen zur Format/Längen-Definition bei Benutzervariablen siehe Format und Länge von Benutzervariablen.
`array-definition` | Array-Dimension-Definition: In der array-definition definieren Sie die untere und die obere Grenze der Dimensionen bei einer Array-Definition. Siehe Definition von Array-Dimensionen in der Statements-Dokumentation.
`HANDLE OF OBJECT` | Object-Handle: Wird in Verbindung mit NaturalX verwendet. Weitere Informationen siehe NaturalX im Leitfaden zur Programmierung.
`A`, `B` or `U` | Datenformat: Mögliche Formate: alphanumerisch, binär oder Unicode bei dynamischen Variablen.
`DYNAMIC` | Dynamische Variable: Ein Feld kann als `DYNAMIC` definiert werden. Weitere Informationen zur Verarbeitung dynamischer Variablen siehe Dynamische Variablen.

### parameter

| n `X` |
|  |  |  | `M` `O` `A` |  |  |
operand | `(``AD=` | `)`

Parameter werden entweder im `DEFINE DATA PARAMETER`-Statement bei der Definition der Function oder in einem `DEFINE PROTOTYPE`-Statement angegeben. Die semantischen und syntaktischen Regeln, die bei den Parametern einer Function gelten, sind die gleichen wie diejenigen, die im Parameterabschnitt von Subprogrammen beschrieben werden. Siehe Parameter in der Beschreibung des `CALLNAT`-Statement.

Wenn Sie mehrere Parameter angeben, müssen Sie diese voneinander abtrennen - entweder mit einem Komma oder mit dem Eingabebegrenzungszeichen, das mit dem Session-Parameter `ID` angegeben wird. Falls in der Liste der Parameter Zahlen vorkommen und wenn das Komma als Dezimalzeichen festgelegt ist (mit dem Session-Parameter `DC`), müssen Sie entweder das Komma mit einem zusätzlichen Leerzeichen vom Wert trennen oder das Eingabebegrenzungszeichen verwenden.

Beispiel mit Begrenzungszeichendefinition `ID=;` und `DC=,`: `WRITE F#ADD (<1 , 2>) F#ADD (<1;2>)`

Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referenzierung erlaubt | Dynam. Definition
--- | --- | --- | --- | ---
`operand` | C | S | A | G |  | A | N | P | I | F | B | D | T | L | C | G | O | ja | nein

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`nX` | Zu überspringende Parameter: Mit der `nX`-Notation können Sie angeben, dass die nächsten n Parameter übersprungen werden sollen (zum Beispiel: `1X`, um den nächsten Parameter zu überspringen oder `3X`, um die nächsten drei Parameter zu überspringen); das bedeutet, dass für die nächsten n Parameter keine Werte an die Function übergeben werden. Ein zu überspringender Parameter muss im `DEFINE DATA PARAMETER`-Statement der Function mit dem Schlüsselwort `OPTIONAL` definiert werden. `OPTIONAL` bedeutet, dass der Wert vom aufrufenden Objekt an einen so gekennzeichneten Parameter übergeben werden kann - jedoch nicht übergeben werden muss.
`AD=` | Attribut-Definition: If `operand` ist eine Variable, die Sie wie folgt markieren können:
`AD=O` | Nicht änderbar: Siehe Session-Parameter `AD=O`. Anmerkung Intern wird `AD=O` auf die gleiche Weise verarbeitet wie `BY VALUE` (siehe parameter-data-definition in the description of the `DEFINE DATA` statement).
`AD=M` | Änderbar: Siehe Session-Parameter `AD=M`. Dies ist die Standardeinstellung.
`AD=A` | Nur zur Eingabe: Siehe Session-Parameter `AD=A`.
Anmerkung Wenn `operand` eine Konstante ist, kann die Attribut-Definition `AD` nicht ausdrücklich angegeben werden. Bei Konstanten gilt immer `AD=O`.

## Beispiel

Im Beispiel-Programm `FUNCEX01` werden die Functions `F#ADDITION`, `F#CHAR`, `F#EVEN` und `F#TEXT` verwendet.

Alle Beispiele in diesem Abschnitt werden in der Natural-System-Library SYSEXPG als Quellcode-Objekte und als katalogisierte Objekte zur Verfügung gestellt.

- Aufrufendes Programm FUNCEX01:

- Aufgerufene Function F#ADDITION

- Aufgerufene Function F#CHAR

- Aufgerufene Function F#EVEN

- Aufgerufene Function F#TEXT

### Aufrufendes Programm FUNCEX01:

    ** Example 'FUNCEX01': Function call  (Program)
    ************************************************************************
    DEFINE DATA LOCAL
      1 #NUM  (I2) INIT <5>
      1 #A    (I2) INIT <1>
      1 #B    (I2) INIT <2>
      1 #C    (I2) INIT <3>
      1 #CHAR (A1) INIT <'A'>
    END-DEFINE
    *
    IF #NUM = F#ADDITION(<#A,#B,#C>)    /* Function with three parameters.
      WRITE 'Sum of #A,#B,#C' #NUM
    ELSE
      IF #NUM = F#ADDITION(<1X,#B,#C>)  /* Function with optional parameters.
        WRITE 'Sum of #B,#C' #NUM
      END-IF
    END-IF
    *
    DECIDE ON FIRST #CHAR
      VALUE F#CHAR (<>)(1)             /* Function with result array.
         WRITE 'Character A found'
      VALUE F#CHAR (<>)(2)
         WRITE 'Character B found'
      NONE
         IGNORE
    END-DECIDE
    *
    IF F#EVEN(<#B>)                    /* Function with logical result value.
      WRITE #B 'is an even number'
    END-IF
    *
    F#TEXT(<'Hello', '*'>)             /* Function used as a statement.
    *
    WRITE F#TEXT(<(IR=A12) 'Good'>)    /* Function with intermediate result.
    *
    END

#### Ausgabe des Programms `FUNCEX01`

    Sum of #B,#C      5
    Character A found
         2 is an even number
    *** Hello world ***
    Good morning

### Aufgerufene Function F#ADDITION

Die Function `F#ADDITION` ist in der Beispiel-Function `FUNCEX02` definiert.

    ** Example 'FUNCEX02': Function call  (Function)
    ************************************************************************
    DEFINE FUNCTION F#ADDITION
      RETURNS (I2)
      DEFINE DATA PARAMETER
        1 #PARM1 (I2) OPTIONAL
        1 #PARM2 (I2) OPTIONAL
        1 #PARM3 (I2) OPTIONAL
      END-DEFINE
      /*
      RESET F#ADDITION
      IF #PARM1 SPECIFIED
        F#ADDITION := F#ADDITION + #PARM1
      END-IF
      IF #PARM2 SPECIFIED
        F#ADDITION := F#ADDITION + #PARM2
      END-IF
      IF #PARM3 SPECIFIED
        F#ADDITION := F#ADDITION + #PARM3
      END-IF
      /*
    END-FUNCTION
    *
    END

### Aufgerufene Function F#CHAR

Die Function `F#CHAR` ist in der Beispiel-Function `FUNCEX03` definiert.

    ** Example 'FUNCEX03': Function call  (Function)
    ************************************************************************
    DEFINE FUNCTION F#CHAR
      RETURNS (A1/1:2)
      /*
      F#CHAR(1) := 'A'
      F#CHAR(2) := 'B'
      /*
    END-FUNCTION
    *
    END

### Aufgerufene Function F#EVEN

Die Function `F#EVEN` ist in der Beispiel-Function `FUNCEX04` definiert.

    ** Example 'FUNCEX04': Function call  (Function)
    ************************************************************************
    DEFINE FUNCTION F#EVEN
      RETURNS (L)
      DEFINE DATA
      PARAMETER
        1 #NUM  (N4) BY VALUE
      LOCAL
        1 #REST (I2)
      END-DEFINE
      /*
      DIVIDE 2 INTO #NUM REMAINDER #REST
      /*
      IF #REST = 0
        F#EVEN := TRUE
      ELSE
        F#EVEN := FALSE
      END-IF
      /*
    END-FUNCTION
    *
    END

### Aufgerufene Function F#TEXT

Die Function `F#TEXT` ist in der Beispiel-Function `FUNCEX05` definiert.

    ** Example 'FUNCEX05': Function call  (Function)
    ************************************************************************
    DEFINE FUNCTION F#TEXT
      RETURNS (A20) BY VALUE
      DEFINE DATA
      PARAMETER
        1 #TEXT1 (A5) BY VALUE
        1 #TEXT2 (A1) BY VALUE OPTIONAL
      LOCAL
        1 #FRAME (A3)
      END-DEFINE
      /*
      IF #TEXT2 SPECIFIED
        MOVE ALL #TEXT2 TO #FRAME
        /*
        COMPRESS #FRAME #TEXT1 'world' #FRAME INTO F#TEXT
        /*
        WRITE F#TEXT
      ELSE
        COMPRESS #TEXT1 'morning' INTO F#TEXT
        /*
      END-IF
      /*
    END-FUNCTION
    *
    END

## Function-Ergebnis

Entsprechend der Function-Definition kann ein Function Call ein einzelnes Ergebnisfeld zurückgeben. Dies kann ein Skalar-Wert sein oder ein Array-Feld, das in dem Statement, in dem der Function Call eingebettet ist, wie ein temporäres Feld verarbeitet wird. Ist das Ergebnis ein Array, dann muss unmittelbar nach dem Function Call ein `array-index-expression` folgen, mit dem die erforderlichen Ausprägungen adressiert werden.

Zum Beispiel, um auf die erste Ausprägung des zurückgegebenen Array zuzugreifen:

    #FCT(<#A,#B>)(1)

## Parameter- und Ergebnisangaben

Um einen Function Call zur Kompilierungszeit korrekt aufzulösen, benötigt der Kompiler die Format-, Längen- und Array-Struktur der Parameter und des Function-Ergebnisses. Die in dem Function Call angegebenen Parameter werden gegen die entsprechenden Definitionen in der Function geprüft um sicherzustellen, dass sie zueinander passen. Wird eine Function anstelle eines Operanden in einem Statement benutzt, muss das Function-Ergebnis hinsichtlich der Format-, Längen- und Array-Struktur mit dem Operanden übereinstimmen.

Sie haben drei Möglichkeiten, diese Informationen zur Verfügung zu stellen:

1. Sie können die Parameter- und Ergebnisangaben implizit aus dem katalogisierten Objekt (falls verfügbar) der aufgerufenen Funktion gewinnen, wenn zuvor kein `DEFINE PROTOTYPE`-Statement ausgeführt wurde.

   Dieses Verfahren erfordert den geringsten Programmieraufwand.

2. Sie können ein `DEFINE PROTOTYPE`-Statement benutzen. Ein `DEFINE PROTOTYPE`-Statement müssen Sie benutzen, wenn das katalogisierte Objekt der aufgerufenen Function nicht verfügbar ist oder wenn die Function zur Kompilierungszeit nicht bekannt, d.h., anstelle eines Function-Namens wird der Name einer alphanumerischen Variablen im Function Call angegeben.

3. Sie können eine explizite (`IR=`)-Klausel im Function Call angeben.

Bei den ersten beiden Möglichkeiten erfolgt eine vollständige Validierung der Format-, Längen- und Array-Struktur der Parameter und des Function-Ergebnisses.

- Zusätzliche Klauseln für den Function Call

- Validierung der Parameters und des Ergebnisses der Function

- Beispiel mit mehreren Definitionen in einem Function Call

### Zusätzliche Klauseln für den Function Call

Wenn weder ein `DEFINE PROTOTYPE`-Statement noch ein katalogisiertes Function-Objekt existiert, können Sie die folgenden Klauseln in Ihrem Function Call benutzen:

- Die Klausel (`IR=`) gibt die Format-, Längen- und Array-Struktur des Funktionsergebnisses an.

  Diese Klausel bestimmt, welche Format-, Längen- und Array-Struktur der Kompiler für das Ergebnisfeld (das Zwischenergebnis, so wie es von dem Statement benutzt wird, das den Function Call enthält) nehmen soll. Wenn für einen Function Call eine Prototyp-Definition zur Verfügung steht, dann setzt die Klausel (`IR=`) die Angaben in dem Prototyp außer Kraft.

  Die Klausel (`IR=`) erzwingt keine Parameterprüfungen.

- Die Klausel (`PT=`) benutzt einen zuvor definierten Prototyp, dessen Namen anders lautet als der Name der Function. Diese Klausel validiert die Parameter und das Ergebnis der Function mit Hilfe eines `DEFINE PROTOTYPE`-Statement mit dem referenzierten Namen.

  In dem folgenden Beispiel wird die Function `#MULT` aufgerufen, es gelten jedoch die Parameter- und Ergebnisangaben aus dem Prototyp, dessen Name `#ADD` ist:

      #I := #MULT(<(PT=#ADD) 2 , 3>)

### Validierung der Parameters und des Ergebnisses der Function

Zur Prüfung der Parameter wird die zuerst gefundene der nachfolgend aufgeführten Definitionen verwendet:

- die Prototyp-Definition, die in der `(PT=)`-Klausel referenziert wird;

- die Prototyp-Definition im `DEFINE PROTOTYPE`-Statement, deren Namen mit dem Namen der Function übereinstimmt, der im Function Call benutzt wird;

- die Parameterangaben im katalogisierten Function-Objekt, die mit dem `DEFINE FUNCTION`-Statement geliefert werden.

Falls keine dieser Optionen angegeben ist, wird keine Parameter-Validierung durchgeführt. Das gestattet es, im Function Call eine beliebige Anzahl Parameter mit beliebigem Layout zu mitliefern, ohne einen Syntaxfehler zu erhalten.

Zur Prüfung des Ergebnisses der Function wird die zuerst gefundene der nachfolgend aufgeführten Definitionen verwendet:

- die Definition, die in der (`IR=`)-Klausel zur Verfügung gestellt wird;

- die `RETURNS`-Definition im Pprototyp, die in der `(PT=)`-Klausel referenziert wird;

- die Prototyp-Definition im `DEFINE PROTOTYPE`-Statement, bei der der Prototyp-Namen mit dem Namen der Function übereinstimmt, der im Function Call benutzt wird;

- die Angabe des Function-Ergebnisses in dem katalogisierten Function-Objekt.

Falls keine der aufgeführten Definitionen angegeben ist, wird ein Syntaxfehler ausgegeben.

### Beispiel mit mehreren Definitionen in einem Function Call

Programm:

    ** Example 'FUNCBX01': Declare result value and parameters  (Program)
    ************************************************************************
    *
    DEFINE DATA LOCAL
      1 #PROTO-NAME (A20)
      1 #PARM1      (I4)
      1 #PARM2      (I4)
    END-DEFINE
    *
    DEFINE PROTOTYPE VARIABLE #PROTO-NAME
      RETURNS (I4)
      DEFINE DATA PARAMETER
        1 #P1 (I4) BY VALUE OPTIONAL
        1 #P2 (I4) BY VALUE
      END-DEFINE
    END-PROTOTYPE
    *
    #PROTO-NAME := 'F#MULTI'
    #PARM1      := 3
    #PARM2      := 5
    *
    WRITE #PROTO-NAME(<#PARM1, #PARM2>)
    WRITE #PROTO-NAME(<1X ,5>)
    *
    WRITE F#MULTI(<(PT=#PROTO-NAME) #PARM1,#PARM2>)
    *
    WRITE F#MULTI(<(IR=N20) #PARM1, #PARM2>)
    *
    END

Function `F#MULTI`:

    ** Example 'FUNCBX02': Declare result value and parameters  (Function)
    ************************************************************************
    DEFINE FUNCTION F#MULTI
      RETURNS #RESULT (I4) BY VALUE
      DEFINE DATA PARAMETER
        1 #FACTOR1 (I4) BY VALUE OPTIONAL
        1 #FACTOR2 (I4) BY VALUE
      END-DEFINE
      /*
      IF #FACTOR1 SPECIFIED
        #RESULT := #FACTOR1 * #FACTOR2
      ELSE
        #RESULT := #FACTOR2 * 10
      END-IF
      /*
    END-FUNCTION
    *
    END

## Reihenfolge bei der Auswertung von Functions in Statements

Alle Function Calls, die in einem Natural-Statement verwendet werden, werden ausgewertet, bevor mit der Ausführung des Statements begonnen wird. Sie werden in derselben Reihenfolge ausgeführt, in der sie im Statement erscheinen. Die Function-Ergebniswerte werden in temporären Feldern gespeichert, die später als Operanden bei der Statement-Ausführung verwendet werden.

Das Aufrufen einer Function, die änderbare Parameter hat, die wiederholt innerhalb desselben Statements benutzt werden, kann unterschiedliche Function-Ergebnisse verursachen, wie im folgenden Beispiel gezeigt wird:

### Beispiel:

Bevor die Ausführung des `COMPUTE`-Statement beginnt, hat die Variable `#I` den Wert `1`. Im ersten Schritt wird die Funktion `F#RETURN` ausgeführt. Dadurch ändert sich `#I` auf den Wert `2` und gibt den Wert `2` als das Ergebnis der Funktion zurück. Danach wird mit der `COMPUTE`-Operation begonnen, wobei die erhöhte Variable `#I (2)` und das temporäre Feld `(2)` auf die Summe von `4` addiert werden.

#### Programm:

    ** Example 'FUNCCX01': Parameter changed within function (Program)
    ************************************************************************
    DEFINE DATA LOCAL
      1 #I      (I2) INIT <1>
      1 #RESULT (I2)
    END-DEFINE
    *
    COMPUTE #RESULT := #I + F#RETURN(<#I>)  /* First evaluate function call,
                                            /* then execute the addition.
    *
    WRITE '#I     :' #I /
          '#RESULT:' #RESULT
    *
    END

#### Function:

    ** Example 'FUNCCX02': Parameter changed within function (Function)
    ************************************************************************
    DEFINE FUNCTION F#RETURN
      RETURNS #RESULT (I2) BY VALUE
      DEFINE DATA PARAMETER
        1 #PARM1 (I2) BY VALUE RESULT
      END-DEFINE
      /*
      #PARM1  := #PARM1 + 1       /* Increment parameter.
      #RESULT := #PARM1           /* Set result value.
      /*
    END-FUNCTION
    *
    END

#### Ausgabe des Programms `FUNCCX01`:

    #I     :      2
    #RESULT:      4

## Verwendung einer Function als Statement

Sie können einen Function Call kann auch anstelle eines Natural-Statements benutzen, d.h. ohne den Function Call in ein anderes Statement einzubetten. In diesem Fall braucht der Function Call keinen Ergebniswert zurückzuliefern; falls doch, wird der Ergebniswert ignoriert.

Um eine unerwünschte Verknüpfung zu dem vorangehenden Statement zu verhindern, muss ein Semikolon (`;`) gesetzt werden, um den Function Call ausdrücklich von diesem Statement zu trennen.

#### Beispiel:

Programm:

    ** Example 'FUNCDX01': Using a function as a statement (Program)
    ************************************************************************
    DEFINE DATA LOCAL
      1 #A (I4) INIT <1>
      1 #B (I4) INIT <2>
    END-DEFINE
    *
    *
    WRITE 'Write:' #A #B
    F#PRINT-ADD(< 2,3 >)     /* Function call belongs to operand list
                             /* immediately preceding it.
    *
    WRITE // '*************************' //
    *
    WRITE 'Write:' #A #B;    /* Semicolon separates operands and function.
    F#PRINT-ADD(< 2,3 >)     /* Function call does not belong to the
                             /* operand list.
    *
    END

Function:

    ** Example 'FUNCDX02': Using a function as a statement (Function)
    ************************************************************************
    DEFINE FUNCTION F#PRINT-ADD
      RETURNS (I4)
      DEFINE DATA PARAMETER
        1 #SUMMAND1 (I4) BY VALUE
        1 #SUMMAND2 (I4) BY VALUE
      END-DEFINE
      /*
      F#PRINT-ADD := #SUMMAND1 + #SUMMAND2    /* Result of function call.
      WRITE 'Function call:' F#PRINT-ADD
      /*
    END-FUNCTION
    *
    END

Ausgabe des Programms `FUNCDX01`:

    Function call:           5
    Write:           1           2           5

    *************************

    Write:           1           2
    Function call:           5

### On this page

- Verwendung
- Einschränkungen
- Syntax-Beschreibung
- Beispiel
- Function-Ergebnis
- Parameter- und Ergebnisangaben
- Reihenfolge bei der Auswertung von Functions in Statements
- Verwendung einer Function als Statement