b'\n_START_ARTICLE_\nPascal (linguaggio di programmazione)\n_START_SECTION_\nStoria\n_START_PARAGRAPH_\nPare che Wirth, docente di programmazione negli anni Sessanta, avvert\xc3\xac 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\xc3\xb2, Wirth cre\xc3\xb2 da zero il linguaggio Pascal, inserendovi il concetto di programmazione strutturata._NEWLINE_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", considerato il riferimento standard per il linguaggio. TeX e parte delle prime versioni del sistema operativo del Macintosh e di Microsoft Windows furono scritte in Pascal._NEWLINE_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\xc3\xa0 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\xc3\xa0 di scrittura del codice al costo della possibilit\xc3\xa0 di rendere pi\xc3\xb9 arduo rilevare errori di struttura e sintassi. _NEWLINE_Il Pascal \xc3\xa8 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\xc3\xa0 di Embarcadero).\n_START_SECTION_\nCaratteristiche\n_START_PARAGRAPH_\nLe 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 \xc3\xa8 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 sezionetype. Permette anche l\'uso dei puntatori e l\'allocazione dinamica della memoria (specifiche new e dispose), in modo comunque pi\xc3\xb9 controllato per esempio del linguaggio C tradizionale._NEWLINE_Il Pascal \xc3\xa8 classificato come linguaggio semidinamico, in quanto gestisce i puntatori, permettendo di creare liste di variabili di dimensione non nota all\'atto della compilazione, ma possono essere di un solo tipo alla volta, quello usato per definire la variabile puntatore stessa. Al posto delle subroutine, di uso comune nei primi linguaggi di programmazione, il Pascal introduce procedure e funzioni, che estendono il concetto di subroutine incapsulando al loro interno le variabili e i dati locali. Inoltre, 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 \xc3\xa8 comunque scoraggiato l\'uso.\n_START_SECTION_\nHello, world!\n_START_PARAGRAPH_\nIl seguente esempio stampa a video il testo "Hello world"._NEWLINE_program hello;  _NEWLINE_uses crt;              <----non obbligatoriabegin_NEWLINE_  clrscr;              <----non obbligatoria_NEWLINE_  writeln(\'Hello World\');_NEWLINE_  readln;end._NEWLINE_Note 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\xc3\xa9 spazi._NEWLINE_La terza riga contiene l\'istruzione begin, usata per iniziare a scrivere il programma vero e proprio._NEWLINE_La quinta riga contiene l\'istruzione writeln, usata per scrivere a video il testo ("Hello World") 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._NEWLINE_Quando verr\xc3\xa0 premuto il tasto invio, il programma proceder\xc3\xa0 eseguendo l\'istruzione end, che pone fine alla sequenza._NEWLINE_Tale comando \xc3\xa8 l\'unico, in ambiente Pascal, ad essere seguito da un punto anzich\xc3\xa9 da un punto e virgola.\n_START_SECTION_\nPuntatori\n_START_PARAGRAPH_\nSi possono specificare puntatori a variabili usando nella dichiarazione un nome seguito dal simbolo ^ che precedete il tipo di variabile a cui deve puntare il puntatore. I puntatori funzionano come in C/C++:_NEWLINE_var_NEWLINE_  pointer : ^int;_NEWLINE_  number : int;begin_NEWLINE_  number := 10;_NEWLINE_  pointer := @number;end._NEWLINE_In questo modo pointer punter\xc3\xa0 a number._NEWLINE_Mentre per assegnare un valore allo spazio di memoria indirizzato da pointer, si user\xc3\xa0 ^ in coda al nome, ovvero come operatore di dereferenziazione:_NEWLINE_pointer^ := 15;\n_START_SECTION_\nInput e output\n_START_PARAGRAPH_\nL\'input di dati da tastiera viene effettuato tramite l\'utilizzo del comando readln(nome_variabile)._NEWLINE_L\'output invece usa il comando writeln(nome_variabile); la stampa a video usa lo stesso il comando writeln, per\xc3\xb2 il testo \xc3\xa8 tra singoli apici \' \' (writeln(\'ciao mondo\');)_NEWLINE_Esistono anche le due funzioni write() e read() che differiscono dalle precedenti per il fatto che non scrivono un codice di "ritorno a capo" (carriage return) a fine riga._NEWLINE_Un esempio di I/O di numeri interi:_NEWLINE_program input_output(input, output);var _NEWLINE_     n1,n2,ris:integer;               {Dichiarazione tipo intero}begin_NEWLINE_     writeln(\'Inserisci n1\');         {viene visualizzato il testo tra \' \'}_NEWLINE_     readln(n1);                      {comando di input, la variabile introdotta viene inserita in n1}_NEWLINE_     writeln(\'Inserisci n2\');_NEWLINE_     readln(n2);_NEWLINE_     ris:=n1+n2;                      {fa la somma di n1 e n2 e il risultato viene inserito in ris}_NEWLINE_     writeln(\'La somma e\'\' uguale a \',ris);     {stampa il messaggio tra \' \' e la variabile ris}_NEWLINE_     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\xc3\xa0.}end._NEWLINE_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_NEWLINE_program input_output(input, output);var   n1,n2,ris:real;                  {Dichiarazione tipo reale}begin_NEWLINE_     writeln(\'Inserisci n1\');         {viene visualizzato il testo tra \' \'}_NEWLINE_     readln(n1);                      {comando di input, la variabile introdotta viene messa in n1}_NEWLINE_     writeln(\'Inserisci n2\');_NEWLINE_     readln(n2);_NEWLINE_     ris:=n1+n2;                      {fa la somma di n1 e n2 e il risultato viene messo in ris}_NEWLINE_     writeln(\'La somma e\'\' uguale a \',ris:6:2);  _NEWLINE_{stampa il messaggio tra \' \' e la variabile ris, con 6 numeri prima della "," , la "," stessa e 2 dopo}_NEWLINE_     readln;end._NEWLINE_Nella stampa a video abbiamo usata un\'alterazione del comando writeln, aggiungendo var:n:m dove var \xc3\xa8 il nome della variabile da visualizzare, n \xc3\xa8 il numero di cifre complessive (compresa la ",") da visualizzare e m sono quelle dopo la virgola. Se ci sono pi\xc3\xb9 cifre da visualizzare di quelle indicate, esse non vengono inviate sul dispositivo di uscita._NEWLINE__NEWLINE_I/O caratteri: l\'input e l\'output di caratteri (numeri, lettere, simboli), \xc3\xa8 lo stesso per caratteri e numeri interi:_NEWLINE_program input_output(input, output);var   ch:char;               {Dichiarazione tipo carattere}begin_NEWLINE_     writeln(\'Inserisci il carattere\');         {viene visualizzato il testo tra \' \'}_NEWLINE_     readln(ch);                      {comando di input, la variabile introdotta viene messa in ch}_NEWLINE_     writeln(\'Il carattere inserito e\'\' \',ch);     {stampa il messaggio tra \' \' e la variabile ch}_NEWLINE_     readln;end._NEWLINE_I/O stringhe: le variabili stringhe come gi\xc3\xa0 detto sono array di char (vettori di caratteri).\n_START_SECTION_\nAlternative\n_START_PARAGRAPH_\nProgram alternativa;var _NEWLINE_   n:integer;begin_NEWLINE_ write(\'inserisci un numero: \');_NEWLINE_ readln(n);_NEWLINE_ if n > 0     {controlla se il valore \xc3\xa8 positivo}_NEWLINE_  then_NEWLINE_    write(\'il numero e\'\' positivo.\')_NEWLINE_  else_NEWLINE_    write(\'il numero e\'\' negativo.\');_NEWLINE_ readln;end.\n_START_SECTION_\nIterazione\n_START_PARAGRAPH_\nI seguenti frammenti di codice riportano un esempio dei cicli di iterazione in linguaggio Pascal._NEWLINE_Program ciclo_for;var i, n, num:integer;begin_NEWLINE_ write(\'quanti numeri vuoi inserire?\');_NEWLINE_ readln(n);_NEWLINE_ for i:=1 to n do_NEWLINE_  begin_NEWLINE_   write(\'inserisci il numero: \');_NEWLINE_   readln(num);_NEWLINE_  end;_NEWLINE_ readln;end._NEWLINE_Dopo la specifica for, occorre l\'assegnazione di un valore a una variabile (in questo caso i:=1). Questa variabile verr\xc3\xa0 incrementata automaticamente ad ogni ripetizione del ciclo, ovvero del codice indicato dopo for tra do e end: una volta uguale al numero (o alla variabile) dopo il to, il ciclo terminer\xc3\xa0._NEWLINE_Il valore di una variabile pu\xc3\xb2 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._NEWLINE_Il ciclo for...to...do ripete un blocco di istruzioni un numero determinato di volte, perci\xc3\xb2 sono vietati valori reali decimali prima e dopo il to, e le variabili da utilizzare dovranno sempre essere state dichiarate di tipo intero (integer)._NEWLINE_Si pu\xc3\xb2 eseguire un ciclo for..to..do anche in ordine inverso, ossia dal numero pi\xc3\xb9 alto a quello pi\xc3\xb9 basso, utilizzando la parola chiave downto al posto di to. In questo caso ad ogni ripetizione del ciclo la variabile verr\xc3\xa0 decrementata invece che incrementata._NEWLINE_Program Esempio2;Uses Crt,WinDos;Var nome1,nome2,stringa:string;_NEWLINE_ file1,file2:text;begin_NEWLINE_ clrscr;_NEWLINE_ write(\'Inserire il nome di un file: \');_NEWLINE_ readln(nome1);_NEWLINE_ write(\'Inserire il nome del file copia: \');_NEWLINE_ readln(nome2);_NEWLINE_ Assign(file1,nome1);_NEWLINE_ Assign(file2,nome2);_NEWLINE_ Reset(file1);_NEWLINE_ Rewrite(file2);_NEWLINE_ repeat_NEWLINE_  readln(file1,stringa);_NEWLINE_  writeln(file2,stringa);_NEWLINE_ until eof(file1);_NEWLINE_ Close(file1);_NEWLINE_ Close(file2);_NEWLINE_ writeln(\'Copia completata!\');_NEWLINE_ readlnend._NEWLINE_Assign(file1,nome1): Questa specifica assegna alla variabile file 1 di tipo testo il nome del file contenuto nella stringa nome1._NEWLINE_Occorre precisare come il linguaggio Pascal tradizionale utilizza i nomi dei file. Un nome pu\xc3\xb2 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, ~, \xc3\xa8 126). Perci\xc3\xb2 il nome testouno.txt \xc3\xa8 corretto e viene mantenuto inalterato. Invece, testoquattro.txt \xc3\xa8 sbagliato e il compilatore produrr\xc3\xa0 messaggio di errore (error 2: File not found); testoq~1.txt \xc3\xa8 la versione corretta dell\'esempio precedente: i caratteri vengono troncati a 6 e aggiunto un ~1._NEWLINE_Reset(file1);\xc2\xa0: l\'istruzione reset(x), dove x \xc3\xa8 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._NEWLINE_Rewrite(file2);\xc2\xa0: valgono le stesse regole di reset. Rewrite(x:text o file) \xc3\xa8 una procedura che crea un nuovo file x (se non \xc3\xa8 specificata la directory nel suo nome, viene creato nel path corrente). Se esiste gi\xc3\xa0 un file di nome x, lo sovrascrive._NEWLINE_repeat...until eof(file1);\xc2\xa0: ripete un ciclo di istruzioni finch\xc3\xa9 l\'espressione indicata dopo until \xc3\xa8 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\xc3\xa9 la variabile reimpostata eof (che significa End Of File; supporta solo parametri di tipo text o file) non \xc3\xa8 vera, e quindi il file da cui leggere \xc3\xa8 al termine._NEWLINE_Close(file1);\xc2\xa0: la procedura close chiude un file._NEWLINE_Come si \xc3\xa8 ben visto, il ciclo repeat ... until serve per ripetere un\'istruzione o un blocco di istruzioni fino a che una condizione non \xc3\xa8 vera. Non serve racchiudere il blocco di istruzioni fra un begin ed un end, poich\xc3\xa9 i confini del blocco sono gi\xc3\xa0 definiti da repeat e until._NEWLINE_Program esempio3;Uses Crt;Var x,y:word;_NEWLINE_ _NEWLINE_begin_NEWLINE_ clrscr;_NEWLINE_ write(\'Inserire due coordinate: \');_NEWLINE_ readln(x,y);_NEWLINE_ while (x<>0) and (y<>0) do_NEWLINE_  begin_NEWLINE_   read(x,y);_NEWLINE_   gotoxy(x,y);_NEWLINE_   write((,x,;,y,));_NEWLINE_  end;    _NEWLINE_ readln;end._NEWLINE_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._NEWLINE_Il ciclo si ripete ogni volta che la condizione indicata \xc3\xa8 vera: in questo caso quando sia x che y sono diversi da 0._NEWLINE_La procedura gotoxy(x,y:word) sposta il cursore alle coordinare (x;y) sullo schermo._NEWLINE_Anche con while \xc3\xa8 opportuno prestare attenzione ai cicli infiniti e si noti che con while \xc3\xa8 necessario includere il blocco di istruzioni fra begin ed end;'