Funktion Mit der Process-Anweisung können Sie ein Script aus einem anderen Script oder einem InputScript heraus aufrufen.

Dadurch können wiederverwendbare Funktionen implementiert, separat ausgetestet und in anderen Scripten verwendet werden.
Beispiel Process address = customeraddress "&V[kunnr]"

Die  Scriptdatei "process_customeraddress.txt" wird geladen und ausgeführt. Der Rückgabewert wird in die Variable V[address] gestellt.

Format 1 Process funcname par1 par2 par2 ...

Das Script "process_funcname.txt" wird geladen und ausgeführt. Die angegebenen Parameter par1, par2,... können jeweils entweder Strings sein, z.B. "X" oder "&V[kunnr]", oder Variablen z.B. V[name1], V[name2]. Details dazu im Abschnitt "Parameterübergabe".

Format 2 Process varname = funcname par1 par2 par2

Zusätzlich wird der in dem aufgerufenen Script mit  Return zurückgegebene Wert in die Variable V[varname] gestellt.

Name der Scriptdatei An den bei Process angegebenen Namen, z.B. "customeraddress", wird ein ".txt" ergänzt sowie "process_" vorangestellt, im Beispiel also "process_customeraddress.txt". Dieses Script wird dann gemäß den gleichen Regeln wie bei anderen Scriptdateien in den im GuiXT Profile hinterlegten Scriptvererzeichnissen gesucht.
Lokaler Namensraum In dem aufgerufenen Script sind alle Variablen V[xxx] lokal definiert; die Variablen aus dem Namesraum des aufrufenden Scripts sind nicht direkt ansprechbar. Mit Verlassen des aufgerufenen Scripts werden alle lokal benutzten Variablen freigegeben.

Auch stukturierte Variablen, Tabellenvariablen und Langtexte text[xxx] sind nur während der Verarbeitung des aufgerufenen Scripts angelegt.

Ausnahme:
Variablen, die mit einem Unterstrich beginnen, z.B. V[_language], werden immer dem globalen Kontext entnommen, sodass alle GuiXT Systemfelder ansprechbar bleiben.

Parameterübergabe In dem aufgerufenen Script werden die möglichen Parameter mit dem Schlüsselwort Parameter definiert, zum Beispiel:
 

Parameter ordernumber
Parameter schedule_lines   "N"

Die Parameter sind ebenfalls lokale Variable, die mit V[ordernumber], V[schedule_lines] angesprochen werden können. Die Zuordnung aus dem Aufruf erfolgt über die Position des Parameters. Nicht in dem Aufruf angegebene Parameter erhalten den angegebenen Defaultwert als Initialwert.

Beispiel:

Set V[vbeln] "0000001234"
Process
myorder = read_customerorder "&V[vbeln]"

Bei Start des aufgerufenen Scripts hat V[ordernumber] den Wert "0000001234" und V[schedule_lines] den Wert "N".
Input/Output Parameter Werden Variablen in dem Aufruf im Format V[xxx] mitgegeben, dann werden sie bei Rückkehr aus dem Script mit dem aktuellen Wert des Parameters belegt.

Beispiel:
 

Parameter serialnumber

Set V[serialnumber] "78923804-89"
Return

Aufruf:

Clear
V[sernr]
Process get_serialnumber V[sernr]

Danach hat V[sernr] den Wert "78923804-89".

Dagegen bliebe bei dem Aufruf

Clear V[sernr]
Process get_serialnumber "&V[sernr]"

die Variable V[sernr] leer, da zwar ihr aktueller Wert an den Parameter V[serialnumber] übergeben wird, aber keine Rückübertragung von V[serialnumber] nach V[sernr] erfolgt.
Rückgabewert Mit dem Format

Process varname = funcname par1 par2 par2

wird der bei  Return "xxx" angegebene Wert "xxx" in die Variable V[varname] gestellt. Falls bei Return kein Wert angegeben ist, wird V[varname] mit dem leeren String "" belegt.
Struktur- und Tabellenvariablen Im Format V[xxx] für die aktuellen Parameter können Struktur- und Tabellenvariablen übergeben werden. Sie werden immer als Referenz übergeben, d.h. Änderungen der Inhalte werden nicht erst bei Rückkehr aus dem aufgerufenen Script zurückgestellt, sondern sofort in den Struktur- oder Tabellenvariablen ausgeführt.

Das aufgerufene Script kann dann ohne eigenes CreateStructure oder CreateTable mit der Struktur oder Tabelle arbeiten, also zum Beispiel mit  AppendRow Tabellenzeilen hinzufügen.


Eine weitere nützliche Möglichkeit ist, Variablen ohne Struktur zu übergeben und diese im aufgerufenen Script mit CreateStructure oder CreateTable in Struktur- oder Tabellenvariablen verwandeln. Die Variablen sind dann mit der angegebenen Struktur nach Rückkehr aus dem Aufruf direkt verwendbar.

Das gilt auch für den Rückgabewert, der dann mit Return V[xxx] als Struktur oder Tabelle zurückgegeben wird.

Insbesondere, wenn man Scripte implementiert, die SAP Objekte wie Kunde, Auftrag, Meldung,... einlesen, ist es praktisch, in dem aufgerufenen Script die gesamte Struktur zu definieren, also beispielsweise die gelesen Felder aus dem Auftragskopf sowe die Auftragszeilen als Struktur und Tabelle anzulegen.

Als Beispiel folgender Aufruf:

Set V[kunnr] "16380"
Process adr = customeraddress "&V[kunnr]"
Message "&V[adr.name1], &V[adr.landx]"

Das aufgerufene Script liest die Kundenadresse und gibt eine Struktur zurück, in der der Aufrufer die einzelnen Adressfelder direkt ansprechen kann.

// Read customer address
Parameter customernumber
 
CreateStructure V[address] kunnr name1 name2 ort01 pstlz land1 landx
CreateTable V[addresstable] include=V[address]
 
// Build join
Set V[join] "KNA1 left outer join T005T "
Set V[join] "&V[join] on T005T~LAND1 = KNA1~LAND1 "
Set V[join] "&V[join] and T005T~SPRAS = '&V[_language]' "
 
Set V[fields] "KNA1~KUNNR,KNA1~NAME1,KNA1~NAME2,
                      KNA1~ORT01,KNA1~PSTLZ,KNA1~LAND1,T005T~LANDX"

Set V[condition] "KNA1~KUNNR = @KUNNR"
Set V[domname1] "KUNNR"
Set V[domvalue1] "&V[customernumber]"
 
// Select from database
Call /guixt/dbselect  cache="transaction" _
  export.table="join" _
  export.fields="fields" _
  export.condition="condition" _
  export.domname1="domname1" _
  export.domvalue1="domvalue1" _
  import.values="addresstable"
 
ReadRow V[address] table=V[addresstable] index=1
 
Return  V[address]
Langtextvariablen Mit der Notation

Parameter
text[xxx]

wird in dem aufgerufenen Script ein Langtextparameter definiert. Im Aufruf kann dann ein Langtext text[...], eine Variable V[...] oder ein beliebiger String mitgegeben werden. Der Inhalt wird im aufgerufenen Script immer als Inhalt der Langtextvariablen text[xxx] zur Verfügung gestellt.

Bei der Übergabe von text[...] oder V[...] an den Textparameter erfolgt bei Rückkehr ein Kopieren des aktuellen Inhalts des Langtextparameters in die angegebene Textvariable oder normale Variable. Beispiel:

Process  wrap_lines text[notification_headertext]  80

Ebenso kann als Returnwert durch

Return text[xxx]

der Inhalt der Langtextvariablen zurückgegeben werden, entweder an eine normale Variable oder mit der Notation

Process text[xyz] = funcname par1 par2 par2


an einen Langtext, hier text[xyz].

BItte beachten Sie beim Mischen von normalen Variablen und Langtextvariablen die maximale Länge 4000 bei normalen Variablen.
Geschachtelte Aufrufe Geschachtelte und rekursive Aufrufe durch Process sind bis zu einer Schachtelungstiefe von ca. 100 möglich. Auch hier hat jeder Aufruf, auch des gleichen Scripts, einen eigenen Satz lokaler Variablen.
Details zum Ablauf Bei der ersten Ausführung eines Scripts mit  Process wird das Script in den Speicher geladen und bleibt pro SAP GUI Modus dort. Dadurch entfällt bei wiederholten Aufrufen der Ladevorgang.

Bitte bei der Entwicklung folgendes beachten:
Durch "Script aktivieren" im Script Editor Pro wird das Script aus dem Speicher entfernt und beim nächsten Aufruf neu geladen. Wenn Sie nur "Sichern" drücken, wird eine Scriptänderung erst nach Öffnen eines neuen SAP GUI Modus wirksam.
Debugging Im GuiXT Debugger werden innerhalb eines mit  Process aufgerufenen Scripts die lokalen Variablen angezeigt.
Einschränkungen Innerhalb eines mit  Process aufgerufenen Scripts können Sie keine  Screen-Anweisung verwenden. Dagegen ist in jedem Screen-Block eines InputScripts der Aufruf über  Process uneingeschränkt möglich.
Performance Für 1000  Process-Aufrufe  können Sie mit etwa 0.03 sec rechnen (gemessen auf PC mit 2Ghz CPU). Die Verarbeitung innerhalb des aufgerufenen Scripts ist etwas schneller also bei sonstigen Scripts, da beim Laden des Scripts einige Optimierungen durchgeführt werden..
Vergleich mit "include" Wiederverwendbare Funktionen kann man im Prinzip auch durch "include" implementieren. Die  Process-Technik bietet demgegenüber folgende Vorteile:
- Durch den eigenen Variablen-Namensraum gibt es keine Nebeneffekte durch Überschreiben von Variablen
- Es fällt kein physisches Laden der Scripte an nach dem ersten Aufruf
- Die Schnittstelle ist eindeutig beschrieben
- Auch kleinere Funktionen wie z.B. spezielle Prüfroutinen, Aufbereitung, Datums- und Zeitrechnungen, Tabellenverarbeitung lassen sich übersichtlich durch  Process abbilden
- Bei der Integration eigener Webseiten (Anweisung  WebView) in  SAP GUI können Sie aus JavaScript mit guixt.process() die gleichen Scripte ausführen
Komponente GuiXT + InputAssistant