CALLNAT

#### Search Results

Search

# CALLNAT

|  |  |  |  |  | `M` |  |  |
`CALLNAT` operand1 | [`USING`] | operand2 | (`AD`= | `O` | )
|  | `A` |
|  | n `X` |  |  |  |  |  |

Dieses Dokument behandelt folgende Themen:

- Funktion CALLNAT

- Syntax-Beschreibung CALLNAT

- Übertragung von Parametern mit dynamischen Variablen

- Beispiele CALLNAT

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

Verwandte Statements: `CALL` | `CALL FILE` | `CALL LOOP` | `DEFINE SUBROUTINE` | `ESCAPE` | `FETCH` | `PERFORM`

Gehört zur Funktionsgruppe: Aufrufen von Programmen und Subprogrammen

## Funktion CALLNAT

Das Statement `CALLNAT` dient dazu, ein Natural-Subprogramm zur Ausführung aufzurufen. Ein Natural-Subprogramm kann nur über ein `CALLNAT`-Statement aufgerufen werden; es kann nicht selbständig ausgeführt werden.

Wenn das `CALLNAT`-Statement ausgeführt wird, wird die Ausführung des aufrufenden Objekts (d.h. des Objekts, das das `CALLNAT`-Statement enthält) unterbrochen und das aufgerufene Subprogramm ausgeführt. Die Ausführung des Subprogramms dauert an, bis entweder sein `END`-Statement erreicht ist oder die Verarbeitung des Subprogramms durch die Ausführung eines `ESCAPE ROUTINE`-Statements gestoppt wird. In beiden Fällen wird dann die Verarbeitung des aufrufenden Objekts mit dem nächsten Statement nach dem `CALLNAT`-Statement fortgesetzt.

Anmerkungen:

1. Ein Subprogramm kann wiederum andere Subprogramme aufrufen.
2. Ein Subprogramm hat keinen Zugriff auf die von dem aufrufenden Objekt benutzte Global Data Area. Wenn ein Subprogramm wiederum eine Subroutine oder Helproutine aufruft, kann es seine eigene Global Data Area erstellen, und diese zusammen mit der Subroutine/Helproutine gemeinsam benutzen.

## Syntax-Beschreibung CALLNAT

Operanden-Definitionstabelle:

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

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`operand1` | Subprogramm-Name: Als operand1 geben Sie den Namen des Subprogramms an, das aufgerufen werden soll. Dieser kann entweder als 1 bis 8 Zeichen lange Konstante angegeben werden oder — falls je nach Programmlogik unterschiedliche Subprogramme aufgerufen werden sollen — als alphanumerische Variable mit Länge 1 bis 8. Die Groß-/Kleinschreibung des Namens wird nicht verändert. Der Name des Subprogramms darf ein Und-Zeichen (&) enthalten; zur Ausführungszeit wird dieses Zeichen durch den aus einem Zeichen bestehenden Code ersetzt, der dem aktuellen Wert der Systemvariablen `*LANGUAGE` entspricht. Dadurch ist es beispielsweise möglich, je nachdem in welcher Sprache eine Eingabe gemacht wird, zur Verarbeitung der Eingabe unterschiedliche Subprogramme aufzurufen.
`operand2` | Parameter: Werden Parameter an das Subprogramm übergeben, muss die Struktur der Parameterliste in einem `DEFINE DATA PARAMETER`-Statement definiert werden. Die mit dem `CALLNAT`-Statement angegebenen Parameter sind die einzigen Daten, die dem Subprogramm vom aufrufenden Objekt zur Verfügung stehen. Standardmäßig erfolgt die Übergabe der Parameter durch Referenzierung ("By Reference"), d.h. die Daten werden über Adress-Parameter übergeben, die Parameterwerte selbst werden nicht übertragen. Es besteht aber auch die Möglichkeit, die Parameterwerte selbst zu übergeben. Hierzu definieren Sie die betreffenden Felder im `DEFINE DATA PARAMETER`-Statement des Subprogramms mit der Option `BY VALUE` bzw. `BY VALUE RESULT` (siehe parameter-data-definition in der Beschreibung des `DEFINE DATA`-Statements). Für die Parameterübergabe durch Referenzierung ("By Reference") gilt: Reihenfolge, Format und Länge der Parameter im aufrufenden Objekt müssen genau den Angaben im `DEFINE DATA PARAMETER`- Statement des Subprogramms entsprechen. Die Namen der Variablen im aufrufenden Objekt und im aufgerufenen Subprogramm können unterschiedlich sein. Für die Übergabe der Parameterwerte selbst ("By Value") gilt: die Reihenfolge der Parameter im aufrufenden Objekt muss der Reihenfolge im `DEFINE DATA PARAMETER`-Statement des Subprogramms entsprechen. Formate und Längen der Variablen im aufrufenden Objekt und im Subprogramm können unterschiedlich sein, müssen aber datenübertragungskompatibel sein (vgl. entsprechende Tabelle im Abschnitt Regeln für arithmetische Operationen, Datenübertragung im Leitfaden zur Programmierung. Die Namen der Variablen im aufrufenden Objekt und im aufgerufenen Subprogramm können unterschiedlich sein. Um Parameterwerte, die im Subprogramm verändert wurden, an das aufrufende Objekt zurückgeben zu können, müssen Sie die betreffenden Felder mit `BY VALUE RESULT` definieren. Mit `BY VALUE` (ohne `RESULT`) ist es nicht möglich, veränderte Parameterwerte an das aufrufende Objekt zurückzugeben (unabhängig von der `AD`-Parameter-Angabe; vgl. unten). Anmerkung Intern wird bei `BY VALUE` eine Kopie der Parameterwerte erzeugt. Das Subprogramm greift auf diese Kopie zu und kann sie modifizieren, was aber keinen Einfluss auf die Originalparameterwerte im aufrufenden Objekt hat. Bei `BY VALUE RESULT` wird ebenfalls eine Kopie erzeugt, aber nach Beendigung des Subprogramms überschreiben die (modifizierten) Werte der Kopie die Originalparameterwerte. Für beide Arten der Parameterübergabe sind folgende Punkte zu beachten: Wenn als operand2 eine Gruppe angegeben wird, werden die einzelnen in der Gruppe enthaltenen Felder an das Subprogramm übergeben; d.h. für jedes dieser Felder muss in der Parameter Data Area des Subprogramms ein entsprechendes Feld definiert werden. Eine Gruppe darf in der Parameter Data Area eines Subprogramms nur innerhalb eines `REDEFINE`-Blocks redefiniert werden. Bei der Übergabe eines Arrays muss die Anzahl seiner Dimensionen und Ausprägungen in der Parameter Data Area des Subprogramms denen in der `CALLNAT`-Parameterliste entsprechen. Anmerkung Wenn mehrere Ausprägungen eines Arrays, das als Teil einer indizierten Gruppe definiert ist, mit dem `CALLNAT`-Statement übergeben werden, dürfen die entsprechenden Felder in der Parameter Data Area des Subprogramms nicht redefiniert werden, da sonst die falschen Adressen übergeben werden. Wenn die Option `PCHECK` des Systemkommandos `COMPOPT` auf `ON` gesetzt ist, überprüft der Compiler Anzahl, Format, Länge und Array-Indexgrenzen der Parameter, die in einem `CALLNAT`-Statement angegeben sind. Die Funktion `OPTIONAL` des `DEFINE DATA PARAMETER`-Statements wird bei der Parameter-Prüfung mit berücksichtigt.
`AD=` | Attribut-Definition: Wenn operand2 eine Variable ist, können Sie sie wie folgt kennzeichnen:
AD=O | Nicht modifizierbar, siehe Session-Parameter `AD=O`. Anmerkung Intern wird `AD=O` genauso verarbeitet wie `BY VALUE` (siehe parameter-data-definition in der Beschreibung des `DEFINE DATA`-Statements).
AD=M | Modifizierbar, siehe Session-Parameter `AD=M`. Dies ist die Standardeinstellung.
AD=A | Nur für Eingabe, siehe Session-Parameter `AD=A`.
Wenn operand2 eine Konstante ist, kann der Session-Parameter `AD` nicht explizit angegeben werden. Für Konstanten gilt immer `AD=O`.
`nX` | Mit der Notation `nX` können Sie angeben, dass die nächsten n Parameter übersprungen werden sollen (z.B. `1X`, um den nächsten Parameter zu überspringen, oder `3X`, um die nächsten drei Parameter zu überspringen); dies bedeutet, dass für die nächsten n Parameter keine Werte an das Subprogramm übergeben werden. Der mögliche Wertebereich für n ist `1 − 4096`. Ein zu überspringender Parameter muss mit dem Schlüsselwort `OPTIONAL` im `DEFINE DATA PARAMETER`-Statement des Subprogramms definiert werden. `OPTIONAL` bedeutet, dass ein Wert vom aufrufenden Objekt an solch einen Parameter übergeben werden kann, aber nicht unbedingt übergeben werden muss.

## Übertragung von Parametern mit dynamischen Variablen

Dynamische Variablen können als Parameter an ein aufgerufenes Programmobjekt (`CALLNAT`, `PERFORM`) übergeben werden.

Eine Übergabe durch Referenzierung ("Call By Reference") ist möglich, weil dynamische Variablen einen zusammenhängenden Wertebereich darstellen.

Bei einer Übergabe der Parameterwerte selbst ("Call By Value") wird die Variablen-Definition des Aufrufenden als Ausgangsoperand und die Parameter-Definition als Zieloperand zugewiesen. Ein "Call By Value Result "bewirkt des weiteren eine Umkehrung der Zuordnung. Bei "Call By Reference" müssen beide Definitionen `DYNAMIC` sein. Wenn nur eine von ihnen `DYNAMIC` ist, wird ein Laufzeitfehler hervorgerufen. Bei "Call By Value (Result)" sind alle Kombinationen möglich.

Die folgende Tabelle veranschaulicht die gültigen Kombinationen statisch und dynamisch definierter Variablen des Aufrufenden und statisch und dynamisch definierter Parameter hinsichtlich der Übertragung von Parametern.

### Call By Reference

operand2 vom Aufrufenden | Parameter-Definition
--- | ---
Statisch | Dynamisch
Statisch | ja | nein
Dynamisch | nein | ja

Die Formate der dynamischen Variablen A oder B müssen miteinander übereinstimmen.

### Call by Value (Result)

operand2 vom Aufrufenden | Parameter-Definition
--- | ---
Statisch | Dynamisch
Statisch | ja | ja
Dynamisch | ja | ja

Anmerkung
Bei statischen/dynamischen oder dynamischen/statischen Definitionen kann es vorkommen, dass ein Wert nach den Datenübertragungsregeln der entsprechenden Zuweisungen abgeschnitten wird.

## Beispiele CALLNAT

- Beispiel 1

- Beispiel 2

### Beispiel 1

Aufrufendes Programm:

    ** Example 'CNTEX1': CALLNAT
    ************************************************************************
    DEFINE DATA LOCAL
    1 #FIELD1 (N6)
    1 #FIELD2 (A20)
    1 #FIELD3 (A10)
    END-DEFINE
    *
    CALLNAT 'CNTEX1N' #FIELD1 (AD=M) #FIELD2 (AD=O) #FIELD3 'P4 TEXT'
    *
    WRITE '=' #FIELD1 '=' #FIELD2 '=' #FIELD3
    *
    END

Aufgerufenes Subprogramm `CNTEX1N`:

    ** Example 'CNTEX1N': CALLNAT  (called by CNTEX1)
    ************************************************************************
    DEFINE DATA PARAMETER
    1 #FIELDA (N6)
    1 #FIELDB (A20)
    1 #FIELDC (A10)
    1 #FIELDD (A7)
    END-DEFINE
    *
    *
    #FIELDA := 4711
    *
    #FIELDB := 'HALLO'
    *
    #FIELDC := 'ABC'
    *
    WRITE '=' #FIELDA '=' #FIELDB '=' #FIELDC '=' #FIELDD
    *
    END

### Beispiel 2

Aufrufendes Programm:

    ** Example 'CNTEX2': CALLNAT
    ************************************************************************
    DEFINE DATA LOCAL
    1 #ARRAY1  (N4/1:10,1:10)
    1 #NUM     (N2)
    END-DEFINE
    *
    *
    CALLNAT 'CNTEX2N' #ARRAY1 (2:5,*)
    *
    FOR #NUM 1 TO 10
      WRITE #NUM #ARRAY1(#NUM,1:10)
    END-FOR
    *
    END

Aufgerufenes Subprogramm `CNTEX2N`:

    ** Example 'CNTEX2N': CALLNAT  (called by CNTEX2)
    ************************************************************************
    DEFINE DATA
    PARAMETER
    1 #ARRAY (N4/1:4,1:10)
    LOCAL
    1 I      (I2)
    END-DEFINE
    *
    *
    FOR I 1 10
      #ARRAY(1,I) := I
      #ARRAY(2,I) := 100 + I
      #ARRAY(3,I) := 200 + I
      #ARRAY(4,I) := 300 + I
    END-FOR
    *
    END

### On this page

- Funktion CALLNAT
- Syntax-Beschreibung CALLNAT
- Übertragung von Parametern mit dynamischen Variablen
- Beispiele CALLNAT