Zusammengesetzte Variablen sind Variablen, die aus mehreren Elementen bestehen. Diese Elemente können über den gemeinsamen Variablennamen, eben den Namen der zusammengesetzten Variablen, angesprochen werden.
Zusammengesetzte Variablen müssen in der Regel explizit mit dem Kommando DECLARE-VARIABLE deklariert werden. Welche Operanden des Kommandos DECLARE-VARIABLE bei der Deklaration verwendet werden müssen, hängt davon ab, ob es sich bei der zusammengesetzten Variablen um eine Liste, ein Array oder eine Struktur handelt.
Arrays und Listen werden über den Operanden MULTIPLE-ELEMENTS = *ARRAY(...) /*LIST(...) deklariert.
Es gibt aber auch Kommandos, wie z.B. SHOW-VARIABLE oder EXECUTE-CMD, die Listen implizit anlegen. Strukturen werden über den Operanden TYPE = *STRUCTURE des Kommandos DECLARE-VARIABLE deklariert (daher werden Strukturen auch als Variablen mit dem Datentyp Struktur bezeichnet). Diese drei Typen zusammengesetzter Variablen werden in den folgenden Abschnitten beschrieben.
Listen
Listen werden auch als Listenvariablen bezeichnet; dieser Begriff wird vor allem dann gewählt, wenn Verwechslungsgefahr mit SDF-Listen besteht (eine SDF-Liste ist ein String, der nach den syntaktischen Regeln für Operandenlisten in Kommandos interpretiert wird).
Listen in SDF-P sind zusammengesetzte Variablen, deren Elemente alle den gleichen Datentyp haben. Auf die Elemente einer Liste kann sequenziell oder direkt zugegriffen werden.
Als Listenelemente sind einfache Variablen zugelassen oder zusammengesetzte Variablen vom Typ Struktur.
Listen haben an der Benutzerschnittstelle nur einen „relativen“ Elementnamen. Dem Listennamen wird dazu das Zeichen # angehängt, gefolgt von der Nummer des Elements. Die Elementnummer ergibt sich aus der Reihenfolge der Elemente in der Liste. Das erste Listenelement, der so genannte Listenkopf, hat immer die Elementnummer 1 (<name>#1). Von diesem Listenkopf ausgehend werden die weiteren Listenelemente durchnummeriert. Beim Ansprechen des Listenkopfs kann die Elementnummer auch weggelassen werden (<name>#).
Listen können in FOR-Schleifen sequenziell abgearbeitet werden: Wenn das aktuelle Listenelement einen gültigen Wert enthält, wird die FOR-Schleife durchlaufen. Dies wird so oft wiederholt, bis die Liste abgearbeitet ist (zu FOR-Schleifen siehe Abschnitt „Schleifendefinieren“ (Schleifen definieren )).
Listen deklarieren
Listen werden explizit mit dem Kommando DECLARE-VARIABLE im Operanden MULTIPLE-ELEMENTS = *LIST(...) deklariert. Die hier festgelegten Variableneigenschaften gelten für alle Elemente der Liste.
Listen sind im Kommando SET-VARIABLE implizit dynamisch erweiterbar durch Anfügen eines neuen Elements am Anfang oder am Ende. Jedoch muss berücksichtigt werden, dass die Folge der Listenelemente lückenlos ist.
Soll die Zahl der Listenelemente eingeschränkt werden, muss das über den Operanden LIMIT im Kommando DECLARE-VARIABLE geschehen.
Listen freigeben
Es kann jeweils ein einzelnes Listenelement oder ein zusammenhängernder Bereich von Listenelementen freigegeben werden. Nach der Freigabe wird die Liste neu nummeriert, sodass immer eine lückenlose Nummerierung ab 1 vorhanden ist.
Beispiel
/DECLARE-VARIABLE L,MULTIPLE-ELEMENTS=*LIST
/L=*STRING-TO-VAR('(1,2,3,4,5,6,7,8)')
/SHOW-VARIABLE L,LIST-INDEX-NUMBER=*YES
L#1 = 1
L#2 = 2
L#3 = 3
L#4 = 4
L#5 = 5
L#6 = 6
L#7 = 7
L#8 = 8
/FREE-VARIABLE L#3
/SHOW-VARIABLE L,LIST-INDEX-NUMBER=*YES
L#1 = 1
L#2 = 2
L#3 = 4
L#4 = 5
L#5 = 6
L#6 = 7
L#7 = 8
/FREE-VARIABLE *LIST(LIST-NAME=L,FROM-INDEX=4),NUMBER-OF-ELEMENTS=3)
/SHOW-VARIABLE L,LIST-INDEX-NUMBER=*YES
L#1 = 1
L#2 = 2
L#3 = 4
L#4 = 8
Listen ausgeben
Einzelne Listenelemente können mit dem Kommando /SHOW-VARIABLE <name>#<nummer> oder in einer FOR-Schleife auszugegeben werden.
Arrays
Arrays sind zusammengesetzte Variablen, deren Elemente alle mit dem gleichen Datentyp deklariert sind.
Arrayelemente können selbst einfache Variablen sein oder zusammengesetzte Variablen vom Typ Struktur. Sie können direkt angesprochen werden über ihren Arrayelementnamen, der sich zusammensetzt aus dem Arraynamen und einem ganzzahligen Arrayindex (siehe Abschnitt „Variablennamen“).
Beispiel 1
KONTO ist ein einfaches Array und besteht aus folgenden Elementen:
KONTO#-12 KONTO#-1 KONTO#0 KONTO#1 KONTO#2 KONTO#123 KONTO#1234
Beispiel 2
KUNDE ist ein zusammengesetztes Array, als Index dient die Kundennummer, die Arrayelemente sind Strukturen, die jeweils die Adresse des Kunden enthalten.
KUNDE#123.NAME KUNDE#123.VORNAME KUNDE#123.STRASSE ... KUNDE#358.NAME KUNDE#358.VORNAME KUNDE#358.STRASSE ...
Arrays deklarieren
Arrays werden deklariert mit dem Kommando DECLARE-VARIABLE, Operand MULTIPLE-ELEMENTS = *ARRAY(...). Die übrigen hier deklarierten Variableneigenschaften gelten für alle Elemente des Arrays.
Arrayelemente können nur implizit deklariert werden. Explizite Deklaration ist für einzelne Elemente nicht möglich.
Arrays sind immer dynamisch erweiterbar. Über die Operanden UPPER-BOUND und LOWER-BOUND kann ein Wertebereich für den Arrayindex definiert und so die Zahl der Arrayelemente eingeschränkt werden.
Strukturen
Strukturen sind zusammengesetzte Variablen, deren Elemente unterschiedliche Datentypen haben können und direkt über alphanumerische Elementnamen angesprochen werden können.
Als Strukturelemente sind einfache Variablen oder zusammengesetzte Variablen vom Typ Liste, Array oder Struktur zugelassen.
Der Strukturelementname setzt sich zusammen aus dem Variablennamen der Struktur und einem Teilnamen vom SDF-Datentyp <structured-name>, die durch einen Punkt voneinander getrennt werden (siehe Abschnitt „Variablennamen“).
Strukturen können statisch oder dynamisch erweiterbar sein. Dies wird bei der Deklaration festgelegt.
Hinweis
Strukturen spielen eine wichtige Rolle bei strukturierten Ausgaben mittels strukturierter Variablenströme. Detail-Informationen hierzu enthält das Kapitel „S-Variablenströme“ff.
Beispiel
ANSCHRIFT ist eine Struktur, die aus den folgenden einfachen Variablen als Elementen besteht:
ANSCHRIFT.NAME ANSCHRIFT.VORNAME ANSCHRIFT.TITEL ANSCHRIFT.STRASSE ANSCHRIFT.HAUSNR ANSCHRIFT.PLZ ANSCHRIFT.ORT
Die Strukturelemente NAME, VORNAME, TITEL, STRASSE und ORT können mit dem Datentyp STRING deklariert werden, die Strukturelemente HAUSNR und PLZ mit dem Datentyp INTEGER.
Strukturen deklarieren
Zusammengesetzte Variablen vom Typ Struktur werden mit dem Kommando DECLARE-VARIABLE deklariert, und zwar im Operanden NAME mit TYPE = *STRUCTURE(DEFINITION= ). Dort wird auch festgelegt, ob die Struktur dynamisch erweiterbar oder statisch ist.
Dynamische Strukturen
Eine Struktur ist „dynamisch“ oder „dynamisch erweiterbar“, wenn die Elemente weder explizit über ein Strukturlayout noch mit *BY-SYSCMD deklariert werden.
Dynamische Strukturen werden explizit deklariert mit dem Kommando DECLARE-VARIABLE, Operand NAME = ...(TYPE = *STRUCTURE(DEFINITION = *DYNAMIC)).
Die Elemente dynamischer Strukturen können explizit oder implizit deklariert werden. Die Einstellung des Operanden IMPLICIT-DECLARATION im Kommando SET-PROCEDURE-OPTIONS im Prozedurkopf hat keinen Einfluss; implizite Deklaration von Elementen dynamischer Strukturen ist immer möglich.
Beispiel 1
Es wird eine dynamische Struktur DYN-STR deklariert:
/DECLARE-VARIABLE DYN-STR (TYPE = *STRUCTURE(*DYNAMIC))
Später wird über eine Zuweisung ein Element dieser Struktur initialisiert:
/DYN-STR.STR2.ARR#123 = 'ABC'
Diese Zuweisung bewirkt Folgendes:
Das Strukturelement DYN-STR.STR2 wird als dynamische Struktur angelegt.
Das Strukturelement DYN-STR.STR2.ARR wird als Array angelegt, mit dem Datentyp TYPE = *ANY.
Das Arrayelement DYN-STR.STR2.ARR#123 wird als einfache Variable angelegt, mit dem Datentyp TYPE = *ANY.
Beispiel 2
/DECLARE-VARIABLE S1 (TYPE = *STRUCTURE(*DYNAMIC))
Über eine Zuweisung wird ein Element dieser Struktur initialisiert:
/S1.S2.ARR#1.S3 = 'ABC'
Diese Zuweisung bewirkt Folgendes:
Das Strukturelement S1.S2 wird als dynamische Struktur angelegt.
Das Strukturelement S1.S2.ARR wird als Array angelegt, mit dem Datentyp TYPE = *STRUCTURE(*DYNAMIC).
Das Arrayelement S1.S2.ARR#1 wird als dynamische Struktur angelegt, mit dem Datentyp TYPE = *STRUCTURE(*DYNAMIC).
Das Strukturelement S1.S2.ARR#1.S3 wird als einfache Variable angelegt, mit dem Datentyp TYPE = *ANY.
Beispiel 3
/DECLARE-VARIABLE DYN-STR (TYPE = *STRUCTURE(*DYNAMIC)) /DECLARE-ELEMENT DYN-STR.S.NUMBER(TYPE=*INTEGER)
In diesem Beispiel sind die Elemente explizit deklariert, und zwar DYN-STR.S als dynamische Struktur und DYN-STR.S.NUMBER als einfache Variable mit TYPE = *INTEGER.
Beispiel 4
/DECLARE-VARIABLE S1 (TYPE = *STRUCTURE(*DYNAMIC)) /S1#123 = 'ABC' -> Fehler
Die Zuweisung wird mit Fehler abgewiesen, da S1 nicht als Array deklariert ist.
Statische Strukturen
Statische Strukturen sind Strukturen, die nicht dynamisch erweiterbar sind. Zu unterscheiden ist hier, ob die statische Struktur durch *BY-SYSCMD erzeugt oder über ein so genanntes Strukturlayout definiert wird. Im folgenden Abschnitt wird zunächst die Deklaration über das Strukturlayout vorgestellt, im Anschluss daran die Deklaration von Strukturen, die für die Ausgabe von BS2000-Kommandos verwendet werden.
Wenn die Strukturdeklaration abgeschlossen ist, können der Struktur keine weiteren Elemente mehr hinzugefügt werden.
Regeln für statische Strukturen
Strukturdeklarationen müssen innerhalb einer Prozedur vollständig sein. Das heißt, sie müssen in der Prozedur, in der sie beginnen, abgeschlossen werden. Dies gilt sowohl für CALL- als auch für INCLUDE-Prozeduren.
Deklarationsblöcke dürfen Kontrollflusskommandos oder Prozeduraufrufe enthalten.
Bei einem Prozeduraufruf innerhalb einer Strukturdeklaration ist Folgendes zu beachten:
Innerhalb eines Deklarationsblocks können Prozeduren beliebig aufgerufen werden.
Wird eine Prozedur mit INCLUDE-PROCEDURE aufgerufen, sind die Elemente, die vor dem Aufruf deklariert wurden, nicht sichtbar. Auch können in der INCLUDE-Prozedur keine weiteren Elemente der unterbrochenen Struktur deklariert werden.
Wenn in einer INCLUDE-Prozedur auf eine unvollständige Struktur oder ein unvollständiges Strukturlayout zugegriffen wird, kommt es zum Fehler.
Abbruch der Strukturdeklaration durch Prozedurende:
Wenn eine Prozedur während einer Strukturdeklaration abgebrochen wird, werden unvollständige Strukturen mit dem Geltungsbereich Prozedur oder Include automatisch gelöscht. Eine entsprechende Warnung wird ausgegeben.
Unvollständige Strukturen und Strukturlayouts mit dem Geltungsbereich Task bleiben erhalten. Die Strukturdeklaration wird implizit abgeschlossen, sodass später auf die Struktur bzw. die zuvor deklarierten Strukturelemente zugegriffen werden kann. Es können jedoch keine weiteren Elemente deklariert werden.
Strukturen mit *BY-SYSCMD deklarieren
Wird eine statische Struktur mit DEFINITION = *BY-SYSCMD deklariert, so muss dem Deklarationskommando für die Struktur direkt die Deklaration der Strukturelemente folgen.
Die Strukturelemente müssen in einem Strukturdeklarationsblock deklariert werden. Dieser Block wird mit dem Kommando BEGIN-STRUCTURE eingeleitet und mit END-
STRUCTURE abgeschlossen. Im Kommando BEGIN-STRUCTURE darf kein Strukturlayoutname angegeben werden.
Es ergeben sich damit für die Deklaration folgende Schritte:
Struktur explizit deklarieren
Das Kommando DECLARE-VARIABLE muss folgende Angaben enthalten:
NAME = variablenname TYPE = *STRUCTURE(DEFINITION = *BY-SYSCMD)
Strukturdeklarationsblock einleiten
Dem Kommando DECLARE-VARIABLE muss direkt das Kommando BEGIN-STRUCTURE folgen. Das Kommando darf weder einen Strukturlayoutnamen(NAME =) noch einen Geltungsbereich (SCOPE =) enthalten.
Strukturelemente deklarieren
Die Strukturelemente müssen einzeln über separate Aufrufe des Kommandos DECLARE-ELEMENT deklariert werden. Die Strukturelemente können als einfache oder zusammengesetzte Variablen deklariert werden, mit beliebigem Datentyp. Sind die Strukturelemente einfache Variablen, können sie mit INITIAL-VALUE initialisiert werden. Alle Eigenschaften, die nicht explizit im Kommando DECLARE-ELEMENT deklariert werden, werden von der übergeordneten Struktur übernommen. Im Operanden NAME wird nur der Elementname angegeben, nicht der Strukturname.
Strukturdeklarationsblock abschließen
Mit dem Kommando END-STRUCTURE wird der Deklarationsblock abgeschlossen.
Beispiel 1
Deklaration einer Struktur mit einfachen Variablen als Strukturelementen:
/DECLARE-VARIABLE M(TYPE = *STRUCTURE(*BY-SYSCMD)) /BEGIN-STRUCTURE / DECLARE-ELEMENT A / DECLARE-ELEMENT B /END-STRUCTURE
Beispiel 2
Deklaration einer Struktur mit einer zusammengesetzten Variablen als Strukturelement:
/DECLARE-VARIABLE M(TYPE = *STRUCTURE(*BY-SYSCMD)) /BEGIN-STRUCTURE / DECLARE-ELEMENT A(TYPE = *STRUCTURE(*BY-SYSCMD)) / BEGIN-STRUCTURE / DECLARE-ELEMENT B / END-STRUCTURE /END-STRUCTURE
Es existiert jetzt die statische Struktur M mit dem Element M.A.B. Da A wiederum als Struktur mit *BY-SYSCMD deklariert wurde, musste BEGIN-STRUCTURE geschachtelt werden.
Regeln für Strukturen mit *BY-SYSCMD
Die Kommandos DECLARE-VARIABLE und BEGIN-STRUCTURE müssen in dieser Reihenfolge direkt aufeinander folgen.
BEGIN-STRUCTURE darf weder einen Layoutnamen noch einen Geltungsbereich enthalten.
Auf die Strukturelemente kann erst dann zugegriffen werden, wenn die Deklaration aller Elemente abgeschlossen ist. (Ausnahme: mit dem Kommando SHOW-VARIABLE kann der Inhalt der Strukturelemente jederzeit angezeigt werden.)
Strukturen mit benanntem Strukturlayout deklarieren
Das Strukturlayout entspricht einer Schablone, die es erlaubt, gleichartige Strukturen einfach zu erzeugen. Existiert ein Strukturlayout, dann kann es in beliebig vielen DECLARE-VARIABLE Kommandos verwendet werden, die so beliebig viele Strukturen mit den gleichen Elementen erzeugen.
Als Folge von SDF-P-Kommandos beginnt ein Strukturlayout mit einem Kommando BEGIN-STRUCTURE, gefolgt von DECLARE-ELEMENT-Kommandos, und abgeschlossen wird es mit dem Kommando END-STRUCTURE.
In diesen Strukturlayouts werden die einzelnen Elemente von Strukturen explizit deklariert. Strukturlayouts sind eindeutig durch einen Namen gekennzeichnet. Dieser Name muss bei der Deklaration der Struktur im Kommando DECLARE-VARIABLE wiederholt werden.
Es ergeben sich damit im Einzelnen folgende Schritte:
Strukturlayout (= Deklarationsblock für die Strukturelemente) einleiten
Mit dem Kommando BEGIN-STRUCTURE wird das Strukturlayout eingeleitet. Im Operanden NAME muss ein Name angegeben werden (NAME = layoutname). Über diesen Namen wird später eine Verbindung hergestellt zwischen der Deklaration der Variablen „variablenname“ vom Typ Struktur im Kommando DECLARE-VARIABLE und der Deklaration der Elemente dieses Strukturlayouts.Wenn das Kommando DECLARE-VARIABLE aufgerufen wird, muss das Strukturlayout existieren.
Strukturelemente deklarieren
Alle Layoutelemente werden über separate Aufrufe des Kommandos DECLARE-ELEMENT deklariert. Sie können als einfache Variablen oder als zusammengesetzte Variablen vom Typ Liste, Array oder Struktur deklariert werden.Alle Variablenmerkmale, die im DECLARE-ELEMENT-Kommando nicht explizit deklariert werden, werden von der übergeordneten Struktur übernommen.Layoutelemente dürfen nicht initialisiert werden.
Strukturlayout/Deklarationsblock abschließen
Mit dem Kommando END-STRUCTURE wird das Strukturlayout abgeschlossen.
Struktur explizit deklarieren
Im Kommando DECLARE-VARIABLE, im Operanden NAME = variablenname (TYPE = *STRUCTURE(...)) wird in der Klammer ein Layoutname angegeben(DEFINITION = layoutname) und so die Verbindung zu dem bereits deklarierten Strukturlayout hergestellt.
Beispiel
Zunächst wird ein Strukturlayout A deklariert:
/BEGIN-STRUCTURE A / DECLARE-ELEMENT B / DECLARE-ELEMENT C /END-STRUCTURE
Es existiert noch keine Struktur, Wertzuweisungen sind nicht möglich. Später werden Strukturen deklariert, für die das Strukturlayout A gelten soll:
/DECLARE-VARIABLE KK (TYPE = *STRUCTURE (DEFINITION = A)) /... /DECLARE-VARIABLE CC (TYPE = *STRUCTURE (DEFINITION = A))
Jetzt existieren zwei statische Strukturen, KK und CC, mit den Elementen KK.B und KK.C bzw. CC.B und CC.C. Diesen Elementen können jederzeit Werte zugewiesen werden.
Regeln für Strukturlayouts
Bei der Deklaration muss im einleitenden Kommando BEGIN-STRUCTURE ein Name angegeben werden.
Strukturlayouts müssen vor den Strukturen deklariert werden.
Jedes Strukturlayout steht für beliebig viele Deklarationen von statischen Strukturen zur Verfügung.
Strukturlayouts haben einen eigenen Namensraum, das heißt, Variablen und Strukturlayouts dürfen gleiche Namen haben.
Einem Strukturlayout dürfen keine Werte zugewiesen werden. Es dient nur als Schablone für spätere Deklarationen.
Strukturlayouts dürfen - im Gegensatz zu anderen Strukturdeklarationen - nicht geschachtelt werden. Das heißt, jeder Deklarationsblock muss mit END-STRUCTURE abgeschlossen werden, bevor der nächste Deklarationsblock mit BEGIN-STRUCTURE geöffnet werden kann.
Hinweis
Beispiele für die Deklaration von Strukturen, Strukturlayouts und Strukturelementen enthält auch die Beschreibung des Kommandos DECLARE-ELEMENT auf "DECLARE-ELEMENT Strukturelement deklarieren ".