A REXX ELJÁRÁSNYELV LEÍRÁSA

Készítette : Mocsáry János és Belme Attila

Tartalom

A VM/SP System Product Interpreter és a REXX eljárásnyelv

A REXX elemei

A REXX parancsok ismertetése

Beépitett függvények

Egyéb függvények

Példák

A VM/SP System Product Interpreter és a REXX eljárásnyelv

A CMS alatt mûködõ EXEC eljárásnyelvek között sorrendben ez már a harmadik, és szinte semmiben sem hasonlít az elõdeihez.

Az interpreter képes végrehajtani a REXX nyelven készült eljárásokat CMS és XEDIT környezetben egyaránt.

A REXX elemei

Az utasítások írásmódja ::: Az utasításokat egyenként külön sorba , vagy egy sorba az egymás után következõket ";" -el elválasztva lehet írni. A sor hossza maximum 250 karakter. Ha egy utasítás nem fér ki egy sorba, akkor több soron keresztül is folytathatjuk.

Megjegyzés (Comment) ::: /* és */ karakterek közé írt bármilyen szöveg. A REXX programot megjegyzés sorral kell kezdeni, mert a CMS az elsõ sor alapján választja ki a megfelelõ interpretert.

Változó név (Szimbólum) ::: betûvel kezdõdik, és maximum 250 karakter hosszú. A kis és nagybetûk között nincs különbség. Amíg egy változó értéket nem kap, addig az értéke a saját neve lesz. Ha a változó string-et tartalmaz, akkor annak hosszát csak a virtuális tár mérete korlátozza.

Értékadás ::: Változó = kifejezés Az értékadást tehát egyenlõségjellel jelezzük. A kifejezés tetszõleges aritmetikai, logikai, vagy szöveges (String) mûveleteket tartalmazhat.

String ::: ' vagy " karakterek közé írt tetszõleges szöveg. Hossza maximum 250 karakter. Ha ' jelek között újabb ' -ot akarunk megadni, akkor írjuk ki duplán. Például: 'DATUM:''89.11.12'.

Hexstring ::: Egy string, ami mögé "x" betût írunk. A string csak 0-9, illetve A-F karakrereket tartalmazhat. Pl: "F1F2F3"X A hexstring segítségével hexadecimálisan beírhatunk olyan adatokat is, melyeket egyébként nem tudnánk.

Szám ::: Csak számjegyeket vagy ".+-e" valamelyikét tartalmazó karaktersorozat, vagy string. Pl : 12.3 vagy -32e+3 vagy "+2".

Függvény ::: szimbólum(kifejezés) A "szimbólum" a függvény neve, a "kifejezés" pedig az átadott paraméterek.

String konkatenáció ::: A konkatenáció jele : !! (két függõleges vonal). Az interpreter azonban a konkatenációt minden határolójelnél elvégzi. Pl: V='alma' Z=V'fa' R=V 'a fa' alatt E=v!!'fa' Miután elvégezte a fenti mûveleteket, a változók értéke a következõ lesz : V : "alma". Z és E : "almafa". R : "alma a fa ALATT". R értéke azt is mutatja, hogy ha egy változó (itt: alatt) nem kap értéket, akkor az értéke a saját neve lesz, nagybetûsre alakítva.

Aritmetika ::: + :: összeadás; - :: kivonás; * :: szorzás; / :: osztás; ** :: hatványozás egész számmal; % :: osztás, az eredmény az egész érték lesz; // :: osztás, az eredmény a maradék lesz;

Összehasonlítás::: == :: teljesen egyforma, pl. két string; = :: egyenlõ, pl. két szám, vagy két string (a bevezetõ és záró szóközöket leszámítva); < :: kisebb; > :: nagyobb; <= :: kisebb vagy egyenlõ (^> : u.az) >= :: nagyobb vagy egyenlõ (^< : u. az) <> :: nem egyenlõ (^= és >< u. az) ^== :: nem azonos (nem egyforma)

Logikai mûveletek (Boolean) ::: Csak 0 és 1 logikai értékek között végez mûveleteket. & :: logikai és; ! :: logikai vagy (függõleges vonal); && :: logikai kizáró vagy; ^ :: negáció

Összetett szimbólumok ::: sz1.sz2.sz3 formájúak. Ilyen esetben a szimbólum értékét úgy kapjuk meg, hogy jobbról behelyettesítõdnek a változónevek, és minõsítik a tõlük balra lévõ nevet. Pl: b=2 c=3 a.b.c="palacsinta" mûveletek elvégzése után a "palacsinta" értéket az A.2.3 nevû változó kapja meg

Törzs változó::: szimbólum. A "." jelzi, hogy a szimbólum egy törzs változót jelez. Ilyen pl: A.; ALFA.; Példa a használatukra: ALFA.="zongora" A fenti utasítás az összes lehetséges "ALFA."-al kezdõdõ változónak a "zongora" értéket adja.

Címkék ::: szimbólum: A szimbólum után írt ":"-al jelezhetjük, hogy ez egy címke, amire pl. egy CALL utasítással adhatjuk át a vezérlést.

CMS vagy XEDIT parancs kiadása ::: A HOST rendszernek (azaz annak, amelyikbõl ezt a programot elindították) is kiadhatunk parancsokat. A parancsokat egyszerûen is kiadhatjuk, ha az nem REXX változónév (vagy parancs). Pl.: LISTFILE (D Ha azonban nem vagyunk biztosak abban, hogy a kívánt utasítás nem REXX változó vagy parancs, akkor a következõképpen adhatjuk ki : 'LISTFILE (D' A kiadott parancsot mindig az a rendszer hajtja végre, amelyik alatt a REXX program elindult. Ha ez nem felel meg az elvárásainknak, akkor a végrehajtó rendszert közvetlenül is kijelölhetjük az ADDRESS paranccsal (ld. késõbb).

Aritmetikai és logikai mûveletek esetén a REXX felismeri és kezeli az általános mûveleti hierarchiát.

A REXX-ben van néhány speciális változó, ezekhez fenntartott nevek vannak. Ez természetesen nem jelenti azt, hogy e változóknak nem adhatunk értéket! E változók az alábbiak :

RC - külsõ (CMS, CP stb...) parancsok végrehajtása után ebbe a változóba kerül bele a visszatérési kód.

SIGL - a SIGNAL utasítás használatakor ebbe kerül bele annak a programsornak a száma, ahonnan az ugrás történt.

RESULT - Ha egy eljárást a CALL utasítással hívunk, és az a RETURN-nál paramétereket ad vissza (pl. az összes függvény ilyen), akkor az eredményt a RESULT-ban kapjuk meg.

E leírásban a kulcsszavak nagybetûkkel szerepelnek. Ezeket mindig így, betû szerint kell leírni. A nem kötelezõ paramétereket [] jelek közé tettem. Az így jelölt paraméterek tehát elmaradhatnak. Ahol a leírásban több paraméter egymás alatt <> és ! jelek között áll, az azt jelenti, hogy a felsorolt paraméterek közül egyet meg kell adni, de több nem adható meg egyszerre.

A REXX parancsok ismertetése

    ADDRESS rendszer [parancs]

    ARG változó nevek

    CALL név [kif1[,kif2[,kif3...

- Ciklus vagy utasításcsoport szervezése :

    DO ismétlés feltétel;
      utasítás1;
      utasítás2;
      stb...
    END;
 
        "ismétlés":      név = kif1 [TO kif2] [BY kif3] [FOR kif4]
                         FOREVER
                         kif4
 
        "feltétel":      WHILE kif5
                         UNTIL kif6

"név" : a ciklusváltozó neve.

"kif1" : a ciklusváltozó kezdeti értéke.

"kif2" : a ciklusváltozó végértéke.

"kif3" : a ciklusváltozó értéke ennyivel változik az utasításcsoport végrehajtása után.

"kif4" : a ciklus (legfeljebb) ennyiszer hajtódik végre.

"kif5" : a ciklus végrehajtódik, ha ez a logikai érték igaz.

"kif6" : a ciklus végrahajtódik, ha ez a logikai érték hamis.

A ciklusváltozó és a WHILE feltétel értékét a ciklus elején, m&iac UNTIL feltétel értékét a ciklus végén vizsgálja az interpreter.

Példa :

             DO L=1 BY -2 FOR 3; SAY L ; END;
             a példa eredménye :
             1
             -1
             -3
 

    DROP név1 [név2...

    EXIT kif

- Feltételes vezérlés :

    IF feltétel THEN utasítás1;
                ELSE utasítás2;

- Kifejezéssel elõállított utasítások végrehajtása :

    INTERPRET kif

- DO ciklus hátralévõ részének átugrása :

    ITERATE [név]

- DO ciklus befejezése

    LEAVE [név]

- Üres utasítás

    NOP

- Aritmetikai mûveletek és változók pontosságának megadása :

    NUMERIC DIGITS kif1
 
    NUMERIC FORM SCIENTIFIC
                 ENGINEERING
 
    NUMERIC FUZZ kif2

- Változók feltöltése valamilyen inputból, azt szétszedve.

                  !ARG             !
                  !EXTERNAL        !
                  !NUMERIC         !
    PARSE [UPPER]  mindenféle
                  !SOURCE               !
                  !VALUE kif WITH !
                  !VAR név         !
                  !VERSION         !

ARG : az eljárásnak átadott argumentumot szedi szét.

EXTERNAL: a terminál input pufferbõl vett adatokkal dolgozik.

NUMERIC : az utolsó NUMERIC parancs paramétereit adja vissza.

PULL : a program stack következõ sorát emeli ki, és azzal dolgozik.

SOURCE : megadja, hogy milyen módon indítottuk el ezt a REXX programot. (Pl.: CMS COMMAND v. SUBROUTINE, az exec file neve, stb...)

VALUE : a megadott "kif" kifejezés kiértékelõdik és így vesz részt a további mûveletben.

VAR : a "név"-el megadott változó értéke vesz részt a mûveletben.

VERSION : megadja a REXX interpreter verzióját.

"mindenféle" - megadhatunk itt változóneveket, és határolókat. A parancs úgy mûködik, hogy a megadott határolóknál (vagy, ha nem adunk meg ilyet, akkor szóközöknél) szétbontja az input- ot, és a megadott változókba teszi. Ha a határoló string, akkor ott vágja szét az input-ot, ahol e string elõfordul. (Ha változó tartalmazza a határolót, akkor tegyük a változónevet zárójelbe.) Ha szám a határoló, akkor a számmal jelzett pozición, elõjeles szám esetén a jelenlegi pozicióhoz képest ennyivel eltolva vágja el. Pl.:

             PARSE VALUE TIME() WITH A ':' B ':' C;
             PARSE VALUE TIME() WITH x 4 y;
             SAY "A PONTOS IDO :" A "ORA ," B "PERC ," C "MASODPERC";
             SAY "X erteke="X "Y erteke="Y;
                a futás után pl. a következõ eredményt kapjuk :
             A PONTOS IDO : 17 ORA 12 PERC 23 MASODPERC
             X erteke=17: Y erteke=12:23

- A változók védelme belsõ szubrutinok hívása esetén :

    PROCEDURE [EXPOSE vált.nevek]

- Adatok kiemelése a program stack-bõl :

    PULL mindenféle

- Adatok besüllyesztése a program stack-be :

    PUSH kif

    QUEUE kif

- Visszatérés alprogramból :

    RETURN [kif]

- Szöveg kiiratása a terminálra :

    SAY kif

- Többféle alternatív utasítás feltételes végrehajtása :

    SELECT;
             WHEN kif1 THEN utas1
             WHEN kif2 THEN utas2
             WHEN kif3 THEN utas3
        ... stb ...
             OTHERWISE utasn
    END;

- Feltétel nélküli vezérlés :

    SIGNAL címke
    SIGNAL VALUE kifejezés

    SIGNAL ON ERROR
              HALT
              NOVALUE
              SYNTAX

ERROR - egy eljárás vagy HOST parancs befejezésekor nem 0 az RC ;

HALT - a terminálon kiadták a HI parancsot ;

NOVALUE - olyan változót használunk inputként (azaz pl. egy értékadás jobb oldalán), amely még nem kapott értéket ;

SYNTAX - szintaktikai hiba a REXX programban .

- Nyomkövetés :

    TRACE tparm

ALL minden utasítás kiíródik a terminálra, amelyet az interpreter végrehajt.

RESULTS az ALL hatásán kívül az utasítások eredményeit is kiírja.

OFF a nyomkövetés kikapcsolása.

Lehetõség van interaktív nyomkövetésre is. Pl: ha kiadjuk, hogy TRACE ?ALL ; akkor az interaktív nyomkövetést kapcsoltuk be. Interaktiv nyomkövetés közben két utasítás között a terminálró kiadhatunk bármilyen REXX, CMS, vagy CP parancsot. Ez a lehetõség nagymértékben megkönnyíti a REXX programok "belövését".

- Konvertálás nagybetûkre :

    UPPER változónevek

Beépített függvények

str1, str2,... string típusú paramétert jelöl;

ln hossz paraméter;

num szám típusú paramétert jelöl;

tölt kitöltõ karaktert jelöl, mellyel a mûvelet a végeredményt, vagy valamelyik paramétert a kívánt hosszúságra kiegészíti, feltölti (általában jobbról vagy balról).

n1, n2, ... sorszámot jelöl

    ABBREV(str1,str2[,ln])

    ABS(num)

    ADDRESS()

    ARG([n1[,opt]])

    BITAND(str1[,[str2][,tölt]])
    BITOR(str1[,[str2][,tölt]])
    BITXOR(str1[,[str2][,tölt]])

    CENTER(str1,ln[,tölt])
    CENTRE(str1,ln[,tölt])

    COMPARE(str1,str2[,tölt])

    COPIES(str1,n)

    C2D(str1[,n])

    C2X(str1)

    DATATYPE(str1[,típus])

• A - betûket vagy számjegyeket tartalmaz;
• B - csak 0 vagy 1 számjegyeket tartalmaz;
• L - csak kisbetûket tartalmaz;
• M - csak betûket tartalmaz;
• N - érvényes REXX szám-ot tartalmaz;
• S - érvényes REXX szimbólumot tartalmaz;
• U - csak nagybetûket tartalmaz;
• W - csak a NUMERIC DIGITS utasításnak megfelelõ számot tartalmaz;
• X - csak hexadecimális számjegyeket tartalmaz;

    DATE([opció])

• C - ebben a században eltelt napok számát;
• D - ebben az évben eltelt napok számát;
• E - dátumot, NN/HH/ÉÉ formában;
• J - dátumod, ÉÉDDD formában, ahogyan az OS (pl. MVS);
• M - a jelenlegi hónap nevét, pl.: November ;
• O - dátumot, ÉÉ/HH/NN formában;
• S - dátumot, ÉÉÉÉHHNN formában;
• U - dátumot, HH/NN/ÉÉ formában;
• W - a mai nap nevét, pl.: Wednesday;

    DELSTR(str1,n[,ln])

    DELWORD(str1,n[,ln])

    D2C(num[,ln])

    D2X(num[,ln])

    ERRORTEXT(n)

    EXTERNALS()

    FIND(str1,str2)

    FORMAT(num[,[n1][,n2]])

    INDEX(str1,str2[,n])

    INSERT(str1,str2[,[n][,[ln][,tölt]]])

    JUSTIFY(str1,ln[,tölt])

    LASTPOS(str1,str2[,n])

    LEFT(str1,ln[,tölt])

    LENGTH(str1)

    LINESIZE()

    MAX(n1[,n2]...)

    MIN(n1[,n2]...)

    OVERLAY(str1,str2[,[n][,[ln][,tölt]]])

    POS(str1,str2[,start])

    QUEUED()

    RANDOM([min][,[max][,indít])

    REVERSE(str1)

    RIGHT(str1,ln[,tölt])

    SIGN(num)

    SOURCELINE([n])

    SPACE(str1[,[n][,tölt]])

    STRIP(str1[,[opció][,chr]])

    SUBSTR(str1,n[,[ln][,tölt]])

    SUBWORD(str1,n[,ln])

    SYMBOL(str1)

    TIME([opció])

• E - Az eltelt idõt a START vagy RESET óta, MMMMMMMMM.UUUUUU (másodperc.mikromásodperc) formában.
• R - Az eltelt idõt adja vissza a START vagy RESET óta, az "E"-vel egyezõ formában, majd végrehajt egy RESET-et. "R" és "E" esetén az elsõ hívás felel meg a START-nak.
• H A napi idõ óra részét adja vissza, == formában.
• L A napi idõt adja vissza hosszú formában : ==.PP.MM.UUUUUU, ahol UUUUUU a mikromásodpercet jelenti.
• M Az éjfél óta eltelt perceket adja vissza PPPP formában.
• S Az éjfél óta eltelt másodperceket adja vissza MMMMM formában.

    TRACE([opció])

    TRANSLATE(str1[,[tabo][,[tabi][,tölt]]])

    TRUNC(num[,n])

    USERID()

    VALUE(név)

    VERIFY(str1,str2[,['M'][,n]])

    WORD(str1,n)

    WORDINDEX(str1,n)

    WORDLENGTH(str1,n)

    WORDS(str1)

    XRANGE([start][,end])

    X2C(str1)

    X2D(str1[,n])

Egyéb függvények

    CMSFLAG(flag)

    DIAG(n[,str1,str2...])
    DIAGRC(n[,str1,str2...])

    STORAGE()

    STORAGE(cím,hossz)

    STORAGE(cím,hossz,adat)

PÉLDÁK

 
 
        Az elsõ példa azt mutatja be, hogy hogyan készithetünk egy
  számológép eljárást REXX nyelven :
 
 
  /* Kalkulator */
 
  Arg x;            /* Az argumentum eloallitasa az X valtozoba */
  Interpret 'z=' x; /* A kivant muvelet vegrehajtasa */
  Say x'='z;        /* A vegeredmeny kiiratasa */
 
  Ha a fenti eljárást beirjuk a PP EXEC nevû file-ba, akkor a
  következõképpen használhatjuk :
 
  PP 5+4*3
              És az eredmény :
  5+4*3=17
 
 
  A fenti eljárást kiegészitve elérhetjük, hogy XEDIT-bõl kiadva ne törölje
  le a képernyõt :
 
  /* Kalkulator */
 
  Arg x;
  Interpret 'z=' x;
  Address 'XEDIT' 'MSG' x'='z; /* Kiiratas a XEDIT MSG parancsaval */
  If rc = -3 then Say x'='z;   /* Kiiratas, ha nincs XEDIT */
 
  A fenti eljárást bármely CMS felhasználó megtalálhatja a CALC EXEC S2 nevû
  file-ban.
 
  Az alábbi példa egy XEDIT makró. Ha pl. a PP XEDIT nevû file-ba tesszük,
  és a XEDIT parancs-sorban kiadjuk hogy PP, akkor az aktuális sor tartalmát
  a sor közepére helyezi, feltéve, hogy egy sor a képernyõn 72 karakteres
  (általában annyi) :
 
  /* Pelda */
 
  'EXTRACT /CURLINE /LINE /SIZE'; /* A jelzett XEDIT valtozok elohozasa */
 
  /* Ha az aktualis sor a "TOP OF FILE" vagy "END OF FILE", akkor kilep : */
 
  if line.1<1 ! line.1>size.1 then exit;
 
  /* Egyebkent elvegzi a kivant funkciot, es ezzel vege : */
 
  'REPLACE' centre(strip(curline.3),72);
 
 
        A következõ eljárással egy ideiglenes lemezt definiálhatunk, és
  formázhatunk meg egyszerre. Az eljárás neve a példában TDEF EXEC :
 
 
 
  /* Temporalis diszk definialo eljaras */;
 
    arg nnn ccc m tobbi; /* argumentum szetszedese parameterekre */
 
  if arg()=0 ! nnn="" ! ccc="" ! m="" then
    do;                                         /* Ha keves parametert */
     say 'Keves a parameter.     Hivasmod :';   /* adtunk meg, akkor   */
     say 'TDEF nnn ccc m';                      /* ezeket a sorokat    */
                                                /* irja ki             */
     say '("nnn" a virtualis cim,"ccc" a cilinderszam,"m" a cms diszk jele)'
     exit 4;
     end;
 
  'desbuf'; /* CMS program stack kitörlése */
 
  'query disk' m '(stack'; /* Megkérdezzük a CMS-t, hogy letezik-e ez a
                              diszk ? */
 
   rrc=queued(); /* eltaroljuk, hogy hány sor van a stack-ben */
 
   'desbuf'; /* újra töröljük a program stack-et */
 
  if rrc^=1 then do; /* Ha nem 1 sor volt a stack-ben, akkor a diszk
                        ACCESS-alva van, hibajelzest adunk : */
 
                  say 'A(z) 'm' jelu cms diszk mar letezik  ';
                  exit 8;
                  end;
 
  /* Ha nem volt ilyen cms diszk, akkor megprobaljuk definialni : */;
 
  'cp define t3350' nnn ccc;
 
  if rc^=0 then do; /* Ha RC erteke nem 0, akkor nem sikerult definialni */
                 say 'A(z)' nnn 'cimu egyseg nem definialhato  ';
                 exit 12;
                 end;
 
  'set cmstype ht'; /* A CMS kiirasokat letiltjuk */
 
  queue 'yes';    /* Betesszuk a program stack-be a FORMAT parancsnak  */
  queue 'tmp'nnn; /* adando valaszokat egymas utan, FIFO modszerrel    */
 
  'format' nnn m; rrc=rc; /* Kiadjuk a FORMAT parancsot a CMS-nek */
 
  'set cmstype rt'; /* A FORMAT lefutasa utan ujra engedelyezzuk a CMS
                       terminal output-ot */
 
  if rrc=0 then do; /* Ha a FORMAT sikeres volt : */
 
        'query disk' m '(stack';
        pull; /* fejlec eltavolitasa */
        pull a; a=word(a,words(a)); /* az utolso szo kiszedese */
 
        say 'A(z)' nnn'/'m 'diszk formazasa kesz. Merete :',
        ccc 'cilinder ('a 'Blokk).';
        exit;
        end;
 
           else do; /* Ha viszont nem sikerult : */
 
               say 'A(z)' nnn 'diszk formazasa nem sikerult  ';
               exit 16;
               end;
 
        Az alábbi példán azt szeretném bemutatni, hogy hogyan irhatunk olyan
  eljárást REXX nyelven, ami kiment egy CMS minidiszket szalagra. Az eljárás
  neve a példában : DMP EXEC .
 
 
 
  /* Szalagra menti a megadott lemezt */
 
  /* A kovetkezo utasitas szetszedi az argumentumot parameterekre,
     mikozben nagybetus formara konvertalja : */
 
  parse upper arg diszk szalag '(' miegymas
 
  /* Most megvizsgaljuk, hogy eleg parametert adtak-e meg ? */
 
  if diszk='' ! szalag='' then
 
      do ;    /* keves a parameter */
        say 'Tul keves parametert adtal'
        say 'Helyes hivasmod :'
        say 'DMP diszk szalag'
        say '("diszk","szalag" - a minidiszk es a szalag virtualis cimei)'
        exit 4;
        end;
 
  /* Most megvizsgaljuk szintaktikailag a parametereket */
 
  if datatype(diszk,x) then
             if datatype(szalag,x) then nop;
                                   else do;
                                   say 'Hibas a szalagcim  '
                                   exit 8;
                                   end;
 
                       else do;
                       say 'Hibas a lemezcim  '
                       exit 8;
                       end;
 
  /* Itt megkerdezzük a CP-t, hogy tud-e ilyen cimu virt. eszkozokrol ? */
 
  parse value diag(8,'Q V' szalag) with mindegy tobbi;
 
  if mindegy^='TAPE' then do;
        say 'A(z)' szalag 'cimu egyseg nem szalag (vagy nincs is ilyen)';
        exit 12;
        end;
 
  /* Ezután leolvassuk a szalag cimkejet, es megkerdezzuk
     a T. felhasznalot, hogy megfelelo szalag van-e fent ? */
 
  do until v='I' ! v='N'
 
  'tape dvol1 ('szalag; 'tape fsf ('szalag;
     say 'Jo a kiirt szalagcimke ? (I-igen, N-nem)';
     pull v
     end;
 
  if v='N' then do; Say 'Akkor nem bantom'; exit 16; end;
 
  */ Itt megkerjuk a CP-t, hogy arulja el a virtuális diszk meretet... */
 
  parse value diag(8,'Q V' diszk) with mindegy ' ' 26 cylno tobbi;
 
  if mindegy^='DASD' then do;
        Say 'A(z)' szalag 'cimu egyseg nem lemez (vagy nincs is ilyen)';
        exit 12;
        end;
 
  /* Betesszuk a DDR utility vezerlo parancsait a program stack-be */
 
  queue 'input' diszk '3350';
  queue 'output' szalag '3420 (compact leave';
  queue 'dump 0 'cylno-1 ; queue 'yes';
  queue ; queue ;
 
  /* Letiltjuk a terminal outputot, meghivjuk a DDR -t, majd
     ujra engedélyezzük a terminal outputot */
 
  'set cmstype ht';
  'ddr'; rrc=rc; desbuf;
  'set cmstype rt';
 
  /* Megvizsgaljuk, hogy sikerült-e a mentes ? */
 
  if rrc^=0 then do;
              say 'A mentes nem sikerult  '
  file: dmp      exec     a   vm/sp cms on 4361 at elte szk
                          page 00002
              exit rrc;
              end;
 
  /* Ha a mentes sikerult, ezt meguzenjuk a felhasznalonak,
     és irunk egy TAPE MARK-ot (szalagjelet) a szalagra,
     a mentes utan. */
 
  say 'A mentes sikerult'
 
  'tape wtm ('szalag;
 
  /* Megkerdezzük a felhasznalotol, hogy letekerhetjük-e a szalagot ? */
 
  do until valasz='I' ! valasz='N';
 
 
      Say 'Letekerjem a szalagot ? (I-igen, N-nem)';
 
      parse upper pull valasz;
 
      if valasz='I' then do;
                        'tape run ('szalag ;
                        say 'A szalagot letekertem...';
                        exit;
                        end;
      end;
 
  exit;