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 após seu envolvimento com a
especificação de ALGOL 68, e sua sugestão para essa especificação, o ALGOL W.
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 1980, 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 nos IDEs Embarcadero Delphi (Object Pascal), 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
Nota importante: Os programas foram desenvolvidos com o Turbo
Pascal (Borland). Para funcionarem com outros compiladores, devem ser
feitas as seguintes alterações:
- Linha inicial passa de program name; para program name (input,output);
- 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.
Programa Troco da Compra
Program trocoCompra; {Programa para retorno da quantidade exata de troco, com o uso do menor número de notas e moedas) ***Em Reais***.} CONST cemMil = 100000; cincoMil = 5000; doisMil = 2000; mil = 1000; quinhentos = 500; duzentos = 200; cem = 100; cinquenta = 50; vinteECinco = 25; dez = 10; cinco = 5; hum = 1; var a,b,c,d,e,humReal,f,g,cinquentaCentavos,h,vinteECincoCentavos,j,dezCentavos,m,cincoCentavos,o,humCentavo,totalCompra, pagamento,troco,cemReais,cinquentaReais,vinteReais,dezReais,cincoReais,doisReais,somaValores:INTEGER; Begin writeln ('Qual o valor da compra? (Para 2,50, digite 250.)'); readln (totalCompra); writeln ('Qual o valor dado pelo cliente? (Para 2,50, digite 250.)'); readln (pagamento); troco := (pagamento - totalCompra); {calcula as notas de 100 reais} cemReais := troco div cemMil; a := troco mod cemMil; {calcula as notas de 50 reais} cinquentaReais := a div cincoMil; b := a mod cincoMil; {calcula as notas de 20 reais} vinteReais := b div doisMil; c := b mod doisMil; {calcula as notas de 10 reais} dezReais := c div mil; d := c mod mil; {calcula as notas de 5 reais} cincoReais := d div quinhentos; e := d mod quinhentos; {calcula as notas de 2 reais} doisReais := e div duzentos; f := e mod duzentos; {calcula as moedas de 1 real} humReal := f div cem; g := f mod cem; {calcula as moedas de 50 centavos} cinquentaCentavos := g div cinquenta; h := g mod cinquenta; {calcula as moedas de 25 centavos} vinteECincoCentavos := h div vinteECinco; j := h mod vinteECinco; {calcula as moedas de 10 centavos} dezCentavos := j div dez; m := j mod dez; {calcula as moedas de 5 centavos} cincoCentavos := m div cinco; o := m mod cinco; {calcula as moedas de 1 centavo} humCentavo := o div hum; somaValores := (humReal + (doisReais*2) + (cincoReais*5) + (dezReais*10) + (vinteReais*20) + (cinquentaReais*50) + (cemReais*100)); if (troco <= 1000) then begin if (somaValores = 0) then writeln ('O troco a ser dado ao cliente eh: ',g,' Centavos.') else if (somaValores = 1) then writeln ('O troco a ser dado ao cliente eh: ',somaValores,' Real e ',g,' Centavos.') else writeln ('O troco a ser dado ao cliente eh: ',somaValores,' Reais e ',g,' Centavos.'); end; if (troco > 1000) then writeln ('O troco a ser dado ao cliente eh: ',somaValores,' Reais e ',g,' Centavos.'); writeln ('Notas de 100 reais: ',cemReais); writeln ('Notas de 50 reais: ',cinquentaReais); writeln ('Notas de 20 reais: ',vinteReais); writeln ('Notas de 10 reais: ',dezReais); writeln ('Notas de 5 reais: ',cincoReais); writeln ('Notas de 2 reais: ',doisReais); writeln ('Moedas de 1 real: ',humReal); writeln ('Moedas de 50 centavos: ',cinquentaCentavos:0); writeln ('Moedas de 25 centavos: ',vinteECincoCentavos:0); writeln ('Moedas de 10 centavos: ',dezCentavos:0); writeln ('Moedas de 5 centavos: ',cincoCentavos:0); writeln ('Moedas de 1 centavo: ',humCentavo:0); End.
Programa para Escrever na tela
program EscreverNaTela; begin writeln('Isso será escrito na tela'); end.
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 usuário 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 primeiro nome:'); readln(q1); writeln('Digite uma qualidade para o segundo nome:'); readln(q2); writeln('O 1º nome e a 1ª qualidade são: ',n1,' ',q1); writeln('O 2º nome e a 2ª qualidade são: ',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.
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.
Programa de Cinco
Program Cinco_Numeros; Uses WINCRT; 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); readln; 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.
Compiladores Gratuitos
Há vários compiladores Pascal gratuitos, como por exemplo:
- Chrome é a próxima geração do Object Pascal para as plataformas .NET e Mono, desenvolvida pela RemObjects Software;
- 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;
- 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;
- 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;
- P4 compiler , utilizado para o desenvolvimento de vários compiladores Pascal escritos em Pascal, incluindo o UCSD p-System;
- Pascalzim O Pascalzim é um compilador gratuito que foi desenvolvido na Universidade de Brasília e é utilizado em várias disciplinas de introdução a programação na UnB e outras universidades;
- 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);
- 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.
0 comentários:
Postar um comentário