Ada (programmeringsspråk) -

Ada (programming language)

Ada är ett strukturerat , statiskt typat , imperativt och objektorienterat programmeringsspråk på hög nivå , utökat från Pascal och andra språk. Den har inbyggt språkstöd för design by contract (DbC), extremt stark maskinskrivning , tydlig samtidighet, uppgifter, synkron meddelandeöverföring, skyddade objekt och icke-determinism . Ada förbättrar kodsäkerheten och underhållbarheten genom att använda kompilatorn för att hitta fel till förmån för körtidsfel . Ada är en internationell teknisk standard , gemensamt definierad av International Organization for Standardization (ISO) och International Electrotechnical Commission (IEC). Från och med 2020 är standarden, kallad Ada 2012 informellt, ISO/IEC 8652: 2012.

Ada designades ursprungligen av ett team som leddes av den franska datavetenskaparen Jean Ichbiah från CII Honeywell Bull under kontrakt till USA: s försvarsdepartement (DoD) från 1977 till 1983 för att ersätta över 450 programmeringsspråk som användes av DoD vid den tiden. Ada fick sitt namn efter Ada Lovelace (1815–1852), som har blivit krediterad som den första datorprogrammeraren.

Ada designades ursprungligen för inbäddade och realtidssystem . Ada 95-revisionen, designad av S. Tucker Taft of Intermetrics mellan 1992 och 1995, förbättrade stödet för system, numerisk, finansiell och objektorienterad programmering (OOP).

Funktioner hos Ada inkluderar: stark typning , modulära programmeringsmekanismer (paket), körningstidskontroll , parallell bearbetning ( uppgifter , synkron meddelandeöverföring , skyddade objekt och icke-bestämda utvalda uttalanden ), undantagshantering och generika . Ada 95 har lagt till stöd för objektorienterad programmering , inklusive dynamisk sändning .

Syntaxen för Ada minimerar valet av sätt att utföra grundläggande operationer och föredrar engelska sökord (som "eller annat" och "och sedan") framför symboler (som "||" och "&&"). Ada använder de grundläggande aritmetiska operatorerna "+", "-", "*" och "/", men undviker att använda andra symboler. Kodblock avgränsas av ord som "deklarera", "börja" och "sluta", där "slutet" (i de flesta fall) följs av identifieraren för blocket det stänger (t.ex. om ... slut om , loop ... end loop ). När det gäller villkorade blockeringar undviker detta en dinglande annan som kan paras med felkapslade if-uttryck på andra språk som C eller Java.

Ada är utformat för att utveckla mycket stora mjukvarusystem. Ada -paket kan sammanställas separat. Ada -paketspecifikationer (paketgränssnittet) kan också sammanställas separat utan implementering för att kontrollera om det är konsekvent. Detta gör det möjligt att upptäcka problem tidigt under designfasen, innan implementeringen startar.

Ett stort antal kompileringstidskontroller stöds för att undvika buggar som inte skulle kunna upptäckas förrän körtiden på vissa andra språk eller som skulle kräva att explicita kontroller läggs till i källkoden. Till exempel kräver syntaxen uttryckligen namngiven stängning av block för att förhindra fel på grund av felaktiga sluttoken. Efterlevnaden av stark skrivning gör det möjligt att upptäcka många vanliga programvarufel (felaktiga parametrar, intervallöverträdelser, ogiltiga referenser, felaktiga typer, etc.) antingen under kompileringstid eller på annat sätt under körtid. Eftersom samtidighet är en del av språkspecifikationen kan kompilatorn i vissa fall upptäcka potentiella blockeringar. Kompilatorer söker också ofta efter felstavade identifierare, pakets synlighet, redundanta deklarationer etc. och kan ge varningar och användbara förslag på hur man åtgärdar felet.

Ada stöder också körningskontroller för att skydda mot åtkomst till oallokerat minne, buffertöverflödesfel , intervallöverträdelser, felaktiga fel , arrayåtkomstfel och andra detekterbara buggar. Dessa kontroller kan inaktiveras av intresse för körningseffektivitet, men kan ofta kompileras effektivt. Det innehåller också faciliteter för att hjälpa till med programverifiering . Av dessa skäl används Ada i stor utsträckning i kritiska system, där varje avvikelse kan leda till mycket allvarliga konsekvenser, t.ex. oavsiktlig död, skada eller allvarlig ekonomisk förlust. Exempel på system där Ada används inkluderar flygteknik , flygtrafikledning , järnvägar, bank, militär och rymdteknik.

Även om språkets semantik tillåter automatisk sophämtning av otillgängliga objekt, stöder de flesta implementeringar det inte som standard, eftersom det skulle orsaka oförutsägbart beteende i realtidssystem. Ada stöder en begränsad form av regionbaserad minneshantering ; kreativ användning av lagringspooler kan också tillhandahålla en begränsad form av automatisk sophämtning, eftersom förstörelse av en lagringspool också förstör alla föremål i poolen.

En dubbel streck ( "-"), som liknar en tankstreck betecknar kommentartext. Kommentarer stannar vid slutet av raden, för att förhindra att okända kommentarer av misstag upphäver hela delar av källkoden. Inaktivera ett helt kodblock kräver nu prefix för varje rad (eller kolumn) individuellt med "-". Medan den tydligt markerar inaktiverad kod med en kolumn med upprepade "-" längs sidan gör detta experimentell avstängning/återaktivering av stora block till en mer utdragen process.

Semikolon (";") är en termineringsterminator , och null- eller icke-operation-satsen är null;. En singel ;utan ett uttalande att avsluta är inte tillåtet.

Till skillnad från de flesta ISO standard definition (kallas Ada språket Manual Ada Reference eller ARM , eller ibland Language Reference Manual eller LRM är) fritt innehåll . Således är det en vanlig referens för Ada -programmerare, inte bara programmerare som implementerar Ada -kompilatorer. Förutom referenshandboken finns också ett omfattande motiveringsdokument som förklarar språkutformningen och användningen av olika språkkonstruktioner. Detta dokument används också i stor utsträckning av programmerare. När språket reviderades skrevs ett nytt motiveringsdokument.

Ett anmärkningsvärt gratis mjukvaruverktyg som används av många Ada -programmerare för att hjälpa dem att skriva Ada -källkod är GNAT Programming Studio , en del av GNU Compiler Collection .

På 1970-talet blev det amerikanska försvarsdepartementet (DoD) bekymrat över antalet olika programmeringsspråk som används för sina inbäddade datorsystemprojekt, varav många var föråldrade eller maskinvaruberoende, och inget av dem stödde säker modulär programmering. År 1975 bildades en arbetsgrupp , High Order Language Working Group (HOLWG) med avsikt att minska detta antal genom att hitta eller skapa ett programmeringsspråk som i allmänhet är lämpligt för avdelningens och det brittiska försvarsministeriets krav. Efter många iterationer som började med ett original Straw man -förslag fick det slutliga programmeringsspråket namnet Ada. Det totala antalet programmeringsspråk på hög nivå som används för sådana projekt sjönk från över 450 1983 till 37 år 1996.

HOLWG -arbetsgruppen utarbetade Steelman -språkkraven , en serie dokument med de krav som de ansåg att ett programmeringsspråk borde uppfylla. Många befintliga språk granskades formellt, men teamet kom 1977 fram till att inget befintligt språk uppfyllde specifikationerna.

Augusta Ada King , grevinnan av Lovelace.

Begäran om förslag på ett nytt programmeringsspråk utfärdades och fyra entreprenörer anställdes för att utveckla sina förslag under namnen Red ( Intermetrics ledd av Benjamin Brosgol), Green ( CII Honeywell Bull , ledd av Jean Ichbiah ), Blue ( SofTech , ledd av John Goodenough) och Yellow ( SRI International , ledd av Jay Spitzen). I april 1978, efter offentlig granskning, gick de röda och gröna förslagen vidare till nästa fas. I maj 1979 valdes det gröna förslaget, designat av Jean Ichbiah på CII Honeywell Bull, och fick namnet Ada - efter Augusta Ada, grevinnan av Lovelace . Detta förslag påverkades av språket LIS som Ichbiah och hans grupp hade utvecklat på 1970 -talet. Den preliminära Ada-referensmanualen publicerades i ACM SIGPLAN Notices i juni 1979. Military Standard-referenshandboken godkändes den 10 december 1980 ( Ada Lovelaces födelsedag) och fick numret MIL-STD-1815 för att hedra Ada Lovelaces födelse år. 1981 utnyttjade CAR Hoare sitt Turing Award -tal för att kritisera Ada för att vara alltför komplex och därmed opålitlig, men tycktes därefter återta i det förord ​​han skrev för en Ada -lärobok.

Ada väckte stor uppmärksamhet från programmeringsgemenskapen som helhet under sina första dagar. Dess stödjare och andra förutspådde att det kan bli ett dominerande språk för programmering för allmänna ändamål och inte bara försvarsrelaterat arbete. Ichbiah uttalade offentligt att det inom tio år bara skulle vara två programmeringsspråk kvar: Ada och Lisp . Tidiga Ada-kompilatorer kämpade för att implementera det stora, komplexa språket, och prestanda för både kompileringstid och körning tenderade att vara långsam och verktyg primitiva. Kompilatörsleverantörerna har lagt ned de flesta av sina ansträngningar för att klara den massiva, ACV-valideringspaket som krävdes av språköverensstämmelse, som krävdes i en annan nyhet i Ada-språkansträngningen. The Jargon File , en ordlista över datorhacker -slang med ursprung 1975–1983, noterar i en post på Ada att "det är precis vad man kan förvänta sig med tanke på den typen av godkännande av fiat; utformad av kommittén ... svårt att använda, och överlag en katastrofal mångmiljard-dollar-bockglasögon ... Ada Lovelace ... skulle nästan säkert blanchera vid den användning som hennes namn senare har använts; det snällaste som har sagts om det är att det förmodligen finns en bra liten språk som skriker för att komma ut ur sin stora elefantin. "

Den första validerade Ada-implementeringen var NYU Ada/Ed-översättaren, certifierad den 11 april 1983. NYU Ada/Ed är implementerat på det högt inställda språket SETL . Flera kommersiella företag började erbjuda Ada-kompilatorer och tillhörande utvecklingsverktyg, inklusive Alsys , TeleSoft , DDC-I , Advanced Computer Techniques , Tartan Laboratories , TLD Systems och Verdix .

1991 började det amerikanska försvarsdepartementet kräva att Ada ( Ada -mandatet ) används för all programvara, även om undantag från denna regel ofta beviljades. Försvarsdepartementets Ada-mandat togs bort 1997, eftersom DoD började omfamna kommersiell off-the-shelf ( COTS ) teknik. Liknande krav fanns i andra Natoländer : Ada krävdes för NATO-system som involverar kommando och kontroll och andra funktioner, och Ada var det mandat eller föredragna språket för försvarsrelaterade tillämpningar i länder som Sverige, Tyskland och Kanada.

I slutet av 1980-talet och början av 1990-talet hade Ada-kompilatorer förbättrats i prestanda, men det fanns fortfarande hinder för att fullt ut utnyttja Adas förmågor, inklusive en uppgiftsmodell som skilde sig från vad de flesta realtidsprogrammerare var vana vid.

På grund av Adas säkerhetskritiska supportfunktioner används den nu inte bara för militära applikationer, utan också för kommersiella projekt där ett mjukvarufel kan få allvarliga konsekvenser, t.ex. avionik och flygtrafikkontroll , kommersiella raketer som Ariane 4 och 5 , satelliter och andra rymdsystem, järnvägstransporter och bank. Till exempel skrevs Airplane Information Management System , fly-by-wire- systemprogramvaran i Boeing 777 , i Ada. Utvecklat av Honeywell Air Transport Systems i samarbete med konsulter från DDC-I , blev det utan tvekan det mest kända av alla Ada-projekt, civila eller militära. Det kanadensiska automatiserade lufttrafiksystemet skrevs i 1 miljon rader av Ada ( SLOC -antal ). Den innehöll avancerad distribuerad bearbetning , en distribuerad Ada-databas och objektorienterad design. Ada används också i andra flygtrafiksystem, t.ex. är Storbritanniens nästa generations flygtrafikledningssystem för interim Future Area Control Tools Support (iFACTS) utformat och implementerat med SPARK Ada. Den används också i franska TVM in- hyttsignal- systemet på TGV höghastighetståg systemet, och tunnelbanan pendeltåg i Paris, London, Hong Kong och New York City.

Språket blev en ANSI- standard 1983 ( ANSI/MIL-STD 1815A ), och efter översättning på franska och utan ytterligare förändringar i engelska blev det en ISO-standard 1987 (ISO-8652: 1987). Denna version av språket är allmänt känd som Ada 83, från det datum då det antogs av ANSI, men kallas ibland även som Ada 87, från det datum då det antogs av ISO.

Ada 95, den gemensamma ISO/ANSI-standarden ( ISO-8652: 1995 ) publicerades i februari 1995, vilket gjorde Ada 95 till det första ISO-standard objektorienterade programmeringsspråket. För att hjälpa till med standardrevisionen och framtida acceptans finansierade US Air Force utvecklingen av GNAT -kompilatorn . För närvarande är GNAT -kompilatorn en del av GNU -kompilatorsamlingen .

Arbetet har fortsatt med att förbättra och uppdatera det tekniska innehållet i Ada -språket. En teknisk rättelse till Ada 95 publicerades i oktober 2001, och en större ändring, ISO/IEC 8652: 1995/Amd 1: 2007 publicerades den 9 mars 2007. Vid Ada-Europe 2012-konferensen i Stockholm, Ada Resource Association (ARA) och Ada-Europe tillkännagav färdigställandet av utformningen av den senaste versionen av Ada-språket och inlämning av referensmanualen till International Organization for Standardization (ISO) för godkännande. ISO/IEC 8652: 2012 publicerades i december 2012.

Ada är ett ALGOL -liknande programmeringsspråk med kontrollstrukturer med reserverade ord som om , då , annars , medan , för osv. Ada har dock också många datastruktureringsfaciliteter och andra abstraktioner som inte ingick i den ursprungliga ALGOL 60 , till exempel typdefinitioner , poster , pekare , uppräkningar . Sådana konstruktioner ärvdes delvis från eller inspirerades av Pascal .

"Hej världen!" i Ada

Ett vanligt exempel på ett språks syntax är Hello world -programmet : (hello.adb)

with
 
Ada.Text_IO
;
 
use
 
Ada.Text_IO
;
procedure
 
Hello
 
is
begin
   
Put_Line
 
(
"Hello, world!"
);
end
 
Hello
;

Detta program kan kompileras genom att använda den fritt tillgängliga open source -kompilatorn GNAT , genom att köra

gnatmake hello.adb

Datatyper

Adas typsystem är inte baserat på en uppsättning fördefinierade primitiva typer utan tillåter användare att deklarera sina egna typer. Denna förklaring är i sin tur inte baserad på den interna representationen av typen utan på att beskriva målet som bör uppnås. Detta gör det möjligt för kompilatorn att bestämma en lämplig minnesstorlek för typen och att kontrollera om det finns kränkningar av typdefinitionen vid kompileringstid och körtid (dvs intervallöverträdelser, buffertöverskridanden, typkonsistens etc.). Ada stöder numeriska typer definierade av ett intervall, modulotyper, aggregerade typer (poster och matriser) och uppräkningstyper. Åtkomsttyper definierar en referens till en instans av en specificerad typ; oskrivna pekare är inte tillåtna. Särskilda typer som tillhandahålls av språket är uppgiftstyper och skyddade typer.

Till exempel kan ett datum representeras som:

type
 
Day_type
   
is
 
range
    
1
 
..
   
31
;
type
 
Month_type
 
is
 
range
    
1
 
..
   
12
;
type
 
Year_type
  
is
 
range
 
1800
 
..
 
2100
;
type
 
Hours
 
is
 
mod
 
24
;
type
 
Weekday
 
is
 
(
Monday
,
 
Tuesday
,
 
Wednesday
,
 
Thursday
,
 
Friday
,
 
Saturday
,
 
Sunday
);

type
 
Date
 
is
   
record
     
Day
   
:
 
Day_type
;
     
Month
 
:
 
Month_type
;
     
Year
  
:
 
Year_type
;
   
end record
;

Typer kan förädlas genom att deklarera undertyper :

subtype
 
Working_Hours
 
is
 
Hours
 
range
 
0
 
..
 
12
;
            
-- at most 12 Hours to work a day
subtype
 
Working_Day
 
is
 
Weekday
 
range
 
Monday
 
..
 
Friday
;
   
-- Days to work

Work_Load
:
 
constant
 
array
(
Working_Day
)
 
of
 
Working_Hours
  
-- implicit type declaration
   
:=
 
(
Friday
 
=>
 
6
,
 
Monday
 
=>
 
4
,
 
others
 
=>
 
10
);
           
-- lookup table for working hours with initialization

Typer kan ha modifierare som begränsat, abstrakt, privat etc. Privata typer kan endast nås och begränsade typer kan endast modifieras eller kopieras inom ramen för paketet som definierar dem. Ada 95 lägger till ytterligare funktioner för objektorienterad förlängning av typer.

Kontrollstrukturer

Ada är ett strukturerat programmeringsspråk , vilket innebär att kontrollflödet är strukturerat i standarduttalanden. Alla standardkonstruktioner och tidig utgång på djup nivå stöds, så det behövs sällan användning av de " gå till " -kommandon som också stöds .

-- while a is not equal to b, loop.
while
 
a
 
/=
 
b
 
loop
  
Ada
.
Text_IO
.
Put_Line
 
(
"Waiting"
);
end
 
loop
;

if
 
a
 
>
 
b
 
then
  
Ada
.
Text_IO
.
Put_Line
 
(
"Condition met"
);
else
  
Ada
.
Text_IO
.
Put_Line
 
(
"Condition not met"
);
end
 
if
;

for
 
i
 
in
 
1
 
..
 
10
 
loop
  
Ada
.
Text_IO
.
Put
 
(
"Iteration: "
);
  
Ada
.
Text_IO
.
Put
 
(
i
);
  
Ada
.
Text_IO
.
Put_Line
;
end
 
loop
;

loop
  
a
 
:=
 
a
 
+
 
1
;
  
exit
 
when
 
a
 
=
 
10
;
end
 
loop
;

case
 
i
 
is
  
when
 
0
 
=>
 
Ada
.
Text_IO
.
Put
 
(
"zero"
);
  
when
 
1
 
=>
 
Ada
.
Text_IO
.
Put
 
(
"one"
);
  
when
 
2
 
=>
 
Ada
.
Text_IO
.
Put
 
(
"two"
);
  
-- case statements have to cover all possible cases:
  
when
 
others
 
=>
 
Ada
.
Text_IO
.
Put
 
(
"none of the above"
);
end
 
case
;

for
 
aWeekday
 
in
 
Weekday
'
Range
 
loop
               
-- loop over an enumeration
   
Put_Line
 
(
 
Weekday
'
Image
(
aWeekday
)
 
);
         
-- output string representation of an enumeration
   
if
 
aWeekday
 
in
 
Working_Day
 
then
               
-- check of a subtype of an enumeration
      
Put_Line
 
(
 
" to work for "
 
&
               
Working_Hours
'
Image
 
(
Work_Load
(
aWeekday
))
 
);
 
-- access into a lookup table
   
end
 
if
;
end
 
loop
;

Paket, procedurer och funktioner

Bland delarna i ett Ada -program finns paket, procedurer och funktioner.

Exempel: Paketspecifikation (exempel.ads)

package
 
Example
 
is
     
type
 
Number
 
is
 
range
 
1
 
..
 
11
;
     
procedure
 
Print_and_Increment
 
(
j
: 
in
 
out
 
Number
);
end
 
Example
;

Paketkropp (exempel.adb)

with
 
Ada.Text_IO
;
package
 
body
 
Example
 
is

  
i
 
:
 
Number
 
:=
 
Number
'
First
;

  
procedure
 
Print_and_Increment
 
(
j
: 
in
 
out
 
Number
)
 
is

    
function
 
Next
 
(
k
: 
in
 
Number
)
 
return
 
Number
 
is
    
begin
      
return
 
k
 
+
 
1
;
    
end
 
Next
;

  
begin
    
Ada
.
Text_IO
.
Put_Line
 
(
 
"The total is: "
 
&
 
Number
'
Image
(
j
)
 
);
    
j
 
:=
 
Next
 
(
j
);
  
end
 
Print_and_Increment
;

-- package initialization executed when the package is elaborated
begin
  
while
 
i
 
<
 
Number
'
Last
 
loop
    
Print_and_Increment
 
(
i
);
  
end
 
loop
;
end
 
Example
;

Detta program kan kompileras, t.ex. genom att använda den fritt tillgängliga open-source-kompilatorn GNAT , genom att köra

gnatmake -z example.adb

Paket, procedurer och funktioner kan häckas till vilket djup som helst, och var och en kan också vara det logiska yttersta blocket.

Varje paket, procedur eller funktion kan ha sina egna deklarationer av konstanter, typer, variabler och andra procedurer, funktioner och paket, som kan deklareras i valfri ordning.

Samtidighet

Ada har språkstöd för uppgiftsbaserad samtidighet. Den grundläggande samtidiga enheten i Ada är en uppgift , som är en inbyggd begränsad typ. Uppgifterna specificeras i två delar - uppgiftsdeklarationen definierar uppgiftsgränssnittet (liknande en typdeklaration), uppgiftsorganet anger genomförandet av uppgiften. Beroende på implementeringen mappas Ada -uppgifter antingen till operativsystemets trådar eller processer eller schemaläggs internt med Ada -körningstiden.

Uppgifter kan ha poster för synkronisering (en form av synkroniserad meddelandeöverföring ). Uppgiftsposter deklareras i uppgiftsspecifikationen. Varje uppgiftspost kan ha ett eller flera accepterande uttalanden inom uppgiftsorganet. Om kontrollflödet för uppgiften når en accept -sats blockeras uppgiften tills motsvarande post anropas av en annan uppgift (på samma sätt blockeras en anropsuppgift tills den uppringda uppgiften når motsvarande accept -sats). Uppgiftsposter kan ha parametrar som liknar förfaranden, vilket gör att uppgifter synkront kan utbyta data. I samband med utvalda påståenden är det möjligt att definiera vakter på accepterande uttalanden (liknande Dijkstras bevakade kommandon ).

Ada erbjuder också skyddade objekt för ömsesidigt utanförskap . Skyddade objekt är en monitorliknande konstruktion, men använd vakter istället för villkorliga variabler för signalering (liknande villkorliga kritiska regioner). Skyddade objekt kombinerar datakapslingen och säker ömsesidig uteslutning från bildskärmar och inträdesvakter från villkorliga kritiska regioner. Den största fördelen jämfört med klassiska bildskärmar är att villkorliga variabler inte krävs för signalering, vilket undviker potentiella blockeringar på grund av felaktig låssemantik. Precis som uppgifter är det skyddade objektet en inbyggd begränsad typ, och det har också en deklarationsdel och en kropp.

Ett skyddat objekt består av inkapslade privata data (som endast kan nås inifrån det skyddade objektet) och procedurer, funktioner och poster som garanterat är ömsesidigt uteslutande (med det enda undantaget för funktioner som måste vara biverkningsfria) och kan därför köras samtidigt med andra funktioner). En uppgift som kallar ett skyddat objekt blockeras om en annan uppgift för närvarande körs inuti samma skyddade objekt och släpps när den andra uppgiften lämnar det skyddade objektet. Blockerade uppgifter köas på det skyddade objektet beställt efter ankomsttid.

Skyddade objektposter liknar procedurer, men har dessutom vakter . Om en vakt utvärderar till falsk blockeras en uppringningsuppgift och läggs till i kön för den posten. nu kan en annan uppgift tillåtas till det skyddade objektet, eftersom ingen uppgift för närvarande utförs inuti det skyddade objektet. Vakter omvärderas varje gång en uppgift lämnar det skyddade objektet, eftersom detta är den enda gången då utvärderingen av vakter kan ha förändrats.

Samtal till poster kan göras om till andra poster med samma signatur. En uppgift som begärs blockeras och läggs till i köposten för målposten; detta innebär att det skyddade objektet frigörs och tillåter tillträde till en annan uppgift.

Den select uttalande Ada kan användas för att implementera icke-blockerande inträdes samtal och accepterar icke-deterministiska urval av poster (även med vakter), time-outer och avbryter.

Följande exempel illustrerar några begrepp för samtidig programmering i Ada.

with
 
Ada.Text_IO
;
 
use
 
Ada.Text_IO
;

procedure
 
Traffic
 
is

   
type
 
Airplane_ID
 
is
 
range
 
1.
.
10
;
             
-- 10 airplanes

   
task
 
type
 
Airplane
 
(
ID
: 
Airplane_ID
);
        
-- task representing airplanes, with ID as initialisation parameter
   
type
 
Airplane_Access
 
is
 
access
 
Airplane
;
     
-- reference type to Airplane

   
protected
 
type
 
Runway
 
is
                     
-- the shared runway (protected to allow concurrent access)
      
entry
 
Assign_Aircraft
 
(
ID
: 
Airplane_ID
);
  
-- all entries are guaranteed mutually exclusive
      
entry
 
Cleared_Runway
 
(
ID
: 
Airplane_ID
);
      
entry
 
Wait_For_Clear
;
   
private
      
Clear
:
 
Boolean
 
:=
 
True
;
                   
-- protected private data - generally more than only a flag...
   
end
 
Runway
;
   
type
 
Runway_Access
 
is
 
access
 
all
 
Runway
;

   
-- the air traffic controller task takes requests for takeoff and landing
   
task
 
type
 
Controller
 
(
My_Runway
: 
Runway_Access
)
 
is
      
-- task entries for synchronous message passing
      
entry
 
Request_Takeoff
 
(
ID
: 
in
 
Airplane_ID
;
 
Takeoff
: 
out
 
Runway_Access
);
      
entry
 
Request_Approach
(
ID
: 
in
 
Airplane_ID
;
 
Approach
: 
out
 
Runway_Access
);
   
end
 
Controller
;

   
--  allocation of instances
   
Runway1
    
:
 
aliased
 
Runway
;
              
-- instantiate a runway
   
Controller1
:
 
Controller
 
(
Runway1
'
Access
);
 
-- and a controller to manage it

   
------ the implementations of the above types ------
   
protected
 
body
 
Runway
 
is
      
entry
 
Assign_Aircraft
 
(
ID
: 
Airplane_ID
)
 
when
 
Clear
 
is
   
-- the entry guard - calling tasks are blocked until the condition is true
      
begin
       
Clear
 
:=
 
False
;
       
Put_Line
 
(
Airplane_ID
'
Image
 
(
ID
)
 
&
 
" on runway "
);
      
end
;

      
entry
 
Cleared_Runway
 
(
ID
: 
Airplane_ID
)
 
when
 
not
 
Clear
 
is
      
begin
         
Clear
 
:=
 
True
;
         
Put_Line
 
(
Airplane_ID
'
Image
 
(
ID
)
 
&
 
" cleared runway "
);
      
end
;

      
entry
 
Wait_For_Clear
 
when
 
Clear
 
is
      
begin
         
null
;
      
-- no need to do anything here - a task can only enter if "Clear" is true
      
end
;
   
end
 
Runway
;

   
task
 
body
 
Controller
 
is
   
begin
      
loop
         
My_Runway
.
Wait_For_Clear
;
   
-- wait until runway is available (blocking call)
         
select
                      
-- wait for two types of requests (whichever is runnable first)
            
when
 
Request_Approach
'
count
 
=
 
0
 
=>
  
-- guard statement - only accept if there are no tasks queuing on Request_Approach
             
accept
 
Request_Takeoff
 
(
ID
:
 
in
 
Airplane_ID
;
 
Takeoff
:
 
out
 
Runway_Access
)
             
do
                                 
-- start of synchronized part
               
My_Runway
.
Assign_Aircraft
 
(
ID
);
  
-- reserve runway (potentially blocking call if protected object busy or entry guard false)
               
Takeoff
 
:=
 
My_Runway
;
            
-- assign "out" parameter value to tell airplane which runway
             
end
 
Request_Takeoff
;
               
-- end of the synchronised part
         
or
            
accept
 
Request_Approach
 
(
ID
:
 
in
 
Airplane_ID
;
 
Approach
:
 
out
 
Runway_Access
)
 
do
               
My_Runway
.
Assign_Aircraft
 
(
ID
);
               
Approach
 
:=
 
My_Runway
;
            
end
 
Request_Approach
;
         
or
                          
-- terminate if no tasks left who could call
            
terminate
;
         
end
 
select
;
      
end
 
loop
;
   
end
;

   
task
 
body
 
Airplane
 
is
      
Rwy
 
:
 
Runway_Access
;
   
begin
      
Controller1
.
Request_Takeoff
 
(
ID
,
 
Rwy
);
 
-- This call blocks until Controller task accepts and completes the accept block
      
Put_Line
 
(
Airplane_ID
'
Image
 
(
ID
)
 
&
 
"  taking off..."
);
      
delay
 
2.0
;
      
Rwy
.
Cleared_Runway
 
(
ID
);
               
-- call will not block as "Clear" in Rwy is now false and no other tasks should be inside protected object
      
delay
 
5.0
;
 
-- fly around a bit...
      
loop
         
select
   
-- try to request a runway
            
Controller1
.
Request_Approach
 
(
ID
,
 
Rwy
);
 
-- this is a blocking call - will run on controller reaching accept block and return on completion
            
exit
;
 
-- if call returned we're clear for landing - leave select block and proceed...
         
or
            
delay
 
3.0
;
  
-- timeout - if no answer in 3 seconds, do something else (everything in following block)
            
Put_Line
 
(
Airplane_ID
'
Image
 
(
ID
)
 
&
 
"   in holding pattern"
);
  
-- simply print a message
         
end
 
select
;
      
end
 
loop
;
      
delay
 
4.0
;
  
-- do landing approach...
      
Put_Line
 
(
Airplane_ID
'
Image
 
(
ID
)
 
&
 
"            touched down!"
);
      
Rwy
.
Cleared_Runway
 
(
ID
);
  
-- notify runway that we're done here.
   
end
;

   
New_Airplane
:
 
Airplane_Access
;

begin
   
for
 
I
 
in
 
Airplane_ID
'
Range
 
loop
  
-- create a few airplane tasks
      
New_Airplane
 
:=
 
new
 
Airplane
 
(
I
);
 
-- will start running directly after creation
      
delay
 
4.0
;
   
end
 
loop
;
end
 
Traffic
;

Pragmas

En pragma är ett kompilatordirektiv som förmedlar information till kompilatorn för att möjliggöra specifik manipulering av kompilerad utdata. Vissa pragmor är inbyggda i språket, medan andra är implementeringsspecifika.

Exempel på vanlig användning av kompilatorpragmer skulle vara att inaktivera vissa funktioner, till exempel körningstypskontroll eller matrisgränssnittskontroll, eller att instruera kompilatorn att infoga objektkod istället för ett funktionsanrop (som C/C ++ gör med inline-funktioner ).

Generika

• APSE - en specifikation för en programmeringsmiljö för att stödja mjukvaruutveckling i Ada
• Ravenscar-profil- en delmängd av Ada-uppgiftsfunktionerna som är utformade för säkerhetskritisk hård realtidsberäkning
• SPARK (programmeringsspråk) - ett programmeringsspråk som består av en mycket begränsad delmängd av Ada, kommenterad med metainformation som beskriver önskat komponentbeteende och individuella körningskrav

Internationella standarder

• ISO/IEC 8652 : Informationsteknik — Programmeringsspråk — Ada
• ISO/IEC 15291 : Informationsteknik - Programmeringsspråk - Ada Semantic Interface Specification ( ASIS )
• ISO/IEC 18009 : Informationsteknik — Programmeringsspråk — Ada: Överensstämmelsebedömning av en språkprocessor ( ACATS )
• IEEE Standard 1003.5b-1996 , POSIX Ada-bindning
• Ada Language Mapping Specification , CORBA -gränssnittets beskrivningsspråk (IDL) till Ada -mappning

Logisk grund

Dessa dokument har publicerats i olika former, inklusive tryck.

• Ichbiah, Jean D .; Barnes, John GP; Firth, Robert J .; Woodger, Mike (1986), Motivering för design av Ada programmeringsspråk , arkiverad från originalet 2007-02-02
  Finns också [ https://apps.dtic.mil/dtic/tr/fulltext/u2/a187106.pdf på
• Barnes, John GP (1995), Ada 95 -resonemang: språket: standardbiblioteken
• Barnes, John (2006) [2005], Motivering för Ada 2005

Böcker

Arkiv

• Ada Programming Language Materials, 1981–1990 . Charles Babbage Institute , University of Minnesota. Inkluderar litteratur om mjukvaruprodukter avsedda för Ada -språket; Amerikanska regeringens publikationer, inklusive Ada 9X -projektrapporter, tekniska rapporter, arbetsdokument, nyhetsbrev; och användargruppsinformation.

• Ada - C/C ++ växlare - MapuSoft
• DOD Ada programmeringsspråk (ANSI/MIL STD 1815A-1983) specifikation
• JTC1/SC22/WG9 ISO hem för Ada Standards
• Ada (programmeringsspråk) på Curlie