WASCANA ECLIPSE MANUALE UTENTE - Università degli Studi di Modena e Reggio Emilia Paolo Piccinini

Università degli Studi di Modena
e Reggio Emilia

Paolo Piccinini

                  WASCANA ECLIPSE
                  MANUALE UTENTE
                  Corso di Fondamenti di Informatica 2010-2011

Sommario
Introduzione .......................................................................................................................................... 3
Installazione di Wascana Eclipse per Windows ........................................................................................ 4
Installazione di Wascana Eclipse per Mac OS X ........................................................................................ 7
Prima Esecuzione e Configurazione ......................................................................................................... 8
Tutorial 1: Creazione di una semplice applicazione .................................................................................. 9
      Step 1: Creazione del progetto .................................................................................................................. 9
      Step 2: Revisione del codice e building dell’applicazione ........................................................................ 11
      Step 3: Esecuzione dell’applicazione ........................................................................................................ 13
Tutorial 2: Creazione di un nuovo progetto ........................................................................................... 13
      Step 1: Creazione del progetto ................................................................................................................ 13
      Esecuzione con parametri ........................................................................................................................ 17
Debugging e Debugger ......................................................................................................................... 18
      Debugging ............................................................................................................................................... 18
      Debugger ................................................................................................................................................. 18
      Debugging in Wascana Eclipse ................................................................................................................ 19

Introduzione
Eclipse è un software di sviluppo multi – linguaggio che comprende un ambiente di sviluppo integrato
(Integrated Develpoment Environment - IDE) ed estendibile attraverso svariati plug-in. È stato scritto
principalmente in Java e può essere usato per sviluppare applicazioni in Java, e per mezzo di vari plug-in
anche per altri linguaggi come: C/C++, COBOL, COBOL, Python, Perl, PHP, Scala, Scheme e Ruby. L’IDE
prende il nome di Eclipse ADT per Ada, Eclipse CDT per C/C++, Eclipse JDT per Java e Eclipse PDT per PHP.

Wascana è un IDE C/C++ per Eclipse che contiene la MinGW GNU toolchain ed na selezione di librerie open
source che posso essere usate per lo sviluppo di applicazioni Windows.

Installazione di Wascana Eclipse per Windows
  1. Scaricare il software al seguente indirizzo:
     http://code.google.com/a/eclipselabs.org/p/wascana/downloads/detail?name=wascana-1.0-
     setup.exe

  2. Lanciare l’eseguibile wascana-1.0-setup.exe.

3. Nella schermata Welcome to the Wascana C/C++ IDE for Windows Setup Wizard selezionare Next
   e procedere alla schermata successiva.
4. Selezionare la cartella in cui si desidera installare l’ambiente di sviluppo.

5. Infine selezionare la cartella nella barra dei menu.

6. Completare l’installazione ed uscire dal Setup Wizard.

Installazione di Wascana Eclipse per Mac OS X
Download e installazione di Eclipse.

    1. Andare sul sito eclipse.org.
    2. Cliccare su Downloads.
    3. Cliccare su Eclipse IDE for C/C++ Developers.
    4. Nella sezione Download Links selezionare Mac OS X(Cocoa 32) oppure Mac OS X(Cocoa 64).
    5. Scaricare il software cliccando sull’icona di download. Il file da scaricare è solitamente compresso e
       dovrebbe avere un nome simile al seguente eclipse-cpp-helios-SR1-macosx-cocoa.tar.gz.
    6. Quando il download è stato completato, decomprimere l’archivio in una cartella arbitraria.
       L’installazione è così completata.
    7. Cliccare sull’icona Eclipse per lanciare l’ambiente di sviluppo.

Solitamente per sistemi Linux/Unix o Mac OS X il compilatore è già stato installato. Se non lo fosse, occorre
instllare il tool di sviluppo che si trova sul CD fornito con il computer al momento dell’acquisto o presso il
sito Apple's developer connection (http://connect.apple.com).

Prima Esecuzione e Configurazione
La prima volta che viene lanciato l’ambiente di sviluppo viene richiesto dove salvare i progetti che verranno
successivamente creati. È possibile scegliere la directory di volta in volta, ma è preferibile usare sempre la
stessa, perciò occorre selezionare il check box “Use this as the default and do no ask again”

Alla prima esecuzione, l’ambiente si apre con la finestra di benvenuto, tramite le quale è possibile esplorare
l’help on-line, i tutorials e vari esempi.

L’editor può essere personalizzato a piacere. Scegliendo Window > Preference si acceda a tutte le opzioni
di personalizzazione dell’ambiente.

IMPORTANTE: in laboratorio deve essere selezionata la propria unità di rete, per poter accedere al proprio
codice anche da una macchina diversa. Se il codice viene salvato su una particolare macchina e nella lezione
di laboratorio successiva si usa un macchina diversa il lavoro viene perso. Quindi è buona norma impostare
di default una cartella di destinazione all’interno della vostra unità di rete.

Tutorial 1: Creazione di una semplice applicazione
In questo tutorial useremo il CDT per creare la semplice applicazione “Hello World”. Questo tutorial
descrive come creare un nuovo progetto ANSI C in cui la compilazione ed il linking sono gestiti
automaticamente dal CDT.

Per creare il programmino “Hello World” con il CDT, occorre eseguire i seguenti passi:

Step 1: Creazione del progetto
   1. Selezionare File > New > C Project.

2. Scegliere il nome del progetto e selezionare Executable > Hello World ANSI C Project
3. Selezionare MinGW GCC dalla lista Toolchians.
4. Una volta impostati tutti i parametri precedenti selezionare Finish.

Step 2: Revisione del codice e building dell’applicazione

Questo è il frammento di codice che viene creato automaticamente.

   1. Si può aggiungere altro codice a questo file e salvare i cambiamenti cliccando su File > Save, o
      mediante shortcut CRTL+S.
      Successivamente occorre fare la build del progetto prima di eseguirlo.

2. Per fare la build del progetto premere CTRL+B, oppure dalla barra dei menu Project > Build
   Project. Se il building genera degli errori o dei warning, questi possono essere visualizzati in
   dettaglio nella tab Problems e localizzati facilmente all’interno del codice sorgente mediante l’icona
   di errore.

3. Leggere i messaggi nella tab Console. Il progetto dovrebbe essere stato compilato senza problemi.

Step 3: Esecuzione dell’applicazione
Per eseguire l’applicazione:

Dalla barra dei menu selezionare Run > Run AS > Local C/C++ Application.

A questo punto nella tab Console si dovrebbe vede l’applicazione Hello World funzionare. La Console
mostra anche quale applicazione è in esecuzione nella barra dei titoli.

Tutorial 2: Creazione di un nuovo progetto
Step 1: Creazione del progetto
   1. Selezionare File > New > C Project.

2. Scegliere il nome del progetto e selezionare Executable > Empty Project
3. Selezionare MinGW GCC dalla lista Toolchians.
4. Una volta impostati tutti i parametri precedenti selezionare Finish.

5. Creare la cartella in cui salvare il codice sorgente selezionando File > New > Source Folder.

6. Verificare che in Project name sia stato riportato il nome del progetto corretto e inserire il nome
   della cartella (in questo caso “src”) che verrà creata allo scopo di contenere i file sorgenti.

7. Creare il file sorgente selezionando File > New > Source File.

8. Attraverso il tasto Browse selezionare la cartella dei sorgenti creata in precedenza.
9. Inserire il nome del file da creare. Importante: occorre inserire il nome del file completo
   dell’estensione .c.

A questo punto si può scrivere il codice della propria applicazione. Per eseguire l’applicazione appena
creata seguire i passi dallo Step2 del Tutorial 1.

Esecuzione con parametri
La funzione main() è presente in tutti i programmi C ed è sempre eseguita per prima, tuttavia non è
necessario chiamarla dall'interno del programma. La chiamata a main() è contenuta in un object file, fornito
con il compilatore, che il linker collega automaticamente in testa al modulo oggetto prodotto dalla
compilazione del sorgente. Si tratta dello startup module (o startup code): è questa, in realtà, la parte di
codice eseguita per prima; lo startup module effettua alcune operazioni preliminari ed al termine di queste
chiama main() dopo avere copiato sullo stack tre parametri, che essa può, opzionalmente, referenziare.

In C, il prototipo della funzione main assume una delle seguenti forme:

    •   int main(void)
    •   int main(int argc, char *argv[])

I parametri argc (argument count) e argv (argument vector) restituiscono il numero ed Il valore degli
argomenti della linea di comando. I nomi argc ed argv possono essere sostituiti da qualsiasi identificatori
validi del C, ma per convenzione si usano questi nomi.

Per impostare i parametri che devono essere utilizzati all’interno del main, occorre selezionare Run > Run
Configuration. Invece per settare i parametri per un’esecuzione di debug selezionare Run > Debug
Configuration.

Nella finestra che si aprirà successivamente, occorre selezionare il tab Argument. I parametri possono
essere sia stringhe che numeri e ogni parametro deve essere separato dal successivo con lo spazio.

Debugging e Debugger
Debugging
Debugging (o semplicemente debug) è un'attività che consiste nell’individuazione della porzione di
software affetta da errori (bug) rilevati a seguito dell'utilizzo del programma.

L'errore può essere rilevato sia in fase di collaudo del programma, quando cioè questo è ancora in fase di
sviluppo e non è stato ancora dichiarato pronto per essere utilizzato dall'utente finale, sia in fase di utilizzo
del programma da parte dell'utente finale.

Alla rilevazione dell'errore segue la fase di debugging, ossia di individuazione della parte di software, a volte
molto complesso, nella quale si annida l'errore.

Questa attività è oggi supportata da programmi specifici (debugger), che mostrano allo sviluppatore
l'esecuzione, istruzione per istruzione, del programma, permettendo nel contempo l'analisi dei dati trattati
dal programma stesso.

In assenza di tali strumenti per le attività di debugging, si ricorre alla più semplice ma anche meno efficace
tecnica di loggare (stampare) a video o su file le istruzioni che il programma sta eseguendo, inserendo a tal
scopo nel codice delle istruzioni di debug.

L'attività di debug è una delle operazioni più importanti per la messa a punto di un programma, spesso
estremamente difficile per la complessità dei software oggi in uso e delicata per il pericolo di introdurre
nuovi errori o comportamenti difformi da quelli desiderati nel tentativo di correggere quelli per cui si è
svolta l'attività di debug.

Sebbene ogni sessione di debug sia unica e costituisca una storia a sé, alcuni principi generici sono
applicabili a tutte le sessioni di debug. In particolare, per il debug di applicazioni software, in genere si
possono riconoscere cinque fasi nel debug:

    1.   identificazione del bug;
    2.   individuazione del componente in cui è presente il bug;
    3.   individuazione della causa del bug;
    4.   progettazione di una correzione per il bug;
    5.   implementazione e testing della suddetta correzione.

È necessario fare autocritica, e accettare il fatto che il programma non si comporta come dovrebbe e che si
è fatto un errore; se tutto fosse stato previsto e non ci fossero errori, il programma funzionerebbe
correttamente. Tale atteggiamento mentale incrementa significativamente la possibilità di trovare dei bug.

Debugger
Il debugger è un programma/software specificatamente progettato per l'analisi e l'eliminazione dei bug
(ovvero errori di programmazione interni al programma) presenti in altri programmi. Assieme al
compilatore è fra i più importanti strumenti di sviluppo a disposizione di un programmatore.

Un programma eseguito in modalità debugger è tipicamente molto più lento di quando è eseguito
direttamente sul processore per cui è stato sviluppato.

Il compito principale del debugger è quello di mostrare il frammento di codice macchina che genera il
problema (tipicamente un crash). Il codice può essere mostrato nella sua forma nativa, tradotto in

linguaggio assembly o perfino sotto forma di codice sorgente nel linguaggio in cui il programma analizzato è
stato scritto. Per mostrare il codice assembly il debugger fa tipicamente uso di un disassembler,
eventualmente integrato nel debugger stesso. Per l'analisi del codice sorgente, invece, è in generale
necessario uno speciale tipo di compilazione per il programma utente.

Quasi tutti i debugger consentono l'esecuzione del programma analizzato a piccoli passi, mostrando nelle
interruzioni il codice relativo all'istruzione corrente e lo stato attuale della CPU. L'interruzione
dell'esecuzione può avvenire ad ogni singola istruzione oppure in punti esplicitamente assegnati dall'utente
(breakpoint). In pratica, un breakpoint è definito in base ad una serie di condizioni che determinano
quando il programma debba essere interrotto. La versione "classica" del breakpoint, quella più semplice,
interrompe il programma immediatamente prima che venga eseguita una certa istruzione specificata dal
programmatore, presente in una certa riga del codice. In altri casi (quelli più comuni), l'esecuzione del
programma può essere interrotta:

    1.   quando si tenta di leggere o scrivere su una determinata variabile o un'area di memoria;
    2.   quando una variabile viene modificata, così da assumere un certo valore ben definito;
    3.   quando viene lanciata un'eccezione (in linguaggi quali C, Java, ecc.);
    4.   all'entrata o all'uscita di una certa procedura o metodo.

Queste condizioni, seppure semplici di per sé, facilitano notevolmente il compito del programmatore. Ad
esempio, il più delle volte esse rendono possibile interrompere il programma solo quando necessario, cioè
nei casi in cui sia superfluo controllare la validità dello stato delle variabili nel programma quando queste
assumono determinati valori (che già a priori si sanno essere corretti).

Debugging in Wascana Eclipse
Per prima cosa occorre individuare la parte del codice che non si comporta come dovrebbe. Una volta
individuata occorre settare il breakpoint.

Per settare il breakpoint basta cliccare con il tasto destro del mouse sul margine sinistro della finestra del
codice in corrispondenza dell’istruzione in cui si vuole bloccare l’esecuzione; a questo punto si aprirà un
menu a tendina in cui si deve selezionare la prima voce, Toggle Breakpoint.

A questo punto, sul margine sinistro in corrispondenza dell’istruzione desiderata, apparirà un cerchietto
blu, segno che il breakpoint è stato impostato correttamente. Per rimuovere un breakpoint cliccare con il
tasto destro del mouse sul cerchietto blu e dal menu a tendina selezionare nuovamente la voce Toggle
Breakpoint.

Per eseguire l’applicazione in modalità di debug selezionare Run > Debug.

A questo punto, l’ambiente di sviluppo cambia faccia e si aprono svariate finestre. Quella di maggiore
interesse ai fini del corso è quella con titolo Variable che si apre in alto a destra. La finestra Variable
visualizza il valore assunto dalle variabili in corrispondenza dell’ultima istruzione eseguita.

Quando si usa la modalità di debug, Eclipse non bloccata l’esecuzione in corrispondenza del primo
breakpoint settato, ma in corrispondenza della prima istruzione che è contenuta nel main. Per raggiungere
il breakpoint occorre premere il tasto F8. A questo punto per continuare ad eseguire l’applicazione
istruzione per istruzione occorre premere il tasto F6. Nella finestra Variable il valore delle variabili coinvolte
nell’istruzione appena eseguita verrà aggiornato.