Sekvan paĝon! Antaŭan paĝon! Indekson! Instrukcion!

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


Sekvan paĝon Indekson Instrukcion
Hosted by uCoz