A PEARL programozási nyelv

Típusok, típuskonstrukciók

Típusszerkezet

A PEARL egy erősen típusos nyelv.

A nyelvben megtalálható típusok:

Elemi típusok:

Típuskonstrukciók:

Elemi típusok

Deklaráció(DECLARE/DCL) és specifikáció(SPECIFY/SPC)

A PEARL nyelvben változókat a DECLARE vagy röviden DCL után deklarálhatunk.

Egy switch nevű, bit sztring típusú (alapértelmezésben 1 hosszú) változó deklarációja:

DECLARE switch BIT;

Változó specifikáció a SPECIFY, vagy röviden SPC kulcsszó után lehetséges. pl.:

Egy status nevű, bit sztring típusú (16 karakter hosszú) globális változó specifikációja:

SPECIFY status BIT(16) GLOBAL;

Eltérő típusú változók deklarációját egymástól vesszővel elválasztva írhatjuk egymás után is:

DECLARE x FLOAT, i FIXED;

Több azonos típusú változót egymástól vesszővel elválasztva, zárójelben deklarálhatunk egyszerre:

DECLARE (x,y,z) FLOAT;

Egész számok (FIXED)

Egész számokat tízes és kettes számrendszerbeli reprezentációban lehet megadni. Bináris számok esetén 0-k és 1-ek sorozatát adjuk meg B-vel lezárva. pl:

Decimális
Bináris
6
110B
123
1111011B

Meg lehet adni továbbá a számok pontosságát a szám után zárójelben. pl.: 123(31) Amennyiben nem adjuk meg a pontosságot, akkor az adott típushoz a felhasználó által definiált alapértelmezett pontosságot (LENGTH definíció) fogja használni. Általában 15-öt vagy 31-et használnak egészek esetén.

 

DCL counter FIXED(31), (i,j,k) FIXED;
...
i := 2;

Lebegőpontos számok (FLOAT)

Valós számok a következők sorozataként adhatók meg:

1. Egy pont, egy egész szám, és lehetőség van exponens megadására. Az exponens E után írható. pl.:

Lebegőpontos szám
Érték
.123
0.123
.123E2
12.3
.123E-1
0.0123

2. Egy egész szám, és utána az 1. pontban adott sorozat. pl.:

Lebegőpontos szám
Érték
3.123E2
312.3

3. Egy egész szám, egy pont és utána esetlegesen exponens.

Lebegőpontos szám
Érték
3.
3.0

4. Egy egész szám, és egy exponens. pl.:

Lebegőpontos szám
Érték
3E-2
0.03

Az egész számokkal analóg módon a lebegőpontos számoknak is megadható a pontossága. Általában a 23-at vagy az 53-at használják.

DCL (x,y,z) FLOAT, Koeff FLOAT(53);
...
x:=3.5; y:=1; Koeff:=3.14E-10;

Bit sztringek (BIT)

A bit sztringeknek kettes(B1), négyes(B2), nyolcas(B3) és tizenhatos(B4) számrendszerbeli megadása is van.

Egy bit sztring aposztróffal kezdődik, ezt követi

majd még egy aposztróf, és a megfelelő Bi (i=1..4).

pl.: ’110010100111’B1 = ’302213’B2 = ’6247’B3 = ’CA7’B4

B1 helyett rövidebben B is írható.

DCL X_coord BIT(2), Y_coord BIT(8);
...
X_coord:= ’01’B;
Y_coord:= ’A9’B4;

Karakter sztringek (CHARACTER)

Karakter sztringeket aposztrófok között tudunk megadni. Ha a sztringben szeretnénk aposztrófot használni, akkor azt egymás utáni két aposztróf írásával tudjuk megtenni. (pl.: 'abc ''d') Kontrol karaktereket a sztringbe '\ és \' közé írhatunk.

DCL ArticleIdentificator CHAR(6);
...
ArticleIdentificator:=’BCD/27’;

A hossz megadása (LENGTH)

A hossz definíció azokra a számokra, és sztringekre vonatkozik, amelyeknek a pontosságát, illetve hosszát nem jelöltük (konstansoknál), vagy deklaráltuk (változóknál).

Az általános alak:

LENGTH FIXED(pontosság);

LENGTH FLOAT(pontosság);

LENGTH BIT(hossz);

LENGTH CHARACTER(hossz);

LENGTH CHAR(hossz);

PROBLEM;
LENGTH FIXED(15);
LENGTH FLOAT(53);
DCL A FIXED, /* A is of type FIXED(15) */
X FLOAT, /* X is of type FLOAT(53) */
Y FLOAT(23); /* Y is of type FLOAT(23) */
...

A hossz definíciójára ugyanazok a láthatósági feltételek érvényesek, mint a változó deklarációkra.

Idő (CLOCK)

Egy idő konstans

mindegyiket kettősponttal elválasztva.

Példák:

Időpont(CLOCK)
Megfelelője
11:30:00
11:30
15:45:3.5
15:45 és 3.5 másodperc
25:00:00
1:00

 

DCL time CLOCK;
...
time:=12:30:00;

Időtartam (DURATION/DUR)

Az időtartamot meg lehet adni órákban (HRS), percekben (MIN), és másodpercekben (SEC), vagy ezek tetszőleges kombinációjában.

Példák:

Időtartam
Jelentése
5 MIN 30 SEC
5 perc, 30 másodperc
.05 SEC
50 miliszekundum
5 HRS 10 SEC
5 óra 10 másodperc

Ezekben a konstansokban a számoknak nem adható meg a pontossága.

DCL delay DUR;
...
delay:=0.1 SEC;

Referenciák (REF)

Referenciáknak azonos típusú változók nevét adhatjuk értékül.

A mutatott változó értékét a CONT (content) operátor segítségével érhetjük el (dereferencia).

Példák:

DCL (k,l) FIXED,
x FLOAT,
(rk1,rk2) REF FIXED, /* egészre mutató referencia */
rx REF FLOAT; /* lebegőpontos számra mutató referencia */
rk1:=k; /* rk1 k-ra mutat */
rk1:=l; /* rk1 l-re mutat */
rk2:=rk1; /* rk2 l-re mutat */
rx:=x; /* rx x-re mutat */
rx:=k; /* hibás, nem egyezik a típus */
rx:=rk1; /* hibás, nem egyezik a típus */
l:=2;
k:=CONT rk1; /* k értéke 2 lesz */
rk2:=3; /* hibás, a 3 nem változó */
CONT rk2:=3; /* l értéke 3 lesz */
CONT rk2:=k; /* l értéke 2 lesz */

"k:=CONT rk1" helyett rövidebben írhatjuk, hogy "k:=rk1". Általánosan az értékadás jobb oldaláról a CONT elhagyható, a dereferencia itt automatikus.

Vegyünk egy R referenciát ami egy F tömbre, [S struktúrára] mutat, melynek az elemei [komponensei] F(i,j,k,...) [S.Ki], ekkor az F elemeire [S komponenseire] hivatkozhatunk egyszerűen R (i,j,k,...) [R.Ki] alakban, a CONT használata nélkül.

Továbbá automatikusan végrehajtódik még a dereferencia a következő esetekben:

Példa:

DCL rk REF FIXED, k FIXED;
...
rk:=k; k:=2;
k:=rk+1; /* k:=k+1;-vel ekvivalens*/

Referenciák értékének összehasonlítására az IS illetve az ISNT operátorok használhatók.

IS [ISNT] használatával az összehasonlítás végeredménye '1'B ['0'B] ha a két referencia értéke megegyezik [eltér], egyébként az eredmény '0'B ['1'B].

DCL NextOrder REF type_order;
...
IF NextOrder IS NIL THEN
...
FIN;

Interrupts (Megszakítások)

Egy Interrupt egy folyamat üzenete, amely megszakítás vezérlő megszakítás bemeneti során keresztül jelez az operációs rendszernek, és amely a megszakítás bekövetkezése után kezdeményezi a reakciót, amelyet a programozó tervezhet meg. Ilyen terv például az, hogy: „a Ready interrupt bekövetkezésekor indítsuk el a Supply taszkot”.

A számítógépes rendszer megszakítás-csatornáinak nevei benne vannak a rendszer felhasználói kézikönyvében. Az PEARL nyelvben az interrupt deklarációnál ezeket a neveket rendeljük hozzá az interrupthoz. A példában a Hard Int a megszakításcsatorna rendszerspecifikus neve. Példa:

MODULE; SYSTEM; Ready: Hard Int(7); PROBLEM; SPECIFY Ready INTERRUPT; ... Initialisation: TASK; ... WHEN Ready ACTIVATE Supply; ... END; ! Initialisation ... Supply: TASK PRIORITY 2; ! task body END; ! Supply ...

Amikor deklaráljuk az interruptokat, akkor még le vannak tiltva. Ha használni akarjuk, előbb engedélyezni kell őket az ENABLE kifejezéssel. Amennyiben egy engedélyezett interrupt hatását el kell fojtanunk, azaz a tőle függő taszknak nem szabadna elindulnia az interrupt azzal együtt sem, ha a megszakítás bekövetkezik, akkor a DISABLE kifejezést kell használnunk.

Valós idejű programok tesztelésénél néha szükséges, hogy szimuláljuk az interruptok hatását, kiváltképp, ha a folyamat még nem is csatlakozott a számítógéphez. Ezekhez a szimulációkhoz a TRIGGER kifejezés használható. Példa:

MODULE; SYSTEM; Ready: Soft Int; ... PROBLEM; ... ... WHEN Ready ACTIVATE Control; ... MODEND; MODULE(Test); PROBLEM; SPC Ready IRPT GLOBAL; … TRIGGER Ready; ... ... MODEND;

Signals (szignálok)

Bizonyos utasítások végrehajtásakor belső események, úgynevezett signalok következnek be, melyek a futó taszk leállítják. Ezek a szignálok bekövetkezhetnek olyan helyzetekben, mint a túlcsordulás bizonyos matematikai műveleteknél, nullával való osztás, vagy a fájl végének elérése. A program abortálása elkerülhető, ha hibakezelést alkalmazunk ilyen esetekben. Ehhez szükség van egy programra, amely a System részben van definiálva. Ebben a deklarációban rendelhetünk az eseményekhez általunk választott neveket. Ezen túl definiálhatunk egy hibalistát, amellyel limitálja a signal hatáskörét egy vagy több egyedi hibaszámra. Mielőtt használnánk a signalokat, azokat specifikálni kell a használati nevükkel a modul szint problem részében. A példában az IO_SIGNAL és az ENDF rendszer-specifikus nevek a felhasználói kézikönyvből, c_error_open pedig egy konstans:

MODULE; SYSTEM; OPEN ERR : IO SIGNAL (c error open); EOF : ENDF; ... PROBLEM; SPC ( OPEN ERR, EOF ) SIGNAL; ... MODEND;

A reakciót, amely a signal bekövetkezésekor van betervezve a következő módon iktathatjuk be a rendszerünkbe:

SchedulingSignalReaction ::= ON Name§Signal { [ RST ( Name§ErrorVariable-FIXED ) ] : SignalReaction | RST ( Name§ErrorVariable-FIXED ) }; ahol: SignalReaction ::= UnlabeledStatement

Az UnlabeledStatement helyett bármely másik Statement is írható, így blokkok, és metódushívások is. A SchedulingSignalReaction viszont nincs engedélyezve BEGIN, és REPEAT blokkokon belül. Ha a szintaxist a következőképpen használjuk:

ON Name§Signal RST ( Name§ErrorVariable-FIXED );

akkor a „beiktatást végző” taszk nem terminál, hanem folytatódik, miután a hibaváltozó hozzáfog a megfelelő signal kiváltásához. Ahhoz, hogy teszteljük a reakciót a hiba bekövetkezése nélkül, szimulálhatjuk a signal bekövetkezését hasonlóképpen, mint az interruptoknál. Ehhez az INDUCE kifejezésre van szükségünk:

InduceStatement ::= INDUCE Name§Signal [ RST ( Expression§ErrorNumber ) ];

Amíg az aszinkron módon fellépő szituációkra ( azaz a taszkon kívül fellépő szituációkra ) az interruptokkal van lehetőségünk reagálni, addig a signal kezelés kizárólag szinkron hibaállapotok kezelésére ad megoldást ( azaz olyan hibaállapotokra, amelyek abból a taszkból származnak, ahol a signal is van ).

Típuskonstrukciók

Tömbök

Azonos típusú skalár változókat n-dimenziós (n=1,2,3,4...) tömbökbe rendezhetünk.

Amikor egy tömböt deklarálunk akkor egy azonosítót adunk neki, és a benne tárolt elemeket ezen a néven, és a tömbön belüli pozíciószám (index) segítségével érhetjük el.

Az indexhatárokra csak annyi a megkötés, hogy a felső határ nagyobb, vagy egyenlő kell legyen mint az alsó. Negatív számok is lehetnek indexek, valamint az alsó indexhatár elhagyható, ebben az esetben 1-nek tekinthető.

n darab vessző a dimenziószám megadásában azt jelenti, hogy a tömb dimenziója n+1.

Példák:

A következő példában egy BIT(4) típusú elemeket tartalmazó, 3 elemű, 1-től 3-al indexelt tömböt vezetünk be, majd adunk neki értéket:

DCL switch on(1:3) BIT(4);
switch on(1):=’0001’B;
switch on(2):=’0010’B;
switch on(3):=’0100’B;

A következő deklaráció egy 2 dimenziós tömböt vezet be, ahol az első dimenziónál az 1 az alsó indexhatár és 2 a felső, azaz 2 hosszú, a második dimenziónál pedig az alsó indexhatár 0, a felső 3, tehát 4 hosszú:

DCL Koeff(1:2, 0:3) FIXED;

Az itt bevezetett Koeff tömb tehát 8 FIXED típusú elemet tartalmaz: Koeff(1,0) Koeff(1,1) Koeff(1,2) Koeff(1,3) Koeff(2,0) Koeff(2,1) Koeff(2,2) Koeff(2,3)

Struktúrák

Tömbök segítségével azonos típusú skalár változókat tudunk együtt kezelni. Amennyiben arra van szükségünk, hogy eltérő típusú komponensekből állítsunk össze adatstruktúrákat, akkor struktúrákat használunk.

Példa:

Egy TV csatornánál a híreket a szerkesztők számítógép segítségével szeretnék összeállítani. Hogy ezt megtehessék a következő adatokra van szükségük az egyes hírek kapcsán:

Egy ennek megfelelő adatstruktúrát definiál a következő példa:

DCL hir STRUCT
[ (azonosito_szam, archivalasi_szam) FIXED,
kozvetitett(3) BIT(1),
hossz DURATION,
eredeti_anyag BIT(1),
szoveg_hossza FIXED,
szoveg CHAR(200)
];

Struktúrákat “[” és “]” zárójelek zárják közre.

A struktúrák komponenseit a struktúra nevével, és a komponens nevével azonosítjuk:

hir.hossz := 47 SEC;

Struktúrák komponensei tömbök is lehetnek, ezek komponenseinek az elérése a szokásos módon történik:

IF hir.kozvetitett(i) THEN...FIN;

Struktúrák komponensei is lehetnek struktúrák, ilyenkor a belső struktúrák komponenseit az összes tartalmazó struktúra hierarchikusan való felsorolásával, mindegyiket ponttal elválasztva érhetjük el.

Típus definíció (TYPE)

Struktúra lehet paraméter, másik struktúra részstruktúrája, vagy adatállomás által továbbított adat típusa is. Minden ilyen alkalommal meg kell adni a struktúra típusát, és hogy ezt megkönnyítsük ezeket új adattípusként definiálhatjuk.

Példa:

PROBLEM;
...
TYPE Message STRUCT
[
(IdentNo, Archive) FIXED,
already broadcast(3) BIT(1),
(Start, End) FIXED,
OriginalSound BIT(1),
TextLength FIXED,
Text CHAR(200)
];
DCL Content_VTR DATION INOUT Message...;
Coord: TASK;
DCL Contribution Message;
...
READ Contribution FROM Content VTR;
...
END; ! Coord

Új adattípus definíciója még a használat előtt kell, hogy szerepeljen. A modul szinten definiált típusok a modul minden eljárásában és taszkjában használhatóak, a lokális definíciók hatóköre és láthatósága a blokkstruktúra függvénye.

A globális objektumokkal ellentétben ezek a típusok csak abban a modulban használhatók, ahol definiáltuk őket. Ennek következtében, ha általunk definiált típussal rendelkező globális változókat szeretnénk használni, akkor minden modulban újra meg kell adni a megfelelő típusdefiníciót.

Példa:

MODULE (ModuleA);
PROBLEM;
TYPE T STRUCT [...];
...
DCL x T GLOBAL;
...
MODEND;

MODULE (ModuleB);
PROBLEM;
TYPE T STRUCT [...];
...
SPC x T GLOBAL(ModuleA);
...
MODEND;

Kezdő értékadás (INITIAL/INIT)

Kezdeti értékadás (INIT) segítségével értéket adhatunk a változóinknak deklarációnál. Konstansok esetén értékadás csak így lehetséges. Az INIT a deklaráció utolsó megadható attribútuma.

A kezdeti értékadás típusának egyeznie kell a deklarált változó típusával.

Példa:

...
DCL number_devices FIXED INIT(12),
(UGR, OGR) FIXED INIT(2,15);
...
FOR i FROM 1 TO number_devices
...

A példában a number_devices, UGR, és OGR változók értéke 12, 2 és 15.

Tömböknek és struktúráknak is adhatunk értéket a deklarációnál. Struktúráknál minden komponensnek meg kell adni az értékét, de tömbök esetén az elemlista, amit megadunk lehet rövidebb, mint a tényleges tömbméret. Ebben az esetben a program a listában utoljára megadott értékkel tölti fel az üresen maradt helyeket.

Példa:

...
DCL Address STRUCT
[
PostNumber FIXED,
Town CHAR(20),
Street CHAR(20),
HouseNumber FIXED
]
INIT(21337, ’Lueneburg’, ’Erbstorfer Landstr.’, 14);
DCL colours (3) CHAR(7) INIT (’black ’, ’white ’, ’red ’);
DCL all_sixes (6) FIXED INIT (6);
...

Konstansok

Változókat deklarálhatunk INV attribútummal. Az INV attribútum jelentése invariáns, vagyis az így deklarált változó egy konstans. INV attribútummal deklarált változóknak való értékadás fordítási hibát okoz. A típus előtt kell megadni.

Példák:

1.

DCL Pi INV FLOAT INIT(3.141);
Pi := 3; ! fordítási hibát okoz

2.

...
P: PROC(A (,) INV FIXED IDENT, x FLOAT IDENT);
/* az eljaras torzse */
END; ! P
DCL Tab(10,20) FIXED,
Pi INV FLOAT INITIAL(3.141),
R1 REF FLOAT,
R2 REF INV FIXED;
...
SPC pi FLOAT IDENT (Pi); /* hibás */
...
CALL P (Tab, Pi); /* hibás */
R1:=Pi; /* hibás */
R2:=Tab(5,7);

A fenti példában pi változó specifikációja hibás, ugyanis pi-nek lehetne értéket adni a specifikáció alapján, de ezt nem lehetséges, mert a változó, amivel azonosítjuk, Pi konstans.

P hívása azért hibás, mert az x formális paraméter értéke változhat a függvény törzsében, de a neki megfeleltetett aktuális paraméter, Pi konstans és konstansok értékét megváltoztatni nem lehetséges. Az A paraméternek a Tab változó megfeleltetése viszont helyes.

Az R1:=Pi értékadás azért hibás, mert R1-en keresztül lehetséges lenne a konstans Pi-nek az értékadás, ami hibához vezetne.

Kifejezések

Kifejezések például a következők:

Általánosan a egy kifejezés a következő alakú lehet:

kifejezés ::= [egyváltozós_operátor] operandus [kétváltozós_operátor kifejezés]

A kifejezés operandusa

lehet.

Például: A, A(3), A(i,j,2*k), A.B, A.B.C, A(3).B.C(i,j)

Operátorok

Operátorok precedenciája

Operátorok precedenciája PEARL-ben
Rang Kétváltozós operátor Kiértékelési sorrend
1 **, FIT, LWB, UPB jobbról balra
2 *, /, ><, //, REM balról jobbra
3 +, -, <>, SHIFT balról jobbra
4 <, >, <=, >= balról jobbra
5 ==, /=, IS, ISNT balról jobbra
6 AND balról jobbra
7 OR, EXOR balról jobbra

Az egyváltozós standard operátorok precedenciája 1.

Egyváltozós operátorok

Egyváltozós operátorok a PEARL nyelvben a

vagy saját operátorok is lehetnek.

Egyváltozós operátorok numerikus, időtartam és bit értékekhez
Kifejezés
Operandus típusa Eredmény típusa Operátor jelentése
+ a FIXED(pontosság) FIXED(pontosság) identitás
FLOAT(pontosság) FLOAT(pontosság)
DURATION DURATION
- a FIXED(pontosság) FIXED(pontosság) előjelváltás
FLOAT(pontosság) FLOAT(pontosság)
DURATION DURATION
NOT a BIT(hossz) BIT(hossz) invertálás bitenként
ABS a FIXED(pontosság) FIXED(pontosság) abszolút érték
FLOAT(pontosság) FLOAT(pontosság)
DURATION DURATION
SIGN a FIXED(pontosság) FIXED(1)

a előjele:
1 ha a>0
0 ha a=0
-1 ha a<0

FLOAT(pontosság)
DURATION

Egyváltozós operátorok explicit típuskonverzióhoz
Kifejezés
Operandus típusa Eredmény típusa Operátor jelentése
TOFIXED a CHARACTER(1) FIXED(7) karakter ASCII kódja
BIT(hossz) FIXED(pontosság) bit sztring konvertálása egészre, ahol hossz=pontosság
TOFLOAT a FIXED(pontosság) FLOAT(pontosság) a konvertálása lebegőpontos számmá
TOBIT a FIXED(pontosság) BIT(hossz) egész szám konvertálása bit sztringgé, ahol hossz=pontosság
TOCHAR a FIXED CHARACTER(1) a-nak megfelelő ASCII kódú karakter
ENTIER a FLOAT(pontosság) FIXED(pontosság) a legnagyobb, a-nál kisebb, vagy egyenlő egész; alsó egészrész
ROUND a FLOAT(pontosság) FIXED(pontosság) a-nál nagyobb, legkisebb egész; felső egészrész
CONT a REF típus típus explicit dereferencia

Egyváltozós aritmetikai operátorok
Kifejezés
Operandus típusa Eredmény típusa Operátor jelentése
SQRT a

FIXED(pontosság) vagy FLOAT(pontosság)

FLOAT(pontosság) gyök
SIN a szinusza
COS a koszinusza
EXP a e^a, ahol e=2.718281828459
LN a természetes alapú logaritmus
TAN a tangens
ATAN a arkusztangens
TANH a tangens hiperbolikusz

További egyváltozós operátorok
Kifejezés
Operandus típusa Eredmény típusa Operátor jelentése
LWB a tömb FIXED(31) a tömb első dimenziójának alsó indexhatára
UPB a tömb FIXED(31) a tömb első dimenziójának felső indexhatára
CHARACTER(hossz) FIXED(15) a karakter sztring hossza
SIZEOF a azonosító FIXED(31) a lefoglalt memóriaterület mérete futási időben (byte)
elemi típus
SIZEOF a MAX REF CHAR( ) FIXED(31) a referencia által mutatott karakter sztring maximális hossza
SIZEOF a LENGTH REF CHAR( ) FIXED(31) a referencia által mutatott karakter sztring aktuális hossza
TRY a SEMA BIT(1) szemaforral védett erőforrás szabad-e; ’1’B
az eredmény, ha szabad

Kétváltozós operátorok

Kétváltozós operátorok a nyelvben a

vagy saját operátorok lehetnek.

Kétváltozós operátorok numerikus értékekhez, valmint időhöz és időtartamhoz
Kifejezés 1. operandus típusa 2. operandus típusa Eredmény típusa Operátor jelentése
op1 + op2
FIXED(g1) FIXED(g2) FIXED(g3)

összeadás, ahol g3=max (g1, g2)

FIXED(g1) FLOAT(g2) FLOAT(g3)
FLOAT(g1) FIXED(g2) FLOAT(g3)
FLOAT(g1) FLOAT(g2) FLOAT(g3)
DURATION DURATION DURATION
DURATION CLOCK CLOCK
CLOCK DURATION CLOCK
op1 - op2
FIXED(g1) FIXED(g2) FIXED(g3)

kivonás, ahol g3=max (g1, g2)

FIXED(g1) FLOAT(g2) FLOAT(g3)
FLOAT(g1) FIXED(g2) FLOAT(g3)
FLOAT(g1) FLOAT(g2) FLOAT(g3)
DURATION DURATION DURATION
CLOCK DURATION CLOCK
CLOCK CLOCK DURATION
op1 * op2
FIXED(g1) FIXED(g2) FIXED(g3)

szorzás, ahol g3=max (g1, g2)

FIXED(g1) FLOAT(g2) FLOAT(g3)
FLOAT(g1) FIXED(g2) FLOAT(g3)
FLOAT(g1) FLOAT(g2) FLOAT(g3)
FIXED(g1) DURATION DURATION
DURATION FIXED(g2) DURATION
FLOAT(g1) DURATION CLOCK
DURATION FLOAT(g2) DURATION
op1 / op2
FIXED(g1) FIXED(g2) FLOAT(g3)

osztás, ha op2 nem 0, ahol g3=max (g1, g2) és g4=31 (implementációfüggő)

FLOAT(g1) FIXED(g2) FLOAT(g3)
FIXED(g1) FLOAT(g2) FLOAT(g3)
FLOAT(g1) FLOAT(g2) FLOAT(g3)
DURATION FIXED(g2) DURATION
DURATION FLOAT(g2) DURATION
DURATION DURATION FLOAT(g4)
op1 // op2 FIXED(g1) FIXED(g2) FIXED(g3) egész osztás, ahol g3=max (g1, g2)
op1 REM op2 FIXED(g1) FIXED(g2) FIXED(g3) osztási maradék
op1 ** op2 FIXED(g1) FIXED(g2) FIXED(g1) hatványozás
FLOAT(g1) FIXED(g2) FLOAT(g1)
op1 FIT op2 FIXED(g1) FIXED(g2) FIXED(g2) op1 pontosságát op2 pontosságára állítja át
FLOAT(g1) FLOAT(g2) FLOAT(g2)

Kétváltozós operátorok összehasonlításhoz
Kifejezés 1. operandus típusa 2. operandus típusa Eredmény típusa Operátor jelentése
op1 < op2
op1 LT op2
FIXED(g1) FIXED(g2) BIT(1)

ha op1 kisebb, mint op2 akkor az eredmény '1'B, egyébként '0'B

FIXED(g1) FLOAT(g2)
FLOAT(g1) FIXED(g2)
FLOAT(g1) FLOAT(g2)
CLOCK CLOCK
DURATION DURATION
CHAR(lg1) CHAR(lg2) karakter sztingek összehasonlítása
op1 > op2
op1 GT op2
mint op1<op2 esetén mint op1<op2 esetén BIT(1) ha op1 nagyobb, mint op2 akkor az eredmény '1'B, egyébként '0'B
op1 <= op2
op1 LE op2
mint op1<op2 esetén mint op1<op2 esetén BIT(1) ha op1 kisebb, vagy egyenlő mint op2 akkor az eredmény '1'B, egyébként '0'B
op1 >= op2
op1 GE op2
mint op1<op2 esetén mint op1<op2 esetén BIT(1) ha op1 nagyobb, vagy egyenlő mint op2 akkor az eredmény '1'B, egyébként '0'B
op1 == op2
op1 EQ op2
FIXED(g1) FIXED(g2) BIT(1)

ha op1 egyenlő op2-vel, akkor az eredmény '1'B, egyébként '0'B
ha lg1 nem egyenlő lg2-vel, akkor a rövidebb karakter sztring esetén szóközökkel, bit szting esetén 0-kkal kiegészítve kerül összehasonlításra a másikkal.

FIXED(g1) FLOAT(g2)
FLOAT(g1) FIXED(g2)
FLOAT(g1) FLOAT(g2)
CLOCK CLOCK
DURATION DURATION
CHAR(lg1) CHAR(lg2)
BIT(lg1) BIT(lg2)
op1 /= op2
op1 NE op2
mint op1<op2 esetén mint op1<op2 esetén BIT(1) ha op1 nem egyenlő op2-vel, akkor az eredmény '1'B, egyébként '0'B
ha lg1 nem egyenlő lg2-vel, akkor a rövidebb karakter sztring esetén szóközökkel, bit szting esetén 0-kkal kiegészítve kerül összehasonlításra a másikkal.
op1 IS op2 REF type REF type BIT(1) referenciák összehasonlítása; '1'B az eredmény, ha ugyanarra mutatnak
op1 ISNT op2 REF type REF type BIT(1) referenciák összehasonlítása; '1'B az eredmény, ha nem ugyanarra mutatnak

Kétváltozós logikai operátorok, és eltolás
Kifejezés 1. operandus típusa 2. operandus típusa Eredmény típusa Operátor jelentése
op1 AND op2 BIT(lg1) BIT(lg2) BIT(lg3) logikai és, vagy illetve xor művelet, ahol lg3=max(lg1,lg2)
a rövidebb operandust nullákkal egészíti ki, hogy egyenlő hosszúak legyenek a művelet elvégzéséhez
op1 OR op2 BIT(lg1) BIT(lg2) BIT(lg3)
op1 EXOR op2 BIT(lg1) BIT(lg2) BIT(lg3)
op1 <> op2
op1 CSHIFT op2
BIT(lg) FIXED(g) BIT(lg) ciklikus eltolás;
op1-et tolja el op2 pozícióval, amennyiben op2>0 balra, egyébként jobbra
op1 SHIFT op2 BIT(lg) FIXED(g) BIT(lg) eltolás;
op1-et tolja el op2 pozícióval, amennyiben op2>0 balra, egyébként jobbra, a fennmaradó helyekre nullák kerülnek

Kétváltozós sztring operátorok
Kifejezés 1. operandus típusa 2. operandus típusa Eredmény típusa Operátor jelentése
op1 >< op2
op1 CAT op2
CHAR(lg1) CHAR(lg2) CHAR(lg3) konkatenáció
lg3 = lg1 + lg2
BIT(lg1) BIT(lg2) BIT(lg3)

Egyéb kétváltozós operátorok
Kifejezés 1. operandus típusa 2. operandus típusa Eredmény típusa Operátor jelentése
op1 LWB op2 FIXED(g) tömb FIXED(31) az op2 tömb op1. dimenziójának alsó indexhatára, amennyiben létezik
op1 UPB op2 FIXED(g) tömb FIXED(31) az op2 tömb op1. dimenziójának felső indexhatára, amennyiben létezik

Operátor definíció (OPERATOR)

PEARL-ben lehetséges új operátorok definiálása, és a standard operátorok felüldefiniálása is, a következő formában:

OPERATOR operator_nev ( [ parameter1 , ] parameter2 )
RETURNS (eredmeny_tipusa);
...
END;

Az operátor neve lehet szabadon választott azonosító, vagy +, −, *, **, /, //, ==, / =, <=, >=, <, >,<>, >< valamelyike.

Példa:

A standard + operátort definiálhatjuk komplexekre is:

PROBLEM;

TYPE Complex STRUCT
[
Real FLOAT,
Imag FLOAT
];

OPERATOR + (A Complex IDENT, B Complex IDENT) RETURNS (Complex):
DCL Sum Complex;
Sum.Real := A.Real + B.Real;
Sum.Imag := A.Imag + B.Imag;
RETURN (Sum);
END; ! Operator +

DCL (XX, YY, ZZ) Complex,
(X, Y, Z) FLOAT;
...
ZZ := XX + YY;
Z := X + Y;
...

Ahogy a példa is mutatja, lehetséges több operátort ugyanazzal a névvel létrehozni, amennyiben az operandusok típusa eltérő.

Kifejezések kiértékelésénél, amikben ilyen operátorok előfordulnak, mindig azt az operátort alkalmazza, aminek az operandusainak típusa megegyezik a kifejezésben adottakkal.

Amikor standard operátorokat terjesztünk ki, akkor az új operátor precedenciája megegyezik az eredeti operátor precedenciájával. Ha új operátornevet vezetünk be, akkor az ilyen operátoroknak 1 és 7 közötti rang adható meg, a következő formában:

PRECEDENCE operator_nev ( 1/2/3/4/5/6/7 );

Hogyha akarunk precedenciát megadni az operátornak, akkor azt a definíciója előtt tehetjük meg. Amenniyben ezt elhagyjuk, az új operátor precedenciája az alapértelmezett 7 lesz.

Példa:

PRECEDENCE INDEX(1);
OPERATOR INDEX...;