Pascal (linguagem de programação)

Origem: Wikipédia, a enciclopédia livre.

É uma linguagem de programação estruturada que recebeu este nome em homenagem ao matemático Blaise Pascal. Foi criada em 1970 pelo suíço Niklaus Wirth, tendo em mente encorajar ou uso de código estruturado.

O próprio Niklaus Wirth diz Pascal foi criada simultaneamente para ensinar programação estruturada e para ser utilizada em sua fábrica de software. Simultaneamente, a linguagem refleta a liberação pessoal de Wirth das restrições impostas pelo após seu envolvimento com a especificação de ALGOL 68, e sua sugestão para essa especificação, o ALGOL W.

A linguagem é extremamente bem estruturada e muito adequada para ensino de linguagens de programação. É provavelmente uma das linguagens mais bem resolvidas entre as linguagens estruturadas, e certamente um dos exemplos de como uma linguagem especificada por uma pessoa pode ser bem melhor do que uma linguagem especificada por um comitê.

Pascal originou uma enorme gama de dialetos, podendo também ser considerada uma família de linguagens de programação. Grande parte de seu sucesso se deve a criação, na década de 80, da linguagem Turbo Pascal, inicialmente disponível para computadores baseados na na arquitetura 8086 (com versões para 8080 no seu início).

Pascal é normalmente uma das linguagens de escolha para ensinar programação, junto com Scheme, C e Fortran.

Comercialmente, a linguagem foi sucedida pela criação da linguagem Object Pascal, atualmente utilizada nas IDEs Borland Delphi, Kylix e Lazarus. Academicamente, seus sucessores são as linguagens subsequentes de Niklaus Wirth: Modula-2 e Oberon

A partir da versão 2005, o Delphi passou a se referir a sua linguagem de programação como Delphi Language.

Assim como a Linguagem C, que é padronizado pela ANSI (Ansi C), o Pascal possui padrões pela ISO, como o Pascal Standard e o Advanced Pascal.

[editar] Implementações

O primeiro compilador Pascal foi desenvolvido em Zurique para a família de computadores CDC 6000, sendo lançado em 1970. Também em 1970 foi desenvolvido o primeiro compilador Pascal norte americano, na Universidade de Illinois por Donald B. Gillies, que gerava código de máquina nativo para o mini-computador PDP-11.

Pensando-se em propagar rapidamente o uso da linguagem, foi criado, em Zurique, um "kit de conversão" que incluia um compilador que gerava código intermediário, e um simulador para ele. Esse kit foi batizado de p-System, e foi utilizado, entre outras coisas, para criar um sistema operacional para mini-computadores chamado UCSD p-System, desenvolvido pelo Instituto de Sistemas de Informação da Universidade da Califórnia em San Diego. Segundo o próprio Niklaus Wirth, o p-System e o UCSD foram instrumentais na popularização do Pascal.

Nos anos 80, Anders Hejlsberg desenvolveu o compilador Blue Label Pascal o Nascom-2. Depois, ele foi trabalhar na Borland e reescreveu seu compilador transformando-o no Turbo Pascal para a plataforma IBM PC (e também CP/M 80), que era vendido a US$ 49,95, muito mais barato do que o Blue Label. Uma característica muito importante é que o Turbo Pascal é uma linguagem compilada, que gera código de máquina real para a arquitetura Intel 8088, tornando-a muito mais rápida do que as linguagens interpretadas.

Por ser mais barato, o Turbo Pascal passou a ter uma grande influência na comunidade Pascal, que começou a se concentrar na plataforma IBM PC no fim dos anos 80. Muitos usuários de PC da época migraram para o Turbo Pascal, em busca de uma linguagem estruturada que não fosse interpretada, para substituir, por exemplo, o BASIC. Pode se afirmar que o sucesso comercial de Turbo Pascal foi definitivo para a ampla divulgação da linguagem Pascal entre os usuários de micro-computador.

Outra variante era o Super Pascal, que adicionava labels não numéricas, o comando return e expressões como nomes de tipos.

Durante os anos 90, compiladores que podiam ser modificados para trabalhar com arquiteturas diferentes tiveram grande destaque, incluindo nessa lista o Pascal.

O próximo grande passo para a linguagem, foi a implementação da orientação a objeto(OO ou OOP em inglês) na sua estrutura, começando com a versão 5.5 do Turbo Pascal. Mais tarde, ao projetar o Delphi, querendo funcionalidades mais elaboradas da orientação a objeto, a Borland utilizou o conceito Object Pascal criado pela Apple, utilizando-o como base para uma nova linguagem, que nas versões iniciais era chamado de Object Pascal foi rebatizado como Delphi Programming Language nas versões posteriores. As maiores diferenças em relação às implementações OO das versões mais antigas foram a adição do conceito de objetos por referência, construtores, destrutores e propriedades, entre outros.

[editar] Padrões

Em 1983, a linguagem foi padronizada, internacionalmente pelo padrão ISO/IEC 7185, nos Estados Unidos pelo ANSI/IEEE770X3.97-1983, entre outros padrões regionais. Em 1990, um padrão ampliado do Pascal foi criado como ISO/IEC 10206.

O padrão ISO 7185 foi criado como uma clarificação dos escritos de Wirth, detalhada em seu User Manual and Report [Jensen and Wirth], mas contém adições como o as "Conformant Array Parameters", que são vetores com índice inicial 1, ao invés do índice inicial 0. Esse padrão foi seguido para compiladores utilizados em computadores de grande porte (mainframes e mini-computadores), mas não na plataforma IBM PC. Nessa, a maioria dos usuários utiliza os padrões do Turbo Pascal e Delphi da Borland, fazendo com que seja importante saber se uma determinada versão utiliza o padrão oficial do Pascal ou é um dialeto das versões da Borland.

[editar] Sintaxe

A linguagem Pascal foi criada para incentivar a programação modular e estruturada, facilitando a criação de procedimentos com baixo acoplamento e alta coesão. Um programa em Pascal é composto de constantes e variáveis globais, procedimentos e funções re-entrantes e um programa principal.

Procedimentos não retornam valores, funções sim. Tanto em procedimentos quanto em funções os parâmetros podem ser passados por nome ou por valor. É possível passar vetores e matrizes com o tamanho, mas não a quantidade de dimensões, especificado no tempo de execução.

Procedimentos e funções podem conter, dentro de seu escopo, novos procedimentos e funções. Dentro de qualquer parte do programa também podem ser criados blocos (com os comandos BEGIN e END, que também possuem seu próprio escopo. Nas versões originais, as variáveis só podiam ser declaradas em posições específicas e não ao decorrer do programa, o que limitava a regra de escopo.

O conjunto de procedimentos e funções pré-definidos é fixo e inclui as funções read, readln, write e writeln, para realizar E/S.

[editar] Exemplos de código

[editar] * Exemplo de programa Pascal *

== 1 ==
 - Construa um software que leia dois nomes e duas qualidades e mostre-os no final:
 program name;
 uses crt; (*biblioteca do pascal)
 var n1,n2,q1,q2:string; (*variáveis criadas pelo usuario do tipo string)
 begin
     clrscr;
     write('primeiro nome:');
     readln(n1);
     write('segundo nome:');
     readln(n2);
     write('primeira qualidade:');
     readln(q1);
     write('segunda qualidade:');
     readln(q2);
     write(n1,' ',q1);
     writeln;
     write(n2,' ',q2);
     readln
 end.

[editar] Outro exemplo de Programa Pascal

program Hello; (* As mensagens entre parênteses e asterisco são apenas comentários *)

var {aqui começa o bloco de variaveis e termina antes de begin}

mensagem : string; (* variavel tipo string pode ser definido com o tamanho que ela deve assumir. ex. string[50]*)

begin {aqui inicia o bloco principal do programa}

mensagem := 'Hello World!'; (* atribui a string 'HELLO WORLD' á variável mensagem *)

write(mensagem);(*aqui escreve no prompt*)

end.(*fim do bloco principal*)

[editar] Exemplo de contador

 program Contar; (* nome do programa *)
 var
    contador: integer; (* declaração de variáveis *)
 begin // inicio do bloco
    writeln('Contando ate 10...'); (* escreve na tela *)
    for contador := 1 to 10 do // conta até 10
    begin
       writeln('Num: ', contador); (* imprime até 10 *)
    end;
readln(contador); (* lê a variável contador *)
 end.

[editar] Repetição

Comando For

   Program Soma-Pares;
var
   superior, soma, num:integer;
begin
   soma:=0;
   write ('Entre com o limite superior');
   readln (superior);
   num:=2;
   for:=2 to 20;
begin
   soma:=soma+num;
   num:=num+2;
until
   (num>superior);
end;
   (writeln('a soma dos números pares de 2 até', superior, 'é', soma);
end.

[editar] Teste Lógico

program Teste;

var a,b:integer;

begin
   write ('Digite um número para A');
   readln (a);
   write ('Digite  o número para B');
   readln (b);

        if (a > b) then     (* Se A é maior que B então *)
        writeln ('A é maior que B')
        else                (* Senão... *)
        writeln ('B é maior que A');
end.

[editar] Compiladores Gratuitos

Vários compiladores Pascal são gratuitos, como por exemplo:

• Pascalzim O Pascalzim é um compilador gratuito que foi desenvolvido na Universidade de Brasilia e é utilizado em várias disciplinas de introdução a programação na UnB e outras universiades
• P4 compiler, utilizado para o desenvolvimento de vários compiladores Pascal escritos em Pascal, incluindo o UCSD p-System.
• Free Pascal é um poderoso compilador escrito em Pascal, distribuido sob a licença de uso GNU GPL. Pode ser utilizado em conjunto com código escrito em Turbo Pascal ou Delphi, e pode ser usados em várias plataformas e sistemas operacionais.
• Turbo Pascal era o principal compilador Pascal para PCs durante os anos 80 e início dos anos 90, devendo sua popularidade ao seu grande poder e pequeno tempo de compilação. Hoje em dia, suas versões mais antigas (até a versão 5.5) podem ser baixadas gratuitamente no site da Borland (exige registro).
• Chrome é a próxima geração do Object Pascal para as plataformas .NET e Mono, desenvolvida pela RemObjects Software.
• GNU Pascal Compiler (GPC) é o compilador padrão da GNU Compiler Collection (GCC). O compilador foi escrito em C, mas a maior parte da biblioteca de funções da linguagem é escrita em Pascal. Ele segue os padrões ANSI/ISO e grande parte dos padrões Borland/Turbo Pascal. O suporte ao Delphi ainda é limitado.
• Delphi é um dos principais produto RAD (Rapid Application Development) da Borland. Ele usa o Delphi programming language, descedente do Pascal, para criar aplicações para a plataforma Windows. O Delphi também pode criar aplicações para a plataforma .NET a partir da versão 8.0. Após esta, apareceram as versões Delphi 2005 e a última é o Delphi 2006.
• Kylix é uma versão do Delphi para o sistema operacional Linux, sendo que seu compilador e sua interface de desenvolvimento são gratuitas para uso não comercial, mas sua biblioteca de componentes não. Espera-se que o código-fonte do compilador seja aberto em breve.
• Virtual Pascal foi criado por Vitaly Miryanov em 1995 como um compilador nativo para OS/2, compatível com a sitaxe do Pascal da Borland. Mais tarde foi comercialmente lançado pela fPrint, adicionando a ele suporte para Win32, tornando-se um freeware em 2000. Atualmente, ele pode ser compilado para as plataformas Win32, OS/2 e Linux, sendo compatível em grande parte com o Pascal da Borland e o Delphi.

Uma extensa lista de compiladores pode ser encontrada na Pascaland. O site é escrito em francês, mas isso não faz muita diferença, já que é apenas uma lista de URLs para os compiladores.

[editar] Ver também

• Free Pascal - Um compilador Pascal profissional e de código-aberto
• Delphi - A IDE para desenvolvimento em Pascal mais popular para Windows
• Lazarus - Uma IDE multiplataforma para Free Pascal
• WOL - Uma ferramenta multiplataforma de desenho de interface gráfica para Free Pascal
• SpeedCASE - Ferramenta CASE para desenvolvimento com Delphi
• Lista de linguagens de programação
• Linguagem ALGOL
• Código Fonte - sinuca - exemplo de código que usa biblioteca gráfica Clique aqui