7.6. Příkaz PERFORM A) Příkaz PERFORM s uvedenou procedurou Příkaz PERFORM se používá k provádění cyklů a vnitřních podprogramů. Umožňuje přerušit provádění příkazů v tom pořadí, v jakém po sobě následují ve zdrojovém programu, a jednou nebo několikrát provést určitý úsek programu. Po ukončení posledního provádění tohoto úseku programu se bude provádět příkaz následující ve zdrojovém programu za příkazem PERFORM. Ve všech formátech příkazu PERFORM je úsek programu, který má být prováděn, určen zápisem procedura-1 [ {THRU|THROUGH} procedura-2 ] Slova THRU a THROUGH jsou ekvivalentní. Jedním provedením tohoto úseku programu se pak rozumí toto: a) Za posledním příkazem procedury-2 se aktivuje "návratový můstek" připravený překladačem. Není-li v zápisu úseku programu uvedena možnost "THRU/THROUGH procedura-2" (tj. má-li zápis úseku programu tvar pouze "procedura-1"), aktivuje se tento "návratový můstek" za posledním příkazem procedury-1. (Tento "návratový můstek představuje vlastně implicitní "příkaz návratu" zařazený překladačem na konec každého úseku programu prováděného pomocí příkazu PERFORM). b) Odskočí se na začátek procedury-1 (jakoby příkazem GO). c) Nyní může program provádět jakékoliv příkazy (včetně GO a PERFORM) jakkoliv rozmístěné v PROCEDURE DIVISION. Jakmile se při provádění programu přijde na aktivovaný návratový můstek, vrátí tento můstek řízení zpět do příkazu PERFORM. Jednalo-li se o jediné nebo poslední provádění příslušného úseku programu, je tímto návratem příkaz PERFORM ukončen, můstek se dezaktivuje a přejde se na příkaz následující ve zdrojovém programu za příkazem PERFORM. Má-li být příslušný úsek programu znovu prováděn, není tímto návratem příkaz PERFORM ukončen, návratový můstek zůstává aktivován a po provedení určitých organizačních akcí se znovu předává řízení na začátek procedury-1. Poznámky: 1) "Návratový můstek" vygenerovaný na konci úseku programu může v určitém okamžiku sloužit pouze pro jediný aktivní příkaz PERFORM. Provede-li se ještě před ukončením činnosti jednoho příkazu PERFORM a odpovídající dezaktivací aktivovaného "návratového můstku" nový příkaz PERFORM (týž anebo jiný), jehož úsek programu končí na témže "návratovém můstku", bude nadále tento "návratový můstek" sloužit pouze pro tento nový příkaz PERFORM a původní příkaz PERFORM "zaniká", takže k jeho ukončení již nikdy nemůže dojít. 2) Přijde-li při výpočtu řízení na "návratový můstek" ukončující úsek programu patřící k některému příkazu PERFORM, přičemž však tento "návratový můstek" není právě aktivován (neboť žádný z odpovídajících příkazů PERFORM není právě aktivní), bude "návratový můstek" zcela neúčinný a nezpůsobí žádný odskok, takže výpočet bude pokračovat na příkazu následujícím za tímto "návratovým můstkem". 3) Každý příkaz PERFORM s uvedenou procedurou může být nahrazen pomocí ostatních příkazů jazyka COBOL (GO, IF, MOVE, ADD), čímž se sice prodlouží zápisy ve zdrojovém programu, ale každé provádění úseku programu se velmi výrazně zrychlí. Je to způsobeno tím, že jazyk C, do něhož je cobolský program překládán, nezná žádnou konstrukci odpovídající cobolskému příkazu PERFORM s uvedenou procedurou, takže cobolský příkaz PERFORM musí být překládán velmi komplikovaným a neefektivním způsobem. Pokud je to možné, je výhodné se příkazům PERFORM s uvedenou procedurou vyhýbat. Naproti tomu příkaz PERFORM bez procedury (viz B) je překládán zhruba stejně efektivně, jako kdyby jej uživatel sám nahradil pomocí příkazů GO, IF, MOVE, ADD atd. Formát 1: PERFORM procedura [{THRU|THROUGH} procedura] Funkce: Příkaz PERFORM formátu 1 způsobí jediné provedení zadaného úseku programu. Příklady: PERFORM TISK PERFORM ZACATEK OF PRVNI THRU KONEC OF POSLEDNI Formát 2: PERFORM procedura [{THRU|THROUGH} procedura] { celé-číslo | celočís.položka } TIMES Funkce: Příkaz PERFORM formátu 2 provede zadaný úsek programu tolikrát, kolik činí hodnota uvedeného celého čísla nebo celočíselné položky. Pravidla: 1) Celé číslo smí být nejvýše 2147483647. 2) Při uvedení celočíselné položky je počet opakování určen počáteční hodnotou této položky v okamžiku začátku provádění příkazu PERFORM. Změny hodnoty této položky během provádění zadaného úseku programu již nemají na počet opakování vliv. 3) Je-li hodnota uvedené celočíselné položky záporná nebo nulová, neprovede se úsek programu ani jednou. Příklady: PERFORM ALFA THRU OMEGA 25 TIMES PERFORM KONTROLA N TIMES Formát 3: PERFORM procedura [{THRU|THROUGH} procedura] UNTIL podmíněný-výraz Funkce: Příkaz PERFORM s klauzulí UNTIL způsobí, že zadaný úsek programu bude prováděn opakovaně tak dlouho, až poprvé bude shledán pravdivým podmíněný výraz uvedený za slovem UNTIL, čímž se činnost příkazu PERFORM ukončí. Je-li tento podmíněný výraz pravdivý již na začátku provádění příkazu PERFORM, neprovede se zadaný úsek programu ani jednou. Schéma příkazu PERFORM s klauzulí UNTIL: ------------ --------------- |podm.výraz| ano |proveď příkaz| ------>-|pravdivý ?|----->-----| následující |-->--- | ------------ | za PERFORM | | V ne --------------- | --------------- --<-|proveď zadaný| |úsek programu| --------------- Příklad: PERFORM ZPRAC UNTIL X > 10 Bude-li při vyhodnocování podmínky X <= 10, provede se procedura ZPRAC a znovu se přejde na vyhodnocování podmínky. Při X > 10 se provádění příkazu PERFORM (tj. opakované provádění procedury ZPRAC) ukončí a přejde se na následující příkaz. V proceduře ZPRAC by se zřejmě měla měnit hodnota položky X, jinak se výpočet zacyklí. Formát 4: V následujícím formátu "proměnná" označuje "numerickou-položku" nebo "speciální-index", zatímco "arg" označuje "numerickou-položku" nebo "numerický-literál" nebo "speciální-index" nebo "UI-položku" a "podm" je zkratka pro "podmíněný-výraz": PERFORM procedura [{THRU|THROUGH} procedura] VARYING proměnná [FROM arg] [BY arg] [UNTIL podm] - - | AFTER proměnná [FROM arg] [BY arg] [UNTIL podm] | ... - - Pravidla: 1) V příkazu PERFORM formátu 4 je přípustné uvést libovolný počet klauzulí AFTER. 2) Je-li za VARYING resp. AFTER uvedena numerická položka, bude argument uvedený za FROM do ní přesunován příkazem MOVE (jedná-li se o numerickou položku nebo o numerický literál) nebo příkazem SET s volbou TO (jedná-li se o speciální index, v tom případě však položka za VARYING/AFTER musí být celočíselná). Při numerické položce za VARYING/AFTER nesmí být za FROM uvedena UI-položka. Argument uvedený za BY musí být numerická položka nebo numerický literál a bude k numerické položce uvedené za VARYING/AFTER přičítán příkazem ADD. 3) Je-li za VARYING resp. AFTER uveden speciální index, smí za FROM stát pouze speciální index, UI-položka, celočíselná numerická položka nebo celočíselný numerický literál; tento argument bude do speciálního indexu uvedeného za VARYING/AFTER přesunován příkazem SET s volbou TO. Za BY smí stát pouze celočíselná numerická položka, celočíselný numerický literál, speciální index nebo UI-položka; tento argument bude k speciálnímu indexu uvedenému za VARYING/AFTER přičítán příkazem SET s volbou UP. 4) Klauzule "FROM argument" smí být vynechána, předpokládá se pak "FROM 1". Obdobně klauzule "BY argument" smí být vynechána, předpokládá se pak "BY 1", Je tedy přípustný např. příkaz PERFORM Q VARYING I UNTIL I > 10 a je ekvivalentní s příkazem PERFORM Q VARYING I FROM 1 BY 1 UNTIL I > 10 (a to nezávisle na tom, zda I je numerická položka nebo speciální index). Rovněž je přípustný např. příkaz PERFORM Q VARYING I UNTIL I > N AFTER J UNTIL J > M a je ekvivalentní s příkazem PERFORM Q VARYING I FROM 1 BY 1 UNTIL I > N AFTER J FROM 1 BY 1 UNTIL J > M. 5) Je-li za VARYING resp. AFTER uveden speciální index, smí být klauzule "UNTIL podmíněný-výraz" vynechána. Předpokládá se pak podmínka, že speciální index uvedený za VARYING/AFTER je větší než počet prvků určený tou klauzulí OCCURS, v níž je tento speciální index definován v podklauzuli INDEXED. Tak např. při popisu 02 PRVEK OCCURS 100 INDEXED I. je příkaz "PERFORM Q VARYING I" ekvivalentní s příkazem "PERFORM Q VARYING I FROM 1 BY 1 UNTIL I > 100". Naproti tomu při popisu 02 ZAMEST OCCURS 10000 DEPENDING N INDEXED I J. je příkaz "PERFORM Q VARYING I" ekvivalentní s příkazem "PERFORM Q VARYING I FROM 1 BY 1 UNTIL I > N", jenž je ovšem neefektivní; výhodnější by bylo převést předem hodnotu položky N do "maximálního" speciálního indexu J příkazem "SET J TO N" a pak provést příkaz "PERFORM Q VARYING I UNTIL I > J" s explicitně uvedenou podmínkou. Je-li za VARYING resp. AFTER uvedena numerická položka, nesmí být klauzule "UNTIL podmíněný-výraz" vynechána. Schéma příkazu PERFORM s klauzulí VARYING a bez kl. AFTER: PERFORM úsek-programu VARYING A FROM B BY C UNTIL podm.výraz ------------- --------------- --------------- |MOVE B TO A| | podm.výraz |ano |proveď příkaz| --->| resp. |-->| pravdivý ? |--->| následující | |SET A TO B | | --------------- | za PERFORM | ------------- | |ne --------------- | --------------- | |proveď zadaný| | |úsek-programu| | --------------- | --------------- | | ADD C TO A | -<| resp. | |SET A UP BY C| --------------- Funkce: Příkaz PERFORM formátu 4 bez klauzule AFTER provádí opakovaně zadaný úsek programu, přičemž při prvním průchodu má položka resp. speciální index za VARYING hodnotu rovnou hodnotě údaje uvedeného za FROM, a před každým dalším průchodem bude hodnota položky resp. speciálního indexu za VARYING zvětšena o hodnotu argumentu uvedeného za BY. Provádění úseku programu se ukončí, jakmile na začátku průchodu (tj. již s přičteným argumentem za BY) bude podmíněný výraz uvedený za UNTIL shledán pravdivým. Je-li tento podmíněný výraz pravdivý již před prvním průchodem (tj. již s naplněnou položkou resp. speciálním indexem za VARYING), neprovede se zadaný úsek programu ani jednou. Příklad: PERFORM PRESUN VARYING I FROM 1 BY UNTIL I > 10 Procedura PRESUN bude provedena celkem desetkrát, přičemž položka I bude mít postupně hodnoty 1, 2, ..., 10 (pokud se ovšem při provádění procedury PRESUN nemění hodnota I). Funkce: Při uvedení jedné, dvou nebo více klauzulí AFTER se jedná o dva, tři nebo více cyklů "vložených do sebe". Následující schémata ukazují funkci příkazu PERFORM s jednou a se dvěma klauzulemi AFTER. Schéma příkazu PERFORM s jednou klauzulí AFTER: PERFORM úsek-programu VARYING A1 FROM B1 BY C1 UNTIL podmíněný-výraz-1 AFTER A2 FROM B2 BY C2 UNTIL podmíněný-výraz-2 --------------- --------------- |MOVE B1 TO A1| |MOVE B2 TO A2| --->| resp. |-->| resp. | |SET A1 TO B1 | |SET A2 TO B2 | --------------- --------------- --------------- --------------- |podm.výraz-1 |ano |proveď příkaz| ---------->|je pravdivý? |---->| následující | | --------------- | za PERFORM | | | --------------- | | | --------------- | |podm.výraz-2 | ano | ----->|je pravdivý? |------>----- | | --------------- | | | |ne | | | | ----------------- | | ----------------- | MOVE B2 TO A2 | | | | proveď zadaný | | resp. | | | | úsek-programu | | SET A2 TO B2 | | | ----------------- ----------------- | | ----------------- ----------------- | | | ADD C2 TO A2 | | ADD C1 TO A1 | | | | resp. | | resp. | | -<---|SET A2 UP BY C2| |SET A1 UP BY C1| | ----------------- ----------------- ------------------------<------------- Schéma příkazu PERFORM se dvěma klauzulemi AFTER: PERFORM úsek-programu VARYING A1 FROM B1 BY C1 UNTIL podmíněný-výraz-1 AFTER A2 FROM B2 BY C2 UNTIL podmíněný-výraz-2 AFTER A3 FROM B3 BY C3 UNTIL podmíněný-výraz-3 | --------------- |MOVE B1 TO A1| | resp. | |SET A1 TO B1 | --------------- --------------- |MOVE B2 TO A2| | resp. | |SET A2 TO B2 | --------------- --------------- |MOVE B3 TO A3| | resp. | |SET A3 TO B3 | --------------- --------------- --------------- ano |proveď příkaz| ----->|podm.výraz-1 |------------------------->| následující | | |je pravdivý? | | za PERFORM | | --------------- --------------- | -------------- ano | --->|podm.výraz-2|---------------->----------------- | | |je pravdivý?| | | | -------------- | | | -------------- ano | | | ->|podm.výraz-3|------->----- | | | | |je pravdivý?| | | | | | -------------- | | | | | | | | | | | | ------------------ ----------------- | | |----------------- | MOVE B3 TO A3 | | MOVE B2 TO A2 | | | || proveď zadaný | | resp. | | resp. | | | || úsek-programu | | SET A3 TO B3 | | SET A2 TO B2 | | | |----------------- ------------------ ----------------- | | |----------------- ------------------ ----------------- | | || ADD C3 TO A3 | | ADD C2 TO A2 | | ADD C1 TO A1 | | | -| resp. | | resp. | | resp. | | | |SET A3 UP BY C3| |SET A2 UP BY C2 | |SET A1 UP BY C1| | | ----------------- ------------------ ----------------- | | | | | | | | | -------------<----------------- | --------------------------------------<--------------- Poznámky: l) Pro správnou činnost příkazu PERFORM s jednou nebo více klauzulemi AFTER je nezbytné, aby položky a speciální indexy uvedené za VARYING a za AFTER byly navzájem různé. 2) Ze schémat je vidět, že se vždy nejprve dosazuje počáteční hodnota do A2 resp. A3, a teprve potom se zvětšuje hodnota A1 resp. A2 (na pořadí těchto dvou operací by záleželo např. tehdy, kdyby A2 a C1 byla táž položka). 3) Během provádění zadaného úseku programu je přípustné libovolně změnit hodnoty položek a speciálních indexů uvedených v příkazu; všechny další operace s nimi (nastavování počáteční hodnoty, zvětšování hodnoty a zjišťování pravdivosti podmíněných výrazů) se pak provádějí již s těmito změněnými hodnotami. (Jinými slovy: u každé z uvedených položek a speciálních indexů se vždy používá jejich okamžitá hodnota a nikoliv nějaká uschovaná počáteční hodnota.) Příklad: PERFORM TISK VARYING I FROM 1 BY 1 UNTIL I > 3 AFTER J FROM 1 BY 1 UNTIL J = 5 AFTER K FROM 1 BY 1 UNTIL K = 3 Nemění-li se v proceduře TISK hodnoty položek I, J, K, bude tato procedura provedena celkem 24-krát, přičemž při jednotlivých prováděních budou mít položky I, J, K postupně tyto hodnoty: I: 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 J: 1 1 2 2 3 3 4 4 1 1 2 2 3 3 4 4 1 1 2 2 3 3 4 4 K: 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 1 2 Nejpomaleji se tedy mění položka uvedená za VARYING, pak položka uvedená za prvním AFTER atd., až nejrychleji se mění položka uvedená za posledním AFTER. Po ukončení činnosti příkazu PERFORM bude I = 4, J = 1, K = 1. Poznámka: Během provádění úseku programu odpovídajícího jednomu příkazu PERFORM je přípustné provést další příkaz PERFORM. Je však potřebné dodržet následující pravidla: l) Při provádění úseku programu odpovídajícího jednomu příkazu PERFORM by nemělo přijít řízení na aktivovaný "návratový můstek" odpovídající jinému příkazu PERFORM, který byl zahájen dříve a je doposud též v činnosti. 2) Dva úseky programu odpovídající dvěma různým příkazům PERFORM, který mohou být současně v činnosti, by neměly mít společný konec. Pokud by úseky programu odpovídající oběma příkazům PERFORM byly souvislé části zdrojového programu (což je sice obvyklé, ne však nezbytné), měl by tedy druhý z nich ležet buďto celý uvnitř anebo celý vně prvního. Výše uvedené podmínky pochopitelně nemohou být kontrolovány během překladu. Pokud je však uživatel při výpočtu poruší, bude výpočet probíhat nesprávně. Příklady správného použití: 1) PERFORM A THRU B : : A. IF I = 0 GO TO B. PERFORM T. (procedura T leží celá vně B. ADD 1 TO J. úseku programu "A THRU B") C. : : T. DISPLAY I J K. 2) PERFORM A THRU C : (procedura B leží celá uvnitř : úseku programu "A THRU C"; A. MOVE 1 TO N. provede se celkem 10-krát (!), PERFORM B 9 TIMES. a to po desáté již mimo příkaz B. ADD P(N) TO Q. "PERFORM B 9 TIMES", takže ADD 1 TO N. "návratový můstek" na konci C. DISPLAY Q. paragrafu B bude neúčinný) Příklady chybného použití: 1) PERFORM A THRU C : : A. ADD 1 TO I. B. PERFORM C THRU D. C. ADD 1 TO J. D. ADD 1 TO K. E. Provedou se postupně následující akce: a) První příkaz PERFORM aktivuje můstek na konci paragrafu C; připraví se zde skok za první příkaz PERFORM. b) První příkaz PERFORM odskočí na začátek paragrafu A. c) Po provedení příkazu ADD se přijde na druhý příkaz PERFORM. d) Druhý příkaz PERFORM aktivuje můstek na konci paragrafu D; připraví se zde skok za druhý příkaz PERFORM. e) Druhý příkaz PERFORM odskočí na začátek paragrafu C. f) Po provedení příkazu ADD se přijde na aktivovaný můstek na konci paragrafu C, nastavený prvním příkazem PERFORM. Provede se tedy skok za první příkaz PERFORM a můstek na konci paragrafu C bude dezaktivován. Můstek na konci paragrafu D, nastavený druhým příkazem PERFORM, zůstane aktivován. Přijde-li se někdy v dalším výpočtu na konec paragrafu D, způsobí tento aktivovaný můstek skok za druhý příkaz PERFORM. 2) PERFORM A THRU C : : A. ADD 1 TO I. B. PERFORM C. C. ADD 1 TO J. D. Provedou se postupně následující akce: a) První příkaz PERFORM aktivuje můstek na konci paragrafu C; připraví zde skok za první příkaz PERFORM. b) První příkaz PERFORM odskočí na začátek paragrafu A. c) Po provedení příkazu ADD se přijde na druhý příkaz PERFORM. d) Druhý příkaz PERFORM aktivuje můstek na konci paragrafu C; připraví zde skok za druhý příkaz PERFORM. Tím se beze zbytku zruší původně připravený odskok za první příkaz PERFORM, nastavený v bodě a). e) Druhý příkaz PERFORM odskočí na začátek paragrafu C. f) Po provedení příkazu ADD se přijde na aktivovaný můstek na konci paragrafu C, nastavený druhým příkazem PERFORM. Provede se tedy skok za druhý příkaz PERFORM a můstek na konci paragrafu C bude dezaktivován (takže přijde-li - jak je tomu např. v našem zjednodušeném příkladě - někdy řízení na konec paragrafu C, můstek zde umístěný bude neúčinný a projde se lineárně dále na paragraf D). Návrat za první příkaz PERFORM se již nikdy neuskuteční, protože k tomu potřebná odskoková instrukce nastavená v bodě a) byla zrušena v bodě d). Tento příklad by bylo třeba opravit např. tak, že mezi paragrafy C a D vložíme paragraf neobsahující žádné příkazy (resp. obsahující pouze příkaz EXIT nebo NOTE): PERFORM A THRU C-POM. : : A. ADD 1 TO I. B. PERFORM C. C. ADD 1 TO J. C-POM. EXIT. (slouží pouze pro "návratový můstek") D. B) Příkaz PERFORM bez procedury Každý z formátů příkazu PERFORM popsaných v části A může být uveden i v modifikovaném tvaru jakožto příkaz PERFORM bez procedury, jenž se od příkazu PERFORM s uvedenou procedurou (popsaného v části A) liší v těchto vlastnostech: 1) Za slovem PERFORM se neuvádí určení úseku programu "procedura [{THRU|THROUGH} procedura]". Následující klauzule příkazu PERFORM (TIMES, UNTIL, VARYING - viz A) však zůstávají beze změny co do zápisu i co do významu. 2) Příkaz PERFORM nepředává řízení do jiných procedur ani vět programu. Úsek programu, jenž bude účinkem příkazu PERFORM bez procedury jednou nebo několikrát prováděn, je tvořen posloupnosti příkazů následujících v téže větě programu bezprostředně za příkazem PERFORM. Tento úsek programu může sahat nejvýše po tečku ukončující tuto větu programu, může však být ukončen i dříve, a to klauzulí END-PERFORM. Mimoto je tento úsek programu ukončen i při dosažení klauzule ELSE, END-IF nebo WHEN od takového příkazu IF, ON nebo SEARCH, jenž ve větě programu předchází před naším příkazem PERFORM (tzn. jehož "rozsah" zahrnuje náš příkaz PERFORM); před takovýmto ELSE, END-IF resp. WHEN se pak vlastně předpokládá implicitní klauzule END-PERFORM, která má přesně stejný účinek, jako kdyby zde byla uvedena explicitní klauzule END-PERFORM (viz 5.1.F). 3) Po ukončení posledního provádění příslušného úseku programu (jakož i v případě, že úsek programu nemá být prováděn ani jednou) se přejde na příkaz následující ve zdrojovém programu za posledním příkazem tohoto úseku programu (přesněji: za "návratovým můstkem" vygenerovaným automaticky překladačem na konci tohoto úseku programu, kterýžto můstek vlastně odpovídá explicitní nebo implicitní klauzuli END-PERFORM nebo tečce). Formát 1: PERFORM [příkaz] ... [END-PERFORM] Formát 2: PERFORM { celé-číslo | celočís.položka } TIMES [příkaz] ... [END-PERFORM] Formát 3: PERFORM UNTIL podmíněný-výraz [příkaz] ... [END-PERFORM] Formát 4: PERFORM VARYING proměnná [FROM arg] [BY arg] [UNTIL podm] -- -- | AFTER proměnná [FROM arg] [BY arg] [UNTIL podm] | ... -- -- [příkaz] ... [END-PERFORM] Příklady: PERFORM VARYING I FROM 1 BY 1 UNTIL I > N ADD A(I) TO SUMA. PERFORM VARYING I AFTER J AFTER K ADD A(I J K) TO SOUCET. PERFORM VARYING J UNTIL J > M COMPUTE S = S + A(J) * B(J). IF B = 0 SET I TO 1 PERFORM N TIMES MOVE A(I) TO C(I) SET I UP 1 END-PERFORM WRITE W1 ELSE SET I TO K PERFORM UNTIL D(I) > 100 MOVE 0 TO E(I) SET I TO F(I) END-PERFORM WRITE W2. Příklad: Úsek programu smí být i prázdný, tzn. smí neobsahovat žádné příkazy. Tato možnost má praktický význam pouze při formátu s VARYING, např. PERFORM VARYING I FROM 1 BY 1 UNTIL JMENO(I) = 'NOVAK'. Tento příkaz PERFORM nalezne nejmenší index I takový, že JMENO(I) = 'NOVAK'. Týž účinek by ovšem po předchozím nastavení "SET I TO 1" měl i příkaz SEARCH PRVEK WHEN JMENO(I) = 'NOVAK' ... jenž nalezne index I rychleji a navíc umožňuje hlídat konec tabulky pomocí klauzule AT END a ošetřit tak i případ, že žádný takový index I neexistuje. Poznámky: 1) Mezi příkazy v prováděném úseku programu smí být jakékoliv příkazy, tedy též další příkaz PERFORM bez procedury, jehož úsek programu může končit současně s úsekem programu od "vnějšího" příkazu PERFORM anebo i dříve na své klauzuli END-PERFORM (případně ELSE, END-IF nebo WHEN, viz 5.1.F). Každý z těchto příkazů PERFORM má ovšem svůj "návratový můstek". Počet takto do sebe vložených příkazů PERFORM bez procedury smí být až 256 (podrobněji viz 5.1.F). 2) V rámci prováděného úseku programu lze samozřejmě bez omezení provádět příkazy PERFORM s uvedenou procedurou, příkazy CALL, volat deklarativní sekce atd. 3) Vzhledem k tomu, že do prováděného úseku programu nelze předat řízení z ostatních částí zdrojového programu, a že překladač generuje zvláštní "návratový můstek" pro každý příkaz PERFORM bez procedury (i v případě společného konce několika úseků programu), odpadají zde všechna pravidla a omezení uvedená u příkazu PERFORM s uvedenou procedurou pro "návratové můstky" (viz část A výše). 4) Je povoleno opustit úsek programu bez návratu (příkazem GO apod.) a později provést týž příkaz PERFORM bez procedury znovu, aniž by dřívější opuštění úseku programu mělo jakékoliv následky (původní PERFORM se zcela zapomene). 5) Klauzule END-PERFORM znamená "soukromou tečku" (tj. konec "rozsahu") nejen pro odpovídající příkaz PERFORM, ale též pro všechny dosud neukončené příkazy IF a ON (u nichž tedy klauzule END-PERFORM má zároveň funkci i klauzule END-IF), příkazy SEARCH a příkazy s klauzulemi AT END, INVALID KEY, ON SIZE ERROR, ON OVERFLOW, AT EOP resp. AT END-OF-PAGE a NO DATA ležící mezi začátkem odpovídajícího příkazu PERFORM a klauzulí END-PERFORM. Jejich "rozsahy" jsou tedy touto klauzulí END-PERFORM též ukončeny, takže při dosažení klauzule ELSE nebo WHEN resp. při nepravdivosti podmíněného výrazu u příkazu IF bez ELSE resp. při "neoznačeném" průchodu u příkazu ON bez ELSE resp. při neuplatnění klauzule AT END atd. se skáče nikoliv až na první příkaz za tečkou, nýbrž pouze na "návratový můstek" vygenerovaný na místě klauzule END-PERFORM. Obráceně klauzule ELSE, END-IF a WHEN ukončují rozsahy všech příkazů PERFORM bez procedury začínajících mezi začátkem odpovídajícího příkazu IF, ON resp. SEARCH a klauzulí ELSE, END-IF resp. WHEN, které dosud nebyly ukončeny (stejně jako kdyby bezprostředně před tímto ELSE, END-IF resp. WHEN byla pro každý takový příkaz PERFORM bez procedury explicitně uvedena klauzule END-PERFORM). 6) Klauzule END-PERFORM bezprostředně následovaná tečkou nebo některou z klauzulí ELSE, END-IF nebo WHEN může být vynechána a předpokládá se zde implicitně. Použití: Formáty 2, 3 a 4 slouží k zjednodušení zápisu a ke zrychlení výpočtu v případě, že opakovaně prováděný úsek programu může být zapsán tak, aby neobsahoval ani záhlaví procedur ani tečky, to jest jakožto část jediné věty programu. Příkaz PERFORM bez procedury je při každém provádění úseku programu velmi výrazně (snad o desítky instrukcí) rychlejší než odpovídající příkaz PERFORM s uvedenou procedurou a je prakticky stejně rychlý jako nahrazení tohoto příkazu PERFORM pomocí příkazů MOVE, SET, IF, GO, ADD atd. Formát 2 (s TIMES) je při téže akci prakticky stejně rychlý jako formát 3 (s UNTIL) nebo formát 4 (s VARYING). Poznámka: Formát 1 neprovádí vlastně žádnou činnost a má význam pouze "příkazových závorek" pro ukončení rozsahu (tj. určení cíle skoku) vložených podmíněných příkazů s klauzulemi WHEN, AT END, INVALID KEY atd.; např. IF T1 = 1 AND T2 = 1 PERFORM READ S1 AT END MOVE 0 TO T1 END-PERFORM PERFORM READ S2 AT END MOVE 0 TO T2 END-PERFORM PERFORM ZPRACOVANI. Zde při neuplatnění klauzule AT END odskakuje každý z příkazů READ nikoliv až za tečku, nýbrž pouze na konec svého rozsahu tj. za nejbližší klauzuli END-PERFORM. Oba příkazy PERFORM bez procedury (formátu 1) se jinak zcela ignorují.