II. További segédfüggvények

Meghajtók, könyvtárak és fájlok kezelése

REXX tudásunk fejlôdésével párhuzamosan fog kialakulni az az igény, hogy képesek legyünk a meghajtók, a könyvtárak illetve a fájlok hatékony kezelésére. A REXXUtil függvények között jó néhányat találunk, amelyek ebben sokat segítenek.

Egy telepítôprogramnak például ellenôriznie kell az A: meghajtóban lévô hajlékonylemez címkéjét, hogy meggyôzôdjünk arról, hogy a megfelelô lemezt tették be. Egy biztonságimásolat-készítô programnak ellenôriznie kell, hogy elég hely van-e azon a meghajtón, ahová a másolatot akarják készíteni. Két REXXUtil függvénnyel megszerezhetjük mindkét információt. A SysDriveMap függvény visszatérési értéke a rendszeren található meghajtók listája:

lista = SysDriveMap([meghajtó] [, opció])

A lista változóban szóközkarakterekkel elválasztja találjuk a meghajtók felsorolását. Ha például három meghajtónk (C:, D: és E:) van, akkor a lista a következôképpen néz ki:

C: D: E:

A meghajtó paraméterrel lehet szabályozni, hogy a lista melyik meghajtótól kezdôdjön. Az opció paraméterrel lehet behatárolni, hogy mely meghajtók tûnjenek fel a listában:

Opció:	Meghajtó-lista:
DETACHED	A kapcsolt hálózati meghajtók
FREE	Az éppen nem használt meghajtók
LOCAL	A lokális meghajtók
REMOTE	A távoli meghajtók
USED	Az összes elérhetô meghajtó (default)

Ha tehát az összes elérhetô meghajtó listáját akarjuk lekérdezni, akkor a függvényt paraméter nélkül is elég meghívni:

lista = SysDriveMap()

Ha már megvan a lista, akkor azt feldolgozhatjuk a PARSE VAR vagy a WORD függvények valamelyikével. Amikor már tudjuk, hogy milyen meghajtók vannak a vizsgált rendszeren, akkor az egyes meghajtókról további információt kaphatunk a SysDriveInfo függvénnyel:

info = SysDriveInfo(meghajtó)

Ez a függvény is egy listát ad vissza, amelyben megtaláljuk a vizsgált meghajtó betûjelét, a szabad és a teljes helyet bájtokban megadva és a címkét:

C:    63456    104841216     OS2

Az info kiértékelésénél vigyázzunk arra, hogy a címke szóközöket is tartalmazhat. Mivel a szabad hely és a címke között egynél több szóköz van, a PARSE-sal történô feldolgozás után szóközök maradnak a címke elôtt. Vigyázzunk ezekre a dolgokra! A következô programrészlet kiértékeli a visszaadott listát és ügyel az extra szóközök helyes kezelésére is:

PARSE VALUE SysDriveInfo('C:') WITH drive free used label
label = STRIP(label, 'B')

Most pedig lássunk egy példát a fenti függvények használatára. A bemutatott példaprogram megjeleníti a rendszeren található lokális meghajtók szabad és teljes kapacitását.

/* információ a meghajtókról */

CALL RxFuncADD 'SysLoadFuncs', 'RexxUtil', 'SysLoadFuncs'
CALL SysLoadFuncs

meghajtok = SysDriveMap( , 'Local')

DO WHILE meghajtok <> ''
	PARSE VAR meghajtok meghajto meghajtok
	info = SysDriveInfo(meghajto)
	IF info <> '' THEN
		DO
			PARSE VAR info drive free total label
			label = STRIP(label, 'B')
			free = free % 1024
			total = total % 1024
			SAY
			SAY 'A(z) 'drive' meghajtó címkéje:' label
			SAY 'Szabad hely: 'free'Kb, Teljes kapacitás: 'total'Kb'
		END
END

EXIT

Egy másik, sokszor elôforduló feladat a könyvtárak létrehozása és törlése. Erre a célra elvileg megfelelnek a operációs rendszer mkdir és rmdir parancsai, azonban ezeknek megvan az a káros mellékhatásuk, hogy üzeneteket jeleníthetnek meg, amelyek aztán elronthatják a program nagy gonddal megtervezett felületét. Nem kell tartanunk ezektôl a problémáktól, ha a REXXUtil segédfüggvények között található SysMkDir és SysRmDir függvényeket használjuk, amelyek ráadásul kicsit gyorsabbak is, mint a megfelelô rendszerparancsok. A SysMkDir és SysRmDir függvények szintakszisa a következô:

rc = SysMkDir(könyvtár)
rc = SysRmDir(könyvtár)

Amennyiben a paraméterként megadott könyvtárat sikerült elkészíteni, vagy pedig letörölni, a függvények 0-át adnak vissza, ellenkezô esetben pedig egy, a hibától függô kódot. Ezeket a visszatérési értékeket alábbi táblázatunkban foglaltuk össze:

Hibakód:	Jelentés:
0	Sikeres végrehajtás
2	Nem létezô fájl
3	Nem létezô elérési út
5	Hozzáférés megtagadva
16	Ez a jelenleg használt könyvtár
26	Nem DOS lemez
87	Érvénytelen paraméter
108	A meghajtó nem elérhetô
206	A fájl neve nem megfelelô

Talán az egyik legbonyolultabb paraméterezésû, ugyanakkor minden bizonnyal az egyik leghasznosabb segédfüggvény a SysFileTree. Segítségével ugyanis általunk megfogalmazott kritériumoknak megfelelô fájlok és könyvtárak listáját állíthatjuk elô:

rc = SysFileTree(fájlspecifikáció, lista [, [opciók] [, [cél-attr] [, [új-attr]]])

A fájlspecifikáció tartalmazza a fájlok és könyvtárak keresési kritériumát (pl. *txt*). A lista összetett változó kapja meg a keresés eredményét tartalmazó listát. A találatok száma a lista.0 változóban található. Az opciók paraméterrel a lista összetétele szabályozható:

Opció:	Hatása:
B	Mind a fájlok, mind pedig a könyvtárak között keresünk. Ez a default beállítás.
D	Csak a könyvtárak között keresünk.
F	Csak a fájlok között keresünk.
O	Csak a fájlok és könyvtárak nevét tartalmazza a lista. Ezen opció nélkül a SysFileTree a név mellett visszaadja a dátumot, idôt, méretet és a kiterjesztett attribútumokat is.
S	Az alkönyvtárakban is keres.
T	A dátum és az idô az év/hónap/nap/óra/perc sorrendben kerülnek ábrázolásra.

A cél-attr paraméterrel megadhatjuk azt is, hogy mely attribútummal rendelkezô fájlokat keressük. A cél-attr értéke az ADHRS maszknak megfelelô sorrendû attól függôen, hogy archív, könyvtár, rejtett (hidden), csak olvasható (read-only) vagy pedig rendszer (system) attribútumokra keresünk. Amennyiben egy adott attribútum a keresésünkre nézve közömbös, akkor annak a helyét egy csillaggal kell kitölteni a maszkban. Ha egy attribútumnak jelen kell lennie, akkor azt az összeadás jellel adjuk meg. Ha pedig éppen egy attribútum hiányát akarjuk megadni, akkor arra a kivonás jel szolgál. A -++-- maszk például azt jelzi, hogy csak a rejtett attribútummal rendelkezô könyvtárakat keressük. Az alapértelmezett érték *****, azaz a maszknak nincs hatása. Az új-attr szintén egy attribútum maszk, csak ezzel éppen törölni lehet a megtalált fájlok attribútumait. Hatása tehát megegyezik az OS/2 attrib parancséval.

Mint már említettük, a SysFileTree függvény összetett változóban adja vissza a keresés eredményét. A meghíváskor idézôjelek közé kell tenni az összetett változó nevét, mivel nem az értékét, hanem a nevét akarjuk a függvénynek átadni:

CALL SysFileTree 'C:\OS2\*.*', 'fajlok.'
DO i = 1 TO fajlok.0
	SAY fajlok.i
END

A megadott kódrészlet az alábbi listához hasonló kimenetet produkál:

 8/09/96   0:36a        5139  A----  C:\OS2\ANSI.EXE
 8/25/96  11:47a       17406  A----  C:\OS2\ARCINST.EXE
 8/25/96  11:48a       22991  A----  C:\OS2\ARCRECOV.EXE
 8/09/96   0:02a       37277  A----  C:\OS2\ATTRIB.EXE
 8/09/96   0:37a       28196  A----  C:\OS2\BACKUP.EXE
 8/28/96   3:21a       21523  A----  C:\OS2\BLDLEVEL.EXE
 8/09/96   0:40a       43056  A----  C:\OS2\BOOT.COM
 8/13/96  11:19a       11820  A----  C:\OS2\CACHE.EXE
 7/22/96  11:05a        5850  A----  C:\OS2\CGA.RC
 8/09/96   0:04a       70208  -----  C:\OS2\CHKDSK.COM

Figyeljük meg, hogy a lista sok tekintetben eltér a dir parancs által produkálttól. A fájlnevek például a teljes elérési útvonallal szerepelnek (ezt az opciókkal ki sem lehet kapcsolni) és a fájl attribútumok is megjelennek.

Gyakran elôfordul az is, hogy nem a fájlok neve, hanem a tartalmuk alapján kell keresnünk. Éppen erre a célra szolgál a SysFileSearch segédfüggvény, amellyel megkerestethetjük egy fájlon belül egy adott karakterlánc összes elôfordulási helyét:

rc = SysFileSearch(karakterlánc, fájlnév, lista [, opciók])

A karakterlánc paraméterrel adjuk meg a keresett információt, a fájlnév pedig értelemszerûen a vizsgált fájl nevét jelenti. A lista összetett változó tárolja a keresés eredményét. Itt is az elsô elem, a lista.0 tartalmazza a találatok számát. A 0 visszatérési érték a sikeres végrehajtásról tudósít. A 2 azt jelzi, hogy elfogyott a memória, a 3 pedig azt, hogy nem sikerült megnyitni a kérdéses fájlt. A megadható opcióknak két fajtája lehetséges. A C azt jelenti, hogy a nagy és kisbetûk közötti eltérést is figyelembe kívánjuk venni a keresés során. Az N pedig azt adja meg, hogy a megtalált sorok sorszámát is tartalmazza a lista. 

A SysFileTree és SysFileSearch kombinálásával olyan programot is írhatunk, amellyel kiválthatjuk a UNIX rendszerekbôl ismert grep parancsot:

/* Szöveg keresése fájlokban */

CALL RxFuncADD 'SysLoadFuncs', 'RexxUtil', 'SysLoadFuncs'
CALL SysLoadFuncs

PARSE ARG '"' search '"' filespec
IF search = '' | filespec = '' THEN
	DO 
		SAY 'Használat: lecke2b.cmd "keresett_szöveg" fájl_specifikáció'
		EXIT
	END

filespec = Strip(filespec , 'B')
CALL SysFileTree filespec, 'fajlok.', 'FSO'
DO i = 1 to fajlok.0
	IF SysFileSearch(search, fajlok.i, 'sorok.') = 0 & sorok.0 > 0 THEN
		DO
			SAY fajlok.i':'
				DO j = 1 TO sorok.0
					SAY '  'sorok.j
				END
			SAY
		END
END

EXIT

Már csak a SysFileDelete függvény maradt, amely szorosan hozzátartozik a fájlokkal és könyvtárakkal végzett mûveletekhez. Mint ahogy azt a neve is mutatja, ezzel a függvénnyel fájlokat törölhetünk, így a del, vagy erase parancs kiváltására alkalmas:

rc = SysFileDelete(fájl)

A 0 visszatérési érték a feladat sikeres végrehajtását jelzi, ellenkezô esetben egy hibaüzenetet kapunk. A törlendô fájl nevét pontosan kell megadni, nem lehet például gyorsítókaraktereket (*, ?) használni. Ez egyébként igaz a SysFileSearch fájlnév paraméterére is.

Kiterjesztett attribútumok

Kiterjesztett attribútumnak (a továbbiakban EA, Extenden Atrribute) nevezünk minden olyan információt, amelyet az OS/2 egy fájllal kapcsolatban, a fájltól elkülönítve tárol. Az EA-k egy részét (.SUBJECT, .COMMENTS, .KEYPHRASES, .HISTORY) megnézhetjük a fájl Beállítások (Settings/Properties) könyvének Fájl menüpontjánál. A megfelelô REXX segédfüggvényekkel minden további nélkül lehet az EA-kat írni és olvasni. A SysGetEA függvény például az olvasásra szolgál:

rc = SysGetEA(fájlnév, EA-név, változó)

Az elsô paraméter adja meg annak a fájlnak a nevét, amelynek az EA-ját ki szeretnénk olvasni. Az EA-név az EA neve, amely érzékeny a kis és nagybetûk közötti különbségekre! A változóban kerül eltárolásra a kiolvasott EA. A 0 visszatérési érték jelzi a mûvelet sikerességét. Az alábbi táblázatban összefoglaltuk a standard EA-kat:

EA:	Leírás:
.ASSOCTABLE	Az alkalmazásokat a fájltípusokhoz rendelô EA.
.CODEPAGE	Jelzi, hogy a fájl kódtáblázata más, mint a alkalmazás, vagy a default kódtábla.
.COMMENTS	Megjegyzéseket tartalmazó EA.
.HISTORY	A fájlmódosításokat nyilvántartó EA.
.ICON	A fájlhoz tartozó ikon EA-ja.
.KEYPHRASES	Kulcsszavakat, vagy kifejezéseket tároló EA.
.LONGNAME	A hosszú fájlnevet tároló EA. Erre akkor van szükség, ha hosszú fájlnévvel rendelkezô állományt például FAT partícióra másolunk.
.SUBJECT	A fájl tartalmáról vagy céljáról készített összefoglalás EA-ja.
.TYPE	A fájl típusát tároló EA.
.VERSION	A fájl verzióját tároló EA.

Az EA-k természetesen kódolt, bináris formátumban vannak eltárolva. Kiolvasásuk és értelmezésük ezért kicsit bonyolultabb, mint az egyszerû szöveges állományok kezelése. A tárolt információn kívül az EA-kban mindig találunk egy adattípus-azonosítót is, és egy, a méretre utaló mezôt. Példaképpen tekintsük meg az alábbi kódrészlet, amely beolvassa, visszakódolja és megjeleníti a fájlról tárolt összefoglaló (.SUBJECT) EA tartalmát:

IF SysGetEA(fajlnev, 'SUBJECT.', 'subject') = 0 & subject <> '' THEN
	DO
		PARSE VAR subject eatipus 3 hossz 5 szoveg
		SAY '.SUBJECT'
		SAY C2X(Reverse(eatipus)) C2D(Reverse(hossz))
		SAY szoveg
	END

Az elsô sorban beolvassuk a megfelelô EA-t a SysGetEA függvénnyel, majd pedig felbontjuk a változó tartalmát. Az EA típusa és hossza az elsô két-két bájton van eltárolva. A maradék a tulajdonképpeni információ. A típus és a hossz fordított sorrendben van ábrázolva, ezért a megjelenítés elôtt a Reverse függvénnyel vissza kell állítani a helyes sorrendet. A típust hexadecimális, a méretet pedig tizes számrendszerben íratjuk ki.

Mivel az EA típusok elôre definiáltak, ezért elég, ha csak az EA típusát vizsgáljuk meg, hogy kitaláljuk, hogy az milyen fajta adatot tartalmaz. Az alábbi táblázatban összefoglaltuk az adattípusokat:

Adattípus:	Érték:	Leírás:
EAT_ASN1	'FFDD'x	ASN.1 adat
EAT_ASCII	'FFFD'x	ASCII szöveg
EAT_BINARY	'FFFE'x	Bináris adat
EAT_BITMAP	'FFFB'x	Bitmap
EAT_EA	'FFEE'x	Az EA-hoz kapcsolódó másik EA neve
EAT_ICON	'FFF9'x	Ikon
EAT_METAFILE	'FFFA'x	Metafájl
EAT_MVMT	'FFDF'x	Több értékû, több típusú adat
EAT_MVST	'FFDE'x	Több értékû, egyetlen típusú adat

Nézzük meg egy kicsit jobban a legutolsó két típust. Több értékû, több típusú EA például akkor fordul elô, amikor egy fájlhoz több, azonban eltérô típus (.TYPE) is tartozik. Ebben az esetben a .TYPE értéke nem EAT_ASCII, hanem EAT_MVMT lesz, az EA struktúrája pedig a következôképpen alakul:

EAT_MVMT kódlap darabszám
	EAT_ASCII hossz szöveg
	EAT_ASCII hossz szöveg

A szöveg kivételével valamennyi mezô két bájtot foglal el, amelyek a már említett fordított sorrendben vannak ábrázolva. A darabszám adja meg, hogy hány típust tartalmaz az EA. A kódlap értéke nulla, már amennyiben az adatok a default kódlaptól eltérô kódlap alatt készültek. A hossz adja meg az eltárolt típusok méretét.

A másik összetett EA az egyetlen típusú, ugyanakkor több értéket tartalmazó EA:

EAT_MVST kódlap darabszám EAT_ASCII
	szöveg
	szöveg

Ezt a fajta EA-t leginkább a .COMMENTS és .KEYPHRASES attribútumoknál használják. A továbbiakban tekintsünk meg egy programot, amellyel egy tetszôleges fájl összes EA-ja megjeleníthetô!

/* Az EA-k megjelenítése */

CALL RxFuncADD 'SysLoadFuncs', 'RexxUtil', 'SysLoadFuncs'
CALL SysLoadFuncs

PARSE ARG fajl
IF fajl = '' THEN EXIT

/* EA típusok */
eat. 		= ''
eat.asn1 	= 'FFDD'x
eat.ascii 	= 'FFFD'x 
eat.binary 	= 'FFFE'x 
eat.bitmap 	= 'FFFB'x 
eat.ea 		= 'FFEE'x 
eat.icon 	= 'FFF9'x
eat.metafile 	= 'FFFA'x 
eat.mvmt 	= 'FFDF'x 
eat.mvst 	= 'FFDE'x

/* Standard EA-k */
EANevek.0	= 7
EANevek.1	= '.SUBJECT'
EANevek.2	= '.COMMENTS'
EANevek.3	= '.TYPE'
EANevek.4	= '.LONGNAME'
EANevek.5	= '.HISTORY'
EANevek.6	= '.KEYPHRASES'
EANevek.7	= '.VERSION'

DO j = 1 TO EANevek.0
	IF GetAndFormatEA(fajl, EANevek.j) THEN
		DO
			SAY EANevek.j':'
			DO i = 1 TO ea.0
				SAY '  'ea.i.tipus':' ea.i.adat
			END
		END
END

EXIT

/* Beolvassa és értelmezi az EA-kat */
GetAndFormatEA: PROCEDURE EXPOSE eat. ea.

	FajlNev = Arg(1)
	EANev   = Arg(2)

	ea.0 = 0
	IF SysGetEA(FajlNev, EANev, valami) = 0 & valami <> '' THEN
		DO
			CALL FormatEA valami, 1
			RETURN 1
		END
	RETURN 0

/* Rekurzív függvény az EA-k kiértékelésére */
FormatEA: PROCEDURE EXPOSE eat. ea.
	valami = Arg(1)
	szam   = Arg(2)
	PARSE VAR valami eat 3 .
	eat = Reverse(eat)
	SELECT
		WHEN eat == eat.ascii THEN
			DO
				ea.0 = szam
				PARSE VAR valami 3 hossz 5
				hossz = C2D(Reverse(hossz))
				PARSE VAR valami 5 ea.szam.adat +(hossz) valami
				ea.szam.tipus = 'ASCII'
			END
		WHEN eat == eat.icon THEN
			DO
				ea.0 = szam
				PARSE VAR valami 3 hossz 5
				hossz = C2D(Reverse(hossz))
				PARSE VAR valami 5 ea.szam.adat +(hossz) valami
				ea.szam.tipus = 'ICON'
			END
		WHEN eat == eat.mvmt THEN
			DO
				PARSE VAR valami 5 hossz 7 valami
				hossz = C2D(Reverse(hossz))
				DO i = 0 TO (hossz-1)
					valami = FormatEA(valami, szam+1)
				END
			END
		WHEN eat == eat.mvst THEN
			DO
				PARSE VAR valami 5 hossz 7 valami
				hossz = C2D(Reverse(hossz))
				DO i = 0 TO (hossz-1)
					valami = FormatEA(valami, szam+1)
					valami = Reverse(eat.ASCII) || valami
				END
			END
		OTHERWISE
			ea.0 = szam
			ea.szam.tipus = '???'
			ea.szam.adat  = 'Ismeretlen EA típus' C2X(eat)
		END
	RETURN valami

A program két összetett változót használ az EA típusok és a standard EA-k tárolására. Minden egyes standard EA esetében meghívjuk a GetAndFormatEA-t és megjelenítjük a visszaadott információt. A GetAndFormatEA eljárás kiolvassa a fájlhoz kapcsolt EA-t és meghívja a FormatEA eljárást, amely aztán feldolgozza azt. Amennyiben összetett EA-ról van szó, a FormatEA függvényt rekurzív úton többször is meghívjuk.

Az EA-k írása a SysPutEA függvénnyel történhet:

rc = SysPutEA(fájlnév, EA-név, adat)

Értelemszerûen a fájlnév paraméter adja meg annak a fájlnak a nevét, amelyhez az EA-t akarjuk kapcsolni. Az EA-név lehet a standard EA-k valamelyike, vagy valamilyen alkalmazás-specifikus név. Az adat hordozza az eltárolni kívánt információt. Természetesen a kiolvasásánál már megismert kódolást itt is alkalmazni kell. E szerint az EA típusa és a hossza az elôállítandó karakterlánc elsô két-két bájtját foglalják le, fordított bináris sorrendben. Tekintsük meg az alábbi programrészletet, amellyel az ujSubject változóban elôzôleg eltárolt .SUBJECT EA-t lehet megváltoztatni:

hossz = Right(D2C(Length(ujSubject)), 2, '00'x) 		/* A hossz kiszámítása */
subj  = Reverse(eat.ascii) || Reverse(hossz) || ujSubject 	/* Az EA összerakása 	*/
CALL SysPutEA fajlnev, '.SUBJECT', subj 			/* Az EA kiíratása 	*/

Az .INI fájlok elérése és módosítása

Az OS/2 OS2.INI és OS2SYS.INI fájljai bináris formátumban tárolják a telepített programokkal, és a rendszerrel kapcsolatos információkat. A SysIni segédfüggvény felhasználásával lehetôség nyílik az eltárolt információ megjelenítésére, módosítására, illetve törlésére. Az INI fájlokban tárolt információt alkalmazásonként egy, esetleg több kulcs alatt csoportosítják. A SysIni függvénnyel lekérdezhetjük egy adott alkalmazás adott kulcsához tartozó információt:

érték = SysIni([ini-fájl], alkalmazás, kulcs)

Az ini-fájl paraméter a vizsgált ini fájl neve, a teljes elérési útvonallal. Amennyiben az OS2.INI fájlról van szó, akkor a USER, az OS2SYS.INI esetében pedig a SYSTEM kulcsszavat is használhatjuk a fájlnév helyett. Amennyiben egyszerre mindkét fájlból akarunk olvasni, akkor a BOTH kulcsszót kell használnunk. Az alkalmazás és kulcs paraméterek értelemszerûen a lekérdezendô információhoz tartozó alkalmazás és kulcs nevét jelentik. Arra is lehetôség van, hogy egy adott alkalmazás összes kulcsát lekérdezzük. Ekkor a kulcs paraméter helyébe az ALL: szót kell beírni, és meg kell adni egy összetett változónevet is, amelybe a kinyert információ kerül:

rc = SysIni([ini-fájl], alkalmazás, 'ALL:', info)

A függvény által visszaadott érték (rc) ERROR:, amennyiben nem sikerült a mûvelet, ellenkezô esetben pedig egy üres karakterlánc. Az info.0 értéke sikeres végrehajtás esetében meg fog egyezni a talált kulcsok számával, a kulcsok pedig az info.1, info.2 stb. változókban lesznek megtalálhatóak. Az összes alkalmazás nevét ehhez nagyon hasonlóan, az alkalmazás paraméter helyébe írt ALL: szócskával lehet lekérdezni:

rc = SysIni([ini-fájl], 'ALL:', info)

Egy adott alkalmazás-kulcs pároshoz tartozó információt a DELETE: opció megadásával tudjuk kitörölni:

rc = SysIni([ini-fájl], alkalmazás, kulcs, 'DELETE:')

Sikeres végrehajtás esetén üres karakterláncot találunk az rc változóban, ellenkezô esetben pedig az ERROR: üzenetet. Mint sok más esetben, a törlés itt is visszafordíthatatlan mûvelet, ezért a kísérletezés elôtt mindig készítsünk az INI fájlokról biztonsági másolatot!!!

Már csak a SysIni függvény harmadik használati módja, az információ eltárolása hiányzik kelléktárunkból, amelyet ezennel pótolunk:

rc = SysIni([ini-fájl], alkalmazás, kulcs, adat)

/* Az INI fájlok kiolvasása */

CALL RxFuncADD 'SysLoadFuncs', 'RexxUtil', 'SysLoadFuncs'
CALL SysLoadFuncs

PARSE Arg alk kulcs
SELECT
	WHEN alk = '' THEN
		rc = SysIni('BOTH', 'ALL:', 'iniData.')
	WHEN kulcs = '' THEN 
		rc = SysIni('BOTH', alk, 'ALL:', 'iniData.')
	OTHERWISE
		iniData.1 = SysIni('BOTH', alk, kulcs)
		iniData.0 = 1
		rc = ''
END

IF rc = 'ERROR:' THEN
	SAY 'Sikertelen olvasás!'
ELSE
	DO i = 1 TO iniData.0
		SAY iniData.i
	END

EXIT