# Installare &kdevelop;

In questo capitolo saranno illustrate tutte le fasi per la compilazione e l'installazione di &kdevelop;:

- Come ottenere &kdevelop; illustra lo scaricamento dei sorgenti di &kdevelop; dal CVS.

- I requisiti di &kdevelop; che comprendono i programmi e le librerie che devono essere installate per compilare con successo l'IDEA.

- Compilazione e installazione di &kdevelop; che spiega la procedura di compilazione e installazione.

- Come ottenere la documentazione API di &kdevelop; indica cosa è un'API e come ottenere un tale strumento per navigare attraverso i sorgenti di &kdevelop;.

## Come ottenere &kdevelop;

&kdevelop; è disponibile in formato binario in molte distribuzioni &Linux; come SuSE, RedHat e altre. Questi file sono impacchettati in formati comodi da installare, principalmente RPM. Per installarli seguire le istruzioni standard fornite con la propria distribuzione.

Si possono anche ottenere i sorgenti di &kdevelop;, compilarli ed installarli personalmente. Possono essere trovati attraverso la home page del progetto http://www.kdevelop.org o attraverso il sito ftp di &kde;.

### Scaricare gli snapshot giornalieri di &kdevelop; dal &CVS;

Se si vuole rimanere sempre aggiornati con lo sviluppo corrente,sono disponibili gli snapshot attraverso il deposito anonymous &CVS;. Il nome del modulo è kdevelop in `:pserver:anonymous@anoncvs.kde.org:/home/kde`.

#### Controllo iniziale del &CVS;

Per ottenere una versione iniziale di &kdevelop; la si deve scaricare (questa è la cosiddetta operazione di checkout) da un anonymous &CVS;. Seguire questa procedura.

In seguito si presumerà che si voglia installare la propria copia di &kdevelop; nella sottodirectory `kde3src` della propria directory home `~`.

- # Creare la directory di destinazione, se necessario:
- `~>` `mkdir kde3src`
- `~>` `cd kde3src`
- `~/kde3src>` `cvs -z3 -d :pserver:anonymous@anoncvs.kde.org:/home/kde co kdevelop`
- `~/kde3src>` `cd kdevelop`

Una volta effettuato il checkout della versione di &kdevelop; si può stare al passo con i cambiamenti usando la procedura di aggiornamento che sarà mostrata nella prossima sezione.

Mantenere basso il carico sul server. Si prega di non effettuare il checkout tutte le volte che si vuole aggiornare &kdevelop;!: usare invece il comando CVS update.

Ora si può compilare la propria versione di &kdevelop; come mostrato nel capitolo Compilazione e installazione di &kdevelop;.

#### Mantenere la propria copia &CVS; aggiornata

Dopo aver fatto il checkout (e compilato con successo) &kdevelop; da CVS come mostrato prima, può essere mantenuto aggiornato in modo da installare tutte le patch. Seguire questa procedura. (Anche in questo caso si presume che si abbia la propria copia di &kdevelop; nella directory `kde3src`).

Notare il comando `up` (= update) al posto del comando `co` (che indica checkout).

- `~>` `cd kde3src`
- `~/kde3src>` `cvs -z3 -d :pserver:anonymous@anoncvs.kde.org:/home/kde up kdevelop`
- `~/kde3src>` `cd kdevelop`

Tenere sotto controllo i messaggi che sono prodotti da &CVS; durante la sequenza di aggiornamento. Da essi dipende l'esatta sequenza di compilazione.

Ora si può compilare una nuova versione di &kdevelop; come mostrato nel capitolo Considerazioni speciali per la compilazione &CVS;.

## Requisiti di &kdevelop;

Per compilare con successo e usare &kdevelop; sono necessari i seguenti programmi e librerie. Sono disponibili per la maggior parte delle distribuzioni e facili da installare.

## Requisiti:

- gcc/g++ ≥ 2.95.3 (o compatibile)

  Disponibile nel sito gcc.gnu.org

- &GNU; make (o compatibile)

  Disponibile nel sito www.gnu.org/software/make

- &perl; 5.004 (o maggiore)

  Disponibile nel sito www.perl.com

- autoconf ≥ 2.52 (o maggiore)

  Disponibile nel sito www.gnu.org/software/autoconf

- automake ≥ 1.6 (o maggiore)

  Disponibile nel sito www.gnu.org/software/automake

- flex 2.5.4 (o maggiore)

  Disponibile nel sito www.gnu.org/software/flex

- &Qt; ≥ 3.0.3 (o maggiore)

  Disponibile nel sito www.trolltech.com/products/qt

- KDE ≥ 3.0.2 (o maggiore)

  Disponibile nel sito www.kde.org

## Opzionali:

- Lo strumento di navigazione dei sorgenti ctags, scaricabile da http://ctags.sourceforge.net, che fornisce un veloce accesso alle dichiarazioni e alle definizioni attraverso dei semplici clic su un nome nell'editor.

- dot, un compilatore di linguaggio grafico http:/www.graphviz.org. Se si vuole avere una visualizzazione grafica delle relazioni tra classi (altamente raccomandata), è necessario utilizzare questo strumento insieme a &doxygen;.

- Lo strumento per la documentazione &doxygen; http://www.doxygen.org, necessario se si vuole generare una potente e precisa documentazione API dei propri progetti.

- valgrind http://developer.kde.org/~sewardj/ aiuta a trovare i problemi di gestione della memoria nelle proprie applicazioni.

- CVS dal sito http://www.cvshome.org se si vuole usare il &CVS; versioning system.

- Altri compilatori e/o strumenti nel caso si voglia sviluppare in un altro linguaggio/piattaforma diverso da C++/&kde; oppure usare qualche funzione speciale.

1. Si può aggirare il vincolo per &autoconf; ≥ 2.52 e &automake; ≥ 1.6 così: rimuovere la directory `admin` nella directory di installazione di &kdevelop; e scrivere

   - `(directory-di-kdevelop)>` `ln -s $KDEDIR/share/apps/kdelibs/admin admin`

   alla console. Questo farà sì che &kdevelop; usi le impostazioni standard nella directory `admin` di &kde;.

2. Si presti attenzione a non mescolare versioni diverse di &Qt;. Collegare sempre &kdevelop; alla stessa versione delle librerie &Qt; con cui sono state compilate le librerie &kde;, altrimenti probabilmente si otterranno comportamenti anomali.

## Compilazione e installazione di &kdevelop;

Quando tutti i requisiti sono stati soddisfatti, si può compilare e installare &kdevelop;. Questo capitolo esaminerà le fasi di questa procedura.

- Nelle fasi preliminari viene spiegato come impostare le variabili d'ambiente appropriate.

- La compilazione di &kdevelop; comprende lo scaricamento dei sorgenti dal &cvs; e la procedura di compilazione e installazione.

- Le opzioni di configure permettono di eseguire &kdevelop; anche se viene installato in una posizione diversa dalla directory di &kde;.

### Fasi preliminari

Prima di addentrarsi nella sequenza di compilazione è necessario assicurarsi che siano disponibili tutte le librerie e gli strumenti per make. Per realizzarlo è necessario che alcune variabili d'ambiente siano impostate correttamente. Le procedura dipende dalla shell usata.

Per evitare di scrivere tutti i comandi necessari ad impostare le variabili d'ambiente ogni volta che si compila, dovrebbero essere inseriti nel proprio file `.bashrc` o `.csgrc`. In questo modo le variabili d'ambiente verranno impostate correttamente ogni volta che viene avviata la shell.

#### Impostare le variabili per la shell bash

Se si usa la shell bash aggiungere le linee seguenti:

- `export KDEDIR=`(percorso dell'installazione di KDE)
- `export QTDIR=`(percorso della libreria Qt)
- `export LD_LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LD_LIBRARY_PATH`
- `export LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LIBRARY_PATH`
- `export PATH=$QTDIR/bin:$KDEDIR/bin:$PATH`

#### Impostare le variabili per la shell tcsh

Se si usa la shell tcsh aggiungere le linee seguenti:

- `setenv KDEDIR` (percorso dell'installazione di KDE)
- `setenv QTDIR` (percorso della libreria Qt)
- `setenv LD_LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LD_LIBRARY_PATH`
- `setenv LIBRARY_PATH $QTDIR/lib:$KDEDIR/lib:$LIBRARY_PATH`
- `setenv PATH $QTDIR/bin:$KDEDIR/bin:$PATH`

### Compilare &kdevelop;

Si presume che in seguito la propria copia dei sorgenti di &kdevelop; sarà messa nella directory `~/kde3src/kdevelop`.

#### Considerazioni speciali per la compilazione &CVS;

Se si usa uno snapshot dal &CVS;, le fasi iniziali della compilazione dipendono dal fatto che si sia eseguito di un checkout completo oppure un aggiornamento dei soli sorgenti.

#### Dopo un checkout CVS

Si dovrebbe inizializzare il sistema make dopo un recente checkout. Questo è vero anche ogni volta che si deve ricominciare da zero. Scrivere:

- `~/kde3src/kdevelop>` `make -f admin/Makefile.common cvs-clean`

e dopo seguire tutte le fasi seguenti.

Se si deve ricostruire qualche file danneggiato o mancante, potrebbe essere necessario avere accesso al deposito &CVS;.

Il comando `cvs-clean` rimuoverà tutti i file non presenti nel &CVS; della directory! Assicurarsi di effettuare un backup di tutte le informazioni importanti prima di inviare questo comando.

#### Dopo un aggiornamento CVS

La fase seguente dipende dall'output della sequenza di aggiornamento di &CVS;. Se si riceve qualcosa di simile (notare il contrassegno U o P a sinistra, che indica il cambiamento del file):

    U /percorso_directory/Makefile.am

oppure se si è eseguito un checkout completo si deve scrivere:

- `~/kde3src/kdevelop>` `make -f Makefile.cvs`

prima di procedere con tutte le fasi successive.

#### Sequenza dei principali comandi `make`

Una volta che il sistema make è impostato si deve decidere che tipo di &kdevelop; si vuole usare. Questo viene fatto nella seguente fase di compilazione che costruisce i `Makefile` usati dal comando `make`.

Se si vuole che &kdevelop; venga installato nella directory di default di &kde; si può tralasciare l'opzione `--prefix` nelle seguenti linee di comando di `configure`. Vedere il capitolo Alcune note sulle opzioni di configure.

#### Versione compilata con il supporto per il debug

Se si vuole tenere traccia di cosa succede a &kdevelop; a runtime si potrebbe compilare una versione con il supporto per il debug, indicandolo a `configure` così:

- `~/kde3src/kdevelop>` `./configure --enable-debug=full --prefix=`(dove-si-trova-kde3)

#### Una versione compilata release

Se si desidera solo usare &kdevelop; così com'è sarà sufficiente una versione release (più piccola e più veloce). É la versione di default.

- `~/kde3src/kdevelop>` `./configure --prefix=`(dove-si-trova-kde3)

Se si vuole costruire la propria documentazione API per &kdevelop;, si deve includere anche un'altra opzione nel comando `configure`:

- `~/kde3src/kdevelop>` `./configure --`(opzioni come sopra) `\`
- `--with-kdelibsdoxy-dir=$KDEDIR/share/doc/HTML/en/kdelibs-apidocs`

#### Compilare e installare &kdevelop;

`configure` controllerà il sistema e costruirà un file `Makefile` in base a quello che rileverà. Il comando `make` per default userà questo `Makefile`. Quindi

- `~/kde3src/kdevelop>` `make`

È sufficiente. A questo punto, se necessario, ottenere i diritti dell'utente root con:

- `~/kde3src/kdevelop>` `su`

e inserire la password di root. Quindi installare l'applicazione:

- `~/kde3src/kdevelop>` `make install`

Questo è tutto. Se &kdevelop; è stato installato nella directory di default di &kde; si può avviare l'IDE. In caso contrario devono essere eseguiti ulteriori comandi come mostrato nella sezione Directory di installazione non di default.

In realtà vengono generalmente installate tre applicazioni relative a &kdevelop;:

- L'IDE di &kdevelop; — è l'applicazione che si usa normalmente per lavorare.

- L'Assistente di &kdevelop; — racchiude in una applicazione separata tutti gli strumenti per la documentazione di &kdevelop;. È utile quando si vuole consultare qualche argomento relativo alla programmazione senza dover avviare l'IDE.

- Il Designer di &kdevelop; — espande il Designer &Qt; con elementi specifici di &kde; e si integra facilmente con l'IDE di &kdevelop;.

### Alcune note sulle opzioni di `configure`

#### Directory di installazione non di default

Per default `configure` predispone l'installazione dell'IDE nella directory di default di &kde;. Questo è necessario perchè &kdevelop; accede direttamente ad alcuni strumenti e componenti che risiedono lì. Se si vuole usare una propria directory di installazione, lo si deve indicare a `configure` attraverso l'opzione `--prefix`:

- `~/kde3src/kdevelop>` `./configure --prefix=`(dove-si-trova-kde3)

Come controindicazione si deve fornire a &kdevelop; un sistema per accedere agli strumenti e ai componenti necessari situati nella directory di &kde;. (Si può sempre usare l'IDE senza farlo, ma le sue capacità saranno molto limitate).

Accedere alla shell ed eseguire i seguenti comandi prima di avviare &kdevelop; al prompt.

Assicurarsi di usare il plurale: è `KDEDIRS`, non `KDEDIR`

- `~>` `export KDEDIRS=/usr/local/kde:/opt/kde3`
- `~>` `kbuildsycoca`
- (Ora avviare &kdevelop;:)
- `~>` `kdevelop`

- La variabile d'ambiente `KDEDIRS` deve essere impostata con l'elenco delle directory &kde; del proprio sistema. Sono state usate le directory
- `/usr/local/kde`:`/opt/kde3`
- solo come esempio.
- La directory `/usr/local/kde` potrebbe ad esempio contenere una versione incompleta di &kde; compilata per effettuare il debug, e la directory `/opt/kde3` potrebbe contenere la versione &kde; standard della propria distribuzione usata per il lavoro di tutti i giorni.

Nella shell tcsh si deve impostare la variabile d'ambiente così:

- `~>` `setenv KDEDIRS /usr/local/kde:/opt/kde3`

Il comando `kbuildsycoca` (build system control cache) cerca le librerie e conserva in cache le loro posizioni e versioni in modo che &kdevelop; le possa trovare. Questa operazione può portare via parecchio tempo - e deve essere fatto ogni volta che si avvia la shell. Si potrebbero mettere i comandi sopra in uno script della shell per risparmiare fatica.

(Non è consigliabile inserire questi comandi nel file `.bashrc` o `.cshrc`, poiché `kbuildsycoca` verrebbe eseguito ogni volta che si chiama la shell).

Il comando `kbuildsycoca` non viene eseguito come root, quindi deve essere avviato da un utente non root. (Dopo tutto non è affatto una buona idea sviluppare applicazioni come utente root!)

## Come ottenere la documentazione API di &kdevelop;

API è l'abbreviazione di Application Program Interface. In realtà una interfaccia di programmazione delle applicazioni è una serie di descrizioni (cioè un insieme di chiamate) con le quali una applicazione accede al sistema operativo e ad altri servizi. In questo contesto tuttavia viene adottata una definizione più ampia: le API di una applicazione &kde; o &Qt; sono un riassunto delle interfacce delle classi e dei metodi, un sommario da usare come dizionario per navigare tra i sorgenti.

L'ultima versione delle API è presente nel sito web di KDevelop. Sono automaticamente aggiornate ogni 24 ore.

Se non si possiede sempre un accesso a Internet si può anche costruire la documentazione API dai sorgenti di &kdevelop;. Per farlo si deve indicare al sistema automake la posizione delle API di KDELIBS nel proprio sistema. Questo può essere fatto con la speciale opzione `--with-kdelibsdoxy-dir` del comando `configure` quando si stanno compilando i sorgenti di &kdevelop;:

- `~/kde3src/kdevelop>` `./configure --`(solite-opzioni)`\`
- `--with-kdelibsdoxy-dir=$KDEDIR/share/doc/HTML/en/kdelibs-apidocs`

(`make` sostituirà `$KDEDIR` con l'attuale directory di &kde;). Poi chiamare il comando `make` come al solito. Dopo che l'IDE &kdevelop; è stato compilato si avrà l'opzione di compilare anche le API. Per questo si deve scrivere

- `~/kde3src/kdevelop>` `make apidocs`

Questo costruirà nella directory di base di &kdevelop; un `Doxyfile` che verrà successivamente elaborato dall'applicazione Doxygen per costruire una serie di file `.html`. Quando il processo della costruzione delle API giunge alla fine (su un sistema lento potrebbe durare più di un'ora) dovranno essere installate, in modo simile all'installazione di &kdevelop;. Se necessario ottenere i diritti di superutente con

- `~/kde3src/kdevelop>` `su`

e inserire la password di root. Quindi installare i file API con

- `~/kde3src/kdevelop>` `make install-apidox`

Una volta fatto, `make` indicherà la directory dove si potranno vedere i contenuti della documentazione delle API. Prendere nota dell'indirizzo, in modo da poterlo usare con &konqueror; e all'interno di &kdevelop;.

Si vedranno molto probabilmente molti avvertimenti e/o messaggi d'errore durante la costruzione delle API effettuata con Doxygen. Conviene ignorarli, essendo di interesse solo per gli sviluppatori di &kdevelop;. Se la generazione delle API giunge alla fine con successo, si potranno usare i file `.html`.