1 L`AMBIENTE DI PROGRAMMAZIONE TURBO PASCAL

Transcript

L’AMBIENTE DI PROGRAMMAZIONE TURBO PASCAL ......................................... 2
LE COMPONENTI DELL’AMBIENTE DI SVILUPPO ...................................................................... 2
La barra dei menu ............................................................................................................ 2
Il desktop o finestra attiva ................................................................................................ 4
La linea di stato ................................................................................................................ 4
Uso delle caselle di dialogo.............................................................................................. 4
REALIZZAZIONE DI UN PROGETTO NELL’AMBIENTE TURBO PASCAL ......... 5
AVVIAMENTO DELL’AMBIENTE .............................................................................................. 6
APERTURA DI UN NUOVO FILE O DI UNO GIÀ ESISTENTE .......................................................... 6
SCRITTURA E/O MODIFICA DEL CODICE SORGENTE ................................................................. 6
SALVATAGGIO DEL FILE CON IL CODICE SORGENTE ................................................................ 7
STAMPA DEL LISTATO ............................................................................................................ 7
COMPILAZIONE E COLLEGAMENTO ......................................................................................... 8
ESECUZIONE .......................................................................................................................... 9
VERIFICA E CORREZIONE DEGLI ERRORI ................................................................................. 9
Esecuzione step by step..................................................................................................... 9
Esecuzione con interruzioni............................................................................................ 10
Comandi per il debugging .............................................................................................. 10
USCITA DALL’AMBIENTE...................................................................................................... 11
1
© 2003 RCS Scuola S.p.A. - Tramontana
IL PASCAL: Concetti di base del linguaggio

L’ambiente di programmazione Turbo Pascal
Nei primi compilatori Pascal, il programmatore per passare dal progetto astratto al codice finale, aveva a disposizione un editor di testi, un compilatore, un linker e un debugger posti in
programmi eseguibili separati. L’attività del programmatore risultava quindi complessa a causa dei continui passaggi da un ambiente all’altro dei diversi strumenti software.
Per agevolare il lavoro dei programmatori, alcune aziende produttrici di software hanno avuto
l’idea di riunire tutti gli strumenti precedenti in un unico ambiente integrato per lo sviluppo
(IDE: Integrated Development Environment) di programmi. In un IDE il programmatore, senza mai uscire dall’ambiente, può:
scrivere o richiamare un file sorgente;
salvare il file sorgente in un file di testo;
compilare il codice sorgente e collegarlo con altri sottoprogrammi;
eseguire il programma finale;
verificare nel codice la correttezza (testing) e correggere gli eventuali errori (debugging).
Il Turbo Pascal è un ambiente integrato per lo sviluppo di programmi scritti utilizzando il
linguaggio di programmazione Pascal.
L’ambiente di lavoro Turbo Pascal, prodotto dalla Borland, ha subito variazioni passando dalle diverse versioni dalla 1.0 fino alla 7.0, anche se le operazioni principali per la realizzazione
di un programma eseguibile restano però invariate da una versione all’altra. Nel seguito prenderemo come riferimento la versione 7.0.
Le componenti dell’ambiente di sviluppo
Per iniziare una sessione nell’ambiente di lavoro, nel sistema operativo MS-DOS (anche avviato con un
di Windows), si deve eseguire il programma TURBO.EXE
nel percorso dove è installato il programma Turbo Pascal, digitando:
L’ambiente di sviluppo è formato da tre parti grafiche:
la barra dei menu;
la finestra di edit o desktop (la scrivania);
la linea di stato
come indicato nella figura seguente.
La barra dei menu
L’ambiente mette a disposizione del programmatore un insieme di comandi organizzati in
menu; ogni comando consente di effettuare una operazione quale, ad esempio, l’apertura di un
2

nuovo file sorgente o la compilazione del codice. L’insieme dei menu (gruppi di istruzioni)
costituisce la barra dei menu, come indicato nella figura successiva.
significa che prima di eseguire
Per convenzione se un comando termina con tre punti
l’operazione verrà visualizzata una finestra di dialogo dove il programmatore deve introdurre
alcuni dati necessari all’esecuzione dell’operazione stessa. Il simbolo
indica invece
l’apertura di un menu successivo “flottante” (popup menu).
I menu sono organizzati in modo da contenere tutti i comandi relativi ad una specifica parte
della fase di realizzazione di un progetto software; in particolare i menu riguardano:
Come fare per...
gestire i file contenenti i programmi sorgente.
utilizzare l’editor di testo interno all’ambiente per la creazione del codice sorgente.
compilare un programma sorgente.
eseguire un codice.
verificare e correggere un programma sorgente.
modificare alcune caratteristiche dell’ambiente di lavoro.
gestire più di un solo programma sorgente, posti in finestre di edit diverse.
avere un aiuto (help) sui comandi dell’ambiente o sul linguaggio.
Menu
File
Edit, Search
Compile
Run
Debug
Tools, Options
Window
Help
Tutte le operazioni possono essere effettuate con la tastiera oppure con il mouse. Per eseguire
una operazione si deve:
con la tastiera
selezionare un menu nella barra con il tasto
ALT seguito dalla lettera evidenziata (tasto
scorciatoia o di scelta rapida) nel menu stesso;
con i tasti direzione, scegliere il comando nel
menu e premere RETURN.
con il mouse
fare clic sul menu nella barra per renderlo attivo;
fare clic sul comando selezionato.

I comandi più frequenti possono essere eseguiti direttamente premendo il tasto funzione riportato nella barra di stato.
Ad esempio, F2 consente di salvare il codice sorgente attuale, F3 apre una finestra di dialogo
per caricare un nuovo file sorgente dal disco, mentre ALT+F9 esegue l’operazione di compilazione.
3

Il desktop o finestra attiva
Il programmatore può considerare l’ambiente Turbo Pascal come il tavolo della sua scrivania
di lavoro, con la differenza che invece di avere un foglio e una matita ha a sua disposizione lo
schermo del video, la tastiera ed eventualmente il mouse.
Il codice sorgente è scritto in una zona dello schermo denominata finestra (window) di edit.
Vi possono essere diverse finestre con programmi sorgenti differenti, ma soltanto quella che
appare in primo piano è attiva, ovvero riceve i comandi impartiti dal programmatore. Per passare da una finestra all’altra si utilizzano i comandi del menu Window. La figura seguente presenta le parti associate ad una finestra di edit dell’ambiente.
Le operazioni più frequenti in una finestra di edit sono effettuate in questo modo:
Come fare per...
aprire una finestra.
chiudere una finestra.
Comando o oggetto della finestra
Si preme F3 oppure si seleziona il comando File | Open.
Si preme ALT+F3 o si fa clic sulla casella di uscita della finestra stessa
.
passare da una finestra attiva Si sceglie Window | List o ALT seguito dal numero che individua ogni
finestra.
ad un’altra.
ridimensionare una finestra. Si seleziona il comando Window | Size o si usa il pulsante di zoom
.
Si fa “clic” sulle barre di scorrimento con il mouse oppure si usano i
spostarsi lungo la finestra.
tasti direzione.
La linea di stato
Il Turbo Pascal ha un suo stato, visualizzato sulla linea o barra di stato. Le informazioni contenute in questa linea variano sulla base delle azioni che il programmatore sta svolgendo; in
particolare la linea di stato contiene:
i tasti funzione per la scelta rapida delle operazioni più frequenti;
l’operazione che si sta svolgendo (edit, compilazione, ecc.);
la descrizione del comando che si è selezionato, ad esempio:
Uso delle caselle di dialogo
Quando una operazione richiede per essere eseguita dei dati di ingresso (parametri e/o opzioni) aggiuntivi (simbolo
dopo il comando), questi sono introdotti dal programmatore mediante una finestra di dialogo.
4

Esempio
L’ambiente presenta la finestra di dialogo:
quando si seleziona il comando File | Save as... per salvare in un file di testo (non formattato)
il codice sorgente scritto nella finestra attiva.
L’uso di una finestra di dialogo avviene:
Come fare per...
spostarsi nella finestra di dialogo.
chiudere annullando l’operazione.
chiudere la finestra eseguendo
l’operazione con i dati digitati nelle caselle
di input.
Comando o oggetto della finestra di dialogo
Usare il mouse e fare clic nella casella di input scelta
oppure usare il tasto tabulatore TAB.
Selezionale il pulsante di azione Cancel.
Selezionale il pulsante di azione OK.
Realizzazione di un progetto nell’ambiente Turbo Pascal
Supponiamo di volere realizzare un programma eseguibile che stampi sullo schermo il mes. A tal fine, possiamo usare il seguente codice
saggio
sorgente:
PROGRAM PrimoProgramma;
CONST
Uscita = 'Entriamo nel mondo del Pascal!';
BEGIN
WRITELN(Uscita)
END.
Nel programma precedente:
il modello dei dati è costituito solo dalla costante stringa Uscita;
la parte eseguibile è formata dall’istruzione WRITELN, che visualizza sullo schermo il
contenuto della costante dichiarata nel modello dei dati.
Nell’ambiente Turbo Pascal per passare dal codice sorgente al programma finale eseguibile si
seguono le azioni:
1. avviamento dell'ambiente;
2. apertura di un nuovo file con il codice sorgente oppure di uno già esistente;
3. scrittura di un nuovo programma sorgente oppure modifica di un file già esistente;
4. salvataggio del nuovo codice, o delle modifiche, in un file di testo sul disco rigido o
flessibile;
5. eventuale stampa del listato del programma (per la documentazione);
5

6. compilazione e collegamento;
7. esecuzione del programma finale;
8. verifica (testing) e correzione degli errori (debugging);
9. uscita dall’ambiente Turbo Pascal.
Ognuna di queste operazioni è eseguita mediante opportuni comandi organizzati in modo logico nei menu dell’ambiente di sviluppo.
Avviamento dell’ambiente
Per avviare il programma si deve eseguire dalla linea del prompt di DOS il programma eseguibile TURBO.EXE.
Apertura di un nuovo file o di uno già esistente
Si utilizzano i comandi del menu File nel seguente modo:
Come fare per...
aprire una nuova finestra di testo.
aprire un file già esistente con il
codice sorgente.
Comando
Selezionare il comando File | New.
Eseguire il comando File | Open..., che con una finestra di dialogo richiede all’operatore di specificare il nome e il percorso
(unità e directory) dove è salvato il file.
Scrittura e/o modifica del codice sorgente
Il codice sorgente deve essere scritto nella finestra di editor attiva. I principali comandi per
l’edit di un file sorgente sono:
Come fare per...
introdurre una nuova linea.
passare dalla modalità inserimento
(Insert) a quella di sovrascrittura
(Overwrite) e viceversa.
indentare il testo.
annullare i risultati dell’ultimo comando eseguito.
muoversi lungo il testo.
Comando
Premere INVIO.
Premere il tasto INS.
Premere il tasto TAB.
Premere ALT+BACKSPACE oppure selezionare il comando Edit |
Undo (non fare).
Utilizzare i tasti direzione oppure con il mouse facendo clic sulle barre di scorrimento.
Con la tastiera: posizionarsi sul primo carattere e tenendo preselezionare un blocco di testo.
muto SHIFT spostarsi alla fine del blocco.
Con il mouse: fare clic sul primo carattere e trascinare il puntatore alla fine del blocco tenendo sempre premuto il tasto sinistro.
tagliare il blocco selezionato e co- Si prema SHIFT+DEL oppure si selezioni il comando Edit | Cut.
piarlo in un’area di memoria temporanea (clipboard).
cancellare un blocco selezionato. Premere CTRL+DEL oppure selezionare il comando Edit | Clear.
copiare il blocco selezionato nella Premere CTRL+INS oppure eseguire il comando Edit | Copy.
clipboard.
effettuare la ricerca di un testo nel Si selezioni il comando Search | Find... e si digiti nella successiva finestra di dialogo le parole cercate.
file.
6

Particolarmente utile è l’uso del tasto TAB che consente di spostare il cursore attivo di un numero di spazi definito. In tal modo, si possono far rientrare (indentare) le istruzioni all’interno
di una struttura di controllo, rendendo il codice sorgente più leggibile. Nel nostro esempio,
dopo la digitazione del programma sorgente, la finestra di edit appare nel seguente modo:
Salvataggio del file con il codice sorgente
Il programma sorgente deve essere salvato in modo permanente in un file di testo, di estensione PAS, con i comandi:
Come fare per...
Comando
salvare il codice sorgente in Selezionare il comando File | Save as..., che chiede all’operatore di
specificare il nome e il percorso dove memorizzare il nuovo file. Salun nuovo file.
vando il codice con nomi diversi, sempre con File | Save as..., si possono creare copie di riserva del medesimo file sorgente.
salvare le modifiche su un Eseguire il comando File | Save.
file già esistente.
E’ sempre conveniente organizzare i file su disco suddividendoli sulla base del tipo in
directory diverse.
Esempio
Tutti i file sorgenti possono essere memorizzati in una directory \SORGENTI, i file oggetto in
\OGGETTO, quelli eseguibili in \EXE, mentre tutti i file di Turbo Pascal possono essere posti
nella directory \BIN.
Nei menu delle diverse versioni di Turbo Pascal, è presente una opzione per selezionare i vari
percorsi per i diversi tipi di file; nella versione 7.0 il comando è Options | Directories...
Il programma sorgente dell’esempio è stato salvato con il comando File | Save as... con il nome PRIMO.PAS nella directory \TP7\SORGENTI\.
Dopo avere salvato o caricato un file già esistente, nella parte superiore della finestra di edit
compare il percorso e il nome del file che contiene il codice che si sta modificando.
In tal modo ogni finestra di edit è associata senza ambiguità ad un file sorgente Pascal.
Stampa del listato
E’ sempre conveniente conservare una copia del codice sorgente sia memorizzata su file sia
stampata su carta. Il comando Print del menu File stampa il listato del programma della finestra di edit sulla stampante collegata al calcolatore. Prima di effettuare una stampa si deve im7

postare il tipo di stampante disponibile all’interno dell’ambiente mediante la finestra di dialogo che si apre con l’opzione Printer setup... del menu File.
Compilazione e collegamento
Le operazioni di compilazione e di collegamento (linking) sono effettuate in modo automatico
all’interno dell’ambiente. Il programma eseguibile finale può avere due destinazioni:
la memoria centrale;
la memoria di massa, in genere il disco magnetico.
Quella predefinita è la memoria principale. Per modificare la destinazione si utilizza il comando Destination del menu Compile: in tal modo l’opzione
diventa
per indicare che il programma eseguibile sarà salvato sul disco.
Se si compila il programma finale in memoria, quando si chiude la sessione di lavoro, il programma è definitivamente perso, mentre se la destinazione è il disco esso verrà memorizzato
in modo permanente in un nuovo file eseguibile con lo stesso nome del programma sorgente,
ma con estensione EXE. Essendo la compilazione in memoria più veloce, è conveniente produrre il file eseguibile sul disco solo quando si è sicuri che il programma sorgente è privo di
errori.
Per compilare il codice sorgente della finestra di edit attiva si usa il comando Compile del
menu (omonimo) Compile oppure si digita la combinazione di tasti ALT+F9. Se non si sono
verificati errori durante l’operazione di compilazione e di collegamento viene visualizzata una
finestra di dialogo del tipo:
Viceversa il compilatore si arresta indicando al programmatore il primo punto dove è stato
trovato un errore. In alcuni casi, il compilatore “cerca di capire” il tipo di errore commesso e
fornisce quindi una indicazione sullo schermo.
Esempio
Se modifichiamo l’istruzione WRITELN in quella errata
la traduzione si arresta indicando il seguente errore:
che indica che si è utilizzato un comando non noto al compilatore (unknown).
8

Dopo la compilazione su disco, se si visualizza il contenuto della directory con il comando
DOS DIR si ottiene:
che dimostra la creazione del file con il programma eseguibile.
Esecuzione
Un programma può essere eseguito in due modi diversi, all’interno oppure all’esterno
dell’ambiente.
Il comando Run del menu Run (o CTRL+F9) effettua prima una compilazione e un linking del
codice sorgente contenuto nella finestra di edit ed in seguito lo esegue mediante il sistema operativo in una nuova finestra di output. Per visualizzare il contenuto di questa finestra si
deve digitare la combinazione di tasti ALT+F5, mentre per ritornare alla finestra di edit si deve
premere un tasto qualsiasi.
Se si è già eseguita una compilazione precedente e il codice non è stato modificato, questa istruzione non effettua nuovamente la traduzione mandando il programma direttamente in esecuzione. Nel nostro esempio, dopo avere eseguito il comando Run | Run dobbiamo digitare
ALT+F5 per visualizzare la finestra di output e quindi il risultato dell’esecuzione del programma:
Lo stesso programma, una volta compilato su disco, può essere eseguito con il DOS, digitando
al prompt dei comandi:
dopo essere usciti dall’ambiente Turbo Pascal.
Verifica e correzione degli errori
Il debugger dell'ambiente Turbo Pascal può funzionare in due modalità differenti denominate:
1. passo dopo passo (step by step);
2. con interruzioni (breakpoint).
Le modalità di esecuzione precedenti permettono al programmatore di analizzare il tracciato
del programma sorgente e del corrispondente algoritmo realizzato.
Esecuzione step by step
In questa modalità il programma è eseguito una linea alla volta, interrompendo il procedimento ad ogni passo, in modo che il programmatore possa controllare l’esecuzione tramite:
1. la visualizzazione del contenuto attuale delle variabili in quella linea;
2. la visualizzazione dell’output corrente del programma sullo schermo del video.
Il debugger del Turbo Pascal consente anche di modificare il valore delle variabili durante la
stessa esecuzione passo-passo.
9

Esecuzione con interruzioni
In questa modalità, il codice è eseguito fino ad un punto specifico, denominato di interruzione
(breakpoint) dove il programma si interrompe. Da questo punto in poi il programmatore può
scegliere se proseguire:
1. nel modo usuale, dopo avere controllato lo stato del programma e l’output sul video;
2. nella modalità step by step.
Questo modo di funzionamento è utile in tutti quei casi in cui si vuole ispezionare una specifica parte di codice, ad esempio, un richiamo ad un sottoprogramma e non l’intero modulo sorgente.
La visualizzazione del tracciato di un programma è una delle tecniche principali non solo per
l’attività di debugging, ma anche per l’apprendimento delle diverse tecniche di programmazione.
Comandi per il debugging
L’ambiente Turbo Pascal dispone di un programma di debug (integrato) che permette di realizzare le modalità di messa a punto analizzate in precedenza. Per il debugging si utilizzano i
seguenti comandi dell’ambiente:
Modalità step by step
Come fare per...
Comando dell’ambiente
Iniziare l’esecuzione step by Si utilizzano i comandi del menu Run:
Step over (o tasto funzione F8) che esegue il programma una listep.
nea alla volta (dopo averlo compilato interamente in memoria
centrale) considerando i sottoprogrammi (procedure e funzioni)
come un unico passo;
Trace into (o F7) che effettua il tracciamento sia del modulo
principale sia dei sottoprogrammi, dopo averli caricati in memoria.
Terminare la modalità debug. Si usa l’opzione Program reset del menu Run o CTRL+F2.
Proseguire un passo alla volta Nel menu Run, con il tasto funzione F7 (Trace) si esegue il tracciato
dell’intero programma avanzando, di una linea alla volta per ogni
nella modalità debug.
digitazione,
mentre con F8 (Step over) non si ha traccia
dell'esecuzione dei sottoprogrammi.
Modalità con interruzioni
Come fare per...
Nel menu Debug, utilizzare le opzioni Breakpoints... o Add breaInserire un breakpoint
kpoint..., che aprono una finestra di dialogo in cui si può definire o
aggiungere un nuovo punto di interruzione tramite il suo numero di
linea nel codice sorgente.
Trasferire il controllo al brea- Utilizzare i comandi del menu Run, Go to cursor (F4) oppure Run
(CRTL+F9). Se non si sono definiti punti di interruzione, l’opzione
kpoint inserito
Go to cursor inizia l’esecuzione dalla linea della finestra di edit dove è posizionato il cursore attivo.
Nel Turbo Pascal lo stato del programma è presentato mediante alcune finestre aggiuntive diverse da quella di edit, contenente il codice sorgente.
Le informazioni per la messa a punto sono organizzate nelle seguenti finestre:
di watch (di osservazione): consente di visualizzare il contenuto delle variabili aggiornato
al passo in cui è ferma l’esecuzione;
10

di output: presenta l’output sullo schermo utente, così come lo vedrebbe un operatore durante l’esecuzione effettiva;
di chiamata di sottoprogrammi: visualizza la successione di tutte le chiamate a procedure e/o funzioni con il valore dei parametri reali. I richiami ai sottoprogrammi sono presentati in ordine di chiamata in una lista in cui l’ultima procedura ad essere richiamata è posta
in cima alla pila.

Per la gestione dello stato del programma si usano i seguenti comandi dell’ambiente:
Come fare per...
Visualizzare il valore delle va- Il comando Watch del menu Debug apre una finestra “sullo stato del
programma”, denominata Watches. Premendo dalla tastiera ENTER
riabili.
oppure facendo doppio click con il mouse all’interno di Watches, si
apre una finestra di dialogo per l’input dell’identificatore della
variabile che si desidera visualizzare durante l'esecuzione passopasso del codice.
Presentare la finestra con lo Premendo ATL+F5 si visualizza solo lo schermo utente, mentre con
l’opzione Output del menu Debug si apre la finestra di output conschermo utente.
temporaneamente a quella di edit.
Visualizzare le chiamate ai Il comando Call stack del menu Debug, apre una finestra con una lista delle chiamate a procedure e/o funzioni con i valori degli argosottoprogrammi.
menti reali passati al momento della chiamata.
Modificare i valori delle va- Il comando Evaluate/Modify..., nel menu Debug, permette di modificare i valori delle variabili anche durante l’esecuzione del programriabili.
ma oppure di definire nuove espressioni.
Uscita dall’ambiente
E’ possibile uscire dall’ambiente Turbo Pascal in modo:
definitivo, ritornando al sistema operativo;
momentaneo, per eseguire comandi DOS.
Il comando Exit del menu File consente di uscire dal programma e ritornare sotto il controllo
del sistema operativo. Se prima di uscire non si sono salvate su file le modifiche apportate ad
alcune finestre di edit, Turbo Pascal richiede all’operatore mediante una finestra di dialogo di
effettuare il salvataggio.
In alcuni casi, durante l’attività di codifica, è necessario eseguire alcuni comandi DOS. Ad esempio, per creare una nuova directory si dovrebbe salvare il proprio lavoro, uscire
dall’ambiente, creare la directory ed infine rientrare.
Turbo Pascal consente di uscire solo temporaneamente dall’ambiente per eseguire istruzioni
MS-DOS mediante il comando File | DOS shell. Questa istruzione apre una nuova finestra,
contenente l’interprete dei comandi DOS, nella quale si possono eseguire le istruzioni del sistema operativo, terminate le quali si può ritornare nell’ambiente digitando al prompt del comandi
Alcune delle fasi di realizzazione di un programma possono essere compiute direttamente con
il sistema operativo.
Esempio
E' possibile:
11


visualizzare il file con il codice sorgente con il comando TYPE:

modificare
il
file
con
l’Editor
;
stampare il listato con l’istruzione PRINT:
12
di
DOS
digitando,
ad
esempio,
.