Pascal/Strumenti

Wikibooks, manuali e libri di testo liberi.
Jump to navigation Jump to search

Compilatori[modifica]

I compilatori eseguono la traduzione del linguaggio Pascal in linguaggio macchina, creando cosi un file eseguibile.
A fianco a quelli a pagamento offerti dalla Borland sono sempre più diffusi compilatori gratuiti e open-source, sviluppati inizialmente per ambienti Linux.

  • A pagamento
    • Borland Pascal
    • Borland Delphi

Problemi di compatibilità[modifica]

L'uso di differenti compilatori può far sorgere alcuni problemi di incompatibilità tra versioni, non tanto comunque per quanto riguarda il linguaggio vero e proprio.

Ad esempio, il compilatore di Delphi (che serve per creare applicazione normalmente basate su un'interfaccia grafica) necessita della direttiva di compilazione

{$APPTYPE CONSOLE}

da porre subito dopo l'intestazione del programma, la quale specifica che il programma è da eseguire in un'interfaccia solo testo della console.

Inoltre, sempre per quanto riguarda l'uso di Borland Delphi, non è necessario eseguire alcune operazioni come la cancellazione dello schermo, in quanto ciò viene fatto in automatico all'avvio del programma da esso compilato.

A seconda della versione più o meno recente del compilatore, il tipo di dato integer supporta una gamma di valori più vasta di -32.768...32.767

IDE[modifica]

IDE è l'acronimo per Integrated Development Environment, che significa ambiente di sviluppo integrato.
L'IDE è un particolare software che facilita il programmatore nella stesura, nella compilazione e nella distribuzione del programma. Un tipico esempio di aiuto offerto da un IDE è l'evidenziazione della sintassi e l'individuazione di semplici errori di sintassi prima della compilazione.

  • A pagamento
    • Borland Delphi
    • Borland Turbo Pascal

Da notare che Borland Delphi e Lazarus sono IDE di Delphi, ovvero un'evoluzione del Pascal orientata ad oggetti; riescono tuttavia a compilare senza problemi il Pascal normale.

Compilare i propri sorgenti[modifica]

Abbiamo visto in precedenza il concetto di compilatore: la sua funzione è quella di tradurre il linguaggio Pascal in un linguaggio comprensibile al computer (linguaggio macchina).
Il processo della compilazione può avere esito positivo come può fallire a causa di errori di compilazione, cioè errori di sintassi o di grammatica nel linguaggio Pascal. Questi errori sono generalmente segnalati dai compilatori con messaggi del tipo:

Error on line 17: ';' expected but variable found

Questo è un errore che vi potrà capitare molto spesso, e segnala la mancanza di un punto e virgola alla fine di un'istruzione.
Il compilatore non conclude la compilazione fino a che il listato non presenterà errori.

Su sistemi operativi Linux una buona soluzione consiste nell'uso di Free Pascal. Per compilare un sorgente sono sufficienti pochi comandi di console; innanzitutto è necessario spostarsi nella directory in cui è presente il sorgente, successivamente basta eseguire le istruzioni:

> fpc nome_sorgente.pas
... il programma fornisce indicazioni sul compilatore, sul file
    e sugli eventuali errori di compilazione riscontrati ...

Potremo eseguire il programma digitando:

> ./nome_sorgente

Su Windows l'uso di Free Pascal da riga di comando risulta identico dal prompt dei comandi tranne per l'esecuzione del file, che viene fatta nella forma

> nome_sorgente.exe

L'uso degli IDE semplifica molto questi processi. Generalmente è possibile individuare nella barra dei menu di questi programmi voci come Compile -> Compile oppure Run -> Run (esegue il programma) oppure Compile -> Run.

Alcuni esempi commentati[modifica]

Questo è un programma che, dato un numero, ne calcola la radice quadrata (senza l'uso della funzione sqrt, ovviamente) usando una regola spiegata durante l'esecuzione del programma.
Il cuore dell'algoritmo è un ciclo ripeti... sino a quando che, oltre a calcolare le approssimanzioni, stampa anche una tabella passo per passo dei calcoli effettuati

program radq;
uses crt;
 {$APPTYPE CONSOLE} {in alcuni compilatori è superfluo}
 const eps=1E-10;
 var  num, app: real;
begin
 clrscr;
 write('Questo programma si basa sulla regola di Newton');
 writeln(' riguardante le radici quadrate, secondo la quale ');
 writeln;
 writeln('     se app e'' un'' approssimazione della radice quadrata di num');
 writeln('     allora (num/app + app)/2 e'' un''approsimazione migliore.');
 writeln;
 write('Il programmera continuera'' a calcolare un''approssimazione migliore');
 writeln(' sino a quando non varra''' );
 writeln;
 writeln('     |num/app^2 - 1| < 10^-10');
 writeln;
 writeln('Introdurre il valore del numero num di cui si vuole calcolare la radice quadrata e della prima approssimazione app');
 writeln;
 write('     '); readln(num);
 write('     '); readln(app);
 writeln;
 if num < 0 then
  writeln(num:10:2, ' non ha radice quadrata reale')
 else
 begin
  {stampa una piccola tabella}
  writeln('         app                          app^2');
  writeln;
  repeat
   writeln(app:20:10, app*app:30:10); {stampa la riga}
   app:=(num/app +app)/2; {calcola la successiva approssiamazione}
  until abs(num/ sqr(app) -1) < eps; {se il valore non differisce troppo da quello reale}
  writeln;
  writeln(app:20:10, app*app:30:10); {stampa l'ultima approssimazione contente il valore definitivo della radice quadrata}
 end;
 readln; {in alcuni compilatori è superfluo}
end.

Il seguente esempio è un programma che permette invece di simulare il lancio di un oggetto con velocità e posizione iniziale scelte dall'utente; per fare ciò si ricorre all'uso della libreria graph, a cui è stata dedicata una sezione nel corso del libro.
Come per il programma precedente, bisognerà adattare alcune opzioni in base al compilatore in uso.
Il cuore del programma è qui la procedura lancio, che calcola man mano le posizioni dell'oggetto lanciato e le disegna sullo schermo grafico.

program lanci;
uses crt, graph;
{i tipi word e double sono estensioni dei tipi di dati rispettivamente integer e real}
{funzionano in modo analogo ma hanno un range di dati diverso}
var t,v0,x0, y0:double; a:real;
    s,m:smallint;
    c:word;
    r:char;
const g = 9.8;
 
{questa procedura serve a cambiare sempre i colori}
procedure move_color (pos:smallint);
begin
    c:=c+pos;
    setcolor(c mod getmaxcolor);
end;
 
 
procedure lancio (v0, x0, y0 :double; a:real; delay_time:integer);
{longint è un'estensione degli integer ma con più range}
var y,x, vx, vy, t:double;
    xi, yi:smallint;
begin
    a:=pi() * a / 180;
    vx := v0 * cos(a);
    vy := v0 * sin(a);
    {è necessario troncare i valori perché la grafica funziona solo con valori interi}
    moveto(trunc(x0), getmaxy-1-trunc(y0));
 
    move_color(1);
 
    repeat
    begin
     y:=vy * t-( g/2 * t* t)+y0;
     x:=vx * t+x0;
     {0,0 corrisponde all'angolo in alto a sinistra, noi vogliamo quello in basso a sinistra}
     {per questo invertiamo il valore della y secondo getmaxy}
     yi:=trunc(getmaxy-y);
     xi:=trunc(x);
     move_color(1);
     lineto(xi,yi);
     move_color(-1);
     circle(xi,yi,20);
     t:=t+0.25;
     delay(delay_time);
    end;
    until (yi > getmaxy); {fino a quando la "pallina" non esce dallo schermo}
 
    writeln('Lancio terminato. Premere un tasto per continuare');
    readkey;
end; {lancio}
 
begin
    s:=detect;
    initgraph(s,m,''); {ovviamente bisogna cambiare la directory}
    directvideo:= true;
 
    repeat
    clrscr;
    begin
     writeln('       SIMULAZIONE DI LANCI INCLINATI');
     {stampa un piccolo menu}
     writeln; writeln;
     writeln('   L. Nuovo lancio');
     writeln('   C. Cancella schermo grafico');
     writeln('   E. Esci dal programma');
     writeln;writeln;
     write('               Selezionare un''opzione -> '); readln(r);
     {le diverse opzioni...}
     case r of
      'L', 'l':
      begin
         clrscr;
         writeln('Introdurre i valori della velocita'' iniziale v0 (espressa in m/s)');
         writeln('della misura in gradi dell''angolo di inclinazione del lancio dal suolo');
         writeln('e della posizione (x, y) iniziale del lancio');
         write('  v0      = '); readln(v0);
         write('  ang (ø) = '); readln(a);
         write('  x0      = '); readln(x0);
         write('  y0      = '); readln(y0);
         {legge le opzioni e chiama la procedura lancio}
         lancio(v0, x0,y0, a, 30);
      end;
      'c', 'C':
      begin
         {per cancellare lo schermo chiudiamo e riapriamo la sessione grafica}
         closegraph;
         s:=detect;
         initgraph(s,m,'');
         directvideo:= true;
      end;
     end; {case of}
    end; {until}
    until (r = 'e') or (r  = 'E');
    closegraph;
end.