@DO (Format 1) - Starten von EDT-Prozeduren aus Arbeitsdateien

Mit Format 1 der @DO-Anweisung wird eine @DO-Prozedur gestartet, d.h. die in der angegebenen Arbeitsdatei stehenden Textzeilen und EDT-Anweisungen werden abgearbeitet.
Einzelheiten zum Aufbau und zur Bearbeitung von EDT-Prozeduren findet man im Abschnitt „EDT-Prozeduren“.

Operation	Operanden	F-Modus, L-Modus
@DO	procnr [,] [ (param [,...]) ] [spec] [=line1,line2 [, [-] line3] ] [PRINT]

procnr	Die Nummer der Arbeitsdatei (1..22), deren Inhalt der EDT abarbeiten soll. Ist die Arbeitsdatei leer, wird die Fehlermeldung EDT4950 ausgegeben.
param	Parameter, die an die auszuführende Prozedur übergeben werden. Die Parameter müssen in der Prozedur mit @PARAMS definiert sein (siehe @PARAMS-Anweisung). Sie werden voneinander durch Komma getrennt. Sind Parameter (auch leere) angegeben und enthält die Prozedur keine @PARAMS-Anweisung, wird die Anweisung mit der Meldung EDT4944 abgewiesen. Sind zu viele Parameter angegeben wird die Fehlermeldung EDT4963 bzw. EDT4965 ausgegeben. Es wird zwischen Stellungs- und Schlüsselwortparametern unterschieden. Bei Stellungsparametern wird nur der Wert des Parameters übergeben, bei Schlüsselwortparametern ein Ausdruck der Form formal=value, wobei formal das Schlüsselwort (ohne das einleitende &-Zeichen) ist, mit dem der Parameter in der @PARAMS-Anweisung definiert wurde (Einzelheiten zur Parameterübergabe sind weiter unten sowie bei der @PARAMS-Anweisung erläutert). Die Stellungsparameter müssen vor den Schlüsselwortparametern stehen und genau in der Reihenfolge angegeben werden, in der sie in @PARAMS definiert wurden. Schlüsselwortparameter können in beliebiger Reihenfolge angegeben werden. Wird ein Stellungsparameter nach einem Schlüsselwortparameter angegeben, wird die Anweisung mit der Meldung EDT4948 abgewiesen. Wird ein Schlüsselwortparameter mehrfach angegeben, erfolgt die Meldung EDT3911. Die mögliche Anzahl der Parameter ist durch die maximale Länge einer EDT-Anweisung begrenzt.
spec	Schleifenzähler. In der Prozedur kann er als Operand in EDT-Anweisungen verwendet werden, wenn eine Zeilennummer angesprochen werden soll. Bei der Ausführung der Prozedur nimmt der EDT den jeweils aktuellen Wert des Schleifenzählers (siehe Abschnitt „EDT-Prozeduren“). Der Schleifenzähler muss eines der zugelassenen Sonderzeichen sein, sonst wird @DO mit der Fehlermeldung EDT3952 abgewiesen. Um Fehler und unvorhersehbare Ergebnisse zu vermeiden, sollten folgende Zeichen nicht als Schleifenzähler gewählt werden: % $ ? * ( : # + -  . < = > ’ ; Das Zeichen '=' kann wegen der Syntax des Kommandos gar nicht angegeben werden. Wird die Prozedur im F-Modus gestartet, darf ';' nicht verwendet werden. Geeignete Zeichen für den Schleifenzähler sind: ! { } [ ] | / Wird der Schleifenzähler nicht angegeben, gilt er als undefiniert. Wird die Operandenfolge line1,line2,[–]line3 nicht angegeben, hat der Schleifenzähler den Wert 1.
=line1,line2,[–]line3
	Eine Prozedur wird mehrmals durchlaufen (siehe Beispiel 3). Vor dem ersten Durchlaufen weist der EDT line1 dem Schleifenzähler als Anfangswert zu. Nach jedem Durchlauf erhöht oder vermindert (Minuszeichen vor line3) der EDT den Wert des Schleifenzählers um line3. Standardwert für line3 ist 1. Solange der Schleifenzähler den Wert von line2 noch nicht überschritten bzw. unterschritten hat, wird die Prozedur erneut durchlaufen. Andernfalls wird das Durchlaufen der Prozedur abgebrochen. Die Prozedur wird mindestens einmal durchlaufen, da die Prüfung jeweils nach der Bearbeitung der letzten Zeile erfolgt (REPEAT UNTIL). Wird die letzte Zeile aufgrund einer @RETURN-Anweisung in der Prozedur nicht erreicht, findet die Prüfung nicht statt und die Prozedur wird nicht erneut durchlaufen. Für line1, line2 oder line3 können auch Zeilennummernsymbole (z.B. %,$) angegeben werden. Der EDT nimmt den Wert, den dieses Symbol bei der Ausführung von @DO hat. Ändert sich der Wert dieses Symbols während der Ausführung der Prozedur, bleibt die Zahl der Durchläufe davon unberührt.
	Der Schleifenzähler wird innerhalb der Prozedur wie eine Zeilennummervariable behandelt. Eine Ersetzung des Schleifenzählers durch den aktuellen Wert findet daher auch nur dann statt, wenn der Schleifenzähler als Zeilennummer angesprochen wird, insbesondere also nicht in Literalen. Bei Angabe des Schleifenzählers in einer Anweisung, die eine Zeilennummer mit impliziter Schrittweite erlaubt, wird die implizite Schrittweite – wie bei Zeilennummervariablen – daher immer als 0.0001 angenommen (siehe Beispiel 6). Da ein Sonderzeichen nur dann als Schleifenzähler betrachtet wird, wenn es an Stelle einer Zeilennummer verwendet und in der aufrufenden @DO- Anweisung auch als Schleifenzähler spezifiziert wird, kann bei geschachtelten äußeren Schleifen der gleiche Schleifenzähler mehrfach verwendet werden. Er nimmt dann stets die Werte an, die in der aufrufenden @DO- Anweisung angegeben wurden (siehe Beispiel 7). Ein Zugriff auf Schleifenzähler, die beim Aufruf in einer tieferen Ebene der Schachtelung angegeben wurden, ist nicht möglich, die dort verwendeten Symbole werden in der höheren Ebene nicht durch Zeilennummern ersetzt, was meist zu Syntaxfehlern führt. Der Standardwert für line1, line2 und line3 ist 1.
PRINT	Jede Zeile der Prozedur soll vor ihrer Verarbeitung (mit expandierten Parametern) protokolliert werden. Die Ausgabe erfolgt im Dialogbetrieb nach SYSOUT und im Stapelbetrieb nach SYSLST. Durch die Angabe von PRINT wird auch erreicht, dass alle Fehlermeldungen ausgegeben werden und der EDT-Fehlerschalter gesetzt wird. Normalerweise werden die beiden Meldungen EDT0901 und EDT4932 in Prozeduren nicht ausgegeben und der EDT-Fehlerschalter nicht gesetzt (siehe Abschnitt „Meldungstexte“).

Der Wert eines Stellungsparameters ergibt sich aus allen angegebenen Zeichen zwischen den Kommas bzw. den Klammern, einschließlich der Leerzeichen.
Befinden sich keine Zeichen zwischen den Kommas bzw. den Klammern, so ist der Wert des Stellungsparameters die leere Zeichenfolge.
Der Wert eines Schlüsselwortparameters ergibt sich aus allen angegebenen Zeichen zwischen dem Gleichheitszeichen und dem nachfolgenden Komma bzw. der Klammer, einschließlich der Leerzeichen.
Befinden sich keine Zeichen zwischen dem Gleichheitszeichen und dem nachfolgenden Komma bzw. der Klammer, so ist der Wert des Schlüsselwortparameters die leere Zeichenfolge.

Ein Parameter kann in Hochkommas eingeschlossen werden, diese werden nicht übernommen, wenn sie als erstes und letztes Zeichen des Parameterwerts auftreten und dazwischen entweder keine oder nur doppelte Hochkommas auftreten.

In allen anderen Fällen bleiben alle angegebenen Hochkommas Bestandteil des Parameters (siehe Beispiele bei der @PARAMS-Anweisung). Die Zeichen Komma und schließende Klammer können nur Bestandteil eines Parameters sein, wenn sie innerhalb einer durch Hochkomma eingeschlossenen Teilzeichenfolge des Parameterwertes vorkommen. Hochkommas müssen immer paarig in einem Parameterwert vorkommen. Ein einzelnes Hochkomma kann nicht in einem Parameterwert übergeben werden. Wurde zuvor mit @QUOTE einem anderen Zeichen die Funktion des Hochkommas zugeordnet, gilt dies nicht für die den Parameterwert einschließenden Hochkommas.
Wird ein Stellungsparameter nicht angegeben, erhält der Parameter als Wert die leere Zeichenfolge.
Wird ein Schlüsselwortparameter nicht angegeben, erhält er den Standardwert, der in der @PARAMS-Anweisung festgelegt wurde.

Die angegebenen Parameter werden bei der Parameter-Ersetzung in den Zeichensatz der Prozedur-Arbeitsdatei konvertiert. Enthält die Zeichenfolge Zeichen, die im Ziel-Zeichensatz nicht darstellbar sind, werden diese durch ein Ersatzzeichen ersetzt, sofern ein solches spezifiziert ist (siehe @PAR SUBSTITUTION-CHARACTER). Anderenfalls wird die @DO-Anweisung abgewiesen und die Fehlermeldung EDT5453 ausgegeben.

In Parametern können evtl. Unicode-Ersatzdarstellungen enthalten sein. Diese werden bei der Parameter-Ersetzung noch nicht expandiert. Dies geschieht erst bei der Ausführung der jeweiligen Prozedurzeile.

EDT-Prozeduren können durch [K2] jederzeit unterbrochen werden.
Vom Betriebssystem aus kann man mit /RESUME-PROGRAM die Prozedur fortsetzen oder mit /INFORM-PROGRAM in den EDT zurückkehren und die Prozedur abbrechen.

Während der Abarbeitung einer Benutzeranweisung (siehe @USE) kann die Prozedur nicht mit /INFORM-PROGRAM abgebrochen werden.

Eine fehlerhafte Anweisung innerhalb der Prozedur führt nicht zum Abbruch.

Beispiel 1

1.     @SET #S0 = 'TEST VON PROZEDURDATEI 1'
1.     @PROC 1 ------------------------------------------------------- (1)
1.     @ @SET #S1 = #S0:1-4: ----------------------------------------- (2)
2.     @ @CREATE #S2: ' '*4,#S0:5-9:
3.     @ @CREATE #S3: ' '*9,#S0:10-24:
4.     @ @CREATE #S4: ' '*24
5.     @ @PRINT #S1.-#S4
6.     @ @PRINT #S0
7.     @END ---------------------------------------------------------- (3)
1.     @DO 1 --------------------------------------------------------- (4)
  #S01 TEST
  #S02      VON
  #S03          PROZEDURDATEI 1
  #S04
  #S00 TEST VON PROZEDURDATEI 1
1.

(1)	Es wird in die Arbeitsdatei 1 umgeschaltet.
(2)	In die Arbeitsdatei 1 werden EDT-Anweisungen geschrieben. Diese bewirken beim Aufruf der Prozedur mit @DO, dass die Zeichenfolgevariablen #S1 bis #S4 erzeugt und zusammen mit #S0 ausgegeben werden.
(3)	Mit @END wird aus der Arbeitsdatei 1 zurückgekehrt.
(4)	Die in Arbeitsdatei 1 stehende Prozedur wird aufgerufen.

Beispiel 2

1.     @PROC 2 ------------------------------------------------------- (1)
1.     @ @PARAMS &STRING --------------------------------------------- (2)
2.     @ @SET #S1 = '+++++++++++'
3.     @ @SET #S2 = &STRING ------------------------------------------ (3)
4.     @ @PRINT #S2
5.     @END
1.     @DO 2(#S1) PRINT ---------------------------------------------- (4)
1.     @SET #S1 = '+++++++++++'
1.     @SET #S2 = #S1
1.     @PRINT #S2
  #S02 +++++++++++
1.     @DO 2('#S1') PRINT -------------------------------------------- (5)
1.     @SET #S1 = '+++++++++++'
1.     @SET #S2 = #S1
1.     @PRINT #S2
  #S02 +++++++++++
1.     @DO 2('BLANK''#S1''BLANK') PRINT ------------------------------------------ (6)
1.     @SET #S1 = '+++++++++++'
1.     @SET #S2 = 'BLANK''#S1''BLANK'
1.     @PRINT #S2
  #S02 #S1
1.

(1)	Es wird in die Arbeitsdatei 2 umgeschaltet.
(2)	Die erste in dieser Arbeitsdatei abgelegte Zeile ist eine @PARAMS-Anweisung. Damit kann innerhalb dieser Arbeitsdatei der Stellungsparameter &STRING angesprochen werden.
(3)	#S2 soll ein Wert zugewiesen werden, der jedoch zum Zeitpunkt der Definition der Arbeitsdatei 2 nicht feststeht und erst in einem @DO 2(...)... angegeben wird.
(4)	Durch den in Klammern stehenden Wert #S1 wird vor Ausführung der in der Arbeitsdatei 2 stehenden Anweisungen überall für &STRING der Wert #S1 eingesetzt. PRINT bewirkt das Ausgeben der Anweisungen vor ihrer Durchführung.
(5)	Nun wird der Wert #S1 für den Stellungsparameter &STRING übergeben. Da das erste und letzte Zeichen dieses Parameterwertes ein Hochkomma ist, werden diese beim Ersetzen des Parameterwertes in Arbeitsdatei 2 unterdrückt, was auch hier der PRINT- Operand deutlich zeigt. Somit führt dies zum selben Effekt wie (4).
(6)	Der einzige Unterschied zu (5) ist, dass der Parameterwert um ein vorangehendes bzw. nachfolgendes Leerzeichen erweitert wurde. Dies genügt aber, um das Hochkomma als Inhalt des Parameterwertes zu übergeben.

Beispiel 3

 1.     *
 2.     @PROC 3 ------------------------------------------------------- (1)
 1.     @ @CREATE $+1: $,'*' ------------------------------------------ (2)
 2.     @END ---------------------------------------------------------- (3)
 2.     @DO 3,!=1,15 -------------------------------------------------- (4)
 2.     @PRINT
 1.0000 *
 2.0000 **
 3.0000 ***
 4.0000 ****
 5.0000 *****
 6.0000 ******
 7.0000 *******
 8.0000 ********
 9.0000 *********
10.0000 **********
11.0000 ***********
12.0000 ************
13.0000 *************
14.0000 **************
15.0000 ***************
16.0000 **************** ---------------------------------------------- (5)
 2.

(1)	Es wird in die Arbeitsdatei 3 umgeschaltet.
(2)	Eine einzige EDT-Anweisung wird in die Arbeitsdatei 3 geschrieben.
(3)	Es wird in die Arbeitsdatei 0 zurückgekehrt.
(4)	Die Arbeitsdatei 3 wird ausgeführt. Hierbei wird als Schleifenzähler das Zeichen ! verwendet. Die Arbeitsdatei 3 wird 15mal durchlaufen. Man könnte dort Zeilennummern über ! ansprechen, kann dies aber auch unterlassen wie in diesem Beispiel. Mit !=1,15 erreicht man dasselbe wie durch 15maliges Abschicken von @DO 3 ohne diese Operandenfolge.
(5)	Beim Ausgeben erkennt man, dass 15 neue Zeilen angelegt wurden.

Beispiel 4

   5.     @PRINT
   1.0000 1111111
   2.0000 2222222
   3.0000 3333333
   4.0000 4444444
   5.     @SET #S4 = '-----------------'
   5.     @PROC 4 ------------------------------------------------------- (1)
   1.     @ @PRINT !.-.$ ------------------------------------------------ (2)
   2.     @ @PRINT #S4 N
   3.     @END
   5.     @DO 4,!=$,%,-1 ------------------------------------------------ (3)
   4.0000 4444444
-----------------
   3.0000 3333333
   4.0000 4444444
-----------------
   2.0000 2222222
   3.0000 3333333
   4.0000 4444444
-----------------
   1.0000 1111111
   2.0000 2222222
   3.0000 3333333
   4.0000 4444444
-----------------
   5.

(1)	Es wird in die Arbeitsdatei 4 umgeschaltet.
(2)	Eine Zeilennummer wird über den Schleifenzähler ! angesprochen.
(3)	Die Arbeitsdatei 4 wird mehrmals ausgeführt. Beim 1. Durchlauf wird für ! der Wert der höchsten vergebenen Zeilennummer angenommen. Bei jedem weiteren Durchlauf erniedrigt sich dieser Wert um 1 (drittes line=-1), bis der Schleifenzähler den Wert der niedrigsten vergebenen Zeilennummer (%) angenommen hat.

Beispiel 5

1.     @PROC 4 ------------------------------------------------------- (1)
1.     @READ 'PROC-DATEI.4' ------------------------------------------ (2)
6.     @PRINT
1.0000 @PARAMS &A, &OPTION=ALL 
2.0000 ABCABCABCABC
3.0000 EFG
4.0000 @ON  1 CHANGE &OPTION 'ABC' TO '&A'
5.0000 @5: &A
6.     @END ---------------------------------------------------------- (3)
1.     @DO 4 ('A','B',OPTION=R) -------------------------------------- (4)
6.     @PRINT
1.0000 ABCABCABCA,'B ------------------------------------------------- (5)
2.0000 EFG
5.0000  A,''B
6.

(1)	Es wird in die Arbeitsdatei 4 umgeschaltet.
(2)	Die SAM-Datei PROC-DATEI.4 wird in die Arbeitsdatei 4 gelesen.
(3)	Es wird in die Arbeitsdatei 0 zurückgekehrt.
(4)	Der Standardwert ALL des Schlüsselwortparameters &OPTION wird beim Aufruf durch R ersetzt. Folglich findet das Suchen und Ersetzten in Zeile 1 rückwärts statt.
(5)	Beim Ausführen der Arbeitsdatei wurden Zeilen in die aktuelle Arbeitsdatei geschrieben. In Zeile 1 hat der EDT eines der 2 aufeinander folgenden Hochkommas unterdrückt. In Zeile 3 hat der EDT den Parameterwert unverändert übernommen.

Beispiel 6

1.     AAA
2.     BBB
3.     CCC
4.     @PROC 1
1.     @@COPY 1-3 TO ! ----------------------------------------------- (1)
2.     @END 
4.     @DO 1,!=4,4 --------------------------------------------------- (2)
5.0002 @DO 1,!=5.0,5.0 ----------------------------------------------- (3)
6.0002 @PRINT -------------------------------------------------------- (4)
1.0000 AAA
2.0000 BBB
3.0000 CCC
4.0000 AAA
4.0001 BBB
4.0002 CCC
5.0000 AAA
5.0001 BBB
5.0002 CCC
6.0002

(1)	Die Prozedurdatei enthält eine Anweisung, bei der die Schrittweite implizit durch die Angabe der Zeilennummer des Zielbereichs festgelegt wird.
(2)	Aufruf der Prozedur mit Schleifenzähler 4.
(3)	Aufruf der Prozedur mit Schleifenzähler 5.0.
(4)	Die Ausgabe zeigt, dass für den Schleifenzähler stets die implizite Schrittweite 0.0001 genommen wurde - wie dies auch bei Zeilennummervariablen der Fall ist.

Beispiel 7

1.     @PROC 1
1.     @   @DO 2, !=!,1,-1 ------------------------------------------- (1)
1.     @END
1.     @PROC 2
1.     @   @SET #L1 = ! ---------------------------------------------- (2)
2.     @   @SET #S1 = C #L1 ------------------------------------------ (3)
3.     @   @PRINT #S1 ------------------------------------------------ (4)
3.     @END
1.     @DO 1, !=1,4 -------------------------------------------------- (5)
  #S01    1.0000 ----------------------------------------------------- (6)
  #S01    2.0000
  #S01    1.0000
  #S01    3.0000
  #S01    2.0000
  #S01    1.0000
  #S01    4.0000
  #S01    3.0000
  #S01    2.0000
  #S01    1.0000
1. 

(1)	In Arbeitsdatei 1 wird eine @DO-Anweisung abgelegt. Der Schleifenzähler ! wird hier in zwei Bedeutungen verwendet, einmal wird er neu definiert für den Aufruf der@DO-Prozedur in Arbeitsdatei 2, zum anderen wird als Anfangswert der aktuelle Wert des Schleifenzählers übernommen, der beim Aufruf von Arbeitsdatei 1 spezifiziert wurde. Dies ist möglich, weil die Ersetzung nur dort stattfindet, wo das Symbol ! auch als Zeilennummer verwendet wird.
(2)	In Arbeitsdatei 2 wird der Wert des dort aktuellen Schleifenzählers der Zeilennummervariablen #L1 zugewiesen.
(3)	Die Zeilennummervariable #L1 wird abdruckbar in #S1 abgelegt.
(4)	Die Zeichenfolgevariable #S1 wird ausgegeben.
(5)	Beim Aufruf von Arbeitsdatei 1 lässt man den Schleifenzähler von 1 bis 4 laufen.
(6)	Das Ergebnis zeigt: der innere Schleifenzähler (in Arbeitsdatei 2) läuft viermal rückwärts bis 1.0000 ausgehend von den Startwerten 1.0000 bis 4.0000.