Az Algol68 programozási nyelv

Mode-ok



Mode-ok

Az Algol 68 erősen típusos nyelv. Típus szó helyett a nyelv inkább a mode szót használja. Számtalan lehetőség van arra, hogy a programozó saját mode-ot definiáljon a primitív mode-okat felhasználva. Objektumon a memóriában tárolt entitást értjük. Például: egy egész vagy valós. Minden objektumnak értéke van, és ezeket adjuk értékül a változóknak.

Primitív típusok

Ezen kívül megengedett a short és long módosítók használata az int, real, bits és bytes esetében. Például: ha egy gépi szó 32 bit, akkor short short int 8bit, short int 16bit, int 32bit, long int 64bit, long long int 96bit, long long long int 128bit.
A string típus egy nulla vagy ennél hosszabb karaktersorozatot definiál. A stringek tetszőleges hosszúak lehetnek és tetszőleges string változónak értékül adhatóak. A bits és byteas típussal lehetővé teszik, hogy a programozók memóriát spóroljanak. Implementációfüggő, hogy egy bits típusú objektum hány bites, általában egy gépi szó. Algol68-ban minden változót deklarálni kell. Minden programnak legalább egy utasítást kell tartalmaznia. Az üres utasítást a skip jelöli. Így a következő program szintaktikailag helyes.

begin int i,j; real x,y,z; bool l; skip; char c end

Tömbök (multiple value)

A tömbök deklarálásának jellemzője, hogy a méretét nem kötelező megadni. Tömbindex egész szám lehet. A tömbök nem statikusak, az indexhatárok változhatnak - a string típus valójában ilyen változó méretű tömb. A tömb határai nem részei a típusnak, azaz a tömb típusa, pl. [] int. A nyelv ismeri a több dimenziós tömböket is. Egy tömbbe csak azonos típusú elemek tartozhatnak bele. Van altömbképzés is, pl.:

begin [1:10] int vector; vector[1:4] := (1,2,3,4); end;

Példa tömbökre

[1:12] int month; [0:n-1,0:n-1] real matrix;

A tömb határai nem részei a típusnak, a vektor típusa: [] int, a matrix típusa [,] real. Egy tömb változó indexhatárral is rendelkezhet. A string változók valójában ilyen változó méretű tömbök.

Rekord típus (Structure)

Példa egy struktúra típusú változó deklarációjára:

struct (string név, int hány lábú, bool házi állat) állat;

A három szelektor: név, hány lábú és házi állat. A szelektorokra az of kulcsszóval lehet hivatkozni: név of állat := "csiga"; értéket adni ezen kívül a következő aggregált módon is lehet: állat:=("krokodil",4,false);

Eljárás típus

Az Algol 68-ban az eljárások is objektumok, amelyeknek értéke és típusa van. Továbbá vannak eljárás változók, amelyeknek eljárásokat lehet értékül adni. Az eljárás típusát a paramétereinek típusa határozza meg + az eljárás visszaadott értéke.A láthatóság és hatáskör fogalmai meglehetősen intuitívan működnek a Haskell esetében, azaz egy függvény változói a függvényre nézve lokálisak, hatáskörük kiterjed a belőlük hívott függvényekre, de a hívott függvényen belül nem láthatók. A függvények adta természetes szabályozás mellett a Haskellben van még két mechanizmus, amellyel a láthatóságot és hatáskört befolyásolni lehet. Ezek a let kifejezések és where klózok.

Például egy int paraméterű eljárás, amely real-t ad vissza proc (int) real típusú. Abban az esetben, ha egy eljárás nem ad vissza értéket, akkor void-ot ad vissza. Példa: egy olyan eljárás típusa, aminek nincs paramétere és void-ot ad vissza:proc void. Eljárás paramétere eljárás is lehet, egy valós függvény integrálját számító eljárás proc ( proc ( real ) real, real, real) real típusú.
Példa eljárás változókra:

begin real x; proc (real) real f; #f egy real paraméterű real-t visszaadó eljárás# f := sin; x := 3.14; print (f(x)); f := cos; print (f(x)) end

Ezt az implementáláskor valószínűleg pointerekkel oldják meg

Unió típus

Az Algol 68 uniójánál is érvényesül az erős típusosság. Az uniónak nincsenek szelektorai. Futási időben case szerkezet segítségével dönthetjük el, hogy mi a tényleges tartalom típusa és kaphatjuk meg a tartalmat egy megfelelő típusú változóban.
Példa uniók használatára:

begin union (int, real, bool, char, bits, bytes, [] int, [] real ) kitchen sink; # 4 helyes értékadás # kitchen sink := 3; kitchen sink := 3.14; kitchen sink := true; kitchen sink := "a"; # a random standard fv # if random < .5 then kitchen sink := 1 else kitchen sink := 2.78; fi; # mennyi volt a random? # case kitchen sink in (int i) : print(("integer",i)), (real r) : print(("real",r)) esac end

Hivatkozás (Reference-to) típus

Algol 68-ban egy int-nek deklarált változó típusa ref int. (reference to) Az értékadások esetén a baloldalnak konvertálhatónak kell lenni egy ref T típusú objektummá, a jobboldalnak pedig egy T típusúvá (erősen típusos pointerek). Az automatikus konverziókat kényszerítésnek (coercion) nevezik, ennek egy fajtája a dereferencing (egy ref T típusút T-vé alakít). Egy T típusú objektumra mutató pointert ref T-nek kell deklarálni (ebből lehet ref ref ref T is). Típus nélküli pointer nincs. Több pointer is mutathat ugyanoda.
Például:

begin ref int pt; int i, j; i := 0; j := 4; if random < .5 then pt := i else pt := j fi; int k := pt end

pt vagy i vagy j tárcímét fogja tartalmazni, míg k értéke 0 vagy 4 lesz.

Típusdeklaráció

Példa típusdeklarációkra:

mode tree = struct ( int value, ref tree right, left ); mode m1 = union ( int, real ); mode m2 = union ( real, int ); mode m3 = struct ( int i, real r ); mode m4 = struct ( int j, real r ); mode m5 = struct ( real r, int i );

Míg m1 és m2 azonos típust ír le addig m3, m4 és m5 mind különböző, mivel a szelektor is része a rekord típusának.

mode book = struct (string title, author, int pages, year, bool paperback); mode magazine = struct (string title, int subscribers, publ frequency); publisher, mode library = [1 : size] union (book, magazine);

Típusdeklaráció

A felhasználó által definiált típusok az ortogonalitásnak megfelelően ugyanúgy használhatók, mint a beépítettek. Említésre méltó a következő tömbökkel kapcsolatos szabály:

begin int n; n := 3; mode vector = [1:n] int; n := 25; vector x; # 25 hosszú lesz !!! # n := 75; vector y; # 75 hosszú lesz !!! # skip end

A változóknak kezdeti értéket is adhatunk deklaráláskor, tömböket és struktúrákat részben is inicializálhatunk a skip kulcsszóval. Az inicializálatlan elemeknek értéket kell adnunk, mielőtt kifejezésekben szerepelnek. Egy példa:

mode functionset = [1:3] proc (real) real; functionset trig := (sin,cos,skip);

Kényszerítés (automatikus típuskonverzió). Coercions.

Hat fajta automatikus módkonverzió van:

dereferencingref m -> m, pl.: int i,j; i:=1; j:=1; -ben a második értékadásnál
deproceduringproc m -> m, az eljáráshívás értékét adja értékül, azaz az eljáráshívásnak felel meg
wideningpl.: int -> real, real -> comp (ha értelmes)
rowingm -> [] m (pl.: [1:1] int a := 3; tömbösítés)
unitingm -> union(m,m1)
voidingm -> void, ez történik mindig, ha egy utasítássorozat értéke nem kell

Ezen kívül környezettől is függ, hogy ott milyen típuskonverzió megengedett. Erre öt erősséget vezettek be, és a környezeteket csoportokra osztották.