MOVE

Dieses Dokument behandelt folgende Themen:

Funktion
Syntax 1 - MOVE
Syntax 2 - MOVE SUBSTRING
Syntax 3 - MOVE BY NAME / POSITION
Syntax 4 − MOVE EDITED (Editiermaske bei operand2)
Syntax 5 − MOVE EDITED (Editiermaske bei operand1)
Syntax 6 - MOVE LEFT / RIGHT JUSTIFIED
Syntax 7 - MOVE NORMALIZED
Syntax 8 - MOVE ENCODED
Syntax 9 - MOVE ALL
Beispiele

Gehört zur Funktionsgruppe: Arithmetische Funktionen und Datenzuweisungen

Funktion

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

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

Siehe auch Abschnitt Regeln für arithmetische Operationen im Leitfaden zur Programmierung.

Syntax 1 - MOVE

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

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

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:

Syntax-Element Beschreibung

MOVE
                                       ROUNDED

MOVE ROUNDED-Option:

Diese Option bewirkt, dass operand2 gerundet wird.

ROUNDED wird ignoriert, wenn operand2 nicht numerisch ist oder wenn der Quelloperand dieselben oder weniger Präzisionsstellen als der Zieloperand hat.

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

operand1
operand2

Quell- und Zieloperanden:

operand1 ist der Quelloperand, dessen Wert in den Zieloperanden operand2 übertragen wird.

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.

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 Systemvariablen *LENGTH bestimmt werden. Allgemeine Informationen zu dynamischen Variablen siehe den Abschnitt Dynamische und große Variablen benutzen im Leitfaden zur Programmierung.

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

parameter

Parameter-Option:

Als parameter können Sie den Session-Parameter PM oder den Session-Parameter DF angeben:

PM=I

Schreibrichtung-Option:

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=S|I|L

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.

Syntax 2 - MOVE SUBSTRING

`MOVE`		`operand1` `SUBSTRING` (`operand1,operand3,operand4`)	[(`parameter`)]
	`TO`	`operand2` `SUBSTRING` (`operand2`,`operand5`,`operand6`)

Diese Syntax gilt, wenn Sie nur einen Teil des Feldinihalts (einen Teil einer Zzeichenkette) eines Quell- und/oder Zieloperanden übertragen wollen. Anderfalls gilt Syntax 1.

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

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:

Syntax Element Description

Syntax Element	Description
`MOVE SUBSTRING`	MOVE SUBSTRING: Ohne `SUBSTRING`-Option wird der ganze Inhalt des Feldes übertragen. Die `SUBSTRING`-Option ermöglicht es Ihnen, nur einen bestimmten Teil eines alphanumerischen oder eines Unicode-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/Unicode (A) oder binär (B) ist, gelten die mit `operand3` oder `operand4` angegebenen Werte als Byte-Zahlen; Wenn das zugrundeliegende Feldformat von `operand1` Unicode (U) ist, gelten die mit `operand3` oder `operand4` als Zahlen in Unicode-Code-Einheiten, d.h. als Doppelbytes. Um zum Beispiel die 5. bis einschließlich 12. Stelle eines Feldes `#A` in ein Feld `#B` zu übertragen, geben Sie Folgendes an: 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/Unicode oder binären 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/Unicode (A/U) oder binär (B) ist, gelten die mit `operand5` oder `operand6` angegebenen Werte als Byte-Zahlen. Wenn das zugrundeliegende Feldformat von `operand2` Unicode (U) ist, gelten die mit `operand3` oder `operand4` als Zahlen in Unicode-Code-Einheiten, d.h. als Doppelbytes. Um zum Beispiel den Wert eines Feldes `#A` in die 3. bis einschließlich 6. Stelle eines Feld `#B` zu übertragen, geben Sie Folgendes an: 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 größere 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`/`operand5` oder `operand4`/`operand6` eine binäre Variable ist, kann sie nur mit einer Länge kleiner als oder gleich 4 benutzt werden. Wenn Sie `operand3`/`operand5` weglassen, wird ab der ersten Stelle des Feldes übertragen. Wenn Sie `operand4`/`operand6` weglassen, wird ab der angegebenen Stelle 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 erhöhen, muss `operand6` angegeben werden, um die neue Länge der Variablen zu bestimmen. Anmerkung: `MOVE` with the `SUBSTRING` option is a byte-by-byte move (that is, the rules described under Rules for Arithmetic Assignment in the Programming Guide do not apply). Anmerkung: `MOVE` mit `SUBSTRING`-Option bewirkt eine Byte-für-Byte-Übertragung (d.h. die unter Arithmetische Operationen im Leitfaden zur Programmierung beschriebenen Regeln gelten hier nicht).
`parameter`	Parameter-Option: Siehe `parameter` unter Syntax 1.

MOVE
                                       SUBSTRING

MOVE SUBSTRING:

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

Die SUBSTRING-Option ermöglicht es Ihnen, nur einen bestimmten Teil eines alphanumerischen oder eines Unicode-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/Unicode (A) oder binär (B) ist, gelten die mit operand3 oder operand4 angegebenen Werte als Byte-Zahlen;
Wenn das zugrundeliegende Feldformat von operand1 Unicode (U) ist, gelten die mit operand3 oder operand4 als Zahlen in Unicode-Code-Einheiten, d.h. als Doppelbytes.

Um zum Beispiel die 5. bis einschließlich 12. Stelle eines Feldes #A in ein Feld #B zu übertragen, geben Sie Folgendes an:

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/Unicode oder binären 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/Unicode (A/U) oder binär (B) ist, gelten die mit operand5 oder operand6 angegebenen Werte als Byte-Zahlen.
Wenn das zugrundeliegende Feldformat von operand2 Unicode (U) ist, gelten die mit operand3 oder operand4 als Zahlen in Unicode-Code-Einheiten, d.h. als Doppelbytes.

Um zum Beispiel den Wert eines Feldes #A in die 3. bis einschließlich 6. Stelle eines Feld #B zu übertragen, geben Sie Folgendes an:

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 größere 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/operand5 oder operand4/operand6 eine binäre Variable ist, kann sie nur mit einer Länge kleiner als oder gleich 4 benutzt werden.

Wenn Sie operand3/operand5 weglassen, wird ab der ersten Stelle des Feldes übertragen. Wenn Sie operand4/operand6 weglassen, wird ab der angegebenen Stelle 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 erhöhen, muss operand6 angegeben werden, um die neue Länge der Variablen zu bestimmen.

Anmerkung:
MOVE with the SUBSTRING option is a byte-by-byte move (that is, the rules described under Rules for Arithmetic Assignment in the Programming Guide do not apply).

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

parameter

Parameter-Option:

Siehe parameter unter Syntax 1.

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:

Syntax-Element Beschreibung

Syntax-Element	Beschreibung
`MOVE BY NAME operand1 TO operand2`	MOVE BY NAME-Option: 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 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 dem Index (*) versehen; dies kann zu einem Fehler führen, falls die Arrays nicht den Zuweisungsbedingungen für Arrays entsprechen (siehe Abschnitt Verarbeitung von Arrays im Leitfaden zur Programmierung). Siehe auch Beispiel 3 − MOVE BY NAME mit Arrays.
`MOVE BY POSITION operand1 TO operand2`	MOVE BY POSITION-Option: 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 Regeln für arithmetische Operationen (siehe Arithmetische Operationen im Leitfaden zur Programmierung). Die beiden Operanden können auch Views sein. Siehe auch Beispiel 4 − MOVE BY POSITION.

MOVE BY NAME operand1 TO
                                       operand2

MOVE BY NAME-Option:

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 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 dem Index (*) versehen; dies kann zu einem Fehler führen, falls die Arrays nicht den Zuweisungsbedingungen für Arrays entsprechen (siehe Abschnitt Verarbeitung von Arrays im Leitfaden zur Programmierung).

Siehe auch Beispiel 3 − MOVE BY NAME mit Arrays.

MOVE BY POSITION
                                       operand1 TO
                                       operand2

MOVE BY POSITION-Option:

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 Regeln für arithmetische Operationen (siehe Arithmetische Operationen im Leitfaden zur Programmierung). Die beiden Operanden können auch Views sein.

Siehe auch Beispiel 4 − MOVE BY POSITION.

Syntax 4 − MOVE EDITED (Editiermaske bei `operand2`)

`MOVE` `EDITED` `operand1` `TO` `operand2`			(`EM`=`value`)
			(`EMU`=`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:

Syntax-Element Beschreibung

Syntax-Element	Beschreibung
`MOVE EDITED`	MOVE EDITED-Option - Übertragung mit Editiermaske: Ist für `operand2` eine Editiermaske definiert, so wird der Wert von `operand1` unter Verwendung dieser Editiermaske in das Feld `operand2` gestellt. Die Editiermaske kann als eine Eingabe-Editiermaske für `operand2` angesehen werden, die dazu dient anzugeben, an welchen Stellen in dem alphanumerischen/Unicode-Inhalt von `operand1` die signifikanten Eingabedaten für `operand2` zu finden sind. 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`	Editiermaske: Einzelheiten zu Editiermasken finden Sie unter dem Session-Parameter `EM` in der Parameter-Referenz.
`EMU`	Unicode-Editiermaske: Einzelheiten zu Editiermasken finden Sie unter dem Session-Parameter `EMU` in der Parameter-Referenz.

MOVE EDITED

MOVE EDITED-Option - Übertragung mit Editiermaske:

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

Die Editiermaske kann als eine Eingabe-Editiermaske für operand2 angesehen werden, die dazu dient anzugeben, an welchen Stellen in dem alphanumerischen/Unicode-Inhalt von operand1 die signifikanten Eingabedaten für operand2 zu finden sind.

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

Editiermaske:

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

EMU

Unicode-Editiermaske:

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

Syntax 5 − MOVE EDITED (Editiermaske bei `operand1`)

`MOVE` `EDITED` `operand1`			(`EM`=`value`)		`TO` `operand2`
			(`EMU`=`value`)

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:

Syntax-Element Beschreibung

Syntax-Element	Beschreibung
`MOVE EDITED`	MOVE EDITED-Option - Ü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/Unicode-Zeichenkette mit dem/der durch die Editiermaske festgelegten 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 oder Ziffern 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`	Editiermaske: Einzelheiten zu Editiermasken finden Sie unter dem Session-Parameter `EM` in der Parameter-Referenz.
`EMU`	Unicode-Editiermaske: Einzelheiten zu Editiermasken finden Sie unter dem Session-Parameter `EMU` in der Parameter-Referenz.

MOVE EDITED

MOVE EDITED-Option - Ü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/Unicode-Zeichenkette mit dem/der durch die Editiermaske festgelegten 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 oder Ziffern 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

Editiermaske:

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

EMU

Unicode-Editiermaske:

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

Syntax 6 - MOVE LEFT / RIGHT JUSTIFIED

`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:

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` gestellt wird. Der Rest von `operand2` wird dann 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` abgeschnitten (auf Großrechnern werden Leerzeichen und binäre Nullen entfernt), bevor der Wert rechtsbündig in `operand2` gestellt wird. Der Rest von `operand2` wird dann 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`	Parameter für invertierte Anzeigerichtung: Wenn Sie `MOVE LEFT/RIGHT JUSTIFIED` in Verbindung mit `PM=I` verwenden, erfolgt die Übertragung in folgenden Schritten: Falls `operand1` nicht alphanumerisches/Unicode-Format hat, wird der Wert in alphanumerisches/Unicode-Format umgesetzt. Nachfolgende Leerzeichen in `operand1` werden entfernt (auf Großrechnern werden Leerzeichen und binäre Nullen entfernt). Bei `LEFT JUSTIFIED` werden außerdem vorangestellte Leerzeichen in `operand1` entfernt (auf Großrechnern werden Leerzeichen und binäre Nullen entfernt). Der Wert wird umgedreht und dann in `operand2` übertragen. 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-Diagramm:

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:

Syntax-Element Beschreibung

Syntax-Element	Beschreibung
`MOVE NORMALIZED`	MOVE NORMALIZED-Option: Diese Option dient zum Konvertieren von Unicode-Feldern mit potenziell nicht normalisiertem 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`	Quelloperand: Der Quelloperand `operand1` enthält die zu konvertierende Unicode-Zeichenkette.
`operand2`	Zieloperand: Der Zieloperand `operand2` dient zur Aufnahme der konvertierten Unicode-Zeichenkette.

MOVE NORMALIZED

MOVE NORMALIZED-Option:

Diese Option dient zum Konvertieren von Unicode-Feldern mit potenziell nicht normalisiertem 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

Quelloperand:

Der Quelloperand operand1 enthält die zu konvertierende Unicode-Zeichenkette.

operand2

Zieloperand:

Der Zieloperand operand2 dient zur Aufnahme der konvertierten Unicode-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 immer dies möglich ist.

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:

Syntax Element	Description
`MOVE ENCODED`	Codepage-Umsetzung: Die Option `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: Der Quelloperand `operand1` enthält die umzusetzende Zeichenkette.
`CODEPAGE operand2`	Codepage der umzusetzenden Zeichenkette: In `operand2` geben Sie die Codepage von `operand1` an. Kann nur angegeben werden, wenn `operand1` das Format A oder B hat. Siehe Anmerkung 1 und 3.
`TO operand3`	Umgesetzte Zeichenkette: In den Zieloperanden `operand3` wird die konvertierte Zeichenkette gestellt. Wenn das Ergebnis der Umsetzung nicht in den Zieloperanden (`operand3`) passt, wird das Ergebnis aufgefüllt bzw. abgeschnitten. Als Füllzeichen wird das Leerzeichen der resultierenden Codepage benutzt. Wenn das Zielfeld als eine dynamische Variable definiert wird, ist kein Auffüllen oder Abschneiden erforderlich, da sich die Länge der dynamischen Variablen automatisch an die Länge des Ergebnisses der Konvertierung anpasst.
`CODEPAGE operand4`	Codepage der umgesetzten Zeichenkette: In `operand4` geben Sie die Codepage von `operand3` an. 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 Sie das Schlüsselwort `GIVING` angeben, gibt `operand5` eine `0` oder den Natural-Fehlercode anstelle 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:

Wenn kein Codepage-Operand angegeben wird, dann wird die voreingestellte (Standard-)Codepage (Wert der Systemvariablen *CODEPAGE) benutzt.
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.
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 für MOVE ENCODED:

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.

Syntax 9 - MOVE ALL

Das Statement MOVE ALL ermöglicht es, den Wert von operand1 so oft nach operand2 zu übertragen, bis das Zielfeld voll oder bis der UNTIL-Wert (operand7) erreicht ist.

Mit einer SUBSTRING-Klausel können Sie die MOVE ALL-Operation auf Segmente des Ausgangs- und des Zielfelds begrenzen.

Syntax-Diagram:

MOVE ALL

SUBSTRING (operand1,operand3,operand4)
operand1

TO

SUBSTRING (operand2,operand5,operand6)
operand2

[UNTIL operand7]

Anmerkung:
Die UNTIL-Option ist nicht erlaubt, wenn eine SUBSTRING-Klausel für den Zieloperanden verwendet wird.

Operanden-Definitionstabelle:

Operand	Mögliche Struktur			Mögliche Formate						Referenzierung erlaubt	Dynam. Definition
`operand1`	C	S	A	A	U	N¹			B	yes	no
`operand2`		S	A	A	U				B	yes	yes
`operand3`	C	S				N	P	I	B²	yes	no
`operand4`	C	S				N	P	I	B²	yes	no
`operand5`	C	S				N	P	I	B²	yes	no
`operand6`	C	S				N	P	I	B²	yes	no
`operand7`	C	S				N	P	I		yes	no

¹ Ein numerisches Format (N) für A operand1 ist nur dann erlaubt, wenn die SUBSTRING-Klausel nicht benutzt wird.

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

Syntax-Element-Beschreibung:

Syntax-Element	Beschreibung
`operand1`	Ausgangsoperand: Dieser Operand enthält den zu übertragenden Wert. Bei einem numerischen Operanden werden alle Stellen einschließlich vorangestellter Nullen übertragen.
`TO operand2`	Zieloperand: In diesen Operanden wird der Wert übertragen. Der vorherige Inhalt des Operanden wird vor der `MOVE ALL`-Operation nicht zurückgesetzt. Dies ist insbesondere bei Verwendung der `UNTIL`-Option zu beachten, da bereits in `operand2` enthaltene Daten dort behalten werden, es sei denn, sie werden während der `MOVE ALL`-Operation ausdrücklich überschrieben.
`UNTIL operand3`	UNTIL-Option: Mit der `UNTIL`-Option können Sie die `MOVE ALL`-Operation auf eine bestimmte Anzahl von Stellen in `operand2` begrenzen. Mit `operand3` geben Sie an, wieviele Stellen in `operand2` gefüllt werden sollen; ist diese Anzahl erreicht, wird die `MOVE ALL`-Operation beendet. Übersteigt die Länge von `operand7` die Länge von `operand2`, wird die `MOVE ALL`-Operation beendet, sobald `operand2` vollständig gefüllt ist. Die Option `UNTIL` kann auch verwendet werden, um einer dynamischen Variable einen Startwert zuzuweisen. Wenn `operand2` eine dynamische Variable ist, entspricht ihre Länge nach der `MOVE ALL`-Operation dem Wert von `operand7`. Die aktuelle Länge einer dynamischen Variable kann unter Verwendung der Systemvariablen `LENGTH` festgestellt werden. Allgemeine Informationen zu dynamischen Variablen finden Sie im Abschnitt Benutzung dynamischer Variablen.. Anmerkung:* Die `UNTIL`-Option ist nicht erlaubt, wenn für den Zieloperanden eine `SUBSTRING`-Klausel verwendet wird.
`SUBSTRING`	SUBSTR-Klausel: Mit der `SUBSTR`-Klausel können Sie ein festes Segment der Ausgangs- oder Zielvariablen in einem `MOVE ALL`-Statement auswählen, während ohne die `SUBSTRING`-Klausel der gesamte Inhalt der Ausgangs- oder Zielvariablen verarbeitet wird. `operand3` und `operand4` beschreiben die Startposition und die Länge des als Ausgangswert verwendeten Segments von `operand1`. `operand5` und `operand6` beschreiben die Startposition und die Länge des Segments von `operand2`, das bei der `MOVE ALL`-Operationgefüllt wird. Wenn die Startposition (`operand3` bzw. `operand5`) weggelassen wird, dann wird standardmäßig Position 1 als Startposition genommen. Wird die Substring-Länge (`operand4` bzw. `operand6`) weggelassen, dann wird die übrig bleibende Länge des Feldes genommen. Wenn die `SUBSTRING`-Klausel für das Ausgangsfeld verwendet wird, müssen der Startwert und die Länge (`operand3` und `operand4`) ein Datensegment beschreiben, das vollständig innerhalb von `operand5` liegt. Wenn die `SUBSTRING`-Klausel für das Zielfeld verwendet wird, gelten folgende Regeln: Wenn `operand2` eine Variable mit fester Länge ist, muss der der durch den Startwert und die Länge beschriebene Bereich (`operand5` und `operand6`) vollständig im Bereich des Feldes liegen. Wenn `operand2` eine dynamische Variable ist, kann der Startwert (`operand5`) entweder in oder unmittelbar hinter die aktuelle Feldlänge (`*LENGTH +1`) zeigen. Wenn das Ende des `SUBSTR`-Bereichs innerhalb der zugeordneten Felddaten liegt, erfolgt die Verarbeitung wie bei einem Feld mit fester Länge. Wenn das `SUBSTRING`-Ende die Größe des aktuellen Felds überschreitet, wird die dynamische Variable im gleichen Maß erweitert. Siehe auch Beispiele für die Verwendung der SUBSTRING-Klausel weiter unten.

Beispiele für die Verwendung der SUBSTRING-Klausel

DEFINE DATA LOCAL
1 ALFA (A10) INIT <'AAAAAAAAAA'>
1 DYN (A) DYNAMIC INIT <'1234567890'>
1 #VAL (A4) INIT <'1234'>
END-DEFINE

Statement	Ergebnis
Statement	Vorher	Nachher
`MOVE ALL SUBSTR(#VAL,1,2) TO ALFA`	`AAAAAAAAAA`	`1212121212`
`MOVE ALL '123' TO SUBSTR (ALFA,3,5)`	`AAAAAAAAAA`	`AA12312AAA`
`MOVE ALL 'x' TO SUBSTR (DYN,7,3)`	`1234567890` (`*LENGTH`=`10`)	`123456xxx0` (`*LENGTH`=`10`)
`MOVE ALL 'xyz' TO SUBSTR (DYN,7,6)`	`1234567890` (`*LENGTH`=`10`)	`123456xyzxyz` (`*LENGTH`=`12`)
`MOVE ALL 'xyz' TO SUBSTR (DYN,11,4)`	`1234567890` (`*LENGTH`=`10`)	`1234567890xyzx` (`*LENGTH`=`14`)

Beispiele

Beispiel 1 - Verschiedene Beispiele für die Benutzung des MOVE-Statements
Beispiel 2 - MOVE BY NAME
Beispiel 3 - MOVE BY NAME mit Arrays
Beispiel 4 - MOVE BY POSITION
Beispiel 5 - MOVE ALL

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.

Beispiel 5 - MOVE ALL

** Example 'MOAEX1': MOVE ALL                                           
************************************************************************
DEFINE DATA LOCAL                                                       
1 EMPLOY-VIEW VIEW OF EMPLOYEES                                         
  2 PERSONNEL-ID                                                        
  2 FIRST-NAME                                                          
  2 NAME                                                                
  2 CITY                                                                
1 VEH-VIEW VIEW OF VEHICLES                                             
  2 PERSONNEL-ID                                                        
  2 MAKE                                                                
END-DEFINE                                                              
*                                                                       
LIMIT 4                                                                 
RD. READ EMPLOY-VIEW BY NAME                                            
  SUSPEND IDENTICAL SUPPRESS                                            
  /*                                                                    
  FD. FIND VEH-VIEW WITH PERSONNEL-ID = PERSONNEL-ID (RD.)              
    IF NO RECORDS FOUND                                                  
      MOVE ALL '*' TO FIRST-NAME (RD.)        
      MOVE ALL '*' TO CITY (RD.)              
      MOVE ALL '*' TO MAKE (FD.)              
    END-NOREC                                 
    /*                                        
    DISPLAY NOTITLE (ES=OFF IS=ON ZP=ON AL=15)
            NAME (RD.) FIRST-NAME (RD.)       
            CITY (RD.)                        
            MAKE (FD.) (IS=OFF)               
    /*                                        
  END-FIND                                    
END-READ                                      
END

Ausgabe des Programms MOAEX1:

     NAME         FIRST-NAME         CITY            MAKE      
--------------- --------------- --------------- ---------------
                                                               
ABELLAN         *************** *************** ***************
ACHIESON        ROBERT          DERBY           FORD           
ADAM            *************** *************** ***************
ADKINSON        JEFF            BROOKLYN        GENERAL MOTORS

MOVE

Funktion

Syntax 1 - MOVE

Syntax 2 - MOVE SUBSTRING

Syntax 3 - MOVE BY NAME / POSITION

Syntax 4 − MOVE EDITED (Editiermaske bei operand2)

Syntax 5 − MOVE EDITED (Editiermaske bei operand1)

Syntax 6 - MOVE LEFT / RIGHT JUSTIFIED

Syntax 7 - MOVE NORMALIZED

Syntax 8 - MOVE ENCODED

Beispiele für MOVE ENCODED:

Syntax 9 - MOVE ALL

Beispiele für die Verwendung der SUBSTRING-Klausel

Beispiele

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

Beispiel 2 - MOVE BY NAME

Beispiel 3 - MOVE BY NAME mit Arrays

Beispiel 4 - MOVE BY POSITION

Beispiel 5 - MOVE ALL

Ausgabe des Programms MOAEX1:

Syntax 4 − MOVE EDITED (Editiermaske bei `operand2`)

Syntax 5 − MOVE EDITED (Editiermaske bei `operand1`)