Ugrás a tartalomhoz

Rexx

Ellenőrzött
A Wikipédiából, a szabad enciklopédiából
Rexx
Paradigmaprocedurális, strukturált
Jellemző kiterjesztés.cmd, .bat, .exec, .rexx, .rex, EXEC
Megjelent1979
TervezőMike Cowlishaw
Fejlesztő
Utolsó kiadásANSI X3.274 (stabil verzió, 1996)
Típusosságdinamikus
Hatással volt rá
Weboldal


A Rexx (Restructured Extended Executor) egy olyan programozási nyelv, amely értelmezhető vagy fordítható. Az IBM-nél fejlesztette ki Mike Cowlishaw. 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.

Jellemzők

[szerkesztés]
  • 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]

Története

[szerkesztés]

1990 előtt

[szerkesztés]

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

[szerkesztés]

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:

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]

Változatok

[szerkesztés]

Eszközök

[szerkesztés]

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.

Helyesírás és nagybetűs írásmód

[szerkesztés]

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]

Szintaxis

[szerkesztés]

Ciklus

[szerkesztés]

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

[szerkesztés]

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

Ismétlődő hurkok

[szerkesztés]

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.

Kombinált ciklusok

[szerkesztés]

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

[szerkesztés]

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.

Több feltétel tesztelése

[szerkesztés]

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.

Egyszerű változók

[szerkesztés]

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

Összetett változók

[szerkesztés]

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.

Kulcsszó utasítások

[szerkesztés]

PARSE

[szerkeszté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.

Példák
[szerkesztés]

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.

INTERPRET

[szerkesztés]

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.

NUMERIC

[szerkesztés]
 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)*/
  Calculates √2 Calculates e
code 
 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
output sqrt 2 = 1.414213562373095048801688724209698078569671875377 e = 2.7182818284590452353602874713526624977572470936998

SIGNAL

[szerkesztés]

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.

Hibakezelés és kivételek

[szerkesztés]

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.

Feltételek

[szerkesztés]
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 */

Jegyzetek

[szerkesztés]
  1. ↑ Catalog of All Documents (filter=rexx). IBM library server, 2005. [2013. február 15-i dátummal az eredetiből archiválva]. (Hozzáférés: 2014. február 10.)
  2. ↑ Does ArcaOS include REXX support?. (Hozzáférés: 2020. szeptember 3.)
  3. ↑ A TSO EXEC parancs minősítetlen adatkészletnévvel és sem a CLIST, sem az EXEC opcióval nem vizsgálja az alacsony szintű minősítőt vagy az EXEC-et.
  4. ↑ Ha a SYSPROC-ból lehívott szkript első sora egy REXX-et tartalmazó megjegyzés, akkor a rendszer REXX-ként kezeli, nem pedig CLIST-ként. A SYSEXEC-ből lehívott szkriptnek REXX-nek kell lennie.
  5. ↑ IBM Virtual Machine Facility /370: EXEC User's Guide, Second, International Business Machines Corporation. GC20-1812-1 (1975. április 1.) 
  6. ↑ EXEC 2 Reference, Second, International Business Machines Corporation, 92. o.. SC24-5219-1 (1982. április 1.) 
  7. ↑ a b M. F. Cowlishaw (1984). „The design of the REXX language”. IBM Systems Journal 23 (4), 333. o, Kiadó: IBM Research. DOI:10.1147/sj.234.0326. (Hozzáférés: 2014. január 23.) „Lehet, hogy az új funkcióhoz magas meghökkenési faktor társul? Ha egy funkciót a felhasználó véletlenül rosszul alkalmaz, és a felhasználó számára kiszámíthatatlannak tűnő eredményt okoz, akkor az adott funkciónak magas a meghökkenési faktor, és ezért nem kívánatos. Ha egy szükséges funkciónak magas a meghökkenési faktor, akkor szükség lehet a funkció újratervezésére.” 
  8. ↑ a b M. F. Cowlishaw: IBM REXX Brief History. IBM. (Hozzáférés: 2006. augusztus 15.)
  9. ↑ M. F. Cowlishaw: REX -- A Command Programming Language. SHARE, 1981. február 18. (Hozzáférés: 2006. augusztus 15.)
  10. ↑ Melinda Varian: REXX Symposium, May 1995
  11. ↑ Lundin, Leigh (1987. április 23.). „T/REXX, a REXX compiler for CMS”. U.S. Copyright Office, Washington, DC (TXu000295377), Kiadó: Independent Intelligence Incorporated. (Hozzáférés: 2010. február 20.) 
  12. ↑ a b Howard Fosdick. Rexx Programmer's Reference. Wiley Publishing, 390. o. (2005). ISBN 0-7645-7996-7 
  13. ↑ Rexx Implementations. RexxLA. [2006. szeptember 24-i dátummal az eredetiből archiválva]. (Hozzáférés: 2006. augusztus 15.)
  14. ↑ a b Mark Hessling: Regina Rexx Interpreter. SourceForge project regina-rexx, 2012. október 25. (Hozzáférés: 2014. február 10.)
  15. ↑ While ANSI INCITS 274-1996/AMD1-2000 (R2001) and ANSI INCITS 274-1996 (R2007) are chargeable, a free draft can be downloaded: American National Standard for Information Systems – Programming Language REXX
  16. ↑ A TIOBE programozói közösségi index a programozási nyelvek népszerűségének mérőszáma.
  17. ↑ The Next 50 Programming Languages. TIOBE index. tiobe.com, 2017. [2017. január 19-i dátummal az eredetiből archiválva]. (Hozzáférés: 2017. január 10.)
  18. ↑ RexxLA - Symposium Schedule
  19. ↑ IBM: REXX/VM Reference. MANMRK, 1999 (Hozzáférés: 2023. május 29.)
  20. ↑ TSO/E REXX Reference
  21. ↑ ARexx Programming
  22. ↑ REXX/imc reference
  23. ↑ NetRexx
  24. ↑ Open Object Rexx
  25. ↑ KEXX Summary
  26. ↑ Chapter 8. Rexx Utilities (RexxUtil). Open Object Rexx . (Hozzáférés: 2023. október 13.)
  27. ↑ REXX Tips & Tricks:REXXUTIL functions. EDM2: The Electronic Developer Magazine for OS/2 . (Hozzáférés: 2023. október 14.)
  28. ↑ Regina Rexx Interpreter. Sourceforge . (Hozzáférés: 2023. október 14.)
  29. ↑ Rexx/Tk
  30. ↑ M. F. Cowlishaw. The Rexx Language - A Practical Approach to Programming, 2nd, Prentice Hall (1990). ISBN 0-13-780651-5 
  31. ↑ A Rexx nem rendelkezik a SELECT (kifejezés); formájának megfelelőjével.
  32. ↑ How to Code Arrays and Other Data Structures In Rexx
  33. ↑ A Rexx a számokat szövegként tárolja, ezért a pontosság csak a string hosszától függ.

További információk

[szerkesztés]

Fordítás

[szerkesztés]
  • 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.
A lap eredeti címe: „https://hu.wikipedia.org/w/index.php?title=Rexx&oldid=27663048”