MOVE

#### Search Results

Search

# MOVE

Dieses Dokument behandelt folgende Themen:

- Funktion MOVE

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

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

Gehört zur Funktionsgruppe: Arithmetische Funktionen und Datenzuweisungen

## Funktion MOVE

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
--- | ---
`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/U) 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-Codeeinheiten, 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-Codeeinheiten, 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` 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
--- | ---
`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
--- | ---
`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
--- | ---
`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 siehe Unicode- und Codepage-Unterstützung in der Natural-Programmiersprache, Abschnitt Natural-Statements, Unterabschnitt `MOVE NORMALIZED` in der Unicode- und Codepage-Unterstützung-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
--- | ---
`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 umzuwandelnde Unicode-Zeichenkette.
`operand2` | Zieloperand: Der Zieloperand `operand2` dient zur Aufnahme der umgewandelten Unicode-Zeichenkette.

Beispiel:

Einige Codepunkte haben unterschiedliche Darstellungen in Unicode. Zum Beispiel der deutsche Buchstabe `Ä`: die getrennte Darstellung im Unicode ist `U+0041`, gefolgt von `U+0308`, bei der ein zusamengesetztes Zeichen (`U+0308`) benutzt wird; eine andere Darstellung ist das vorher zusammengesetzte Zeichen `U+00C4`. Das Statement `MOVE NORMALIZED` wandelt die Unicode-Darstellung mit zusamengesetzten Zeichen in eine standardisierte Unicode-Darstellung mittels vorher zusammengesetzter Zeichen, wo immer dies möglich ist.

## Syntax 8 - MOVE ENCODED

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

Weitere Informationen siehe Unicode- und Codepage-Unterstützung in der Natural-Programmiersprache, Abschnitt Natural-Statements, Unterabschnitt `MOVE ENCODED` in der Unicode- und Codepage-Unterstützung-Dokumentation.

Syntax-Diagramm:

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

1. Wenn kein Codepage-Operand angegeben wird, dann wird die voreingestellte (Standard-)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 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 | N1 |  |  |  | B |  |  |  |  |  |  | yes | no
`operand2` |  | S | A |  |  | A | U |  |  |  |  | B |  |  |  |  |  |  | yes | yes
`operand3` | C | S |  |  |  |  |  | N | P | I |  | B2 |  |  |  |  |  |  | yes | no
`operand4` | C | S |  |  |  |  |  | N | P | I |  | B2 |  |  |  |  |  |  | yes | no
`operand5` | C | S |  |  |  |  |  | N | P | I |  | B2 |  |  |  |  |  |  | yes | no
`operand6` | C | S |  |  |  |  |  | N | P | I |  | B2 |  |  |  |  |  |  | yes | no
`operand7` | C | S |  |  |  |  |  | N | P | I |  |  |  |  |  |  |  |  | yes | no

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

2 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
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 MOVE

- 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

### On this page

- Funktion MOVE
- 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 MOVE