Newsgroup: it.comp.os.linux.development
Titolo: Creare il makefile

Ciao a tutti!
Devo scrivere un programma C che si divide su più file sorgenti. Ho letto
che, utilizzando un makefile oppurtuno, è possibile compilare tutti i file
di un programma in una volta sola. La domanda è: dove posso trovare esempi
di makefile che facciano al caso mio?
Grazie.
--
Marco Minerva, 
vbco...@libero.it
http://www.marcominerva.com/vbcorner


Prova nelle info pages: digita
info make
li' trovarai la descrizione della struttura dei makefile e un esempio.
Altri esempi li troverai in quasi tutti i sorgenti dei progetti in C che
trovi per esempio su freshmeat 
www.freshmeat.net
--
Alessandro Staltari
staltari(a)
geocities.com

 di un programma in una volta sola. La domanda č: dove posso trovare esempi


 di makefile che facciano al caso mio?
se ti serve solo una cosa molto semplice:
all:    
        rm -f eseguibile
        gcc OPZIONI file1.c file2.c ..... filen.c -o eseguibile
clean:
        rm -f eseguibile
ciao
-- 
matteo merli
http://www.petaligrigi.net

 solo le implementations...
MIO DIO...

 ha scritto nel messaggio
news:abnrsg$2cp$1...@e3k.asi.ansaldo.it...


 sbaglio ?
sarebbe più elegante fare i cicli con i "goto" !!
;)


:

Non e' "sbagliato" (come non lo e' il goto), e' un pessimo modo di
procedere pero'.
Mettere in moduli separati ti permette di poter compilare una volta il
tuo modulo in file oggetto (o addirittura farne una libreria) e poi
riutilizzarlo a piacere solo conoscendo i dati contenuti nel .h (i
prototipi, l'eventuale presenza di variabili globali, le strutture
utilizzate, le define).
Ti e' anche di aiuto in fase di compilazioni per grossi progetti
perche' non devi ricompilare tutto, ma solo il modulo che e' stato
modificato (pensa a quando ci metti a compilare il kernel e pensa se
tu fossi uno sviluppatore che ha cambiato solo un dettaglio e vuole
provarlo... brrr).
Il makefile poi ti semplifica la vita liberandoti dalle faccende
noiose, come capire cosa va' effettivamente compilato e cosa puo'
restare invariato.
Il .h e' nato con lo scopo di rendere noto al resto del mondo
l'interfaccia di un dato modulo, non di fornire tutto il modulo :P
A sto punto tanto varrebbe includere direttamente il .c, almeno non
hai ambiguita'.
-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."

di makefile che facciano al caso mio?
se vai sul sito 
www.gnu.org
 e cerchi un pò (mi dispiace non so essere
+ preciso) c'è un file .ps (ma credo anche molti altri formati) del
manuale ufficiale di make. Ci sono molti esempi all'interno.

Thanks...
mi hai schiarito abbastanza le idee...
effettivamente mi sa che sia arrivata l'ora che i miei progettini si
meritino un makefile!
ps: se i miei progettini non dovessi consegnarli
qualche goto lo sparerei dentro di tanto intanto... ;p
Mox a scritto:





 di makefile che facciano al caso mio?
info make
Breve riassunto:
CC=gcc
CLIB=-lwhatever
CFLAGS=-DSOMETHING -Wall
%.o: %.c
        $(CC) $(CFLAGS) -c $<
prog: file1.o file2.o file3.o
        $(CC) $(CLIB) $(CFLAGS) -o $@ $^
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Il dottore mi ha detto di smettere di fare cene intime per quattro.
A meno che non ci siamo altre tre persone.

 procedere pero'.
--- start file.h ---
int bar(int foo) {
        return foo % 2;
}
--- end file.h ---
--- start file1.c ---
#include "file.h"
void quux(int a);
int main() {
        quux(123);
        return 0;
}
--- end file1.c ---
--- start file2.c ---
#include "file.h"
void quux(int a) {
        bar(a);
}
--- end file2.c ---
Ti sfido a compilare questo ;)
L'implementazione non va *mai* messa negli headers.
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Mi piace avere amici rispettabili;
Mi piace essere il peggiore della compagnia.

L'implementazione non va *mai* messa negli headers.
Su questo siamo daccordo :)


 
http://groups.google.com/advanced_group_search

Chiaro... dopo che uno si č fatto 6 mesi di corso di assembler con un
progetto a settimana...
Me lo sogno pure di notte il gotooooo!!!
->difatti ora odio java...

Mo li so fare pure io i makefile...
BUHAHAHA
mi sento molto fiero di me...

 mi sento molto fiero di me...
Però mi è rimasto un dubbio:
se io ho 3 file .c e un .h a cosa mi serve un Makefile?
Scusate la mia ignoranza, ma vorrei capire *meglio* l'utilizzo effettivo,
Scusate la domanda, magari sciocca, ma molto utile per me..
Grazie
--
-------------------------------------------------------------------------
"Nella terra delle talpe una talpa è re."
                                        * C. Bukowski *
  ____       ____                    ______
 |  _ \ __ _|  _ \ _ __   __ _ _ __ |__  (_) ___
 | |_) / _` | |_) | '_ \ / _` | '_ \  / /| |/ _ \   icq uin : 86622960
 |  __/ (_| |  _ <| | | | (_| | | | |/ /_| | (_) |  
parn...@email.it
 |_|   \__,_|_| \_\_| |_|\__,_|_| |_/____|_|\___/
-------------------------------------------------------------------------

 se io ho 3 file .c e un .h a cosa mi serve un Makefile?
Se preferisci scrivere "gcc file1.c file2.c file3.c -o myprog" anziche' un
semplice "make" ogni volta che devi ricompilare puoi anche evitare di usare
il Makefile.
Ciao
Alessandro.

Scusate la domanda, magari sciocca, ma molto utile per me..
Il Makefile ha 2 utilita' fondamentali:
- fa' un controllo della data di ultima modifica e di conseguenza 
  decide quali cose ricompilare e quali no.
  A te per 2 file questa feature non serve, pero' e' comodo dare solo 
  il comando "make" anziche' gcc -o output_file -Iblablabla-Iblablabla
  -lm -lpthread -g3 -DDRYDEN -DPIPPO -Lblablabla -o2 ciao.c ciao.h... 
  soprattutto se devi ricompilare piu' volte.
- fornisce un'interfaccia verso altre operazioni "funzioni", come la 
  creazione del pacchetto, la cancellazione dei file oggetto,   
  dell'eseguibile, lo strip dell'eseguibile, installazione, 
  compilazione della documentazione in LaTeX... e chi piu' ne ha piu' 
  ne metta, il make e' in grado di avviare qualsiasi programma o 
  script, senza contare che gli puoi dare dei comandi, che lui 
  eseguira' come in uno script di bash (ovviamente se metti i comandi 
  in corrispondenza di un target che verra' eseguito).
Fidati, avere un modo automatico per cancellare i .o ti evita
spiacevoli problemi quali "rm * .o" :P  O che ti scappi un "rm *.java"
:P
