ALGOL 68

ALGOL 68
Relatório revisado sobre a linguagem algorítmica – Algol 68 Editado por: A. van Wijngaarden et al, setembro de 1973 [1]
ParadigmasMultiparadigma : concorrente , imperativo
FamíliaALGOL
Projetado porA. van Wijngaarden , BJ Mailloux , JEL Peck e CHA Koster , et al.
Apareceu pela primeira vezRelatório Final: 1968 ; 56 anos atrás r0 ( 1968 )
Versão estável
Algol 68/RR/Relatório Revisado: 1973 ; 51 anos atrás r1 ( 1973 )
Disciplina de digitaçãoestático , forte , seguro , estrutural
EscopoLexical
Principais implementações
ALGOL 68C , Algol 68 Genie (recente), ALGOL 68-R , ALGOL 68RS , ALGOL 68S , FLACC , Алгол 68 Unidade Leningrado/Leningrado, Odra ALGOL 68
Dialetos
ALGOL 68/FR (Relatório Final r0 )
Influenciado por
ALGOL 60 , ALGOL Y
Influenciado
C , [3] [5] C++ , [6] Bourne shell , KornShell , Bash , Steelman , Ada , Python , [7] Seed7 , Mary , S3

ALGOL 68 (abreviação de Algorithmic Language 1968 ) é uma linguagem de programação imperativa que foi concebida como sucessora da linguagem de programação ALGOL 60 , projetada com o objetivo de um escopo de aplicação muito mais amplo e sintaxe e semântica definidas com mais rigor.

A complexidade da definição da linguagem, que abrange várias centenas de páginas repletas de terminologia não padronizada, dificultou a implementação do compilador e foi dito que ele "não tinha implementações nem usuários". Isto era apenas parcialmente verdade; O ALGOL 68 encontrou uso em vários nichos de mercado, principalmente no Reino Unido , onde era popular em máquinas da International Computers Limited (ICL) e em funções de ensino. Fora desses campos, o uso era relativamente limitado.

No entanto, as contribuições do ALGOL 68 para o campo da ciência da computação têm sido profundas, abrangentes e duradouras, embora muitas dessas contribuições só tenham sido identificadas publicamente quando reapareceram em linguagens de programação desenvolvidas posteriormente. Muitas linguagens foram desenvolvidas especificamente como resposta à complexidade percebida da linguagem, sendo a mais notável Pascal , ou foram reimplementações para funções específicas, como Ada .

Muitas linguagens da década de 1970 traçam seu design especificamente no ALGOL 68, selecionando alguns recursos e abandonando outros que eram considerados muito complexos ou fora do escopo para determinadas funções. Entre estas está a linguagem C , que sofreu influência direta do ALGOL 68, especialmente por sua forte tipagem e estruturas. A maioria das linguagens modernas rastreia pelo menos parte de sua sintaxe para C ou Pascal e, portanto, direta ou indiretamente para ALGOL 68.

Visão geral

Os recursos do ALGOL 68 incluem sintaxe baseada em expressão, tipos e estruturas / uniões marcadas declaradas pelo usuário, um modelo de referência de variáveis ​​​​e parâmetros de referência, string, array e fatiamento de matriz e simultaneidade.

ALGOL 68 foi projetado pelo Grupo de Trabalho 2.1 da Federação Internacional para Processamento de Informações (IFIP) IFIP sobre Linguagens Algorítmicas e Cálculos. Em 20 de dezembro de 1968, a linguagem foi formalmente adotada pelo grupo, e depois aprovada para publicação pela Assembleia Geral do IFIP.

ALGOL 68 foi definido usando um formalismo , uma gramática formal de dois níveis , inventada por Adriaan van Wijngaarden . As gramáticas de Van Wijngaarden usam uma gramática livre de contexto para gerar um conjunto infinito de produções que reconhecerão um programa ALGOL 68 específico; notavelmente, eles são capazes de expressar o tipo de requisitos que em muitos outros padrões técnicos de linguagem de programação são rotulados como semântica e devem ser expressos em prosa de linguagem natural propensa a ambiguidades e então implementados em compiladores como código ad hoc anexado ao analisador de linguagem formal .

ALGOL 68 foi a primeira (e possivelmente uma das últimas) linguagens principais para a qual uma definição formal completa foi feita antes de ser implementada.

ACHA Koster [8]

Os principais objetivos e princípios de design do ALGOL 68:

  1. Completude e clareza da descrição [9]
  2. Ortogonalidade do design [10]
  3. Segurança [11]
  4. Eficiência: [12]

ALGOL 68 foi criticado, principalmente por alguns membros de seu comitê de design, como CAR Hoare e Edsger Dijkstra , por abandonar a simplicidade do ALGOL 60 , tornando-se um veículo para ideias complexas ou excessivamente gerais, e fazendo pouco para tornar a tarefa do escritor do compilador mais fácil, em contraste com contemporâneos (e concorrentes) deliberadamente simples, como C , S-algol e Pascal .

Em 1970, ALGOL 68-R tornou-se o primeiro compilador funcional para ALGOL 68.

Na revisão de 1973, certos recursos — como procedimentos , gomas [13] e limites formais — foram omitidos. [14] Cf A linguagem do relatório não revisado.r0

Embora as agências de defesa europeias (na Grã-Bretanha Royal Signals and Radar establishment (RSRE)) tenham promovido o uso do ALGOL 68 pelas suas esperadas vantagens de segurança, o lado americano da aliança da NATO decidiu desenvolver um projecto diferente, a linguagem Ada , tornando a sua utilização obrigatória. para contratos de defesa dos EUA.

ALGOL 68 também teve uma influência notável na União Soviética , cujos detalhes podem ser encontrados no artigo de Andrey Terekhov de 2014: "ALGOL 68 e seu impacto na URSS e na programação russa", [15] e "Алгол 68 и его влияние na programação em СССР e России". [16]

Steve Bourne , que estava no comitê de revisão do ALGOL 68, levou algumas de suas ideias para seu shell Bourne (e, portanto, para shells descendentes do Unix , como Bash ) e para C (e, portanto, para descendentes, como C++ ).

A história completa do projeto pode ser encontrada em A History of ALGOL 68, de CH Lindsey . [17] [18]

Para um tratamento completo da linguagem, consulte "Programming ALGOL 68 Made Easy" [19] do Dr. Sian Mountbatten, ou "Learning ALGOL 68 Genie" [20] de Marcel van der Veer que inclui o Relatório Revisado.

História

Origens

ALGOL 68, como o nome indica, é uma continuação da linguagem ALGOL que foi formalizada pela primeira vez em 1960. Nesse mesmo ano, a Federação Internacional para Processamento de Informação (IFIP) formou e iniciou o Grupo de Trabalho sobre ALGOL, ou WG2.1. Este grupo lançou uma especificação ALGOL 60 atualizada em Roma em abril de 1962. Em uma reunião de acompanhamento em março de 1964, foi acordado que o grupo deveria começar a trabalhar em dois padrões subsequentes, ALGOL X , que seria uma redefinição da linguagem com alguns acréscimos, e um ALGOL Y , que teria a capacidade de modificar seus próprios programas no estilo da linguagem LISP . [21]

Processo de definição

A primeira reunião do grupo ALGOL X foi realizada na Universidade de Princeton em maio de 1965. Um relatório da reunião observou dois temas amplamente apoiados, a introdução de tipagem forte e o interesse nos conceitos de Euler de 'árvores' ou 'listas' para lidar com coleções. [22]

Na segunda reunião em outubro na França, três propostas formais foram apresentadas, o ALGOL W de Niklaus Wirth , juntamente com comentários sobre estruturas de registros de CAR (Tony) Hoare , uma linguagem semelhante de Gerhard Seegmüller e um artigo de Adriaan van Wijngaarden sobre " Desenho ortogonal e descrição de uma linguagem formal”. Este último, escrito em "W-Grammar" quase indecifrável, revelou-se uma mudança decisiva na evolução da língua. A reunião foi encerrada com um acordo de que van Wijngaarden reescreveria a apresentação de Wirth/Hoare usando sua W-Grammar. [22]

Esta tarefa aparentemente simples acabou por revelar-se mais difícil do que o esperado, e a reunião de acompanhamento teve de ser adiada seis meses. Quando se reuniu em abril de 1966 em Kootwijk , o rascunho de van Wijngaarden permaneceu incompleto e Wirth e Hoare apresentaram uma versão usando descrições mais tradicionais. Foi geralmente acordado que o seu artigo era "a linguagem certa no formalismo errado". [23] À medida que estas abordagens foram exploradas, tornou-se claro que havia uma diferença na forma como os parâmetros eram descritos que teriam efeitos no mundo real, e embora Wirth e Hoare protestassem que mais atrasos poderiam tornar-se intermináveis, o comité decidiu esperar por van Versão de Wijngaarden. Wirth então implementou sua definição atual como ALGOL W. [24]

Na reunião seguinte em Varsóvia , em outubro de 1966, [25] houve um relatório inicial do Subcomitê I/O que se reuniu no Laboratório Nacional de Oak Ridge e na Universidade de Illinois , mas ainda não havia feito muito progresso. As duas propostas da reunião anterior foram novamente exploradas, e desta vez surgiu um novo debate sobre o uso de ponteiros ; ALGOL W os usou apenas para se referir a registros, enquanto a versão de van Wijngaarden poderia apontar para qualquer objeto. Para aumentar a confusão, John McCarthy apresentou uma nova proposta para sobrecarga de operadores e a capacidade de encadear e/ ou construir, e Klaus Samelson queria permitir funções anônimas . Na confusão resultante, houve alguma discussão sobre o abandono de todo o esforço. [24] A confusão continuou durante o que deveria ser a reunião do ALGOL Y em Zandvoort em maio de 1967. [22]

Publicação

Um rascunho do relatório foi finalmente publicado em fevereiro de 1968. Isso foi recebido com "choque, horror e dissidência", [22] principalmente devido às centenas de páginas de gramática ilegível e terminologia estranha. Charles H. Lindsey tentou descobrir que "linguagem estava escondida dentro dela", [26] um processo que exigiu seis semanas de esforço. O artigo resultante, "ALGOL 68 com menos lágrimas", foi amplamente divulgado. Numa reunião mais ampla de processamento de informações em Zurique , em maio de 1968, os participantes reclamaram que a linguagem estava sendo imposta a eles e que o IFIP era "o verdadeiro vilão desta situação irracional", já que as reuniões eram em sua maioria fechadas e não havia nenhum mecanismo formal de feedback. Wirth e Peter Naur renunciaram formalmente aos seus cargos de autoria no WG2.1 naquela época. [26]

A próxima reunião do WG2.1 ocorreu em Tirrenia em junho de 1968. Era para discutir o lançamento de compiladores e outras questões, mas em vez disso evoluiu para uma discussão sobre a linguagem. van Wijngaarden respondeu dizendo (ou ameaçando) que divulgaria apenas mais uma versão do relatório. A essa altura, Naur, Hoare e Wirth haviam abandonado o esforço, e vários outros ameaçavam fazê-lo. [27] Seguiram-se várias outras reuniões, North Berwick em agosto de 1968, Munique em dezembro, que produziram a divulgação do Relatório oficial em janeiro de 1969, mas também resultaram na redação de um controverso Relatório Minoritário. Finalmente, em Banff, Alberta, em setembro de 1969, o projeto foi geralmente considerado completo e a discussão centrou-se principalmente em erratas e em uma Introdução ao Relatório bastante ampliada. [28]

O esforço durou cinco anos, queimou muitos dos maiores nomes da ciência da computação e, em diversas ocasiões, chegou a um impasse em questões tanto na definição quanto no grupo como um todo. Hoare lançou uma "Crítica do ALGOL 68" quase imediatamente, [29] que foi amplamente referenciada em muitos trabalhos. Wirth desenvolveu ainda mais o conceito ALGOL W e o lançou como Pascal em 1970.

Implementações

ALGOL 68-R

A primeira implementação do padrão, baseada no rascunho do relatório do final de 1968, foi introduzida pelo Royal Radar establishment no Reino Unido como ALGOL 68-R em julho de 1970. Este era, no entanto, um subconjunto da linguagem completa, e Barry Mailloux , o editor final do Relatório, brincou dizendo: "É uma questão de moralidade. Temos uma Bíblia e você está pecando!" [30] No entanto, esta versão tornou-se muito popular nas máquinas ICL e tornou-se uma linguagem amplamente utilizada na codificação militar, especialmente no Reino Unido. [31]

Entre as mudanças no 68-R estava a exigência de que todas as variáveis ​​fossem declaradas antes de seu primeiro uso. Isso tinha a vantagem significativa de permitir que o compilador fosse de passagem única, pois o espaço para as variáveis ​​no registro de ativação era reservado antes de ser usado. No entanto, esta mudança também teve o efeito colateral de exigir que os PROC fossem declarados duas vezes, uma vez como uma declaração dos tipos e depois novamente como o corpo do código. Outra mudança foi eliminar o modo VOID assumido , uma expressão que não retorna nenhum valor (chamada de instrução em outras línguas) e exigindo que a palavra VOID fosse adicionada onde teria sido assumida. Além disso, o 68-R eliminou os comandos explícitos de processamento paralelo baseados em PAR . [30]

Outros

A primeira implementação completa da linguagem foi introduzida em 1974 pelo CDC Holanda para a série de mainframes Control Data . Isto teve uso limitado, principalmente no ensino na Alemanha e na Holanda. [31]

Uma versão semelhante ao 68-R foi introduzida pela Carnegie Mellon University em 1976 como 68S, e foi novamente um compilador de passagem única baseado em várias simplificações do original e destinado ao uso em máquinas menores como o DEC PDP-11 . Também foi usado principalmente para fins de ensino. [31]

Uma versão para mainframes IBM não foi disponibilizada até 1978, quando uma foi lançada pela Universidade de Cambridge . Isso estava "quase completo". Lindsey lançou uma versão para máquinas pequenas, incluindo o IBM PC em 1984. [31]

Três implementações de código aberto do Algol 68 são conhecidas: [32]

Linha do tempo

Ano Evento Contribuinte
Março de 1959 Boletim ALGOL Edição 1 (Primeira) Peter Naur / ACM
Fevereiro de 1968 Relatório preliminar (DR) publicado [34] Grupo de Trabalho IFIP 2.1
Março de 1968 Relatório final do Algol 68 r0 apresentado na reunião de Munique Grupo de Trabalho IFIP 2.1
Junho de 1968 Reunião em Tirrenia, Itália Grupo de Trabalho IFIP 2.1
Agosto de 1968 Reunião em North Berwick, Escócia Grupo de Trabalho IFIP 2.1
Dezembro de 1968 Relatório final do ALGOL 68 r0 apresentado na reunião de Munique Grupo de Trabalho IFIP 2.1
Abril de 1970 ALGOL 68-R (R) sob GEORGE 3 em um ICL 1907F Royal Signals e Radar Est.
Julho de 1970 ALGOL 68 para o sistema de compartilhamento de tempo Dartmouth [35] [36] Sidney Marshall
Setembro de 1973 Relatório revisado do Algol 68 [37] r1 publicado Grupo de Trabalho IFIP 2.1
1975 ALGOL 68C (C) – compilador transportável (zcode VM ) S. Bourne , Andrew Birrell e Michael Guy
Junho de 1975 GE Hedrick e Alan Robertson. O compilador de subconjunto ALGOL 68 do estado de Oklahoma. Conferência Internacional de 1975 sobre ALGOL 68.
Junho de 1977 Conferência Strathclyde ALGOL 68, Escócia ACM
Maio de 1978 Propostas para ALGOL H – Uma Superlinguagem do ALGOL 68 [38] AP Black, VJ Rayward-Smith
1984 Compilador ALGOL 68S (S) completo para Sun, SPARC e PCs CH Lindsey et al, Manchester
Agosto de 1988 Boletim ALGOL Edição 52 (última) Ed. CH Lindsey/ACM
Maio de 1997 Algol68 S (S) publicado na internet [39] Charles H. Lindsey
Novembro de 2001 Algol 68 Genie (G) publicado na internet [40] (licenciamento de código aberto GNU GPL) Marcel van der Veer
  • "Uma história mais curta do Algol 68"
  • ALGOL 68 – ALGOL de 3ª geração

A linguagem algorítmica ALGOL 68 Relatórios e membros do grupo de trabalho

"Van Wijngaarden certa vez caracterizou os quatro autores, um tanto irônicos, como: Koster: transputador, Peck: sintaxedor, Mailloux: implementador, Van Wijngaarden: ideólogo do partido." – Koster.

  • Outubro de 1968: Penúltimo relatório preliminar sobre a linguagem algorítmica ALGOL 68 — Capítulos 1-9 [42] Capítulos 10-12 [43] — Editado por: A. van Wijngaarden, BJ Mailloux, JEL Peck e CHA Koster.
  • Dezembro de 1968: Relatório sobre a Linguagem Algorítmica ALGOL 68 — Separata de Numerische Mathematik, 14, 79-218 (1969); Springer-Verlag. [44] — Editado por: A. van Wijngaarden, BJ Mailloux, JEL Peck e CHA Koster.
  • Março de 1970: Relatório da minoria, Boletim ALGOL AB31.1.1 — assinado por Edsger Dijkstra , Fraser Duncan, Jan Garwick, Tony Hoare , Brian Randell , Gerhard Seegmüller, Wlad Turski e Mike Woodger .
  • Setembro de 1973: Relatório revisado sobre a linguagem algorítmica Algol 68 — Springer-Verlag 1976 [45] — Editado por: A. van Wijngaarden, B. Mailloux, J. Peck, K. Koster, Michel Sintzoff , Charles H. Lindsey , Lambert Meertens e Richard G. Fisker.
  • outros membros do WG 2.1 ativos no projeto do ALGOL 68: [18] Friedrich L. Bauer • Hans Bekic • Gerhard Goos • Peter Zilahy Ingerman • Peter LandinJohn McCarthy • Jack Merner • Peter Naur • Manfred Paul • Willem van der PoelDoug RossKlaus SamelsonNiklaus WirthNobuo Yoneda .

Cronograma de padronização

1968: Em 20 de dezembro de 1968, o "Relatório Final" (MR 101) foi adotado pelo Grupo de Trabalho, e posteriormente aprovado pela Assembleia Geral do IFIP da UNESCO para publicação. Foram feitas traduções da norma para russo , alemão , francês e búlgaro , e posteriormente para japonês e chinês . [46] O padrão também foi disponibilizado em Braille .

1984: TC 97 considerou ALGOL 68 para padronização como "Novo Item de Trabalho" TC97/N1642 [2][3]. Alemanha Ocidental, Bélgica, Holanda, URSS e Tchecoslováquia estavam dispostas a participar na preparação do padrão, mas a URSS e a Tchecoslováquia "não eram os tipos certos de membros dos comitês ISO certos"[4] e a padronização ISO do Algol 68 estagnou.[5]

1988: Posteriormente, o ALGOL 68 tornou-se um dos padrões GOST na Rússia.

  • GOST 27974-88 Linguagem de programação ALGOL 68 — Язык программирования АЛГОЛ 68 [47]
  • GOST 27975-88 Linguagem de programação ALGOL 68 estendida - Язык программирования АЛГОЛ 68 расширенный [48]

Elementos de linguagem notáveis

Símbolos em negrito e palavras reservadas

A linguagem padrão contém cerca de sessenta palavras reservadas, normalmente em negrito na impressão, e algumas com equivalentes de "símbolo breve":

MODE , OP , PRIO , PROC ,
 FLEX , HEAP , LOC , LONG , REF , SHORT ,
 BITS , BOOL , BYTES , CHAR , COMPL , INT , REAL , SEMA , STRING , VOID ,
 CHANNEL , FILE , FORMAT , STRUCT , UNION ,
 AT "@", OU r0 , IS ":=:", ISNT   IS NOT r0 ":/=:" ":≠:", OF "→" r0 , TRUE , FALSE , EMPTY , NIL "○", SKIP " ~",
 CO "¢", COMMENT "¢", PR , PRAGMAT ,
 CASE ~ IN ~ OUSE ~ IN ~ OUT ~ ESAC "( ~ | ~ |: ~ | ~ | ~ )",
 FOR ~ FROM ~ TO ~ BY ~ WHILE ~ DO ~ OD ,
 IF ~ THEN ~ ELIF ~ THEN ~ ELSE ~ FI "( ~ | ~ |: ~ | ~ | ~ )",
 PAR  BEGIN ~ END "( ~ )", GO TO , GOTO , EXIT " □" r0 .

Unidades: Expressões

A construção básica da linguagem é a unidade . Uma unidade pode ser uma fórmula , uma cláusula fechada , um texto de rotina ou uma das várias construções tecnicamente necessárias (atribuição, salto, salto, nada). O termo técnico cláusula incluída unifica algumas das construções inerentemente entre colchetes conhecidas como block , do Statement , Switch Statement em outras linguagens contemporâneas. Quando palavras-chave são usadas, geralmente a sequência de caracteres invertida da palavra-chave de introdução é usada para encerrar o anexo, por exemplo ( IF ~ THEN ~ ELSE ~ FI , CASE ~ IN ~ OUT ~ ESAC , FOR ~ WHILE ~ DO ~ OD ). Esta sintaxe do Guarded Command foi reutilizada por Stephen Bourne no shell Unix Bourne comum . Uma expressão também pode produzir um valor múltiplo , que é construído a partir de outros valores por uma cláusula colateral . Essa construção se parece com o pacote de parâmetros de uma chamada de procedimento.

modo: Declarações

Os tipos de dados básicos ( chamados s modena linguagem Algol 68) são real,, ( número complexo ) ,,, e . Por exemplo: intcomplboolcharbitsbytes

INT n = 2;
CO n é fixado como uma constante de 2. CO 
INT m := 3;
CO m é uma variável local recém-criada cujo valor é inicialmente definido como 3. CO 
CO     Esta é a abreviação de ref int m = loc int := 3; CO 
REAL avogadro = 6,0221415⏨23; CO Número de Avogadro CO 
longo longo real longo longo pi = 3,14159 26535 89793 23846 26433 83279 50288 41971 69399 37510;
COMPL raiz quadrada de menos um = 0 ⊥ 1;

No entanto, a declaração REAL x;é apenas um açúcar sintático para . Isto é, é realmente o identificador constante para uma referência a uma variável REAL local recém-gerada . REF REAL x = LOC REAL;x

Além disso, em vez de definir ambos floate double, ou inte longe short, etc., o ALGOL 68 fornece modificadores , de modo que o atualmente comum doubleseria escrito como LONG REAL ou LONG LONG REAL , por exemplo. As constantes prelúdio max real e min long intsão fornecidas para adaptar programas a diferentes implementações.

Todas as variáveis ​​precisam ser declaradas, mas a declaração não precisa preceder o primeiro uso.

declarador primitivo: INT , REAL , COMPL , COMPLEX G , BOOL , CHAR , STRING , BITS , BYTES , FORMAT , FILE , PIPE G , CHANNEL , SEMA

  • BITS – um "vetor compactado" de BOOL .
  • BYTES – um "vetor compactado" de CHAR .
  • STRING – um array FLEXÍVEL de CHAR .
  • SEMA – um foro SEMA que pode ser inicializado com o operador OP LEVEL .

Tipos complexos podem ser criados a partir de tipos mais simples usando vários construtores de tipos:

  • Modo REF – uma referência a um valor do tipo mode , semelhante a & em C/C++ e REF em Pascal
  • STRUCT – usado para construir estruturas, como STRUCT em C/C++ e RECORD em Pascal
  • UNION – usado para construir uniões, como em C/C++ e Pascal
  • PROC – usado para especificar procedimentos, como funções em C/C++ e procedimentos/funções em Pascal

Para alguns exemplos, consulte Comparação de ALGOL 68 e C++ .

Outros símbolos de declaração incluem: FLEX , HEAP , LOC , REF , LONG , SHORT , EVENT S

  • FLEX – declara que o array é flexível, ou seja, pode aumentar de comprimento sob demanda.
  • HEAP – aloca à variável algum espaço livre do heap global.
  • LOC – aloca variável em algum espaço livre da pilha local.
  • LONG – declara que um INT , REAL ou COMPL tem um tamanho LONG er.
  • SHORT – declara um INT , REAL ou COMPL como sendo de tamanho SHORT .

Um nome para um modo (tipo) pode ser declarado usando uma declaração MODE , que é semelhante a TYPEDEF em C/C++ e TYPE em Pascal:

 INT máx=99;
 MODO novo modo = [0:9][0:max] ESTRUTURA (
      LONG  REAL a, b, c, SHORT  INT i, j, k, REF  REAL r
 );

Isso é semelhante ao seguinte código C:

  const int máximo = 99 ; typedef estrutura { duplo a , b , c ; curto eu , j , k ; flutuar * r ; } novo modo [ 9 + 1 ][ máx + 1 ];  
    
               
   

Para o ALGOL 68, apenas a indicação do modo NEWMODE aparece à esquerda do símbolo de igual e, mais notavelmente, a construção é feita e pode ser lida da esquerda para a direita, independentemente das prioridades. Além disso, o limite inferior das matrizes Algol 68 é um por padrão, mas pode ser qualquer número inteiro de - max int a max int .

As declarações de modo permitem que os tipos sejam recursivos : definidos direta ou indiretamente em termos de si mesmos. Isto está sujeito a algumas restrições – por exemplo, estas declarações são ilegais:

 MODO  A = REF  A 
 MODO  A = ESTRUTURA ( A a, B b)
  MODO  A = PROC ( A a) A

enquanto estes são válidos:

 MODO  A = ESTRUTURA ( REF  A a, B b)
  MODO  A = PROC ( REF  A a) REF  A

Coerções: elenco

As coerções produzem um coagido a partir de um coagido de acordo com três critérios: o modo a priori do coagido antes da aplicação de qualquer coerção, o modo a posteriori do coagido exigido após essas coerções e a posição sintática ou "tipo" do coagido . As coerções podem ser em cascata.

As seis coerções possíveis são denominadas desprocedimento , desreferenciação , união , ampliação , remo e anulação . Cada coerção, exceto a união , prescreve um efeito dinâmico correspondente nos valores associados. Conseqüentemente, muitas ações primitivas podem ser programadas implicitamente por coerções.

Força do contexto – coerções permitidas:

  • suave – desprocessamento
  • fraco – desreferenciação ou desprocessamento, produzindo um nome
  • manso – desreferenciação ou desprocessamento
  • firme – manso, seguido de união
  • forte – firme, seguido de alargamento, remo ou anulação

Hierarquia de coerção com exemplos

ALGOL 68 possui uma hierarquia de contextos que determina o tipo de coerções disponíveis em um determinado ponto do programa. Esses contextos são:

Contexto
Localização do contexto Coerções disponíveis Exemplos de coerção no contexto
Macio
Fraco
Manso
Empresa
Forte
Forte
Lado direito de:
  • Declarações de identidade, como "~" em:REAL x = ~
  • Inicializações, como "~" em:REAL x := ~

Também:

  • Parâmetros reais de chamadas, como "~" em:PROC: sin(~)
  • Cláusulas fechadas de conversões, como "~" em:REAL(~)
  • Unidades de textos de rotina
  • Declarações que geram VOID
  • Todas as partes (exceto uma) de uma cláusula equilibrada
  • Um lado de uma relação de identidade, como "~" em: ~ IS ~
desprocedimento
Tudo SOFT e então desreferenciação fraca (desreferenciação ou desprocedimento, produzindo um nome)
Todos FRACO e depois desreferenciando (desreferenciando ou desproc​edando)
Todos MEEK então se unindo
Toda a FIRME então alargando, remando ou anulando

O alargamento ocorre se não houver perda de precisão. Por exemplo: Um INT será coagido para REAL , e um REAL será coagido para LONG REAL . Mas não vice-versa. Exemplos:

  • INT para LONG INT
  • INT para REAL
  • REAL para COMPL
  • BITS para [] BOOL
  • BYTES para STRING

Uma variável também pode ser forçada (rematada) para uma matriz de comprimento 1.

Por exemplo:

  • INT para [1] INT
  • REAL para [1] REAL etc.
Empresa
  • Operandos de fórmulas como "~" em:OP: ~ * ~
  • Parâmetros de chamadas de transput
Exemplo:

UNION(INT,REAL) var := 1

Manso
  • Trimscripts (produzindo INT )
  • Consultas: por exemplo, como "~" no seguinte

IF ~ THEN ... FIe FROM ~ BY ~ TO ~ WHILE ~ DO ... OD etc

  • Primárias de chamadas (por exemplo, sin in sin(x))
Exemplos:
  • REF REF BOOL para BOOL
  • REF REF REF INT para INT
Fraco
  • Primárias de fatias, como em "~" em:~[1:99]
  • Secundários de seleções, como "~" em:value OF ~
Exemplos:
  • REF BOOL para REF BOOL
  • REF REF INT para REF INT
  • REF REF REF REAL para REF REAL
  • REF REF REF REF ESTRUTURA para REF ESTRUTURA
Macio
O LHS das atribuições, como "~" em:~ := ... Exemplo:
  • desprocessamento de:PROC REAL random: e.g. random

Para obter mais detalhes sobre Primários, Secundários, Terciários e Quaternários, consulte Precedência do Operador.

pr & co: Pragmats e comentários

Pragmats são diretivas no programa, normalmente dicas para o compilador; nas línguas mais recentes, são chamados de "pragmas" (sem 't'). por exemplo

Pilha PRAGMAT =32 Pilha PRAGMAT 
PR =32 PR

Os comentários podem ser inseridos de diversas maneiras:

¢ A maneira original de adicionar seus 2 centavos a um programa ¢
 COMENTÁRIO Comentário "negrito" COMENTÁRIO 
CO Estilo i comentário CO
# Comentário estilo ii #
£ Este é um comentário hash/libra para um teclado do Reino Unido £

Normalmente, os comentários não podem ser aninhados no ALGOL 68. Esta restrição pode ser contornada usando diferentes delimitadores de comentários (por exemplo, use hash apenas para exclusões temporárias de código).

Expressões e declarações compostas

Sendo o ALGOL 68 uma linguagem de programação orientada a expressões , o valor retornado por uma instrução de atribuição é uma referência ao destino. Assim, o seguinte código ALGOL 68 é válido:

 REAL meio pi, um pi; um pi: = 2 * (meio pi: = 2 * arco tan (1))

Esta noção está presente em C e Perl , entre outros. Observe que, como em linguagens anteriores, como Algol 60 e FORTRAN , espaços são permitidos em identificadores, de modo que half piseja um identificador único (evitando assim os sublinhados versus camel case versus todos os problemas de minúsculas ).

Como outro exemplo, para expressar a ideia matemática de uma soma de f(i)i=1 a n, a seguinte expressão inteira do ALGOL 68 é suficiente:

( INT soma := 0; FOR i TO n DO soma +:= f(i) OD ; soma)

Observe que, sendo uma expressão inteira, o bloco de código anterior pode ser usado em qualquer contexto onde um valor inteiro possa ser usado . Um bloco de código retorna o valor da última expressão avaliada; essa ideia está presente no Lisp , entre outras linguagens.

As instruções compostas são todas terminadas por colchetes de fechamento distintos:

  • Cláusulas de escolha SE :
 Condição IF instruções THEN [ instruções ELSE ] FI
 forma "breve": ( condição | declarações | declarações )
 Declarações IF condição1 THEN ELIF condição2 THEN declarações [ declarações ELSE ] FI
 forma "breve": (condição1 | declarações |: condição2 | declarações | declarações)

Este esquema não apenas evita o problema do else pendente , mas também evita ter que usar BEGINe em sequências de instruçõesEND incorporadas .

  • Cláusulas de escolha CASE :
 CASE switch IN instruções, instruções,... [ instruções OUT ] ESAC
 forma "breve": ( switch | declarações, declarações,... | declarações )
 CASE switch1 IN instruções, instruções, ... OUSE switch2 IN instruções, instruções, ... [ instruções OUT ] ESAC 
 forma "breve" da instrução CASE : ( switch1 | instruções, instruções, ... |: switch2 | instruções, instruções ,... | declarações )

Exemplo de cláusula de escolha com símbolos breves :

PROC dias no mês = ( INT ano, mês) INT :
  (mês |
    31,
    (ano÷×4=0 ∧ ano÷×100≠0 ∨ ano÷×400=0 | 29 | 28 ),
    31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  );

Exemplo de cláusula de escolha com símbolos em negrito :

PROC dias no mês = ( INT ano, mês) INT :
   CASE mês IN
    31,
    SE ano MOD 4 EQ 0 E ano MOD 100 NE 0   OU   ano MOD 400 EQ 0 ENTÃO 29 ELSE 28 FI ,
    31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  ESAC ;

Exemplo de cláusula de escolha misturando símbolos Negrito e Breve :

PROC dias no mês = ( INT ano, mês) INT :
   CASE mês IN
¢Jan¢ 31,
¢Fevereiro¢ (ano MOD 4 = 0 E ano MOD 100 ≠ 0   OU   ano MOD 400 = 0 | 29 | 28 ),
¢31, 30, 31, 30, 31, 31, 30, 31, 30, 31 de março¢ a 31 de dezembro ¢
  ESAC ;

Algol68 permitiu que a opção fosse do tipo INT ou (exclusivamente) UNION . Este último permite impor tipagem forte em variáveis ​​UNION . cf união abaixo, por exemplo.

[ FOR índice ] [ FROM primeiro ] [ BY incremento ] [ TO último ] [ WHILE condição ] Instruções DO OD 
 A forma mínima de uma "cláusula de loop" é assim: Instruções DO OD

Este foi considerado o loop "universal", a sintaxe completa é:

PARA i DE 1 POR -22 A -333 ENQUANTO i×i≠4444 DO ~ OD

A construção tem vários aspectos incomuns:

  • apenas a parte DO ~ OD era obrigatória; nesse caso, o loop irá iterar indefinidamente.
  • portanto, a cláusula TO 100 DO ~ OD irá iterar apenas 100 vezes.
  • o "elemento sintático" WHILE permitiu que um programador interrompesse um loop FOR antecipadamente. por exemplo
INT soma quadrada:=0;
POR TEMPO
 _
  print(("Até agora:",i,nova linha));
  soma quadrada≠70↑2
FAZER
  soma quadrada+:=i↑2
DO

As "extensões" subsequentes ao padrão Algol68 permitiram que o elemento sintático TO fosse substituído por UPTO e DOWNTO para obter uma pequena otimização. Os mesmos compiladores também incorporaram:

  • ATÉ (C) – para finalização tardia do loop.
  • FOREACH (S) – para trabalhar em arrays em paralelo .

Outros exemplos podem ser encontrados nos exemplos de código abaixo.

struct, union & [:]: Estruturas, uniões e arrays

ALGOL 68 suporta arrays com qualquer número de dimensões e permite o fatiamento de linhas ou colunas inteiras ou parciais.

  VETOR DE MODO = [1:3]     REAL ;   # declaração vetorial MODE (typedef) # 
 MODE  MATRIX = [1:3,1:3] REAL ;   # declaração MODE da matriz (typedef) # 
 VECTOR v1 := (1,2,3);         # variável de array inicialmente (1,2,3) # 
 [] REAL v2 = (4,5,6);         # matriz constante, tipo equivalente a VECTOR , limites estão implícitos # 
 OP + = ( VECTOR a,b) VECTOR :     # definição binária do operador OP # 
   ( VECTOR out; FOR i FROM ⌊a TO ⌈a DO out[i] := a [i]+b[i] OD ; fora);
 MATRIZ m := (v1, v2, v1+v2);
 imprimir ((m[,2:]));              # uma fatia da 2ª e 3ª colunas #

As matrizes podem ser divididas de qualquer maneira, por exemplo:

 Linha REF  VETOR = m[2,];  # define um REF (ponteiro) para a 2ª linha # 
 REF  VECTOR col = m[,2];  # define um REF (ponteiro) para a 2ª coluna #

ALGOL 68 suporta múltiplas estruturas de campo ( STRUCT ) e modos unidos . Variáveis ​​de referência podem apontar para qualquer MODO , incluindo fatias de array e campos de estrutura.

Para um exemplo de tudo isso, aqui está a declaração tradicional de lista vinculada:

 MODE  NODE = UNION ( VOID , REAL , INT , COMPL , STRING ),
       LIST = STRUCT ( NODE val, REF  LIST next);

Exemplo de uso para UNION CASE de NODE :

Algol68 r0 como no Relatório Final de 1968 Algol68 r1 como no Relatório Revisado de 1973
  n := "1234";
 REAL r; INT i; COMPL c; STRING s
  CASE r,i,c,s::=n IN
   imprimir(("real:", r)),
   imprimir(("int:", i)),
   imprimir(("compl:", c)),
   imprimir(("string:",s))
   OUT imprimir(("?:", n))
  ESAC
  n := "1234";
 # ou n := VAZIO; #
  CASE n IN 
   ( VOID ): print(("void:", "EMPTY")),
   ( REAL r): imprimir(("real:", r)),
   ( INT i): imprimir(("int:", i)),
   ( COMPL c): imprimir(("compl:", c)),
   ( STRING s): print(("string:", s))
    OUT          print(("?:", n))
  ESAC

processo: Procedimentos

As declarações de procedimento ( PROC ) exigem especificações de tipo tanto para os parâmetros quanto para o resultado ( VOID se nenhum):

 PROC max de real = ( REAL a, b) REAL :
     SE a > b ENTÃO a ELSE b FI ;

ou, usando a forma "breve" da declaração condicional:

 PROC max de real = ( REAL a, b) REAL : (a>b | a | b);

O valor de retorno de a procé o valor da última expressão avaliada no procedimento. Referências a procedimentos ( ref proc ) também são permitidas. Os parâmetros de chamada por referência são fornecidos especificando referências (como ref real) na lista formal de argumentos. O exemplo a seguir define um procedimento que aplica uma função (especificada como parâmetro) a cada elemento de um array:

 PROC aplicar = ( REF [] REAL a, PROC ( REAL ) REAL f):
  
    FOR i DE  LWB a PARA  UPB a DO a[i] := f(a[i]) OD

Esta simplicidade de código era inatingível no antecessor do ALGOL 68, ALGOL 60 .

operação: Operadores

O programador pode definir novos operadores e tanto estes quanto os pré-definidos podem ficar sobrecarregados e suas prioridades podem ser alteradas pelo codificador. O exemplo a seguir define o operador MAXcom versões diádicas e monádicas (verificando os elementos de uma matriz).

 PRIO  MÁX = 9;
  
 OP  MAX = ( INT a,b) INT : ( a>b | a | b );
 OP  MAX = ( REAL a,b) REAL : ( a>b | a | b );
 OP  MAX = ( COMPL a,b) COMPL : ( ABS a > ABS b | a | b );
  
 OP  MAX = ([] REAL a) REAL :
    ( REAL out := a[ LWB a];
      FOR i FROM  LWB a + 1 TO  UPB a DO ( a[i]>out | out:=a[i] ) OD ;
     fora)

Operações de array, procedimento, desreferência e coerção

Prioridade _ Operação r0 e r1 +Algol68 r0 +Algol68 G
Efetivamente 12
(Primário)
desreferenciação, desprocessamento (~, ~), subscrição [~], remo [~,], fatiamento [~: ~], denotações de tamanho LONG & SHORT processando curry(~,,,), DIAG , TRNSP , ROW , COL
Efetivamente 11
(secundário)
OF (seleção), LOC e HEAP (geradores) → (seleção) NOVO (geradores)

Tecnicamente, não são operadores, mas são considerados "unidades associadas a nomes"

Operadores monádicos

PRIO ridade
(Terciário)
Algol68 "Personagens dignos [6] " r0&r1 +Algol68 r0&r1 +Algol68 C,G +Algol68 r0
10 NÃO ~, PARA CIMA , PARA BAIXO , LWB , UPB ,

-, ABS , ARG , BIN , ENTIER , LENG , LEVEL , ODD , REPR , ROUND , SHORTEN

¬, ↑, ↓, ⌊, ⌈ NORM , TRACE , T , DET , INV LWS , UPS , ⎩, ⎧, BTB , CTB

Operadores diádicos com prioridades associadas

PRIO ridade
(Terciário)
Algol68 "Personagens dignos" r0&r1 +Algol68 r0&r1 +Algol68 C,G +Algol68 r0
9 +*, eu +×, ⊥ !
8 SHL , SHR , **, PARA CIMA , PARA BAIXO , LWB , UPB ↑, ↓, ⌊, ⌈ ××, ^, LWS , UPS , ⎩, ⎧
7 *, /, %, SOBRE , %*, MOD , ELEM ×, ÷, ÷×, ÷*, %×, □ ÷:
6 -, +
5 <, LT , <=, LE , >=, GE , >, GT ≤, ≥
4 EQ =, NE ~= /= ≠, ¬=
3 &, E /\
2 OU \/
1 MINUSAB , PLUSAB , TIMESAB , DIVAB , OVERAB , MODAB , PLUSTO ,

-:=, +:=, *:=, /:=, %:=, %*:=, +=:

×:=, ÷:=, ÷×:=, ÷*:=, %×:= MENOS , MAIS , DIV , OVERB , MODB , ÷::=, PRUS

Detalhes específicos:

  • Os terciários incluem os nomes NIL e ○.
  • LWS : Em Algol68 r0 os operadores LWS e ⎩ ... ambos retornam TRUE se o estado inferior da dimensão de um array for fixo.
  • Os operadores UPS e ⎧ são semelhantes no estado superior .
  • Os operadores LWB e UPB estão automaticamente disponíveis em UNION s de diferentes ordens (e MODE s) de arrays. por exemplo. UPB de união([]int, [,]real, flex[,,,]char)

Atribuição e relações de identidade, etc.

Tecnicamente, não são operadores, mas são considerados "unidades associadas a nomes"

PRIO ridade
(Quaternários)
Algol68 "Personagens dignos" r0&r1 +Algol68 r0&r1 +Algol68 C,G,R +Algol68 r0
Efetivamente 0 :=, É  :=:, NÃO É  :/=: :~=:, AT @, ":", ";" :≠: :¬=: :=:= C , =:= R ..=, .=, CT , ::, CTAB , ::=, .., não é , "..", ".,"

Nota: Os quaternários incluem os nomes SKIP e ~.

":=:" (alternativamente " IS ") testa se dois ponteiros são iguais; ":/=:" (alternativamente " ISNT ") testa se eles são desiguais.

Por que :=: e :/=: são necessários: Considere tentar comparar dois valores de ponteiro, como as seguintes variáveis, declaradas como ponteiros para número inteiro:

REF INT ip, jp

Agora considere como decidir se esses dois estão apontando para o mesmo local ou se um deles está apontando para NIL . A seguinte expressão

ip = jp

irá desreferenciar ambos os ponteiros para valores do tipo INT e compará-los, uma vez que o operador "=" é definido para INT , mas não REF INT . Não é legal definir "=" para operandos do tipo REF INT e INT ao mesmo tempo, pois então as chamadas tornam-se ambíguas, devido às coerções implícitas que podem ser aplicadas: os operandos devem ser deixados como REF INT e essa versão de a operadora ligou? Ou eles deveriam ser desreferenciados para INT e essa versão usada? Portanto, a seguinte expressão nunca poderá ser legalizada:

ip = NIL

Daí a necessidade de construções separadas, não sujeitas às regras normais de coerção para operandos para operadores. Mas há uma pegadinha. As seguintes expressões:

ip :=: jp
ip :=: NIL

embora legal, provavelmente não fará o que seria esperado. Eles sempre retornarão FALSE , porque estão comparando os endereços reais das variáveis ip​​e jp, e não o que apontam . Para obter o efeito correto, seria necessário escrever

ip :=: REF INT(jp)
ip :=: REF INT(NIL)

Caracteres especiais

Teclado IBM 2741 com símbolos APL

A maioria dos caracteres "especiais" de Algol (⊂, ≡, ␣, ×, ÷, ≤, ≥, ≠, ¬, ⊃, ≡, ∨, ∧, →, ↓, ↑, ⌊, ⌈, ⎩, ⎧, ⊥, ⏨, ¢, ○ e □) podem ser encontrados no teclado IBM 2741 com a cabeça de impressão APL "bola de golfe" inserida; estes foram disponibilizados em meados da década de 1960, enquanto o ALGOL 68 estava sendo elaborado. Esses caracteres também fazem parte do padrão Unicode e a maioria deles está disponível em diversas fontes populares .

transput: Entrada e saída

Transput é o termo usado para se referir aos recursos de entrada e saída do ALGOL 68. Inclui procedimentos predefinidos para transferência não formatada, formatada e binária. Arquivos e outros dispositivos de transferência são tratados de maneira consistente e independente da máquina. O exemplo a seguir imprime alguma saída não formatada no dispositivo de saída padrão :

  print ((nova página, "Título", nova linha, "O valor de i é ",
    i, "e x[i] é ", x[i], nova linha))

Observe os procedimentos predefinidos newpagee newlinepassados ​​como argumentos.

Livros, canais e arquivos

O TRANSPUT é considerado de LIVROS , CANAIS e ARQUIVOS :

  • Os livros são compostos de páginas, linhas e caracteres, e podem ser apoiados por arquivos.
    • Um livro específico pode ser localizado pelo nome com uma chamada para match.
  • CHANNEL s correspondem a dispositivos físicos. por exemplo, perfuradores de cartões e impressoras.
    • Três canais padrão são diferenciados: canal stand in , canal stand out e canal back .
  • Um ARQUIVO é um meio de comunicação entre um programa e um livro que foi aberto através de algum canal.
    • O MOOD de um arquivo pode ser lido, escrito, char, bin e aberto.
    • os procedimentos de transferência incluem: establish, create, open, associate, lock, close, scratch.
    • posição pergunta: char number, line number, page number.
    • rotinas de layout incluem:
      • space, backspace, newline, newpage.
      • get good line, get good page, get good book, ePROC set=(REF FILE f, INT page,line,char)VOID:
    • Um arquivo possui rotinas de eventos . por exemplo on logical file end, on physical file end, on page end, on line end, on format end, on value error, on char error.

transferência formatada

A "transput formatada" na transput do ALGOL 68 tem sua própria sintaxe e padrões (funções), com FORMAT s embutidos entre dois caracteres $. [49]

Exemplos:

printf (($2l"A soma é:"x, g(0)$, m + n)); ¢ imprime o mesmo que: ¢
 imprimir ((nova linha, nova linha, "A soma é:", espaço, inteiro (m + n, 0))

par: Processamento paralelo

ALGOL 68 suporta programação de processamento paralelo. Utilizando a palavra-chave PAR , uma cláusula colateral é convertida em uma cláusula paralela , onde a sincronização das ações é controlada por meio de semáforos . No A68G as ações paralelas são mapeadas para threads quando disponíveis no sistema operacional host . No A68S foi implementado um paradigma diferente de processamento paralelo (veja abaixo).

PROC 
    comer = VOID : ( muffins-:=1; print(("Yum!",nova linha))),
    speak = VOID : ( palavras-:=1; print(("Iaque...",nova linha)));
 
Muffins INT := 4, palavras:= 8;
Boca SEMA = NÍVEL 1;
 
PAR  COMEÇA 
    ENQUANTO muffins > 0 FAÇA PARA 
        BAIXO a boca;
        comer;
        UP boca
     OD ,
     ENQUANTO palavras > 0 DO 
        DOWN boca;
        falar;
        PARA CIMA da boca
     OD 
FIM

Diversos

Por suas complexidades técnicas, o ALGOL 68 precisa de uma infinidade de métodos para negar a existência de algo:

SKIP , "~" ou "?" C – um valor indefinido sempre sintaticamente válido,
 EMPTY – o único valor admissível para VOID , necessário para selecionar VOID em um UNION ,
 VOID – sintaticamente como um MODE , mas não um,
 NIL ou "○" – um nome que não denota nada, de um modo de referência não especificado,
() ou especificamente [1:0] INT – um vácuo é uma matriz vazia (aqui especificamente de MODE [] INT ).
indefinido – um procedimento de relatórios de padrões que gera uma exceção no sistema de tempo de execução.
ℵ – Usado no relatório de padrões para inibir a introspecção de certos tipos. por exemplo, SEMA

O termo NIL IS var sempre é avaliado como TRUE para qualquer variável (mas veja acima o uso correto de IS  :/=:), enquanto não se sabe para qual valor uma comparação x < SKIP avalia para qualquer inteiro x .

ALGOL 68 deixa intencionalmente indefinido o que acontece em caso de overflow de inteiro , a representação de bit inteiro e o grau de precisão numérica para ponto flutuante.

Ambos os relatórios oficiais incluíam alguns recursos avançados que não faziam parte da linguagem padrão. Estes foram indicados com um ℵ e considerados efetivamente privados. Os exemplos incluem "≮" e "≯" para modelos, o OUTTYPE / INTYPE para digitação bruta e os operadores STRAIGHTOUT e STRAIGHTIN para "endireitar" matrizes e estruturas aninhadas

Exemplos de uso

Amostra de código

Este programa de exemplo implementa o Crivo de Eratóstenes para encontrar todos os números primos menores que 100. NIL é o análogo ALGOL 68 do ponteiro nulo em outras linguagens. A notação x OF y acessa um membro x de uma STRUCT y .

COMEÇAR # Peneira de número primo Algol-68, estilo funcional #
  
  Erro PROC = ( STRING s) VOID :
     (print((nova linha, " erro: ", s, nova linha)); GOTO stop);
  PROC um para = ( INT n) LIST :
     ( PROC f = ( INT m,n) LISTA : (m>n | NIL | cons(m, f(m+1,n))); f(1,n));
  
   LISTA DE MODOS = DE REF  ;
  MODO  = ESTRUTURA ( INT h, LISTA t);
  PROC cons = ( INT n, LIST l) LIST : HEAP NODE  := (n,l);
  PROC hd = ( LIST l) INT : ( l IS NIL | erro("hd NIL "); SKIP | h OF l );
  PROC tl = ( LIST l) LIST : ( l IS NIL | error("tl NIL "); SKIP | t OF l );
  PROC show = ( LIST l) VOID : ( l ISNT NIL | print((" ",whole(hd(l),0))); show(tl(l)));     
  
  Filtro PROC = ( PROC ( INT ) BOOL p, LIST l) LIST :
      SE l É  NIL  ENTÃO  NIL 
     ELIF p (hd (l)) ENTÃO cons (hd (l), filtro (p, tl (l)))
      ELSE filtro (p, tl(l))
      FI ;
  
  Peneira PROC = ( LIST l) LIST :
      SE l FOR  NIL  ENTÃO  NIL 
     ELSE 
        PROC não múltiplo = ( INT n) BOOL : n MOD hd(l) ~= 0;
        contras(hd(l), peneira( filtro( não múltiplo, tl(l) )))
     FI ;
  
  PROC primos = ( INT n) LIST : peneira (tl (um para (n)));
  
  mostrar(primos(100) )
FIM

Sistemas operacionais escritos em ALGOL 68

  • Computador Cambridge CAP - Todos os procedimentos que constituem o sistema operacional foram escritos em ALGOL 68C , embora vários outros procedimentos protegidos intimamente associados, como um paginador, sejam escritos em BCPL . [50]
  • Eldon 3 - Desenvolvido na Universidade de Leeds para o ICL 1900 foi escrito em ALGOL 68-R . [51]
  • Máquina Flex - O hardware era customizado e microprogramável, com sistema operacional, compilador (modular), editor, coletor de lixo e sistema de arquivamento todos escritos em ALGOL 68RS . O shell de comando Curt [52] foi projetado para acessar dados digitados semelhantes aos modos Algol-68.
  • VMES3 foi a linguagem de implementação do sistema operacional VME. S3 foi baseado no ALGOL 68 mas com tipos de dados e operadores alinhados aos oferecidos pela Série ICL 2900 .

Nota: Os computadores da Era Soviética Эльбрус-1 (Elbrus-1) e Эльбрус-2 foram criados usando a linguagem de alto nível Эль-76 (AL-76), em vez da montagem tradicional. Эль-76 se assemelha ao Algol-68. A principal diferença são os tipos de ligação dinâmica em Эль-76 suportados no nível de hardware. Эль-76 é usado para aplicação, controle de trabalho e programação de sistema. [53]

Formulários

Tanto o ALGOL 68C quanto o ALGOL 68-R são escritos em ALGOL 68, tornando efetivamente o ALGOL 68 uma aplicação por si só. Outras aplicações incluem:

Bibliotecas e APIs

Representação do programa

Uma característica do ALGOL 68, herdada da tradição ALGOL , são as suas diferentes representações. Existe uma linguagem de representação usada para descrever algoritmos em trabalhos impressos, uma linguagem estrita (rigorosamente definida no Relatório) e uma linguagem de referência oficial destinada a ser usada na entrada do compilador. Os exemplos contêm palavras do tipo BOLD , esta é a linguagem STRICT . As palavras reservadas do ALGOL 68 estão efetivamente em um namespace diferente dos identificadores, e espaços são permitidos nos identificadores, então este próximo fragmento é legal:

 INT um real int = 3 ;

O programador que escreve código executável nem sempre tem a opção de fonte BOLD ou sublinhado no código, pois isso pode depender de questões culturais e de hardware. Diferentes métodos para denotar esses identificadores foram desenvolvidos. Isso é chamado de regime de stropping . Por exemplo, todos ou alguns dos seguintes podem ser representações de programação disponíveis :

 INT um real int = 3; # a linguagem ESTRITA #
'INT'A REAL INT = 3; # CITAÇÃO estilo de corte #
.INT A REAL INT = 3; # Estilo de corte POINT #
 INT um real int = 3; # Estilo de corte UPPER #
 int a_real_int = 3; # Estilo RES stropping, existem 61 palavras reservadas aceitas #

Todas as implementações devem reconhecer pelo menos POINT, UPPER e RES dentro das seções PRAGMAT. Destes, os stroppings POINT e UPPER são bastante comuns, enquanto os stroppings RES são uma contradição com a especificação (já que não há palavras reservadas). QUOTE (citação com apóstrofo único) era a recomendação original, enquanto a citação com apóstrofo correspondente, comum no ALGOL 60, não é muito usada no ALGOL 68. [56]

Os seguintes caracteres foram recomendados para portabilidade e denominados "caracteres dignos" no Relatório sobre a representação de hardware padrão do Algol 68 arquivado em 02/01/2014 na Wayback Machine :

  • ^ Personagens dignos: ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 "#$%'()*+,-./:;<=>@[ ]_|

Isso refletia um problema na década de 1960, onde alguns hardwares não suportavam letras minúsculas, nem alguns outros caracteres não ASCII ; na verdade, no relatório de 1973 estava escrito: "Quatro caracteres dignos - "|", "_", "[ ", e "]" — são frequentemente codificados de forma diferente, mesmo em instalações que usam nominalmente o mesmo conjunto de caracteres."

  • Caracteres básicos: "Personagens dignos" são um subconjunto de "personagens básicos".

Exemplo de diferentes representações de programas

Representação Código
Algol68 "estrito"
conforme normalmente publicado
¢ sublinhado ou 
   negrito ¢ 
 MODE  XINT = INT ;
 XINT soma quadrada:=0;
 POR TEMPO _
   soma quadrada≠70×70
 FAZER
   soma quadrada+:=i↑2
 DO
Citação de citações
(como wikitext )
'pr' citação 'pr'
'modo' 'xint' = 'int';
'xint' soma sq:=0;
'para' eu 'enquanto'
  soma quadrada≠70×70
'fazer'
  soma quadrada+:=i↑2
'od'
Para um compilador de código de caracteres de 7 bits
. PR  SUPERIOR  .PR
MODO XINT = INT;
XINT soma quadrada:=0;
POR TEMPO
  soma quadrada/=70*70
FAZER
  soma quadrada+:=i**2
DO
Para um compilador de código de caracteres de 6 bits
. PONTO PR  .PR 
. MODO .XINT = .INT; 
. XINT SOMA SQ:=0; 
. PARA EU . ENQUANTO        
  SOMA QUADRADA.NE 70*70
. FAZER
  SOMA SQ .PLUSAB I .UP 2
. DO
Algol68 usando RES stropping
(palavra reservada)
. PR  RES.PR  _
modo .xint = int;
. xint  soma  quadrada:=0;
por enquanto
  soma quadrada≠70×70
fazer
  soma quadrada+:=i↑2
ah

ALGOL 68 permite que cada linguagem natural defina seu próprio conjunto de palavras-chave Algol-68. Como resultado, os programadores são capazes de escrever programas usando palavras-chave da sua língua nativa. Abaixo segue um exemplo de procedimento simples que calcula “o dia seguinte”, o código está em dois idiomas: inglês e alemão. [ carece de fontes ]

# Data do dia seguinte - variante em inglês #
  MODE  DATE = STRUCT ( INT dia, STRING mês, INT ano);
 PROC no dia seguinte = ( DATA x) DATA :
       SE dia DE   x <duração do mês (mês DE x, ano DE x)
       ENTÃO (dia DE x + 1, mês DE x, ano DE x)
       ELIF mês DE x = " Dezembro"
       THEN (1, "janeiro", ano OF x + 1)
       ELSE (1, sucessor do mês (mês OF x), ano OF x)
       FI ;
# Nachfolgetag - Deutsche Variante #
  MENGE  DATUM = TUPEL ( tag GANZ , WORT monat, GANZ jahr);
 FUNKTION naechster tag nach = ( DATUM x) DATUM :
           WENN tag VON x < monatslaenge(monat VON x, jahr VON x)
           DANN (tag VON x + 1, monat VON x, jahr VON x)
           WENNABER monat VON x = "Dezembro"
           DANN (1, "Janeiro", jahr VON x + 1)
           ANSONSTEN (1, nachfolgemonat(monat VON x), jahr VON x)
           ENDEWENN ;

Exemplo russo/soviético: Em inglês, a instrução case de Algol68 diz CASE ~ IN ~ OUT ~ ESAC , em cirílico diz выб ~ в ~ либо ~ быв .

Revisões

Exceto onde indicado (com sobrescrito ), a linguagem descrita acima é a do "Relatório Revisado (r1) ".

A linguagem do relatório não revisado

A linguagem original (conforme o "Relatório Final" r0 ) difere na sintaxe do modo cast , e tinha a característica de processuring , ou seja, coagir o valor de um termo em um procedimento que avalia o termo. O procedimento teria como objetivo tornar as avaliações preguiçosas . A aplicação mais útil poderia ter sido a avaliação em curto-circuito de operadores booleanos. Em:

OP  ANDF = ( BOOL a, PROC  BOOL b) BOOL :(a | b | FALSE );
OP  ORF = ( BOOL a, PROC  BOOL b) BOOL :(a | VERDADEIRO | b);

b só é avaliado se a for verdadeiro.

Conforme definido no ALGOL 68, não funcionou conforme o esperado, por exemplo no código:

IF  FALSE  ANDF  CO proc bool: CO ( print ("Não deve ser executado"); TRUE )
 THEN ...

contra as expectativas ingênuas dos programadores, a impressão seria executada, pois apenas o valor da cláusula anexa elaborada após ANDF foi processado. Inserção textual do PROC BOOL comentado : faz funcionar.

Algumas implementações emulam o comportamento esperado para este caso especial por extensão da linguagem.

Antes da revisão, o programador poderia decidir avaliar os argumentos de um procedimento serialmente, em vez de colateralmente, usando ponto-e-vírgula em vez de vírgulas ( gomma s).

Por exemplo em:

Teste PROC = ( REAL a; REAL b):...
...
teste (x MAIS 1, x);

É garantido que o primeiro argumento a testar será avaliado antes do segundo, mas da maneira usual:

Teste PROC = ( REAL a, b):...
...
teste (x MAIS 1, x);

então o compilador poderia avaliar os argumentos na ordem que quisesse.

Propostas de extensão do IFIP WG 2.1

Após a revisão do relatório, foram propostas algumas extensões à linguagem para ampliar a aplicabilidade:

  • parametrização parcial (também conhecida como Currying ): criação de funções (com menos parâmetros) pela especificação de alguns, mas não todos os parâmetros para uma chamada, por exemplo, um logaritmo de função de dois parâmetros, base e argumento, pode ser especializado em log natural, binário ou decádico , [57]
  • extensão do módulo : para suporte à ligação externa, foram propostos dois mecanismos, módulos de definição bottom-up , uma versão mais poderosa das facilidades do ALGOL 68-R e furos top-down , semelhantes às cláusulas ENVIRONe USINGdo ALGOL 68C [58]
  • parâmetros de modo : para implementação de polimorfismo paramétrico limitado (a maioria das operações em estruturas de dados como listas, árvores ou outros contêineres de dados podem ser especificadas sem tocar na carga útil). [59]

Até agora, apenas a parametrização parcial foi implementada, no Algol 68 Genie.

Especificação verdadeira do ALGOL 68s e cronograma de implementação

Nome Ano Propósito Estado Descrição CPU alvo Licenciamento Linguagem de implementação
ALGOL generalizado 1962 Científico Holanda ALGOL para gramáticas generalizadas
ALGOL Y Y 1966 Projecto de proposta Internacional Primeira versão do Algol 68 Especificação ACM
ALGOL 68 DR 1968 Projecto de proposta Internacional Relatório preliminar do GT 2.1 do IFIP Especificação – março ACM
ALGOL 68 r0 1968 Padrão Internacional Relatório Final do GT 2.1 do IFIP Especificação – agosto ACM
ALGOL 68-R R 1970 Militares Reino Unido ICL 1900 ALGOL 60
ÉPOS ALGOL E 1971 Científico
ALGOL 68RS RS 1972 Militares Reino Unido Sistema compilador portátil Gerador ICL 2900/Série 39, Multics, VMS e C (1993) Direitos autorais da Coroa ALGOL 68RS
Algol 68 com áreas 1972 Experimental e outros Reino Unido Adição de áreas ao Algol 68
Mini ALGOL 68 1973 Pesquisar Holanda "Um intérprete para programas simples do Algol 68" Arquivado em 18/07/2011 na Wayback Machine Intérprete portátil Centro Matemático ALGOL 60
ORÉGANO 1973 Pesquisar NÓS “A importância dos modelos de implementação.” UCLA
ALGOL 68C C 1975 Científico Reino Unido Cambridge Algol 68 ICL , IBM 360, PDP 10 e Unix, Telefunken , Tesla e Z80 (1980) [60] Cambridge ALGOL 68C
ALGOL 68 Relatório Revisado r1 1975 Padrão Internacional Relatório revisado do IFIP WG 2.1 Especificação ACM
Algol H H 1975 Experimental e outros Reino Unido Extensões propostas para o sistema de modo do Algol 68 Especificação ALGOL W
Odra Algol 68 1976 usos práticos URSS/Polônia Odra 1204/IL soviético ALGOL 60
Oklahoma ALGOL 68 1976 instrução de programação EUA Implementação da Universidade Estadual de Oklahoma [61] IBM 1130 e System/370 /158 Desconhecido ANSI Fortran 66 .
Berlim ALGOL 68 1977 Pesquisar DE "A implementação do ALGOL 68 em Berlim" & [62] Uma máquina abstrata ALGOL 68 - compilador independente de máquina Universidade Técnica de Berlim CDL 2
FLAC F 1977 Multiuso CA Implementação completa do relatório revisado com recursos de depuração Sistema/370 arrendamento, Chion Corporation Montador
ALGOL 68-RT RT 1979 Científico Reino Unido ALGOL 68-R paralelo
RS Algol rs 1979 Científico Reino Unido
ALGOL 68+ 1980 Científico Holanda Superlinguagem proposta do ALGOL 68 [63]
M-220 ALGOL 68 URSS M-220 soviético ÉPSILON
Leningrado ALGOL 68 L 1980 Telecomunicações URSS Idioma completo + módulos IBM, DEC, CAMCOH, PS 1001 e PC soviético
ALGOL 68 I interativo 1983 Reino Unido Compilação incremental PC Shareware não comercial
ALGOL 68S S 1985 Científico Internacional Versão Sun do ALGOL 68 Sun-3 , Sun SPARC (sob SunOS 4.1 e Solaris 2), Atari ST (sob GEMDOS ), Acorn Archimedes (sob RISC OS ), VAX-11 sob Ultrix-32
Algol68toC [64] (ctrans) 1985 Eletrônicos Reino Unido ctrans de ELLA ALGOL 68RS Gerador C portátil  Software de código aberto 1995 ALGOL 68RS
MK2 Interativo ALGOL 68 1992 Reino Unido Compilação incremental PC Shareware não comercial [65]
Algol 68 Genie G 2001 Idioma completo Holanda Inclui cláusula de garantia padrão Intérprete portátil GPL C
Algol 68 Genie versão 2.0.0 2010 Idioma completo Holanda Intérprete portátil; compilação opcional de unidades selecionadas GPL C

A linguagem S3 usada para escrever o sistema operacional ICL VME e muitos outros softwares de sistema na série ICL 2900 foi um derivado direto do Algol 68. No entanto, ela omitiu muitos dos recursos mais complexos e substituiu os modos básicos por um conjunto de tipos de dados mapeados diretamente para a arquitetura de hardware da série 2900.

Extensões específicas de implementação

ALGOL 68R (R) de RRE foi a primeira implementação de subconjunto ALGOL 68, rodando no ICL 1900 . Com base na linguagem original, as principais restrições do subconjunto foram definição antes do uso e nenhum processamento paralelo. Este compilador era popular nas universidades do Reino Unido na década de 1970, onde muitos estudantes de ciência da computação aprenderam o ALGOL 68 como sua primeira linguagem de programação; o compilador era conhecido por boas mensagens de erro.

ALGOL 68RS (RS) da RSRE foi um sistema compilador portátil escrito em ALGOL 68RS (inicializado a partir do ALGOL 68R) e implementado em uma variedade de sistemas, incluindo ICL 2900 / Series 39 , Multics e DEC VAX/VMS . A linguagem foi baseada no Relatório Revisado, mas com restrições de subconjuntos semelhantes ao ALGOL 68R. Este compilador sobrevive na forma de um compilador Algol68 para C.

No ALGOL 68S (S) da Carnegie Mellon University o poder do processamento paralelo foi melhorado com a adição de uma extensão ortogonal, eventing . Qualquer declaração de variável contendo a palavra-chave EVENT tornava as atribuições a esta variável elegíveis para avaliação paralela, ou seja, o lado direito era transformado em um procedimento que era movido para um dos processadores do sistema multiprocessador C.mmp . Os acessos a tais variáveis ​​foram atrasados ​​após o término da tarefa.

Cambridge ALGOL 68C (C) foi um compilador portátil que implementou um subconjunto do ALGOL 68, restringindo as definições dos operadores e omitindo a coleta de lixo, linhas flexíveis e transput formatada.

Algol 68 Genie (G) de M. van der Veer é uma implementação do ALGOL 68 para os computadores e sistemas operacionais atuais.

"Apesar das boas intenções, um programador pode violar a portabilidade ao empregar inadvertidamente uma extensão local. Para se proteger contra isso, cada implementação deve fornecer uma opção pragmat PORTCHECK. Enquanto esta opção estiver em vigor, o compilador imprime uma mensagem para cada construção que reconhece como violando alguma restrição de portabilidade." [66]

Citações

  • ... O esquema de composição de tipos adotado por C tem uma dívida considerável com Algol 68, embora talvez não tenha surgido em uma forma que os adeptos de Algol aprovariam. A noção central que capturei do Algol foi uma estrutura de tipos baseada em tipos atômicos (incluindo estruturas), composta em arrays, ponteiros (referências) e funções (procedimentos). O conceito de sindicatos e elencos do Algol 68 também teve uma influência que apareceu posteriormente. Dennis Ritchie, abril de 1993. [2]
  • ... C não descende do Algol 68 é verdade, mas houve influência, grande parte dela tão sutil que é difícil recuperar mesmo quando penso muito. Em particular, o tipo de união (uma adição tardia a C) deve-se a A68, não em detalhes, mas na ideia de ter tal tipo. Mais profundamente, a estrutura de tipos em geral e até mesmo, de uma forma estranha, a sintaxe de declaração (a parte do construtor de tipos) foi inspirada em A68. E sim, claro, "longo". Dennis Ritchie , 18 de junho de 1988 [4]
  • "Parabéns, seu Mestre conseguiu" - Niklaus Wirth [67]
  • Quanto mais vejo isso, mais infeliz fico – EW Dijkstra, 1968 [68]
  • [...] dizia-se que a popularidade do A68 era inversamente proporcional [...] à distância de AmsterdãGuido van Rossum [69]
  • [...] O melhor que pudemos fazer foi enviar junto um relatório minoritário, declarando nossa opinião ponderada de que, "... como ferramenta para a criação confiável de programas sofisticados, a linguagem foi um fracasso." [...] - CAR Hoare em sua palestra sobre o Prêmio Turing de outubro de 1980 [70]
  • “[...] Mais do que nunca será exigido de uma ferramenta de programação adequada que auxilie, por estrutura, o programador nos aspectos mais difíceis do seu trabalho, ou seja, na criação confiável de programas sofisticados. Não conseguimos ver como a linguagem aqui proposta representa um avanço significativo: pelo contrário, sentimos que a sua visão implícita da tarefa do programador é praticamente a mesma que, digamos, há dez anos. como ferramenta de programação, a linguagem deve ser considerada obsoleta. [...]" Relatório minoritário do Grupo de Trabalho de 1968 em 23 de dezembro de 1968. [71]

Veja também

Referências

Citações

  1. ^ van Wijngaarden, Adriaan ; Mailloux, Barry James ; Peck, John Edward Lancelot ; Koster, Cornelis Hermanus Antonius ; Sintzoff, Michel [em francês] ; Lindsey, Charles Hodgson ; Meertens, Lambert Guillaume Louis Théodore ; Fisker, Richard G., eds. (1976). Relatório revisado sobre a linguagem algorítmica ALGOL 68 (PDF) . Springer-Verlag . ISBN 978-0-387-07592-1. OCLC  1991170. Arquivado (PDF) do original em 19/04/2019 . Recuperado em 11/05/2019 .
  2. ^ ab Dennis Ritchie (abril de 1993). "O Desenvolvimento da Linguagem C" (PDF) . Arquivado do original (PDF) em 06/11/2005 . Recuperado em 26/04/2007 .
  3. ^ Influência em C: tipos, estruturas, arrays, ponteiros e procedimentos – Dennis Ritchie [2]
  4. ^ ab Dennis Ritchie (junho de 1988). "C e Algol 68" . Recuperado em 15/09/2006 .
  5. ^ Influência em C: união, estrutura, sintaxe e precisão longa – Dennis Ritchie [4]
  6. ^ "Uma História do C++: 1979–1991" (PDF) . Março de 1993. Página 12, 2º parágrafo: Algol68 [deu] sobrecarga de operador (§3.3.3), referências (§3.3.4) e a capacidade de declarar variáveis ​​em qualquer lugar de um bloco (§3.3.1) . Recuperado em 06/05/2008 .
  7. ^ “Entrevista com Guido van Rossum” . Julho de 1998. Arquivado do original em 01/05/2007 . Recuperado em 29/04/2007 .
  8. ^ "Uma história mais curta do ALGOL 68" . Arquivado do original em 10/08/2006 . Recuperado em 15/09/2006 .
  9. ^ Veer, Marcel van der (05/04/2023). "Relatório revisado sobre a linguagem algorítmica Algol 68". jmvdveer.home.xs4all.nl/ . Arquivado do original em 17/03/2013.
  10. ^ Veer, Marcel van der (05/04/2023). "Relatório revisado sobre a linguagem algorítmica Algol 68". jmvdveer.home.xs4all.nl/ . Arquivado do original em 17/03/2013.
  11. ^ Veer, Marcel van der (05/04/2023). "Relatório revisado sobre a linguagem algorítmica Algol 68". jmvdveer.home.xs4all.nl/ . Arquivado do original em 17/03/2013.
  12. ^ Veer, Marcel van der (05/04/2023). "Relatório revisado sobre a linguagem algorítmica Algol 68". jmvdveer.home.xs4all.nl/ . Arquivado do original em 17/03/2013.
  13. ^ "Gomas?".
  14. ^ Relatório revisado sobre a linguagem algorítmica Algol 68 arquivado em 17/03/2013 na máquina Wayback . jmvdveer.home.xs4all.nl (20/12/1968). Obtido em 21/07/2013.
  15. ^ Terekhov, Andrey (2014). "ALGOL 68 e seu impacto na URSS e na programação russa". Terceira Conferência Internacional de 2014 sobre Tecnologia da Computação na Rússia e na Antiga União Soviética . pp. 97–106. doi :10.1109/SoRuCom.2014.29. ISBN 978-1-4799-1799-0. S2CID16097093  .
  16. ^ http://toc.proceedings.com/25445webtoc.pdf "Алгол 68 и его влияние на программирование в СССР и России" - páginas: 336 e 342
  17. ^ Lindsey 1996.
  18. ^ Lindsey, Charles H. (1996). Bergin, TJ; Gibson, RG (eds.). Uma história do ALGOL 68 . História das Linguagens de Programação-II . Vol. 28. também em ACM SIGPLAN Notices 28(3), março de 1993 (inclui uma bibliografia abrangente das reuniões e discussões antes, durante e depois do desenvolvimento do ALGOL 68). ACM Pressione . pp. 97–132. doi :10.1145/155360.155365. ISBN  978-0-201-89502-5. {{cite book}}: |journal=ignorado ( ajuda )
  19. ^ Programação Algol 68 facilitada
  20. ^ Veer, Marcel van der. "Marcel van der Veer - Algol 68 Genie" . jmvdveer.home.xs4all.nl/ .
  21. ^ Lindsey 1993, pág. 7.
  22. ^ abcd Lindsey 1993, p. 9.
  23. ^ Lindsey 1993, pág. 24.
  24. ^ ab Lindsey 1993, p. 10.
  25. ^ "O Boletim Algol" .
  26. ^ ab Lindsey 1993, p. 12.
  27. ^ Lindsey 1993, pág. 13.
  28. ^ Lindsey 1993, pág. 15.
  29. ^ Hoare, CA. R. (novembro de 1968). "Crítica do ALGOL 68". Boletim ALGOL . 29 :27–29.
  30. ^ ab Peck, JEL, ed. (1970), Anais da conferência de trabalho do IFIP sobre implementação do ALGOL 68 , Munique: Holanda do Norte, ISBN 0-7204-2045-8
  31. ^ abcd Koster, CHA "Uma história mais curta de Algol 68". Arquivado do original em 17/12/2007.
  32. ^ camionete der Veer, Marcel. "Implementações de código aberto do Algol 68" . algol68.sourceforge.net .
  33. ^ E. Marchesi, José. "Frontend Algol68 para GCC" . jemarch.net .
  34. ^ Van Wijngaarden, A.; Mailloux, BJ; Peck, J.; Koster, CHA (01/03/1968). "Rascunho de Relatório sobre a Linguagem Algorítmica ALGOL 68" . Boletim ALGOL (Sup 26): 1–84 . Recuperado em 07/04/2023 – via março de 1968.
  35. ^ Sidney Marshall, "ALGOL 68 Implementation", Proceedings of the IFIP Working Conference on ALGOL 68 Implementation , Munique, 20-24 de julho de 1970, JEL Peck, editor, North Holland, páginas 239-243.
  36. ^ Sidney Marshall, Sobre a implementação do ALGOL 68 , Tese de doutorado, Dartmouth College, 1972.
  37. ^ Relatório revisado do Algol 68
  38. ^ Preto, AP; Rayward-Smith, VJ (01/05/1978). “Propostas para ALGOL H - Uma Superlinguagem do ALGOL 68”. Boletim ALGOL (42): 36–49 . Recuperado em 07/04/2023 – via maio. 1978.
  39. ^ “Algol68 S (S) publicado na internet” . Arquivado do original em 03/12/2005 . Recuperado em 30/08/2004 .
  40. ^ Veer, Marcel van der. "Marcel van der Veer - Algol 68 Genie" . jmvdveer.home.xs4all.nl/ . Recuperado em 07/04/2023 .
  41. ^ "Rascunho de relatório sobre a linguagem algorítmica ALGOL 68" . Março de 1968. Arquivado do original em 30/09/2007 . Recuperado em 22/06/2007 .
  42. ^ "Penúltimo relatório preliminar sobre a linguagem algorítmica ALGOL 68 - Capítulos 1-9" (PDF) . Outubro de 1968 . Recuperado em 22/06/2007 .[ link morto permanente ]
  43. ^ "Penúltimo relatório preliminar sobre a linguagem algorítmica ALGOL 68 - Capítulos 10-12" (PDF) . Outubro de 1968 . Recuperado em 22/06/2007 .[ link morto permanente ]
  44. ^ "Relatório sobre a linguagem algorítmica ALGOL 68" (PDF) . Dezembro de 1968. Arquivado do original (PDF) em 06/04/2008 . Recuperado em 30/12/2007 .
  45. ^ "Relatório revisado sobre a linguagem algorítmica Algol 68" . Setembro de 1973. Arquivado do original em 27/09/2007 . Recuperado em 30/04/2007 .
  46. ^ Lu Hu-quan (1971). "A tradução de Algol 68 para o chinês" (PDF) . Pequim, China: Instituto de Matemática, Academia Sinica . Recuperado em 17/08/2012 .
  47. ^ "GOST 27974-88 Linguagem de programação ALGOL 68 - Язык программирования АЛГОЛ 68" (PDF) (em russo). GOST . 1988. Arquivado do original (PDF) em 15/11/2008 . Recuperado em 15/11/2008 .
  48. ^ "GOST 27975-88 Linguagem de programação ALGOL 68 estendida - Язык программирования АЛГОЛ 68 расширенный" (PDF) (em russo). GOST . 1988. Arquivado do original (PDF) em 29/04/2011 . Recuperado em 15/11/2008 .
  49. ^ "Sintaxe de formato em ALGOL 68G" . Arquivado do original em 09/01/2008 . Recuperado em 07/04/2023 .
  50. ^ Needham, RM; Wilkes, MV (janeiro de 1979). "O computador Cambridge CAP e seu sistema operacional" (PDF) . Pesquisa da Microsoft .
  51. ^ David Holdsworth (inverno 2009–2010). "Compartilhamento de tempo KDF9: Eldon 2 não é EGDON!" Ressurreição do Computador – Número 49 . Sociedade de Conservação de Computadores . Recuperado em 03/10/2010 .
  52. ^ SE Currie; JM Foster (setembro de 1982). "Memorando RSRE" (PDF) . vitanuova. com . Recuperado em 07/04/2023 .
  53. ^ Эльбрус Бабаяна e Pentium Пентковского. Ixbt. com. Recuperado em 21 de julho de 2013.
  54. ^ Oliver, JR; Newton, RS (1979). “Experiência prática com ALGOL 68-RT”. O Jornal de Informática . 22 (2): 114–118. doi : 10.1093/comjnl/22.2.114 .
  55. ^ Aplicativos, bibliotecas e suítes de testes — Grupo de Preservação de Software. Softwarepreservation.org. Recuperado em 21 de julho de 2013.
  56. ^ Relatório revisado, página 123, nota de rodapé
  57. ^ Lindsey, CH (julho de 1974). “Parametrização Parcial”. Boletim ALGOL (37): 24–26 . Recuperado em 19/09/2022 .
  58. ^ Lindsey, CH; Boom, HJ (dezembro de 1978). "Um recurso de módulos e compilação separada para ALGOL 68" . Boletim ALGOL (43): 19–53 . Recuperado em 29/01/2020 .Errata de comentários
  59. ^ Lindsey, CH (julho de 1974). “Modais”. Boletim ALGOL (37): 26–29 . Recuperado em 19/09/2022 .
  60. ^ "Cópia arquivada" (PDF) . Arquivado do original (PDF) em 15/04/2010 . Recuperado em 20/03/2010 .{{cite web}}: CS1 maint: cópia arquivada como título ( link )
  61. ^ http://htportal.acm.org/ft_gateway.cfm?id=803425&type=pdf [ link morto permanente ]
  62. ^ Uma máquina ALGOL 68 abstrata e sua aplicação em um compilador independente de máquina – Springer. Springerlink. com. Obtido em 21/07/2013.
  63. ^ "A Enciclopédia de Linguagens de Computação" . Arquivado do original em 10/03/2011 . Recuperado em 20/03/2010 .
  64. ^ Implementações de código aberto do Algol 68 – Procure arquivos em. Fonteforge.net. Obtido em 21/07/2013.
  65. ^ [1] Arquivado em 29/08/2006 na Wayback Machine
  66. ^ "Cópia arquivada" (PDF) . Arquivado do original (PDF) em 02/01/2014 . Recuperado em 27/08/2005 .{{cite web}}: CS1 maint: cópia arquivada como título ( link )
  67. ^ CHA Koster (1993). A Fabricação do Algol 68 . Notas de aula em Ciência da Computação. CiteSeerX 10.1.1.76.2072 . 
  68. ^ Dijkstra, EW "Ao Editor ALGOL 68 Mathematische Centrum". Arquivado do original em 21/04/2007 . Recuperado em 28/04/2007 .
  69. ^ van Rossum, Guido (junho de 2005). "Lista de desejos do Python-Dev: dowhile" . Recuperado em 28/04/2007 .
  70. ^ Hoare, CAR (fevereiro de 1981) [baseado em sua palestra sobre o Prêmio Turing de 1980 ]. “As roupas velhas do imperador”. Comunicações da ACM . 24 (2): 75–83. doi : 10.1145/358549.358561 . S2CID97895  .URL alternativo arquivado em 02/10/2017 na Wayback Machine
  71. ^ "Boletim ALGOL (referido em AB30.1.1.1)" . Março de 1970. Arquivado do original em 30/09/2007 . Recuperado em 01/03/2007 .

Trabalhos citados

  • Brailsford, DF e Walker, AN, Programação Introdutória do ALGOL 68 , Ellis Horwood/Wiley, 1979
  • Lindsey, CH e van der Meulen, SG, Introdução informal ao ALGOL 68 , Holanda do Norte, 1971
  • Lindsey, CH (02/03/1993). "Uma História do ALGOL 68". Avisos da ACM SIGPLAN . 28 (3): 97–132. doi : 10.1145/155360.155365 .
  • McGettrick, AD, ALGOL 68, Um Primeiro e Segundo Curso , Cambridge Univ. Imprensa, 1978
  • Peck, JEL, um companheiro do ALGOL 68 , Univ. da Colúmbia Britânica, outubro de 1971
  • Tanenbaum, AS, A Tutorial on ALGOL 68 , Computing Surveys 8 , 155-190, junho de 1976 e 9 , 255-256, setembro de 1977, [7] [ link morto permanente ]
  • Woodward, PM e Bond, SG, ALGOL 68-R Users sic Guide , Londres, Her Majesty's Stationery Office, 1972

links externos

  • Relatório revisado sobre a linguagem algorítmica ALGOL 68 A referência oficial para usuários e implementadores da linguagem (arquivo pdf grande, digitalizado do Boletim Algol)
  • Relatório Revisado sobre a Linguagem Algorítmica ALGOL 68 Versão HTML com hiperlink do Relatório Revisado
  • Um Tutorial sobre Algol 68, por Andrew S. Tanenbaum , em Computing Surveys , Vol. 8, nº 2, junho de 1976, com retificação (Vol. 9, nº 3, setembro de 1977)
  • Algol 68 Genie - um compilador-interpretador GNU GPL Algol 68
  • Implementações de código aberto do ALGOL 68, no SourceForge
  • Representação de hardware padrão Algol68 (.pdf) Arquivado em 02/01/2014 na Wayback Machine
  • Esta história é compilada com Álgol 68
  • Algol 68 – 25 anos na URSS
  • Sistema de programa dinâmico para transferência para Álgol 68
  • História C com herança Algol68
  • McJones, Paul, "Implementações e dialetos do Algol 68", Grupo de Preservação de Software , Museu de História do Computador , 05/07/2011
  • Compilador ALGOL 68 habilitado para Web para pequenos experimentos
Obtido em "https://en.wikipedia.org/w/index.php?title=ALGOL_68&oldid=1207178973"