• Kezdő oldal
• Bevezetés
  • A PEARL általános jellemzői
  • Párhuzamosság
  • Lehetséges input és output
  • Program struktúra
  • Adattípusok
  • Vezérlési szerkezetek
• Nyelvi elemek
  • Jelkészlet
  • Azonosítók
  • Megjegyzések
• Típusok, típuskonstrukciók
  • Típusszerkezet
  • Elemi típusok
  • Deklaráció(DECLARE/DCL) és specifikáció(SPECIFY/SPC)
  • Egész számok (FIXED)
  • Lebegőpontos számok (FLOAT)
  • Bit sztringek (BIT)
  • Karakter sztringek (CHARACTER)
  • A hossz megadása (LENGTH)
  • Idő (CLOCK)
  • Időtartam (DURATION/DUR)
  • Referenciák (REF)
  • Interrupts (Megszakítások)
  • Signals (Szignálok)
  • Típuskonstrukciók
  • Tömbök
  • Struktúrák
  • Típus definíció (TYPE)
  • Kezdő értékadás (INITIAL/INIT)
  • Konstansok
  • Kifejezések
  • Operátorok
  • Operátorok precedenciája
  • Egyváltozós operátorok
  • Kétváltozós operátorok
  • Operátor definíció (OPERATOR)
• Utasítások, vezérlési szerkezetek
  • Elágazás(IF)
  • Többszörös esetszétválasztás(CASE)
  • Ciklus
  • Feltétel nélküli vezérlésátadás(GOTO)
  • Az EXIT utasítás
  • A PUT, és a GET utasítás
• Alprogramok, modulok
  • Programok felépítése
  • Modulok
  • Deklaráció és specifikáció
  • Blokkstruktúra, élettartam
  • Modulok közötti hivatkozások
  • Program végrehajtása
  • Eljárások
  • Eljárások(PROC) deklarációja és specifikációja
  • Eljárás hívás(CALL)
  • Referenciák eljárásokra(REF PROC)
• Absztrakt adattípusok
• Kivételkezelés
• Objektum-orientált programozás
• Helyesség
• Párhuzamosság
  • Bevezetés
  • Taszk deklaráció és specifikáció
  • Taszkok kezelése
  • Taszkok szinkronizálása
• Szabványos könyvtárak
• Fordítók
• További információk
  • Linkek
• Példaprogramok
• Készítők
  • Készítők neve, e-mailje
  • Aktuális felelős neve, e-mailje

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:

• FIXED megadható pontossággal
• FLOAT megadható pontossággal
• BIT sztring
• CHARACTER szting
• CLOCK (idő)
• DURATION (időtartam)
• DATION (eszközök és fájlok)
• INTERRUPT (megszakítások)
• SIGNAL (szignálok)
• SEMA (szemaforok)
• BOLT
• REF (referenciák)

Típuskonstrukciók:

• Tömb
• Struktúra

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:

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.:

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

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

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

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

• B1 esetén 0,1 számjegyek sorozata,
• B2 esetén 0..3 számjegyek sorozata,
• B3 esetén 0..7 számjegyek sorozata,
• és B4 esetén 0..9 számjegyek és A..F betűk sorozata,

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

• egy pozitív egészből, ami az órát adja (az értéke mod 24 értendő),
• egy 0..59 egész számból ami a percet, és
• egy 0 és 59.999... közötti lebegőpontos számból áll, ami a másodpercnek felel meg,

mindegyiket kettősponttal elválasztva.

Példák:

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:

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:

• Ha a referencia egy függvényhívás aktuális paramétere, és a formális paraméter nem referencia.
• Ha kétváltozós operátor operandusa, és az operátor nem referenciákra van definiálva (pl IS)

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:

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:

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:

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

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:

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:

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 címke, ami a hírt beazonosítja
• archiválási szám
• feljegyzés arról, hogy az aznapi 1. 2. vagy 3. híradóban már adták-e a hírt
• a hír hossza
• van-e eredeti audió/videó anyag a hír kapcsán
• szöveg hossza, amennyiben van
• szöveg, ha van

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:

• -A + B * C - D/E**2
• (A - B) / (A + B)
• F(Tab(K, 2*i)) / (F(i) - 3)
• A < B OR A < C
• ProcessImage_new AND NOT ProcessImage_old
• Xcoord >< Ycoord >< Zcoord - (három bit sztring konkatenációja)

Á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

• konstans, név , függvény hívás, feltételes kifejezés, dereferencia, sztring, vagy (kifejezés)

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

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

Egyváltozós operátorok

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

• + , -, NOT, ABS, SIGN, LWB, UPB, SIZEOF, CONT, TOFIXED, TOFLOAT,TOBIT, TOCHAR, ENTIER, ROUND, ...

vagy saját operátorok is lehetnek.

Kétváltozós operátorok

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

• +, -, *, /, //, REM, **, <, LT, >, GT,<=, LE, >=, GE, ==, EQ, /=, NE, AND, OR, EXOR, ><, CAT, <>, CSHIFT, SHIFT, LWB, UPB, IS, ISNT, FIT,

vagy saját operátorok lehetnek.

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...;

Powered by PHP and XML
Valid XHTML and CSS
Copgyright © 2010 - ELTE IK, Programozási Nyelvek és Fordítóprogramok Tanszék