Newsgroup: it.comp.os.linux.sys
Titolo: makefile

Ciao a tutti,
sto cercando di capire un makefile che per le mie conoscenze appare ostico.
In passato ho lavorato con makefile relativamente semplici, per girare un
programma e linkare qualche libreria.
In # metto i miei commenti, per cercare di capire se ho capito, ma vostri
consigli sonon benvenuti
CC= gcc
# dico che nel seguito chiamo con CC il comando gcc. E' convenzione usare
maiuscole e se si, perche?
STD= _GNU_SOURCE
# questo non mi e' chiaro
OBJS= object1.o object2.o
# definisco con OBJS due file oggetto che usero' dopo
.c.o: # non mi e' chiaro
    $(CC) -c -Wall $(CFLAGS) -D$(STD) $< # qui compilo il programma e richiedo
di avere tutti i warning. CFLAGS cosa e'?
                                                                                 # -D che opzione e'?
all: name1 name2 # qui faccio due eseguibili?
test: all # qui testo file 1 con input1 e scrivo risultati in un testfile?
        name1 input1 >testfile
# di qui in poi ho idee confuse, forse perche' gia' sopra ho capito poco ...
name1: $(OBJS)
    $(CC) $(OBJS) -o name2
name2: name1
    rm -f
    ln name1 name2
name1.h: header1.h header2.h
        touch $@
 
clean:
    rm -f *.o core
clobber: clean
    rm -f name1 name2
# End Makefile
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 programma e linkare qualche libreria.
[...]
a) Dovresti aver postato su icol.development (e infatti posto il
followup lì).
b) Dovresti almeno aver fatto un man make, tanto per risponderti da
solo a due o tre delle tue domande.
c) Googlare per "make tutorial" ritorna un sacco di roba, l'hai letta?
Saludos
Adriano

         touch $@
 
serve a far andare la compilazione anche se si sono toccati gli header, e
non i .c
sbaglio o in questo makefile si creano solo librerie e nessun eseguibile?
ci sono un milione di opzioni , leggiti questo:
http://www.gnu.org/software/make/manual/make.html
Red
ps: ricordati icoldevelop

         name1 input1 >testfile
il target 'test' ha come prerequisito 'all'; dopo che 'all' e' stato
soddisfatto, viene eseguito il comando name1 input1 >testfile .
non ti offendere, ma icol.sys e' un gruppo per sistemisti; spostati su
icol.iniziare.  GNU make viene con un ottimo manuale di 188 pagine a
corredo; leggilo, e troverai tutte le spiegazioni in dettaglio --- o,
magari, basta "man make"...
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Dept. of Physics, Univ. of Padova, Italy              ROT13: 
ybe...@cq.vasa.vg

 # ho capito poco ...
Forse perche' era meglio leggere un tutoria su make :(
Con google ho trovato circa sessantun milioni di pagine con
"make tutorial"

 # di qui in poi ho idee confuse, forse perche' gia' sopra


 chiamato da un makefile superiore...
Si' un makefile di ordine superiore.
E noi siamo solo una simulazione e la terra e' 
un immenso computer programmato per trovare la 
domanda alla risposta piu' importante dell'universo.
Tale risposta e': "42"

> it.comp.os.linux.programmare o
che esiste solo nella tua testa
Red

 Si' un makefile di ordine superiore.
che palle che sei,dopo ho anche specificato "struttura ad albero".

RedWiz wrote:

it.comp.os.linux.development
-- 
www.iuz-lab.info

 it.comp.os.linux.development
... ?

Grazie mille a tutti per
le info e gli aiuti. Pian piano vedo la luce in fondo al tunnel (mi scuso
per postare la risposta su questo ng, piuttosto che development, ma da web
non riesco -uso libero-).
Metto a seguire quanto ho -spero- compreso, se qualcuno di voi volesse
tediarsi ;)
Ah, una domanda: che tipo di paramtri posso passare per fare utility ?
CC= gcc
# Questo mi e' chiaro ora. In sostanza e' come se definissi un macro, ma una
macro che e' comunque interna al make
STD= _GNU_SOURCE
# anche qui definisco una macro. _GNU_SOURCE e' una macro che ora chiamo STD
e passero' sotto al compilatore con opzione -D
OBJS= object1.o object2.o
# definisco un'altra macro OBJS composta da due file oggetto
# successivamente, quando per esempio scrivo $(CC) o $(STD) il make espande
e gira queste macro
.c.o:
    $(CC) -c -Wall $(CFLAGS) -D$(STD) $<
# e' la regola per creare .o file a partire da sorgente .c
# uso opzione -Wall in make per avere tutti warnings. CFLAGS e' una macro
definita da qualche parte fuori da questo makefile
# STD e' macro definita sopra per cui serve opzione -D in gcc.
# $< penso si riferisca al sorgente, ma non capisco molto bene
all: name1 name2
# definisco un target di nome all.
# il target all dipende da name1 e da name2. Se digito make all, per
soddisfare questa richiesta, name1 e name2 devono essere soddisfatti.
test: all
        name1 input1 >testfile
# definisco un target di nome test. Taget test dipenda dal taget all
# Se all e' soddisfatto, allora eseguo il comando name1 input1 >testfile
name1: $(OBJS)
    $(CC) $(OBJS) -o name2
# definisco un target di nome name1 che dipende dalla macro OBJS
# se la macro OBJS e' soddistta, allora creo gli oggetti
name2: name1
    rm -f
    ln name1 name2
# definisco un taget chiamato name2 che dipende da name1. Se name 1 e'
soddisfatto, allora parte il comando rm -f (cioe' rimuovo con opzione per
forzare?) e poi creo un link (name2 diventa il link a name1, giusto?Cioe' in
sostanza copio name1 e lo chiamo name2)
###Putroppo di qui in poi sono ancora confuso!!
name1.h: header1.h header2.h
        touch $@
# creo un taget di nome name1.h che dipende dai due header scritti. E poi
applico touch al target corrente (cioe' name1.h). Giusto?
 
clean:
    rm -f *.o core
# cosa faccio? creo un taget clean per cui rimuovo tutti i file oggetto?
Vengono rimossi perche' tanto gli oggetto non servono a nulla? cosa e'
opzione core?
clobber: clean
    rm -f name1 name2
# qui incertezza regna sovrana :((


 girare un programma e linkare qualche libreria.
]zac[
Alcuni dicono che sono strumenti del demonio, ma prova a usare gli autotools
(autoconf, automake, ecc.)
Prendi un piccolo progetto già fatto e funzionante, guarda gli esempi
insieme ad autoxyz, una piccola letta alla documentazione degli autoxyz,
poi fai le modifiche e adattamenti.
Dopo di che le modifiche di manutenzione diventano molto semplici, e la
configurazione, compilazione, installazione, una bazzecola.
Gli autoxyz diventano obbligatori se devi gestire i multilinguaggi
(gettext), test di esistenza di librerie e file, particolari azioni,
supporto di molteplici sistemi e distribuzioni, ecc. .

 # qui incertezza regna sovrana :((
Quando digiti:
make clobber
make cerca il file clean  per controllare la sua data 
non lo trova ed allora esegue il target clean; il 
risultato e` che cancelli tutto, sia gli eseguibili 
che i file oggetto; e` un modo come un altro per 
forzare una ricompilazione.
Oppure è un comando da dare dopo 
make install
per eliminare dalla propria home i file appena 
compilati (tanto li abbiamo messi in /usr/local/bin
o quel che sia) ma conservare i sorgenti.