Az ELAN programozási nyelv

Alprogramok, modulok

5. Alprogramok, modulok

Ez a fejezet az alábbi című alfejezeteket tartalmazza:
5.1. Az ELAN programegységei
5.2. Specialitások
5.3. Az ELAN1 beépített operátorai és eljárásai

5.1. Az ELAN programegységei

Ez az alfejezet az ELAN nyelv programegységeit ismerteti, melyek az alábbiak:
5.1.1. Eljárás
5.1.2. Függvény
5.1.3. Operátor
5.1.4. Típus

Négyféle programegységet fogunk megvizsgálni: az eljárást, a függvényt, az operátort, és a típust.

5.1.1. Eljárás

Az ELAN nyelvben is létezik a "hagyományos" eljárás fogalom. A programban az eljárások az alulról felfelé (azaz: Bottom-up) irányuló építkezés eszközei, szemben a finomításokkal, melyek az algoritmus felülről lefelé (azaz: Top-down) irányuló építésének eszközei.

Az ELAN eljárásai sorrendben az alábbi három részből állnak:
- fej
- törzs
- vég

1.) Eljárásfej

Az eljárásfej tartalmazza az adott eljárás nevét, paramétereinek típusát, hozzáférési jogát, és ha van neki, akkor a visszaadott érték típusát. A hozzáférési jog vagy CONST, vagy pedig VAR lehet.


CONST

CONST fajtájú hozzáférési jog esetén az adott eljárás a paraméternek az értékét kapja meg. Ez azt jelenti, hogy hiába változik meg az adott paraméter értéke az adott eljáráson belül, a megváltozott érték nem kerül vissza a főprogramhoz.


VAR

VAR fajtájú hozzáférési jog esetén az adott eljárás a paraméternek a címét kapja meg. Ez azt jelenti, hogy ha az adott paraméter értéke az adott eljáráson belül megváltozik, akkor a megváltozott érték visszakerül a főprogramhoz, és a főprogram is az adott paraméter megváltozott értékét fogja használni a továbbiakban.


Az eljárásfej formája az alábbi a) vagy pedig b) pontban megadott alakú lehet:

a)


PROC eljárásnév (formális paraméterlista):


b)


eredmény típusa PROC eljárásnév (formális paraméterlista):


A b)-beli eljárásfej-forma a függvényként használandó eljárások definíciójában használatos.


A formális paraméterlista megadási módjának alakja az alábbi:


típusnév1 használati jog1 név11, név12, ...,
típusnév2 ...



Egy adott eljárás kaphat paraméterként másik eljárást is. Ilyenkor a formális paraméterlistába be kell írnunk a kapott eljárás eredményének a típusát és paramétereit (virtuális paraméterlista), ha vannak. A paraméterként átadott eljárást a következő módon kell leírnunk:


eredmény típusa PROC (virtuális paraméterlista), ...



Virtuális paraméterlista:

A virtuális paraméterlista hasonlóan adható meg, mint a formális paraméterlista, de a virtuális paraméterlista nem tartalmazza a paraméterek nevét.


2.) Eljárástörzs

Az eljárás törzse az adott eljárás utasításaiból (azaz a gyökérből), és a gyökér által használt finomításokból (Top-down rész) áll.


3.) Eljárásvég


ENDPROC eljárásnév ;


Az ELAN eljárásai - és a többi programegység is - egymástól függetlenül, tetszőleges sorrendben helyezhetők el.


PROC eljárás(formális paraméterek):
utasítások
.
Lokális finomítások
ENDPROC eljárásnév;


A lokális finomítások, az őket megelőző, az eljárástörzset lezáró .-tal együtt elmaradhatnak.

Paramétereik változók, konstansok, valamint további eljárások, függvények, operátorok is lehetnek. Több paraméter esetén egymástól vesszővel választjuk el őket. Az egymás után felsorolt, azonos típusú és hozzáférési jogú (CONST, VAR) változóknál a típust és a hozzáférési jogot elég az elsőnél megadni, s a többiek nevét az ő nevétől vesszővel elválasztani.


A formális paraméterek (azaz: változók, konstansok, valamint további eljárások, függvények, operátorok) megadási módjai:


típus hozzáférési jog változónév
PROC (virtuális paraméterek) eljárásnév
típus PROC (virtuális paraméterek) függvénynév
típus OP (virtuális paraméterek) operátornév


A virtuális paraméterek megadása a formális paraméterekére hasonlít, de nem tartalmaz változóneveket:


típus hozzáférési jog


Példa: (függvénytabellázás)


PROC függvénytábla(REAL CONST a,b,c, REAL PROC f(REAL CONST)):
REAL VAR x;
x:=a;
WHILE x<=b
REP
put(x); put(f(x)); line;
x:=x+c;
ENDREP
ENDPROC függvénytábla;


Eljárás hívása

Az eljáráshívás egyszerűen a név és az aktuális paraméterek leírásával történik:


eljárásnév (aktuális paraméterlista) ;


Az aktuális paramétereknek meg kell felelniük a deklarációnál felsorolt formális paramétereknek számban, sorrendben, típusban, hozzáférési jogban. Tehát például ha a formális paraméterlistában egy adott paraméter VAR hozzáférési joggal van megadva, akkor az adott formális paraméterhez tartozó aktuális paraméter sem lehet konstans, hanem csak változó lehet.

Az aktuális paraméterek változók, kifejezések, függvények, eljárások, és operátorok lehetnek. Megadási módjuk:


változónév
kifejezés
PROC (virtuális paraméterek) eljárásnév
típus PROC (virtuális paraméterek) függvénynév
típus OP (virtuális paraméterek) operátornév


Ha az aktuális paraméterekből több van, akkor egymástól vesszővel kell elválasztani őket.

Példa: (a függvénytabellázás hívása)


függvénytábla(0.0, 10.0, 1.0, REAL PROC (REAL CONST) abs);

függvénytábla(-3.0, 6.0, 0.01, REAL PROC (REAL CONST) sin);


Példák:


PROC osszeg1 (INT VAR r):
INT VAR i;
r := 0;
FOR i FROM 1 UPTO db
REP r := r + a[i]
ENDREP
ENDPROC osszeg1;

INT PROC osszeg2:
INT VAR i;
INT VAR s;
s := 0;
FOR i FROM 1 UPTO db
REP s := s + a[i]
ENDREP;
s
ENDPROC osszeg2;


Az osszeg1 eljárás az eredményt az r nevű cím szerint átadott paraméterben adja vissza. Az osszeg2-t függvényként használhatjuk. Eredménye az utolsó sorban található kifejezés értéke lesz. Ha a függvény végén elágazás van, akkor az elágazás minden ágába ugyanolyan típusú értéket kell írnunk. A két eljárást az alábbi módon tudjuk használni:


INT VAR q, p;
q := osszeg2;

osszeg1(p);


5.1.2. Függvény

A függvény formailag az eljáráshoz nagyban hasonlító szerkezet, a függvényérték típusa azonban a legtöbb programozási nyelvvel ellentétben itt tetszőleges lehet.


típus PROC függvénynév(formális paraméterek):
utasítások
kifejezés
.
Lokális finomítások
ENDPROC függvénynév;


Mint a függvényszerű finomításoknál, úgy itt is a függvény utolsó utasítása helyén szereplő kifejezés adja a függvény értékét. A függvények paraméterei pontosan olyanok lehetnek, mint az eljárások paraméterei. Használatuk formája is pontosan olyan, csak nem önálló utasításként, hanem kifejezés részeként szerepelhetnek.

Példa: (n faktoriális)


INT PROC fakt(INT CONST n):
INT VAR f :: 1;
INT VAR i;
FOR i FROM 1 UPTO n
REP
f := f * i
ENDREP;
f
ENDPROC fakt;
put(fakt(9));


A függvények (és az eljárások) lehetnek rekurzívak is:

Példa: (n faktoriális)


INT PROC fakt(INT CONST n):
IF n=0
THEN 1
ELSE n*fakt(n-1)
FI
ENDPROC fakt;


5.1.3. Operátor

Az operátorok egy- vagy kétargumentumú függvények helyett alkalmazható infix (egy argumentum esetén prefix) műveletek.


típus OP operátornév(formális paraméterek):
utasítások
kifejezés
.
Lokális finomítások
ENDPROC operátornév;


Az operátorok minden jellemzője (paraméterek, használat) azonos a függvényekével, nevük azonban nagybetűs vagy pedig - szokásos - műveleti jel (pl. +, -, * stb.)

Példa: (valós szám kerekítése db darab tizedesjegyre)


REAL OP TIZEDES(REAL CONST v, INT CONST db):
round(v*10**db)/10**db
ENDOP TIZEDES;
y:=12.536;
x:=y TIZEDES 2; # x értéke 12.54 lesz. #

Az operátorok egy speciális fajtája nem a függvényekhez, hanem az eljárásokhoz hasonlít, első paraméterüket változtatják meg (ilyen volt az előző részben szerepelt INCR és DECR operátor).


OP operátornév(formális paraméterek):
utasítások
kifejezés
.
Lokális finomítások
ENDPROC operátornév;


Ez a fajta operátor tehát nem kifejezésekben, hanem utasítások helyén szerepelhet.

Példa: (valós szám kerekítése db darab tizedesjegyre)


OP TIZEDES(REAL VAR v, INT CONST db):
v:=round(v*10**db)/10**db
ENDOP TIZEDES;
y:=12.536;
y TIZEDES 2; # y értéke 12.54 lesz. #


5.1.4. Típus

A típus az ELAN-ban önálló programegység, de a Pascalhoz hasonlóan itt is csak a szerkezet megadásáról beszélhetünk.


TYPE típusnév = típuskonstrukció


A típusnév kötelezően nagybetűs azonosító kell legyen. A típusdefiníció sokféleségét a következő részben az összetett típusokkal kapcsolatban fogjuk megvizsgálni.

Új típusokra a típusnév egyben konstrukciós függvény:


típusnév: változókonstrukció


Példa:


TYPE KOMPLEX = STRUCT(REAL valós, képzetes)

Nem azonos a típusuk az alábbiaknak:


STRUCT(REAL valós, képzetes) VAR a;
KOMPLEX VAR b;

Különböző típusúak, de azonos szerkezetűek az alábbi konstansok:


a:=[1.0, 0.0]
b:=KOMPLEX: [1.0, 0.0]


5.2. Specialitások

Ez az alfejezet az ELAN nyelvvel kapcsolatban további két témakört ismertet, melyek az alábbiak:
5.2.1. Fájlkezelés
5.2.2. Véletlenszámok

5.2.1. Fájlkezelés

A jelenlegi ELAN csak szekvenciális szövegfájlok kezelésére képes. Egy szekvenciális fájlt vagy olvasásra, vagy pedig írásra lehet megnyitni. Ezt a tényt rögzíti egy típus, s annak két konstans függvénye:


TYPE TRANSPUTDIRECTION
TRANSPUTDIRECTION PROC input
TRANSPUTDIRECTION PROC output


A fájltípus egy rekorddal - az úgynevezett fájlleíró rekorddal - írható le, amely mindazt az információt tartalmazza, amelyre a fájl olvasásakor szükség lehet. Ezek közül a felhasználható mezők az alábbiak:


TYPE FILE = STRUCT( TEXT name; # az adott fájl neve #
BOOL open; # nyitva van-e az adott nevű fájl? #
BOOL eof; # az adott fájl végén vagyunk-e? #
TRANSPUTDIRECTION dir; # az adott fájl input- vagy outputfájl? #
BOOL eot; # üres-e a puffer? #
TEXT buffer; # a puffer tartalma #
INT width; # maximális sorhossz #
BOOL new; # az adott fájl új-e? #
)


File típusú változó definiálása, illetve a fájl megnyitása és lezárása a következőképpen történhet:


FILE VAR változó;
változó := sequential file(input, "file-név");
változó := sequential file(output, "file-név");
close(változó)


Egy adott fájl olvasásra történő megnyitásakor az aktuális könyvtárban az adott nevű fájlnak már léteznie kell.
Egy adott fájl írásra történő megnyitása esetén:
a) ha az aktuális könyvtárban már létezik az általunk megadott nevű fájl, akkor azt a fájlt az ELAN előbb kitörli az aktuális könyvtárból, majd ezután létrehozza az adott nevű üres fájlt.
b) ha az aktuális könyvtárban még nem létezik az általunk megadott nevű fájl, akkor az ELAN létrehozza az adott nevű üres fájlt.

A többi fájlkezelő műveletet néhány konkrét feladaton keresztül nézzük meg.

Feladat1: Készítsünk fájllistázó programot, amely soronként írja ki a fájlt a képernyőre!

A megoldáshoz olyan műveletre van szükségünk, amely a fájlból egyszerre egy sort tud kiolvasni. (Az analógia miatt az olvasó eljárásokkal párhuzamosan mindig közöljük az író eljárásokat is.) A sorolvasás, sorírás műveletek a fájlon kívül egy szöveg típusú változót használnak paraméterként.


get line(file-változó, változó)
put line(file-változó, változó)


A listázás befejezéséhez szükségünk van a fájl vége elérésének érzékelésére. Ezt megoldhatjuk a fájl típusú változó megfelelő mezőjének megvizsgálásával, de használhatjuk rá a fájlvége függvényt is:


eof(f)


A megoldásban a sorok képernyőre tördelésével nem foglalkozunk.

Megoldás:


listázás:
FILE VAR f; TEXT VAR sor;
f:=sequential file(input, "SZOVEG.TXT");
WHILE NOT eof(f)
REP
get line(f, sor);
put(sor); line; # a sorvég karakter nem kerül bele a sorba #
ENDREP
close(f);
.


Feladat2: Készítsünk fájllistázó programot, amely szavanként írja ki a fájlt a képernyőre!

Itt olyan beolvasásra van szükségünk, amelynek egy szó (illetve egy egész vagy valós szám) lehet a paramétere. Ahogyan a billentyűzetről való beolvasásnál, úgy a fájloknál is igaz, hogy a szöveg típusú adatok beolvasásakor a feltételezett határoló jel a szóköz. A beolvasás és a kiírás a következő alakú:


get(file-változó, változó)
put(file-változó, változó)


Megoldás:


listázás:
FILE VAR f; TEXT VAR szó;
f:=sequential file(input, "SZOVEG.TXT");
WHILE NOT eof(f)
REP
get(f, szó);
put(szó); line; # a szóköz karakter nem kerül bele a szóba #
ENDREP
close(f);
.


Feladat3: Készítsünk fájllistázó programot, amely betűnként írja ki a fájlt a képernyőre!

A feladat megoldásához olyan beolvasásra van szükség, amely adott darabszámú karakter beolvasására képes. Ez a művelet nagyon hasonlít a billentyűzetről olvasás műveleteire.


get(file-változó, változó, darabszám)


Megoldás:


listázás:
FILE VAR f; TEXT VAR betű;
f:=sequential file(input, "SZOVEG.TXT");
WHILE NOT eof(f)
REP
get(f, betű, 1);
put(betű); line;
ENDREP
close(f);
.


Feladat4: Készítsünk fájllistázó programot, amely mondatonként írja ki a fájlt a képernyőre!

A feladat megoldásához olyan beolvasásra van szükség, amely adott végjelig (most éppen a pontig) olvas. Ez a művelet nagyon hasonlít a billentyűzetről olvasás műveleteire.


get(file-változó, változó, végjel)


Megoldás:


listázás:
FILE VAR f; TEXT VAR mondat;
f:=sequential file(input, "SZOVEG.TXT");
WHILE NOT eof(f)
REP
get(f, mondat, ".");
put(mondat+"."); line;
ENDREP
close(f);
.

A feladatok végignézése után még felsorolunk néhány kiegészítő műveletet.

Szekvenciális outputfájloknál - a képernyőhöz hasonlóan - szükségünk lesz soremelés műveletre (kivéve, ha a put line eljárást használjuk):


line(file-változó)
line(file-változó, darabszám)


A fájl állapotának további lekérdező függvényei (a fájl típusú változó megfelelő mezői értékét adják):


name(file-változó)
opened(file-változó)
max line length(file-változó)
new(file-változó)



Végezetül a fájlokat törlő eljárás amely tetszőleges fájlt töröl úgy, hogy
a) ha a törlendő fájl éppen nincs megnyitva, akkor törli,
b) ha pedig a törlendő fájl éppen meg van nyitva olvasásra vagy írásra, akkor előbb lezárja, majd utána törli a fájlt.


erase(file-változó)


5.2.2. Véletlenszámok

Véletlen jelenségek is modellezhetők ELAN-ban, de ezek használatához meg kell ismerkednünk a véletlenszámokkal.

A véletlenszámgenerálás szokás szerint két lépésből áll: először be kell állítani a generátor kezdőértékét, majd pedig a generáló eljárást használhatjuk, ahányszor csak szükségünk van rá.

A generátor kezdőértékének beállítása egy egyszerű eljárással megoldható:


initialize random(egész érték)


Ebben az esetben minden programfutásnál a megadott kezdőértékről indul a véletlenszámgenerátor, s így mindig ugyanazt a véletlenszámsorozatot adja. Ha kezdőértéket nem állítunk be, akkor a memória adott címén talált - véletlenszerű - érték lesz a kezdőérték.

Nézzünk néhány "klasszikus" feladatot példaként véletlenszámok alkalmazására!


Feladat1: Szimuláljunk a számítógéppel 10 darab kockadobást!

A kockadobás eredményei olyan számok, amelyek 1 és 6 közöttiek, s értékük előre nem jósolható meg. A feladat megoldásához egy függvény áll rendelkezésünkre:


random(alsó határ, felső határ)


A függvény a két határ - mint zárt intervallum - közötti véletlen egész számot ad értékül. Használjuk fel ezt a megoldásban!

Megoldás:


kockadobások:
UPTO 10
REP
put( random(1, 6) )
ENDREP
.


Feladat2: Keverjük össze számítógéppel az angol ábécé magánhangzóit!

Ha a magánhangzókat egy tömbben tároljuk, akkor a véletlenszámmal való tömbindexelést kell megoldanunk. A keverés lényege: az 1. lépésben cseréljük fel a tömb 1. elemét a mögötte levők valamelyikével! A véletlenszámgenerátor minden hívása újabb véletlenszám generálását eredményezi, ezért egy új változóba kell tenni a véletlenszámot, s a későbbiekben azt felhasználni.

Megoldás:


keverés:
ROW 5 TEXT VAR betű :: ["a", "e", "i", "o", "u"];
INT VAR i, j;
TEXT VAR t;
FOR i FROM 1 UPTO 4
REP
j := random(i, 5);
t := betű[i]; betű[i] := betű[j]; betű[j] := t
ENDREP
.


Feladat3: Szimuláljunk a számítógéppel 5 darab pénzfeldobást!

Az alapprobléma az, hogy a pénzérme nem számjellegű információt tartalmaz, hanem a FEJ vagy ÍRÁS esetek valamelyikét. Mindkét eset azonos (= 0.5) valószínűséggel fordul elő. Ennek a feladatnak a megoldásához olyan véletlenszámgenerátorra van szükségünk, amellyel adott valószínűségű eseményeket játszhatunk le. Erre a célra egy olyan függvényt fogunk használni, amely a [0, 1) balról zárt, jobbról nyílt intervallumban ad egyenletes eloszlású véletlen valós számokat:


random


Megoldás:


pénzfeldobások:
UPTO 5
REP
IF random < 0.5
THEN put("FEJ")
ELSE put("ÍRÁS")
FI
ENDREP
.


Feladat4: Szimuláljuk a síkbeli véletlenszerű bolyongást!

Bolyongáskor irányt választunk véletlenszerűen: a pozitív X-tengellyel bezárt szög az óramutató járásával ellentétes irányú. Az irány 0 és 2*pí közötti véletlen valós szám lehet. Ezt a [0, 1) intervallumbeli véletlen valós számból transzformációval kaphatjuk.

Megoldás:


PROC bolyongás(REAL VAR x, y):
REAL VAR ir;
pontrajzolás(x, y)
REP
ir := random * 2 * pí;
ponttörlés(x, y);
x := x + cos(ir); y := y - sin(ir);
pontrajzolás(x, y)
UNTIL feltétel
ENDREP
ENDPROC bolyongás;
.


5.3. Az ELAN1 beépített operátorai és eljárásai

Ez az alfejezet az ELAN1 nyelv beépített operátorait és eljárásait ismerteti, melyek az alábbiak:
5.3.1. Egész (azaz: INT) típusú adatok kezelésére használható elemi programegységek
5.3.2. Valós (azaz: REAL) típusú adatok kezelésére használható elemi programegységek
5.3.3. Szöveg (azaz: TEXT) típusú adatok kezelésére használható elemi programegységek
5.3.4. Fájl (azaz: FILE) típusú adatok kezelésére használható elemi programegységek
5.3.5. Logikai (azaz: BOOL) típusú adatok kezelésére használható elemi programegységek
5.3.6. Egyéb célokra használható elemi programegységek

Most pedig jöjjön az ELAN1 elemi programegységeinek listája.
A leírás első oszlopában az egyes függvények, operátorok által visszaadott eredmény típusa van. Ezután következik magának az objektumnak a típusa, ami PROC (azaz: eljárás), OP (azaz: operátor), vagy pedig LET (azaz: szinoníma) lehet. Ezután jön a név. Végül pedig eljárások és operátorok esetén a formális paraméterlista következik. A szinonímák mellett az egyenlőségjel után azok értékét írtuk.

5.3.1. Egész (azaz: INT) típusú adatok kezelésére használható elemi programegységek

TYPE INT

Visszaadott eredmény típusaObjektum típusaObjektum neveFormális paraméterlista
PROCget(INT VAR x)
PROCput(INT CONST x)
BOOLOP=(INT CONST x, y)
BOOLOP<>(INT CONST x, y)
BOOLOP<(INT CONST x, y)
BOOLOP<=(INT CONST x, y)
BOOLOP>(INT CONST x, y)
BOOLOP>=(INT CONST x, y)
INTOP+(INT CONST x, y)
INTOP-(INT CONST x, y)
INTOP*(INT CONST x, y)
INTOPDIV(INT CONST x, y)
INTOPMOD(INT CONST x, y)
INTOP**(INT CONST x, y)
INTOP+(INT CONST x)
INTOP-(INT CONST x)
OPINCR(INT VAR x, INT CONST y)
OPDECR(INT VAR x, INT CONST y)
INTOPSIGN(INT CONST x)
INTOPABS(INT CONST x)
INTPROCsign(INT CONST x)
INTPROCabs(INT CONST x)
BOOLPROCeven(INT CONST x)
BOOLPROCodd(INT CONST x)
INTPROCmax(INT CONST x, y)
INTPROCmin(INT CONST x, y)
INTPROCtrunc(REAL CONST x)
INTPROCround(REAL CONST x)
INTPROCint(TEXT CONST t)
INTPROCascii(TEXT CONST t)
INTPROCcode(TEXT CONST t)
INTPROCdigit(TEXT CONST t)
INTPROCmaxint
INTPROCminint


5.3.2. Valós (azaz: REAL) típusú adatok kezelésére használható elemi programegységek

TYPE REAL

Visszaadott eredmény típusaObjektum típusaObjektum neveFormális paraméterlista
PROCget(REAL VAR x)
PROC put(REAL CONST x)
BOOLOP=(REAL CONST x, y)
BOOLOP<>(REAL CONST x, y)
BOOLOP<(REAL CONST x, y)
BOOLOP<=(REAL CONST x, y)
BOOLOP>(REAL CONST x, y)
BOOLOP>=(REAL CONST x, y)
REALOP+(REAL CONST x, y)
REALOP-(REAL CONST x, y)
REALOP*(REAL CONST x, y)
REALOP/(REAL CONST x, y)
REALOP/(INT CONST x, y)
REALOPMOD(REAL CONST x, y)
REALOP**(REAL CONST x, INT CONST y)
REALOP**(REAL CONST x, y)
REALPROCsqrt(REAL CONST x)
REALOP+(REAL CONST x)
REALOP-(REAL CONST x)
OPINCR(REAL VAR x, REAL CONST y)
OPDECR(REAL VAR x, REAL CONST y)
INTOPSIGN(REAL CONST x)
REALOPABS(REAL CONST x)
INTPROCsign(REAL CONST x)
REALPROCabs(REAL CONST x)
REALPROCmax(REAL CONST x, y)
REALPROCmin(REAL CONST x, y)
REALPROCreal(INT CONST x)
REALPROCreal(TEXT CONST x)
REALPROCmaxreal
REALPROCsmallreal
LETpi = 3.141592653589793
REALPROCsin(REAL CONST x)
REALPROCcos(REAL CONST x)
REALPROCtan(REAL CONST x)
REALPROCarctan(REAL CONST x)
REALPROCarccos(REAL CONST x)
REALPROCarcsin(REAL CONST x)
LETe = 2.71828182845904
REALPROCexp(REAL CONST x)
REALPROCln(REAL CONST x)
REALPROClog10(REAL CONST x)
REALPROClog2(REAL CONST x)


5.3.3. Szöveg (azaz: TEXT) típusú adatok kezelésére használható elemi programegységek

TYPE TEXT

Visszaadott eredmény típusaObjektum típusaObjektum neveFormális paraméterlista
PROCget(TEXT VAR t)
PROCget(TEXT VAR t, INT CONST maxhossz)
PROCget(TEXT VAR t, TEXT CONST végjel)
PROC put(TEXT CONST t)
BOOLOP=(TEXT CONST x, y)
BOOLOP<>(TEXT CONST x, y)
BOOLOP<(TEXT CONST x, y)
BOOLOP<=(TEXT CONST x, y)
BOOLOP>(TEXT CONST x, y)
BOOLOP>=(TEXT CONST x, y)
INTOPLENGTH(TEXT CONST t)
INTPROClength(TEXT CONST t)
TEXTOP+(TEXT CONST x, y)
OPCAT(TEXT VAR x, TEXT CONST y)
TEXTOP*(INT CONST n, TEXT CONST t)
TEXTPROCcompress(TEXT CONST t)
TEXTPROCtext(TEXT CONST t, INT CONST hossz)
TEXTPROCtext(TEXT CONST t, INT CONST hossz, kezdet)
TEXTPROCsubtext(TEXT CONST t, INT CONST kezdet)
TEXTPROCsubtext(TEXT CONST t, INT CONST kezdet, vég)
TEXTOPSUB(TEXT CONST t, INT OP i)
PROCreplace(TEXT VAR t, INT CONST kezd, TEXT CONST új)
PROCchange(TEXT VAR t, TEXT CONST régi, új)
PROCchange all(TEXT VAR t, TEXT CONST régi, új)
INTPROCpos(TEXT CONST t, sz)
INTPROCpos(TEXT CONST t, sz, INT CONST kezdet)
INTPROCpos(TEXT CONST t, sz, INT CONST kezdet, vég)
TEXTOPHEAD(TEXT CONST t)
TEXTOPTAIL(TEXT CONST t)
TEXTPROCascii(INT CONST kód)
TEXTPROCcode(INT CONST kód)
TEXTPROCdigit(INT CONST i)
TEXTPROCtext(INT CONST i)
TEXTPROCtext(INT CONST i, méret)
TEXTPROCtext(REAL CONST r)
TEXTPROCtext(REAL CONST r, INT CONST méret)
TEXTPROCtext(REAL CONST r, INT CONST méret, periódus)
LETniltext = ""
LETblank = " "
LETquote = """


5.3.4. Fájl (azaz: FILE) típusú adatok kezelésére használható elemi programegységek

TYPE FILE
TYPE TRANSPUTDIRECTION
Visszaadott eredmény típusaObjektum típusaObjektum neveFormális paraméterlista
FILEPROCsequential file(TRANSPUTDIRECTION CONST d, TEXT CONST azonosító)
TRANSPUTDIRECTIONPROCinput
TRANSPUTDIRECTIONPROCoutput
PROCclose(FILE CONST f)
PROCerase(FILE CONST f)
PROCline(FILE CONST f)
PROCline(FILE CONST f, INT CONST i)
PROCputline(FILE CONST f, TEXT CONST t)
PROCput(FILE CONST f, INT CONST i)
PROCput(FILE CONST f, REAL CONST r)
PROCput(FILE CONST f, TEXT CONST t)
PROCgetline(FILE CONST f, TEXT VAR t)
PROCget(FILE CONST f, INT VAR i)
PROCget(FILE CONST f, REAL VAR r)
PROCget(FILE CONST f, TEXT VAR t)
PROCget(FILE CONST f, TEXT VAR t, INT CONST hossz)
PROCget(FILE CONST f, TEXT VAR t, TEXT CONST vég)
INTPROCmax line length(FILE CONST f)
TEXTPROCname(FILE CONST f)
BOOLPROCopened(FILE CONST f)
BOOLPROCnew(FILE CONST f)
BOOLPROCeof(FILE CONST f)
PROCnew file(TEXT CONST név)
PROCold file(TEXT CONST név)
PROCclose file
PROCerase file(TEXT CONST név)
PROCwrite(INT CONST i)
PROCwrite(REAL CONST r)
PROCwrite(TEXT CONST t)
PROCwrite line
PROCread(INT VAR i)
PROCread(REAL VAR r)
PROCread(TEXT VAR t)
BOOLPROCfile ended


5.3.5. Logikai (azaz: BOOL) típusú adatok kezelésére használható elemi programegységek

TYPE BOOL

Visszaadott eredmény típusaObjektum típusaObjektum neveFormális paraméterlista
LETtrue = TRUE
LETfalse = FALSE
BOOLOPNOT(BOOL CONST b)
BOOLOPAND(BOOL CONST b1, b2)
BOOLOPOR(BOOL CONST b1, b2)
BOOLOP=(BOOL CONST b1, b2)
BOOLOP<>(BOOL CONST b1, b2)


5.3.6. Egyéb célokra használható elemi programegységek

Visszaadott eredmény típusaObjektum típusaObjektum neveFormális paraméterlista
PROCline
PROCline(INT CONST i)
PROCpage
PROCbeep
INTPROCxsize
INTPROCysize
PROCcursor(INT CONST x, y)
PROCget cursor(INT VAR x, y)
PROCedit(TEXT VAR t, INT CONST kezdő pozíció, balmargó, TEXT CONST vég)
PROCedit(TEXT VAR t, INT CONST kezdő pozíció, balmargó, jobbmargó, TEXT CONST vég, TEXT VAR c)
PROCinchar(TEXT VAR t)
TEXTPROCinchar
TEXTPROCincharety
INTPROCgraphics x limit
INTPROCgraphics y limit
REALPROCaspect
PROCenter graphics mode
PROCenter text mode
BOOLPROCin text mode
PROCcolor(INT CONST c)
PROCclear graphics screen
INTPROCcurrent x position
INTPROCcurrent y position
PROCmove(INT CONST x, y)
PROCdraw(INT CONST x, y)
PROCplot pixel
PROCplot text
INTPROCcharacter width
INTPROCline height
PROCinitialize random(INT CONST x)
PROCinitialize random(REAL CONST r)
INTPROCrandom(INT CONST a, b)
PROCrandom(INT VAR n)
REALPROCrandom
INTPROCchoose128
BOOLOPISNIL(NILTYPE CONST x)
BOOLPROCisnil(NILTYPE CONST x)
BOOLPROClast conversion ok
BOOLPROCyes(TEXT CONST kérdés)
BOOLPROCno(TEXT CONST kérdés)
INTPROCfreespace
INTPROCexectime
PROCsleep(INT CONST másodperc)
PROCtrace on
PROCstop
PROCassert(BOOL CONST b, TEXT CONST üzenet)
PROCassert(BOOL CONST b)