Indice

00. Introduzione
01. Consumo
03. Compilazione e Linking
04. Cenni sulla gestione degli errori e il debugging

00. iNtrODUZIONE
------------

Nulla da dichiarare!

02. cONSUMO
-------

1) ll contenuto di una caffettiera da 3 di caffe' 100% arabica tostatura forte
2) Una tazza di te' verde
3) biscotti di cereali integrali e frutta (con moderazione. Sono a dieta)

03. cOMP1L4zione 3 lINKING
----------------------

Per ottenere un eseguibile ossia un programma in linguaggio macchina direttamente
comprensibile al nostro computer occorre compiere 3 step.

Per prima cosa dobbiamo avere il file sorgente del nostro programma scritto in C
che per consuetudine terminano con estensione .c .
Il sorgente viene compilato dal compilatore C che genera un nuovo file, il file
oggetto che sui sistemi linux ha estensione .o .
Il file oggetto e' un file binario che non puo' pero' essere eseguito in
quanto potrebbe non essere completo di tutte le librerie che vengono incluse
durante l'ultimo step quello di linking. L'operazione di linking e' eseguita
da un programma speciale chiamato linker che viene generalmente incluso
nel package del compilatore.
Il linker, (ld su Linux) e' usato per unire tra loro i file oggetto, la
libreria standard C e altre librerie generate dall'utente per creare il
file eseguibile - il codice binario.
In questo passo, il codice binario delle librerie che sono invocate dal
sorgente vengono combinate con il file oggetto generato a partire dal sorgente
stesso.
Il risultato e' salvato in un nuovo file - il file eseguibile.
Occorre tenere a mente che i file oggetto e quelli eseguibili sono dipendenti
dall'architettura hardware e dal sistema; non possono essere semplicemente
copiati e trasferiti su piattaforme differenti nonostante lo sia (nel caso
in cui si sia fatto solo impiego della libreria ANSI C) il codice sorgente.

04. cENNI sULLa GeSTIOnE dEGLI eRRoRI e iL DeBUGGINg
------------------------------------------------

Una volta terminata la stesura del programma ci capitera' in fase di
compilazione di incorrere in diversi messaggi di errore o di warning.
Non preoccupatevi siamo umani! Pensate solo a gioire del fatto che il
compilatore si preoccupera' con voi di verificare la correttezza di quanto avete
prodotto prima di farvi fare ulteriori ....

Il compilatore infatti si preoccupera' di verificare la correttezza sintatica
del programma mentre il linker generera' degli errori qualora non sia possibile
recuperare le librerie contenenti la definizione delle funzioni che avete utilizzato.
Per esempio se utilizzate la funzione matematica sin() e avete sbagliato a digitare
scrivendo sinn() nel vostro codice la compilazione si interrompera' con un messaggio
simile a questo:

/tmp/ccLySlSb.o: In function `main':
error.c:(.text+0xf): undefined reference to `sinn'

Tutti gli errori individuati (dal compilatore o dal linker) devono essere corretti
prima che possa essere generato il file eseguibile.

Gli errori presenti nei programmi vengono chiamati BuG. In molti casi questi
verranno individuati da compilatore o linker ma molto piu' spesso di quanto
ci si possa aspettare la generazione dell'eseguibile giungera' a termine pero'
il programma non si comportera' come atteso e restituira' risultati non corretti.
Per individuare questi errori nascosti e' necessario utilizzare un debugger.

Generalmente la suite di sviluppo oltre al compilatore prevedere anche la
disponibilita' di un debugger.
Il debugger consente l'esecuzione del programma una riga per volta cosi'
da poter verificare cosa viene effettuato operazione per operazione.
Grazie al debugger e' poi possibile verificare il contenuto di variabili,
alterarne il contenuto, bloccare l'esecuzione di un programma in punti
o condizioni particolari.

In seguito tratteremo nel dettaglio l'utilizzo del debugger della
famiglia GNU: GDB.

Have Fun ;-)