Dieses Dokument behandelt folgende Themen:
Generell gilt Folgendes:
Eine dynamische alphanumerische Variable kann immer dann benutzt werden, wenn ein alphanumerisches Feld zulässig ist.
Ein dynamisches binäres Feld kann immer dann benutzt werden, wenn ein binäres Feld erlaubt ist.
Ein dynamisches Unicode-Feld kann überall dort verwendet werden, wo ein Unicode-Feld erlaubt ist.
Dynamische Variablen sind nicht zulässig beim
SORT-Statement. Um
dynamische Variablen in einem DISPLAY-,
WRITE-,
PRINT-, RREINPUT- oder
INPUT-Statement zu
benutzen, müssen Sie entweder den Session-Parameter
AL oder
EM
benutzen, um die Länge der Variable zu definieren.
Die benutzte Länge (siehe Natural-Systemvariable
*LENGTH,
Aktuell für eine
dynamische Variable benutzter Wertespeicher) und die Größe
des zugewiesenen Speicherplatzes der dynamischen Variablen sind gleich Null,
bis auf die Variable als Ziel-Operand zum ersten Mal zugegriffen wird. Aufgrund
von Zuweisungen oder anderen Operationen können dynamische Variablen zuerst
zugewiesen oder auf die exakte Größe des Source-Operanden erweitert werden (neu
zugewiesen).
Die Größe einer dynamischen Variable kann mit den folgenden Statements erweitert werden, wenn sie als ein änderbarer Operand (Ziel-Operand) in den folgenden Statements benutzt wird:
ASSIGN
|
operand1 (Ziel-Operand in einer Zuweisung). |
CALLNAT
|
Siehe Parameter-Übertragung bei
dynamischen Variablen (außer wenn AD=O, oder
wenn BY VALUE in der entsprechenden PDA vorhanden ist)
|
COMPRESS
|
operand2, siehe Verarbeitung. |
EXAMINE
|
operand1 in der
DELETE
REPLACE-Klausel.
|
MOVE
|
operand2 (Ziel-Operand), siehe Funktion. |
PERFORM
|
Außer wenn AD=O, oder wenn BY
VALUE in der betreffenden PDA vorhanden ist.
|
READ WORK
FILE
|
operand1 und operand2, siehe Verarbeitung großer und dynamischer Variablen. |
SEPARATE
|
operand4. |
SELECT (SQL)
|
parameter in der
INTO-Klausel.
|
SEND
METHOD
|
operand3 (außer wenn
AD=O).
|
Zurzeit gibt es die folgende Beschränkung in Bezug auf die Verwendung von großen Variablen:
| CALL | Parameter-Größe kleiner als 64 KB pro Parameter (keine
Beschränkung für CALL mit INTERFACE4-Option).
|
|---|
In den folgenden Abschnitten wird die Benutzung der dynamischen Variablen detaillierter und mit Beispielen erörtert.
Im Allgemeinen wird eine Zuweisung in der zurzeit benutzten Länge
des Source-Operanden durchgeführt (siehe Natural-Systemvariable
*LENGTH).
Wenn der Ziel-Operand eine dynamische Variable ist, wird seine zurzeit
zugewiesene Größe gegebenenfalls erweitert, um den Source-Operanden ohne
Abschneiden zu verschieben.
Beispiel:
#MYDYNTEXT1 := OPERAND MOVE OPERAND TO #MYDYNTEXT1 /* #MYDYNTEXT1 IS AUTOMATICALLY EXTENDED UNTIL THE SOURCE OPERAND CAN BE COPIED
MOVE
ALL bzw. MOVE ALL UNTIL mit dynamischen
Ziel-Operanden wird wie folgt definiert:
MOVE ALL verschiebt den Source-Operanden
wiederholt zum Ziel-Operanden, bis die benutzte Länge
(*LENGTH) des Ziel-Operanden erreicht ist.
*LENGTH wird nicht geändert. Wenn
*LENGTH Null ist, wird das Statement
ignoriert.
MOVE ALL operand1 TO
operand2 UNTIL operand3 verschiebt
operand1 wiederholt zu
operand2, bis die in
operand3 angegebene Länge erreicht ist. Wenn
operand3 größer als
*LENGTH(operand2) ist, wird
operand2 erweitert, und
*LENGTH(operand2) wird auf
operand3 gesetzt. Wenn
operand3 kleiner als
*LENGTH(operand2) ist, wird die
benutzte Länge auf operand3 reduziert. Wenn
operand3 gleich
*LENGTH(operand2) ist, entspricht das
Verhalten dem bei MOVE ALL.
Beispiel:
#MYDYNTEXT1 := 'ABCDEFGHIJKLMNO' /* *LENGTH(#MYDYNTEXT1) = 15
MOVE ALL 'AB' TO #MYDYNTEXT1 /* CONTENT OF #MYDYNTEXT1 = 'ABABABABABABABA';
/* *LENGTH IS STILL 15
MOVE ALL 'CD' TO #MYDYNTEXT1 UNTIL 6 /* CONTENT OF #MYDYNTEXT1 = 'CDCDCD';
/* *LENGTH = 6
MOVE ALL 'EF' TO #MYDYNTEXT1 UNTIL 10 /* CONTENT OF #MYDYNTEXT1 = 'EFEFEFEFEF';
/* *LENGTH = 10
MOVE JUSTIFIED wird zur Kompilierungszeit
zurückgewiesen, wenn der Ziel-Operand eine dynamische Variable ist.
MOVE SUBSTR und MOVE TO SUBSTR sind
zulässig. MOVE SUBSTR führt zu einem Laufzeitfehler, wenn ein
Substring hinter der benutzten Länge einer dynamischen Variable
(*LENGTH) referenziert wird. MOVE TO
SUBSTR führt zu einem Laufzeitfehler, wenn eine Substring-Position
hinter *LENGTH + 1 referenziert wird, weil dies zu einer
undefinierten Lücke im Inhalt der dynamischen Variable führen würde. Wenn der
Ziel-Operand von MOVE TO SUBSTR erweitert werden sollte (zum
Beispiel, wenn der zweite Operand auf *LENGTH+1 gesetzt wird), ist
der dritte Operand zwingend.
Gültige Syntax:
#OP2 := *LENGTH(#MYDYNTEXT1) MOVE SUBSTR (#MYDYNTEXT1, #OP2) TO OPERAND /* MOVE LAST CHARACTER TO OPERAND #OP2 := *LENGTH(#MYDYNTEXT1) + 1 MOVE OPERAND TO SUBSTR(#MYDYNTEXT1, #OP2, #lEN_OPERAND) /* CONCATENATE OPERAND TO #MYDYNTEXT1
Ungültige Syntax:
#OP2 := *LENGTH(#MYDYNTEXT1) + 1 MOVE SUBSTR (#MYDYNTEXT1, #OP2, 10) TO OPERAND /* LEADS TO RUNTIME ERROR; UNDEFINED SUB-STRING #OP2 := *LENGTH(#MYDYNTEXT1 + 10) MOVE OPERAND TO SUBSTR(#MYDYNTEXT1, #OP2, #EN_OPERAND) /* LEADS TO RUNTIME ERROR; UNDEFINED GAP #OP2 := *LENGTH(#MYDYNTEXT1) + 1 MOVE OPERAND TO SUBSTR(#MYDYNTEXT1, #OP2) /* LEADS TO RUNTIME ERROR; UNDEFINED LENGTH
Beispiel:
#MYDYNTEXT1 := #MYSTATICVAR1 #MYSTATICVAR1 := #MYDYNTEXT2
Wenn der Source-Operand eine statische Variable ist, wird die
benutzte Länge des dynamischen Ziel-Operanden
(*LENGTH(#MYDYNTEXT1)) auf die Format-Länge der statischen
Variablen gesetzt, und der Source-Wert wird einschließlich nachfolgender
Leerzeichen (alphanumerische und Unicode-Felder) oder binärer Nullen (für
binäre Felder) in diese Länge kopiert.
Wenn der Ziel-Operand statisch und der Source-Operand dynamisch ist, wird die dynamische Variable in ihre zurzeit benutzte Länge kopiert. Wenn diese Länge kleiner als die Format-Länge der statischen Variable ist, wird der Rest mit Leerzeichen (für alphanumerische und Unicode-Felder) oder binären Nullen (für binäre Felder) aufgefüllt, sonst wird der Wert abgeschnitten. Wenn die aktuell benutzte Länge der dynamischen Variable Null (0) ist, wird der statische Ziel-Operand mit Leerzeichen (für alphanumerische und Unicode-Felder) oder binären Nullen (für binäre Felder) aufgefüllt.
Dynamische Variablen können mit einem
RESET-Statement mit
Leerzeichen (alphanumerische und Unicode-Felder) oder Nullen (binäre Felder)
bis zur aktuell benutzten Länge (= *LENGTH)
initialisiert werden. *LENGTH wird nicht
geändert.
Beispiel:
DEFINE DATA LOCAL 1 #MYDYNTEXT1 (A) DYNAMIC END-DEFINE #MYDYNTEXT1 := 'SHORT TEXT' WRITE *LENGTH(#MYDYNTEXT1) /* USED LENGTH = 10 RESET #MYDYNTEXT1 /* USED LENGTH = 10, VALUE = 10 BLANKS
Um eine dynamische Variable mit einem angegebenen Wert in einer
angegebenen Länge zu initialisieren, kann das
MOVE ALL
UNTIL-Statement benutzt werden.
Beispiel:
MOVE ALL 'Y' TO #MYDYNTEXT1 UNTIL 15 /* #MYDYNTEXT1 CONTAINS 15 'Y'S, USED LENGTH = 15
Wenn ein änderbarer Operand eine dynamische Variable ist, wird ihre
zurzeit zugewiesene Länge möglicherweise erhöht, um die Operation ohne
Abschneidung oder Fehlermeldung auszuführen. Dies gilt für die Verkettung
(COMPRESS) und
Trennung von dynamischen alphanumerischen Variablen (SEPARATE).
Beispiel:
** Example 'DYNAMX01': Dynamic variables (with COMPRESS and SEPARATE) ************************************************************************ DEFINE DATA LOCAL 1 #MYDYNTEXT1 (A) DYNAMIC 1 #TEXT (A20) 1 #DYN1 (A) DYNAMIC 1 #DYN2 (A) DYNAMIC 1 #DYN3 (A) DYNAMIC END-DEFINE * MOVE ' HELLO WORLD ' TO #MYDYNTEXT1 WRITE #MYDYNTEXT1 (AL=25) 'with length' *LENGTH (#MYDYNTEXT1) /* dynamic variable with leading and trailing blanks * MOVE ' HELLO WORLD ' TO #TEXT * MOVE #TEXT TO #MYDYNTEXT1 WRITE #MYDYNTEXT1 (AL=25) 'with length' *LENGTH (#MYDYNTEXT1) /* dynamic variable with whole variable length of #TEXT * COMPRESS #TEXT INTO #MYDYNTEXT1 WRITE #MYDYNTEXT1 (AL=25) 'with length' *LENGTH (#MYDYNTEXT1) /* dynamic variable with leading blanks of #TEXT * * #MYDYNTEXT1 := 'HERE COMES THE SUN' SEPARATE #MYDYNTEXT1 INTO #DYN1 #DYN2 #DYN3 IGNORE * WRITE / #MYDYNTEXT1 (AL=25) 'with length' *LENGTH (#MYDYNTEXT1) WRITE #DYN1 (AL=25) 'with length' *LENGTH (#DYN1) WRITE #DYN2 (AL=25) 'with length' *LENGTH (#DYN2) WRITE #DYN3 (AL=25) 'with length' *LENGTH (#DYN3) /* #DYN1, #DYN2, #DYN3 are automatically extended or reduced * EXAMINE #MYDYNTEXT1 FOR 'SUN' REPLACE 'MOON' WRITE / #MYDYNTEXT1 (AL=25) 'with length' *LENGTH (#MYDYNTEXT1) /* #MYDYNTEXT1 is automatically extended or reduced * END
Anmerkung:
Im Falle von nicht-dynamischen Variablen kann eine Fehlermeldung
zurückgegeben werden.
Im Allgemeinen erfolgt eine Lese-Operation (z.B. ein Vergleich) bei einer dynamischen Variablen mit ihrer zurzeit benutzten Größe. Dynamische Variablen werden wie statische Variablen verarbeitet, wenn sie in einem Lese-Kontext (nicht änderbar) benutzt werden.
Beispiel:
IF #MYDYNTEXT1 = #MYDYNTEXT2 OR #MYDYNTEXT1 = "**" THEN ... IF #MYDYNTEXT1 < #MYDYNTEXT2 OR #MYDYNTEXT1 < "**" THEN ... IF #MYDYNTEXT1 > #MYDYNTEXT2 OR #MYDYNTEXT1 > "**" THEN ...
Auch im Falle von nachfolgenden Leerzeichen oder führenden Nullen zeigen dynamische Variablen ein entsprechendes Verhalten.
Für dynamische Variablen ist der alphanumerische Wert
AA gleich AA, und der binäre Wert
00003031 ist gleich 3031.
Führende Nullen für alphanumerische und Unicode-Variablen oder
führende binäre Nullen für binäre Variablen werden bei statischen und
dynamischen Variablen gleich behandelt. Zum Beispiel werden alphanumerische
Variable, die die Werte AA und AA (d.h.
AA mit nachfolgendem Leerzeichen) enthalten, als gleich angesehen.
Binäre Variablen, die beispielsweise die Werte H'0000031' und H'3031'
enthalten, werden ebenso als gleich angesehen. Wenn ein Vergleichsergebnis nur
im Falle einer exakten Kopie wahr (TRUE) sein sollte, müssen die
benutzten Längen der dynamischen Variablen außerdem miteinander verglichen
werden. Wenn eine Variable eine exakte Kopie der anderen ist, sind ihre
benutzten Längen auch gleich.
Beispiel:
#MYDYNTEXT1 := 'HELLO' /* USED LENGTH IS 5
#MYDYNTEXT2 := 'HELLO ' /* USED LENGTH IS 10
IF #MYDYNTEXT1 = #MYDYNTEXT2 THEN ... /* TRUE
IF #MYDYNTEXT1 = #MYDYNTEXT2 AND
*LENGTH(#MYDYNTEXT1) = *LENGTH(#MYDYNTEXT2) THEN ... /* FALSE
Zwei dynamische Variablen werden Position für Position miteinander verglichen (von links nach rechts bei alphanumerischen Variablen und von rechts nach links bei binären Variablen) bis zum Minimum ihrer benutzten Längen. Die erste Position, an der die Variablen nicht gleich sind, legt fest, ob die erste oder zweite Variable größer, gleich oder kleiner als die andere ist. Die Variablen sind gleich, wenn sie bis zum Minimum ihrer benutzten Längen gleich sind, und der Rest der längeren Variable nur Leerzeichen (bei alphanumerischen dynamischen Variablen) oder binäre Nullen (bei dynamischen binären Variablen) enthält. Um zwei dynamische Unicode-Variablen miteinander zu vergleichen, werden aus beiden Werten die führenden Nullen entfernt, bevor zum Vergleich der beiden resultierenden Werte der ICU-Collation-Algoritmus benutzt wird. Siehe auch Logical Condition Criteria in der Unicode and Code Page Support-Dokumentation.
Beispiel:
#MYDYNTEXT1 := 'HELLO1' /* USED LENGTH IS 6 #MYDYNTEXT2 := 'HELLO2' /* USED LENGTH IS 10 IF #MYDYNTEXT1 < #MYDYNTEXT2 THEN ... /* TRUE #MYDYNTEXT2 := 'HALLO' IF #MYDYNTEXT1 > #MYDYNTEXT2 THEN ... /* TRUE
Vergleiche zwischen dynamischen und statischen Variablen sind gleichwertig mit Vergleichen zwischen dynamischen Variablen. Die Format-Länge der statischen Variable wird als ihre benutzte Länge interpretiert.
Beispiel:
#MYSTATTEXT1 := 'HELLO' /* FORMAT LENGTH OF MYSTATTEXT1 IS A20 #MYDYNTEXT1 := 'HELLO' /* USED LENGTH IS 5 IF #MYSTATTEXT1 = #MYDYNTEXT1 THEN ... /* TRUE IF #MYSTATTEXT1 > #MYDYNTEXT1 THEN ... /* FALSE
Der Vergleich des Gruppenwechsel-Kontrollfeldes mit seinem alten Wert wird Position für Position von links nach rechts durchgeführt. Wenn der alte und der neue Wert der dynamischen Variable jeweils unterschiedliche Längen hat, dann wird zu Vergleichszwecken der Wert mit der kürzeren Länge nach rechts aufgefüllt (mit Leerzeichen für alphanumerisch und Unicode (dynamische Werte oder binäre Nullen für binäre Werte).
Im Falle eines alphanumerischen oder Unicode-Gruppenwechselkontrollfeldes sind nachfolgende Leerzeichen nicht bedeutend für den Vergleich, d.h. nachfolgende Leerzeichen bedeuten keine Änderung des Wertes, und es tritt kein Gruppenwechsel auf.
Im Falle eines binären Gruppenwechselkontrollfeldes sind nachfolgende binäre Nullen nicht bedeutend für den Vergleich, d.h. nachfolgende binäre Nullen bedeuten keine Änderung des Wertes, und es findet kein Gruppenwechsel statt.
Dynamische Variablen können als Parameter an aufgerufene
Programmobjekte (CALLNAT,
PERFORM) übergeben
werden. Aufruf über eine Referenz (Call-by-Reference) ist möglich, weil der
Wertespeicher einer dynamischen Variable zusammenhängend ist. Aufruf über Wert
(Call-by-Value) führt zu einer Zuweisung der Variablen-Definition des
Aufrufenden als Source-Operand und der Parameter-Definition als Ziel-Operand.
Bei Aufruf über Wert (Ergebnis) (Call-by-Value (Result)) ist es umgekehrt.
Bei Aufruf über eine Referenz (Call-by-Reference) müssen beide Definitionen dynamisch (DYNAMIC) sein. Wenn nur eine von ihnen dynamisch ist, tritt ein Laufzeitfehler auf. Im Falle von Call-by-Value (Result), d.h. Aufruf über Wert (Ergebnis) sind alle Kombinationen möglich. Die folgende Tabelle veranschaulicht die gültigen Kombinationen:
| Caller | Parameter | |
|---|---|---|
| Statisch | Dynamisch | |
| Statisch | Ja | Nein |
| Dynamisch | Nein | Ja |
Die Formate der dynamischen Variablen A oder B müssen miteinander im Einklang sein.
| Caller | Parameter | |
|---|---|---|
| Statisch | Dynamisch | |
| Statisch | Ja | Ja |
| Dynamisch | Ja | Ja |
Anmerkung:
Im Falle von statischen/dynamischen oder dynamischen/statischen
Definitionen können gemäß der Datenübertragungsregeln der betreffenden
Zuweisungen Werte abgeschnitten werden.
** Example 'DYNAMX02': Dynamic variables (as parameters) ************************************************************************ DEFINE DATA LOCAL 1 #MYTEXT (A) DYNAMIC END-DEFINE * #MYTEXT := '123456' /* extended to 6 bytes, *LENGTH(#MYTEXT) = 6 * CALLNAT 'DYNAMX03' USING #MYTEXT * WRITE *LENGTH(#MYTEXT) /* *LENGTH(#MYTEXT) = 8 * END
Subprogramm DYNAMX03:
** Example 'DYNAMX03': Dynamic variables (as parameters) ************************************************************************ DEFINE DATA PARAMETER 1 #MYPARM (A) DYNAMIC BY VALUE RESULT END-DEFINE * WRITE *LENGTH(#MYPARM) /* *LENGTH(#MYPARM) = 6 #MYPARM := '1234567' /* *LENGTH(#MYPARM) = 7 #MYPARM := '12345678' /* *LENGTH(#MYPARM) = 8 EXPAND DYNAMIC VARIABLE #MYPARM TO 10 /* 10 bytes are allocated * WRITE *LENGTH(#MYPARM) /* *LENGTH(#MYPARM) = 8 * /* content of #MYPARM is moved back to #MYTEXT /* used length of #MYTEXT = 8 * END
** Example 'DYNAMX04': Dynamic variables (as parameters)
************************************************************************
DEFINE DATA LOCAL
1 #MYTEXT (A) DYNAMIC
END-DEFINE
*
#MYTEXT := '123456' /* extended to 6 bytes, *LENGTH(#MYTEXT) = 6
*
CALLNAT 'DYNAMX05' USING #MYTEXT
*
WRITE *LENGTH(#MYTEXT) /* *LENGTH(#MYTEXT) = 8
/* at least 10 bytes are
/* allocated (extended in DYNAMX05)
*
END
Subprogramm DYNAMX05:
** Example 'DYNAMX05': Dynamic variables (as parameters) ************************************************************************ DEFINE DATA PARAMETER 1 #MYPARM (A) DYNAMIC END-DEFINE * WRITE *LENGTH(#MYPARM) /* *LENGTH(#MYPARM) = 6 #MYPARM := '1234567' /* *LENGTH(#MYPARM) = 7 #MYPARM := '12345678' /* *LENGTH(#MYPARM) = 8 EXPAND DYNAMIC VARIABLE #MYPARM TO 10 /* 10 bytes are allocated * WRITE *LENGTH(#MYPARM) /* *LENGTH(#MYPARM) = 8 * END
Dynamische und große Variablen können mit dem
CALL-Statement sinnvoll
benutzt werden, wenn die Option INTERFACE4 verwendet
wird. Der Einsatz dieser Option führt zu einer Schnittstelle zum 3GL-Programm
mit einer unterschiedlichen Parameter-Struktur.
Bevor Sie ein 3GL-Programm mit dynamischen Parametern aufrufen,
ist es wichtig sicherzustellen, dass die erforderliche Puffergröße zugewiesen
wird. Dies kann explizit über das EXPAND-Statement erfolgen.
Wenn ein initialisierter Puffer erforderlich ist, kann die
dynamische Variable mittels des MOVE ALL UNTIL-Statements
auf den Ausgangswert und auf die erforderliche Größe gesetzt werden. Natural
stellt eine Reihe von Funktionen zur Verfügung, die es dem 3GL-Programm
ermöglichen, Informationen über dynamische Parameter zu erhalten und die Länge
zu ändern, wenn Parameterdaten zurückgeschrieben werden.
Beispiel:
MOVE ALL ' ' TO #MYDYNTEXT1 UNTIL 10000 /* a buffer of length 10000 is allocated /* #MYDYNTEXT1 is initialized with blanks /* and *LENGTH(#MYDYNTEXT1) = 10000 CALL INTERFACE4 'MYPROG' USING #MYDYNTEXT1 WRITE *LENGTH(#MYDYNTEXT1) /* *LENGTH(#MYDYNTEXT1) may have changed in the 3GL program
Eine ausführlichere Beschreibung finden Sie beim
CALL-Statement in der
Statements-Dokumentation.
Es gibt keinen Unterschied in der Behandlung fester Längen von Variablen mit einer Länge kleiner gleich 253 Bytes und großen Variablen mit einer Länge größer als 253 Bytes.
Dynamische Variablen werden in der eingerichteten Länge geschrieben
(d.h. der Wert der Systemvariable *LENGTH
für diese Variable), wenn das WRITE
WORK FILE-Statement ausgeführt wird. Da die Länge für jede
Ausführung desselben WRITE WORK FILE-Statements unterschiedlich
sein kann, muss das Schlüsselwort VARIABLE angegeben werden.
Beim Lesen von Arbeitsdateien des Typs FORMATTED wird
eine dynamische Variable in der Länge gefüllt, die gültig ist (d.h. der Wert
der Systemvariable *LENGTH für diese Variable),
wenn das READ WORK FILE-Statement ausgeführt wird. Wenn die
dynamische Variable länger als die verbleibenden Daten im aktuellen Datensatz
ist, wird sie bei alphanumerischen und Unicode-Feldern mit Leerzeichen und bei
binären Feldern mit binären Nullen aufgefüllt.
Beim Lesen einer Arbeitsdatei des Typs UNFORMATTED wird
eine dynamische Variable mit dem Rest der Arbeitsdatei aufgefüllt. Ihre Größe
wird dementsprechend angepasst und wird im Wert der Systemvariable
*LENGTH für diese Variable reflektiert.
Wenn eine dynamische Variable in kleinen Beträgen mehrmals (z.B.
byteweise) erweitert werden soll, benutzen Sie das
EXPAND-Statement vor
den Schleifen-Iterationen, wenn die obere Grenze des erforderlichen Speichers
(ungefähr) bekannt ist. Dadurch vermeiden Sie zusätzlichen
Verarbeitungsmehraufwand zum Anpassen des erforderlichen Speicherplatzes.
Benutzen Sie das REDUCE- oder
RESIZE-Statement, wenn
die dynamische Variable nicht mehr erforderlich ist, insbesondere für Variablen
mit einem hohen Wert von *LENGTH.
Dadurch wird es Natural ermöglicht, den Speicherplatz wieder zu benutzen oder
freizugeben. Somit kann die Gesamtleistung verbessert werden.
Die Größe des einer dynamischen Variable zugewiesenen Hauptspeichers
kann mittels des REDUCE DYNAMIC
VARIABLE-Statements auf eine angegebene Größe reduziert
werden. Um eine Variable auf eine angegebene Größe (neu) zuzuweisen, kann das
EXPAND-Statement
benutzt werden.
Wenn die Variable initialisiert werden soll, benutzen Sie das
MOVE ALL
UNTIL-Statement.
** Example 'DYNAMX06': Dynamic variables (allocated memory)
************************************************************************
DEFINE DATA LOCAL
1 #MYDYNTEXT1 (A) DYNAMIC
1 #LEN (I4)
END-DEFINE
*
#MYDYNTEXT1 := 'a' /* used length is 1, value is 'a'
/* allocated size is still 1
WRITE *LENGTH(#MYDYNTEXT1)
*
EXPAND DYNAMIC VARIABLE #MYDYNTEXT1 TO 100
/* used length is still 1, value is 'a'
/* allocated size is 100
*
CALLNAT 'DYNAMX05' USING #MYDYNTEXT1
WRITE *LENGTH(#MYDYNTEXT1)
/* used length and allocated size
/* may have changed in the subprogram
*
#LEN := *LENGTH(#MYDYNTEXT1)
REDUCE DYNAMIC VARIABLE #MYDYNTEXT1 TO #LEN
/* if allocated size is greater than used length,
/* the unused memory is released
*
REDUCE DYNAMIC VARIABLE #MYDYNTEXT1 TO 0
WRITE *LENGTH(#MYDYNTEXT1)
/* free allocated memory for dynamic variable
END
Benutzen Sie dynamische Operanden überall dort, wo es sinnvoll ist.
Benutzen Sie EXPAND, wenn die obere Grenze der
Hauptspeicher-Benutzung bekannt ist.
Benutzen Sie REDUCE, wenn der dynamische Operand
nicht mehr gebraucht wird.
Dynamische Variablen können innerhalb von Ausgabe-Statements wie folgt benutzt werden:
| Statement | Anmerkungen |
|---|---|
DISPLAY
|
Mit diesen Statements müssen Sie das Format der Ausgabe
oder Eingabe von dynamischen Variablen setzen, indem Sie die Session-Parameter
|
WRITE
|
|
INPUT
|
|
REINPUT
|
-- |
PRINT |
Da die Ausgabe des |
Ein dynamisches X-Array kann zugewiesen werden, indem man zuerst die Anzahl der Ausprägungen angibt und dann die Länge der vorher zugewiesenen Array-Ausprägungen erweitert.
Beispiel:
DEFINE DATA LOCAL 1 #X-ARRAY(A/1:*) DYNAMIC END-DEFINE * EXPAND ARRAY #X-ARRAY TO (1:10) /* Current boundaries (1:10) #X-ARRAY(*) := 'ABC' EXPAND ARRAY #X-ARRAY TO (1:20) /* Current boundaries (1:20) #X-ARRAY(11:20) := 'DEF'