Kozics Sándor - Az ADA Programozási Nyelv (1992, 162 Oldal)

OS
EOTV LORA ND TUDOMA NYEGYETEM
TERMESZETTUDOMANYI KAR
Kozics Sandor
Az Ada programozasi nyelv
Budapest, 1992
Ada 3
El}oszo
Ez a jegyzet a programozo matematikus szakot vegz}o hallgatok szamara

keszult. Feltetelezi a Bevezetes a programozashoz c. targy anyaganak, s a Modula-
2 nyelvnek az ismeretet.
A jegyzet celja a nyelv onallo tanulasanak tamogatasa. Ennek erdekeben a
jegyzet vegen kulonboz}o nehezseg}u feladatokat is elhelyeztunk.
A jegyzet kesztesehez felhasznaltuk az alabbi cikkeket es konyveket:
1]Coat, D., "Pascal, Ada and Modula-2", BYTE 8(1984) 215-232.

2]Young, S.J., An Introduction to Ada (Ellis Horwood Limited, 1983).
3]Pyle, I.C., Az Ada programozasi nyelv (M}uszaki Konyvkiado, Budapest,
1987).
4]Reference Manual for the Ada Programming Language (january 1983)
5]Gehani, N., Ada, An Advanced Introduction (Prentice-Hall Inc., Englewood
Clis, 1984.)
6]Miller, N.E., Petersen, C.G., File Structures with Ada (The Benja-
min/Cummings Publishing Company, Inc., Redwood City, California, 1990.)
7]Dershem, H.L., Jipping, M.J., Programming Languages: Structures and Mo-
dels (Wadsworth Publishing Company, Belmont, California, 1990.)
4 Ada
1. Az Ada nyelv attekintese
1.1. Az Ada torteneti hattere

Az 1970 -es evek elejen az US DoD (United States Department of Defense) ugy
dontott, hogy tennie kell a software-koltsegek rohamos novekedese ellen. 1973 -
ban peldaul a DoD software-koltsege 3 milliard dollar korul volt, aminek 56 %-
at az alap-software jelleg}u rendszerek fejlesztese emesztette fel. O sszehasonlta-
sul: adatfeldolgozasra 19 %-ot, a tudomanyos programokra 5 %-ot koltottek.
A legnagyobb koltsegmegtakartas nyilvanvaloan ugy erhet}o el, ha ezek kozul
az alap-software rendszerek koltsegeit csokkentik. Mg az adatfeldolgozas es a
tudomanyos programok nyelve szeles korben a COBOL es a FORTRAN, a rend-
szerprogramok kesztesehez nem alakult ki hagyomanyos nyelv. E celra szamos
nyelvet hasznaltak, mint pl. a JOVIAL, CMS-2, TACPOL, SPL/1, es meg sok
mast. Ezert arra lehetett kovetkeztetni, hogy jotekonyan hatna a koltsegekre ennek
a teruletnek az egysegestese. Ennek erdekeben szervezte meg az US DoD a HOL
(High Order Language) elnevezes}u munkat, kett}os cellal. Az els}o, rovidtavu cel
egy vagy tobb ideiglenesen hasznalhato nyelv kivalasztasa, a masodik, hosszutavu
cel pedig egy nagy megbzhatosagu alap-software kesztesere alkalmas nyelvnek a
kijelolese ill. denialasa volt.
Az els}o celt hamarosan elertek, es a kovetkez}o nyelveket valasztottak ki: TAC-
POL, CMS-2, SPL/1, JOVIAL J3 es JOVIAL J73.
A hosszutavu cel eleresenek els}o lepese a kovetelmenyek rogztese es a letez}o
nyelvek ertekelese volt. A kovetelmenyeket egyre nomodo dokumentumokban
rogztettek, amelyek a STRAWMAN, WOODENMAN, TINMAN, IRONMAN,
vegul a STEELMAN nevet kaptak (szalma-, fa-, badog-, vas-, acelember). Ezeket
a dokumentumokat szeleskor}u es nylt vitakon nomtottak.
A letez}o nyelvek ertekeleset 1976-ban, a munka harmadik szakaszaban
vegeztek el. A FORTRAN, COBOL, PL/I, HAL/S, TACPOL, CMS-2, CS-4,
SPL/1, J3B, Algol 60, Algol 68, CORAL 66, Pascal, SIMULA 67, LIS, LTR,
RTL/2, EUCLID, PDL2, PEARL, MORAL es EL-1 nyelvek ertekeleset pub-
likaltak. Az ertekeles eredmenyet negy pontban foglaltak ossze:
1. Nincs olyan letez}o nyelv, ami egymagaban megfelelne a celnak.
2. Egyetlen nyelvet kell kialaktani.
3. A kovetelmenyek denialasanak meg kell maradnia a "state of art" szintjen.
4. A fejlesztest a meglev}o ertekek felhasznalasaval kell vegezni.
Az ertekelt nyelveket harom osztalyba soroltak:
- nem hasznalhato fel : Ide tartoznak az elavult, vagy elhibazott nyelvek.
Az Ada nyelv attekintese 5
Ezekr}ol nem adtak reszletesebb elemzest. Ebbe a kategoriaba kerult pl. a FORT-
RAN es a CORAL 66.
- megfelel}o : Ide kerultek azok a nyelvek, amelyek ugyan kozvetlenul nem alkal-
masak, de nehany elemuk felhasznalhato. Ebbe a csoportba kerult pl. az RTL/2
es a LIS.
- alapnyelvkent hasznalhato : Harom ilyen nyelvet talaltak, a Pascalt, a PL/I-
et es az ALGOL 68-at, amiket az uj nyelv tervezesenek kiindulopontjaul ajanlottak.
Ezzel a TINMAN dokumentumot befejeztek, es a kovetkez}o szakaszban negy
vallalkozora bztak a tervezest, akik valamelyik alapnak alkalmas nyelvb}ol indul-
hattak ki. Tizenhet jelentkez}ob}ol valasztottak ki azt a negyet, akik parhuzamosan
folytattak a nyelv tervezeset. A negy vallalkozot sznekkel kodoltak:
CII Honeywell Bull | Zold
Intermetrics | Piros
Softech | Kek
SRI International | Sarga
Mind a negyen a Pascalt valasztottak alapnyelvnek. (A sznkodolast az elfogulat-
lan velemenyezes erdekeben vezettek be.)
Az els}o fazis vegen Kek es Sarga kiesett a kuzdelemb}ol, de Zold es Piros
folytattak a versengest. Ezt a tervezesi szakaszt 1979 majusaban fejeztek be, es a
gy}oztes Zold lett.
A Zold es Piros kozotti valasztas nem volt konny}u a DoD szamara. Azt
mondtak, hogy a Piros egy jobb nyelv lehet}oseget hordozta magaban, de az IRON-
MAN masodik szakaszaban ez a nyelv olyan mertekben megvaltozott, hogy a ter-
vez}ok nem tudtak befejezni a munkat. A Zold nyelv keveset valtozott, es a de-
ncioja joval teljesebb volt, gy a Zold valasztasa jart kisebb kockazattal. Pi-
ros nyelv nehany fogalmanak implementalasa igen problematikus volt, mg a Zold
nyelvvel mar lehetett dolgozni.
Ebben az id}oben hatarozta el a DoD, hogy az uj nyelvet Adanak fogjak hvni.
Ada | Lord Byron lanya, es Babbage asszisztense volt. O} volt a vilagon az els}o
programozo.
A HOL ezzel elerkezett az utolso szakaszba. Ennek a szakasznak a feladata
a nyelv vegs}o nomtasa es denialasa volt, s itt nagy reszt tett ki a Tesztelesi es
E rtekelesi munka. Ez utobbi abban allt, hogy kulonboz}o csoportok programokat
rtak Ada nyelven, hogy annak hasznalhatosagarol meggy}oz}odjenek. Ezekr}ol a
munkakrol 82 elemzes keszult, amiket 1979 oktobereben a bostoni konferencian
adtak el}o. Az altalanos velemeny az volt, hogy a nyelv jo, de nehany ponton
modostasra szorul.
A Teszteles es E rtekeles nem volt minden problema nelkuli. A mega-
dott id}o nem volt eleg ahhoz, hogy Ada-stlusban tervezzek meg a programokat,
ezert altalaban meglev}o programokat hasznaltak fel, amiket azutan eljarasonkent
6 Ada
atrtak Adara. Igy az Ada alkalmassagat nagy programok rasara vegul is nem si-
kerult tesztelni. Emellett nagyobb programok eseteben problemat okoztak a
nyelv tesztelesehez elkesztett interpreter zavarai. Ezt az interpretert meg az
IRONMAN masodik szakaszaban abbol a celbol fejlesztettek ki, hogy megmu-
tassak, a nyelv vegrehajthato. A harmadik problema az Ada kezikonyv tomorsege
volt. Bar a kezikonyv tokeletesen lerta a nyelvet, mint oktatokonyv nem volt
tulsagosan jo. Ezzel egyutt a Tesztelesi es E rtekelesi szakaszban igen alapos es in-
tenzv tesztelest vegeztek, amelynek az eredmenyei alapjan a nyelvet tovabb -
nomtottak.
1.2. Az Ada rovid jellemzese

Az Ada tervezesenek 1,2,3,4,5,6] f}o szempontjai a program megbzhatosaga,
karbantarthatosaga, emberkozelisege (olvashatosaga) es hatekonysaga voltak. A
nyelv alapja a Pascal, de nehany vonast atvett a kovetkez}o nyelvekb}ol is: Euclid,
Lis, Mesa, Modula, Sue, Algol 68, Simula 67, Alphard, CLU.
Az Ada programegysegei az
- alprogramok, amelyek a szamtasokat elvegz}o algoritmusbol allnak,
- a package, ami alprogramok, tpusok, konstansok es valtozok gy}ujtemenye,
- a task, ami parhuzamosan vegrehajthato szamtasokat tartalmaz, es
- a generic, ami tpussal es alprogrammal is parameterezhet}o makro-szer}u
package-t vagy alprogramot jelent.
A programegysegekb}ol (kiveve a taskot) kialakthatok onalloan fordthato
egysegek. Ezek kozott a f}oprogram egy olyan eljaras lehet, amelynek nincs pa-
rametere.
A programegysegek ket reszb}ol allnak: specikacios reszb}ol, ami a mas
egysegekb}ol lathato informaciot tartalmazza, es a torzsb}ol, ami az implementaciot
tartalmazza, es ami mas egysegekb}ol nem lathato.
A specikacios resz es a torzs szetvalasztasa, es a kulon valo fordtas lehet}ove
teszi nagymertekben fuggetlen programkomponensek tervezeset, rasat es tesz-
teleset.
A programegyseg torzse ket reszb}ol all: deklaracios reszb}ol, ami denialja
a programegysegben hasznalt konstansokat, valtozokat, hibaesemenyeket (excep-
tion) es programegysegeket, es egy utastassorozatbol, ami denialja a prog-
ramegyseg vegrehajtasanak hatasat. A torzs vegrehajtasa ennek megfelel}oen
ket lepesben tortenik: az els}o lepes a deklaracio kiertekelese, a masodik az
utastassorozat vegrehajtasa. A vegrehajtas hibaesemenyeket is el}oidezhet (ilyen
pl. a tulcsordulas, az indextullepes, vagy egy, a felhasznalo altal denialt hiba
fellepese), es ezeknek a hibaknak a lekezelesere a torzs vegen specialis programre-
szek (exception handler) helyezhet}ok el.
Az Ada nyelv attekintese 7
Az Ada er}osen tpusos nyelv. Minden objektum rendelkezik egy a fordtas

soran egyertelm}uen megallapthato tpussal, s a tpusok megfelel}o hasznalata el-
len}orzott. Vannak a nyelvnek elemi tpusai, mint a felsorolasi tpus es a kulonboz}o
numerikus tpusok, valamint osszetett tpusai, mint a rekord, a tomb es a poin-
ter (access) tpus. A felhasznalo is denialhat tpust, un. private tpust ugy,
hogy megadja az ertekhalmazt es a m}uveletek programjait egy package program-
egysegben.
Az Ada az input-output-ot predenit generic package-kben denialja.
A lefordtott Ada egysegek egy specialis konyvtarban, egy adatbazisban he-
lyezkednek el. Kezdetben a konyvtar csak predenit package-ket tartalmaz, ezek-
hez illesztheti hozza a felhasznalo a maga konyvtari egysegeit. Egy Ada prog-
ram kifejlesztese a konyvtari egysegek adatbazisanak felepteset jelenti.
Az Ada a nyelv kulonboz}o variansainak kialakulasa ellen is vedekezik. A nyelv
szabvanya tartalmazza azt a kitetelt, hogy csak az a fordtoprogram hasznalhatja
az "Ada fordtoprogram" megnevezest, ami a nyelv minden szabalyat pontosan al-
kalmazza, s ami nem vezet be sem modostasokat, sem kiterjeszteseket. Azt, hogy
egy fordtoprogram viselheti-e az "Ada fordtoprogram" cmket, egy New York-
ban felalltott intezetben dontik el. Az ide elkuldott fordtoprogram validalasa
ugy tortenik, hogy lefordtanak es lefuttatnak egy tobb ezer programbol allo teszt-
sorozatot.
Az Ada szintaxisanak lerasara a tovabbi fejezetekben egy kiterjesztett BNF
nyelvet hasznalunk. A bal- es jobboldalt ::= jellel, a jobboldal alternatvait jellel
j
valasztjuk el. A nemterminalis elemeket < es > jelek koze rjuk. A szogletes
zarojelel koze zart resz tetszes szerint elhagyhato vagy hasznalhato a programban,
a kapcsos zarojelbe tett resz pedig tetsz}olegesen sokszor (akar nullaszor is) egymas
utan rhato.
8 Ada
2. Lexikalis elemek
<graphic character> ::= <basic graphic character>

j<lower case letter>j<other special character>
<basic graphic character> ::= <upper case letter>
j<digit>j<special character>j<space character>
<identier> ::= <letter> f <underline> ] <letter or digit>g
Az Ada az azonostokban es az alapszavakban nem tesz kulonbseget a kis-
es nagybet}uk kozott. Az azonosto minden karaktere szignikans. A nyelv-
ben | a modern gyakorlatnak megfelel}oen | az alapszavakat kulon jelolni nem
kell, de ezek kotott szavak, azonostokent nem hasznalhatok. Vannak a nyelv-
ben predenit szavak is (pl. a tpusok felepteseben hasznalt INTEGER, TRUE, ST-
RING stb.), ezek u jradenialhatok. Az Adaban az a szokas, hogy az alapszava-
kat kis, az azonostokat nagybet}ukkel rjak.
<numeric literal> ::= <decimal literal>j<based literal>
<decimal literal> ::= <integer> . <integer> ] <exponent> ]
<integer> ::= <digit> f <underline> ] <digit>g
<exponent> ::= E + ] <integer>j E ; <integer>
<based literal> ::= <base> # <based integer>
. <based integer> ] # <exponent>
<base> ::= <integer>
<based integer> ::= <extended digit> f <underline> ] <extended digit>
<extended digit> ::= <digit>j<letter>
A szamoknak ket alapformaja van: a decimalis es az alapszammal felrt forma.
A szamrendszer alapszama kett}ot}ol tizenhatig barmelyik szam lehet, de maga az
alapszam mindig decimalis. A szamok tagolasara hasznalhatjuk az alahuzasjelet,
aminek a szam erteke szempontjabol nincs jelent}osege.
123 456 789 ;; decimalis egesz szam
1E6 ;; decimalis egesz exponencialis alakban
2#1011# ;; binaris egesz szam
3.14159 ;; decimalis valos
16#F.FF#E2 ;; hexadecimalis valos exponencialis alak
2#1.1111 1111 111#E11 ;; a kitev}ohoz tartozo alap a szamrendszer
;; alapszama, tehat a ket utobbi ertek
;; egyarant 4095.0
A valos szamokat az kulonbozteti meg az egesz szamoktol, hogy tizedespontot
tartalmaznak.
<character literal> ::= ' <graphic character> '
<string literal> ::= " f<graphic character>g "
Az Ada karakteres stringliteralokban csak megjelenthet}o karaktereket
hasznalhatunk. A karakterliteralokat ugy rjuk, hogy a karaktert aposztrofok koze
Lexikalis elemek 9
zarjuk. A stringliteralokat idez}ojelek koze tesszuk, es nem nyulhatnak tul a sor
vegen. A nem megjelenthet}o karaktereket karakteres konstans formajaban a pre-
denit ASCII package denialja.
'A' 'a' ''' ;; ez egy nagy es kis A bet}u es egy aposztrof
"" ;; u res string
"""" ;; egy idez}ojelet tartalmazo string
"abc" & 'd' & "ef" & 'g';; ez a konkatenacio ford tasi id}oben ertekel}odik ki
ASCII.ESC & "9B"
Az elemi szintaktikai egysegek (alapszavak, azonostok, literalok stb.) koze

tetsz}olegesen sok szokoz elhelyezhet}o, de ezek belsejeben nem lehet szokoz. (Nem
lehet tehat szokoz a tobb karakterrel kifejezett szimbolumok, pl. :=, /=, => stb.
belsejeben sem.)
A megjegyzest ket mnuszjel vezeti be, es a sor vegeig tart.
;; ez egy megjegyzes .
Megjegyzes a program barmely soraban elhelyezhet}o. A megjegyzesnek nincs

hatasa sem a program szintaktikus helyessegere, sem a jelentesere.
10 Ada
3. Deklaraciok
Deklaracionak nevezzuk egy azonostonak es

egy egyednek az osszekapcsolasat. A ltalaban maga a deklaracios utastas tar-
talmazza az egyed denciojat is (pl. valtozo es konstans eseten), egyes ese-
tekben azonban a deklaracio es a dencio szet is valhat (pl. tpus es alprog-
ram eseten). Ha egy azonostora hivatkozunk, annak a szovegben korabban dek-
laraltnak kell lennie (kiveve a cmkek esetet, ld. 5.8.).
Az egyedek denciojanak kiertekelese futasi id}oben tortenik, emiatt pl. a
tpusdencio valtozot es fuggvenyhvast is tartalmazhat.
<declarative part> ::= f<basic declarative item>gf<later declarative item>g
<basic declarative item> ::= <basic declaration>j<represetation clause>
j<use clause>
<later declarative item> ::= <body>j<subprogram declaration>
j<package declaration>j<task declaration>j<generic declaration>
j<use clause>j<generic instantiation>
<body> ::= <proper body>j<body stub>
<proper body> ::= <subprogram body>j<package body>j<task body>
<name> ::= <simple name>j<character literal>j<operator symbol>
j<indexed component>j<slice>j<selected component>j<attribute>
<simple name> ::= <identier>
<basic declaration> ::= <object declaration>j<number declaration>
j<type declaration>j<subtype declaration>j<subprogram declaration>
j<exception declaration>j<generic instantiation>j<renaming declaration>
j<deferred constant declaration>
A kulonfele elemek deklaraciojanak es a deklaracios reszben lev}o dencioknak
a sorrendje a kovetkez}o: el}obb a tpus- es objektumdeklaraciok, valamint az alp-
rogramspecikaciok kovetkeznek, majd ezek utan johet a taskok, package-k es alp-
rogramok torzse. A taskok es package-k specikacioja barhol lehet, de an-
nak meg kell el}oznie a hozza tartozo torzset.
Ha egy deklaracios reszben szerepel egy alprogram, package vagy task speci-
kacioja, ugyanebben a deklaracios reszben kell lennie a megfelel}o torzsnek is.
<object declaration> ::= <identier list> : constant ]
<subtype indication> := <expression> ]
j<identier list> : constant ]
<constrained array denition> := <expression> ]
Objektumnak nevezzuk azokat az elemeket, amelyeknek valamilyen tpusu
erteke lehet. Objektum a valtozo, a konstans, a formalis parameter, a cik-
lusvaltozo, a tombelem es a resztomb. Objektum denialasakor az objektum kap-
Deklaraciok 11
hat kezd}oerteket is. Az erteket ado komponens erteke futasi id}oben kerul meg-
hatarozasra.
COUNT, SUM : INTEGER
SORTED : BOOLEAN := FALSE
COLOR TABLE : array
(1 .. N) of
COLOR
OPTION : BIT VECTOR(1 .. 10) := (OPTION'RANGE = > TRUE)
K : INTEGER := K * K ;; hibas
INTEGER : INTEGER ;; hibas
Azokat a deklaraciokat, amelyekben a jobboldal ugyanaz, osszevonhatjuk egyetlen
deklaracios utastasba (ilyen esetet mutat be a fenti peldak kozul az els}o). Ez az
osszevonas nem valtoztatja meg a program jelenteset, tehat az alabbi deklaraciok
ekvivalensek (a new dinamikus memoria allokalasara szolgalo m}uvelet, ld. 4.7.):
P1, P2 : POINTER := new INTEGER'(0)
illetve
P1 : POINTER := new INTEGER'(0)
P2 : POINTER := new INTEGER'(0)
A konstansok denciojaban a kett}ospont utan a constant szot kell rni. A
konstans erteket megado kifejezes is futasi id}oben ertekel}odik ki.
LOW LIMIT : constant INTEGER := LIMIT / 10
TOLERANCE : constant COEFFICIENT := DISPERSION(1.15)
Egy objektumdeklaracio futas kozbeni kiertekelese a kovetkez}o lepesekben

zajlik le:
a) Kiertekelesre kerul az objektum altpusa.
b) Kiertekelesre kerul az objektum kezd}oerteket megado kifejezes, vagy ha
ilyen nincs, akkor az a) pontban meghatarozott tpus denciojaban mega-
dott kezd}oertekadas.
c) Letrejon (allokalasra kerul) az objektum.
d) Ha van az objektumnak, vagy valamelyik komponensenek kezdeti erteke, fel-
veszi azt.
<number declaration> ::= <identier list> : constant :=
<universal static expression>
<identier list> ::= <identier> f , <identier>g
Az Adaban a szamok nemcsak mint a tpusok tpusertekei leteznek, ha-
nem hasznalhatok a tpusoktol fuggetlenul is, mint ahogy pl. a zikaban
is hasznalnak szamokat mertekegyseg nelkul is. (Az Adaban ilyen uni-
verzalis szamertekeket adnak vissza egyes attributumok, pl. amelyik meg-
adja a valos szamok gepi abrazolasaban a mantissza hosszat bitben, ame-
lyik megadja a program rendelkezesere allo memoria meretet, vagy amelyik meg-
adja, hogy egy adott rekordtpuson belul valamelyik mez}o hanyadik bitpozcion
kezd}odik stb.) Az ilyen, univerzalis szamokat ellathatjuk nevvel, es gy de-
nialhatunk un. univerzalis ("tpustalan") konstansokat. Ezekben a kons-
tansdenciokban a kifejezesek kiertekelese fordtasi id}oben tortenik. Az uni-
12 Ada
verzalis szamok ertektartomanyara az Ada nem vezet be korlatozast.

LIMIT : constant := 100
ZERO : constant := 0
SIZE : constant := LIMIT * 2
LIMIT2 : constant INTEGER := 100
VAL1 : INTEGER
VAL2 : MY INT
VAL1 := LIMIT2
VAL1 := LIMIT
VAL2 := LIMIT
PI : constant:= 3.14159
VAL2 := LIMIT2 ;; hibas (konvertalni kellene!)
Tpusok 13
4. Tpusok
Az Ada a programok megbzhatosaganak novelese celjabol igen er}os

tpusfogalmat hasznal. Ez a kovetkez}oket jelenti:
- Minden objektumnak egyetlen tpusa van.
- Minden tpus egy ertekhalmazt es egy m}uvelethalmazt denial, amely
m}uveletek ezekre az ertekekre alkalmazhatok. Egy tpus nem lehet kompo-
nense sajat maganak.
- Az ertek es az erteket kapo objektum tpusanak minden ertekadasban meg
kell egyezni.
- Ha egy ertekre alkalmazunk egy tpusm}uveletet, annak a tpusm}uveletek hal-
mazaban szerepelnie kell.
<type declaration> ::= <full type declaration>
j<incomplete type declaration>j<private type declaration>
<full type declaration> ::= type <identier> <discriminant part> ] is
<type denition>
<type denition> ::= <enumeration type denition>
j<integer type denition>j<real type denition>
j<array type denition>j<record type denition>
j<access type denition>j<incomplete type denition>
Az Adaban a kovetkez}o tpusosztalyok leteznek :
- skalar tpusok, ezen belul diszkret es valos tpusok
- diszkret tpusok, ezen belul felsorolasi es egesz tpusok
- osszetett tpusok (tomb es rekord tpusok)
- access tpus
- private tpusok
- task tpusok.
<attribute> ::= <prex> ' <attribute designator>
<attribute designator> ::= <simple name>
( <universal static expression> ) ]
<prex> ::= <name>j<function call>
Az Ada az egyes tpusosztalyokhoz is bevezet tpusm}uveleteket, un. attributu-
mokat. Ezeket az osztaly minden tpusara hasznalhatjuk. Pl. az egesz tpusra al-
kalmazhato a FIRST es a LAST attributum, es a tpus legkisebb ill. legna-
gyobb ertekere INTEGER'FIRST ill. INTEGER'LAST formaban hivatkozhatunk. Az
=es /= relacio a limited private tpus (ld. 7.4.) kivetelevel barmilyen tpusu ob-
jektumra alkalmazhato.
A V'ADDRESS attributum barmilyen V objektumra alkalmazhato, s meg-
adja az objektumnak a memoriabeli cmet. A T'SIZE, V'SIZE attributum
barmilyen T tpusra es V objektumra alkalmazhato, s megadja a tpus ertekeinek
14 Ada
ill. az objektumnak a tarolasahoz szukseges bitek szamat. (Mindket attri-

butumnak els}osorban mas nyelv}u, pl. assembly rutinok hvasakor van sze-
repe.)
Minden tpus csak onmagaval ekvivalens. Kulonboz}o denciok kulonboz}o
tpusokat denialnak.
A : array (1 .. 10) of BOOLEAN
B : array (1 .. 10) of BOOLEAN ;; A es B t pusa k ulonboz}o
X, Y:array (1 .. 10) of BOOLEAN ;; X es Y t pusa k ulonboz}o
4.1. Az altpus fogalma

<subtype declaration> ::= subtype <identier> is <subtype indication>
<subtype indication> ::= <type indication> <constraint> ]
<type mark> ::= <type name>j<subtype name>
<constraint> ::= <range constraint>j<oating point constraint>
j<xed point constraint>j<index constraint>j<discriminant constraint>
Az egyik eszkoz, amit a biztonsag novelesere az Ada bevezet, az altpus
fogalma. Altpust a tpus ertekhalmazanak megszortasaval (azaz er}osebb
tpusinvarians megadasaval) allthatunk el}o. A megszortas modja fugg a
tpusosztalytol (pl. diszkret tpusok eseteben a megszortas az ertektartomany egy
intervallumanak kivalasztasa). Az altpuskepzes nem vezet be uj tpust, ennek csak
a futas kozbeni ellen}orzesben van szerepe. Ez a megoldas ezen kvul ertekes in-
formaciokat ad a program olvasojanak a valtozo hasznalatarol.
type COLOR is (WHITE, RED, YELLOW, GREEN, BLUE, BROWN, BLACK)
type MATRIX is
array (INTEGER range <>,INTEGER range <>) of REAL
type TEXT (MAX:POSITIVE) is
record
LENGTH : NATURAL := 0
VALUE : array (1 .. MAX) of CHARACTER
end record
subtype RAINBOW is COLOR range RED .. BLUE
subtype RED BLUE is RAINBOW
subtype SQUARE is MATRIX(1 .. 10, 1 .. 10)
subtype LINE is TEXT(80)
Barmely T altpusra alkalmazhato a T'BASE attributum, ami megadja
a T bazistpusat. T'BASE csak attributumok prexekent hasznalhato, pl.
T'BASE'FIRST.
(Megjegyzes. Az alt puskepzes az ertekhalmazra vonatkozo m}uvelet. A progra-

mozas szempontjabol hasznosak lennenek az olyan alt puskepz}o m}uveletek is, amelyek a
t pus m}uvelethalmazara vonatkoznak, ilyeneket azonban az Ada nem tartalmaz. Ugyani-
lyen szempontbol hasznosak lennenek a t pusdenialasnak olyan formai is, amikor az uj t pus
m}uvelethalmaza kib}ovul.)
Tpusok 15
4.2. Szarmaztatott tpusok

Az Ada nemcsak a kulonboz}o tpusok osszekeveredese ellen ad vedelmet, ha-
nem a programban szerepl}o kulonboz}o, de ugyanolyan tpusu objektumok-
nak a szintaxis szintjen valo elkulontesere is eszkozokkel szolgal. Ez az eszkoz
az uj tpus szarmaztatasa egy mar letez}o tpusbol.
<derived type denition> ::= new <subtype indication>
A szarmaztatott tpus atveszi az eredeti tpus strukturajat, ertekhalmazat es
a m}uveleteit, atveszi annak kezdeti ertekeit is, de a ket tpus nem ekvivalens. (A
tpusm}uveletekben termeszetesen a regi tpus helyere a szarmaztatott tpus kerul.)
(Megjegyzes. Ha peldaul egy programnak zikai jellemz}okkel kell szamolnia, a legtobb
nyelvben a valtozokat gy deklaraljuk :
D1,D2 : REAL ;; tavolsagok
V1,V2 : REAL ;; sebessegek
Igy semmilyen mod nincs a D1 := V1 utas tas nyilvanvalo hibajanak felismeresere. A
szarmaztatas seg tsegevel a kulonfele valos mennyisegekhez viszont uj t pusokat vezethetunk be:
type TAVOLSAG is new REAL
type SEBESSEG is new REAL
D1, D2 : TAVOLSAG
V1, V2 : SEBESSEG
Ekkor D1 := V2 szintaktikusan hibas utas tas, mert a baloldal es a jobboldal t pusa nem egyezik
meg. Emlekezzunk arra, hogy az Adaban minden t pus csak onmagaval ekvivalens.)
A szarmaztatas osszekothet}o az altpuskepzessel.
type NEW TYPE is new OLD TYPE <megszor tas>
ekvivalens a kovetkez}ovel:
type <new type> is new <base type of OLD TYPE>
subtype NEW TYPE is <new type><megszor tas>
Az eredeti tpus (}ostpus) ertekeit atkonvertalhatjuk a szarmaztatott tpusba
es viszont. Ilyenkor a tpus nevet hasznalhatjuk konverzios fuggvenykent.
type STATUS is (OFF,ON)
type BIT is new STATUS
S : STATUS
B : BIT
Ekkor B := BIT(S) es S := STATUS(B) egyarant helyes konverzio.
4.3. Diszkret tpusok

Az Ada diszkret tpusai a felsorolasi es az egesz tpusok.
16 Ada
4.3.1. Felsorolasi tpusok

<enumeration type denition> ::= ( <enumaration literal specication>
f , <enumaration literal specication>g )
<enumaration literal specication> ::= <enumeration literal>
<enumeration literal> ::= <identier>j<character literal>
A felsorolasi tpus denciojaban a tpusertekeket azonostoikkal felsoroljuk,
es az azonostok sorrendje rja le a nagysagrendi viszonyaikat. Ezek az azonostok
a programban literalkent hasznalhatok.
type NAP is (HET,KED,SZE,CSU,PEN,SZO,VAS)
type VEGYES is ('a',VAS) ;; VAS atlapolt konstans
type STATUS is (OFF,ON)
type SWITCH is (OFF,ON)
type HEXA is ('A', 'B', 'C', 'D', 'E', 'F')
Egy felsorolasi tpus literaljainak nevei kulonboz}ok kell legyenek. Egy azo-
nostoval (vagy karakteres literallal) azonban tobb tpusnak egy-egy erteket is
jelolhetjuk | ezt a nevek atlapolasanak nevezzuk. Ha ekkor a program egy pontjan
nem egyertelm}u, hogy melyik tpus erteker}ol van szo, a literalra un. min}ostett ki-
fejezessel hivatkozhatunk. Pl. NAP'(VAS).
<qualied expression> ::= <type mark> ' ( <expression> )
j<type mark> ' <aggregate>
Peldak szarmaztatott tpusokra es altpusokra :
type BIT is new SWITCH
type MUNKANAP is range HET .. PEN
subtype RAINBOW is COLOR range RED .. BLUE
Peldak tpuskonverziora es ertekadasra :
ST : STATUS
SW : SWITCH
B : BIT
ST := STATUS(SW);; illegalis !
SW := SWITCH(B) ;; helyes
B := BIT(SW) ;; helyes
A CHARACTER tpus egy predenit felsorolasi tpus, ami az ASCII karaktere-
ket tartalmazza. A nem megjelenthet}o karakterekre valo hivatkozashoz az Ada be-
vezet egy predenit ASCII nev}u package-t, s a nem megjelenthet}o karakterekre AS-
CII.LF, ASCII.CR,... formaban hivatkozhatunk.
A logikai tpus is egy predenit felsorolasi tpus, amelynek dencioja a
kovetkez}o :
type BOOLEAN is (FALSE,TRUE)
A logikai ertekekre alkalmazhatok az and, or, xor es not m}uveletek. Az and then es
Tpusok 17
or else operatorok megfelelnek a logikai "es" es "vagy" m}uveleteknek, de a masodik

operandus nem kerul kiertekelesre, ha az eredmeny az els}o operandus alapjan is
megadhato.
4.3.2. Az egesz szamok tpusai

<integer type denition> ::= <range constraint>
<range constraint> ::= range <range>
<range> ::= <range attribute>j<simple expression> .. <simple expression>
Az Ada az INTEGER, SHORT INTEGER, LONG INTEGER predenit egesz tpusokat
tartalmazza. Az INTEGER tpusbol uj tpust pl. a
type INT is new INTEGER range ;1000 .. 1000
vagy rovidebben
type INT is range ;1000 .. 1000
formaban szarmaztathatunk (ez egyszerre szarmaztatas es altpuskepzes is). Az

INTEGER tpusb ol szarmaztatott tpusoknak abban van a jelent}oseguk, hogy mg az
INTEGER tpus implement acioja gepenkent valtozhat, az gy szarmaztatott es meg-
szortott tpusoke mindenutt egyforma. Ez nagyban el}osegti a program atvitelet
mas gepre.
A NATURAL es a POSITIVE az INTEGER tpusnak egy predenit altpusa. A
denciojuk a kovetkez}o :
subtype NATURAL is INTEGER range 0 .. INTEGER'LAST
subtype POSITIVE is INTEGER range 1 .. INTEGER'LAST
Az INTEGER tpus ertekeit egesz szamliteralokkal rjuk le, a m}uveletei a
szokasos aritmetikai m}uveletek (+, ;, *, /, mod, rem, **, abs). Az A rem B ki-
fejezes el}ojele megegyezik az A el}ojelevel, erteke pedig abszolut ertekben kisebb,
mint abs(B). Az A mod B kifejezes el}ojele megegyezik a B el}ojelevel, erteke pe-
dig abszolut ertekben kisebb, mint abs(B).
4.3.3. A diszkret tpusok tpusm}uveletei

A diszkret tpusu ertekekre ertelmezve vannak az alabbi relaciok : <, <=, >,
>=, in, not in.
A diszkret tpusosztalynal hasznalhato attributumok a kovetkez}ok: PRED,
SUCC, POS, VAL, FIRST, LAST, IMAGE, VALUE, WIDTH. Ha T egy diszkr et tpus
es V:T egy valtozo, akkor T'FIRST a tpus els}o (legkisebb) erteke, T'LAST a tpus
utolso (legnagyobb) erteke, T'POS(V) a V ertek sorszama a tpusertekek kozott,
IMAGE: T ;! STRING es VALUE : STRING ;! T egy-egy konverzios fuggveny (pl.
INTEGER'IMAGE(20)="20", COLOR'IMAGE(RED)="RED"). T'WIDTH a T'IMAGE(V)
ertekek hosszainak maximuma. E rvenyesek az alabbi egyenletek :
18 Ada
T'POS(T'SUCC(v)) = T'POS(V) + 1
T'POS(T'PRED(V)) = T'POS(V) ; 1
T'VAL(T'POS(V)) = V
T'POS(T'VAL(k)) = k ( 0 k T'POS(T'LAST))
T'SUCC(T'PRED(V)) = V
T'VALUE(T'IMAGE(V)) = V
4.4. Valos tpusok

Bar az Adat nem specialisan a numerikus analzis feladatainak megoldasara
terveztek, megis alkalmasabb a kenyes numerikus problemak megoldasara mint pl.
a FORTRAN. Az itt denialt valos tpus nagyban tamogatja a hordozhatosagot.
A valos ertekek hibajanak pontosabb denialasahoz az Ada uj fogalmakat
vezet be. Minden valos tpushoz denialja azoknak az ertekeknek a halmazat,
amit a nyelv minden implementaciojanak pontosan kell abrazolnia. Ezeket az
ertekeket a tpus modellszamainak nevezzuk. A modellszamok csak a tpusde-
nciotol fuggenek, az implementaciotol nem. Minden valos tpushoz denialja a
biztonsagos szamok halmazat, ami a tpusnak azokat az ertekeit jelenti, amelyek az
adott implementacioban pontosan abrazolhatok. A biztonsagos szamok halmaza
lehet b}ovebb a modellszamok halmazanal.
A tpusertekek egy olyan intervallumat, amelynek mindket vegpontja mo-
dellszam, modell intervallumnak nevezzuk. Minden elmeleti valos szamhoz
hozzarendelhetunk egy modell intervallumot: azt a legkisebb modell inter-
vallumot, ami a szamot tartalmazza. (A modellszamokhoz egy olyan inter-
vallum tartozik, amelynek kezd}o- es vegpontja egyarant maga a szam.) A
m}uveletek es a relaciok a modell intervallumokon vannak denialva. Egy m}uvelet
eredmenye mindig az a legkisebb modell intervallum, ami tartalmazza azt a leg-
kisebb es legnagyobb matematikailag pontos eredmenyt, amit a operandus in-
tervallumok ertekeire megkaphatunk. Ha az eredmenyul kapott modell inter-
vallum valamelyik hatara abszolut ertekben nagyobb, mint a legnagyobb biz-
tonsagos szam, az NUMERIC ERROR hibat valt ki.
A valos tpusu ertekeket valos szamliteralokkal adjuk meg, az ertekekre
hasznalhatjuk a szokasos aritmetikai m}uveleteket (a hatvanyozas kitev}oje egesz
szam kell legyen), es a matematikai konyvtar fuggvenyeit (pl. SIN, COS, SQRT).
A valos tpusokon ertelmezve vannak a szokasos rendezesi relaciok is.
<real type denition> ::= <oating point constraint>
j<xed point constraint>
Az Ada valos tpusai ket osztalyba sorolhatok: xpontos es lebeg}opontos

szamok.
Tpusok 19
4.4.1. Lebeg}opontos tpusok

A lebeg}opontos szamok egy x hosszusagu mantisszabol, es egy ehhez tartozo
el}ojeles egesz exponensb}ol allnak. Normalizalt formanak hvjuk azt az alakot, ami-
kor a mantissza egeszresze nulla, s az els}o tizedesjegy nullatol kulonboz}o (elte-
kintve a 0.0 szam esetet}ol).
<oating point constraint> ::= <oating accuracy denition>
<range constraint> ]
<oating accuracy denition> ::= digits <static simple expression>
Az Ada a FLOAT predenit lebeg}opontos tpust vezeti be, aminek az abrazolasa
implementaciofugg}o. Ezert a programokban altalaban nem ezt, hanem az ebb}ol
szarmaztatott tpusokat hasznaljuk.
type REAL is new FLOAT
Egy lebeg}opontos valos tpus pontossagat ugy denialhatjuk, hogy megad-
juk a mantissza abrazolasahoz szukseges decimalis jegyek szamat. Jelolje ezt most
D. A ltalaban a gepeken az abrazolas kettes szamrendszerben tortenik, a mo-
dellszamok mantisszajanak abrazolasahoz B bitre van szukseg, ahol B = D
log(10)=log(2) + 1. A modellszamokra a kitev}o ertektartomanyat az Ada pon-
tosan denialja: ez a ;4 B .. 4 B tartomany.
type REAL is new FLOAT digits 10
vagy rovidebben
type REAL is digits 10
Peldak lebeg}opontos tpusok denialasara:
type MY FLOAT is digits 8 range ;1.0E20 .. 1.0E20 ;; helyes
X : MY FLOAT
Z : MY FLOAT range ;1000.0 .. 1000.0
type COEFFICIENT is digits 10 range ;1.0 .. 1.0
type MASS is new REAL digits 7 range 0.0 .. 1.0E10
Az egesz-lebeg}opontos ill. lebeg}opontos-egesz szamkonverziora a kovetkez}o
ket fuggvenyt hasznalhatjuk:
FLOAT(integer value)
INTEGER(oat value) ;; csonk tas a tortresz elhagyasaval
A lebeg}opontos tpusok attributumai:

T'DIGITS ugyanaz a digits ertek, amit a t pus
den ciojaban megadtunk
T'MANTISSA a t pus ertekei mantisszajanak abrazolasahoz
felhasznalt bitek szama
T'EPSILON az 1.0 es az azt kovet}o els}o modellszam elterese
T'SMALL a t pus legkisebb pozit v modellszama
20 Ada
T'LARGE a t pus legnagyobb modellszama

T'EMAX a t pus legnagyobb (normalizalt) modellszamanak kitev}oje
Az attributumokra ervenyesek az alabbi egyenletek:
T'EMAX = 4 * T'MANTISSA (den cio szerint)
T'EPSILON = 2.0 ** (1 ; T'MANTISSA)
T'SMALL = 2.0 ** (;T'EMAX ; 1)
T'LARGE = 2.0 ** T'EMAX * (1.0 ; 2.0 ** (;T'MANTISSA))
4.4.2. Fixpontos tpusok

<xed point constraint> ::= <xed accuracy denition>
<xed accuracy denition> ::= delta <static simple expression>
Az Adaban nincs predenit xpontos tpus, de a programozo denialhat x-
pontos tpusokat. A xpontos szamokat x szamu szamjeggyel, es egy kepzeletbeli
tizedesponttal abrazoljuk. Ha a tortresz k db jegyb}ol all, akkor a 10;k erteket az
adott xpontos szamhoz tartozo delta-nak nevezzuk.
type MY FIXED is delta 0.01 range ;100.0 .. 100.0
Ez a dencio azt jelenti, hogy a szamok ket tizedesjegyet tartalmaznak, gy a
fenti tpus abrazolasahoz 1+7+7=15 bit szukseges (7 bit az egeszresz, es 7 bit
a tortresz abrazolasahoz). Mivel a szamtogepeken a szamok abrazolasa kettes
szamrendszerben tortenik, ezert a tpus ertekei nem az x 10;k , hanem az x 2;p
szamok, ahol p a legkisebb olyan pozitv egesz, amire 2;p 10;k (x alkalmas
egesz). A 2;p szamot a tpushoz tartozo small erteknek nevezzuk.
DEL : constant := 1.0 / 2 ** (WORD LENGTH ; 1)
type FRAC is delta DEL range ;1.0 .. 1.0 ; DEL
;; FRAC gy egy olyan t pus, ami egy egesz szot elfoglal
type VOLT is delta 0.125 range 0.0 .. 255.0
subtype S VOLT is VOLT delta 0.5
A xpontos-integer konverziora a xpontos tpus neve hasznalhato konverzios
fuggvenykent.
A1 : AFIX A2 : AFIX C : CFIX I : INTEGER
C := CFIX(A1 * A2)
I := INTEGER(A1 * A2)
Mivel a delta erteket 10-es szamrendszerben adjuk meg, small erteke pedig
kett}o hatvanya, ezert a xpontos tpusok ertekei pontatlanok is lehetnek.
type CENTS is delta 0.01 range 0.0 .. 1.0
A 0.01 pontossag helyett small erteke 1/128 (= 0.0078...). Ezert, ha pl. a
0.05 erteket a CENTS tpusba konvertaljuk, akkor ott a 0.046... erteket kap-
Tpusok 21
juk. Azert, hogy az ilyen hibakat elkeruljuk, celszer}u reprezentacios el}orassal de-
nialni a tpushoz a small erteket (ld. 13.):
type CENTS is delta 0.01 range 0.0 .. 1.0
for CENTS'SMALL use 1.0 / 2 ** (WORD LENGTH ; 1)
A xpontos tpusok attributumai:
T'DELTA ugyanaz a delta ertek, amit a t pus
den ciojaban megadtunk
T'MANTISSA a t pus ertekei mantisszajanak abrazolasahoz
felhasznalt bitek szama
T'SMALL a t pus legkisebb pontosan abrazolt pozit v erteke
T'LARGE a t pus legnagyobb pontosan abrazolt erteke
Az attributumokra ervenyes az alabbi egyenlet:
T'LARGE = (2 ** T'MANTISSA - 1) * T'SMALL
4.5. Tomb tpusok

A tomb egy olyan osszetett tpus, ami ket komponens tpusbol, az in-
dextpusbol es az elemtpusbol all. Minden tpusertek az elemtpusbol vett ertekek
sorozata, amiket az indextpusbol vett ertekekkel folyamatosan sorszamoztunk.
Az elemtpus barmilyen tpus, az indextpus barmilyen diszkret tpus lehet. A
tombnek tobb indexe is lehet.
<array type denition> ::= <unconstrained array denition>
j<constrained array denition>
<unconstrained array denition> ::= array ( <index subtype denition>
f , <index subtype denition>g ) of <component subtype indication>
<constrained array denition> ::= array <index constraint> of
<component subtype indication>
<index subtype denition> ::= <type mark> range <>
<index constraint> ::= ( <discrete range> f , <discrete range>g )
<discrete range> ::= <discrete subtype indication>j<range>
A tomb tpus denialasanak ket formaja van : a hatarozott es a hatarozatlan
indexhatarral valo denialas.
type TABLAZAT is array (INTEGER range 1 .. 6) of INTEGER
type VECTOR is array (INTEGER range <>) of INTEGER
type MATRIX is
array (INTEGER range <>, INTEGER range <>) of REAL
type SCHEDULE is array (NAP) of BOOLEAN
A : MATRIX(1 .. 2, 1 .. 5)
MIX : array (COLOR range RED .. GREEN) of BOOLEAN
INVERSE : MATRIX (1 .. N, 1 .. N) ;; N lehet valtozo is
Z : constant MATRIX := ((0.0,0.0),(0.0,0.0))
Bar egy tomb tpusban az indexhatarok lehetnek hatarozatlanok, egy objek-

22 Ada
tum (valtozo vagy konstans) indexhatarai mar mindig hatarozottak kell legye-
nek. Egy hatarozatlan indexhataru tomb tpusbol indexmegszortas megadasaval
kepezhetunk olyan altpust, amely mar alkalmas objektumok denialasara. Szere-
pelhet viszont meghatarozatlan meret}u tomb alprogram formalis parameterekent
(ld. a kovetkez}o peldat), ilyenkor az alprogram meghvasakor az aktualis pa-
rameter denialja az indexhatarokat.
procedure ADD TO(A:in VECTOR B:in out VECTOR) is
begin ;; Feltetelezzuk, hogy A'RANGE = B'RANGE.
for I in A'RANGE loop
B(I) := B(I) + A(I)
end loop
end ADD TO
<indexed component> ::= <prex> ( <expression> f , <expression>g )
<slice> ::= <prex> ( <discrete range> )
A tombok elemeire a szokasos modon, indexelessel hivatkozhatunk. Pl.
MIX(RED), M(I,J), vagy vektorokb ol kepzett vektor eseten X(I)(J). Ha ervenyes
a
type FRAME is access MATRIX
tpusdencio (ld. 4.7.) es a
function NEXT FRAME(K:POSITIVE) return FRAME
fuggvenydencio (ld. 6.1.), akkor NEXT FRAME(L)(I,J) is szabalyos indexeles.
Tehat nemcsak a valtozok, hanem a tomberteket visszaado fuggvenyhivatkozasok
is indexelhet}ok.
Az Adaban nemcsak a vektor egeszere vagy egy elemere, hanem pl.
V1(TOL..IG) form aban a vektor egy reszere is lehet hivatkozni. (Megje-
gyezzuk, hogy V1(1..1) es V1(1) nem egyenertek}u!)
V1,V2 : VECTOR(0 .. 9)
V3 : VECTOR(1 .. 10)
V4 : VECTOR(0 .. 10)
V1 := V2
V3 := V1
V3(1) := V4(0)
V1(0 .. 4) := V2(5 .. 9)
V4(0 .. 9) := V1
V4 := V1 ;; szintaktikusan hibas
V4(0) := V1(0 .. 4)(K);; helyes, ha 0 K 4
A tombokre alkalmazhato az = es a /= relacio, tovabba tetsz}oleges diszk-
ret ertek}u vektorokra a <, <=, >, >= (lexikograkusan ertelmezett) relaciok,
azonos hosszusagu logikai vektorokra az and, or, xor, not m}uveletek (amelyek
eredmenye olyan logikai vektor, amelynek indexhatarait a baloldali argumentum
indexhatarai adjak), es altalaban a vektorokra a konkatenacio (&). A konkatenacio
Tpusok 23
egyik operandusa lehet skalar is.

A tombokkel kapcsolatban hasznalhato attributumok a kovetkez}ok (itt X egy
k-dimenzios tomb, n egy statikus kifejezes) :
X'FIRST(n) az n. index kezd}oerteke
X'LAST(n) az n. index vegerteke
X'LENGTH(n) = X'LAST(n) ; X'FIRST(n)+1
X'RANGE(n) = X'FIRST(n) .. X'LAST(n)
(n = 1 esetben n a zarojelekkel egyutt elhagyhato.) A tomb lehet ures is, ekkor

dencio szerint X'LAST = X'FIRST ; 1.
<aggregate> ::= ( <component association> f , <component association>g )
<component association> ::= <choice> f j <choice>g => ] <expression>
A tomb es rekord tpusu osszetett ertekeket az Ada aggregatumnak nevezi. Az
aggregatumokat ketfelekeppen lehet megadni. Pozcios formaban,
A : TABLAZAT := (2, 4, 4, 4, 0, 0)
A : TABLAZAT := (2, 4, 4, 4, others > 0)
=
vagy nev szerinti formaban (ebben az esetben nem kotelez}o az ertekeket az indexek
novekv}o sorrendjeben megadni):
A := (1 => 2, 2 j 3 j 4 => 4, others => 0)
M := (1 => (1.1,1.2,1.3), 2 => (2.1,2.2,2.3))
M := (1 .. 2 => (1 .. 2 => 0.0)) :
B : TABLAZAT := TABLAZAT'(2 j 4 j 6 => 1, others => 0)
C : constant MATRIX := (1 .. 5 => (1 .. 8 => 0.0))
X : BIT VECTOR(M .. N) := (X'RANGE => TRUE)
Az others nem hasznalhato akkor, ha az aggregatum indexhatarait a

kornyezete nem hatarozza meg egyertelm}uen.
if X < (others => TRUE) then ... ;; hibas!
A STRING egy predenit vektor tpus a kovetkez}o dencioval:
type STRING is array (POSITIVE range <>) of CHARACTER
Helyesek a kovetkez}o tpusdenciok es deklaraciok:
type ROMAN DIGIT is ('I','V','X','L','C','D','M')
type ROMAN NUMBER is array(POSITIVE range <>) of ROMAN DIGIT
KILENCVENHAT : constant ROMAN NUMBER := "XCVI"
S1 : constant STRING := "GIN"
S2 : constant STRING := ('G','I','N')
S3 : constant STRING := 'G' & FUNC(0)
NULL STRING : constant STRING(1..0)
Vegul kesztunk egy eljarast a STRING tpus hasznalatanak bemutatasara:

24 Ada
procedure REVERSE STRING(S:in out STRING) is

L: constant NATURAL := S'FIRST
U: constant NATURAL := S'LAST
C: CHARACTER
begin
for I in L .. (L + U) / 2 loop
C := S(I) S(I) := S(U ; I + 1) S(U ; I + 1) := C
end loop
end REVERSE STRING
4.6. A rekord tpus

<record type denition> ::= record <component list> end record
<component list> ::= <component declaration> f<component declaration>g
j f<component declaration>g <variant part>j null
<component declaration> ::= <identier list> :
<component subtype denition> := <expression> ]
<component subtype denition> ::= <subtype indication>
A rekord egy osszetett tpus, amelynek komponens tpusai kulonboz}ok lehet-
nek. A rekordertekekben a komponensekre nevvel, un. szelektorral hivatkozha-
tunk.
type HONAP is (JAN,FEB,MAR,MAJ,JUN,JUL,AUG,SZE,OKT,NOV,DEC)
type DATUM is
record
NAP : INTEGER range 1 .. 31
HO : HONAP
EV : INTEGER
end record
type COMPLEX is
record
RE, IM : FLOAT := 0.0
end record
D : DATUM := (4,JUL,1776)
C1 : COMPLEX
C2 : COMPLEX := (1.0,2.0)
A rekord mez}oire a szokasos szelekcios jelolessel hivatkozhatunk, tehat pl.

D.EV .
<selected component> ::= <prex> . <selector>
<selector> ::= <simple name>j<character literal>j<operator symbol>j all
A rekord az egyetlen tpusfajta, ahol a tpus denciojaban megadhatok a
tpus objektumainak kezd}oertekei. Csak akkor nem hasznalhatunk kezd}oerteket,
ha a rekord limited (ld. 7.4.).
type NAME is
record
VAL : STRING(1 .. MAX SIZE)
Tpusok 25
SIZE: INTEGER range 0 .. MAX SIZE := 0

end record
Az N1:NAME deklaracio pillanataban az N1.SIZE komponens erteke 0 lesz. (A
kezdeti ertek termeszetesen felulrhato.)
A rekord aggregatumokat | a tomb aggregatumokhoz hasonloan |
ketfelekeppen is rhatjuk: vagy felsoroljuk a mez}ok sorrendjeben azok ertekeit
(ez az un. pozcios forma), vagy felrjuk a szelektorokat, es mindegyik melle
odarjuk a mez}o erteket (un. nev szerinti forma). Az utobbi esetben a mez}ok fel-
sorolasanak sorrendje kozombos.
D2 : DATUM := (4, JUL, 1776)
>
D1 : DATUM := (HO = JUL, NAP = > 4 , EV => 1776 )
Ha egy aggregatum tpusa nem egyertelm}u, akkor min}ostest hasznalhatunk:
DATUM'(4,JUL,1776).
4.6.1. A rekord diszkriminansai

<discriminant part> ::= ( <discriminant specication>
f <discriminant specication>g )
<discriminant specication> ::= <identier list> :
<type mark> := <expression> ]
<discriminant constraint> ::= ( <discriminant association>
f , <discriminant association>g )
<discriminant association> ::= <discriminant simple name>
f j <discriminant simple name>g => ] <expression>
Az Ada, ugyanugy, ahogy a tomb tpus eseteben lehet}oseget ad parameteres
tpus denialasara, megengedi a rekord tpusok parameterezeset is egy vagy tobb
parameterrel. A rekord tpus parameteret a rekord diszkriminansanak hvjuk. A
rekord diszkriminansa csak diszkret ertek lehet.
Hasonloan a hatarozatlan indexhataru tombhoz, a parameteres rekord tpus
sem alkalmas kozvetlenul objektum (valtozo vagy konstans) denialasara, sze-
repeltethet}o viszont alprogram formalis parameterekent (ilyenkor az alprogram
meghvasakor az aktualis objektum denialja a diszkriminans erteket). A rekor-
dok eseteben azonban megis picit mas a helyzet, mint a tomboknel lattuk, ui. a re-
kord diszkriminansanak lehet default erteke (ilyenkor a rekord tpus minde-
gyik diszkriminansanak kell hogy legyen default erteke). Abban az esetben, ha a re-
kord diszkriminansai default ertekkel rendelkeznek, a tpus megszortas megadasa
nelkul is hasznalhato objektum-denialasra, mert ilyenkor a diszkriminans egy-
szer}uen felveszi a default erteket.
Fontos szabaly, hogy ha a tpus felhasznalasakor explicit modon megadunk
a diszkriminanshoz egy megszortast, ezzel a tpus egy altpusat alltjuk el}o. Ha
viszont a diszkriminans default erteket hasznaljuk fel, azzal nem sz}uktjuk le a
26 Ada
tpust.
A diszkriminanssal ellatott rekord alkalmazasat mutatja be a kovetkez}o ket
pelda :
type TEXT (MAX : POSITIVE) is
record
LENGTH : NATURAL := 0
VALUE : STRING(1 .. MAX)
end record
A TEXT tpus masodik komponensenek erteke olyan string lehet, aminek maximalis
hossza MAX. A LENGTH komponenst arra hasznalhatjuk, hogy jelezzuk a VALUE
vektorban elhelyezett karaktersorozat valodi hosszat.
NAP : TEXT(9)
NAP := (9,6,"MONDAY ")
NAP : TEXT ;; csak akkor lenne rhato, ha default ertek van
Diszkriminanssal rendelkez}o rekord tpus eseteben, ha az objektum de-
nialasakor nem adunk meg megszortast (tehat a diszkriminans default erteket
hasznaljuk fel), akkor a fordtoprogram a legnagyobb valtozathoz tartozo memoriat
foglalja le.
subtype LINE RANGE is INTEGER range 1 .. 100
type LINE (SIZE: LINE RANGE := 10) is
record
VAL : array (1 .. SIZE) of CHARACTER
end record
Ha megszortas nelkul deklaralunk valtozot a LINE tpus felhasznalasaval (pl. L :
LINE), akkor a fordt o 100 karakternek foglal le helyet. Ha megadjuk a meg-
szortast, pl. L : LINE(16), akkor csak az altpus szamara foglal le he-
lyet, tehat itt most 16 karaktert.
4.6.2. Varians rekord

<variant part> ::= case <discriminant simple name> is
<variant> f<variant>g
end case
<variant> ::= when <choice> f j <choice>g => <component list>
<choice> ::= <simple expression>j<discrete range>j others
j<component simple name>
Az diszkriminans felhasznalasaval alakthato ki az un. varians reszt tartal-
mazo rekord, ami unio tpus denialasara hasznalhato.
type DEVICE is (PRINTER, DISK, DRUM)
type STATE is (OPEN, CLOSED)
type PERIPHERAL(UNIT : DEVICE := PRINTER) is
Tpusok 27
record
STATUS : STATE
case UNIT is
when PRINTER =>
LINE COUNT : INTEGER range 1 .. PAGE SIZE
when others =>
CYLINDER : CYLINDER INDEX
TRACK : TRACK NUMBER
end case
end record
subtype MMDDYY is STRING(1 .. 6)
subtype NAME TYPE is STRING(1 .. 25)
type STATUS TYPE is (DIVORCED, MARRIED, SINGLE, WIDOWED)
type SEX TYPE is (FEMALE, MALE)
type PERSON (MARITAL STATUS: STATUS TYPE := SINGLE) is
record
NAME : NAME TYPE
SEX : SEX TYPE
DATE OF BIRTH : MMDDYY
NUMBER OF DEFENDENTS : INTEGER
caseMARITAL STATUS is
when >
MARRIED = SPOUSE NAME : NAME TYPE
when >
DIVORCED = DATE OF DIVORCE
when SINGLE = > null

when >
WIDOWED = DATE OF DEATH : MMDDYY
end case
end record

Az esetmegjeloleseket (when) statikus kifejezesekkel kell megadni. Ha in-

tervallumot hasznalunk (pl. A .. B), ez nem lehet ures. Minden szobajohet}o
erteket fel kell sorolni az esetmegjelolesek kozott (vagy pedig az others lehet}oseget
kell hasznalni.) Ha egy PERIPHERAL tpusu X objektumban UNIT = PRINTER, ak-
kor X.TRACK := 1 futas kozben hibajelzest (exception-t) valt ki.
A varians reszt tartalmazo, diszkriminanssal ellatott rekord tpus olyan re-
kordertekek halmaza, amelyek feleptese kulonboz}o. Ugyanugy, ahogyan a diszkret
tpusoknal az ertekkeszlet megszortasat hasznaljuk altpuskepzesre, a varians resz
egy variansanak megkotese szolgal a rekord tpus megszortasara. Pl. a PERIPHE-
RAL tpusb ol altpust is denialhatunk:
subtype LP is PERIPHERAL(PRINTER)
L : LP := (PRINTER,OPEN,72)
Altpuskepzeskor az osszes diszkriminanst meg kell adni (vagy a pozcios, vagy

a nevvel jelolt formaban).
Tekintsuk a kovetkez}o peldat:
X : PERIPHERAL
C : PERIPHERAL(PRINTER)
X most egy olyan rekord objektum, amely a UNIT diszkriminans aktualis erteket}ol
28 Ada
fugg}oen mas-mas szerkezet}u ertekeket viselhet (ez futas kozben megvaltoztathato).

C -ben param eterezessel rogztettuk a UNIT mez}o erteket, es ez mar nem
valtoztathato meg. C csak a PRINTER variansnak megfelel}o erteket vehet fel.
Az Ada a diszkriminansokkal szemben megkoveteli meg a kovetkez}oket:
- tpusdencioban a diszkriminans csak indexmegszortaskent, a varians
resz nevekent, vagy aktualis parameterkent hasznalhato. Minden eset-
ben onmagaban kell allnia, nem szerepelhet kifejezesben.
- A varians resz neve nem kezelhet}o ugy, mint a rekord egy komponense. Csak
ugy kaphat uj erteket, ha az egesz rekord uj erteket kap.
- Ha a diszkriminanssal rendelkez}o tpus ujabb diszkriminanssal rendelkez}o
tpust tartalmaz, akkor ennek a diszkriminansa csak a kuls}o tpus diszkri-
minansaitol fugghet.
type SHAPE is (RECT, CIRCLE, POINT)
type POSITION is record X, Y : FLOAT end record
type GEOMETRIC FIGURE(S:SHAPE) is
record
PERIMETER : FLOAT
case S is
when RECT => L, B : NATURAL
when CIRCLE => RADIUS : FLOAT := 1.0
when POINT => P : POSITION
end case
end record
function AREA(F : GEOMETRIC FIGURE) return FLOAT is
PI : constant := 3.1614
begin
case F.S is
when RECT => return FLOAT(F.L * F.B)
when CIRCLE => return PI * F.RADIUS ** 2
when POINT => return 0.0
end case
end AREA
4.7. Pointer tpusok

Valamely programegyseg vagy blokk deklaracios reszeben denialt objek-
tum az illet}o egyseg memoriareszeben kap helyet. Az objektum letezesenek ideje
alatt ennek az objektumnak a merete es a cme allando, az objektumra a nevevel hi-
vatkozhatunk.
Azokat a tpusokat, amelyek objektumainak merete vagy a cme a letrehozasa
utan is valtozhat, dinamikus tpusoknak mondjuk. A dinamikus objektumokat a
programozasi nyelvekben, s gy az Adaban is, pointerekkel eptjuk fel. Az Ada a
"pointer", "pointer tpus" elnevezesek helyett az access tpus elnevezest hasznalja.
Azt a tpust, amilyen tpusu objektumokra a pointerek mutatnak, a dinamikus
tpus gy}ujt}otpusanak nevezzuk.
Tpusok 29
<access type denition> ::= access <subtype indication>

<incomplete type denition> ::= type <identier> <discriminant part> ]
<allocator> ::= new <subtype indication>j new <qualied expression>
Egy acces tpus denialasakor el}ofordulhat, hogy a dencio "rekurzv" (pl. ez
el}ofordul mar egy egyszer}u lista denciojakor is). Mivel az Adaban az a szabaly,
hogy minden azonostonak, amire hivatkozunk, mar deklaraltnak kell lennie, ezert
ilyen esetben a kovetkez}okeppen jarhatunk el :
type CELL ;; A CELL azonos tot t pusnevnek deklaraljuk,
;; ez lesz majd a pointer t pus gy}ujt}ot pusa.
type LINK is access CELL ;; Ezutan denialjuk a LINK t pust,
type CELL is ;; vegul megadjuk a gy}ujt}ot pus teljes den ciojat.
record
VALUE : INTEGER
PRED,SUCC : LINK
end record

Peldak a fenti tpus hasznalatara:

HEAD : LINK := null ;; default null ertek
NEXT : LINK
HEAD := NEXT ;; masolja a pointert
HEAD.PRED := NEXT ;; szabalyos
HEAD. all
:= NEXT. all ;; A HEAD pointer altal mutatott
;; teljes objektumra HEAD.all formaban hivatkozhatunk.
C: constant LINK := new CELL'(0,null,null)
Minden dinamikus objektum letrehozasa allokatorral tortenik. Ha nem all
rendelkezesre elegend}o memoria, a new vegrehajtasa STORAGE ERROR hibat valt ki.
HEAD : new CELL'(0,null,null)
NEXT := new CELL'(0,null,HEAD)
L := new CELL
N := new CELL'(10,L) ;; az uj az el}oz}ore mutat
Az acces tpus predenit konstansa a null. Az a pointer, amelynek az erteke

null, nem mutat objektumra. Denialhatok konstans pointerek is, amelyek va-
lamely objektumra mutatnak. Megjegyezzuk, hogy ebben az esetben a poin-
ter a konstans, es nem az objektum.
CP1 : constant ITEM PTR := new ITEM'(" ",null)
CP2 : constant ITEM PTR := CP1
CP1 := null ;; hibas, mert CP1 konstans
CP1.NAME := "+++" ;; helyes (CP2.NAME is erteket kap!)
Az access tpus gy}ujt}otpusa lehet diszkriminanssal ellatott rekord, es
hatarozatlan meret}u tomb is. Ilyen esetben legkes}obb egy objektum allokalasakor
meg kell adni a megszortast. Vagyis, miutan dinamikusan allokaltunk egy pa-
rameteres rekordot (pl. varians reszt, vagy hatarozatlan hosszusagu tombot tar-
talmazo rekordot), futas kozben a meretet mar nem valtoztathatjuk meg.
30 Ada
type P is access PERIPHERAL

V1 : P := new PERIPHERAL'( UNIT => DISK)
V2 : P := new PERIPHERAL'( UNIT => PRINTER)
V3 : P(UNIT => DISK)
type ACC STRING is access STRING
type VSTR(FIRST, LAST : INTEGER) is
record
DATA : ACC STRING(FIRST .. LAST)
end record
X : VSTR(1 .. 3)
X := (1, 3, new STRING(1 .. 3))
X : P := new PERIPHERAL (ld. 4.6.) hib as, ha PERIPHERAL -ban nincs default
ertek UNIT-ra. A masodik sorban a megszortas csak a kezdeti ertekre vonatkozik,
a negyedikben viszont V3 tpusara. Tehat (a fenti ertekek eseten) pl. V1 := V2
legalis, s}ot, V3 := V1 is az, de V3 := V2 hibas, mert V3 nem vehet fel PRINTER
szerkezet}u erteket.
A dinamikus objektumok legfeljebb addig maradnak fenn, amg a tpus de-
nciojat tartalmazo programegyseg vagy blokk aktv. A tpus hataskorenek el-
hagyasakor az Ada futtato rendszere a felszabadult teruletet ujrafelhasznalhatova
teszi. (Ha az access tpust tulsagosan magas szinten, pl. egy fordtasi egyseg speci-
kacios reszeben denialjuk, akkor egy bels}o blokkban lokalis adatok eletben ma-
radhatnak a blokkjuk megsz}unte utan is, bar ezek mar soha nem erhet}ok el.) Az
Adaban a dinamikus memoria meretet konstanskent rogztik. Mivel az Ada biz-
tonsagosan es hatekonyan kvanja kezelni a dinamikus adatokat, ezert nem tartal-
maz explicit felszabadto utastast, hanem a felszabadtast a hataskorrel hozza kap-
csolatba.
type NODE
type BRANCH is access NODE
type NODE is
record
VALUE : INTEGER
LEFT, RIGHT : BRANCH
end record
function in
SEARCH(R: BRANCH X: in INTEGER) return BOOLEAN is
begin
if R = null then return FALSE
elsif X = R.VALUE then return TRUE
elsif X < R.VALUE then return SEARCH(R.LEFT, X)
else return SEARCH(R.RIGHT, X)
end if
end SEARCH
(Megjegyzes. A dinamikus t pusok kerdeseben nem sikerul az Adanak meghaladnia a tobbi
korabeli nyelv szintjet. A pointerekkel az a baj, hogy tulsagosan is konnyen, egeszen apro prog-
ramhibakkal mar inkonzisztens adatszerkezeteket kaphatunk. Ez a fogalom alacsonyabb szint}u,
mint az Ada tobbi t pusa. Ugyanakkor, ha bevezettek volna mondjuk a lista es a graf osszetett
t pusokat, a nyelv biztonsagossagat tovabb novelhettek volna. Olyan ez, mintha nem lenne a
nyelvben while ciklus, hanem if es goto utas tasokkal kellene azt megszervezni.)
Utastasok 31
5. Utastasok
<sequence of statements> ::= <statement> f<statement>g

<statement> ::= f<label>g <simple statement>
j f<label>g <compound statement>
Az Ada programegysegek torzse egy deklaracios reszt es egy utastassorozatot
tartalmaz. Ezek az utastasok a lerasuk sorrendjeben hajtodnak vegre, s ezt a
sorrendet csak egy goto utastas vagy egy hibaesemeny fellepese valtoztathatja
meg.
<simple statement> ::= <null statement>j<assignment statement>
j<procedure call statement>j<exit statement>j<return statement>
j<goto statement>j<entry call statement>j<delay statement>
j<abort statement>j<raise statement>j<code statement>
<compound statement> ::= <if statement>j<case statement>
j<loop statement>j<block statement>j<accept statement>
j<select statement>
<label> ::= << <label simple name> >>
<null statement> ::= null
5.1. Az ertekadas
<expression> ::= <relation> f and <relation>g
j<relation> f and then <relation>g
j<relation> f or <relation>g
j<relation> f or else <relation>g
j<relation> f xor <relation>g
<relation> ::= <simple expression>
<relational operator><simple expression> ]
j<simple expression> not ] in <range>
j<simple expression> not ] in <type mark>
<simple expression> ::= <unary adding operator> ] <term>
f<binary adding operator><term>g
<term> ::= <factor> f<multiplying operator><factor>g
<factor> ::= <primary> ** <primary> ] j abs <primary>j not <primary>
<primary> ::= <numeric literal>j null j<aggregate>j<string literal>
j<name>j<allocator>j<function call>j<type conversion>
j<qualied expression>j ( <expression> )
<logical operator> ::= and j or j xor
<relational operator> ::= = j /= j < j <= j > j >=
<binary adding operator> ::= + j ; j &
<unary adding operator> ::= + j ;
<multiplying operator> ::= * j / j mod j rem
<highest precedence operator> ::= ** j abs j not
<type conversion> ::= <type mark> ( <expression> )
32 Ada
Az ertekadas arra szolgal, hogy egy kifejezes erteket egy valtozohoz rendeljuk.
<assignment statement> ::= <variable name> := <expression>
Az ertekadasban az ertek es a valtozo tpusanak meg kell egyeznie. A kifejezes
erteke nem felel meg a valtozo altpusanak, az CONSTRAINT ERROR hibat vat ki.
Az ertekadas a limited private tpusu (ld. 7.4.) valtozoktol eltekintve minden
valtozora alkalmazhato.
I,J : INTEGER range 1 .. 10
K : INTEGER range 1 .. 20
I := J ;; azonos tartomanyuak
K := J ;; osszeegyeztethet}o tartomanyuak
J := K ;; ha K > 10, akkor el}oidezi a CONSTRAINT ERROR-t
A kifejezes egy formula, ami az ertek kiszamtasat denialja. Az Ada kifejezes

megfelel a szokasos kifejezesformaknak.
Az ertekadas tombokre is alkalmazhato, ilyenkor a ket tomb elemtpusanak
es az elemszamnak meg kell egyeznie, az indexhatarok elterhetnek.
A : STRING(1 .. 31)
B : STRING(3 .. 33)
A := B ;; azonos elemszamuak
A(1 .. 9) := "tar sauce"
A(4 .. 12) := A(1 .. 9) ;; A(1 .. 12) = "tartar sauce"
;; es nem A(1 .. 12) = "tartartartar" !
5.2. Az if utastas
<if statement> ::= if <condition> then <sequence of statements>
f elsif <condition> then <sequence of statements>g
else <sequence of statements> ]
end if
<condition> ::= <boolean expression>
Az if utastas szemantikajat az Ada a szokasos modon (pl. mint a Modula-
2) hatarozza meg.
if MONTH = DECEMBER and DAY = 31 then
MONTH := JANUARY
DAY := 1
YEAR := YEAR + 1
end if
if INDENT then
CHECK LEFT MARGIN LEFT SHIFT
elsif OUTDENT then
RIGHT SHIFT
else
CARRIAGE RETURN CONTINUE SCAN
end if
Utastasok 33
if MY CAR.OWNER.VEHICLE /= MY CAR then

FAIL("Incorrect record")
end if
5.3. A case utastas

<case statement> ::= case <expression> is
<case statement alternative> f<case statement alternative>g
end case
<case statement alternative> ::= when <choice> f j <choice>g =>
<sequence of statements>
A case utastasban vagy hasznalni kell az others agat, vagy pedig a kife-
jezes minden lehetseges erteket fel kell sorolni a when agak kozott, es mindegyi-
ket pontosan egyszer.
subtype UP TO 20 is INTEGER range 1 .. 20
VAL : UP TO 20
case VAL is
when 1 .. 3 j 5 j 7 j 11 j 13 j 17 j 19 => DO PRIME
when others => null ;; Ha az others szot hasznaljuk, az
end case ;; utolso agban kell lennie.
case BIN NUMBER(COUNT) is
when 1 => UPDATE BIN(1)
when 2 => UPDATE BIN(2)
when 3 j 4 => EMPTY BIN(1) EMPTY BIN(2)
when others => raise ERROR
end case
case TODAY is
when MON => INITIAL BALANCE
when FRI => CLOSING BALANCE
when TUE .. THU => REPORT(TODAY)
when SAT j SUN => null
end case
5.4. Ciklus utastasok

<loop statement> ::= <loop simple name> : ] <iteration scheme> ] loop
end loop <loop simple name> ]
<iteration scheme> ::= while <condition>
j for <loop parameter specication>
<loop parameter specication> ::= <identier> in reverse ]
<discrete range>
A ciklusnak harom formaja hasznalatos. Az egyik a tradicionalis iteracio
ciklusvaltozo segtsegevel (a for ciklus ures tartomany eseten egyszer sem hajtja
vegre a ciklusmagot):
34 Ada
for I in 1 ..
MAX NUM ITEMS loop
GET NEW ITEM(NEW ITEM)
MERGE ITEM(NEW ITEM.STORAGE FILE)
exit when
NEW ITEM = TERMINAL.ITEM
end loop
for J in reverse BUFFER'RANGE loop
if BUFFER(J) /= SPACE then
PUT(BUFFER(J))
end if
end loop
A ciklusvaltozo a ciklus lokalis konstansa, amit a ciklus els}o soraban deklaralunk.
A masodik forma a while tpusu ciklus :
SUM := 0
whileNEXT /= null loop

SUM := SUM + NEXT.VALUE
NEXT := NEXT.SUCC
end loop
while BID(N).PRICE < CUT OFF.PRICE loop
RECORD BID(BID(N).PRICE)
N := N + 1
end loop
A harmadik forma egy feltetel nelkuli ciklus, aminek a megszaktasat az exit

utastassal erhetjuk el (ld. 5.6.).
loop
;;
exit when FELTETEL
;;
end loop
A ciklusnak nevet is adhatunk. Ennek formaja az, hogy a ciklusfej el}ott,
attol kett}osponttal elvalasztva lerunk egy azonostot. A ciklusnevnek az exit
utastasban, es egymasbaagyazott ciklusok eseten van szerepe.
A1 : for I in ... loop
A2 : for I in ... loop
... B(A1.I) ...
end loop A2
end loop A1
(Feladat. Az Ada nem tartalmaz a Modula-2 REPEAT utas tasahoz hasonlo, un. posttest
iteration ciklust. Tervezzunk egyet, ami jol illik az Ada tobbi ciklusahoz!)
5.5. A blokk utastas

Blokkot kepezni az Ada programban nemcsak alprogram kialaktasaval, ha-
nem declare utastassal is lehet.
Utastasok 35
<block statement> ::= <block simple name> : ]

<declare declarative part> ]
begin <sequence of statements>
exception <exception handler f<exception handler>g
end <block simple name> ]
A declare a kovetkez}o helyzetekben hasznalhato el}onyosen:
- Ha egy nagy adatstrukturara van szukseg a program egy rovid szakaszan.
Ebben az esetben a struktura deklaralhato egy blokkban, gy a memoriat a
program csak arra az id}ore terheli meg, amg a struktura aktv.
declare
TEMP : T
begin
TEMP := A A := B B := TEMP
end
- Az Ada megengedi olyan objektumok denialasat, amelyek meretet futasi
id}oben szamtjuk ki. Van ugy, hogy a meretet nem lehet egy kifejezessel
megadni, egy keves szamtast is el kell vegezni a valtozo deklaracioja el}ott.
Egy lehetseges megoldas ilyenkor a declare utastas hasznalata.
A:VECTOR(N)
...
M := A'FIRST
while and then A(M) /= 0 loop
M /= A'LAST
M := M + 1
end loop
declare
B:VECTOR(M)
begin
...
end
- Mar egy deklaracios resz nelkuli blokktorzs is lehet}ove teszi, hogy a blokkban
hibakezel}o programreszt (exception handler, ld. 8.) helyezzunk el.
begin
A := C / B
exception
when OVERFLOW => A := INTEGER'LAST
when UNDERFLOW => A := INTEGER'FIRST
end
A blokkban hasznalhatjuk annak lokalis azonostoit, es a blokkot magaba
foglalo egysegben lathato azonostokat, mint globalis neveket. Ha nevazonossag
fordul el}o, szelekcios jelolessel (pl. X.A) hivatkozhatunk a kvant objektumra.
KULSO: declare
I,J:INTEGER
begin
36 Ada
;; I,J:INTEGER kozvetlenul elerhet}o

BELSO: declare
I:MY INT
begin
;; I:MY INT es J:INTEGER kozvetlenul elerhet}o, de
;; I:INTEGER csak KULSO.I alakban erhet}o el
end BELSO
;;
end KULSO
5.6. Az exit utastas

<exit statement> ::= exit <loop name> ] when <condition> ]
Az exit utastas elhelyezhet}o barmely ciklusmagban. Hatasara a vezerles a
ciklus utani els}o utastasra adodik at.
loop
text io.get(CH)
exit when CH = '.'
if CH = '(' or CH = ')' then
text io.put(CH)
end if
end loop
KULSO: loop
;;
loop
;;
exit KULSO when FELTETEL
;;
end loop
;;
end loop KULSO
5.7. A return utastas

<return statement> ::= return <expression> ]
A return utastas hatasara az alpogram vegrehajtasa befejez}odik. Fuggveny
eseten a return utastasban adjuk meg a fuggveny eredmenyet is.
A fuggveny eredmenyenek tpusara az Ada nem tesz megkotest, gy az nem-
csak skalar, hanem osszetett tpus is lehet.
5.8. A goto utastas

<goto statement> ::= goto <label name>
A goto utastasra a nyelvben valojaban nincsen nagy szukseg. Azert vettek
Utastasok 37
be az utastaskeszletbe, mert van olyan helyzet, amikor a kodot rovidebbe lehet

tenni goto hasznalataval.
<<COMPARE>>
if A(I) < ELEMENT then
if LEFT(I) /= 0 then
I := LEFT(I)
goto COMPARE
end if
;; utas tasok
end if
38 Ada
6. Alprogramok
6.1. Alprogram de ncioja

<subprogram declaration> ::= <subprogram specication>
<subprogram specication> ::= procedure <identier> <formal part> ]
j function <designator> <formal part> ] return <type mark>
<designator> ::= <identier>j<operator symbol>
<operator symbol> ::= <string literal>
<formal part> ::= ( parameter specication> f <parameter specication>g )
<subprogram body> ::= <subprogram specication> is
<declarative part> ]
exception <exception handler> f<exception handler>g ]
end <designator> ]
Az Ada nyelv ketfele alprogramot ismer: az eljarast es fuggvenyt. Az alprog-
ramok ket f}o reszb}ol allnak: a specikacios resz tartalmazza az alprogram pa-
rametereinek (es fuggveny eseten az eredmenynek) a lerasat, a torzs tartal-
mazza az alprogram megvalostasat. A torzs maga is ket reszre oszthato: a dek-
laracios resz tartalmazza az alprogram lokalis deklaracioit, a torzs utastasresze pe-
dig az alprogram hatasat denialo utastasokat.
A specikacios resz valamely deklaracios reszben onalloan is allhat, ekkor
az a szerepe, hogy deklaralja az alprogram nevet, ami a programszoveg tovabbi
reszeben gy mar felhasznalhato az alprogram aktivizalasara. A torzs sohasem all
onmagaban, mindig megel}ozi a specikacios resz.
procedure A ;; onmagaban allo specikacios resz
procedure B is
begin
A
end B
procedure A is
begin
;; utas tasok
end A
(Megjegyzes. Az Ada tervez}oi sem vallalkoztak ra, hogy az alprogramok specikaciojahoz
olyan elemeket illesszenek, amellyekkel a programozo le rhatja az alprogram feladatat, vagy
legalabb az el}ofeltetelet. Termeszetesen olyan formalis le rasra gondolunk, amit a futtato rend-
szer ellen}orzesre fel tud hasznalni. Ilyen megoldasokra mas nyelvekben vannak k serletek, azon-
ban a kifejlesztett specikacios nyelvek tulsagosan primit vek. A problema jo megoldasanak
haszna oriasi lenne.)
Pelda fuggvenyre :
Alprogramok 39
type VECTOR is
array (INTEGER range <>) of REAL
function INNER(A,B:VECTOR) return REAL is
SUM : REAL := 0.0
begin
for I in A'RANGE loop
SUM := SUM + A(I) * B(I)
end loop
return SUM
end INNER
A fuggveny visszateresi erteke lehet akar tomb vagy rekord is, s}ot, az osszetett
tpusu erteket visszaado fuggvenyek hvasara alkalmazhatok a tpus tpusm}uveletei
is. Tehat, ha pl. F egy vektor ertek}u fuggveny, akkor szabalyos az F(X)(1)
indexeles, ami az eredmenyvektor 1 -es index}u elemet adja meg, s ugyangy, ha F
egy rekord ertek}u fuggveny, akkor szabalyos az F(X).S akalu szelekcios kifejezes
(ha S a rekord egy szelektora).
Pelda eljarasra :
procedure ADD TO LIST(L:in out LINK V:in INTEGER) is
NEXT : LINK
begin
NEXT := new CELL'(V,null,L)
if L /= null then
L.PRED := NEXT
end if
L := NEXT
end ADD TO LIST
6.2. Alprogram hvasa

<procedure call statement> ::= <procedure name>
<actual parameter part> ]
<function call> ::= <function name> <actual parameter part> ]
<actual parameter part> ::= ( <parameter association>
f , <parameter association>g )
<parameter association> ::= <formal parameter> => ] <actual parameter>
<formal parameter> ::= <parameter simple name>
<actual parameter> ::= <expression>j<variable name>
j<type mark> ( <variable name> )
Az el}oz}o pontban denialt INNER fuggvenyt gy hasznalhatjuk :
declare
P,Q : VECTOR(1 .. 100)
R:REAL
begin
...
40 Ada
R := INNER(P,Q)
...
end
Parameterek nelkuli fuggvenyek eseteben az ures parameterlistat jelkepez}o

zarojelpart is elhagyjuk.
Az Ada alprogramjai meghvhatjak onmagukat is. Megengedett a kozvetlen
rekurzio, s az is, hogy egy alprogram egy hvasi lancolaton keresztul hvja meg
onmagat (pl. A hvja B -t, B hvja C, C hvja A -t).
type MATRIX is
array (INTEGER range <>, INTEGER range <>) of REAL
function DETERMINANT(X : MATRIX) return REAL is
D : REAL := 0.0
B : array (X'RANGE(2)) of BOOLEAN := (others => FALSE)
procedure THREAD(P:in REAL E:in INTEGER I:in INTEGER) is
F : INTEGER
begin
if I > X'LAST(1) then
D := D + P * REAL((;1) ** E)
elsif P /= 0.0 then
F := 0
for J in reverse X'RANGE(2) loop
if B(J) then
F := F + 1
else
B(J) := TRUE
THREAD(P * X(I,J), E + F, I + 1)
B(J) := FALSE
end if
end loop
end if
end THREAD
begin
if X'LENGTH(1) /= X'LENGTH(2) then raise MATRIX ERROR end if
THREAD(1.0, 0, X'FIRST(1))
return D
end DETERMINANT
Az eljarashvas hagyomanyos formajaban az aktalis parameterek megfelel-
tetese a formalis parametereknek pozcio szerint tortenik: az els}o aktualis pa-
rametert megfeleltetjuk az els}o formalis parameternek, a masodikat a masodiknak
stb.
ADD TO LIST (HEAD,3)
Az Adaban ezen kvul (az eljaras- es a fuggvenyhvasokban egyarant)

hasznalhato meg a nevvel jelolt forma is, ahol az aktualis parametert megel}ozi
a formalis parameter neve:
ADD TO LIST (L => HEAD, V => 3)
Alprogramok 41
A nevvel jelolt esetben az aktualis parameterek sorrendje tetsz}oleges. A pa-

rameterek megfeleltetesenek ketfele jelolese keverhet}o is, de ekkor a pozicionalisan
megadott parametereknek kell elol allniuk.
ADD TO LIST (HEAD, V => 3)
6.3. Parameteratadas
Az aktualis-formalis parametermegfeleltetesre ugyanaz a szabaly vonatkozik,
mint az ertekadasra: az aktualis es a formalis objektum tpusanak meg kell egyezni.
A formalis parameter lehet egy hatarozatlan indexhataru tomb, vagy egy
diszkriminanssal rendelkez}o rekord tpus is, ekkor az aktualis parameter adja meg
a megszortast.
<parameter specication> ::= <identier list> : <mode><type mark>
:= <expression> ]
<mode> ::= in ] j in out j out
A parameteratadas modja szempontjabol az alprogramok parameterei
haromfelek lehetnek:
- in | a formalis parameter lokalis konstans, amelynek erteket az aktualis
parameter adja meg (az alprogramban nem modosthato az erteke)
- out | a formalis parameter az alprogram valtozoja, ami az alprogram
szamtasanak eredmenyet viseli, es ezt az erteket kapja meg az aktualis pa-
rameter (az alprogramban nem hivatkozhatunk az ertekere)
- in out | a formalis parameter az alprogram valtozoja, ami felveszi az aktualis
parameter erteket, es a szamtas vegen erteket ad vissza az aktualis pa-
rameternek.
Ha a formalis parameter mell}ol a jelzest elhagyjuk, akkor a felteteltezes in.
Fuggvenynek csak in fajtaju parametere lehet.
Az aktualis parameter egy tpuskonverzio is lehet. Ekkor in es in out modu
parameter eseten a parameteratadas el}ott, in out es out modu parameter eseten
az ertekek visszaadasakor tortenik meg a konvertalas.
Ha az alprogram vegrehajtasa egy exception kivaltasaval fejez}odik be, akkor a
visszatereskor az in out es az out modu parametereknek megfelel}o valtozok erteke
denialatlan.
Parameteratadaskor ellen}orzesre kerul az is, hogy az ertekek megfelelnek-e a
megszortasoknak. Skalar tpusok eseten
- a parameteratadas el}ott: az in es in out parametereknel ellen}orzesre kerul,
hogy az ertekek eleget tesznek-e a formalis tpus megszortasanak
- a parameterertekek visszaadasa el}ott: az in out es out parametereknel el-
len}orzesre kerul, hogy az ertekek eleget tesznek-e az aktualis tpus meg-
42 Ada
szortasanak.
Minden mas tpus eseten az Ada csak a belepeskor ellen}orzi a parametereket,
s a skalarokra vonatkozo szabalyt alkalmazza.
(Megjegyzes. Ha egy in out modu formalis parameter t pusa, vagy annak egy kompo-
nensenek t pusa alt pus, pl. NATURAL, s az aktualis parameter meg nem kapott erteket, az az
eljarasba valo belepeskor futasi hibat okozhat. Ha meggondoljuk, hogy egy absztrakt t pus vek-
torral valo reprezentalasakor a vektor egyes elemei kezdetben nem rendelkeznek ertekkel, ak-
kor latjuk, hogy az Ada szigoru ellen}orzesi mechanizmusa milyen konnyen lehet kellemet-
len is.)
A pointerek es a skalar ertekek atadasakor az Ada el}orja, hogy minden nyelvi
implementacio ugy koteles az parameteratadast megvalostani, hogy in es in out
eseten a hvas el}ott az erteket egy lokalis valtozoba atmasolja, in out es out eseten
visszatereskor az erteket visszamasolja az aktualis parameterbe. Az osszetett
tpusu ertekek atadasara az Ada megengedi a fordtoprogram szamara az ertek sze-
rinti es a cm szerinti parameteratadas kozotti valasztast.
(Feladat. Kesz tsunk olyan eljarast, amivel megallap thatjuk, hogy a rendelkezesunkre allo
Ada ford toprogramban a tombok atadasa ertek szerint, vagy c m szerint tortenik-e!)
6.4. A formalis parameterek default erteke

Az Ada erdekes lehet}osege, hogy az in modu parametereknek feltetelezett be-
men}o erteke lehet. Az alprogram specikacios resze tartalmazza ezt a feltetelezett
erteket, amit akkor vesz fel a formalis parameter, ha neki megfelel}o aktualis pa-
rametert nem adtunk meg.
type SPIRIT is (GIN,VODKA)
type STYLE is (ON THE ROCKS,STRAIGHT UP)
type TRIMMING is (OLIVE,TWIST)
Ha feltetelezett ertekeket hasznalunk, akkor az alprogram specikaciojat gy
adjuk meg:
procedure DRY MARTINI
(BASE :in SPIRIT := GIN
HOW :in STYLE := ON THE ROCKS
WITH :in TRIMMING := OLIVE)
Itt BASE, HOW es WITH a formalis parameterek.

(Megjegyzes. Az alprogramok parametereit altalaban ket osztalyba sorolhatjuk: az
egyikbe azok a parameterek tartoznak, amelyeken az alprogram a f}o operaciot vegzi, vagy en-
nek eredmenyet adja vissza, a masikba azok a parameterek, amelyek ehhez a f}o funkciohoz
kiegesz t}o adatkent szolgalnak. Peldaul egy egyenes szakaszt rajzolo eljarasnak alapvet}o pa-
rametere a szakasz ket vegpontja, kiegesz t}o parametere a vonal vastagsaga. Az ilyen, kiegesz t}o
parameterekhez adunk meg altalaban default erteket. A default parameterertekek beve-
Alprogramok 43
zetese kenyelmesebbe is teszi az alprogramok hasznalatat, es altalanosabb alprogramok rasat

is seg ti.)
A fenti eljarast pl. a kovetkez}o formaban hvhatjuk:
DRY MARTINI ( VODKA,WITH => TWIST )
DRY MARTINI ( HOW => STRAIGHT UP )
DRY MARTINI
6.5. Alprogramok atlapolasa

Korabban mar lattuk, hogy a felsorolasi tpusok konstansai atlapolhatok, azaz
tobb tpusnak is lehet ugyanolyan nev}u erteke. Ekkor egy ilyen literal eseten
az, hogy melyik tpus erteker}ol van szo, a szovegkornyezetb}ol derthet}o ki. Az
alprogramok eseteben hasonlo dologra van lehet}oseg. E rvenyben lehet egyszerre
pl. a kovetkez}o harom alprogram :
procedure SET(EZ A NAP:in NAP)
procedure SET(S:in SZIN)
procedure SET(A:in ALLAPOT)
Ekkor kulonboz}o alprogramok aktivizalasat jelentik a SET(HETFO) ill. a
SET(PIROS) elj arashvasok. Ha pl. PIROS maga is atlapolt konstans, ak-
kor min}ostest kell alkalmaznunk, es az utastast gy kell rni :
SET(SZIN'(PIROS))
Ezekutan meg kell hataroznunk, hogy ket alprogramspecikacio mikor egye-

zik meg, ill. mikor kulonboznek. Ket alprogramspecikacio akkor egye-
zik meg, ha azok ugyanazokat a szintaktikus elemeket ugyanolyan sorrend-
ben tartalmazzak, amennyiben azonban a specikaciok szamokat is tartalmaz-
nak, azok ertekenek (es nem az rasformajuknak) kell megegyezni. Tehat az alabbi
ket P eljaras specikacioja megegyezik, a ket Q eljarase kulonbozik:
procedure P --
(A:in INTEGER := 32)
procedure P(A : in INTEGER := 16#20#)
function Q(A:in INTEGER)
function Q(A: INTEGER)
44 Ada
6.6. Az operatorok atlapolasa

Az alprogramok neve lehet azonosto, mint korabban is lattuk, de fel-
hasznalhatjuk a nyelv operatorait is fuggvenyeink nevekent. Peldaul denialhatjuk
a vektorok kozotti szorzast a "*" nevvel:
function "*"(A,B:VECTOR) return REAL is
...
end "*"
Ez a "*" m}uvelet atlapolasat jelenti. Ezutan a vektorok kozotti szorzast R :=
P * Q alakban rhatjuk. (Az eg eszek, valosak, stb. kozotti szorzas m}uveleti
jele tovabbra is a "*" marad.) Ha a "*" szerepel valahol a programban, es nem
volna egyertelm}u, hogy melyik "*" fuggvenyr}ol van szo, akkor a fenti ertekadas
min}ostessel rhato:
R := VECTOR'(P) * VECTOR'(Q)
Egy masik, teljesebb peldat is mutatunk. Tf. denialtuk a kovetkez}o tpust :

type IRANY is (E,EK,K,DK,D,DNY,NY,ENY)
A relacios operatorok (=, /=, <, <=, >, >=, in, not in) es a diszkret tpus att-
ributumai automatikusan biztostottak a tpus szamara. Ha tovabbi m}uveletekre
is szuksegunk van, azoknak a programjait magunknak kell megrnunk. Tf.
szuksegunk van egy additv m}uveletre, ahol D + M azt az iranyt jelenti, amit
ugy kapunk, hogy D -hez hozzaadunk M nyolcadot az ora jarasanak megfe-
lel}o iranyban. Ez a m}uvelet gy denialhato :
function "+"(D:IRANY M:INTEGER) return IRANY is
begin
return IRANY'VAL((IRANY'POS(D) + M) mod 8 )
end "+"
Igen veszelyes lehet a D2 := D1 + 3 + 2 formaju utastas, aminek jelenteset
zarojelezessel celszer}u egyertelm}uve tenni.
(Megjegyzes. A programozonak illik ilyenkor a "+" korabbi tulajdonsagait |pl. kommu-
tativitas| megtartani, e celbol el kell kesz teni a
function "+"(M:INTEGER D:IRANY) return IRANY is ...
fuggvenyt is.)
Ket megkotes ervenyes az operatorok atlapolasara. El}oszor: az in, a not in,
az and then es az or else relaciok nem atlapolhatok. Masodszor: az = csak akkor
atlapolhato, ha az operandusok limited private tpusuak. Meg ebben az esetben
is az = eredmenye logikai kell hogy legyen. A /= sohasem atlapolhato, am mindig
automatikusan az = eredmenyenek ellentettjet adja.
Alprogramok 45
6.7. Peldaprogramok
i) Negyzetgyokvonas
Ez a pelda azt mutatja be, hogy az Adaban altpusok bevezetesevel egy-
szer}usthet}o az el}ofeltetel ellen}orzese.
subtype NON NEGATIVE REAL is FLOAT range 0.0 .. FLOAT'LAST
subtype POSITIVE REAL is
FLOAT range FLOAT'SMALL .. FLOAT'LAST
function SQRT(X : NON NEGATIVE REAL
EPS : POSITIVE REAL) return FLOAT is
OLD VALUE : FLOAT := 0.0
NEW VALUE : FLOAT := X / 2.0
begin
while abs(NEW VALUE - OLD VALUE) > EPS loop
OLD VALUE := NEW VALUE
NEW VALUE := 0.5 * (OLD VALUE + X / OLD VALUE)
end loop
returnNEW VALUE
end SQRT
ii) Makrohelyettestesek
Egy olyan programot kesztunk, ami egy text-le-t dolgoz fel: felismeri benne
a makrodenciokat, s a makrohvasokat kicsereli a makro torzsere.
A makrodencio formaja: #dene makronev makrotorzs. A #dene szoveg
mindig a sor elejen kezd}odik. A makronev bet}ukb}ol es szamjegyekb}ol allo azo-
nosto, a makrotorzs egy szokozoket nem tartalmazo tetsz}oleges string. Egy makro
hvasa a denciojat kovet}oen barhol el}ofordulhat, kiveve a makrodencios soro-
kat.
A denialt neveket egy egyszer}u tablazatban, egy vektorban (TT, NT) tart-
juk nyilvan. Az Ada vektorm}uveletek kihasznasaval (ANALYSE) nagyon roviden
kodolhato a makroneveknek a makrotorzsekre valo kicserelese egy-egy soron belul
(gondolkozzunk el azon, hogyan oldanank ezt meg mondjuk Modula-2 -ben !).
with TEXT IO use TEXT IO
procedure PREPROCESSZOR is
;; A define neveket es ertekeket nyilvantarto tablazat:
type PNEV is access STRING
type NEVPAR is record
N, E : PNEV
end record
type TABLA is array (INTEGER range <>) of NEVPAR
TT : TABLA(1 .. 128)
NT : INTEGER := 0 ;; a t
abl
azat pillanatnyi hossza
;;
46 Ada
LINE : STRING(1 .. 128)

N : INTEGER
F, G : FILE TYPE
procedure ENTER(STR:in STRING) is
;; Az STR string egy #define utastasnak a #define
;; utani reszet tartalmazza. ENTER feladata az STR
;; alapjan egy uj par felvetele a TT tablazatba.
I : INTEGER := STR'FIRST
I0 : INTEGER
procedure LEVALASZT is
begin
while I <= STR'LAST and then STR(I) = ' '
loop I := I + 1
end loop
I0 := I
while I <= STR'LAST and then STR(I) /= ' '
loop I := I + 1
end loop
end LEVALASZT
begin
NT := NT + 1
LEVALASZT
TT(NT).N := new STRING'(STR(I0 .. I ; 1))
LEVALASZT
TT(NT).E := new STRING'(STR(I0 .. I ; 1))
end ENTER
function FIND(STR : STRING) return INTEGER is
;; Feladata: az STR nev megkeresese a TT tablazatban.
;; Visszaadja az elem indexet, ill. ;1-et, ha a nev
;; nem szerepel a tablazatban.
begin
for I in 1 .. NT loop
if TT(I).N.all = STR then return I end if
end loop
return ;1
end FIND
function ANALYSE(STR : STRING) return STRING is
;; Feladata: egy szovegsorban a makronevek kicser
el
ese
;; a makrotorzsekre.
I : INTEGER := STR'FIRST
I0 : INTEGER
K : INTEGER
function
ALPHA(CH:CHARACTER) return BOOLEAN is
begin
return (CH >= 'A' and then CH <= 'Z') or else
(CH >= 'a' and then CH <= 'z')
end ALPHA
function ALNUM(CH:CHARACTER) return BOOLEAN is
begin
return (CH >= '0' and then CH <= '9') or else
ALPHA(CH)
end ALNUM
begin
Alprogramok 47
if STR'LENGTH = 0 then return "" end if

while I <= STR'LAST and then not ALPHA(STR(I))
loop I := I + 1
end loop
I0 := I
while I <= STR'LAST and then ALNUM(STR(I))
loop I := I + 1
end loop
;; I0 az STR stringben az els}o betu} indexe,
;; vagy I0 = STR'LAST + 1.
;; I az I0 indexen kezd}od}o azonosto
;; utani pozcio
indexe, vagy I = STR'LAST + 1.
K := FIND(STR(I0 .. I ; 1))
if in
K TT'RANGE then
returnSTR(STR'FIRST .. I0 ; 1) & TT(K).E. all
&
ANALYSE(STR(I .. STR'LAST))
else
return STR(STR'FIRST .. I ; 1) &
ANALYSE(STR(I .. STR'LAST))
end if
end ANALYSE
begin
PUT("Input file = ") GET LINE(LINE, N)
OPEN(F, IN FILE, LINE(1 .. N))
PUT("Output file = ") GET LINE(LINE, N)
CREATE(G, OUT FILE, LINE(1 .. N))
while notEND OF FILE(F) loop
GET LINE(F, LINE, N)
if
LINE(1 .. 7) = "#define" then
ENTER(LINE(8 .. N))
else
PUT LINE(G, ANALYSE(LINE(1 .. N)))
end if
end loop
CLOSE(G)
CLOSE(F)
end PREPROCESSZOR
48 Ada
7. A package
A package fordtasi egysegkent is szerepeltethet}o programegyseg, es mint ilyen

a program feldarabolasanak egyik f}o eszkoze.
7.1. A package speci kacioja

<package declaration> ::= <package specication>
<package specication> ::= package <identier> is
f<basic declarative item>g
private f<basic declarative item>g ]
end <package simple name> ]
A package ket reszb}ol all, a specikacios reszb}ol es a torzsb}ol. Az el}oz}o
rja le az exportalt informaciok jellemz}oit, az utobbi tartalmazza (es egyben el-
rejti) a megvalostast. (A specikacios resz lathato reszeben megadott osszes in-
formacio exportalasra kerul.) Specialisan el}ofordulhat az is, hogy a package-nek
csak specikacios resze van, torzse nincs (pl. ha a specikacios resz csak valtozokat
tartalmaz, es ezek mint kozos adatmez}o hasznalatosak). Ha a package speci-
kacioja tartalmazza valamely programegyseg specikaciojat, akkor a program-
egyseg torzsenek a package-torzsben kell lennie.
package STACK is
procedure PUSH(X:in REAL)
function POP return REAL
end STACK
7.2. A package torzse

<package body> ::= package body <package simple name> is
exception <exception handler> f<exception handler>g ] ]
A package torzse tartalmazza a specikacios reszben felsorolt progra-
megysegek torzseit, tartalmazhat lokalis deklaraciokat, valamint tartalmazhat
egy inicializalo reszt. A kozvetlenul a torzsben denialt objektumok a pac-
kage torzsenek kiertekelesekor jonnek letre, s a package-et tartalmazo egysegb}ol
valo kilepeskor sz}unnek meg. Ugyancsak a package torzsenek kiertekelesekor
hajtodik vegre a package inicializalo resze. Konyvtari szint}u package eseten a torzs
kiertekelesere a f}oprogram vegrehajtasanak megkezdese el}ott, beagyazott pac-
kage eseten a tartalmazo deklaracios resz kiertekelesekor kerul sor.
A package 49
A torzsben kozvetlenul hivatkozhatunk a torzshoz tartozo specikacios

reszben elhelyezett barmely deklaraciora.
package body STACK is
MAX : constant := 100
S : array (1 .. MAX) of REAL
PTR : INTEGER range 0 .. MAX
procedure PUSH(X:in REAL) is
begin
PTR := PTR + 1 S(PTR) := X
end PUSH
function POP return REAL is
begin
PTR := PTR ; 1 return S(PTR + 1)
end POP
begin
PTR := 0
end STACK
A STACK package ket alprogramot denial, amelyek egy (legfeljebb 100 elem}u)
vermen vegeznek m}uveleteket. A MAX, S, PTR azonostok lokalisak, a package-
en kvulr}ol nem erhet}ok el.
7.3. A private tpus

A package-k egy fontos alkalmazasi terulete a privat tpusok kialaktasa.
<private type declaration> ::= type <identier> <discriminant part> ] is
limited ] private
<deferred constant declaration> ::= <identier list> :
constant <type mark>
A kovetkez}o peldaban megmutatjuk, hogyan epthet}o fel a privat COMPLEX
tpus, hogyan denialhatok ennek a m}uveletei, es ezutan hogyan hasznalhatja azt
a programozo.
package COMPLEX NUMBERS is
type COMPLEX is private
function "+"(X,Y:COMPLEX) return COMPLEX
function ";"(X,Y:COMPLEX) return COMPLEX
function "*"(X,Y:COMPLEX) return COMPLEX
function "/"(X,Y:COMPLEX) return COMPLEX
function CONS(R,I:REAL) return COMPLEX
function RL PART(X:COMPLEX) return REAL
function IM PART(X:COMPLEX) return REAL
private
type COMPLEX is
record RL,IM : REAL end record
end
A specikacios resz tehat ket darabra valik, az un. lathato reszre es a privat
50 Ada
reszre. A privat resz csak a package torzseben lathato, kvulr}ol nem. A privat
reszban adjuk meg a privat tpusok denciojat.
(Megjegyzes. A package-n k vuli utas tasokban nem hivatkozhatunk a privat reszban el-
rejtett informaciora. A ford toprogram viszont termeszetesen felhasznalja ezt a reszt is a
tobbi egyseg ford tasakor, pl. egy privat t pusu valtozo denialasakor a privat reszb}ol ol-
vassa el, hogy hany byte-t foglal el a valtozo. I nincs szukseg olyan jelleg}u megszor tasra,
mint a Module-2 -ben, ahol egy atlatsztlan t pus reprezentacioja csak annyi helyet foglal-
hat el, mint a WORD t pus.)
A privat tpus is parameterezhet}o. Pl. a korabban is hasznalt TEXT tpus
dencioja gy rhato fel :
type TEXT(MAX:NATURAL) is private
Ekkor a privat reszben a tpus implementaciojanak is kell tartalmaznia ugyanezt
a parametert.
A kovetkez}o peldaban dinamikus tombot tartalmazo parameterezett rekorddal
reprezentaljuk az X tpust:
package P is
subtype ARRAY RANGE is INTEGER range 0 .. 100
type X(SIZE:ARRAY RANGE) is private
;; az X t pus m}uveletei kovetkeznek itt
private
type X(SIZE:ARRAY RANGE) is
record
AY:array (1 .. SIZE) of T
end record
end P
Egy 100 hosszusagu vektor tpust hoz letre a kovetkez}o deklaracio:
F1 : X(SIZE => 100)
A lathato reszben szerepelhet privat konstans is, pl.

I : constant COMPLEX
ekkor a privat reszben meg kell adni ennek az erteket :

I : constant COMPLEX := (0.0,1.0)
A COMPLEX NUMBERS package torzse pl. ez lehet :

package body COMPLEX NUMBERS is
function "+"(X,Y:COMPLEX) return COMPLEX is
begin
return (X.RL + Y.RL, X.IM + Y.IM)
end "+"
function ";"(X,Y:COMPLEX) return COMPLEX is
begin
A package 51
return (X.RL ; Y.RL, X.IM ; Y.IM)

end ";"
function "*"(X,Y:COMPLEX) return COMPLEX is
begin
return (X.RL * Y.RL ; X.IM * Y.IM,
X.RL * Y.IM + X.IM * Y.RL)
end "*"
function "/"(X,Y:COMPLEX) return COMPLEX is
B : REAL := Y.RL ** 2 + Y.IM ** 2
begin
return ((X.RL * Y.RL + X.IM * Y.IM) / B,
(X.IM * Y.RL ; X.RL * Y.IM) / B)
end "/"
function CONS(R,I:REAL) return COMPLEX is
begin
return (R,I)
end CONS
function RL PART(X:COMPLEX) return REAL is
begin
return X.RL
end RL PART
function IM PART(X:COMPLEX) return REAL is
begin
return X.IM
end IM PART
end COMPLEX NUMBERS
Ha most pl. ezt a reprezentaciot kicsereljuk polarkoordinatas alakra, a
package-re hivatkozo egysegben semmit sem kell valtoztatni.
A COMPLEX NUMBERS package a kovetkez}o modon hasznalhato fel:
declare
use COMPLEX NUMBERS
Z : constant COMLEX := CONS(0.0,0.0)
C,D:COMPLEX
R,S:REAL
begin
C := CONS(1.5, ;0.6)
D := C + I ;; COMPLEX +
R := RL PART(D) + 6.0;; REAL +
end
(Figyeljuk meg, hogy pl. D = I helyes feltetel, de D > I nem az!)

A privat tpus m}uveletei az = es a /= relaciok, s azok az alprogramok, ami-
ket ugyanabban a specikacios reszben specikaltunk, ahol a privat tpus van,
s amelyek parameterlistajan a privat tpus szerepel. Privat tpusbol valo
szarmaztataskor a tpusm}uveletek ugyanugy atszarmaznak az uj tpusra, mint mas
tpusok eseten.
A privat reszben es a package torzseben termeszetesen hasznalhato a privat
tpus reprezentaciojabol adodo minden tpusm}uvelet.
52 Ada
7.4. A limited private tpus

A privat tpusokra az ertekadas es az =, /= relaciok ugyanugy alkalmazha-
tok, mint mas tpusok eseteben. Ez nem mindig el}onyos. (Gondoljuk meg, mi lesz
az osszehasonltas eredmenye ket verem eseten, vagy mi lesz az ertekadas hatasa
egy pointerekkel megvalostott tpus eseten.)
A limited private valtozokra csak a package-ben denialt m}uveletek alkalmaz-
hatok. A limited private valtozokra vonatkozo szabalyok:
- a limited private valtozo nem kaphat kezd}oerteket (a package-en kvul),
- a limited private tpus parametereinek nem lehet kezd}oerteke,
- a package-n kvul nem denialhato limited private konstans.
Peldakent a limited private tpusra tekintsuk meg a kovetkez}o package-t.
package I O PACKAGE is
type FILE is limited private
procedure OPEN (F:out FILE FILE NAME:in STRING)
procedure CLOSE(F:in out FILE)
procedure READ (F:in out FILE ITEM:out INTEGER)
procedure WRITE(F:in out FILE ITEM:in INTEGER)
private
type FILE is
record
;; a le-descriptor le rasa (ez gepfugg}o)
end record
end I O PACKAGE
package body I O PACKAGE is
procedure OPEN (F:out FILE FILE NAME:in STRING) is ...
procedure CLOSE(F:in out FILE) is ...
...
begin
...
end I O PACKAGE
7.5. Peldaprogramok
i) Veletlenszamok el}oalltasa
A package a nyelv legalkalmasabb eszkoze absztrakt fogalmak meg-
valostasara. Nem a tpusmegvalostas az egyetlen terulet, ahol ilyen celra al-
kalmazhatjuk a package-t. Ebben a pontban egy masfajta absztrakt fogalom imp-
lementalasara mutatunk peldat.
package RNG is
function RANDOM return FLOAT
A package 53
SEED : INTEGER
end RNG
with CALENDAR use CALENDAR
package body RNG is
MODULUS : INTEGER := 65536
MULT : INTEGER := 13849
ADDON : INTEGER := 56963
function RANDOM returnFLOAT is
begin
SEED := (SEED * MULT + ADDON) mod MODULUS
return FLOAT(SEED) / FLOAT(MODULUS)
end RANDOM
begin
SEED := INTEGER(SECONDS(CLOCK)) mod MODULUS
end RNG
ii) Halmaz megvalostasa

Az ORDERED SET package egy olyan halmazt valost meg, amelynek ele-
meit az ID diszkret tpus ertekeivel, mint kulcsokkal azonostjuk, s ezekhez a kul-
csokhoz DURATION tpusu ertekekkel megadott id}otartamok tartoznak. A SMAL-
LEST alprogramot f uggvenykent megvalostani nem volna szerencses, ennek ugya-
nis mellekhatasa van: azon kvul, hogy a legkisebb elem indexet megadja, ezt az
elemet ki is veszi a halmazbol.
type ID is range 1 .. 128
package ORDERED SET is
procedure INSERT(JOB:in ID T:in DURATION)
procedure SMALLEST(JOB:out ID)
function EMPTY return BOOLEAN
end ORDERED SET
package body ORDERED SET is
IN SET : array (ID) of BOOLEAN := (ID => FALSE)
RANK : array (ID) of DURATION
procedure INSERT(JOB:in ID T:in DURATION) is
begin
IN SET(JOB) := TRUE RANK(JOB) := T
end INSERT
procedure SMALLEST(JOB:out ID) is
;; Feltetelezzuk,hogy a halmaz nem u
res.
T : DURATION := DURATION'LAST
SMALL : ID
begin
for I in ID loop
if IN SET(I) and then RANK(I) <= T then
SMALL := I T := RANK(I)
end if
end loop
IN SET(SMALL) := FALSE
JOB := SMALL
54 Ada
end SMALLEST
function EMPTY return BOOLEAN is
begin
for I in ID loop
if IN SET(I) then return FALSE end if
end loop
return TRUE
end EMPTY
end ORDERED SET
Ez a package egyetlen halmaz objektumot valost meg. Ennel altalanosabb
megoldas az, amit a kovetkez}o peldaban mutatunk a heap tpusra.
iii) A heap tpus megvalostasa

A heap tpus egyetlen komponens tpust tartalmazo iteralt tpus. A heap
alaptpusa csak olyan tpus lehet, amelyen ertelmezve van egy rendezesi relacio. A
tpushoz ot m}uveletet denialunk:
create : ! Heap
push : Heap Basetype ! Heap
top : Heap ! Basetype
pop : Heap ! Heap
empty : Heap ! Boolean
A tpus sajatossaga, hogy a top es pop m}uvelet mindig a sorozat legnagyobb
elemet valasztja le.
empty(create) = true
empty(push(h,x)) = false
top(create) = error
pop(create) = error
push(pop(h), top(h)) = h
pop(push(h,x)) = if empty(h) or top(h) x then h else push(pop(h), x)
top(push(h, x)) = if empty(h) or top(h) x then x else top(h)
Egy olyan reprezentaciot valasztunk, amelyben a legnagyobb elem konnyen
elerhet}o, de egy elem behelyezese vagy torlese is keves m}uveletet igenyel. A heap-
et egy h(1..SIZE) vektorral es egy n egesszel abrazoljuk. n a sorozat hossza es n
= 0 jelenti az u res heap-et, a sorozatot pedig a h(1), ..., h(n) elemekkel fejezzuk
ki. A reprezentaciohoz hozzarendelt invarians: 81 i n2 : hi max(h2i h2i+1).
Ez a vektorral valo abrazolas megfelel a heap egy kiegyensulyozott rende-
zett binaris faval valo abrazolasanak. Az invarians most azt jelenti, hogy min-
den reszfaban a gyoker a legnagyobb elem. Igy a sorozat legnagyobb elemet min-
dig h(1) abrazolja, annak kivetelekor pedig h(2) vagy h(3), ezek helyere pe-
dig a "bel}oluk lelogo" elemek egyike "csuszik el}ore", st. Egy elem behe-
lyezesenek vagy torlesenek koltsege egyarant log n -nel aranyos.
A package 55
package HEAP TYPE is

type HEAP(SIZE : NATURAL := 128) is limited private
HEAP EMPTY : exception
HEAP FULL : exception
procedurePUSH (H : in out
HEAP X : in
INTEGER)
functionTOP (H : HEAP) return
INTEGER
procedure POP (H : in out
HEAP)
functionEMPTY (H : HEAP) return
BOOLEAN
private
type VECTOR is array (INTEGER range) <>) of INTEGER
type HEAP(SIZE : NATURAL := 128) is
record
N : NATURAL := 0
H : VECTOR(1 .. SIZE)
end record

end HEAP TYPE
package body HEAP TYPE is
procedure PUSH (H : in out HEAP X : in INTEGER) is
I, J : NATURAL SWAP : BOOLEAN
begin
if H.N = H.SIZE then raise HEAP FULL end if
H.N := H.N + 1 J := H.N SWAP := TRUE
while SWAP and then J >= 2 loop
I := J J := J / 2
if X > H.H(J)
then H.H(I) := H.H(J)
else SWAP := FALSE
end if
end loop
if SWAP then H.H(J) := X else H.H(I) := X end if
end PUSH
function TOP(H : HEAP) return INTEGER is
begin
if H.N = 0 then raise HEAP EMPTY end if
return H.H(1)
end TOP
procedure POP(H : in out HEAP) is
I, J : NATURAL SWAP : BOOLEAN TMP : INTEGER
begin
if H.N = 0 then raise HEAP EMPTY end if
TMP := H.H(H.N) H.N := H.N ; 1
J := 1 SWAP := TRUE
while SWAP and then <
2*J = H.N loop
I := J J := 2 * J
if <
J H.N and thenH.H(J+1) >
H.H(J)
thenJ := J + 1
end if

if
TMP <
H.H(J)
thenH.H(I) := H.H(J)
else
SWAP := FALSE
end if

end loop
ifSWAP thenH.H(J) := TMP else
H.H(I) := TMP end if
56 Ada
end POP
function EMPTY (H : HEAP) return BOOLEAN is
begin
return H.N = 0
end EMPTY
end HEAP TYPE
Hibakezeles, kivetelkezeles 57
8. Hibakezeles, kivetelkezeles
Az Ada megadja a programozo szamara annak lehet}oseget, hogy hibak es

egyeb kiveteles vegrehajtasi helyzetek eseten rendelkezzek ezek lekezeleser}ol.
<exception declaration> ::= <identier list> : exception
<exception handler> ::= when <exception choice> f j <exception choice>g
=> <sequence of statements>
<exception choice> ::= <exception name>j others
A nyelv tartalmaz predenit kiveteleket is, es a felhasznalo maga is denialhat
kiveteleket.
ADAT HIBA : exception
A blokkok es alprogramok torzsenek vegen a programozo utastasokat (un. excep-

tion handler) helyezhet el a kivetelek lekezelesere.
begin
;; utas tassorozat
exception
when ADAT HIBA =>
;; a hibat lekezel}o utas tasok
end
Ha a torzs egy utastasanal fellep valamilyen vegrehajtasi hiba, kivetel, akkor a
vezerles atadodik a blokk vegen lev}o kivetelkezel}o resznek. Ez egy case-szer}u szer-
kezet, aminek a kivetelhez tartozo agaban lev}o utastasok vegrehajtasaval a blokk
vagy programegyseg vegrehajtasa vegeter. Az exception utastasban a when-agak
utan szerepelhet egy others-ag is, ami osszefogja a fel nem sorolt kiveteleket.
Az Ada predenit kivetelei a kovetkez}ok:
- CONSTRAINT ERROR | akkor l ep fel, ha megszortas megsertese (pl. egy
valtozo olyan erteket kap, ami kvul esik a tpusertekhalmazan), indexhiba,
diszkriminans megsertese, vagy null ertek}u pointer felhasznalasa kovetkezik
be
- NUMERIC ERROR | akkor l ep fel, ha egy predenit numerikus operator
eredmenye hibas eredmenyt ad
- PROGRAM ERROR | akkor l ep fel, ha olyan alprogram, task vagy gene-
ric aktivizalasara tortenik kserlet, aminek a torzse meg nincs kiertekelve,
ha a fuggveny vegrehajtasa befejez}odott, de nem hajtodott vegre re-
turn utastas, vagy ha egy szelektv varakoztatas (ld. 12. 7.1.) min-
den aga zart es nincs az utastasnak else aga
- STORAGE ERROR | akkor l ep fel, ha nem all rendelkezesre eleg memoria az
igenyelt allokalashoz
- TASKING ERROR | taskok k ozotti kommunikacioban lephet fel.
58 Ada
<raise statement> ::= raise <exception name> ]

A kivetel mindig a raise utastas hatasara lep fel.
begin
;; utas tasok
raise ADAT HIBA
;; utas tasok
exception
when NUMERIC ERROR j CONSTRAINT ERROR =>
PUT("Numeric or constrain error occured")
when STORAGE ERROR =>
PUT("Ran out of space")
when others =>
PUT("Something else went wrong")
end
Kivetel bekovetkezesekor a futtato rendszerben a kivetelkezel}o kivalasztasa
attol fugg, hogy a kivetel a deklaracio kiertekelese, vagy az utastasok vegrehajtasa
soran lepett-e fel. Ha kivetel lep fel egy blokk deklaracios reszenek kiertekelesekor,
akkor a blokk vegrehajtasa abbamarad, s az exception a blokk vegrehajtasat kez-
demenyez}o egysegben lep fel. A vegrehajtast kezdemenyez}o egyseg package es
blokk eseteben a tartalmazo blokk, alprogram eseteben a hvo blokk, task eseteben
az aktivizalo blokk. A programegyseg vagy blokk vegrehajthato reszeben fellep}o
kivetelt lekezel}o programresz magaban a blokkban van. Ha a blokk nem tartalmaz
ehhez a kivetelhez rendelkezest, akkor a blokk vegrehajtasa befejez}odik, es a kivetel
fellep a blokk vegrehajtasat kezdemenyez}o egysegben. Ha a kivetelkezel}o program
vegrehajtasa kozben kovetkezik be hiba, akkor a blokk vegrehajtasa befejez}odik,
es a kivetel a a blokk vegrehajtasat kezdemenyez}o egysegben lep fel. (Ha egy alp-
rogram hibaval ter vissza, akkor az nem ad vissza erteket az out es in out modu pa-
rametereiben.)
A kivetelt haromfele modon hasznalhatjuk.
El}oszor. Hasznalni lehet egyszer}u modon hibajelzesek adasara: ha a prog-
ram adathibat eszlel, vegrehajt egy raise utastast, es ezzel jelzi az o}t aktivizalo
blokknak a szamtast sikertelenseget.
Masodszor. A kivetelkezel}o program kialakthato ugy, hogy felismerje a hibat,
korrigalja azt, es a programegyseg vagy blokk helyett adjon egy tobbe-kevesbe
hasznalhato eredmenyt, megmentve a programot a leallastol.
Harmadszor. A programegyseg a kivetel felismerese utan meg elvegez nehany
befejez}o m}uveletet, es csak ezutan jelzi a hibat a hvo szintjen.
with DATA IO use DATA IO
procedure ANALYSE
(FILE NAME:in STRING RES:out ANSWER) is
procedure INIT(RESULTS:in out ANSWER) is
begin
Hibakezeles, kivetelkezeles 59
;; a RESULTS inicializalasa
end INIT
procedure UPDATE
(CURRENT:in DATA RES:in out ANSWER) is
begin
;; CURRENT feldolgozasa es RESULTS jav tasa
;; a hibakat ezeken keresztul jelezzuk
end UPDATE
procedure PROCESS FILE
(FILE NAME:in STRING RES:out ANSWER) is
F:IN FILE
X:DATA
begin
OPEN(F,FILE NAME) INIT(RES)
while not END OF FILE(F) loop
READ(F,X) UPDATE(X,RES)
end loop
CLOSE(F)
exception
when others => CLOSE(F) raise
end PROCESS FILE
begin
;;
PROCESS FILE(FILE NAME,RESULTS)
;;
exception
;; a fellepett kivetelek lekezelese
end ANALYSE
APROCESS FILE eljarasban le kell zarni a le-t, es a hibat tovabb kell adni az
ANALYSE eljarasnak. (A parameter nelkuli raise utastas hatasara a lekezelt kivetel
ujra fellep.)
A kivetel lekezelesenek ez a fejlett rendszere biztostja, hogy nagy
megbzhatosagu software rendszereket keszthessunk Ada nyelven.
(Megjegyzes. Azert vannak az Ada hibakezel}o mechanizmusanak komoly hianyossagai is.
Mivel egy hiba fellepesekor a raise utas tas nem ad vissza semmilyen mas informaciot, csak
a hiba tenyet, ezert, ha ennel tobb informaciot akarunk a h vonak visszaadni, akkor globalis
valtozokat kell bevezetnunk. A masik kellemetlen eset akkor all el}o, ha valahol egy h vo nem
kezel le egy hibat, gy az tovabbadodhat, s vegul egy olyan programreszhez is eljuthat, ahol
mar nem kezelhet}o le ertelmesen. A problema az, hogy a hiba tovabbterjedesenek semmi hatara
nincs kijelolve. Hasonlo problema lephet fel a when others => null szerkezet fegyelmezetlen
hasznalatakor, ami olyan hibakat kezelhet le, jobban mondva szuntethet meg, amiket "masnak
szantak", s gy nem jut el a c mzetthez.)
60 Ada
8.1. Peldaprogramok
i) Verem objektum megvalostasa

Absztrakt objektumok vagy tpusok megvalostasakor a legtobb korabbi nyelv-
ben komoly gondot okoz az objektum kezelesevel kapcsolatos hibak jelzese es ke-
zelese. A ltalaban az egyetlen hasznalhato megoldas az, hogy a tpusm}uveleteket
kiegesztjuk egy kimen}o logikai parameterrel. Ez a megoldas azonban egyreszt
lassubba teszi az alprogramhvast, masreszt visszateres utan mindig ellen}orizni kell
a visszaadott erteket, hogy megtudjuk, sikerult-e a m}uvelet vegrehajtasa. Min-
dez azert kellemetlen, mert csak nagyon ritkan, vagy soha el}nem ofordulo helyze-
tek kezelesere kell nem keves energiat fordtanunk. Az Ada altal bevezetett hiba-
kezeles megfelel}o megoldas ennek a problemanak a kezelesere.
package STACK is
ERROR : exception
procedure PUSH(X:in REAL)
function POP return REAL
end STACK
PTR : INTEGER range 0 .. MAX
begin
if PTR = MAX then raise ERROR end if
PTR := PTR + 1 S(PTR) := X
end PUSH
function POP return REAL is
begin
if PTR=0 then raise ERROR end if
PTR := PTR ; 1 return S(PTR ; 1)
end POP
begin PTR := 0
end STACK
Lathatosagi szabalyok 61
9. Lathatosagi szabalyok
A deklaracio egy azonostonak es egy egyednek az osszekapcsolasa. A dek-

laracio hataskore a programszovegnek az szakasza, ahol az azonostoval a dek-
laralt egyedre hivatkozhatunk. Kozvetlen hataskornek hvjuk a szovegnek azt a sza-
kaszat, amely a deklaracio pontjatol a deklaralo egyseg vegeig tart. Nemely eset-
ben a hataskor nagyobb a kozvetlen hataskornel, kiterjed a deklaraciot tartal-
mazo deklaracios resz hataraig. Ilyen esetek Adaban
- a package specikacios reszeben lev}o deklaracio,
- egy entry deklaracioja,
- rekordkomponens deklaracioja,
- diszkriminans,
- alprogramparameter specikacioja,
- generic parameter specikacioja.
A szoveg egy adott helyen egy azonosto jelenteset a lathatosagi es az
atlapolasi szabalyok hatarozzak meg. Az Adaban egy deklaracio a hataskoren
belul mindenutt lathato, ez a lathatosag azonban lehet kozvetlen vagy lehet sze-
lekcios lathatosag. Pl. a package-ben denialt eljarasra a package-n kvul sze-
lekcios formaban (PACKAGE.ELJARAS) hivatkozhatunk, es ugyanez a helyzet a re-
kord komponenseivel is.
Az Adaban, mint minden ALGOL-szer}u nyelvben, a programegysegek
egymasbaagyazhatok. Ezt a szerkezetet blokkstrukturanak nevezzuk. Egy
beagyazott blokk szempontjabol a kuls}o blokk deklaracioit globalisnak, a blokk
sajat deklaracioit pedig lokalisnak mondjuk.
procedure P is
A, B, C : INTEGER
procedure Q is
A, C : INTEGER
procedure R is
A : INTEGER
begin
;; kozvetlenul lathato nevek: Q a P-b}ol, R a Q-bol,
;; A az R-b}ol, B a P-b}ol, C a Q-bol
;; csak szelekcios hivatkozassal elerhet}o nevek: P.A, P.C, Q.A
;; globalis nevek: P, P.A, P.B, P.C, Q, Q.A, Q.C
;; lokalis nevek: R, A
end R
begin
;; kozvetlenul lathato nevek: Q a P-b}ol, R a Q-bol,
;; A a Q-bol, B a P-b}ol, C a Q-bol
;; csak szelekcios hivatkozassal elerhet}o nevek: P.A, P.C
;; globalis nevek: P, P.A, P.B, P.C
;; lokalis nevek: Q, A, C, R
end Q
62 Ada
procedure S is
B : INTEGER
begin
;; kozvetlenul lathato nevek: Q a P-b}ol, S a P-b}ol,
;; A a P-b}ol, B az S-b}ol, C a P-b}ol
;; csak szelekcios hivatkozassal elerhet}o nevek: P.B
;; globalis nevek: P, P.A, P.B, P.C, Q
;; lokalis nevek: S, B
end S
begin
;; kozvetlenul lathato nevek: Q a P-b}ol, S a P-b}ol,
;; A a P-b}ol, B a P-b}ol, C a P-b}ol
;; lokalis nevek: P, A, B, C, Q, S
end P
A programszoveg egy adott pontjan egy azonostohoz tobb egyed is tartoz-
hat, azaz ugyanaz az azonosto tobb kozvetlenul lathato deklaraciora is hivatkoz-
hat. Ezt az azonostok atlapolasanak nevezzuk. Az Adaban atlapolhatok a felso-
rolasi konstansok nevei es az alprogramok nevei. Ilyenkor az azonosto kornyezete
(pl. a parameterlista) alapjan csak egyetlen olyan deklaracio lehet, ami minden
szempontbol megfelel a hivatkozasnak, kulonben a hivatkozas szintaktikus hibat je-
lent. Az alabbi peldaban a P eljarasban a T tpus /= operatora ket helyr}ol is latszik,
ezert a hivatkozasnal a package nevenek megadasaval egyertelm}uve kell tenni a hi-
vatkozast:
package A is
type T is new INTEGER
end A
package B is
subtype T1 is T
end B
with A, B use A, B
procedure P(X, Y :in T) is
begin
if B."/="(X, Y) then ... ;; gy helyes
end P
type ACC STRING is access STRING
function F(X : INTEGER) return ACC STRING
function F return ACC STRING
;; Most F(3)'ADDRESS nem egyertelm}u kifejezes.
A deklaracio eltakarasanak (elrejtesenek) nevezzuk azt az esetet, ha egy

ervenyes deklaracio hataskoreben egy bels}o blokkban ugyanahhoz az azonostohoz
egy masik egyedet rendelunk. A kvul deklaralt egyedre ilyenkor csak sze-
lekcios jelolessel hivatkozhatunk.
procedure P is
A,B:BOOLEAN
procedure Q is
C:BOOLEAN
B:BOOLEAN
begin
Lathatosagi szabalyok 63
B := A ;; Q.B := P.A
C := P.B;; Q.C := P.B
end Q
begin
A:=B ;; P.A := P.B
end P
Itt Q -ban a P -beli B -re csak szelektven lehet hivatkozni, mert B Q-beli deklaracioja
eltakarja a P-belit.
9.1. A use utastas

<use clause> ::= use <package simple name> f , <package simple name>g
A use utastas a szelekcios hivatkozas lerovidtesere szolgal. Pelda
egymasbaagyazott blokkok es use eseten a hivatkozasi szabalyok alkalmazasara:
package D is
T,U,V : BOOLEAN
end D
package P is
package E is
B,W,V : INTEGER
end E
procedure Q is
T,X : REAL
use D,E
begin
;; Ezen a ponton
;; T jelentese Q.T (es nem D.T),
;; U jelentese D.U,
;; B jelentese E.B,
;; W jelentese E.W,
;; X jelentese Q.X,
;; V illegalis, D.V vagy E.V alakban kell V-re hivatkozni
end Q
begin
...
end P
9.2. Az atnevezes
Lehetseges az eddig felsoroltakon kvul meg egy masik hivatkozasi mod is:
atnevezhetjuk a lathato objektumokat.
<renaming declaration> ::= <identier> :
<type mark> renames <object name>
j<identier> : exception renames <exception name>
j package <identier> renames <package name>
j<subprogram specication> renames <subprogram or entry name>
64 Ada
Az alabbi atnevezesek mind szabalyosak.

function REAL PLUS(LEFT, RIGHT : REAL) return REAL renames "+"
function NEXT(C : COLOR) return COLOR renames COLOR'SUCC
declare
procedure SPUSH(X:in REAL) renames STACK.PUSH
function SPOP return REAL renames STACK.POP
begin
SPUSH(X)
...
X := SPOP
end
Az atnevezes egyarant hasznalhato a szoveg rovidtesere, a nevek kozotti konf-

liktusok feloldasara es a vegrehajtasi id}o csokkentesere.
L : INTEGER renames D.EV
AI : REAL renames A(I)
Ezutan az AI := AI + 1 forma hasznalataval elkeruljuk az indexkifejezes

tobbszori kiszamtasat. (Ha I erteke a programban megvaltozik, azert az AI
tovabbra is a korabbi valtozot jelenti.)
Programstruktura 65
10. Programstruktura
A fordtasi egysegek ketfelek: un. konyvtari egysegek (alprogram, package

vagy generic specikacioja, generic peldanyostasa (ld. 11.2), alprogram torzse)
vagy masodlagos egysegek (konyvtari egyseg torzse vagy alegyseg, ld. 10.1.). A
konyvtari egysegek nevei kulonboz}ok kell legyenek. Ada f}oprogram olyan konyvtari
eljaras lehet, amelynek nincs parametere.
<compilation> ::= f<compilation unit>g
<compilation unit> ::= <context clause><library unit>
j<context clause><secondary unit>
<library unit> ::= <subprogram declaration>j<package declaration>
j<generic declaration>j<generic instantiation>j<subprogram body>
<secondary unit> ::= <library unit body>j<subunit>
<library unit body> ::= <subprogram body>j<package body>
<context clause> ::= f<with clause> f<use clause>gg
<with clause> ::= with <library unit simple name>
f , <library unit simple name>g
Mivel a fordtasi egysegek kozott kulonfele kapcsolatok lehetnek (egy egyseg
importalhat egy masikbol, specikacio-torzs kapcsolat, torzs-alegyseg kapcso-
lat), egy egyseg fordtasakor a fordtoprogramnak szuksege van a hivatko-
zott egysegekben denialt bizonyos informaciokra. Ezert a lefordtott egysegek
az un. Ada konyvtarba kerulnek, ahol az egysegek object kodjan kvul meg}orzesre
kerulnek a szukseges szimboltablak is. A konyvtar nyilvantartja az egysegek
kozotti kapcsolatokat is.
Ha egy egyseg fordtasakor a fordtoprogram hibat eszlel, akkor az egyseg
nem kerul be a konyvtarba. Ha olyan egyseget fordtunk, ami mar szere-
pel a konyvtarban, akkor az uj egyseg a regi helyere kerul, s ervenytelenne valik a
konyvtarban minden olyan egyseg, ami az uj egysegt}ol fugg. Az ervenytelenne valt
egysegek a konyvtaron belul ujrafordthatok (tehat anelkul, hogy egy fordtassal be-
vinnenk a konyvtarba, azaz a fordtas es az ujrafordtas ket kulon m}uvelet).
Az egysegek fordtasi sorrendjere vonatkozo szabalyok teljesen megegyez-
nek a Modula-2 szabalyaival. Egy programegyseg akkor fordthato, ha azok-
nak az egysegeknek a specikacios resze, amelyekre ez hivatkozik, mar le van-
nak fordtva. A package specikacioja es torzse egy-egy onallo egyseg, es ezek kozul
a specikaciot kell el}obb fordtani. Ha egy egyseg csak a specikaciotol fugg, ak-
kor a torzs megvaltoztatasa miatt ezt az egyseget nem kell ujra lefordtani. (Az al-
egysegekre vonatkozo szabalyokat ld. a 10.1. pontban.)
A konyvtarban vannak a predenit Ada egysegek moduljai. Ilyenek az input-
output modulok (ld. 15.), a CALENDAR modul (ld. 12.6.) es a rendszerfugg}o
informaciokat tartalmazo modulok (SYSTEM, UNCHECKED CONVERSION, UNCHEC-
66 Ada
,
KED DEALLOCATION MACHINE CODE stb.).
A konyvtari rendszer biztostja, hogy a fuggetlenul fordtott egysegek kapcso-
lata egymasnak megfelel}o legyen (ezeket ellen}orzi).
(Megjegyzes. Eleg sok modulbol allo programoknal azt lathatjuk, hogy a modulok a feladat
egy-egy logikai resze kore csoportosulnak. Pl. egy ford toprogram moduljainak egy csoportja a
szemantikus elemzeshez, masik csoportja a kodgeneralashoz s t. tartozik. Az ilyen csoportoknak
altalaban csak egy-ket olyan moduljuk van, amib}ol masik csoportbeli modul importal, a tobbi
modul ezt az egy-ket modult szolgalja ki. Sajnos sem az Ada, sem mas programozasi nyelv nem
ad eszkozt az ilyen "modulcsoportoknak" a kezelesere.)
Minden fordtasi egyseg el}ott with utastasban kell felsorolni azokat az
egysegeket, amelyekb}ol importalni akarunk. A with a hivatkozott egyseg altal ex-
portalt osszes deklaraciot lathatova teszi. A megnevezett package-ben denialt ne-
vekre ezutan package.nev formaban hivatkozhatunk. Hogy ezt a hosszadal-
mas format elkeruljuk, a with utastas utan szinte mindig alkalmazunk egy use
utastast is, ami kozvetlenul lathatova teszi a package exportalt neveit. (Ha ilyen
modon tobb package-b}ol is importaltuk ugyanazt az azonostot, az nem hiba,
majd az azonosto hasznalatakor kell egyertelm}uve tenni, hogy melyikre hivat-
kozunk.)
(Megjegyzes. A programkesz tes szempontjabol hasznos lenne, ha importalaskor va-
lamikeppen el lehetne hagyni a programbol az importalt modulnak a felesleges alprogram-
jait. Pl. kellemetlen, hogy ha a programozo egy olyan fajta keszletet hasznal, mint a mate-
matikai fuggvenyek modulja, akkor annak minden alprogramja hozzaszerkeszt}odik a program-
hoz, pedig talan csak az SQRT fuggvenyre lenne szukseg.)
Pelda teljes Ada programra :
with TEXT IO, REAL OPERATIONS use REAL OPERATIONS
procedure QUADRATIC EQUATION is
A,B,C,D : REAL
use REAL IO ,
TEXT IO ,
REAL FUNCTIONS
begin
GET(A) GET(B) GET(C)
D := B ** 2 ; 4.0 * A * C
if <
D 0.0 then
PUT("Imaginary Roots.")
else
PUT("Real Roots : X1 = ")
PUT((;B ; SQRT(D)) / (2.0 * A)) PUT(" X2 = ")
PUT((;B + SQRT(D)) / (2.0 * A))
end if
NEW LINE
end QUADRATIC EQUATION
Tekintsuk a kovetkez}o programot.

Programstruktura 67
procedure MAIN is
type COLOR is (RED,BLUE,GREEN,YELLOW)
package SETS is
type CSET is private
procedure INSERT(C:in COLOR CS:in out CSET)
;; mas m}uveletek
private
type CSET is array (COLOR) of BOOLEAN
end SETS
package body SETS is
procedure INSERT(C:in COLOR CS:in out CSET) is
;;
end INSERT
;; mas m}uveletek
end SETS
use SETS
A,B:CSET
begin
;;
INSERT(RED,A)
;;
end MAIN
Ezt a programot a kovetkez}okeppen valaszthatjuk szet onallo progra-
megysegekre:
package GLOBALS is
type COLOR is (RED,BLUE,GREEN,YELLOW)
end GLOBALS
with GLOBALS use GLOBALS
package SETS is
type CSET is private
procedure INSERT(C:in COLOR CS:in out CSET)
;; mas m}uveletek
private
type CSET is array (COLOR) of BOOLEAN
end SETS
package body SETS is
procedure INSERT(C:in COLOR CS:in out CSET) is
;;
end INSERT
;; mas m}uveletek
end SETS
with GLOBALS, SETS use GLOBALS, SETS
procedure MAIN is
A,B:CSET
begin
;;
INSERT(RED,A)
;;
end MAIN
68 Ada
10.1. Alegysegek
<body stub> ::= <subprogram specication> is separate
j package body <package simple name> is separate
j task body <task simple name> is separate
<subunit> ::= separate ( <parent unit name> ) <body>
Egy package-ben denialt alprogram torzset kiemelhetjuk a package-b}ol, es
onallo fordtasi egyseget, un. alegyseget kepezhetunk. A package-ben az al-
egyseg torzsenek helyen egy csonk marad. Peldaul a STACK package torzset a
kovetkez}okeppen is rhatjuk :
PTR : INTEGER range 0.MAX
procedure PUSH(X:in REAL) is separate
function POP return REAL is separate
begin
PTR := 0
end STACK
A ket alegyseg ekkor kulon fordthato, ezek formaja a kovetkez}o:
separate STACK
begin
PTR := PTR + 1
S(PTR) := X
end PUSH
separate STACK
procedure POP return REAL is
begin
PTR := PTR ; 1
return S(PTR + 1)
end POP
Egy alegysegben a hataskor es a lathatosag pontosan olyan, mintha az
alegyseg a csonk helyen lenne. Tehat pl. az alegysegben minden kulon jeloles
nelkul hivatkozhatunk olyan tpusokra es globalis valtozokra, amelyek a szul}oben
vannak denialva.
Egy alegysegb}ol szinten el lehet kulonteni valamely beagyazott progra-
megyseg torzset, azaz alegysegnek szinten lehet alegysege. Az alegysegek fordtasi
sorrendjere az a szabaly, hogy egy alegyseg csak akkor fordthato le, ha mar le-
fordtottuk azt az egyseget, amelyb}ol az alegyseg szarmazik. Ha egy torzset vagy
alegyseget ismetelten lefordtunk, akkor ujra kell fordtani ezek osszes alegyseget.
Azt az egyseget, amib}ol az alegyseget levalasztottuk, az alegyseg szul}ojenek
Programstruktura 69
hvjuk. A szul}ok lancolatan visszafele haladva egy olyan egyseghez jutunk, ami
mar nem alegyseg, hanem valodi torzs. Ezt a torzset az alegyseg }osenek nevezzuk.
Nem egyezhet meg ket olyan alegysegnek a neve, amelyeknek kozos }osuk van.
10.2. Peldaprogramok
i) Prioritasi sorok
Ebben a peldaban tobb package felhasznalasaval eptunk fel egy absztrakt
objektumot.
Tekintsunk egy olyan operacios rendszert, amelyben a jobok 1 es 10 kozotti
prioritasokkal vannak ellatva. A jobok kezeleset a PRIORITY QUEUES package-el
kepzeljuk el.
package PRIORITY QUEUES is
MAX SIZE : constant := 50
type PRIORITY is new INTEGER range 1 .. 10
procedure ADD(P:in PRIORITY J:in JOB ID)
;; A varakozo jobok koze felveszi
;; a J azonostoju P prioritasu jobot.
procedure NEXT(J:out JOB ID)
;; Kiveszi a legmagasabb prioritasu varakozo jobok
;; kozul azt, amelyik a legregebben varakozik.
function FULL(P : PRIORITY) return BOOLEAN
;; Egy adott prioritashoz legfeljebb MAX SIZE darab
;; varakozo tartozhat. Igazat ad vissza, ha a P
;; prioritashoz tartozo varakozasi sor tele van.
function ANY JOB return BOOLEAN
;; Igazat ad vissza, ha van varakozo job.
end PRIORITY QUEUES
Az egyes prioritasokhoz tartozo varakozasi sorok kezelesere elkesztjuk a FIFO
package-t.
package FIFO is
type QUEUE(MAX: INTEGER) is limited private
QUEUE OVERFLOW : exception
QUEUE UNDERFLOW : exception
procedure ADD(Q:in out QUEUE J:in JOB ID)
;; Hozzaveszi a Q sorhoz a J erteket.
procedure FIRST(Q:in out QUEUE J:out JOB ID)
;; Visszaadja es torli a Q sorbol a legregebbi elemet.
function FULL(Q : QUEUE) return BOOLEAN
function EMPTY(Q : QUEUE) return BOOLEAN
private
type JOBS is array (INTEGER range <>) of JOB ID
type QUEUE(MAX: INTEGER) is
record
70 Ada
X : JOBS(1 .. MAX)
FIRST, LAST : INTEGER := 1
CUR SIZE : INTEGER := 0
end record

end FIFO
package body FIFO is
procedure ADD(Q:in out QUEUE J:in JOB ID) is
begin
if FULL(Q) then raise QUEUE OVERFLOW end if
Q.X(Q.LAST) := J
Q.LAST := Q.LAST mod Q.X'LENGTH + 1
Q.CUR SIZE := Q.CUR SIZE + 1
end ADD
procedure FIRST(Q:in out QUEUE J:out JOB ID) is
begin
if EMPTY(Q) then raise QUEUE UNDERFLOW end if
J := Q.X(Q.FIRST)
Q.FIRST := Q.FIRST mod Q.X'LENGTH + 1
Q.CUR SIZE := Q.CUR SIZE ; 1
end FIRST
function FULL(Q : QUEUE) return BOOLEAN is
begin
return Q.CUR SIZE = Q.X'LENGTH
end FULL
function EMPTY(Q : QUEUE) return BOOLEAN is
begin
return Q.CUR SIZE = 0
end EMPTY
end FIFO
A PRIORITY QUEUES package torzse most mar minden nehezseg nelkul
megrhato a FIFO package felhasznalasaval.
with FIFO
package body PRIORITY QUEUES is
PQ : array (PRIORITY) of FIFO.QUEUE(MAX SIZE)
procedure ADD(P:in PRIORITY J:in JOB ID) is
begin
FIFO.ADD(PQ(P), J)
end ADD
procedure NEXT(J:out JOB ID) is
begin ;; Feltetelezi, hogy van varakozo job.
for I in reverse PRIORITY loop
if not FIFO.EMPTY(PQ(I)) then
FIFO.FIRST(PQ(I), J)
return
end if
end loop
end NEXT
function FULL(P : PRIORITY) return BOOLEAN is
begin
return FIFO.FULL(PQ(P))
Programstruktura 71
end FULL
function ANY JOB return BOOLEAN is
begin
for I in PRIORITY loop
if not FIFO.EMPTY(PQ(I)) then return TRUE end if
end loop
return FALSE
end ANY JOB
end PRIORITY QUEUES
ii) Keresztreferencia lista kesztese

Ebben a pontban egy Ada nyelv}u programokrol keresztreferencia listat nyom-
tato programot kesztunk. A program nevsor szerint felsorolja az Ada program-
ban szerepl}o azonostokat, s mindegyikr}ol megadja, hogy mely sorokban fordul
el}o. A megjegyzeseket, szovegliteralokat es az alapszavakat a program nem veszi
gyelembe.
A program ket reszb}ol all: egy scanner-b}ol, ami az input szoveget
"megvalogatja", kihagyja bel}ole a feladat szempontjabol erdektelen reszeket, es
egy tablakezel}ob}ol, ami nyilvantartja az azonostokat es a sorszamokat, vala-
mint nyomtatni tudja ezt a tablazatot. Az elemz}o reszt a f}omodul foglalja magaba,
el}oszor ezt adjuk meg. A f}omodul hivatkozik a tablakezel}o package-re, ami-
nek a specikacios resze a kovetkez}o :
package TABLE HANDLER is
type TABLE is private
TABLE FULL : exception
procedure INIT TABLE(T:in out TABLE)
procedure ENTER(T:in TABLE NAME:in STRING N:in INTEGER)
;; Felvesz egy nevet a tablaba, ha az meg nem
;; szerepelt benne, s hozzarja a sorszamot.
procedure TABULATE(F:in FILE TYPE T:in TABLE)
;; Nyomtatja a t
abl
azat teljes tartalm
at.
private
type ITEM
type LIST PTR is access ITEM
type ITEM is record
NUM : INTEGER := 0
NEXT : LIST PTR
end record
type STRING PTR is access
STRING
type WORD
type TABLE is access
WORD
type WORD is record
KEY : STRING PTR
FIRST : LIST PTR
LEFT, RIGHT : TABLE
end record
72 Ada
end TABLE HANDLER
A f}omodul a tablazatkezel}o modulon kvul csak a text input-output modult

hasznalja fel.
with TEXT IO, TABLE HANDLER
use TEXT IO, TABLE HANDLER
procedure XREF is
LNO : NATURAL := 0 ;; az aktu
alis sor sorsz
ama
T : TABLE
F, G : FILE TYPE
INFILE, OUTFILE : STRING(1 .. 64)
ID : STRING(1 .. 80)
CH : CHARACTER
K : NATURAL
type KEY TYPE is access STRING
type KEY TYPES is array (INTEGER range <>) of KEY TYPE
KEYS : constant KEY TYPES(1 .. 63) := (
new STRING'("abort"), new STRING'("abs"),
new STRING'("accept"), new STRING'("access"),
new STRING'("all"), new STRING'("and"),
new STRING'("array"), new STRING'("at"),
new STRING'("begin"), new STRING'("body"),
new STRING'("case"), new STRING'("constant"),
new STRING'("declare"), new STRING'("delay"),
new STRING'("delta"), new STRING'("digits"),
new STRING'("do"), new STRING'("else"),
new STRING'("elsif"), new STRING'("end"),
new STRING'("entry"), new STRING'("exception"),
new STRING'("exit"), new STRING'("for"),
new STRING'("function"), new STRING'("generic"),
new STRING'("goto"), new STRING'("if"),
new STRING'("in"), new STRING'("is"),
new STRING'("limited"), new STRING'("loop"),
new STRING'("mod"), new STRING'("new"),
new STRING'("not"), new STRING'("null"),
new STRING'("of"), new STRING'("or"),
new STRING'("others"), new STRING'("out"),
new STRING'("package"), new STRING'("pragma"),
new STRING'("private"), new STRING'("procedure"),
new STRING'("raise"), new STRING'("range"),
new STRING'("record"), new STRING'("rem"),
new STRING'("renames"), new STRING'("return"),
new STRING'("reverse"), new STRING'("select"),
new STRING'("separate"), new STRING'("subtype"),
new STRING'("task"), new STRING'("terminate"),
new STRING'("then"), new STRING'("type"),
new STRING'("use"), new STRING'("when"),
new STRING'("while"), new STRING'("with"),
new STRING'("xor")
)
EOFCH : constant CHARACTER) := ASCII.NUL
procedure READ(CH:out CHARACTER) is
Programstruktura 73
;; Egyszeres el}oreolvasas megvalostasa.

;; A file vegen egy EOFCH karaktert ad vissza.
;; Ez az eljaras kezeli az LNO sorszamlalot is.
FIRST CH IN CUR LINE : BOOLEAN := TRUE
begin
if FIRST CH IN CUR LINE then
FIRST CH IN CUR LINE := FALSE
LNO := LNO + 1
end if
if END OF FILE(F) then
CH := EOFCH
elsif END OF LINE(F) then
SKIP LINE(F) CH := ASCII.CR
FIRST CH IN CUR LINE := TRUE
else
GET(F, CH)
end if
end READ
function IS KEY(NAME : STRING) return BOOLEAN is
begin
for I in KEYS'RANGE loop
if NAME = KEYS(I).all then return TRUE end if
end loop
return FALSE
end IS KEY
function IS ALPHA(X : CHARACTER) return BOOLEAN is
begin
return (X >= 'a' and then X <= 'z') or else
(X >= 'A' and then X <= 'Z')
end IS ALPHA
function IS NUM(X : CHARACTER) return BOOLEAN is
begin
return X >= '0' and then X <= '9'
end IS NUM
function IS ALNUM(X : CHARACTER) return BOOLEAN is
begin
return IS ALPHA(X) or else IS ALNUM(X)
end IS ALNUM
begin
INIT TABLE(T)
PUT("Input file = ") GET LINE(INFILE, K) NEW LINE
OPEN(F, IN FILE, INFILE(1 .. K))
PUT("Output file = ") GET LINE(OUTFILE, K) NEW LINE
CREATE(G, OUT FILE, OUTFILE(1 .. K))
READ(CH)
whileCH /= EOFCH loop
if
IS ALPHA(CH) then
K := 0
while
CH = ' ' or else
IS ALNUM(CH) loop
K := K + 1 ID(K) := CH READ(CH)
end loop

if not
IS KEY(ID(1 .. K)) then
74 Ada
ENTER(T,ID(1 .. K),LNO)
end if
elsif IS NUM(CH) then
while IS NUM(CH) loop READ(CH) end loop
elsif CH = ';' then
READ(CH)
if CH = ';' then ;; comment
while CH /= ASCII.CR loop READ(CH) end loop
end if
elsif CH = ''' then
READ(CH)
while CH /= ''' loop READ(CH) end loop
elsif CH = '"' then
READ(CH)
while CH /= '"' loop READ(CH) end loop
else
READ(CH)
end if
end loop
TABULATE(G, T)
CLOSE(F) CLOSE(G)
end XREF
A tablazatkezel}o modul exportalja a TABLE tpust es az ENTER es TABULATE

eljarasokat. A tabla szerkezete, valamint a keresesi es eleresi algoritmusok rejtve
maradnak a tobbi modul elol. A tablazatot most igenyesebben abrazoljuk, mint
az el}oz}o peldaban: rendezett binaris fat eptunk. A SEARCH eljaras jo peldat
mutat egy ilyen faban valo keresesre, a TRAVERSE TREE eljaras pedig egy rekurzv
alprogram a fa bejarasara.
package body TABLE HANDLER is
package INT IO is new INTEGER IO(INTEGER) use INT IO
procedure INIT TABLE(T :in out TABLE) is
begin
T := new WORD
end INIT TABLE
function SEARCH(P : TABLE NAME : STRING) return TABLE is
;; Megkeresi a nevet a tablazatban, a ha meg nincs
;; benne, akkor felveszi. Visszaadja a nevet
;; tartalmazo elem cmet.
PP, Q : TABLE LESS : BOOLEAN
begin PP := P Q := PP.RIGHT LESS := FALSE
while Q /= null loop
PP := Q LESS := NAME < PP.KEY.all
if NAME = PP.KEY.all then return PP end if
if LESS then Q := PP.LEFT
else Q := PP.RIGHT
end if
end loop
Q := new WORD'(new STRING'(NAME),null,null,null)
if LESS then PP.LEFT := Q else PP.RIGHT := Q end if
return Q
Programstruktura 75
end SEARCH
procedure ENTER(T:in TABLE NAME:in STRING N:in INTEGER) is
P : TABLE
Q : LIST PTR
i : NATURAL
beginI := 0
P := SEARCH(T, NAME)
Q := new ITEM'(N, P.FIRST)
P.FIRST := Q
end ENTER
procedure PRINT ITEM(F:in FILE TYPE P:in TABLE) is
;; Kinyomtat egy nevet, s a hozza tartozo sorszamokat.
L : constant := 20 H : constant := 6
I : INTEGER
Q : LIST PTR
beginPUT(F, P.KEY. ) all
if
P.KEY'LENGTH = L < then
PUT(F, (1 .. L ; P.KEY'LENGTH = > ' '))
else
NEW LINE(F)
end if
I := L + H Q := P.FIRST
while Q /= null loop
if I + H > 80 then NEW LINE(F) I := L + H end if
PUT(Q.NUM, H) I := I + H
Q := Q.NEXT
end loop
NEW LINE(F)
end PRINT ITEM
procedure TRAVERSE TREE(F:in FILE TYPE P:in TABLE) is
begin
if P /= null then
TRAVERSE TREE(F, P.LEFT)
PRINT ITEM(F, P)
TRAVERSE TREE(F, P.RIGHT)
end if

end TRAVERSE TREE
procedure TABULATE(F:in FILE TYPE T:in TABLE) is
begin
NEW LINE(F) TRAVERSE TREE(F, T.RIGHT)
end TABULATE
end TABLE HANDLER
76 Ada
11. Generic
Lenyeges, hogy a konyvtari eljarasokat eleg altalanosan meg lehessen rni,

es azokat szeles korben, sok feladatra alkalmazni lehessen. Bizonyos altalanossag
elerhet}o az alprogramokkal: ezeket parametereik jo megvalasztasaval sok hasonlo
feladat megoldasara felhasznalhatjuk. A generic lehet}ove teszi, hogy az alprogra-
mokat es a package-ket tpusokkal es alprogramokkal parameterezzuk, s ezzel az
altalanossag novelhet}o.
A generic nem kozvetlenul vegrehajthato programegyseg, hanem egy sab-
lon, amivel vegrehajthato egyedek hozhatok letre. A generic-b}ol egy vegrehajthato
egyed letrehozasat peldanyostasnak (instantiation) nevezzuk. A peldanyostas
mindig fordtasi id}oben hajtodik vegre.
(Megjegyzes. A generic a makroutas tas fogalmanak tovabbfejlesztese. Peldanyos tassal
lenyegeben olyan kodot kapunk, mint ami ugy allna el}o, ha a formalis parametereket kezzel
behelyettes tve kozvetlenul a programegyseget rnank le.)
11.1. Generic deklaracioja

<generic declaration> ::= <generic specication>
<generic specication> ::= <generic formal part><subprogram specication>
j<generic formal part><package specication>
<generic formal part> ::= generic f<generic parameter declaration>g
<generic parameter declaration> ::= <identier list> : in out ] ]
j type <identier> is <generic type denition>
j<private type declaration>
j with <subprogram specication> is name> ]
j with <subprogram specication> is <> ]
<generic type denition> ::= ( <> ) j range <> j digits <>
j delta <> j<array type denition>j<access type denition>
A generic alprogramot vagy package-t ugyanugy rjuk, mint az egyszer}u alp-
rogramot es package-t, csak a specikacio ele kerul a generic alapszo a generic pa-
rametereinek felsorolasaval.
A generic szintaktikus elemzese a generic denialasakor megtortenik, de a
kiertekelesere csak peldanyostaskor kerul sor (ez fontos a konyvtarak eseteben).
A generic programegyseget mindenutt elhelyezhetjuk, ahol egyszer}u program-
egyseg allhat. (Igy pl. a generic fordtasi egyseg is lehet.) A generic konyvtari
egysegre ugyanugy with-tel kell hivatkozni, mint mas konyvtari egysegre (a use-
nak termeszetesen nincs ertelme, s nem is hasznalhato generic-re).
Generic 77
Peldakent egy olyan privat verem tpust denialunk, amiben a verem hossza
es az elemek tpusa a package parametere.
generic
MAX : INTEGER
type ELEM is private
package STACK is
procedure PUSH(X:in ELEM)
function POP return ELEM
end STACK
S : array (1 .. MAX) of ELEM
...
end STACK
A generic haromfele parameterrel parameterezhet}o: egyszer}u adatertekkel
vagy objektummal, tpussal, es alprogrammal.
A kovetkez}o peldaban a generic parametere objektum:
generic
PERIOD : in NATURAL
package RING COUNTER is
function IS ZERO return BOOLEAN
procedure INCREMENT
end RING COUNTER
package body RING COUNTER is
COUNT : INTEGER range 0 .. PERIOD ; 1 := 0
function IS ZERO return BOOLEAN is
begin
return COUNT=0
end IS ZERO
procedure INCREMENT is
begin
COUNT := (COUNT + 1) mod PERIOD
end INCREMENT
end RING COUNTER
A tpussal valo parameterezhet}oseg teszi igazan er}oteljesse az Adat.
generic
type DISCRETE is (<>)
function NEXT OPERATION(X:DISCRETE) return DISCRETE
function NEXT OPERATION(X:DISCRETE) return DISCRETE is
begin
if X=X'LAST then
return X'FIRST
else
return X'SUCC
end if
end NEXT OPERATION
A formalis tpus egy tpusosztaly is lehet. A formalis tpusok osztalyainak
78 Ada
lerasara a kovetkez}o jeleket hasznaljuk:

(<>) | tetsz}oleges diszkret
range <> | tetsz}oleges INTEGER
delta <> | tetsz}oleges xpontos
digits <> | tetsz}oleges lebeg}opontos
Minden, az illet}o tpusosztalyhoz tartozo m}uvelet es attributum hasznalhato a
genericben, kiveve az IMAGE es VALUE attributumokat (ha ezekre megis szukseg
volna, meg kell adni o}ket parameterkent). Megjegyezzuk, hogy ha a (<>) tpusnak
valamely INTEGER tpust feleltetunk meg aktualis parameterkent, az aritmetikai
m}uveletek a generic-ben nem hasznalhatok. Vektor tpus eseten az index es az
elem tpusa (hacsak ezek nem standard tpusok) is parameter kell legyen.
A parameterezes harmadik modja, amikor a parameter egy alprogram. Ezek
altalaban a formalis generic tpusok m}uveletei.
generic
type ITEM is private
type INDEX is (<>)
type VECTOR is array (INDEX range <>) of ITEM
with function "<"(X,Y:ITEM) return BOOLEAN
procedure QUICK SORT(V:in out VECTOR)
procedure QUICK SORT(V:in out VECTOR) is
procedure SORT(LEFT,RIGHT:in INDEX) is
CENTRE VALUE: ITEM :=
V(INDEX'VAL((INDEX'POS(LEFT) + INDEX'POS(RIGHT)) / 2))
LEFT IDX : INDEX := LEFT
RIGHT IDX: INDEX := RIGHT
begin
loop
while V(LEFT IDX) < CENTRE VALUE loop
LEFT IDX := INDEX'SUCC(LEFT IDX)
end loop
while CENTRE VALUE < V(RIGHT IDX) loop
RIGHT IDX := INDEX'PRED(RIGHT IDX)
end loop
if LEFT IDX <= RIGHT IDX then
declare
TEMP : ITEM := V(LEFT IDX)
begin
V(LEFT IDX) := V(RIGHT IDX)
V(RIGHT IDX) := TEMP
end
LEFT IDX := INDEX'SUCC(LEFT IDX)
RIGHT IDX := INDEX'PRED(RIGHT IDX)
end if

exit whenLEFT IDX >
RIGHT IDX
end loop
ifLEFT <RIGHT IDX then
SORT(LEFT,RIGHT IDX)
end if

ifLEFT IDX <RIGHT then
Generic 79
SORT(LEFT IDX,RIGHT)
end if
end SORT
begin
SORT(V'FIRST,V'LAST)
end QUICK SORT
(Megjegyzes. Kar, hogy az Ada nem vallalta fel az "alprogram t pus" bevezeteset, mert
gy ahhoz, hogy alprogramot adjunk meg parameterkent, mindjart generic-et kell kesz tenunk.
Pedig az eljaras t pust mar a Modula-2 is tartalmazza, s a taskok eseteben az Ada is bevezeti.)
11.2. Peldanyostas
<generic instantiation> ::= package <identier> is
new <generic package name> <generic actual part> ]
j procedure <identier> is new <generic procedure name>
<generic actual part> ]
j function <designator> is new <generic function name>
<generic actual part> ::= ( <generic association>
f <generic association>g )
<generic association> ::= <generic formal parameter> => ]
<generic actual parameter>
<generic formal parameter> ::= <parameter simple name>j<operator symbol>
<generic actual parameter> ::= <expression>j<variable name>
j<subprogram name>j<entry name>j<type mark>
Eddig a generic denciojaval foglalkoztunk. Most peldanyostunk egy 100
hosszusagu, REAL elemeket tartalmazo vermet :
declare
package MY STACK is new STACK(100,REAL)
use MY STACK
begin
PUSH(X)
...
X := POP()
end
Nezzuk meg a RING COUNTER generic felhasznalasanak modjat is:

procedure TABULATE (X:in INTEGER VECTOR) is
FIELD WIDTH : constant := 10
package COUNTER is new RING COUNTER(PERIOD => 6)
use COUNTER
begin
for I in X'RANGE loop
PUT(X(I),FIELD WIDTH)
INCREMENT
if IS ZERO then
NEW LINE end if
end loop
end TABULATE
80 Ada
A QUICK SORT genericb}ol letrehozhatjuk pl. a kovetkez}o eljarasokat:

procedure STRING SORT is
new QUICK SORT(CHARACTER,POSITIVE,STRING,"<")
A with-ben itt default erteket lehet megadni:
with function "<"(X,Y:ITEM) return BOOLEAN is <>
Ekkor
procedure STRING SORT is
new QUICK SORT(CHARACTER,POSITIVE,STRING)
helyes, es ekvivalens az el}oz}ovel.
(Ellen}orz}o kerdesek. Nezzuk meg gyelmesen az alabbi programreszleteket!
generic
type A is (<>)
type B is private
package G is
function NEXT(X : A) return A
function NEXT(X : B) return B
end G
package P is new G(BOOLEAN, BOOLEAN)
Adhat-e hibajelzest a ford toprogram a fenti reszletek ford tasakor? Adhat-e hibajelzest P fel-
hasznalasakor?
package P is
type T is private
DC : constant T
generic package PP is end PP
private
type T is new INTEGER
DC : constant T := ;1
end P
procedure Q(X:out P.T) is begin X := P.DC end Q
generic
Y:in out P.T
package CALL is end CALL
package body CALL is begin Q(Y) end CALL
package body P is
Z : T range 0 .. 1 := 0
package body PP is
package CALL Q is new CALL(Z)
end PP
end P
Mi lesz a hatasa a package CALL Q NOW is new P.PP peldanyos tasnak?)
i) Listakezeles
Szinte nincs olyan programozasi nyelv, ami tartalmazna a sorozat tpust.
Ennek az az oka, hogy a sorozat tpusu objektumok nagyon komoly
memoriagazdalkodast igenyelnek, s a nyelvek tervez}oi attol tartanak, hogy a so-
rozatokat nem tudjak eleg hatekonyan implementalni. Ezert a programozora
Generic 81
hagyjak, hogyan akarja implementalni a sorozatot: vektorral, vagy pointerek-

kel feleptett listaval. Ebben a pontban egy listakezel}o generic package-t muta-
tunk be.
generic
type ELEM is private
package LIST PACKAGE is
type CELL is private
type POINTER is access CELL
type ARR is array (INTEGER range <>) of ELEM
function MAKE(A : ARR) return POINTER
function FRONT(P : POINTER) return ELEM
function REST(P : POINTER) return POINTER
function ADD ON(E : ELEM P : POINTER) return POINTER
private
type CELL is
record
VALUE : ELEM
LINK : POINTER
end record

end LIST PACKAGE
package body LIST PACKAGE is
function MAKE(A : ARR) return POINTER is
P : POINTER
begin
for I in reverse A'RANGE loop
P := ADD ON(A(I), P)
end loop
return P
end MAKE
function FRONT(P : POINTER) return ELEM is
begin
return P.VALUE
end FRONT
function REST(P : POINTER) return POINTER is
begin
return P.LINK
end REST
function ADD ON(E : ELEM P : POINTER) return POINTER is
begin
return new CELL'(E, P)
end ADD ON
end LIST PACKAGE
with LIST PACKAGE
procedure LIST DEMO is
package INT LIST is new LIST PACKAGE(INTEGER)
P : INT LIST.POINTER
begin
P := INT LIST.MAKE((1,2,3,4))
P := INT LIST.ADD ON(5, P)
while P /= null loop
PUT(INT LIST.FRONT(P), WIDTH = > 2)
P := INT LIST.REST(P)
82 Ada
end loop
end LIST DEMO
ii) Matematikai konyvtari generic

A generic legfontosabb es legnagyobb felhasznalasi terulete a software
konyvtarak kialaktasa. Az alabbi generic pelda egy matematikai konyvtari
egyseget mutat be:
generic
type REAL is digits <>
with function F(X : REAL) return REAL
function INTEGRATE G(A, B, EPS : in REAL) return REAL
function INTEGRATE G(A, B, EPS : in REAL) return REAL is
;; Fuggveny hatarozott integraljanak kiszamtasa
;; az A, B] intervallumon a trapez-modszer alapjan.
NEW APPROX : REAL := 0.0
PREVIOUS APPROX : REAL := 0.0
FINISHED : BOOLEAN := FALSE
N : INTEGER ;; az intervallumok sz
ama
H : REAL ;; az intervallumok m
erete
SUM : REAL
begin
N := INTEGER(10.0 * (B ; A)) + 1
H := (B ; A) / REAL(N)
while not FINISHED loop
PREVIOUS APPROX := NEW APPROX
SUM := F(A) / 2.0
for in
I 1 .. N-1 loop
SUM := SUM + F(A + REAL(I) * H)
end loop
SUM := SUM + F(B) / 2.0
NEW APPROX := SUM * H
FINISHED := abs
(NEW APPROX ; PREVIOUS APPROX) < EPS
N := N * 2
H := H / 2.0
end loop
return NEW APPROX
end INTEGRATE G
Taskok 83
12. Taskok
A taskot nem tartalmazo program vegrehajtasa az el}oz}o pontokban lert

szabalyok szerint, az utastasainak a szekvencialis vegrehajtasaval tortenik. U gy
kepzelhetjuk el, hogy az utastasokat egyetlen "logikai processzor" hajtja vegre.
A taskok olyan egysegek, amelyek vegrehajtasa parhuzamosan tortenik. U gy
kepzelhetjuk el, hogy mindegyik taskot egy sajat "logikai processzor" hajt vegre.
A szekvencialis programokban egyid}oben egy utastas all vegrehajtas alatt, mg
a parhuzamos programokban a vegrehajtas tobb szalon fut, egy id}opillanatban a
programnak tobb utastasa is lehet vegrehajtas alatt. A kulonboz}o taskok a szink-
ronizacios pontoktol eltekintve egymastol fuggetlenul m}ukodnek. (Az, hogy a
programot egy vagy tobb "zikai processzor" hajtja vegre, csak a nyelv imple-
mentaciojahoz tartozo kerdes.)
A taskoknak lehetnek un. entry pontjaik. A task egy entry pontja hvhato
egy masik taskbol. A hvott taskban az entry-hez tartozik egy accept utastas, es
a hvas hatasara ez hajtodik vegre, ezzel oldhatok meg a szinkronizacios feladatok.
Az entry-nek parameterei is lehetnek, amelyek a taskok kozotti informacioatadasra
szolgalnak.
A taskok szinkronizalasa a taskok randevuival tortenik, ami egy hvast kiado
ill. fogado task kozott zajlik le.
A taskot egy task programegyseggel denialjuk, ami task specikaciobol es
task torzsb}ol all. Ebben a pontban a task egysegre, az entry-kre a taskok kozotti
kapcsolatok lerasahoz denialt utastasokra (entry hvasa, accept, delay, select es
abort utastas) vonatkozo szabalyokat rjuk le.
12.1. A task speci kacioja es torzse

<task declaration> ::= <task specication>
<task specication> ::= task type ] <identier> is
f<entry declaration>gf<representation clause>g
end <task simple name> ] ]
<task body> ::= task body <task simple name> is
end <task simple name> ]
A specikacio es a torzs szerepe pontosan olyan, mint mas programegysegek
eseteben. Az a specikacio, ami a task type alapszavakkal kezd}odik, task tpust
denial (azaz ezt a taskot objektumok denialasaval megtobbszorozhetjuk). A task
tpus ertekei olyan taskok, amelyeknek az entry pontjai pontosan azok, amiket a
84 Ada
specikacios resz felsorol. A type alapszo nelkuli specikacio egyedi taskot denial.
Az ilyen task deklaracio ekvivalens azzal, mintha denialtunk volna egy task tpust
es deklaraltunk volna ehhez egy taskot. Pelda task tpusok es egyszer}u taskok
specikalasara:
task type RESOURCE is
entry SEIZE
entry RELEASE
end RESOURCE
task type KEYBOARD DRIVER is
entry READ (C:out CHARACTER)
entry WRITE(C:is CHARACTER)
end KEYBOARD DRIVER
task PRODUCER
task CONSUMER
task BUFFER is
entry PUT(C:in CHARACTER)
entry GET(C:out CHARACTER)
end BUFFER
A task torzse denialja a task vegrehajtasanak hatasat. A task torzsenek
vegrehajtasa a task aktivizalasanak hatasara tortenik meg. Peldak task torzsre:
task body PRODUCER is
C : CHARACTER
begin
loop
PRODUCE(C)
BUFFER.PUT(C)
end loop
end PRODUCER
task body CONSUMER is
C : CHARACTER
begin
loop
BUFFER.GET(C)
CONSUME(C)
end loop
end CONSUMER
12.2. Task tpusok, task objektumok

A task tpus limited tpus, gy sem az ertekadas sem az osszehasonltas (=,
/=) nem megengedett task tpusu objektumokra, es ezek nem szerepelhetnek out
modu formalis parameterkent sem. Ha a task objektum egy olyan objektum, vagy
egy olyan objektumnak a komponense, amit
a) egy objektumdeklaracioban deklaraltunk, a task objektum erteket a dek-
laracio kiertekelese nyoman hatarozzuk meg
b) egy allokator kiertekelese nyoman hozunk letre, a task objektum erteket az
Taskok 85
allokator kiertekelesekor hatarozzuk meg.

Peldak task valtozok deklaralasara :
type KEYBOARD is access KEYBOARD DRIVER
CONTROL : RESOURCE
TELETYPE : KEYBOARD DRIVER
POOL : array
(1 .. 10) of
KEYBOARD DRIVER
TERMINAL : KEYBOARD := new
KEYBOARD DRIVER
12.3. Taskok aktivizalasa, vegrehajtasa

A task vegrehajtasat a task torzse denialja. A vegrehajtas kezdeti lepese a
task aktivizalasa (ez a deklaracios resz kiertekeleset is magaban foglalja).
A task aktivizalasa az objektumot deklaralo deklaracios resz kiertekelesenek
befejezese utan, a torzs els}o utastasanak vegrehajtasa el}ott tortenik meg. Ha a
deklaracio egy package specikacios reszeben van, az aktivizalas a torzs deklaracios
reszenek kiertekelese utan es a torzs vegrehajtasa el}ott tortenik meg. Az a task
objektum vagy objektum komponens, amit allokatorral hozunk letre, az allokator
kiertekelesekor kerul aktivizalasra. (Ugyanezek ervenyesek arra a taskra is, ami
egy objektum komponense.)
Ha a task aktivizalasa kozben hiba tortenik, a task komplett allapotba
kerul, az aktivizalas befejezese utan fellep a TASKING ERROR a taskokat tartal-
mazo programegyseg torzseben. Egy komplett allapotba kerult taskot mar semmi-
lyen modon nem lehet ujra elindtani.
12.4. Taskok terminalasa

Minden task fugg legalabb egy szul}ot}ol. A szul}o lehet szinten task, vegrehajtas
alatt allo blokk, alprogram vagy konyvtari package. A fugges kozvetlen az alabbi
ket esetben.
a) Ha az objektum vagy objektum komponense altal jelolt taskot egy allokator
kiertekelese kozben hoztuk letre, a task attol az egysegt}ol (mint szul}ot}ol) fugg,
amelyik az access tpust kiertekelte.
b) Ha deklaracio kiertekelese kozben hoztuk letre, akkor attol az egysegt}ol fugg,
amelyik a deklaracio kiertekeleset kezdemenyezte.
Ha a task fugg egy szul}ot}ol, amit egy masik egyseg (szul}o) hajt vegre, akkor
a task (kozvetve) ett}ol a szul}ot}ol is fugg.
A task komplette valik, ha vegeter a task torzseben lev}o utastasok
vegrehajtasa, vagy ha a vegrehajtas kozben hiba lep fel es nincs a taskban hiba-
kezel}o programresz, vagy ha van, es annak a vegrehajtasa befejez}odik. A task ter-
minal, ha komplett, es az osszes t}ole fugg}o task mar terminalt. Kulonben a task
86 Ada
pontosan akkor terminal, ha a vegrehajtasa egy terminate utastashoz ert, es tel-
jesul az alabbi ket feltetel:
a) a task olyan szul}ot}ol fugg, ami mar terminalt (a vegrehajtasa vegetert, tehat
pl. nem konyvtari package)
b) a szul}ot}ol fugg}o osszes task terminalt mar, vagy szinten egy terminate
utastasnal varakozik.
Pelda :
declare
type GLOBAL is access RESOURCE
A, B : RESOURCE
G : GLOBAL
begin ;; A es B aktivizalodik
declare
type LOCAL is access RESOURCE
X : GLOBAL := new RESOURCE
L : LOCAL := new RESOURCE
C : RESOURCE
begin ;; C aktivizalodik
G := X ;; G es X ugyanazt az objektumot jelolik
end ;; varakozas C es L.all terminalasara
end ;; varakozas A, B es G.all terminalasara
A taskokhoz is tartoznak attributumok:
- TaskName'CALLABLE | logikai ertek, ami pontosan akkor hamis, ha a task
mar komplette valt, terminalt vagy abortalt (vagyis mar nem lesz tobbe hvhato).
- TaskName'TERMINATED | logikai ertek, ami pontosan akkor igaz, ha a task
mar terminalt.
- EntryName'COUNT | a megnevezett entry-hez tartozo accept-re varakozo
hvasok szama.
(Ellen}orz}o kerdes. Nezzuk meg gyelmesen az alabbi programreszletet!
procedure MAIN is
task type T
task body T is begin null end T
function F return T is
X : T
begin
return X
end F
begin
if F'TERMINATED then
PUT LINE("terminated")
else
PUT LINE("not terminated")
end if
end MAIN
Mit kell ki rnia a programnak?)
12.5. entry, entry hvas, accept utastas

<entry declaration> ::= entry <identier> ( <discrete range> ) ]
Taskok 87
<formal part> ]
<entry call statement> ::= <entry name> <actual parameter part> ]
<accept statement> ::= accept <entry simple name> ( <entry index> ) ]
<formal part> ]
do <sequence of statements>
end <entry simple name> ] ]
<entry index> ::= <expression>
Az entry hvas es az accept utastas szolgalnak el}osorban a taskok szink-
ronizalasara es adatcserejere. Az entry deklaracio hasonlo az alprogramdek-
laraciohoz, de csak taskban megengedett. Az entry formalis es aktualis pa-
rameterreszere ugyanaz ervenyes, mint az alprogramok parametereire.
Az entry deklaracio deklaralhatja entry-k csaladjat is a csaladot diszkret
intervallummal jeloljuk ki. A csalad egy entry-jere indexelessel hivatkozhatunk. A
torzson kvul az entry nevekre szelekcios formaban kell hivatkozni, ahol az el}otag
a task objektum neve.
Az accept utastas denialja azokat a m}uveleteket (a szamtast), amiket akkor
kell elvegezni, ha az entry hvasa megtortent. Minden entry-hez kulon accept
tartozik.
Ha az entry-t az adott pillanatban csak egy task hvja, ket eset lehetseges.
a) Ha a task vegrehajtasa meg nem jutott el a megfelel}o accept utastashoz, a
hvo felfuggeszt}odik.
b) Ha a task vegrehajtasa egy accept utastashoz ert es nincs a megfelel}o entry-
re hvas, a task felfuggeszt}odik.
Ha az entry hvas pillanataban a hvott entry-hez tartozo accept utastasnal
tart a vegrehajtas, vegrehajtodik az accept utastas torzse (a hvo task
felfuggeszt}odik). Ez a randevu. Az accept torzs vegrehajtasa utan mindket task
parhuzamosan fut tovabb.
Ha tobb task hvja ugyanazt az entry-t, mikozben a vegrehajtas nem erte el
az accept utastast, a hvasok egy varakozasi sorba kerulnek. Minden entry-hez
kulon varakozasi sor tartozik. Az accept utastas minden egyes vegrehajtasa kivesz
egy varakozot a sorbol.
Pelda az accept utastas hasznalatara :
task body BUFFER is
BUF : CHARACTER
begin
loop
accept PUT(C:in CHARACTER) do
BUF := C
end PUT
accept GET(C:out CHARACTER) do
C := BUF
end GET
88 Ada
end loop
end BUFFER
12.6. A delay es az abort utastas

<delay statement> ::= delay <simple expression>
A delay t utastas felfuggeszti a taskot t masodpercre. Az Ada a f}oprogramot
magat is egy tasknak fogja fel, ezert a delay utastas hasznalhato taskon kvul is, ek-
kor a f}oprogramot fuggeszti fel az adott id}ore. Az id}o megadasara az Ada be-
vezeti a predenit valos DURATION tpust. A DURATION tpus gepi repre-
zentaciojara az Ada el}orja, hogy DURATION'SMALL nem lehet nagyobb 20 ez-
redmasodpercnel, a tpus legnagyobb erteke nem lehet kisebb, mint 86400.
Az id}o kezelesehez az Ada konyvtar predenit egysegkent tartalmazza a CA-
LENDAR package-t.
with SYSTEM
package CALENDAR is
type TIME is private
subtype YEAR NUMBER is INTEGER range 1901 .. 2099
subtype MONTH NUMBER is INTEGER range 1 .. 12
subtype DAY NUMBER is INTEGER range 1 .. 31
subtype DAY DURATION is DURATION range 0.0 .. 86 400.0
function CLOCK return TIME
function YEAR (DATE: TIME) return YEAR NUMBER
function MONTH (DATE: TIME) return MONTH NUMBER
function DAY (DATE: TIME) return DAY NUMBER
function SECONDS (DATE: TIME) return DAY DURATION
procedure SPLIT(DATE : in TIME
YEAR : out YEAR NUMBER
MONTH : out MONTH NUMBER
DAY : out DAY NUMBER
SECONDS : out DAY DURATION)
function TIME OF(YEAR : YEAR NUMBER
MONTH : MONTH NUMBER
DAY : DAY NUMBER
return TIME
SECONDS : DAY DURATION := 0.0)
function "+" (LEFT : TIME RIGHT : DURATION) return TIME
function "+" (LEFT : DURATION RIGHT : TIME) return TIME
function ";" (LEFT : TIME RIGHT : DURATION) return TIME
function ";" (LEFT : TIME RIGHT : TIME) return DURATION
function "<" (LEFT, RIGHT : TIME) return BOOLEAN
function "<=" (LEFT, RIGHT : TIME) return BOOLEAN
function ">" (LEFT, RIGHT : TIME) return BOOLEAN
function ">=" (LEFT, RIGHT : TIME) return BOOLEAN
TIME ERROR : exception
private
Taskok 89
;; implementaciofugg}o
end CALENDAR
<abort statement> ::= abort <task name> f , <task name>g
Az abort T1,T2 utastas abnormal allapotba hozza a megnevezett taskokat.
Ebben az allapotban a task randevuban mar nem vehet reszt. Ha az abortalt
task accept, select, delay utastasnal, entry hvasnal (ahol a randevu meg nem jott
letre) tart, akkor a task komplett allapotba kerul.
12.7. A select utastas

<select statement> ::= <selective wait>j<conditional entry call>
j<timed entry call>
A select utastas kombinalva az accept, delay es terminate utastasokkal,
kulonfele helyezetek megoldasara alkalmazhato. Harom ilyen a szelektv
varakoztatas, a felteteles entry utastas es az id}ohoz kotott entry hvas.
12.7.1. A szelektv varakoztatas

<selective wait> ::= select <select alternative>
f or <select alternative>g
end select
<select alternative> ::= when <condition> => ] <selective wait alternative>
<selective wait alternative> ::= <accept alternative>
j<delay alternative>j<terminate alternative>
<accept alternative> ::= <accept statement> <sequence of statements> ]
<delay alternative> ::= <delay statement> <sequence of statements> ]
<terminate alternative> ::= terminate
A select utastasnak ez a formaja lehet}ove teszi valamely feltetelek egyikenek
teljesuleseig a varakozast, majd egy feltetel teljesulesekor a hozza tartozo
utastasok vegrehajtasat.
A szelektv varakoztatasnak legalabb egy olyan aga kell legyen, ami accept
utastast tartalmaz, ezen kvul lehet olyan aga, ami delay utastast, es olyan, ami
terminate utastast tartalmaz.
Egy agat nyitottnak nevezunk, ha nincs benne feltetel (when), vagy ha a
feltetel erteke igaz, kulonben zartnak nevezzuk.
A select utastas vegrehajtasakor a feltetelek kiertekelesre kerulnek, es meg-
hatarozasra kerul, mely agak nyitottak. Ezutan vegrehajtodik egy nyitott
ag, vagy ha ilyen nincs, az else - ag. Ezzel az utastas vegrehajtasa befe-
90 Ada
jez}odik. Ha tobb nyitott ag is van, a valasztas a kovetkez}o szabalyok sze-

rint tortenik :
a) ha van nyitott accept ag, amelynel randevu jon letre, az hajtodik vegre
b) ha nincs nyitott accept ag, akkor egy nyitott delay ag valasztodhat ki
c) az else - ag csak akkor valasztodhat ki, ha mindegyik ag zart
d) a terminate ag nem valasztodhat ki addig, amg van a tasknak nem ures entry-
sora.
Pelda a szelektv varakoztatasra:
task body RESOURCE is
BUSY : BOOLEAN := FALSE
begin
loop
select
when not BUSY =>
accept SEIZE do BUSY := TRUE end
or
accept RELEASE do BUSY := FALSE end
or
terminate
end select
end loop
end RESOURCE
12.7.2. A felteteles entry hvas

<conditional entry call> ::= select <entry call statement>
<sequence of statements> ]
else <sequence of statements>
end select
A felteteles entry hvas csak akkor hoz letre entry hvast, ha a randevu azonnal
letre is jon. Nem tortenik meg az entry hvas, ha a randevu nem johet azonnal
letre (pl. mert a task vegrehajtasa meg nem tart az accept utastasnal, vagy az
accept aga nem nyitott, vagy az illet}o entry-hez tartozo varakozasi sor nem ures).
procedure SPIN(R:in RESOURCE) is
begin
loop
select
R.SEIZE
return
else
null ;; varakozas BUSY = TRUE -ra
end select
end loop
end SPIN
Ha a hvas nem tortenik meg, helyette az else ag hajtodik vegre.
Taskok 91
12.7.3. Id}ohoz kotott entry hvas

<timed entry call> ::= select <entry call statement>
or <delay alternative>
end select
Az id}ohoz kotott entry hvasnal a hvas akkor kovetkezik be, ha a randevu
meg az utastasban megadott id}o lejarta el}ott letrejon. Ha az adott id}o alatt a
randevu nem jon letre, a delay - ag hajtodik vegre.
select
CONTROLLER.REQUEST(MEDIUM)(SOME ITEM)
or
delay 45.0
end select
i) Kolcsonos kizaras
Parhuzamos rendszerekben szukseg van olyan eszkozre, ami biztostja, hogy
amikor egy kozosen hasznalt objektumhoz egy task "hozzanyul", arra az id}ore a
tobbi task ne ferhessen hozza. Az Adaban a kolcsonos kizarast tobbfelekeppen, es
nagyon egyszer}uen meg lehet valostani.
El}oszor az osztott objektumot magaban a taskban helyezzuk el. Itt T egy
korabban denialt tpus, COMMON pedig az osztott objektum neve.
task SHARED DATA is
entry UPDATE(X:in T)
entry READ(X:out T)
end SHARED DATA
task body SHARED DATA is
COMMON : T
begin
loop
select
accept UPDATE(X:in T) do
COMMON := X
end UPDATE
or
accept READ(X:out T) do
X := COMMON
end READ
or
terminate
end select
end loop
end SHARED DATA
92 Ada
Az osztott objektum lehet egy globalis objektum is, ilyenkor a kolcsonos

kizarast szemafor hasznalataval valosthatjuk meg. Egy szemaforhoz egy P es
egy V m}uvelet tartozik. A P operacio csak az els}o }ot meghvo taskot en-
degi tovabb, a tobbit megvarakoztatja, a V operacio pedig mindig tovabbindt
egy a P altal felfuggesztett taskot.
task type SEMAPHORE is
entry P
entry V
end SEMAPHORE
task body SEMAPHORE is
begin
loop
accept P
accept V
end loop
end SEMAPHORE
Az osztott objektumhoz valo fordulas el}ott tehat mindig meg kell hvni a P
operaciot, amikor pedig befejez}odtek az osztott objektumon vegzett m}uveletek,
akkor meg kell hvni a V operaciot, ezzel az objektum hasznalatara vonatkozoan a
kolcsonos kizarast biztostottuk.
COMMON : T
S : SEMAPHORE
begin
...
S.P
COMMON := F(COMMON)
S.V
...
A szemafor egy nem tulsagosan megbzhato szinkronizacios technika, ha ugya-

nis valahol kifelejtjuk a V operacio meghvasat, ez teljesen osszezavarja a prog-
ram m}ukodeset.
ii) Termel}o-fogyaszto feladat

A termel}o-fogyaszto feladatokban ketfajta task szerepel: az egyik, ami bi-
zonyos tpusu adatokat el}oallt, a masik pedig az, amelyik feldolgozza eze-
ket.
with SHARED QUEUE
package SHARED INTEGER QUEUE is
new SHARED QUEUE(INTEGER, 128)
task body PRODUCER is
C : INTEGER
begin
loop
;; C el}oall tasa
Taskok 93
SHARED INTEGER QUEUE.QUEUE.PUT(C)

end loop
end PRODUCER
task body CONSUMER is
C : INTEGER
begin
loop
SHARED INTEGER QUEUE.QUEUE.GET(C)
;; C felhasznalasa
end loop
end CONSUMER
A meg fel nem dolgozott adatokat egy sorban kell tarolni, s ehhez a sorhoz
mind a ket fajta tasknak hozza kell tudni ferni, s}ot, a hozzaferesre biztostani
kell a kolcsonos kizarast. Egy ilyen sor kezeleset mutatjuk meg az alabbi generic-
ben.
generic
type ITEM is private
QUEUE LENGTH : NATURAL
package SHARED QUEUE is
task QUEUE is
entry GET (D:out ITEM)
entry PUT (D:in ITEM)
end QUEUE
end SHARED QUEUE
package body SHARED QUEUE is
task body QUEUE is
type BUFFER POSSIBLE is
new NATURAL range 0 .. QUEUE LENGTH
subtype BUFFER ACTUAL is
BUFFER POSSIBLE range 1 .. BUFFER POSSIBLE'LAST
BUFFER : array (BUFFER ACTUAL) of ITEM
CONTAINS : BUFFER POSSIBLE := 0
INX, OUTX : BUFFER ACTUAL := 1
begin
loop
select
when CONTAINS > 0 =>
accept GET (D:out ITEM) do
D := BUFFER(OUTX)
end GET
OUTX := OUTX mod BUFFER POSSIBLE'LAST + 1
CONTAINS := CONTAINS ; 1
or
when CONTAINS < BUFFER POSSIBLE'LAST =>
accept PUT (D:in ITEM) do
BUFFER(INX) := D
end PUT
INX := INX mod BUFFER POSSIBLE'LAST + 1
CONTAINS := CONTAINS + 1
or
terminate
end select
94 Ada
end loop
end QUEUE
end SHARED QUEUE
iii) Osztott halmaz megvalostasa

A pacakege-kr}ol szolo fejezet vegen kozoltunk egy peldat halmaz meg-
valostasara. Ez volt az ORDERED SET package. Ebben a pontban elkesztjuk ugya-
nazt a package-t, de ugy, hogy a halmaz osztott, tobb task altal is hasznalhato
legyen.
type ID is range 1 .. 128
package ORDERED SET is
EMPTY SET : exception
procedure INSERT(JOB:in ID T:in DURATION)
procedure SMALLEST(JOB:out ID)
end ORDERED SET
package body ORDERED SET is
task SET MANAGER is
entry INSERT (JOB:in ID T:in DURATION)
entry SMALLEST (JOB:out ID PRESENT: out BOOLEAN)
end SET MANAGER
task body SET MANAGER is
IN SET : array (ID) of BOOLEAN := (ID => FALSE)
RANK : array (ID) of DURATION
begin
loop
select
accept INSERT (JOB:in ID T:in DURATION) do
RANK(JOB) := T
IN SET(JOB) := TRUE
end INSERT
or
accept SMALLEST (JOB:out ID PRESENT: out BOOLEAN) do
declare
T : DURATION := DURATION'LAST
SMALL : ID
FOUND : BOOLEAN := FALSE
begin
for I in ID loop
if IN SET(I) and then RANK(I) <= T then
SMALL := I T := RANK(I) FOUND := TRUE
end if
end loop
if FOUND then
IN SET(SMALL) := FALSE
JOB := SMALL
PRESENT := TRUE
else
PRESENT := FALSE
end if
end
Taskok 95
end SMALLEST
or
terminate
end select
end loop
end SET MANAGER
procedure INSERT(JOB:in ID T:in DURATION) is
begin
SET MANAGER.INSERT(JOB, T)
end INSERT
procedure SMALLEST(JOB:out ID) is
PRESENT : BOOLEAN
begin
SET MANAGER.SMALLEST(JOB, PRESENT)
if not PRESENT then raise EMPTY SET end if
end SMALLEST
end ORDERED SET
iv) Egy nagyon egyszer}u terminal emulator

Ebben a peldaban a taskok hasznalataval, pontosabban egy-egy task inter-
rupt rutinkent valo alkalmazasaval foglalkozunk. Ha ez a program pl. egy IBM
PC -n futna, s annak a soros vonalara (RS232) egy masik gep (pl. VAX) ter-
minalvonala volna csatlakoztatva, akkor a program a klaviaturan begepelt pa-
rancsokat tovabbtana a masik gepnek, s megjelentene az arrol jov}o informaciot
ezaltal a PC eljatszhatna egy terminal szerepet. (Az, hogy ez milyen tpusu ter-
minal, tehat pl. VT52, VT100 vagy VT320, attol fugg, hogy a progra-
munk milyen escape-szekvenciakat ismer fel es hajt vegre. A feladatnak ez-
zel a reszevel nem foglalkozunk.)
with TEXT IO, KEYBOARD, RS232
procedure TE is
C : CHARACTER
begin
while TRUE loop
if KEYBOARD.PRESSED then
RS232.PUT(KEYBOARD.GET)
end if
if RS232.RECEIVED then
C := RS232.GET
case C is
when ASCII.ETX =>
exit
when ASCII.ESC =>
... az escape szekvenciak feldolgozasa
when others =>
TEXT IO.PUT(RS232.GET)
end case
end if
end loop
end TE
96 Ada
package KEYBOARD is
function PRESSED return BOOLEAN
function GET return CHARACTER
end KEYBOARD
with TEXT IO
package body KEYBOARD is
DATA : CHARACTER
for DATA use at 16#60#
BUFFER LEN : constant := 256
BUFFER : array (1 .. BUFFER LEN) of CHARACTER
INX, OUTX : INTEGER := 1
COUNT : INTEGER := 0
task KEYBOARD INPUT is
entry INPUT
for INPUT use at 16#09#
end KEYBOARD INPUT
task body KEYBOARD INPUT is
begin
loop
accept INPUT
if COUNT < BUFFER LEN then
BUFFER(INX) := DATA
INX := INX mod BUFFER LEN + 1
COUNT := COUNT + 1
else
TEXT IO.PUT(ASCII.BEL)
end if
end loop
end KEYBOARD INPUT
function PRESSED return BOOLEAN is
begin
return COUNT > 0
end PRESSED
function GET return CHARACTER is
CH : CHARACTER
begin ;; precondition: COUNT > 0
CH := BUFFER(OUTX)
OUTX := OUTX mod BUFFER LEN + 1
COUNT := COUNT ; 1
return CH
end GET
end KEYBOARD
package RS232 is
function RECEIVED return BOOLEAN
procedure PUT(CH:in CHARACTER)
function GET return CHARACTER
end RS232
with TEXT IO
package body RS232 is
type STATUS REGISTER is array (0 .. 15) of BOOLEAN
LINE STATUS : STATUS REGISTER
Taskok 97
for LINE STATUS use at 16#3FD#

DATA : CHARACTER
for DATA use at 16#3F8#
BUFFER LEN : constant := 256
BUFFER : array (1 .. BUFFER LEN) of CHARACTER
INX, OUTX : INTEGER := 1
COUNT : INTEGER := 0
ENABLED : BOOLEAN := TRUE
task RS232 INPUT is
entry INPUT
for INPUT use at 16#30#
end RS232 INPUT
task body RS232 INPUT is
begin
loop
accept INPUT
if COUNT < BUFFER LEN then
BUFFER(INX) := DATA
INX := INX mod BUFFER LEN + 1
COUNT := COUNT + 1
end if
end loop
end RS232 INPUT
function RECEIVED return BOOLEAN is
begin
return COUNT > 0
end RECEIVED
procedure PUT(CH:in CHARACTER) is
begin
DATA := CH
loop
exit when LINE STATUS(9)
end loop
end PUT
function GET return CHARACTER is
CH : CHARACTER
begin ;; precondition: COUNT > 0
if not ENABLED and then COUNT < 30 then
ENABLED := TRUE TEXT IO.PUT(ASCII.DC1)
end if
CH := BUFFER(OUTX)
OUTX := OUTX mod BUFFER LEN + 1
COUNT := COUNT ; 1
if ENABLED and then COUNT > 200 then
ENABLED := FALSE TEXT IO.PUT(ASCII.DC3)
end if
return CH
end GET
end RS232
v) Forgalmi lampak iranytasa

98 Ada
Egy keresztez}odes forgalmi lampainak vezerleset vegz}o programot kesztunk.

aban a f}outon
A keresztez}odesben egy f}out es egy mellekut metszi egymast. Altal
szabad a jelzes, s a f}out forgalmat csak akkor alltjuk meg, ha a mellekutba
beeptett erzekel}o azt jelzi, hogy a mellekuton a keresztez}odeshez gepkocsi
erkezett, vagy ha egy gyalogos azt jelzi, hogy a f}outon lev}o zebran at akar ha-
ladni. Az erzekel}o es a gyalogos nyomogombja egyarant a 8#2000# cmen okoz-
nak interruptot. A f}out forgalmanak megalltasakor be kell tartani a kovetkez}oket:
- A f}out forgalmat csak akkor lehet megalltani, ha legalabb 3 percen keresztul
a zold jelzes volt ervenyben.
- A f}out forgalmat legfeljebb fel percre szabad lealltani.
A forgalmi lampak kapcsolasara a TRAFFIC LIGHT package-t hasznalhatjuk:
package TRAFFIC LIGHT is
procedure START LIGHT
;; a lampak bekapcsolasa a f}out lampaja zold,
;; a mellekute piros
procedure CHANGE LIGHT
;; ellenkez}ore alltja a keresztez}odesben
;; a lampakat
end TRAFFIC LIGHT
A f}oprogram:
with TRAFFIC LIGHT use TRAFFIC LIGHT
procedure CONTROL TRAFFIC LIGHT is
task LIGHT is
entry STOP MAIN
for STOP MAIN use at 8#2000#
end LIGHT
task body LIGHT is
CUT OFF : constant DURATION := 180.0
SIDE ROAD OPEN : constant DURATION := 30.0
begin
START LIGHT
loop
delay CUT OFF
accept STOP MAIN CHANGE LIGHT
delay SIDE ROAD OPEN
for I in 1 .. STOP MAIN'COUNT loop
accept STOP MAIN
end loop
CHANGE LIGHT
end loop
end LIGHT
begin
null
end CONTROL TRAFFIC LIGHT
vi) Prmszamok el}oalltasa

Taskok 99
Prmszamok el}oalltasanak egy jol ismert modszere az Eratoszthenesz-fele szi-

tamodszer. A taskok felhasznalasaval egy erdekes program keszthet}o az alabbi
alapgondolat alapjan: a termeszetes szamokat sorba alltjuk, majd az els}o
prmszammal elindtunk egy sz}ur}o taskot. A sz}ur}o task az els}o kapott szamot
kirja, hiszen ez biztosan prm, elindt egy ujabb sz}ur}o taskot, s a szamokat |
kiveve az els}o szam tobbszoroseit | ennek atadja. 7]
procedure SIEVE is
package INT IO is new INTEGER IO(INTEGER) use INT IO
;; First define the filter type.
task type FILTER is
entry NUMBER STREAM(NUMBER:in INTEGER)
end FILTER
type FILTER TASK is access FILTER ;; pointer to a filter task
FIRST FILTER : FILTER TASK
NUMBERS : INTEGER
functionNEW FILTER return
FILTER TASK is
begin
return new FILTER
end NEW FILTER
task body FILTER is
NEXT FILTER : FILTER TASK
PRIME, NUM : INTEGER
begin
accept NUMBER STREAM(NUMBER:in INTEGER) do
PRIME := NUMBER
end NUMBER STREAM
if PRIME > ;1 then ;; ";1" is an end-of-numbers flag.
PUT(PRIME) NEW LINE
NEXT FILTER := NEW FILTER ;; Spawn a new filter.
loop
accept NUMBER STREAM(NUMBER:in INTEGER) do
NUM := NUMBER
end NUMBER STREAM
if NUM = ;1 then
NEXT FILTER.NUMBER STREAM(NUM)
exit
end if
if NUM mod PRIME /= 0 then
;; Pass the number on.
NEXT FILTER.NUMBER STREAM(NUM)
end if
end loop
end if
end FILTER
begin ;; Main program. Generate the initial list of integers.
PUT("Enter end of integer range: ")
GET(NUMBERS)
FIRST FILTER := new
FILTER
PUT LINE("All primes in the range are: ")
for in
I 2 .. NUMBERS loop
FIRST FILTER.NUMBER STREAM(I)
end loop

100 Ada
;; Flag the end-of-numbers.

FIRST FILTER.NUMBER STREAM(;1)
end SIEVE
Reprezentacios specikaciok 101
13. Reprezentacios speci kaciok
Egy software-kesztesre is alkalmas magasszint}u nyelvnek kulonboz}o szint}u

eszkozokre van szuksege az adatmanipulaciok teren (raadasul ezeknek az
eszkozoknek elesen el kell hatarolodniuk):
- rendelkeznie kell eszkozokkel az absztrakt tpusok kezelesere, ahol az adatok-
nak csak a logikai tulajdonsagai fontosak, es
- rendelkeznie kell olyan eszkozokkel is, amelyek az adatok zikai abrazolasanak
szintjen hasznalhatok fel.
Az eddigiekben az adatkezelesnek a logikai szintjevel foglalkoztunk, ebben a
pontban az alacsonyszint}u, gepkozeli eszkozoket targyaljuk.
<representation clause> ::= <type representation clause>j<address clause>
<type representation clause> ::= <length clause>
j<enumeration representation clause>
j<record representation clause>
<length clause> ::= for <attribute> use <simple expression>
A tpusokhoz megadhatjuk, hogy a tpus egy ertekenek abrazolasahoz a
fordtoprogram mennyi helyet (hany bitet) hasznalhat fel (ez nyilvanvaloan azt is
meghatarozza, hogy az ertekek eleresehez milyen kodot kell generalnia). Peldak:
type MEDIUM is range 0 .. 65000
for MEDIUM'SIZE use 16
type COLOR is (WHITE, RED, YELLOW, GREEN, BLUE, BROWN, BLACK)
for COLOR'SIZE use 8
<enumeration representation clause> ::= for <type simple name>
use <aggregate>
A felsorolasi tpusok ertekeit alapertelmezesben a fordtoprogram a 0, 1, 2, ...
szamokkal kodolja. El}orhato, hogy ez ne gy tortenjen:
type MIX CODE is (ADD, SUB, MUL, LDA)
for MIX CODE use (ADD => 1, SUB => 2, MUL => 3, LDA => 8)
<record representation clause> ::= for <type simple name> use record
<alignment clause> ]
f<component clause>g
end record
<alignment clause> ::= at mod <static simple expression>
<component clause> ::= <component name> at <static simple expression>
range <static range>
Rekord tpus reprezentaciojara el}orhatjuk, hogy az objektumok milyen pa-
ritasu, esetleg 4-gyel vagy 8-cal oszthato cmen kezd}odjenek, ill. hogy a kompo-
nensek a rekordon belul hanyadik szoban es mely biteken helyezkedjenek el.
102 Ada
WORD : constant
:= 4
typeSTATE is
(A, M, W, P)
typeMODE is
(FIX, DEC, EXP, SIGNIF)
typeBYTE MASK is array
(0 .. 7) of
BOOLEAN
typeSTATE MASK is array
(STATE) of
BOOLEAN
typeMODE MASK is array
(MODE) of
BOOLEAN
typePROGRAM STATUS WORD is
record
SYSTEM MASK : BYTE MASK
PROTECTION KEY : INTEGER range 0 .. 3
MACHINE STATE : STATE MASK
INTERRUPT CAUSE : INTERRUPTION CODE
ILC : INTEGER range
0 .. 3
CC : INTEGER range
0 .. 3
PROGRAM MASK : MODE MASK
INST ADDRESS : ADDRESS
end record
for PROGRAM STATUS WORD use
record at mod 8
SYSTEM MASK at 0*WORD range 0 .. 7
PROTECTION KEY at 0*WORD range 10 .. 11
MACHINE STATE at 0*WORD range 12 .. 15
INTERRUPT CAUSE at 0*WORD range 16 .. 31
ILC at 1*WORD range 0 .. 1
CC at 1*WORD range 2 .. 3
PROGRAM MASK at 1*WORD range 4 .. 7
INST ADDRESS at 1*WORD range 8 .. 31
end record
<address clause> ::= for <simple name> use at <simple expression>

Alapertelmezesben a fordto- es a szerkeszt}oprogramok maguk hatarozzak meg
a program objektumainak a cmeit, az Ada eseteben azonban lehet}osegunk van en-
nek felulbralasara, s a programban el}orhatjuk, hogy egy valtozo vagy egy alprog-
ram a memoria mely cmere kepz}odjon le.
CONTROL : INTEGER
forCONTROL use at
16#0020# ;; a CONTROL valtozo a memoria
;; 16#0020#-as c menek szimbolikus
;; neve lesz
task INTERRUPT HANDLER is
entry DONE
for DONE use at 16#0040# ;; a DONE entry megh vasa
;; azt a runtint h vja meg, amelynek c me
;; a 16#0040# c men talalhato
end INTERRUPT HANDLER
Fordtasi direktvak 103
14. Fordtasi direktvak
A reprezentacios specikaciokon kvul a fordtast befolyasolhatjuk meg

fordtasi direktvakkal, un. pragmakkal is. A pragmak szama az egyes Ada imp-
lementaciokban elterhet. Itt csak nehany altalanosan hasznalt pragmat soro-
lunk fel.
<pragma> ::= pragma <identier>
( <argument association> f , <argument association>g ) ]
<argument association> ::= <argument identier> => <name>
j <argument identier> => ] <expression>
pragma ELABORATE(azonosto, ...) | A pragma parameterlistajan va-
lamely, az adott egysegben hasznalt konyvtari egysegek nevei lehetnek. A
pragmat a with es use utastasok es az egyseg specikacios resze kozott kell el-
helyezni. Az ELABORATE pragma azt rja el}o, hogy a megnevezett package-
ket a program vegrehajtasanak kezdeten el}obb kell kiertekelni (a torzs inicia-
lizalo reszet el}obb kell vegrehajtani), mint a pragmat tartalmazo egyseget.
pragma INLINE(azonosto, ...) | A pragma parameterlistajan alprogram-
nevek szerepelnek. A pragmat abban a deklaracios reszben kell elhelyezni, ahol a
listan szerepl}o alprogramok specikacios reszei vannak. Az INLINE pragma azt rja
el}o, hogy az alprogramtorzseket a hvas helyere makroszer}uen be kell masolni. Az
INLINE pragm anak a fordtasi sorrendre is van hatasa. Ha egy egysegben INLINE
alprogramok vannak, akkor az egysegre hivatkozo egysegeket csak azutan lehet
fordtani, hogy az alprogramok torzset tartalmazo egyseget is lefordtottuk.
pragma INTERFACE(nyelv megnevezese, alprogram neve) | A pragmat a meg-
nevezett alprogram specikacioja utan kell elhelyezni. Az INTERFACE pragma
arra gyelmezteti a fordtoprogramot, hogy az alprogramtorzset nem Adaban
kesztettek el, s a hvasokat a jelzett nyelvnek megfelel}oen kell generalni.
pragma OPTIMIZE(azonosto) | A pragma argumentume a TIME vagy
a SPACE szo lehet. A pragmat deklaracios reszben kell elhelyezni, s a dek-
laracios reszhez tartozo blokkra vagy torzsre vonatkozik. El}orja, hogy az id}o
vagy a hely legyen-e az els}odleges optimalizalasi kriterium.
pragma SUPPRESS(azonosto) | A pragma parameterlistajan egy objek-
tum, egy tpus vagy egy exception neve lehet, ill. a pragma hasznalhato ures pa-
rameterlistaval is. A pragmat egy deklaracios reszben kell elhelyezni, s az
egesz torzsre (vagy blokkra) ervenyes. Azt jelenti, hogy a fordtoprogramnak
a megnevezett objektumra, tpusra (pontosabban az ilyen tpusu osszes objek-
tumra) es exception-ra vonatkozo ellen}orzeseket a torzsb}ol ki kell hagynia. A pa-
rameter nelkuli SUPPRESS azt jelenti, hogy a torzs fordtasakor az osszes el-
len}orzest el kell hagyni.
104 Ada
15. Input - output
Az Adaban, a modern gyakorlatnak megfelel}oen, a le-tpusok m}uveletei nem

a nyelv utastasai, hanem predenit package-k alprogramjai. Ezek a SEQUEN-
TIAL IO, DIRECT IO, TEXT IO, IO EXCEPTIONS es a LOW LEVEL IO package. Az Ada
dencioja tartalmazza ezeknek a package-knek a specikacios reszet, s lerja az alp-
rogramok szemantikajat. Ez a megoldas biztostja az I/O egysegesseget es
modosthatosagat, mert gy az I/O implementaciojat konny}u hozzaigaztani az il-
let}o operacios rendszerhez.
Minden I/O egy le-lal kapcsolatos, az I/O utastasok a le tpusok
tpusm}uveletei. A le-ok maguk periferiakon helyezkednek el. Egy le kezelesehez
denialnunk kell egy le-valtozot, ami a feldolgozas pillanatnyi allapotat rja le. A
le-valtozo barmely |megfelel}o tpusu| kuls}o le-lal osszekapcsolhato. A le ke-
zelese tehat nem fugg a berendezest}ol, csak a le tpusatol. (Egy text-le-
t ugyanugy kell kezelni, fuggetlenul attol, hogy az sornyomtaton, vagy leme-
zen van.)
Az Adaban hasznalhato le-tpusokat az emltett package-ek limited private
tpuskent denialjak. A le kezelese a kovetkez}o lepesekben tortenik :
- le-valtozo deklaralasa,
- a le-valtozo osszekapcsolasa egy kuls}o le-lal (le-nyitas),
- az olvaso ill. ro m}uveletek vegrehajtasa,
- a le lezarasa.
Az I/O package-k egysegesek az alprogramok neveinek megvalasztasaban.
Egy le letrehozasa (CREATE), egy letez}o kuls}o le megnyitasa (OPEN), egy le
lezarasa (CLOSE) ugyanolyan eljarassal tortenik, barmelyik package-t hasznaljuk
is.
A le-ok kezelesekor bekovetkez}o hibakat az Ada egy kulon package-ben, az
IO EXCEPTIONS package-ben denialja.
package IO EXCEPTIONS is
STATUS ERROR : exception
MODE ERROR : exception
NAME ERROR : exception
USE ERROR : exception
DEVICE ERROR : exception
END ERROR : exception
DATA ERROR : exception
LAYOUT ERROR : exception
end IO EXCEPTIONS
Input - output 105
15.1. Szekvencialis le-ok kezelese

A szekvencialis le azonos tpusu rekordok sorozata. Az egyes rekordokhoz
un. le-pozciot rendelunk: a le els}o rekordjahoz az 1 -et, a masodikhoz a 2 -t,
..., az utolso rekord utani pozcio neve END OF FILE. A le-nyitas a le-pozciot
1 -re alltja. A SEQUENTIAL IO package generic package, amib}ol a rekordtpus
megadasaval lehet peldanyostani.
with IO EXCEPTIONS
generic
type ELEMENT TYPE is private
package SEQUENTIAL IO is
type FILE TYPE is limited private
type FILE MODE is (IN FILE, OUT FILE)
;; File management
procedure CREATE(FILE : in out FILE TYPE
MODE : in FILE MODE := OUT FILE
NAME : in STRING := ""
FORM : in STRING := "")
procedure OPEN(FILE : in out FILE TYPE
MODE : in FILE MODE
NAME : in STRING
procedure CLOSE(FILE : in out FILE TYPE)
procedure DELETE(FILE : in out FILE TYPE)
procedure RESET(FILE : in out FILE TYPE MODE : in FILE MODE)
procedure RESET(FILE : in out FILE TYPE)
function MODE(FILE : in FILE TYPE) return FILE MODE
function NAME(FILE : in FILE TYPE) return STRING
function FORM(FILE : in FILE TYPE) return STRING
function IS OPEN(FILE : in FILE TYPE) return BOOLEAN
;; Input and output operations
procedure READ(FILE : in FILE TYPE ITEM : out ELEMENT TYPE)
procedure WRITE(FILE : in FILE TYPE ITEM : in ELEMENT TYPE)
function END OF FILE(FILE : in FILE TYPE) return BOOLEAN
;; Exceptions
STATUS ERROR : exception renames IO EXCEPTIONS.STATUS ERROR
MODE ERROR : exception renames IO EXCEPTIONS.MODE ERROR
NAME ERROR : exception renames IO EXCEPTIONS.NAME ERROR
USE ERROR : exception renames IO EXCEPTIONS.USE ERROR
DEVICE ERROR : exception renames IO EXCEPTIONS.DEVICE ERROR
END ERROR : exception renames IO EXCEPTIONS.END ERROR
DATA ERROR : exception renames IO EXCEPTIONS.DATA ERROR
private
106 Ada
end SEQUENTIAL IO

A rekordok olvasasa a READ eljarassal tortenik. Az END OF FILE pozcio
utan valo olvasas END ERROR -t valt ki. Az END OF FILE pozcio felismerhet}o az
END OF FILE f uggvennyel (a fuggveny akkor ad TRUE erteket, ha az aktualis le-
pozcio az END OF FILE pozcio).
A READ es WRITE eljarasok ertelemszer}uen valtoztatjak (1-el novelik) a le-
pozciot.
15.2. Direkt le-ok kezelese

A direkt le-kezeles csak abban kulonbozik a szekvencialistol, hogy a le-
pozcio alltasara az Ada kulon bevezet egy eljarast. Az ras es az olvasas el}ott gy
most pozicionalhatunk a kvant rekordra. Az ras es az olvasas 1-el noveli a le-
pozciot.
with IO EXCEPTIONS
generic
type ELEMENT TYPE is private
package DIRECT IO is
type FILE MODE is (IN FILE, INOUT FILE, OUT FILE)
type COUNT is range 0 .. implementaciofugg}o
subtype POSITIVE COUNT is COUNT range 1 .. COUNT'LAST
;; File management
MODE : in FILE MODE := INOUT FILE
MODE : in FILE MODE
NAME : in STRING
;; Input and output operations
procedure READ(FILE : in FILE TYPE
ITEM : out ELEMENT TYPE
FROM : in POSITIVE COUNT)
procedure READ(FILE : in FILE TYPE
ITEM : out ELEMENT TYPE)
Input - output 107
procedure WRITE(FILE : in FILE TYPE

ITEM : in ELEMENT TYPE
TO : in POSITIVE COUNT)
procedure WRITE(FILE : in FILE TYPE
ITEM : in ELEMENT TYPE)
procedure SET INDEX(FILE : in FILE TYPE
function INDEX(FILE : in FILE TYPE) return POSITIVE COUNT
function SIZE(FILE : in FILE TYPE) return COUNT
;; Exceptions
private
end DIRECT IO
15.3. Text le-ok

A text-le-ok kezelesere valo eljarasok a TEXT IO package-ben vannak de-
nialva. A TEXT IO package nem generic, de generic package-ket tartalmaz az
egesz, valos es felsorolasi tpusokra, valamint alprogramokat a CHARACTER, ST-
RING es BOOLEAN tpusra.
with IO EXCEPTIONS
package TEXT IO is
type FILE MODE is (IN FILE, OUT FILE)
type COUNT is range 0 .. implementaciofugg}o
subtype POSITIVE COUNT is COUNT range 1 .. COUNT'LAST
UNBOUNDED : constant COUNT := 0 ;; line and page length
subtype FIELD is INTEGER range 0 .. implementaciofugg}o
subtype NUMBER BASE is INTEGER range 2 .. 16
type TYPE SET is (LOWER CASE, UPPER CASE)
;; File Management
MODE : in FILE MODE := OUT FILE
MODE : in FILE MODE
108 Ada
NAME :in STRING

FORM :in STRING := "")
;; Control of default input and output files
procedure SET INPUT(FILE : in FILE TYPE)
procedure SET OUTPUT(FILE : in FILE TYPE)
function STANDARD INPUT return FILE TYPE
function STANDARD OUTPUT return FILE TYPE
function CURRENT INPUT return FILE TYPE
function CURRENT OUTPUT return FILE TYPE
;; Specification of line and page lengths
procedure SET LINE LENGTH(FILE : in FILE TYPE TO : in COUNT)
procedure SET LINE LENGTH(TO : in COUNT)
procedure SET PAGE LENGTH(FILE : in FILE TYPE TO : in COUNT)
procedure SET PAGE LENGTH(TO : in COUNT)
function LINE LENGTH(FILE : in FILE TYPE) return COUNT
function LINE LENGTH return COUNT
function PAGE LENGTH(FILE : in FILE TYPE) return COUNT
function PAGE LENGTH return COUNT
;; Column, Line, and Page Control
procedure NEW LINE(FILE : in FILE TYPE
SPACING : in POSITIVE COUNT := 1)
procedure NEW LINE(SPACING : in POSITIVE COUNT := 1)
procedure SKIP LINE(FILE : in FILE TYPE
SPACING : in POSITIVE COUNT := 1)
procedure SKIP LINE(SPACING : in POSITIVE COUNT := 1)
function END OF LINE(FILE : in FILE TYPE) return BOOLEAN
function END OF LINE return BOOLEAN
procedure NEW PAGE(FILE : in FILE TYPE)
procedure NEW PAGE
procedure SKIP PAGE(FILE: in FILE TYPE)
procedure SKIP PAGE
function END OF PAGE(FILE : in FILE TYPE) return BOOLEAN
function END OF PAGE return BOOLEAN
function END OF FILE return BOOLEAN
procedure SET COL(FILE : in FILE TYPE TO : in POSITIVE COUNT)
procedure SET COL(TO : in POSITIVE COUNT)
procedure SET LINE(FILE : in FILE TYPE
Input - output 109
procedure SET LINE(TO : in POSITIVE COUNT)
function COL(FILE : in FILE TYPE) return POSITIVE COUNT
function COL return POSITIVE COUNT
function LINE(FILE : in FILE TYPE) return POSITIVE COUNT
function LINE return POSITIVE COUNT
function PAGE(FILE : in FILE TYPE) return POSITIVE COUNT
function PAGE return POSITIVE COUNT
;; Character Input-Output
;; ld. 15.3.1.
;; String Input-Output
;; ld. 15.3.1.
;; Generic package for Input-Output of Integer Types
generic
type NUM is range <>
package INTEGER IO is
;; ld. 15.3.2.
end INTEGER IO
;; Generic package for Input-Output of Real Types
generic
type NUM is digits <>
package FLOAT IO is
;; ld. 15.3.3.
end FLOAT IO
generic
type NUM is delta <>
package FIXED IO is
;; ld. 15.3.3.
end FIXED IO
;; Generic package for Input-Output of Enumeration types
generic
type ENUM is (<>)
package ENUMERATION IO is
;; ld. 15.3.4.
end ENUMERATION IO
;; Exceptions
LAYOUT ERROR : exception renames IO EXCEPTIONS.LAYOUT ERROR
private
end TEXT IO
Az Adaban leteznek feltetelezett (standard) text-le-ok is, amelyeket a fut-

110 Ada
tato rendszer a program indulasanak pillanataban automatikusan megnyit. In-

teraktv rendszerekben ezek a le-ok a terminalhoz vannak rendelve: a kla-
viatura a standard input, a keperny}o a standard output le. A standard le-ra vo-
natkozo GET es PUT eljarasokban le-valtozot nem kell megadni. A stan-
dard le atiranythato mas text-le-ra is a SET INPUT es SET OUTPUT eljarasokkal.
Az osszes olvasast, ami a text-le-okra vonatkozik, az atlapolt GET eljarassal
hajthatjuk vegre.
A GET eljaras a BOOLEAN, egesz, valos es felsorolasi tpusok eseteben is
ugyanugy m}ukodik: az aktualis sorpozciotol egy szintaktikus egyseget levalaszt es
bels}o formara konvertal, mikozben a bevezet}o szokozoket, tabulatorkaraktereket
es sorvegeket atlepi. Ha az adat formatuma nem felel meg a vart szintaxis-
nak, az DATA ERROR hibat, ha az ertek nem esik a vart ertekhatarok koze, az CONST-
RAINT ERROR hib at okoz.
Minden text-outputot az atlapolt PUT eljarassal lehet elvegezni. A text-le-ok
sormerete lehet rogztett, vagy valtozo. Ha rogztett sormeret mellett a kirando
string nem fer el az aktualis sorban, akkor a kovetkez}o sor els}o pozciojara kerul
(ha a string nem fer el egy sorban, az LAYOUT ERROR hibat okoz). Valtozo sorhossz
eseten a string kirasa folytatolagosan az aktualis sorba tortenik.
A valtozo sorhosszusagu le-okban az aktualis sor befejezesere a NEW LINE
eljaras szolgal. A NEW LINE(N) eljarashvas a standard le-ban befejezi az aktualis
sort, es meg N;1 db ures sort keszt.
Karakteres es string inputnal rogztett sorhossz eseten | a sor teljes beol-
vasasa utan | a GET eljaras automatikusan atlep a kovetkez}o sorra, valtozo sor-
hossz eseten erre kulon m}uvelet van, a SKIP LINE.
A SET COL eljaras az aktualis sorban valo pozicionalasra szolgal.
15.3.1. Karakteres es string I/O

with IO EXCEPTIONS
package TEXT IO is
...
;; Character Input-Output
procedure GET(FILE : in FILE TYPE ITEM : out CHARACTER)
procedure GET(ITEM : out CHARACTER)
procedure PUT(FILE : in FILE TYPE ITEM : in CHARACTER)
procedure PUT(ITEM : in CHARACTER)
;; String Input-Output
procedure GET(FILE : in FILE TYPE ITEM : out STRING)
procedure GET(ITEM : out STRING)
procedure PUT(FILE : in FILE TYPE ITEM : in STRING)
procedure PUT(ITEM : in STRING)
Input - output 111
procedure GET LINE(FILE : in FILE TYPE

ITEM : out STRING
LAST : out NATURAL)
procedure GET LINE(ITEM : out STRING LAST : out NATURAL)
procedure PUT LINE(FILE : in FILE TYPE ITEM : in STRING)
procedure PUT LINE(ITEM : in STRING)
...
end TEXT IO
A CHARACTER es STRING tpusu ertekek konvertalas nelkul kerulnek a le-ba.
Pl. PUT('B') vagy PUT("Ez egy string"). Pelda egy le karakterenkent valo
atmasolasara:
procedure COPY TEXT is
CH : CHARACTER
begin
while not END OF FILE loop
if END OF LINE then
SKIP LINE NEW LINE
else
GET(CH) PUT(CH)
end if
end loop
end COPY TEXT
A GET LINE fuggveny az aktualis sorpozciotol a sor vegeig tarto resz osszes ka-
rakteret megadja a stringvaltozoban, es ezutan atter az uj sorba. A PUT LINE(S)
eljarashvas hatasa megegyezik a kovetkez}o program hatasaval :
PUT(S) NEW LINE
15.3.2. Integer I/O

with IO EXCEPTIONS
package TEXT IO is
...
;; Generic package for Input-Output of Integer Types
generic
type NUM is range <>
package INTEGER IO is
DEFAULT WIDTH : FIELD := NUM'WIDTH
DEFAULT BASE : NUMBER BASE := 10
procedure GET(FILE : in FILE TYPE
ITEM : out NUM
WIDTH : in FIELD := 0)
procedure GET(ITEM : out NUM WIDTH : in FIELD := 0)
procedure PUT(FILE : in FILE TYPE
ITEM : in NUM
WIDTH : in FIELD := DEFAULT WIDTH
BASE : in NUMBER BASE := DEFAULT BASE)
112 Ada
procedure PUT(ITEM : in NUM

procedure GET(FROM : in STRING
ITEM : out NUM
LAST : out POSITIVE)
procedure PUT(TO : out STRING
ITEM : in NUM
end INTEGER IO
...
end TEXT IO
Egesz szamok kirasara az INTEGER IO generic package hasznalhato. Pa-
rametere a NUM tpus. Peldaul a
package INT IO is new TEXT IO.INTEGER IO(INTEGER)
peldanyostas utan a
PUT(128,6) PUT(;3,10) PUT(255,10,16)
program eredmenye a kovetkez}o:

t t t128t t t t t t t t ;3t t tt16#FF#
15.3.3. Float es xed I/O

with IO EXCEPTIONS
package TEXT IO is
...
;; Generic package for Input-Output of Real Types
generic
type NUM is digits <>
package FLOAT IO is
DEFAULT FORE : FIELD := 2
DEFAULT AFT : FIELD := NUM'DIGITS-1
DEFAULT EXP : FIELD := 3
ITEM : out NUM
ITEM : in NUM
FORE : in FIELD := DEFAULT FORE
AFT : in FIELD := DEFAULT AFT
EXP : in FIELD := DEFAULT EXP)
Input - output 113

ITEM : out NUM
ITEM : in NUM
EXP : in INTEGER := DEFAULT EXP)
end FLOAT IO
generic
type NUM is delta <>
package FIXED IO is
DEFAULT FORE : FIELD := NUM'FORE
DEFAULT AFT : FIELD := NUM'AFT
DEFAULT EXP : FIELD := 0
ITEM : out NUM
ITEM : in NUM
ITEM : out NUM
ITEM : in NUM
EXP : in INTEGER := DEFAULT EXP)
end FIXED IO
...
end TEXT IO
A valos szamok kirasara szolgalo eljarasok a FIXED IO es a FLOAT IO generic
package-kben talalhatok. Mindket generic parametere a NUM tpus.
Peldaul a
package REAL IO is new TEXT IO.FLOAT IO(REAL)
X : REAL := 0.003974
PUT(X) PUT(X,WIDTH => 15, MANTISSA => 4)
PUT(X,WIDTH => 8, MANTISSA => 2, EXPONENT => 1)
program eredmenye a kovetkez}o :

114 Ada
3.9740000E;3t t t t tt3.974E;03tt4.0E;3
Hasonloan a
type FIX is delta 0.05 range ;5 .. 5
package FI IO is new TEXT IO.FIXED IO(FIX)
X : FIX := 1.75
PUT(X) PUT(X,WIDTH => 10) PUT(X,FRACT => 4)
program eredmenye :
1.75t t t t tt1.751.7500
15.3.4. A felsorolasi tpusokra vonatkozo I/O

with IO EXCEPTIONS
package TEXT IO is
...
;; Generic package for Input-Output of Enumeration types
generic
type ENUM is (<>)
package ENUMERATION IO is
DEFAULT WIDTH : FIELD := 0
DEFAULT SETTING : TYPE SET := UPPER CASE
procedure GET(FILE : in FILE TYPE ITEM : out ENUM)
procedure GET(ITEM : out ENUM)
ITEM : in ENUM
SET : in TYPE SET := DEFAULT SETTING)
procedure PUT(ITEM : in ENUM
ITEM : out ENUM
ITEM : in ENUM
end ENUMERATION IO
...
end TEXT IO
A felsorolasi tpusok kirasa az ENUMERATION IO generic package eljarasaival
vegezhet}o el. Ennek parametere az ENUM tpus.
Input - output 115
i) A felsorolasi tpus input-outputja

Az alabbi program az TEXT IO package beagyazott package-inek interaktv
hasznalatat mutatja be.
procedure DIALOGUE is
type COLOR is (WHITE, RED, ORANGE, YELLOW,
GREEN, BLUE, BROWN)
package COLOR IO is new ENUMERATION IO(ENUM => COLOR)
package INT IO is new INTEGER IO(INTEGER)
use COLOR IO, INT IO
INVENTORY : array (COLOR) of INTEGER :=
(20, 17, 43, 10, 28, 173, 87)
CHOICE : COLOR
procedure ENTER COLOR(SELECTION: out
COLOR) is
begin
loop
begin
PUT("Color selected: ")
GET(SELECTION)
exit
exception
when DATA ERROR =>
PUT("Invalid color, try again. ")
NEW LINE(2)
end
end loop
end ENTER COLOR
begin ;; DIALOGUE
INT IO.DEFAULT WIDTH := 5
loop
ENTER COLOR(CHOICE)
SET COL(5) PUT(CHOICE) PUT(" items available:")
SET COL(40) PUT(INVENTORY(CHOICE))
NEW LINE
end loop

end DIALOGUE
116 Ada
16. Fuggelek
A) A STANDARD package
Az Adaban a STANDARD package denialja az osszes predenit tpust, objek-
tumot es alprogramot. A package torzse implementaciofugg}o.
Ez a package nem rhato le teljes egeszeben Ada nyelven: egyes imp-
lementaciofugg}o denciokat csak jelezni tudunk az alabbi kodban, a prede-
nit operatorokat pedig csak megjegyzesben adjuk meg, mert ezek bar logikai-
lag ebbe a package-be tartoznak, az Ada fordtoprogram kozvetlenul "ismeri" o}ket.
(Nehany helyen a hosszu felsorolast harom ponttal jeloltuk, de ez csak helyta-
karekossag miatt tortent.)
package STANDARD is
type BOOLEAN is (FALSE, TRUE)
;; The predefined relational operators for this type are
;; follows:
;; function "=" (LEFT, RIGHT : BOOLEAN) return BOOLEAN
;; function "/=" (LEFT, RIGHT : BOOLEAN) return BOOLEAN
;; function "<" (LEFT, RIGHT : BOOLEAN) return BOOLEAN
;; function "<=" (LEFT, RIGHT : BOOLEAN) return BOOLEAN
;; function ">" (LEFT, RIGHT : BOOLEAN) return BOOLEAN
;; function ">=" (LEFT, RIGHT : BOOLEAN) return BOOLEAN
;; The predefined logical operators and the predefined logical
;; negation operator are as follows:
;; function "and" (LEFT, RIGHT : BOOLEAN) return BOOLEAN
;; function "or" (LEFT, RIGHT : BOOLEAN) return BOOLEAN
;; function "xor" (LEFT, RIGHT : BOOLEAN) return BOOLEAN
;; function "not" (RIGHT : BOOLEAN) return BOOLEAN
;; The universal type universal integer is predefined
type INTEGER is implementation dened
;; The predefined operators for this type are follows:
;; function "=" (LEFT, RIGHT : INTEGER) return BOOLEAN
;; function "/=" (LEFT, RIGHT : INTEGER) return BOOLEAN
;; function "<" (LEFT, RIGHT : INTEGER) return BOOLEAN
;; function "<=" (LEFT, RIGHT : INTEGER) return BOOLEAN
;; function ">" (LEFT, RIGHT : INTEGER) return BOOLEAN
;; function ">=" (LEFT, RIGHT : INTEGER) return BOOLEAN
;; function "+" (RIGHT : INTEGER) return INTEGER
;; function "-" (RIGHT : INTEGER) return INTEGER
;; function "abs" (RIGHT : INTEGER) return INTEGER
;; function "+" (LEFT, RIGHT : INTEGER) return INTEGER
;; function "-" (LEFT, RIGHT : INTEGER) return INTEGER
;; function "*" (LEFT, RIGHT : INTEGER) return INTEGER
Fuggelek 117
;; function "/" (LEFT, RIGHT : INTEGER) return INTEGER

;; function "rem" (LEFT, RIGHT : INTEGER) return INTEGER
;; function "mod" (LEFT, RIGHT : INTEGER) return INTEGER
;; function "**" (LEFT : INTEGER RIGHT : INTEGER) return INTEGER
;; An implementation may provide additional predefined integer
;; types. It is recommended that the names of such additional
;; types end with INTEGER as in SHORT INTEGER or LONG INTEGER.
;; The specification of each operator for the type
;; universal integer, or for any additional predefined
;; integer type, is obtaoned by replacing INTEGER by the name of
;; the type in the specification of the corresponding operator
;; of the type INTEGER, except for the roght operand of the
;; exponentiating operator.
;; The universal type universal real is predefined.
type FLOAT is implementation dened
;; The predefined operators for this type are as follows:
;; function "=" (LEFT, RIGHT : FLOAT) return BOOLEAN
;; function "/=" (LEFT, RIGHT : FLOAT) return BOOLEAN
;; function "<" (LEFT, RIGHT : FLOAT) return BOOLEAN
;; function "<=" (LEFT, RIGHT : FLOAT) return BOOLEAN
;; function ">" (LEFT, RIGHT : FLOAT) return BOOLEAN
;; function ">=" (LEFT, RIGHT : FLOAT) return BOOLEAN
;; function "+" (RIGHT : FLOAT) return FLOAT
;; function "-" (RIGHT : FLOAT) return FLOAT
;; function "abs" (RIGHT : FLOAT) return FLOAT
;; function "+" (LEFT, RIGHT : FLOAT) return FLOAT
;; function "-" (LEFT, RIGHT : FLOAT) return FLOAT
;; function "*" (LEFT, RIGHT : FLOAT) return FLOAT
;; function "/" (LEFT, RIGHT : FLOAT) return FLOAT
;; function "**" (LEFT : FLOAT RIGHT : INTEGER) return FLOAT
;; An implementation may provide additional predefined floating
;; point types. It is recommended that the names of such
;; additional types end with FLOAT as in SHORT FLOAT or
;; LONG FLOAT. The specification of each operator for the type
;; universal real, or for any additional predefined
;; floating point type, is obtaoned by replacing FLOAT by the
;; name of the type in the specification of the corresponding
;; operator of the type FLOAT
;; In addition, the following operators are predefined for
;; universal types:
;; function "*" (LEFT : universal integer RIGHT : universal real)
;; return universal real
;; function "*" (LEFT : universal real RIGHT : universal integer)
;; function "/" (LEFT : universal real RIGHT : universal integer)
;; The type universal xed is predefined. The only operators
;; declared for this type are
;; function "*" (LEFT : any xed point type
;; RIGHT : any xed point type)
;; return universal xed
118 Ada
;; function "/" (LEFT : any xed point type

;; RIGHT : any xed point type)
;; return universal xed
;; The following characters from the standard ASCII character
;; set. Character literals corresponding to control characters
;; are not identifiers they are indicated in italics in this
;; definition.
type CHARACTER is
(nul, soh, stx, etx, eot, enq, ack, bel,
bs, ht, lf, vt, , cr, so, si,
dle, dc1, dc2, dc3, dc4, nak, syn, etb,
cna, em, sub, esc, fs, gs, rs, us,
' ', '!', '"', '#', '$', '%', '&', ''',
'(', ')', '*', '+', ',', ';', '.', '/',
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', ':', '', < >
' ', '=', ' ', '?',
'@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',

'X', 'Y', 'Z', ' ', ] b
'n', ' ', '', ' ',
#
'', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
'x', 'y', 'z', 'f', e
'j', 'g', '', del )
for CHARACTER use ;; 128 ASCII character set without holes
(0, 1, 2, 3, ..., 125, 126, 127)
;; The predefined operators for the type CHARACTER are the same
;; as for any enumeration type.
package ASCII is
;; Control characters
NUL : constant CHARACTER := nul
SOH : constant CHARACTER := soh
STX : constant CHARACTER := stx
ETX : constant CHARACTER := etx
EOT : constant CHARACTER := eot
ENQ : constant CHARACTER := enq
ACK : constant CHARACTER := ack
BEL : constant CHARACTER := bel
BS : constant CHARACTER := bs
HT : constant CHARACTER := ht
LF : constant CHARACTER := lf
VT : constant CHARACTER := vt
FF : constant CHARACTER :=
CR : constant CHARACTER := cr
SO : constant CHARACTER := so
SI : constant CHARACTER := si
DLE : constant CHARACTER := dle
DC1 : constant CHARACTER := dc1
NAK : constant CHARACTER := nak
SYN : constant CHARACTER := syn
Fuggelek 119
ETB : constant CHARACTER := etb

CNA : constant CHARACTER := cna
EM : constant CHARACTER := em
SUB : constant CHARACTER := sub
ESC : constant CHARACTER := esc
FS : constant CHARACTER := fs
GS : constant CHARACTER := gs
RS : constant CHARACTER := rs
US : constant CHARACTER := us
;; Other characters
EXCLAM : constant CHARACTER := '!'
QUOTATION : constant CHARACTER := '"'
SHARP : constant CHARACTER := '#'
DOLLAR : constant CHARACTER := '$'
PERCENT : constant CHARACTER := '%'
AMPERSAND : constant CHARACTER := '&'
COLON : constant CHARACTER := ':'
SEMICOLON : constant CHARACTER := ''
QUERY : constant CHARACTER := '?'
AT SIGN : constant CHARACTER := '@'
L BRACKET : constant CHARACTER := ''
BACK SLASH : constant CHARACTER := 'n'
R BRACKET : constant CHARACTER := ']'
CIRCUMFLEX : constant CHARACTER := 'b'
UNDERLINE : constant CHARACTER := ' '
GRAVE : constant CHARACTER := '#'
L BRACE : constant CHARACTER := 'f'
BAR : constant CHARACTER := 'j'
R BRACE : constant CHARACTER := 'g'
TILDE : constant CHARACTER := 'e'
;; Lower case letters
LC A : constant CHARACTER := 'a'
...
LC Z : constant CHARACTER := 'z'
end ASCII
;; Predefined subtypes
subtype NATURAL is INTEGER range 0 .. INTEGER'LAST
subtype POSITIVE is INTEGER range 1 .. INTEGER'LAST
;; Predefined string type
type STRING is array ( POSITIVE range <> ) of CHARACTER
pragma PACK(STRING)
;; The predefined operators for this types are as follows:
;; function "=" (LEFT, RIGHT : STRING) return BOOLEAN
;; function "/=" (LEFT, RIGHT : STRING) return BOOLEAN
;; function "<" (LEFT, RIGHT : STRING) return BOOLEAN
;; function "<=" (LEFT, RIGHT : STRING) return BOOLEAN
;; function ">" (LEFT, RIGHT : STRING) return BOOLEAN
;; function ">=" (LEFT, RIGHT : STRING) return BOOLEAN
;; function "&" (LEFT : STRING RIGHT : STRING)
;; return STRING
;; function "&" (LEFT : CHARACTER RIGHT : STRING)
;; return STRING
120 Ada
;; function "&" (LEFT : STRING RIGHT : CHARACTER)

;; return STRING
;; function "&" (LEFT : CHARACTER RIGHT : CHARACTER)
;; return STRING
;; type DURATION is delta implementation dened
;; range implementation dened
;; The predefined operators for the type DURATION are the same
;; as for any fixed point type.
;; The predefined exceptions:
CONSTRAINT ERROR : exception
NUMERIC ERROR : exception
PROGRAM ERROR : exception
STORAGE ERROR : exception
TASKING ERROR : exception
end STANDARD
Fuggelek 121
B) Az Ada fogalmainak osszefoglalasa

Accept utastas (Accept statement). Ld. entry.
Access ertek (Access value). Ld. access tpus.
Access tpus (Access type). Egy access tpus erteke | azaz egy access ertek |
a null ertek, es azok az objektumot kijelol}o ertekek, amiket allokatorral hoztunk
letre. Az ilyen objektum ertekere hivatkozni, ill. az objektum erteket modostani
az access erteken keresztul lehet. Egy access tpus dencioja specikalja azoknak
az objektumoknak a tpusat, amelyek az access tpus ertekeivel kijelolhet}ok. Ld.
meg kollekcio.
Aktualis parameter (Actual parameter). Ld. parameter.
Aggregatum (Aggregate). Egy aggregatum kiertekelesenek eredmenye egy
osszetett tpusu ertek. Az osszetett erteket a komponensek ertekei hatarozzak meg.
A komponensek megadasanal a pozicionalis megfeleltetes, vagy a nevvel jelolt meg-
feleltetes hasznalhato.
Alegyseg (Subunit). Ld. torzs.
Alegyseg szul}oje (Parent unit). Egy alegyseg szul}ojenek nevezzuk azt fordtasi
egyseget (torzset vagy alegyseget), amelyben az alegysegre vonatkozo csonk van.
Allokator (Allocator). Egy allokator kiertekelese letrehoz egy objektumot, s egy
uj access erteket, ami kijeloli ezt az objektumot.
Alprogram (Subprogram). Az eljarast es a fuggvenyt egyuttveve alprog-
ramnak mondjuk. Az eljaras tevekenysegek egy sorozatat rja el}o, aminek
vegrehajtasat egy eljarashvassal kezdemenyezhetjuk. A fuggveny szinten speci-
kalja tevekenysegek egy sorozatat, valamint specikal egy visszateresi erteket, a
fuggveny eredmenyet. A fuggvenyhvas egy kifejezes. Az alprogramot alprogram-
specikacio es alprogramtorzs formajaban adjuk meg. Az alprogramspecikacioban
rogztjuk a nevet, a formalis parametereit, es (fuggveny eseten) az eredmenyet.
Az alprogramtorzs tartalmazza a tevekenysegek felsorolasat. Az alprogram-
hvas aktualis parametereket tartalmaz, amiket a hvas megfeleltet a formalis pa-
rametereknek. Az alprogram a programegysegek egy fajtaja.
Alprogramspeci kacio (Subprogram specication). Ld. alprogram.
Alprogramtorzs (Subprogram body). Ld. alprogram.
Altpus (Subtype). Egy tpus altpusa a tpusertekhalmaz egy reszhalmazaval jel-
lemezhet}o. A reszhalmazt a tpusra (bazistpusra) megadott megszortassal
122 Ada
hatarozhatjuk meg. A reszhalmazban lev}o ertekekre azt mondjuk, hogy az

altpushoz tartoznak, es eleget tesznek a megszortasnak. Az altpus m}uveletei
ugyanazok, mint a bazistpus m}uveletei.
Attributum (Attribute). Egy attributum kiertekelesenek eredmenye valamely
egyed (pl. tpus, objektum, task) predenit jellemz}oje. Az attributumok altalaban
fuggvenyek.
A tlapolas (Overloading). A programszoveg egy pontjan egy azonostonak tobb je-
lentese is lehet: ezt a tulajdonsagot nevezzuk atlapolhatosagnak. Peldaul:
atlapolt felsorolasi tpusu literal lehet egy olyan azonosto, ami tobb felso-
rolasi tpus denciojaban is szerepel. Egy atlapolt azonosto valodi jelenteset min-
dig a szovegkornyezet hatarozza meg. Az alprogramok, az aggregatumok, az al-
lokatorok es a string literalok szinten atlapolhatok.
A tnevezes (Renaming declaration). Az atnevezes ujabb nevvel lat el egy mar
letez}o egyedet.
Bazistpus (Base type). Azt a tpust, amelynek megszortasaval az altpust
el}oalltottuk, az altpus bazistpusanak nevezzuk. A megszortatlan tpus
bazistpusa onmaga.
Blokk utastas (Block statement). A blokk utastas egy egyszer}u utastas, ami
tartalmazhat egy utastas-sorozatot. Szinten tartalmazhat deklaracios reszt es
kivetelkezel}ot, amelyeknek hatasa csak a blokk utastasaira terjed ki.
Csonk (Stub). Egy beagyazott programegyseg torzset levalaszthatjuk a tartal-
mazo fordtasi egysegr}ol, s bel}ole alegyseget kepezhetunk. Az alegyseg torzsenek
helyen marado reszt (separate) csonknak nevezzuk.
Deklaracio (Declaration). A deklaracio osszekapcsol egy azonostot (vagy mas
elnevezesre alkalmas jelolest) egy egyeddel. Ez az osszekapcsolas a programszoveg
egy szakaszan, a deklaracio hataskoren belul ervenyes. A deklaracio hataskoren
belul hasznalhato az azonosto az egyedre valo hivatkozasra, masszoval, a nev a
hozzakapcsolt egyedet jeloli.
Deklaracios resz (Declarative part). A deklaracios resz deklaraciok sorozatabol
all. Tartalmazhat ezen felul alprogramtorzseket es reprezentacios el}orasokat is.
Diszkret tpus (Discrete Type). A diszkret tpus egy olyan tpus, aminek
ertekkeszlete meghatarozott (skalar) ertekek rendezett halmaza. Diszkret tpusok
a felsorolasi tpusok es az egesz tpusok. Diszkret tpusu ertekek hasznalhatok in-
dexelesre, iteracios ciklus megszervezesere, az esetek lerasara a case utastasban,
es varians resz kepzesere a rekord tpuson belul.
Diszkriminans (Discriminant). A diszkriminans egy kituntetett komponense a
rekord tpusu objektumoknak es ertekeknek. A tobbi komponens altpusa, s}ot je-
lenlete fugghet a diszkriminans erteket}ol.
Fuggelek 123
Diszkriminans megszortasa (Discriminant constraint). Egy rekord tpus vagy

egy privat tpus diszkriminansanak megszortasa a tpus mindegyik diszkriminan-
sanak erteket rogzti.
Egesz tpus (Integer type). Egy egesz tpus olyan diszkret tpus, amely-
nek ertekkeszletet egy meghatarozott intervallumba es}o egesz szamok halmaza rep-
rezentalja.
Egyszer}u nev (Simple name). Ld. deklaracio, nev.
Elaboracio (Elaboration). Egy deklaracio elaboracioja az a folyamat, amely-
nek soran a deklaracio kifejti hatasat (azaz letrehozza az objektumot, hozzarendeli
a nevet, a kezd}oerteket stb.). Az elaboracio a program futasa soran zajlik le.
Eleget tesz a megszortasnak (Satisfy). Ld. megszortas, altpus.
Eljaras (Procedure). Ld. alprogram.
Eljarashvas (Procedure call). Ld. alprogram.
Entry. A entry-ket a taskok kozotti kommunikacioban hasznaljuk. Az entry
hvasa a eljarashvashoz hasonloan tortenik. Az entry "bels}o tulajdonsagait" egy
vagy tobb accept utastassal denialjuk, amelyek lerjak azt a tevekenysegsorozatot,
amit az entry meghvasa eseten el kell vegezni.
Eltakaras (Hidden). Egy deklaracios reszen belul elhelyezkedhet egy masik dek-
laracios resz is. Ha ekkor a bels}o deklaracios reszben el}ofordul a kuls}o deklaracios
reszben lev}o deklaracio egy homografja, akkor azt mondjuk, hogy a bels}o dek-
laracios reszben a deklaracio eltakarja a kuls}o deklaraciot.
E rtekadas (Assignment). Az ertekadas egy olyan m}uvelet, ami kicsereli egy
valtozo erteket egy uj ertekre. Az ertekado utastas a baloldallal specikalja a
valtozot, s a jobboldallal annak uj erteket.
Felsorolasi tpus (Enumeration type). Egy felsorolasi tpus olyan diszk-
ret tpus, amelynek ertekkeszletet a tpus denciojaban megadott literalokkal rep-
rezentaljuk. A felsorolasi tpusu literalkent azonostokat es karakteres literalok
hasznalhatunk.
Fixpontos tpus (Fixed point type). Ld. valos tpus.
Fordtasi egyseg (Compilation unit). Fordtasi egyseg lehet egy programegyseg
specikacioja vagy torzse, amit onallo szovegkent fordtunk le, vagy egy alegyseg.
A fordtasi egyseget megel}ozheti egy kornyezeti el}oras, ami megnevezi azokat a
fordtasi egysegeket, amikt}ol a fordtasi egyseg fugg.
Formalis parameter (Formal parameter). Ld. parameter.
124 Ada
Fuggveny (Function). Ld. alprogram.

Fuggveny eredmenye (Function result). Ld. alprogram.
Fuggvenyhvas (Function call). Ld. alprogram.
Generic. A generic alprogramok vagy package-k el}oalltasara szolgalo minta.
A minta segtsegevel el}oalltott alprogramot vagy package-t a generic egy
peldanyanak hvjuk. A peldanyostas a deklaraciok egy fajtaja, amivel el}oallthato
egy peldany. A generic formailag egy alprogram vagy egy package, amelynek a spe-
cikacios reszet megel}ozi a generic formalis parametereinek felsorolasa. A gene-
ric formalis parametere lehet tpus, alprogram vagy objektum. A generic a progra-
megysegek egy fajtaja.
Hataskor (Scope). Ld. deklaracio.
Homograf deklaracio (Homograph declaration). Ket deklaracio egymas ho-
mografja, ha ugyanazt az azonostot, operatort vagy karakter literalt dek-
laraljak, es | ha egyaltalan van, akkor | megegyezik a parametereik es az
eredmenyuk prole-ja is.
Index. Ld. tomb tpus.
Indexelt komponens (Indexed component). Az indexelt komponens egy tomb
egy elemet jeloli meg. Ez a nev egy formaja, amely olyan kifejezeseket tartalmaz,
amelyek meghatarozzak az indexek erteket. Indexelt komponens jelolhet egy entry-
t az entry-k csaladjaban.
Indexmegszortas (Index constraint). Egy tomb tpus indexmegszortasa a tpus
mindegyik indexenek denialja az also es a fels}o hatarat.
Intervallum (Range). Egy skalar tpus ertekkeszletenek egy osszefgg}o hal-
mazat intervallumnak hvjuk. Az intervallumot az ertekek also es fels}o hataranak
megadasaval specikaljuk.
Intervallum megszortasa (Range constraint). Egy skalar tpus megszortasa
az ertekkeszletnek egy reszintervallumra valo lesz}ukteset jelenti.
Jelol (Denote). Ld. deklaracio.
Kiertekeles (Evaluation). Egy kifejezes kiertekelese az a folyamat, amelynek
soran kiszamtasra kerul a kifejezes erteke. Ez a folyamat a program futasa soran
zajlik le.
Kifejezes (Expression). A kifejezes egy ertek kiszamtasanak modjat denialja.
Kijeloles (Designate). Ld. access tpus, task.
Fuggelek 125
Kiterjesztett nev (Expanded name). A kiterjesztett nev egy olyan egyedet jelol,
amit kozvetlenul egy konstrukcio belsejeben deklaraltunk. A kiterjesztett nevet
szelekcios formabanrjuk: a prex jeloli a konstrukciot (ez lehet pl. programegyseg,
blokk utastas, ciklus vagy accept utastas), az utotag (a szelektor) pedig az egyed
egyszer}u neve.
Kivetel (Exception). A kivetel egy olyan esemeny, ami a program vegrehajtasa
soran lephet fel. A kivetel kivaltasa (fellepese) megszaktja a program
vegrehajtasat. A kivetelkezel}o a programszovegnek az a resze, ami speci-
kalja a kivetel fellepesekor elvegzendo tevekenyseget. Egy kivetel fellepese utan
kivalasztasra kerul a hozza tartozo kivetelkezel}o, majd ennek vegrehajtasa utan a
program vegrehajtasa normal modon folytatodik.
Kivetel kivaltasa (Raising an exception). Ld. kivetel.
Kivetelkezel}o (Exception handler). Ld. kivetel.
Kollekcio (Collection). A kollekcio azoknak az objektumoknak a halmaza, amik
ugyanarra az access tpusra vonatkozo allokatorok kiertekelese eredmenyekeppen
alltak el}o.
Komponens (Component). A komponens egy olyan ertek, ami egy osszetett
ertek resze, vagy olyan objektum, ami egy osszetett objektumnak a resze.
Konstans (Constant). Ld. objektum.
Kornyezeti el}oras (Context clause). Ld. fordtasi egyseg.
Kozvetlen lathatosag (Direct visibility). Ld. lathatosag.
Lathato resz (Visible part). Ld. package.
Lathatosag (Visibility). A programszoveg egy adott pontjan egy deklaracio
(tehat egy egyed es egy azonosto osszekapcsolasa) lathato, ha az azonostonak
az illet}o egyed az egyik lehetseges jelentese.
Lebeg}opontos tpus (Floating point type). Ld. valos tpus.
Lexikalis elem (Lexical element). Lexikalis elemek az azonostok, a literalok, az
elhatarolo jelek es a megjegyzesek.
Limited tpus (Limited type). A limited tpus egy olyan tpus, aminek semmilyen
predenit m}uvelete nincs (tehat sem az ertekadas, sem az implicit "=" m}uvelet
nem megengedett). A task tpus limited tpus, ezen kvul egy privat tpust is
limited tpusnak denialhatunk. A limited tpushoz explicit modon denialhato
az "=" m}uvelet.
Literal (Literal). A literalokat tpusertekek reprezentalasara hasznaljuk. Vannak
126 Ada
numerikus, felsorolasi tpusu, karakteres es string literalok.

Megszortas (Constraint). Egy megszortas egy tpus ertekeinek reszhalmazat
denialja. Azt mondjuk, hogy ennek a reszhalmaznak egy eleme eleget tesz a
megszortasnak.
Min}ostett kifejezes (Qualied expression). A min}ostett kifejezes egy olyan ki-
fejezes, ami tartalmazza a tpusanak vagy altpusanak a megjeloleset is. A
min}ostest akkor hasznaljuk, ha a kifejezes tobbertelm}u, a tpusa nem allapthato
meg egyertelm}uen (pl. egy atlapolas kovetkezteben).
Modellszam (Model number). A modellszamoknak nevezzuk a valos tpusok
pontosan abrazolhato ertekeit. A valos tpusok m}uveleteit (pl. a kerektest) a tpus
modellszamainak segtsegevel denialjuk. A modellszamok es azok m}uveleteinek
tulajdonsagai adjak meg a valos tpusokra azt a minimalis el}orast, amit a nyelv
minden implementaciojanak meg kell valostania.
Mod (Mode). Ld. parameter.
M}uvelet (Operation). Egy tpus m}uveletei a tpusertekeken vegrehajthato ele-
mi tevekenysegek. A m}uveletek lehetnek a tpus dencioja altal implicit modon
meghatarozottak, de megadhatok mint alprogramok is, amelyek parametere vagy
a fuggveny eredmenye az adott tpus egy erteke.
Nevvel jelolt megfeleltetes (Named association). A nevvel jelolt megfeleltetes
egy erteknek egy lista egy vagy tobb pozciojahoz valo hozzarendeleset e pozciok
megnevezesevel adja meg.
Nev (Name). A nev az egyedek kezelesere letrehozott konstrukcio. Azt mondjuk,
hogy egy nev egy egyedet jelol, ill. egy egyed a nev jelentese. Ld. meg deklaracio,
prex.
Objektum (Object). Az objektumok ertekkel rendelkeznek. A program
vagy egy objektum deklaraciojanak elaboracioja, vagy egy allokator kiertekelese
eredmenyekeppen hoz letre uj objektumot. A deklaracio vagy az allokator meg-
hatarozza az objektum tpusat is: az objektum csak ilyen tpusu ertekeket ve-
het fel.
Operator (Operator). Az operator egy muvelet, aminek egy vagy ket operan-
dusa lehet. Az unaris operatort az operandus ele, a binaris operatort a ket operan-
dus koze rjuk. Ez a jeloles a fuggvenyhvas egy specialis formaja. Egy operator je-
lenteset fuggveny formajaban denialhatjuk. A tpusokhoz altalaban leteznek imp-
licit modon denialt operatorok is (pl. "=", "<" stb.).
O sszetett tpus (Compound type). Az O sszetett tpus ertekei komponensekb}ol

allnak. Osszetett tpusok a tomb tpus es a rekord tpus.
O} segyseg (Ancestor). Egy alegyseg szul}oi lancan visszafele haladva egy valodi
Fuggelek 127
torzshoz jutunk, amelynek mar nincs szul}oje. Ezt a fordtasi egyseget az alegyseg
}osegysegenek nevezzuk.
O} stpus (Parent type). Ld. szarmaztatott tpus.
Package. A package logikailag osszetartozo egyedek, tpusok, objektumok, es
alprogramok gy}ujtemenye. A package-t package specikacio es package torzs
formajaban adjuk meg. A packade specikaciojanak van egy lathato resze,
ami azoknak az egyedeknek a deklaracioit tartalmazza, amelyek a package-n
kvul is lathatoak. Emellett tartalmazhat egy privat reszt is, amelynek a dek-
laracioi kiegesztik, teljesse teszik a lathato reszben lev}o denciokat, a package-
n kvul azonban nem lathatoak. A package torzse tartalmazza a package speci-
kacios reszeben felsorolt alprogramok torzseit. A package a programegysegek egy
fajtaja.
Package spaci kacio (Package specication). Ld. package.
Package torzs (Package body). Ld. package.
Parameter (Parameter). Az alprogram, az entry es a generic parametere egy
nevvel rendelkez}o egyed, amit a hozza tartozo alprogramtorzzsel, accept utastassal
ill. generic torzzsel valo kommunikalasra hasznalunk. A formalis parameter egy
azonosto, ami a torzsben az egyedre valo hivatkozasra szolgal. Az aktualis pa-
rametert a alprogramhvas, az entry hvas ill. a peldanyostas koti ossze a meg-
felel}o formalis parameterrel. A formalis parameter modja hatarozza meg, hogy a
megfelel}o aktualis parameter adja at az erteket a formalis parameternek, vagy
a formalis parameter adja at az erteket az aktualis parameternek, vagy pe-
dig mindkett}o megtortenik. Az aktualis parameterek es formalis parameterek
egymashoz rendelese tortenhet nevvel jelolt megfeleltetes, vagy pozicionalis megfe-
leltetes utjan.
Peldanyostas (Instantiation). Ld. generic.
Pozicionalis megfeleltetes (Positional assotiation). A pozicionalis megfeleltetes
egy erteknek egy lista egy pozciojahoz valo hozzarendeleset rja le ugy, hogy az
erteket annyiadikkent sorolja fel, ahanyadik pozcioban a listaban szerepelnie kell.
Pragma. A pragma a fordtoprogramnak szolo el}orasokat foglal magaba.
Pre x. A prex a nevek egyes formaiban a konstrukcio els}o tagjakent allhat.
Prex lehet a fuggvenhvas es a nev.
Privat resz (Private part). Ld. package.
Privat tpus (Private type). A privat tpus egy olyan tpus, amelynek a feleptese
es az ertekhalmaza pontosan denialt, de a tpust hasznalok szamara kozvetlenul
nem hozzaferhet}o. A privat tpust az azt hasznalo csak a diszkriminansain (ha van-
nak) es a m}uveletein keresztul ismerheti. A privat tpus es annak m}uveletei
128 Ada
egy package lathato reszeben, vagy egy generic formalis parameterei kozott de-
nialhatok. Az ertekadas, az "=" es a "/=" m}uveletek a privat tpusra impli-
cit modon denialtak, kiveve, ha a tpus limited tpus.
Pro le. Ket formalis parameter resz prole-ja pontosan akkor egyezik meg, ha
ugyanannyi parametert tartalmaznak, s a parameterek bazistpusa rendre mege-
gyezik. Ket fuggveny eredmenyenek prole-ja pontosan akkor egyezik meg, ha az
eredmenyek bazistpusa megegyezik.
Program. A program valahany fordtasi egysegb}ol allthato ossze, amelyek kozott
az egyik alprogram szerepe kituntetett, ez a f}oprogram. A program vegrehajtasa
a f}oprogram vegrehajtasat jelenti, ami meghvhat olyan alprogramokat, amelyek
a program mas fordtasi egysegeiben helyezkednek el.
Programegyseg (Program unit). A programegysegnek negy fajtaja van: a gene-
ric, a package, az alprogram es a task.
Randevu (Randezvous). A randevu ket task kozotti bizonyos fajta
egyuttm}ukodes: az egyik task hvja a masik egy entry pontjat, s a fogado task
vegrehajtja a megfelel}o accept utastast.
Reprezentacios el}oras (Representation clause). A reprezentacios el}oras meg-
hatarozza a fordtoprogram szamara egy tpus, objektum vagy task egyes tulaj-
donsagainak lekepezeset a targygep szolgaltatasaira. Egyes esetekben teljesen spe-
cikalja a lekepezest, maskor felteteleket denial a lekepezes megvalasztasahoz.
Rekord tpus (Record type). Egy rekord tpusu ertek komponensekb}ol all, ame-
lyek altalaba kulonboz}o tpusuak ill. altpusuak. A rekord tpus mindegyik kompo-
nenshez hozzarendel egy azonostot, amellyel egyertelm}uen kivalaszthato az ertek
vagy az objektum komponense.
Resztomb (Slice). Resztombnek nevezunk egy egydimenzios tomb tpusu
ertek vagy objektum indexeinek egy intervallumaval meghatarozott egydimenzios
tombot.
Statikus kifejezes (Static expression). Statikusnak nevezzuk azokat a kife-
jezeseket, amelyek erteke fordtasi id}oben kiszamthato.
Skalar tpus (Scalar type). A skalar tpusu ertekeknek es objektumoknak nincse-
nek komponensei. Skalar tpusok a diszkret tpusok es a valos tpusok. A skalar
tpus ertekhalmaza rendezett halmaz.
Szarmaztatott tpus (Derived Type). A szarmaztatott tpus egy olyan tpus,
amelynek ertekei es m}uveletei egy mar letez}o tpus masolatai. Ezt a mar letez}o
tpust a szarmaztatott tpus }ostpusanak nevezzuk.
Szelekcios jeloles (Selected komponent). A szelekcios jeloles egy nev, ami tar-
talmaz egy prexet, s egy szelektornak nevezett azonostot. Szelekcios jelolest
Fuggelek 129
hasznalunk a rekord komponenseinek, az entry-knek, es az access ertekkel

elerhet}o objektumoknak a jelolesere. A szelekcios jelolest hasznaljuk a kiterjesz-
tett nevek lerasahoz is.
Szelektor (Selector). Ld. szelekcios jeloles.
Task. A task a program tobbi reszevel parhuzamosan hajtodik vegre. A taskot
task specikacio (ami specikalja a task nevet, s az entry-k formalis parametereit),
es task torzs (ami denialja a task hatasat) formajaban adjuk meg. A task egy
fajtaja a programegysegeknek. A task tpus egy tpus, ami lehet}ove teszi tobb
hasonlo task egyszer}u deklaralasat. A task tpus egy erteke kijelol egy taskot.
Task speci kacio (Task specication). Ld. task.
Task tpus (Task type). Ld. task.
Task torzs (Task body). Ld. task.
Tpus (Type). Egy tpus az ertekhalmazaval, s az ezen ertekekre alkalmazhato
m}uveletekkel jellemezhet}o. Az access tpus, a tomb tpus, a rekord tpus, a skalar
tpus, es a task tpus mind a t pusok egy-egy osztalyat jelentik.
Tomb tpus (Array type). Egy tomb tpusu ertek olyan komponensekb}ol
all, emelyek ugyanabba az altpusba (tpusba) tartoznak. Mindegyik kompo-
nens egyertelm}uen meghatarozhato az indexe (egydimenzios tomb eseten), vagy
az indexeinek egy sorozata (tobbdimenzios tomb eseten) segtsegevel. Minde-
gyik indexnek valamely diszkret tpushoz kell tartoznia, s a megengedett inter-
vallumba kell esnie.
Torzs (Body). A torzs denialja egy alprogram, package vagy egy task hatasat.
A csonk a torzs egy sajatos formaja, ami azt jelzi, hogy a torzset egy onalloan
fordthato alegysegben adjuk meg.
Use utastas (Use clause). A use utastas egy package lathato reszeben lev}o
deklaraciokat kozvetlenul lathatova tesz.
Utastas (Statement). Egy utastas egy vagy tobb olyan tevekenyseget denial,
amik a program futasa soran hajtodnak vegre.
Valos tpus (Real type). A valos tpus egy tpus, amelynek ertekei a valos
szamok kozeltesei. A valos tpusoknak ket fajtaja van: A xpontos tpusokat
a kozeltes megengedett abszolut hibajaval, a lebeg}opontos tpusokat a kozeltes re-
latv hibajaval (az abrazolashoz felhasznalhato decimalis jegyek rogztesevel) de-
nialjuk.
Varians resz (Variant part). A rekord tpus varians resze a diszkriminanstol
fugg}oen denialja a rekord komponenseit. A diszkriminans minden egyes ertekehez
hozzatartozik a komponensek egy pontosan denialt halmaza.
130 Ada
Valtozo (Variable). Ld. objektum.

Vegrehajtas (Execution). Azt a folyamatot, amelynek soran egy utastas kifejti
a hatasat, az utastas vegrehajtasanak mondjuk.
With utastas (With clause). Ld. fordtasi egyseg.
Fuggelek 131
C) Az Ada szintaktikus szabalyai nevsorba szedve

<abort statement> ::= abort <task name> f , <task name>g
<accept alternative> ::= <accept statement> <sequence of statements> ]
<accept statement> ::= accept <entry simple name> ( <entry index> ) ]
<formal part> ]
do <sequence of statements>
end <entry simple name> ] ]
<access type denition> ::= access <subtype indication>
<actual parameter part> ::= ( <parameter association>
f , <parameter association>g )
<actual parameter> ::= <expression>j<variable name>
j<type mark> ( <variable name> )
<address clause> ::= for <simple name> use at <simple expression>
<aggregate> ::= ( <component association> f , <component association>g )
<alignment clause> ::= at mod <static simple expression>
<allocator> ::= new <subtype indication>j new <qualied expression>
<argument association> ::= <argument identier> => <name>
j <argument identier> => ] <expression>
<array type denition> ::= <unconstrained array denition>
j<constrained array denition>
<assignment statement> ::= <variable name> := <expression>
<attribute designator> ::= <simple name>
( <universal static expression> ) ]
<attribute> ::= <prex> ' <attribute designator>
<basic declaration> ::= <object declaration>j<number declaration>
j<type declaration>j<subtype declaration>j<subprogram declaration>
j<exception declaration>j<generic instantiation>j<renaming declaration>
j<deferred constant declaration>
<basic declarative item> ::= <basic declaration>j<represetation clause>
j<use clause>
<basic graphic character> ::= <upper case letter>
j<digit>j<special character>j<space character>
<binary adding operator> ::= + j ; j &
<block statement> ::= <block simple name> : ]
<declare declarative part> ]
exception <exception handler f<exception handler>g
end <block simple name> ]
<body stub> ::= <subprogram specication> is separate
j package body <package simple name> is separate
j task body <task simple name> is separate
<body> ::= <proper body>j<body stub>
132 Ada
<case statement alternative> ::= when <choice> f j <choice>g =>

<case statement> ::= case <expression> is
<case statement alternative> f<case statement alternative>g
end case
<character literal> ::= ' <graphic character> '
<choice> ::= <simple expression>j<discrete range>j others
j<component simple name>
<compilation unit> ::= <context clause><library unit>
j<context clause><secondary unit>
<compilation> ::= f<compilation unit>g
<component association> ::= <choice> f j <choice>g => ] <expression>
<component clause> ::= <component name> at <static simple expression>
range <static range>
<component declaration> ::= <identier list> :
<component subtype denition> := <expression> ]
<component list> ::= <component declaration> f<component declaration>g
j f<component declaration>g <variant part>j null
<component subtype denition> ::= <subtype indication>
<compound statement> ::= <if statement>j<case statement>
j<loop statement>j<block statement>j<accept statement>
j<select statement>
<condition> ::= <boolean expression>
<conditional entry call> ::= select <entry call statement>
else <sequence of statements>
end select
<constrained array denition> ::= array <index constraint> of
<component subtype indication>
<constraint> ::= <range constraint>j<oating point constraint>
j<xed point constraint>j<index constraint>j<discriminant constraint>
<context clause> ::= f<with clause> f<use clause>gg
<declarative part> ::= f<basic declarative item>gf<later declarative item>g
<deferred constant declaration> ::= <identier list> :
constant <type mark>
<delay alternative> ::= <delay statement> <sequence of statements> ]
<delay statement> ::= delay <simple expression>
<derived type denition> ::= new <subtype indication>
<designator> ::= <identier>j<operator symbol>
<discrete range> ::= <discrete subtype indication>j<range>
<discriminant association> ::= <discriminant simple name>
f j <discriminant simple name>g => ] <expression>
<discriminant constraint> ::= ( <discriminant association>
f , <discriminant association>g )
<discriminant part> ::= ( <discriminant specication>
f <discriminant specication>g )
<discriminant specication> ::= <identier list> :
<entry call statement> ::= <entry name> <actual parameter part> ]
Fuggelek 133
<entry declaration> ::= entry <identier> ( <discrete range> ) ]

<formal part> ]
<entry index> ::= <expression>
<enumaration literal specication> ::= <enumeration literal>
<enumeration literal> ::= <identier>j<character literal>
<enumeration representation clause> ::= for <type simple name>
use <aggregate>
<enumeration type denition> ::= ( <enumaration literal specication>
f , <enumaration literal specication>g )
<exception choice> ::= <exception name>j others
<exception declaration> ::= <identier list> : exception
<exception handler> ::= when <exception choice> f j <exception choice>g
=> <sequence of statements>
<exit statement> ::= exit <loop name> ] when <condition> ]
<exponent> ::= E + ] <integer>j E ; <integer>
<expression> ::= <relation> f and <relation>g
j<relation> f and then <relation>g
j<relation> f or <relation>g
j<relation> f or else <relation>g
j<relation> f xor <relation>g
<factor> ::= <primary> ** <primary> ] j abs <primary>j not <primary>
<xed accuracy denition> ::= delta <static simple expression>
<xed point constraint> ::= <xed accuracy denition>
<oating accuracy denition> ::= digits <static simple expression>
<oating point constraint> ::= <oating accuracy denition>
<formal parameter> ::= <parameter simple name>
<formal part> ::= ( parameter specication> f <parameter specication>g )
<full type declaration> ::= type <identier> <discriminant part> ] is
<type denition>
<function call> ::= <function name> <actual parameter part> ]
<generic actual parameter> ::= <expression>j<variable name>
j<subprogram name>j<entry name>j<type mark>
<generic actual part> ::= ( <generic association>
f <generic association>g )
<generic association> ::= <generic formal parameter> => ]
<generic actual parameter>
<generic declaration> ::= <generic specication>
<generic formal parameter> ::= <parameter simple name>j<operator symbol>
<generic formal part> ::= generic f<generic parameter declaration>g
<generic instantiation> ::= package <identier> is
new <generic package name> <generic actual part> ]
j procedure <identier> is new <generic procedure name>
j function <designator> is new <generic function name>
<generic parameter declaration> ::= <identier list> : in out ] ]
134 Ada
j type <identier> is <generic type denition>

j<private type declaration>
j with <subprogram specication> is name> ]
j with <subprogram specication> is <> ]
<generic specication> ::= <generic formal part><subprogram specication>
j<generic formal part><package specication>
<generic type denition> ::= ( <> ) j range <> j digits <>
j delta <> j<array type denition>j<access type denition>
<goto statement> ::= goto <label name>
<graphic character> ::= <basic graphic character>
j<lower case letter>j<other special character>
<highest precedence operator> ::= ** j abs j not
<identier list> ::= <identier> f , <identier>g
<identier> ::= <letter> f <underline> ] <letter or digit>g
<if statement> ::= if <condition> then <sequence of statements>
f elsif <condition> then <sequence of statements>g
end if
<incomplete type denition> ::= type <identier> <discriminant part> ]
<index constraint> ::= ( <discrete range> f , <discrete range>g )
<index subtype denition> ::= <type mark> range <>
<indexed component> ::= <prex> ( <expression> f , <expression>g )
<integer type denition> ::= <range constraint>
<iteration scheme> ::= while <condition>
j for <loop parameter specication>
<label> ::= << <label simple name> >>
<later declarative item> ::= <body>j<subprogram declaration>
j<use clause>j<generic instantiation>
<length clause> ::= for <attribute> use <simple expression>
<library unit body> ::= <subprogram body>j<package body>
<library unit> ::= <subprogram declaration>j<package declaration>
j<generic declaration>j<generic instantiation>j<subprogram body>
<logical operator> ::= and j or j xor
<loop parameter specication> ::= <identier> in reverse ]
<discrete range>
<loop statement> ::= <loop simple name> : ] <iteration scheme> ] loop
end loop <loop simple name> ]
<mode> ::= in ] j in out j out
<multiplying operator> ::= * j / j mod j rem
<name> ::= <simple name>j<character literal>j<operator symbol>
j<indexed component>j<slice>j<selected component>j<attribute>
<null statement> ::= null
<number declaration> ::= <identier list> : constant :=
<universal static expression>
<object declaration> ::= <identier list> : constant ]
<subtype indication> := <expression> ]
Fuggelek 135
j<identier list> : constant ]

<constrained array denition> := <expression> ]
<operator symbol> ::= <string literal>
<package body> ::= package body <package simple name> is
exception <exception handler> f<exception handler>g ] ]
<package declaration> ::= <package specication>
<package specication> ::= package <identier> is
f<basic declarative item>g
private f<basic declarative item>g ]
<parameter association> ::= <formal parameter> => ] <actual parameter>
<parameter specication> ::= <identier list> : <mode><type mark>
:= <expression> ]
<pragma> ::= pragma <identier>
( <argument association> f , <argument association>g ) ]
<prex> ::= <name>j<function call>
<primary> ::= <numeric literal>j null j<aggregate>j<string literal>
j<name>j<allocator>j<function call>j<type conversion>
j<qualied expression>j ( <expression> )
<private type declaration> ::= type <identier> <discriminant part> ] is
limited ] private
<procedure call statement> ::= <procedure name>
<actual parameter part> ]
<proper body> ::= <subprogram body>j<package body>j<task body>
<qualied expression> ::= <type mark> ' ( <expression> )
j<type mark> ' <aggregate>
<raise statement> ::= raise <exception name> ]
<range constraint> ::= range <range>
<range> ::= <range attribute>j<simple expression> .. <simple expression>
<real type denition> ::= <oating point constraint>
j<xed point constraint>
<record representation clause> ::= for <type simple name> use record
<alignment clause> ]
f<component clause>g
end record
<record type denition> ::= record <component list> end record
<relation> ::= <simple expression>
<relational operator><simple expression> ]
j<simple expression> not ] in <range>
j<simple expression> not ] in <type mark>
<relational operator> ::= = j /= j < j <= j > j >=
<renaming declaration> ::= <identier> :
<type mark> renames <object name>
j<identier> : exception renames <exception name>
j package <identier> renames <package name>
j<subprogram specication> renames <subprogram or entry name>
<representation clause> ::= <type representation clause>j<address clause>
136 Ada
<return statement> ::= return <expression> ]

<secondary unit> ::= <library unit body>j<subunit>
<select alternative> ::= when <condition> => ] <selective wait alternative>
<select statement> ::= <selective wait>j<conditional entry call>
j<timed entry call>
<selected component> ::= <prex> . <selector>
<selective wait alternative> ::= <accept alternative>
j<delay alternative>j<terminate alternative>
<selective wait> ::= select <select alternative>
f or <select alternative>g
end select
<selector> ::= <simple name>j<character literal>j<operator symbol>j all
<sequence of statements> ::= <statement> f<statement>g
<simple expression> ::= <unary adding operator> ] <term>
f<binary adding operator><term>g
<simple name> ::= <identier>
<simple statement> ::= <null statement>j<assignment statement>
j<procedure call statement>j<exit statement>j<return statement>
j<goto statement>j<entry call statement>j<delay statement>
j<abort statement>j<raise statement>j<code statement>
<slice> ::= <prex> ( <discrete range> )
<statement> ::= f<label>g <simple statement>
j f<label>g <compound statement>
<string literal> ::= " f<graphic character>g "
<subprogram body> ::= <subprogram specication> is
end <designator> ]
<subprogram declaration> ::= <subprogram specication>
<subprogram specication> ::= procedure <identier> <formal part> ]
j function <designator> <formal part> ] return <type mark>
<subtype declaration> ::= subtype <identier> is <subtype indication>
<subtype indication> ::= <type indication> <constraint> ]
<subunit> ::= separate ( <parent unit name> ) <body>
<task body> ::= task body <task simple name> is
end <task simple name> ]
<task declaration> ::= <task specication>
<task specication> ::= task type ] <identier> is
f<entry declaration>gf<representation clause>g
end <task simple name> ] ]
<term> ::= <factor> f<multiplying operator><factor>g
<terminate alternative> ::= terminate
<timed entry call> ::= select <entry call statement>
or <delay alternative>
Fuggelek 137
end select
<type conversion> ::= <type mark> ( <expression> )
<type declaration> ::= <full type declaration>
j<incomplete type declaration>j<private type declaration>
<type denition> ::= <enumeration type denition>
j<integer type denition>j<real type denition>
j<array type denition>j<record type denition>
j<access type denition>j<incomplete type denition>
<type mark> ::= <type name>j<subtype name>
<type representation clause> ::= <length clause>
j<enumeration representation clause>
j<record representation clause>
<unary adding operator> ::= + j ;
<unconstrained array denition> ::= array ( <index subtype denition>
f , <index subtype denition>g ) of <component subtype indication>
<use clause> ::= use <package simple name> f , <package simple name>g
<variant part> ::= case <discriminant simple name> is
<variant> f<variant>g
end case
<variant> ::= when <choice> f j <choice>g => <component list>
<with clause> ::= with <library unit simple name>
f , <library unit simple name>g
138 Ada
Feladatok
Az alabbi feladatok az Ada programozasi nyelv hasznalatanak a gyakorlasara szolgalnak. A

feladatok tobbsege algoritmikus szempontbol egyszer}u, nehezseget csak az absztrakt programnak
a nyelvre valo atultetese okozhat.
A feladatokat osztalyokba soroltuk aszerint, hogy a kodolas milyen nyelvi elemek
hasznalatat igenyli. Ezt jelzi a feladat sorszama utan feltuntetett 1,2 stb. jel. Azokat a fe-
ladatokat, amelyek megoldasa valamivel nehezebb, egy csillaggal ( 1 *), azokat pedig, ame-
lyek hosszabb gondolkodast igenyelnek, ket csillaggal (
1 **) jeloltuk meg.
1 Kesztsunk egy programot, ami kiszamtja a kozelt}o erteket az alabbi

1.
keplet alapjan!
a) 2 = 21 23 43 54 65 67 :::
b) = 4(1 ; 31 + 51 + 17 + :::)
c) = 3 + 4( 2 13 4 ; 4 15 6 + 6 17 8 ; :::)
2. 1 Kesztsunk egy programot, ami " pontossaggal kiszamtja az alabbi kozelt}o

erteket!
a) ln 2 = 1 ; 21 + 13 ; 14 + 15 ; 16 + :::
b) ln(1 + x) = x ; x2 + x3 ; x4 + :::
2 3 4
c) ln x = 2 ( xx +; 11 + 3((xx;+1)1)3 + 5((xx;+1)1)5 + :::)

3 5
1 Kesztsunk egy programot, ami kinyomtatja a kovetkez}o osszeg els}o N

3.
reszletosszeget!
a)
X
inf
np!
n=1 n
n
X
inf
((n + 1)!)n
b)
n=1 2!4! ::: (2n)!
Feladatok 139
1 Fuggvenyek egy sorozatat az alabbi modon denialjuk: u1(t) = 1 u2 (t) =

4.
t uk+1(t) = 2tuk (t) ; uk;1(t) (k = 2 3:::n ; 1). Kesztsunk programot, ami
adott n es t ertekekre meghatarozza un(t) erteket!
1 Kesztsunk olyan eljarast, ami az adott nh egesz es y0 valos ertekekb}ol
5.
meghatarozza yn erteket az alabbi formula alapjan:
yi+1 = yi + 14 ki + 34 mi (0 i < n)
ki = h(yi2 + yi + 1)
mi = h((yi + 23 ki)2 + yi + 32 ki + 1)
1 Adott a valos AN vektor. Hatarozzuk meg S erteket az alabbi formula

6.
alapjan:
XN X N
a) S = N 1; 1 (ai ; N1 a2j )
i=1 j =1
v
u
u
u 1 X
N
1 X
N 2
b) S = t N a2i ; ( N aj )
i=1 j =1
1 Kesztsunk programot az alabbi osszeg kiszamtasara (a0 , b0 es " adott

7.
kezd}oertekek):
a2 ;X
b2 <"
1
S = 1; 2
n n
2n(a2n ; b2n ) ahol

n=0
p
an = 12 (an;1 + bn;1) bn = an;1 bn;1
1 Adottak a valos Xn es Yn vektorok. Kesztsunk programot az ak

8.
egyutthatok kiszamtasara az alabbi formula alapjan:
4 X
ak = n
n
ypi uk (xi ) k = 1:::n
i=1 1 ; xi
2
u1(z) = 1 u2(z) = z uk+1(z) = 2zuk (z) ; uk;1(z) k = 2:::n

9.
1 Kesztsunk programot az alabbi osszeg kiszamtasara:
2N
a) S = 1 + x + x2! ; 34!x + ::: + (;1)N ;1 (2N(2;N1))!x
2 4
140 Ada
b) S = 23 sin 2x ; 38 sin 3x + ::: + (;1)N N 2N; 1 sin Nx
10.
1 Kesztsunk olyan programot, ami kiszamtja az alabbi tort erteket!
1
1 + 3+ 1 1 1
:::n+
n+1
1 Kesztsunk olyan programot, ami " pontossaggal kiszamtja k px erteket az

11.
alabbi rekurzv formula alapjan :
a) y0 = x yn+1 = k1 ((k ; 1)yn + kx;1 )
yn
k
b) y0 = x yn+1 = ykn2 ((k2 ; 1) + 21 (k + 1) yxk ; 21 (k ; 1) ykn )
n
12. 1 Adottak egy valos vektorban egy polinom egyutthatoi.

a) Kesztsunk olyan programot, ami kiszamtja a derivaltjanak egyutthatoit!
b) Kesztsunk olyan programot, ami kiszamtja a integraljanak egyutthatoit!
c) Kesztsunk olyan programot, ami kiszamtja a negyzetenek egyutthatoit!
13.
1 Kesztsunk olyan eljarast, amelynek bemen}o parameterei egy m-ed es egy
n-ed rend}u polinom egyutthatoit tartalmazo vektorok, kimen}o parametere egy
m+n hosszusagu vektor, s az eljaras kiszamtja a szorzatpolinom egyutthatoit!
14.
3 Kesztsunk olyan modult, ami polinomokra vonatkozo eljarasokat exportal
(polinomok osszeadasa, kivonasa, szammal valo szorzasa stb.)!
1 Adott a valos A szam. Kesztsunk olyan programot, ami meghatarozza az
15.
S es N szamokat ugy, hogy S N minimalis legyen, es j NS ; A j< " teljesuljon!
1 Kesztsunk olyan programot, ami " pontossaggal kiszamtja tg z erteket az
16.
alabbi rekurzv formula alapjan (feltesszuk, hogy z 6= 2 n(n = 1 2:::)) :
tg z = 1 ;z y yi = i ;zy
2
3 i+2
1 Kesztsunk olyan programot, ami kiszamtja Cnp erteket az alabbi rekurzv

17.
formulak alapjan:
C11 = 1 Cnp+1 = pn +; p1 Cnp Cnp+1 = Cnp;1 + Cnp
18.
3 Kesztsunk generic package-t a komplex szamok kezelesere! Az elemi arit-
metikai operaciokon kvul kesztsunk fuggvenyeket az alabbiak kiszamtasara
Feladatok 141
is (a egy komplex szamot jelol, (r) az a polarkoordinatas alakja, n egy egesz

szam):
n pa = n pr (cos + 2k + i sin + 2k ) (k = 0:::n ; 1)
n n
an = enln a
sin a = a ; a3! + a5! ; a7! + :::
3 5 7
cos a = 1 ; a2! + a4! ; a6! + :::

2 4 6
19.
3 Kesztsunk egy olyan modult, ami egesz szamparokkal abrazolt valos
szamok m}uveleteit tartalmazza! Az (ab) szam erteke a 10b, tehat pl. az
(ab) es a (cd) szamok szorzata (a cb + d).
20.
1 Kesztsunk olyan programot, ami meghata2 rozza azoknak az egesz koor-
dinataju pontoknak a szamat, amelyek az y16 + x252 + 1 = 0 ellipszisbe es-
nek!
21.
1 Kesztsunk olyan programot, ami szogfuggvenytablazatot nyomtat!
22. 1 Kesztsunk egy olyan programot, ami kinyomtatja az alabbi fuggveny
ertekeinek tablazatat az ab] intervallumban 0.5 lepeskozzel!
a) f (x) = (1 +xx)2
b) f (x) = 11++xx3
c) f (xnp) = xn px(1 ; p)n;x
23.
1 Ha egy testet elengedunk, szabadon esni kezd. Az elengedest}ol szamtott t.
masodpercben a kiindulasi ponttol mert tavolsagat labban az s = 16 t2 keplet
adja (1 lab=30.48 cm). Nyomtassunk tablazatot az 1;20 masodpercekr}ol, es
ebben adjuk meg a test altal megtett utat cm-ben!
24.
1 Kesztsunk egy olyan programot, ami a tanult kozelt}o eljarasok valame-
lyikenek felhasznalasaval megkeresi az alabbi egyenlet egy gyoket (pl. inter-
vallumfelezes, hurmodszer)!
a) x3 ; 2x + 1:2 = 0 a ;2 ;1] intervallumban
b) x5 ; 0:5 = 0 a 0 1] intervallumban
c) ex ; x2 + 1 = 0 a ;2 ;1] intervallumban
d) ex ; x2 ; 2 = 0 a 0:5 0:6] intervallumban
142 Ada
25.
1 Kesztsunk egy olyan programot, ami a tanult kozelt}o eljarasok vala-
melyikenek felhasznalasaval kiszamolja az alabbi fuggveny hatarozott in-
tegraljat (pl. Simpson-modszer, trapez formula)!
Z1
a) (1 + sin x)2
;1
Z1 p
b) x2 + x2 + 0:1
;1
Z1 x
c)
;1 1 + x2
Z ;1:5
d) x3 ; 3x2 ; x + 9
;2
2 Kesztsunk programot, ami Monte-Carlo modszerrel kiszamtja az (x ;
26.
0:5)2 + (y ; 0:5)2 < 0:25 korlap teruletet! (A lltsunk el}o kb. 200 pontot
egyenletes eloszlassal veletlenszer}uen a ;1 1] ;1 1], tartomanyban, majd
vizsgaljuk meg, hogy a pontok kozul hany esik a korlapra.)
27. 2 Kesztsunk programot, ami Monte-Carlo modszerrel kiszamtja egy
fuggveny hatarozott integraljat! (Foglaljuk teglalapba a fuggvenyt az in-
tervallum hatarai es a fuggveny egy also- es egy fels}o korlatja segtsegevel.
A lltsunk el}o egyenletes eloszlassal veletlenszer}uen pontokat, s allaptsuk meg,
hogy a fuggvenygorbe alatt vagy felett vannak-e. Ezutan egy osztassal meg-
kaphato a gorbe alatti terulet kozeltese.)
28.
2 Kesztsunk egy olyan programot, ami a tanult eljarasok valamelyikenek
felhasznalasaval megoldja az alabbi egyenletet!
a) y0 = x + cos y x0 = 1:7 y0 = 5:3 az 1:7 5:2] intervallumban
b) y0 = x ; y x0 = 0 y0 = 0 a 0 1] intervallumban
c) y0 = ex +y y2 x0 = 0 y0 = 1 a 0 1] intervallumban
29.
2 Kesztsunk egy olyan programot, ami a Runge-Kutta modszer fel-
hasznalasaval megoldja az alabbi egyenletet!
a) y0 = 0:25y2 + x2 y(0) = ;1 a 0 0:5] intervallumban
b) y0 = xy ; y2 y(0) = 1 az 1 2] intervallumban
30.
1 Kesztsunk egy olyan programot, ami az Euler-modszer felhasznalasaval
megoldja az alabbi egyenletet!
a) y0 = 12 xy y(0) = 1 a 0 1] intervallumban
Feladatok 143
b) y0 = 1 + xy2 y(0) = 0 a 0 1] intervallumban

c) y0 = ax + by + c ahol abcy(0) valamint az intervallum adottak
1 Kesztsunk egy olyan programot, ami a Newton-modszer (xk+1 = xk ;
31.
f (x )
f 0(x ) ) felhasznalasaval megoldja az alabbi egyenletet!
k
k
a) log10x ; x12 ; 1 = 0 ha x0 = 4
b) cos x ; 3x = 0 ha x0 = 0:3
c) ex ; 2x ; 21 = 0 ha x0 = 3
32.
2 Kesztsunk egy olyan programot, ami a Seidel-modszer felhasznalasaval
megoldja az alabbi egyenletrendszert!
4x1 + 0:24x2 ; 0:08x3 = 8
a) 0:09x1 + 3x2 ; 0:15x3 = 9
0:04x1 ; 0:08x2 + 4x3 = 20:
10x1 + x2 + x3 = 12
b) 2x1 + 10x2 + x3 = 13
2x1 + 2x2 + 10x3 = 14:
33.
2 Kesztsunk egy olyan programot, ami a Gauss-modszer felhasznalasaval
megoldja az alabbi egyenletrendszert!
7:9x1 + 5:6x2 + 5:7x3 ; 7:2x4 = 6:68
a) 4::35xx1
8 ; 4:8x2
+ 4:2x2
+ 0:8x3
; 3:2x3
+ 3:5x4
+ 9:3x4
= 9:95
= 8:6
1
3:2x1 ; 1:4x2 ; 8:9x3 + 3:3x4 = 1:
6x1 ; x2 ; x3 = 11:33
b) ;x1 + 6x2 ; x3 = 32
;x1 ; x2 + 6x3 = 42:
2 Kesztsunk olyan programot, ami eldonti, hogy az x1 = (5 ;3 2 4)x2 =

34.
(2 ;1 3 5)x3 = 4 ;3 5 ;7) vektorok linearisan fuggetlenek-e! (A feladat
visszavezethet}o a 1 x1 + 2x2 + 3x3 = 0 egyenlet megoldasara. Hasznaljuk
erre a Gauss-Jordan modszert!)
1 Kesztsunk olyan programot, ami kirja adott A0 t}oke 1,2,...,10 evi kamatos
35.
kamattal novelt ertekeinek tablazatat (p a kamatlab) :
A = A0 (1 + 100 p )n
144 Ada
36.
1 Kesztsunk egy olyan programot, ami kinyomtatja egy adott ev adott
honapjanak naptarat!
37.
1 Az egyetemen a penztar olyan cmletekben zeti ki a hallgatok osztondjait
a csoportvezet}onek, hogy az mindenkinek odaadhassa az osztondjat tovabbi
penzvaltas es -visszaadas nelkul, s kozben a penztar a lehet}o legkevesebb
bankjegyet es ermet adja ki. Kesztsuk el a cmletezes programjat, aminek
adata a csoport tagjainak osztondjai, eredmenye az, hogy hany darab 1000-
, 500-, 100-, 50-, 20-, 10-, 5-, 2- es 1-forintost kell a csoportvezet}onek kiadni!
1 Adott egy 1582 es 4902 kozotti datum (ev, honap, nap). Kesztsunk prog-
38.
ramot, ami megallaptja, hogy ez hanyadik nap az evben!
39.
1 Kesztsunk programot, ami megallaptja, hogy egy adott datum hanyadik
munkanap az evben, ill. megfordtva, ami meg tudja adni, hogy az n: munka-
nap az ev melyik napjara esik! (Az unnepnapok egy resze | pl. a karacsony |
ismert, masok egy tablazatban adottak.)
40.
3 Kesztsunk egy modult a datum (ev, honap, nap) tpus megvalostasara, a
datumok kozotti aritmetikai m}uveletek (datum + valahany nap, ket datum
kozott eltelt napok szama, ket datum kozul melyik a korabbi stb.) elvegzesere!
41.
1 Kesztsunk programot, ami meghatarozza egy adott evben az osszes olyan
penteki napot, ami 13-ara esik!
42.
1 Kesztsunk programot, ami a termeszetes szamok szamjegysorozataban
meghatarozza az n. szamjegyet!
1 Kesztsunk programot, ami megszamolja, hogy az m es n kozott elhelyez-
43.
ked}o termeszetes szamok osszesen hany szamjegyb}ol allnak!
44.
1 Kesztsunk olyan programot, ami meghatarozza azokat a haromjegy}u
termeszetes szamokat, amelyek szamjegyeinek kobosszege kiadja magat a
szamot!
45.
2 Kesztsunk olyan programot, ami meghatarozza azokat a termeszetes
szamokat, amelyekre teljesul, hogy felrasukban es negyzetuk felrasaban
egyuttesen a 0 -t kiveve minden szamjegy szerepel, de csak egyszer!
1 Kesztsunk olyan programot, ami meghatarozza azokat a di termeszetes
46.
szamokat,Pamelyekre teljesul, hogy dn 6= 0 es 8i 2 0:::n0 di (i + 1)!,
valamint ni=0 di (i + 1)! egy el}ore megadott szammal egyenl}o!
2 Kesztsunk programot, ami egy adott N termeszetes szamot felbont ket
47.
prmszam osszegere (nem bizonytott, hogy ez mindig lehetseges)!
48.
2 Barmely termeszetes szam el}oallthato legfeljebb negy termeszetes szam
negyzetosszegekent. Kesztsunk programot, ami egy adott N termeszetes
Feladatok 145
szamhoz megadja azokat a termeszetes szamokat, amelyek negyzetosszegekent

el}oallthato!
2 Kesztsunk programot, ami egy adott N termeszetes szamrol megallaptja,
49.
hogy el}oallthato-e harom termeszetes szam negyzetosszegekent, s ha igen,
akkor felsorolja az osszes ilyen el}oalltast!
2 Kesztsunk programot, ami egy adott N termeszetes szamhoz megadja az
50.
N -nel kisebb 2p ; 1 alaku termeszetes szamokat, ahol p prmszam!
1 Kesztsunk programot, ami meghatarozza azt a legnagyobb N termeszetes
51.
szamot, amire N ! 1050!
52.
1 Tokeletesnek nevezzuk azokat a termeszetes szamokat, amelyek osztoinak
(az 1 -et beleertve, de onmagat nem) osszege kiadja magat a szamot.
Kesztsunk programot, ami M es N kozott megadja az osszes tokeletes szamot!
1 Ismert, hogy az m es n nemnegatv egesz szamok (m n) legnagyobb kozos
53.
osztoja meghatarozhato az alabbi rekurzv fuggveny ertekenek kiszamtasaval:
lnko(mn) = m ha n = 0
lnko(n n ]) ha n 6= 0
m
a) Kesztsunk programot ket termeszetes szam legnagyobb kozos osztojanak

meghatarozasara!
b) Kesztsunk programot n db termeszetes szam legnagyobb kozos osztojanak
meghatarozasara! (lnko(a1 :::an) = lnko(lnko(a1:::an;1)an).)
c) Kesztsunk programot ket termeszetes szam legkisebb kozos tobsszorosenek
meghatarozasara!
1 Adott az N termeszetes szam. Kesztsunk programot, ami megallaptja,
54.
hogy
a) igaz-e, hogy a szamban minden szamjegy kulonboz}o!
b) igaz-e, hogy a szamban egy szamjegy haromszor szerepel, a tobbi szamjegy
pedig mind kulonboz}o!
55.
1 Kesztsunk programot egy szemelyi szam ellen}orz}o jegye helyessegenek
megallaptasara! A szemelyi szamok utolso jegye az ellen}orz}o jegy, amit az
alabbi keplettel hataroztak meg (10-es maradekot ado szemelyi szamot nem
adtak ki):
(x1 + 2 x2 + 3 x3 + ::: + 10 x10 ) mod 11
1 Kesztsunk programot, ami prmtenyez}oire bontja az N termeszetes szamot
56.
(vagyis meghatarozza azokat az I , J , K , L, P , Q, R, S termeszetes szamokat,
amelyekre N = I P J QK R:::LS )!
57.
1 Adott egy 1-nel nagyobb termeszetes szam. Ha paros, akkor felezzuk,
kulonben szorozzuk meg harommal, majd adjunk hozza egyet, s ismeteljuk
146 Ada
ezt a m}uveletet, amg 1 -et nem kapunk! Kesztsunk programot, ami a fenti
eljarast alkalmazza, s megadja, hogy hany lepes utan jutott el az 1-hez! (Nem
bizonytott, hogy ez az eljaras minden termeszetes szamra veges.)
2 Kesztsunk programot, ami meghatarozza az a0 a1 :::an szamsorozat ele-
58.
meit (ai 2 f;1 0 1gan 6= 0) ugy, hogy Pni=0 ai 3i egy el}ore megadott ertek
legyen!
59.
2 Kesztsunk programot, ami el}oallt egy olyan termeszetes szamot, aminek
decimalis alakjaban csak a 0 es a 7 szamjegyek fordulnak el}o, s a szam oszthato
egy el}ore megadott termeszetes szammal!
60.
3 Kesztsunk modult tetsz}oleges elemekb}ol allo sorozat tpus megvalostasara!
61.
2 Kesztsunk programot linearis egyenletrendszer megoldasara a triangularis
felbontas modszerevel!
62.
3 Kesztsunk olyan modult, ami egy tetsz}oleges elemekb}ol allo vektor ren-
dezesere exportal kulonboz}o eljarasokat (quicksort, heapsort stb.)!
63. 3 Kesztsunk olyan modult, ami numerikus elemekb}ol allo vektorokon
ertelmezett m}uveleteket exportal (osszeadas, szorzas, norma szamolasa,
mer}olegesseg ellen}orzese stb.)!
64.
3 Kesztsunk olyan modult, ami egy altalanos matrix tpusra exportalja
a gyakoribb matrixm}uveleteket (matrixok osszeadasa, kivonasa, szorzasa,
szammal valo szorzasa, matrixokon ertelmezett relaciok stb.)!
65.
3 Kesztsuk el a f}oatlora szimmetrikus matrixok tpusanak egy hely szem-
pontjabol gazdasagos reprezentaciojat, s rjuk meg a tpusm}uveletek alprog-
ramjait (indexeles, matrixok osszeadasa, kivonasa, szorzasa, szammal valo
szorzasa, matrixokon ertelmezett relaciok stb.)!
66.
3 Kesztsuk el egy ritka (hezagosan kitoltott) matrix tpusnak a hely szem-
pontjabol gazdasagos reprezentaciojat, s rjuk meg a tpusm}uveletek alprog-
ramjait (indexeles, matrixok osszeadasa, kivonasa, szorzasa, szammal valo
szorzasa, matrixokon ertelmezett relaciok stb.)!
67.
1 Kesztsunk olyan programot, ami meghatarozza egy vektor ertek szerint
kozeps}o elemet!
1 Adott egy egesz szamokbol allo vektor es egy K egesz szam. Kesztsunk
68.
olyan programot, ami atrendezi a vektor elemeit ugy, hogy a K -nal kisebb
elemek allnak elol!
69.
1 Kesztsunk egy programot, ami egy matrixban felcserel ket sort es ket
oszlopot ugy, hogy a matrix maximalis eleme az els}o sor els}o eleme legyen!
Feladatok 147
70.
1 Kesztsunk olyan eljarast, ami a parameterkent kapott negyzetes matrixot
az ora jarasa szerint 90 fokkal elforgatja!
1 Kesztsunk olyan programot, ami a 2n meret}u A matrixot blokkokra osztja
71.
A= A 1 A2
A3 A4 alakban, majd a blokkokat felcsereli: A1 -et A4 -el, A2 -t pedig
A3 -mal!
1 Kesztsunk olyan eljarast, ami az adott Xn vektorrol eldonti, hogy az az
72.
1,...,n szamok permutacioja-e!
1 Az AN vektor termeszetes szamokat tartalmaz. Hatarozzuk meg azoknak
73.
az elemeknek az indexet, amelyek osszege megegyezik egy el}ore adott ertekkel!
1 Az AN vektor termeszetes szamokat tartalmaz. Hatarozzuk meg azoknak
74.
az elemeknek az indexet, amelyek (a vektorbeli sorrendjukben) a leghosszabb
novekv}o sorozatot alkotjak!
1 Kesztsunk olyan eljarast, ami az adott Xn vektor ismereteben meg-
75.
hatarozza a Pn vektor erteket ugy, hogy P az 1,...,n szamok permutacioja
legyen es teljesuljon xp xp +1 (i = 1:::n ; 1)!
i i
2 ** Adott egy valos matrix es egy R valos szam. Bontsuk a matrixot a lehet}o
76.
legkevesebb reszmatrixra ugy, hogy egy reszmatrixon belul barmely ket elem
kulonbsege kisebb legyen R -nel!
77.
2 Kesztsunk programot, ami kiszamolja egy matrix sajatertekeit es
sajatvektorait a Jacobi-modszer alapjan!
78.
3 Kesztsunk generic package-ket kulonfele numerikus modszerekre!
79. 1 Kesztsunk olyan programot, ami egy negyzetes matrixot felbont ket matrix
osszegere ugy, hogy az egyik tag szimmetrikus, a masik ferden szimmetri-
kus legyen!
A = S + T S = 12 (A + A ) T = 12 (A ; A )
80.
1 Kesztsunk olyan programot, ami egy negyzetes matrixrol eldonti, hogy az
elemek atrendezesevel szimmetrikus matrixsza tehet}o-e!
1 Legyen A(1) A(2)::: negyzetes binaris matrixok egy sorozata, ahol A(i)
81.
dimenzioja 3i . Kesztsunk programot az A(i) matrix el}oalltasara, ha
01 0 1
1 0 A(i;1) 0 A(i;1) 1
A(1) = @0 1 0 A A(i) = @ 0 A(i;1) 0 A !
1 0 1 A(i;1) 0 A(i;1)
148 Ada
1 * Adott az egeszekb}ol allo Cmn matrix es a Dm vektor. Kesztsunk progra-

82.
mot annak a csak 0 es 1 szamokat tartalmazo Xn vektornak az el}oalltasara,
amelyre C X = D!
1 Adott az SN szamsorozat. Egesztsuk ki a sorozatot tovabbi M darab
83.
szam hozzavetelevel (sN +1:::sM ) ugy, hogy teljesuljon az alabbi feltetel:
s1 = sM s2 = sM ;1 ...!
2 Adott a skon koordinataival N darab pont. Kossuk ossze a pontokat
84.
egy olyan vonallal, ami mindegyik ponton (pontosan egyszer) atmegy, s nem
metszi onmagat!
1 Az y = ax + b1 es az y = ax + b2 egyenesek a skot harom tartomanyra
85.
osztjak. Kesztsunk olyan programot, ami megallaptja, hogy adott N darab
pont kozul melyik hanyadik tartomanyba esik!
1 Adott a skon N db kor. Kesztsunk olyan programot, ami megallaptja,
86.
hogy a korok kozos resze ures-e!
87.
1 Adott vegpontjai koordinataival a skon ket szakasz. Hatarozzuk meg a
metszespont koordinatait!
1 Adott koordinataival a sk N pontja. Rakjuk sorba a pontokat a rajtuk es
88.
az origon athalado egyenesnek az x - tengellyel bezart szoge szerint novekv}o
sorrendbe!
2 Adott koordinataival a sk N pontja. Hatarozzuk meg a ponthalmaz konvex
89.
burkat!
2 Adott koordinataival a sk N pontja. Hatarozzuk meg a ponthalmazhoz a
90.
legkisebb olyan negyzetet, amelybe mindegyik pont beleesik!
2 Adott koordinataival a sk N pontja. Kesztsunk programot, ami kivalaszt
91.
harom olyan pontot, amelyek (legfeljebb " elterest megengedve) egy egyenesre
esnek!
92.
1 Adott a skon csucspontjai koordinataival egy sokszog (a csucspontokat
a keruleten az ora jarasa szerint elfoglalt helyuk sorrendjeben adjuk meg).
Kesztsunk programot, ami eldonti, hogy a sokszog konvex-e!
93.
1 Kesztsunk egy olyan programot, ami egy alfanumerikus keperny}ore vala-
milyen jelekb}ol (pl. csillagokbol) egy adott sugaru kort rajzol!
94.
milyen jelekb}ol (pl. csillagokbol) egy olyan egyenest rajzol, ami athalad az
origon, s aminek pontjai egyenl}o tavolsagra vannak az A es a B ponttol!
95.
Feladatok 149
milyen jelekb}ol (pl. csillagokbol) kirajzolja egy fuggveny grakonjat!

a) y = xx3 +
4 8
+ 1 a ;1 1] intervallumban
b) y = sin x2 a 0] intervallumban
96.
2 Egy veletlenszamgeneratort ellen}orzunk abbol a szempontbol, hogy a (0,1)
intervallumban elegge egyenletesen generalja-e a szamokat. Ehhez az interval-
lumot k egyenl}o reszre osztjuk, majd generalunk n db veletlenszamot. Raj-
zoljunk hisztogramot!
2 Ha ri -k egyenletes eloszlasu veletlenszamok a ;1 1] intervallumban,
97.
akkor az alabbi kepletekkel megadott pontok egyenletes eloszlasuak az
egyseggombon. Kesztsunk programot, ami ellen}orzi, hogy a pontok el-
oszlasa valoban egyenletes-e!
x = r22(+r2rr24++rr21+
r3 )
r2
1 2 3 4
y = r22(+r3rr24+;rr21r+2 )r2
1 2 3 4
z = rr ++rr +; rr +
;r
2 2 2 2
1 4 2 3
2
1
2
2 r 2
3
2
4
X
4
ahol r2 < 1: i
i=1
98.
1 Adott a skon szemkozti csucsai koordinataival egy teglalap, amelynek ol-
dalai parhuzamosak a koordinata-tengelyekkel, es adott a vegpontjai koor-
dinataival egy szakasz. Kesztsunk olyan programot, ami kiszamtja a sza-
kasznak azt a darabjat, ami a teglalapon belulre esik (lehet, hogy a teljes sza-
kasz kvul esik a teglalapon)!
99.
2 * Rendelkezesunkre all a Balaton vzfelszne igen sok pontjanak azo-
nos id}oben mert h}omerseklete. Kesztsunk programot a h}omersekletek szint-
vonalas abrazolasara!
100.
3 Kesztsunk olyan modult, ami szovegben egy adott szoveg megkeresesere
kulonboz}o eljarasokat exportal!
101. 3 Kesztsunk olyan modult, ami u j tpusm}uveleteket ad a STRING tpushoz
(karakter vagy string keresese stringben, az osszes szokoz kihagyasa a st-
ringb}ol, kiveve azokat, amelyek nem szokoz utan kovetkeznek, stringek
osszehasonltasa a szokozok gyelmen kvul hagyasaval, stringbe egy st-
ring beszurasa, stringb}ol egy reszstring elhagyasa stb.)!
150 Ada
102.
1 Kesztsunk rekurzv eljarast, ami
a) egy szovegb}ol kihagyja a szokozoket!
b) egy szovegben megszamolja a maganhangzokat!
103.
1 Kesztsunk programot, ami egy 4000-nel kisebb termeszetes szamot romai
szamma alakt at!
104.
3 Kesztsunk olyan modult, ami romai szamokon vegez el aritmetikai
m}uveleteket!
105.
1 Kesztsunk programot, ami egy szovegben megkeresi a magas-, mely- es
vegyes hangrend}u szavakat!
106.
2 * Kesztsunk programot, ami egy verset u gy nyomtat ki, hogy bejeloli az
id}omerteket!
107.
2 ** Kesztsunk egy interaktv programot, ami a beolvasott szavakat
szotagolva rja vissza!
108.
2 * Kesztsunk egy olyan programot, ami egy termeszetes szamot bet}ukkel
kir! (Tehat pl. 241 eseten a Kett}oszaznegyvenegy szoveget nyomtatja.)
109.
1 Az egyik legegyszer}ubb titkosrast az ABC bet}uinek ciklikus eltolasabol
kaphatjuk meg. Kesztsunk olyan programot, ami egy szoveget kodol ugy,
hogy minden bet}u helyebe az ABC-ben nala adott hellyel hatrabb lev}o bet}ut
teszi!
110.
2 Egy titkosrast a kovetkez}o modon kesztunk el: helyezzunk el bet}uket egy
negyzetes matrixban, s erre tegyunk ra egy negyzetracsos lapot, amelynek
negyzetei egy-egy bet}u fole esnek, s amelynek nehany negyzete ki van vagva.
A lathato bet}uk adjak a megfejtes els}o reszet. Ezutan fordtsuk el ezt a lapot
90 fokkal jobbra, es folytassuk a bet}uk leolvasasat. Ezt a m}uveletet meg
ketszer megismetelve, megkapjuk a teljes szoveget. Kesztsunk egy progra-
mot, ami a fenti modon megfejt egy titkostott szoveget!
111.
2 A titkosras egy modja a kovetkez}o is: rjuk be a szoveget mondjuk sor-
folytonosan egy matrixba, majd a kozeps}o elemt}ol elindulva es spiralisan ki-
fele tartva jarjuk be a matrix elemeit. Az gy kapott karaktersorozat a tit-
kostott szoveg. Kesztsunk egy programot, ami a fenti modon titkost es meg-
fejt egy szoveget!
112. 2 Kesztsunk egy programot, ami egy veletlenszamgenerator felhasznalasaval
titkost egy szoveget! Inicializaljuk a veletlenszamgeneratort egy olyan
ertekkel, amit megjegyzunk, s amire szuksegunk lesz majd a megfejteskor
is. A lltsunk el}o pontosan annyi egyenletes eloszlasu veletlenszamot 1 es
4 kozott, mint amilyen hosszu a szoveg. Ezutan a szoveg minden karak-
teret csereljuk fel azzal a karakterrel, amit ugy kapunk, hogy a neki megfelel}o
veletlenszamot hozzaadjuk. Megfejteskor ugyanazt a veletlenszamgeneratort
Feladatok 151
kell hasznalnunk, s ugyanazzal az ertekkel kell inicializalni.

113. 4 * Egy text-le-ban a szoveget u res sorokkal tagoltuk bekezdesekre.
Kesztsunk olyan programot, ami ugy nyomtatja a le tartalmat, hogy az
egyes bekezdesek els}o sora el}ott harom szokozt hagy, s a bekezdeseken
belul a sorokat egyforman 60 hosszusagura hozza (ez tortenhet szavak
athelyezesevel a kovetkez}o sorba, a kovetkez}o sorbol szavak athozasaval,
szokozok beszurasaval, esetleg szavak elvalasztasaval)!
114.
2 Kesztsunk programot, ami egy karaktersorozatrol eldonti, hogy az a
Modula-2 szintaxisa szerint egy szabalyos felsorolasi tpus dencio-e!
115.
1 Adott egy input rekordban egy zarojelezett kifejezes (maga az egesz kife-
jezes is zarojelben van).
a) Kesztsunk olyan programot, ami eldonti, hogy a zarojelezes helyes-e!
b) Kesztsunk olyan programot, ami megadja (kirja) az osszes zarojelezett
reszkifejezest!
2 Kesztsunk olyan programot, ami el}oalltja az osszes helyes N hosszusagu
116.
zarojelezest! Helyes zarojelezes a (), tovabba, ha P es Q helyes zarojelezesek,
akkor helyes zarojelezes (P ) es (P )(Q) is.
117.
2 Adott egy kifejezes, ami egybet}us vatozokbol, zarojelekb}ol es binaris
operatorokbol (+,-,*,/) all. Kesztsunk egy olyan programot, ami a kife-
jezest fordtott lengyel formara hozza!
118.
2 * Adott egy kifejezes, ami egybet}us vatozokbol, zarojelekb}ol es binaris
operatorokbol (+,-,*,/) all. Kesztsunk egy olyan programot, ami kiszamtja
a kifejezeshez az alabbiakban denialt az S (K ) erteket! Irjuk fel a ki-
fejezes szintaxisfajat, jelolje a fat K , a baloldali reszfat Kl , a jobbolda-
lit Kr . Ha K az ures fa, akkor S (K ) = 0, kulonben pedig a kovetkez}o re-
kurzv formulaval adjuk meg az erteket:
S (K ) = max S (Kl ) + 1 ha Kl = Kr
(S (Kl )S (Kr )) kulonben
2 * Adott egy kifejezes, ami egybet}us vatozokbol, zarojelekb}ol es binaris
119.
operatorokbol (+,-,*,/) all. Kesztsunk egy olyan programot, ami kiszamtja
a kifejezes szintaxisfajanak magassagat!
120.
2 * Adott egy kifejezes szintaxisfajanak preorder es inorder bejarasa soran ka-
pott sorozat. Kesztsunk programot, ami ebb}ol el}oalltja a szintaxisfa postor-
der bejarasakor el}oallo szimbolumsorozatot!
121. 2 * Kesztsunk olyan programot, ami beolvas egy logikai kifejezest, es kinyom-
tatja az igazsagtablajat! A kifejezes egybet}us valtozokat, logikai operatorokat
es (kerek) zarojeleket tartalmazhat. (Egyszer}ubb a feladat, ha feltesszuk,
hogy a kifejezes szintaktikusan helyes.)
152 Ada
122.
2 Adott egy szovegle, amelynek a sorai nem haladjak meg a 80 karaktert.
Masoljuk at a le-t ugy, hogy a szavak koze szokozoket beszurva minden sort
kiegesztunk 80 hosszusagura!
123.
2 Adott egy le-ban egy szoveg, ami csak bet}ukb}ol all. Nyomtassuk a
szoveget ugy, hogy minden bet}ut Morze-jelekkel abrazolunk! A Morze-jelek
kozott hagyjunk egy-egy szokozt, es egy szot nyomtassunk egy sorba!
124.
4 Kesztsunk egy interaktv szotarprogramot! A program szamara le-
hessen denialni egy angol szo jelenteset, es lehessen visszakerdezni egy
szo jelenteset! Visszakerdezeskor engedjuk meg, hogy a kerdezett szava-
kat rovidtsek! A denialt szavakat taroljuk lemezen! (A gyors visszake-
reses erdekeben hasznalhatunk pl. kiegyensulyozott binaris fat.)
125.
1 A llaptsuk meg ket stringr}ol, hogy azok a szokozokt}ol eltekintve
megegyeznek-e!
126.
1 Adva van egy tavirat szovege. Kesztsunk programot, ami meghatarozza a
tavirat tovabbtasaert zetend}o djat!
2 Adva van egy nevsor, amiben a nevek egy vezeteknevb}ol, es va-
127.
lahany utonevb}ol allnak. Kesztsunk programot, ami ugy rja ki a ne-
veket, hogy a vezeteknevnek csak a kezd}obet}uje legyen nagy bet}u, a ve-
zeteknev bet}ui kozott legyen egy-egy szokoz, majd utana egy vessz}o, s ezutan
csak az utonevek nagy kezd}obet}ui alljanak, mindegyik ponttal lezarva!
128.
2 Tegyuk fel, hogy horizontalis tabulator karaktereket tartalmazo szoveget
akarunk listazni olyan nyomtaton, ami nem ismeri a tabulatorokat.
Kesztsunk egy programot, ami el}okeszti a szoveget a nyomtatashoz: a ta-
bulator karaktereket a megfelel}o szamu szokozzel helyettesti! Tegyuk fel,
hogy a tabulator-pozciok az 1, 9, 17, ... pozciok. (A ltalanosabb lesz a meg-
oldasunk, ha a tabulator-pozciok felsorolasaval parameterezhet}o a progra-
munk.)
129.
2 Az el}oz}o feladat "megfordtasa" is ertelmes: Keszthetunk olyan progra-
mot, amely egy szoveg-le-ban a hosszu szokoz-sorozatokat ugy rovidti le,
hogy tabulator karakterekkel cserel fel valahany szokozt.
3 Kesztsunk olyan modult, ami eljarasokat exportal egy inx formaju ki-
130.
fejezes postx alakjanak el}oalltasara (a kifejezesben csak az aritmeti-
kai alapm}uveletek jelei, valos szamok es zarojelek szerepelnek), es egy post-
x formaju kifejezes ertekenek kiszamtasara!
131.
4 * Kesztsunk egy nem interaktv szovegszerkeszt}o programot! A program
egy le-bol beolvasott parancsok alapjan modostsa a text-le-t ugy, hogy az
eredmeny egy uj le-ban keletkezzen. A modosto parancsok a kovetkez}ok (a
modosto parancsokban a sorok sorszamait novekv}o sorrendben kell megadni):
Feladatok 153
- #DEL sorszam f , sorszam g | torli a sorszamaikkal megadott sorokat

- #INC sorszam | a megadott sorszamu sor utan beszurja a parancssor utan
a kovetkez}o parancssorig megadott sorokat.
132.
4* Kesztsunk egy olyan progra-
mot, ami szintezve (tehat a beagyazottsaguknak megfelel}oen) kirja egy Pas-
cal program osszes eljarasanak nevet!
133.
4 Masoljunk at u gy egy szintaktikusan helyes Modula-2 modult, hogy a meg-
jegyzeseket kozben kihagyjuk bel}ole!
134.
4 Hatarozzuk meg, hogy egy bizonyos szo a Modula-2 forrasprogram mely
soraiban fordul el}o!
135.
4 Szamoljuk meg egy szintaktikusan helyes Modula-2 implementacios mo-
dulban, hogy melyik alapszo hanyszor szerepel!
4 Gy}ujtsuk ki egy szintaktikusan helyes Modula-2 implementacios modulbol
136.
a benne denialt eljarasok es fuggvenyek neveit!
137.
4 Egy szintaktikusan helyes Pascal programban az alapszavak bet}uit
valtoztassuk nagybet}ukre, a megjegyzesek es szovegliteralok bet}uit ne
valtoztassuk, a tobbi bet}ut csereljuk kisbet}ure!
138.
4 Kesztsunk olyan programot, ami egy szintaktikusan helyes Ada program-
ban megkeresi azokat a cmkeket, amelyekre nincsen hivatkozas!
139.
4 Kesztsunk programot, ami
a) elemez egy karaktersorozatot, s eldonti, hogy az egy szabalyos Ada <numeric
literal>-e!
b) megadja egy szabalyos Ada <numeric literal> decimalis erteket!
c) egy szabalyos Ada <numeric literal>-nak kirajzolja a szintaxisfajat!
<exponent> ::= E * ] <integer>j E ; <integer>
140.
4 Adott egy CDL-nyelv}u szabaly (programegyseg) torzsenek (nemileg leegy-
szer}ustett) szintaxisa. Kesztsunk programot, ami egy stringr}ol eldonti, hogy
az megfelel-e ennek a szintaxisnak!
<szabaly> ::= <csoport> "."
<csoport> ::= <alternatva>j<alternatva> "" <csoport>
154 Ada
<alternatva> ::= <tag>j<tag> "," <alternatva>

<tag> ::= "+" j "-" j "*" j "*" <azonosto> j
"(" <cmke> ] <csoport> ")"
141.
4 Adott az RSX-11M operacios rendszer parancsainak (nemileg leegyszer}u-
stett) szintaxisa. Kesztsunk programot, ami egy stringr}ol eldonti, hogy az
megfelel-e ennek a szintaxisnak!
<parancs> ::= <parancskod> <parameterek> "=" <parameterek>j
<parancskod> <parameter>
<parameterek> ::= <parameter>j<parameter> <parameterek>
<parameter> ::= <egyseg> ] <felhasznalo> ] <le>
<egyseg> ::= "DK" <szam> ":" j "LP" <szam> ":"
<felhasznalo> ::= "" <szam> "," <szam> "]"
<le> ::= <azonosto> <toldalek> ]
<toldalek> ::= <le-kiegeszt}o> <verzio> ]
<le-kiegeszt}o> ::= "." j "." <azonosto>j "." "*"
<verzio> ::= "" j "" "*" j "." "*"
142.
4 Kesztsunk egy telefonos informaciokat nyilvantarto programot! A program
adjon lehet}oseget a nev es a telefonszam szerinti visszakeresesre is!
143.
4 * Kesztsunk egy orarendet nyilvantarto programot!
a) A program tudjon valaszt adni bizonyos kerdesekre, pl. meg tudja adni egy
tanar orainak id}opontjat es helyet, vagy azt, hogy egy adott teremben, adott
id}oben kinek van oraja stb.!
b) A program tudja ellen}orizni azt, hogy az orarendben nincsen-e ellentmondas!
144.
4 Kesztsunk programot konyvtari kolcsonzesek nyilvantartasara es a nyil-
vantartas lekerdezesere!
145.
4 ** Kesztsunk egy olyan programot, ami egy vasuti menetrendet tarol, s
lehet}oseget ad annak lekerdezesere! (Bonyolultabb a feladat, ha a program
az atszallassal elerhet}o allomasokra is meg tudja adni az indulasi es erkezesi
id}oket.)
146.
4 Adott harom le, ami egy ottusa-verseny eredmenyeit tartalmazza. Az
els}o le rekordjai az indulok rajtszamait es nevet tartalmazzak. A masodik
le a csapatok nevet es a csapatok harom versenyz}ojenek a rajtszamat tartal-
mazzak. A harmadik le az elert eredmenyeket tartalmazza olymodon, hogy
egy rekord a versenyz}o rajtszamabol, a versenyszam megnevezeseb}ol es az
elert pontszambol all. Kesztsunk tablazatot az egyeni versenyr}ol es a csapa-
tok versenyer}ol!
147. 4 A metron utasszamlalast vegeznek: az allomasokat megsorszamozzak,
s minden allomason minden utasnak a kezebe adnak egy kartyat az
allomas sorszamaval, a kiszallo utasoktol pedig a kartyakat osszegy}ujtik.
Az osszegy}ujtott kartyakat minden ora vegen egy-egy zsakba zarjak. A
Feladatok 155
kartyak megszamlalasa utan ismerjuk minden allomasra minden ora vegen

az egyes allomasokrol erkezett utasok szamat. Kesztsunk olyan progra-
mot, ami kulonfele grakonok nyomtatasaval segti az adatok kiertekeleset!
148.
3 Kesztsunk egy tetsz}oleges elemekb}ol allo halmazt megvalosto modult (a
halmazt reprezentalhatjuk pl. egy hash-tablaval)!
3 Kesztsunk egy tetsz}oleges elemekb}ol allo ketiranyu listat megvalosto mo-
149.
dult (Create, PutFirst, Put, PutLast, GetFirst, Get, GetNext, GetP-
rev, Overwrite, Seek, Delete, Concat, Isempty, Length m}uveletekkel)!
150.
3 Kesztsunk egy tetsz}oleges elemekb}ol allo rendez}o-fat megvalosto modult
(create, isempty, write, rst, read m}uveletekkel)!
151.
3 Kesztsunk egy tetsz}oleges elemekb}ol allo n-aris fat megvalosto modult!
152.
2 Kesztsunk olyan programot, ami eldonti egy iranytatlan egyszer}u grafrol,
hogy van-e olyan kore, ami minden csucson athalad!
153.
hogy van-e olyan csucsa, amit minden mas csuccsal el kot ossze!
154.
hogy az teljes graf-e (vagyis, hogy barmely ket csucsa ossze van-e kotve)!
155.
1 Kesztsunk olyan programot, ami meghatarozza egy iranytatlan egy-
szer}u graf komplementer grafjat (azaz: megadja, hogy milyen eleket kel-
lene hozzaadni a grafhoz, hogy teljes grafot kapjunk)!
156.
2 ** Kesztsunk programot, ami meghatarozza egy iranytatlan graf osszes
teljes reszgrafjat!
157.
2 * Kesztsunk programot, ami egy iranytott grafban megkeresi azt a csucsot,
amelyb}ol minden mas csucs elerhet}o (uttal)!
158.
3 * Valostsunk meg privat tpuskent egy iranytott graf tpust!
159.
2 * Kesztsunk programot, ami egy iranytott grafban, ahol az elekhez
hosszertekeket is rendeltunk, megkeresi egy adott csucsbol a tobbi csucsba ve-
zet}o legrovidebb utakat!
160.
2 ** Kesztsunk olyan programot, ami eldonti egy iranytatlan egyszer}u
grafrol, hogy hanyszorosan osszefugg}o!
2 * Kesztsunk olyan programot, ami egy grafban keres egy olyan utat a p es
161.
q csucsok kozott, ami nem halad at az x csucson!
162.
2 * Kesztsunk olyan programot, ami egy grafban meghataroz egy olyan utat,
156 Ada
ami minden elet pontosan egyszer tartalmaz!

163.
2 * Kesztsunk olyan programot, ami megkeresi egy iranytatlan egyszer}u
grafban a minimalis kort!
164.
2 ** Kesztsunk olyan programot, aminek adata ket iranytatlan egyszer}u graf,
s eldonti, hogy az els}o reszgrafja-e a masodiknak!
165.
2 ** Adott egy iranytatlan, de esetleg tobbszoros eleket tartalmazo
skbarajzolhato graf, ami egy kemiai szerkezet rajza. Kesztsunk olyan progra-
mot, ami megkeresi azokat az atomokat, amelyek tobb gy}ur}uben is benne van-
nak!
2 Adott egy iranytatlan, de esetleg tobbszoros eleket tartalmazo
166.
skbarajzolhato graf. Ez egy kemiai szerkezet rajza, ami csak a szenatomokat
tartalmazza. Kesztsunk olyan programot, ami meghatarozza, hogy az egyes
szenatomokhoz hany (a rajzon fel nem tuntetett) hidrogen kapcsolodik!
167.
2 ** Adott egy iranytatlan, de esetleg tobbszoros eleket tartalmazo
skbarajzolhato graf, ami egy kemiai szerkezet rajza. Kesztsunk olyan prog-
ramot, ami megszamolja, hogy a szerkezet hany gy}ur}ut tartalmaz!
168.
2 * Kesztsunk programot, ami meghatarozza egy iranytatlan graf egy
feszt}ofajat!
2 * Adva van N darab elvegzend}o feladat, s egy tablazat, amelyben
169.
feltuntettuk, hogy melyik feladat elvegzese mennyi ideig tart, s melyek azok
a feladatok, amiket csak a feladat befejezese utan lehet elkezdeni. Kesztsunk
olyan programot, ami meghatarozza, hogy az osszes feladat elvegzese legke-
vesebb mennyi id}ot igenyel!
170. 2 Egy csoport elemeit az 1, a, b jelekkel abrazoljuk, s adott a csoport szorzasi
tablaja. Kesztsunk programot, ami kiszamtja egy szorzat (az 1, a, b jelekb}ol
allo sorozat) eredmenyet!
1 a b
1 1 a b
a a b 1
b b 1 a
171.
2 ** Adott egy csoport a szorzasi tablajaval. Kesztsunk programot,
ami kiszamtja a csoport generatorat (azaz: az csoport elemeinek azt a
reszhalmazat, amelynek elemeib}ol szorzassal el}oallthato a csoport tobbi e-
leme)!
2 Adott a H es G csoport a szorzasi tablajaval. Kesztsunk programot, ami
172.
eldonti, hogy H reszcsoportja-e a G csoportnak (azaz: az H elemei egyben G
elemei, s a szorzas eredmenye H -ban ugyanaz, mint G-ben)!
Feladatok 157
173. 2 ** Adott a H es a G csoport a szorzasi tablajaval. Kesztsunk progra-

mot, ami eldonti, hogy a csoportok izomorfak-e (azaz: talalhato-e egy-egy
ertelm}u m}uvelettarto megfeleltetes a H es a G elemei kozott)!
174. 4 Az eletjatekban a sejtek egy negyzetracsba rendezve helyezkednek el, s a sej-
teknek ket allapotuk (el}o, holt) lehet (egy sejtallomany pl. egy matrixszal
abrazolhato). A sejteknek | kiveve a szelen allo sejteket | nyolc szomszedjuk
van. Egy holt sejt helyen akkor keletkezik uj sejt, ha pontosan harom el}o
szomszedja van, ill. egy el}o sejt csak akkor marad eletben, ha ket vagy
harom el}o szomszedja van (kulonben kihal). Kesztsunk programot, ami
egy tetsz}oleges kiindulasi allapotbol kiindulva kirja egy sejtallomany meg-
adott szamu allapotvaltozasat!
175. 4 Adott egy jatektabla, amelyen egymas mellett nyolc lyuk van, mindegyikbe
legfeljebb egy golyo fer. Kezdetben a baloldali negy lyukban egy-egy fekete,
a jobboldali haromban egy-egy feher golyo van. A megengedett m}uveletek:
egy golyot athelyezhetunk a szomszedos ures lyukba, vagy pedig egy golyot
atugorva a masodik lyukba (ha az ures). A fekete golyokat azonban csak
jobbra, a fehereket csak balra vihetjuk. Kesztsunk programot, ami a fenti
szabalyokat betartva atmozgatja a fekete golyokat a tabla jobboldalara, s feher
golyokat a tabla baloldalara!
176.
4 Adott egy jatektabla, amelyen egymas mellett kilenc lyuk van, s minde-
gyikben egy-egy fekete vagy feher golyo van. Kesztsunk programot, ami a
szomszedos golyok felcserelgetesevel atmozgatja a fekete golyokat a tabla job-
boldalara, a feher golyokat pedig a tabla baloldalara!
177.
4 Adott egy jatektabla, amelyen egymas mellett kilenc lyuk van, s minde-
gyikben egy-egy kek, feher vagy piros golyo van. Kesztsunk programot, ami
rendre tetsz}oleges ket golyot felcserelve atmozgatja a kek golyokat a tabla ba-
loldalara, a piros golyokat a tabla jobboldalara, mg a feher golyok kozepen
maradnak!
178.
4 Adott ket halom gyufaszal. Ket jatekos felvaltva lep, s az nyer, aki az utolso
gyufaszalat felveszi! Egy lepes abbol all, hogy a jatekos az egyik halombol
elvesz tetsz}oleges szamu (de legalabb egy) gyufaszalat. Kesztsunk interaktv
programot, ami eljatsza az egyik jatekos szerepet!
179.
4 Adott ket halom gyufaszal. Ket jatekos felvaltva lep, s az nyer, aki az utolso
gyufaszalat felveszi! Egy lepes abbol all, hogy a jatekos az egyik halombol el-
vesz tetsz}oleges szamu (de legalabb egy) gyufaszalat, vagy pedig mindket ha-
lombol elvesz ugyanannyi (de legalabb egy) gyufaszalat. Kesztsunk inte-
raktv programot, ami eljatsza az egyik jatekos szerepet!
180.
2 * Kesztsunk olyan programot, ami megallaptja, hogy egy u res sakktablan
minimalisan hany lepesre van szuksege egy huszarnak, hogy egy adott A
mez}or}ol egy adott B mez}ore jusson!
158 Ada
181.
2 Kesztsunk programot, ami meghatarozza 12 huszarnak minden olyan el-
helyezeset a sakktablan, amelyben minden mez}ot tamadnak!
182.
2 Kesztsunk egy rekurzv eljarast 8 vezer elhelyezesere egy sakktablan u gy,
hogy egyik se usse a masikat!
183.
4 * Kesztsunk olyan programot, ami megallaptja, hogy a sakktablan egy
adott allasban
a) vilagos tehet-e gyaloglepest,
b) vilagos kepes-e utni valamelyik gyalogjaval,
c) vilagos kepes-e sakkot adni!
4 * Kesztsunk olyan programot, ami megallaptja, hogy a sakktablan egy
184.
adott allasban vilagos hany lepest tehet!
185.
4 ** Kesztsunk olyan sakkprogramot, ami
a) a vilagos kirallyal es a vezerrel jatszik a sotet kiraly ellen
b) a vilagos kirallyal es ket bastyaval jatszik a sotet kiraly ellen!
186.
4 ** Kesztsunk olyan programot, ami megallaptja, hogy a sakktablan egy
adott allasban
a) vilagos adhat-e mattot egy lepesben,
b) vilagos adhat-e mattot n lepesben!
4 Kesztsunk interaktv programot, ami segt a tortenelmi datumok ta-
187.
nulasaban! A program tegyen fel kerdeseket (pl. "Mikor volt a mohacsi
csata?"), s adja meg, hogy a valasz helyes volt, vagy sem. Rossz valasz eseten
adja meg a helyes evszamot is, s nehany kerdes mulva tegye fel ismet ugya-
nezt a kerdest.
188.
4 Kesztsunk interaktv programot, ami segt valamely idegen nyelv szavainak
tanulasaban! A program kerdezze meg egy szo jelenteset, s adja meg, hogy a
valasz helyes volt, vagy sem. Rossz valasz eseten adja meg a helyes szot is, s
nehany kerdes mulva tegye fel ismet ugyanezt a kerdest.
189. 4 Valasszunk ki egy olyan helyzetet, amelyben N szemely hasonlo
tevekenyseget vegez, s a tevekenyseg megkezdese es folytatasa valami
feltetelt}ol fugg. Ezutan kesztsunk tasko(ka)t a folyamatokat szimulalasara,
s helyezzunk el a programban megfelel}o kirasokat a folyamat nyomon
kovethet}osege erdekeben! Az egyes szemelyek parametereit valtoztatva
erdekes meggyelni, hogyan valtozik az egesz rendszer m}ukodese. Ilyen
tevekenyseg lehet pl. a sorozes, ahol a folytatas feltetele az, hogy a korsoban
legyen meg sor. Ebben a feladatban nyilvan szukseg van egy kocsmarosra is,
aki id}onkent korbejar, s tolt az ures korsokba.
190.
4 Egy keresztez}odesbe a kulonfele iranyokbol adott gyakorisaggal erkeznek
a gepkocsik. A keresztez}odesben elhelyezett forgalmi lampa adott szabalyok
Feladatok 159
szerint m}ukodik. Kesztsunk taskok felhasznalasaval egy programot az el}oallo

forgalmi dugok vizsgalatara!
191.
4 Kesztsunk programot egy nemdeterminisztikus automata m}ukodesenek
szimulalasara taskok segtsegevel olymodon, hogy nem egyertelm}u eset-
ben a program indtson el egy ujabb taskot! Az automata legyen A =
(fq0q1q2q3q4q5g fabcg q0 fq4g), ahol (q0a) = fq0q1g (q0b) =
fq 0q 2g (q 0c) = fq 4g (q 1c) = fq 0q 3g (q 2b) = fq 2g (q 2c) =
fq 0q 3g (q 3c) = fq 4g, az osszes tobbi esetre (xy ) = fq 5g.
3 Kesztsunk altalanos eljarast egy determinisztikus automata m}ukodesenek
192.
szimulalasara! Az allapotok halmaza (tpusa), a bemen}o jelek halmaza
(tpusa), az atmeneti fuggveny, a kezd}o- es vegallapotok mind legyenek az
eljaras parameterei!
193. 3 Adva van ket edeny: az egyikben az 1 2:::n szamokkal megjelolt
golyok vannak, a masik ures. A lltsunk el}o 1 es n kozotti egyenletes el-
oszlasu veletlenszamokat, s az adott szammal jelolt golyot mindig tegyuk
at a masik edenybe. Kesztsunk programot, ami szimulalja ezt a folyama-
tot, s vizsgaljuk az edenyek tartalmanak valtozasat!
2 Egy reszeg (R pont) ember all egy lampaoszlopnal (origo). Arra vagyunk
194.
kivancsiak, hogy N lepes utan milyen messzire jut az oszloptol. Minden lepese
egysegnyi hosszusagu, s az iranya veletlenszer}u. Kesztsunk programot, ami
K db kserletet vegez, s ezek alapjan megadja a varhato tavolsagot!
195. 4 * Egy zart teremben 30 dohanyos ember van. Minden id}oegyseg vegen
20% annak a valoszn}usege, hogy eggyel n}o, 20%, hogy eggyel csokken az eg}o
cigarettak szama, 60%, hogy nincs valtozas. Egy cigaretta egy id}oegyseg alatt
egy egysegnyi fustmennyiseget termel. Ha a teremben a fustmennyiseg eleri
a 200 egyseget, akkor a szamtogep elindtja az elszvoberendezest, amely egy
id}oegyseg alatt 30 egyseggel csokkenti a teremben a fustmennyiseget. Ha a
teremben a fustmennyiseg 40 egysegnel kevesebb, akkor a gep kikapcsolja az
elszvot. Kesztsunk programot, ami id}oegysegenkent kirja a fustmennyiseg
erteket, a dohanyzok szamat es az elszvo kapcsolojanak allasat!
196.
2 A b}uvos negyzet egy olyan negyzetes matrix, amelynek sorosszegei, osz-
loposszegei es a f}o- ill. 2 a mellekatlojaban lev}o elemek osszege megegye-
zik, s ez az osszeg n(n2+1) (ahol n -nel jeloltuk a negyzet oldalat, es n
paratlan). Kesztsunk programot, ami az n ertek ismereteben elkeszt egy
b}uvos negyzetet!
197.
2 ** A latin negyzet egy olyan negyzetes matrix, amelynek sorai es oszlopai
az 1:::n szamok kulonboz}o permutacioi (n -nel jeloltuk a negyzet oldalat).
Kesztsunk programot, ami az n ertek ismereteben elkeszt egy latin negyzetet!
198.
1 Kesztsunk egy programot, ami egy szamsorozatrol megallaptja, hogy
160 Ada
periodikus-e (egy sorozat akkor periodikus, ha el}oallthato egy elemsoro-

zat tobbszori egymas melle rasaval)!
199.
1 Kesztsunk programot, ami az 1,2,3,...,9 szamok koze + es ; jeleket helyez
el ugy, hogy a kifejezes erteke egy el}ore megadott szam legyen egyenl}o! (Pl.
122 = 12 + 34 ; 5 ; 6 + 78 + 9.)
200.
1 Kesztsunk olyan programot, ami el}oalltja
a) az els}o n termeszetes szam osszes permutaciojat!
b) az els}o n termeszetes szam osszes olyan permutaciojat, ahol pi 6= i (1 i n)!
2 Adott egy N teremb}ol allo labirintus egy binaris matrix formajaban: aij = 1
201.
azt jelenti, hogy az i. es a j . termeket folyoso koti ossze. Kesztsunk prog-
ramot, ami megadja, hogy milyen termeken keresztul juthatunk el egy adott
teremb}ol egy adott masik terembe!
2 ** Egy vallalat N allast hirdet meg. Jelentkezik ra ugyanannyi palyazo, s
202.
mindegyik kozli, hogy melyik allasokat tudna betolteni. Kesztsunk progra-
mot, ami eldonti, hogy a palyazokkal betolthet}o-e minden allas, s ha igen,
akkor adja meg, melyiket milyen allasra kell felvenni!
203. 2 * Egy teherauto A -bol B -be megy. Az u t menten vannak az Ai , Bi helyek
tetsz}oleges sorrendben (de a megfelel}o Bi mindig az Ai parja utan van). Min-
den Ai helyr}ol a hozza tartozo Bi helyre kell szalltani egysegnyi mennyiseget
ugy, hogy a teherauto egyszerre csak egy terhet szallthat. Kesztsunk prog-
ramot, ami eldonti, hogy melyik szalltasokat kell elvallalni ahhoz, hogy a
legtobb igenyt kielegtsuk!
2 Adott N darab targynak a sulya. Osszuk a targyakat ket csoportra u gy,
204.
hogy a ket csoport sulya a lehet}o legkozelebb legyen egymashoz!
Tartalom 161
Tartalom
El}oszo 3
1. Az Ada nyelv attekintese 4
1.1. Az Ada torteneti hattere 4
1.2. Az Ada rovid jellemzese 6
2. Lexikalis elemek 8
3. Deklaraciok 10
4. Tpusok 13
4.1. Az altpus fogalma 14
4.2. Szarmaztatott tpusok 15
4.3. Diszkret tpusok 15
4.3.1. Felsorolasi tpusok 16
4.3.2. Az egesz tpusok 17
4.3.3. A diszkret tpusok tpusm}uveletei 17
4.4. Valos tpusok 18
4.4.1. Lebeg}opontos tpusok 19
4.4.2. Fixpontos tpusok 20
4.5. Tomb tpusok 21
4.6. A rekord tpus 24
4.6.1. A rekord diszkriminansai 25
4.6.2. Varians rekord 26
4.7. Pointer tpusok 28
5. Utastasok 31
5.1. Az ertekadas 31
5.2. Az if utastas 32
5.3. A case utastas 33
5.4. Ciklus utastasok 33
5.5. A blokk utastas 34
5.6. Az exit utastas 36
5.7. A return utastas 36
5.8. A goto utastas 36
6. Alprogramok 38
6.1. Alprogram dencioja 38
6.2. Alprogram hvasa 39
6.3. Parameteratadas 41
6.4. A formalis parameterk default erteke 42
6.5. Alprogramok atlapolasa 43
6.6. Az operatorok atlapolasa 44
6.7. Peldaprogramok 45
7. A package 48
162 Ada
7.1. A package specikacioja 48

7.2. A package torzse 48
7.3. A private tpus 49
7.4. A limited private tpus 52
8. Hibakezeles, kivetelkezeles 57
9. Lathatosagi szabalyok 61
9.1. A use utastas 63
9.2. Az atnevezes 63
10. Programstruktura 65
10.1 Alegysegek 68
11. Generic 76
11.1. Generic deklaracioja 76
11.2. Peldanyostas 79
12. Taskok 83
12.1. A task specikacioja es torzse 83
12.2. Task tpusok, task objektumok 84
12.3. Taskok aktivizalasa, vegrehajtasa 85
12.4. Taskok terminalasa 85
12.5. entry, entry hvasok, accept utastas 86
12.6. A delay es az abort utastas 88
12.7. A select utastas 89
12.7.1. A szelektv varakoztatas 89
12.7.2. A felteteles entry hvas 90
12.7.3. Id}ohoz kotott entry hvas 91
13. Reprezentacios specikaciok 101
14. Fordtasi direktvak 103
15. Input - output 104
15.1. Szekvencialis le-ok kezelese 105
15.2. Direkt le-ok kezelese 106
15.3. Textle-ok 107
15.3.1. Karakteres es string I/O 110
15.3.2. Integer I/O 111
15.3.3. Float es xed I/O 112
15.3.4. A felsorolasi tpusokra vonatkozo I/O 114
Fuggelek 116
A) A STANDARD package 116
B) Az Ada fogalmainak osszefoglalasa 121
C) Az Ada szintaktikus szabalyai nevsorba szedve 131
Feladatok 138
Tartalom 163

Kozics Sándor - Az ADA Programozási Nyelv (1992, 162 Oldal)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Kozics Sándor - Az ADA Programozási Nyelv (1992, 162 Oldal)

Uploaded by

Copyright:

Available Formats

OS

EOTV LORA ND TUDOMA NYEGYETEM

Az Ada programozasi nyelv

Ez a jegyzet a programozo matematikus szakot vegz}o hallgatok szamara

1]Coat, D., "Pascal, Ada and Modula-2", BYTE 8(1984) 215-232.

1. Az Ada nyelv attekintese

1.1. Az Ada torteneti hattere

1.2. Az Ada rovid jellemzese

Az Ada er}osen tpusos nyelv. Minden objektum rendelkezik egy a fordtas

<graphic character> ::= <basic graphic character>

Az elemi szintaktikai egysegek (alapszavak, azonostok, literalok stb.) koze

Megjegyzes a program barmely soraban elhelyezhet}o. A megjegyzesnek nincs

Deklaracionak nevezzuk egy azonostonak es

Egy objektumdeklaracio futas kozbeni kiertekelese a kovetkez}o lepesekben

verzalis szamok ertektartomanyara az Ada nem vezet be korlatozast.

Az Ada a programok megbzhatosaganak novelese celjabol igen er}os

ill. az objektumnak a tarolasahoz szukseges bitek szamat. (Mindket attri-

4.1. Az altpus fogalma

(Megjegyzes. Az alt puskepzes az ertekhalmazra vonatkozo m}uvelet. A progra-

4.2. Szarmaztatott tpusok

Ekkor B := BIT(S) es S := STATUS(B) egyarant helyes konverzio.

4.3. Diszkret tpusok

4.3.1. Felsorolasi tpusok

or else operatorok megfelelnek a logikai "es" es "vagy" m}uveleteknek, de a masodik

4.3.2. Az egesz szamok tpusai

formaban szarmaztathatunk (ez egyszerre szarmaztatas es altpuskepzes is). Az

4.3.3. A diszkret tpusok tpusm}uveletei

4.4. Valos tpusok

Az Ada valos tpusai ket osztalyba sorolhatok: xpontos es lebeg}opontos

4.4.1. Lebeg}opontos tpusok

A lebeg}opontos tpusok attributumai:

T'LARGE a t pus legnagyobb modellszama

4.4.2. Fixpontos tpusok

4.5. Tomb tpusok

Bar egy tomb tpusban az indexhatarok lehetnek hatarozatlanok, egy objek-

egyik operandusa lehet skalar is.

(n = 1 esetben n a zarojelekkel egyutt elhagyhato.) A tomb lehet ures is, ekkor

Az others nem hasznalhato akkor, ha az aggregatum indexhatarait a

Vegul kesztunk egy eljarast a STRING tpus hasznalatanak bemutatasara:

procedure REVERSE STRING(S:in out STRING) is

4.6. A rekord tpus

A rekord mez}oire a szokasos szelekcios jelolessel hivatkozhatunk, tehat pl.

SIZE: INTEGER range 0 .. MAX SIZE := 0

4.6.1. A rekord diszkriminansai

4.6.2. Varians rekord

Az esetmegjeloleseket (when) statikus kifejezesekkel kell megadni. Ha in-

Altpuskepzeskor az osszes diszkriminanst meg kell adni (vagy a pozcios, vagy

fugg}oen mas-mas szerkezet}u ertekeket viselhet (ez futas kozben megvaltoztathato).

4.7. Pointer tpusok

<access type denition> ::= access <subtype indication>

Peldak a fenti tpus hasznalatara:

Az acces tpus predenit konstansa a null. Az a pointer, amelynek az erteke

type P is access PERIPHERAL

<sequence of statements> ::= <statement> f<statement>g

A kifejezes egy formula, ami az ertek kiszamtasat denialja. Az Ada kifejezes

if MY CAR.OWNER.VEHICLE /= MY CAR then

5.3. A case utastas

5.4. Ciklus utastasok

A harmadik forma egy feltetel nelkuli ciklus, aminek a megszaktasat az exit

5.5. A blokk utastas

<block statement> ::= <block simple name> : ]

;; I,J:INTEGER kozvetlenul elerhet}o

5.6. Az exit utastas

4.1. Az altpus fogalma

4.2. Szarmaztatott tpusok

4.3. Diszkret tpusok

4.3.1. Felsorolasi tpusok

4.3.2. Az egesz szamok tpusai

4.3.3. A diszkret tpusok tpusm}uveletei

4.4. Valos tpusok

Az Ada valos tpusai ket osztalyba sorolhatok: xpontos es lebeg}opontos

4.4.1. Lebeg}opontos tpusok

4.4.2. Fixpontos tpusok

4.5. Tomb tpusok

4.6. A rekord tpus

SIZE: INTEGER range 0 .. MAX SIZE := 0

4.7. Pointer tpusok

Az acces tpus predenit konstansa a null. Az a pointer, amelynek az erteke

type P is access PERIPHERAL

A kifejezes egy formula, ami az ertek kiszamtasat denialja. Az Ada kifejezes

5.3. A case utastas

5.4. Ciklus utastasok

5.5. A blokk utastas

;; I,J:INTEGER kozvetlenul elerhet}o

5.6. Az exit utastas

5.7. A return utastas

5.8. A goto utastas

6.1. Alprogram de ncioja

6.2. Alprogram hvasa

Ezekutan meg kell hataroznunk, hogy ket alprogramspecikacio mikor egye-

Egy masik, teljesebb peldat is mutatunk. Tf. denialtuk a kovetkez}o tpust :

LINE : STRING(1 .. 128)

if STR'LENGTH = 0 then return "" end if

A torzsben kozvetlenul hivatkozhatunk a torzshoz tartozo specikacios

7.3. A private tpus

return (X.RL ; Y.RL, X.IM ; Y.IM)

7.4. A limited private tpus

ii) Halmaz megvalostasa

iii) A heap tpus megvalostasa

<raise statement> ::= raise <exception name> ]

i) Verem objektum megvalostasa

9.1. A use utastas

Ezutan az AI := AI + 1 forma hasznalataval elkeruljuk az indexkifejezes

ii) Keresztreferencia lista kesztese

end TABLE HANDLER

;; Egyszeres el}oreolvasas megvalostasa.

12.2. Task tpusok, task objektumok

12.5. entry, entry hvas, accept utastas

12.6. A delay es az abort utastas

12.7. A select utastas

12.7.1. A szelektv varakoztatas

12.7.2. A felteteles entry hvas

12.7.3. Id}ohoz kotott entry hvas