Ada (programmeringsspråk) -
Ada (programming language)

Från Wikipedia, den fria encyklopedin
"MapuSoft Ada-C/C ++ changer" .
, tidigare känd som "AdaMagic med C Intermediate",
DDC-I Score
Ada
Paradigm Multiparadigm : strukturerat , imperativt , objektorienterat
Familj Pascal
Designad av
  • MIL-STD-1815, Ada 83: Jean Ichbiah
  • Ada 95: Tucker Taft
  • Ada 2005: Tucker Taft
  • Ada 2012: Tucker Taft
Första gången dök upp Februari 1980
; 41 år sedan
 (
1980-02
)
Stabil frisättning
Ada 2012 TC1
Skrivdisciplin statisk , stark , säker , nominativ
OS Multi- eller plattformsoberoende
Filnamnstillägg .adb, .ads
Hemsida
Stora implementeringar
Dialekter
SPARK , Ravenscar -profil
Påverkad av
ALGOL 68 , Pascal , Simula 67 , C ++ (Ada 95), Smalltalk (Ada 95), Modula-2 (Ada 95) Java (Ada 2005), Eiffel (Ada 2012)
Påverkad
C ++ , Chapel , Drago , D , Eiffel , Griffin, Java , Nim , ParaSail , PL/SQL , PL/pgSQL , Python , Ruby , Seed7 , SPARforte, Sparkel , SQL/PSM , VHDL

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.

Funktioner

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.

Adas dynamiska minneshantering är på hög nivå och typsäker. Ada har inga generiska eller otypade tips ; inte heller deklarerar det implicit någon pekartyp. Istället måste all dynamisk minnesallokering och deallokering ske via uttryckligen deklarerade åtkomsttyper . Varje åtkomsttyp har en tillhörande lagringspool som hanterar detaljer på låg nivå om minneshantering. programmeraren kan antingen använda standardlagringspoolen eller definiera nya (detta är särskilt relevant för icke-enhetlig minnesåtkomst ). Det är till och med möjligt att deklarera flera olika åtkomsttyper som alla betecknar samma typ men använder olika lagringspooler. Dessutom tillhandahåller språket tillgänglighetskontroller , både vid kompileringstid och vid körning, vilket säkerställer att ett åtkomstvärde inte kan överleva typen av objekt det pekar på.

Ä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 .

Historia

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.

Standardisering

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.

.

Språk konstruerar

Ada är ett ALGOL -liknande programmeringsspråk med kontrollstrukturer med reserverade ord som om , , 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

Ada har haft generika sedan den designades första gången 1977–1980. Standardbiblioteket använder generika för att tillhandahålla många tjänster. Ada 2005 lägger till ett omfattande generiskt containerbibliotek till standardbiblioteket, som inspirerades av C ++: s standardmallbibliotek .

En generisk enhet är ett paket eller ett underprogram som tar en eller flera generiska formella parametrar .

En generisk formell parameter är ett värde, en variabel, en konstant, en typ, ett underprogram eller till och med en instans av en annan, utpekad, generisk enhet. För generiska formtyper skiljer syntaxen mellan diskreta, flytande, fasta, åtkomst (pekare) typer, etc. Vissa formella parametrar kan ha standardvärden.

För att instansera en generisk enhet skickar programmeraren faktiska parametrar för varje formell. Den generiska instansen beter sig då precis som vilken annan enhet som helst. Det är möjligt att instantiera generiska enheter vid körning , till exempel inuti en slinga.

Se även

  • 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

Referenser

Internationella standarder

Logisk grund

Dessa dokument har publicerats i olika former, inklusive tryck.

Böcker

Arkiv