EXAMINE

#### Search Results

Search

# EXAMINE

Dieses Dokument behandelt folgende Themen:

- Syntax 1 - EXAMINE

- Syntax 2 - EXAMINE TRANSLATE

- Syntax 3 - EXAMINE für Unicode-Grapheme

- Beispiele

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

Gehört zur Funktionsgruppe: Arithmetische Funktionen und Datenzuweisungen

## Syntax 1 - EXAMINE

`EXAMINE` | [DIRECTION-clause]
| [`FULL` [`VALUE` [`OF`]]] |  | operand1 |
| `SUBSTRING` (operand1,operand2,operand3)
| [POSITION-clause] |  |
| [`FOR`] [`FULL` [`VALUE` [`OF`]]] [`PATTERN`] operand4
| [DELIMITERS-option]
| DELETE-REPLACE-clause |
GIVING-clause
DELETE-REPLACE-clause GIVING-clause

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

### Syntax-Beschreibung - Syntax 1

Das Statement `EXAMINE` dient dazu, den Inhalt eines alphanumerischen oder binären Feldes oder eines Bereiches von Feldern innerhalb eines Arrays abzusuchen und um

- zu zählen, wie oft eine bestimmte Zeichenkette vorkommt;

- die Byte-Position zurückzugeben, an der eine gesuchte Zeichenkette zuerst erscheint;

- die signifikante Länge des Inhalts eines Feldes zurückzugeben, d.h. die Feldlänge ohne nachfolgende Leerzeichen;

- die Ausprägungsnummer (Indizes) eines Array-Feldes zurückzugeben, wo eine Zeichenkette zuerst gefunden wurde;

- eine Zeichenkette gegen eine andere Zeichenkette auszutauschen;

- eine Zeichenkette zu löschen.

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 | C | S |  |  |  | A | U |  |  |  |  | B |  |  |  |  |  |  | ja | nein

* operand1 darf nur eine Konstante sein, wenn Sie die `GIVING`-Klausel verwenden, aber nicht, wenn Sie die `DELETE`-`REPLACE`-Klausel verwenden.

* `operand4` kann auch ein Array sei, siehe Suchen und Ersetzen mit mehreren Werten.

* Format B von operand2 und operand3 kann nur mit einer Länge von kleiner gleich 4 verwendet werden.

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`DIRECTION-clause` | DIRECTION-Klausel: Mit dieser Klausel legen Sie die Suchrichtung fest. Weitere Informationen siehe DIRECTION-Klausel weiter unten.
`operand1` | Zu untersuchendes Feld: `operand1` ist das Feld, dessen Inhalt untersucht werden soll. Ist `operand1` eine dynamische Variable, kann deren Länge über eine `REPLACE`-Operation auf einen höheren oder niedrigeren Wert gesetzt werden; durch eine `DELETE`-Operation kann deren Länge auf "0" gesetzt werden. Die aktuelle Länge einer dynamischen Variablen kann über die Systemvariable `*LENGTH` ermittelt werden.
`POSITION-clause` | POSITION-Klausel: Mit dieser Klausel können Sie für die Untersuchung eine Start- und Endeposition innerhalb von `operand1` (oder dem Substring von `operand1`) angeben. Weitere Informationen siehe POSITION-Klausel weiter unten.
`operand4` | Für die EXAMINE-Operation zu benutzender Wert: `operand4` ist der Wert, nach dem in dem untersuchten Feld oder Feldern gesucht wird. Sie können nach einem einzelnen Wert oder nach mehreren Werten suchen. Weitere Informationen zu `operand4` und `operand6` siehe operand6, der in der unten beschriebenen DELETE REPLACE-Klausel benutzt wird.
`FULL` | FULL-Option: Wenn Sie für einen Operanden `FULL` angeben, so wird der gesamte Wert, einschließlich nachfolgender Leerstellen, verarbeitet. Ohne `FULL` werden dem Wert nachfolgende Leerstellen bei der Verarbeitung ignoriert.
`SUBSTRING` | SUBSTRING-Option: Normalerweise wird der ganze Inhalt des Feldes untersucht, und zwar vom Anfang des Feldes bis zum Ende bzw. bis zum letzten Zeichen, das kein Leerzeichen ist. Die Option `SUBSTRING` ermöglicht es Ihnen, nur einen bestimmten Teil des Feldes zu untersuchen. In der `SUBSTRING`-Klausel geben Sie nach dem Feldnamen (`operand1`) zunächst die erste Stelle (Startposition, `operand2`) und dann die Länge (`operand3`) des Feldteils an, der untersucht werden soll. Um zum Beispiel die 5. bis einschließlich 12. Stelle eines Feldes #A zu untersuchen, geben Sie folgendes an:
    EXAMINE SUBSTRING(#A,5,8).
Anmerkungen: Wenn Sie `operand2` weglassen, wird ab Anfang des Feldes untersucht. Wenn Sie `operand3` weglassen, wird ab der angegebenen Stelle (`operand2`) bis zum Ende des Feldes untersucht. Wenn `SUBSTRING` in Verbindung mit einer dynamischen Variable benutzt wird, verhält sich das Feld wie eine Variable fester Länge, d.h. die Länge (Systemvariable `*LENGTH`) ändert sich nicht als Ergebnis der `EXAMINE`-Operation, ungeachtet der Tatsache, ob eine `DELETE`- oder `REPLACE`-Operation ausgeführt wurde oder nicht.
`PATTERN` | PATTERN-Option: Wenn Sie das Feld nach einem Wert absuchen möchten, der Variablen enthält, d.h. Platzhalter für Stellen, die bei der Suche nicht berücksichtigt werden sollen, verwenden Sie die Option `PATTERN`. `operand4` kann dann die folgenden Platzhalter für nicht zu untersuchende Stellen enthalten: Ein Punkt (.), Fragezeichen (?) oder Unterstrich (_) steht für eine einzelne Stelle, die nicht untersucht werden soll. Ein Stern (*) oder Prozentzeichen (%) steht für eine beliebige Anzahl von Stellen, die nicht untersucht werden sollen. Beispiel: Mit `PATTERN 'NAT*AL'` könnten Sie ein Feld nach jedem Wert absuchen, in dem `NAT` und `AL` vorkommt, ganz gleich, welche und wieviele andere Zeichen zwischen `NAT` und `AL` stehen (dies würde z.B. auf die Werte `NATURAL` und `NATIONAL` zutreffen, aber auch auf `NATAL`).
`DELIMITERS-option` | DELIMITERS-Option: Diese Option wird zum Suchen eines Wertes benutzt, der Delimiter aufweist. Einzelheiten siehe DELIMITERS-Option weiter unten.
`DELETE-REPLACE-clause` | DELETE REPLACE-Klausel: Die `DELETE`-Option dieser Klausel wird zum Löschen jedes Suchwertes (`operand4`) benutzt, der in `operand1` gefunden wird. Die `REPLACE`-Option wird zum Ersetzen jedes in `operand1` gefundenen Suchwertes (`operand4`) durch den in `operand6` angegebenen Wert benutzt. Siehe DELETE REPLACE-Klausel weiter unten.
`GIVING-clause` | GIVING-Klausel: Siehe GIVING-Klausel weiter unten.

#### DIRECTION-Klausel

Diese Klausel bestimmt die Suchrichtung.

|  | `FORWARD` |
`DIRECTION` | `BACKWARD`
| operand8

#### Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referenzierung erlaubt | Dynam. Definition
--- | --- | --- | --- | ---
operand8 | C | S |  |  |  | A1 |  |  |  |  |  |  |  |  |  |  |  | ja | nein

#### Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`FORWARD` | Suchrichtung von links nach rechts: Wenn Sie `FORWARD` angeben, wird der Feldinhalt von links nach rechts untersucht.
`BACKWARD` | Suchrichtung von rechts nach links: Wenn Sie `BACKWARD` angeben, wird der Feldinhalt von rechts nach links untersucht.
`operand8` | Alternative Angabe: Wenn Sie `operand8` angeben, wird die Suchrichtung durch den Inhalt von `operand8` bestimmt. `operand8` muss mit Format/Länge A1 definiert werden. Wenn `operand8` ein "F" enthält, ist die Suchrichtung `FORWARD`; wenn `operand8` ein "B" enthält, dann ist die Suchrichtung `BACKWARD`. Alle anderen Werte sind ungültig und werden zurückgewiesen: wenn `operand8` eine Konstante ist, wird der Wert zur Kompilierzeit zurückgewiesen; wenn `operand8` eine Variable ist, wird der Wert zur Laufzeit zurückgewiesen.

Anmerkung
Wenn die `DIRECTION`-Klausel nicht angegeben ist, wird die Standardsuchrichtung `FORWARD` benutzt.

#### POSITION-Klausel

Mit dieser Klausel können Sie für die Untersuchung eine Start- und Endeposition innerhalb von `operand1` (oder dem Substring von `operand1`) angeben.

[[`STARTING`] `FROM` [`POSITION`] operand9] |  |  | `ENDING AT` |  | [`POSITION`] operand10 |
`THRU`

Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referenzierung erlaubt | Dynam. Definition
--- | --- | --- | --- | ---
operand9 | C | S |  |  |  |  | N | P | I |  |  |  |  |  |  |  |  | ja | nein
operand10 | C | S |  |  |  |  | N | P | I |  |  |  |  |  |  |  |  | ja | nein

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`FROMoperand9` | Startposition: `operand9` definiert die Startposition für die Untersuchung.
`ENDING AT / THRU operand10` | Endeposition: `operand10` definiert die Endeposition für die Untersuchung.

Startposition (`operand9`) und Endeposition (`operand10`) sind relativ zu `operand1` oder dem Substring von `operand1` und werden beide verarbeitet.

Die Suche beginnt an der Startposition und endet an der Endeposition.

Wenn Start- und/oder Endeposition nicht angegeben sind, gelten die Standardwerte für die Position. Der Wert wird duch die Suchrichtung bestimmt:

Surchrichtung | Standardstartposition | Standardendeposition
--- | --- | ---
`FORWARD` | 1 (erstes Zeichen) | Länge von `operand1` (letztes Zeichen)
`BACKWARD` | Länge von `operand1` (letztes Zeichen) | 1 (erstes Zeichen)

Anmerkung
Eine Suche wird nicht durchgeführt, wenn die Suchrichtung `FORWARD` ist und die Startposition größer als die Endeposition ist, oder wenn die Suchrichtung `BACKWARD` ist und die Startposition kleiner als die Endeposition ist.

#### DELIMITERS-Option

| `ABSOLUTE` |
[`WITH DELIMITERS`]
[`WITH DELIMITERS`] operand5

Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referenzierung erlaubt | Dynam. Definition
--- | --- | --- | --- | ---
operand5 | C | S |  |  |  | A | U |  |  |  | B |  |  |  |  |  |  | ja | nein

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`ABSOLUTE` | Absolute Suche: Standardmäßig gilt die Option `ABSOLUTE`; d.h. die zu suchende Zeichenkette wird auch gefunden, wenn sie von anderen Zeichen umgeben und Teil einer längeren Zeichenkette ist.
`WITH DELIMITERS` | Suchwert mit beliebigen Begrenzungszeichen: Bei Angabe der Option `WITH DELIMITERS` wird ein Wert gesucht, dem je ein Leerzeichen oder irgendein anderes Zeichen, das weder ein Buchstabe noch eine Ziffer ist, vor- und nachgestellt ist. Die Definition des Begrenzungszeichens kann mit dem Profilparameter `SCTAB` geändert werden.
`WITH DELIMITERS operand5` | Suchwert mit bestimmten Begrenzungszeichen: Mit `WITH DELIMITERS` operand5 wird ein Wert gesucht, der von dem oder von einem in operand5 angegebenen Zeichen eingegrenzt ist. Wenn der Suchwert am Anfang bzw. Ende des untersuchten Feldes gefunden wurde, muss nur die rechte bzw. linke Seite durch eines der in operand5 angegebenen Zeichen begrenzt werden.

#### DELETE/REPLACE-Klausel

[`AND`] |  | `DELETE` [`FIRST`] |
`REPLACE` [`FIRST`] [`WITH`] [`FULL` [`VALUE` [`OF`]]] operand6

Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referenzierung erlaubt | Dynam. Definition
--- | --- | --- | --- | ---
operand6 | C | S | A* |  |  | A | U |  |  |  | B |  |  |  |  |  |  | ja | nein

* `operand6` kann auch ein Array sein, siehe Suchen und Ersetzen mit mehreren Werten.

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`DELETE` | Lösch-Option: Dient zum Löschen der ersten (oder aller) Ausprägung(en) des Suchwertes (`operand4`) im Inhalt von `operand1`.
`REPLACE` | Austausch-Option: Wird benutzt zum Ersetzen der ersten (oder aller) Ausprägung(en) des Suchwertes (`operand4`) in `operand1` durch den in `operand6` angegebenen Austauschwert.
`FIRST` | Löschen/Austauschen des ersten identischen Werts: Wenn Sie das Schlüsselwort `FIRST` angeben, wird nur der erste identische Wert gelöscht/ersetzt.

Anmerkungen:

1. Wenn die `REPLACE`-Operation zur Generierung von mehr Zeichen führt, als in den `operand1` passen, erhalten Sie eine Fehlermeldung.
2. Wenn `operand1` eine dynamische Variable ist, kann eine `REPLACE`-Operation dazu führen, dass seine Länge vergrößert oder verkleinert wird; eine `DELETE`-Operation kann dazu führen, dass seine Länge auf Null (0) gesetzt wird. Die aktuelle Länge einer dynamischen Variablen kann mittels der Systemvariable `*LENGTH` ermittelt werden. Allgemeine Informationen zu dynamischen Variablen siehe Dynamische Variablen benutzen.

#### Suchen und Ersetzen mit mehreren Werten

Der Suchwert (`operand4`) und der Ersetzungswert (`operand6`) können auch als Array-Felder definiert werden. Dadurch ist es mit nur einem `EXAMINE`-Statement möglich, mehrere unterschiedliche Muster in dem geprüften Feld (`operand1`) zu ersetzen. Der Such- und der Ersetzungsoperand brauchen nicht die gleiche Anzahl an Ausprägungen zu haben. Es muss lediglich die Übertragungskompatibilität zwischen diesen Feldern gewährleistet sein, d.h. `operand4:=operand6` muss eine gültige Operation sein; siehe auch Zuweisungen bei Arrays im Leitfaden zur Programmierung.

Die Operationslogik für die Suche mit mehreren Werten arbeitet wie folgt:

- Das zu prüfenden Feld (`operand6`) wird nur einmal durchlaufen, entweder von links nach rechts für Richtung `FORWARD` oder von rechts nach links für Richtung `BACKWARD`.

- Die Werte im Such-Array (`operand4`) werden, beginnend mit der ersten Position, auf Übereinstimmung geprüft, und zwar einer nach dem anderen, wobei mit der Array-Ausprägung mit dem niedrigsten Index begonnen wird.

- Wird kein Suchwert gefunden, wird der Vergleich bei der nächsten Feldposition fortgesetzt.

- Wenn eines der gesuchten Muster in einem geprüften Feld (`operand1`) gefunden wird, dann wird es durch den Wert des Ersetzungs-Arrays (`operand6`) ersetzt, das das übereinstimmende Muster in `operand4` überschreibt, wenn eine Operation `operand4:=operand6` ausgeführt würde.

- Nachdem die Ersetzung eines Musters erfolgt ist, wird der Vergleichsvorgang unmittelbar nach dem eingefügten Wert mit der ersten Ausprägung für das Such-Array fortgesetzt. Das bedeutet, dass ein schon einmal ersetztes Muster übersprungen wird und kein zweites Mal mehr ersetzt werden kann.

Beispiel:

Dieses Beispiel zeigt die Ersetzung des Kleiner-als-Zeichens (<), des Größer-als-Zeichens (>) und des Zeichens für das Kaufmännische Und (&) durch die entsprechenden HTML-Zeichen `'&lt;'`, `'&gt;'` und `'&amp;'`.

    DEFINE DATA LOCAL
    1 #HTML  (A/1:3) DYNAMIC INIT <'&lt;','&gt;','&amp;'>
    1 #TAB   (A/1:3) DYNAMIC INIT <'<','>','&'>
    1 #DOC(A) DYNAMIC  /* document to be replaced
    END-DEFINE
    #DOC := 'a&lt;&lt;b&amp;b&gt;c&gt;'
    WRITE #DOC (AL=30) 'before'
    /* Replace #DOC using #HTML to #TAB (n:1 replacement)
    EXAMINE   #DOC FOR  #HTML(*)  REPLACE  #TAB(*)
    /* '&lt;'  is replaced by '<'  (4:1 replacement)
    /* '&gt;'  is replaced by '>'  (4:1 replacement)
    /* '&amp;' is replaced by '&'  (5:1 replacement)
    WRITE #DOC (AL=30) 'after'
    END

Siehe auch Beispiel 3 - EXAMINE und REPLACE mit mehreren Werten.

#### GIVING-Klausel

|  | `GIVING` [`IN`] operand7 |  |
[`GIVING`] `NUMBER` [`IN`] operand7
[[`GIVING`] `POSITION` [`IN`] operand7]
[[`GIVING`] `LENGTH` [`IN`] operand7]
[[`GIVING`] `INDEX` [`IN`] operand7 ...3]

Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referenzierung erlaubt | Dynam. Definition
--- | --- | --- | --- | ---
operand7 |  | S |  |  |  |  | N | P | I |  |  |  |  |  |  |  |  | ja | ja

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`GIVING` | GIVING-Klausel: Wenn nur das Schlüsselwort `GIVING` angegeben wird, entspricht dies `GIVING NUMBER` (Voreinstellung).
`NUMBER` | GIVING NUMBER-Klausel: Wird benutzt, um die Zahl zu erhalten, wie oft der zu suchende Wert (`operand4`) in dem Feld (`operand1`) gefunden wird, dessen Inhalt überprüft werden soll.
`POSITION` | GIVING POSITION-Klausel: Mit `GIVING POSITION` erhalten Sie die Byte-Position, die der erste gefundene Wert (`operand4`) innerhalb von `operand1` (bzw. des Substrings von operand1) innehat.
`LENGTH` | GIVING LENGTH-Klausel: Mit `GIVING LENGTH` erhalten Sie die Länge des Inhalts von `operand1` (bzw. des Substrings von `operand1`), nachdem alle `DELETE`- bzw. `REPLACE`-Operationen abgeschlossen sind. Nachfolgende Leerzeichen werden ignoriert.
`operand7` | Anzahl der Ausprägungen: Die Anzahl der Ausprägungen des Suchwertes. Wenn auch die Option `REPLACE FIRST` oder `DELETE FIRST` benutzt wird, ist die Zahl nicht größer als 1.
`INDEX operand7 ...3` | GIVING INDEX-Klausel: This option is only applicable if the underlying field to be examined is an array field. `GIVING INDEX` wird benutzt, um die Zahl der Array-Ausprägung (Index) von `operand1` zu erhalten, in welcher der erste Suchwert gefunden wurde. `operand7` muss so oft angegeben werden, wie Dimensionen in `operand1` vorhanden sind (maximal dreimal). `operand7` gibt `0` zurück, falls der Suchwert in keiner der Ausprägungen gefunden wird. Anmerkung Falls der Indexbereich von `operand1` die Ausprägung `0` (zum Beispiel `0:5`) enthält, dann ist ein Wert `0` in `operand7` nicht eindeutig. In diesem Fall sollten Sie eine zusätzliche `GIVING NUMBER`-Klausel angeben, um sich zu vergewissern, ob der Suchwert tatsächlich gefunden wurde oder nicht.

## Syntax 2 - EXAMINE TRANSLATE

`EXAMINE` |  | operand1 |  | [`AND`]
`SUBSTRING` | (operand1,operand2,operand3)
|  | `TRANSLATE` |  | `INTO` |  | `UPPER` |  | [`CASE`] |  |
|  | `LOWER` |
|  | `USING` [`INVERTED`] `` operand4 |

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

### Syntax-Beschreibung - Syntax 2

Das Statement `EXAMINE TRANSLATE` dient dazu, die in einem Feld enthaltenen Zeichen in Groß- oder Kleinschreibung oder in andere Zeichen umzusetzen.

Operanden-Definitionstabelle:

Operand | Mögliche Struktur | Mögliche Formate | Referenzierung erlaubt | Dynam. Definition
--- | --- | --- | --- | ---
operand1 |  | S | A |  |  | A |  |  |  |  | B |  |  |  |  |  |  | ja | nein
operand2 | C | S |  |  |  |  | N | P | I |  | B* |  |  |  |  |  |  | ja | nein
operand3 | C | S |  |  |  |  | N | P | I |  | B* |  |  |  |  |  |  | ja | nein
operand4 |  | S | A |  |  | A |  |  |  |  | B |  |  |  |  |  |  | ja | nein

*Format B von `operand2` und `operand3` kann nur mit einer Länge von kleiner gleich 4 verwendet werden.

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`EXAMINE operand1` | Umsetzung des kompletten Feldinhalts: `operand1` ist das Feld, dessen Inhalt umgesetzt werden soll.
`EXAMINE SUBSTRING` `operand1` `operand2` `operand3` | Umsetzung von Teilen des Feldinhalts: Normalerweise wird der Inhalt des gesamten Feldes umgesetzt. Die Option `SUBSTRING` ermöglicht es Ihnen, nur einen bestimmten Teil des Feldes umzusetzen. In der `SUBSTRING`-Klausel geben Sie nach dem Feldnamen (`operand1`) zunächst die erste Stelle (`operand2`) und dann die Länge (`operand3`) des Feldteils, der umgesetzt werden soll, an. Um zum Beispiel die 5. bis einschließlich 12. Stelle eines Feldes `#A` umzusetzen, geben Sie folgendes an:
    EXAMINE SUBSTRING(#A,5,8) AND TRANSLATE ...
Anmerkung Wenn Sie `operand2` weglassen, wird ab Anfang des Feldes umgesetzt. Wenn Sie `operand3` weglassen, wird ab der ersten Stelle bis zum Ende des Feldes umgesetzt.
`TRANSLATE INTO UPPER CASE` | Umsetzung in Großbuchstaben: Der Inhalt von `operand1` wird in Großbuchstaben umgesetzt.
`TRANSLATE INTO LOWER CASE` | Umsetzung in Kleinbuchstaben: Der Inhalt von `operand1` wird in Kleinbuchstaben umgesetzt.
`TRANSLATE USING operand4` | Zu benutzende Umsetzungstabelle: `operand4` ist die Umsetzungstabelle, die für die Zeichenumsetzung verwendet werden soll. Die Tabelle muss Format/Länge A2 oder B2 haben. Anmerkung Falls für ein umzusetzendes Zeichen in der Umsetzungstabelle mehr als eine Umsetzung definiert ist, gilt die jeweils letzte Umsetzung.
`INVERTED` | Wenn Sie das Schlüsselwort `INVERTED` angeben, wird die Umsetzungstabelle (`operand4`) in umgekehrter Richtung verwendet, d.h. die Umsetzungsrichtung wird umgekehrt.

## Syntax 3 - EXAMINE für Unicode-Grapheme

`EXAMINE` [`FULL` [`VALUE` [`OF`]]] |  | `operand1` `SUBSTRING` (`operand1,operand2,operand3`) |
[`POSITION-clause`] |
[`FOR`] |  | `CHARPOSITION` operand4 `CHARLENGTH` operand5 `CHARPOSITION` operand4 `CHARLENGTH` operand5 |
[`GIVING`] `POSITION IN` `operand6` [[`GIVING`] `LENGTH IN` `operand7`]

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

### Syntax-Beschreibung - Syntax 3

Unter einem Graphem versteht ein Benutzer normalerweise ein Zeichen. In den meisten Fällen ist eine UTF-16 Code-Einheit (= U-Formatzeichen) ein Graphem, allerdings kann ein Graphem auch aus mehreren Code-Einheiten bestehen. Beispiele sind: eine Folge von einem Basiszeichen gefolgt von Kombinationszeichen oder einem Ersatz-Paar. Weitere Informationen zu Graphemen und anderen Unicode-Begriffen entnehmen Sie dem Dokument The Unicode Standard unter http://www.unicode.org/.

Das Statement `EXAMINE` für U-Format-Operanden spricht im Allgemeinen Code-Einheiten an. Allerdings ist es bei `CHARPOSITION`- und `CHARLENGTH`-Klauseln möglich, die Startposition und Länge (als Code-Einheiten) einer Graphem-Sequenz zu erhalten. Die zurückgegeben Code-Einheitswerte können dann in anderen Statements/Klauseln benutzt werden, für die Code-Einheitsoperanden erforderlich sind (zum Beispiel in einer `SUBSTRING`-Klausel).

Weitere Informationen zur Syntax des `EXAMINE`-Statements, siehe auch Unicode- und Codepage-Unterstützung in der Natural-Programmiersprache, Abschnitt Natural-Statements, Unterabschnitt EXAMINE in der Unicode- und Codepage-Unterstützung-Dokumentation.

Operanden-Definitionstabelle:

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

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

Syntax-Element-Beschreibung:

Syntax-Element | Beschreibung
--- | ---
`FULL` | FULL-Option: Wenn `FULL` für einen Operanden angegeben wird, wird der gesamte Wert, einschließlich der nachfolgenden Leerzeichen abgearbeitet. Wenn `FULL` nicht angegeben wird, werden nach folgende Leerzeichen im Operanden ignoriert.
`SUBSTRING` `operand1` `operand2` `operand3` | SUBSTRING-Option: Normalerweise wird der ganze Inhalt des Feldes untersucht, und zwar vom Anfang des Feldes bis zum Ende bzw. bis zum letzten signifikanten Zeichen. Die Option `SUBSTRING` ermöglicht es Ihnen, nur einen bestimmten Teil des Feldes zu untersuchen. 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 untersucht werden soll. `operand2` und `operand3` werden als Code-Einheiten angegeben. Um zum Beispiel die 5. bis einschließlich 12. Stelle eines Feldes `#A` zu untersuchen, geben Sie folgendes an:
    EXAMINE SUBSTRING (#A,5,8)
Anmerkungen: Wenn Sie `operand2` weglassen, wird ab Anfang des Feldes (Position 1) untersucht. Wenn Sie `operand3` weglassen, wird ab der angegebenen Stelle bis zum Ende des Feldes untersucht. Wenn `SUBSTRING` in Verbindung mit einer dynamischen Variable benutzt wird, verhält sich das Feld wie eine Variable fester Länge, d.h. die Länge (Systemvariable `*LENGTH`) ändert sich nicht als Ergebnis der `EXAMINE`-Operation, ungeachtet der Tatsache, ob eine `DELETE`- oder `REPLACE`-Operation ausgeführt wurde oder nicht.
`POSITION-clause` | POSITION-Klausel: Bereichswerte für `FROM` und `THRU` werden in Form von Code-Einheiten angegeben. Weitere Informationen siehe POSITION-Klausel unter Syntax 1.
`CHARPOSITION operand4` | CHARPOSITION-Klausel: operand4 legt die Startposition (als Unicode-Graphem) der Graphem-Sequenz fest. Die entsprechende Position wird in `operand6` in Form von Code-Einheiten zurückgegeben. Diese Klausel kann weggelassen werden, wenn die `CHARLENGTH`-Klausel angegeben wird; in diesem Fall ist die Startposition 1.
`CHARLENGTH operand5` | CHARLENGTH-Klausel: `operand5` legt die Länge der Graphem-Sequenz (als Unicode-Graphem) fest. Die Länge der Graphem-Sequenz wird in Form von Code-Einheiten in `operand7` zurückgegeben. Diese Klausel kann weggelassen werden, wenn die `CHARPOSITION`-Klausel angegeben wird; in diesem Fall wird die Länge von der Startposition bis zum Ende der Zeichenkette zurückgegeben.
`GIVING POSITION IN operand6` | GIVING POSITION-Klausel: `operand6` enthält (als Code-Einheiten) die Startposition der von `operand4` und `operand5` definierten Graphem-Sequenz. Wenn `operand1` weniger als `operand4` Grapheme hat, wird Null (0) zurückgegeben. Diese Klausel kann weggelassen werden, wenn die `GIVING LENGTH`-Klausel angegeben wird.
`GIVING LENGTH IN operand7` | GIVING LENGTH-Klausel: `operand7` enthält (als Code-Einheiten) die Länge der mit `operand4` und `operand5` definierten Graphem-Sequenz. Wenn `operand1` weniger als `operand4`+`operand5` Grapheme hat, wird 0 zurückgegeben. Diese Klausel kann weggelassen werden, wenn die `GIVING POSITION`-Klausel angegeben wird.

Anmerkungen:

1. Es muss entweder die `CHARPOSITION`- oder die `CHARLENGTH`-Klausel oder beide angegeben werden.
2. Es muss entweder die `GIVING POSITION`- oder die `GIVING LENGTH`-Klausel oder beide angegeben werden.

## Beispiele

- Beispiel 1 - EXAMINE

- Beispiel 2 - EXAMINE SUBSTRING, PATTERN, TRANSLATE

- Beispiel 3 - EXAMINE und REPLACE mit mehreren Werten

- Beispiel 4 - EXAMINE für Unicode-Grapheme

### Beispiel 1 - EXAMINE

    ** Example 'EXMEX1': EXAMINE
    ************************************************************************
    DEFINE DATA LOCAL
    1 #TEXT   (A45)
    1 #ARRAY  (A5/1:3)
    1 #A      (A3)
    1 #START  (N2)
    1 #NUM    (N2)
    1 #NUM1   (N2)
    1 #NUM2   (N2)
    1 #NUM3   (N2)
    1 #POS    (N2)
    1 #POS1   (N2)
    1 #LENG   (N2)
    1 #INDEX  (N2)
    END-DEFINE
    *
    MOVE 'ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C- ' TO #TEXT
    *
    WRITE / 'EXAMPLE 1  (DELIMITER, GIVING NUMBER)'
    WRITE NOTITLE '#TEXT: ' #TEXT
    EXAMINE #TEXT FOR 'A' GIVING NUMBER #NUM1
    EXAMINE #TEXT FOR 'A' WITH DELIMITER GIVING NUMBER #NUM2
    EXAMINE #TEXT FOR 'A' WITH DELIMITER '.' GIVING NUMBER #NUM3
    WRITE 'EXAMINE #TEXT FOR "A" ' 57T 'Number found:' #NUM1
    WRITE 'EXAMINE #TEXT FOR "A" WITH DELIMITER' 57T 'Number found:' #NUM2
    WRITE 'EXAMINE #TEXT FOR "A" WITH DELIMITER "."'
      57T 'Number found:' #NUM3
    *
    WRITE / 'EXAMPLE 2  (DELIMITER, REPLACE, GIVING NUMBER)'
    WRITE 'EXAMINE #TEXT FOR "A" WITH DELIMITER "-" REPLACE WITH "*"'
    WRITE 'Before:' #TEXT
    EXAMINE #TEXT FOR 'A' WITH DELIMITER '-' REPLACE WITH '*'
            GIVING NUMBER #NUM
    WRITE 'After: ' #TEXT 57T 'Number found:' #NUM
    *
    *
    NEWPAGE
    *
    WRITE / 'EXAMPLE 3  (REPLACE, GIVING NUMBER)'
    WRITE 'EXAMINE      #TEXT FOR " " REPLACE WITH "+"'
    WRITE 'Before:' #TEXT
    EXAMINE #TEXT FOR ' ' REPLACE WITH '+' GIVING NUMBER #NUM
    WRITE 'After: ' #TEXT 57T 'Number found:' #NUM
    *
    WRITE / 'EXAMPLE 4  (FULL, REPLACE, GIVING NUMBER)'
    WRITE 'EXAMINE FULL #TEXT FOR " " REPLACE WITH "+"'
    WRITE 'Before:' #TEXT
    EXAMINE FULL #TEXT FOR ' ' REPLACE WITH '+' GIVING NUMBER #NUM
    WRITE 'After: ' #TEXT 57T 'Number found:' #NUM
    *
    WRITE / 'EXAMPLE 5  (DELETE, GIVING POSITION)'
    WRITE 'EXAMINE #TEXT FOR "+" DELETE GIVING POSITION #POS'
    WRITE 'Before:' #TEXT
    EXAMINE #TEXT FOR '+' DELETE GIVING POSITION #POS
    WRITE 'After: ' #TEXT 57T 'Position found:' #POS
    *
    WRITE / 'EXAMPLE 6  (DELETE, GIVING LENGTH)'
    WRITE 'EXAMINE #TEXT FOR "A" DELETE GIVING LENGTH #LENG'
    WRITE 'Before:' #TEXT
    EXAMINE #TEXT FOR 'A' DELETE GIVING LENGTH #LENG
    WRITE 'After: ' #TEXT 57T 'Length found:' #LENG
    *
    *
    NEWPAGE
    *
    MOVE 'ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C- ' TO #TEXT
    *
    WRITE / 'EXAMPLE 7  (PATTERN, REPLACE, GIVING NUMBER)'
    WRITE 'EXAMINE #TEXT FOR         ".A." AND REPLACE "***"'
    WRITE 'Before:' #TEXT
    EXAMINE #TEXT FOR         '.A.' AND REPLACE '***' GIVING NUMBER #NUM
    WRITE 'After: ' #TEXT 57T 'Number found:' #NUM
    *
    MOVE 'ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C- ' TO #TEXT
    *
    WRITE 'EXAMINE #TEXT FOR PATTERN ".A." AND REPLACE "***"'
    WRITE 'Before:' #TEXT
    EXAMINE #TEXT FOR PATTERN '.A.' AND REPLACE '***' GIVING NUMBER #NUM
    WRITE 'After: ' #TEXT 57T 'Number found:' #NUM
    *
    MOVE 'ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C- ' TO #TEXT
    *
    #A   := 'B C'
    #POS := 6
    #LENG:= 25
    *
    WRITE / 'EXAMPLE 8  (SUBSTRING, REPLACE, GIVING POSITION)'
    WRITE '#A := "B C" ; #POS := 6 ; #LENG:= 25 '
    WRITE 'EXAMINE SUBSTRING(#TEXT,#POS,#LENG) FOR #A AND REPLACE "***"'
    WRITE 'Before:' #TEXT
    EXAMINE SUBSTRING(#TEXT,#POS,#LENG) FOR #A AND REPLACE '***'
            GIVING POSITION #POS1
    WRITE 'After: ' #TEXT 57T 'Position found:' #POS1
    *
    *
    NEWPAGE
    *
    MOVE 'ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C- ' TO #TEXT
    *
    WRITE / 'EXAMPLE 9  (DELETE, GIVING NUMBER, GIVING POSITION, '-
            'GIVING LENGTH)'
    WRITE 'EXAMINE #TEXT FOR "." DELETE GIVING NUMBER   #NUM'
    WRITE 30T 'GIVING POSITION #POS'
    WRITE 30T 'GIVING LENGTH   #LENG'
    WRITE 'Before:' #TEXT
    EXAMINE #TEXT FOR '.' DELETE GIVING NUMBER #NUM
                                 GIVING POSITION #POS
                                 GIVING LENGTH   #LENG
    WRITE 'After: ' #TEXT
    WRITE 'Number found:  ' #NUM
    WRITE 'Position found:' #POS
    WRITE 'Length found:  ' #LENG
    *
    *
    *
    MOVE 'ABC  ' TO #ARRAY (1)
    MOVE '.A.B.' TO #ARRAY (2)
    MOVE '-A-B-' TO #ARRAY (3)
    *
    WRITE / 'EXAMPLE 10 (GIVING NUMBER, GIVING POSITION, GIVING INDEX)'
    WRITE '#ARRAY(1):' #ARRAY(1)
    WRITE '#ARRAY(2):' #ARRAY(2)
    WRITE '#ARRAY(3):' #ARRAY(3)
    WRITE 'EXAMINE #ARRAY(*) FOR "B" GIVING NUMBER   #NUM'
    WRITE 27T 'GIVING POSITION #POS'
    WRITE 27T 'GIVING INDEX    #INDEX'
    EXAMINE #ARRAY(*) FOR 'B' GIVING NUMBER   #NUM
                              GIVING POSITION #POS
                              GIVING INDEX    #INDEX
    WRITE 'Number found:  ' #NUM
    WRITE 'Position found:' #POS
    WRITE 'Index found:   ' #INDEX
    END

Ausgabe des Programms `EXMEX1`:

    EXAMPLE 1  (DELIMITER, GIVING NUMBER)
    #TEXT:  ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C-
    EXAMINE #TEXT FOR 'A'                                   Number found:   4
    EXAMINE #TEXT FOR 'A' WITH DELIMITER                    Number found:   3
    EXAMINE #TEXT FOR 'A' WITH DELIMITER '.'                Number found:   1

    EXAMPLE 2  (DELIMITER, REPLACE, GIVING NUMBER)
    EXAMINE #TEXT FOR 'A' WITH DELIMITER '-' REPLACE WITH '*'
    Before: ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C-
    After:  ABC   A B C   .A.  .B.  .C.    -*-  -B-  -C-    Number found:   1

    EXAMPLE 3  (REPLACE, GIVING NUMBER)
    EXAMINE      #TEXT FOR ' ' REPLACE WITH '+'
    Before: ABC   A B C   .A.  .B.  .C.    -*-  -B-  -C-
    After:  ABC+++A+B+C+++.A.++.B.++.C.++++-*-++-B-++-C-    Number found:  20

    EXAMPLE 4  (FULL, REPLACE, GIVING NUMBER)
    EXAMINE FULL #TEXT FOR ' ' REPLACE WITH '+'
    Before: ABC+++A+B+C+++.A.++.B.++.C.++++-*-++-B-++-C-
    After:  ABC+++A+B+C+++.A.++.B.++.C.++++-*-++-B-++-C-+   Number found:   1

    EXAMPLE 5  (DELETE, GIVING POSITION)
    EXAMINE #TEXT FOR '+' DELETE GIVING POSITION #POS
    Before: ABC+++A+B+C+++.A.++.B.++.C.++++-*-++-B-++-C-+
    After:  ABCABC.A..B..C.-*--B--C-                        Position found:   4

    EXAMPLE 6  (DELETE, GIVING LENGTH)
    EXAMINE #TEXT FOR 'A' DELETE GIVING LENGTH #LENG
    Before: ABCABC.A..B..C.-*--B--C-
    After:  BCBC...B..C.-*--B--C-                           Length found:  21

    EXAMPLE 7  (PATTERN, REPLACE, GIVING NUMBER)
    EXAMINE #TEXT FOR         '.A.' AND REPLACE '***'
    Before: ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C-
    After:  ABC   A B C   ***  .B.  .C.    -A-  -B-  -C-    Number found:   1
    EXAMINE #TEXT FOR PATTERN '.A.' AND REPLACE '***'
    Before: ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C-
    After:  ABC  ***B C   ***  .B.  .C.    ***  -B-  -C-    Number found:   3

    EXAMPLE 8  (SUBSTRING, REPLACE, GIVING POSITION)
    #A := 'B C' ; #POS := 6 ; #LENG:= 25
    EXAMINE SUBSTRING(#TEXT,#POS,#LENG) FOR #A AND REPLACE '***'
    Before: ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C-
    After:  ABC   A ***   .A.  .B.  .C.    -A-  -B-  -C-    Position found:   4

    EXAMPLE 9  (DELETE, GIVING NUMBER, GIVING POSITION, GIVING LENGTH)
    EXAMINE #TEXT FOR '.' DELETE GIVING NUMBER   #NUM
                                 GIVING POSITION #POS
                                 GIVING LENGTH   #LENG
    Before: ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C-
    After:  ABC   A B C   A  B  C    -A-  -B-  -C-
    Number found:     6
    Position found:  15
    Length found:    38

    EXAMPLE 10 (GIVING NUMBER, GIVING POSITION, GIVING INDEX)
    #ARRAY(1): ABC
    #ARRAY(2): .A.B.
    #ARRAY(3): -A-B-
    EXAMINE #ARRAY(*) FOR 'B' GIVING NUMBER   #NUM
                              GIVING POSITION #POS
                              GIVING INDEX    #INDEX
    Number found:     3
    Position found:   2
    Index found:      1

### Beispiel 2 - EXAMINE SUBSTRING, PATTERN, TRANSLATE

    ** Example 'EXMEX2': EXAMINE TRANSLATE
    ************************************************************************
    DEFINE DATA LOCAL
    1 #TEXT  (A50)
    1 #TAB   (A2/1:10)
    1 #POS   (N2)
    1 #LENG  (N2)
    END-DEFINE
    *
    MOVE 'ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C- ' TO #TEXT
    *
    MOVE 'AX' TO #TAB(1)
    MOVE 'BY' TO #TAB(2)
    MOVE 'CZ' TO #TAB(3)
    *
    *
    WRITE NOTITLE / 'EXAMPLE 1  (WITH TRANSLATION TABLE)'
    WRITE 'EXAMINE #TEXT TRANSLATE USING #TAB(*)'
    WRITE 'Before:' #TEXT
    EXAMINE #TEXT TRANSLATE USING #TAB(*)
    WRITE 'After: ' #TEXT
    *
    WRITE / 'EXAMPLE 2  (WITH INVERTED TRANSLATION TABLE)'
    WRITE 'EXAMINE #TEXT TRANSLATE USING INVERTED #TAB(*)'
    WRITE 'Before:' #TEXT
    EXAMINE #TEXT TRANSLATE USING INVERTED #TAB(*)
    WRITE 'After: ' #TEXT
    *
    #POS := 13
    #LENG:= 15
    *
    WRITE / 'EXAMPLE 3  (WITH LOWER CASE TRANSLATION)'
    WRITE '#POS := 13 ; #LENG:= 15 '
    WRITE 'EXAMINE SUBSTRING(#TEXT,#POS,#LENG) TRANSLATE INTO LOWER CASE'
    WRITE 'Before:' #TEXT
    EXAMINE SUBSTRING(#TEXT,#POS,#LENG) TRANSLATE INTO LOWER CASE
    WRITE 'After: ' #TEXT
    *
    END

Ausgabe des Programms `EXMEX2`:

    EXAMPLE 1  (WITH TRANSLATION TABLE)
    EXAMINE #TEXT TRANSLATE USING #TAB(*)
    Before: ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C-
    After:  XYZ   X Y Z   .X.  .Y.  .Z.    -X-  -Y-  -Z-

    EXAMPLE 2  (WITH INVERTED TRANSLATION TABLE)
    EXAMINE #TEXT TRANSLATE USING INVERTED #TAB(*)
    Before: XYZ   X Y Z   .X.  .Y.  .Z.    -X-  -Y-  -Z-
    After:  ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C-

    EXAMPLE 3  (WITH LOWER CASE TRANSLATION)
    #POS := 13 ; #LENG:= 15
    EXAMINE SUBSTRING(#TEXT,#POS,#LENG) TRANSLATE INTO LOWER CASE
    Before: ABC   A B C   .A.  .B.  .C.    -A-  -B-  -C-
    After:  ABC   A B C   .a.  .b.  .c.    -A-  -B-  -C-

### Beispiel 3 - EXAMINE und REPLACE mit mehreren Werten

    *  EXAMPLE 'EXMEX3': EXAMINE AND REPLACE WITH MULTIPLE VALUES
    ************************************************************************
    * This example shows a translation of the pattern
    * 'AA', 'Aa' and 'aA' into '++',
    * 'BB', 'Bb' and 'bB' into '--' and
    * 'CC', 'Cc' and 'cC' into '**'.
    ************************************************************************
    DEFINE DATA LOCAL
    1 #SV     (A2/1:3,1:3) INIT (1,V) <'AA','BB','CC'>
                                (2,V) <'Aa','Bb','Cc'>
                                (3,V) <'aA','bB','cC'>
    1 #RV     (A2/1:3)     INIT       <'++','--','**'>
    1 #STRING (A20)        INIT <'AAABbbbbBCCCcccCaaaA'>
    1 #NUM    (N2)
    END-DEFINE
    *
    *
    WRITE NOTITLE / 'EXAMINE #STRING FOR #SV(*,*) AND REPLACE WITH #RV(*)' /
    *
    WRITE 'Before:' #STRING   /* shows   'AAABbbbbBCCCcccCaaaA'
    *
    EXAMINE #STRING FOR #SV(*,*) AND REPLACE WITH #RV(*)
            GIVING NUMBER #NUM
    *
    WRITE 'After: ' #STRING   /* shows   '++A--bb--****c**aa++'
      40T 'Number found:' #NUM
    *

Ausgabe des Programms `EXMEX3`:

    EXAMINE #STRING FOR #SV(*,*) AND REPLACE WITH #RV(*)

    Before: AAABbbbbBCCCcccCaaaA
    After:  ++A--bb--****c**aa++           Number found:   7

### Beispiel 4 - EXAMINE für Unicode-Grapheme

Dieses Beispiel veranschaulicht die Analyse einer Unicode-Zeichenkette mit den Zeichen `ä` und `ü`. Beide Zeichen sind als Basiszeichen, gefolgt von einem Kombinationszeichen festgelegt: `ä` ist als `U+0061`, gefolgt von `U+0308` kodiert, und `ü` ist als `U+0075`, gefolgt von `U+0308` kodiert.

    DEFINE DATA LOCAL
    1 #U (U20)
    1 #START (I2)
    1 #POS (I2)
    1 #LEN (I2)
    END-DEFINE
    #U := U'AB'-UH'00610308'-U'CD'-UH'00750308'-U'EF'
    *
    REPEAT
      #START := #START + 1
      EXAMINE #U FOR CHARPOSITION #START
                       CHARLENGTH      1
                  GIVING POSITION IN #POS
                           LENGTH IN #LEN
    *
      INPUT (AD=O) MARK POSITION #POS IN FIELD *#U
        '         UNICODE-STRING:' #U     (AD=MI)
     // '          CHARACTER NO.:' #START (EM=9)
      / 'STARTS AT BYTE POSITION:' #POS   (EM=9)
      / '      AND THE LENGTH IS:' #LEN   (EM=9)
    WHILE #POS NE 0
    END-REPEAT
    END

Ausgabe:

Großrechner-Umgebungen: | Windows- oder UNIX-Umgebungen (mit Natural Web I/O Interface):
--- | ---
    UNICODE-STRING: ABa?CDu?EF

              CHARACTER NO.: 1
    STARTS AT BYTE POSITION: 1
          AND THE LENGTH IS: 1
    UNICODE-STRING: ABäCDüEF

              CHARACTER NO.: 1
    STARTS AT BYTE POSITION: 1
          AND THE LENGTH IS: 1
Drücken Sie die Eingabetaste um fortzufahren. | Drücken Sie die Eingabetaste um fortzufahren.
    UNICODE-STRING: ABa?CDu?EF

              CHARACTER NO.: 2
    STARTS AT BYTE POSITION: 2
          AND THE LENGTH IS: 1
    UNICODE-STRING: ABäCDüEF

              CHARACTER NO.: 2
    STARTS AT BYTE POSITION: 2
          AND THE LENGTH IS: 1
Drücken Sie die Eingabetaste um fortzufahren. | Drücken Sie die Eingabetaste um fortzufahren.
Beachten Sie, dass das Zeichen in Position 3 eine Kombinationszeichenfolge ist und zwei Code-Einheiten lang ist.
    UNICODE-STRING: ABa?CDu?EF

              CHARACTER NO.: 3
    STARTS AT BYTE POSITION: 3
          AND THE LENGTH IS: 2
    UNICODE-STRING: ABäCDüEF

              CHARACTER NO.: 3
    STARTS AT BYTE POSITION: 3
          AND THE LENGTH IS: 2
Und so weiter. | Und so weiter.

### On this page

- Syntax 1 - EXAMINE
- Syntax 2 - EXAMINE TRANSLATE
- Syntax 3 - EXAMINE für Unicode-Grapheme
- Beispiele