Pascal/Strumenti
Wikibooks, manuali e libri di testo liberi.
Indice |
[modifica] Compilatori
I compilatori eseguono la traduzione del linguaggio Pascal in linguaggio macchina, creando cosi un file eseguibile.
Affianco 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
- Open Source
- Free Pascal
- GNU Pascal
- DEV Pascal
[modifica] Problemi di compatibilità
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
[modifica] IDE
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
- Open Source
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.
[modifica] Compilare i propri sorgenti
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.
[modifica] Alcuni esempi commentati
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; {$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:integer; c:word; r:char; const g = 9.8; {questa procedura serve a cambiare sempre i colori} procedure move_color (pos:integer); 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:longint; 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,'H:\FPC'); {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,'H:\FPC'); directvideo:= true; end; end; {case of} end; {until} until (r = 'e') or (r = 'È); closegraph; end.
