Newsgroup: it.comp.os.linux.development
Titolo: un make annidato

Salve,
sto sviluppando un applicazione il cui codice sorgente e' suddiviso in 2
parti: una libreria statica e l'applicazione finale che utlizza tale
libreria. Ho deciso quindi di organizzare tutti i sorgenti
dell'applicazione in questo modo:
app/ -> directory di root dell'applicazione
app/lib/ -> directory di root della libreria
app/*.* -> codice riguardante l'applicazione e che fa uso della libreria
app/lin/*.* -> codice riguardante la libreria
app/Makefile
app/bin/Makefile
Ho optato quindi per 2 Makefile: quello piu' interno e' un normale Makefile
che da la possibilita', se lanciato direttamente, di compilare
esclusivamente la libreria. Non riesco invece a realizzare un Makefile per
l'applicazione che mi soddisfi. In particolare il suddetto dovrebbe
rendersi conto se la libreria e gia' updatata e' inutile che ricompili
tutti gli oggetti dell'applicazione dal principio.
Riporto di seguito i due Makefile (e mi scuso per la lunghezza del post...):
----------------------------------------------------------------------------
----------------------------------------------------------------------------
# library Makefile che riesiede in app/lib/
# Settings
CC         = g++
CFLAGS     = -Wall -ggdb
STATIC_LIB = dkst.a
# Rules
$(STATIC_LIB): tree.o iterators.o node.o
        ar rcs $(STATIC_LIB) tree.o iterators.o node.o
tree.o: tree.cpp tree.h exceptions.h iterators.o node.o
        $(CC) $(CFLAGS) -c tree.cpp
iterators.o: iterators.cpp iterators.h exceptions.h node.o
        $(CC) $(CFLAGS) -c iterators.cpp
node.o: node.cpp node.h
        $(CC) $(CFLAGS) -c node.cpp
# Utilities
clean:
        @echo -n 'cleaning up... '
        @rm -f $(STATIC_LIB) *.o *~ \#*\#
        @echo 'done.'
doc:
        doxygen Doxyfile
----------------------------------------------------------------------------
----------------------------------------------------------------------------
# application Makefile che risiede in app/
# Settings
CC      = g++
CFLAGS  = -Wall -ggdb
TARGET  = ../bin/dkstshell
OBJECTS = dkstShell.o wordChain.o dictionary.o words.o dkst/dkst.a
# Rules
$(TARGET): $(OBJECTS) main.cpp
        $(CC) $(CFLAGS) -o $(TARGET) $(OBJECTS) main.cpp
dkstShell.o: wordChain.o dkstShell.cpp dkstShell.h
        $(CC) $(CFLAGS) -c dkstShell.cpp
wordChain.o: dictionary.o wordChain.cpp wordChain.h
        $(CC) $(CFLAGS) -c wordChain.cpp
dictionary.o: words.o dictionary.cpp dictionary.h
        $(CC) $(CFLAGS) -c dictionary.cpp
words.o: dkst/dkst.a words.cpp words.h
        $(CC) $(CFLAGS) -c words.cpp
dkst/dkst.a:
        $(MAKE) -eC dkst/
# Utilities
clean:
        $(MAKE) -eC dkst/ clean
        @echo -n 'cleaning up... '
        @rm -f $(TARGET) *.o *~ \#*\#
        @echo 'done.'
----------------------------------------------------------------------------
----------------------------------------------------------------------------

 tutti gli oggetti dell'applicazione dal principio.
CUT
Ho visto (ed ho fatto anche io cosi') che quasi tutte le applicazioni
composte di varie parti funzionano in questo modo:
* ogni parte ha un Makefile indipendente nella sua directory che si occupa
solo della sua parte.
* nella dir principale dei sorgenti c'e' un Makefile che chiama i Makefile
delle singole directory, e lascia a loro il compito di svolgere la parte
competente, una sorta di call, fatta con make -C directory. Metti il
Makefile della libreria in app/lib e il Makefile dell'applicazione in app,
e se ti serve un Makefile in app/bin.
Poi il Makefile nella directory principale app/ contiene nel tuo caso
due chiamate fatte cosi':
make -C lib/
make -C bin/
che fanno il necessario e poi passano a creare l'applicazione.
e' come se facessi per ogni dir:
cd lib
make
cd ..
cd bin
make 
cd ..
Spero di essermi spiegato.
-- 
Mario "Reliant" Pascucci
"From" field altered. Please use ilpettegolo(a)
yahoo.it
 for private mail.
http://ilpettegolo.altervista.org/