MOVE

Dieses Dokument behandelt folgende Themen:

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

Gehört zur Funktionsgruppe: Arithmetische Funktionen und Datenzuweisungen


Funktion

Das Statement MOVE dient dazu, den Wert eines Operanden in einen oder mehrere andere Operanden (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-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
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:

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

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

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

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

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

Syntax 7 - MOVE NORMALIZED

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

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

Weitere Informationen 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

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