Pascal (linguagem de programação)

Pascal é uma linguagem de programação imperativa e procedural, projetada por Niklaus Wirth como uma linguagem pequena e eficiente destinada a encorajar boas práticas de programação usando programação estruturada e estruturação de dados. É nomeado em homenagem ao matemático, filósofo e físico francês Blaise Pascal.

Pascal foi desenvolvido no padrão da linguagem ALGOL 60. Wirth estava envolvido no processo para melhorar a linguagem como parte dos esforços do ALGOL X e propôs uma versão chamada ALGOL W. Isso não foi aceito e o processo do ALGOL X atolou. Em 1968, Wirth decidiu abandonar o processo ALGOL X e melhorar ainda mais o ALGOL W, lançando-o como Pascal em 1970.

Além dos escalares e arrays do ALGOL, Pascal permite definir tipos de dados complexos e construir estruturas de dados dinâmicas e recursivas, como listas, árvores e gráficos. Pascal tem tipagem forte em todos os objetos, o que significa que um tipo de dado não pode ser convertido ou interpretado como outro sem conversões explícitas. Ao contrário de C (e da maioria das linguagens da família C), Pascal permite definições de procedimentos aninhados em qualquer nível de profundidade e também permite a maioria dos tipos de definições e declarações dentro de sub-rotinas (procedimentos e funções). Um programa é, portanto, sintaticamente semelhante a um único procedimento ou função. Isso é semelhante à estrutura de blocos do ALGOL 60, mas restrita de instruções de bloco arbitrárias a apenas procedimentos e funções.

A Pascal tornou-se muito bem-sucedida na década de 1970, principalmente no florescente mercado de minicomputadores. Os compiladores também estavam disponíveis para muitos microcomputadores quando o campo surgiu no final dos anos 1970. Foi amplamente utilizado como linguagem de ensino em cursos de programação de nível universitário na década de 1980 e também usado em configurações de produção para escrever software comercial durante o mesmo período. Ele foi substituído pela linguagem de programação C durante o final dos anos 1980 e início dos anos 1990, quando os sistemas baseados em UNIX se tornaram populares e, especialmente, com o lançamento do C++.

Um derivado chamado Object Pascal projetado para programação orientada a objetos foi desenvolvido em 1985. Ele foi usado pela Apple Computer (para as máquinas Lisa e Macintosh) e Borland no final dos anos 1980 e posteriormente desenvolvido em Delphi na plataforma Microsoft Windows. Extensões aos conceitos de Pascal levaram às linguagens Modula-2 e Oberon.

História

Esforços anteriores

Grande parte da história do design de linguagem de computador durante a década de 1960 pode ser rastreada até a linguagem ALGOL 60. ALGOL foi desenvolvido durante a década de 1950 com o objetivo explícito de ser capaz de descrever algoritmos claramente. Incluía uma série de recursos para programação estruturada que permanecem comuns em linguagens até hoje.

Pouco depois de sua introdução, em 1962, Wirth começou a trabalhar em sua dissertação com Helmut Weber sobre a linguagem de programação Euler. Euler foi baseado na sintaxe do ALGOL e em muitos conceitos, mas não foi um derivado. Seu objetivo principal era adicionar listas e tipos dinâmicos, permitindo que ele fosse usado em funções semelhantes ao Lisp. A linguagem foi publicada em 1965.

A essa altura, vários problemas no ALGOL foram identificados, principalmente a falta de um sistema de strings padronizado. O grupo encarregado de manter a linguagem iniciou o processo ALGOL X para identificar melhorias, solicitando envios. Wirth e Tony Hoare apresentaram um conjunto conservador de modificações para adicionar strings e limpar parte da sintaxe. Estes foram considerados muito pequenos para valer a pena usar como o novo padrão ALGOL, então Wirth escreveu um compilador para a linguagem, que se tornou o ALGOL W.

Os esforços do ALGOL X continuariam a escolher uma linguagem muito mais complexa, o ALGOL 68. A complexidade dessa linguagem levou a uma dificuldade considerável na produção de compiladores de alto desempenho e não foi amplamente utilizada na indústria. Isso deixou uma abertura para idiomas mais novos.

Pascal

Pascal foi influenciado pelos esforços do ALGOL W, com os objetivos explícitos de ensinar programação de forma estruturada e para o desenvolvimento de software de sistema. Uma geração de estudantes usou Pascal como linguagem introdutória em cursos de graduação.

Um dos primeiros sucessos da linguagem foi a introdução do UCSD Pascal, uma versão que rodava em um sistema operacional customizado que podia ser portado para diferentes plataformas. Uma plataforma chave foi o Apple II, onde foi amplamente utilizado como Apple Pascal. Isso levou Pascal a se tornar a principal linguagem de alto nível usada para desenvolvimento no Apple Lisa e, posteriormente, no Macintosh. Partes do sistema operacional Macintosh original foram traduzidas manualmente para a linguagem assembly Motorola 68000 a partir do código-fonte Pascal.

O sistema de composição TeX de Donald E. Knuth foi escrito em WEB, o sistema de programação alfabetizado original, baseado em DEC PDP-10 Pascal. Aplicativos comerciais de sucesso, como Adobe Photoshop, foram escritos em Macintosh Programmer's Workshop Pascal, enquanto aplicativos como Total Commander, Skype e Macromedia Captivate foram escritos em Delphi (Object Pascal). A Apollo Computer usou Pascal como a linguagem de programação de sistemas para seus sistemas operacionais a partir de 1980.

Variantes de Pascal também têm sido usadas para tudo, desde projetos de pesquisa até jogos de PC e sistemas embarcados. Existem compiladores Pascal mais recentes que são amplamente usados.

Objeto Pascal

Durante o trabalho no Lisa, Larry Tesler começou a se corresponder com Wirth sobre a ideia de adicionar extensões orientadas a objetos à linguagem, para tornar Pascal uma linguagem de programação multiparadigma. Isso levou inicialmente ao Clascal, introduzido em 1983. Como o programa Lisa desapareceu e foi substituído pelo Macintosh, uma versão posterior foi criada e chamada de Object Pascal. Isso foi introduzido no Mac em 1985 como parte da estrutura do aplicativo MacApp e se tornou a principal linguagem de desenvolvimento da Apple no início dos anos 90.

As extensões Object Pascal foram adicionadas ao Turbo Pascal com o lançamento da versão 5.5 em 1989. Ao longo dos anos, Object Pascal tornou-se a base do sistema Delphi para Microsoft Windows, que ainda é usado para desenvolver aplicativos Windows e pode cruzar -Compile o código para outros sistemas. O Free Pascal é uma alternativa multiplataforma de código aberto com seu próprio IDE gráfico chamado Lazarus.

Implementações

Os primeiros compiladores Pascal

O primeiro compilador Pascal foi projetado em Zurique para a família de computadores mainframe da série CDC 6000. Niklaus Wirth relata que uma primeira tentativa de implementá-lo em FORTRAN 66 em 1969 não teve sucesso devido à inadequação do FORTRAN 66 para expressar estruturas de dados complexas. A segunda tentativa foi implementada em uma linguagem semelhante a C (Scallop por Max Engeli) e então traduzida manualmente (por R. Schild) para o próprio Pascal para boot-strapping. Estava operacional em meados de 1970. Muitos compiladores Pascal desde então têm sido auto-hospedados de forma semelhante, ou seja, o próprio compilador é escrito em Pascal, e o compilador geralmente é capaz de recompilar a si mesmo quando novos recursos são adicionados à linguagem ou quando o compilador deve ser portado para um novo ambiente. O compilador GNU Pascal é uma exceção notável, sendo escrito em C.

A primeira porta bem-sucedida do compilador CDC Pascal para outro mainframe foi concluída por Welsh e Quinn na Queen's University of Belfast (QUB) em 1972. O alvo era a série 1900 da International Computers Limited (ICL). Este compilador, por sua vez, foi o pai do compilador Pascal para o minicomputador Multum da Information Computer Systems (ICS). A porta Multum foi desenvolvida – com o objetivo de usar Pascal como uma linguagem de programação de sistemas – por Findlay, Cupples, Cavouras e Davis, trabalhando no Departamento de Ciência da Computação da Universidade de Glasgow. Pensa-se que o Multum Pascal, que foi concluído no verão de 1973, pode ter sido a primeira implementação de 16 bits.

Um compilador completamente novo foi concluído por Welsh et al. no QUB em 1977. Ele oferecia um recurso de diagnóstico no idioma de origem (incorporando criação de perfil, rastreamento e despejos pós-morte formatados com reconhecimento de tipo) que foi implementado por Findlay e Watt na Universidade de Glasgow. Essa implementação foi portada em 1980 para a série ICL 2900 por uma equipe baseada na Southampton University e na Glasgow University. O Standard Pascal Model Implementation também foi baseado neste compilador, tendo sido adaptado, por Welsh e Hay na Manchester University em 1984, para verificar rigorosamente a conformidade com o padrão BSI 6192/ISO 7185 e gerar código para uma máquina abstrata portátil.

O primeiro compilador Pascal escrito na América do Norte foi construído na Universidade de Illinois sob Donald B. Gillies para o PDP-11 e gerou código de máquina nativo.

O sistema Pascal-P

Para propagar a linguagem rapidamente, um kit de portabilidade de compilador foi criado em Zurique que incluía um compilador que gerava o chamado p-code para uma máquina de pilha virtual, ou seja, código que se presta a uma interpretação razoavelmente eficiente, juntamente com um interpretador para esse código – o sistema Pascal-P. Os compiladores do sistema P foram nomeados Pascal-P1, Pascal-P2, Pascal-P3 e Pascal-P4. Pascal-P1 foi a primeira versão e Pascal-P4 foi a última a vir de Zurique. A versão denominada Pascal-P1 foi cunhada após o fato de existirem muitas fontes diferentes para Pascal-P. O compilador foi redesenhado para aumentar a portabilidade e lançado como Pascal-P2. Este código foi posteriormente aprimorado para se tornar Pascal-P3, com um código intermediário compatível com versões anteriores de Pascal-P2 e Pascal-P4, que não era compatível com versões anteriores.

O compilador-interpretador Pascal-P4 ainda pode ser executado e compilado em sistemas compatíveis com o Pascal original. No entanto, ele aceita apenas um subconjunto da linguagem Pascal.

Pascal-P5, criado fora do grupo de Zurique, aceita a linguagem Pascal completa e inclui compatibilidade com ISO 7185.

O UCSD Pascal ramificou-se do Pascal-P2, onde Kenneth Bowles o usou para criar o UCSD p-System interpretativo. Foi um dos três sistemas operacionais disponíveis no lançamento do IBM Personal Computer original. O UCSD Pascal usava um código intermediário baseado em valores de byte e, portanto, foi um dos primeiros compiladores de bytecode. Apple Pascal foi lançado em 1979 para os sistemas de computador Apple 2 e Apple 3. Foi uma implementação ou amplamente baseada em UCSD Pascal. Pascal-P1 a Pascal-P4 não era, mas sim baseado no comprimento de palavra de 60 bits do CDC 6600.

Um compilador baseado no compilador Pascal-P5, que criou arquivos de objetos binários nativos, foi lançado para o computador mainframe IBM System/370 pela Australian Atomic Energy Commission; foi nomeado o AAEC Pascal 8000 Compiler após a abreviação do nome da comissão.

Object Pascal e Turbo Pascal

A Apple Computer criou seu próprio Lisa Pascal para o Lisa Workshop em 1982 e portou o compilador para Apple Macintosh e MPW em 1985. Em 1985, Larry Tesler, em consulta com Niklaus Wirth, definiu o Object Pascal e essas extensões foram incorporadas ao os compiladores Lisa Pascal e Mac Pascal.

Na década de 1980, Anders Hejlsberg escreveu o compilador Blue Label Pascal para o Nascom-2. Uma reimplementação deste compilador para o IBM PC foi comercializada sob os nomes Compas Pascal e PolyPascal antes de ser adquirida pela Borland e renomeada como Turbo Pascal.

Turbo Pascal tornou-se extremamente popular, graças a uma estratégia de preços agressiva, tendo um dos primeiros IDEs de tela cheia e tempo de resposta muito rápido (apenas alguns segundos para compilar, vincular e executar). Ele foi escrito e altamente otimizado inteiramente em linguagem assembly, tornando-o menor e mais rápido do que grande parte da concorrência.

Em 1986, Anders portou o Turbo Pascal para o Macintosh e incorporou as extensões Object Pascal da Apple ao Turbo Pascal. Essas extensões foram adicionadas de volta à versão para PC do Turbo Pascal para a versão 5.5. Ao mesmo tempo, a Microsoft também implementou o compilador Object Pascal. O Turbo Pascal 5.5 teve uma grande influência na comunidade Pascal, que começou a se concentrar principalmente no IBM PC no final dos anos 80. Muitos amadores de PC em busca de um substituto estruturado para o BASIC usaram este produto. Também começou a ser adotado por desenvolvedores profissionais. Na mesma época, vários conceitos foram importados de C para permitir que os programadores de Pascal usassem a interface de programação de aplicativos (API) baseada em C do Microsoft Windows diretamente. Essas extensões incluíam cadeias de caracteres terminadas em nulo, aritmética de ponteiro, ponteiros de função, um operador address-of e typecasts inseguros.

Turbo Pascal e outros derivados com estruturas unidade ou módulo são linguagens de programação modulares. No entanto, ele não fornece um conceito de módulo aninhado ou importação e exportação qualificada de símbolos específicos.

Outras variantes

Super Pascal é uma variante que adiciona rótulos não numéricos, uma declaração de retorno e expressões como nomes de tipos.

O TMT Pascal foi o primeiro compilador compatível com Borland para o modo protegido DOS de 32 bits, OS/2 e sistemas operacionais Win32. A linguagem TMT Pascal foi a primeira a permitir a sobrecarga de funções e operadores.

As universidades de Wisconsin-Madison, Zürich, Karlsruhe e Wuppertal desenvolveram o Pascal-SC e o Pascal-XSC (Extensões para Computação Científica) compiladores, destinados a programar computações numéricas. O desenvolvimento do Pascal-SC começou em 1978 com suporte a ISO 7185 Pascal nível 0, mas o suporte de nível 2 foi adicionado posteriormente. Pascal-SC originalmente visava o processador Z80, mas foi posteriormente reescrito para DOS (x86) e 68000. Pascal-XSC foi várias vezes portado para Unix (Linux, SunOS, HP-UX, AIX) e Microsoft/IBM (DOS com sistemas operacionais EMX, OS/2, Windows). Ele opera gerando código-fonte C intermediário que é então compilado para um executável nativo. Algumas das extensões da linguagem Pascal-SC foram adotadas pelo GNU Pascal.

Pascal Sol foi projetado por volta de 1983 por uma equipe francesa para implementar um sistema semelhante ao Unix chamado Sol. Era Pascal nível 1 padrão (com limites de matriz parametrizados), mas a definição permitia palavras-chave alternativas e identificadores predefinidos em francês e o idioma incluía algumas extensões para facilitar a programação do sistema (por exemplo, um equivalente a lseek). A equipe Sol mais tarde mudou-se para o projeto ChorusOS para projetar um sistema operacional distribuído.

O IP Pascal era uma implementação da linguagem de programação Pascal usando o Micropolis DOS, mas foi movido rapidamente para o CP/M-80 rodando no Z80. Ele foi movido para os tipos de máquina 80386 em 1994 e existe hoje como implementações Windows/XP e Linux. Em 2008, o sistema foi levado a um novo nível e a linguagem resultante denominada "Pascaline" (depois da calculadora de Pascal). Ele inclui objetos, controles de namespace, arrays dinâmicos e muitas outras extensões e geralmente apresenta a mesma funcionalidade e proteção de tipo do C#. É a única implementação que também é compatível com a implementação Pascal original, que é padronizada como ISO 7185.

Construções de linguagem

Pascal, em sua forma original, é uma linguagem puramente procedimental e inclui o array tradicional de estruturas de controle do tipo ALGOL com palavras reservadas como if, then, else, while, for e case, variando em uma única instrução ou um begin-end. Pascal também possui construções de estruturação de dados não incluídas nos tipos originais do ALGOL 60, como registros, variantes, ponteiros, enumerações e conjuntos e ponteiros de procedimento. Tais construções foram em parte herdadas ou inspiradas do Simula 67, ALGOL 68, do próprio ALGOL W de Niklaus Wirth e sugestões de C. A. R. Hoare.

Os programas em Pascal começam com a palavra-chave program com uma lista de descritores de arquivos externos como parâmetros (não é necessário no Turbo Pascal etc.); em seguida, segue o bloco principal entre colchetes pelas palavras-chave begin e end. O ponto-e-vírgula separa as instruções e o ponto final (ou seja, um ponto) encerra todo o programa (ou unidade). As maiúsculas e minúsculas são ignoradas na fonte Pascal.

Aqui está um exemplo do código-fonte em uso para um simples "Hello, World!" programa:

programa Olá.(saída);começar Escrever(Olá, Mundo! ') {No ";" é necessário após a última declaração de um bloco - adicionar uma adiciona uma "declaração nula" ao programa, que é ignorada pelo compilador. ?fim.

Tipos de dados

Uma declaração de tipo em Pascal é usada para definir um intervalo de valores que uma variável desse tipo é capaz de armazenar. Ele também define um conjunto de operações que podem ser realizadas em variáveis desse tipo. Os tipos predefinidos são:

A faixa de valores permitida para os tipos básicos (exceto booleanos) é definida pela implementação. As funções são fornecidas para algumas conversões de dados. Para conversão de real para inteiro, as seguintes funções estão disponíveis: round (que arredonda para inteiro usando o arredondamento do banqueiro) e trunc (arredonda para zero).

O programador tem a liberdade de definir outros tipos de dados comumente usados (por exemplo, byte, string, etc.) em termos de tipos predefinidos usando o recurso de declaração de tipo de Pascal, por exemplo

tipo bytes = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 0...255; assinada_byte = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = - Não.128...127; string = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = embalado arrayNão.1...255] de Charlie.;

Tipos usados com frequência, como byte e string, já estão definidos em muitas implementações.

Normalmente o sistema usará uma palavra para armazenar os dados. Por exemplo, o tipo byte pode ser armazenado em um inteiro da máquina - talvez 32 bits - em vez de um valor de 8 bits. Pascal não contém elementos de linguagem que permitem que os tipos básicos de armazenamento sejam definidos de forma mais granular. Essa capacidade foi incluída em várias extensões Pascal e linguagens subsequentes, enquanto outras, como Modula-2, expandiram o conjunto integrado para cobrir a maioria dos tipos de dados de máquina, como inteiros de 16 bits.

A palavra-chave packed diz ao compilador para usar o método mais eficiente de armazenamento para os tipos de dados estruturados: conjuntos, matrizes e registros, em vez de usar uma palavra para cada elemento. A compactação pode retardar o acesso em máquinas que não oferecem acesso fácil a partes de uma palavra.

Tipos de subfaixa

Subintervalos de qualquer tipo de dados ordinais (qualquer tipo simples, exceto real) também podem ser feitos:

var x : 1...10.; Sim. : "A"...O que é? ';

Definir tipos

Em contraste com outras linguagens de programação de sua época, Pascal suporta um tipo de conjunto:

var Set1 : conjunto de 1...10.; Set2 : conjunto de "A"...O que é? ';

Um conjunto é um conceito fundamental para a matemática moderna e pode ser usado em muitos algoritmos. Tal recurso é útil e pode ser mais rápido do que uma construção equivalente em uma linguagem que não suporta conjuntos. Por exemplo, para muitos compiladores Pascal:

se Eu... em Não.5...10.] então ...

é executado mais rápido que:

se (Eu... > 4) e (Eu... < 11) então ...

Conjuntos de valores não contíguos podem ser particularmente úteis, tanto em termos de desempenho quanto de legibilidade:

se Eu... em Não.0...3, 7, 9, 12...15] então ...

Para esses exemplos, que envolvem conjuntos em pequenos domínios, o desempenho aprimorado geralmente é obtido pelo compilador representando variáveis de conjunto como vetores de bits. Os operadores de conjunto podem então ser implementados eficientemente como operações de código de máquina bit a bit.

Tipos de união

var A: Integer; B: arrayNão.1...4] de Byte absoluto A; C: Integer absoluto 0;

tipo Forma = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = (Círculo, Praça, Triângulo); Dimensões = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = registro Processo Figura: Forma de  Círculo: (Diâmetro: real); Praça: (Largura: real); Triângulo: (Lado: real; Ângulo1, Ângulo2: 0...360.) fim;

Declarações de tipo

Os tipos podem ser definidos a partir de outros tipos usando declarações de tipo:

tipo x = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Intérprete; Sim. = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = x;...

Além disso, tipos complexos podem ser construídos a partir de tipos simples:

tipo um = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = arrayNão.1...10.] de Intérprete; b) = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = registro x : Intérprete; Sim. : Charlie. {extra ponto e vírgula não estritamente necessário} fim; c = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = arquivo de um;

Tipo de arquivo

Como mostrado no exemplo acima, os arquivos Pascal são sequências de componentes. Cada arquivo tem uma variável de buffer que é denotada por f^. Os procedimentos get (para leitura) e put (para escrita) movem a variável buffer para o próximo elemento. Read é introduzido de forma que read(f, x) seja o mesmo que x:= f^; obter(f);. Write é introduzido de forma que write(f, x) seja o mesmo que f^:= x; put(f); O tipo texto é predefinido como arquivo de char. Embora a variável buffer possa ser usada para inspecionar o próximo caractere a ser usado (verificar um dígito antes de ler um inteiro), isso leva a sérios problemas com programas interativos em implementações iniciais, mas foi resolvido posteriormente com o "lazy I /O" conceito.

Em Jensen & Com Pascal, as strings são representadas como matrizes compactadas de caracteres; eles, portanto, têm comprimento fixo e geralmente são preenchidos com espaços.

Tipos de ponteiro

Pascal suporta o uso de ponteiros:

tipo Não. = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ^Node; Node = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = registro um : Intérprete; b) : Charlie.; c : Não.  fim;var NodePtr : Não.; IntPtr : ^Intérprete;

Aqui a variável NodePtr é um ponteiro para o tipo de dado Node, um registro. Os ponteiros podem ser usados antes de serem declarados. Esta é uma declaração antecipada, uma exceção à regra de que as coisas devem ser declaradas antes de serem usadas.

Para criar um novo registro e atribuir o valor 10 e o caractere A aos campos a e b no registro, e para inicializar o ponteiro c para o ponteiro nulo ("NIL" em Pascal), as declarações seriam:

novo novo(NodePtr);...NodePtr↑.um ? 10.;NodePtr↑.b) ? A ';NodePtr↑.c ? n;...

Isso também pode ser feito usando a instrução with, como a seguir:

novo novo(NodePtr);...com NodePtr^ docomeçar um ? 10.; b) ? A '; c ? nfim;...

Dentro do escopo da instrução with, aeb referem-se aos subcampos do ponteiro de registro NodePtr e não ao nó de registro ou ao tipo de ponteiro pNode.

Listas encadeadas, pilhas e filas podem ser criadas incluindo um campo do tipo ponteiro (c) no registro.

Ao contrário de muitas linguagens que apresentam ponteiros, Pascal permite apenas que os ponteiros façam referência a variáveis anônimas criadas dinamicamente e não permite que façam referência a variáveis estáticas ou locais padrão. Os ponteiros também devem ter um tipo associado, e um ponteiro para um tipo não é compatível com um ponteiro para outro tipo (por exemplo, um ponteiro para um caractere não é compatível com um ponteiro para um inteiro). Isso ajuda a eliminar os problemas de segurança de tipo inerentes a outras implementações de ponteiro, particularmente aquelas usadas para PL/I ou C. Também remove alguns riscos causados por ponteiros pendentes, mas a capacidade de desalocar dinamicamente o espaço referenciado usando o dispose (que tem o mesmo efeito que a função da biblioteca livre encontrada em C) significa que o risco de ponteiros pendurados não foi eliminado como em linguagens como Java e C#, que fornecem coleta de lixo (mas que não eliminam o problema relacionado de vazamentos de memória).

Algumas dessas restrições podem ser suspensas em dialetos mais recentes.

Estruturas de controle

Pascal é uma linguagem de programação estruturada, o que significa que o fluxo de controle é estruturado em declarações padrão, geralmente sem 'goto' comandos.

enquanto um < b) do Escreve(Esperando ');se um > b) então Escreve("Condição" ') Não é permitido nenhum ponto-e-vírgula. mais Escreve("Condição não satisfeita ');para Eu... ? 1 para 10. do (nenhum ponto-e-vírgula aqui como ele iria desapegar a próxima declaração) Escreve(' Iteração:, Eu...);repetir um ? um + 1até um = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 10.;Processo Eu... de 0 : Escrever("zero" '); 1 : Escrever(Um '); 2 : Escrever(Dois '); 3,4,5,6,7,8,9,10.: Escrever('? ')fim;

Procedimentos e funções

Pascal estrutura os programas em procedimentos e funções. Geralmente, um procedimento é usado por seus efeitos colaterais, enquanto uma função é usada por seu valor de retorno.

programa Impressão;var Eu... : Intérprete;procedimento Imprimir um registo(JJ : Intérprete);começar ...fim;função triplo(Não. x: Intérprete): Intérprete;começartriplo ? x * 3fim;começar O programa principal ... Imprimir um registo(Eu...); Imprimir um registo(triplo(Eu...)fim.

Procedimentos e funções podem ser aninhados em qualquer profundidade, e o 'programa' construct é o bloco lógico mais externo.

Por padrão, os parâmetros são passados por valor. Se 'var' precede o nome de um parâmetro, é passado por referência.

Cada procedimento ou função pode ter suas próprias declarações de rótulos goto, constantes, tipos, variáveis e outros procedimentos e funções, que devem estar todos nessa ordem. Este requisito de ordenação foi originalmente planejado para permitir uma compilação eficiente de passagem única. No entanto, em alguns dialetos (como o Delphi), o requisito estrito de ordenação das seções de declaração foi relaxado.

Ponto-e-vírgula como separadores de instrução

Pascal adotou muitos recursos de sintaxe de linguagem da linguagem ALGOL, incluindo o uso de um ponto e vírgula como separador de instrução. Isso está em contraste com outras linguagens, como PL/I e C, que usam o ponto-e-vírgula como um terminador de instrução. Nenhum ponto e vírgula é necessário antes da palavra-chave end de uma declaração de tipo de registro, um bloco ou uma instrução case; antes da palavra-chave until de uma instrução repeat; e antes da palavra-chave else de uma instrução if.

A presença de um ponto e vírgula extra não era permitida nas primeiras versões do Pascal. No entanto, a adição de declarações vazias do tipo ALGOL no Relatório Revisado de 1973 e alterações posteriores no idioma na ISO 7185:1983 agora permitem ponto-e-vírgula opcional na maioria desses casos. Um ponto-e-vírgula ainda não é permitido imediatamente antes da palavra-chave else em uma instrução if, porque o else segue uma única instrução, não uma sequência de instruções. No caso de ifs aninhados, um ponto-e-vírgula não pode ser usado para evitar o problema do else pendente (onde o if interno não tem um else, mas o if externo tem) encerrando putativamente o if aninhado com um ponto-e-vírgula - isso encerra ambos os ifs cláusulas. Em vez disso, um bloco begin...end explícito deve ser usado.

Recursos

Compiladores e interpretadores

Vários compiladores e interpretadores Pascal estão disponíveis para uso geral:

• Delphi é o produto da Embarcadero (anteriormente Borland/CodeGear) de desenvolvimento de aplicações rápidas (RAD). Ele usa a linguagem Object Pascal (termed 'Delphi' by Borland), descendente de Pascal, para criar aplicativos para Windows, macOS, iOS e Android. O suporte do.NET que existiu de D8 até D2005, D2006 e D2007 foi terminado, e substituído por uma nova linguagem (Prism, que é remarcado Oxygene, ver abaixo) que não é totalmente compatível com versões anteriores. Nos últimos anos o apoio Unicode e os genéricos foram adicionados (D2009, D2010, Delphi XE).
• Free Pascal é um compilador multiplataforma escrito em Object Pascal (e é auto-hosting). É destinado a fornecer um compilador conveniente e poderoso, ambos capazes de compilar aplicativos legados e ser os meios para desenvolver novos. Ele é distribuído sob a Licença Pública Geral GNU (GNU GPL), enquanto que pacotes e biblioteca de tempo de execução vêm sob uma Licença Pública Geral Menos Geral Modificada GNU (GNU LGPL). Além dos modos de compatibilidade para Turbo Pascal, Delphi e Mac Pascal, ele tem seus próprios modos de sintaxe processual e orientada a objetos com suporte para recursos prolongados, como sobrecarga do operador. Ele suporta muitas plataformas e sistemas operacionais. As versões atuais também possuem um modo ISO.
• Turbo51 é um compilador Pascal gratuito para a família Intel 8051 de microcontroladores, com sintaxe Turbo Pascal 7.
• Oxygene (anteriormente nomeado Chrome) é um compilador Object Pascal para o. Plataformas NET e Mono. Foi criado e é vendido pela RemObjects Software, e vendido por um tempo pela Embarcadero como o compilador de backend de Prism.
• Kylix era um descendente de Delphi, com suporte para o sistema operacional Linux e uma biblioteca de objetos melhorada. Já não é suportado. Compiler e IDE estão disponíveis agora para uso não comercial.
• GNU Pascal Compiler (GPC) é o compilador Pascal da GNU Compiler Collection (GCC). O compilador é escrito em C, a biblioteca de tempo de execução principalmente em Pascal. Distribuído sob a Licença Pública Geral GNU, é executado em muitas plataformas e sistemas operacionais. Ele suporta as linguagens padrão ANSI/ISO e tem suporte parcial do dialeto de Turbo Pascal. Uma das omissões mais notáveis é a ausência de um tipo de corda totalmente compatível com Turbo Pascal (curto). Suporte para Borland Delphi e outras variantes de idioma é bastante limitado. Há algum suporte para Mac-pascal, no entanto.
• Virtual Pascal foi criado por Vitaly Miryanov em 1995 como um compilador nativo OS/2 compatível com a sintaxe Borland Pascal. Então, ele tinha sido desenvolvido comercialmente por fPrint, adicionando suporte Win32, e em 2000 tornou-se freeware. Hoje ele pode compilar para Win32, OS/2 e Linux, e é principalmente compatível com Borland Pascal e Delphi. O desenvolvimento foi cancelado em 4 de abril de 2005.
• Compilador P4, a base para muitos compiladores Pascal-implemented-in-Pascal subsequentes. Implementa um subconjunto de Pascal completo.
• Compilador P5 é uma adaptação ISO 7185 (full Pascal) de P4.
• Smart Mobile Studio é um compilador Pascal para HTML5/Javascript
• Turbo Pascal foi o compilador de Pascal dominante para PCs durante os anos 1980 e início dos anos 90, popular tanto por causa de suas extensões poderosas e tempos de compilação extremamente curtos. Turbo Pascal foi compactamente escrito e poderia compilar, executar e depurar tudo da memória sem acessar o disco. As unidades de disco flexível lenta eram comuns para programadores na época, ampliando ainda mais a vantagem de velocidade do Turbo Pascal. Atualmente, versões mais antigas do Turbo Pascal (até 5.5) estão disponíveis para download gratuito no site da Borland.
• O IP Pascal implementa a linguagem "Pascaline" (nomeada após a calculadora de Pascal), que é um Pascal altamente estendido compatível com o Pascal original de acordo com a ISO 7185. Possui módulos com controle namespace, incluindo módulos de tarefas paralelos com semaphores, objetos, matrizes dinâmicas de quaisquer dimensões que são alocadas em tempo de execução, sobrecargas, sobreposições e muitas outras extensões. IP Pascal tem uma biblioteca de portabilidade integrada que é personalizada sob medida para o idioma Pascal. Por exemplo, um aplicativo padrão de saída de texto de Pascal original de 1970 pode ser recompilado para trabalhar em uma janela e até mesmo ter construções gráficas adicionadas.
• Pascal-XT foi criado pela Siemens para seus sistemas operacionais de mainframe BS2000 e SINIX.
• PocketStudio é uma ferramenta de compilador de subconjunto Pascal e RAD para processadores Palm OS e MC68xxx com algumas de suas próprias extensões para ajudar a interferir com a API Palm OS. Ele se assemelha a Delphi e Lazarus com um designer de forma visual, um inspetor de objetos e um editor de código fonte.
• MIDletPascal – Um compilador Pascal e IDE que gera bytecode Java pequeno e rápido especificamente projetado para criar software para celulares.
• Vector Pascal é uma linguagem para conjuntos de instruções SIMD, como o MMX e o AMD 3d Now, suportando todos os processadores Intel e AMD e o PlayStation 2 Emotion Engine da Sony.
• Morfik Pascal permite o desenvolvimento de aplicações Web inteiramente escritas em Object Pascal (ambos servidor e navegador lado).
• WDSibyl – Ambiente de Desenvolvimento Visual e compilador Pascal para Win32 e OS/2.
• PP Compiler, um compilador para Palm OS que é executado diretamente no computador portátil.
• CDC 6000 Pascal compilador é o código fonte para o primeiro compilador Pascal (CDC 6000).
• Pascal-S
• AmigaPascal é um compilador Pascal gratuito para o computador Amiga.
• VSI Pascal para OpenVMS (anteriormente HP Pascal para OpenVMS, Compaq Pascal, DEC Pascal, VAX Pascal e originalmente VAX-11 Pascal) é um compilador Pascal que funciona em sistemas OpenVMS. Também foi apoiado sob Tru64. VSI Pascal para OpenVMS é compatível com ISO/IEC 7185:1990 Pascal também alguns de ISO/IEC 10206:1990 Extended Pascal, e também inclui suas próprias extensões. O frontend do compilador é implementado no BLISS.
• Stony Brook Pascal+ foi um compilador de 16 bits (mais tarde 32 bits) otimizando para DOS e OS/2, comercializado como um substituto direto para Turbo Pascal, mas produzindo código que executou pelo menos duas vezes mais rápido.

IDEs

• Dev-Pascal é um Pascal IDE que foi projetado em Borland Delphi e que suporta Free Pascal e GNU Pascal como backends.
• Lazarus é um IDE multiplataforma visual livre de Delphi para desenvolvimento rápido de aplicações (RAD). Com base no Free Pascal, o Lazarus está disponível para inúmeras plataformas, incluindo Linux, FreeBSD, macOS e Microsoft Windows.
• Fogo (macOS) e Água (Windows) para o Oxygene e o compilador de elementos

Bibliotecas

• Biblioteca WOL para criar aplicações GUI com o Free Pascal Compiler.

Padrões

ISO/IEC 7185:1990 Pascal

Em 1983, a linguagem foi padronizada no padrão internacional IEC/ISO 7185 e em vários padrões locais específicos de cada país, incluindo o americano ANSI/IEEE770X3.97-1983 e ISO 7185:1983. Esses dois padrões diferiam apenas porque o padrão ISO incluía um "nível 1" extensão para matrizes conformes (uma matriz em que os limites da matriz não são conhecidos até o tempo de execução), onde o ANSI não permitia essa extensão para o idioma original (versão Wirth). Em 1989, a ISO 7185 foi revisada (ISO 7185:1990) para corrigir vários erros e ambiguidades encontrados no documento original.

O ISO 7185 foi declarado como um esclarecimento da linguagem de Wirth de 1974, conforme detalhado pelo Manual do Usuário e Relatório [Jensen e Wirth], mas também foi notável por adicionar "Parâmetros de matriz conforme" como nível 1 para o padrão, nível 0 sendo Pascal sem matrizes compatíveis. Esta adição foi feita a pedido de C. A. R. Hoare e com a aprovação de Niklaus Wirth. A causa precipitante foi que Hoare queria criar uma versão Pascal da (NAG) Numerical Algorithms Library, que havia sido escrita originalmente em FORTRAN, e descobriu que não era possível fazê-lo sem uma extensão que permitisse parâmetros de array de tamanhos variados. Considerações semelhantes motivaram a inclusão na ISO 7185 da facilidade para especificar os tipos de parâmetros de procedimentos e parâmetros funcionais.

O próprio Niklaus Wirth referiu-se à linguagem de 1974 como "o Padrão", por exemplo, para diferenciá-la dos recursos específicos da máquina do compilador CDC 6000. Esta linguagem foi documentada em The Pascal Report, a segunda parte do "Pascal users manual and report".

Nas grandes máquinas (mainframes e minicomputadores) nas quais o Pascal se originou, os padrões eram geralmente seguidos. No IBM PC, eles não eram. Em PCs IBM, os padrões Turbo Pascal e Delphi da Borland têm o maior número de usuários. Assim, normalmente é importante entender se uma implementação específica corresponde à linguagem Pascal original ou a um dialeto Borland dela.

As versões da linguagem para IBM PC começaram a diferir com o advento do UCSD Pascal, uma implementação interpretada que apresentava várias extensões para a linguagem, juntamente com várias omissões e alterações. Muitos recursos de linguagem UCSD sobrevivem até hoje, inclusive no dialeto da Borland.

ISO/IEC 10206:1990 Pascal Estendido

Em 1990, um padrão Pascal estendido foi criado como ISO/IEC 10206, que é idêntico em conteúdo técnico ao IEEE/ANSI 770X3.160-1989 A partir de 2019, está planejado o suporte de Extended Pascal no FreePascal Compiler.

Variações

A versão Zurique de Niklaus Wirth do Pascal foi emitida fora da ETH em duas formas básicas: a fonte do compilador CDC 6000 e um kit de portabilidade chamado sistema Pascal-P. O compilador Pascal-P deixou de fora vários recursos da linguagem completa que não eram necessários para inicializar o compilador. Por exemplo, procedimentos e funções usados como parâmetros, registros de variantes indiscriminadas, empacotamento, descarte, gotos interprocedimentais e outros recursos do compilador completo foram omitidos.

O UCSD Pascal, sob a orientação do professor Kenneth Bowles, foi baseado no kit Pascal-P2 e, conseqüentemente, compartilhou várias das restrições da linguagem Pascal-P. O UCSD Pascal foi posteriormente adotado como Apple Pascal e continuou por várias versões lá. Embora o UCSD Pascal realmente tenha expandido o subconjunto Pascal no kit Pascal-P adicionando de volta construções Pascal padrão, ainda não era uma instalação padrão completa do Pascal.

No início dos anos 1990, Alan Burns e Geoff Davies desenvolveram Pascal-FC, uma extensão para Pl/0 (do livro de Niklaus Algorithms + Data Structures = Programs). Várias construções foram adicionadas para usar Pascal-FC como uma ferramenta de ensino para Programação Concorrente (como semáforos, monitores, canais, invocação remota e recursos). Para poder demonstrar simultaneidade, a saída do compilador (uma espécie de código P) pode ser executada em uma máquina virtual. Essa máquina virtual não apenas simulava um ambiente normal – justo –, mas também podia simular condições extremas (modo injusto).

Compiladores Pascal tipo Borland

O Turbo Pascal da Borland, escrito por Anders Hejlsberg, foi escrito em linguagem assembly independente da UCSD e dos compiladores de Zürich. No entanto, adotou muito do mesmo subconjunto e extensões do compilador UCSD. Isso provavelmente ocorre porque o sistema UCSD era o sistema Pascal mais comum adequado para desenvolver aplicativos nos sistemas de microprocessadores com recursos limitados disponíveis na época.

O Turbo Pascal versão 3 e versões posteriores, incluindo Object Pascal e Delphi da Borland e quase compatíveis não Borland, tornaram-se populares entre os programadores, incluindo autores de shareware, e assim a biblioteca SWAG do código Pascal apresenta um grande quantidade de código escrito com versões como Delphi em mente.

Produtos de software (compiladores e IDE/Rapid Application Development (RAD)) nesta categoria:

• Turbo Pascal – "TURBO.EXE" até a versão 7, e Turbo Pascal para Windows ("TPW") e Turbo Pascal para Macintosh.
• Pure Pascal e HiSPeed Pascal 2 Pascal linguagem Ambiente para a gama Atari ST de computadores.
• Borland Pascal 7 – Uma versão profissional da linha Turbo Pascal que visava tanto o DOS quanto o Windows.
• Objeto Pascal – uma extensão da linguagem Pascal que foi desenvolvida no Apple Computer por uma equipe liderada por Larry Tesler em consulta com Niklaus Wirth, o inventor de Pascal; suas características foram adicionadas ao Turbo Pascal de Borland para Macintosh e em 1989 para Turbo Pascal 5.5 para DOS.
• Delphi – Object Pascal é essencialmente a sua linguagem subjacente.
• Free Pascal compilador (FPC) – Free Pascal adotou o dialeto padrão de facto de programadores Pascal, Borland Pascal e, mais tarde, Delphi.
• PascalABC.NET – uma nova geração de linguagem de programação Pascal, incluindo compilador e IDE.
• Borland Kylix é um compilador e IDE anteriormente vendido por Borland, mas mais tarde descontinuado. É uma versão Linux do ambiente de desenvolvimento de software Borland Delphi e C++Builder.
• Lázaro – semelhante a Kylix em função, é um IDE visual multiplataforma livre para RAD usando o compilador Pascal livre, que suporta dialetos de Objeto Pascal para graus variados.
• Virtual Pascal – VP2/1 é um compilador Pascal totalmente Borland- e Borland Delphi - compatível com 32 bits para OS/2 e Windows 32 (com uma versão Linux "a propósito").
• Sybil é uma fonte aberta Delphi-como IDE e compilador; implementações incluem:
  • WDSibyl para Microsoft Windows e OS/2, um ambiente comercial compatível com Borland Pascal lançado por uma empresa chamada Speedsoft que foi posteriormente desenvolvido em um ambiente de desenvolvimento rápido de aplicativos (RAD) chamado Sybil e, em seguida, aberto sob a GPL quando essa empresa fechou;
  • Open Sybil, que é um projeto em curso, uma ferramenta de código aberto para OS/2 e eCS que foi originalmente baseada nas fontes WDsybl Sibyl Portable Component Classes (SPCC) e Sibyl Visual Development Tool (SVDE), mas agora seu núcleo é IBM System Object Model (SOM), WPS e OpenDoc.

Lista de padrões relacionados

• ISO 8651-2:1988 Sistemas de processamento de informação – Computação gráfica – Graphical Kernel System (GKS) ligações linguísticas – Parte 2: Pascal

Recepção

Pascal gerou uma ampla variedade de respostas na comunidade de computação, tanto críticas quanto elogiosas.

Críticas iniciais

Embora muito popular na década de 1980 e início de 1990, as implementações de Pascal que seguiram de perto a definição inicial de Wirth da linguagem foram amplamente criticadas por serem inadequadas para uso fora do ensino. Brian Kernighan, que popularizou a linguagem C, delineou suas críticas mais notáveis a Pascal já em 1981 em seu artigo "Por que Pascal não é minha linguagem de programação favorita". O problema mais sério descrito por Kernighan era que os tamanhos dos arrays e os comprimentos das strings faziam parte do tipo, então não era possível escrever uma função que aceitasse arrays de comprimento variável ou mesmo strings como parâmetros. Isso tornava inviável escrever, por exemplo, uma biblioteca de ordenação. Kernighan também criticou a ordem imprevisível de avaliação de expressões booleanas, suporte de biblioteca pobre e falta de variáveis estáticas, e levantou uma série de questões menores. Além disso, ele afirmou que a linguagem não fornecia nenhuma construção simples para "escapar" (consciente e forçosamente ignorar) restrições e limitações. Reclamações mais gerais de outras fontes observaram que o escopo das declarações não estava claramente definido na definição do idioma original, o que às vezes tinha sérias consequências ao usar declarações de encaminhamento para definir tipos de ponteiro, ou quando declarações de registro levavam à recursão mútua ou quando um identificador pode ou pode não ter sido usado em uma lista de enumeração. Outra dificuldade era que, assim como o ALGOL 60, a linguagem não permitia que procedimentos ou funções passadas como parâmetros predefinissem o tipo esperado de seus parâmetros.

Apesar das críticas iniciais, Pascal continuou a evoluir, e a maioria dos pontos de Kernighan não se aplica a versões da linguagem que foram aprimoradas para serem adequadas ao desenvolvimento de produtos comerciais, como o Turbo Pascal da Borland. Como Kernighan previu em seu artigo, a maioria das extensões para corrigir esses problemas era incompatível de compilador para compilador. Desde o início dos anos 1990, no entanto, a maioria das variedades parece condensada em duas categorias: ISO e tipo Borland. Extended Pascal aborda muitas dessas críticas iniciais. Ele suporta cadeias de caracteres de comprimento variável, inicialização variável, compilação separada, operadores booleanos de curto-circuito e cláusulas padrão (caso contrário) para instruções case.