DEFINE PROTOTYPE

DEFINE PROTOTYPE

../graphics/sbo1.gif

[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:

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

Verwandtes Statement: DEFINE FUNCTION


Funktion

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:

Syntax-Beschreibung

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

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