Ada (linguagem de programação) - Ada (programming language)


Da Wikipédia, a enciclopédia livre
Ada
Paradigma Multi-paradigma
Projetado por
  • MIL-STD-1815 / Ada 83: jean ichbiah
  • Ada 95: Tucker Taft
  • Ada 2005: Tucker Taft
  • Ada 2012: Tucker Taft
Apareceu pela primeira vez Fev 1980 ; 38 anos atrás ( 1980-1902 )
Versão estável
Ada 2012 TC1 / 1 de fevereiro de 2016 ; 2 anos atrás ( 2016/02/01 )
Release Preview
Ada 2012 TC1 / abr 2015 ; 3 anos atrás ( 2015-04 )
disciplina Typing estática , forte , segura , nominativas
OS Cross-plataforma (multi-plataforma)
extensões de arquivo .adb, .ads
Local na rede Internet www .adaic .org
grandes implementações
AdaCore GNAT (download gratuito: http://libre.adacore.com/download ),
Green Hills Software Otimização Ada 95 compilador,
PTC, Inc. PTC ApexAda e PTC ObjectAda,
"MapuSoft Ada-C / C ++ trocador" ., Anteriormente conhecida como "AdaMagic com C Intermediário",
DDC-I Pontuação
dialetos
SPARK , perfil Ravenscar
Influenciado por
ALGOL 68 , Pascal , C ++ (Ada 95), Smalltalk (Ada 95), Modula-2 (Ada 95) Java (Ada 2005), Eiffel (Ada 2012)
Influenciado
C ++ , Capela , "Drago" ., Eiffel , "Griffin" ., Java , Nim , parasail , PL / SQL , PL / pgSQL , rubi , Seed7 , "SPARforte" ., Sparkel , SQL / PSM , VHDL

Ada é uma estruturada , tipagem estática , imperativo , e orientada a objetos de alto nível computador linguagem de programação , se estendia desde Pascal e outras linguagens. Ele foi construído com suporte de idioma para projeto-por-contrato , digitação extremamente forte, a simultaneidade explícita, tarefas, passagem de mensagens síncronas, objetos protegidos e não-determinismo . Ada melhora a segurança de código e de manutenção usando o compilador para encontrar erros em favor de erros de execução. Ada é uma norma internacional; a versão corrente (conhecido como Ada 2012) é definido pela norma ISO / IEC 8652: 2012.

Ada foi originalmente concebido por uma equipa liderada por jean ichbiah da CII Honeywell Touro sob contrato com o Departamento de Estados Unidos de Defesa (DoD) 1977-1983 para substituir mais de 450 linguagens de programação usadas pelo DoD nesse momento. Ada foi nomeado após Ada Lovelace (1815-1852), que foi creditado como o primeiro programador de computador.

Características

Ada foi originalmente dirigido a incorporados e em tempo real de sistemas. A revisão Ada 95, concebido por S. Tucker Taft de Intermetrics entre 1992 e 1995, um suporte melhorado para sistemas numéricos, financeiras, e orientada a objectos de programação (OOP).

Características do Ada incluem: tipagem forte , mecanismos de modularidade (pacotes), em tempo de execução verificação , processamento paralelo ( tarefas , síncrona passagem de mensagens , objetos protegidos , e não deterministas instruções select ), tratamento de exceções , e os genéricos . Ada 95 adicionou suporte para programação orientada para o objecto , incluindo o envio dinâmico .

A sintaxe de Ada minimiza escolhas de maneiras de executar operações básicas, e prefere palavras-chave em inglês (como "ou então" e "e") para símbolos (como "||" e "&&"). Ada usa os operadores aritméticos básicos "+", "-", "*" e "/", mas evita usar outros símbolos. Blocos de código são delimitados por palavras tais como "declarar", "começar" e "fim", onde o "fim" (na maioria dos casos) é seguido pelo identificador do bloco que fecha (por exemplo, se ... final, se , circuito ... end loop ). No caso de blocos condicionais isso evita uma outra coisa pendurada que poderia emparelhar com o nested se-expressão errada em outras linguagens como C ou Java.

Ada é projetado para o desenvolvimento de grandes sistemas de software. pacotes Ada podem ser compilados separadamente. especificações do pacote ada (a interface do pacote) também pode ser compilado separadamente sem a aplicação para verificar a consistência. Isso torna possível para detectar problemas mais cedo durante a fase de design, antes do início da implementação.

Um grande número de verificações de tempo de compilação são suportadas para ajudar a evitar erros que não seria detectável até run-time em algumas outras línguas ou exigiriam verificações explícitas para ser adicionado ao código-fonte. Por exemplo, a sintaxe exige explicitamente chamado fechamento de blocos para evitar erros devido a símbolos finais incompatíveis. A adesão a tipagem forte permite a detecção de muitos erros comuns de software (parâmetros errados, violações alcance, referências inválidas, tipos incompatíveis, etc.), quer durante tempo de compilação, ou de outra forma durante o tempo de execução. Como a concorrência é parte da especificação da linguagem, o compilador pode, em alguns casos detectar possíveis impasses. Compiladores também comumente verificar identificadores com erros ortográficos, a visibilidade de pacotes, declarações redundantes, etc. e pode fornecer avisos e sugestões úteis sobre como corrigir o erro.

Ada também suporta verificações de tempo de execução para proteger contra o acesso à memória não alocado, buffer overflow erros, violações alcance, off-by-one erros , erros de acesso à matriz, e outros erros detectáveis. Estas verificações podem ser desativadas no interesse da eficiência de tempo de execução, mas muitas vezes pode ser compilado de forma eficiente. Ele também inclui instalações para ajudar a verificação do programa. Por estas razões, Ada é amplamente utilizado em sistemas críticos, onde qualquer anomalia pode levar a consequências muito graves, por exemplo, morte acidental, lesão ou perda financeira grave. Os exemplos de sistemas onde Ada é usado incluem aviônicos , ATC , ferrovias, serviços bancários, militar e tecnologia espacial.

Dinâmica de Ada gerenciamento de memória é de alto nível e tipo seguro. Ada não tem genéricos ou sem tipo ponteiros ; nem declarar implicitamente qualquer tipo de ponteiro. Em vez disso, toda a alocação dinâmica de memória e desalocação deve ocorrer através explicitamente declarados tipos de acesso . Cada tipo de acesso tem um associado pool de armazenamento que lida com os detalhes de baixo nível de gerenciamento de memória; o programador pode utilizar a piscina de armazenamento padrão ou definir novas (isto é particularmente relevante para o acesso não uniforme a memória ). É ainda possível declarar vários tipos de acesso diferentes que todos designam o mesmo tipo, mas usam diferentes pools de armazenamento. Além disso, a linguagem prevê verificações de acessibilidade , tanto em tempo de compilação e em tempo de execução, que garante que um valor de acesso não pode sobreviver ao tipo de objeto ele aponta.

Embora a semântica da linguagem permitir automático de coleta de lixo de objetos inacessíveis, a maioria das implementações não suportam-lo por padrão, uma vez que poderia causar um comportamento imprevisível em sistemas de tempo real. Ada suporta uma forma limitada de gerenciamento de memória baseada em região ; também, o uso criativo de pools de armazenamento pode fornecer para uma forma limitada de coleta de lixo automática, desde a destruição de um pool de armazenamento também destrói todos os objetos na piscina.

Um duplo traço ( "-"), semelhante a um travessão , denota texto do comentário. Comentários parar no fim da linha, para evitar comentários não fechadas acidentalmente anular seções inteiras do código-fonte. A desativação de um bloco inteiro de código agora exige que o prefixo de cada linha (ou coluna) individualmente com "-". Enquanto denotando claramente código desativado com uma coluna de repetidos "-" para baixo a página isto torna o dis experimentais / re-habilitação de grandes blocos de um processo mais prolongado.

O ponto e vírgula ( ";") é um terminador de instrução , eo nulo ou não-operação afirmação é null;. Uma única ;sem uma declaração de encerrar não é permitido.

Ao contrário da maioria ISO normas, a definição da linguagem Ada (conhecido como o manual de Ada Referência ou ARM , ou às vezes o Manual de Referência da Linguagem ou LRM ) é de conteúdo livre . Assim, é uma referência comum para programadores Ada e não apenas programadores de aplicação compiladores Ada. Além do manual de referência, há também um extenso documento lógica que explica o projeto de linguagem e o uso de várias construções de linguagem. Este documento também é amplamente utilizado por programadores. Quando o idioma foi revisado, um novo documento lógica foi escrito.

Uma notável software livre ferramenta que é utilizada por muitos programadores Ada para ajudá-los a escrever o código fonte Ada é o Estúdio GNAT programação .

História

Na década de 1970, o Departamento de Defesa dos EUA (DoD) estava preocupado com o número de diferentes linguagens de programação que está sendo usado para os seus projectos de sistemas informáticos incorporados, muitos dos quais eram obsoletos ou dependentes de hardware, e nenhum dos que apoiou a programação modular seguro. Em 1975, um grupo de trabalho , a Língua Grupo de Trabalho Ordem de alta (HOLWG), foi formada com a intenção de reduzir este número por encontrar ou criar uma linguagem de programação geralmente adequado para o departamento de e o Ministério da Defesa do Reino Unido requisitos. Depois de muitas iterações começando com um original Proposta do homem de palha a eventual linguagem de programação foi nomeado Ada. O número total de linguagens de programação de alto nível em uso para estes projectos caiu de mais de 450 em 1983 para 37, 1996.

O grupo de trabalho HOLWG trabalhada os requisitos linguísticos Steelman , uma série de documentos que indicam os requisitos que sentiram uma linguagem de programação deve satisfazer. Muitas línguas existentes foram revisados formalmente, mas a equipe concluiu em 1977 que nenhuma língua existente reunidas as especificações.

Os pedidos de propostas para uma nova linguagem de programação foram emitidas e quatro empreiteiros foram contratados para desenvolver suas propostas no âmbito dos nomes dos Red ( Intermetrics liderado por Benjamin Brosgol), Green ( CII Honeywell Touro , liderado por jean ichbiah ), Azul ( SofTech , liderados por John Goodenough) e amarelo ( SRI International , liderada por Jay Spitzen). Em abril de 1978, após o escrutínio público, a propostas vermelhas e verdes passado para a próxima fase. Em maio de 1979, a proposta verde, projetado por jean ichbiah a CII Honeywell Bull foi escolhido e dado o nome Ada-após Augusta Ada, Condessa de Lovelace . Esta proposta foi influenciado pela linguagem de programação LIS que Ichbiah e seu grupo tinham desenvolvido na década de 1970. O manual de referência preliminar Ada foi publicada nas Informações ACM SIGPLAN em junho de 1979. O manual de referência padrão militar foi aprovado em 10 de Dezembro, 1980 ( Ada Lovelace aniversário 's), e dado o número MIL-STD-1815 em honra do nascimento de Ada Lovelace ano. Em 1981, a CAR Hoare se aproveitou de seu Turing Award discurso para criticar Ada por ser excessivamente complexa e, portanto, não confiável, mas depois parecia retratar no prefácio que escreveu para um livro de Ada.

Ada atraído muita atenção por parte da comunidade de programação como um todo durante seus primeiros dias. Seus aliados e outros previram que ele pode se tornar uma língua dominante para a programação de propósito geral e não apenas trabalho-relacionados com a defesa. Ichbiah declarou publicamente que dentro de dez anos, apenas duas linguagens de programação permaneceria, Ada e Lisp . Compiladores Ada primeiros lutado para implementar a grande linguagem, complexo, e tanto em tempo de compilação e tempo de execução desempenho tende a ser lenta e ferramentas primitivas. Fornecedores do compilador gasta a maior parte de seus esforços em passar a, língua-conformidade-teste, suite enorme exigido pelo governo "ACVC" validação que foi exigido por outro característica inovadora do esforço linguagem Ada.

A implementação Ada primeira validado foi o tradutor NYU Ada / Ed, certificadas em 11 de abril de 1983. NYU Ada / Ed é implementado na linguagem conjunto de alto nível SETL . Uma série de empresas comerciais começaram a oferecer compiladores Ada e ferramentas de desenvolvimento associadas, incluindo Alsys , Telesoft , DDC-I , técnicas de computação avançada , Laboratories Tartan , Sistemas TLD , Verdix , e outros.

Augusta Ada Rei , condessa de Lovelace.

Em 1991, o Departamento de Defesa dos Estados Unidos começou a exigir o uso de Ada (o mandato Ada ) para todo o software, embora exceções a esta regra eram frequentemente concedido. O mandato do Departamento de Defesa Ada foi efetivamente removido em 1997, como o DoD começou a abraçar COTS tecnologia. Requisitos semelhantes existiram em outros OTAN países: Ada foi necessário para os sistemas da NATO envolvendo comando e controle e outras funções, e Ada era a língua obrigatória ou preferida para aplicações relacionadas com a defesa em países como a Suécia, Alemanha e Canadá.

No final dos anos 1980 e início dos anos 1990, compiladores Ada tinha melhorado no desempenho, mas ainda havia barreiras para a plena exploração das capacidades de Ada, incluindo um modelo tasking que era diferente do que a maioria dos programadores em tempo real foram usadas para.

Por causa de Ada de segurança crítica recursos de suporte, é agora usado não só para aplicações militares, mas também em projetos comerciais onde um erro de software pode ter consequências graves, por exemplo, aviônicos e de controle de tráfego aéreo , foguetes comerciais, como o Ariane 4 e 5 , satélites e outros sistemas espaciais, transporte ferroviário e bancárias. Por exemplo, o Sistema de Gestão de Informação avião , o fly-by-wire software do sistema no Boeing 777 , foi escrito em Ada. Desenvolvido por sistemas de transporte aéreo Honeywell em colaboração com consultores da DDC-I , tornou-se indiscutivelmente o mais conhecido de qualquer projeto Ada, civil ou militar. O sistema de tráfego aéreo Automated canadense foi escrito em 1 milhão de linhas de Ada ( SLOC contagem). Ele apresentava processamento avançado distribuído, um banco de dados Ada distribuída e projeto orientado a objetos. Ada é também usado em outros sistemas de tráfego aéreo, por exemplo, ferramentas Futuro Controle de Área Support (iFacts) sistema de controle de próxima geração do Reino Unido Interim tráfego aéreo é concebido e implementado usando SPARK Ada. Ele também é usado no francês TVM in- cab sinalização do sistema no TGV sistema ferroviário de alta velocidade, e os trens suburbanos de metrô em Paris, Londres, Hong Kong e Nova York.

estandardização

A linguagem tornou-se um ANSI padrão em 1983 ( ANSI / MIL-STD 1815A tradução), e depois em francês e sem quaisquer alterações em Inglês tornou-se um padrão ISO em 1987 (ISO-8652: 1987). Esta versão da linguagem é comumente conhecido como Ada 83, a partir da data da sua adopção pelo ANSI, mas às vezes é referido também como Ada 87, a partir da data da sua aprovação pela ISO.

Ada 95, o padrão ISO / ANSI conjunta ( ISO-8652: 1995 ) foi publicado em fevereiro de 1995, tornando Ada 95 o primeiro padrão linguagem de programação orientada a objetos ISO. Para ajudar com a revisão padrão e aceitação futuro, a Força Aérea dos EUA financiou o desenvolvimento do GNAT Compiler . Atualmente, a GNAT Compiler faz parte do GNU Compiler Collection .

Trabalho continuou em melhorar e atualizar o conteúdo técnico da linguagem de programação Ada. A Rectificação Técnico para Ada 95 foi publicado em Outubro de 2001, e uma alteração importante, ISO / IEC 8652: 1995 / Amd 1: 2007 foi publicado em 9 de Março de 2007. Em Ada-Europa, a conferência de 2012 em Estocolmo, a Associação de Recursos Ada (ARA) e Ada-Europe anunciou a conclusão do projeto da versão mais recente da linguagem de programação Ada ea apresentação do manual de referência para a Organização Internacional de Normalização (ISO) para aprovação. ISO / IEC 8652: 2012 foi publicado em dezembro de 2012.

Outras normas relacionadas incluem ISO 8651 -3: 1988 processamento de Sistemas de Informação, Computação gráfica-Graphical Kernel System (GKS) língua ligações-Parte 3: Ada .

construções de linguagem

Ada é uma ALGOL -como linguagem de programação com estruturas de controle com palavras reservadas, como se , em seguida , outra pessoa , enquanto , para , e assim por diante. No entanto, Ada também tem muitas facilidades de estruturação de dados e outras abstrações que não foram incluídos no original ALGOL 60 , tais como definições de tipo , registros , ponteiros , enumerações . Tais construes foram, em parte, a partir de ou herdado inspirado por Pascal .

"Olá Mundo!" em Ada

Um exemplo comum de uma língua sintaxe é o programa Olá, mundo : (hello.adb)

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

Este programa pode ser compilado usando o compilador de código aberto disponível gratuitamente GNAT , executando

gnatmake hello.adb

Tipos de dados

Sistema de tipo de Ada não se baseia em um conjunto de predefinidos tipos primitivos , mas permite que os usuários declarar os seus próprios tipos. Esta declaração por sua vez, não se baseia na representação interna do tipo, mas em que descreve o objectivo que deve ser atingido. Isto permite que o compilador para determinar um tamanho de memória adequado para o tipo, e para verificar se há violações da definição de tipo em tempo de compilação e tempo de execução (isto é, gama violações, sobrecargas de buffer, tipo de consistência, etc.). Ada suporta tipos numéricos definidas por um intervalo, tipos de módulo, tipos de agregados (fichas e matrizes), e os tipos de enumeração. Os tipos de acesso definir uma referência a um exemplo de um tipo especificado; ponteiros sem tipo não são permitidas. Tipos especiais fornecidos pela linguagem são tipos de tarefas e de conservação.

Por exemplo, uma data pode ser representada como:

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;

Tipos pode ser refinado, declarando subtipos:

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

Tipos pode ter modificadores tal como limitado, abstratas, privadas tipos etc. privado só pode ser acessado e tipos limitados só podem ser modificados ou copiados no âmbito do pacote que os define. Ada 95 acrescenta recursos adicionais para a extensão orientada a objetos de tipos.

estruturas de controle

Ada é uma programação estruturada linguagem, o que significa que o fluxo de controle está estruturado em declarações padrão. Todas as construções padrão e nível profundo saída precoce são suportados de modo que o uso do também apoiou ' ir para ' comandos raramente é necessário.

-- 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;

Pacotes, procedimentos e funções

Entre as partes de um programa Ada são pacotes, procedimentos e funções.

Exemplo: especificação Pacote (example.ads)

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

corpo do pacote (example.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;

Este programa pode ser compilados, por exemplo, utilizando o compilador aberto fonte livremente disponível GNAT , executando

gnatmake -z example.adb

Os pacotes, procedimentos e funções podem ninho para qualquer profundidade e cada um pode ser também o bloco lógico mais exterior.

Cada pacote, procedimento ou função pode ter suas próprias declarações de constantes, tipos, variáveis ​​e outros procedimentos, funções e pacotes, que podem ser declarados em qualquer ordem.

simultaneidade

Ada tem suporte linguagem para concorrência baseada em tarefas. A unidade concorrente fundamental na Ada é uma tarefa , que é um tipo limitado embutido. As tarefas são especificadas em duas partes - o declaração tarefa define a interface de tarefa (semelhante a uma declaração de tipo), o corpo da tarefa especifica a execução da tarefa. Dependendo da implementação, tarefas Ada ou são mapeados para segmentos ou processos do sistema operacional, ou estão programadas internamente pelo runtime Ada.

As tarefas podem ter entradas para sincronização (uma forma de passagem de mensagens síncronas ). Entradas de tarefa são declarados na especificação tarefa. Cada entrada tarefa pode ter um ou mais aceitar instruções dentro do corpo da tarefa. Se o fluxo da tarefa de controle atinge uma declaração de aceitar, a tarefa é bloqueado até que a entrada correspondente é chamado por outra tarefa (da mesma forma, uma tarefa chamada é bloqueado até que a tarefa chamada atinge a declaração aceitar correspondente). Entradas de tarefa pode ter parâmetros semelhantes aos procedimentos, permitindo que tarefas para trocar de forma síncrona de dados. Em conjunto com selecione declarações é possível definir guardas de aceitar declarações (semelhante ao de Dijkstra comandos guardados ).

Ada também oferece objetos protegidos para exclusão mútua . Objectos protegidos são um monitor como construo, mas usar guardas em vez de variáveis condicionais para a sinalização (semelhante às regiões críticas condicionais). Objetos protegidos combinar o encapsulamento de dados e exclusão mútua salvo de monitores e guardas de entrada de regiões críticas condicionais. A principal vantagem sobre os monitores clássicos é que as variáveis condicionais não são necessários para a sinalização, evitando potenciais bloqueios devido a semântica travamento incorrecto. Como tarefas, o objeto protegido é um tipo limitado built-in, e também tem uma parte de declaração e um corpo.

Um objecto protegido consiste de dados encapsulados particulares (que só podem ser acedidos a partir de dentro do objecto protegido), e os procedimentos, as funções e as entradas que são garantidos a ser mutuamente exclusivas (com a única excepção de funções, que são necessárias para ser livre de efeitos colaterais e pode, por conseguinte, ser executado simultaneamente com outras funções). A tarefa de chamar um objeto protegido é bloqueado se uma outra tarefa está em execução dentro do mesmo objeto protegido, e liberada quando esta outra tarefa deixa o objeto protegido. tarefas bloqueados são enfileiradas no objeto protegido ordenados por tempo de chegada.

Entradas objeto protegido são semelhantes aos procedimentos, mas também tem guardas . Se um guarda avaliada como falsa, uma tarefa chamada está bloqueado e adicionado à fila de que a entrada; agora outra tarefa pode ser admitido para o objeto protegido, como nenhuma tarefa está sendo executado dentro do objeto protegido. Guardas são novamente avaliados sempre que uma tarefa deixa o objeto protegido, como este é o único momento em que a avaliação de guardas pode ter mudado.

Chamadas para as entradas podem ser reenfileirada a outras entradas com a mesma assinatura. A tarefa que é recolocado na fila é bloqueada e adicionado à fila de entrada do alvo; isto significa que o objeto protegido é lançado e permite a admissão de outra tarefa.

O seleto declaração em Ada pode ser usado para implementar não-bloqueio de entrada de chamadas e aceita, a seleção não-determinístico de entradas (também com guardas), time-outs e aborta.

O exemplo a seguir ilustra alguns conceitos de programação concorrente em 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 just 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

Um pragma é uma directiva compilador que transmite informação para o compilador para permitir a manipulação específica de saída compilada. Certos pragmas são incorporadas ao idioma, enquanto outros são específicos de implementação.

Exemplos de uso comum de pragmas compilador seria para desactivar certas características, tais como o tipo de controlo de tempo de execução ou matriz subscrito verificação de fronteira, ou para instruir o compilador para inserir código objecto no lugar de uma chamada de função (como C / C ++ faz com in-line funções).

Veja também

  • APSE - uma especificação para um ambiente de programação para apoiar o desenvolvimento de software em Ada
  • Perfil Ravenscar - um subconjunto dos recursos tasking Ada projetados para duro computação em tempo real de segurança crítica
  • SPARK (linguagem de programação) - uma linguagem de programação que consiste de um subconjunto altamente restrito de Ada, anotada com uma meta-informação descrevendo o comportamento desejado dos componentes e requisitos de tempo de execução individuais

Referências

Padrões internacionais

análise racional

(Estes documentos foram publicados em várias formas, incluindo impressão.)

livros

arquivo

  • Ada Programming Materiais Language, 1981-1990 . Charles Babbage Institute , da Universidade de Minnesota. Inclui literatura sobre produtos de software projetados para a linguagem Ada; Publicações do governo dos EUA, incluindo relatórios Ada 9X projeto, relatórios técnicos, documentos de trabalho, boletins informativos; e informações grupo de usuários.

links externos