SEPARATE

#### Search Results

Search

# SEPARATE

`SEPARATE` |  | operand1 |
`SUBSTRING` (operand1,operand2,operand3)
| [[`STARTING`] `FROM` [`POSITION`] operand8] |
| [`LEFT` [`JUSTIFIED`]] `INTO` operand4
|  | `IGNORE` |  |
| `REMAINDER` operand5
`REMAINDER POSITION` operand9
|  | `WITH` [`RETAINED`] |  | [`ANY`] `DELIMITERS` |  |
| `INPUT DELIMITERS`
| `DELIMITERS` operand6
| [[`GIVING`] `NUMBER` [`IN`] operand7]

Dieses Dokument behandelt folgende Themen:

- Funktion SEPARATE

- Syntax-Beschreibung SEPARATE

- Regeln und operative Aspekte

- Beispiele SEPARATE

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

Verwandte Statements: `COMPRESS` | `COMPUTE` | `EXAMINE` | `MOVE` | `MOVE ALL` | `RESET`

Gehört zur Funktionsgruppe: Arithmetische Funktionen und Datenzuweisungen

## Funktion SEPARATE

Das Statement `SEPARATE` dient dazu, den Inhalt eines alphanumerischen oder binären Operanden auf zwei oder mehr alphanumerische oder binäre Operanden (oder auf mehrere Ausprägungen eines alphanumerischen oder binären Arrays) zu verteilen.

## Syntax-Beschreibung SEPARATE

Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referenzierung erlaubt | Dynam. Definition
--- | --- | --- | --- | ---
`operand1` | C | S | A |  |  | A | U |  |  |  |  | B |  |  |  |  |  |  | ja | nein
`operand2` | C | S |  |  |  |  |  | N | P | I |  | B* |  |  |  |  |  |  | ja | nein
`operand3` | C | S |  |  |  |  |  | N | P | I |  | B* |  |  |  |  |  |  | ja | nein
`operand4` |  | S | A | G |  | A | U |  |  |  |  | B |  |  |  |  |  |  | ja | ja
`operand5` |  | S |  |  |  | A | U |  |  |  |  | B |  |  |  |  |  |  | ja | ja
`operand6` | C | S |  |  |  | A | U |  |  |  |  | B |  |  |  |  |  |  | ja | nein
`operand7` |  | S |  |  |  |  |  | N | P | I |  |  |  |  |  |  |  |  | ja | ja
`operand8` | C | S |  |  |  |  |  | N | P | I |  |  |  |  |  |  |  |  | ja | nein
`operand9` |  | S |  |  |  |  |  | N | P | I |  |  |  |  |  |  |  |  | ja | yes

* Format B von operand2 und operand3 können nur mit einer Länge von kleiner gleich 4 benutzt werden.

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`operand1` | Ausgangsoperand: operand1 ist die alphanumerische/binäre Konstante oder Variable, deren Inhalt aufgeteilt werden soll. Nachgestellte Leerzeichen in operand1 werden entfernt, bevor der Wert verarbeitet wird (auch wenn das Leerzeichen als Begrenzungszeichen verwendet wird; vgl. `DELIMITERS`-Option).
`SUBSTRING` | SUBSTRING-Option: Normalerweise wird der ganze Inhalt des Feldes aufgeteilt, und zwar vom Anfang des Feldes an. Die `SUBSTRING`-Option ermöglicht es Ihnen, nur einen bestimmten Teil des Feldes aufzuteilen. In der `SUBSTRING`-Klausel geben Sie nach dem Feldnamen (operand1) zunächst die erste Stelle (operand2) und dann die Länge (operand3) des Feldteils an, der aufgeteilt werden soll. Wenn z.B. ein Feld `#A` den Wert `CONTRAPTION` enthält, würde `SUBSTRING(#A,5,3)` den Wert `RAP` enthalten. Normalerweise wird der ganze Inhalt des Feldes aufgeteilt, und zwar vom Anfang des Feldes an. Anmerkung Wenn Sie operand2 weglassen, wird ab Anfang des Feldes (Position 1) aufgeteilt. Wenn Sie operand3 weglassen, wird ab der angegebenen Stelle (operand2) bis zum Ende des Feldes aufgeteilt.
`STARTING FROM POSITION operand8` | STARTING FROM POSITION-Option: Diese Option bestimmt die Startposition des aufzuteilenden Ausgangsoperanden (`operand1`). Weitere Informationen siehe Bereiche für STARTING FROM POSITION festlegen.
`LEFT JUSTIFIED` | LEFT JUSTIFIED-Option: Diese Option bewirkt, dass den aufgeteilten Feldwertteilen vorangestellte Leerzeichen aus den Zieloperanden entfernt werden.
`operand4` | Zieloperand: operand4 enthält die Zieloperanden, die die Teile des Ausgangsoperanden aufnehmen sollen. Wird als Zieloperand ein Array verwendet, wird es Ausprägung für Ausprägung mit den übertragenen Feldwertteilen gefüllt. Die Anzahl der Zieloperanden entspricht der Anzahl der Begrenzungszeichen (einschließlich nachgestellter Begrenzungszeichen) in operand1, plus 1. Ist operand4 eine dynamische Variable, kann deren Länge mit der `SEPARATE`-Operation geändert werden. Die aktuelle Länge einer dynamischen Variable kann mittels der Systemvariable `*LENGTH` ermittelt werden. Allgemeine Informationen zu dynamischen Variablen finden Sie im Abschnitt Dynamische und große Variablen benutzen im Leitfaden zur Programmierung.
`IGNORE /` `REMAINDER` `operand5` | IGNORE/REMAINDER-Optionen: Wenn Sie nicht genug Zieloperanden angeben, um alle Feldwertteile aufzunehmen, erhalten Sie eine entsprechende Fehlermeldung. Um dies zu vermeiden, haben Sie zwei Möglichkeiten: IGNORE-Option: Wenn Sie `IGNORE` angeben, ignoriert Natural es, falls nicht genügend Zieloperanden zur Aufnahme des Ausgangswertes vorhanden sind. REMAINDER-Option: Wenn Sie `REMAINDER operand5` angeben, wird der Teil des Ausgangswertes, für den keine Zieloperanden mehr zur Verfügung stehen, in operand5 gestellt. Den Inhalt von operand5 können Sie dann weiter verarbeiten, zum Beispiel in einem anschließenden `SEPARATE`-Statement. `REMAINDER` darf nur bei Feldern mit einem einzelnen Wert verwendet werden. Bei Array-Ausgangsfeldern müssen Sie `REMAINDER POSITION` verwenden. Siehe auch Regeln und operative Aspekte und Beispiel 3.
`REMAINDER POSITION operand9` | REMAINDER POSITION-Option: Der von der `REMAINDER POSITION`-Klausel zurückgegebene Wert entspricht der Position, ab der ein `REMAINDER`-Datenfeld gefüllt wird. Weitere Informationen siehe Regeln und operative Aspekte.
`DELIMITERS` | DELIMITERS-Option: Siehe Delimiters-Option weiter unten.
`RETAINED` | RETAINED-Option: Normalerweise werden die Begrenzungszeichen selbst nicht mit in die Zieloperanden übertragen. Wenn Sie allerdings `RETAINED` angeben, wird jedes Begrenzungszeichen (d.h. entweder das mit dem Session-Parameter `ID` festgelegte Standard-Begrenzungszeichen und Leerzeichen oder die mit operand6 angegebenen Zeichen) ebenfalls in einen Zieloperanden übertragen. Beispiel: Das folgende `SEPARATE`-Statement überträgt `150` nach `#B`, das Plus-Zeichen (`+`) nach `#C` und `30` nach `#D`:
    ...
    MOVE '150+30' TO #A
    SEPARATE #A INTO #B #C #D WITH RETAINED DELIMITER '+'
    ...
Siehe auch Beispiel 3.
`GIVING NUMBER` `operand7` | GIVING NUMBER-Option Diese Option bewirkt, dass die Anzahl der Zieloperanden, die mit einem Wert gefüllt wurden (einschließlich der mit Leerzeichen gefüllten), in operand7 ausgegeben wird. Die Anzahl, die Sie erhalten, errechnet sich aus der Anzahl der Delimiterzeichen plus 1. Wenn Sie die `IGNORE`-Option verwenden, enthält operand7 maximal die Anzahl der Zieloperanden (operand4). Wenn Sie die REMAINDER-Option verwenden, enthält operand7 maximal die Anzahl der Zieloperanden (operand4) plus operand5.

#### DELIMITERS-Option:

Begrenzungszeichen innerhalb von operand1 bestimmen die Stellen, an denen der Wert geteilt werden soll.

| `WITH` [`RETAINED`] |  | [`ANY`] `DELIMITERS` |  |
`INPUT DELIMITERS`
`DELIMITERS` operand6

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`WITH [ANY] DELIMITERS` | Falls Sie die `DELIMITERS`-Option nicht angeben (oder `WITH ANY DELIMITER` angeben), wird jedes Leerzeichen sowie jedes Zeichen, das weder ein Buchstabe noch eine Ziffer ist, als Begrenzungszeichen interpretiert. Die Definition des Begrenzungszeichens kann mit dem Profilparameter `SCTAB` geändert werden.
`WITH INPUT DELIMITERS` | Bedeutet, dass das mit dem Session-Parameter `ID` definierte Zeichen sowie das Leerzeichen als Begrenzungszeichen gelten.
`WITH DELIMITERS operand6` | Bedeutet, dass jedes der angegebenen Zeichen (operand6) als Begrenzungszeichen interpretiert wird. Wenn operand6 nachgestellte Leerzeichen enthält, werden diese ignoriert.

## Regeln und operative Aspekte

- Verarbeitung von Ausgangs- und Zielfeldern

- Bereiche für STARTING FROM POSITION festlegen

- Rückgabewert der REMAINDER POSITION-Klausel

- Feldüberlappungen: REMAINDER und REMAINDER POSITION

- Begrenzungszeichen beim SEPARATE-Statement

### Verarbeitung von Ausgangs- und Zielfeldern

Nachgezogene Leerstellen in Ausgangsfeldern (und auch in einzelnen Werten und Array-Ausprägungen) werden ignoriert, wenn der Aufteilungsvorgang beginnt. Nachgezogene Leerstellen zählen nur dann, wenn der `REMAINDER POSITION`-Wert berechnet wird. Siehe auch Rückgabewert der REMAINDER POSITION-Klausel.

Ist das Ausgangsfeld (`operand1`) ein leeres dynamisches Feld (`*LENGTH=0`) oder ein X-Array, das nicht erweitert wird, beendet das `SEPARATE`-Statement die Ausführung nach Rücksetzen folgender Felder:

- alle Zielfelder (`operand4`);

- das Feld (`operand7`), welches die Anzahl der gefüllten Zielfelder zurückgibt;

- das `REMAINDER`-Datenfeld (`operand5`);

- das `REMAINDER POSITION`-Feld (`operand9`).

Dasselbe gilt, wenn das Ausgangsfeld nur Leerstellen enthält.

### Bereiche für STARTING FROM POSITION festlegen

Der zulässige Wertebereich für `operand8` in der `STARTING FROM POSITION`-Klausel ist `1:n`. Dabei ist `n` das letzte Byte des Ausgangsfeldes.

Falls es sich bei dem Ausgangsfeld (`operand1`) um ein Array handelt, werden alle Ausprägungen, einschließlich der nachgezogenen Leerstellen, gezählt. Bei einem dynamischen Arry wird die Länge jedes Einzelfeldes bis zur angegebenen Position gezählt.

Beispiele für `operand8`:

Position 63 in `#A (A100)` | ist das the 63. Zeichen in `#A`.
Position 63 in `#B (A20/1:10)` | ist das dritte Zeichen in `#B(4`).
Position 63 in `#C (A10/1:3,1:4)` | ist das dritte Zeichen in `#C(2,3)`.
Position 63 in `#D (1:5) DYNAMIC` mit `*LENGTH(#D(*)) = (15,25,0,33,61)` | ist das 23. Zeichen in `#D(4)`.

Bei Angabe eines ungültigen Wertebereichs (ein negativer Wert oder ein Null-Wert oder ein Wert, der größer als die tatsächliche Feldlänge ist) werden die im Abschnitt Verarbeitung von Ausgangs- und Zielfeldern aufgeführten Rückgabefelder zurückgesetzt, jedoch tritt kein Laufzeitfehler auf. Da der `STARTING FROM`-Wert eine Position (und keinen Versatz) angibt, wird in `operand8` ein Mindestwert von `1` für die erste Ausführung benötigt.

### Rückgabewert der REMAINDER POSITION-Klausel

Der von der `REMAINDER POSITION`-Klausel zurückgegebene Wert entspricht der Position, ab der ein `REMAINDER`-Datenfeld gefüllt wird.

Beispiel:

    ...
    SEPARATE 'AB  CD' INTO #A REMAINDER #R
    ...

Dieses Statement gibt `#A= 'AB'` und `#R= ' CD'` zurück, weil der `REMAINDER` nach dem Trennzeichen (hier: Leerzeichen) unmittelbar nach `AB` beginnt. Verwendet man stattdessen die `REMAINDER POSITION`-Option, wird der Wert `4` zurückgegeben.

Zwar werden nachgezogene Leerstellen während des Trennvorgangs ignoriert, aber bei der Berechnung des `REMAINDER POSITION`-Wertes werden sie bei den Ausprägungen eines Array-Ausgangsfeldes berücksichtigt.

Wenn alle Ausgangsfeldabschnitte verarbeitet sind und das Ende des Ausgangsfelds erreicht ist, gibt die `REMAINDER POSITION`-Klausel den Wert Null zurück, was besagt, dass keine weiteren Daten mehr vorhanden sind.

Siehe auch Beispiel 6 - Verwendung eines Array-Ausgangsfeldes mit den Optionen STARTING FROM und REMAINDER POSITION.

### Feldüberlappungen: REMAINDER und REMAINDER POSITION

Bei der Ausführung des `SEPARATE`-Statements werden die Ausgangsdaten normalerweise kopiert und aus einem Arbeitsfeld verarbeitet. Deshalb ist das `REMAINDER`-Ergebnis unabhängig von möglicherweise überlappenden Ausgangs- und Ergebnis-(INTO-)Feldern

Solche Feld-Sicherungskopien werden bei Verwendung einer `REMAINDER POSITION`-Klausel nicht erstellt. Der gesamte Trennvorgang arbeitet unabhängig davon, ob Sie den Ausgangs- und den Zieloperanden trennen, mit dem ursprünglichen Ausgangsoperanden. Operandenüberlappung werden weder beim Kompilieren noch bei der Ausführung zurückgewiesen, können aber zu unerwünschten Ergebnissen führen.

### Begrenzungszeichen beim SEPARATE-Statement

Wenn Sie ein Feld mit einem einzelnen Wert aufteilen, begrenzt die Feldgrenze immer das letzte Wort. Dies gilt ebenfalls bei jeder einzelnen Ausprägung eines Array-Feldes. Das bedeutet, dass das folgende Einzel-Statement dasselbe bewirkt wie die Statement-Sequenz:

Bei Verwendung der `RETAINED DELIMITERS`-Option werden die Begrenzungszeichen ebenfalls in das Zielfeld gestellt. Dies gilt nur bei Begrenzungszeichen innerhalb einer Array-Ausprägung und nicht bei aufeinander folgenden Array-Ausprägungen, welche automatisch (ohne Begrenzungszeichen) begrenzt werden, wenn eine Ausprägung endet.

Siehe auch Beispiel 4 - Verwendung eines Array-Ausgangsfeldes einer redefinierten Zeichenkette und Beispiel 5 - Verwendung eines Array-Ausgangsfeldes mit RETAIN-Option.

## Beispiele SEPARATE

- Beispiel 1 — Verschiedene Beispiele für den Gebrauch des SEPARATE-Statements

- Beispiel 2 — SEPARATE-Statement bei einem Array

- Beispiel 3 — Gebrauch der Optionen REMAINDER/RETAINED

- Example 4 - Beispiel 4 - Verwendung eines Array-Ausgangsfeldes einer redefinierten Zeichenkette

- Beispiel 5 - Verwendung eines Array-Ausgangsfeldes mit RETAIN-Option

- Beispiel 6 - Verwendung eines Array-Ausgangsfeldes mit den Optionen STARTING FROM und REMAINDER POSITION

### Beispiel 1 — Verschiedene Beispiele für den Gebrauch des SEPARATE-Statements

    ** Example 'SEPEX1': SEPARATE
    ************************************************************************
    DEFINE DATA LOCAL
    1 #TEXT1   (A6) INIT <'AAABBB'>
    1 #TEXT2   (A7) INIT <'AAA BBB'>
    1 #TEXT3   (A7) INIT <'AAA-BBB'>
    1 #TEXT4   (A7) INIT <'A.B/C,D'>
    1 #FIELD1A (A6)
    1 #FIELD1B (A6)
    1 #FIELD2A (A3)
    1 #FIELD2B (A3)
    1 #FIELD3A (A3)
    1 #FIELD3B (A3)
    1 #FIELD4A (A3)
    1 #FIELD4B (A3)
    1 #FIELD4C (A3)
    1 #FIELD4D (A3)
    1 #NBT     (N1)
    1 #DEL     (A5)
    END-DEFINE
    *
    WRITE NOTITLE 'EXAMPLE A (SOURCE HAS NO BLANKS)'
    SEPARATE #TEXT1 INTO #FIELD1A #FIELD1B GIVING NUMBER #NBT
    WRITE     / '=' #TEXT1 5X '=' #FIELD1A 4X '=' #FIELD1B 4X '=' #NBT
    *
    WRITE NOTITLE /// 'EXAMPLE B (SOURCE HAS EMBEDDED BLANK)'
    SEPARATE #TEXT2 INTO #FIELD2A #FIELD2B GIVING NUMBER #NBT
    WRITE     / '=' #TEXT2 4X '=' #FIELD2A 7X '=' #FIELD2B 7X '=' #NBT
    *
    WRITE NOTITLE /// 'EXAMPLE C (USING DELIMITER ''-'')'
    SEPARATE #TEXT3 INTO #FIELD3A #FIELD3B WITH DELIMITER '-'
    WRITE     /    '=' #TEXT3 4X '=' #FIELD3A 7X '=' #FIELD3B
    *
    MOVE ',/' TO #DEL
    WRITE NOTITLE /// 'EXAMPLE D USING DELIMITER' '=' #DEL
    *
    SEPARATE #TEXT4 INTO #FIELD4A #FIELD4B
             #FIELD4C #FIELD4D WITH DELIMITER #DEL
    WRITE     /    '=' #TEXT4 4X '=' #FIELD4A 7X '=' #FIELD4B
              /              19X '=' #FIELD4C 7X '=' #FIELD4D
    *
    END

Ausgabe des Programms `SEPEX1`:

    EXAMPLE A (SOURCE HAS NO BLANKS)

    #TEXT1: AAABBB     #FIELD1A: AAABBB    #FIELD1B:           #NBT:  1

    EXAMPLE B (SOURCE HAS EMBEDDED BLANK)

    #TEXT2: AAA BBB    #FIELD2A: AAA       #FIELD2B: BBB       #NBT:  2

    EXAMPLE C (USING DELIMITER '-')

    #TEXT3: AAA-BBB    #FIELD3A: AAA       #FIELD3B: BBB

    EXAMPLE D USING DELIMITER #DEL: ,/

    #TEXT4: A.B/C,D    #FIELD4A: A.B       #FIELD4B: C
                       #FIELD4C: D         #FIELD4D:

### Beispiel 2 — SEPARATE-Statement bei einem Array

    ** Example 'SEPEX2': SEPARATE (using array variable)
    ************************************************************************
    DEFINE DATA LOCAL
    1 #INPUT-LINE (A60) INIT <'VALUE1,   VALUE2,VALUE3'>
    1 #FIELD      (A20/1:5)
    1 #NUMBER     (N2)
    END-DEFINE
    *
    SEPARATE #INPUT-LINE LEFT JUSTIFIED INTO #FIELD (1:5)
                         GIVING NUMBER IN #NUMBER
    *
    WRITE NOTITLE #INPUT-LINE //
                  #FIELD (1)  /
                  #FIELD (2)  /
                  #FIELD (3)  /
                  #FIELD (4)  /
                  #FIELD (5)  /
                  #NUMBER
    *
    END

Ausgabe des Programms `SEPEX2`:

    VALUE1,   VALUE2,VALUE3

    VALUE1
    VALUE2
    VALUE3

      3

### Beispiel 3 — Gebrauch der Optionen REMAINDER/RETAINED

    ** Example 'SEPEX3': SEPARATE (with REMAINDER, RETAIN option)
    ************************************************************************
    DEFINE DATA LOCAL
    1 #INPUT-LINE (A60) INIT <'VAL1,   VAL2, VAL3,VAL4'>
    1 #FIELD      (A10/1:4)
    1 #REM        (A30)
    END-DEFINE
    *
    WRITE TITLE LEFT 'INP:' #INPUT-LINE /
                '#FIELD (1)' 13T '#FIELD (2)' 25T '#FIELD (3)'
            37T '#FIELD (4)' 49T 'REMAINDER'
           /    '----------' 13T '----------' 25T '----------'
            37T '----------' 49T '------------------------------'
    *
    SEPARATE #INPUT-LINE INTO #FIELD (1:2)
             REMAINDER #REM WITH DELIMITERS ','
    WRITE #FIELD(1) 13T #FIELD(2) 25T #FIELD(3) 37T #FIELD(4) 49T #REM
    *
    RESET #FIELD(*) #REM
    SEPARATE #INPUT-LINE INTO #FIELD (1:2)
             IGNORE WITH DELIMITERS ','
    WRITE #FIELD(1) 13T #FIELD(2) 25T #FIELD(3) 37T #FIELD(4) 49T #REM
    *
    RESET #FIELD(*) #REM
    SEPARATE #INPUT-LINE INTO #FIELD (1:4) IGNORE
            WITH RETAINED DELIMITERS ','
    WRITE #FIELD(1) 13T #FIELD(2) 25T #FIELD(3) 37T #FIELD(4) 49T #REM
    *
    RESET #FIELD(*) #REM
    *
    SEPARATE SUBSTRING(#INPUT-LINE,1,50) INTO #FIELD (1:4)
             IGNORE WITH DELIMITERS ','
    WRITE #FIELD(1) 13T #FIELD(2) 25T #FIELD(3) 37T #FIELD(4) 49T #REM
    *
    END

Ausgabe des Programms `SEPEX3`:

    INP: VAL1,   VAL2, VAL3,VAL4
    #FIELD (1)  #FIELD (2)  #FIELD (3)  #FIELD (4)  REMAINDER
    ----------  ----------  ----------  ----------  ------------------------------
    VAL1           VAL2                              VAL3,VAL4
    VAL1           VAL2
    VAL1        ,              VAL2     ,
    VAL1           VAL2      VAL3       VAL4

### Example 4 - Beispiel 4 - Verwendung eines Array-Ausgangsfeldes einer redefinierten Zeichenkette

    **  Example 'SEPEX4': SEPARATE with source array
    ************************************************************************
    * This example shows different results when separating a scalar string
    * or a string array redefining the scalar string.
    *
    *
    ************************************************************************
    *
    *
    DEFINE DATA LOCAL
    1 #TEXT (A24) INIT <'VAL1 VAL2 VAL3 VAL4 VAL5'>
    1 REDEFINE #TEXT
      2 #TEXTARRAY (A12/2)
    1 #WORD1(A5/6)
    1 #WORD2(A5/6)
    END-DEFINE
    *
    SEPARATE #TEXT INTO #WORD1(*)
    /* Redefinition may split original words into two parts
    SEPARATE #TEXTARRAY(*) INTO #WORD2(*)
    *
    DISPLAY #TEXT #WORD1(*) #TEXTARRAY(*) #WORD2(*)
    END

Ausgabe des Programms `SEPEX4`:

             #TEXT           #WORD1  #TEXTARRAY  #WORD2
    ------------------------ ------ ------------ ------

    VAL1 VAL2 VAL3 VAL4 VAL5 VAL1   VAL1 VAL2 VA VAL1
                             VAL2   L3 VAL4 VAL5 VAL2
                             VAL3                VA
                             VAL4                L3
                             VAL5                VAL4
                                                 VAL5

### Beispiel 5 - Verwendung eines Array-Ausgangsfeldes mit RETAIN-Option

    **  Example 'SEPEX5': SEPARATE with and without RETAINED DELIMITERS
    ***********************************************************************
    * This example shows different results with a source array
    * when using the option RETAINED DELIMITERS or not.
    *
    *
    ***********************************************************************
    *
    *
    DEFINE DATA LOCAL
    1 #TEXT(A20)        INIT <'VAL1,VAL2,VAL3,VAL4'>
    1 #TEXTARRAY(A10/3) INIT <'VAL1,VAL2',
                              'VAL3',
                              'VAL4'>
    1 #WORD1(A5/7)
    1 #WORD2(A5/7)
    END-DEFINE
    *
    SEPARATE #TEXT         INTO #WORD1(*)
    SEPARATE #TEXTARRAY(*) INTO #WORD2(*)
    DISPLAY #TEXT #WORD1(*) #TEXTARRAY(*) #WORD2(*)
    *
    SEPARATE #TEXT         INTO #WORD1(*) WITH RETAINED DELIMITERS
    SEPARATE #TEXTARRAY(*) INTO #WORD2(*) WITH RETAINED DELIMITERS
    DISPLAY #TEXT #WORD1(*) #TEXTARRAY(*) #WORD2(*)
    *
    END

Ausgabe des Programms `SEPEX5`:

           #TEXT         #WORD1 #TEXTARRAY #WORD2
    -------------------- ------ ---------- ------

    VAL1,VAL2,VAL3,VAL4  VAL1   VAL1,VAL2  VAL1
                         VAL2   VAL3       VAL2
                         VAL3   VAL4       VAL3
                         VAL4              VAL4

    VAL1,VAL2,VAL3,VAL4  VAL1   VAL1,VAL2  VAL1
                         ,      VAL3       ,
                         VAL2   VAL4       VAL2
                         ,                 VAL3
                         VAL3              VAL4
                         ,
                         VAL4

### Beispiel 6 - Verwendung eines Array-Ausgangsfeldes mit den Optionen STARTING FROM und REMAINDER POSITION

    **  Example 'SEPEX6': SEPARATE with STARTING FROM and REMAINDER POSITION
    ************************************************************************
    * This example shows how the options STARTING FROM POSITION and
    * REMAINDER POSITION work together in a processing loop when
    * separating a source array.
    *
    ************************************************************************
    *
    *
    DEFINE DATA LOCAL
    1 #TEXT (A15/1:3) INIT <'VAL1 VAL2',
                            'VAL3',
                            'VAL4 VAL5 VAL6'>
    1 #WORD (A5/1:4)
    1 #POS  (I1) INIT <1>
    END-DEFINE
    *
    WRITE '#TEXT(A15/1:3):      (1)             (2)             (3)'
      /  16T #TEXT(*)
      /  16T '----+----1----+ ----2----+----3 ----+----4----+'
      // '#WORD (A5/1:4): (1)   (2)   (3)   (4)      :  #POS'
         '(within #TEXT(*))'
    *
    REPEAT
      SEPARATE #TEXT(*) STARTING FROM POSITION #POS
          INTO #WORD(*) REMAINDER POSITION #POS
      WRITE 16T #WORD(*) 44T ': ' #POS
      UNTIL #POS = 0
    END-REPEAT
    END

Ausgabe des Programms `SEPEX6`:

    #TEXT(A15/1:3):      (1)             (2)             (3)
                   VAL1 VAL2       VAL3            VAL4 VAL5 VAL6
                   ----+----1----+ ----2----+----3 ----+----4----+

    #WORD (A5/1:4): (1)   (2)   (3)   (4)      :  #POS (within #TEXT(*))
                   VAL1  VAL2  VAL3  VAL4      :    36
                   VAL5  VAL6                  :     0

### On this page

- Funktion SEPARATE
- Syntax-Beschreibung SEPARATE
- Regeln und operative Aspekte
- Beispiele SEPARATE