Pascal (linguagem de programação)

Predefinição:Info/Linguagem de computador Pascal é 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 o uso de código estruturado.

O próprio Niklaus Wirth diz que Pascal foi criada simultaneamente para ensinar programação estruturada e para ser utilizada em sua fábrica de software. Simultaneamente, a linguagem reflete 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 foi padronizado pela ANSI (ANSI C), o Pascal possui padrões pela ISO, como o Pascal Standard e o Advanced Pascal.

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.

Padrões/Normas

Em 1983, a linguagem foi padronizada, na norma internacional ISO / IEC 7185, assim como vários padrões locais específicos de cada país, incluindo a norma americana ANSI/IEEE770X3.97-1983, e ISO 7185:1983. A diferença entre as duas normas é que a padrão ISO possui o “nível 1”, extensão do arrays conformantes, enquanto a ANSI não permitiu esta extensão à linguagem original (versão Wirth). Em 1989, foi revista ISO 7185 (ISO 7185:1990) para corrigir vários erros e ambiguidades encontradas no documento original

Em 1990, foi criado uma norma ISO / IEC 10206 padronizando o Pascal. Em 1993, o padrão ANSI foi substituído pelo ANSI organização com um "ponteiro" para a norma ISO 7185:1990, que termina efetivamente o seu estatuto como um padrão diferente.

A norma ISO 7185 foi indicado para ser uma clarificação de Wirth da linguagem como detalhado em 1974 Manual do Usuário e Relatório [Jensen e Wirth], mas também foi notável pela inclusão de "Parâmetros de array conformantes" como um nível 1 da norma, sendo nível 0 Pascal sem Conformantes Arrays.

Note que o próprio Niklaus Wirth se refere à linguagem 1974 como “o padrão”, por exemplo, para diferenciá-la das características específicas de implementação em nível de 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) originadas pelo Pascal, eram seguidos padrões gerais. Na IBM-PC, não eram. No IBM-PC, o Turbo Pascal e Delphi, padrão Borland, tem o maior número de usuários. Assim, é de extrema importância entender se uma determinada aplicação corresponde a linguagem original Pascal, Borland ou um dialeto do mesmo.

As versões da linguagem do IBM-PC começaram a divergir com a vinda da UCSD Pascal, uma aplicação que implementou ao programa várias prorrogações para a linguagem, juntamente com várias omissões e mudanças. Muitas características da linguagem UCSD sobrevivem atualmente, inclusive em linguagens Borlands.

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.

Exemplos de código

Exemplos de implementações em Pascal

Nota importante: Os programas foram escritos em Turbo Pascal (Borland).
Para funcionarem noutras versões de Pascal devem ser feitas as seguintes alterações:

• Linha inicial passa de program name; para program name (input,output);
• Comentários passam de { e } para (* e *) respectivamente
• A instrução readkey desaparece
• A directiva uses desaparece porque é própria do Turbo Pascal, bem como a biblioteca crt
• A instrução clrscr desaparece porque faz parte da biblioteca crt
• A declaração string passa para array [1..255] of char (supondo que iriam ser usados até 255 caracteres) já que o Pascal não suporta strings nativamente.
• As instruções readln para ler cadeias de caracteres, têm de estar TODAS dentro de ciclos, para ler um caracter de cada vez.

Números Perfeitos

program numerosPerfeitos;

uses crt;
var ate, x, soma, i: integer;

begin
clrscr;
x:=0;
writeln('Numeros perfeitos abaixo de');
Readln(ate);
repeat
      x:=x+1;
      soma:=0;
      for i:= 1 to x-1 do
          begin
          if x mod i = 0 then soma:=soma + i;
          end;
      if soma = x then
         begin
         writeln(x);
         end;
until (x > ate);
writeln('Pressione qualquer tecla para finalizar...');
readkey;
end.

Programa de qualidades pessoais

 program name;
 uses 
   crt; (* biblioteca do pascal *)
 var 
   n1,n2,q1,q2:string; (*variáveis criadas pelo usuario do tipo string*)
 begin
   {Limpa a tela}
   clrscr;
   writeln('Digite o primeiro nome:');
   readln(n1);
   writeln('Digite o segundo nome:');
   readln(n2);
   writeln('Digite uma qualidade para o primero nome:');
   readln(q1);
   writeln('Digite uma qualidade para o segundo nome:');
   readln(q2);
   writeln(n1,' ',q1);
   writeln(n2,' ',q2);
   {Aguarda até uma tecla ser pressionada}
   readkey;
 end.

Conversão monetária para troco

(Ex.:6,80 euros é igual a 680 cêntimos), o programa deverá devolver essa quantia em moedas de 1 euro, 50 cêntimos, 20 cêntimos e 10 cêntimos} Obs.: Esse programa nao rodaria pois ele não possui o comando readkey/delay(<num>) antes de end.

Program trocos;
const
 z=100;
 x=50;
 y=20;
 w=10;
 k=5;
 s=2;
 r=1;
 var a,b,c,d,e,f,g,h,i,j,l,m,n,o,p,q,aa,bb,t:integer;
  begin
   writeln('Introduza uma quantia de dinheiro');
    readln(t);
    {calcula a moeda de 1 euro}
    e:=t div z;
    f:=t mod z;
    {calcula a moeda de 50 cêntimos}
    g:=f div x;
    h:=f mod x;
    {calcula as moedas de 20 cêntimos}
    i:=h div y;
    j:=h mod y;
    {calcula as moedas de 10 cêntimos}
    l:=j div w;
    m:=j mod w;
    n:=m div k;
    o:=m mod k;
    p:=o div s;
    q:=o mod s;
    aa:=q div r;
    bb:=q mod r;
   writeln('A quantidade de moedas usadas de 1 euro sao:',e:0);
   writeln('A quantidade de moedas usadas de 50 cêntimos sao:',g:0);
   writeln('A quantidade de moedas usadas de 20 cêntimos sao:',i:0);
   writeln('A quantidade de moedas usadas de 10 cêntimos sao:',l:0);
   writeln('A quantidade de moedas usadas de 5 cêntimos sao:',n:0);
   writeln('A quantidade de moedas usadas de 2 cêntimos sao:',p:0);
   writeln('A quantidade de moedas usadas de 1 cêntimos sao:',aa:0);
  readln;
 end.

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 *) 
  readkey; (*ou readln;*)(* para mensagem ser exibida ate que se pressione uma tecla*)
end.(* fim do bloco de informações finais *)

Programa de Cinco

Program Cinco_Numeros;
 Uses
   CRT;
 Var
   Numbers1, Numbers2, Numbers3,
   Numbers4, Numbers5, Sum : Integer;
 Begin
   ClrScr;
   WriteLn('Entre com os cinco números: ');
   ReadLn(Numbers1, Numbers2, Numbers3, Numbers4, Numbers5);
   Sum := Numbers1 + Numbers2 + Numbers3 +
   Numbers4 + Numbers5;
   WriteLn('A soma dos números é: ',Sum);
   WriteLn('Pressione ENTER ...');
   Readkey;
 End.

Repetição

Soma dos números pares.

 program Soma_Pares;
 uses crt;
 var
    superior, soma, num: integer;
 begin
    soma:=0;
    write ('Entre com o limite superior');
    readln (superior);
    num:=2;
   
    repeat
      soma:=soma+num;
      num:=num+2;
    until (num > superior);
 
    writeln('A soma dos números pares de 2 até ', superior, ' é ', soma);
 end.

Números Pares entre dois valores inteiros

 program pares;
 var
   x,y : integer;
 begin
   writeln('Digite os dois valores');
   readln(x,y);
   if (x mod 2) <> 0 then 
     x := x + 1;
   while x <= y do 
     begin
       writeln(x, ' - ');
       x := x + 2;
     end;
   writeln('Fim da Lista');
 end.

Teste Lógico

program Teste;
var 
  a,b:integer;
uses 
  crt; 
begin
  clrscr;
  writeln ('Digite um número para A');
  readln (a);
  writeln ('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... }
    if (a < b) then
      writeln ('B é maior que A')
    else
      writeln ('B é igual à A');
  readkey;
end.

Programinha

Vejamos um exemplo:

program tic_tac; uses crt; begin

     writeln('Tic, Tac, Toc');

end.

autor: GAYBRIEL

Ver também

• Wikilivros

• 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
• Sinuca Exemplo de código que usa biblioteca gráfica