Programovací jazyk Ada: nástroje pro řízení běhu programu

Nástroje pro řízení běhu programu můžeme rozdělit do dvou základních skupin: smyčky a podmíněné výrazy. Ze smyček jsou v jazyce Ada obsaženy tři základní: jednoduchá smyčka a smyčky while a for.

Zde jsou příklady pro jednoduchou smyčku včetně dvou možností jejího předčasného ukončení při splnění zadaných podmínek:

    loop
      -- tělo smyčky
   end loop;

    loop
      if podmínka then
         exit;
      end if;
   end loop;

   loop
      exit when podmínka;
   end loop;

Toto jsou příklady smyčky while a for pro dopředný a zpětný chod v rámci zadaného rozsahu.

   while podmínka loop
      -- tělo smyčky
   end loop;

   for proměnná in rozsah loop
      -- tělo smyčky
   end loop;

   for proměnná in reverse rozsah loop
      -- tělo smyčky
   end loop;

Podmíněné výrazy jsou v Ada dva: if a case:

   if podmínka  then
      -- příkazy
   end if;

   if podmínka  then
      -- příkazy
   else
      -- příkazy
   end if;

   if podmínka then
      -- příkazy
   elsif podmínka then
      -- příkazy
   else
      -- příkazy
   end if;

Zde není asi nic překvapivého nebo nečekaného.

   case výraz is
      when vybrané volby =>
          -- příkazy
      when vybrané volby =>
          --příkazy
      when others =>
          -- příkazy
   end case;

U podmínky case je ale vše úplně jinak, než je třeba v Javě nebo C++.

Jako poslední by zde bylo vhodné doplnit dvě věci: kdo si četl přílohu se seznamem vyhrazených slov, tak si možná všiml příkazu GOTO. Ten zde skutečně existuje, ale jeho použití je poměrně striktně omezené. Vzhledem k tomu, že ho většina programátorů moc nepoužívá, tak ho nebudeme nijak popisovat. Poslední postřeh je opět o nápadné podobnosti s Pascalem při ukončování všech smyček či podmíněných příkazů.

Deklarace proměnných samotných a jejich uživatelských typů je jedním z velmi silných nástrojů jazyka Ada hlavně ve spojitosti se silnou statickou typovostí. Zde si proto ukážeme jenom několik jednoduchých případů a více probereme až konkrétně v ukázkových příkladech. Vezměme situaci, kdy chceme definovat proměnnou, která bude obsahovat čísla měsíců v kalendářním roce, tedy 1 – 12:

      mes : Integer;            -- jednoduchá věc, ale rozsah proměnné je zbytečný
      mes : Short_Short_Integer -- rozsah je mnohem menší, ale nemáme zaručeno, že číslo měsíce nemůže být záporné nebo nula
      mes : Positive;       -- číslo je od jedné do plného rozsahu celého čísla
      mes : Integer range 1..12;    -- žádný rozsah nevadí, protože máme definován uzavřený rozsah 1 - 12

Přiřazení hodnoty do definované proměnné:

      val : Integer := 0;       -- v definici můžeme přiřadit proměnné vstupní hodnotu
      val : constant Integer := 1;
      val : constant := 125_000;    -- dvě možné definice konstanty

Uživatelské typy:

      type mesic is new Integer range 1..12;    -- vzniká derivovaný neboli odvozený typ
      type mesic is range 1..12;            -- pokud je rozsah z celých čísel, vzniká celočíselný typ
      mes : mesic;                      -- pomocí typu se definuje proměnná

Podtypy:

    type dny is (Po, Ut, St, Ct, Pa, So, Ne);       -- definují se všechny dny v týdnu
    subtype pracovni is dny range Po, Ut, St, Ct, Pa;   -- definují se pracovní dny
    subtype vikend is dny range So, Ne;                 -- definují se víkendové dny

Pole:

    type pole is array (1..20) of Positive;     -- pole 20-ti prvků s definovaným typem
    type trzba is Natural range 0..100_000;     -- celočíselná hodnota v daném rozsahu
    type mesic is range 1..12               -- měsíce v kalendářním roce
    type prodej is array (mesic) of trzba;      -- pole pro každý měsíc a tržbu v něm v definovaném rozsahu

To by pro základní přehled možností mohlo stačit a nyní se již konečně pustíme do praktických zkoušek a pokusů s překladem a spuštěním uvedených jednoduchých programů. V jeho rámci rozvineme podrobnější popis uvedených příkladů a doplníme je o ještě další možnosti, které Ada svým věrným nabízí.

K tomu, abychom nějaký program mohli spustit, potřebujeme buď nějaké běhové prostředí (třeba JVM, když budeme uvažovat Javu) nebo překladač, který nám vytvoří spustitelnou formu, samozřejmě platformně závislou. V našem případě, kdy se bavíme o jazycích Ada nebo C++, budeme určitě potřebovat překladač. Pro Adu existuje možností víc, ale pro začátek bude dostačující podpora, která je obsažena přímo v GCC. Jenom pro informaci zde uvedeme přehled přímo dostupných nástrojů pro tři vybrané distribuce (ve výukovém kurzu je tato tabulka rozšířená o nástroje pro překlad C++ a prostředí Java):

Pokud nebude výslovně uvedeno jinak, všechny testy budou prováděny na distribuci Salix64–14.1 s prostředím MATE.

• 
• 
• 

Dalších 5 fotografií

Do správce balíčků si zadáme hledání a instalaci výše uvedeného balíčku gcc-gnat – viz první obrázek v galerii. Když už jsme ve správci, doinstalujeme ještě balíček geany plugins – viz další obrázek. Pak v Geany vytvoříme soubor podle druhého příkladu pro Ada a uložíme pod názvem helloa1.adb – viz třetí obrázek. V terminálu spustíme příkaz:

# ~$ gcc -c helloa1.adb

I když se objevilo varování, že název souboru nesouhlasí s názvem procedury, v adresáři se objevily dva nové soubory – helloa1.ali a helloa1.o. Kýžený spustitelný soubor se sice neobjevil, ale není to žádná závažná chyba. Stačí zadat další dva příkazy:

# ~$ gnatbind helloa1
# ~$ gnatlink helloa1

a na čtvrtém obrázku vidíme vytvořený spustitelný soubor včetně ověření jeho funkčnosti. Zkopírujeme kód z vytvořeného souboru, upravíme a uložíme tak, jak je vidět na následujícím obrázku. Pak zadáme příkaz:

# ~$ gnatmake helloa2.adb

Na posledním obrázku pak vidíme, že tento příkaz automaticky vykonal všechny tři předchozí a vytvořil spustitelný soubor, který funguje.

Hned v následujícím příkladu se vrátíme k popisu numerických typů, kde jsme konstatovali, že neznáme jejich rozsah. K překladu a zobrazení hlášek překladače opět využijeme editor Geany. Nově se zde seznámíme s atributy, což jsou vlastnosti jazyka Ada, které umožňují získávat různé typy informací o jednotlivých druzích objektů. Pomocí atributů se lze objektů „dotazovat“ na slušné množství věcí a získávat na ně zajímavé odpovědi. Jejich přehled obsahuje příloha Atributy-ADA nebo je možné se podívat přímo na ALRM 2012 zde: ALRM 2012 – atributy.

Zde zjistíme, že jich je velmi mnoho a některé pro různé objekty poskytují různé informace. My si jich v příkladu ukážeme jenom pár a začneme čtyřmi, z nichž jeden je poměrně důležitý. Každému je asi jasné, že je v terminálových aplikacích nutné do řádků vypisovat nejenom řetězce, ale i všechny typy numerických hodnot. Ada má k dispozici jeden atribut, který to bez problémů dokáže. Dále se v prvním příkladu podíváme na atributy, které nám prozradí číselný rozsah celočíselných typů na dané platformě. Vytvoříme proto novou proceduru, která obsahuje tento kód: (je také v příloze ada1):

with Ada.Text_IO;  use Ada.Text_IO;             --1
    procedure Ada1 is                   --2
    begin                               --3
        Put_Line ("Long_Long_Integer---");      --4
        Put_Line (Long_Long_Integer'First'Img);     --5
        Put_Line (Long_Long_Integer'Last'Img);      --6
        Put_Line (Long_Long_Integer'Size'Img);      --7
        Put_Line ("Long_Integer--------");      --8
        Put_Line (Long_Integer'First'Img);      --9
        Put_Line (Long_Integer'Last'Img);       --10
        Put_Line (Long_Integer'Size'Img);       --11
        Put_Line ("Integer-------------");      --12
        Put_Line (Integer'First'Img);           --13
        Put_Line (Integer'Last'Img);            --14
        Put_Line (Integer'Size'Img);            --15
        Put_Line ("Short_Integer-------");      --16
        Put_Line (Short_Integer'First'Img);     --17
        Put_Line (Short_Integer'Last'Img);      --18
        Put_Line (Short_Integer'Size'Img);      --19
        Put_Line ("Short_Short_Integer-");      --20
        Put_Line (Short_Short_Integer'First'Img);   --21
        Put_Line (Short_Short_Integer'Last'Img);    --22
        Put_Line (Short_Short_Integer'Size'Img);    --23
        Put_Line ("Natural-------------");      --24
        Put_Line (Natural'First'Img);           --25
        Put_Line (Natural'Last'Img);            --26
        Put_Line (Natural'Size'Img);            --27
        Put_Line ("Positive------------");      --28
        Put_Line (Positive'First'Img);          --29
        Put_Line (Positive'Last'Img);           --30
        Put_Line (Positive'Size'Img);           --31
    end Ada1;                       --32

Jak je vidět, procedura obsahuje celkem 32 řádků, z nichž první tři a ten poslední nemohou být vůbec žádným překvapením. Vlastně ani řádky 4,8,12,16,20,24 a 28 nejsou neznámé. V nich se do řádků zobrazují názvy všech sedmi celočíselných numerických typů. Blíže se tedy podíváme na řádek číslo 5, kde je známý příkaz na zápis do řádku a za ním ještě další povědomý text – název celočíselného typu. Pak už ale následují čtyři zatím neznámé příkazy. Prvním z nich je znak ' – apostrof. Ten od sebe odděluje objekt a jeden nebo více atributů. Po něm následuje jeden z atributů pro získání informací o vlastnostech objektu – v tomto případě čísla. Postupně se jedná o dolní hranici rozsahu (First), horní hranici (Last) a bitovou velikost čísla (Size). Dalším apostrofem je pak oddělen následný atribut (Img), který umožní do řádku zobrazit předcházející číslo.

Tento příklad si dokončíme až v příštím dílu našeho seriálu.

V dnešním dílu jsme dokončili základní přehled možností jazyka Ada a vyzkoušeli si překlady jednoduchých aplikací Ada včetně ukázky základních atributů. V příštím dílu se blíže podíváme na editor Geany. Budeme se také věnovat praktickým příkladům, které ještě lépe osvětlí uvedené teoretické informace. Doplníme překlad příkladu pro využití atributů, ukážeme si práci se smyčkami a základy typové kontroly jazyka Ada.