A PAWN programozási nyelv

Vezérlési szerkezetek, operátorok, függvények

Vezérlési szerkezetek

Mivel a nyelv C alapú szintaxissal rendelkezik, így az abban megszokott módon kell a vezérlési szerkezeteket használni.

// Elágazás if ( expression ) statement_1 else statement_2 // vagy if ( expression_1 ) statement_1 [else if ( expression_2 ) statement_2] .. [else if ( expression_n ) statement_n] [else statement_else]
// Elöl tesztelő ciklus while ( expression ) statement // Hátul tesztelő ciklus do statement while ( expression )
// for ciklus for ( expression_1 ; expression_2 ; expression_3 ) statement
// szelekció switch ( expression ) { case list }

További infó

Operátorok

Operátorokban sem szégyenkezhet a nyelv, nagyon sokat örökölt a SmallCből.

Függvényhívás, tömbindexelés

()Függvényhívás
[]Tömb elemére hivatkozás (cella)
{}Tömb elemére hivatkozás (karakter)

Unerási operátorok

!logikai tagadás
~egyes komplemens
-kettes komplemens (negálás)
++inkrementálás
--csökkentés
:tag definiálás
definedszimbólum definiált státuszának lekérése
sizeofszimbólum mérete elemszámban
stateállapot beállítása
tagoftag egyedi azonosítója

Matematikai operátorok

*szorzás
/osztás
%maradékosztás
+összeadás
-kivonás

Bitmanipulátorok

>>aritmetikai eltolás jobbra
>>>logikai eltolás right
<<shift left
&bitenkénti és
^bitenkénti kizáró vagy
|bitenkénti vagy

Logikai operátorok

<smaller than
<=smaller than or equal to
>greater than
>=greater than or equal to
==equality
!=inequality
&&logical and
||logical or
? :conditional
=smaller than
<=smaller than or equal to
>greater than
>=greater than or equal to
==equality
!=inequality
&&logical and
||logical or
? :conditional

Értékadások

Függvények

A nyelvben nincsenek eljárás, csak függvény, amiknek nem kötelező visszatérési értéket megadni. (tehát generálhatunk eljárásokat is, hasonlóan, mint JavaScriptben)

// Szintaxis név (paraméter1, paraméter2, ... ) { } név (paraméter1, paraméter2, ... ); // előre deklarált függvény

A függvényhívások paramétereit átadhatjuk érték szerint, vagy cím szerint. Ez azért érdekes, mert csak itt használható a Cben használt referencia jel.

// pl: swap(&a, &b) { new temp = b b = a a = temp }

Függvények hívása hasonlóan történik mint C/C++ban. Érdekesség viszont az, hogy ha nem kell a visszatérési érték, a zárójelek és vesszők elhagyhatóak. Továbbá a paraméterek lehetnek nevesített paraméterek és pozícionált paraméterek. Nevesített paraméter esetén nem kell a megadott sorrendben felírni a paramétereket, csupán a híváskor megadni az értékeket.

weekday(month, day, year) { if (month <= 2) month += 12, --year new j = year % 100 new e = year / 100 return (day + (month+1)*26/10 + j + j/4 + e/4 - 2*e) % 7 } // Így használhatjuk: new wkday1 = weekday( .month = 12, .day = 31, .year = 1999) new wkday2 = weekday( .day = 31, .month = 12, .year = 1999) new wkday3 = weekday( .year = 1999, .month = 12, .day = 31)

A függvények paraméterei rendelkezhetnek alapértelmezett konstans értékekkel. Ekkor a függvény hívásakor ezen értékek megfadása nem kötelező. Ha az alapértelmezett értéket kívánjuk használni egy paraméternél, akkor a _ karaktert használjuk.

increment(&value, incr=1) value += incr // Így használható increment(a) increment(a, _) increment(a, 1) // pl2 divmod(a, b, &quotient=0, &remainder=0) { quotient = a / b remainder = a % b } // Így használható new p, q divmod(10, 3, p, q) divmod(10, 3, p, _) divmod(10, 3, _, q) divmod(10, 3, p) divmod 10, 3, p, q

A függvények alapértelmezett értékeinél egy esetben megadhatunk nem konstans, azaz dinamikusan változó értéket. Ehez kell a sizeof operátor. Tömbök esetén használható, segítségével átadhatjuk egy tömb méretét. Ekkor a függvény hívásakor fog kiértékelődni az alapértelmezett érték, így minden híváskor más def érték keletkezik.

F(Tomb[], Meret = sizeof Tomb);

Az argumentumok taggelhetőek, növeli a fordítási időben a hibakeresést. A Javascripthez hasonlóan lehetőség van változó mennyiségű változó átadása egy függvénynek. Ehhez a ... argumentumot kell megadni, s a függvényben a getarg setarg parancsokkal lekérhetjük, módosíthatjuk az argumentumokat.

sum(...) { new result = 0 for (new i = 0; i < numargs(); ++i) result += getarg(i) return result }

A függvények létrehozásakor elűáthatjuk további típusjelzőkkel az alábbiak közül: pubic, static, native, stock

Public

Alapértelmezetten minden önálló programnak kell rendelkeznie egy main függvénnyel, vagy egy másik, publikus függvénnyel. Ezeket belépési pontnak nevezhetjük, hiszen hívhatóak az absztrakt gépen keresztül. (Tehát a maint el is hagyhatjuk, amennyiben rendelkezünk másik publikus belépési ponttal. (pl onkey)) Ilyen függvény létrehozásához elegendő a public kulcsszót használni (vagy a @ jelet)

Stock

Hasonló, mint a változóknál: célja a kód optimalizálása, és a memóriaigény csökkentése Ebből adódóan a native és public függvényeket nem lehet stock tulajdonsággal ellátni.

Native

Ezen keresztül hívhatóak, az alkalmazás specifikus függvények. A native kulcsszóval kell deklarálni a függvényt.

native getparam(a[], b[], size) native multiply_matrix(a[], b[], size) native openfile(const name[])

A függvény nevek belső nevek, amiket a PAWN lát. Megadható egy külső név is, ami a host alkalmazás számára érhető el, ezeket "értékadással" kell a prototípus után írni. Fontos, hogy native függvényeknek nem lehet state tulajdonságokat beállítani. (Ezt később taglaljuk)

native getparam(a[], b[], size) = host_getparam native multiply_matrix(a[], b[], size) = mtx_mul

A felhasználóknak lehetőségük van operátorokat túlterhelni. Csak a meglévő operátork egy részét lehet csak túlterhelni, méghozzá saját tagekkel. Pár megkötés:

// pl alpha: operator+(alpha: a, alpha: b) // vagy beta: operator+(alpha: a, alpha: b)

Forward deklarációk

A C(++)szal ellentétben nem szükséges előre deklarálni a függvényeket, viszont felhasználó által definiált operátorok esetén ez már nem elhanyagolható, ezt jelezni kell előre. Ehhez egy új kulcsszót vezzettek be: forward Ezek lehetnek nativeok vagy stockok függvények is. (native esetén meg kell adnni a host program fgnevét is!)

forward Float: operator%(Float: a, Float: b) native Float: operator+(Float: val, Float: val) = float_add // példa az értékadás operátorra: ones: operator=(a) return ones: ( (a >= 0) ? a : ~(-a) )