Rexx

Rexx
Paradigma	procedurális, strukturált
Jellemző kiterjesztés	.cmd, .bat, .exec, .rexx, .rex, EXEC
Megjelent	1979
Tervező	Mike Cowlishaw
Fejlesztő	IBM Mike Cowlishaw
Utolsó kiadás	ANSI X3.274 (stabil verzió, 1996)
Típusosság	dinamikus
Hatással volt rá	PL/I ALGOL CMS EXEC EXEC 2
Weboldal

A Rexx (Restructured Extended Executor) egy olyan programozási nyelv, amely értelmezhető vagy fordítható. Az IBM-nél fejlesztette ki Mike Cowlishaw(wd). Ez egy strukturált, magas szintű programozási nyelv, amelyet úgy terveztek, hogy könnyen tanulható és olvasható legyen. Saját és nyílt forráskódú Rexx-értelmezők léteznek a számítási platformok széles skálájához; az IBM mainframe számítógépeihez léteznek fordítóprogramok.^[1]

A Rexx egy teljes értékű nyelv, amely szkriptnyelvként, makrónyelvként és alkalmazásfejlesztési nyelvként is használható. Gyakran használják adatok és szövegek feldolgozására és jelentések készítésére; ez azt jelenti, hogy a Rexx jól működik a Common Gateway Interface (CGI) programozásban, és erre a célra használják, akárcsak a későbbi nyelveket, például a Perlt. A Rexx az elsődleges szkriptnyelv egyes operációs rendszerekben, pl. OS/2, MVS(wd), VM(wd), AmigaOS(wd), és belső makrónyelvként is használatos néhány más szoftverben, például az SPF/PC-ben(wd), a KEDIT-ben, a THE-ben(wd) és a ZOC(wd) terminálemulátorban(wd). Ezenkívül a Rexx nyelv használható szkriptek és makrók készítésére bármely olyan programban, amely a Windows Scripting Host(wd) ActiveX szkriptmotorok nyelveit használja (pl. VBScript(wd) és JScript(wd)), ha a Rexx motorok egyike telepítve van.

A Rexx a VM/SP Release 3-tól felfelé, a TSO/E 2. verziójától felfelé, az OS/2 (1.3 és újabb, ahol hivatalosan Procedures Language/2 a neve), az AmigaOS 2. verziójától felfelé, a PC DOS(wd) (7.0 vagy 2000), az ArcaOS(wd)^[2], és a Windows NT 4.0 (Resource Kit: Regina). A CMS-hez(wd) készült REXX szkriptek osztoznak az EXEC és EXEC2 fájltípuson, és a szkript első sora megadja a használandó értelmezőt. Az MVS-hez készült REXX szkriptek felismerhetők^[3] az EXEC alacsony szintű minősítő alapján, vagy felismerhetők^[4] a kontextus és az első sor alapján. Az OS/2-re készült REXX szkriptek a .cmd fájlnévkiterjesztést használják más szkriptnyelvekkel együtt, és a szkript első sora megadja a használandó értelmezőt. A REXX-tudatos alkalmazások REXX-makrói az alkalmazás által meghatározott kiterjesztéseket használják. Az 1980-as évek végén a Rexx az IBM Systems Application Architecture(wd) általános szkriptnyelvévé vált, ahol átkeresztelték „SAA Procedure Language REXX”-re.

A nagyszámítógépes programozásban a Rexx szkriptet vagy parancsot néha EXEC-nek nevezik, az EXEC(wd)^[5], EXEC 2(wd)^[6] és a CP/CMS(wd) és a VM/370-től(wd) a z/VM-ig(wd) használt CMS fájltípusra utalva.

• Egyszerű szintaxis
• A parancsok több környezetbe történő továbbításának lehetősége.
• Az a képesség, hogy egy adott hívó környezethez tartozó függvényeket, eljárásokat és parancsokat támogasson.
• Beépített verem, amely képes együttműködni a hoszt veremmel, ha van ilyen.
• Kis utasításkészlet, amely mindössze két tucat utasítást tartalmaz.
• szabad(wd) szintaxis
• Nagy- és kisbetűket nem érzékelő tokenek, beleértve a változók neveit is.
• Karakterlánc-alap
• Dinamikus adattípusozás(wd), deklarációk nélkül
• Nincsenek fenntartott kulcsszavak(wd), kivéve helyi kontextusban
• Nincsenek include fájl lehetőségek
• Tetszőleges numerikus pontosság(wd)
• Decimális aritmetika, lebegőpontos számítás
• Beépített függvények gazdag választéka, különösen a karakterlánc- és szövegfeldolgozásban.
• Automatikus tároláskezelés
• Crash-védelem
• Tartalomcímezhető adatszerkezetek
• Asszociatív tömbök
• Egyszerű hozzáférés a rendszerparancsokhoz és eszközökhöz
• Egyszerű hibakezelés, beépített nyomkövetés és hibakeresés
• Kevés mesterséges korlátozás
• Egyszerűsített I/O eszközök
• Nem szokványos operátorok
• Csak részben támogatja a Unix stílusú parancssori paramétereket, kivéve bizonyos implementációkat.
• Nem biztosít alapvető terminálvezérlést a nyelv részeként, kivéve bizonyos implementációkat.
• Nem biztosít általános módot a külső könyvtárakból származó függvények és alprogramok bevonására, kivéve a speciális megvalósításokat.

A Rexx mindössze huszonhárom, nagyrészt magától értetődő utasítással rendelkezik (például call, parse, és select) minimális írásjel- és formázási követelményekkel. Lényegében egy szinte szabad formájú nyelv(wd), egyetlen adattípussal, a karakterlánccal; ez a filozófia azt jelenti, hogy minden adat látható (szimbolikus), és a hibakeresés és a nyomon követés leegyszerűsödik.

A Rexx szintaxisa hasonló a PL/I-hez, de kevesebb jelöléssel rendelkezik; ez megnehezíti a (programonkénti) elemzést, de megkönnyíti a használatát, kivéve azokat az eseteket, ahol a PL/I szokásai meglepetésekhez vezethetnek. A REXX tervezési céljai között szerepelt a legkisebb meghökkentés elve.^[7]

A Rexx-et először 1979. március 20. és 1982 közepe között Mike Cowlishaw(wd), az IBM munkatársa tervezte és valósította meg assembly nyelven, mint „saját munkaidős” projektet, eredetileg egy szkriptprogramozási nyelvként, amely az EXEC és EXEC 2 nyelvek helyettesítésére készült.^[8] Úgy tervezték, hogy makró vagy szkriptnyelv legyen bármilyen rendszerhez. Mint ilyen, a Rexx a Tcl(wd) és a Python előfutárának tekinthető. A Rexx-et a PL/I programozási nyelv egyszerűsített és könnyebben megtanulható változatának szánta a készítője. A PL/I-től való néhány eltérés azonban az óvatlanok számára buktatót jelenthet.

Először 1981-ben, a texasi Houstonban megrendezett SHARE 56 konferencián mutatták be nyilvánosan^[9], ahol a Ted Johnston SLAC által támogatott vásárlói reakciók oda vezettek, hogy 1982-ben IBM termékként szállították.

Az évek során az IBM szinte minden operációs rendszerébe (VM/CMS(wd), MVS TSO/E(wd), IBM OS/400(wd), VSE/ESA(wd), AIX, PC DOS(wd), and OS/2), beépítette a Rexx-et, és elérhetővé tette a Novell NetWare, Windows, Java, és Linux számára is.

Az első nem IBM-es változatot Charles Daney írta PC DOS-ra(wd) 1984/5-ben^[10] és a Mansfield Software Group (amelyet Kevin J. Kearney alapított 1986-ban) forgalmazta.^[8] 1987-ben jelent meg az első fordítóváltozat, amelyet Lundin és Woodruff írt CMS-re.^[11] Más változatok is készültek Atari, AmigaOS(wd), Unix (számos változat), Solaris, DEC, Microsoft Windows, Windows CE, Pocket PC, DOS, Palm OS(wd), QNX, OS/2, Linux, BeOS, EPOC32(wd)/Symbian, AtheOS, OpenVMS,^[12] Apple Macintosh, és Mac OS X.^[13]

A Rexx Amiga változatát, az ARexx-et(wd) az AmigaOS 2-től kezdve tartalmazta AmigaOS(wd), és népszerű volt a szkriptek írására, valamint az alkalmazások vezérlésére. Sok Amiga alkalmazásba beépítettek egy „ARexx portot”, amely lehetővé teszi az alkalmazás vezérlését a Rexx-ből. Egyetlen Rexx szkript akár különböző Rexx portok között is válthatott, hogy több futó alkalmazást is vezérelhessen.

1990-ben Cathie Dager, az SLAC munkatársa megszervezte az első független Rexx-szimpóziumot, amely a REXX Language Association megalakulásához vezetett. A szimpóziumokat évente tartják.

A Rexx több ingyenes verziója is elérhető. 1992-ben jelent meg a két legszélesebb körben használt nyílt forráskódú port: Ian Collier REXX/imc-je Unixra és Anders Christensen Regina^[14] (később Mark Hessling által átvett) Windowsra és Unixra. A BREXX jól ismert a WinCE és a Pocket PC platformokon, és „visszaportálták” VM/370-re és MVS-re(wd).

Az OS/2-nek van egy vizuális fejlesztőrendszere a Watcom(wd) VX-REXX(wd). Egy másik dialektus a VisPro REXX volt a Hockware-től.

A Portable Rexx by Kilowatt és a Personal Rexx by Quercus két DOS-ra tervezett Rexx-értelmező, amelyek Windows alatt is futtathatók parancssor segítségével. Az 1990-es évek közepe óta a Rexx két újabb változata jelent meg:

• NetRexx(wd): Java forráskódon keresztül Java bájtkódra(wd) fordítja; egyáltalán nem rendelkezik fenntartott kulcsszavakkal, és a Java objektum modellt használja, ezért általában nem felfelé kompatibilis a „klasszikus” Rexx-szel.
• Object REXX(wd): a Rexx objektumorientált, általában felfelé kompatibilis változata.

1996-ban az American National Standards Institute (ANSI) szabványt adott ki a Rexx-re: ANSI X3.274–1996 "Information Technology – Programming Language REXX".^[15] Több mint két tucat Rexx-ről szóló könyv jelent 1985 óta.

A Rexx 2004. március 20-án ünnepelte 25. évfordulóját, amelyet a REXX Language Association 15. Nemzetközi REXX Szimpóziumán ünnepeltek Böblingenben, Németországban, 2004 májusában.

2004. október 12-én az IBM bejelentette, hogy tervezi az Object REXX(wd) implementációjának forrásait a Common Public License(wd) alatt kiadni. Az Object REXX legújabb kiadásai tartalmaznak egy ActiveX(wd) Windows Scripting Host(wd) (WSH) szkriptelőmotort, amely a Rexx nyelv ezen változatát valósítja meg.

2005. február 22-én jelentették be az Open Object Rexx (ooRexx) első nyilvános kiadását. Ez a termék egy WSH scripting motort tartalmaz, amely lehetővé teszi a Windows operációs rendszer és az alkalmazások Rexx-szel történő programozását ugyanolyan módon, mint ahogyan a Visual Basic és a JScript(wd) az alapértelmezett WSH telepítés és a Perl, Tcl(wd), Python harmadik féltől származó scripting motorok által megvalósított.

2017 januárjától a REXX a TIOBE-indexben(wd)^[16] a 100 legjobb nyelv közé nem tartozó ötven nyelv között szerepelt.^[17]

2019-ben a 30. Rexx Language Association Symposium a Rexx 40. évfordulóját ünnepelte. A szimpóziumot az angliai Hursleyben tartották, ahol a Rexx-et először tervezték és megvalósították.^[18]

• VM/SP R3,^[19]
• TSO/E V2^[20]
• SAAREXX
• ARexx(wd)^[21]
• BREXX
• Regina^[14]
• Personal REXX
• REXX/imc^[22]
• Reginald
• roo!
• r4
• Rexx for Palm OS
• S/REXX
• uni-REXX
• NetRexx(wd)^[23]
• ooREXX(wd)^[24]
• KEXX(wd)^[25]

A RexxUtil eszközkészlet egy olyan függvénycsomag, amely a legtöbb Rexx implementációhoz és a legtöbb host operációs rendszerhez elérhető.^{[26] [27][28]} A RexxUtil egy fájl- és könyvtárfüggvényeket, ablakos I/O-t, valamint a rendszerszolgáltatások, például a WAIT és a POST elérésére szolgáló függvényeket tartalmazó csomag.

A Rexx/Tk, a Tcl/Tk-hoz(wd) hasonlóan a Rexx programokban használható grafikai eszközkészlet széles körben elérhető.^[29]

Windowsra kifejlesztettek egy Rexx IDE-t, a RxxxEd-et.^[12] A hálózati kommunikációra szolgáló RxSock-ot, valamint a Regina Rexx egyéb kiegészítőit és implementációit is kifejlesztették, és a Windows parancssorához egy Rexx-értelmezőt is mellékelnek a legtöbb Resource Kitben a Windows különböző verzióihoz, amely a DOS mellett mindegyik alatt működik.

Eredetileg a nyelv neve Rex (Reformed Executor) volt; az extra „X”-et azért tették hozzá, hogy elkerüljék az ütközést más termékek nevével. A REX eredetileg csupa nagybetű volt, mivel a nagyszámítógépes kód nagybetű-orientált volt. Az akkori stílus a csupa nagybetűs nevek voltak, részben azért, mert akkoriban még szinte minden kód csupa nagybetűs volt. A termék esetében REXX lett belőle, és Mike Cowlishaw könyvének mindkét kiadása csupa nagybetűs nevet használ. A REstructured eXtended eXecutor-ra való bővítést 1984-ben használták a rendszertermékhez.^[7]

A ciklusvezérlési struktúra a Rexx-ben egy DO-val kezdődik és egy END-del végződik, de többféle változata létezik. A NetRexx a DO helyett a LOOP kulcsszót használja a ciklusoknál, míg az ooRexx a LOOP-ot és a DO-t egyenértékűnek tekinti

A Rexx támogatja a hagyományos strukturált programozási ciklusok sokaságát, miközben egy feltételt tesztel az utasítások listájának végrehajtása előtt (do while) vagy után (do until):

 do while [feltétel]
 [utasítások]
 end

 do until [feltétel]
 [utasítások]
 end

A legtöbb nyelvhez hasonlóan a Rexx is képes ciklusokat létrehozni egy indexváltozó inkrementálása közben, és egy határérték elérésekor megállni:

 do index = start [to limit] [by increment] [for count]
 [instructions]
 end

A növekmény elhagyható, és alapértelmezett értéke 1. A határérték is elhagyható, ami a ciklus örökké tartó folytatását eredményezi.

A Rexx engedélyezi a megszámlált ciklusokat, ahol a ciklus elején kiszámít egy kifejezést, és a cikluson belüli utasításokat ennyiszer hajtja végre:

 do kifejezés
 [utasítások]
 end

A Rexx akár a program befejezéséig is képes ismételni:

 do forever
 [utasítások]
 end

A program a leave utasítással kiléphet az aktuális ciklusból, ami a do forever ciklusból való kilépés szokásos módja, vagy az iterate utasítással rövidre zárhatja azt.

A PL/I-hez hasonlóan a Rexx is lehetővé teszi a feltételes és ismétlődő elemek kombinálását ugyanabban a ciklusban:^[30]

 do index = start [to limit] [by increment] [for count] [while condition]
 [instructions]
 end

 do expression [until condition]
 [instructions]
 end

Feltételek tesztelése IF használatával:

 if [condition] then
 do
 [instructions]
 end
 else
 do
 [instructions]
 end

Az ELSE záradék opcionális.

Egyetlen utasítás esetén a DO és az END is elhagyható:

 if [condition] then
 [instruction]
 else
 [instruction]

A behúzás nem kötelező, de segít az olvashatóság javításában.

A SELECT a Rexx CASE struktúrája(wd), amely a PL/I SELECT utasítás SELECT; form{{efn|Rexx has no equivalent to the SELECT (expression); formájából^[31] származik. Más dinamikus nyelvek CASE-konstrukcióinak egyes implementációihoz hasonlóan a Rexx WHEN záradékai teljes feltételeket határoznak meg, amelyeknek nem kell egymással kapcsolatban állniuk. Ebben a tekintetben inkább hasonlítanak az IF-THEN-ELSEIF-THEN-...-ELSE kódok kaszkádolt halmazaira, mint a C vagy Java switch utasításokra.

 select
 when [condition] then
 [instruction] or NOP
 when [condition] then
 do
 [instructions] or NOP
 end
 otherwise
 [instructions] or NOP
 end

A NOP utasítás „nincs művelet”, és akkor használatos, ha a programozó nem kíván semmit sem csinálni egy olyan helyen, ahol egy vagy több utasításra lenne szükség.

Az OTHERWISE záradék opcionális. Ha elhagyjuk, és nem teljesül a WHEN feltétel, akkor a SYNTAX feltétel lép életbe.

A változók a Rexx-ben típus nélküliek, és kezdetben a nevükként, nagybetűvel kerülnek kiértékelésre. Így egy változó típusa változhat a programban való használatától függően:

 say hello /* => HELLO */
 hello = 25
 say hello /* => 25 */
 hello = "say 5 + 3"
 say hello /* => say 5 + 3 */
 interpret hello /* => 8 */
 drop hello
 say hello /* => HELLO */

Sok más programozási nyelvtől eltérően a klasszikus Rexx nem támogatja közvetlenül a numerikus indexszel címzett változók tömbjeit. Ehelyett összetett változókat biztosít.^[32] Egy összetett változó egy törzsből (stem) és egy farokból (tail) áll. A . (pont) a törzs és a farok összekapcsolására szolgál. Ha a használt farkak numerikusak, könnyen előállítható ugyanaz a hatás, mint egy tömb esetében.

 do i = 1 to 10
 stem.i = 10 - i
 end

Ezután a következő változók léteznek a következő értékekkel: stem.1 = 9, stem.2 = 8, stem.3 = 7...

A tömbökkel ellentétben a törzsváltozók indexének nem kell egész számmal rendelkeznie. Például a következő kód érvényes:

 i = 'Monday'
 stem.i = 2

A Rexx-ben lehetőség van egy törzs alapértelmezett értékének beállítására is.

 stem. = 'Unknown'
 stem.1 = 'USA'
 stem.44 = 'UK'
 stem.33 = 'France'

E hozzárendelések után a stem.3 kifejezés 'Unknown' eredményt adna.

A teljes törzs a DROP utasítással is törölhető.

 drop stem.

Ennek hatására a korábban beállított alapértelmezett értékek is törlődnek.

Megállapodás szerint (és nem a nyelv részeként) az összetett stem.0-t gyakran arra használják, hogy nyomon kövessék, hány elem van egy törzsben, például egy eljárás, amely egy szót ad hozzá egy listához, így kódolható:

 add_word: procedure expose dictionary.
 parse arg w
 n = dictionary.0 + 1
 dictionary.n = w
 dictionary.0 = n
 return

Lehetséges az is, hogy egy összetett változónak több eleme is legyen. Például:

 m = 'July'
 d = 15
 y = 2005
 day.y.m.d = 'Friday'

Több numerikus farokelemet lehet használni, hogy egy többdimenziós tömb hatását keltse.

A Rexx összetett változókhoz hasonló funkciók számos más nyelvben is megtalálhatóak (beleértve az asszociatív tömböket az AWK-ban, a hash-eket a Perl-ben és a Hashtables-t a Java-ban). A legtöbb ilyen nyelv rendelkezik olyan utasítással, amellyel egy ilyen konstrukció összes kulcsán (vagy a Rexx kifejezéssel élve: farkain) végig lehet iterálni, de ez hiányzik a klasszikus Rexx-ből. Ehelyett szükség van a tail (farok) értékek segédlistáinak vezetésére. Például egy szavak számlálására szolgáló programban a következő eljárást használhatjuk egy szó minden egyes előfordulásának rögzítésére.

 add_word: procedure expose count. word_list
 parse arg w .
 count.w = count.w + 1 /* feltételezzük, hogy a count. 0-ra van állítva */
 if count.w = 1 then word_list = word_list w
 return

majd később:

 do i = 1 to words(word_list)
 w = word(word_list,i)
 say w count.w
 end

Némi áttekinthetőség árán lehetséges ezeket a technikákat egyetlen törzsben kombinálni:

 add_word: procedure expose dictionary.
 parse arg w .
 dictionary.w = dictionary.w + 1
 if dictionary.w = 1 /* feltételezzük, hogy a dictionary. = 0 */
 then do
 n = dictionary.0+1
 dictionary.n = w
 dictionary.0 = n
 end
 return

és később:

 do i = 1 to dictionary.0
 w = dictionary.i
 say i w dictionary.w
 end

A Rexx itt nem nyújt biztonsági hálót, így ha az egyik szó véletlenül egy egész szám, amely kisebb, mint a dictionary.0, akkor ez a technika rejtélyes módon kudarcot vall.

A Rexx legújabb implementációi, beleértve az IBM Object REXX-et és a nyílt forráskódú implementációkat, mint az ooRexx, tartalmaznak egy új nyelvi konstrukciót(wd), amely egyszerűsíti az iterációt egy törzs értéke felett, vagy egy másik gyűjtő objektum, például egy tömb, táblázat vagy lista felett.

 do i over stem.
 say i '-->' stem.i
 end

Összefoglalva, az összetett változók szinte bármilyen adatszerkezet létrehozására alkalmas mechanizmust biztosítanak a Rexx-ben. Ezek közé tartoznak a listák vagy egyszerű tömbök, n-dimenziós tömbök, ritka vagy sűrű tömbök, kiegyensúlyozott vagy kiegyensúlyozatlan fák, rekordok és még sok más.

A PARSE utasítás különösen erős; egyesít néhány hasznos karakterlánc-kezelő funkciót. Szintaxisa a következő:

parse [upper] origin [template]

ahol az origin a forrást adja meg:

• arg (argumentumok, a parancssor legfelső szintjén, a sor végén)
• linein (szabványos bemenet, pl. billentyűzet)
• pull (Rexx-adatsor vagy szabványos bemenet)
• source (információ a program végrehajtásának módjáról)
• value (egy kifejezés) with: a with kulcsszó szükséges a kifejezés végének megjelölésére.
• var (változó)
• version (verziószám/kiadási szám)

és template lehet:

• változók listája
• oszlopszám-határolók
• literális elválasztójelek

upper opcionális; ha megadjuk, az adatokat nagybetűvé konvertáljuk az elemzés előtt.

Változólista használata sablonként

myVar = "John Smith"
parse var myVar firstName lastName
say "First name is:" firstName
say "Last name is:" lastName

a következőket jeleníti meg:

First name is: John
Last name is: Smith

Határoló használata sablonként:

myVar = "Smith, John"
parse var myVar LastName "," FirstName
say "First name is:" firstName
say "Last name is:" lastName

a következőket is megjeleníti:

First name is: John
Last name is: Smith

Oszlopszám-határolók használata:

myVar = "(202) 123-1234"
parse var MyVar 2 AreaCode 5 7 SubNumber
say "Area code is:" AreaCode
say "Subscriber number is:" SubNumber

a következőket jeleníti meg:

Area code is: 202
Subscriber number is: 123-1234

Egy sablon (template) változók, szó szerinti határolók és oszlopszámhatárolók kombinációját használhatja.

Az INTERPRET utasítás kiértékeli az argumentumát, és annak értékét Rexx utasításként kezeli. Néha az INTERPRET a legegyértelműbb módja egy feladat elvégzésének, de gyakran akkor használják, amikor egyértelműbb kódot lehet használni, például a value() használatával.

Az INTERPRET további felhasználási területei a Rexx (decimális) tetszőleges pontosságú^[33] aritmetikája (beleértve a fuzzy összehasonlításokat), a PARSE utasítás használata programozási sablonokkal, törzstömbökkel és ritka tömbökkel.

 /* demonstrate INTERPRET with square(4) => 16 */
 X = 'square'
 interpret 'say' X || '(4) ; exit'
 SQUARE: return arg(1)**2

Ez a 16-os értéket jeleníti meg, és kilép. Mivel a Rexx-ben a változók tartalma karakterláncok, beleértve a racionális számokat exponensekkel és akár teljes programokat is, a Rexx felajánlja a karakterláncok kiértékelt kifejezésekként való értelmezését.

Ez a funkció használható függvények átadására függvényparaméterként, például SIN vagy COS átadása egy eljárásnak integrálok kiszámítására.

A Rexx csak olyan alapvető matematikai funkciókat kínál, mint az ABS, DIGITS, MAX, MIN, SIGN, RANDOM, valamint a hexa és bináris konverziók teljes készletét bitműveletekkel. Az olyan összetettebb függvényeket, mint a SIN, a semmiből implementálták, vagy harmadik féltől származó külső könyvtárakból szerezték be. Néhány külső könyvtár, jellemzően a hagyományos nyelveken megvalósítottak, nem támogatták a kiterjesztett pontosságot.

A későbbi (nem klasszikus) verziók támogatják a CALL variable konstrukciókat. A beépített VALUE függvénnyel együtt a CALL számos esetben használható az INTERPRET helyett. Ez egy klasszikus program:

 /* terminated by input "exit" or similar */
 do forever ; interpret linein() ; end

Egy kissé kifinomultabb „Rexx kalkulátor”:

 X = 'input BYE to quit'
 do until X = 'BYE' ; interpret 'say' X ; pull X ; end

A PULL a parse upper pull rövidítése. Hasonlóképpen, az ARG a parse upper arg rövidítése.

Az INTERPRET utasítás erejét másképp is lehetett használni. A Valour szoftvercsomag(wd) a Rexx értelmező képességére támaszkodott egy OOP-környezet megvalósításában. Egy másik felhasználási módot a Westinghouse(wd) Time Machine nevű, még ki nem adott termékében találtak, amely képes volt egy végzetes hibát követően teljes mértékben helyreállni.

 say digits() fuzz() form() /* => 9 0 SCIENTIFIC */
 say 999999999+1 /* => 1.000000000E+9 */
 numeric digits 10 /* csak a rendelkezésre álló memória korlátozza */
 say 999999999+1 /* => 1000000000 */

 say 0.9999999999=1 /* => 0 (false) */
 numeric fuzz 3
 say 0.99999999=1 /* => 1 (true) */
 say 0.99999999==1 /* => 0 (false) */

 say 100*123456789 /* => 1.23456789E+10 */
 numeric form engineering
 say 100*123456789 /* => 12.34567890E+9 */

 say 53 // 7   /* => 4   (rest of division)*/

 numeric digits 50
 n=2
 r=1
 do forever /* Newton-módszer */
 rr=(n/r+r)/2
 if r=rr then leave
 r=rr
 end
 say "sqrt" n ' = ' r

 numeric digits 50
 e=2.5
 f=0.5
 do n=3
 f=f/n
 ee=e+f
 if e=ee then leave
 e=ee
 end
 say "e =" e

A SIGNAL utasítás a vezérlés áramlásában bekövetkező rendellenes változásokra szolgál (lásd a következő szakaszt). Azonban vissza lehet élni vele, és úgy lehet kezelni, mint a más nyelvekben található GOTO utasítást (bár ez nem teljesen egyenértékű vele, mert a ciklusokat és más konstrukciókat is megszakítja). Ez nehezen olvasható kódot eredményezhet.

A Rexx-ben a SIGNAL utasítás segítségével lehetőség van hibák és egyéb kivételek elfogására és kezelésére. Hét rendszerállapot létezik: ERROR, FAILURE, HALT, NOVALUE, NOTREADY, LOSTDIGITS és SYNTAX. Mindegyik kezelése tetszés szerint ki- és bekapcsolható a forráskódban.

A következő program addig fut, amíg a felhasználó meg nem szakítja:

 signal on halt;
 do a = 1
     say a
     do 100000 /* késleltetés */
     end
 end
 halt:
 say "The program was stopped by the user"
 exit

A signal on novalue utasításra adott jel megállítja a nem definiált változók használatát, amelyek egyébként a saját (nagybetűs) nevüket kapnák értékként. A NOVALUE feltétel állapotától függetlenül egy változó állapota mindig ellenőrizhető a beépített SYMBOL függvénnyel, amely a VAR-t adja vissza a definiált változók esetében.

A VALUE függvény használható a változók értékének lekérdezésére NOVALUE feltétel kiváltása nélkül, de fő célja a környezeti változók olvasása és beállítása, hasonlóan a POSIX getenv és putenv függvényekhez.

ERROR

Pozitív RC egy rendszerparancsból

FAILURE

Negatív RC egy rendszerparancshoz (pl. a parancs nem létezik)

HALT

Rendellenes befejezés

NOVALUE

Egy nem beállított változóra hivatkozott

NOTREADY

Bemeneti vagy kimeneti hiba (pl. olvasási kísérlet a fájl végén túl)

SYNTAX

Érvénytelen programszintaxis vagy más hibaállapot

LOSTDIGITS

Elvesznek a szignifikáns számjegyek (ANSI Rexx, a TRL második kiadásában nem szerepel).

Amikor egy állapotot a SIGNAL ON kezel, a SIGL és RC rendszerváltozók elemezhetők a helyzet megértéséhez. Az RC tartalmazza a Rexx hibakódot, a SIGL pedig a hiba keletkezésének sorszámát.

A Rexx 4-es verziójától kezdve a feltételek neveket is kaphatnak, és van egy CALL ON konstrukció is. Ez praktikus, ha külső függvények nem feltétlenül léteznek:

 ChangeCodePage: procedure /* a SIGNAL beállítások védelme */
 signal on syntax name ChangeCodePage.Trap
 return SysQueryProcessCodePage()
 ChangeCodePage.Trap: return 1004 /* windows-1252 on OS/2 */

• Mike Cowlishaw's home page
• REXX language page at IBM
• REXX Language Association
• Mi a REXX?

• Ez a szócikk részben vagy egészben a Rexx című angol Wikipédia-szócikk fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét és a szerzői jogokat jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.