
	Version 6.3.8 für Windows	SUCHEN INHALT \| PDF-SEITE PDF-BÜCHER \| HOME HOCH ZURÜCK VOR

— Statements —

MOVE

Dieses Dokument behandelt folgende Themen:

Funktion
Syntax-Beschreibung
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 (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.

Syntax-Beschreibung

Das MOVE-Statement bietet mehrere Syntax-Varianten:

Syntax 1 — MOVE ROUNDED
Syntax 2 - MOVE SUBSTRING
Syntax 3 - MOVE BY NAME / POSITION
Syntax 4 − MOVE EDITED (Editiermaske mit operand2 angegeben)
Syntax 5 − MOVE EDITED (Editiermaske mit operand1 angegeben)
Syntax 6 - MOVE LEFT / RIGHT JUSTIFIED
Syntax 7 - MOVE NORMALIZED
Syntax 8 - MOVE ENCODED

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).

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.

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

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-Parameter`EM` in der Parameter-Referenz.
EMU	Parameter für Editiermaske: Einzelheiten zu Editiermasken finden Sie unter dem Session-Parameter `EMU` in der Parameter-Referenz.

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.

Parameter für Editiermaske:

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

EMU

Parameter für Editiermaske:

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

Syntax 5 − MOVE EDITED (Editiermaske mit `operand1` angegeben)

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

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.
EMU	Parameter für Editiermaske: Einzelheiten zu Editiermasken finden Sie unter dem Session-Parameter `EMU` in der Parameter-Referenz.

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.

Parameter für Editiermaske:

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

EMU

Parameter für Editiermaske:

Einzelheiten zu Editiermasken finden Sie unter dem Session-Parameter EMU 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: Falls `operand1` nicht alphanumerisches Format hat, wird der Wert in alphanumerisches 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-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.

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

Wenn kein Codepage-Operand angegeben wird, dann wird die voreingestellte (Default-)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.

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.

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 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.

SUCHEN INHALT | PDF-SEITE PDF-BÜCHER | HOME HOCH ZURÜCK VOR

MOVE

Funktion

Weitere Hinweise

Syntax-Beschreibung

Syntax 1 — MOVE ROUNDED

Syntax 2 - MOVE SUBSTRING

Syntax 3 - MOVE BY NAME / POSITION

Syntax 4 − MOVE EDITED (Editiermaske mit operand2 angegeben)

Syntax 5 − MOVE EDITED (Editiermaske mit operand1 angegeben)

Syntax 6 - MOVE LEFT / RIGHT JUSTIFIED

Syntax 7 - MOVE NORMALIZED

Syntax 8 - MOVE ENCODED

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

Syntax 4 − MOVE EDITED (Editiermaske mit `operand2` angegeben)

Syntax 5 − MOVE EDITED (Editiermaske mit `operand1` angegeben)