Ada (linguagem de programação)

Ada é uma linguagem de programação de alto nível estruturada, tipada estaticamente, imperativa e orientada a objetos, estendida de Pascal e outras linguagens. Ele tem suporte de linguagem embutido para design by contract (DbC), digitação extremamente forte, simultaneidade explícita, tarefas, passagem de mensagem síncrona, objetos protegidos e não determinismo. A 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 é um padrão técnico internacional, definido em conjunto pela Organização Internacional de Padronização (ISO) e pela Comissão Eletrotécnica Internacional (IEC). A partir de 2020, o padrão, chamado informalmente de Ada 2012, é ISO/IEC 8652:2012.

Ada foi originalmente projetada por uma equipe liderada pelo cientista da computação francês Jean Ichbiah da 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 na época. Ada recebeu o nome de Ada Lovelace (1815–1852), que foi considerada a primeira programadora de computador.

Recursos

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

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

A sintaxe de Ada minimiza as escolhas de maneiras de executar operações básicas e prefere palavras-chave em inglês (como "ou então" e "e então") a símbolos (como &# 34;||" 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", "iniciar" 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 pode emparelhar com a expressão if aninhada errada 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 torna possível detectar problemas no início da fase de projeto, antes do início da implementação.

Um grande número de verificações em tempo de compilação é suportado para ajudar a evitar bugs que não seriam detectados 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 o fechamento de blocos nomeados explicitamente para evitar erros devido a tokens finais incompatíveis. A adesão à digitação forte permite detectar muitos erros de software comuns (parâmetros errados, violações de intervalo, referências inválidas, tipos incompatíveis, etc.) durante o tempo de compilação ou 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 impasses. 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 proteção contra acesso a memória não alocada, erros de estouro de buffer, violações de intervalo, erros off-by-one, erros de acesso à matriz e outros bugs detectáveis. Essas verificações podem ser desativadas no interesse da eficiência do tempo de execução, mas geralmente podem ser compiladas com eficiência. Também inclui recursos para ajudar na 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. Exemplos de sistemas em que o Ada é usado incluem aviônicos, controle de tráfego aéreo, ferrovias, bancos, tecnologia militar e espacial.

O gerenciamento dinâmico de memória da Ada é de alto nível e seguro. 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 deve ocorrer por meio de tipos de acesso explicitamente declarados. Cada tipo de acesso tem um pool de armazenamento associado que lida com os detalhes de baixo nível do gerenciamento de memória; o programador pode usar o pool de armazenamento padrão ou definir novos (isso é particularmente relevante para Non-Uniform Memory Access). É até possível declarar vários tipos de acesso diferentes, todos designando o mesmo tipo, mas usando 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, garantindo 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 automática de lixo 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 suporta 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, já que a destruição de um pool de armazenamento também destrói todos os objetos do pool.

Um traço duplo ("--"), semelhante a um traço eme, denota 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. Desativar um bloco inteiro de código agora requer o prefixo de cada linha (ou coluna) individualmente com "--". Embora denotando claramente o código desativado com uma coluna de "--" descer a página, isso torna a desativação/reativação experimental de grandes blocos 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 único ; sem uma instrução para terminar não é permitido.

Ao contrário da maioria dos padrões ISO, a definição de linguagem Ada (conhecida como Ada Reference Manual ou ARM, ou às vezes o Language Reference Manual 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 que é usada por muitos programadores Ada para ajudá-los a escrever o código-fonte Ada é o GNAT Programming Studio e o GNAT, que faz parte da GNU Compiler Collection.

História

Na década de 1970, o Departamento de Defesa dos EUA (DoD) ficou preocupado com o número de diferentes linguagens de programação usadas para seus projetos de sistemas de computador embarcados, muitos dos quais eram obsoletos ou dependentes de hardware, e nenhum dos quais 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 o departamento e o Ministério da Defesa do Reino Unido.;s requisitos. Depois de muitas iterações, começando com uma proposta original do Straw man, a linguagem de programação final 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.

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.

Foram lançados pedidos de propostas para uma nova linguagem de programação e foram contratadas quatro empreiteiras para desenvolver as 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, liderada por Jay Spitzen). Em abril de 1978, após escrutínio público, as propostas Vermelha e Verde passaram para a fase seguinte. Em maio de 1979, a proposta Green, projetada 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 Ada preliminar 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 a Ada Ano de nascimento de Lovelace. Em 1981, C. A. R. Hoare aproveitou seu discurso do Prêmio Turing para criticar Ada por ser excessivamente complexo e, portanto, não confiável, mas posteriormente pareceu retratar-se 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 uso 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 lutaram para implementar a linguagem grande e complexa, e o desempenho do tempo de compilação e do tempo de execução tendia a ser lento e as ferramentas primitivas. Os fornecedores de compiladores despenderam a maior parte de seus esforços para aprovar o enorme pacote de validação Ada Compiler Validation Capability (ACVC) exigido pelo governo, que era exigido em outro novo recurso do esforço da linguagem Ada. O Jargon File, um dicionário de gírias de hackers de computador originário de 1975–1983, observa em uma entrada sobre Ada que "é exatamente o que se poderia esperar, dado esse tipo de endosso por decreto; projetado por um comitê... difícil de usar e, no geral, um desastre desastroso de vários bilhões de dólares... Ada Lovelace... quase certamente empalideceria com o uso que seu nome foi feito ultimamente; a coisa mais gentil que já foi dita sobre isso é que provavelmente há uma boa língua pequena gritando para sair de dentro de seu vasto volume elefantino."

A primeira implementação Ada validada foi o tradutor NYU Ada/Ed, certificado em 11 de abril de 1983. NYU Ada/Ed é 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, Irvine Compiler, TLD Systems e Verdix. Os fabricantes de computadores que tinham negócios significativos nos setores de defesa, aeroespacial ou relacionados também ofereciam compiladores e ferramentas Ada em suas plataformas; estes incluíram Concurrent Computer Corporation, Cray Research, Inc., Harris Computer Systems e Siemens Nixdorf Informationssysteme AG.

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 de Ada do Departamento de Defesa foi efetivamente removido em 1997, quando o DoD começou a adotar a tecnologia comercial pronta para uso (COTS). Requisitos semelhantes existiam em outros países da OTAN: Ada era necessário 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 dos anos 1980 e início dos anos 1990, os compiladores Ada melhoraram em desempenho, mas ainda havia barreiras para explorar totalmente as habilidades de Ada, incluindo um modelo de tarefas que era diferente do que a maioria dos programadores de tempo real estavam acostumados.

Devido aos recursos críticos de segurança 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, tornou-se 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). Apresentava processamento distribuído avançado, um banco de dados Ada distribuído e design orientado a objetos. O Ada também é usado em outros sistemas de tráfego aéreo, por exemplo, o sistema de controle de tráfego aéreo Interim Future Area Control Tools Support (iFACTS) da próxima geração do Reino Unido foi projetado e implementado usando o SPARK Ada. Também é usado no sistema francês de sinalização de cabine TVM no sistema ferroviário de alta velocidade TGV e nos trens metropolitanos suburbanos em Paris, Londres, Hong Kong e Nova York.

Padronização

A Ada Preliminar pode ser encontrada em ACM Sigplan Notices Vol 14, No 6, June 1979.

Ada foi publicado pela primeira vez em 1980 como um padrão ANSI ANSI/MIL-STD 1815. Como esta primeira versão continha muitos erros e inconsistências (consulte Resumo das alterações de linguagem Ada), a edição revisada foi publicada em 1983 como ANSI/MIL -STD 1815A. Sem mais alterações, tornou-se um padrão ISO em 1987, ISO 8652:1987. Esta versão da linguagem é comumente conhecida como Ada 83, a partir da data de sua adoção pela ANSI, mas às vezes também é chamada de Ada 87, a partir da data de sua adoção pela ISO. Este é o Manual de Referência Ada 83. Há também uma tradução francesa; DIN traduziu para o alemão como DIN 66268 em 1988.

Ada 95, o padrão conjunto ISO/IEC/ANSI ISO/IEC 8652:1995 (consulte Ada 95 RM) foi publicado em fevereiro de 1995, tornando-se a primeira linguagem de programação orientada a objetos 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 Compilador GNAT faz parte da Coleção de Compiladores GNU.

Continua 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, ISO/IEC 8652:1995/Corr 1:2001 (consulte Ada 95 RM com TC 1) e uma alteração importante, ISO/IEC 8652: 1995/Amd 1:2007 (consulte Ada 2005 RM) foi publicado em 9 de março de 2007, comumente conhecido como Ada 2005 porque o trabalho no novo padrão foi concluído naquele ano.

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 à ISO/IEC JTC 1/SC 22/WG 9 da Organização Internacional de Normalização (ISO) e da Comissão Eletrotécnica Internacional (IEC) para aprovação. A ISO/IEC 8652:2012 (consulte Ada 2012 RM) foi publicada em dezembro de 2012, conhecida como Ada 2012. Uma correção técnica foi publicada ISO/IEC 8652:2012/COR 1:2016 (ver RM 2012 com TC 1).

Apesar dos nomes Ada 83, 95 etc., legalmente existe apenas uma norma Ada, a da última norma ISO/IEC: com a aceitação de uma nova versão da norma, a anterior torna-se retirado. Os outros nomes são apenas informais referenciando uma determinada edição.

Outros padrões relacionados incluem ISO/IEC 8651-3:1988 Sistemas de processamento de informações—Gráficos de computador—Ligação de linguagem do Sistema de Kernel Gráfico (GKS)—Parte 3: Ada.

Construções de linguagem

Ada é uma linguagem de programação semelhante a ALGOL apresentando estruturas de controle com palavras reservadas como if, então, else, enquanto , para e assim por diante. No entanto, Ada também possui 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. Tais construções foram em parte herdadas ou inspiradas por Pascal.

"Olá, mundo!" em Ada

Um exemplo comum da sintaxe de uma linguagem é o programa Hello world: (olá.adb)

com Ada.;procedimento Olá. ocomeçar Ada..Textos.Put_Line ("Olá, mundo!");fim Olá.;

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

Olá.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. Esta 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 agregados (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. Tipos especiais fornecidos pela linguagem são tipos de tarefas e tipos protegidos.

Por exemplo, uma data pode ser representada como:

tipo Dia_tipo o gama 1 ... 31;tipo Mês-tipo o gama 1 ... 12;tipo Ano_tipo o gama 1800 ... 2100;tipo Horas o mod 24.;tipo Dia de semana o (Segunda-feira, Terça-feira, Quarta-feira, Quinta-feira, Sexta-feira, Sábado, Domingo);tipo Data o registro Dia : Dia_tipo; Mês : Mês-tipo; Ano : Ano_tipo; registro final;

Importante observar: Day_type, Month_type, Year_type, Hours são tipos incompatíveis, o que significa que, por exemplo, a seguinte expressão é ilegal:

Hoje: Dia_tipo ? 4;Corrente_Month: Mês-tipo ? 10.;... Hoje + Corrente_Month ... - ilegal.

O operador de adição predefinido só pode adicionar valores do mesmo tipo, portanto, a expressão é ilegal.

Os tipos podem ser refinados declarando subtipos:

subtipo Working_Hours o Horas gama 0 ... 12; -- no máximo 12 Horas para trabalhar um diasubtipo Trabalho_ Dia o Dia de semana gama Segunda-feira ... Sexta-feira; - Dias para trabalharTrabalho_Load: constante constante array(Trabalho_ Dia) de Working_Hours -- Declaração de tipo implícita ? (Sexta-feira - Sim. 6, Segunda-feira - Sim. 4, outros - Sim. 10.); -- mesa de pesquisa para horas de trabalho com inicialização

Os tipos podem ter modificadores como limited, abstract, private etc. Os tipos privados não mostram sua estrutura interna; objetos de tipos limitados não podem ser copiados. A Ada 95 adiciona mais recursos para extensão de tipos orientada a objetos.

Estruturas de controle

Ada é uma linguagem de programação estruturada, o que significa que o fluxo de controle é estruturado em declarações padrão. Todas as construções padrão e saída antecipada de nível profundo são suportadas, portanto, o uso do "ir para" comandos raramente são necessários.

- enquanto um não é igual a b, loop.enquanto um - Sim. b) loop Ada..Textos.Put_Line ("Waiting");fim loop;se um > b) então Ada..Textos.Put_Line ("Condição");mais Ada..Textos.Put_Line ("Condição não encontrada");fim se;para Eu... em 1 ... 10. loop Ada..Textos.Puta ("Iteração: "); Ada..Textos.Puta (Eu...); Ada..Textos.Put_Line;fim loop;loop um ? um + 1; saída quando um = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 10.;fim loop;Processo Eu... o quando 0 - Sim. Ada..Textos.Puta ("zero"); quando 1 - Sim. Ada..Textos.Puta ("um"); quando 2 - Sim. Ada..Textos.Puta ("dois"); -- as declarações de caso têm de cobrir todos os casos possíveis: quando outros - Sim. Ada..Textos.Puta ("nenhum dos acima");fim Processo;para Um dia em Dia de semana'Gama loop -- loop sobre uma enumeração Put_Line ( Dia de semana'Imagem(Um dia) ); -- representação de cadeia de saída de uma enumeração se Um dia em Trabalho_ Dia então -- verificação de um subtipo de uma enumeração Put_Line ( "para trabalhar para " > Working_Hours'Imagem (Trabalho_Load(Um dia) ); - acesso a uma mesa de pesquisa fim se;fim 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)

pacote Exemplo o tipo Número o gama 1 ... 11; procedimento Print_and_Increment (JJ: em fora Número);fim Exemplo;

Corpo do pacote (example.adb)

com Ada.;pacote corpo Exemplo o Eu... : Número ? Número'Primeiro.; procedimento Print_and_Increment (JJ: em fora Número) o função Próximo (k: em Número) retorno Número o começar retorno k + 1; fim Próximo; começar Ada..Textos.Put_Line ( "O total é: " > Número'Imagem(JJ) ); JJ ? Próximo (JJ); fim Print_and_Increment;-- inicialização do pacote executada quando o pacote é elaboradocomeçar enquanto Eu... < Número'Última loop Print_and_Increment (Eu...); fim loop;fim Exemplo;

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

gnatmake -z exemplo.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 linguagem para simultaneidade baseada em tarefas. A unidade concorrente fundamental em Ada é uma tarefa, que é um tipo limitado embutido. 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 agendadas internamente pelo tempo de execução Ada.

Tarefas podem ter entradas para sincronização (uma forma de passagem de mensagem síncrona). As entradas da tarefa são declaradas na especificação da tarefa. Cada entrada de tarefa pode ter uma ou mais instruções accept no 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 será bloqueada até que a tarefa chamada atinja 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 forma síncrona. Em conjunto com as instruções select, é possível definir guards nas instruções de aceitação (semelhante aos comandos guardados de Dijkstra).

Ada também oferece objetos protegidos para exclusão mútua. 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). Objetos protegidos combinam o encapsulamento de dados e 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 possíveis deadlocks devido à semântica de bloqueio incorreta. Assim como as tarefas, o objeto protegido é um tipo limitado interno 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 garantidos como mutuamente exclusivos (com a única exceção de funções, que devem ser livre de efeitos colaterais e, portanto, pode ser executado simultaneamente com outras funções). Uma tarefa que chama um objeto protegido é bloqueada se outra tarefa estiver sendo executada dentro do mesmo objeto protegido e liberada quando essa outra tarefa deixar o objeto protegido. Tarefas bloqueadas são enfileiradas no objeto protegido ordenadas por hora de chegada.

As entradas de objetos protegidos são semelhantes aos procedimentos, mas também 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 no objeto protegido, já que nenhuma tarefa está sendo executada 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.

Chamadas para entradas podem ser enfileiradas novamente para outras entradas com a mesma assinatura. Uma tarefa recolocada na fila é bloqueada e incluída na 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 de entrada sem bloqueio e aceita, seleção não determinística de entradas (também com guardas), limites de tempo e interrupções.

O exemplo a seguir ilustra alguns conceitos de programação concorrente em Ada.

com Ada.; uso Ada.;procedimento Tráfego o tipo Avião_ID o gama 1..10.; - 10 aviões tarefa tipo Avião (ID: Avião_ID); -- tarefa representando aviões, com ID como parâmetro de inicialização tipo Avião_Access o acesso Avião; -- Tipo de referência para Avião protegido tipo Correr o -- a pista compartilhada (protegida para permitir acesso simultâneo) entrada Assign_Aircraft (ID: Avião_ID); -- todas as entradas são garantidas mutuamente exclusivas entrada Limpar_Runway (ID: Avião_ID); entrada Aguarde.; privado Livre: Boole. ? É verdade.; -- dados privados protegidos - geralmente mais do que apenas uma bandeira... fim Correr; tipo Runway_Access o acesso Todos Correr; -- a tarefa do controlador de tráfego aéreo leva pedidos de descolagem e desembarque tarefa tipo Controlador (O meu caminho: Runway_Access) o -- entradas de tarefa para passar mensagem síncrona entrada Pedido_Takeoff (ID: em Avião_ID; Descolagem: fora Runway_Access); entrada Solicitação_Abordagem(ID: em Avião_ID; Abordagem: fora Runway_Access); fim Controlador; -- alocação de instâncias Runway1 : Aliasado Correr; - Instante uma pista Controlador1: Controlador (Runway1'Acesso); -- e um controlador para gerenciá-lo ------- as implementações dos tipos acima -------- protegido corpo Correr o entrada Assign_Aircraft (ID: Avião_ID) quando Livre o -- o guarda de entrada - tarefas de chamada são bloqueadas até que a condição é verdadeira começar Livre ? Falso; Put_Line (Avião_ID'Imagem (ID) > "na pista"); fim; entrada Limpar_Runway (ID: Avião_ID) quando não Livre o começar Livre ? É verdade.; Put_Line (Avião_ID'Imagem (ID) > "estrada limpa"); fim; entrada Aguarde. quando Livre o começar Null; -- não há necessidade de fazer nada aqui - uma tarefa só pode entrar se "Clear" é verdade fim; fim Correr; tarefa corpo Controlador o começar loop O meu caminho.Aguarde.; -- espere até que a pista esteja disponível (chamada de bloqueio) selecionar -- esperar por dois tipos de pedidos (qualquer que seja executável primeiro) quando Solicitação_Abordagem'contagem = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 0 - Sim. -- declaração de guarda - só aceita se não houver tarefas queuing no Request_ Abordagem aceitar Pedido_Takeoff (ID: em Avião_ID; Descolagem: fora Runway_Access) do -- início da parte sincronizada O meu caminho.Assign_Aircraft (ID); -- reserva pista (potencialmente bloqueio chamada se objeto protegido ocupado ou guarda de entrada falso) Descolagem ? O meu caminho; -- atribuir o valor do parâmetro "out" para dizer ao avião que pista fim Pedido_Takeoff; -- fim da parte sincronizada ou aceitar Solicitação_Abordagem (ID: em Avião_ID; Abordagem: fora Runway_Access) do O meu caminho.Assign_Aircraft (ID); Abordagem ? O meu caminho; fim Solicitação_Abordagem; ou -- rescindir se não houver tarefas que possam chamar rescindida; fim selecionar; fim loop; fim; tarefa corpo Avião o Rwy! : Runway_Access; começar Controlador1.Pedido_Takeoff (ID, Rwy!); -... Esta chamada bloqueia até que a tarefa Controller aceite e complete o bloco de aceitação Put_Line (Avião_ID'Imagem (ID) > "desaparecer..."); atraso 2.0; Rwy!.Limpar_Runway (ID); -- chamada não irá bloquear como "Clear" em Rwy é agora falso e nenhuma outra tarefa deve ser dentro de objeto protegido atraso 5.; - voar um pouco... loop selecionar -- tente solicitar uma pista Controlador1.Solicitação_Abordagem (ID, Rwy!); -- esta é uma chamada de bloqueio - será executado no controlador atingindo bloco de aceitação e retorno na conclusão saída; - Se a chamada devolvêssemos, vamos para aterrar. ou atraso 3.0.; -- timeout - se nenhuma resposta em 3 segundos, faça outra coisa (tudo no seguinte bloco) Put_Line (Avião_ID'Imagem (ID) > " no padrão de retenção"); -- basta imprimir uma mensagem fim selecionar; fim loop; atraso 4.0; - Abordagem de aterragem... Put_Line (Avião_ID'Imagem (ID) > Tocou no chão!); Rwy!.Limpar_Runway (ID); - notificar a pista que terminamos aqui. fim; New_Airplane: Avião_Access;começar para Eu... em Avião_ID'Gama loop -- criar algumas tarefas do avião New_Airplane ? novo novo Avião (Eu...); -- começará a correr diretamente após a criação atraso 4.0; fim loop;fim Tráfego;

Pragmas

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

Exemplos de uso comum de pragmas de compilador seriam desabilitar certos recursos, como verificação de tipo de 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 embutidas).

Genéricos