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

Ada
Paradigma Multi-paradigma : estruturado , imperativo , orientado a objetos
Família Pascal
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 Fevereiro de 1980 ; 41 anos atrás ( 1980-02 )
Versão estável
Ada 2012 TC1
Disciplina de digitação estático , forte , seguro , nominativo
SO Multi ou multiplataforma
Extensões de nome de arquivo .adb, .ads
Local na rede Internet www .adaic .org
Implementações principais
AdaCore GNAT (download gratuito: https://www.adacore.com/download ), compilador
Green Hills Software Optimizing Ada 95,
PTC, Inc. PTC ApexAda e PTC ObjectAda,
"MapuSoft Ada-C / C ++ changer" ., anteriormente conhecido como "AdaMagic com C intermediário", Pontuação
DDC-I
Dialetos
SPARK , perfil Ravenscar
Influenciado por
ALGOL 68 , Pascal , Simula 67 , C ++ (Ada 95), Smalltalk (Ada 95), Modula-2 (Ada 95) Java (Ada 2005), Eiffel (Ada 2012)
Influenciado
C ++ , Chapel , Drago , D , Eiffel , Griffin, Java , Nim , ParaSail , PL / SQL , PL / pgSQL , Python , Ruby , Seed7 , SPARforte, Sparkel , SQL / PSM , VHDL

Ada é uma linguagem de programação de alto nível estruturada , estaticamente tipada , imperativa e orientada a objetos , estendida de Pascal e outras linguagens. Possui suporte de linguagem embutido para design by contract (DbC), tipagem extremamente forte , simultaneidade explícita, tarefas, passagem síncrona de mensagens, objetos protegidos e não determinismo . Ada melhora a segurança do código e a capacidade de manutenção usando o compilador para localizar erros em favor de erros de tempo de execução . Ada é uma norma técnica internacional , definida em conjunto pela International Organization for Standardization (ISO) e a International Electrotechnical Commission (IEC). A partir de 2020, o padrão, denominado Ada 2012 informalmente, é ISO / IEC 8652: 2012.

Ada foi originalmente projetado por uma equipe liderada pelo cientista da computação francês Jean Ichbiah do CII Honeywell Bull sob contrato com o Departamento de Defesa dos Estados Unidos (DoD) de 1977 a 1983 para substituir mais de 450 linguagens de programação usadas pelo DoD naquela época. Ada foi nomeada em homenagem a Ada Lovelace (1815–1852), que foi creditado como o primeiro programador de computador.

Recursos

Ada foi originalmente projetado para sistemas embarcados e em tempo real. A revisão Ada 95, projetada por S. Tucker Taft da Intermetrics entre 1992 e 1995, melhorou o suporte para programação de sistemas, numérica, financeira e orientada a objetos (OOP).

Os recursos do Ada incluem: tipagem forte , mecanismos de programação modular (pacotes), verificação em tempo de execução , processamento paralelo ( tarefas , passagem de mensagem síncrona , objetos protegidos e instruções de seleção não determinísticas ), tratamento de exceções e genéricos . Ada 95 adicionou suporte para programação orientada a objetos , incluindo despacho dinâmico .

A sintaxe de Ada minimiza as opções de maneiras de realizar operações básicas e prefere palavras-chave em inglês (como "or else" e "e então") a símbolos (como "||" e "&&"). Ada usa os operadores aritméticos básicos "+", "-", "*" e "/", mas evita usar outros símbolos. Os blocos de código são delimitados por palavras como "declarar", "começar" e "fim", onde o "fim" (na maioria dos casos) é seguido pelo identificador do bloco que fecha (por exemplo, if ... end if , loop ... end loop ). No caso de blocos condicionais, isso evita um else pendente que poderia emparelhar com a expressão if aninhada incorreta em outras linguagens como C ou Java.

Ada é projetado para desenvolver sistemas de software muito grandes. Os pacotes Ada podem ser compilados separadamente. As especificações do pacote Ada (a interface do pacote) também podem ser compiladas separadamente sem a implementação para verificar a consistência. Isso possibilita detectar problemas no início da fase de design, antes do início da implementação.

Um grande número de verificações de tempo de compilação é suportado para ajudar a evitar bugs que não seriam detectáveis ​​até o tempo de execução em algumas outras linguagens ou exigiriam verificações explícitas a serem adicionadas ao código-fonte. Por exemplo, a sintaxe requer fechamento explicitamente nomeado de blocos para evitar erros devido a tokens de final incompatíveis. A adesão à tipagem forte permite detectar muitos erros de software comuns (parâmetros errados, violações de faixa, referências inválidas, tipos incompatíveis, etc.) durante o tempo de compilação ou de outra forma durante o tempo de execução. Como a simultaneidade faz parte da especificação da linguagem, o compilador pode, em alguns casos, detectar possíveis deadlocks. Os compiladores também costumam verificar identificadores com erros ortográficos, visibilidade de pacotes, declarações redundantes, etc. e podem fornecer avisos e sugestões úteis sobre como corrigir o erro.

Ada também oferece suporte a verificações de tempo de execução para proteger contra acesso à memória não alocada, erros de estouro de buffer , violações de intervalo, erros off-by-one , erros de acesso de array e outros bugs detectáveis. Essas verificações podem ser desabilitadas no interesse da eficiência do tempo de execução, mas muitas vezes podem ser compiladas com eficiência. Também inclui recursos para ajudar na verificação do programa . Por essas razões, Ada é amplamente utilizado em sistemas críticos, onde qualquer anomalia pode levar a consequências muito graves, por exemplo, morte acidental, ferimentos ou graves perdas financeiras. Exemplos de sistemas onde Ada é usado incluem aviônica , controle de tráfego aéreo , ferrovias, bancos, tecnologia militar e espacial.

O gerenciamento de memória dinâmica de Ada é de alto nível e com segurança de tipo. Ada não tem ponteiros genéricos ou não digitados ; nem declara implicitamente qualquer tipo de ponteiro. Em vez disso, toda alocação e desalocação de memória dinâmica devem ocorrer por meio de tipos de acesso declarados explicitamente . Cada tipo de acesso tem um pool de armazenamento associado que lida com os detalhes de baixo nível de gerenciamento de memória; o programador pode usar o pool de armazenamento padrão ou definir novos (isso é particularmente relevante para Acesso à memória não uniforme ). É ainda possível declarar vários tipos de acesso diferentes que designam o mesmo tipo, mas usam pools de armazenamento diferentes. Além disso, a linguagem fornece verificações de acessibilidade , tanto em tempo de compilação quanto em tempo de execução, que garantem que um valor de acesso não sobreviva ao tipo de objeto para o qual aponta.

Embora a semântica da linguagem permita a coleta de lixo automática de objetos inacessíveis, a maioria das implementações não a suporta por padrão, pois causaria um comportamento imprevisível em sistemas de tempo real. Ada oferece suporte a uma forma limitada de gerenciamento de memória baseado em região ; além disso, o uso criativo de pools de armazenamento pode fornecer uma forma limitada de coleta de lixo automática, uma vez que destruir um pool de armazenamento também destrói todos os objetos no pool.

Um travessão duplo ("-"), semelhante a um travessão , indica o texto do comentário. Os comentários param no final da linha, para evitar que comentários não fechados anulem acidentalmente seções inteiras do código-fonte. A desativação de um bloco inteiro de código agora requer a prefixação de cada linha (ou coluna) individualmente com "-". Embora denote claramente o código desativado com uma coluna de "-" repetido ao longo da página, isso torna a desativação / reativação experimental de blocos grandes um processo mais demorado.

O ponto-e-vírgula (";") é um terminador de instrução , e a instrução nula ou sem operação é null;. Um single ;sem uma declaração para encerrar não é permitido.

Ao contrário da maioria dos padrões ISO , a definição de linguagem Ada (conhecida como Manual de Referência Ada ou ARM ou, às vezes, Manual de Referência de Linguagem ou LRM ) é um conteúdo gratuito . Portanto, é uma referência comum para programadores Ada, não apenas programadores que implementam compiladores Ada. Além do manual de referência, há também um extenso documento de justificativa que explica o design da linguagem e o uso de várias construções de linguagem. Este documento também é amplamente utilizado por programadores. Quando a linguagem foi revisada, um novo documento de justificativa foi escrito.

Uma notável ferramenta de software livre usada por muitos programadores Ada para ajudá-los a escrever o código-fonte Ada é o GNAT Programming Studio , parte da GNU Compiler Collection .

História

Na década de 1970, o Departamento de Defesa dos Estados Unidos (DoD) ficou preocupado com o número de linguagens de programação diferentes sendo usadas para seus projetos de sistema de computador embarcado, muitos dos quais eram obsoletos ou dependentes de hardware, e nenhum deles suportava programação modular segura. Em 1975, um grupo de trabalho , o High Order Language Working Group (HOLWG), foi formado com a intenção de reduzir esse número, encontrando ou criando uma linguagem de programação geralmente adequada para os requisitos do departamento e do Ministério da Defesa do Reino Unido . Depois de muitas iterações, começando com uma proposta original do Homem de Palha, a linguagem de programação eventual foi chamada de Ada. O número total de linguagens de programação de alto nível em uso para tais projetos caiu de mais de 450 em 1983 para 37 em 1996.

O grupo de trabalho HOLWG elaborou os requisitos da linguagem Steelman , uma série de documentos declarando os requisitos que eles achavam que uma linguagem de programação deveria satisfazer. Muitos idiomas existentes foram revisados ​​formalmente, mas a equipe concluiu em 1977 que nenhum idioma existente atendia às especificações.

Augusta Ada King , Condessa de Lovelace.

Pedidos de propostas para uma nova linguagem de programação foram emitidos e quatro empreiteiros foram contratados para desenvolver suas propostas sob os nomes de Red ( Intermetrics liderada por Benjamin Brosgol), Green ( CII Honeywell Bull , liderada por Jean Ichbiah ), Blue ( SofTech , liderada por John Goodenough) e Yellow ( SRI International , liderado por Jay Spitzen). Em abril de 1978, após escrutínio público, as propostas Vermelha e Verde passaram para a próxima fase. Em maio de 1979, a proposta Verde, desenhada por Jean Ichbiah no CII Honeywell Bull, foi escolhida e recebeu o nome de Ada - em homenagem a Augusta Ada, condessa de Lovelace . Essa proposta foi influenciada pela linguagem LIS que Ichbiah e seu grupo desenvolveram na década de 1970. O manual de referência preliminar da Ada foi publicado em ACM SIGPLAN Notices em junho de 1979. O manual de referência do Padrão Militar foi aprovado em 10 de dezembro de 1980 ( aniversário de Ada Lovelace ), e recebeu o número MIL-STD-1815 em homenagem ao nascimento de Ada Lovelace ano. Em 1981, CAR Hoare aproveitou seu discurso sobre o Prêmio Turing para criticar Ada por ser excessivamente complexa e, portanto, não confiável, mas posteriormente pareceu se retratar no prefácio que escreveu para um livro de Ada.

Ada atraiu muita atenção da comunidade de programação como um todo durante seus primeiros dias. Seus patrocinadores e outros previram que ela poderia se tornar uma linguagem dominante para programação de propósito geral e não apenas para trabalhos relacionados à defesa. Ichbiah declarou publicamente que dentro de dez anos, apenas duas linguagens de programação permaneceriam: Ada e Lisp . Os primeiros compiladores Ada se esforçaram para implementar a linguagem grande e complexa, e tanto o desempenho em tempo de compilação quanto em tempo de execução tendiam a ser lentos e as ferramentas primitivas. Os fornecedores de compiladores despenderam a maior parte de seus esforços para passar no enorme pacote de validação "ACVC" exigido pelo governo, para testes de conformidade de linguagem e exigido em outro recurso novo do esforço da linguagem Ada. The Jargon File , um dicionário de gíria de hackers de computador originado em 1975-1983, observa em uma entrada em Ada que "é exatamente o que se poderia esperar, dado esse tipo de endosso por decreto; elaborado por um comitê ... difícil de usar e no geral, uma confusão desastrosa de vários bilhões de dólares ... Ada Lovelace ... quase certamente empalideceria com o uso que seu nome foi feito recentemente; a coisa mais gentil que foi dita sobre isso é que provavelmente há um bom nome linguagem gritando para sair de dentro de seu vasto volume elefantino. "

A primeira implementação Ada validada foi o tradutor Ada / Ed da NYU, certificado em 11 de abril de 1983. O Ada / Ed da NYU é implementado na linguagem de conjunto de alto nível SETL . Várias empresas comerciais começaram a oferecer compiladores Ada e ferramentas de desenvolvimento associadas, incluindo Alsys , TeleSoft , DDC-I , Advanced Computer Techniques , Tartan Laboratories , TLD Systems e Verdix .

Em 1991, o Departamento de Defesa dos Estados Unidos começou a exigir o uso de Ada (o mandato Ada ) para todos os softwares, embora exceções a essa regra fossem frequentemente concedidas. O mandato do Departamento de Defesa Ada foi efetivamente removido em 1997, quando o DoD começou a adotar a tecnologia comercial de prateleira ( COTS ). Exigências semelhantes existiam em outros países da OTAN : Ada era necessária para sistemas da OTAN envolvendo comando e controle e outras funções, e Ada era o idioma obrigatório ou preferido para aplicações relacionadas à defesa em países como Suécia, Alemanha e Canadá.

No final da década de 1980 e início da década de 1990, os compiladores Ada haviam melhorado em desempenho, mas ainda havia barreiras para explorar totalmente as habilidades de Ada, incluindo um modelo de tarefas diferente daquele com o qual a maioria dos programadores de tempo real estava acostumada.

Por causa dos recursos de suporte de segurança crítica do Ada , ele agora é usado não apenas para aplicações militares, mas também em projetos comerciais onde um bug de software pode ter consequências graves, por exemplo, aviônicos e 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ário. Por exemplo, o Airplane Information Management System , o software do sistema fly-by-wire do Boeing 777 , foi escrito em Ada. Desenvolvido pela Honeywell Air Transport Systems em colaboração com consultores da DDC-I , ele se tornou indiscutivelmente o mais conhecido de qualquer projeto Ada, civil ou militar. O Canadian Automated Air Traffic System foi escrito em 1 milhão de linhas de Ada ( contagem SLOC ). Ele apresentava processamento distribuído avançado , um banco de dados Ada distribuído e design orientado a objetos. Ada também é usado em outros sistemas de tráfego aéreo, por exemplo, o sistema de controle de tráfego aéreo provisório de próxima geração do Suporte de Ferramentas de Controle de Área do Futuro (iFACTS) do Reino Unido é projetado e implementado usando SPARK Ada. Também é usado no sistema de sinalização na cabine da TVM francês no sistema ferroviário de alta velocidade TGV e nos trens suburbanos de Paris, Londres, Hong Kong e Nova York.

estandardização

O idioma tornou-se um padrão ANSI em 1983 ( ANSI / MIL-STD 1815A ) e, após a tradução em francês e sem quaisquer alterações adicionais em inglês, tornou-se um padrão ISO em 1987 (ISO-8652: 1987). Essa versão da linguagem é comumente conhecida como Ada 83, a partir da data de sua adoção pelo ANSI, mas às vezes também é chamada de Ada 87, a partir da data de sua adoção pela ISO.

Ada 95, o padrão conjunto ISO / ANSI ( ISO-8652: 1995 ) foi publicado em fevereiro de 1995, tornando o Ada 95 a primeira linguagem de programação orientada a objetos do padrão ISO. Para ajudar na revisão do padrão e aceitação futura, a Força Aérea dos Estados Unidos financiou o desenvolvimento do Compilador GNAT . Atualmente, o GNAT Compiler faz parte da GNU Compiler Collection .

Prosseguiu o trabalho de melhoria e atualização do conteúdo técnico da linguagem Ada. Uma retificação técnica para Ada 95 foi publicada em outubro de 2001, e uma alteração principal, ISO / IEC 8652: 1995 / Amd 1: 2007 foi publicada em 9 de março de 2007. Na conferência Ada-Europe 2012 em Estocolmo, a Ada Resource Association (ARA) e a Ada-Europe anunciaram a conclusão do design da versão mais recente da linguagem Ada e o envio do manual de referência à Organização Internacional de Padronização (ISO) para aprovação. ISO / IEC 8652: 2012 foi publicado em dezembro de 2012.

Outros padrões relacionados incluem ISO 8651 -3: 1988 Sistemas de processamento de informações — Gráficos de computador — Vinculações de linguagem Graphical Kernel System (GKS) — Parte 3: Ada .

Construções de linguagem

Ada é uma linguagem de programação semelhante ao ALGOL que apresenta estruturas de controle com palavras reservadas, como if , then , else , while , for e assim por diante. No entanto, Ada também tem muitos recursos de estruturação de dados e outras abstrações que não foram incluídas no ALGOL 60 original , como definições de tipo , registros , ponteiros , enumerações . Essas construções foram em parte herdadas ou inspiradas por Pascal .

"Olá Mundo!" em Ada

Um exemplo comum de sintaxe de uma linguagem é o programa Hello world : (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 GNAT disponível gratuitamente , executando

gnatmake hello.adb

Tipos de dados

O sistema de tipos de Ada não é baseado em um conjunto de tipos primitivos predefinidos, mas permite que os usuários declarem seus próprios tipos. Essa declaração, por sua vez, não se baseia na representação interna do tipo, mas na descrição do objetivo que deve ser alcançado. Isso permite que o compilador determine um tamanho de memória adequado para o tipo e verifique se há violações da definição de tipo em tempo de compilação e tempo de execução (ou seja, violações de intervalo, saturações de buffer, consistência de tipo, etc.). Ada oferece suporte a tipos numéricos definidos por um intervalo, tipos de módulo, tipos de agregação (registros e matrizes) e tipos de enumeração. Os tipos de acesso definem uma referência a uma instância de um tipo especificado; ponteiros não digitados não são permitidos. Os tipos especiais fornecidos pela linguagem são tipos de tarefas e tipos protegidos.

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;

Os tipos podem ser refinados 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

Os tipos podem ter modificadores como limitado, abstrato, privado, etc. Os tipos privados só podem ser acessados ​​e os tipos limitados só podem ser modificados ou copiados dentro do escopo do pacote que os define. Ada 95 adiciona mais recursos para extensão orientada a objetos de tipos.

Estruturas de controle

Ada é uma linguagem de programação estruturada , o que significa que o fluxo de controle é estruturado em instruções padrão. Todas as construções padrão e saída antecipada de nível profundo são suportadas, portanto, o uso dos comandos " ir para " também com suporte 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 estão pacotes, procedimentos e funções.

Exemplo: especificação do 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 compilado, por exemplo, usando o compilador de código aberto GNAT disponível gratuitamente , executando

gnatmake -z example.adb

Pacotes, procedimentos e funções podem ser aninhados em qualquer profundidade e cada um também pode ser o bloco lógico mais externo.

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 de idioma para simultaneidade baseada em tarefas. A unidade simultânea fundamental em Ada é uma tarefa , que é um tipo limitado integrado. As tarefas são especificadas em duas partes - a declaração da tarefa define a interface da tarefa (semelhante a uma declaração de tipo), o corpo da tarefa especifica a implementação da tarefa. Dependendo da implementação, as tarefas Ada são mapeadas para threads ou processos do sistema operacional ou são programadas internamente pelo tempo de execução Ada.

As tarefas podem ter entradas para sincronização (uma forma de transmissão síncrona de mensagens ). As entradas de tarefas são declaradas na especificação da tarefa. Cada entrada de tarefa pode ter uma ou mais instruções de aceitação dentro do corpo da tarefa. Se o fluxo de controle da tarefa atingir uma instrução de aceitação, a tarefa será bloqueada até que a entrada correspondente seja chamada por outra tarefa (da mesma forma, uma tarefa de chamada é bloqueada até que a tarefa chamada alcance a instrução de aceitação correspondente). As entradas de tarefas podem ter parâmetros semelhantes aos procedimentos, permitindo que as tarefas troquem dados de maneira síncrona. Em conjunto com as declarações select , é possível definir guardas nas declarações de aceitação (semelhantes aos comandos protegidos de Dijkstra ).

Ada também oferece objetos protegidos para exclusão mútua . Os objetos protegidos são uma construção semelhante a um monitor , mas usam guardas em vez de variáveis ​​condicionais para sinalização (semelhante a regiões críticas condicionais). Os objetos protegidos combinam o encapsulamento de dados e a exclusão mútua segura 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árias para a sinalização, evitando conflitos potenciais devido à semântica de bloqueio incorreta. Como as tarefas, o objeto protegido é um tipo limitado integrado e também possui uma parte de declaração e um corpo.

Um objeto protegido consiste em dados privados encapsulados (que só podem ser acessados ​​de dentro do objeto protegido) e procedimentos, funções e entradas que são garantidamente mutuamente exclusivas (com a única exceção de funções, que devem ser livres de efeitos colaterais e pode, portanto, ser executado simultaneamente com outras funções). Uma tarefa que chama um objeto protegido é bloqueada se outra tarefa estiver em execução dentro do mesmo objeto protegido e liberada quando essa outra tarefa deixa o objeto protegido. As tarefas bloqueadas são enfileiradas no objeto protegido, ordenadas por hora de chegada.

As entradas de objetos protegidos são semelhantes aos procedimentos, mas, além disso, possuem guardas . Se um guarda for avaliado como falso, uma tarefa de chamada será bloqueada e adicionada à fila dessa entrada; agora outra tarefa pode ser admitida para o objeto protegido, visto que nenhuma tarefa está sendo executada atualmente dentro do objeto protegido. Os guardas são reavaliados sempre que uma tarefa deixa o objeto protegido, pois este é o único momento em que a avaliação dos guardas pode ter mudado.

As chamadas para entradas podem ser enfileiradas para outras entradas com a mesma assinatura. Uma tarefa recolocada na fila é bloqueada e adicionada à fila da entrada de destino; isso significa que o objeto protegido é liberado e permite a admissão de outra tarefa.

A instrução select em Ada pode ser usada para implementar chamadas e aceitações de entrada sem bloqueio, seleção não determinística de entradas (também com guardas), tempos limite e abortos.

O exemplo a seguir ilustra alguns conceitos de programação simultânea 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 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

Um pragma é uma diretiva do compilador que transmite informações ao compilador para permitir a manipulação específica da saída compilada. Certos pragmas são integrados à linguagem, enquanto outros são específicos de implementação.

Exemplos de uso comum de pragmas do compilador seriam desabilitar certos recursos, como verificação de tipo em tempo de execução ou verificação de limite de subscrito de matriz, ou instruir o compilador a inserir código de objeto em vez de uma chamada de função (como C / C ++ faz com funções inline )

Genéricos

Ada tem genéricos desde que foi projetado pela primeira vez em 1977-1980. A biblioteca padrão usa genéricos para fornecer muitos serviços. O Ada 2005 adiciona uma biblioteca de contêineres genérica abrangente à biblioteca padrão, que foi inspirada na biblioteca de modelos padrão do C ++ .

Uma unidade genérica é um pacote ou subprograma que assume um ou mais parâmetros formais genéricos .

Um parâmetro formal genérico é um valor, uma variável, uma constante, um tipo, um subprograma ou mesmo uma instância de outra unidade genérica designada. Para tipos formais genéricos, a sintaxe distingue entre tipos discretos, de ponto flutuante, de ponto fixo, de acesso (ponteiro), etc. Alguns parâmetros formais podem ter valores padrão.

Para instanciar uma unidade genérica, o programador passa parâmetros reais para cada formal. A instância genérica então se comporta como qualquer outra unidade. É possível instanciar unidades genéricas em tempo de execução , por exemplo, dentro de um loop.

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 de tarefas Ada projetados para computação em tempo real crítica de segurança
  • SPARK (linguagem de programação) - uma linguagem de programação que consiste em um subconjunto altamente restrito de Ada, anotado com meta informações que descrevem o comportamento do componente desejado e requisitos individuais de tempo de execução

Referências

Padrões internacionais

Justificativa

Esses documentos foram publicados em várias formas, incluindo impressos.

Livros

  • Booch, Grady (1987). Engenharia de software com Ada . Califórnia: The Benjamin / Cummings Publishing Company. ISBN 0-8053-0604-8.
  • Skansholm, Jan (1996). Ada 95 desde o início . Addison-Wesley. ISBN 0-201-40376-5.
  • Gilpin, Geoff (1985). Ada: um tour guiado e tutorial . Prentice hall. ISBN 978-0-13-004045-9.
  • Barnes, John (2006). Programação em Ada 2005 . Addison-Wesley. ISBN 0-321-34078-7.
  • Barnes, John (1991). Programação no Manual de Referência da Linguagem Ada plus . Addison-Wesley. ISBN 0-201-56539-0.
  • Barnes, John (1998). Programação em Ada 95 . Addison-Wesley. ISBN 0-201-34293-6.
  • Barnes, John (1997). Ada de alta integridade: a abordagem SPARK . Addison-Wesley. ISBN 0-201-17517-7.
  • Barnes, John (2003). Software de alta integridade: a abordagem SPARK para proteção e segurança . Addison-Wesley. ISBN 0-321-13616-0.
  • Beidler, John (1997). Estruturas de dados e algoritmos: uma abordagem orientada a objetos usando Ada 95 . Springer-Verlag. ISBN 0-387-94834-1.
  • Gonzalez, Dean W. (1991). Manual do programador Ada . Benjamin-Cummings Publishing Company. ISBN 0-8053-2529-8.
  • Ben-Ari, M. (1998). Ada para engenheiros de software . John Wiley & Sons. ISBN 0-471-97912-0.
  • Cohen, Norman (1996). Ada como segunda língua . McGraw-Hill Ciência / Engenharia / Matemática. ISBN 0-07-011607-5.
  • Burns, Alan ; Wellings, Andy (2001). Sistemas em tempo real e linguagens de programação. Ada 95, Real-Time Java e Real-Time POSIX . Addison-Wesley. ISBN 0-201-72988-1.
  • Burns, Alan ; Wellings, Andy (1995). Simultaneidade em Ada . Cambridge University Press. ISBN 0-521-62911-X.
  • Atkinson, Colin (1991). Reutilização, simultaneidade e distribuição orientada a objetos: uma abordagem baseada em Ada . Addison-Wesley. ISBN 0-201-56527-7.
  • Booch, Grady ; Bryan, Doug (1994). Engenharia de software com Ada . Addison-Wesley. ISBN 0-8053-0608-0.
  • Jones, Do-While (1989). Ada em ação: com exemplos práticos de programação . John Wiley & Sons. ISBN 0-471-60708-8.
  • Stubbs, Daniel; Webre, Neil W. (1993). Estruturas de dados com tipos abstratos de dados e Ada . Brooks Cole. ISBN 0-534-14448-9.
  • Ledru, Pascal (dezembro de 1998). Programação Distribuída em Ada com Objetos Protegidos . Dissertation.com. ISBN 1-58112-034-6.
  • Culwin, Fintan (1997). Ada, uma abordagem de desenvolvimento . Prentice Hall. ISBN 0-13-264680-3.
  • Inglês, John; Culwin, Fintan (janeiro de 1997). Ada 95 o Ofício da Programação Orientada a Objetos . Prentice Hall. ISBN 0-13-230350-7.
  • Musser, David R .; Stepanov, Alexander (24 de outubro de 1989). A Biblioteca Genérica Ada: Pacotes de Processamento de Lista Linear . Springer-Verlag. ISBN 0-387-97133-5.
  • Feldman, Michael B. (1997). Construção de software e estruturas de dados com Ada 95 . Addison-Wesley. ISBN 0-201-88795-9.
  • Johnston, Simon (1997). Ada 95 para programadores C e C ++ . Addison-Wesley. ISBN 0-201-40363-3.
  • Feldman, Michael B .; Koffman, Elliot B. (1992-1993). Ada: Resolução de problemas e desenho de programas . Addison-Wesley. ISBN 0-201-52279-9. 795 páginas.
  • Feldman, Michael B .; Koffman, Elliot B. (1999). Ada 95 . Addison-Wesley. ISBN 0-201-36123-X.
  • Dale, Nell B .; Weems, Chip; McCormick, John (agosto de 1996). Programação e solução de problemas com Ada 95 . Jones & Bartlett Publishers. ISBN 0-7637-0293-5.
  • Dale, Nell B .; McCormick, John (2007). Ada Plus Data Structures: An Object-Oriented Approach, 2nd edition . Jones & Bartlett Publishers. ISBN 978-0-7637-3794-8.
  • Krell, Bruce C. (1992). Desenvolvendo com Ada: Métodos de Ciclo de Vida . Bantam Dell Pub Group. ISBN 0-553-09102-6.
  • Bishop, Judy (10 de maio de 1990). Ada Distribuída: Desenvolvimentos e Experiências . Cambridge University Press. ISBN 0-521-39251-9.
  • Sanden, Bo (1994). Construção de sistemas de software com exemplos em Ada . Prentice Hall. ISBN 0-13-030834-X.
  • Hillam, Bruce (1994). Introdução aos tipos de dados abstratos usando Ada . Prentice Hall. ISBN 0-13-045949-6.
  • Rudd, David (1994). Introdução ao design e desenvolvimento de software com Ada . Brooks Cole. ISBN 0-314-02829-3.
  • Pyle, Ian C. (1991). Desenvolvendo sistemas de segurança: um guia usando Ada . Prentice Hall. ISBN 0-13-204298-3.
  • Baker, Louis (1989). Inteligência artificial com Ada . McGraw-Hill. ISBN 0-07-003350-1.
  • Burns, Alan ; Wellings, Andy (1995). HRT-HOOD: Um Método de Projeto Estruturado para Sistemas Hard Real-Time Ada . Holanda do Norte. ISBN 0-444-82164-3.
  • Savitch, Walter; Peterson, Charles (1992). Ada: Uma Introdução à Arte e Ciência da Programação . Benjamin-Cummings Publishing Company. ISBN 0-8053-7070-6.
  • Weiss, Mark Allen (1993). Estruturas de dados e análise de algoritmos em Ada . Benjamin-Cummings Publishing Company. ISBN 0-8053-9055-3.
  • Ledgard, Henry (1983). Ada: Uma introdução (segunda edição). Springer-Verlag. ISBN 0-387-90814-5.
  • Bjørner, Dines; Oest, Ole N., eds. (1980). Rumo a uma descrição formal de Ada . Londres: Springer-Verlag. ISBN 3-540-10283-3.

Arquivos

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

links externos