Newsgroup: it.comp.lang.c
Titolo: MAKE files

Sto finendo un progetto per un esame di ingegneria del software.
Uso la versione 5.0 della Borland C++. Il programma e tutti i suoi
componenti sono stati modificati e la compilazione ha successo.
Il professore però ci ha chiesto di modificare il make file e di inserire
una procedura di installa/disinstalla.
Non ho capito bene a cosa serve il make files e cosa dovrei modificare a
quello creato automaticamente.
Grazie in anticipo e ciao!
--
.-:^:-..-:^:-..-:^:-..-:^:-..-:^:-..-:^:-..-:^:-..-:^:-.
I mal pensieri vengono ai mal pensanti!
Giangi - 
giangiv...@libero.it
.-:^:-..-:^:-..-:^:-..-:^:-..-:^:-..-:^:-..-:^:-..-:^:-.

quello creato automaticamente.
i make files sono dei file particolari che conservano informazioni
sull'ordine in cui vanno compilati i diversi "pezzi" di un progetto e
che fanno in modo che, di volta in volta, si compilino del progetto
solo i file effettivamente modificati.
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
---------------------------------------------

Grazie in anticipo e ciao!
Il makefile e' un file di testo che contiene principalmente due tipi di 
informazioni. Il primo consiste in una descrizione delle dipendenze tra i vari 
file che compongono il progetto, per esempio:
pippo.c: pippo.h pluto.h
significa che il file pippo.c dipende da pippo.h e da pluto.h (di solito 
cio' avviene a causa di direttive tipo #include "pippo.h" ed #include 
"pluto.h"). Inoltre verosimilmente si avra' anche qualcosa tipo:
pippo.obj: pippo.c
ovvero il file pippo.obj (che e' il risultato della compilazione di pippo.c) 
dipende da pippo.c. Qui dire che "A dipende da B" equivale piu' o meno a dire 
che "se B e' piu' nuovo di A allora A deve essere rielaborato".
Supponi di avere il seguente makefile:
pippo.exe: pippo.obj pluto.obj
pippo.obj: pippo.c
pluto.obj: pluto.c
pippo.c: pippo.h pluto.h
pluto.c: pluto.h
che ha il compito di creare pippo.exe (nota: e' solo un esempio, non 
funzionera' se provi ad usarlo cosi' com'e'). Che succede se modifico pippo.c? 
Dal makefile si vede che pippo.exe dipende da pippo.obj che a sua volta 
dipende da pippo.c, quindi se modifico pippo.c bisogna creare da capo 
pippo.obj ed in seguito pippo.exe: pippo.c -> pippo.obj -> pippo.exe. Se 
invece modifico pluto.h ho piu' operazioni da svolgere perche' sia pippo.c che 
pluto.c dipendono da pluto.h: pluto.h -> pippo.c, pluto.c -> pippo.obj, 
pluto.obj -> pippo.exe.
Il secondo tipo di informazione all'interno del makefile riguarda *come* 
elaborare i file. Abbiamo visto che pippo.obj dipende da pippo.c, ma come? 
Ovvero qual'e' l'operazione che a partire da pippo.c permette di creare 
pippo.obj? In questo caso si tratta ovviamente della compilazione, percio' la 
regola potrebbe essere:
pippo.obj: pippo.c
    cc pippo.c -o pippo.obj
ovvero compila pippo.c per produrre pippo.obj. Nel caso di pippo.c (che 
dipende da pippo.h e pluto.h) non c'e' bisogno di nessuna regola perche' e' 
compito tuo scrivere il file sorgente quindi non si specifica nulla e se il 
make non trova pippo.c si fermera' con un errore. Invece per pippo.exe la 
regola c'e' ma e' diversa perche' in questo caso bisogna linkare:
pippo.exe: pippo.obj pluto.obj
    link pippo.obj pluto.obj -o pluto.exe
Ovviamente nomi e parametri di compilatore e linker sono variabili a seconda 
della piattaforma e della marca.
Dato il precedente makefile supponendo di compilare tutto da capo l'esecuzione 
comporta i seguenti passi:
1) per costruire pippo.exe ho bisogno di pippo.obj e pluto.obj
2) per costruire pippo.obj ho bisogno di pippo.c
3) per costruire pippo.c ho bisogno di pippo.h e pluto.h
4) ok, ho trovato pippo.c, pippo.h e pluto.h allora applico il comando:
    cc pippo.c -o pippo.obj
    per costruire pippo.obj
5,6,7) stessa cosa per pluto.obj
8) ok, ora ho pippo.obj e pluto.obj, per costruire pippo.exe applico allora il 
    comando: link pippo.obj pluto.obj -o pluto.exe
Spero di essere stato relativamente chiaro almeno a grandi linee! In pratica i 
concetti rimangono gli stessi ma si usano tipi di regole diverse. Immagina di 
avere un progetto composto da 100 sorgenti... bisogna scriverli nel makefile 
uno per uno? No, se si fa uso delle regole implicite:
c.obj: 
    cc $< -o $@
questo significa che, per default, ogni file .obj dipende da un file .c che ha 
lo stesso nome (cambia solo l'estension), e che per passare da .c a .obj 
bisogna invocare il programma cc con i parametri specificati. Qui si usano 
nomi "strani" come $< o $@ perche' ovviamente non e' possibile conoscere in 
partenza i nomi dei file: le variabili vengono di volta in volta risolte dal 
make con i nomi appropriati. La sintassi varia fortemente da make a 
make percio' se qualcosa funziona con il make dello GNU non e' detto che 
funzioni con il make Borland, ecc. (tra l'altro non mi ricordo assolutamente 
quali sono i nomi giusti ma guardando un makefile qualsiasi dovrebbe essere 
abbastanza facile trovarli).
Un ultima nota: di solito e' buona regola non modificare i makefile generati 
automaticamente, sia perche' e' piu' difficile metterci le mani (sono pieni di 
ogni stranezza) sia perche' rischi di non far funzionare piu' l'IDE o di 
vederteli sovrascritti appena risalvi il progetto.
P.S. Come al solito, e specialmente perche' e' lunedi', ti consiglio di non 
credere a quanto sopra e di provarlo per conto tuo...

 "pluto.h"). Inoltre verosimilmente si avra' anche qualcosa tipo:
!!!!!!!!
L'esempio č calzante come concetto, ma trascura il fatto che il make non sa
neanche cosa siano i .h
--
Alessandro Monti

 solo i file effettivamente modificati.
Si e' giusto tutto cio',pero' i make file non servono soltanto per compilare
,ma anche per richiamare procedure ed eseguire operazioni (annesse alla
compilazione/gestione dei progretti) in maniera automatica,quali possono
essere per esempio la rimozione di files,stampa di una pagina del man ( per
sistemi unix), o anche eseguire procedure di installazione/disinstallazione
del progetto, magari tramite files batch, shell e via dicendo.
Ivan Molella

neanche cosa siano i .h
Se e' per questo non sa neanche cosa sono i .c e i .obj.


 Se e' per questo non sa neanche cosa sono i .c e i .obj.
Questo non e' vero, perche' make hai dei suffissi di default per la compilazione
dei .c e dei .o e molte altre estensioni.
Ivan Molella

dei .c e dei .o e molte altre estensioni.
QUALE make ?


 QUALE make ?
Tutte le implementazioni  che ho usato.
Ivan Molella

Tutte le implementazioni  che ho usato.
Cioe' quelle che accompagnavano compilatori C ?
In generale, parlando di make, si prescinde dal compilatore.


 wrote in message
38a13fe2...@diesel.cu.mi.it...


programmatore.
Ribadisco : parlando di make si prescinde dal compilatore.
