Rexx

A Rexx (Restructured Extended Executor) egy magas szintű programozási nyelv nyelv, amelyet az IBM-nél fejlesztett ki Mike Cowlishaw.^[1][2] Mind a szabadalmaztatott, mind a nyílt forráskódú Rexx interpreterek léteznek a számítástechnikai platformok széles skálájához, és léteznek fordítóprogramok az IBM nagyszámítógépekhez.^[3] A Rexx-et szkriptek, alkalmazás-makrók és alkalmazásfejlesztés céljára használják. Általános célú szkriptnyelvként a Rexx a Tcl(wd) és a Python előfutárának tekinthető.

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 számos környezetben támogatott. Ez az elsődleges szkriptnyelv néhány operációs rendszerben, mint az OS/2, az MVS(wd), a VM(wd), AmigaOS(wd), és egyes szoftverekben, például az SPF/PC-ben(wd), a KEDIT-ben, a THE-ben(wd) és a ZOC(wd) terminálemulátorban(wd) használják makrókhoz. Telepített motorral a Rexx használható parancsfájlokhoz és makrókhoz olyan programokban, amelyek Windows Scripting Host(wd) ActiveX szkriptmotort (például VBScript(wd) vagy JScript(wd)) használnak. A Rexx a VM/SP 3-as kiadással, a TSO/E 2-es verziójával, az OS/2-vel (1.3 és újabb, ahol hivatalosan Procedures Language/2 a neve), az AmigaOS 2-es verziójától felfelé, a PC DOS(wd) (7.0 vagy 2000), azArcaOS(wd)^[4] és a Windows NT 4.0 (Resource Kit: Regina) szoftverekbe került. 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 szkript a kontextustól függően különféle módokon van társítva egy Rexx értelmezőhöz futás közben. 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(wd) fájltípusra utalva. A szkript első sora a Rexx értelmező használatát írja elő a megjegyzésben úgy, hogy a kódot Rexx nyelvként azonosítja, vagy az EXTPROC-on keresztüli fájl útvonalon keresztül. MVS-en a Rexx szkriptek felismerhetők az "EXEC" alacsony szintű minősítővel,^[7] vagy ha a SYSPROC-ból lekért első sor egy megjegyzés, amely "REXX"-et tartalmaz, akkor a rendszer Rexx-ként kezeli (nem pedig CLIST-ként), és a SYSEXEC-ből lehívott szkriptnek Rexx-nek kell lennie. OS/2 rendszeren a Rexx szkriptek a „.cmd” fájlnévkiterjesztésen osztoznak más szkriptnyelvekkel, és a szkript első sora határozza meg a használandó értelmezőt. Linuxon a Rexx szkriptek általában shebang-gel kezdődnek. A Rexx-makrók a Rexx-tudatos alkalmazásokhoz az alkalmazás által meghatározott kiterjesztést használnak.

Elnevezés

Eredetileg a nyelvet REX-nek hívták, ami a Reformed Executor rövidítése, de egy extra „X”-et adtak hozzá, hogy elkerüljék a más termékekkel való összetéveszthetőséget. A név eredetileg csupa nagybetűs volt, mert akkoriban csak így lehetett megjeleníteni a mainframe kódban. Mike Cowlishaw a nyelvet leíró első könyvének mindkét kiadása csupa nagybetűt, a REXX-et használ, bár a borítógrafika vegyes kis- és nagybetűket használ. A NetRexx-ről szóló könyvében vegyes kis- és nagybetűket használ, de a borító grafikájában csupa nagybetű, nagy- és kisbetűkkel, Sablon:BigETSablon:BigEXX. A rendszertermékhez 1984-ben a REstructured eXtended eXecutor rövidítésnek megfelelő bővítést használtak.^[8] A Rexx (vegyes kis- és nagybetűs) nevet ebben a cikkben használjuk, és máshol is gyakran így használják.

Jellemzők

A Rexx objektív és szubjektív tulajdonságai a következők:

• Egyszerű szintaxis
• Képes parancsokat több környezetbe irányítani
• 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 gazdagép (host) veremmel, ha van ilyen.
• Kis utasításkészlet
• szabad(wd) formájú szintaxis; a behúzás nem kötelező, de segítheti az olvashatóságot
• Kis- és nagybetűket nem megkülönböztető tokenek, beleértve a változóneveket
• 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ég
• Tetszőleges pontosságú aritmetika(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
• Ütközésvédelem (Crash protection)
• Tartalomcímezhető adatszerkezetek
• Asszociatív tömb
• 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 lehetőségek
• Nem szokványos operátorok
• Csak részben támogatja a Unix stílusú parancssori paramétereket, kivéve bizonyos megvalósításokat.
• Nem biztosít alapvető terminálvezérlést a nyelv részeként, kivéve bizonyos megvalósításokat.
• Nem biztosít általános módot a külső könyvtárak függvényeinek és alprogramok bevonására, kivéve a konkrét megvalósításokat.

Egyesek azt állítják, hogy a Rexx egy viszonylag egyszerű nyelv. Mindössze 23 utasítással (például call, parse, és select) viszonylag kis utasításkészlettel rendelkezik. A Rexx korlátozott írásjelekkel és formázási követelményekkel rendelkezik. A Rexxnek csak egy adattípusa van, a karakterlánc; 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.

Egyesek szerint a Rexx kód hasonlít a PL/I kódhoz, de kevesebb jelölést tartalmaz. Kevesebb jelöléssel általában nehezebb értelmezni a fordítóval, de könnyebb megírni. A kódolás egyszerűsítése szándékos volt, amint azt a Rexx tervezési célja, a legkisebb meghökkentés elve is jelzi.^[8]

Története

1990 előtt

A Rexx-et először 1979. március 20. és 1982 közepe között Mike Cowlishaw, 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.^[1] Ú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 verziót Charles Daney írta PC DOS-ra 1984/5-ben[7], és a Mansfield Software Group (Kevin J. Kearney 1986-ban alapította) forgalmazta[6]. Az első Rexx fordító 1987-ben jelent meg, Lundin és Woodruff írta CMS-re.[14] Atari, AmigaOS, Unix (sok változat), Solaris, DEC, Windows, Windows CE, Pocket PC, DOS, Palm OS, QNX, OS/2, Linux, BeOS, EPOC32/Symbian, AtheOS, OpenVMS,[15],[15], Macintosh,16 és MacOS operációs rendszerekre is készültek további verziók.

Az első nem IBM-es változatot Charles Daney írta PC DOS-ra(wd) 1984/5-ben^[2] és a Mansfield Software Group (amelyet Kevin J. Kearney alapított 1986-ban) forgalmazta.^[1] 1987-ben jelent meg az első fordítóváltozat, amelyet Lundin és Woodruff írt CMS-re.^[10] 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,^[11] Apple Macintosh, és Mac OS X.^[12]

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-től napjainkig

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^[13] (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".^[14] 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)^[15] a 100 legjobb nyelv közé nem tartozó ötven nyelv között szerepelt.^[16]

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.^[17]

Változatok

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

Eszközkészletek

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ő.^{[25] [26][27]} 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ő.^[28]

Windowsra kifejlesztettek egy Rexx IDE-t, a RxxxEd-et.^[11] 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.

Szintaxis

Az utasítások típusai

Értékadó utasítás

Egy kifejezés kiértékelése és értékének hozzárendelése egy egyszerű vagy összetett változóhoz.

Kifejezés

Kiértékeli a kifejezést és az értéket parancsként kezeli az alapértelmezett környezetben.^[29]

address foo /* set default environment for bare expression */
bar /* equivalent to address foo bar */

Kulcsszó utasítás

Egy adott szóval kezdődik

DO blokkok

A nyelv két célból biztosít do blokkokat:

• Egy if vagy select utasításon belüli utasításcsoportok egységként való kezelése folyamatvezérlés céljából.
• A hurokvezérléshez(wd), hasonlóan sok más nyelvhez. Egyetlen do blokk opcionálisan tartalmazhat ismétlő kifejezéseket, feltételes kifejezéseket vagy mindkettőt, leállítással, ha bármelyik teljesül.

A do blokk a do szóval kezdődik és end-el végződik. Egyetlen blokk mindkét célt szolgálhatja. A kapcsolódó ooRexx-ben és NetRexx-ben egyaránt található egy do és egy loop kulcsszó, szinte azonos szemantikával; abban különböznek egymástól, hogy az egyszerű do egyenértékű a do 1-gyel, míg az egyszerű loop a loop forever-rel.

Az ALGOL 60(wd) és a PL/I begin utasításától eltérően a do blokknak nincs hatása a változók hatókörére.

Egy do blokk iterációja egy iterate utasítással, a teljes blokk pedig egy leave utasítással zárható le.

Egyszerű do

Bár bárhol érvényes, egy egyszerű művelet kifejezetten hasznos a feltételes utasításokban:

 if foo = bar
 then
   do
     i=1
     j=3
   end
 else
   do
     i=2
     j=4
   end

Ciklus

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

Feltételes ciklusok

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

Egyszerű ismétlődő ciklus

A nyelv lehetővé teszi a számlált ciklusokat, ahol egy kifejezést a ciklus elején számítanak ki, és a cikluson belüli utasításokat annyiszor hajtják végre:

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

Ellenőrzött ismétlődő ciklus

A ciklus növelheti az indexváltozó, és leállhat, ha elér egy határértéket:

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

A növekmény értéke 1, ha a by záradékot elhagyjuk. A ciklus örökké folytatódik, ha a to záradékra vonatkozó korlátot kihagyjuk, kivéve, ha korábban egy másik záradék vagy egy leave kulcsszó fejezi be.

Feltétel nélküli ciklus

A nyelv támogatja a feltétel nélküli hurkot a forever segítségével, amely a ciklus megszakításáig vagy a program befejezéséig folytatódik.

 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.

Kombinált ciklus

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

A nyelv biztosítja a feltételes végrehajtást az if, then és else segítségével egy do és end által határolt blokkhoz:

 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.

Több feltétel tesztelése

A nyelv több feltételes elágazást(wd) biztosít a select-en keresztül, amely a SELECT-ből származik; A PL/I SELECT utasítás formájának megfelelőjével.^[31] Más dinamikus nyelvek hasonló konstrukcióihoz hasonlóan a Rexx amikor záradékai teljes feltételeket adnak meg – nem az utasítás egyetlen értékű egyenlőségi tesztjeit, mint egyes nyelvek. Ebben inkább hasonlítanak a lépcsőzetes if-then-else kódhoz, mint a C vagy Java switch utasításhoz.

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 akkor szükséges, ha nincs művelet társítva a when feltételhez.

Az otherwise záradék nem kötelező. Ha elhagyja, és nem teljesülnek a when feltételek, akkor a szintaxis feltétele lép életbe.

Változók

Típizálási rendszer

A változók típus nélküliek, és kezdetben nagybetűs nevükként 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 */

Kiértékelés

Ha nincs beállítva novalue feltételkezelő, akkor egy definiálatlan változó a nevére értékelődik, nagybetűvel. A beépített SYMBOL függvény „VAR” értéket ad vissza egy definiált változóra, és nem vált ki novalue-t, még akkor sem, ha nem definiált. A VALUE függvény a változó értékét anélkül kapja meg, hogy novalue feltételt váltana ki, 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.

Összetett változó

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 (compound variable) biztosít.^[32] Egy összetett változó támogatja a mezők (úgynevezett farok, tail) hozzáadását egy változóhoz (amelyet ebben az összefüggésben törzsnek neveznek, stem), hogy támogassa az adatstruktúrákat, például listákat, tömböket, n-dimenziós tömböket, ritka vagy sűrű tömböket, kiegyensúlyozott vagy kiegyensúlyozatlan fákat és rekordokat. A . (pont) a törzs és a farok összekapcsolására szolgál.

A nyelv nem nyújt speciális támogatást a numerikus tömb indexeléséhez, mint sok más nyelv. Ehelyett egy numerikus végű összetett változó hasonló hatást vált ki.^[33]

A következő kód a stem.1 = 9, stem.2 = 8, stem.3 = 7 ... változókat határozza meg:

 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 tipikus tömböktől eltérően a farok (a törzsváltozók indexe) nem köteles egész értéket azonosítani (nevezni). Például a következő kód érvényes:

 i = 'Monday'
 stem.i = 2

Alapértelmezett érték rendelhető egy törzshöz a . (pont) segítségével, de nincs farka.

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

Ebben az esetben például a stem.3 kifejezést az alapértelmezett 'Unknown' értékre értékeli ki.

A teljes törzs (beleértve az alapértelmezett értéket is) a DROP utasítással törölhető.

 drop stem.

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

Egy törzsnek több farka is lehet. 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.

Az összetett változóhoz hasonló funkciók más nyelvekben is megtalálhatók, 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 dinamikus objektumokat a JavaScriptben. E nyelvek többsége biztosít egy mechanizmust az ilyen konstrukciók kulcsai (farok) feletti iterációjához, de ez hiányzik a klasszikus Rexx-ből. Ehelyett további információkat kell tárolni. Például a következő eljárás használható egy szó minden előfordulásának megszámlálására.

 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

Az újabb Rexx-változatok, beleértve az Object REXX-et és az ooRexx-et is, egy konstrukciót biztosítanak a törzs farkain való iterációhoz.

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

Parse

A PARSE utasítás szintaxison keresztül biztosítja a karakterlánc-kezelést:

parse [upper] origin [template]

Ha upper szerepel, akkor a bemenetet a rendszer nagybetűvé alakítja az elemzés előtt.

Az origin a bemenetet a következők egyikeként írja le:

• arg – argumentumok, a parancssor felső 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 expression with – a with kulcsszó a kifejezés végét jelzi
• var – változó
• version – verzió/kiadási szám

és template lehet változók, szó szerinti határolók és oszlopszámhatárolók kombinációja:

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

Példák

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

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

myVar = "[phone]"
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

Interpret

Az interpret utasítás az argumentumát Rexx utasításként kezeli, amely lehetővé teszi a futás közben formázott kód kiértékelését. A felhasználási területek közé tartozik egy függvény paraméterként való átadása, a tetszőleges precíziós aritmetika, a parse utasítás használata programozott sablonokkal, törzstömbök és ritka tömbök.^[34] A következő példa a 16-os értéket jeleníti meg és kilép.

X = 'square'
interpret 'say' X || '(4) ; exit'
SQUARE: return arg(1)**2

A Valour szoftvercsomag^[35] a Rexx értelmező képességére támaszkodott az OOP környezet megvalósítására. Egy másik felhasználási területet találtak a Time Machine nevű kiadatlan Westinghouse-termékben(wd), amely képes volt teljesen helyreállni egy egyébként végzetes hiba után.

Numeric

 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)*/

Calculate √2

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

sqrt 2 = 1.414213562373095048801688724209698078569671875377

Calculate e

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

e = 2.7182818284590452353602874713526624977572470936998

Hibakezelés és kivételek

Signal

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 signal utasítás úgy konfigurálja a futási környezetet, hogy egyéni kódot futtasson a rendszerállapot kezelésére, ha az aktiválásra kerül. A feltételek a következők:

• error – Pozitív visszatérési kód egy rendszerparancsból
• failure – Negatív visszatérési kód egy rendszerparancsból (pl. a parancs nem létezik)
• halt – Rendellenes befejezés
• novalue – Egy változó nevét használták, de a változó nincs definiálva
• 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 – A szignifikáns számjegyek eltűntek (ANSI Rexx, nem a TRL második kiadásában)

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 Rexx 4-es verziója óta egy kezelő nevezhető. A következő példában a ChangeCodePage.Trap kezelő syntax feltétel van beállítva.

ChangeCodePage: procedure
  signal on syntax name ChangeCodePage.Trap
return SysQueryProcessCodePage()

ChangeCodePage.Trap: return 1004

Amikor egy feltételt kezelnek (a signal on bekapcsolásával konfigurálva), az állapot elemezhető RC-n keresztül, amely jelzi az utolsó hibakódot, és SIGL-en keresztül, amely jelzi a feltételt kiváltó kód sorszámát.