Programming | Other » Kozics Sándor - Az ADA programozási nyelv

LORA ND TUDOMA NYEGYETEM EO
TVOS TERMESZETTUDOMANYI KAR Kozics Sandor Az Ada programozasi nyelv Budapest, 1992 Ada 3 El}osz
o Ez a jegyzet a programozo matematikus szakot vegz}o hallgatok szamara kesz
ult. Feltetelezi a Bevezetes a programozashoz c targy anyaganak, s a Modula2 nyelvnek az ismeretet A jegyzet celja a nyelv
onallo tanulasanak tamogatasa. Ennek erdekeben a jegyzet vegen k
ul
onb
oz}o nehezseg}u feladatokat is elhelyezt
unk. A jegyzet kesztesehez felhasznaltuk az alabbi cikkeket es k
onyveket: 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 K
onyvkiado, 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, CG, File Structures with Ada (The

Benja- min/Cummings Publishing Company, Inc., Redwood City, California, 1990) 7]Dershem, H.L, Jipping, MJ, Programming Languages: Structures and Mo- dels (Wadsworth Publishing Company, Belmont, California, 1990.) 4 Ada 1. Az Ada nyelv
attekint
ese 1.1 Az Ada tort
eneti h
attere Az 1970 -es evek elejen az US DoD (United States Department of Defense) ugy d
ont
ott, hogy tennie kell a software-k
oltsegek rohamos n
ovekedese ellen. 1973 ban peldaul a DoD software-k
oltsege 3 milliard dollar k
or
ul volt, aminek 56 %
at az alap-software jelleg}u rendszerek fejlesztese emesztette fel. Osszehasonl tasul: adatfeldolgozasra 19 %-ot, a tudomanyos programokra 5 %-ot k
olt
ottek. A legnagyobb k
oltsegmegtakartas nyilvanvaloan ugy erhet}o el, ha ezek k
oz
ul az alap-software rendszerek k
oltsegeit cs
okkentik. Mg az adatfeldolgozas es a tudomanyos programok nyelve szeles k
orben a COBOL es a FORTRAN, a rendszerprogramok 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 k
ovetkeztetni, hogy jotekonyan hatna a k
oltsegekre ennek a ter
uletnek az egysegestese. Ennek erdekeben szervezte meg az US DoD a HOL (High Order Language) elnevezes}u munkat, kett}os cellal. Az els}o, r
ovidtavu cel egy vagy t
obb ideiglenesen hasznalhato nyelv kivalasztasa, a masodik, hosszutavu cel pedig egy nagy megbzhatosagu alap-software kesztesere alkalmas nyelvnek a kijel
olese ill. denialasa volt Az els}o celt hamarosan elertek, es a k
ovetkez}o nyelveket valasztottak ki: TACPOL, CMS-2, SPL/1, JOVIAL J3 es JOVIAL J73. A hosszutavu cel eleresenek els}o lepese a k
ovetelmenyek r
ogztese es a letez}o nyelvek ertekelese volt. A k
ovetelmenyeket egyre nomodo dokumentumokban r
ogztettek, amelyek a STRAWMAN, WOODENMAN, TINMAN, IRONMAN, veg
ul a STEELMAN nevet kaptak (szalma-,

fa-, badog-, vas-, acelember). Ezeket a dokumentumokat szelesk
or}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 publikaltak. 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 k
ovetelmenyek 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 ker
ult pl a FORTRAN es a CORAL 66 -

megfelel}o : Ide ker
ultek azok a nyelvek, amelyek ugyan k
ozvetlen
ul nem alkalmasak, de nehany elem
uk felhasznalhato. Ebbe a csoportba ker
ult pl az RTL/2 es a LIS. - alapnyelvkent hasznalhato : Harom ilyen nyelvet talaltak, a Pascalt, a PL/Iet es az ALGOL 68-at, amiket az uj nyelv tervezesenek kiindulopontjaul ajanlottak. Ezzel a TINMAN dokumentumot befejeztek, es a k
ovetkez}o szakaszban negy vallalkozora bztak a tervezest, akik valamelyik alapnak alkalmas nyelvb}ol indulhattak ki. Tizenhet jelentkez}ob}ol valasztottak ki azt a negyet, akik parhuzamosan folytattak a nyelv tervezeset. A negy vallalkozot sznekkel kodoltak: CII Honeywell Bull | Z
old Intermetrics | Piros Softech | Kek SRI International | Sarga Mind a negyen a Pascalt valasztottak alapnyelvnek. (A sznkodolast az elfogulatlan velemenyezes erdekeben vezettek be) Az els}o fazis vegen Kek es Sarga kiesett a k
uzdelemb}ol, de Z
old es Piros folytattak a

versengest. Ezt a tervezesi szakaszt 1979 majusaban fejeztek be, es a gy}oztes Z
old lett. A Z
old es Piros k
oz
otti valasztas nem volt k
onny}u a DoD szamara. Azt mondtak, hogy a Piros egy jobb nyelv lehet}oseget hordozta magaban, de az IRONMAN masodik szakaszaban ez a nyelv olyan mertekben megvaltozott, hogy a tervez}ok nem tudtak befejezni a munkat. A Z
old nyelv keveset valtozott, es a dencioja joval teljesebb volt, gy a Z
old valasztasa jart kisebb kockazattal Piros nyelv nehany fogalmanak implementalasa igen problematikus volt, mg a Z
old 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 k
ul
onb
oz}o csoportok programokat rtak Ada nyelven, hogy annak hasznalhatosagarol meggy}oz}odjenek. Ezekr}ol a munkakrol 82 elemzes kesz
ult, 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 nelk
uli. A megadott 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 veg
ul is nem siker
ult 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 megmutassak, a nyelv vegrehajthato. A harmadik problema az Ada kezik
onyv

t
om
orsege volt. Bar a kezik
onyv t
okeletesen lerta a nyelvet, mint oktatok
onyv nem volt tulsagosan jo. Ezzel egy
utt a Tesztelesi es E rtekelesi szakaszban igen alapos es intenzv tesztelest vegeztek, amelynek az eredmenyei alapjan a nyelvet tovabb nomtottak 1.2 Az Ada rovid jellemz
ese Az Ada tervezesenek 1,2,3,4,5,6] f}o szempontjai a program megbzhatosaga, karbantarthatosaga, emberk
ozelisege (olvashatosaga) es hatekonysaga voltak. A nyelv alapja a Pascal, de nehany vonast atvett a k
ovetkez}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 k
oz
ott a f}oprogram egy olyan eljaras lehet, amelynek nincs parametere A programegysegek ket reszb}ol allnak: specikacios reszb}ol, ami a mas egysegekb}ol lathato informaciot tartalmazza, es a t
orzsb}ol, ami az implementaciot tartalmazza, es ami mas egysegekb}ol nem lathato. A specikacios resz es a t
orzs szetvalasztasa, es a k
ul
on valo fordtas lehet}ove teszi nagymertekben f
uggetlen programkomponensek tervezeset, rasat es teszteleset. A programegyseg t
orzse ket reszb}ol all: deklaracios reszb}ol, ami denialja a programegysegben hasznalt konstansokat, valtozokat, hibaesemenyeket (exception) es programegysegeket, es egy utastassorozatbol, ami denialja a programegyseg vegrehajtasanak hatasat. A t
orzs vegrehajtasa ennek megfelel}oen ket lepesben t
ortenik: 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 t
orzs vegen specialis programreszek (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 ellen}orz
ott. Vannak a nyelvnek elemi tpusai, mint a felsorolasi tpus es a k
ul
onb
oz}o numerikus tpusok, valamint
osszetett tpusai, mint a rekord, a t
omb es a pointer (access) tpus. A felhasznalo is denialhat tpust, un private tpust ugy, hogy megadja az ertekhalmazt es a m}uveletek programjait egy package programegysegben. Az Ada az input-output-ot predenit generic package-kben denialja. A lefordtott Ada egysegek egy specialis k
onyvtarban, egy

adatbazisban helyezkednek el. Kezdetben a k
onyvtar csak predenit package-ket tartalmaz, ezekhez illesztheti hozza a felhasznalo a maga k
onyvtari egysegeit Egy Ada program kifejlesztese a k
onyvtari egysegek adatbazisanak felepteset jelenti Az Ada a nyelv k
ul
onb
oz}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 alkalmazza, s ami nem vezet be sem modostasokat, sem kiterjeszteseket. Azt, hogy egy fordtoprogram viselheti-e az "Ada fordtoprogram" cmket, egy New Yorkban felalltott intezetben d
ontik el. Az ide elk
uld
ott fordtoprogram validalasa ugy t
ortenik, hogy lefordtanak es lefuttatnak egy t
obb ezer programbol allo tesztsorozatot. Az Ada szintaxisanak lerasara a tovabbi fejezetekben egy kiterjesztett BNF nyelvet hasznalunk. A bal- es

jobboldalt ::= jellel, a jobboldal alternatvait jellel valasztjuk el. A nemterminalis elemeket < es > jelek k
oze rjuk A sz
ogletes zarojelel k
oze zart resz tetszes szerint elhagyhato vagy hasznalhato a programban, a kapcsos zarojelbe tett resz pedig tetsz}olegesen sokszor (akar nullaszor is) egymas utan rhato. j 8 Ada 2. Lexik
alis 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 k
ul
onbseget a kises nagybet}uk k
oz
ott. Az azonosto minden karaktere szignikans A nyelvben | a modern gyakorlatnak megfelel}oen | az alapszavakat k
ul
on jel
olni nem kell, de ezek k
ot
ott szavak, azonostokent nem

hasznalhatok. Vannak a nyelvben predenit szavak is (pl a tpusok felepteseben hasznalt INTEGER, TRUE, STRING stb), ezek u jradenialhatok. Az Adaban az a szokas, hogy az alapszavakat 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 1E6 2#1011# 3.14159 16#F.FF#E2 2#1.1111 1111 111#E11 ;; decimalis egesz szam ;; decimalis egesz exponencialis alakban ;; binaris egesz szam ;; decimalis valos ;; hexadecimalis valos exponencialis alak ;; a kitev}ohoz tartozo alap a szamrendszer ;; alapszama, tehat a ket utobbi ertek ;; egyarant 4095.0 A valos szamokat az k
ul
onb
ozteti meg az egesz szamoktol, hogy tizedespontot tartalmaznak. <character literal> ::= <graphic character> <string literal> ::= " f<graphic character>g " Az Ada karakter- es stringliteralokban csak megjelenthet}o karaktereket hasznalhatunk. A karakterliteralokat ugy rjuk, hogy a karaktert aposztrofok k
oze Lexikalis elemek 9 zarjuk. A stringliteralokat idez}ojelek k
oze tessz
uk, es nem nyulhatnak tul a sor vegen. A nem

megjelenthet}o karaktereket karakteres konstans formajaban a predenit ASCII package denialja A a ;; "" ;; """" ;; "abc" & d & "ef" & g;; ASCII.ESC & "9B" ez egy nagy es kis A bet}u es egy aposztrof u res string egy idez}ojelet tartalmazo string ez a konkatenacio ford tasi id}oben ertekel}odik ki Az elemi szintaktikai egysegek (alapszavak, azonostok, literalok stb.) k
oze tetsz}olegesen sok szok
oz elhelyezhet}o, de ezek belsejeben nem lehet szok
oz. (Nem lehet tehat szok
oz a t
obb 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. Deklar
aci
ok Deklaracionak nevezz
uk egy azonostonak es egy egyednek az


osszekapcsolasat. A ltalaban maga a deklaracios utastas tartalmazza az egyed denciojat is (pl valtozo es konstans eseten), egyes esetekben azonban a deklaracio es a dencio szet is valhat (pl tpus es alprogram eseten) Ha egy azonostora hivatkozunk, annak a sz
ovegben korabban deklaraltnak kell lennie (kiveve a cmkek esetet, ld 58) Az egyedek denciojanak kiertekelese futasi id}oben t
ortenik, emiatt pl. a tpusdencio valtozot es f
uggvenyhvast 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<package declaration>j<task declaration>j<generic declaration> j<exception declaration>j<generic instantiation>j<renaming declaration> j<deferred constant declaration> A k
ul
onfele elemek deklaraciojanak es a deklaracios reszben lev}o dencioknak a sorrendje a k
ovetkez}o: el}obb a tpus- es objektumdeklaraciok, valamint az alprogramspecikaciok k
ovetkeznek, majd ezek utan j
ohet a taskok, package-k es alprogramok t
orzse. A taskok es package-k specikacioja barhol

lehet, de annak meg kell el}oznie a hozza tartozo t
orzset Ha egy deklaracios reszben szerepel egy alprogram, package vagy task specikacioja, ugyanebben a deklaracios reszben kell lennie a megfelel}o t
orzsnek is. <object declaration> ::= <identier list> :  constant ] <subtype indication>  := <expression> ]  j<identier list> :  constant ] <constrained array denition>  := <expression> ]  Objektumnak nevezz
uk azokat az elemeket, amelyeknek valamilyen tpusu erteke lehet. Objektum a valtozo, a konstans, a formalis parameter, a ciklusvaltozo, a t
ombelem es a reszt
omb Objektum denialasakor az objektum kap- Deklaraciok 11 hat kezd}oerteket is. Az erteket ado komponens erteke futasi id}oben ker
ul meghatarozasra COUNT, SUM : INTEGER SORTED : BOOLEAN := FALSE COLOR TABLE : (1 . N) COLOR OPTION : BIT VECTOR(1 . 10) := (OPTIONRANGE = K : INTEGER := K * K ;; hibas INTEGER : INTEGER ;; hibas array

of > TRUE) Azokat a deklaraciokat, amelyekben a jobboldal ugyanaz,
osszevonhatjuk egyetlen deklaracios utastasba (ilyen esetet mutat be a fenti peldak k
oz
ul 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. 47): P1, P2 : POINTER := new INTEGER(0) illetve P1 : POINTER := P2 : POINTER := new INTEGER(0) 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 k
ozbeni kiertekelese a k
ovetkez}o lepesekben zajlik le: a) Kiertekelesre ker
ul az objektum altpusa. b) Kiertekelesre ker
ul az objektum kezd}oerteket megado kifejezes, vagy ha ilyen nincs, akkor az a) pontban

meghatarozott tpus denciojaban megadott kezd}oertekadas. c) Letrej
on (allokalasra ker
ul) az objektum. d) Ha van az objektumnak, vagy valamelyik komponensenek kezdeti erteke, felveszi 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, hanem hasznalhatok a tpusoktol f
uggetlen
ul is, mint ahogy pl. a zikaban is hasznalnak szamokat mertekegyseg nelk
ul is. (Az Adaban ilyen univerzalis szamertekeket adnak vissza egyes attributumok, pl amelyik megadja a valos szamok gepi abrazolasaban a mantissza hosszat bitben, amelyik megadja a program rendelkezesere allo memoria meretet, vagy amelyik megadja, hogy egy adott rekordtpuson bel
ul valamelyik mez}o hanyadik bitpozcion kezd}odik stb.) Az ilyen, univerzalis szamokat ellathatjuk nevvel, es gy

denialhatunk un univerzalis ("tpustalan") konstansokat Ezekben a konstansdenciokban a kifejezesek kiertekelese fordtasi id}oben t
ortenik 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 VAL2 VAL1 VAL1 VAL2 PI : VAL2 : INTEGER : MY INT := LIMIT2 := LIMIT := LIMIT := 3.14159 := LIMIT2 ;; hibas (konvertalni constant kellene!) Tpusok 13 4. T
pusok Az Ada a programok megbzhatosaganak n
ovelese celjabol igen er}os tpusfogalmat hasznal. Ez a k
ovetkez}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 komponense 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 halmazaban 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 k
ovetkez}o tpusosztalyok leteznek : skalar tpusok, ezen bel
ul diszkret es valos tpusok diszkret tpusok, ezen bel
ul felsorolasi es egesz tpusok
osszetett tpusok (t
omb 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. attributumokat Ezeket az osztaly minden tpusara hasznalhatjuk Pl az egesz tpusra alkalmazhato a FIRST es a LAST attributum, es a tpus legkisebb ill legnagyobb ertekere INTEGERFIRST ill INTEGERLAST formaban hivatkozhatunk Az = es /= relacio a limited private tpus (ld. 74) kivetelevel barmilyen tpusu objektumra alkalmazhato A VADDRESS attributum barmilyen V objektumra alkalmazhato, s megadja az objektumnak a memoriabeli cmet. A TSIZE, VSIZE attributum barmilyen T tpusra es V objektumra alkalmazhato, s megadja a tpus ertekeinek 14 Ada ill. az objektumnak a tarolasahoz sz
ukseges bitek szamat (Mindket attributumnak els}osorban mas nyelv}u, pl assembly rutinok hvasakor van szerepe) Minden tpus csak o
nmagaval ekvivalens. K
ul
onb
oz}o denciok k
ul
onb
oz}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 alt
pus 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 eszk
oz, amit a biztonsag n
ovelesere az Ada bevezet, az altpus fogalma. Altpust a tpus ertekhalmazanak megszortasaval (azaz er}osebb tpusinvarians megadasaval) allthatunk el}o. A megszortas modja f
ugg a tpusosztalytol (pl. diszkret tpusok eseteben a megszortas az ertektartomany egy intervallumanak kivalasztasa). Az altpuskepzes nem vezet be uj tpust, ennek csak a

futas k
ozbeni ellen}orzesben van szerepe. Ez a megoldas ezen kv
ul ertekes informaciokat 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 TBASE attributum, ami megadja a T bazistpusat. TBASE csak attributumok prexekent hasznalhato, pl TBASEFIRST. (Megjegyzes. Az alt puskepzes az ertekhalmazra vonatkozo m}uvelet A programozas szempontjabol hasznosak lennenek az olyan alt puskepz}o m}uveletek is, amelyek a t pus m}uvelethalmazara vonatkoznak, ilyeneket azonban az Ada nem tartalmaz. Ugyanilyen szempontbol hasznosak lennenek a t pusdenialasnak olyan

formai is, amikor az uj t pus m}uvelethalmaza kib}ovul.) Tpusok 15 4.2 Sz
armaztatott t
pusok Az Ada nemcsak a k
ul
onb
oz}o tpusok o
sszekeveredese ellen ad vedelmet, hanem a programban szerepl}o k
ul
onb
oz}o, de ugyanolyan tpusu objektumoknak a szintaxis szintjen valo elk
ul
ontesere is eszk
oz
okkel szolgal. Ez az eszk
oz 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 ker
ul.) (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
osszek
othet}o az altpuskepzessel. type NEW TYPE is new OLD TYPE <megszor tas> ekvivalens a k
ovetkez}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 f
uggvenykent 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 Diszkr
et t
pusok Az Ada diszkret tpusai a felsorolasi es az

egesz tpusok. 16 Ada 4.31 Felsorol
asi t
pusok <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 k
ul
onb
oz}ok kell legyenek. Egy azonostoval (vagy karakteres literallal) azonban t
obb tpusnak egy-egy erteket is jel
olhetj
uk | ezt a nevek atlapolasanak nevezz
uk. Ha ekkor a program egy pontjan nem egyertelm}u,

hogy melyik tpus erteker}ol van szo, a literalra un. min}ostett kifejezessel 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);; SW := SWITCH(B) ;; B := BIT(SW) ;; illegalis ! helyes helyes A CHARACTER tpus egy predenit felsorolasi tpus, ami az ASCII karaktereket tartalmazza. A nem megjelenthet}o karakterekre valo hivatkozashoz az Ada bevezet egy predenit ASCII nev}u package-t, s a nem megjelenthet}o karakterekre ASCIILF, ASCIICR, form aban hivatkozhatunk. A logikai tpus is egy predenit felsorolasi tpus, amelynek dencioja a k
ovetkez}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 ker
ul kiertekelesre, ha az eredmeny az els}o operandus alapjan is megadhato. 4.32 Az eg
esz sz
amok t
pusai <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}oseg
uk, hogy mg az INTEGER tpus implement acioja gepenkent valtozhat, az gy szarmaztatott es megszortott tpusoke

minden
utt egyforma. Ez nagyban el}osegti a program atvitelet mas gepre. A NATURAL es a POSITIVE az INTEGER tpusnak egy predenit altpusa. A denciojuk a k
ovetkez}o : subtype NATURAL is INTEGER range 0 . INTEGERLAST subtype POSITIVE is INTEGER range 1 . INTEGERLAST Az INTEGER tpus ertekeit egesz szamliteralokkal rjuk le, a m}uveletei a szokasos aritmetikai m}uveletek (+, ;, *, /, mod, rem, , abs). Az A rem B kifejezes 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 pedig abszolut ertekben kisebb, mint abs(B) 4.33 A diszkr
et t
pusok t
pusm}uveletei A diszkret tpusu ertekekre ertelmezve vannak az alabbi relaciok : <, <=, >, >=, in, not in. A diszkret tpusosztalynal hasznalhato attributumok a k
ovetkez}ok: PRED, SUCC, POS, VAL, FIRST, LAST, IMAGE, VALUE, WIDTH. Ha T egy diszkr et tpus es V:T egy valtozo, akkor

TFIRST a tpus els}o (legkisebb) erteke, TLAST a tpus utolso (legnagyobb) erteke, TPOS(V) a V ertek sorszama a tpusertekek k
oz
ott, IMAGE: T ;! STRING  es VALUE : STRING ;! T egy-egy konverzios f
uggveny (pl. INTEGERIMAGE(20)="20", COLORIMAGE(RED)="RED"). TWIDTH a TIMAGE(V) ertekek hosszainak maximuma. E rvenyesek az alabbi egyenletek : 18 Ada TPOS(TSUCC(v)) = TPOS(V) + 1 TPOS(TPRED(V)) = TPOS(V) ; 1 TVAL(TPOS(V)) = V TPOS(TVAL(k)) = k ( 0  k  TPOS(TLAST)) TSUCC(TPRED(V)) = V TVALUE(TIMAGE(V)) = V 4.4 Val
os t
pusok 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 nevezz
uk. A modellszamok csak a tpusdenciotol f
uggenek, 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 modellszam, modell intervallumnak nevezz
uk. Minden elmeleti valos szamhoz hozzarendelhet
unk egy modell intervallumot: azt a legkisebb modell intervallumot, ami a szamot tartalmazza. (A modellszamokhoz egy olyan intervallum 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 legkisebb es legnagyobb

matematikailag pontos eredmenyt, amit a operandus intervallumok ertekeire megkaphatunk. Ha az eredmeny
ul kapott modell intervallum valamelyik hatara abszolut ertekben nagyobb, mint a legnagyobb biztonsagos 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 k
onyvtar f
uggvenyeit (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.41 Lebeg}opontos t
pusok A lebeg}opontos szamok egy x hosszusagu mantisszabol, es egy ehhez tartozo el}ojeles egesz exponensb}ol allnak. Normalizalt formanak hvjuk azt az alakot, amikor a mantissza

egeszresze nulla, s az els}o tizedesjegy nullatol k
ul
onb
oz}o (eltekintve a 00 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 implementaciof
ugg}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 megadjuk a mantissza abrazolasahoz sz
ukseges decimalis jegyek szamat. Jel
olje ezt most D. A ltalaban a gepeken az abrazolas kettes szamrendszerben t
ortenik, a modellszamok mantisszajanak abrazolasahoz B bitre van sz
ukseg, ahol B = D  log(10)=log(2) + 1. A modellszamokra a kitev}o ertektartomanyat az Ada pontosan 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 10E20 ;; helyes X : MY FLOAT Z : MY FLOAT range ;1000.0 10000 type COEFFICIENT is digits 10 range ;1.0 10 type REAL is digits 8 type MASS is new REAL digits 7 range 0.0 10E10 Az egesz-lebeg}opontos ill. lebeg}opontos-egesz szamkonverziora a k
ovetkez}o ket f
uggvenyt hasznalhatjuk: FLOAT(integer value) INTEGER(oat value) ;; csonk tas a tortresz elhagyasaval A lebeg}opontos tpusok attributumai: TDIGITS ugyanaz a digits ertek, amit a t pus TMANTISSA TEPSILON TSMALL den ciojaban megadtunk a t pus ertekei mantisszajanak abrazolasahoz felhasznalt bitek szama az 1.0 es az azt kovet}o els}o modellszam elterese a t pus legkisebb pozit v modellszama 20 Ada TLARGE TEMAX a t pus legnagyobb modellszama a t pus legnagyobb (normalizalt) modellszamanak kitev}oje Az attributumokra ervenyesek az alabbi egyenletek: TEMAX = 4 * TMANTISSA

(den cio szerint) TEPSILON = 2.0 * (1 ; TMANTISSA) TSMALL = 2.0 * (;TEMAX ; 1) TLARGE = 2.0 * TEMAX (1.0 ; 20 * (;TMANTISSA)) 4.42 Fixpontos t
pusok <xed point constraint> ::= <xed accuracy denition>  <range constraint> ] <xed accuracy denition> ::= delta <static simple expression> Az Adaban nincs predenit xpontos tpus, de a programozo denialhat xpontos tpusokat. A xpontos szamokat x szamu szamjeggyel, es egy kepzeletbeli tizedesponttal abrazoljuk. Ha a t
ortresz k db jegyb}ol all, akkor a 10;k erteket az adott xpontos szamhoz tartozo delta-nak nevezz
uk. type MY FIXED is delta 0.01 range ;1000 1000 Ez a dencio azt jelenti, hogy a szamok ket tizedesjegyet tartalmaznak, gy a fenti tpus abrazolasahoz 1+7+7=15 bit sz
ukseges (7 bit az egeszresz, es 7 bit a t
ortresz abrazolasahoz). Mivel a szamtogepeken a szamok abrazolasa kettes szamrendszerben t
ortenik, 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 nevezz
uk DEL : constant := 1.0 / 2 * (WORD LENGTH ; 1) type FRAC is delta DEL range ;1.0 10 ; DEL ;; FRAC gy egy olyan t pus, ami egy egesz szot elfoglal type VOLT is delta 0.125 range 00 2550 subtype S VOLT is VOLT delta 0.5 A xpontos-integer konverziora a xpontos tpus neve hasznalhato konverzios f
uggvenykent. 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 00 10 A pontossag helyett small erteke 1/128 (= 0.0078) Ezert, ha pl a erteket a CENTS tpusba konvertaljuk, akkor ott a 0.046 erteket kap- 0.01 0.05 Tpusok 21 juk. Azert, hogy az ilyen hibakat

elker
ulj
uk, celszer}u reprezentacios el}orassal denialni a tpushoz a small erteket (ld 13): type CENTS is delta 0.01 range 00 10 for CENTSSMALL use 1.0 / 2 * (WORD LENGTH ; 1) A xpontos tpusok attributumai: TDELTA ugyanaz a delta ertek, amit a t pus TMANTISSA TSMALL TLARGE den ciojaban megadtunk a t pus ertekei mantisszajanak abrazolasahoz felhasznalt bitek szama a t pus legkisebb pontosan abrazolt pozit v erteke a t pus legnagyobb pontosan abrazolt erteke Az attributumokra ervenyes az alabbi egyenlet: TLARGE = (2 * TMANTISSA - 1) TSMALL 4.5 Tomb t
pusok A t
omb egy olyan
osszetett tpus, ami ket komponens tpusbol, az indextpusbol 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 t
ombnek t
obb 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 t
omb 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,00),(00,00)) Bar egy t
omb tpusban az indexhatarok lehetnek hatarozatlanok, egy objek- 22 Ada tum (valtozo vagy konstans) indexhatarai mar mindig hatarozottak kell legyenek. Egy hatarozatlan indexhataru t
omb tpusbol indexmegszortas megadasaval kepezhet
unk olyan altpust, amely mar alkalmas objektumok denialasara. Szerepelhet viszont meghatarozatlan meret}u t
omb alprogram formalis parameterekent (ld. a k
ovetkez}o peldat), ilyenkor az alprogram meghvasakor az aktualis parameter denialja az indexhatarokat procedure ADD TO(A:in VECTOR B:in out VECTOR) is begin ;; Feltetelezzuk, hogy ARANGE = BRANGE. for I in ARANGE loop B(I) := B(I) + A(I) end loop end ADD TO <indexed component> ::= <prex> ( <expression> f , <expression>g ) <slice> ::= <prex> ( <discrete range> ) A t
omb
ok 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. 47) es a function NEXT FRAME(K:POSITIVE) return FRAME f
uggvenydencio (ld. 61), akkor NEXT FRAME(L)(I,J) is szabalyos indexeles Tehat nemcsak a valtozok, hanem a t
omberteket visszaado f
uggvenyhivatkozasok 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. (Megjegyezz
uk, hogy V1(11) 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 ;; V4(0) := V1(0 . 4)(K);; szintaktikusan hibas helyes, ha 0  K  4 A t
omb
okre alkalmazhato az = es a /= relacio, tovabba tetsz}oleges diszkret 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 t
omb
okkel kapcsolatban hasznalhato attributumok a k
ovetkez}ok (itt X egy k-dimenzios t
omb, n egy statikus kifejezes) : XFIRST(n) XLAST(n) XLENGTH(n) XRANGE(n) az n. index kezd}oerteke az n. index vegerteke = XLAST(n) ; XFIRST(n) +1 = XFIRST(n) . XLAST(n) (n = 1 esetben n a zarojelekkel egy
utt elhagyhato.) A t
omb lehet u
res is, ekkor dencio szerint XLAST = XFIRST ; 1. <aggregate> ::= ( <component association> f , <component association>g ) <component association> ::=  <choice> f j <choice>g => ] <expression> A t
omb 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 k
otelez}o az ertekeket az indexek n
ovekv}o sorrendjeben megadni): A := (1 => 2, 2 j 3 j 4 => 4, others => 0) M := (1 => (1.1,12,13), 2 => (21,22,23)) M := (1 . 2 => (1 2 => 00)) : B : TABLAZAT := TABLAZAT(2 j 4 j 6 => 1, others => 0) C : constant MATRIX := (1 . 5 => (1 8 => 00)) X : BIT VECTOR(M . N) := (XRANGE => TRUE) Az others nem hasznalhato akkor, ha az aggregatum indexhatarait a k
ornyezete nem hatarozza meg egyertelm}uen. if X < (others => TRUE) then . ;; hibas! A STRING egy predenit vektor tpus a k
ovetkez}o dencioval: type STRING is array (POSITIVE range <>) of CHARACTER Helyesek a k
ovetkez}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) Veg
ul keszt
unk egy eljarast a STRING tpus hasznalatanak bemutatasara: 24 Ada procedure REVERSE STRING(S:in out STRING) is L: constant NATURAL := SFIRST U: constant NATURAL := SLAST 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 t
pus <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 k
ul
onb
oz}ok lehetnek. A rekordertekekben a komponensekre nevvel, un szelektorral hivatkozhatunk 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  COMPLEX end record type is record RE, IM : FLOAT := 0.0 end record D : DATUM := (4,JUL,1776) C1 : COMPLEX C2 : COMPLEX := (1.0,20) A rekord mez}oire a szokasos szelekcios jel
olessel hivatkozhatunk, tehat pl. . <selected component> ::= <prex> . <selector> <selector> ::= <simple name>j<character literal>j<operator symbol>j all D.EV 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. 74) type NAME is record VAL : STRING(1 . MAX SIZE) Tpusok SIZE: INTEGER end record range 0 . Az N1:NAME deklaracio

pillanataban az kezdeti ertek termeszetesen fel
ulrhato.) 25 MAX SIZE := 0 N1.SIZE komponens erteke 0 lesz. (A A rekord aggregatumokat | a t
omb 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 felsorolasanak sorrendje k
oz
omb
os 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.61 A rekord diszkrimin
ansai <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 t
omb tpus eseteben lehet}oseget ad parameteres tpus denialasara, megengedi a rekord tpusok parameterezeset is egy vagy t
obb parameterrel. A rekord tpus parameteret a rekord diszkriminansanak hvjuk A rekord diszkriminansa csak diszkret ertek lehet. Hasonloan a hatarozatlan indexhataru t
ombh
oz, a parameteres rekord tpus sem alkalmas k
ozvetlen
ul objektum (valtozo vagy konstans) denialasara, szerepeltethet}o viszont alprogram formalis parameterekent (ilyenkor az alprogram meghvasakor az aktualis objektum denialja a diszkriminans erteket). A rekordok eseteben azonban megis picit mas a helyzet, mint a t
omb
oknel lattuk, ui a rekord diszkriminansanak lehet default erteke (ilyenkor a rekord tpus mindegyik diszkriminansanak kell

hogy legyen default erteke) Abban az esetben, ha a rekord diszkriminansai default ertekkel rendelkeznek, a tpus megszortas megadasa nelk
ul is hasznalhato objektum-denialasra, mert ilyenkor a diszkriminans egyszer}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}uktj
uk le a 26 Ada tpust. A diszkriminanssal ellatott rekord alkalmazasat mutatja be a k
ovetkez}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 jelezz
uk 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 denialasakor 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 nelk
ul deklaralunk valtozot a LINE tpus felhasznalasaval (pl. L : LINE), akkor a fordt o 100 karakternek foglal le helyet. Ha megadjuk a megszortast, pl L : LINE(16), akkor csak az altpus szamara foglal le helyet, tehat itt most 16 karaktert 4.62 Vari
ans 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 tartalmazo rekord, ami unio tpus denialasara hasznalhato type DEVICE is (PRINTER, DISK, DRUM) type STATE is (OPEN, CLOSED) type PERIPHERAL(UNIT : DEVICE := PRINTER) is Tpusok record STATUS : STATE case UNIT is when PRINTER => LINE COUNT : INTEGER range 1 . when others => 27 PAGE SIZE 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 MARITAL STATUS MARRIED = SPOUSE NAME : NAME TYPE DIVORCED = DATE OF DIVORCE SINGLE =  WIDOWED = DATE OF DEATH : MMDDYY   case when when

when when end case end record is > > > null > Az esetmegjel
oleseket (when) statikus kifejezesekkel kell megadni. Ha intervallumot hasznalunk (pl A B), ez nem lehet u
res Minden szobaj
ohet}o erteket fel kell sorolni az esetmegjel
olesek k
oz
ott (vagy pedig az others lehet}oseget kell hasznalni.) Ha egy PERIPHERAL tpusu X objektumban UNIT = PRINTER, akkor XTRACK := 1 futas k
ozben hibajelzest (exception-t) valt ki A varians reszt tartalmazo, diszkriminanssal ellatott rekord tpus olyan rekordertekek halmaza, amelyek feleptese k
ul
onb
oz}o. Ugyanugy, ahogyan a diszkret tpusoknal az ertekkeszlet megszortasat hasznaljuk altpuskepzesre, a varians resz egy variansanak megk
otese szolgal a rekord tpus megszortasara. Pl a PERIPHERAL 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

jel
olt formaban). Tekints
uk a k
ovetkez}o peldat: X : PERIPHERAL C : PERIPHERAL(PRINTER) X most egy olyan rekord objektum, amely a UNIT diszkriminans aktualis erteket}ol 28 Ada f
ugg}oen mas-mas szerkezet}u ertekeket viselhet (ez futas k
ozben megvaltoztathato). C -ben param eterezessel r
ogztett
uk 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 megk
oveteli meg a k
ovetkez}oket: - tpusdencioban a diszkriminans csak indexmegszortaskent, a varians resz nevekent, vagy aktualis parameterkent hasznalhato. Minden esetben
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 k
uls}o tpus diszkriminansaitol f
ugghet. 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 t
pusok Valamely programegyseg vagy blokk deklaracios reszeben denialt objektum 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 hivatkozhatunk. 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 eptj
uk 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 nevezz
uk. 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 k
ovetkez}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 HEAD.PRED := NEXT HEAD. := NEXT.  ;; masolja a pointert ;; szabalyos all all ;; A HEAD pointer altal mutatott ;; teljes objektumra HEAD.all formaban hivatkozhatunk constant LINK := new CELL(0,null,null) C: Minden dinamikus objektum letrehozasa allokatorral t
ortenik. 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 valamely objektumra mutatnak

Megjegyezz
uk, hogy ebben az esetben a pointer 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 t
omb is. Ilyen esetben legkes}obb egy objektum allokalasakor meg kell adni a megszortast. Vagyis, miutan dinamikusan allokaltunk egy parameteres rekordot (pl varians reszt, vagy hatarozatlan hosszusagu t
omb
ot tartalmazo rekordot), futas k
ozben 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. 46) 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 denciojat tartalmazo programegyseg vagy blokk aktv. A tpus hatask
orenek elhagyasakor az Ada futtato rendszere a felszabadult ter
uletet ujrafelhasznalhatova teszi. (Ha az access tpust tulsagosan magas szinten, pl egy fordtasi egyseg specikacios reszeben denialjuk, akkor egy bels}o blokkban lokalis adatok eletben maradhatnak a blokkjuk megsz}unte utan is, bar ezek mar soha nem erhet}ok el) Az Adaban a dinamikus memoria meretet konstanskent r
ogztik. Mivel az Ada biztonsagosan es hatekonyan kvanja kezelni a

dinamikus adatokat, ezert nem tartalmaz explicit felszabadto utastast, hanem a felszabadtast a hatask
orrel hozza kapcsolatba type NODE type BRANCH is access NODE type NODE is record VALUE : INTEGER LEFT, RIGHT : BRANCH  SEARCH(R: BRANCH X: end record function in 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(RLEFT, 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 programhibakkal 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. Utas
t
asok <sequence of statements> ::= <statement> f<statement>g <statement> ::= f<label>g <simple statement> j f<label>g <compound statement> Az Ada programegysegek t
orzse 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
ert
ekad
as <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 rendelj
uk. <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. 74) valtozoktol eltekintve minden valtozora alkalmazhato. I,J : INTEGER range 1 .

10 K : INTEGER range 1 . 20 I := J K := J J := K ;; azonos tartomanyuak ;; osszeegyeztethet}o tartomanyuak ;; 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 t
omb
okre is alkalmazhato, ilyenkor a ket t
omb elemtpusanak es az elemszamnak meg kell egyeznie, az indexhatarok elterhetnek. A : STRING(1 . 31) B : STRING(3 . 33) A := B A(1 . 9) := "tar sauce" A(4 . 12) := A(1 9) ;; azonos elemszamuak ;; A(1 . 12) = "tartar sauce" ;; es nem A(1 . 12) = "tartartartar" ! 5.2 Az if utas
t
as <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 Modula2) 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.OWNERVEHICLE /= MY CAR then FAIL("Incorrect record") end if 5.3 A case utas
t
as <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 kifejezes minden lehetseges erteket fel kell sorolni a when agak k
oz
ott, es mindegyiket 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 utas
t
asok <loop statement> ::=  <loop simple name> : ]  <iteration scheme> ] loop <sequence of statements> 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 u
res tartomany eseten egyszer sem hajtja vegre a ciklusmagot): 34 Ada for I in 1 . loop MAX NUM ITEMS GET NEW ITEM(NEW ITEM) MERGE

ITEM(NEW ITEM.STORAGE FILE) NEW ITEM = TERMINAL.ITEM exit when end loop for J in reverse BUFFERRANGE 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 NEXT /=  SUM := SUM + NEXT.VALUE NEXT := NEXT.SUCC  while null loop end loop while BID(N).PRICE < CUT OFFPRICE loop RECORD BID(BID(N).PRICE) N := N + 1  end loop A harmadik forma egy feltetel nelk
uli ciklus, aminek a megszaktasat az exit utastassal erhetj
uk el (ld. 56) 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(A1I) 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 utas
t
as Blokkot kepezni az Ada programban nemcsak alprogram kialaktasaval, hanem 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 k
ovetkez}o helyzetekben hasznalhato el}ony
osen: - Ha egy nagy adatstrukturara van sz
ukseg a program egy r
ovid 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 := AFIRST M /= ALAST M := M + 1  while and then A(M) /= 0 loop end loop declare B:VECTOR(M) begin . end - Mar egy deklaracios resz nelk
uli blokkt
orzs is lehet}ove teszi, hogy a blokkban hibakezel}o programreszt (exception handler, ld. 8) helyezz
unk el begin A := C / B exception when OVERFLOW => A := INTEGERLAST when UNDERFLOW => A := INTEGERFIRST end A blokkban hasznalhatjuk annak lokalis azonostoit, es a blokkot magaba foglalo egysegben lathato azonostokat, mint globalis neveket. Ha nevazonossag fordul el}o, szelekcios jel
olessel (pl. XA) hivatkozhatunk a kvant objektumra KULSO: declare I,J:INTEGER begin 36 Ada ;; I,J:INTEGER kozvetlenul elerhet}o declare BELSO: I:MY INT begin end BELSO ;; end KULSO ;; I:MY INT es J:INTEGER kozvetlenul

elerhet}o, de ;; I:INTEGER csak KULSO.I alakban erhet}o el 5.6 Az exit utas
t
as <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 utas
t
as <return statement> ::= return  <expression> ]  A return utastas hatasara az alpogram vegrehajtasa befejez}odik. F
uggveny eseten a return utastasban adjuk meg a f
uggveny eredmenyet is. A f
uggveny eredmenyenek tpusara az Ada nem tesz megk
otest, gy az nemcsak skalar, hanem
osszetett tpus is lehet. 5.8 A goto utas
t
as <goto statement> ::= goto <label name>  A goto utastasra a nyelvben valojaban nincsen nagy sz
ukseg. Azert vettek

Utastasok 37 be az utastaskeszletbe, mert van olyan helyzet, amikor a kodot r
ovidebbe 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 n
ci
oja <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> ] begin <sequence of statements>  exception <exception handler> f<exception handler>g ] end  <designator> ]  Az Ada nyelv

ketfele alprogramot ismer: az eljarast es f
uggvenyt. Az alprogramok ket f}o reszb}ol allnak: a specikacios resz tartalmazza az alprogram parametereinek (es f
uggveny eseten az eredmenynek) a lerasat, a t
orzs tartalmazza az alprogram megvalostasat A t
orzs maga is ket reszre oszthato: a deklaracios resz tartalmazza az alprogram lokalis deklaracioit, a t
orzs utastasresze pedig 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 programsz
oveg tovabbi reszeben gy mar felhasznalhato az alprogram aktivizalasara. A t
orzs 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 rendszer ellen}orzesre fel tud hasznalni Ilyen megoldasokra mas nyelvekben vannak k serletek, azonban a kifejlesztett specikacios nyelvek tulsagosan primit vek A problema jo megoldasanak haszna oriasi lenne.) Pelda f
uggvenyre : 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 ARANGE loop SUM := SUM + A(I) * B(I) end loop return SUM end INNER A f
uggveny visszateresi erteke lehet akar t
omb vagy rekord is, s}ot, az
osszetett tpusu erteket visszaado f
uggvenyek hvasara alkalmazhatok a tpus tpusm}uveletei is. Tehat, ha pl F egy vektor ertek}u f
uggveny, 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 f
uggveny, 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 h
v
asa <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 f
uggvenyt gy hasznalhatjuk : declare P,Q : VECTOR(1 . 100) R:REAL begin . 40

Ada R := INNER(P,Q) .  end Parameterek nelk
uli f
uggvenyek eseteben az u
res parameterlistat jelkepez}o zarojelpart is elhagyjuk. Az Ada alprogramjai meghvhatjak
onmagukat is. Megengedett a k
ozvetlen rekurzio, s az is, hogy egy alprogram egy hvasi lancolaton kereszt
ul 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 (XRANGE(2)) of BOOLEAN := (others => FALSE) procedure THREAD(P:in REAL E:in INTEGER I:in INTEGER) is F : INTEGER begin if I > XLAST(1) then D := D + P * REAL((;1) E) elsif P /= 0.0 then F := 0 for J in reverse XRANGE(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 XLENGTH(1) /= XLENGTH(2) then raise MATRIX ERROR end if THREAD(1.0, 0, XFIRST(1)) return D end

DETERMINANT Az eljarashvas hagyomanyos formajaban az aktalis parameterek megfeleltetese a formalis parametereknek pozcio szerint t
ortenik: az els}o aktualis parametert megfeleltetj
uk az els}o formalis parameternek, a masodikat a masodiknak stb. ADD TO LIST (HEAD,3) Az Adaban ezen kv
ul (az eljaras- es a f
uggvenyhvasokban egyarant) hasznalhato meg a nevvel jel
olt forma is, ahol az aktualis parametert megel}ozi a formalis parameter neve: ADD TO LIST (L => HEAD, V => 3) Alprogramok 41 A nevvel jel
olt esetben az aktualis parameterek sorrendje tetsz}oleges. A parameterek megfeleltetesenek ketfele jel
olese keverhet}o is, de ekkor a pozicionalisan megadott parametereknek kell el
ol allniuk. ADD TO LIST (HEAD, V => 3) 6.3 Param
eter
atad
as 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 t
omb, 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 parameter (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 parameternek. Ha a formalis

parameter mell}ol a jelzest elhagyjuk, akkor a felteteltezes in. F
uggvenynek 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 t
ortenik 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 ker
ul az is, hogy az ertekek megfelelnek-e a megszortasoknak. Skalar tpusok eseten - a parameteratadas el}ott: az in es in out parametereknel ellen}orzesre ker
ul, hogy az ertekek eleget tesznek-e a formalis tpus megszortasanak - a parameterertekek visszaadasa el}ott: az in out es out parametereknel ellen}orzesre ker
ul, 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 komponensenek 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 vektorral valo reprezentalasakor a vektor egyes elemei kezdetben nem rendelkeznek ertekkel, akkor latjuk, hogy az Ada szigoru ellen}orzesi mechanizmusa milyen konnyen lehet kellemetlen is) A pointerek es a skalar ertekek atadasakor az Ada el}orja, hogy minden nyelvi implementacio ugy k
oteles 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 szerinti es a cm szerinti parameteratadas k
oz
otti 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 form
alis param
eterek default
ert
eke Az Ada erdekes lehet}osege, hogy az in modu parametereknek feltetelezett bemen}o erteke lehet. Az alprogram specikacios resze tartalmazza ezt a feltetelezett erteket, amit akkor vesz fel a formalis parameter, ha neki megfelel}o aktualis parametert 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 ennek 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 parametere 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 k
ovetkez}o formaban hvhatjuk: DRY MARTINI ( VODKA,WITH => TWIST ) DRY MARTINI ( HOW => STRAIGHT UP ) DRY MARTINI 6.5 Alprogramok
atlapol
asa Korabban mar lattuk, hogy a felsorolasi tpusok konstansai atlapolhatok, azaz t
obb tpusnak is lehet ugyanolyan nev}u erteke. Ekkor egy ilyen literal eseten az,

hogy melyik tpus erteker}ol van szo, a sz
ovegk
ornyezetb}ol derthet}o ki. Az alprogramok eseteben hasonlo dologra van lehet}oseg. E rvenyben lehet egyszerre pl. a k
ovetkez}o harom alprogram : procedure SET(EZ A NAP:in NAP) procedure SET(S:in SZIN) procedure SET(A:in ALLAPOT) Ekkor k
ul
onb
oz}o alprogramok aktivizalasat jelentik a SET(HETFO) ill. a SET(PIROS) elj arashvasok. Ha pl PIROS maga is atlapolt konstans, akkor min}ostest kell alkalmaznunk, es az utastast gy kell rni : SET(SZIN(PIROS)) Ezekutan meg kell hataroznunk, hogy ket alprogramspecikacio mikor egyezik meg, ill. mikor k
ul
onb
oznek Ket alprogramspecikacio akkor egyezik meg, ha azok ugyanazokat a szintaktikus elemeket ugyanolyan sorrendben tartalmazzak, amennyiben azonban a specikaciok szamokat is tartalmaznak, azok ertekenek (es nem az rasformajuknak) kell megegyezni Tehat az alabbi ket P eljaras specikacioja megegyezik, a ket Q eljarase k
ul
onb
ozik:

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 oper
atorok
atlapol
asa Az alprogramok neve lehet azonosto, mint korabban is lattuk, de felhasznalhatjuk a nyelv operatorait is f
uggvenyeink nevekent. Peldaul denialhatjuk a vektorok k
oz
otti szorzast a "*" nevvel: function "*"(A,B:VECTOR) return REAL is . end "*" Ez a "*" m}uvelet atlapolasat jelenti. Ezutan a vektorok k
oz
otti szorzast R := P * Q alakban rhatjuk. (Az eg eszek, valosak, stb. k
oz
otti szorzas m}uveleti jele tovabbra is a "*" marad.) Ha a "*" szerepel valahol a programban, es nem volna egyertelm}u, hogy melyik "*" f
uggvenyr}ol van szo, akkor a fenti ertekadas min}ostessel rhato: R := VECTOR(P) * VECTOR(Q) Egy masik, teljesebb peldat is mutatunk. Tf denialtuk a k
ovetkez}o tpust : type IRANY is

(E,EK,K,DK,D,DNY,NY,ENY) A relacios operatorok (=, /=, <, <=, >, >=, in, not in) es a diszkret tpus attributumai automatikusan biztostottak a tpus szamara. Ha tovabbi m}uveletekre is sz
ukseg
unk van, azoknak a programjait magunknak kell megrnunk. Tf sz
ukseg
unk van egy additv m}uveletre, ahol D + M azt az iranyt jelenti, amit ugy kapunk, hogy D -hez hozzaadunk M nyolcadot az ora jarasanak megfelel}o iranyban. Ez a m}uvelet gy denialhato : function "+"(D:IRANY M:INTEGER) return IRANY is begin return IRANYVAL((IRANYPOS(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 kommutativitas| megtartani, e celbol el kell kesz teni a function "+"(M:INTEGER D:IRANY) return IRANY is . fuggvenyt is.) Ket megk
otes ervenyes az

operatorok atlapolasara. El}osz
or: 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 P
eldaprogramok i) N
egyzetgyokvon
as Ez a pelda azt mutatja be, hogy az Adaban altpusok bevezetesevel egyszer}usthet}o az el}ofeltetel ellen}orzese. subtype NON NEGATIVE REAL is FLOAT range 0.0 FLOATLAST subtype POSITIVE REAL is FLOAT range FLOATSMALL . FLOATLAST 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)  NEW VALUE SQRT end loop return end ii) Makrohelyettes
t
esek Egy olyan

programot keszt
unk, ami egy text-le-t dolgoz fel: felismeri benne a makrodenciokat, s a makrohvasokat kicsereli a makro t
orzsere. A makrodencio formaja: #dene makronev makrotorzs. A #dene sz
oveg mindig a sor elejen kezd}odik. A makronev bet}ukb}ol es szamjegyekb}ol allo azonosto, a makrot
orzs egy szok
oz
oket nem tartalmazo tetsz}oleges string Egy makro hvasa a denciojat k
ovet}oen barhol el}ofordulhat, kiveve a makrodencios sorokat. A denialt neveket egy egyszer}u tablazatban, egy vektorban (TT, NT) tartjuk nyilvan. Az Ada vektorm}uveletek kihasznasaval (ANALYSE) nagyon r
oviden kodolhato a makroneveknek a makrot
orzsekre valo kicserelese egy-egy soron bel
ul (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 := STRFIRST I0 : INTEGER procedure LEVALASZT is begin while I <= STRLAST and then STR(I) = loop I := I + 1 end loop I0 := I while I <= STRLAST and then STR(I) /= loop I := I + 1 end loop end LEVALASZT begin NT := NT + 1 LEVALASZT TT(NT).N := LEVALASZT TT(NT).E := ENTER new STRING(STR(I0 . I ; 1)) new STRING(STR(I0 . I ; 1)) end 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).Nall

= STR then return I end if end loop return ;1 end FIND function ANALYSE(STR : STRING) return STRING is ;; Feladata: egy szovegsorban ;; a makrotorzsekre. a makronevek kicser el ese I : INTEGER := STRFIRST I0 : INTEGER K : INTEGER ALPHA(CH:CHARACTER) function 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 STRLENGTH = 0 then return "" end if while I <= STRLAST and then not ALPHA(STR(I)) loop I := I + 1 end loop I0 := I while I <= STRLAST and then ALNUM(STR(I)) loop I := I + 1 end loop ;; I0 az STR stringben az elso} betu} indexe, ;; vagy I0 = STRLAST + 1. ;; I az I0 indexen kezdo}do} azonosto ;; utani pozcio indexe, vagy I = STRLAST + 1. K := FIND(STR(I0 . I ; 1)) K TTRANGE STR(STRFIRST . I0 ; 1) & TT(K)E &

ANALYSE(STR(I . STRLAST)) if in then return else return STR(STRFIRST . I ; 1) & ANALYSE(STR(I . STRLAST)) 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)) END OF FILE(F) GET LINE(F, LINE, N) LINE(1 . 7) = "#define" ENTER(LINE(8 . N)) while not loop if then else PUT LINE(G, ANALYSE(LINE(1 . end if end loop end CLOSE(G) CLOSE(F) PREPROCESSZOR N))) all 48 Ada 7. A package A package fordtasi egysegkent is szerepeltethet}o programegyseg, es mint ilyen a program feldarabolasanak egyik f}o eszk
oze. 7.1 A package speci k
aci
oja <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 t
orzsb}ol. Az el}oz}o rja le az exportalt informaciok jellemz}oit, az utobbi tartalmazza (es egyben elrejti) a megvalostast. (A specikacios resz lathato reszeben megadott
osszes informacio exportalasra ker
ul) Specialisan el}ofordulhat az is, hogy a package-nek csak specikacios resze van, t
orzse nincs (pl. ha a specikacios resz csak valtozokat tartalmaz, es ezek mint k
oz
os adatmez}o hasznalatosak). Ha a package specikacioja tartalmazza valamely programegyseg specikaciojat, akkor a programegyseg t
orzsenek a package-t
orzsben 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  <declarative part> ]  begin <sequence of statements>  exception <exception handler> f<exception handler>g ] ] end  <package simple name> ]  A package t
orzse

tartalmazza a specikacios reszben felsorolt programegysegek t
orzseit, tartalmazhat lokalis deklaraciokat, valamint tartalmazhat egy inicializalo reszt. A k
ozvetlen
ul a t
orzsben denialt objektumok a package t
orzsenek kiertekelesekor j
onnek letre, s a package-et tartalmazo egysegb}ol valo kilepeskor sz}unnek meg. Ugyancsak a package t
orzsenek kiertekelesekor hajtodik vegre a package inicializalo resze. K
onyvtari szint}u package eseten a t
orzs kiertekelesere a f}oprogram vegrehajtasanak megkezdese el}ott, beagyazott package eseten a tartalmazo deklaracios resz kiertekelesekor ker
ul sor. A package 49 A t
orzsben k
ozvetlen
ul hivatkozhatunk a t
orzsh
oz 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 packageen kv
ulr}ol nem erhet}ok el 7.3 A private t
pus A package-k egy fontos alkalmazasi ter
ulete a privat tpusok kialaktasa. <private type declaration> ::= type <identier>  <discriminant part> ] is  limited ] private  <deferred constant declaration> ::= <identier list> : constant <type mark>  A k
ovetkez}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 t
orzseben lathato, kv
ulr}ol nem A privat reszban adjuk meg a privat tpusok denciojat. (Megjegyzes. A package-n k vuli utas tasokban nem hivatkozhatunk a privat reszban elrejtett 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 olvassa 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 foglalhat el, mint a WORD t pus.) A privat tpus is parameterezhet}o. Pl a korabban is hasznalt dencioja

gy rhato fel : type TEXT(MAX:NATURAL) is private TEXT tpus Ekkor a privat reszben a tpus implementaciojanak is kell tartalmaznia ugyanezt a parametert. A k
ovetkez}o peldaban dinamikus t
omb
ot 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 k
ovetkez}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,10) A COMPLEX NUMBERS package t
orzse pl. ez lehet : package body COMPLEX NUMBERS is function "+"(X,Y:COMPLEX) return COMPLEX is begin return (X.RL + YRL, XIM + YIM) end "+" function

";"(X,Y:COMPLEX) return COMPLEX is begin A package 51 return (X.RL ; YRL, XIM ; YIM) end ";" function "*"(X,Y:COMPLEX) return COMPLEX is begin return (X.RL * Y.RL ; XIM * Y.IM, X.RL * Y.IM + XIM * Y.RL) end "*" function "/"(X,Y:COMPLEX) return COMPLEX is B : REAL := Y.RL * 2 + Y.IM * 2 begin return ((X.RL * Y.RL + XIM * Y.IM) / B, (X.IM * Y.RL ; XRL * 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 kicserelj
uk polarkoordinatas alakra, a package-re hivatkozo egysegben semmit sem kell valtoztatni. A COMPLEX NUMBERS package a k
ovetkez}o modon hasznalhato fel: declare use COMPLEX NUMBERS Z : constant COMLEX := CONS(0.0,00) C,D:COMPLEX R,S:REAL begin C :=

CONS(1.5, ;06) D := C + I ;; COMPLEX + R := RL PART(D) + 6.0;; REAL +  end (Figyelj
uk 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, amiket 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 t
orzseben termeszetesen hasznalhato a privat tpus reprezentaciojabol adodo minden tpusm}uvelet. 52 Ada 7.4 A limited private t
pus A privat tpusokra az ertekadas es az =, /= relaciok ugyanugy alkalmazhatok, mint mas tpusok eseteben. Ez nem mindig el}ony
os (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 alkalmazhatok. A limited private valtozokra vonatkozo szabalyok: - a limited private valtozo nem kaphat kezd}oerteket (a package-en kv
ul), - a limited private tpus parametereinek nem lehet kezd}oerteke, - a package-n kv
ul nem denialhato limited private konstans. Peldakent a limited private tpusra tekints
uk meg a k
ovetkez}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 P
eldaprogramok i) V
eletlensz
amok el}o
all
t
asa A package a nyelv legalkalmasabb eszk
oze

absztrakt fogalmak megvalostasara. Nem a tpusmegvalostas az egyetlen ter
ulet, ahol ilyen celra alkalmazhatjuk a package-t Ebben a pontban egy masfajta absztrakt fogalom implementalasara 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 RANDOM FLOAT function return 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 megval
os
t
asa Az ORDERED SET package egy olyan halmazt valost meg, amelynek elemeit az ID diszkret tpus ertekeivel, mint kulcsokkal azonostjuk, s ezekhez a kulcsokhoz DURATION tpusu ertekekkel megadott id}otartamok tartoznak. A SMALLEST alprogramot f
uggvenykent megvalostani nem volna szerencses, ennek ugyanis mellekhatasa van: azon

kv
ul, 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  ures. T : DURATION := DURATIONLAST 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 k
ovetkez}o peldaban mutatunk a heap tpusra. iii) A heap t
pus megval
os
t
asa 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 k
onnyen elerhet}o, de egy elem behelyezese vagy t
orlese is keves m}uveletet igenyel. A heapet egy h(1SIZE) vektorral es egy n egesszel abrazoljuk n a sorozat

hossza es n
res heap-et, a sorozatot pedig a h(1), ., h(n) elemekkel fejezz
uk = 0 jelenti az u ki. A reprezentaciohoz hozzarendelt invarians: 81  i  n2 : hi  max(h2i h2i+1) Ez a vektorral valo abrazolas megfelel a heap egy kiegyensulyozott rendezett binaris faval valo abrazolasanak. Az invarians most azt jelenti, hogy minden reszfaban a gy
oker a legnagyobb elem Igy a sorozat legnagyobb elemet mindig h(1) abrazolja, annak kivetelekor pedig h(2) vagy h(3), ezek helyere pedig a "bel}ol
uk lelogo" elemek egyike "csuszik el}ore", st Egy elem behelyezesenek vagy t
orlesenek k
oltsege 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 PUSH (H : HEAP X : INTEGER) TOP (H : HEAP) INTEGER POP (H : HEAP) EMPTY (H : HEAP) BOOLEAN procedure in out in function return procedure in out function return private type

VECTOR is array (INTEGER range) <>) of INTEGER type HEAP(SIZE : NATURAL := 128) is record N : NATURAL := 0 H : VECTOR(1 . SIZE)  HEAP TYPE end record end package body HEAP TYPE is procedure PUSH (H : in out HEAP X : in INTEGER) is I, J : NATURAL SWAP : BOOLEAN begin if H.N = HSIZE then raise HEAP FULL end if H.N := HN + 1 J := HN SWAP := TRUE while SWAP and then J >= 2 loop I := J J := J / 2 if X > H.H(J) then H.H(I) := HH(J) else SWAP := FALSE end if end loop if SWAP then H.H(J) := X else HH(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(HN) HN := HN ; 1 J := 1 SWAP := TRUE SWAP 2*J = H.N I := J J := 2 * J J H.N H.H(J+1) H.H(J) J := J + 1  TMP H.H(J) H.H(I) := HH(J) SWAP := FALSE   SWAP H.H(J) := TMP H.H(I) :=

TMP while and then if < and then then end if if < then else end if end loop if then < loop > else 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. Hibakezel
es, kiv
etelkezel
es 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 t
orzsenek vegen a programozo utastasokat (un. exception handler) helyezhet el a kivetelek lekezelesere begin

;; utas tassorozat exception when ADAT HIBA => ;; a hibat lekezel}o utas tasok end Ha a t
orzs egy utastasanal fellep valamilyen vegrehajtasi hiba, kivetel, akkor a vezerles atadodik a blokk vegen lev}o kivetelkezel}o resznek. Ez egy case-szer}u szerkezet, 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 k
ovetkez}ok: ep fel, ha megszortas megsertese (pl. egy CONSTRAINT ERROR | akkor l valtozo olyan erteket kap, ami kv
ul esik a tpusertekhalmazan), indexhiba, diszkriminans megsertese, vagy null ertek}u pointer felhasznalasa k
ovetkezik 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 generic

aktivizalasara t
ortenik kserlet, aminek a t
orzse meg nincs kiertekelve, ha a f
uggveny vegrehajtasa befejez}od
ott, de nem hajtodott vegre return utastas, vagy ha egy szelektv varakoztatas (ld. 12 71) minden 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
oz
otti 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 bek
ovetkezesekor a futtato rendszerben a kivetelkezel}o kivalasztasa attol f
ugg, 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 kezdemenyez}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 k
ozben k
ovetkezik be hiba, akkor a blokk vegrehajtasa befejez}odik, es a kivetel a a blokk vegrehajtasat kezdemenyez}o egysegben lep fel. (Ha egy alprogram hibaval ter vissza, akkor az nem ad vissza erteket az

out es in out modu parametereiben) A kivetelt haromfele modon hasznalhatjuk. El}osz
or. Hasznalni lehet egyszer}u modon hibajelzesek adasara: ha a program adathibat eszlel, vegrehajt egy raise utastast, es ezzel jelzi az }ot 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 t
obbe-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 A eljarasban le kell zarni a le-t, es a hibat tovabb kell adni az eljarasnak. (A parameter nelk
uli raise utastas hatasara a lekezelt kivetel ujra fellep.) PROCESS FILE ANALYSE A kivetel lekezelesenek ez a fejlett rendszere biztostja, hogy nagy megbzhatosagu software rendszereket keszthess
unk 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 P
eldaprogramok i) Verem objektum megval
os
t
asa Absztrakt objektumok vagy tpusok megvalostasakor a legt
obb korabbi nyelvben komoly gondot okoz az objektum kezelesevel kapcsolatos hibak jelzese es kezelese. A ltalaban az egyetlen hasznalhato megoldas az, hogy a tpusm}uveleteket kiegesztj
uk 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, siker
ult-e a m}uvelet vegrehajtasa. Mindez azert kellemetlen, mert csak nagyon ritkan, vagy soha el}nem ofordulo helyzetek kezelesere kell nem keves energiat fordtanunk Az Ada altal bevezetett hibakezeles megfelel}o megoldas ennek a problemanak a kezelesere package STACK is ERROR : exception procedure PUSH(X:in REAL) function POP return REAL end STACK 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 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. L
athat
os
agi szab
alyok A deklaracio egy azonostonak es egy egyednek az
osszekapcsolasa. A deklaracio hataskore a

programsz
ovegnek az szakasza, ahol az azonostoval a deklaralt egyedre hivatkozhatunk Kozvetlen hataskornek hvjuk a sz
ovegnek azt a szakaszat, amely a deklaracio pontjatol a deklaralo egyseg vegeig tart Nemely esetben a hatask
or nagyobb a k
ozvetlen hatask
ornel, kiterjed a deklaraciot tartalmazo 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 sz
oveg egy adott helyen egy azonosto jelenteset a lathatosagi es az atlapolasi szabalyok hatarozzak meg. Az Adaban egy deklaracio a hatask
oren bel
ul minden
utt lathato, ez a lathatosag azonban lehet kozvetlen vagy lehet szelekcios lathatosag. Pl a package-ben denialt eljarasra a package-n kv
ul szelekcios formaban (PACKAGEELJARAS) hivatkozhatunk, es ugyanez a

helyzet a rekord komponenseivel is Az Adaban, mint minden ALGOL-szer}u nyelvben, a programegysegek egymasbaagyazhatok. Ezt a szerkezetet blokkstrukturanak nevezz
uk Egy beagyazott blokk szempontjabol a k
uls}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, PC, QA ;; globalis nevek: P, P.A, PB, PC, Q, QA, QC ;; 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, PC ;; globalis nevek: P, P.A, PB, PC ;; 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, PB, PC, 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 programsz
oveg egy adott pontjan egy azonostohoz t
obb egyed is tartozhat, azaz ugyanaz az azonosto t
obb k
ozvetlen
ul lathato deklaraciora is hivatkozhat. Ezt az azonostok atlapolasanak nevezz
uk Az Adaban atlapolhatok a felsorolasi konstansok nevei es az alprogramok nevei Ilyenkor az azonosto k
ornyezete (pl. a parameterlista) alapjan csak egyetlen olyan deklaracio lehet, ami minden szempontbol megfelel a hivatkozasnak, k
ul
onben a hivatkozas szintaktikus hibat jelent. 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 hivatkozast: 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) nevezz
uk azt az esetet, ha egy ervenyes deklaracio hatask
oreben egy bels}o blokkban ugyanahhoz az azonostohoz egy masik egyedet rendel
unk. A kv
ul deklaralt egyedre ilyenkor csak szelekcios jel
olessel hivatkozhatunk procedure P is A,B:BOOLEAN procedure Q is C:BOOLEAN B:BOOLEAN begin Lathatosagi szabalyok 63 B := A ;; Q.B := PA C := P.B;; QC := PB Q end begin A:=B end P ;; P.A := PB 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 utas
t
as <use clause> ::= use <package simple name> f ,

<package simple name>g  A use utastas a szelekcios hivatkozas ler
ovidtesere 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 DT), ;; U jelentese D.U, ;; B jelentese E.B, ;; W jelentese E.W, ;; X jelentese Q.X, ;; V illegalis, D.V vagy EV alakban kell V-re hivatkozni end Q begin . end P 9.2 Az
atnevez
es Lehetseges az eddig felsoroltakon kv
ul meg egy masik hivatkozasi mod is: atnevezhetj
uk 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 COLORSUCC 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 sz
oveg r
ovidtesere, a nevek k
oz
otti konfliktusok feloldasara es a vegrehajtasi id}o cs
okkentesere. L : INTEGER renames D.EV AI : REAL renames A(I) Ezutan az AI := AI + 1 forma hasznalataval elker
ulj
uk az indexkifejezes t
obbsz
ori kiszamtasat. (Ha I erteke a programban megvaltozik, azert az AI tovabbra is a korabbi valtozot jelenti.) Programstruktura 65 10. Programstrukt
ura A fordtasi egysegek ketfelek: un. k
onyvtari egysegek (alprogram, package vagy generic specikacioja, generic peldanyostasa (ld. 112), alprogram t
orzse) vagy masodlagos egysegek (k
onyvtari egyseg t
orzse vagy

alegyseg, ld. 101) A k
onyvtari egysegek nevei k
ul
onb
oz}ok kell legyenek. Ada f}oprogram olyan k
onyvtari 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 k
oz
ott k
ul
onfele kapcsolatok lehetnek (egy egyseg importalhat egy masikbol, specikacio-t
orzs kapcsolat, t
orzs-alegyseg kapcsolat), egy egyseg

fordtasakor a fordtoprogramnak sz
uksege van a hivatkozott egysegekben denialt bizonyos informaciokra. Ezert a lefordtott egysegek az un. Ada k
onyvtarba ker
ulnek, ahol az egysegek object kodjan kv
ul meg}orzesre ker
ulnek a sz
ukseges szimboltablak is. A k
onyvtar nyilvantartja az egysegek k
oz
otti kapcsolatokat is. Ha egy egyseg fordtasakor a fordtoprogram hibat eszlel, akkor az egyseg nem ker
ul be a k
onyvtarba. Ha olyan egyseget fordtunk, ami mar szerepel a k
onyvtarban, akkor az uj egyseg a regi helyere ker
ul, s ervenytelenne valik a k
onyvtarban minden olyan egyseg, ami az uj egysegt}ol f
ugg. Az ervenytelenne valt egysegek a k
onyvtaron bel
ul ujrafordthatok (tehat anelk
ul, hogy egy fordtassal bevinnenk a k
onyvtarba, azaz a fordtas es az ujrafordtas ket k
ul
on m}uvelet). Az egysegek fordtasi sorrendjere vonatkozo szabalyok teljesen megegyeznek a Modula-2 szabalyaival. Egy programegyseg akkor

fordthato, ha azoknak az egysegeknek a specikacios resze, amelyekre ez hivatkozik, mar le vannak fordtva A package specikacioja es t
orzse egy-egy
onallo egyseg, es ezek k
oz
ul a specikaciot kell el}obb fordtani. Ha egy egyseg csak a specikaciotol f
ugg, akkor a t
orzs megvaltoztatasa miatt ezt az egyseget nem kell ujra lefordtani (Az alegysegekre vonatkozo szabalyokat ld a 101 pontban) A k
onyvtarban vannak a predenit Ada egysegek moduljai. Ilyenek az inputoutput modulok (ld 15), a CALENDAR modul (ld 126) es a rendszerf
ugg}o informaciokat tartalmazo modulok (SYSTEM, UNCHECKED CONVERSION, UNCHEC- 66 Ada , KED DEALLOCATION MACHINE CODE stb.) A k
onyvtari rendszer biztostja, hogy a f
uggetlen
ul fordtott egysegek kapcsolata 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 exportalt
osszes deklaraciot lathatova teszi A megnevezett package-ben denialt nevekre ezutan packagenev formaban hivatkozhatunk Hogy ezt a hosszadalmas format elker
ulj
uk, a with utastas utan szinte mindig alkalmazunk egy use utastast is, ami k
ozvetlen
ul lathatova teszi a package exportalt neveit. (Ha ilyen modon t
obb package-b}ol is importaltuk ugyanazt az azonostot, az nem hiba, majd az azonosto hasznalatakor kell

egyertelm}uve tenni, hogy melyikre hivatkozunk.) (Megjegyzes. A programkesz tes szempontjabol hasznos lenne, ha importalaskor valamikeppen el lehetne hagyni a programbol az importalt modulnak a felesleges alprogramjait Pl kellemetlen, hogy ha a programozo egy olyan fajta keszletet hasznal, mint a matematikai fuggvenyek modulja, akkor annak minden alprogramja hozzaszerkeszt}odik a programhoz, 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 D 0.0 PUT("Imaginary Roots.") if < else then PUT("Real Roots : X1 = ") PUT((;B ; SQRT(D)) / (2.0 * A)) PUT(" X2 = ") PUT((;B + SQRT(D)) / (2.0 * A))  NEW LINE QUADRATIC EQUATION end if end Tekints
uk a k
ovetkez}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 k
ovetkez}okeppen valaszthatjuk szet
onallo programegysegekre: 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 Alegys
egek <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 t
orzset kiemelhetj
uk a package-b}ol, es
onallo fordtasi egyseget, un. alegyseget kepezhet
unk A package-ben az alegyseg t
orzsenek helyen egy csonk marad Peldaul a STACK package t
orzset a k
ovetkez}okeppen is rhatjuk : package body STACK is MAX : constant := 100 S : array (1 . MAX) of REAL 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 k
ul
on fordthato, ezek formaja a k
ovetkez}o: separate STACK procedure PUSH(X:in REAL) is begin PTR := PTR + 1 S(PTR) := X PUSH end separate STACK procedure POP return REAL is begin PTR := PTR ; 1 return S(PTR + 1) end POP Egy alegysegben a hatask
or es a lathatosag

pontosan olyan, mintha az alegyseg a csonk helyen lenne. Tehat pl az alegysegben minden k
ul
on jel
oles nelk
ul hivatkozhatunk olyan tpusokra es globalis valtozokra, amelyek a sz
ul}oben vannak denialva. Egy alegysegb}ol szinten el lehet k
ul
onteni valamely beagyazott programegyseg t
orzset, azaz alegysegnek szinten lehet alegysege. Az alegysegek fordtasi sorrendjere az a szabaly, hogy egy alegyseg csak akkor fordthato le, ha mar lefordtottuk azt az egyseget, amelyb}ol az alegyseg szarmazik. Ha egy t
orzset 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 sz
ul}ok lancolatan visszafele haladva egy olyan egyseghez jutunk, ami mar nem alegyseg, hanem valodi t
orzs. Ezt a t
orzset az alegyseg }osenek nevezz
uk Nem egyezhet meg ket olyan alegysegnek a neve, amelyeknek k
oz
os

}os
uk van. 10.2 P
eldaprogramok i) Priorit
asi sorok Ebben a peldaban t
obb package felhasznalasaval ept
unk fel egy absztrakt objektumot. Tekints
unk egy olyan operacios rendszert, amelyben a jobok 1 es 10 k
oz
otti prioritasokkal vannak ellatva. A jobok kezeleset a PRIORITY QUEUES package-el kepzelj
uk 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 elkesztj
uk 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  FIFO end record end 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(QLAST) := J Q.LAST := QLAST mod QXLENGTH + 1 Q.CUR SIZE := QCUR 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(QFIRST) Q.FIRST := QFIRST mod QXLENGTH + 1 Q.CUR SIZE := QCUR SIZE ; 1 end FIRST function FULL(Q : QUEUE) return BOOLEAN is begin return Q.CUR SIZE = QXLENGTH end FULL function EMPTY(Q : QUEUE) return BOOLEAN is begin return Q.CUR SIZE = 0 end EMPTY end FIFO A PRIORITY QUEUES package t
orzse most mar minden nehezseg nelk
ul 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 k
esz
t
ese Ebben a pontban egy Ada nyelv}u programokrol keresztreferencia listat nyomtato programot keszt
unk. A program nevsor szerint felsorolja az Ada programban szerepl}o azonostokat, s mindegyikr}ol megadja, hogy mely sorokban fordul el}o. A megjegyzeseket, sz
ovegliteralokat es az alapszavakat a program nem veszi gyelembe. A program ket reszb}ol all: egy scanner-b}ol, ami az input sz
oveget "megvalogatja", kihagyja bel}ole a feladat szempontjabol erdektelen reszeket, es egy tablakezel}ob}ol, ami nyilvantartja az azonostokat es a sorszamokat, valamint nyomtatni tudja ezt a tablazatot. Az elemz}o reszt a f}omodul foglalja magaba, el}osz
or ezt adjuk meg. A f}omodul hivatkozik a tablakezel}o package-re, aminek a specikacios resze a k
ovetkez}o : with TEXT IO use TEXT IO 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  STRING PTR STRING WORD TABLE WORD WORD KEY : STRING PTR FIRST : LIST PTR LEFT, RIGHT : TABLE  end record type is access type type is access type is record end record 72 Ada end TABLE HANDLER A f}omodul a tablazatkezel}o modulon kv
ul 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") ) constant CHARACTER) := ASCII.NUL procedure READ(CH:out CHARACTER) is EOFCH : Programstruktura 73 ;; Egyszeres elo}reolvasas 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 OF FILE(F) CH := EOFCH END OF LINE(F) SKIP LINE(F) CH := ASCII.CR FIRST CH IN CUR LINE := TRUE end if if elsif then then else GET(F, CH) end if end READ function IS KEY(NAME : STRING) return BOOLEAN is begin for I in KEYSRANGE 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) CH /= EOFCH IS ALPHA(CH) K := 0 CH = IS ALNUM(CH) K := K + 1 ID(K) := CH READ(CH)  IS KEY(ID(1 . K)) while if while end loop if not loop then or else loop 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 end TABULATE(G, T) CLOSE(F) CLOSE(G) 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 t
obbi modul el
ol. A tablazatot most igenyesebben abrazoljuk, mint az el}oz}o peldaban: rendezett binaris fat ept
unk. A SEARCH eljaras jo peldat mutat egy ilyen faban valo keresesre, a TRAVERSE TREE eljaras pedig egy rekurzv alprogram a fa bejarasara. with TEXT IO use TEXT IO 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.KEYall if NAME = PP.KEYall 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 PPRIGHT := Q end if return Q Programstruktura end SEARCH procedure ENTER(T:in TABLE NAME:in STRING N:in INTEGER) is P : TABLE Q : LIST PTR i : NATURAL I := 0 P := SEARCH(T, NAME) Q := ITEM(N, P.FIRST) P.FIRST := Q ENTER begin new end 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 PUT(F, P.KEY ) P.KEYLENGTH = L PUT(F, (1 . L ; PKEYLENGTH = begin all if < then > )) 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  NEW LINE(F) PRINT ITEM end loop end 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) 

TRAVERSE TREE end if end procedure TABULATE(F:in FILE TYPE T:in TABLE) is begin NEW LINE(F) TRAVERSE TREE(F, T.RIGHT) end TABULATE end TABLE HANDLER 75 76 Ada 11. Generic Lenyeges, hogy a k
onyvtari eljarasokat eleg altalanosan meg lehessen rni, es azokat szeles k
orben, 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 alprogramokat es a package-ket tpusokkal es alprogramokkal parameterezz
uk, s ezzel az altalanossag n
ovelhet}o. A generic nem k
ozvetlen
ul vegrehajthato programegyseg, hanem egy sablon, amivel vegrehajthato egyedek hozhatok letre. A generic-b}ol egy vegrehajthato egyed letrehozasat peldanyostasnak (instantiation) nevezz
uk. 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 deklar
aci
oja <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 ] ] <type mark>  := <expression> ]  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 alprogramot es package-t, csak a specikacio ele ker
ul a generic alapszo a generic parametereinek felsorolasaval. A generic szintaktikus elemzese a generic denialasakor megt
ortenik, de a kiertekelesere csak peldanyostaskor ker
ul sor (ez fontos a k
onyvtarak eseteben). A generic programegyseget minden
utt elhelyezhetj
uk, ahol egyszer}u programegyseg allhat. (Igy pl a generic fordtasi egyseg is lehet) A generic k
onyvtari egysegre ugyanugy with-tel kell hivatkozni, mint mas k
onyvtari egysegre (a usenak 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 package body STACK is S : array (1 . MAX) of

ELEM . end STACK A generic haromfele parameterrel parameterezhet}o: egyszer}u adatertekkel vagy objektummal, tpussal, es alprogrammal. A k
ovetkez}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=XLAST then return XFIRST else return XSUCC end if end NEXT OPERATION A formalis tpus egy tpusosztaly is lehet. A formalis tpusok osztalyainak 78 Ada lerasara a k
ovetkez}o jeleket

hasznaljuk: (<>) | range <> | delta <> | digits <> | tetsz}oleges diszkret tetsz}oleges INTEGER tetsz}oleges xpontos 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 sz
ukseg volna, meg kell adni }oket parameterkent). Megjegyezz
uk, hogy ha a (<>) tpusnak valamely INTEGER tpust feleltet
unk 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(INDEXVAL((INDEXPOS(LEFT) + INDEXPOS(RIGHT)) / 2)) LEFT IDX : INDEX := LEFT RIGHT IDX: INDEX := RIGHT begin loop while V(LEFT IDX) < CENTRE VALUE loop LEFT IDX := INDEXSUCC(LEFT IDX) end loop while CENTRE VALUE < V(RIGHT IDX) loop RIGHT IDX := INDEXPRED(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  LEFT IDX := INDEXSUCC(LEFT IDX) RIGHT IDX := INDEXPRED(RIGHT IDX)  LEFT IDX RIGHT IDX  LEFT RIGHT IDX SORT(LEFT,RIGHT IDX)  LEFT IDX RIGHT end end if exit when end loop if < end if if < > then then Generic 79 SORT(LEFT IDX,RIGHT) end if end SORT begin SORT(VFIRST,VLAST) 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 P
eld
anyos
t
as <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 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 Nezz
uk 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 XRANGE loop PUT(X(I),FIELD WIDTH) INCREMENT IS ZERO NEW LINE  TABULATE if end loop end then end if 80 Ada A QUICK SORT genericb}ol letrehozhatjuk pl. a k
ovetkez}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 felhasznalasakor? 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 := PDC 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?) 11.3 P
eldaprogramok i) Listakezel
es 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 sorozatokat nem tudjak eleg hatekonyan

implementalni. Ezert a programozora Generic 81 hagyjak, hogyan akarja implementalni a sorozatot: vektorral, vagy pointerekkel feleptett listaval. Ebben a pontban egy listakezel}o generic package-t mutatunk 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  LIST PACKAGE end record end package body LIST PACKAGE is function MAKE(A : ARR) return POINTER is P : POINTER begin for I in reverse ARANGE 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) P /= PUT(INT LIST.FRONT(P), WIDTH = P := INT LIST.REST(P) while null loop > 2) 82 Ada end loop end LIST DEMO ii) Matematikai konyvt
ari generic A generic legfontosabb es legnagyobb felhasznalasi ter
ulete a software k
onyvtarak kialaktasa. Az alabbi generic pelda egy matematikai k
onyvtari 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) FINISHED PREVIOUS APPROX := NEW APPROX SUM := F(A) / 2.0 I 1 . N-1 SUM := SUM + F(A + REAL(I) * H)  SUM := SUM + F(B) / 2.0 NEW APPROX := SUM * H FINISHED := (NEW APPROX ; PREVIOUS APPROX) N := N * 2 H := H / 2.0  NEW APPROX INTEGRATE G while not loop for in end loop loop abs end loop return end < EPS Taskok 83 12. Taskok A taskot nem tartalmazo program vegrehajtasa az el}oz}o pontokban lert szabalyok szerint, az utastasainak a szekvencialis vegrehajtasaval t
ortenik. U gy kepzelhetj
uk el, hogy az utastasokat egyetlen "logikai processzor" hajtja vegre. A taskok olyan egysegek, amelyek vegrehajtasa parhuzamosan t
ortenik. U gy kepzelhetj
uk 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 t
obb szalon fut, egy id}opillanatban a programnak t
obb utastasa is lehet vegrehajtas alatt. A k
ul
onb
oz}o taskok a szinkronizacios pontoktol eltekintve egymastol f
uggetlen
ul m}uk
odnek (Az, hogy a programot egy vagy t
obb "zikai processzor" hajtja vegre, csak a nyelv implementaciojahoz 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 k
oz
otti informacioatadasra szolgalnak. A taskok szinkronizalasa a taskok randevuival t
ortenik, ami egy hvast kiado ill. fogado task k
oz
ott zajlik le A taskot egy task programegyseggel denialjuk, ami task specikaciobol es task t
orzsb}ol all. Ebben a pontban a

task egysegre, az entry-kre a taskok k
oz
otti kapcsolatok lerasahoz denialt utastasokra (entry hvasa, accept, delay, select es abort utastas) vonatkozo szabalyokat rjuk le. 12.1 A task speci k
aci
oja
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  <declarative part> ] begin <sequence of statements>  exception <exception handler> f<exception handler>g ] end  <task simple name> ]  A specikacio es a t
orzs 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 megt
obbsz
or
ozhetj
uk). A task tpus ertekei olyan taskok, amelyeknek az entry pontjai pontosan

azok, amiket a 84 Ada specikacios resz felsorol. A type alapszo nelk
uli 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 t
orzse denialja a task vegrehajtasanak hatasat. A task t
orzsenek vegrehajtasa a task aktivizalasanak hatasara t
ortenik meg. Peldak task t
orzsre: task body PRODUCER is C : CHARACTER begin loop PRODUCE(C) BUFFER.PUT(C)  PRODUCER end loop end task body CONSUMER is C : CHARACTER begin loop BUFFER.GET(C) CONSUME(C)  CONSUMER end loop end 12.2 Task t
pusok, 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 deklaracio 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 : (1 . 10) KEYBOARD DRIVER TERMINAL : KEYBOARD := KEYBOARD DRIVER array of new 12.3 Taskok aktiviz
al
asa, v
egrehajt
asa A task vegrehajtasat a task t
orzse 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 t
orzs els}o utastasanak vegrehajtasa el}ott t
ortenik meg. Ha a deklaracio egy package specikacios reszeben van, az aktivizalas a t
orzs deklaracios reszenek kiertekelese utan es a t
orzs vegrehajtasa el}ott t
ortenik meg. Az a task objektum vagy objektum komponens, amit allokatorral hozunk letre, az allokator kiertekelesekor ker
ul aktivizalasra. (Ugyanezek ervenyesek arra a taskra is, ami egy objektum komponense.) Ha a task aktivizalasa k
ozben hiba t
ortenik, a task komplett allapotba ker
ul, az aktivizalas befejezese utan fellep a TASKING ERROR a taskokat tartalmazo programegyseg t
orzseben. Egy komplett allapotba ker
ult taskot mar semmilyen modon nem lehet ujra elindtani 12.4 Taskok termin
al
asa Minden task f
ugg legalabb egy sz
ul}ot}ol. A sz
ul}o lehet szinten task, vegrehajtas alatt allo blokk,

alprogram vagy k
onyvtari package. A f
ugges k
ozvetlen az alabbi ket esetben. a) Ha az objektum vagy objektum komponense altal jel
olt taskot egy allokator kiertekelese k
ozben hoztuk letre, a task attol az egysegt}ol (mint sz
ul}ot}ol) f
ugg, amelyik az access tpust kiertekelte. b) Ha deklaracio kiertekelese k
ozben hoztuk letre, akkor attol az egysegt}ol f
ugg, amelyik a deklaracio kiertekeleset kezdemenyezte. Ha a task f
ugg egy sz
ul}ot}ol, amit egy masik egyseg (sz
ul}o) hajt vegre, akkor a task (k
ozvetve) ett}ol a sz
ul}ot}ol is f
ugg. A task komplette valik, ha vegeter a task t
orzseben lev}o utastasok vegrehajtasa, vagy ha a vegrehajtas k
ozben hiba lep fel es nincs a taskban hibakezel}o programresz, vagy ha van, es annak a vegrehajtasa befejez}odik. A task terminal, ha komplett, es az
osszes t}ole f
ugg}o task mar terminalt K
ul
onben a task 86 Ada pontosan akkor terminal, ha a vegrehajtasa egy terminate

utastashoz ert, es teljes
ul az alabbi ket feltetel: a) a task olyan sz
ul}ot}ol f
ugg, ami mar terminalt (a vegrehajtasa vegetert, tehat pl. nem k
onyvtari package) b) a sz
ul}ot}ol f
ugg}o
osszes task terminalt mar, vagy szinten egy terminate utastasnal varakozik. Pelda : declare type GLOBAL is access RESOURCE A, B : RESOURCE G : GLOBAL ;; A es B begin 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: - TaskNameCALLABLE | logikai ertek, ami pontosan akkor hamis, ha a task mar komplette valt, terminalt vagy abortalt (vagyis mar nem lesz t
obbe hvhato). - TaskNameTERMINATED | logikai ertek, ami pontosan akkor igaz, ha a task mar terminalt. - EntryNameCOUNT | a megnevezett

entry-hez tartozo accept-re varakozo hvasok szama. (Ellen}orz}o kerdes. Nezzuk meg gyelmesen az alabbi programreszletet! with TEXT IO use TEXT IO 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 FTERMINATED then PUT LINE("terminated") else PUT LINE("not terminated") end if end MAIN Mit kell ki rnia a programnak?) 12.5 entry, entry h
v
as, accept utas
t
as <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

szinkronizalasara es adatcserejere. Az entry deklaracio hasonlo az alprogramdeklaraciohoz, de csak taskban megengedett Az entry formalis es aktualis parameterreszere ugyanaz ervenyes, mint az alprogramok parametereire Az entry deklaracio deklaralhatja entry-k csaladjat is a csaladot diszkret intervallummal jel
olj
uk ki. A csalad egy entry-jere indexelessel hivatkozhatunk A t
orzs
on kv
ul 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 megt
ortent. Minden entry-hez k
ul
on 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 felf
uggeszt}odik. b) Ha a task vegrehajtasa egy accept utastashoz ert es nincs a megfelel}o entryre hvas, a task

felf
uggeszt}odik. Ha az entry hvas pillanataban a hvott entry-hez tartozo accept utastasnal tart a vegrehajtas, vegrehajtodik az accept utastas t
orzse (a hvo task felf
uggeszt}odik). Ez a randevu Az accept t
orzs vegrehajtasa utan mindket task parhuzamosan fut tovabb. Ha t
obb task hvja ugyanazt az entry-t, mik
ozben a vegrehajtas nem erte el az accept utastast, a hvasok egy varakozasi sorba ker
ulnek. Minden entry-hez k
ul
on 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 utas
t
as <delay statement> ::= delay <simple expression>  A delay t utastas felf
uggeszti a taskot t masodpercre. Az Ada a f}oprogramot magat is egy

tasknak fogja fel, ezert a delay utastas hasznalhato taskon kv
ul is, ekkor a f}oprogramot f
uggeszti fel az adott id}ore. Az id}o megadasara az Ada bevezeti a predenit valos DURATION tpust A DURATION tpus gepi reprezentaciojara az Ada el}orja, hogy DURATIONSMALL nem lehet nagyobb 20 ezredmasodpercnel, a tpus legnagyobb erteke nem lehet kisebb, mint 86400 Az id}o kezelesehez az Ada k
onyvtar predenit egysegkent tartalmazza a CApackage-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 4000 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 LENDAR MONTH : MONTH NUMBER DAY : DAY NUMBER SECONDS : DAY DURATION := 0.0) return TIME 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 j
ott letre) tart, akkor a task komplett allapotba ker
ul. 12.7 A select utas
t
as <select statement> ::= <selective wait>j<conditional entry call> j<timed entry call> A select utastas kombinalva az accept, delay es terminate utastasokkal, k
ul
onfele helyezetek megoldasara alkalmazhato. Harom ilyen a szelektv varakoztatas, a felteteles entry utastas es az id}oh
oz k
ot
ott entry hvas. 12.71 A szelekt
v v
arakoztat
as <selective wait> ::= select <select alternative> f or <select alternative>g  else <sequence of statements> ] 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 teljes
uleseig a varakozast, majd egy feltetel teljes
ulesekor a hozza tartozo utastasok vegrehajtasat. A szelektv varakoztatasnak legalabb egy olyan aga kell legyen, ami accept utastast tartalmaz, ezen kv
ul lehet olyan aga, ami delay utastast, es olyan, ami terminate utastast tartalmaz. Egy agat nyitottnak nevez
unk, ha nincs benne feltetel (when), vagy ha a feltetel erteke igaz, k
ul
onben zartnak nevezz
uk. A select utastas vegrehajtasakor a feltetelek kiertekelesre ker
ulnek, es meghatarozasra ker
ul, 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 t
obb nyitott ag is van, a valasztas a k
ovetkez}o szabalyok szerint t
ortenik : a) ha van nyitott accept ag, amelynel randevu j
on 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 u
res entrysora. 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.72 A felt
eteles entry h
v
as <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 j
on. Nem t
ortenik meg az entry

hvas, ha a randevu nem j
ohet 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 u
res). 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 t
ortenik meg, helyette az else ag hajtodik vegre. Taskok 91 12.73 Id}ohoz kotott entry h
v
as <timed entry call> ::= select <entry call statement>  <sequence of statements> ] or <delay alternative> end select  Az id}oh
oz k
ot
ott entry hvasnal a hvas akkor k
ovetkezik be, ha a randevu meg az utastasban megadott id}o lejarta el}ott letrej
on. Ha az adott id}o alatt a randevu nem j
on letre, a delay - ag hajtodik vegre. select or CONTROLLER.REQUEST(MEDIUM)(SOME ITEM) delay 45.0 end select 12.8 P
eldaprogramok i) Kolcsonos kiz
ar
as Parhuzamos

rendszerekben sz
ukseg van olyan eszk
ozre, ami biztostja, hogy amikor egy k
oz
osen hasznalt objektumhoz egy task "hozzanyul", arra az id}ore a t
obbi task ne ferhessen hozza. Az Adaban a k
olcs
on
os kizarast t
obbfelekeppen, es nagyon egyszer}uen meg lehet valostani. El}osz
or az osztott objektumot magaban a taskban helyezz
uk 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 k
olcs
on
os kizarast szemafor hasznalataval valosthatjuk meg. Egy szemaforhoz egy P es egy V m}uvelet tartozik. A P operacio csak az els}o o}t meghvo taskot endegi tovabb, a t
obbit

megvarakoztatja, a V operacio pedig mindig tovabbindt egy a P altal felf
uggesztett 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 k
olcs
on
os kizarast biztostottuk. COMMON : T S : SEMAPHORE begin . S.P COMMON := F(COMMON) S.V . A szemafor egy nem tulsagosan megbzhato szinkronizacios technika, ha ugyanis valahol kifelejtj
uk a V operacio meghvasat, ez teljesen
osszezavarja a program m}uk
odeset. ii) Termel}o-fogyaszt
o feladat A termel}o-fogyaszto feladatokban ketfajta task szerepel: az egyik, ami bizonyos tpusu adatokat el}oallt, a masik pedig az, amelyik feldolgozza ezeket. 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.QUEUEPUT(C) end loop end PRODUCER task body CONSUMER is C : INTEGER begin loop SHARED INTEGER QUEUE.QUEUEGET(C) ;; C felhasznalasa  CONSUMER end loop end 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 k
olcs
on
os kizarast. Egy ilyen sor kezeleset mutatjuk meg az alabbi genericben 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 POSSIBLELAST 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 POSSIBLELAST + 1 CONTAINS := CONTAINS ; 1 or when CONTAINS < BUFFER POSSIBLELAST => accept PUT (D:in ITEM) do BUFFER(INX) := D end PUT INX := INX mod BUFFER POSSIBLELAST + 1 CONTAINS := CONTAINS + 1 or terminate end select 94 Ada end loop end QUEUE end SHARED QUEUE iii) Osztott halmaz megval
os
t
asa A pacakege-kr}ol szolo fejezet vegen k
oz
olt
unk egy peldat halmaz megvalostasara. Ez volt az ORDERED SET package Ebben a pontban elkesztj
uk ugyanazt a package-t, de ugy, hogy a halmaz osztott, t
obb 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 or RANK(JOB) := T IN SET(JOB) := TRUE INSERT end accept SMALLEST (JOB:out ID PRESENT: out BOOLEAN) do declare T : DURATION := DURATIONLAST 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 termin
al emul
ator Ebben a peldaban a taskok hasznalataval, pontosabban egy-egy task interrupt 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) terminalvonala volna csatlakoztatva, akkor a program a klaviaturan begepelt parancsokat tovabbtana a masik gepnek, s megjelentene az arrol j
ov}o informaciot ezaltal a PC eljatszhatna egy terminal szerepet. (Az, hogy ez milyen tpusu terminal, tehat pl VT52, VT100 vagy VT320, attol f
ugg, hogy a programunk milyen escape-szekvenciakat ismer fel es hajt vegre A feladatnak ezzel a reszevel nem foglalkozunk) with TEXT IO, KEYBOARD, RS232 procedure TE is C : CHARACTER begin while TRUE loop if KEYBOARD.PRESSED then RS232.PUT(KEYBOARDGET) end if if RS232.RECEIVED then C := RS232.GET case C is when ASCII.ETX => exit when ASCII.ESC => . az escape szekvenci ak feldolgozasa when others => TEXT

IO.PUT(RS232GET) 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(ASCIIBEL) 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 . LINE STATUS : STATUS REGISTER 15) of BOOLEAN Taskok 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(ASCIIDC1) 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(ASCIIDC3) end if return CH end GET end RS232 v) Forgalmi l
amp
ak ir
any
t
asa 97 98 Ada Egy keresztez}odes forgalmi lampainak vezerleset vegz}o programot keszt
unk.  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 haladni. Az erzekel}o es a gyalogos nyomogombja egyarant a 8#2000# cmen okoznak interruptot A f}out forgalmanak megalltasakor be kell tartani a k
ovetkez}oket: - A f}out forgalmat csak akkor lehet megalltani, ha legalabb 3 percen kereszt
ul a z
old

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 fo}ut lampaja zold, ;; a mellekute piros procedure CHANGE LIGHT ;; ellenkezo}re alltja a keresztezo}desben ;; 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 MAINCOUNT loop accept STOP MAIN end loop CHANGE LIGHT end loop end LIGHT begin null end CONTROL TRAFFIC LIGHT vi) Pr
msz
amok el}o
all
t
asa Taskok 99 Prmszamok el}oalltasanak egy jol ismert modszere az

Eratoszthenesz-fele szitamodszer. 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 t
obbsz
or
oseit | ennek atadja. 7] with TEXT IO use TEXT IO 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 NEW FILTER FILTER TASK function return begin return new FILTER end NEW FILTER task body FILTER is 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 := FILTER PUT LINE("All primes in the range are: ") I 2 . NUMBERS FIRST FILTER.NUMBER STREAM(I)  new for in end loop loop 100 Ada ;; Flag the end-of-numbers. FIRST FILTER.NUMBER STREAM(;1) end SIEVE Reprezentacios specikaciok 101 13. Reprezent
aci
os speci k
aci
ok Egy software-kesztesre is alkalmas magasszint}u nyelvnek k
ul
onb
oz}o szint}u eszk
oz
okre van sz
uksege az adatmanipulaciok teren (raadasul ezeknek az eszk
oz
oknek

elesen el kell hatarolodniuk): - rendelkeznie kell eszk
oz
okkel az absztrakt tpusok kezelesere, ahol az adatoknak csak a logikai tulajdonsagai fontosak, es - rendelkeznie kell olyan eszk
oz
okkel is, amelyek az adatok zikai abrazolasanak szintjen hasznalhatok fel. Az eddigiekben az adatkezelesnek a logikai szintjevel foglalkoztunk, ebben a pontban az alacsonyszint}u, gepk
ozeli eszk
oz
oket 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 MEDIUMSIZE use 16 type COLOR is (WHITE, RED, YELLOW, GREEN, BLUE, BROWN, BLACK) for COLORSIZE 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 t
ortenjen: 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 paritasu, esetleg 4-gyel vagy 8-cal oszthato cmen kezd}odjenek, ill. hogy a komponensek a

rekordon bel
ul hanyadik szoban es mely biteken helyezkedjenek el 102 Ada constant type is type is type is array of type is array of type is array of type is record : BYTE MASK SYSTEM MASK PROTECTION KEY : INTEGER range 0 . WORD : := 4 STATE (A, M, W, P) MODE (FIX, DEC, EXP, SIGNIF) BYTE MASK (0 . 7) BOOLEAN STATE MASK (STATE) BOOLEAN MODE MASK (MODE) BOOLEAN PROGRAM STATUS WORD MACHINE STATE : INTERRUPT CAUSE : ILC : CC : PROGRAM MASK : INST ADDRESS :  PROGRAM STATUS WORD 8 SYSTEM MASK PROTECTION KEY MACHINE STATE INTERRUPT CAUSE ILC CC PROGRAM MASK INST ADDRESS  end record for record at mod 3 STATE MASK INTERRUPTION CODE INTEGER 0 . 3 INTEGER 0 . 3 MODE MASK ADDRESS range range use at 0*WORD range 0 . 7 at 0*WORD range 10 . 11 at 0*WORD range 12 . 15 at 0*WORD range 16 . 31 at 1*WORD range 0 . 1 at 1*WORD range 2 . 3 at 1*WORD range 4 . 7 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}oseg
unk van ennek fel
ulbralasara, s a programban el}orhatjuk, hogy egy valtozo vagy egy alprogram a memoria mely cmere kepz}odj
on le. CONTROL : INTEGER CONTROL 16#0020# for use at task INTERRUPT HANDLER is entry DONE for DONE use at 16#0040# end INTERRUPT HANDLER ;; a CONTROL valtozo a memoria ;; 16#0020#-as c menek szimbolikus ;; neve lesz ;; a DONE entry megh vasa ;; azt a runtint h vja meg, amelynek c me ;; a 16#0040# c men talalhato Fordtasi direktvak 103 14. Ford
t
asi direkt
v
ak A reprezentacios specikaciokon kv
ul a fordtast befolyasolhatjuk meg fordtasi direktvakkal, un. pragmakkal is A pragmak szama az egyes Ada implementaciokban elterhet Itt csak nehany altalanosan hasznalt pragmat sorolunk 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 valamely, az adott egysegben hasznalt k
onyvtari egysegek nevei lehetnek A pragmat a with es use utastasok es az egyseg specikacios resze k
oz
ott kell elhelyezni. Az ELABORATE pragma azt rja el}o, hogy a megnevezett packageket a program vegrehajtasanak kezdeten el}obb kell kiertekelni (a t
orzs inicializalo reszet el}obb kell vegrehajtani), mint a pragmat tartalmazo egyseget pragma INLINE(azonosto, .) | A pragma parameterlistajan alprogramnevek 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 alprogramt
orzseket 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 t
orzset tartalmazo egyseget is lefordtottuk. pragma INTERFACE(nyelv megnevezese, alprogram neve) | A pragmat a megnevezett alprogram specikacioja utan kell elhelyezni. Az INTERFACE pragma arra gyelmezteti a fordtoprogramot, hogy az alprogramt
orzset 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 deklaracios reszhez tartozo blokkra vagy t
orzsre vonatkozik El}orja, hogy az id}o vagy a hely legyen-e az els}odleges optimalizalasi kriterium. pragma SUPPRESS(azonosto) | A pragma parameterlistajan egy objektum, egy tpus vagy egy exception neve lehet, ill. a pragma hasznalhato u
res

parameterlistaval is A pragmat egy deklaracios reszben kell elhelyezni, s az egesz t
orzsre (vagy blokkra) ervenyes. Azt jelenti, hogy a fordtoprogramnak a megnevezett objektumra, tpusra (pontosabban az ilyen tpusu
osszes objektumra) es exception-ra vonatkozo ellen}orzeseket a t
orzsb}ol ki kell hagynia. A parameter nelk
uli SUPPRESS azt jelenti, hogy a t
orzs fordtasakor az
osszes ellen}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 SEQUENes a LOW LEVEL IO package Az Ada TIAL IO, DIRECT IO, TEXT IO, IO EXCEPTIONS  dencioja tartalmazza ezeknek a package-knek a specikacios reszet, s lerja az alprogramok szemantikajat. Ez a megoldas biztostja az I/O egysegesseget es modosthatosagat, mert gy az I/O implementaciojat k
onny}u hozzaigaztani az illet}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| k
uls}o le-lal o
sszekapcsolhato. A le kezelese tehat nem f
ugg a berendezest}ol, csak a le tpusatol (Egy text-let ugyanugy kell kezelni, f
uggetlen
ul attol, hogy az sornyomtaton, vagy lemezen van) Az Adaban hasznalhato le-tpusokat az emltett package-ek limited private tpuskent denialjak. A le kezelese a k
ovetkez}o lepesekben t
ortenik : - le-valtozo deklaralasa, - a le-valtozo
osszekapcsolasa egy k
uls}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 k
uls}o le megnyitasa (OPEN), egy le lezarasa (CLOSE)

ugyanolyan eljarassal t
ortenik, barmelyik package-t hasznaljuk is. A le-ok kezelesekor bek
ovetkez}o hibakat az Ada egy k
ul
on package-ben, az 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 IO EXCEPTIONS Input - output 105 15.1 Szekvenci
alis le-ok kezel
ese A szekvencialis le azonos tpusu rekordok sorozata. Az egyes rekordokhoz un. le-pozciot rendel
unk: 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 FORM : 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 exception renames IO EXCEPTIONS.STATUS ERROR exception renames IO

EXCEPTIONS.MODE ERROR exception renames IO EXCEPTIONS.NAME ERROR exception renames IO EXCEPTIONS.USE ERROR exception renames IO EXCEPTIONS.DEVICE ERROR exception renames IO EXCEPTIONS.END ERROR exception renames IO EXCEPTIONS.DATA ERROR STATUS ERROR : MODE ERROR : NAME ERROR : USE ERROR : DEVICE ERROR : END ERROR : DATA ERROR : private ;; implementaciofugg}o 106 Ada end SEQUENTIAL IO A rekordok olvasasa a READ eljarassal t
ortenik. 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 f
uggveny akkor ad TRUE erteket, ha az aktualis lepozcio az END OF FILE pozcio). A READ es pozciot. WRITE eljarasok ertelemszer}uen valtoztatjak (1-el n
ovelik) a le- 15.2 Direkt le-ok kezel
ese A direkt le-kezeles csak abban k
ul
onb
ozik a szekvencialistol, hogy a lepozcio alltasara az Ada k
ul
on bevezet egy eljarast. Az ras es az olvasas el}ott gy most

pozicionalhatunk a kvant rekordra. Az ras es az olvasas 1-el n
oveli a lepozciot with IO EXCEPTIONS generic type ELEMENT TYPE is private package DIRECT IO is type FILE TYPE is limited private type FILE MODE is (IN FILE, INOUT FILE, OUT FILE) type COUNT is range 0 . implementaciofugg}o subtype POSITIVE COUNT is COUNT range 1 . COUNTLAST ;; File management procedure CREATE(FILE : in out FILE TYPE MODE : in FILE MODE := INOUT FILE NAME : in STRING := "" FORM : in STRING := "") procedure OPEN(FILE : in out FILE TYPE MODE : in FILE MODE NAME : in STRING FORM : 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 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 TO : in POSITIVE COUNT) function INDEX(FILE : in FILE TYPE) return POSITIVE COUNT function SIZE(FILE : in FILE TYPE) return COUNT function END OF FILE(FILE : in FILE TYPE) return BOOLEAN ;; Exceptions exception renames IO EXCEPTIONS.STATUS ERROR exception renames IO EXCEPTIONS.MODE ERROR exception renames IO EXCEPTIONS.NAME ERROR exception renames IO EXCEPTIONS.USE ERROR exception renames IO EXCEPTIONS.DEVICE ERROR exception renames IO EXCEPTIONS.END ERROR exception renames IO EXCEPTIONS.DATA ERROR STATUS ERROR : MODE ERROR : NAME ERROR : USE

ERROR : DEVICE ERROR : END ERROR : DATA ERROR : private ;; implementaciofugg}o end DIRECT IO 15.3 Text le-ok A text-le-ok kezelesere valo eljarasok a TEXT IO package-ben vannak denialva. A TEXT IO package nem generic, de generic package-ket tartalmaz az egesz, valos es felsorolasi tpusokra, valamint alprogramokat a CHARACTER, STRING  es BOOLEAN tpusra. with IO EXCEPTIONS package TEXT IO is type FILE TYPE is limited private type FILE MODE is (IN FILE, OUT FILE) type COUNT is range 0 . implementaciofugg}o subtype POSITIVE COUNT is COUNT range 1 . COUNTLAST 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 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 108 Ada in STRING 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 NAME : FORM : ;; 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(FILE : in FILE TYPE) 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 TO : in POSITIVE COUNT) 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. 1531 ;; String Input-Output ;; ld. 1531 ;; Generic package for Input-Output generic type NUM is range <> package INTEGER IO is ;; ld. 1532 end INTEGER IO of Integer Types ;; Generic package for Input-Output of Real Types ;; Generic package for Input-Output of Enumeration types generic type NUM is digits <> package FLOAT IO is ;; ld. 1533 end FLOAT IO generic type NUM is delta <> package FIXED IO is ;; ld. 1533 end FIXED IO generic type ENUM is (<>) package

ENUMERATION IO is ;; ld. 1534 end ENUMERATION IO ;; Exceptions exception renames IO EXCEPTIONS.STATUS ERROR exception renames IO EXCEPTIONS.MODE ERROR exception renames IO EXCEPTIONS.NAME ERROR exception renames IO EXCEPTIONS.USE ERROR exception renames IO EXCEPTIONS.DEVICE ERROR exception renames IO EXCEPTIONS.END ERROR exception renames IO EXCEPTIONS.DATA ERROR exception renames IO EXCEPTIONS.LAYOUT ERROR STATUS ERROR : MODE ERROR : NAME ERROR : USE ERROR : DEVICE ERROR : END ERROR : DATA ERROR : LAYOUT ERROR : private ;; implementaciofugg}o 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. Interaktv rendszerekben ezek a le-ok a terminalhoz vannak rendelve: a klaviatura a standard input, a keperny}o a standard output le A standard le-ra vonatkozo GET es PUT eljarasokban le-valtozot nem kell megadni A standard le

atiranythato mas text-le-ra is a SET INPUT es SET OUTPUT eljarasokkal Az o
sszes 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}uk
odik: az aktualis sorpozciotol egy szintaktikus egyseget levalaszt es bels}o formara konvertal, mik
ozben a bevezet}o szok
oz
oket, tabulatorkaraktereket es sorvegeket atlepi. Ha az adat formatuma nem felel meg a vart szintaxisnak, az DATA ERROR hibat, ha az ertek nem esik a vart ertekhatarok k
oze, az CONSTRAINT ERROR hib at okoz. Minden text-outputot az atlapolt PUT eljarassal lehet elvegezni. A text-le-ok sormerete lehet r
ogztett, vagy valtozo. Ha r
ogztett sormeret mellett a kirando string nem fer el az aktualis sorban, akkor a k
ovetkez}o sor els}o pozciojara ker
ul (ha a string nem fer el egy sorban, az LAYOUT ERROR hibat okoz). Valtozo sorhossz eseten a

string kirasa folytatolagosan az aktualis sorba t
ortenik. 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 u
res sort keszt. Karakteres es string inputnal r
ogztett sorhossz eseten | a sor teljes beolvasasa utan | a GET eljaras automatikusan atlep a k
ovetkez}o sorra, valtozo sorhossz eseten erre k
ul
on m}uvelet van, a SKIP LINE. A SET COL eljaras az aktualis sorban valo pozicionalasra szolgal. 15.31 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 nelk
ul ker
ulnek a le-ba. Pl. PUT(B) vagy PUT("Ez egy string") Pelda egy le karakterenkent valo atmasolasara: with TEXT IO use TEXT IO 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 f
uggveny az aktualis sorpozciotol a sor vegeig tarto resz
osszes karakteret megadja a stringvaltozoban, es ezutan atter az uj sorba. A PUT LINE(S) eljarashvas hatasa megegyezik a k
ovetkez}o program hatasaval : PUT(S) NEW LINE 15.32

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 := NUMWIDTH 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 WIDTH : in FIELD := DEFAULT WIDTH BASE : in NUMBER BASE := DEFAULT BASE) procedure GET(FROM : in STRING ITEM : out NUM LAST : out POSITIVE) procedure PUT(TO : out STRING ITEM : in NUM BASE : in NUMBER BASE := DEFAULT BASE) end INTEGER IO . end TEXT IO Egesz szamok kirasara az INTEGER IO generic package hasznalhato. Parametere 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 k
ovetkez}o: t t t128t t t t t t t t ;3t t tt16#FF# 15.33 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 := NUMDIGITS-1 DEFAULT EXP : FIELD := 3 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 FORE : in FIELD := DEFAULT FORE AFT : in FIELD := DEFAULT AFT EXP : in FIELD := DEFAULT EXP) procedure PUT(ITEM : in NUM FORE : in FIELD := DEFAULT FORE AFT : in FIELD := DEFAULT AFT EXP : in FIELD := DEFAULT EXP) Input - output 113 procedure GET(FROM : in STRING ITEM : out NUM LAST : out POSITIVE) procedure PUT(TO : out STRING ITEM : in NUM AFT : in FIELD := DEFAULT AFT EXP : in INTEGER := DEFAULT EXP) end FLOAT IO generic

type NUM is delta <> package FIXED IO is DEFAULT FORE : FIELD := NUMFORE DEFAULT AFT : FIELD := NUMAFT DEFAULT EXP : FIELD := 0 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 FORE : in FIELD := DEFAULT FORE AFT : in FIELD := DEFAULT AFT EXP : in FIELD := DEFAULT EXP) procedure PUT(ITEM : in NUM FORE : in FIELD := DEFAULT FORE AFT : in FIELD := DEFAULT AFT EXP : in FIELD := DEFAULT EXP) procedure GET(FROM : in STRING ITEM : out NUM LAST : out POSITIVE) procedure PUT(TO : out STRING ITEM : in NUM AFT : in FIELD := DEFAULT AFT 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 type REAL is digits 8 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 k
ovetkez}o : 114 Ada 3.9740000E;3t t t t tt3974E;03tt40E;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 tt17517500 15.34 A felsorol
asi t
pusokra vonatkoz
o 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) procedure PUT(FILE : in FILE TYPE ITEM : in ENUM WIDTH : in FIELD := DEFAULT WIDTH SET : in TYPE SET := DEFAULT SETTING) procedure PUT(ITEM : in ENUM WIDTH : in FIELD := DEFAULT WIDTH SET : in TYPE SET := DEFAULT

SETTING) procedure GET(FROM : in STRING ITEM : out ENUM LAST : out POSITIVE) procedure PUT(TO : out STRING ITEM : in ENUM SET : in TYPE SET := DEFAULT SETTING) 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 15.4 P
eldaprogramok i) A felsorol
asi t
pus input-outputja Az alabbi program az TEXT IO package beagyazott package-inek interaktv hasznalatat mutatja be. with TEXT IO use TEXT IO 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 ENTER COLOR(SELECTION: COLOR) procedure begin loop begin out is 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  DIALOGUE end loop end 116 Ada 16. Fuggel
ek A) A STANDARD package Az Adaban a STANDARD package denialja az
osszes predenit tpust, objektumot es alprogramot. A package t
orzse implementaciof
ugg}o Ez a package nem rhato le teljes egeszeben Ada nyelven: egyes implementaciof
ugg}o denciokat csak jelezni tudunk az alabbi kodban, a predenit operatorokat pedig csak megjegyzesben adjuk meg, mert ezek bar logikailag ebbe a package-be tartoznak, az Ada fordtoprogram k
ozvetlen
ul "ismeri" }oket. (Nehany helyen a hosszu felsorolast harom ponttal jel
olt
uk, de ez csak helytakarekossag miatt t
ortent.) 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) ;; return universal real ;; function "/" (LEFT : universal real RIGHT : universal integer) ;; return universal real ;; 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, bs, ht, lf, vt, dle, dc1, dc2, dc3, cna, em, sub, esc, , !, ", #, (, ), *, +, 0, 1, 2, 3, 8, 9, :, , @, A, B, C, H, I, J, K, P, Q, R, S, X, Y, Z, , , a, b, c, h, i, j, k, p, q, r, s, x, y, z, f,  # eot, enq, ack, bel, , cr, so, si, dc4, nak, syn, etb, fs, gs, rs, us, $, %, &, , ,, ;, ., /, 4, 5, 6, 7, , =, , ?, D, E, F, G, L, M, N, O, T, U, V, W, n, , , , d, e, f, g, l, m, n, o, t, u, v, w, j, g, , del ) < > ] b e 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 NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI DLE DC1 DC2 DC3 DC4 NAK SYN characters : : : : : : : : : : : : : : : : : : : : : : : constant CHARACTER := nul constant CHARACTER := soh constant CHARACTER := stx constant CHARACTER := etx constant CHARACTER := eot constant

CHARACTER := enq constant CHARACTER := ack constant CHARACTER := bel constant CHARACTER := bs constant CHARACTER := ht constant CHARACTER := lf constant CHARACTER := vt constant CHARACTER :=  constant CHARACTER := cr constant CHARACTER := so constant CHARACTER := si constant CHARACTER := dle constant CHARACTER := dc1 constant CHARACTER := dc2 constant CHARACTER := dc3 constant CHARACTER := dc4 constant CHARACTER := nak constant CHARACTER := syn Fuggelek 119 ETB CNA EM SUB ESC FS GS RS US : : : : : : : : : constant CHARACTER := etb constant CHARACTER := cna constant CHARACTER := em constant CHARACTER := sub constant CHARACTER := esc constant CHARACTER := fs constant CHARACTER := gs constant CHARACTER := rs constant CHARACTER := us EXCLAM QUOTATION SHARP DOLLAR PERCENT AMPERSAND COLON SEMICOLON QUERY AT SIGN L BRACKET BACK SLASH R BRACKET CIRCUMFLEX UNDERLINE GRAVE L BRACE BAR R BRACE TILDE : : : : : : : : : : : : : : : : : : : : constant CHARACTER

:= ! constant CHARACTER := " constant CHARACTER := # constant CHARACTER := $ constant CHARACTER := % constant CHARACTER := & constant CHARACTER := : constant CHARACTER :=  constant CHARACTER := ? constant CHARACTER := @ constant CHARACTER :=  constant CHARACTER := n constant CHARACTER := ] constant CHARACTER := b constant CHARACTER :=  constant CHARACTER := # constant CHARACTER := f constant CHARACTER := j constant CHARACTER := g constant CHARACTER := e ;; Other characters ;; Lower case letters LC A : . LC Z : constant CHARACTER := a constant CHARACTER := z end ASCII ;; Predefined subtypes ;; Predefined string type subtype NATURAL is INTEGER range 0 . subtype POSITIVE is INTEGER range 1 . INTEGERLAST INTEGERLAST 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 NUMERIC ERROR PROGRAM ERROR STORAGE ERROR TASKING ERROR end STANDARD : : : : : exception exception

exception exception exception Fuggelek 121 B) Az Ada fogalmainak osszefoglal
asa Accept utas
t
as (Accept statement). Ld entry Access
ert
ek (Access value). Ld access tpus Access t
pus (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 kereszt
ul lehet. Egy access tpus dencioja specikalja azoknak az objektumoknak a tpusat, amelyek az access tpus ertekeivel kijel
olhet}ok. Ld meg kollekcio. Aktu
alis param
eter (Actual parameter). Ld parameter Aggreg
atum (Aggregate). Egy aggregatum kiertekelesenek eredmenye egy osszetett tpusu ertek. Az o
sszetett erteket a komponensek ertekei hatarozzak meg A komponensek megadasanal a pozicionalis megfeleltetes, vagy a nevvel jelolt megfeleltetes hasznalhato. Alegys
eg

(Subunit). Ld torzs Alegys
eg szul}oje (Parent unit). Egy alegyseg sz
ul}ojenek nevezz
uk azt fordtasi egyseget (t
orzset vagy alegyseget), amelyben az alegysegre vonatkozo csonk van. Allok
ator (Allocator). Egy allokator kiertekelese letrehoz egy objektumot, s egy uj access erteket, ami kijeloli ezt az objektumot. Alprogram (Subprogram). Az eljarast es a fuggvenyt egy
uttveve alprog- ramnak mondjuk. Az eljaras tevekenysegek egy sorozatat rja el}o, aminek vegrehajtasat egy eljarashvassal kezdemenyezhetj
uk. A f
uggveny szinten specikalja tevekenysegek egy sorozatat, valamint specikal egy visszateresi erteket, a fuggveny eredmenyet. A fuggvenyhvas egy kifejezes Az alprogramot alprogramspecikacio es alprogramtorzs formajaban adjuk meg Az alprogramspecikacioban r
ogztj
uk a nevet, a formalis parametereit, es (f
uggveny eseten) az eredmenyet. Az alprogramt
orzs tartalmazza a tevekenysegek felsorolasat.

Az alprogramhvas aktualis parametereket tartalmaz, amiket a hvas megfeleltet a formalis parametereknek Az alprogram a programegysegek egy fajtaja Alprogramspeci k
aci
o (Subprogram specication). Ld alprogram Alprogramtorzs (Subprogram body). Ld alprogram Alt
pus (Subtype). Egy tpus altpusa a tpusertekhalmaz egy reszhalmazaval jellemezhet}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
tlapol
as (Overloading). A programsz
oveg egy pontjan egy azonostonak t
obb je- lentese is lehet: ezt a tulajdonsagot nevezz
uk atlapolhatosagnak. Peldaul:

atlapolt felsorolasi tpusu literal lehet egy olyan azonosto, ami t
obb felsorolasi tpus denciojaban is szerepel. Egy atlapolt azonosto valodi jelenteset mindig a sz
ovegk
ornyezet hatarozza meg Az alprogramok, az aggregatumok, az allokatorok es a string literalok szinten atlapolhatok A
tnevez
es (Renaming declaration). Az atnevezes ujabb nevvel lat el egy mar letez}o egyedet. B
azist
pus (Base type). Azt a tpust, amelynek megszortasaval az altpust el}oalltottuk, az altpus bazistpusanak nevezz
uk. bazistpusa
onmaga. A megszortatlan tpus Blokk utas
t
as (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 tartalmazo fordtasi egysegr}ol, s bel}ole alegyseget kepezhet
unk Az

alegyseg t
orzsenek helyen marado reszt (separate) csonknak nevezz
uk. Deklar
aci
o (Declaration). A deklaracio
osszekapcsol egy azonostot (vagy mas elnevezesre alkalmas jel
olest) egy egyeddel. Ez az
osszekapcsolas a programsz
oveg egy szakaszan, a deklaracio hataskoren bel
ul ervenyes. A deklaracio hatask
oren bel
ul hasznalhato az azonosto az egyedre valo hivatkozasra, masszoval, a nev a hozzakapcsolt egyedet jeloli. Deklar
aci
os r
esz (Declarative part). A deklaracios resz deklaraciok sorozatabol all. Tartalmazhat ezen fel
ul alprogramtorzseket es reprezentacios el}orasokat is Diszkr
et t
pus (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 indexelesre, iteracios ciklus megszervezesere, az esetek lerasara a case utastasban,

es varians resz kepzesere a rekord tpuson bel
ul. Diszkrimin
ans (Discriminant). A diszkriminans egy kit
untetett komponense a rekord tpusu objektumoknak es ertekeknek. A t
obbi komponens altpusa, s}ot jelenlete f
ugghet a diszkriminans erteket}ol Fuggelek 123 Diszkrimin
ans megszor
t
asa (Discriminant constraint). Egy rekord tpus vagy egy privat tpus diszkriminansanak megszortasa a tpus mindegyik diszkriminansanak erteket r
ogzti. Eg
esz t
pus (Integer type). Egy egesz tpus olyan diszkret tpus, amely- nek ertekkeszletet egy meghatarozott intervallumba es}o egesz szamok halmaza reprezentalja. Egyszer}u n
ev (Simple name). Ld deklaracio, nev Elabor
aci
o (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

megszor
t
asnak (Satisfy). Ld megszortas, altpus Elj
ar
as (Procedure). Ld alprogram Elj
ar
ash
v
as (Procedure call). Ld alprogram Entry. A entry-ket a taskok k
oz
otti kommunikacioban hasznaljuk Az entry hvasa a eljarashvashoz hasonloan t
ortenik. Az entry "bels}o tulajdonsagait" egy vagy t
obb accept utastassal denialjuk, amelyek lerjak azt a tevekenysegsorozatot, amit az entry meghvasa eseten el kell vegezni. Eltakar
as (Hidden). Egy deklaracios reszen bel
ul elhelyezkedhet egy masik dek- laracios resz is. Ha ekkor a bels}o deklaracios reszben el}ofordul a k
uls}o deklaracios reszben lev}o deklaracio egy homografja, akkor azt mondjuk, hogy a bels}o deklaracios reszben a deklaracio eltakarja a k
uls}o deklaraciot. E
rt
ekad
as (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. Felsorol
asi t
pus (Enumeration type). Egy felsorolasi tpus olyan diszk- ret tpus, amelynek ertekkeszletet a tpus denciojaban megadott literalokkal reprezentaljuk. A felsorolasi tpusu literalkent azonostokat es karakteres literalok hasznalhatunk. Fixpontos t
pus (Fixed point type). Ld valos tpus Ford
t
asi egys
eg (Compilation unit). Fordtasi egyseg lehet egy programegyseg specikacioja vagy torzse, amit
onallo sz
ovegkent 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 f
ugg. Form
alis param
eter (Formal parameter). Ld parameter 124 Ada Fuggv
eny (Function). Ld alprogram Fuggv
eny eredm
enye (Function result). Ld alprogram Fuggv
enyh
v
as (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 specikacios reszet megel}ozi a generic formalis parametereinek felsorolasa A generic formalis parametere lehet tpus, alprogram vagy objektum A generic a programegysegek egy fajtaja Hat
askor (Scope). Ld deklaracio Homogr
af deklar
aci
o (Homograph declaration). Ket deklaracio egymas ho- mografja, ha ugyanazt az azonostot, operatort vagy karakter literalt deklaraljak, es | ha egyaltalan van, akkor | megegyezik a parametereik es az eredmeny
uk 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 jel
olhet

egy entryt az entry-k csaladjaban Indexmegszor
t
as (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
osszef
gg}o hal- mazat intervallumnak hvjuk. Az intervallumot az ertekek also es fels}o hataranak megadasaval specikaljuk. Intervallum megszor
t
asa (Range constraint). Egy skalar tpus megszortasa az ertekkeszletnek egy reszintervallumra valo lesz}ukteset jelenti. Jelol (Denote). Ld deklaracio Ki
ert
ekel
es (Evaluation). Egy kifejezes kiertekelese az a folyamat, amelynek soran kiszamtasra ker
ul a kifejezes erteke. Ez a folyamat a program futasa soran zajlik le. Kifejez
es (Expression). A kifejezes egy ertek kiszamtasanak modjat denialja Kijelol
es (Designate). Ld access tpus, task Fuggelek 125 Kiterjesztett n
ev (Expanded name). A kiterjesztett nev egy olyan egyedet

jelol, amit k
ozvetlen
ul egy konstrukcio belsejeben deklaraltunk. A kiterjesztett nevet szelekcios formaban rjuk: a prex jel
oli a konstrukciot (ez lehet pl. programegyseg, blokk utastas, ciklus vagy accept utastas), az utotag (a szelektor) pedig az egyed egyszer}u neve. Kiv
etel (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 programsz
ovegnek az a resze, ami specikalja a kivetel fellepesekor elvegzend
o tevekenyseget Egy kivetel fellepese utan kivalasztasra ker
ul a hozza tartozo kivetelkezel}o, majd ennek vegrehajtasa utan a program vegrehajtasa normal modon folytatodik. Kiv
etel kiv
alt
asa (Raising an exception). Ld kivetel Kiv
etelkezel}o (Exception handler). Ld kivetel Kollekci
o (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}o
r
as (Context clause). Ld fordtasi egyseg Kozvetlen l
athat
os
ag (Direct visibility). Ld lathatosag L
athat
o r
esz (Visible part). Ld package L
athat
os
ag (Visibility). A programsz
oveg 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 t
pus (Floating point type). Ld valos tpus Lexik
alis elem (Lexical element). Lexikalis elemek az azonostok, a literalok, az elhatarolo jelek es a megjegyzesek. Limited t
pus (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 kv
ul egy privat tpust is limited tpusnak denialhatunk. A limited tpushoz explicit modon denialhato az "=" m}uvelet. Liter
al (Literal). A literalokat tpusertekek reprezentalasara hasznaljuk Vannak 126 Ada numerikus, felsorolasi tpusu, karakteres es string literalok. Megszor
t
as (Constraint). Egy megszortas egy tpus ertekeinek reszhalmazat denialja. Azt mondjuk, hogy ennek a reszhalmaznak egy eleme eleget tesz a megszortasnak. Min}os
tett kifejez
es (Qualied expression). A min}ostett kifejezes egy olyan ki- fejezes, ami tartalmazza a tpusanak vagy altpusanak a megjel
oleset is. A min}ostest akkor hasznaljuk, ha a kifejezes t
obbertelm}u, a tpusa nem allapthato meg egyertelm}uen (pl. egy atlapolas k
ovetkezteben) Modellsz
am (Model number). A modellszamoknak nevezz
uk 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. M
od (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. N
evvel jelolt megfeleltet
es (Named association). A nevvel jelolt megfeleltetes egy erteknek egy lista egy vagy t
obb pozciojahoz valo hozzarendeleset e pozciok megnevezesevel adja meg. N
ev (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 meghatarozza az objektum tpusat is: az objektum csak ilyen tpusu ertekeket vehet fel Oper
ator (Operator). Az operator egy m
uvelet, aminek egy vagy ket operandusa lehet Az unaris operatort az operandus ele, a binaris operatort a ket operandus k
oze rjuk Ez a jel
oles a fuggvenyhvas egy specialis formaja Egy operator jelenteset f
uggveny formajaban denialhatjuk A tpusokhoz altalaban leteznek implicit modon denialt operatorok is (pl "=", "<" stb) O sszetett t
pus (Compound type). Az O sszetett tpus ertekei komponensekb}ol allnak. O
sszetett tpusok a tomb tpus es a rekord tpus O} segys
eg (Ancestor). Egy alegyseg szul}oi lancan visszafele haladva egy valodi Fuggelek 127 torzsh
oz jutunk, amelynek

mar nincs sz
ul}oje. Ezt a fordtasi egyseget az alegyseg }osegysegenek nevezz
uk. O} st
pus (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 kv
ul is lathatoak. Emellett tartalmazhat egy privat reszt is, amelynek a deklaracioi kiegesztik, teljesse teszik a lathato reszben lev}o denciokat, a packagen kv
ul azonban nem lathatoak A package t
orzse tartalmazza a package specikacios reszeben felsorolt alprogramok t
orzseit A package a programegysegek egy fajtaja. Package spaci k
aci
o (Package specication). Ld package Package torzs (Package body). Ld package Param
eter (Parameter). Az alprogram, az entry es a generic parametere egy nevvel

rendelkez}o egyed, amit a hozza tartozo alprogramtorzzsel, accept utastassal ill. generic t
orzzsel valo kommunikalasra hasznalunk A formalis parameter egy azonosto, ami a t
orzsben az egyedre valo hivatkozasra szolgal. Az aktualis parametert a alprogramhvas, az entry hvas ill a peldanyostas k
oti
ossze a megfelel}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 pedig mindkett}o megt
ortenik. Az aktualis parameterek es formalis parameterek egymashoz rendelese t
ortenhet nevvel jelolt megfeleltetes, vagy pozicionalis megfeleltetes utjan. P
eld
anyos
t
as (Instantiation). Ld generic Pozicion
alis megfeleltet
es (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. Priv
at r
esz (Private part). Ld package Priv
at t
pus (Private type). A privat tpus egy olyan tpus, amelynek a feleptese es az ertekhalmaza pontosan denialt, de a tpust hasznalok szamara k
ozvetlen
ul nem hozzaferhet}o. A privat tpust az azt hasznalo csak a diszkriminansain (ha vannak) es a m}uveletein kereszt
ul ismerheti A privat tpus es annak m}uveletei 128 Ada egy package lathato reszeben, vagy egy generic formalis parameterei k
oz
ott denialhatok. Az ertekadas, az "=" es a "/=" m}uveletek a privat tpusra implicit 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 megegyezik. Ket fuggveny eredmenyenek prole-ja pontosan akkor egyezik meg, ha az eredmenyek bazistpusa megegyezik. Program. A program valahany fordtasi egysegb}ol allthato o
ssze, amelyek k
oz
ott az egyik alprogram szerepe kit
untetett, ez a f}oprogram. A program vegrehajtasa a f}oprogram vegrehajtasat jelenti, ami meghvhat olyan alprogramokat, amelyek a program mas fordtasi egysegeiben helyezkednek el. Programegys
eg (Program unit). A programegysegnek negy fajtaja van: a generic, a package, az alprogram es a task Randev
u (Randezvous). A randevu ket task k
oz
otti bizonyos fajta egy
uttm}uk
odes: az egyik task hvja a masik egy entry pontjat, s a fogado task vegrehajtja a megfelel}o accept utastast. Reprezent
aci
os el}o
r
as (Representation clause). A reprezentacios el}oras meg- hatarozza a fordtoprogram

szamara egy tpus, objektum vagy task egyes tulajdonsagainak lekepezeset a targygep szolgaltatasaira. Egyes esetekben teljesen specikalja a lekepezest, maskor felteteleket denial a lekepezes megvalasztasahoz Rekord t
pus (Record type). Egy rekord tpusu ertek komponensekb}ol all, amelyek altalaba k
ul
onb
oz}o tpusuak ill altpusuak A rekord tpus mindegyik komponenshez hozzarendel egy azonostot, amellyel egyertelm}uen kivalaszthato az ertek vagy az objektum komponense. R
esztomb (Slice). Reszt
ombnek nevez
unk egy egydimenzios tomb tpusu ertek vagy objektum indexeinek egy intervallumaval meghatarozott egydimenzios t
omb
ot. Statikus kifejez
es (Static expression). Statikusnak nevezz
uk azokat a kifejezeseket, amelyek erteke fordtasi id}oben kiszamthato Skal
ar t
pus (Scalar type). A skalar tpusu ertekeknek es objektumoknak nincsenek komponensei Skalar tpusok a diszkret tpusok es a valos tpusok A

skalar tpus ertekhalmaza rendezett halmaz. Sz
armaztatott t
pus (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 nevezz
uk. Szelekci
os jelol
es (Selected komponent). A szelekcios jel
oles egy nev, ami tartalmaz egy prexet, s egy szelektornak nevezett azonostot Szelekcios jel
olest Fuggelek 129 hasznalunk a rekord komponenseinek, az entry-knek, es az access ertekkel elerhet}o objektumoknak a jel
olesere. A szelekcios jel
olest hasznaljuk a kiterjesztett nevek lerasahoz is Szelektor (Selector). Ld szelekcios jeloles Task. A task a program t
obbi 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 t
obb hasonlo task egyszer}u deklaralasat. A task tpus egy erteke kijelol egy taskot Task speci k
aci
o (Task specication). Ld task Task t
pus (Task type). Ld task Task torzs (Task body). Ld task T
pus (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 t
pus (Array type). Egy t
omb tpusu ertek olyan komponensekb}ol all, emelyek ugyanabba az altpusba (tpusba) tartoznak. Mindegyik komponens egyertelm}uen meghatarozhato az indexe (egydimenzios t
omb eseten), vagy az indexeinek egy sorozata (t
obbdimenzios t
omb eseten) segtsegevel. Mindegyik indexnek valamely diszkret tpushoz kell tartoznia, s a megengedett intervallumba kell esnie Torzs (Body). A t
orzs denialja egy alprogram, package vagy egy task hatasat A csonk

a t
orzs egy sajatos formaja, ami azt jelzi, hogy a t
orzset egy
onalloan fordthato alegysegben adjuk meg. Use utas
t
as (Use clause). A use utastas egy package lathato reszeben lev}o deklaraciokat kozvetlenul lathatova tesz. Utas
t
as (Statement). Egy utastas egy vagy t
obb olyan tevekenyseget denial, amik a program futasa soran hajtodnak vegre. Val
os t
pus (Real type). A valos tpus egy tpus, amelynek ertekei a valos szamok k
ozeltesei. A valos tpusoknak ket fajtaja van: A xpontos tpusokat a k
ozeltes megengedett abszolut hibajaval, a lebeg}opontos tpusokat a k
ozeltes relatv hibajaval (az abrazolashoz felhasznalhato decimalis jegyek r
ogztesevel) denialjuk. Vari
ans r
esz (Variant part). A rekord tpus varians resze a diszkriminanstol f
ugg}oen denialja a rekord komponenseit. A diszkriminans minden egyes ertekehez hozzatartozik a komponensek egy pontosan denialt halmaza. 130 Ada

V
altoz
o (Variable). Ld objektum V
egrehajt
as (Execution). Azt a folyamatot, amelynek soran egy utastas kifejti a hatasat, az utastas vegrehajtasanak mondjuk. With utas
t
as (With clause). Ld fordtasi egyseg Fuggelek 131 C) Az Ada szintaktikus szab
alyai n
evsorba 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> <base> ::= <integer> <based integer> ::= <extended digit> f  <underline> ] <extended digit> <based literal> ::= <base> # <based integer>  . <based integer> ] #

<exponent> <basic declaration> ::= <object declaration>j<number declaration> j<type declaration>j<subtype declaration>j<subprogram declaration> j<package declaration>j<task declaration>j<generic 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> ] begin <sequence of statements>  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 => <sequence of statements> <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>  <sequence of statements> ] 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 <decimal literal> ::= <integer>  . <integer> ]  <exponent> ] <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> : <type mark>  := <expression> ] <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 <extended digit> ::= <digit>j<letter> <factor> ::= <primary>  * <primary> ] j abs <primary>j not <primary> <xed accuracy denition> ::= delta <static simple expression> <xed point constraint> ::= <xed accuracy denition>  <range constraint> ] <oating accuracy denition> ::= digits <static simple expression> <oating point constraint> ::= <oating accuracy denition>  <range constraint> ] <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>  <generic actual part> ]  j function <designator> is new <generic function name>  <generic actual part> ]  <generic parameter declaration> ::= <identier list> :  in  out ] ] <type mark>  := <expression> ]  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  else <sequence of statements> ] 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> <integer> ::= <digit> f  <underline> ] <digit>g <iteration scheme> ::= while <condition> j for <loop parameter

specication> <label> ::= << <label simple name> >> <later declarative item> ::= <body>j<subprogram declaration> j<package declaration>j<task declaration>j<generic 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 <sequence of statements> 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>  <numeric literal> ::= <decimal literal>j<based literal> <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  <declarative part> ]  begin <sequence of statements>  exception <exception handler> f<exception handler>g ] ] end  <package simple name> ]  <package declaration> ::= <package specication> 

<package specication> ::= package <identier> is f<basic declarative item>g  private f<basic declarative item>g ] end  <package simple name> ] <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  else <sequence of statements> ] 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  <declarative part> ] begin <sequence of statements>  exception <exception handler> f<exception handler>g ] 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  <declarative part> ] begin <sequence of statements>  exception <exception handler> f<exception handler>g ] 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>  <sequence of statements> ] 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 feladatokat, amelyek megoldasa valamivel nehezebb, egy csillaggal ( 1 *), azokat pedig, amelyek hosszabb gondolkodast igenyelnek, ket csillaggal ( 1 *) jeloltuk meg. 1.  1 Keszts
unk egy programot, ami kiszamtja a  k
ozelt}o erteket az alabbi keplet alapjan! a) 2 = 21  23  34  45  56  67  ::: b)  = 4(1 ; 13 + 51 + 17 + :::) c)  = 3 + 4( 2  13  4 ; 4  15  6 + 6  17  8 ; :::) 2.  1 Keszts
unk egy programot, ami " pontossaggal kiszamtja az alabbi k
ozelt}o erteket! a) ln 2 = 1 ; 21 + 13 ; 14 + 15 ; 16 + ::: 3 4 2 b) ln(1 + x) = x ; x2 + x3 ; x4 + ::: 3 5 c) ln x = 2 ( xx +; 11 + 3((xx;+1)1)3 + 5((xx;+1)1)5 + :::) 3.  1 Keszts
unk egy programot, ami kinyomtatja a k
ovetkez}o o
sszeg els}o N reszlet
osszeget! a) inf X np! n=1 n n inf X ((n + 1)!)n b) 2!4! ::: (2n)! n=1 Feladatok 139 4.  1 F
uggvenyek egy sorozatat az alabbi modon

denialjuk: u1(t) = 1 u2 (t) = t uk+1(t) = 2tuk (t) ; uk;1(t) (k = 2 3:::n ; 1). Keszts
unk programot, ami adott n es t ertekekre meghatarozza un(t) erteket! 5.  1 Keszts
unk olyan eljarast, ami az adott nh egesz es y0 valos ertekekb}ol 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) 6.  1 Adott a valos AN vektor. Hatarozzuk meg S erteket az alabbi formula alapjan: N N X X a) S = N 1; 1 (ai ; N1 a2j ) i=1 j =1 v u 2 u N N X X u 1 1 b) S = t N a2i ; ( N aj ) i=1 j =1 7.  1 Keszts
unk programot az alabbi o
sszeg kiszamtasara (a0 , b0 es " adott kezd}oertekek): a2 ;X b2 <" 1 S = 1; 2 2n(a2n ; b2n ) ahol n=0 n n p an = 12 (an;1 + bn;1) bn = an;1 bn;1 8.  1 Adottak a valos Xn es Yn vektorok. Keszts
unk programot az ak egy
utthatok kiszamtasara az alabbi formula alapjan: n ypi uk (xi )  k = 1:::n 4 X

ak = n 2 i=1 1 ; xi u1(z) = 1 u2(z) = z uk+1(z) = 2zuk (z) ; uk;1(z) k = 2:::n 9.  1 Keszts
unk programot az alabbi
osszeg kiszamtasara: 2N 2 4 a) S = 1 + x + x2! ; 34!x + ::: + (;1)N ;1 (2N(2;N1))!x  140 Ada b) S = 23 sin 2x ; 38 sin 3x + ::: + (;1)N N 2N; 1 sin Nx 10.  1 Keszts
unk olyan programot, ami kiszamtja az alabbi t
ort erteket! 1 1 + 3+ 1 1 1 :::n+ n+1 11.  1 Keszts
unk olyan programot, ami " pontossaggal kiszamtja k px erteket az 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 ; 12 (k ; 1) ykn ) n 12. a) b) c)  1 Adottak egy valos vektorban egy polinom egy
utthatoi. Keszts
unk olyan programot, ami kiszamtja a derivaltjanak egy
utthatoit! Keszts
unk olyan programot, ami kiszamtja a integraljanak egy
utthatoit! Keszts
unk olyan programot, ami kiszamtja a negyzetenek egy
utthatoit! 13.  1 Keszts
unk olyan eljarast,

amelynek bemen}o parameterei egy m-ed es egy n-ed rend}u polinom egy
utthatoit tartalmazo vektorok, kimen}o parametere egy m+n hosszusagu vektor, s az eljaras kiszamtja a szorzatpolinom egy
utthatoit! 14.  3 Keszts
unk olyan modult, ami polinomokra vonatkozo eljarasokat exportal (polinomok
osszeadasa, kivonasa, szammal valo szorzasa stb.)! 15.  1 Adott a valos A szam. Keszts
unk olyan programot, ami meghatarozza az S es N szamokat ugy, hogy S  N minimalis legyen, es j NS ; A j< " teljes
ulj
on! 16.  1 Keszts
unk olyan programot, ami " pontossaggal kiszamtja tg z erteket az alabbi rekurzv formula alapjan (feltessz
uk, hogy z 6= 2 n(n = 1 2:::)) : 2 tg z = 1 ;z y  yi = i ;zy 3 i+2 17.  1 Keszts
unk olyan programot, ami kiszamtja Cnp erteket az alabbi rekurzv formulak alapjan: C11 = 1 Cnp+1 = pn +; p1 Cnp Cnp+1 = Cnp;1 + Cnp 18.  3 Keszts
unk generic package-t a komplex szamok kezelesere! Az elemi

aritmetikai operaciokon kv
ul keszts
unk f
uggvenyeket az alabbiak kiszamtasara Feladatok 141 is (a egy komplex szamot jel
ol, (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 3 5 7 sin a = a ; a3! + a5! ; a7! + ::: 4 6 2 cos a = 1 ; a2! + a4! ; a6! + ::: 19.  3 Keszts
unk 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 Keszts
unk olyan programot, ami meghata2 rozza azoknak az egesz koordinataju pontoknak a szamat, amelyek az y16 + x252 + 1 = 0 ellipszisbe esnek! 21.  1 Keszts
unk olyan programot, ami sz
ogf
uggvenytablazatot nyomtat! 22.  1 Keszts
unk egy olyan programot, ami kinyomtatja az alabbi f
uggveny ertekeinek tablazatat az ab] intervallumban 0.5 lepesk
ozzel! 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 elenged
unk, 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 Keszts
unk egy olyan programot, ami a tanult k
ozelt}o eljarasok valamelyikenek felhasznalasaval megkeresi az alabbi egyenlet egy gy
oket (pl. intervallumfelezes, hurmodszer)! a) x3 ; 2x + 1:2 = 0 b) x5 ; 0:5 = 0 c) ex ; x2 + 1 = 0 d) ex ; x2 ; 2 = 0 a ;2 ;1] intervallumban a 0 1] intervallumban a ;2 ;1] intervallumban a 0:5 0:6] intervallumban 142 Ada 25.  1 Keszts
unk egy olyan programot, ami a tanult k
ozelt}o eljarasok valamelyikenek felhasznalasaval kiszamolja az alabbi f
uggveny hatarozott integraljat (pl. Simpson-modszer, trapez formula)! a) b) Z1 ;1 Z1 ;1 (1 + sin x)2

p x2 + x2 + 0:1 Z1 x c) ;1 1 + x2 Z ;1:5 d) ;2 x3 ; 3x2 ; x + 9 26.  2 Keszts
unk programot, ami Monte-Carlo modszerrel kiszamtja az (x ; 0:5)2 + (y ; 0:5)2 < 0:25 k
orlap ter
uletet! (A lltsunk el}o kb. 200 pontot egyenletes eloszlassal veletlenszer}uen a ;1 1]  ;1 1], tartomanyban, majd vizsgaljuk meg, hogy a pontok k
oz
ul hany esik a k
orlapra.) 27.  2 Keszts
unk programot, ami Monte-Carlo modszerrel kiszamtja egy f
uggveny hatarozott integraljat! (Foglaljuk teglalapba a f
uggvenyt az intervallum hatarai es a f
uggveny egy also- es egy fels}o korlatja segtsegevel. A lltsunk el}o egyenletes eloszlassal veletlenszer}uen pontokat, s allaptsuk meg, hogy a f
uggvenyg
orbe alatt vagy felett vannak-e. Ezutan egy osztassal megkaphato a g
orbe alatti ter
ulet k
ozeltese) 28.  2 Keszts
unk 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 Keszts
unk egy olyan programot, ami a Runge-Kutta modszer felhasznalasaval 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 Keszts
unk 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 31.  1 Keszts
unk egy olyan programot, ami a Newton-modszer (xk+1 = xk ; 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 Keszts
unk 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 Keszts
unk egy olyan programot, ami a Gauss-modszer felhasznalasaval megoldja az alabbi egyenletrendszert! 7:9x1 a) 84::53xx1 1 3:2x1 + 5:6x2 ; 4:8x2 + 4:2x2 ; 1:4x2 + 5:7x3 + 0:8x3 ; 3:2x3 ; 8:9x3 ; 7:2x4 + 3:5x4 + 9:3x4 + 3:3x4 = 6:68 = 9:95 = 8:6 = 1: 6x1 ; x2 ; x3 = 11:33 b) ;x1 + 6x2 ; x3 = 32 ;x1 ; x2 + 6x3 = 42: 34.  2 Keszts
unk olyan programot, ami eld
onti, hogy az x1 = (5 ;3 2 4)x2 = (2 ;1 3 5)x3 = 4 ;3 5 ;7) vektorok linearisan f
uggetlenek-e! (A feladat visszavezethet}o a 1 x1 + 2x2 + 3x3 = 0 egyenlet megoldasara. Hasznaljuk erre a Gauss-Jordan modszert!) 35.  1 Keszts
unk olyan programot, ami kirja adott A0 t}oke 1,2,.,10 evi kamatos kamattal n
ovelt ertekeinek tablazatat (p a kamatlab) : p

)n A = A0 (1 + 100 144 Ada 36.  1 Keszts
unk egy olyan programot, ami kinyomtatja egy adott ev adott honapjanak naptarat! 37.  1 Az egyetemen a penztar olyan cmletekben zeti ki a hallgatok
oszt
ondjait a csoportvezet}onek, hogy az mindenkinek odaadhassa az
oszt
ondjat tovabbi penzvaltas es -visszaadas nelk
ul, s k
ozben a penztar a lehet}o legkevesebb bankjegyet es ermet adja ki. Keszts
uk el a cmletezes programjat, aminek adata a csoport tagjainak
oszt
ondjai, eredmenye az, hogy hany darab 1000, 500-, 100-, 50-, 20-, 10-, 5-, 2- es 1-forintost kell a csoportvezet}onek kiadni! 38.  1 Adott egy 1582 es 4902 k
oz
otti datum (ev, honap, nap). Keszts
unk programot, ami megallaptja, hogy ez hanyadik nap az evben! 39.  1 Keszts
unk programot, ami megallaptja, hogy egy adott datum hanyadik munkanap az evben, ill. megfordtva, ami meg tudja adni, hogy az n: munkanap az ev melyik napjara esik! (Az u
nnepnapok egy resze | pl a

karacsony | ismert, masok egy tablazatban adottak.) 40.  3 Keszts
unk egy modult a datum (ev, honap, nap) tpus megvalostasara, a datumok k
oz
otti aritmetikai m}uveletek (datum + valahany nap, ket datum k
oz
ott eltelt napok szama, ket datum k
oz
ul melyik a korabbi stb.) elvegzesere! 41.  1 Keszts
unk programot, ami meghatarozza egy adott evben az
osszes olyan penteki napot, ami 13-ara esik! 42.  1 Keszts
unk programot, ami a termeszetes szamok szamjegysorozataban meghatarozza az n. szamjegyet! 43.  1 Keszts
unk programot, ami megszamolja, hogy az m es n k
oz
ott elhelyezked}o termeszetes szamok
osszesen hany szamjegyb}ol allnak! 44.  1 Keszts
unk olyan programot, ami meghatarozza azokat a haromjegy}u termeszetes szamokat, amelyek szamjegyeinek k
ob
osszege kiadja magat a szamot! 45.  2 Keszts
unk olyan programot, ami meghatarozza azokat a termeszetes szamokat, amelyekre teljes
ul, hogy felrasukban es

negyzet
uk felrasaban egy
uttesen a 0 -t kiveve minden szamjegy szerepel, de csak egyszer! 46.  1 Keszts
unk olyan programot, ami meghatarozza azokat a di termeszetes szamokat,Pamelyekre teljes
ul, 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! 47.  2 Keszts
unk programot, ami egy adott N termeszetes szamot felbont ket prmszam
osszegere (nem bizonytott, hogy ez mindig lehetseges)! 48.  2 Barmely termeszetes szam el}oallthato legfeljebb negy termeszetes szam negyzet
osszegekent. Keszts
unk programot, ami egy adott N termeszetes Feladatok 145 szamhoz megadja azokat a termeszetes szamokat, amelyek negyzet
osszegekent el}oallthato! 49.  2 Keszts
unk programot, ami egy adott N termeszetes szamrol megallaptja, hogy el}oallthato-e harom termeszetes szam negyzet
osszegekent, s ha igen, akkor felsorolja az
osszes ilyen el}oalltast! 50.  2 Keszts
unk

programot, ami egy adott N termeszetes szamhoz megadja az N -nel kisebb 2p ; 1 alaku termeszetes szamokat, ahol p prmszam! 51.  1 Keszts
unk programot, ami meghatarozza azt a legnagyobb N termeszetes szamot, amire N !  1050! 52.  1 T
okeletesnek nevezz
uk azokat a termeszetes szamokat, amelyek osztoinak (az 1 -et beleertve, de
onmagat nem)
osszege kiadja magat a szamot. Keszts
unk programot, ami M es N k
oz
ott megadja az
osszes t
okeletes szamot! 53.  1 Ismert, hogy az m es n nemnegatv egesz szamok (m  n) legnagyobb k
oz
os osztoja meghatarozhato az alabbi rekurzv f
uggveny ertekenek kiszamtasaval:  ha n = 0 lnko(mn) = m m lnko(n  n ])  ha n 6= 0 a) Keszts
unk programot ket termeszetes szam legnagyobb k
oz
os osztojanak meghatarozasara! b) Keszts
unk programot n db termeszetes szam legnagyobb k
oz
os osztojanak meghatarozasara! (lnko(a1 :::an) = lnko(lnko(a1:::an;1)an).) c) Keszts
unk programot ket

termeszetes szam legkisebb k
oz
os t
obssz
or
osenek meghatarozasara! 54.  1 Adott az N termeszetes szam. Keszts
unk programot, ami megallaptja, hogy a) igaz-e, hogy a szamban minden szamjegy k
ul
onb
oz}o! b) igaz-e, hogy a szamban egy szamjegy haromszor szerepel, a t
obbi szamjegy pedig mind k
ul
onb
oz}o! 55.  1 Keszts
unk 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 56.  1 Keszts
unk programot, ami prmtenyez}oire bontja az N termeszetes szamot (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 felezz
uk, k
ul
onben szorozzuk meg harommal, majd adjunk hozza egyet, s ismetelj
uk

146 Ada ezt a m}uveletet, amg 1 -et nem kapunk! Keszts
unk 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.) 58.  2 Keszts
unk programot, ami meghatarozza az a0 a1 :::an szamsorozat elemeit (ai 2 f;1 0 1gan 6= 0) ugy, hogy Pni=0 ai 3i egy el}ore megadott ertek legyen! 59.  2 Keszts
unk 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 Keszts
unk modult tetsz}oleges elemekb}ol allo sorozat tpus megvalostasara! 61.  2 Keszts
unk programot linearis egyenletrendszer megoldasara a triangularis felbontas modszerevel! 62.  3 Keszts
unk olyan modult, ami egy tetsz}oleges elemekb}ol allo vektor rendezesere exportal k
ul
onb
oz}o eljarasokat (quicksort, heapsort

stb.)! 63.  3 Keszts
unk olyan modult, ami numerikus elemekb}ol allo vektorokon ertelmezett m}uveleteket exportal (
osszeadas, szorzas, norma szamolasa, mer}olegesseg ellen}orzese stb.)! 64.  3 Keszts
unk 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 Keszts
uk el a f}oatlora szimmetrikus matrixok tpusanak egy hely szempontjabol gazdasagos reprezentaciojat, s rjuk meg a tpusm}uveletek alprogramjait (indexeles, matrixok
osszeadasa, kivonasa, szorzasa, szammal valo szorzasa, matrixokon ertelmezett relaciok stb.)! 66.  3 Keszts
uk el egy ritka (hezagosan kit
olt
ott) matrix tpusnak a hely szempontjabol gazdasagos reprezentaciojat, s rjuk meg a tpusm}uveletek alprogramjait (indexeles, matrixok o
sszeadasa, kivonasa, szorzasa, szammal valo szorzasa,

matrixokon ertelmezett relaciok stb.)! 67.  1 Keszts
unk olyan programot, ami meghatarozza egy vektor ertek szerint k
ozeps}o elemet! 68.  1 Adott egy egesz szamokbol allo vektor es egy K egesz szam. Keszts
unk olyan programot, ami atrendezi a vektor elemeit ugy, hogy a K -nal kisebb elemek allnak el
ol! 69.  1 Keszts
unk 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 Keszts
unk olyan eljarast, ami a parameterkent kapott negyzetes matrixot az ora jarasa szerint 90 fokkal elforgatja! 71.  1 Keszts
unk olyan programot, ami a 2n meret}u A matrixot blokkokra osztja 1 A2 A= A A3 A4 alakban, majd a blokkokat felcsereli: A1 -et A4 -el, A2 -t pedig A3 -mal! 72.  1 Keszts
unk olyan eljarast, ami az adott Xn vektorrol eld
onti, hogy az az 1,.,n szamok permutacioja-e! 73.  1 Az AN vektor termeszetes szamokat

tartalmaz. Hatarozzuk meg azoknak az elemeknek az indexet, amelyek
osszege megegyezik egy el}ore adott ertekkel! 74.  1 Az AN vektor termeszetes szamokat tartalmaz. Hatarozzuk meg azoknak az elemeknek az indexet, amelyek (a vektorbeli sorrendj
ukben) a leghosszabb n
ovekv}o sorozatot alkotjak! 75.  1 Keszts
unk olyan eljarast, ami az adott Xn vektor ismereteben meghatarozza a Pn vektor erteket ugy, hogy P az 1,.,n szamok permutacioja legyen es teljes
ulj
on xp  xp +1 (i = 1:::n ; 1)! i i 76.  2 * Adott egy valos matrix es egy R valos szam. Bontsuk a matrixot a lehet}o legkevesebb reszmatrixra ugy, hogy egy reszmatrixon bel
ul barmely ket elem k
ul
onbsege kisebb legyen R -nel! 77.  2 Keszts
unk programot, ami kiszamolja egy matrix sajatertekeit es sajatvektorait a Jacobi-modszer alapjan! 78.  3 Keszts
unk generic package-ket k
ul
onfele numerikus modszerekre! 79.  1 Keszts
unk olyan programot, ami egy negyzetes

matrixot felbont ket matrix
osszegere ugy, hogy az egyik tag szimmetrikus, a masik ferden szimmetrikus legyen! A = S + T S = 12 (A + A ) T = 12 (A ; A ) 80.  1 Keszts
unk olyan programot, ami egy negyzetes matrixrol eld
onti, hogy az elemek atrendezesevel szimmetrikus matrixsza tehet}o-e! 81.  1 Legyen A(1) A(2)::: negyzetes binaris matrixok egy sorozata, ahol A(i) dimenzioja 3i . Keszts
unk programot az A(i) matrix el}oalltasara, ha A(1) = 01 @0 1 0 1 1 0 A 1 0 1 A(i) = 0 A(i;1) 0 A(i;1) 1 @ 0 A(i;1) 0 A ! A(i;1) 0 A(i;1) 148 Ada 82.  1 * Adott az egeszekb}ol allo Cmn matrix es a Dm vektor. Keszts
unk programot annak a csak 0 es 1 szamokat tartalmazo Xn vektornak az el}oalltasara, amelyre C  X = D! 83.  1 Adott az SN szamsorozat. Egeszts
uk ki a sorozatot tovabbi M darab szam hozzavetelevel (sN +1:::sM ) ugy, hogy teljes
ulj
on az alabbi feltetel: s1 = sM s2 = sM ;1  .! 84.  2 Adott a skon

koordinataival N darab pont. K
oss
uk
ossze a pontokat egy olyan vonallal, ami mindegyik ponton (pontosan egyszer) atmegy, s nem metszi
onmagat! 85.  1 Az y = ax + b1 es az y = ax + b2 egyenesek a skot harom tartomanyra osztjak. Keszts
unk olyan programot, ami megallaptja, hogy adott N darab pont k
oz
ul melyik hanyadik tartomanyba esik! 86.  1 Adott a skon N db k
or. Keszts
unk olyan programot, ami megallaptja, hogy a k
or
ok k
oz
os resze u
res-e! 87.  1 Adott vegpontjai koordinataival a skon ket szakasz. Hatarozzuk meg a metszespont koordinatait! 88.  1 Adott koordinataival a sk N pontja. Rakjuk sorba a pontokat a rajtuk es az origon athalado egyenesnek az x - tengellyel bezart sz
oge szerint n
ovekv}o sorrendbe! 89.  2 Adott koordinataival a sk N pontja. Hatarozzuk meg a ponthalmaz konvex burkat! 90.  2 Adott koordinataival a sk N pontja. Hatarozzuk meg a ponthalmazhoz a legkisebb olyan negyzetet, amelybe mindegyik pont

beleesik! 91.  2 Adott koordinataival a sk N pontja. Keszts
unk programot, ami kivalaszt harom olyan pontot, amelyek (legfeljebb " elterest megengedve) egy egyenesre esnek! 92.  1 Adott a skon csucspontjai koordinataival egy soksz
og (a csucspontokat a ker
uleten az ora jarasa szerint elfoglalt hely
uk sorrendjeben adjuk meg). Keszts
unk programot, ami eld
onti, hogy a soksz
og konvex-e! 93.  1 Keszts
unk egy olyan programot, ami egy alfanumerikus keperny}ore valamilyen jelekb}ol (pl. csillagokbol) egy adott sugaru k
ort rajzol! 94.  1 Keszts
unk egy olyan programot, ami egy alfanumerikus keperny}ore valamilyen 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.  1 Keszts
unk egy olyan programot, ami egy alfanumerikus keperny}ore vala- Feladatok 149 milyen jelekb}ol (pl. csillagokbol) kirajzolja egy f
uggveny grakonjat! 4 8 a) y = xx3

+ + 1  a ;1 1] intervallumban b) y = sin x2 a 0] intervallumban 96.  2 Egy veletlenszamgeneratort ellen}orz
unk abbol a szempontbol, hogy a (0,1) intervallumban elegge egyenletesen generalja-e a szamokat. Ehhez az intervallumot k egyenl}o reszre osztjuk, majd generalunk n db veletlenszamot Rajzoljunk hisztogramot! 97.  2 Ha ri -k egyenletes eloszlasu veletlenszamok a ;1 1] intervallumban, akkor az alabbi kepletekkel megadott pontok egyenletes eloszlasuak az egysegg
omb
on. Keszts
unk programot, ami ellen}orzi, hogy a pontok eloszlasa valoban egyenletes-e! r3 )  x = r22(+r2rr24++rr21+ r2 1 2 3 4 y = r22(+r3rr24+;rr21r+2 )r2  1 2 3 4 2 1 2 1 2 4 2 2 2 2 2 3 2 3 2 4 z = rr ++rr +; rr ;+rr  4 X ahol r2 < 1: i=1 i 98.  1 Adott a skon szemk
ozti csucsai koordinataival egy teglalap, amelynek oldalai parhuzamosak a koordinata-tengelyekkel, es adott a vegpontjai koordinataival egy szakasz. Keszts
unk olyan programot, ami

kiszamtja a szakasznak azt a darabjat, ami a teglalapon bel
ulre esik (lehet, hogy a teljes szakasz kv
ul esik a teglalapon)! 99.  2 * Rendelkezes
unkre all a Balaton vzfelszne igen sok pontjanak azonos id}oben mert h}omerseklete. Keszts
unk programot a h}omersekletek szintvonalas abrazolasara! 100.  3 Keszts
unk olyan modult, ami sz
ovegben egy adott sz
oveg megkeresesere k
ul
onb
oz}o eljarasokat exportal! 101.  3 Keszts
unk olyan modult, ami u j tpusm}uveleteket ad a STRING tpushoz (karakter vagy string keresese stringben, az
osszes szok
oz kihagyasa a stringb}ol, kiveve azokat, amelyek nem szok
oz utan k
ovetkeznek, stringek
osszehasonltasa a szok
oz
ok gyelmen kv
ul hagyasaval, stringbe egy string beszurasa, stringb}ol egy reszstring elhagyasa stb.)! 150 Ada 102.  1 Keszts
unk rekurzv eljarast, ami a) egy sz
ovegb}ol kihagyja a szok
oz
oket! b) egy sz
ovegben megszamolja a maganhangzokat! 103.  1 Keszts
unk

programot, ami egy 4000-nel kisebb termeszetes szamot romai szamma alakt at! 104.  3 Keszts
unk olyan modult, ami romai szamokon vegez el aritmetikai m}uveleteket! 105.  1 Keszts
unk programot, ami egy sz
ovegben megkeresi a magas-, mely- es vegyes hangrend}u szavakat! 106.  2 * Keszts
unk programot, ami egy verset u gy nyomtat ki, hogy bejel
oli az id}omerteket! 107.  2 * Keszts
unk egy interaktv programot, ami a beolvasott szavakat szotagolva rja vissza! 108.  2 * Keszts
unk egy olyan programot, ami egy termeszetes szamot bet}ukkel kir! (Tehat pl. 241 eseten a Kett}oszaznegyvenegy sz
oveget nyomtatja) 109.  1 Az egyik legegyszer}ubb titkosrast az ABC bet}uinek ciklikus eltolasabol kaphatjuk meg. Keszts
unk olyan programot, ami egy sz
oveget kodol ugy, hogy minden bet}u helyebe az ABC-ben nala adott hellyel hatrabb lev}o bet}ut teszi! 110.  2 Egy titkosrast a k
ovetkez}o modon keszt
unk el: helyezz
unk el bet}uket egy

negyzetes matrixban, s erre tegy
unk ra egy negyzetracsos lapot, amelynek negyzetei egy-egy bet}u f
ole 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 sz
oveget. Keszts
unk egy programot, ami a fenti modon megfejt egy titkostott sz
oveget! 111.  2 A titkosras egy modja a k
ovetkez}o is: rjuk be a sz
oveget mondjuk sorfolytonosan egy matrixba, majd a k
ozeps}o elemt}ol elindulva es spiralisan kifele tartva jarjuk be a matrix elemeit. Az gy kapott karaktersorozat a titkostott sz
oveg Keszts
unk egy programot, ami a fenti modon titkost es megfejt egy sz
oveget! 112.  2 Keszts
unk egy programot, ami egy veletlenszamgenerator felhasznalasaval titkost egy sz
oveget! Inicializaljuk a veletlenszamgeneratort egy olyan ertekkel, amit

megjegyz
unk, s amire sz
ukseg
unk lesz majd a megfejteskor is. A lltsunk el}o pontosan annyi egyenletes eloszlasu veletlenszamot 1 es 4 k
oz
ott, mint amilyen hosszu a sz
oveg. Ezutan a sz
oveg minden karakteret cserelj
uk 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 sz
oveget u
res sorokkal tagoltuk bekezdesekre. Keszts
unk olyan programot, ami ugy nyomtatja a le tartalmat, hogy az egyes bekezdesek els}o sora el}ott harom szok
ozt hagy, s a bekezdeseken bel
ul a sorokat egyforman 60 hosszusagura hozza (ez t
ortenhet szavak athelyezesevel a k
ovetkez}o sorba, a k
ovetkez}o sorbol szavak athozasaval, szok
oz
ok beszurasaval, esetleg szavak elvalasztasaval)! 114.  2 Keszts
unk programot, ami egy karaktersorozatrol eld
onti,

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 kifejezes is zarojelben van). a) Keszts
unk olyan programot, ami eld
onti, hogy a zarojelezes helyes-e! b) Keszts
unk olyan programot, ami megadja (kirja) az
osszes zarojelezett reszkifejezest! 116.  2 Keszts
unk olyan programot, ami el}oalltja az
osszes helyes N hosszusagu 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. Keszts
unk egy olyan programot, ami a kifejezest fordtott lengyel formara hozza! 118.  2 * Adott egy kifejezes, ami egybet}us vatozokbol, zarojelekb}ol es binaris operatorokbol (+,-,*,/) all. Keszts
unk egy olyan programot, ami kiszamtja a

kifejezeshez az alabbiakban denialt az S (K ) erteket! Irjuk fel a kifejezes szintaxisfajat, jel
olje a fat K , a baloldali reszfat Kl , a jobboldalit Kr . Ha K az u
res fa, akkor S (K ) = 0, k
ul
onben pedig a k
ovetkez}o rekurzv formulaval adjuk meg az erteket: (Kl ) + 1  ha Kl = Kr S (K ) = Smax (S (Kl )S (Kr ))  k
ul
onben 119.  2 * Adott egy kifejezes, ami egybet}us vatozokbol, zarojelekb}ol es binaris operatorokbol (+,-,*,/) all. Keszts
unk egy olyan programot, ami kiszamtja a kifejezes szintaxisfajanak magassagat! 120.  2 * Adott egy kifejezes szintaxisfajanak preorder es inorder bejarasa soran kapott sorozat. Keszts
unk programot, ami ebb}ol el}oalltja a szintaxisfa postorder bejarasakor el}oallo szimbolumsorozatot! 121.  2 * Keszts
unk olyan programot, ami beolvas egy logikai kifejezest, es kinyomtatja az igazsagtablajat! A kifejezes egybet}us valtozokat, logikai operatorokat es (kerek) zarojeleket

tartalmazhat. (Egyszer}ubb a feladat, ha feltessz
uk, hogy a kifejezes szintaktikusan helyes.) 152 Ada 122.  2 Adott egy sz
ovegle, amelynek a sorai nem haladjak meg a 80 karaktert. Masoljuk at a le-t ugy, hogy a szavak k
oze szok
oz
oket beszurva minden sort kiegeszt
unk 80 hosszusagura! 123.  2 Adott egy le-ban egy sz
oveg, ami csak bet}ukb}ol all. Nyomtassuk a sz
oveget ugy, hogy minden bet}ut Morze-jelekkel abrazolunk! A Morze-jelek k
oz
ott hagyjunk egy-egy szok
ozt, es egy szot nyomtassunk egy sorba! 124.  4 Keszts
unk egy interaktv szotarprogramot! A program szamara lehessen denialni egy angol szo jelenteset, es lehessen visszakerdezni egy szo jelenteset! Visszakerdezeskor engedj
uk meg, hogy a kerdezett szavakat r
ovidtsek! A denialt szavakat taroljuk lemezen! (A gyors visszakereses erdekeben hasznalhatunk pl. kiegyensulyozott binaris fat)  llaptsuk meg ket stringr}ol, hogy azok a szok
oz
okt}ol eltekintve 125.

 1 A megegyeznek-e! 126.  1 Adva van egy tavirat sz
ovege. Keszts
unk programot, ami meghatarozza a tavirat tovabbtasaert zetend}o djat! 127.  2 Adva van egy nevsor, amiben a nevek egy vezeteknevb}ol, es valahany utonevb}ol allnak. Keszts
unk programot, ami ugy rja ki a neveket, hogy a vezeteknevnek csak a kezd}obet}uje legyen nagy bet}u, a vezeteknev bet}ui k
oz
ott legyen egy-egy szok
oz, majd utana egy vessz}o, s ezutan csak az utonevek nagy kezd}obet}ui alljanak, mindegyik ponttal lezarva! 128.  2 Tegy
uk fel, hogy horizontalis tabulator karaktereket tartalmazo sz
oveget akarunk listazni olyan nyomtaton, ami nem ismeri a tabulatorokat. Keszts
unk egy programot, ami el}okeszti a sz
oveget a nyomtatashoz: a tabulator karaktereket a megfelel}o szamu szok
ozzel helyettesti! Tegy
uk fel, hogy a tabulator-pozciok az 1, 9, 17, . pozciok (A ltalanosabb lesz a megoldasunk, ha a tabulator-pozciok felsorolasaval

parameterezhet}o a programunk) 129.  2 Az el}oz}o feladat "megfordtasa" is ertelmes: Keszthet
unk olyan programot, amely egy sz
oveg-le-ban a hosszu szok
oz-sorozatokat ugy r
ovidti le, hogy tabulator karakterekkel cserel fel valahany szok
ozt. 130.  3 Keszts
unk olyan modult, ami eljarasokat exportal egy inx formaju kifejezes postx alakjanak el}oalltasara (a kifejezesben csak az aritmetikai alapm}uveletek jelei, valos szamok es zarojelek szerepelnek), es egy postx formaju kifejezes ertekenek kiszamtasara! 131.  4 * Keszts
unk egy nem interaktv sz
ovegszerkeszt}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 k
ovetkez}ok (a modosto parancsokban a sorok sorszamait n
ovekv}o sorrendben kell megadni): Feladatok 153 - #DEL sorszam f , sorszam g | t
orli a sorszamaikkal megadott sorokat - #INC

sorszam | a megadott sorszamu sor utan beszurja a parancssor utan a k
ovetkez}o parancssorig megadott sorokat. 132.  4* Keszts
unk egy olyan programot, ami szintezve (tehat a beagyazottsaguknak megfelel}oen) kirja egy Pascal program
osszes eljarasanak nevet! 133.  4 Masoljunk at u gy egy szintaktikusan helyes Modula-2 modult, hogy a megjegyzeseket k
ozben 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 modulban, hogy melyik alapszo hanyszor szerepel! 136.  4 Gy}ujts
uk ki egy szintaktikusan helyes Modula-2 implementacios modulbol a benne denialt eljarasok es f
uggvenyek neveit! 137.  4 Egy szintaktikusan helyes Pascal programban az alapszavak bet}uit valtoztassuk nagybet}ukre, a megjegyzesek es sz
ovegliteralok bet}uit ne valtoztassuk, a t
obbi bet}ut cserelj
uk kisbet}ure! 138.  4 Keszts
unk

olyan programot, ami egy szintaktikusan helyes Ada programban megkeresi azokat a cmkeket, amelyekre nincsen hivatkozas! 139.  4 Keszts
unk programot, ami a) elemez egy karaktersorozatot, s eld
onti, 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! <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> 140.  4 Adott egy CDL-nyelv}u szabaly (programegyseg) t
orzsenek (nemileg leegyszer}ustett) szintaxisa. Keszts
unk programot, ami egy stringr}ol eld
onti, 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}ustett) szintaxisa. Keszts
unk programot, ami egy stringr}ol eld
onti, 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 Keszts
unk egy telefonos informaciokat nyilvantarto programot! A program adjon lehet}oseget a nev es a telefonszam szerinti visszakeresesre is! 143.  4 * Keszts
unk 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 Keszts
unk programot k
onyvtari k
olcs
onzesek nyilvantartasara es a nyilvantartas lekerdezesere! 145.  4 * Keszts
unk 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 tartalmazzak. A harmadik le az elert eredmenyeket tartalmazza olymodon, hogy egy rekord a versenyz}o rajtszamabol, a versenyszam megnevezeseb}ol es az elert pontszambol all.

Keszts
unk tablazatot az egyeni versenyr}ol es a csapatok 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}ujt
ott kartyakat minden ora vegen egy-egy zsakba zarjak. A Feladatok 155 kartyak megszamlalasa utan ismerj
uk minden allomasra minden ora vegen az egyes allomasokrol erkezett utasok szamat. Keszts
unk olyan programot, ami k
ul
onfele grakonok nyomtatasaval segti az adatok kiertekeleset! 148.  3 Keszts
unk egy tetsz}oleges elemekb}ol allo halmazt megvalosto modult (a halmazt reprezentalhatjuk pl. egy hash-tablaval)! 149.  3 Keszts
unk egy tetsz}oleges elemekb}ol allo ketiranyu listat megvalosto modult (Create, PutFirst, Put, PutLast, GetFirst, Get, GetNext, GetPrev, Overwrite, Seek, Delete, Concat,

Isempty, Length m}uveletekkel)! 150.  3 Keszts
unk egy tetsz}oleges elemekb}ol allo rendez}o-fat megvalosto modult (create, isempty, write, rst, read m}uveletekkel)! 151.  3 Keszts
unk egy tetsz}oleges elemekb}ol allo n-aris fat megvalosto modult! 152.  2 Keszts
unk olyan programot, ami eld
onti egy iranytatlan egyszer}u grafrol, hogy van-e olyan k
ore, ami minden csucson athalad! 153.  1 Keszts
unk olyan programot, ami eld
onti egy iranytatlan egyszer}u grafrol, hogy van-e olyan csucsa, amit minden mas csuccsal el k
ot
ossze! 154.  1 Keszts
unk olyan programot, ami eld
onti egy iranytatlan egyszer}u grafrol, hogy az teljes graf-e (vagyis, hogy barmely ket csucsa o
ssze van-e k
otve)! 155.  1 Keszts
unk olyan programot, ami meghatarozza egy iranytatlan egyszer}u graf komplementer grafjat (azaz: megadja, hogy milyen eleket kellene hozzaadni a grafhoz, hogy teljes grafot kapjunk)! 156.  2 * Keszts
unk programot, ami

meghatarozza egy iranytatlan graf
osszes teljes reszgrafjat! 157.  2 * Keszts
unk 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 * Keszts
unk programot, ami egy iranytott grafban, ahol az elekhez hosszertekeket is rendelt
unk, megkeresi egy adott csucsbol a t
obbi csucsba vezet}o legr
ovidebb utakat! 160.  2 * Keszts
unk olyan programot, ami eld
onti egy iranytatlan egyszer}u grafrol, hogy hanyszorosan
osszef
ugg}o! 161.  2 * Keszts
unk olyan programot, ami egy grafban keres egy olyan utat a p es q csucsok k
oz
ott, ami nem halad at az x csucson! 162.  2 * Keszts
unk olyan programot, ami egy grafban meghataroz egy olyan utat, 156 Ada ami minden elet pontosan egyszer tartalmaz! 163.  2 * Keszts
unk olyan programot, ami megkeresi egy iranytatlan egyszer}u grafban a minimalis

k
ort! 164.  2 * Keszts
unk olyan programot, aminek adata ket iranytatlan egyszer}u graf, s eld
onti, hogy az els}o reszgrafja-e a masodiknak! 165.  2 * Adott egy iranytatlan, de esetleg t
obbsz
or
os eleket tartalmazo skbarajzolhato graf, ami egy kemiai szerkezet rajza. Keszts
unk olyan programot, ami megkeresi azokat az atomokat, amelyek t
obb gy}ur}uben is benne vannak! 166.  2 Adott egy iranytatlan, de esetleg t
obbsz
or
os eleket tartalmazo skbarajzolhato graf. Ez egy kemiai szerkezet rajza, ami csak a szenatomokat tartalmazza. Keszts
unk olyan programot, ami meghatarozza, hogy az egyes szenatomokhoz hany (a rajzon fel nem t
untetett) hidrogen kapcsolodik! 167.  2 * Adott egy iranytatlan, de esetleg t
obbsz
or
os eleket tartalmazo skbarajzolhato graf, ami egy kemiai szerkezet rajza. Keszts
unk olyan programot, ami megszamolja, hogy a szerkezet hany gy}ur}ut tartalmaz! 168.  2 * Keszts
unk programot, ami meghatarozza egy

iranytatlan graf egy feszt}ofajat! 169.  2 * Adva van N darab elvegzend}o feladat, s egy tablazat, amelyben felt
untett
uk, hogy melyik feladat elvegzese mennyi ideig tart, s melyek azok a feladatok, amiket csak a feladat befejezese utan lehet elkezdeni. Keszts
unk olyan programot, ami meghatarozza, hogy az
osszes feladat elvegzese legkevesebb mennyi id}ot igenyel! 170.  2 Egy csoport elemeit az 1, a, b jelekkel abrazoljuk, s adott a csoport szorzasi tablaja. Keszts
unk 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. Keszts
unk programot, ami kiszamtja a csoport generatorat (azaz: az csoport elemeinek azt a reszhalmazat, amelynek elemeib}ol szorzassal el}oallthato a csoport t
obbi eleme)! 172.  2 Adott a H es G csoport a szorzasi tablajaval. Keszts
unk programot, ami eld
onti, 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. Keszts
unk programot, ami eld
onti, hogy a csoportok izomorfak-e (azaz: talalhato-e egy-egy ertelm}u m}uvelettarto megfeleltetes a H es a G elemei k
oz
ott)! 174.  4 Az eletjatekban a sejtek egy negyzetracsba rendezve helyezkednek el, s a sejteknek 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 (k
ul
onben kihal). Keszts
unk programot, ami egy tetsz}oleges kiindulasi allapotbol kiindulva kirja egy sejtallomany megadott 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 athelyezhet
unk a szomszedos u
res lyukba, vagy pedig egy golyot atugorva a masodik lyukba (ha az u
res). A fekete golyokat azonban csak jobbra, a fehereket csak balra vihetj
uk. Keszts
unk 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 mindegyikben egy-egy fekete vagy feher golyo van. Keszts
unk programot, ami a szomszedos golyok felcserelgetesevel atmozgatja a fekete golyokat a tabla jobboldalara, a feher golyokat pedig a tabla baloldalara! 177.  4 Adott egy jatektabla, amelyen egymas mellett kilenc lyuk van, s mindegyikben egy-egy kek, feher vagy piros golyo van.

Keszts
unk programot, ami rendre tetsz}oleges ket golyot felcserelve atmozgatja a kek golyokat a tabla baloldalara, a piros golyokat a tabla jobboldalara, mg a feher golyok k
ozepen 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. Keszts
unk 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 elvesz tetsz}oleges szamu (de legalabb egy) gyufaszalat, vagy pedig mindket halombol elvesz ugyanannyi (de legalabb egy) gyufaszalat. Keszts
unk interaktv programot, ami eljatsza az egyik jatekos szerepet! 180.  2 * Keszts
unk olyan programot, ami megallaptja, hogy egy

u
res sakktablan minimalisan hany lepesre van sz
uksege egy huszarnak, hogy egy adott A mez}or}ol egy adott B mez}ore jusson! 158 Ada 181.  2 Keszts
unk programot, ami meghatarozza 12 huszarnak minden olyan elhelyezeset a sakktablan, amelyben minden mez}ot tamadnak! 182.  2 Keszts
unk egy rekurzv eljarast 8 vezer elhelyezesere egy sakktablan u gy, hogy egyik se u
sse a masikat! 183.  4 * Keszts
unk olyan programot, ami megallaptja, hogy a sakktablan egy adott allasban a) vilagos tehet-e gyaloglepest, b) vilagos kepes-e u
tni valamelyik gyalogjaval, c) vilagos kepes-e sakkot adni! 184.  4 * Keszts
unk olyan programot, ami megallaptja, hogy a sakktablan egy adott allasban vilagos hany lepest tehet! 185.  4 * Keszts
unk olyan sakkprogramot, ami a) a vilagos kirallyal es a vezerrel jatszik a s
otet kiraly ellen b) a vilagos kirallyal es ket bastyaval jatszik a s
otet kiraly ellen! 186.  4 *

Keszts
unk olyan programot, ami megallaptja, hogy a sakktablan egy adott allasban a) vilagos adhat-e mattot egy lepesben, b) vilagos adhat-e mattot n lepesben! 187.  4 Keszts
unk interaktv programot, ami segt a t
ortenelmi datumok tanulasaban! 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 ugyanezt a kerdest. 188.  4 Keszts
unk 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

f
ugg. Ezutan keszts
unk tasko(ka)t a folyamatokat szimulalasara, s helyezz
unk el a programban megfelel}o kirasokat a folyamat nyomon k
ovethet}osege erdekeben! Az egyes szemelyek parametereit valtoztatva erdekes meggyelni, hogyan valtozik az egesz rendszer m}uk
odese. Ilyen tevekenyseg lehet pl. a s
or
ozes, ahol a folytatas feltetele az, hogy a korsoban legyen meg s
or. Ebben a feladatban nyilvan sz
ukseg van egy kocsmarosra is, aki id}onkent k
orbejar, s t
olt az u
res korsokba. 190.  4 Egy keresztez}odesbe a k
ul
onfele iranyokbol adott gyakorisaggal erkeznek a gepkocsik. A keresztez}odesben elhelyezett forgalmi lampa adott szabalyok Feladatok 159 szerint m}uk
odik. Keszts
unk taskok felhasznalasaval egy programot az el}oallo forgalmi dugok vizsgalatara! 191.  4 Keszts
unk programot egy nemdeterminisztikus automata m}uk
odesenek szimulalasara taskok segtsegevel olymodon, hogy nem egyertelm}u esetben 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 o
sszes t
obbi esetre (xy ) = fq 5g. 192.  3 Keszts
unk altalanos eljarast egy determinisztikus automata m}uk
odesenek szimulalasara! Az allapotok halmaza (tpusa), a bemen}o jelek halmaza (tpusa), az atmeneti f
uggveny, a kezd}o- es vegallapotok mind legyenek az eljaras parameterei! 193.  3 Adva van ket edeny: az egyikben az 1 2:::n szamokkal megjel
olt golyok vannak, a masik u
res. A lltsunk el}o 1 es n k
oz
otti egyenletes eloszlasu veletlenszamokat, s az adott szammal jel
olt golyot mindig tegy
uk at a masik edenybe. Keszts
unk programot, ami szimulalja ezt a folyamatot, s vizsgaljuk az edenyek tartalmanak valtozasat! 194.  2 Egy reszeg (R pont) ember all egy lampaoszlopnal (origo). Arra

vagyunk kivancsiak, hogy N lepes utan milyen messzire jut az oszloptol. Minden lepese egysegnyi hosszusagu, s az iranya veletlenszer}u. Keszts
unk 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 cs
okken az eg}o cigarettak szama, 60%, hogy nincs valtozas. Egy cigaretta egy id}oegyseg alatt egy egysegnyi f
ustmennyiseget termel. Ha a teremben a f
ustmennyiseg eleri a 200 egyseget, akkor a szamtogep elindtja az elszvoberendezest, amely egy id}oegyseg alatt 30 egyseggel cs
okkenti a teremben a f
ustmennyiseget. Ha a teremben a f
ustmennyiseg 40 egysegnel kevesebb, akkor a gep kikapcsolja az elszvot. Keszts
unk programot, ami id}oegysegenkent kirja a f
ustmennyiseg erteket, a dohanyzok szamat es az elszvo kapcsolojanak allasat! 196.  2 A

b}uv
os negyzet egy olyan negyzetes matrix, amelynek sor
osszegei, oszlop
osszegei es a f}o- ill. 2 a mellekatlojaban lev}o elemek
osszege megegyezik, s ez az
osszeg n(n2+1) (ahol n -nel jel
olt
uk a negyzet oldalat, es n paratlan). Keszts
unk programot, ami az n ertek ismereteben elkeszt egy b}uv
os negyzetet! 197.  2 * A latin negyzet egy olyan negyzetes matrix, amelynek sorai es oszlopai az 1:::n szamok k
ul
onb
oz}o permutacioi (n -nel jel
olt
uk a negyzet oldalat). Keszts
unk programot, ami az n ertek ismereteben elkeszt egy latin negyzetet! 198.  1 Keszts
unk egy programot, ami egy szamsorozatrol megallaptja, hogy 160 Ada periodikus-e (egy sorozat akkor periodikus, ha el}oallthato egy elemsorozat t
obbsz
ori egymas melle rasaval)! 199.  1 Keszts
unk programot, ami az 1,2,3,.,9 szamok k
oze + 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 Keszts
unk 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)! 201.  2 Adott egy N teremb}ol allo labirintus egy binaris matrix formajaban: aij = 1 azt jelenti, hogy az i. es a j termeket folyoso k
oti o
ssze Keszts
unk programot, ami megadja, hogy milyen termeken kereszt
ul juthatunk el egy adott teremb}ol egy adott masik terembe! 202.  2 * Egy vallalat N allast hirdet meg. Jelentkezik ra ugyanannyi palyazo, s mindegyik k
ozli, hogy melyik allasokat tudna bet
olteni. Keszts
unk programot, ami eld
onti, hogy a palyazokkal bet
olthet}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). Minden Ai helyr}ol a

hozza tartozo Bi helyre kell szalltani egysegnyi mennyiseget ugy, hogy a teherauto egyszerre csak egy terhet szallthat. Keszts
unk programot, ami eld
onti, hogy melyik szalltasokat kell elvallalni ahhoz, hogy a legt
obb igenyt kielegts
uk! 204.  2 Adott N darab targynak a sulya. Osszuk a targyakat ket csoportra u gy, hogy a ket csoport sulya a lehet}o legk
ozelebb legyen egymashoz! Tartalom 161 Tartalom 1. 1.1 1.2 2. 3. 4. 4.1 4.2 4.3 4.31 4.32 4.33 4.4 4.41 4.42 4.5 4.6 4.61 4.62 4.7 5. 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 6. 6.1 6.2 6.3 6.4 6.5 6.6 6.7 7. El}oszo Az Ada nyelv attekintese Az Ada t
orteneti hattere Az Ada r
ovid jellemzese Lexikalis elemek Deklaraciok Tpusok Az altpus fogalma Szarmaztatott tpusok Diszkret tpusok Felsorolasi tpusok Az egesz tpusok A diszkret tpusok tpusm}uveletei Valos tpusok Lebeg}opontos tpusok Fixpontos tpusok T
omb tpusok A rekord tpus A rekord diszkriminansai Varians rekord Pointer

tpusok Utastasok Az ertekadas Az if utastas A case utastas Ciklus utastasok A blokk utastas Az exit utastas A return utastas A goto utastas Alprogramok Alprogram dencioja Alprogram hvasa Parameteratadas A formalis parameterk default erteke Alprogramok atlapolasa Az operatorok atlapolasa Peldaprogramok A package 3 4 4 6 8 10 13 14 15 15 16 17 17 18 19 20 21 24 25 26 28 31 31 32 33 33 34 36 36 36 38 38 39 41 42 43 44 45 48 162 7.1 7.2 7.3 7.4 7.5 8. 8.1 9. 9.1 9.2 10. 10.1 10.2 11. 11.1 11.2 11.3 12. 12.1 12.2 12.3 12.4 12.5 12.6 12.7 12.71 12.72 12.73 12.8 13. 14. 15. 15.1 15.2 15.3 15.31 15.32 15.33 15.34 15.4 Ada A package specikacioja A package t
orzse A private tpus A limited private tpus Peldaprogramok Hibakezeles, kivetelkezeles Peldaprogramok Lathatosagi szabalyok A use utastas Az atnevezes Programstruktura Alegysegek Peldaprogramok Generic Generic deklaracioja Peldanyostas Peldaprogramok Taskok A task

specikacioja es t
orzse Task tpusok, task objektumok Taskok aktivizalasa, vegrehajtasa Taskok terminalasa entry, entry hvasok, accept utastas A delay es az abort utastas A select utastas A szelektv varakoztatas A felteteles entry hvas Id}oh
oz k
ot
ott entry hvas Peldaprogramok Reprezentacios specikaciok Fordtasi direktvak Input - output Szekvencialis le-ok kezelese Direkt le-ok kezelese Textle-ok Karakteres es string I/O Integer I/O Float es xed I/O A felsorolasi tpusokra vonatkozo I/O Peldaprogramok F
uggelek A) A STANDARD package B) Az Ada fogalmainak o
sszefoglalasa C) Az Ada szintaktikus szabalyai nevsorba szedve Feladatok 48 48 49 52 52 57 60 61 63 63 65 68 69 76 76 79 80 83 83 84 85 85 86 88 89 89 90 91 91 101 103 104 105 106 107 110 111 112 114 115 116 116 121 131 138 Tartalom 163