- Normoj pri Ada
- Leksiko de Ada
- La aranĝo de programo en Ada
- Duoniga serĉo en Ada
- Enkapsuligo kaj
abstraktaj datumtipoj
- racionoj: Ekzemplo pri enkapsuligo kaj abstrakta
datumtipo en Ada
- Paralelado en Ada
- Esceptoj
Ada havas internacian normon (ISO 8652), kaj en la mondo ekzistas pli ol 450
tradukiloj por diversaj komputiloj, kies
konformeco al la normo estas oficiale atestita. En Usono Ada estas norma
lingvo por programado en militaj aplikoj (la normo ISO/IEC
8652:1995(E)). Krome, Ada estas uzata en instruado kiel baza
programlingvo aŭ por ilustri kelkajn konceptojn mankantajn en Paskalo —
ekz-e deksesuma nombrosistemo,
escepto, genera programpeco, laŭbita operacio, pasigo per valorrezulto, rendevuo, revenordono, ŝlosilvorta parametro k.a. (vd
sube).
La normoj tre rigore difinas la eksteran prezenton de la programoj en Ada. La lingvo estas
usklecoblinda, kaj ni uzas ĉefliterojn por neformale apartigi la apriorajn nomojn. La ŝlosilvortoj en Ada estas tre multenombraj
kaj rezervitaj (ni ilin substrekas). Komenton
komencas du apudaj minusoj -- kaj
fermas la sekva linifino (kiel en programpeco
racionoj).
Kompleta programo en Ada estas bindata el bibliotekaj pecoj (angle library
unit) anticipe tradukitaj. La lingvo kaj ĝiaj tradukaj rimedoj provizas
la kontrolon, ĉu la interfacoj de la pecoj
koheras. Se ene de iu biblioteka peco oni bezonas atingi objektojn de aliaj
pecoj, la nomoj de tiuj aliaj pecoj estas listigendaj en speciala
kunteksta sekcio (angle context clause), kiel montras
ekzemplo (Duoniga serĉo en Ada).
--------- Unua biblioteka peco: ---------
PACKAGE tabeloj IS --------- interfaca pakaĵo:
TYPE sxlosilo IS NEW INTEGER;
TYPE ano IS RECORD
sxlo: sxlosilo; valoro: STRING(1..20);
END RECORD;
TYPE vektoro IS ARRAY (POSITIVE RANGE <›) OF sxlosilo;
sercxoeraro: EXCEPTION;
END tabeloj;
--------- Dua biblioteka peco: ---------
WITH tabeloj; -- la "kunteksta sekcio" ebliganta atingi "tabeloj"n
USE tabeloj; -- de ĉi tie la objektoj de "tabeloj" uzeblas senprefikse
FUNCTION sercxo(v: vektoro; sx: sxlosilo) RETURN POSITIVE;
sube, meze, supre: POSITIVE; -- lokaj variabloj
sx_m: sxlosilo;
BEGIN sube := v'FIRST; supre := v'LAST; -- la indiclimoj de v
WHILE sube <= supre LOOP
meze := (sube + supre) / 2;
sx_m := v(meze).sxlo;
IF sx = sx_m THEN RETURN meze; -- la bona elirejo
ELSIF sx < sx_m THEN supre := meze - 1;
ELSE sube := meze + 1;
END IF;
END LOOP;
RAISE sercxoeraro; -- escepta elirejo (kun esceptosignalo)
END sercxo;
Pakaĵa tradukpeco povas enkapsuligi ne nur datumojn (kiel estas en la Duoniga serĉo en Ada), sed ankaŭ
agojn (procedurojn). En tia okazo krom la
interfaca pakaĵo (analogia al la difina
modulo de MODULA) oni registras en la
biblioteko ankaŭ la respondan pakaĵkorpon (analogian al la realiga modulo de MODULA). Tiel en ekzempla
programo (racionoj) la interfaca pakaĵo specifas la
racionojn preskaŭ kiel abstraktan datumtipon, dum la
pakaĵkorpo difinas konkretan realigon de la
operacioj.
PACKAGE racionoj IS --------- la interfaca "difina" pakaĵo
TYPE raciona IS RECORD
supro: INTEGER; subo: POSITIVE; -- numeratoro kaj denominatoro
END RECORD;
FUNCTION egalas(x,y: raciona) RETURN BOOLEAN; -- ekz-e 1/2=2/4
FUNCTION "/"(x,y: INTEGER) RETURN raciona; -- racionkonstruilo
FUNCTION "+"(x,y: raciona) RETURN raciona; -- raciona adicio
FUNCTION "-"(x,y: raciona) RETURN raciona; -- raciona subtraho
FUNCTION "*"(x,y: raciona) RETURN raciona; -- raciona multipliko
FUNCTION "/"(x,y: raciona) RETURN raciona; -- raciona divido
END racionoj; -- la interfaca pakaĵo finiĝis
PACKAGE BODY racionoj IS --------- la realigo (pakaĵkorpo)
PROCEDURE samonigu(x, y: IN OUT raciona) IS -- kaŝitaĵo
xx: raciona; -- loka variablo
BEGIN IF x.subo = y.subo THEN RETURN; END IF;
xx := x;
x.subo := x.subo * y.subo;
x.supro := x.supro * y.subo;
y.subo := y.subo * xx.subo;
y.supro := y.supro * xx.subo;
END samonigu;
FUNCTION egalas(x, y: raciona) RETURN BOOLEAN;
u:raciona:=x; v:raciona:=y; -- lokaj variabloj, komencvalorizo
BEGIN samonigu(u,v); RETURN u.supro = v.supro;
END egalas;
FUNCTION "/"(x, y: INTEGER) RETURN raciona IS
BEGIN IF y›0 THEN RETURN (x,y); END IF; -- pozicia racionindiko
RETURN (supro=›-x, subo=›-y); -- ŝlosila racionindiko
END "/";
FUNCTION "+"(x, y: raciona) RETURN raciona IS
u: raciona := x; v: raciona := y;
BEGIN samonigu(u,v); RETURN (u.supro + v.supro, u.subo);
END "+";
FUNCTION "-"(x, y: raciona) RETURN raciona IS
u: raciona := x; v: raciona := y;
BEGIN samonigu(u,v); RETURN (u.supro - v.supro, v.subo);
END "-";
FUNCTION "*"(x, y: raciona) RETURN raciona IS
BEGIN RETURN (x.supro * y.supro, x.subo * y.subo);
END "*";
FUNCTION "/"(x, y: raciona) RETURN raciona IS
BEGIN RETURN (x.supro * y.sube, x.subo * y.supro);
END "/";
END racionoj;
Ada disponigas rimedojn por paralelado: oni
povas deklari programpecon tasko; interago kaj sinkronigo de la taskoj (t.e. de la de ili
priskribataj procezoj) estas farata per rendevuoj. Ekzemplo pri plurtaskado estas problemo pri la
mortemaj manĝantaj filozofoj (la programo: La 5 filozofoj).
Komparu esceptotraktadon en Paskalo kaj Ada. La ekzemploj uzas nomojn serĉo, fiasko;
tabeloj, sercxoeraro el funkcioj realigantaj duonigan serĉon en Paskalo (Duoniga serĉo en Paskalo)
kaj Ada (Duoniga serĉo en Ada).
MARKO 666; {mishalto} | WITH INTEGER_IO, tabeloj;
VAR n, x, ind: entjera; | USE INTEGER_IO, tabeloj; -- ktp ...
|
{............................} | -------------------------------------
|
n := 3; {ni toleros 3 erarojn} | FOR n IN 1..3 LOOP
RIPETU | DECLARE x:INTEGER; BEGIN
SE n = 0 TIAM AL 666; | GET(x);
leguLin(x); | p(sercxo(w, x) - 1); -- eblas escepto
n := n - 1; | EXIT; -- elirejo: escepto ne okazis
ind := serĉo(w, x); | EXCEPTION -- esceptotraktilo:
SE ind = fiasko TIAM | WHEN sercxoeraro =›
skribuLin('bv reklavi'); | IF n = 3 THEN GOTO halt;
ĜIS ind <> fiasko; | END IF;
| PUT("bv reklavi");
p(ind-1); {uzo de ind} | END; -- finiĝis bloko kaj esc.-traktilo
| END LOOP; -- fino de la iteracikorpo