DEFINE PROTOTYPE

#### Search Results

Search

# DEFINE PROTOTYPE

`DEFINE PROTOTYPE` |  | [`FOR`] `VARIABLE` |  | prototype-name
|  | `UNKNOWN` [return-data-definition ] [parameter-definition] same-as-clause `USING FUNCTION` [`DEFINITION` [`OF`]] function-name |  |
`END-PROTOTYPE`

Dieses Dokument behandelt folgende Themen:

- Funktion DEFINE PROTOTYPE

- Syntax-Beschreibung DEFINE PROTOTYPE

- Beispiele DEFINE PROTOTYPE

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

Verwandtes Statement: `DEFINE FUNCTION`

## Funktion DEFINE PROTOTYPE

Das `DEFINE PROTOTYPE`-Statement dient dazu, die Eigenschaften für den Aufruf einer Function anzugeben:

- die Parameter, die an den Function Call übergeben werden sollen,

- der Ergebniswert, die vom Function Call zurückgegeben werden soll, und

- wie die Function aufgerufen wird: entweder mit dem Function-Namen, der im `DEFINE FUNCTION`-Statement definiert ist, oder mit einer alphanumerischen Variablen, die den Function-Namen enthält.

Diese Informationen dienen dazu, einen Function Call innerhalb eines Natural-Objekts zur Kompilierungszeit aufzulösen.

Ein `DEFINE PROTOTYPE`-Statement wird für einen Function Call nur dann benötigt, wenn Folgendes zutrifft:

- Der angegebene Function-Name ist eine alphanumerische Variable, die den Namen der zur Ausführungszeit aufzurufenden Function enthält.

- In dem Function Call ist keine `(IR=)`-Option angegeben, und ein katalogisiertes Objekt der aufgerufenen Funktion ist nicht verfügbar,

- Die im Function Call mitgegebenen Parameter sollen validiert werden, und das katalogisierte Objekt der aufgerufenen Funktion ist nicht verfügbar.

Wenn die Function von mehreren Objekten aufgerufen werden soll kann das `DEFINE PROTOTYPE`-Statement in ein Copycode-Objekt eingefügt werden.

Weitere Information finden Sie in folgenden Abschnitte im Leitfaden zur Programmierung:

- Natural-Objektyp Function

- Function Call

## Syntax-Beschreibung DEFINE PROTOTYPE

Syntax-Element | Beschreibung
--- | ---
`[VARIABLE]` `prototype-name` | Prototyp-Name: `prototype-name` ist Folgendes: entweder der Name des Prototyps, dessen Parameter- und Ergebnisfeld-Definitionen verwendet werden sollen. Dieser Name stimmt in der Regel mit dem `function-name` im `DEFINE FUNCTION`-Statement der referenzierten Function überein; oder der Name eines alphanumerischen Feldes, der als `function-name` in einem Function Call angegeben wird, wenn das Schlüsselwort `VARIABLE` angegeben ist. Dieses Feld muss den Namen der Function enthalten, die zur Ausführungszeit aufgerufen werden soll. Mit dem Feldnamen darf kein Array-Index-Ausdruck angegeben werden.
`UNKNOWN` | UNKNOWN-Option: Das Schlüsselwort `UNKNOWN` gibt an, dass das Function-Interface zurzeit nicht definiert ist. In diesem Fall wird das katalogisierte Objekt (falls verfügbar) nicht benutzt, um das Layout des Function-Ergebnisses und die Parameter-Beschreibung zu extrahieren. Wenn ein Function Call in ein Natural-Statement eingebettet ist, muss dass Ergebnis-Layout explizit mit einer `(IR=)`-Klausel angegeben werden. Außerdem werden in der Function enthaltene Parameter nicht geprüft.
`return-data-definition` | Siehe Rückgabedatendefinition weiter unten.
`parameter-definition` | Siehe Parameter-Definition weiter unten.
`same-as-clause` | Siehe SAME AS-Klausel weiter unten.
`USING FUNCTION [DEFINITION [OF]] function-name` | Siehe USING FUNCTION-Klausel weiter unten.
`END-PROTOTYPE` | Ende des DEFINE PROTOTYPE-Statement: Das für Natural reservierte Wort `END-PROTOTYPE` muss zum Beenden des `DEFINE PROTOTYPE`-Statements benutzt werden.

### Rückgabedatendefinition

(`return-data-definition`)

`RETURNS` [variable-name] |  | (format-length [/array-definition]) |
[(array-definition)] `HANDLE OF OBJECT`
( |  | `A` |  | [/array-definition]) | `DYNAMIC`
`U`
`B`

Mit dieser Klausel werden das Format und die Länge und, falls zutreffend, die Array-Struktur des Rückgabewerts festgelegt.

Wenn keine Festlegung der Rückgabedaten erfolgt, kann ein Function Call nur innerhalb eines Statements benutzt werden, wenn eine explizite `(IR=)`-Klausel verfügbar ist. Fehlt eine solche Klausel, kann die Function nur als ein Statement aufgerufen werden, aber nicht anstelle eines Operanden in einem Statement.

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`variable-name` | Name des Rückgabewerts: Die optionale Angabe bei `variable-name` hat hier keine Bedeutung. Sie ist nur vorhanden, um eine ähnliche Syntaxstruktur wie bei der Rückgabedatendefinition-Klausel des `DEFINE FUNCTION`-Statements zu haben.
`format-length` | Format-/Länge-Definition: Format und Länge des Ergebnisfeldes. Weitere Informationen siehe Format und Länge von Benutzervariablen im Leitfaden zur Programmierung.
`array-definition` | Definition der Array-Dimensionen: Falls das Ergebnisfeld der Function ein Array-Feld ist, legen Sie hier die untere und obere Grenze einer Dimension fest. Weitere Informationen siehe `DEFINE DATA`-Statement, Definition von Array-Dimensionen.
`HANDLE OF OBJECT` | Object-Handle: Wird bei NaturalX verwendet. Weitere Informationen siehe NaturalX im Leitfaden zur Programmierung.
`A`, `U` or `B` | Datentyp: Alphanumerisch (A), Unicode (U) oder binär (B) für ein numerisches Ergebnis.
`DYNAMIC` | Dynamische Variable: Das Function-Ergebnis kann als `DYNAMIC` definiert werden. Weitere Informationen siehe Dynamische Variablen im Leitfaden zur Programmierung.

### Parameter-Definition

(`parameter-definition`)

`DEFINE DATA` |  |  |  |  |
|  | `PARAMETER UNKNOWN` |  |  |  |  |
| `PARAMETER` |  | `USING` parameter-data-area |  |  |
parameter-data-definition `...` | `...`
`END-DEFINE` |  |  |  |  |

Mit dieser Klausel werden die Parameter festgelegt, die bei einem Function Call zur Verfügung gestellt werden. Das hier festgelegte Layout wird gegen die Parameter geprüft, welche in einem Function Call mitgegeben werden. Wird diese Klausel weggelassen, wird die Function als parameterfrei deklariert. In diesem Fall wird jeder Versuch, Parameter im Function Call mitzugeben, zurückgewiesen.

Die für die Namensgebung der Parameterfelder verwendeten Bezeichner haben keine Bedeutung. Sie sind hier nur vorhanden, um eine ähnliche Syntaxstruktur wie bei der `DEFINE DATA PARAMETER`-Syntax zu haben.

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`PARAMETER UNKNOWN` | UNKNOWN-Option: Wird diese Option benutzt, dann wird kein Parameter angegeben. Dadurch wird die Parameterprüfung im Function Call ausgeschaltet. Das hat zur Folge, dass eine beliebige Anzahl von Parametern in der Funktion akzeptiert wird.
`USING parameter-data-area` | PDA-Name: Name der Parameter Data Area, welche Datenelemente enthält, die als Parameter in einem Function Call verwendet werden. Siehe auch Definition von Parameter Data in der `DEFINE DATA`-Statement-Beschreibung.
`parameter-data-definition` | Parameterdatendefinition: Anstatt eine Parameter Data Area zu definieren, können Parameter auch direkt in einem Function Call definiert werden. Siehe auch Direkte Definition von Parameterdaten in der `DEFINE DATA`-Statement-Beschreibung.
`END-DEFINE` | Ende der Klausel: Das für Natural reservierte Wort `END-DEFINE` muss zum Beenden der `parameter-definition`-Klausel benutzt werden.

### SAME AS-Klausel

(`same-as-clause`)

`SAME AS` [`PROTOTYPE`] | prototype-name

Durch Angabe dieser Klausel können die Parameter- und Ergebnisfeld-Definitionen eines anderes Prototyps verwendet werden, welcher zuvor im selben Natural-Objekt definiert worden ist.

## Beispiele DEFINE PROTOTYPE

- Beispiel 1 - DEFINE PROTOTYPE mit einem definierten Function-Namen

- Beispiel 2 - DEFINE PROTOTYPE mit einem variablen Function-Namen

### Beispiel 1 - DEFINE PROTOTYPE mit einem definierten Function-Namen

Dies ist eine Prototyp-Definition einer Funktion mit dem Namen `F#FACTOR`, wobei der `prototype-name` dem `function-name` entspricht, der im referenzierten `DEFINE FUNCTION`-Statement angegeben ist. Das von der Function zurückgelieferte Ergebnis hat das Format (I2/1:3), und es ist nur ein einzelner Parameter nötig, welcher das Format (I2) hat.

    ** Example 'DPTEX1': DEFINE PROTOTYPE and function call
    ************************************************************************
    DEFINE DATA LOCAL
      1 #NUM (I2)
    END-DEFINE
    *
    DEFINE PROTOTYPE F#FACTOR
      RETURNS (I2/1:3)
      DEFINE DATA PARAMETER
        1 #VALUE (I2)
      END-DEFINE
    END-PROTOTYPE
    *
    #NUM := 3
    *
    WRITE 'Function call:' F#FACTOR(<#NUM>)(*)
    *
    END

Die Function `F#FACTOR` ist definiert in der Beispiel-Function `DFUEX2` in der Library `SYSEXSYN`. Siehe Beispiele in der `DEFINE FUNCTION`-Statement-Beschreibung.

#### Ausgabe des Programms `DPTEX1`:

    Function call:      3      6      9

### Beispiel 2 - DEFINE PROTOTYPE mit einem variablen Function-Namen

Wegen des Schlüsselworts `VARIABLE` gibt dieser Prototyp einen Function Call, bei dem der referenzierte Prototyp-Name eine alphanumerische Variable ist, die den Namen der Function zum Zeitpunkt der Ausführung enthält.

    ** Example 'DPTEX2': DEFINE PROTOTYPE and function call
    ************************************************************************
    DEFINE DATA LOCAL
      1 #NAME (A20)
      1 #TEXT (A10)
    END-DEFINE
    *
    DEFINE PROTOTYPE VARIABLE #NAME
      RETURNS #RETURN (A1)
      DEFINE DATA PARAMETER
        1 #IN (A10)
      END-DEFINE
    END-PROTOTYPE
    *
    #NAME := 'F#FIRST-CHAR'
    #TEXT := 'ABCDEFGHIJ'
    *
    WRITE 'First character:' #NAME(<#TEXT>)
    *
    END

Die Funktion `F#FIRST-CHAR` ist definiert in der Beispiel-Function `DFUEX1` in der Library `SYSEXSYN`. Siehe Beispiele in der `DEFINE FUNCTION`-Statement-Beschreibung.

#### Ausgabe des Programms `DPTEX2`:

    First character: A

### On this page

- Funktion DEFINE PROTOTYPE
- Syntax-Beschreibung DEFINE PROTOTYPE
- Beispiele DEFINE PROTOTYPE