BerndPol IanWadham Questo capitolo si occupa solo di progetti compilati, come C++, Java o Fortran. I progetti per linguaggi di scripting come Python e Php funzionano in modo molto diverso. Si troveranno informazioni sui seguenti argomenti: Sommario sul gestore Automake contenente una panoramica sul gestore Automake, Operazioni con il gestore Automake dove sono descritte le operazioni principali per lavorare con il gestore Automake, Nel capitolo Sistemi di compilazione è stata esposta una panoramica approssimativa sui sistemi di compilazione usati comunemente sui sistemi &UNIX;. Nelle sezioni seguenti verranno esaminati più in dettaglio. È presente una certa confusione su come chiamare questi sistemi. &GNU; parla di sistemi di compilazione (build systems) quando descrive Automake, Autoconf e Libtool. QMake si descrive come uno strumento per scrivere Makefile per diversi compilatori e piattaforme. In &kde; è spesso usato il termine sistemi di gestione di progetti (project management systems). Si userà questo permine in senso più ampio per descrivere l'ambiente incorporato di &tdevelop; che è usato per organizzare e compilare i progetti. Nel contesto di questa sezione, comunque si parlerà principalmente di sistemi di compilazione automatici. Se si ha un semplice programma Hello World scritto in C, lo si può compilare ed effettuare il linking usando &gcc; -o hello hello.c e può essere eseguito usando il comando ./hello, perciò non è addirittura necessario un Makefile. Se si ha un'applicazione C con diversi moduli e file header che viene eseguita solo sulla propria macchina (&ie; un'applicazione "interna"), servirà solo un Makefile abbastanza semplice da scrivere a mano (per maggiori informazioni consultare info make). Le complicazioni iniziano quando: Il codice sorgente, la documentazione, la grafica, i suoni, le traduzioni, i file di dati, ecc. sono presenti in più di una directory, Si ha una gerarchia di directory e sottodirectory, Si stanno usando librerie che non fanno parte dell'insieme tradizionale presente in &UNIX;, come le librerie &Qt; o le librerie &kde;, Si sta usando un pre-processore per generare parte del codice sorgente, come il pre-compilatore MOC di Qt, Si vuole distribuire l'applicazione a livello mondiale, a persone che potrebbero non avere lo stesso sistema &UNIX;/&Linux; o lo stesso software e hardware, Si necessita di un sistema di installazione e disinstallazione, Si vuole far sì che l'applicazione faccia parte di &kde; Desktop. Se si è in una o tutte tra queste situazioni, probabilmente sarà necessario un sistema di compilazione. Nell'esempio sopra è stato usato &gcc; per compilare il programma Hello World, ma non tutti i compilatori C si chiamano &gcc;. Quindi se si distribuisce l'applicazione a qualcuno che sta usando un altro compilatore C, il Makefile deve usare in qualche modo il nome del compilatore di quella persona, altrimenti l'applicazione non compilerà — e questo è solo un semplice esempio di quello che può andare storto. Un sistema di compilazione nasconderà queste differenze. Controllerà che le librerie necessarie siano presenti su ogni macchina di destinazione, scansionerà automaticamente tutte le directory dell'applicazione per cercare i file da pre-processare, compilare o installare e installerà i componenti dell'applicazione nelle directory di destinazione corrette, assicurandosi che le directory vengano create come richiesto sulla macchina di destinazione. In poche parole, un sistema di compilazione offre un metodo sicuro per compilare e installare correttamente l'applicazione sulla macchina di destinazione. Come è stato mostrato prima nella panoramica Sistemi di gestione dei progetti, &tdevelop; fornisce tre sistemi di compilazione automatici e le opzioni per creare i propri Makefile. In breve (fare clic sul nome del progetto per ricevere ulteriori informazioni): I Progetti Automake che usano gli strumenti standard di sviluppo &GNU;. I Progetti QMake che usano il gestore di progetti Qmake di Trolltech. I Progetti ANT che usano il gestore di progetti ANT di Apache per lo sviluppo con &Java;. I Progetti personalizzati che richiedono che si gestiscano i propri Makefile. Quando si crea un progetto si deve scegliere una di queste quattro alternative e questa scelta è difficile da cambiare in seguito, quindi ci si dovrebbe pensare un momento prima di iniziare. Esistono diversi tutorial disponibili sul sistema di compilazione &GNU; usato dal Gestore Automake (Autoconf, Automake e Libtool). Un breve tutorial su autoconf scritto da Christopher W. Curtis è disponibile sulla home page di KDevelop. Esso illustra in pochi passi le istruzioni su come modificare un Makefile. Un tutorial più dettagliato può essere trovato qui: Sviluppo di software con GNU. E questo è il famoso Goat Book inititolato Autoconf, Automake and Libtool. È un'introduzione concisa e facile da leggere ai principali aspetti degli Autotool &GNU;. Quando si crea un Nuovo progetto che usa il sistema di compilazione &GNU;, come C++ KDE Application Framework, la procedura guidata imposta i primi file Makefile.am. Ci sarà un file Makefile.am in ogni directory del progetto, che conterrà le istruzioni per compilare, costruire e installare i file, assieme ad un riferimento ad eventuali sottodirectory che avranno a loro volta un file Makefile.am e altri file da compilare, costruire ed installare. La directory del progetto e i file sorgente possono essere strutturati a qualunque livello di profondità, oppure si può preferire una struttura piatta con tutte le sottodirectory al livello più alto. Lo scopo del sistema di compilazione &GNU; consiste nel produrre strutture di file sorgenti che possano essere compilati e installati su ogni sistema &UNIX; o &Linux; usando questi semplici comandi: ./configure make make install # Normalmente come "root". e possano essere disinstallati dal comando make uninstall (normalmente come utente root). Come funziona? configure è uno script che risolve le problematiche relative ai dettagli del sistema in cui si trova, come quale compilatore e librerie usare e dove sono localizzate crea file Makefile ricorsivi completando le sostituzioni nei corrispondenti file Makefile.in. I Makefile.in sono file di input — modelli che forniscono le informazioni di base per i Makefile che saranno prodotti a partire da essi utilizzando alcune informazioni relative al sistema. Essi sono generati dall'utility Automake a partire dai file Makefile.am. Il processo che parte dai Makefile.am (.am significa file modello di Automake) fino ad arrivare ai file Makefile viene gestito automaticamente dal &promanag; di &tdevelop;, usando l'utility Autoconf, le macro M4 e altre cose arcane in cui non è necessario addentrarsi. In questo modo, quando viene avviato make, esso ottiene automaticamente i componenti corretti dal sistema, come compilatori e librerie. Analogamente, make install installa i componenti dell'applicazione, come i file eseguibili, la documentazione e i file di dati nei posti corretti per quell'ambiente. Se si distribuisce l'applicazione come tarball (un singolo file compresso che può essere creato da &tdevelop;), saranno inclusi i file Makefile.in e il file script configure, in modo che il destinatario potrà compilare e installare l'applicazione senza possedere sul proprio computer Automake, Autoconf o &tdevelop;. Vengono inclusi anche i file Makefile.am, nel caso in cui il destinatario debba fare qualche modifica al codice sorgente. Le regole sono piuttosto diverse se si distribuisce attraverso un repository di codice sorgente come il &cvs; di &kde;. Genera i file Makefile.am nelle sottodirectory conosciute come sottoprogetti. Aggiorna i file Makefile.am quando cambia la struttura del progetto. Aggiorna i file Makefile.am quando vengono aggiunti o rimossi dei file dal progetto. Interpreta le definizioni sulla compilazione e installazione dei vari file e modifica adeguatamente i file Makefile.am. Accetta i parametri usati nella compilazione o installazione (ad es. i nomi di libreria) e si assicura che siano usati nelle fasi di compilazione. Le linee di un file Makefile.am contengono nomi di variabile seguiti dal segno di uguale e una lista di file o parametri. Le variabili hanno nomi costituiti da due parti, come bin_PROGRAMS, myapp_SOURCES o kdelnk_DATA. La seconda parte è detta primaria e rappresenta qualcosa da compilare o installare. La prima parte è chiamata il prefisso e rappresenta: Una directory nella quale effettuare l'installazione (ad es. bin), Un qualificatore per la parte primaria (ad es. myapp per SOURCES, indicando che i file sorgente elencati dopo myapp_SOURCES finiranno nella compilazione di myapp), Lo speciale prefisso noinst (abbreviazione per nessuna installazione), normalmente usato per elencare i file header (.h), O lo speciale prefisso EXTRA, per tutte le cose dipendenti dalla configurazione. Per ulteriori informazioni sui file Automake e Makefile.am, controllare info Automake. Fondamentalmente il gestore Automake crea e aggiorna i nomi delle variabili e le liste di file o parametri. Vedere il seguente esempio di un Makefile.am per una applicazione tipica chiamata myapp. ## Makefile.am for myapp # questo è il programma che viene installato. Il suo nome è usato per # tutte le altre variabili del Makefile.am bin_PROGRAMS = myapp # impostare i percorsi di include per X, qt e KDE INCLUDES = $(all_includes) # percorso di ricerca per le librerie. myapp_LDFLAGS = $(KDE_RPATH) $(all_libraries) # le librerie con cui verrà fatto il link. myapp_LDADD = $(LIB_KFILE) $(LIB_TDEPRINT) # quali file sorgente dovrebbero essere compilati per myapp myapp_SOURCES = main.cpp myapp.cpp myappview.cpp # questi sono gli header per il proprio progetto noinst_HEADERS = myapp.h myappview.h # permetti ad automoc di gestire tutti i metafile (moc) METASOURCES = AUTO KDE_ICON = myapp # qui è dove andrà il file kdelnk kdelnkdir = $(kde_appsdir)/Utilities kdelnk_DATA = myapp.desktop # qui è dove vanno i file risorsa XML-GUI rcdir = $(kde_datadir)/myapp rc_DATA = myappui.rc AM_CXXFLAGS = -DMY_C++_PREPROCESSOR_OPTION Come si può vedere, molti degli elementi a destra sono simboli del tipo $(xxxx). Queste sono variabili d'ambiente che sono definite nell'attuale ambiente &kde; e vengono sostituite con i veri valori quando ./configure genera i file Makefile finali nel computer destinatario. Inoltre, è una buona idea avviare il comando ./configure --help che visualizzerà tutte le opzioni che si possono cambiare nel momento della compilazione. In particolare, il comando: ./configure --prefix=/dove/si/desidera eseguirà l'intera installazione in una struttura di directory a scelta, cambiando il valore della variabile interna $(prefix) in /dove/si/desidera. In questo capitolo si troverà una descrizione essenziale degli elementi del gestore Automake e sul loro uso. Questo comprende: La finestra del gestore Automake descrive la struttura di base della finestra principale del gestore Automake. La vista panoramica descrive gli elementi della parte superiore. La vista dettagli descrive gli elementi della parte inferiore. Navigare nel gestore Automake elenca le operazioni fondamentali che possono essere compiute con il gestore Automake. Menu a comparsa del gestore Automake descrive i menu che appaiono quando si seleziona una azione nel gestore Automake. Il gestore Automake funziona in una finestra divisa in due. La parte superiore è chiamata panoramica e la parte inferiore è chiamata dettagli. Tra esse c'è una barra sottile che può essere trascinata con il mouse per modificare la dimensione delle due finestre. Nella modalità IDEAl si può trascinare anche il lato della finestra in modo da modificarne la larghezza. Nella parte alta di entrambe le viste c'è una barra degli strumenti, nella quale i pulsanti vengono attivati quando si seleziona un elemento in quella visuale. Questo fornisce un modo per accedere alle azioni disponibili per quell'elemento. Gli altri sono menu contestuali che appaiono con il clic del tasto destro del mouse, come verrà spiegato dopo. Nella modalità IDEAl sono presenti due piccoli pulsanti in più nella parte sinistra della barra del titolo della finestra del gestore Automake — un freccia a destra a forma di triangolo e un pulsante con un punto. Il pulsante con la freccia viene usato per chiudere la finestra. Il pulsante con il punto invece manterrà la finestra aperta anche se viene selezionata un'altra finestra di &tdevelop; (Altrimenti la finestra del gestore Automake si chiuderà automaticamente quando un'altra finestra riceve il focus). La finestra panoramica contiene una lista ad albero di tutte le directory del progetto che contengono file di programma, documentazione o dati. Ogni directory contiene un file Makefile.am e viene riconosciuta dal gestore Automake come un sottoprogetto. Ci sono tre sottoprogetti tipici in un progetto di tipo &kde;, come mostrato nella illustrazione precedente: src – file sorgente dell'applicazione. doc – manuale utente o guida, po – estratti delle stringhe dei file sorgente che devono essere tradotte in altri linguaggi umani (⪚ titoli delle finestre, nomi di menu, etichette dei pulsanti, testi delle finestre di dialogo e messaggi di vario tipo). Notare che il sottoprogetto doc ha sempre un sottoprogetto en, che si può vedere se si fa clic sul simbolo + vicino alla parola doc. Questo è dovuto al fatto che il linguaggio di base di tutta la documentazione &kde; è l'inglese (en). Se la propria applicazione farà parte di &kde;, le squadre di traduzione potranno tradurre la documentazione dall'inglese in altri linguaggi e queste le traduzioni saranno inserite in altri sottoprogetti, come de (Tedesco) o fr (Francese). Anche le stringhe nel sottoprogetto po potranno essere tradotte e memorizzate, consentendo quindi all'applicazione di essere utilizzata dalle persone che non conoscono l'inglese. I sottoprogetti doc e po servono a diversi scopi: doc contiene la documentazione come il manuale utente, mentre po contiene le stringhe di testo traducibili dell'interfaccia utente che è integrata nel codice sorgente dell'applicazione. La finestra panoramica funziona — tra le altre cose — come strumento di navigazione. Se si seleziona un sottoprogetto nella finestra panoramica verranno visualizzati i dettagli corrispondenti nella finestra dettagli. Questa finestra contiene una lista ad albero di tutti i file del sottoprogetto selezionato nella finestra panoramica, così come le regole di compilazione e installazione del sottoprogetto. Quindi le due visuali assieme forniscono un accesso a tutti i componenti dell'applicazione e a tutte le informazioni per compilarla e installarla. La lista ad albero nella finestra dettagli ha due livelli. Il livello principale è composto dai cosiddetti target e il sottolivello contiene la lista dei file che andranno a costruire quel target. Il concetto di target per il gestore Automake differisce da quello dei target dei file Makefile. In breve: Il modo in cui deve essere compilato o installato un insieme di file è chiamato target nel Gestore Automake, mentre viene rappresentato come variabile nello stesso Automake. In make un target è spesso qualcosa di completamente differente, essendo il parametro di un comando make (ad es. make install, make clean). Comunque, alcune variabili di Makefile.am rappresentano un sub-target in make. In entrambe le finestre panoramica e dettagli si può fare clic con il tasto sinistro sul simbolo + o - vicino ad un sottoprogetto o al nome di un target per espandere o raggruppare la vista ad albero. Se lo si fa con un sottoprogetto nella finestra panoramica, verrà mostrato o nascosto il sottoprogetto del livello più basso (se esiste). Se lo si fa con un target nella finestra dettagli, verrà mostrata o nascosta la lista dei file relativi di quel target. Aprire un file per la modifica Se si fa clic con il &LMB; sul nome di un file nella finestra dettagli, verrà aperto nella finestra dell'editor di &tdevelop;. Attivare i pulsanti della barra degli strumenti del gestore Automake Se si fa clic con il &LMB; sul nome di un sottoprogetto nella finestra panoramica oppure sul nome di un target nella finestra dettagli, il nome verrà evidenziato e saranno resi attivi alcuni pulsanti nella barra degli strumenti nella parte superiore di quella finestra. È raccomandato l'uso del pulsante destro del mouse e dei menu a comparsa al posto dei pulsanti della barra degli strumenti, poiché risulta più semplice vedere e capire quello che si sta facendo. Le operazioni sui sottoprogetti e sui target hanno effetti molto estesi sulla struttura, la compilazione e l'installazione dell'applicazione. Selezionare Azioni/Menu a comparsa Se si fa clic con il &RMB; del mouse sul nome di un sottoprogetto, target o file apparirà un menu a comparsa con il quale si potranno selezionare le azioni da eseguire su un sottoprogetto, target o file, come aggiungere un target ad un sottoprogetto, aggiungere un file ad un target o rimuovere logicamente il file selezionato dal suo target. Le sezioni seguenti illustreranno brevemente le operazioni disponibili nei menu contestuali che appaiono quando si fa clic con il tasto destro del mouse nella finestra del Gestore Automake. Questa è solo una panoramica generale, si troveranno le descrizioni dettagliate della maggior parte delle operazioni in un successivo capitolo. Quando si fa clic con il &RMB; sul nome di un file nella finestra dettagli, apparirà il seguente menu a comparsa che permette di scegliere una operazione da effettuare su quel file. Nell'illustrazione seguente viene selezionato il file icona hi-16app-kdevel.png del target Dati icona in kde_icon del sottoprogetto myapp/src. La voce principale del menu a comparsa per un file è Rimuovi, che rimuove un file dal suo target (cioè non verrà più usato per compilare, costruire o installare quel target). La voce CVS fornisce una serie di operazioni CVS per quel file. La voce Apri con permette di aprire il file con diversi editor o applicazioni (ad es. si può aprire il file icona dell'esempio con TDEIcon). La voce Perforce è usata in operazioni simili a quelle del CVS, usando il version control system commerciale Perforce. Quando si fa clic con il tasto destro su un target nella finestra dettagli apparirà il seguente menu, che permetterà di selezionare una delle operazioni da effettuare. Nell'illustrazione seguente è stato selezionato il target myapp (Programma in bin) del sottoprogetto myapp/src. La voce Opzioni per un target riguarda solo i file sorgente. Nella finestra di dialogo corrispondente si può specificare i flag del linker, i percorsi per localizzare le librerie e si può fornire una lista di librerie con cui effettuare il link nell'applicazione. La voce Crea nuovo file mostrerà una finestra di dialogo nella quale si potrà impostare il nome e il tipo di file che sarà generato (da una lista). La voce Aggiungi file esistenti visualizza una finestra di dialogo nella quale si può aggiungere al progetto dei file esistenti. La voce Rimuovi per un target permette di rimuovere logicamente un target e tutti i suoi file dalla struttura del progetto. La voce Rendi target attivo si riguarda solo i target che contengono codice sorgente. I nuovi file verranno sempre aggiunti ad un target attivo. La voce Compila target avvia tutte le operazioni di compilazione per costruire il codice solo di questo target. Quando si fa clic con il &RMB; su un sottoprogetto nella finestra panoramica apparirà il seguente menu a comparsa che permetterà di effettuare cambiamenti alla struttura del progetto e al modo in cui sarà compilato, costruito e installato. Lo si può usare per espandere o modificare la struttura iniziale del progetto costruita dalla procedura guidata. La voce Opzioni controlla il modo in cui un sottoprogetto verrà compilato, costruito e installato. La finestra di dialogo che appare possiede le etichette per le opzioni che riguardano la compilazione, le directory include, i prefissi e l'ordine di costruzione. La voce Aggiungi sottoprogetto crea una nuova directory e lo scheletro di un file Makefile.am. La voce Aggiungi Target fa comparire una finestra di dialogo con la quale si possono impostare le regole per la compilazione, la costruzione o l'installazione di un gruppo di file all'interno del sottoprogetto. Aggiungi servizio (... da scrivere ...) Aggiungi Applicazione (... da scrivere ...) Aggiungi sottoprogetti esistenti (... da scrivere ...) Il modo appropriato per rimuovere un sottoprogetto consiste nell'uso della voce Elimina sottoprogetto del menu a comparsa del un sottoprogetto. Verranno corretti i file Makefile.am. Sarà mostrata l'opzione di cancellare tutti i file (o collegamenti) della directory corrispondente. Ovviamente, questa caratteristica dovrebbe essere usata con cautela. La voce Compila avvia le operazioni necessarie per compilare solo il codice di quel sottoprogetto. Forza Reedit (... da scrivere ...) Ripulisci (... da scrivere ...) Installa (... da scrivere ...) Installa (come superutente) (... da scrivere ...) autoproject gestore Automake Autoconf Libtool (... da scrivere ...) script configure script config.status Makefile.in config.h.in da Makefile.in a Makefile prefix = @prefix@ INSTALL = @INSTALL@ build_triplet = @build@ CXX = @CXX@ prefix = /home/bernd/kde3 INSTALL = /usr/bin/ginstall -c -p build_triplet = i686-pc-linux-gnu CXX = g++ da config.h.in a config.h /* Define if you have libz */ #undef HAVE_LIBZ /* The size of a `int', as computed by sizeof. */ #undef SIZEOF_INT /* Define if you have libz */ #define HAVE_LIBZ 1 /* The size of a `int', as computed by sizeof. */ #define SIZEOF_INT 4 (... da scrivere ...)

-rpath PIC static plugins: no-undefined Makefile build.xml (... da scrivere ...) (... da scrivere ...) (... da scrivere ...)