Pascal (linguaggio di programmazione)

Pascal; linguaggio di programmazione
	Programma in Pascal
Autore	Niklaus Wirth
Data di origine	1970
Ultima versione	ISO/IEC 10206:1991 Stage: 90.93 (29 июля 2008 года)
Utilizzo	generico, didattico
Paradigmi	programmazione strutturata
Tipizzazione	forte, statica
Specifiche di linguaggio	Pascal user manual and Report
Estensioni comuni	.pas, .inc
Influenzato da	ALGOL
	Modifica dati su Wikidata · Manuale

Il Pascal, in informatica, è un linguaggio di programmazione creato da Niklaus Wirth e basato sul linguaggio ALGOL; il nome è dedicato a Blaise Pascal che inventò nel 1645 la Pascalina, considerata la prima calcolatrice.

Storia

Pare che Wirth, docente di programmazione negli anni Sessanta, avvertisse la mancanza di un linguaggio di programmazione adatto all'insegnamento della propria materia e dotato di strutture dati avanzate. Il BASIC, creato nel 1964, era facile da imparare ma non aveva strutture dati avanzate e non incoraggiava abbastanza ad analizzare il problema prima di scrivere effettivamente il codice. Nemmeno linguaggi come ALGOL e Fortran sembravano adatti per i suoi fini didattici. Perciò, Wirth creò da zero il linguaggio Pascal, inserendovi il concetto di programmazione strutturata^[1].

La prima implementazione del linguaggio divenne operativa nel 1970, ma raggiunse una discreta diffusione nel campo industriale a partire dal 1974, con la pubblicazione del libro Pascal User Manual and Report^[2], considerato il riferimento standard per il linguaggio. TeX e parte delle prime versioni del sistema operativo del Macintosh^[3] e di Microsoft Windows^[4] furono scritte in Pascal.

Essendo un linguaggio pensato per studenti e utenti inesperti, i compilatori Pascal hanno un atteggiamento protettivo nei confronti del programmatore (partendo dal presupposto che qualunque irregolarità del codice scritto sia un errore), che spesso infastidisce un po' gli esperti. Per esempio i dati e le funzioni sono verificati dal compilatore usando la cosiddetta tipizzazione forte (strong type checking), ovvero uno stretto rigore riguardo alla definizione ed al modo di usare i tipi di dati, a differenza di linguaggi a tipizzazione debole (per esempio JavaScript) che invece consentono ai programmatori esperti una maggiore libertà di scrittura del codice al costo della possibilità di rendere più arduo rilevare errori di struttura e sintassi.

Il Pascal è un linguaggio che impone sia l'uso di un buono stile di programmazione, sia di analizzare a fondo il problema prima di cominciare a scrivere codice sorgente. Data la diffusione negli ambienti scolastici e l'evoluzione della tecnologia e delle esigenze del mercato, ne sono state create versioni ad oggetti, come per esempio il Turbo Pascal e l'Object Pascal (utilizzato nell'ambiente di sviluppo Delphi di Borland, ora di proprietà di Embarcadero).

Caratteristiche

Le caratteristiche principali del Pascal sono una sintassi chiara e rigida con l'obbligo di dividere il programma in sezioni ben definite (specifiche uses e implementation) e di dichiarare in anticipo tutte le variabili usate nel programma. Anche la sequenza di definizione degli elementi nel codice sorgente è rigidamente codificata e sequenziale, ovvero: etichette, costanti, tipi, variabili, procedure e funzioni (label, const, type, var, procedure, function). Inoltre, permette l'uso di tipi di dati complessi e definibili dal programmatore (record) tramite la specifica di sezione type. Permette anche l'uso dei puntatori e l'allocazione dinamica della memoria (specifiche new e dispose), in modo comunque più controllato per esempio del linguaggio C tradizionale.

Benché il Pascal sia identificato come linguaggio dalle origini didattiche, in realtà il suo sviluppo non si è mai fermato negli anni ed ha superato il concetto iniziale di programmazione strutturata introducendo, già con Delphi, la programmazione ad oggetti. Negli anni sono state introdotte caratteristiche dei moderni linguaggi di programmazione come ad esempio le interfacce e i generics, mentre le funzioni anonime erano già state anticipate da Wirth con le funzioni e procedure nidificate, che hanno il pregio di rendere più leggibile il codice sorgente. Questi miglioramenti lo hanno reso un linguaggio molto versatile, tanto da poter essere considerato ad alto livello, ma anche a basso livello in quanto può gestire puntatori e codice unmanaged. La forte tipizzazione lo rende un linguaggio che presenta tendenzialmente meno bug, la semplicità sintattica permette uno sviluppo veloce e, essendo compilato, gli eseguibili sono generalmente molto veloci.

Da sottolineare che, nella sua formulazione originale, il linguaggio era privo dell'istruzione GOTO, concettualmente nemica della strutturazione corretta dei programmi, aggiunta poi in seguito ma della quale è comunque scoraggiato l'uso.

Tutte queste caratteristiche fanno del Pascal un linguaggio evergreen adatto a sviluppare un ampio ventaglio di applicazioni.

Compilatori gratuiti

Free Pascal^[5], un compilatore con licenza GPL, con sintassi compatibile con Object Pascal;
Lazarus^[6], nato come sottoprogetto di Free Pascal, un clone avanzato GPL di Borland Delphi;
Dev-Pascal^[7], IDE per Windows 9X, parzialmente compatibile con la serie NT/2K/XP e non più sviluppato, basato sul compilatore Free Pascal.

Programmi di esempio

Hello, world!

Il seguente esempio stampa a video il testo "Hello world".

program hello;  
uses crt;              <----non obbligatoria
begin
  clrscr;              <----non obbligatoria
  writeln('Hello World');
  readln
end.

La prima riga introduce il programma con la parola chiave program, a cui segue il titolo del programma. Non possono essere utilizzati caratteri speciali né spazi. La terza riga contiene l'istruzione begin, usata per iniziare a scrivere il programma vero e proprio. La quinta riga contiene l'istruzione writeln, usata per scrivere a video Hello World (il testo riportato tra parentesi), mentre la sesta, con l'istruzione readln, pone il programma in attesa di un input da tastiera, in modo da non far scomparire immediatamente la scritta. Quando verrà premuto il tasto ↵ Invio, il programma procederà eseguendo l'istruzione end, che pone fine alla sequenza. Tale comando è l'unico, in ambiente Pascal, ad essere seguito da un punto anziché da un punto e virgola.

Variabili

Il Pascal mette a disposizione molti tipi di variabili:

Tipi interi, utilizzati per memorizzare valori numerici interi, con o senza segno e compresi entro determinati intervalli numerici. In Pascal sono:
- integer: variabile di tipo intero a 16 bit con segno (numeri da −32 768 a 32 767)
- word: variabile di tipo intero a 16 bit senza segno, con valori compresi tra 0 e 65 535.
- byte: come già suggerisce il nome, questo tipo occupa un byte in memoria e consente $2^{8}=256$ differenti valori, da 0 a 255. Questo tipo è completamente compatibile con il tipo char: l'unica differenza consiste nel fatto che un tipo byte ha come visualizzazione predefinita quella di un numero, mentre il char quella di un carattere.
- shortint: come il precedente occupa un solo byte, ma rappresenta numeri dotati di segno, perciò i valori possono variare da -128 a 127.
- longint: occupa 4 byte (ovvero 32 bit) e permette di gestire $2^{32}=4294967296$ diversi valori con segno, compresi fra −2 147 483 648 e 2 147 483 647.
- comp: è il tipo intero più grande. Occupa 8 byte (64 bit), pertanto permette di gestire $2^{64}=18446744073709551616$ diversi valori con segno, compresi tra -9.2E18 e 9.2E18.
Tipi reali:
- real: numero reale con segno (numeri da -2.9E-39 a 1.7E38), rappresentabili in notazione scientifica o esponenziale. Se si inseriscono da tastiera numeri real, bisogna scriverli in notazione esponenziale. Per stampare a video un numero reale in formato decimale utilizzare la seguente sintassi:

... {Altre istruzioni}
Var R:Real;
... {Altre istruzioni}
Writeln('Il numero reale è ',R:10:3);
... {Altre istruzioni}

In questo caso vengono visualizzate in tutto 10 cifre, di cui 3 decimali.

Tipo carattere (char): variabile di carattere, rappresenta un solo carattere generalmente codificati in otto bit con formato ASCII.
Tipo stringa (string): variabile che contiene più caratteri, di fatto è un vettore di caratteri (array of char). Per accedere ai singoli caratteri contenuti in una stringa è sufficiente usare le parentesi quadre [] specificando al loro interno il numero del carattere che si vuole utilizzare (lettura/scrittura). Si può indicare la lunghezza massima della stringa inserendo [n] durante la dichiarazione, se non viene specificata, la lunghezza, sarà di 256 caratteri.
Tipo booleano (boolean): variabile binaria (vero/falso).

Puntatori

Si possono specificare puntatori a variabili usando nella dichiarazione un nome seguito dal simbolo ^ che precede il tipo di variabile a cui deve puntare il puntatore. I puntatori funzionano come in C/C++:

var
  puntatore : ^int;
  numero : int;
begin
  numero := 10;
  puntatore := @numero
end.

In questo modo puntatore punterà a numero. Mentre per assegnare un valore allo spazio di memoria indirizzato da puntatore, si userà ^ in coda al nome, ovvero come operatore di dereferenziazione:

puntatore^ := 15;

Array

Gli array in Pascal sono una sequenza ordinata, in quantità prestabilita, di elementi dello stesso tipo. Gli elementi possono essere composti da qualunque tipo di dati, nativo o definito dal programmatore usando type.

Una caratteristica importante del linguaggio Pascal sta nel fatto che nel momento della dichiarazione di un array, viene definito anche il valore iniziale dell'indice da utilizzare per la scansione dei vari elementi:

Array di un tipo generico:

Var nome : array [inizio..fine] of tipo;

Stringhe: Come in molti altri linguaggi le stringhe sono semplicemente degli array di caratteri. La dichiarazione di una variabile stringa è quindi la dichiarazione di un array composto da una quantità predefinita di caratteri. Nell'esempio seguente viene creato una variabile stringa di 20 caratteri. La variabile dichiarata in questo modo può essere usata come un array, cioè accedendo alle informazioni carattere per carattere oppure nel suo insieme. Se si utilizza un'assegnazione di quest'ultimo tipo vengono interessati anche gli elementi successivi alla lunghezza della stringa letterale assegnata. Quindi, seguendo l'esempio, l'array riceve il nome «Paolo» nei suoi primi cinque elementi, mentre negli altri viene comunque inserito uno spazio. Nelle più recenti implementazioni di Pascal è tuttavia possibile usare il tipo String, che sostituisce la dichiarazione array [0..n] of char.

Var nome : array [1..20] of char;
..... {Altre istruzioni}
nome := 'Paolo'; {assegnazione nel suo insieme}
nome[5] :='a';  {assegnazione del solo quinto carattere}

Record

In Pascal è possibile definire un tipo personalizzato (custom), strutturato dal programmatore stesso. La sintassi si basa sulla specifica type:

type persona = record
     nome:string[30];
     eta:int
end;

per poi usare il tipo di variabile personalizzato in questo modo:

var qualcuno : persona;
begin
    qualcuno.nome := 'Asdrubale'
    qualcuno.eta := 35
end.

Input e output

L'input di dati da tastiera viene effettuato tramite l'utilizzo del comando readln(nome_variabile).
L'output invece usa il comando writeln(nome_variabile); la stampa a video usa lo stesso il comando writeln, però il testo è tra singoli apici (writeln('ciao mondo');)

Esistono anche le due funzioni write() e read() che differiscono dalle precedenti per il fatto che non scrivono un codice di "ritorno a capo" a fine riga.
Un esempio di I/O di numeri interi:

program input_output(input, output);
var 
     n1,n2,ris:integer;                         {Dichiarazione tipo intero}
begin
     writeln('Inserisci n1');                   {viene visualizzato il testo tra ' '}
     readln(n1);                                {comando di input, la variabile introdotta viene inserita in n1}
     writeln('Inserisci n2');
     readln(n2);
     ris:=n1+n2;                                {fa la somma di n1 e n2 e il risultato viene inserito in ris}
     writeln('La somma e'' uguale a ',ris);     {stampa il messaggio tra ' ' e la variabile ris}
     readln                                     {questo evita che il programma si chiuda senza che sia possibile leggere l'ultima riga, il programma si aspetta che l'utente scriva qualcosa e poi prema INVIO. In questo modo il programma si chiuderà.}
end.

I/O reali: per l'input di numeri reali il metodo resta sempre lo stesso (readln (variabile)), invece per l'output, per vedere numeri comprensibili bisogna usare una sintassi diversa nel writeln.

program input_output(input, output);
var   n1,n2,ris:real;                               {Dichiarazione tipo reale}
begin
     writeln('Inserisci n1');                       {viene visualizzato il testo tra ' '}
     readln(n1);                                    {comando di input, la variabile introdotta viene messa in n1}
     writeln('Inserisci n2');
     readln(n2);
     ris:=n1+n2;                                    {fa la somma di n1 e n2 e il risultato viene messo in ris}
     writeln('La somma e'' uguale a ',ris:6:2);     {stampa il messaggio tra ' ' e la variabile ris, con 6 numeri prima della "," , la "," stessa e 2 dopo}
     readln
end.

Nella stampa a video abbiamo usata un'alterazione del comando writeln, aggiungendo var:n:m dove var è il nome della variabile da visualizzare, n è il numero di cifre complessive (compresa la ",") da visualizzare e m sono quelle dopo la virgola. Se ci sono più cifre da visualizzare di quelle indicate, esse non vengono inviate sul dispositivo di uscita.

I/O caratteri: l'input e l'output di caratteri (numeri, lettere, simboli), è lo stesso per caratteri e numeri interi:

program input_output(input, output);
var   ch:char;                                      {Dichiarazione tipo carattere}
begin
     writeln('Inserisci il carattere');             {viene visualizzato il testo tra ' '}
     readln(ch);                                    {comando di input, la variabile introdotta viene messa in ch}
     writeln('Il carattere inserito e'' ',ch);      {stampa il messaggio tra ' ' e la variabile ch}
     readln
end.

I/O stringhe: le variabili stringhe come già detto sono array di caratteri.

Strutture di controllo

Alternative

Program alternativa;
var 
   n:integer;
begin
  write('inserisci un numero: ');
  readln(n);
  if n > 0     {controlla se il valore è positivo}
  then
    write('il numero e'' positivo.')
  else
    write('il numero e'' negativo.');
  readln
end.

Iterazione

I seguenti frammenti di codice riportano un esempio dei cicli di iterazione in linguaggio Pascal.

Program ciclo_for;
var i, n, num:integer;
begin
  write('quanti numeri vuoi inserire?');
  readln(n);
  for i:=1 to n do
  begin
    write('inserisci il numero: ');
    readln(num);
  end;
  readln
end.

Dopo la specifica for, occorre l'assegnazione di un valore a una variabile (in questo caso i:=1). Questa variabile verrà incrementata automaticamente a ogni ripetizione del ciclo, ovvero del codice indicato dopo for tra do ed end: una volta uguale al numero (o alla variabile) dopo il to, il ciclo terminerà.

Il valore di una variabile può essere incrementato anche usando la stessa variabile come riferimento. Ovviamente non bisogna fare confusione tra queste espressioni in Pascal, e in molti altri linguaggi, con le convenzioni delle equazioni matematiche.

Il ciclo for...to...do ripete un blocco di istruzioni un numero determinato di volte, perciò sono vietati valori reali decimali prima e dopo il to, e le variabili da utilizzare dovranno sempre essere state dichiarate di tipo intero.

Si può eseguire un ciclo for...to...do anche in ordine inverso, ossia dal numero più alto a quello più basso, utilizzando la parola chiave downto al posto di to. In questo caso ad ogni ripetizione del ciclo la variabile verrà decrementata invece che incrementata.

Program Esempio2;
Uses Crt,WinDos;
Var nome1,nome2,stringa:string;
  file1,file2:text;
begin
  clrscr;
  write('Inserire il nome di un file: ');
  readln(nome1);
  write('Inserire il nome del file copia: ');
  readln(nome2);
  Assign(file1,nome1);
  Assign(file2,nome2);
  Reset(file1);
  Rewrite(file2);
  repeat
    readln(file1,stringa);
    writeln(file2,stringa);
  until eof(file1);
  Close(file1);
  Close(file2);
  writeln('Copia completata!');
  readln
end.

Assign(file1,nome1): Questa specifica assegna alla variabile file 1 di tipo testo il nome del file contenuto nella stringa nome1.

Occorre precisare come il linguaggio Pascal tradizionale utilizza i nomi dei file. Un nome può essere composto al massimo da 8 caratteri, estensione esclusa. Se il nome supera gli 8 caratteri viene troncato a 6 e si aggiunge un ~1 (il codice ASCII della tilde, ~, è 126). Perciò il nome testouno.txt è corretto e viene mantenuto inalterato. Invece, testoquattro.txt è sbagliato e il compilatore produrrà messaggio di errore (error 2: File not found); testoq~1.txt è la versione corretta dell'esempio precedente: i caratteri vengono troncati a 6 e aggiunto un ~1.

Reset(file1);: l'istruzione reset(x), dove x è una variabile inizializzata con Assign e di tipo text o file, serve per aprire il file x, in vista di operazioni di lettura/scrittura su di esso.

Rewrite(file2);: valgono le stesse regole di reset. Rewrite(x:text o file) è una procedura che crea un nuovo file x (se non è specificata la directory nel suo nome, viene creato nel percorsocorrente). Se esiste già un file di nome x, lo sovrascrive.

repeat...until eof(file1);: ripete un ciclo di istruzioni finché l'espressione indicata dopo until è vera. Nel nostro caso, il programma continua a leggere, riga per riga, ogni sequenza di caratteri contenuta in file1 e la copia in file2, finché la variabile reimpostata eof (che significa End Of File; supporta solo parametri di tipo text o file) non è vera, e quindi il file da cui leggere è al termine.

Close(file1);: la procedura close chiude un file.

Come si è ben visto, il ciclo repeat ... until serve per ripetere un'istruzione o un blocco di istruzioni fino a che una condizione non è vera. Non serve racchiudere il blocco di istruzioni fra un begin e un end, poiché i confini del blocco sono già definiti da repeat e until.

Program esempio3;
Uses Crt;
Var x,y:word;
 
begin
  clrscr;
  write('Inserire due coordinate: ');
  readln(x,y);
  while (x<>0) and (y<>0) do
    begin
      read(x,y);
      gotoxy(x,y);
      write((,x,;,y,));
    end;    
  readln
end.

Questo programma legge da tastiera due coordinate, sposta il cursore a quelle date coordinate e scrive in quel punto le ascisse e le ordinate tra parentesi, separate da un punto e virgola. Il ciclo si ripete ogni volta che la condizione indicata è vera: in questo caso quando sia x che y sono diversi da 0.

La procedura gotoxy(x,y:word) sposta il cursore alle coordinate $(x;y)$ sullo schermo.

Anche con while è opportuno prestare attenzione ai cicli infiniti e si noti che con while è necessario includere il blocco di istruzioni fra begin ed end.

Note

^ (EN) IEEE Computer Society, The Art of Teaching Computer Science: Niklaus Wirth, su computer.org.
^ Kathleen, Wirth, Niklaus Jensen, Pascal User Manual and Report - ISO Pascal Standard, New York, Springer-Verlag, 1974, ISBN 978-3-540-90144-0.
^ (EN) What language was “standard” for Apple development before Objective C?, su softwareengineering.stackexchange.com.
^ (EN) The Secret Origin of Windows, su technologizer.com.
^ Free Pascal - Un compilatore Pascal Open Source avanzato per Pascal e Object Pascal
^ Lazarus Project :: Write once compile everywhere!
^ Bloodshed Software - Providing Free Software to the Internet community

Bibliografia

Flavio Waldner, Impariamo il Pascal, Gruppo Editoriale Jackson, 1981.
Pierre Le Beux, Introduzione al Pascal, Gruppo Editoriale Jackson, 1982, ISBN 88-7056-118-6.
Olivier Lecarme e Jean-Louis Nebut, Pascal - Guida per programmatori, McGraw-Hill, 1985, ISBN 88-7700-602-1.
Daniel-Jean David e Jean-Luc Deschamps, Programmare in Pascal, Gruppo Editoriale Jackson, 1982, ISBN 88-7056-116-X.
Kathleen Jensen e Niklaus Wirth, Pascal - Manuale e standard del linguaggio, Gruppo Editoriale Jackson, 1981.
Kenneth L. Bowles, Soluzioni di problemi con Pascal, Gruppo Editoriale Jackson, 1982, ISBN 88-7056-110-0.