FUNKTIONEN
Beschreibung
Ab Version 2.00:
Funktionen:
Eine Funktion wird GLOBAL oder LOCAL definiert.
Eine GLOBALe Funktion wird nach Beendigung des Programms, das die GLOBALe Funktion definiert hat nicht aus dem Speicher gelöscht, und steht somit auch nachfolgenden Programmen zum Aufruf zur Verfügung.
GLOBALe Funktionen haben keinen Zugriff auf Variablen/Felder die zu einem Dokument oder einer Gruppe gehören, die nicht innerhalb dieser GLOBALen Funktion geöffnet bzw. eröffnet wurde.
(Dies ist auch dann nicht möglich, wenn der GLOABLen Funktion der NOTEHANDLE oder die VARGROUP übergeben wird.)
Eine Ausnahme bildet die VARGROUP GLOBAL, Variablen dieser Gruppe sind addressierbar.
Wird eine Variable der VARGROUP GLOBAL in einer GLOBALen Funktion direkt angesprochen, so darf diese Variable nicht mit DELVAR, oder ähnlich physikalisch, zwischen dem compilieren der GLOBALen Funktion und deren Aufruf gelöscht werden.
(Eine sichere und erlaubte Methode ist die @Funktionen @GetVar und @SetVar zu benutzen um auf solche Variablen zuzugreifen. Gelöschte Variablen führen natürlich (adressiert mit @GetVar/@SetVar) zu ERROR Werten oder zu PV Inhalten.)
Mögliche Folgen einer direkten Adressierung von GLOBALen Variablen in GLOBALen DEFFN Funktionen sind:
Serverabsturz.
Überschreiben anderer Variablen.
Statt der Adressierten Variable kommt im Programm-Lauf der Inhalt einer anderen Variable.
Dies trifft auch für direkt, per VSTACKPATH, adressierte Variablen zu.
Die Namen der Augenblicklich definierten GLOBALen Funktionen können mit der @Funktion @GetDEFFNGlobal ermittelt werden.
LOCALe Funktionen können auf alle Variablen zugreifen, die im Programm oder in anderen LOCALen Funktionen benutzt werden und einer Gruppe oder einem Dokument zugeordnet sind.
LOCALe Variablen vom Programm oder von Funktionen sind generell nur der jeweiligen Funktion oder dem Programm bekannt.
Eine Funktion kann nur definiert werden, wenn nicht schon eine Funktion gleichen Namens vorhanden ist.
Ein Funktions-Name muß eindeutig sein.
Es ist aber möglich eine GLOBALe Funktion und eine LOCALe Funtkion gleichen Namens zu definieren.
Parameter-Übergabe:
Ein Parameter wird einer Funktion übergeben, wie einer @Funktion.
Hierbei muß die Reihenfolge der Parameter beim Aufruf und bei der Definition der Funktion beachtet werden.
Die Namensgebung muß nicht identisch sein.
Reine Input-Parameter können auch Ausdrücke sein.
Ein Return-Parameter muß eine echte Variable sein (also keine Konstante und kein Ausdruck erlaubt).
Einem Return Parameter wird beim Aufruf ein kaufmännisches Und & und bei der Definition ein Stern * vorangestellt.
Löschen einer Funktion:
GLOBALe Funktionen können mit DELFN wieder gelöscht werden.
Wird eine GLOBALe Funktion nach dem Löschen von einem CALL oder CALLFAST aufgerufen, der vor der Löschung compiliert wurde, führt dies zum Absturz.
Besteht die Möglichkeit hierfür sollte statt dessen ein CALLSAVE verwandt werden.
Aufruf von Funktionen:
Für rekursive Funktionen sollte entweder ein CALL oder ein CALLSAVE verwandt werden, da ein CALLFAST die LOCALen Variablen der Funktion nicht puffert.
Ein CALL (egal welchen Typs) auf eine LOCALe Funktion muß immer schon beim compilieren linkbar sein, das heißt eine LOCALe Funktion muß im Programm das diese LOCALe Funktion aufruft definiert sein.
Ein CALL (egal welchen Typs) auf eine GLOBALe Funktion muß nicht schon beim compilieren linkbar sein, das heißt eine GLOBALe Funktion kann auch erst durch ein späteres Programm definiert werden oder wurde schon vorher definiert.
Ein einmal gelinkter CALL oder CALLFAST ist jedoch endgültig, ein nachträgliches löschen der aufzurufenden Funktion führt dann bei deren Aufruf zum Absturz, wenn die Möglichkeit für diesen Fall besteht muß ein CALLSAVE verwendet werden.
Syntax GLOBAL:
DEFFN:Name[GLOBAL](P1;P2;*P3)
{
}
Es wird eine GLOBALe Funktion Name definiert mit den Input-Parametern P1 und P2 und dem Return-Parameter P3.
Die Parameter P1,P2 und P3 können wie normale LOCALe Parameter behandelt werden.
DELFN:Name[GLOBAL]();
Es wird die GLOBALe Funktion Name physikalisch aus dem Speicher gelöscht.
CALL:Name[GLOBAL](P1;P2;&P3);
CALLFAST:Name[GLOBAL](P1;P2;&P3);
CALLSAVE:Name[GLOBAL](P1;P2;&P3);
Es wird die GLOBALe Funktion Name aufgerufen.
Für P1 und P2 können auch andere Variable Namen oder Konstanten oder Ausdrücke verwendet werden als in der Definition der Funktion (er wurde hier nur gleich gewählt um den Zusammenhang der Positionen der Parameter zu verdeutlichen).
Für P3 kann auch ein anderer Variable Name verwendet werden als in der Definition der Funktion (er wurde hier nur gleich gewählt um den Zusammenhang der Positionen der Parameter zu verdeutlichen).
Syntax LOCAL:
DEFFN:Name(P1;P2;*P3)
{
}
Es wird eine LOCALe Funktion Name definiert mit den Input-Parametern P1 und P2 und dem Return-Parameter P3.
Die Parameter P1,P2 und P3 können wie normale LOCALe Parameter behandelt werden.
CALL:Name(P1;P2;&P3);
CALLFAST:Name(P1;P2;&P3);
CALLSAVE:Name(P1;P2;&P3);
Es wird die LOCALe Funktion Name aufgerufen.
Für P1 und P2 können auch andere Variable Namen oder Konstanten oder Ausdrücke verwendet werden als in der Definition der Funktion (er wurde hier nur gleich gewählt um den Zusammenhang der Positionen der Parameter zu verdeutlichen).
Für P3 kann auch ein anderer Variable Name verwendet werden als in der Definition der Funktion (er wurde hier nur gleich gewählt um den Zusammenhang der Positionen der Parameter zu verdeutlichen).
Beispiel Programm (PRC) für GLOBALe Funktionen:
@LogReport("Derzeit definierte [GLOBAL] Funktionen:");
@LogReport(@GetDEFFNGlobal);
Test[VARGRP1]:="Vargroup Test";
CALL:Test1[GLOBAL]("Hallo Input Parameter";&Back);
@LogReport(Back);
CALLFAST:Test1[GLOBAL](100+10*3;&Ret);
@LogReport(Ret);
Tralala:="Tralala";
CALLSAVE:Test1[GLOBAL](Tralala;Hupfdidupf);
@LogReport(Hupfdidupf);
CALL:Test2[GLOBAL]("Text1";1234;&R1;&R2);
@LogReport(R1);
@LogReport(R2);
CALLFAST:Test2[GLOBAL]("Text"+"2 ";@Sqrt(100);&R1;&R2);
@LogReport(R1);
@LogReport(R2);
I1:="Input Para 1";
I2:=6666;
CALLSAVE:Test2[GLOBAL](I1;I2;&R1;&R2);
@LogReport(R1);
@LogReport(R2);
DELFN:Test1[GLOBAL]();
DEFFN:Test1[GLOBAL](Input;*Return)
{
@LogReport("Test1[GLOABL] Funktion Start");
@LogReport(Test[VARGRP1]);
@LogReport(Input);
Return:="Return Text";
@LogReport("Test1[GLOABL] Funktion End");
}
DELFN:Test2[GLOBAL]();
DEFFN:Test2[GLOBAL](Text;Zahl;*Ret1;*Ret2)
{
@LogReport("Test2[GLOABL] Funktion Start");
@LogReport(Test[VARGRP1]);
@LogReport(Text);
@LogReport(Zahl);
Ret1:=Text+@Text(Zahl);
Ret2:=Zahl*2;
@LogReport("Test2[GLOABL] Funktion End");
}
Beispiel Programm (PRC) für LOCALe Funktionen:
Test[VARGRP1]:="Vargroup Test";
CALL:Test1("Hallo Input Parameter";&Back);
@LogReport(Back);
CALLFAST:Test1(100+10*3;&Ret);
@LogReport(Ret);
Tralala:="Tralala";
CALLSAVE:Test1(Tralala;Hupfdidupf);
@LogReport(Hupfdidupf);
CALL:Test2("Text1";1234;&R1;&R2);
@LogReport(R1);
@LogReport(R2);
CALLFAST:Test2("Text"+"2 ";@Sqrt(100);&R1;&R2);
@LogReport(R1);
@LogReport(R2);
I1:="Input Para 1";
I2:=6666;
CALLSAVE:Test2(I1;I2;&R1;&R2);
@LogReport(R1);
@LogReport(R2);
DEFFN:Test1(Input;*Return)
{
@LogReport("Test1 Funktion Start");
@LogReport(Test[VARGRP1]);
@LogReport(Input);
Return:="Return Text";
@LogReport("Test1 Funktion End");
}
DEFFN:Test2(Text;Zahl;*Ret1;*Ret2)
{
@LogReport("Test2 Funktion Start");
@LogReport(Test[VARGRP1]);
@LogReport(Text);
@LogReport(Zahl);
Ret1:=Text+@Text(Zahl);
Ret2:=Zahl*2;
@LogReport("Test2 Funktion End");
}