### Pri Ada

1. Normoj pri Ada
2. Leksiko de Ada
3. La aranĝo de programo en Ada
4. Duoniga serĉo en Ada
5. Enkapsuligo kaj abstraktaj datumtipoj
6. racionoj: Ekzemplo pri enkapsuligo kaj abstrakta datumtipo en Ada
7. Paralelado en Ada
8. Esceptoj

#### Normoj pri Ada

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

#### Leksiko de Ada

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

#### La aranĝo de programo en Ada

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

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

#### Enkapsuligo kaj abstraktaj datumtipoj

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.

#### Racionoj: Enkapsuligo kaj abstrakta datumtipo en Ada

       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;

#### Paralelado en Ada

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

#### Esceptoj

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