DEIS - Università di Bologna - L I A - Laboratorio d'Informatica Avanzata

Progetti in RHIDE 1.4

Introduzione

Il concetto di progetto e' essenziale per poter lavorare in RHIDE, anche per poter compilare ed eseguire il piu' semplice dei programmi.

In estrema sintesi, un progetto e' una sorta di contenitore, che elenca i file C che fanno parte, appunto, di uno stesso progetto di lavoro. Nel caso piu' semplice, il progetto comprende un solo file, ma la sua utilita' si apprezza in particolare quando una applicazione e' costruita a partire da piu' files, che devono essere compilati e poi collegati insieme per dare luogo all'applicazione eseguibile finale.

L'ambiente RHIDE (come quasi tutti gli ambienti commerciali) sfrutta il concetto di progetto per gestire, nell'ambito del processo di costruzione di un'applicazione (make), la fase di collegamento (linking).
Infatti, mentre la fase di compilazione di un file sorgente riguarda il singolo file, la successiva fase di collegamento richiede, per definizione, di conoscere e avere disponibili tutti i file da collegare (incluse le librerie di sistema, anche se non esplicitamente indicate).
In questo ambito il progetto, elencando i file che fanno parte di uno stesso progetto di lavoro, costituisce un "contenitore logico" ideale.

RHIDE e i progetti

Appena avviato, RHIDE mostra una finestra vuota. Per iniziare a lavorare, la cosa migliore e' aprire un nuovo progetto. Per fare questo, basta scegliere la voce Apri dal menu' Progetto, e immettere un nome di progetto nuovo (cioe' non gia' utilizzato). Il nome deve avere l'estensione .gpr, ad esempio prova.gpr:

Ora occorre inserire nel progetto il file (o i file) che ne devono fare parte (non e' necessario che esistano gia'). Per aggiungere file al progetto, basta premere il tasto INS sulla tastiera, e selezionare (o digitare i nomi, per i file nuovi) i file da aggiungere, premendo OK volta per volta. A immissione terminata, premere cancel (annulla). Ad esempio, per aggiungere al progetto il file prova.c:

Fatto questo, il nome del file prova.c sara' listato nella finestra del progetto. Per aprire l'editor su quel file (per modificarlo se gia' esiste, o creare se inesistente) basta ora un doppio clic sul nome del file.

E' quindi possibile scrivere / modificare il file sorgente, avendo cura di salvarlo a intervalli regolari (si puo' usare allo scopo il tasto F2).

Compilazione ed esecuzione del programma

Quando il file e' pronto per la compilazione, scegliere Compila dall'omonimo menu': RHIDE mostrera' i comandi usati per invocare il compilatore GCC e le relative opzioni. Al termine, se non ci sono errori, si potra' passare alla fase di collegamento (linking).

IN ALTERNATIVA, le due fasi compilazione + collegamento possono essere svolte automaticamente da RHIDE, in sequenza, scegliendo la voce Make (costruisci) dal menu' Compile.

In assenza di errori di linking, il programma cosi' ottenuto e' pronto per l'esecuzione. Per eseguirlo, basta scegliere Run dal menu' omonimo, o digitare CTRL+F9: i risultati saranno osservabili nella finestra di uscita, visualizzabile o premendo ALT+F5 o scegliendo la voce User Screen dal menu' Windows. In entrambi i casi, un qualsiasi tasto riporta poi a RHIDE.

NOTA: al termine dell'esecuzione, l'ambiente visualizza una finestra informativa che mostra il "codice di ritorno" del programma. Questo e' semplicemente il valore restituito dalla funzione main() quando e' definita di tipo int, e ha significato solo quando il programma e' stato progettato per farne uso. Se, viceversa, main() e' stata dichiarata di tipo void, il valore mostrato e' casuale, e deve essere ignorato.

Alla fine, chiudere il progetto mediante l'apposita voce del menu' Project.

Esecuzione passo-passo del programma

Se il programma, pur compilandosi ed essendo possibile eseguirlo, non si comporta nel modo atteso, e' spesso molto utile poterne seguire il comportamento passo-passo, tenendo anche d'occhio, contemporaneamente, come evolvono le variabili piu' significative.

Tutto questo processo di analisi, noto come debugging, puo' essere eseguito interamente all'interno di RHIDE. Per fare questo, il programma deve essere gia' stato preventivamente costruito (compilato e collegato) senza errori.

Per eseguirlo passo passo (o in altro modo "controllato") sono disponibili vari comandi entro il menu' Run:

Trace into (o tasto F7): esegue il programma passo-passo, entrando anche dentro alle singole funzioni chiamate;
Step over (o tasto F8): esegue il programma passo-passo, ma eseguendo "in un sol colpo" le chiamate di funzione, come se fossero una singola istruzione (cio' e' utile quando si sa che la funzione e' corretta, e non occorre seguirne l'esecuzione passo-passo);
Go to cursor (o tasto F4): esegue il programma in un sol colpo fino alla posizione corrente del cursore: li' si ferma, e da li' si potra' continuare passo-passo (cio' e' utile quando una prima parte del programma e' gia' stata verificata, e non interessa ri-seguirla passo-passo nuovamente).

Da notare che l'esecuzione passo-passo opera per righe: quindi, a ogni pressione di F7/F8 verranno eseguite tutte le istruzioni sulla stessa riga, e si passera' poi alla riga successiva. La prossima riga da eseguire e' evidenziata in azzurro. In conseguenza di questo modo di procedere, l'evidenziazione azzurra saltera' sistematicamente le righe contenenti commenti, o comunque non associabili ad almeno una istruzione.

Quindi, ad esempio, eseguendo passo-passo il nostro programma di prova (premendo F7), la riga azzurra si portera' sulla riga della printf(); ripremendo F7, la printf() verra' eseguita, e la riga azzurra si portera' sulla parentesi graffa di chiusura. Una ulteriore pressione di F7 causera' l'uscita dal programma e la conseguente scomparsa della riga azzurra.
NOTA: se, a ogni pressione di F7, si preme ALT+F5 per verificare cosa accade nella finestra di uscita, si potra' constatare come la scritta "ciao mondo" venga in effetti emessa alla fine del programma. Cio' e' dovuto al fatto che la stringa di formato di printf() non comprende il carattere di "a capo", \n, e quindi i caratteri stampati restano nel buffer di uscita fino a quando il termine del programma non ne forza la stampa. Se il programma venisse modificato cambiando la printf("ciao mondo") in printf("ciao mondo\n"), la stampa apparirebbe in uscita subito dopo l'esecuzione della riga contenente la printf().

Al termine del programma, per rieseguirlo da capo occorre prima "resettarlo", cioe' riportare concettualmente all'inizio il contatore di programma che indica la prossima istruzione da eseguire.
Cio' puo' essere fatto scegliendo l'apposita voce nel menu' Run (o premendo CTRL+F2).

Osservazione delle variabili del programma

Durante l'esecuzione passo-passo, spesso e' necessario poter seguire l'evoluzione delle principali variabili del programma. Per fare questo, esse devono prima essere "messe sotto osservazione", tramite il concetto di watch. Questa opzione e' disponibile, insieme a varie altre, sotto il menu' Debug.

Scegliendo questa opzione (o premendo l'equivalente combinazione CTRL+F7), apparira' una finestrina che chiedera' di introdurre l'espressione da "tenere d'occhio". Solitamente, tale espressione sara' semplicemente il nome di una variabile. Nel nostro esempio, non essendoci variabili, cio' e' inutile: ma in altri casi e' di estrema utilita'. Si veda ad esempio il seguente programma modificato:

Questa opzione e' molto utile anche per comprendere bene il significato di ambito di visibilita' di una variabile.

Le altre opzioni del menu' Debug consentono rispettivamente:

di predisporre dei breakpoint, cioe' dei "punti di fermata" del programma. Questa possibilita' e' utile quando il programma e' voluminoso, e la sua completa esecuzione passo-passo e' improponibile. In questo modo, invece, il programma puo' essere lanciato normalmente con Run, ma si fermera' comunque in corrispondenza dei "punti di fermata" prefissati. Esistono quindi comandi nel menu' Debug per togliere/inserire breakpoint, e per visualizzare quelli attivi e le loro caratteristiche (tra l'altro i breakpoint possono essere condizionali, ossia provocare il blocco del programma solo in presenza di certe condizioni - ad esempio, se una certa variabile ha valore negativo, o nullo, etc.).
di valutare / modificare espressioni, in particolare valori di variabili. In questo modo e' possibile intervenire nel programma durante la sua esecuzione (ovviamente, in un momento di fermata), e leggere o cambiare " al volo" i valori delle variabili per "pilotare" l'esecuzione nel modo desiderato, o per simulare situazioni particolari.
di vedere i record di attivazione delle funzioni, osservando lo stato attuale dello stack delle chiamate. Ovviamente, quello che si vede dipende dal quando si guarda lo stack. In particolare, lo stack sara' sempre vuoto se il programma non e' in esecuzione. Quindi, questa opzione e' utile solo in abbinamento alla esecuzione passo-passo, e/o all'inserimento di breakpoint. Da notare come la prima funzione realmente chiamata non sia main(), ma una funzione di partenza inserita dall'ambiente.