Ada (programmeringsspråk) - Ada (programming language)
Paradigm | Multiparadigm : strukturerat , imperativt , objektorienterat |
---|---|
Familj | Pascal |
Designad av |
|
Första gången dök upp | Februari 1980 |
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.
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 .
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.

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
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.- 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-02Finns 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
- Booch, Grady (1987). . Kalifornien: Benjamin/Cummings Publishing Company. ISBN 0-8053-0604-8.
- Skansholm, Jan (1996). Ada 95 Från början . Addison-Wesley. ISBN 0-201-40376-5.
- Gilpin, Geoff (1985). Ada: En guidad tur och handledning . Prentice hall. ISBN 978-0-13-004045-9.
- Barnes, John (2006). Programmering i Ada 2005 . Addison-Wesley. ISBN 0-321-34078-7.
- Barnes, John (1991). Programmering i Ada plus Language Reference Manual . Addison-Wesley. ISBN 0-201-56539-0.
- Barnes, John (1998). Programmering i Ada 95 . Addison-Wesley. ISBN 0-201-34293-6.
- Barnes, John (1997). High Integrity Ada: SPARK -metoden . Addison-Wesley. ISBN 0-201-17517-7.
- Barnes, John (2003). High Integrity Software: SPARK -metoden för säkerhet och säkerhet . Addison-Wesley. ISBN 0-321-13616-0.
- Beidler, John (1997). Datastrukturer och algoritmer: en objektorienterad metod med Ada 95 . Springer-Verlag. ISBN 0-387-94834-1.
- Gonzalez, Dean W. (1991). Ada Programmer's Handbook . Benjamin-Cummings Publishing Company. ISBN 0-8053-2529-8.
- Ben-Ari, M. (1998). Ada för programvaruingenjörer . John Wiley & Sons. ISBN 0-471-97912-0.
- Cohen, Norman (1996). Ada som andraspråk . McGraw-Hill Science/Engineering/Math. ISBN 0-07-011607-5.
- Burns, Alan ; Wellings, Andy (2001). Realtidssystem och programmeringsspråk. Ada 95, Real-Time Java och Real-Time POSIX . Addison-Wesley. ISBN 0-201-72988-1.
- Burns, Alan ; Wellings, Andy (1995). Samtidighet i Ada . Cambridge University Press. ISBN 0-521-62911-X.
- Atkinson, Colin (1991). Objektorienterad återanvändning, samtidighet och distribution: en adabaserad metod . Addison-Wesley. ISBN 0-201-56527-7.
- Booch, Grady ; Bryan, Doug (1994). Programvaruteknik med Ada . Addison-Wesley. ISBN 0-8053-0608-0.
- Jones, Do-While (1989). Ada in Action: Med praktiska programmeringsexempel . John Wiley & Sons. ISBN 0-471-60708-8.
- Stubbs, Daniel; Webre, Neil W. (1993). Datastrukturer med abstrakta datatyper och Ada . Brooks Cole. ISBN 0-534-14448-9.
- Ledru, Pascal (december 1998). Distribuerad programmering i Ada med skyddade objekt . Dissertation.com. ISBN 1-58112-034-6.
- Culwin, Fintan (1997). Ada, en utvecklingsmetod . Prentice Hall. ISBN 0-13-264680-3.
- Engelska, John; Culwin, Fintan (januari 1997). Ada 95 the Craft of Object-Oriented Programming . Prentice Hall. ISBN 0-13-230350-7.
- Musser, David R .; Stepanov, Alexander (24 oktober 1989). Ada Generic Library: Linear List Processing Packages . Springer-Verlag. ISBN 0-387-97133-5.
- Feldman, Michael B. (1997). Programvarukonstruktion och datastrukturer med Ada 95 . Addison-Wesley. ISBN 0-201-88795-9.
- Johnston, Simon (1997). Ada 95 för C och C ++ programmerare . Addison-Wesley. ISBN 0-201-40363-3.
- Feldman, Michael B .; Koffman, Elliot B. (1992–1993). Ada: Problemlösning och programdesign . Addison-Wesley. ISBN 0-201-52279-9. 795 sidor.
- Feldman, Michael B .; Koffman, Elliot B. (1999). Ada 95 . Addison-Wesley. ISBN 0-201-36123-X.
- Dale, Nell B .; Weems, Chip; McCormick, John (augusti 1996). Programmering och problemlösning med Ada 95 . Jones & Bartlett Publishers. ISBN 0-7637-0293-5.
- Dale, Nell B .; McCormick, John (2007). Ada Plus Data Structures: An Object-Oriented Approach, andra upplagan . Jones & Bartlett Publishers. ISBN 978-0-7637-3794-8.
- Krell, Bruce C. (1992). Utveckla med Ada: Life-Cycle Methods . Bantam Dell Pub Group. ISBN 0-553-09102-6.
- Biskop, Judy (10 maj 1990). Distribuerad Ada: Utvecklingar och upplevelser . Cambridge University Press. ISBN 0-521-39251-9.
- Sanden, Bo (1994). Konstruktion av mjukvarusystem med exempel i Ada . Prentice Hall. ISBN 0-13-030834-X.
- Hillam, Bruce (1994). Introduktion till abstrakta datatyper med hjälp av Ada . Prentice Hall. ISBN 0-13-045949-6.
- Rudd, David (1994). Introduktion till mjukvarudesign och utveckling med Ada . Brooks Cole. ISBN 0-314-02829-3.
- Pyle, Ian C. (1991). Utveckla säkerhetssystem: En guide med Ada . Prentice Hall. ISBN 0-13-204298-3.
- Baker, Louis (1989). Artificiell intelligens med Ada . McGraw-Hill. ISBN 0-07-003350-1.
- Burns, Alan ; Wellings, Andy (1995). HRT-HOOD: En strukturerad designmetod för hårda Ada-system i realtid . Nord-Holland. ISBN 0-444-82164-3.
- Savitch, Walter; Peterson, Charles (1992). Ada: En introduktion till programmeringens konst och vetenskap . Benjamin-Cummings Publishing Company. ISBN 0-8053-7070-6.
- Weiss, Mark Allen (1993). Datastrukturer och algoritmanalys i Ada . Benjamin-Cummings Publishing Company. ISBN 0-8053-9055-3.
- Ledgard, Henry (1983). Ada: An Introduction (andra upplagan). Springer-Verlag. ISBN 0-387-90814-5.
- Bjørner, Dines; Oest, Ole N., red. (1980). Mot en formell beskrivning av Ada . London: Springer-Verlag. ISBN 3-540-10283-3.
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.