Version 4.2.6
 —  Statements  —

MOVE

Dieses Dokument behandelt folgende Themen:

Verwandte Statements: ADD | COMPRESS | COMPUTE | DIVIDE | EXAMINE | MOVE ALL | MULTIPLY | RESET | SEPARATE | SUBTRACT

Gehört zur Funktionsgruppe: Arithmetische Funktionen und Datenzuweisungen


Funktion

Das Statement MOVE dient dazu, den Wert eines Operanden in einen oder mehrere andere Operanden (Felder oder Arrays) zu übertragen.

Ein MOVE-Statement mit mehreren Zieloperanden ist mit den betreffenden einzelnen MOVE-Statements identisch:

MOVE #SOURCE TO #TARGET1 #TARGET2

ist identisch mit:

MOVE #SOURCE TO #TARGET1 
MOVE #SOURCE TO #TARGET2

Beispiel:

DEFINE DATA LOCAL
1 #ARRAY(I4/1:3) INIT <3,0,9>
1 #INDEX(I4)
1 #RESULT(I4)
END-DEFINE
*
#INDEX := 1
MOVE #ARRAY(#INDEX) TO #INDEX       /* #INDEX is 3 
                       #RESULT      /* #RESULT is 9  
*
#INDEX := 2
MOVE #ARRAY(#INDEX) TO  #INDEX     /* #INDEX is 0
                        #ARRAY(3)  /* returns run time error NAT1316 

Ist operand2 eine dynamische Variable, kann ihre Länge mit der MOVE-Operation geändert werden. Die aktuelle Länge einer dynamischen Variable kann mittels der Systemvariable *LENGTH bestimmt werden. Allgemeine Informationen zu dynamischen Variablen siehe den Abschnitt Dynamische und große Variablen benutzen im Leitfaden zur Programmierung.

Hat operand2 das Format C, kann operand1 auch als (parameter) angegeben werden. Es gibt die folgenden gültigen Parameter:

Parameter, die mit dem MOVE-Statement angegeben werden können: Spezifikation:
S = auf Statement-Ebene
E = auf Element-Ebene
AD Attribute Definition SE
CD Color Definition S

Weitere Informationen zur Datenübertragungs-Kompatibilität und den Regeln für die Datenübertragung finden Sie im Abschnitt Datenübertragung im Leitfaden zur Programmierung.

Weitere Hinweise

Wird ein Datenbankfeld als Ergebnisfeld (operand2) verwendet, so ändert sich der Wert des Feldes durch die MOVE-Operation nur programmintern. Der in der Datenbank gespeicherte Feldwert wird davon nicht beeinflusst.

Eine Natural-Systemfunktion darf nur eingesetzt werden, wenn das MOVE-Statement in Verbindung mit einem AT BREAK-, AT END OF DATA- oder AT END OF PAGE-Statement verwendet wird.

Siehe auch Abschnitt Arithmetische Operationen im Leitfaden zur Programmierung.

Anmerkung:
Wenn operand1 eine Zeitvariable (Format T) ist, wird nur die Zeitkomponente des Variableninhalts übertragen, aber nicht die Datumskomponente (außer bei MOVE EDITED). Siehe Syntax 4 und Syntax 5.

Seitenanfang

Syntax-Beschreibung

Das MOVE-Statement bietet mehrere Syntax-Varianten:

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

Syntax 1 — MOVE ROUNDED

MOVE [ROUNDED] operand1 [( parameter)] TO operand2

Operanden-Definitionstabelle:

Operand Mögliche Struktur Mögliche Formate Referenzierung erlaubt Dynam. Definition
operand1 C S A   N A U N P I F B D T L C G O ja nein
operand2   S A   M A U N P I F B D T L C G O ja ja

Syntax-Element-Beschreibung:

MOVE ROUNDED
Rundung:

Das Schlüsselwort ROUNDED bewirkt, dass der Wert von operand2 auf- bzw. abgerundet wird.

ROUNDED wird ignoriert, wenn operand2 nicht numerisch ist.

Wenn operand2 das Format N oder P hat und mehr als einmal angegeben wird, wird ROUNDED bei Zieloperanden mit 7 Stellen hinter dem Dezimalpunkt (Komma) ignoriert.

Siehe auch Beispiel 1 − Verschiedene Beispiele für die Benutzung des MOVE-Statements.

(parameter)
Parameter:

Als parameter können Sie die Option PM=I oder den Session-Parameter DF angeben:

PM=I
Schreibrichtung:

Zur Unterstützung von Sprachen, deren Schreibrichtung von rechts nach links verläuft, können Sie die Option PM=I angeben, um den Wert von operand1 invers (d.h. von rechts nach links) in operand2 zu übertragen.

Zum Beispiel hätte als Ergebnis der folgenden Statements das Feld #B den Inhalt ZYX:

MOVE 'XYZ' TO #A
MOVE #A (PM=I) TO #B

PM=I kann nur angegeben werden, wenn operand2 alphanumerisches Format hat.

Nachfolgende Leerzeichen in operand1 werden entfernt (auf Großrechnern werden Leerzeichen und binäre Nullen entfernt), dann wird der Wert umgedreht und anschließend in operand2 übertragen. Falls operand1 nicht alphanumerisches Format hat, wird der Wert in alphanumerisches Format umgesetzt, bevor er umgedreht wird.

Zur Verwendung von PM=I zusammen mit MOVE LEFT/RIGHT JUSTIFIED siehe MOVE LEFT/RIGHT JUSTIFIED.

DF
Datumsformat:

Wenn operand1 eine Datumsvariable und operand2 ein alphanumerisches Feld ist, können Sie den Session-Parameter DF als parameter für diese Datumsvariable angeben.

Der Session-Parameter DF ist in der ParameterReferenz beschrieben.

Syntax 2 - MOVE SUBSTRING

MOVE

operand1

[(parameter)] TO

operand2

SUBSTRING (operand1,operand3,operand4) SUBSTRING (operand2,operand5,operand6)

Operanden-Definitionstabelle:

Operand Mögliche Struktur Mögliche Formate Referenzierung erlaubt Dynam. Definition
operand1 C S A     A U         B             ja nein
operand2   S A     A U         B             ja nein
operand3 C S           N P I   B*             ja nein
operand4 C S           N P I   B*             ja nein
operand5 C S           N P I   B*             ja nein
operand6 C S           N P I   B*             ja nein

* Siehe Text.

Syntax-Element-Beschreibung:

MOVE SUBSTRING
Teilweise Übertragung:

Ohne SUBSTRING-Option wird der ganze Inhalt des Feldes übertragen.

Die Option SUBSTRING ermöglicht es Ihnen, nur einen bestimmten Teil eines alphanumerischen oder binären Feldes zu übertragen. In der SUBSTRING-Klausel geben Sie nach dem Feldnamen (operand1) zunächst die erste Stelle (operand3) und dann die Länge (operand4) des Feldteils an, der übertragen werden soll.

Wenn das zugrundeliegende Feldformat von operand1:

  • alphanumerisch (A) oder numerisch (N) ist, gelten die mit operand3 oder operand4 angegebenen Werte als Byte-Zahlen.

  • Unicode (U) ist, gelten die mit operand3 oder operand4 angegebenen Werte als Zahl der Unicode-Codeeinheiten, d.h. als Doppelbytes.

Um zum Beispiel die 5. bis einschließlich 12. Stelle eines Feldes #A in ein Feld #B zu übertragen, würden Sie folgendes angeben:

MOVE SUBSTRING(#A,5,8) TO #B

Ist operand1 eine dynamische Variable, muss der angegebene und zu übertragene Feldteil im Bereich seiner aktuellen Länge sein; sonst tritt ein Laufzeit-Fehler auf.

Sie können einen Wert eines alphanumerischen, binären oder numerischen Feldes auch in einen bestimmten Teil des Zielfeldes übertragen. In der SUBSTRING-Klausel geben Sie nach dem Feldnamen (operand2) zunächst die erste Stelle (operand5) und dann die Länge (operand6) des Feldteils an, in den der Wert übertragen werden soll.

Wenn das zugrundeliegende Feldformat von operand2:

  • alphanumerisch (A) oder numerisch (N) ist, gelten die mit operand5 oder operand6 angegebenen Werte als Byte-Zahlen.

  • Unicode (U) ist, gelten die mit operand5 oder operand6 angegebenen Werte als Zahl der Unicode-Codeeinheiten, d.h. als Doppelbytes.

Um zum Beispiel den Wert eines Feldes #A in die 3. bis einschließlich 6. Stelle eines Feldes #B zu übertragen, würden Sie folgendes angeben:

MOVE #A TO SUBSTRING(#B,3,4)

Wenn operand2 eine dynamische Variable ist, darf die erste Stelle (operand5) nicht größer sein als die aktuelle Länge der Variable plus 1; eine höhere erste Stelle würde einen Laufzeit-Fehler zur Folge haben, weil dies zu einer nicht definierten Lücke im Inhalt von operand2 führen würde.

Wenn operand3 bzw operand5 oder operand4 bzw. operand6 eine binäre Variable ist, kann sie nur mit einer Länge kleiner gleich 4 benutzt werden

Wenn Sie operand3 bzw. operand5 weglassen, wird ab Anfang des Feldes übertragen. Wenn Sie operand4 bzw. operand6 weglassen, wird ab der angegebenen Stelle (operand3 bzw. operand5) bis zum Ende des Feldes übertragen.

Wenn operand2 eine dynamische Variable ist und die erste Stelle (operand5) der aktuellen Länge der Variable plus 1 entspricht, was bedeutet, dass die MOVE-Operation verwendet wird, um die Länge der Variablen zu vergrößern, muss operand6 angegeben werden, um die neue Länge der Variablen zu bestimmen.

Anmerkung:
MOVE mit SUBSTRING-Option ist eine Byte-für-Byte-Übertragung (d.h. die unter Arithmetische Operationen im Leitfaden zur Programmierung beschriebenen Regeln gelten hierbei nicht).

Syntax 3 - MOVE BY NAME / POSITION

MOVE BY

[NAME]

operand1 TO operand2
POSITION

Operanden-Definitionstabelle:

Operand Mögliche Struktur Mögliche Formate Referenzierung erlaubt Dynam. Definition
operand1       G                           ja nein
operand2       G                           ja nein

Syntax-Element-Beschreibung:

MOVE BY NAME operand1 TO operand2
Positionsunabhängige Übertragung:

Mit dieser Option können Sie einzelne in einer Datenstruktur enthaltene Felder in eine andere Datenstruktur übertragen, und zwar unabhängig von ihrer Position innerhalb der Struktur.

Ein Feld kann nur übertragen werden, wenn sein Name in beiden Datenstrukturen vorkommt (dies gilt auch für mit einem REDEFINE-Statement redefinierte Felder sowie Felder, die aus einer Redefinition resultieren). Die einzelnen Felder können jedes beliebige Format haben. Die beiden Operanden können auch Views sein.

Anmerkung:
Die Reihenfolge der einzelnen Übertragungen ergibt sich aus der Reihenfolge der Felder in operand1

Siehe auch Beispiel 2 − Statement MOVE BY NAME.

MOVE BY NAME mit Arrays:

Enthalten die Datenstrukturen Arrays, so werden diese bei der Übertragung intern mit Index (*) versehen; dies kann zu einem Fehler führen, falls die Arrays nicht den Zuweisungsbedingungen für Arrays (siehe Abschnitt Verarbeitung von Arrays im Leitfaden zur Programmierung) entsprechen.

Siehe auch Beispiel 3 − MOVE BY NAME mit Arrays.

MOVE BY POSITION operand1 TO operand2
Positionsabhängige Übertragung:

Mit dieser Option können Sie Werte von Feldern einer Gruppe in Felder einer anderen Gruppe übertragen, und zwar unabhängig von den Namen der Felder.

Die Werte werden Feld für Feld von einer Gruppe in die andere übertragen, und zwar in der Reihenfolge, in der die Felder definiert sind (Felder, die aus einer Redefinition resultieren, werden dabei nicht berücksichtigt).

Die einzelnen Felder können jedes beliebige Format haben. Die Anzahl der Felder in beiden Gruppen muss gleich sein; auch die Level-Struktur und die Array-Dimensionen der Felder müssen einander entsprechen. Format- Umsetzungen erfolgen entsprechend der im Natural Statements-Handbuch beschriebenen Regeln für arithmetische Operationen. Die beiden Operanden können auch Views sein.

Siehe auch Beispiel 4 − MOVE BY POSITION.

Syntax 4 − MOVE EDITED (Editiermaske mit operand2 angegeben)

MOVE EDITED operand1 TO operand2 (EM=value)

Operanden-Definitionstabelle:

Operand Mögliche Struktur Mögliche Formate Referenzierung erlaubt Dynam. Definition
operand1 C S A     A U         B             ja nein
operand2   S A     A U N P I F B D T L       ja ja

Syntax-Element-Beschreibung:

MOVE EDITED
Übertragung mit Editiermaske:

Ist für operand2 eine Editiermaske definiert, so wird der Wert von operand1 unter Verwendung dieser Editiermaske in das Feld operand2 übertragen.

Die Editiermaske kann als eine Eingabe-Editiermaske für operand2 angesehen werden, die dazu dient anzugeben, an welchen Stellen in dem alphanumerischen Inhalt von operand1 der signifikante Input für operand2 zu finden ist.

Wenn die Editiermaske mehr Zeichen oder Ziffern enthält, als in operand2 vorhanden sind, erfolgt eine entsprechende Abschneidung. Die Länge von operand1 darf nicht kleiner sein als die von der Editiermaske dargestellte Länge des Eingabewertes. Wenn die Länge von operand1 die Länge der Editiermaske übersteigt, werden alle darüber hinaus gehenden Daten ignoriert.

Unter der Voraussetzung, dass die Länge von operand1 nicht die Länge der Editiermaske übersteigt, kann man die Operation

MOVE EDITED operand1 TO operand2 (EM=value)

als Ausführung der folgenden Operation ansehen:

STACK TOP DATA operand1
INPUT operand2 (EM=value)

Siehe auch Beispiel 1 − Verschiedene Beispiele für die Benutzung des MOVE-Statements.

EM
Parameter für Editiermaske:

Einzelheiten zu Editiermasken finden Sie unter dem Session-ParameterEM in der Parameter-Referenz.

Syntax 5 − MOVE EDITED (Editiermaske mit operand1 angegeben)

MOVE EDITED operand1 (EM=value) TO operand2

Operanden-Definitionstabelle:

Operand Mögliche Struktur Mögliche Formate Referenzierung erlaubt Dynam. Definition
operand1 C S A   N A U N P I F B D T L       ja nein
operand2   S A     A U         B             ja ja

Syntax-Element-Beschreibung:

MOVE EDITED
Übertragung mit Editiermaske:

Ist für operand1 eine Editiermaske definiert, wird diese Editiermaske auf operand1 angewandt und der Wert anschließend in operand2 übertragen.

Die Editiermaske kann als eine Ausgabe-Editiermaske für operand1 angesehen werden, die dazu dient, eine alphanumerische Zeichenkette mit dem/der durch die Editiermaske festegelegten Layout/Länge zu erstellen. Außer den aus operand1 stammenden Datenzeichen oder -ziffern können Sie zusätzliche ausschmückende Zeichen in die Ausgabe-Zeichenkette aufnehmen.

Wenn die Editiermaske mehr Zeichen referenziert, als in operand1 vorhanden sind, erfolgt eine entsprechende Abschneidung. Die Länge der erstellten Ausgabe-Zeichenkette (die sich nach Anwendung der Editiermaske aus dem Wert von operand1 ergibt) darf nicht die Länge von operand2 übersteigen.

Unter der Voraussetzung, dass die Länge von operand2 nicht kleiner ist als die Länge der Editiermaske, kann man die Operation

MOVE EDITED operand1 (EM=value) TO operand2

als eine Operation

WRITE operand1 (EM=value)

betrachten, bei der die Ausgabe nicht auf den Schirm erfolgt, sondern in die Variable operand2 geschrieben wird.

Siehe auch Beispiel 1 − Verschiedene Beispiele für die Benutzung des MOVE-Statements.

EM
Parameter für Editiermaske:

Einzelheiten zu Editiermasken finden Sie unter dem Session-Parameter EM in der Parameter-Referenz.

Syntax 6 - MOVE LEFT / RIGHT JUSTIFIED

(Wertübertragung mit links- oder rechtsbündiger Ausrichtung)

MOVE

LEFT

[JUSTIFIED] operand1 [(parameter)] TO operand2
RIGHT

Operanden-Definitionstabelle:

Operand Mögliche Struktur Mögliche Formate Referenzierung erlaubt Dynam. Definition
operand1 C S A   N A U N P I F B D T L       ja nein
operand2   S A     A U                       ja ja

Syntax-Element-Beschreibung:

MOVE LEFT / RIGHT JUSTIFIED
Ausrichtung:

Mit dieser Option können Sie festlegen, ob der übertragene Wert in operand2 links- oder rechtsbündig ausgerichtet werden soll.

MOVE LEFT/RIGHT JUSTIFIED kann nicht benutzt werden, wenn operand2 eine dynamische Variable ist.

MOVE LEFT JUSTIFIED
Linksbündig:

Bei MOVE LEFT JUSTIFIED werden vorangestellte Leerzeichen in operand1 entfernt (auf Großrechnern werden Leerzeichen und binäre Nullen entfernt), bevor der Wert linksbündig in operand2 übertragen wird. Der Rest von operand2 wird dann gegebenenfalls mit Leerzeichen aufgefüllt. Falls der Wert länger als operand2 ist, wird der Wert rechts abgeschnitten.

MOVE RIGHT JUSTIFIED
Rechtsbündig:

Bei MOVE RIGHT JUSTIFIED werden nachfolgende Leerzeichen in operand1 entfernt (auf Großrechnern werden Leerzeichen und binäre Nullen entfernt), bevor der Wert rechtsbündig in operand2 übertragen wird. Der Rest von operand2 wird dann gegebenenfalls mit Leerzeichen aufgefüllt. Falls der Wert länger als operand2 ist, wird der Wert links abgeschnitten.

Siehe auch Beispiel 1 − Verschiedene Beispiele für die Benutzung des MOVE-Statements.

parameter
Invertierte Anzeigerichtung:

Wenn Sie MOVE LEFT/RIGHT JUSTIFIED in Verbindung mit PM=I verwenden, erfolgt die Übertragung in folgenden Schritten:

  1. Falls operand1 nicht alphanumerisches Format hat, wird der Wert in alphanumerisches Format umgesetzt.

  2. Nachfolgende Leerzeichen in operand1 werden entfernt (auf Großrechnern werden Leerzeichen und binäre Nullen entfernt).

  3. Bei LEFT JUSTIFIED werden außerdem vorangestellte Leerzeichen in operand1 entfernt (auf Großrechnern werden Leerzeichen und binäre Nullen entfernt).

  4. Der Wert wird umgedreht und dann in operand2 übertragen.

  5. Gegebenenfalls wird operand2 mit Leerzeichen aufgefüllt oder der Wert abgeschnitten (vgl. oben).

Syntax 7 - MOVE NORMALIZED

Das Statement MOVE NORMALIZED konvertiert eine Unicode-Zeichenkette in die Unicode Normalization Form C (NFC). Die sich daraus ergebende Unicode-Zeichenkette enthält keine Kombinationssequenzen für Zeichen mehr, die als vordefinierte Zeichen zur Verfügung stehen.

Wenn das Format des Zieloperanden selbst kein Unicode ist, findet eine implizite Konvertierung von Unicode in das Codepage-Format des Zieloperanden statt − während dieser Konvertierung wird die Standard-Codepage (siehe Systemvariable *CODEPAGE) benutzt.

Weitere Informationen zum Statement MOVE NORMALIZED siehe Abschnitt Statements in der Unicode and Code Page Support-Dokumentation.

Syntax-Diagram:

MOVE NORMALIZED operand1 TO operand2

Operanden-Definitionstabelle:

Operand Mögliche Struktur Mögliche Formate Referenzierung erlaubt Dynam. Definition
operand1 C S A       U                       ja nein
operand2   S A     A U                       ja ja

Syntax-Element-Beschreibung:

MOVE NORMALIZED
Konvertierung von Unicode-Feldern:

Diese Option dient zum Konvertieren von Unicode-Feldern mit potenziell unnormalisiertem Inhalt in die Unicode Normalization Form C (NFC).

Diese zusammengesetzte Form einer Unicode-Zeichenkette enthält keine Kombinationssequenzen für Zeichen, die als vordefinierte Zeichen zur Verfügung stehen.

Siehe auch http://www.unicode.org/reports/tr15/#Canonical_Composition_Examples (Normalization Forms D and C Examples).

Beispiel:

MOVE NORMALIZED #SCR TO #TGT
operand1
Zu konvertierende Unicode-Zeichenkette:

operand1 enthält die zu konvertierende Unicode-Zeichenkette.

operand2
Konvertierte Zeichenkette:

operand2 (Zieloperand) dient zur Aufnahme der konvertierten Zeichenkette.

Beispiel:

Einige Codepunkte haben unterschiedliche Darstellungen im Unicode. Zum Beispiel der deutsche Buchstabe Ä: die aufgelöste Darstellung im Unicode ist U+0041, gefolgt von U+0308, bei der ein Kombinationszeichen (U+0308) benutzt wird; eine andere Darstellung ist das vordefinierte Zeichen U+00C4. Das Statement MOVE NORMALIZED konvertiert die Unicode-Darstellung mit Kombinationszeichen in eine standardisierte Unicode-Darstellung mittels vordefinierter Zeichen, wo möglich.

Syntax 8 - MOVE ENCODED

Dieser Abschnitt erläutert die Syntax des Statements MOVE ENCODED.

Weitere Informationen zum Statement MOVE ENCODED siehe Abschnitt Statements in der Unicode and Code Page Support-Dokumentation.

Syntax-Diagram:

MOVE ENCODED
   operand1 [[IN] CODEPAGE operand2] TO
   operand3 [[IN] CODEPAGE operand4]
   [GIVING operand5]

Operanden-Definitionstabelle:

Operand Mögliche Struktur Mögliche Formate Referenzierung erlaubt Dynam. Definition
operand1 C S A     A U B                     ja nein
operand2   S       A U                       ja nein
operand3   S       A U B                     ja ja
operand4   S A     A U                       ja nein
operand5   S             I4                   ja ja

Syntax-Element-Beschreibung:

MOVE ENCODED
Codepage-Umsetzung:

Das Statement MOVE ENCODED setzt eine in einer Codepage kodierte Zeichenkette in die äquivalente Zeichenkette einer anderen Codepage um.

Anmerkung:
Natural verwendet für die Unicode-Konvertierung die International Components for Unicode (ICU) Library. Weitere Informationen siehe http://icu.sourceforge.net/userguide/.

operand1
Umzusetzende Zeichenkette:

operand1 enthält die umzusetzende Zeichenkette.

[IN] CODEPAGE operand2
Codepage der umzusetzenden Zeichenkette:

Die Codepage von operand1 kann nur angegeben werden, wenn operand1 das Format A oder B hat. Siehe Anmerkung 1 und 3.

TO operand3
Umgesetzte Zeichenkette:

Wenn das Ergebnis der Umsetzung nicht in das Zielfeld (operand3) passt, wird das Ergebnis aufgefüllt bzw. abgeschnitten, und als Füllzeichen wird das Leerzeichen der sich daraus ergebenden Codepage benutzt.

Wenn das Zielfeld als eine dynamische Variable definiert wird, ist kein Auffüllen oder Abschneiden erforderlich, da die Länge der dynamischen Variablen automatisch an die Länge des Ergebnisses der Konvertierung angepasst wird.

[IN] CODEPAGE operand4
Codepage der umgesetzten Zeichenkette:

Die Codepage von operand3 kann nur angegeben werden, wenn operand3 das Format A oder B hat. Siehe Anmerkung 1 und 3.

GIVING operand5
GIVING-Klausel:

Ohne das Schlüsselwort GIVING wird im Falle eines Fehlers eine Natural- Fehlermeldung zurückgegeben. Wenn das Schlüsselwort GIVING benutzt wird, gibt operand5 eine 0 oder den Natural-Fehlercode anstatt der Natural-Fehlermeldung zurück.

Wenn der Zieloperand abgeschnitten wird, wird keine Natural-Fehlermeldung ausgegeben, aber wenn das Schlüsselwort GIVING benutzt wird, enthält operand5 einen entsprechenden Fehlerkode, um auf ein Abschneiden hinzuweisen.

Anmerkungen:

  1. Wenn kein Codepage-Operand angegeben wird, dann wird die voreingestellte (Default-)Codepage (Wert der Systemvariablen *CODEPAGE) benutzt.
  2. Wenn der Session-Parameter CPCVERR in dem Statement SET GLOBALS oder in dem Systemkommando GLOBALS auf ON gesetzt ist, wird ein Fehler ausgegeben, wenn mindestens ein Zeichen des Ausgangsfeldes nicht ordnungsgemäß in die Ziel-Codepage umgesetzt werden konnte, sondern im Zielfeld durch ein Ersetzungszeichen ersetzt wurde.
  3. Nur mit dem Makro NTCPAGE im Quellmodul NATCONFG definierte Codepage-Namen können benutzt werden. Andere Codepage-Namen werden mit einem entsprechenden Laufzeitfehler zurückgewiesen.

Beispiele:

MOVE ENCODED A-FIELD1 TO A-FIELD2

Ungültig: Dies führt zu einem Syntaxfehler, da die Codepage-Namen standardmäßig übernommen werden und für operand1 und operand3 identisch sind.

MOVE ENCODED A-FIELD1 CODEPAGE 'IBM01140' TO A-FIELD2 CODEPAGE 'IBM01140'

Ungültig: Dies führt zu einem Fehler, da die kodierten Codepage-Namen für operand1 und operand3 identisch sind.

MOVE ENCODED A-FIELD1 CODEPAGE 'IBM01140' TO A-FIELD2 CODEPAGE 'IBM037'

Gültig: Die Zeichenkette in A−FIELD1 (kodiert in IBM01140) wird in A−FIELD2 (kodiert in IBM037) konvertiert.

MOVE ENCODED U-FIELD TO U-FIELD

Ungültig: Dies führt zu einem Fehler, da mindestens ein Operand vom Format A oder B sein muss.

MOVE ENCODED U-FIELD TO A-FIELD

Gültig: Die Unicode-Zeichenkette in U−FIELD wird angesichts der Tatsache, dass sie in UTF-16 kodiert ist, in das alphanumerische A−FIELD in der Standard-Codepage (*CODEPAGE) konvertiert.

MOVE ENCODED A-FIELD TO U-FIELD

Gültig: Die Zeichenkette in A−FIELD wird angesichts der Tatsache, dass sie in der Standard-Codepage (*CODEPAGE) kodiert ist, in das Unicode-Feld U−FIELD konvertiert.

MOVE ENCODED A100-FIELD CODEPAGE 'IBM1140' TO A50-FIELD CODEPAGE 'IBM037'

Gültig: Die Konvertierung erfolgt mittels der betreffenden Codepages von A100−FIELD (Format/Länge: A100) in A50−FIELD (Format/Länge: A50). Der Zieloperand wird abgeschnitten. Keine Natural-Fehlermeldung wird zurückgegeben.

MOVE ENCODED A100-FIELD CODEPAGE 'IBM1140' TO A50-FIELD CODEPAGE 'IBM037' GIVING RC-FIELD

Gültig: Die Konvertierung erfolgt mittels der betreffenden Codepages von A100−FIELD (Format/Länge: A100) in A50−FIELD (Format/Länge: A50). Das Ziel wird abgeschnitten. Da eine GIVING-Klausel angegeben wird, erhält das RC−FIELD einen Fehlerkode, der darauf hinweist, dass in diesem Fall Werte abgeschnitten wurden.

Seitenanfang

Beispiele

Beispiel 1 — Verschiedene Beispiele für die Benutzung des MOVE-Statements

** Example 'MOVEX1': MOVE                                               
************************************************************************
DEFINE DATA LOCAL                                                       
1 #A (N3)                                                               
1 #B (A5)                                                               
1 #C (A2)                                                               
1 #D (A7)                                                               
1 #E (N1.0)                                                             
1 #F (A5)                                                               
1 #G (N3.2)                                                             
1 #H (A6)                                                               
END-DEFINE                                                              
*                                                                       
MOVE 5 TO #A                                                            
WRITE NOTITLE 'MOVE 5 TO #A'      30X '=' #A                            
*                                                                       
MOVE 'ABCDE' TO #B #C #D                                                
WRITE 'MOVE ABCDE TO #B #C #D'    20X '=' #B '=' #C '=' #D              
*                                                                       
MOVE -1  TO #E                                             
WRITE 'MOVE -1  TO #E'            28X '=' #E               
*                                                          
MOVE ROUNDED 1.995 TO #E                                   
WRITE 'MOVE ROUNDED 1.995 TO #E'  18X '=' #E               
*                                                          
*                                                          
MOVE RIGHT JUSTIFIED 'ABC' TO #F                           
WRITE 'MOVE RIGHT JUSTIFIED ''ABC'' TO #F'       10X '=' #F
*                                                          
MOVE EDITED '003.45' TO #G (EM=999.99)                     
WRITE 'MOVE EDITED ''003.45'' TO #G (EM=999.99)'  4X '=' #G
*                                                          
MOVE EDITED 123.45 (EM=999.99) TO #H                      
WRITE 'MOVE EDITED 123.45 (EM=999.99) TO #H'      6X '=' #H
*                                                          
END                                   

Ausgabe des Programms MOVEX1:

MOVE 5 TO #A                              #A:    5                  
MOVE ABCDE TO #B #C #D                    #B: ABCDE #C: AB #D: ABCDE
MOVE -1  TO #E                            #E: -1                    
MOVE ROUNDED 1.995 TO #E                  #E:  2                    
MOVE RIGHT JUSTIFIED 'ABC' TO #F          #F:   ABC                 
MOVE EDITED '003.45' TO #G (EM=999.99)    #G:    3.45               
MOVE EDITED 123.45 (EM=999.99) TO #H      #H: 123.45            

Beispiel 2 — MOVE BY NAME

** Example 'MOVEX2': MOVE BY NAME                                       
************************************************************************
DEFINE DATA LOCAL                                                       
1 #SBLOCK                                                               
  2 #FIELDA (A10) INIT <'AAAAAAAAAA'>                                   
  2 #FIELDB (A10) INIT <'BBBBBBBBBB'>                                   
  2 #FIELDC (A10) INIT <'CCCCCCCCCC'>                                   
  2 #FIELDD (A10) INIT <'DDDDDDDDDD'>                                   
1 #TBLOCK                                                               
  2 #FIELD1 (A15) INIT <' '>                                            
  2 #FIELDA (A10) INIT <' '>                                            
  2 #FIELD2 (A10) INIT <' '>                                            
  2 #FIELDB (A10) INIT <' '>                                            
  2 #FIELD3 (A20) INIT <' '>                                            
  2 #FIELDC (A10) INIT <' '>                                            
END-DEFINE                                                              
*                                                                       
MOVE BY NAME #SBLOCK TO #TBLOCK                                      
*                                                                       
WRITE NOTITLE 'CONTENTS OF #TBLOCK AFTER MOVE BY NAME:'
       // '=' #TBLOCK.#FIELD1                          
        / '=' #TBLOCK.#FIELDA                          
        / '=' #TBLOCK.#FIELD2                          
        / '=' #TBLOCK.#FIELDB                          
        / '=' #TBLOCK.#FIELD3                          
        / '=' #TBLOCK.#FIELDC                          
*                                                      
END                                                   

Inhalt von #TBLOCK nach der MOVE BY NAME-Verarbeitung:

CONTENTS OF #TBLOCK AFTER MOVE BY NAME:
                                       
#FIELD1:                               
#FIELDA: AAAAAAAAAA                    
#FIELD2:                               
#FIELDB: BBBBBBBBBB                    
#FIELD3:                               
#FIELDC: CCCCCCCCCC                   

Beispiel 3 — MOVE BY NAME mit Arrays

DEFINE DATA LOCAL
  1 #GROUP1
    2 #FIELD (A10/1:10)
  1 #GROUP2
    2 #FIELD (A10/1:10)
END-DEFINE
... 
MOVE BY NAME #GROUP1 TO #GROUP2
...

In diesem Beispiel würde das MOVE-Statement intern wie folgt aufgelöst:

MOVE #GROUP1.#FIELD (*) TO #GROUP2.#FIELD (*)

Wenn ein Teil einer indizierten Gruppe in einen anderen Teil derselben Gruppe übertragen wird, kann dies zu unerwarteten Ergebnissen führen, wie im folgenden Beispiel veranschaulicht.

DEFINE DATA LOCAL
  1 #GROUP1 (1:5)
    2 #FIELDA (N1) INIT <1,2,3,4,5>
    2 REDEFINE #FIELDA
      3 #FIELDB (N1)
END-DEFINE
...
MOVE BY NAME #GROUP1 (2:4) TO #GROUP1 (1:3)
...

In diesem Beispiel würde das MOVE-Statement intern wie folgt aufgelöst:

MOVE #FIELDA (2:4) TO #FIELDA (1:3)
MOVE #FIELDB (2:4) TO #FIELDB (1:3)

Zunächst wird der Inhalt der Ausprägungen 2 bis 4 von #FIELDA in die Ausprägungen 1 bis 3 von #FIELDA übertragen; d.h. die Ausprägungen erhalten folgende Werte:

Ausprägung: 1. 2. 3. 4. 5.
Wert vorher: 1 2 3 4 5
Wert nachher: 2 3 4 4 5

Dann wird der Inhalt der Ausprägungen 2 bis 4 von #FIELDB in die Ausprägungen 1 bis 3 von #FIELDB übertragen; d.h. die Ausprägungen erhalten folgende Werte:

Ausprägung: 1. 2. 3. 4. 5.
Wert vorher: 2 3 4 4 5
Wert nachher: 3 4 4 4 5

Beispiel 4 — MOVE BY POSITION

DEFINE DATA LOCAL
  1 #GROUP1
    2 #FIELD1A (N5)
    2 #FIELD1B (A3/1:3)
    2 REDEFINE #FIELD1B
      3 #FIELD1BR (A9)
  1 #GROUP2
    2 #FIELD2A (N5)
    2 #FIELD2B (A3/1:3)
    2 REDEFINE #FIELD2B
      3 #FIELD2BR (A9)
END-DEFINE
...
MOVE BY POSITION #GROUP1 TO #GROUP2   
...

In diesem Beispiel wird der Inhalt von #FIELD1A in #FIELD2A übertragen, und der Inhalt von #FIELD1B in #FIELD2B; die Felder #FIELD1BR und #FIELD2BR sind davon nicht betroffen.

Seitenanfang