<?xml version="1.0" ?>
<!DOCTYPE book PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN" "dtd/kdex.dtd" [
  <!ENTITY kappname "Kdesvn-build">
  <!ENTITY package "kdesdk">
  <!ENTITY % addindex "IGNORE">
  <!ENTITY % Italian "INCLUDE"
> <!-- Change language only here -->
  <!ENTITY kdesvn-build "<application
>Kdesvn-build</application
>">
  <!ENTITY autoconf '<application
>Autoconf</application
>'>
  <!ENTITY automake '<application
>Automake</application
>'>
  <!ENTITY BSD '<acronym
>BSD</acronym
>'>
  <!ENTITY cmake '<application
>CMake</application
>'>
  <!ENTITY make '<application
>Make</application
>'>
  <!ENTITY ssh '<application
>SSH</application
>'>
  <!ENTITY subversion '<application
>Subversion</application
>'>
  <!ENTITY sudo '<application
>Sudo</application
>'>
  <!ENTITY unsermake '<application
>Unsermake</application
>'>
  <!ENTITY url '<acronym
>URL</acronym
>'>

  <!-- These define shortcut entities for some of the configuration options.
       Just add them as necessary.
  -->

  <!ENTITY configure-flags '<link linkend="conf-configure-flags"
>configure-flags</link
>'>
  <!ENTITY apply-qt-patches '<link linkend="conf-apply-qt-patches"
>apply-qt-patches</link
>'>
  <!ENTITY kdedir '<link linkend="conf-kdedir"
>kdedir</link
>'>
  <!ENTITY qtdir '<link linkend="conf-qtdir"
>qtdir</link
>'>
  <!ENTITY build-dir '<link linkend="conf-build-dir"
>build-dir</link
>'>
  <!ENTITY module-base-path '<link linkend="conf-module-base-path"
>module-base-path</link
>'>
  <!ENTITY override-url '<link linkend="conf-override-url"
>override-url</link
>'>
  <!ENTITY source-dir '<link linkend="conf-source-dir"
>source-dir</link
>'>
  <!ENTITY email-address '<link linkend="conf-email-address"
>email-address</link
>'>
  <!ENTITY email-on-compile-error '<link linkend="conf-email-on-compile-error"
>email-on-compile-error</link
>'>
  <!ENTITY colorful-output '<link linkend="conf-colorful-output"
>colorful-output</link
>'>
  <!ENTITY tag '<link linkend="conf-tag"
>tag</link
>'>
  <!ENTITY apidox '<link linkend="conf-apidox"
>apidox</link
>'>
  <!ENTITY branch '<link linkend="conf-branch"
>branch</link
>'>
  <!ENTITY no-rebuild-on-fail '<link linkend="conf-no-rebuild-on-fail"
>no-rebuild-on-fail</link
>'>
  <!ENTITY inst-apps '<link linkend="conf-inst-apps"
>inst-apps</link
>'>
  <!ENTITY do-not-compile '<link linkend="conf-do-not-compile"
>do-not-compile</link
>'>
  <!ENTITY checkout-only '<link linkend="conf-checkout-only"
>checkout-only</link
>'>
  <!ENTITY svn-server '<link linkend="conf-svn-server"
>svn-server</link
>'>
  <!ENTITY make-install-prefix '<link linkend="conf-make-install-prefix"
>make-install-prefix</link
>'>
  <!ENTITY niceness '<link linkend="conf-niceness"
>niceness</link
>'>
  <!ENTITY set-env '<link linkend="conf-set-env"
>set-env</link
>'>
  <!ENTITY libpath '<link linkend="conf-libpath"
>libpath</link
>'>
  <!ENTITY binpath '<link linkend="conf-binpath"
>binpath</link
>'>
  <!ENTITY use-unsermake '<link linkend="conf-use-unsermake"
>use-unsermake</link
>'>

  <!-- These define shortcut entities for some of the command line options.
       Just add them as necessary.
  -->
  <!ENTITY cmd-nice '<link linkend="cmdline-nice"
>--nice</link
>'>
  <!ENTITY cmd-ignore-modules '<link linkend="cmdline-ignore-modules"
>--ignore-modules</link
>'>
  <!ENTITY cmd-resume-from '<link linkend="cmdline-resume-from"
>--resume-from</link
>'>
  <!ENTITY cmd-no-rebuild-on-fail '<link linkend="cmdline-no-rebuild-on-fail"
>--no-rebuild-on-fail</link
>'>
  <!ENTITY cmd-reconfigure '<link linkend="cmdline-reconfigure"
>--reconfigure</link
>'>
  <!ENTITY cmd-refresh-build '<link linkend="cmdline-refresh-build"
>--refresh-build</link
>'>
]>

<book lang="&language;">

<bookinfo>
<title
>Manuale dello script &kdesvn-build;</title>

<authorgroup id="authors">
<author
><firstname
>Michael</firstname
><surname
>Pyne</surname
> <affiliation
><address
><email
>michael.pyne@kdemail.net</email
></address
></affiliation>
</author
> 
<author
><firstname
>Carlos</firstname
><surname
>Woelz</surname
> <affiliation
><address
><email
>carloswoelz@imap-mail.com</email
></address
></affiliation>
</author
> 


<othercredit role="translator"
><firstname
>Federico</firstname
><surname
>Zenith</surname
><affiliation
><address
><email
>zenith@chemeng.ntnu.no</email
></address
></affiliation
><contrib
>Traduzione della documentazione in italiano</contrib
></othercredit
> 

</authorgroup>

<copyright>
<year
>2006</year>
<year
>2007</year>
<year
>2008</year>
<holder
>Michael Pyne</holder>
</copyright>

<copyright>
<year
>2005</year>
<holder
>Carlos Woelz</holder>
</copyright>


<legalnotice
>&FDLNotice;</legalnotice>

<date
>2008-08-09</date>
<releaseinfo
>1.6.3</releaseinfo>

<abstract>
<para
>&kdesvn-build; è uno script che genera e installa &kde; direttamente dal codice sorgente del deposito &subversion; di &kde;.</para>
</abstract>

<keywordset>
<keyword
>KDE</keyword>
<keyword
>kdesdk</keyword>
<keyword
>SVN</keyword>
<keyword
>Subversion</keyword>
<keyword
>Sviluppo di KDE</keyword>
</keywordset>

</bookinfo>

<chapter id="introduction">
<title
>Introduzione</title>

<para
>&kdesvn-build; è uno script che aiuta gli utenti ad installare <ulink url="http://www.kde.org/"
>&kde;</ulink
> dal suo deposito <ulink url="http://subversion.tigris.org/"
>&subversion;</ulink
> del codice sorgente. </para>

<para
>Qui documentiamo la sintassi e le opzioni del <link linkend="configure-data"
>file di configurazione</link
> di &kdesvn-build;, le sue <link linkend="cmdline"
>opzioni alla riga di comando</link
>, le sue <link linkend="features"
>funzionalità</link
>, e una <link linkend="getting-started"
>panoramica</link
> di tutti i passi necessari a generare &kde; dal codice sorgente, inclusi i passi che dovresti effettuare con altri strumenti, cioè quelli non effettuati automaticamente dallo script &kdesvn-build;. </para>

</chapter>

<chapter id="getting-started">
<title
>Per cominciare</title>

<para
>In questo capitolo, mostriamo come usare &kdesvn-build; per ritirare i moduli dal deposito di &kde; e generarli. Diamo anche una rapida spiegazione della struttura del deposito &subversion; di &kde; e di cosa devi fare prima di eseguire lo script. </para>

<para
>Tutti gli argomenti qui presenti sono trattati in maggiore dettaglio nella <ulink url="http://quality.kde.org/develop/cvsguide/buildstep.php"
>guida a generare &kde; dai file sorgente</ulink
>, al <ulink url="http://quality.kde.org"
>sito Web della squadra di qualità di &kde;</ulink
>. Se stai compilando &kde; per la prima volta, è una buona idea leggerla, o almeno consultarla come riferimento. Troverai informazioni dettagliate sugli strumenti di gestione dei pacchetti e su requisiti, errori comuni di compilazione, strategie e informazioni su come far funzionare la tua nuova installazione di &kde;. </para>

<para
>Inoltre, il wiki <ulink url="http://techbase.kde.org/"
>&kde; TechBase</ulink
> mantiene una procedura per <ulink url="http://techbase.kde.org/index.php?title=Getting_Started/Build/KDE4"
>generare &kde; dal codice sorgente</ulink
>. </para>

<sect1 id="before-building">
<title
>Preparare il sistema per la generazione di &kde;</title>

<sect2 id="before-building-users">
<title
>Configurare un nuovo account utente</title>

<para
>Si raccomanda di scaricare e generare &kde; usando un account utente a parte. Se hai già installato i pacchetti di &kde;, la scelta migliore sarebbe creare un utente diverso (apposito) per generare ed avviare il nuovo &kde;. Il vantaggio di generare &kde; con un utente apposito è che non puoi rovinare il sistema di base, e avrai sempre il modo di continuare a lavorare tranquillamente anche se qualcosa va storto. </para>

<para
>In seguito, se vorrai, potrai fare un'installazione di sistema. Questo documento non considera l'installazione di sistema. Se stai facendo un'installazione per tutto il sistema, dovresti già sapere cosa stai facendo. Altrimenti, dovresti consultare la documentazione o i siti di supporto della tua distribuzione per per preparare e usare il sistema correttamente. </para>

</sect2>
<sect2 id="before-building-preparation">
<title
>Assicurati che il tuo sistema sia pronto a generare il sorgente di &kde;</title>

<para
>Prima di usare lo script &kdesvn-build; (o qualsiasi altra strategia di generazione) devi installare gli strumenti di sviluppo e le librerie necessarie a &kde;. L'elenco completo degli strumenti necessari può essere recuperato dalla pagina dei <ulink url="http://www.kde.org/info/requirements/3.5.php"
>requisiti di compilazione di &kde;</ulink
>). I requisiti per la serie 4 di &kde; si possono ottenere dal sito <ulink url="http://techbase.kde.org/"
>KDE TechBase</ulink
>. </para>

<para
>Ecco un elenco di alcune delle cose che ti serviranno:</para>
<itemizedlist>

<listitem
><para
>Se stai generando &kde; 3, ti serviranno gli Autotools GNU (cioè &automake; e &autoconf;).</para
></listitem>

<listitem
><para
>Se stai generando &kde; 4, ti servirà &cmake;. La versione richiesta cambierà a seconda di quale versione di &kde; stai generando, vedi il sito TechBase per le informazioni specifiche.</para
></listitem>

<listitem
><para
>Il programma client &subversion;, incluso il supporto per l'HTTP sicuro (https). Per assicurarti di avere il supporto necessario, puoi eseguire <userinput
><command
>svn <option
>--version</option
></command
></userinput
>. Se il modulo <filename
>ra_dav</filename
> dice che può gestire lo schema https, sei a posto.</para
></listitem>

<listitem
><para
>Il compilatore <application
>gcc</application
>, con supporto per C++. Le versioni dalla 3.3 in avanti sono le meglio supportate.</para
></listitem>

<listitem
><para
>Assicurati di controllare la pagina dei <ulink url="http://www.kde.org/info/requirements/3.5.php"
>requisiti di compilazione di &kde;</ulink
> per assicurarti che sia inclusa ogni altra libreria necessaria.</para
></listitem>

</itemizedlist>

<para
>Un'eccezione è la libreria &Qt;. Normalmente &kdesvn-build; installerà una copia di &Qt; che tu l'abbia già installata o meno, quindi non è necessario averla. Se non vuoi usare la copia di &Qt;, devi fare queste cose: </para>

<itemizedlist>
<listitem>
  <para
>Assicurati di rimuovere il modulo qt-copy dal tuo <link linkend="configure-data"
>file di configurazione</link
>, perché non ti servirà, e averlo porterebbe via tempo alla tua generazione.</para>
</listitem>

<listitem>
  <para
>Cambia l'impostazione dell'opzione <link linkend="conf-qtdir"
>qtdir</link
> nel tuo <link linkend="configure-data"
>file di configurazione</link
> per farla puntare alla libreria &Qt; del sistema. Ciò normalmente equivale all'impostazione di $<envar
>QTDIR</envar
> sul sistema.</para>
</listitem>

<listitem>
  <para
>Se non hai già installato &Qt; sul sistema, fallo e includi qualsiasi pacchetto indicato con -dev o -devel. Ti servirà almeno &Qt; 3.3 se stai generando &kde; 3.5, o &Qt; 4.4 se stai generando &kde; 4.</para>

  <note
><para
>Se stai generando &kde; 4 si raccomanda caldamente di usare la versione qt-copy di &Qt;, assicurandosi di applicare le patch raccomandate (questa è l'impostazione predefinita, controllata dall'opzione <link linkend="conf-apply-qt-patches"
>apply-qt-patches</link
>).</para
></note>
</listitem>
</itemizedlist>

<para
>Alcuni di questi pacchetti sono divisi in librerie (o programmi) e pacchetti di sviluppo. Ti serviranno almeno il programma o la libreria, e il suo pacchetto di sviluppo. Nel dubbio, installa tutto. Le librerie di cui avrai bisogno cambieranno a seconda dei moduli che intendi generare, perché ogni modulo ha i suoi requisiti. Il sito <ulink url="http://techbase.kde.org/Getting_Started/Build/KDE4#Required_packages_from_your_distribution"
>TechBase di &kde;</ulink
> ha maggiori dettagli sugli strumenti e tecniche specifici usati per installare e trovare i programmi necessari. </para>

</sect2>

<sect2 id="before-building-prepare-script">
<title
>Configurare &kdesvn-build;</title>

<sect3 id="get-kdesvn-build">
<title
>Installare &kdesvn-build;</title>
<para
>Probabilmente hai già una versione dello script &kdesvn-build; installata sul sistema. Però, se così non è, puoi scaricarlo dalla <ulink url="http://kdesvn-build.kde.org/"
>pagina Web di &kdesvn-build;</ulink
>, o puoi trovarlo nel suo posto nel deposito del codice sorgente di &kde;.</para>

<note
><para
>&kdesvn-build; è incluso con il modulo kdesdk, e il modulo è spesso preinstallato nelle varie distribuzioni. Se hai scaricato &kdesvn-build;, assicurati di usare la versione che hai scaricato. Puoi usare l'opzione <userinput
><option
>--version</option
></userinput
> per controllare di stare usando la versione giusta.</para
></note>

<orderedlist>
<listitem
><para
>Per scaricare &kdesvn-build; dalla sua pagina Web, basta andare alla <ulink url="http://kdesvn-build.kde.org/"
>pagina Web di &kdesvn-build;</ulink
> e scaricare l'ultimo rilascio. Il rilascio è impacchettato come archivio Tar, che puoi estrarre con &ark; o <command
>tar</command
>. I contenuti dell'archivio includono lo script &kdesvn-build; e un file di configurazione campione (<filename
>kdesvn-buildrc-sample</filename
>).</para
></listitem>

<listitem
><para
>Oppure, puoi recuperare &kdesvn-build; dal suo deposito sorgente, situato a <ulink url="http://websvn.kde.org/trunk/KDE/kdesdk/scripts/"
>http://websvn.kde.org/trunk/KDE/kdesdk/scripts/</ulink
>. Questa è la cartella degli script del kit di sviluppo software di &kde;, che è la casa di &kdesvn-build;. Puoi fare clic sulla voce <filename
>kdesvn-build</filename
>, il che ti porterà a una pagina dove puoi scaricare l'ultima revisione. Fallo, e salvala in un posto comodo sul disco fisso. Fa' lo stesso per <filename
>kdesvn-buildrc-sample</filename
>, se ti serve.</para
></listitem>
</orderedlist>

<para
>Indipendentemente dal modo usato, devi assicurarti che il file <filename
>kdesvn-build</filename
> sia eseguibile. Per comodità dovresti assicurarti che sia in una cartella contenuta nella variabile d'ambiente <envar
>PATH</envar
>, altrimenti potresti ricevere messaggi che dicono che il comando non è stato trovato, o potresti lanciare per sbaglio una versione precedentemente installata.</para>
</sect3>

<sect3 id="setup-rcfile">
<title
>Preparare il file di configurazione</title>

<para
>Sebbene &kdesvn-build; non richieda la creazione di un <link linkend="configure-data"
>file di configurazione</link
>, ciò rende il lavoro molto più semplice. Usando un <link linkend="configure-data"
>file di configurazione</link
>, puoi controllare quali moduli sono installati, o rimuovere dei moduli che non vuoi installare. &kdesvn-build;, come impostazione predefinita, genera un'installazione usabile di &kde; usando delle opzioni di installazione molto generiche, che potrebbero non corrispondere alle tue necessità. Perciò è meglio usare un <link linkend="configure-data"
>file di configurazione</link
>. </para>

<para
>Il <link linkend="configure-data"
>file di configurazione </link
> dovrebbe chiamarsi <filename
>.kdesvn-buildrc</filename
>. Questo file dovrebbe venire installato nella cartella Home (<filename class="directory"
>~/</filename
>), e contenere tutti i dati di configurazione necessari per l'esecuzione dello script, come le opzioni di configurazione, di compilazione, la posizione dei sorgenti, la destinazione dell'installazione (il prefisso), i moduli da costruire, eccetera. I dati di configurazione predefiniti sono forniti nel file <filename
>kdesvn-buildrc-sample</filename
>, che puoi copiare come <filename
>~/.kdesvn-buildrc</filename
> e poi modificarlo. </para>

<para
>Puoi trovare maggiori informazioni sulla sintassi del <link linkend="configure-data"
>file di configurazione</link
> nel<xref linkend="configure-data"/> e nel<xref linkend="kdesvn-buildrc"/>. </para>

</sect3>
</sect2>
</sect1>

<sect1 id="configure-data">
<title
>Impostare i dati della configurazione</title>

<para
>Per usare &kdesvn-build;, dovresti avere un file nella tua cartella Home chiamato <filename
>.kdesvn-buildrc</filename
>, che imposta le opzioni generali e i moduli che vuoi scaricare e generare. </para>

<note
><para
>È possibile usare diversi file di configurazione per &kdesvn-build;, come descritto nel<xref linkend="kdesvn-buildrc"/>. Se hai bisogno di usare configurazioni multiple, vedi quella sezione. Qui, assumeremo che la configurazione sia salvata in <filename
>~/.kdesvn-buildrc</filename
>.</para
></note>

<para
>Il modo più semplice di procedere è usare il file <filename
>kdesvn-buildrc-sample</filename
> come modello, cambiando le opzioni globali per adattarle alle tue esigenze e cambiando anche l'elenco dei moduli da generare. </para>

<para
>Le impostazioni predefinite dovrebbero essere già appropriate per generare &kde;. Alcune impostazioni che potresti voler cambiare includono: <itemizedlist>
<listitem
><para
><link linkend="conf-binpath"
>binpath</link
>, per cambiare l'elenco di cartelle in cui si cercheranno i comandi. È la stessa cosa che la la variabile <envar
>PATH</envar
> nella shell.</para
></listitem>

<listitem
><para
><link linkend="conf-use-stable-kde"
>use-stable-kde</link
> per cambiare la versione predefinita di cui generare i moduli di &kde;. Come impostazione predefinita, &kdesvn-build; la versione di sviluppo (<quote
>trunk</quote
>) di &kde; (attualmente &kde; 4). Se vuoi generare l'ultimo rilascio stabile di &kde; invece di usare i pacchetti della tua distribuzione (attualmente il ramo 3.5 di &kde; è stabile), devi impostare questa opzione a <replaceable
>true</replaceable
>. </para
></listitem>

<listitem
><para
><link linkend="conf-kdedir"
>kdedir</link
>, che cambia la cartella di destinazione in cui &kde; sarà installato. Il valore predefinito è <filename class="directory"
>~/kde</filename
>, che è un'installazione per un solo utente.</para
></listitem>

<listitem
><para
><link linkend="conf-qtdir"
>qtdir</link
>, che controlla il percorso all'installazione di &Qt; da usare. L'impostazione predefinita è usare il modulo qt-copy del deposito &subversion; di &kde; (<filename class="directory"
>~/kdesvn/build/qt-copy</filename
>).</para>

<para
>Per le versioni di &Qt; che supportano l'installazione, questa opzione controlla anche dove installare qt-copy.</para
></listitem>

<listitem
><para
><link linkend="conf-svn-server"
>svn-server</link
>, che seleziona l'&url; da cui scaricare il codice sorgente. È utile se sei uno sviluppatore con un <ulink url="http://developer.kde.org/documentation/misc/firststepsaccount.php"
>account &subversion; di &kde;</ulink
>.</para
></listitem>
</itemizedlist>
</para>

<para
>Dopo la sezione globale c'è un elenco di moduli da generare, delimitata da delle righe <computeroutput
>module</computeroutput
> e <computeroutput
>end module</computeroutput
>. Controlla se i moduli elencati sono effettivamente quelli che vuoi generare. Le opzioni predefinite del file <filename
>kdesvn-buildrc-sample</filename
> dovrebbero essere sufficienti per avere un'installazione di &kde; piuttosto completa. Salva il risultato come <filename
>.kdesvn-buildrc</filename
> nella tua cartella Home. </para>

<para
>Se vuoi affinare il file <filename
>.kdesvn-buildrc</filename
>, consulta <xref linkend="kdesvn-buildrc"/> per informazioni dettagliate su tutte le opzioni di configurazione. </para>

</sect1>

<sect1 id="building-and-troubleshooting">
<title
>Usare lo script &kdesvn-build;</title>

<para
>Adesso sei pronto per eseguire lo script. Da una finestra di terminale, accedi come l'utente che vuoi usare per compilare &kde; ed esegui lo script: <screen
><prompt
>&percnt;</prompt
><command
>su</command
> <option
>-</option
> <replaceable
>nome utente</replaceable>
<prompt
>&percnt;</prompt
><command
>kdesvn-build</command
>
</screen>
</para>

<para
>Adesso lo script dovrebbe cominciare a scaricare il codice sorgente e a compilarlo. A seconda di quanti moduli stai scaricando, è possibile che &kdesvn-build; non riesca la prima volta che compili &kde;. Non disperare! </para>

<para
>&kdesvn-build; registra l'output di ogni comando che esegue. Come impostazione predefinita, i file di registro sono tenuti in <filename class="directory"
>~/kdesvn/log</filename
>. Per vedere cosa ha causato un errore in un modulo l'ultima volta che si è avviato &kdesvn-build;, è di solito sufficiente guardare in <filename class="directory"
>~/kdesvn/log/latest/<replaceable
>nome-modulo</replaceable
>/error.log</filename
>.</para>

<para
>In quel file, vedrai l'errore che ha impedito la generazione del modulo. Se il file dice (in fondo) che ti mancano dei pacchetti, prova ad installarli (includendo i pacchetti -dev appropriati) prima di generare quel modulo, e passa l'opzione <link linkend="cmdline-reconfigure"
>--reconfigure</link
> dopo aver installato i pacchetti mancanti.</para>

<para
>Se l'errore sembra essere un errore di generazione, è probabilmente un errore del codice sorgente di &kde;, che si spera venga risolto nel giro di pochi giorni. Se non viene risolto, manda pure una lettera a <email
>kde-devel@kde.org</email
> (è possibile ti venga richiesto di iscriverti) per segnalare l'errore di generazione.</para>

<para
>Puoi trovare altri esempi comuni di cose che possono andare storte e le relative soluzioni, oltre a suggerimenti e strategie generali per generare &kde; nella <ulink url="http://quality.kde.org/develop/cvsguide/buildstep.php#step1"
>guida passo-passo alla generazione di &kde;</ulink
>. </para>

<note
><para
>Per maggiori informazioni sulle funzionalità di registro di &kdesvn-build;, vedi <xref linkend="kdesvn-build-logging"/>.</para
></note>

</sect1>

<sect1 id="environment">
<title
>Impostare l'ambiente per far funzionare il nuovo &kde;</title>

<para
>Supponendo che tu stia usando un utente apposito per generare &kde;, e che abbia già installato una versione di &kde;, far funzionare il nuovo &kde; potrebbe essere un po' difficile, perché il nuovo deve prendere la precedenza sul vecchio. Cambia le variabili d'ambiente per assicurarti che sia così. </para>

<sect2 id="changing-profile">
<title
>Cambiare le impostazioni del profilo di avvio</title>

<important
><para
>Il file <filename
>.bash_profile</filename
> contiene le impostazioni di accesso alla popolare shell <application
>Bash</application
> usata da molte distribuzioni &Linux;. Se usi una shell diversa, potresti dover correggere i campioni forniti in questa sezione per la tua shell.</para
></important>

<para
>Apri o crea il file <filename
>.bash_profile</filename
> nella cartella Home con un qualsiasi editor di testo. Se stai generando il modulo qt-copy (che è l'impostazione predefinita), aggiungi:<programlisting>
QTDIR=<replaceable
>(percorso a cartella qt)</replaceable
>   # Come ~/kdesvn/build/qt-copy, predefinito
KDEDIR=<replaceable
>(percorso a cartella kde)</replaceable
> # Come ~/kde, predefinito
KDEDIRS=$KDEDIR
PATH=$KDEDIR/bin:$QTDIR/bin:$PATH
MANPATH=$QTDIR/doc/man:$MANPATH

# Fai la cosa giusta se LD_LIBRARY_PATH non è già impostata.
if [ -z $LD_LIBRARY_PATH ]; then
  LD_LIBRARY_PATH=$KDEDIR/lib:$QTDIR/lib
else
  LD_LIBRARY_PATH=$KDEDIR/lib:$QTDIR/lib:$LD_LIBRARY_PATH
fi

export QTDIR KDEDIRS PATH MANPATH LD_LIBRARY_PATH
</programlisting
> Oppure, se non stai generando <filename
>qt-copy</filename
> (e stai usando le librerie &Qt; del sistema), aggiungi: <programlisting
>KDEDIR=<replaceable
>(percorso a kdedir)</replaceable
>  # Come ~/kde, predefinito.
KDEDIRS=$KDEDIR
PATH=$KDEDIR/bin:$QTDIR/bin:$PATH

# Fai la cosa giusta se LD_LIBRARY_PATH non è già impostata.
if [ -z $LD_LIBRARY_PATH ]; then
  LD_LIBRARY_PATH=$KDEDIR/lib
else
  LD_LIBRARY_PATH=$KDEDIR/lib:$LD_LIBRARY_PATH
fi

export KDEDIRS PATH LD_LIBRARY_PATH
</programlisting>
</para>

<para
>Se non stai usando un utente apposito, imposta una diversa variabile $<envar
>KDEHOME</envar
> per il nuovo ambiente nel file <filename
>.bash_profile</filename
>: <programlisting
>export KDEHOME="${HOME}/.kde-svn"

# Crealo se necessario
[ ! -e ~/.kde-svn ] &amp;&amp; mkdir ~/.kde-svn
</programlisting>
</para>

<note>
<para
>Se in seguito il menu K è vuoto o troppo affollato da applicazioni della tua distribuzione, potresti dover impostare le variabili d'ambiente <acronym
>XDG</acronym
> nel tuo <filename
>.bash_profile</filename
>: <programlisting
>XDG_CONFIG_DIRS="/etc/xdg"
XDG_DATA_DIRS="${KDEDIR}/share:/usr/share"
export XDG_CONFIG_DIRS XDG_DATA_DIRS
</programlisting>

</para>
</note>

</sect2>
<sect2 id="starting-kde">
<title
>Avviare &kde;</title>

<para
>Adesso che hai adattato le impostazioni d'ambiente per usare il &kde; giusto, è importante assicurarsi che sia usato anche lo script <command
>startkde</command
> giusto. </para>

<para
>Apri il file di testo <filename
>.xinitrc</filename
> dalla cartella Home, o crealo se necessario. Aggiungi la riga: <programlisting
><command
>exec</command
> <option
>${KDEDIR}/bin/startkde</option
>
</programlisting>
</para>

<important
><para
>Su alcune distribuzioni, potrebbe essere necessario effettuare gli stessi passi con il file <filename
>.xsession</filename
>, anch'esso nella cartella Home. Ciò è vero in particolare quando si usano gestori di accesso grafici come &kdm;, <application
>gdm</application
> o <application
>xdm</application
>.</para>
</important>

<para
>Adesso, avvia il tuo nuovo &kde;: nei sistemi &BSD; e &Linux; con supporto per i terminali virtuali, le combinazioni di tasti da <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F1</keycap
></keycombo
> a <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F12</keycap
></keycombo
>vengono usate per selezionare le console virtuali dalla 1 alla 12. Ciò permette di avere più di un ambiente desktop allo stesso tempo. Le prime sei sono terminali di testo, e le seguenti sono terminali grafici. </para>

<para
>Se invece quando avvii il computer ti viene presentato un gestore grafico, puoi usare il nuovo ambiente &kde; anche se non è elencato nelle opzioni. La maggior parte dei gestori d'accesso grafici, &kdm; incluso, hanno l'opzione di usare una <quote
>sessione personalizzata</quote
> all'accesso. Con questa opzione, vengono caricate le tue impostazioni di sessione dal file <filename
>.xsession</filename
> nella tua cartella Home. Se hai già modificato il file come descritto sopra, questa opzione dovrebbe farti entrare nella nuova installazione di &kde;. </para>

<para
>Se non lo fa, c'è qualcos'altro da provare che di solito funziona: Premi <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F2</keycap
></keycombo
>, e ti troverai davanti a un terminale testuale. Accedi con l'utente dedicato e scrivi: </para>

<screen
><command
>start</command
> <option
>--</option
> <option
>:1</option
>
</screen>

<tip>
<para
>Puoi usare il &kde; dal codice sorgente e il vecchio &kde; allo stesso tempo! accedi usando il tuo utente regolare, avvia il desktop stabile di &kde;. Premi <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F2</keycap
></keycombo
> (o <keycap
>F1</keycap
>, <keycap
>F3</keycap
>, eccetera) e ti sarà presentato un terminale testuale. Accedi con l'utente &subversion; dedicato a &kde; e scrivi:</para>

<screen
><command
>start</command
> <option
>--</option
> <option
>:1</option
>
</screen>

<para
>Puoi tornare al desktop &kde; del tuo utente regolare premendo il tasto scorciatoia per il desktop già in esecuzione. Questo è normalmente <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F7</keycap
></keycombo
>, ma potrebbe anche essere <keycap
>F6</keycap
> o <keycap
>F8</keycap
>. Per tornare al tuo &kde; compilato con &kdesvn-build;, devi usare la stessa sequenza, ma con il prossimo tasto funzione. Per esempio, se hai dovuto inserire <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F7</keycap
></keycombo
> per andare al &kde; normale, devi premere <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F8</keycap
></keycombo
> per tornare al &kde; di &kdesvn-build;.</para>
</tip>

</sect2>
</sect1>

</chapter>

<chapter id="features">
<title
>Funzionalità dello script</title>

<sect1 id="features-overview">
<title
>Panoramica delle funzionalità</title>

<para
>Le funzionalità di &kdesvn-build; includono: </para>

<itemizedlist>

<listitem
><para
>Supporta i <link linkend="changing-verbosity"
>livelli di messaggi di output</link
>, da molto silenzioso a debug completo. </para
></listitem>

<listitem
><para
>&kdesvn-build; può, con l'aiuto del <ulink url="http://kdesvn-build.kde.org/"
>sito Web di &kdesvn-build;</ulink
> e del server FTP di &kde; (FTP dalla versione 1.4 di &kdesvn-build;), permettere il ritiro rapido di alcuni moduli. Se il modulo che stai ritirando è già stato preparato sul sito Web, &kdesvn-build; ne scaricherà una copia e la preparerà per l'uso sul tuo computer. </para>

<para
>Ciò è più veloce per te, e aiuta a ridurre il carico sui server &subversion; anonimi di kde.org.</para>
</listitem>

<listitem
><para
>Un altro modo di fare più velocemente è avviare il processo di generazione di un modulo non appena il codice sorgente di quel modulo è stato scaricato (disponibile dalla versione 1.6). </para
></listitem>

<listitem
><para
>Ha un eccellente supporto per il <link linkend="using-qt-copy"
>modulo qt-copy</link
>, inclusa l'applicazione opzionale delle correzioni e delle ottimizzazioni al modulo. </para
></listitem>

<listitem
><para
>&kdesvn-build; ha <link linkend="kdesvn-build-color"
>output colorato</link
>. </para
></listitem>

<listitem
><para
>&kdesvn-build; non richiede un'interfaccia grafica per funzionare. Quindi, puoi generare &kde; senza bisogno di un altro ambiente grafico. </para
></listitem>

<listitem
><para
>Supporta l'impostazione di opzioni predefinite per tutti i moduli (come le impostazioni di compilazione o le opzioni di configurazione). Queste opzioni possono anche essere cambiate per dei moduli specifici.</para>

<para
>Inoltre, &kdesvn-build; <link linkend="kdesvn-build-std-flags"
>aggiungerà dei flag standard</link
> appropriati per risparmiarti la fatica e i possibili errori derivanti dallo scriverli da te. </para
></listitem>

<listitem
><para
>&kdesvn-build; può ritirare un <link linkend="using-branches"
>tag o ramo</link
> particolare di un modulo. Puoi anche assicurarti che sia ritirata una particolare <link linkend="conf-revision"
>revisione</link
> di un modulo. </para
></listitem>

<listitem
><para
>&kdesvn-build; può passare automaticamente a una cartella sorgente di un altro deposito, ramo o tag. Ciò viene fatto automaticamente quando cambi un'opzione che cambia l'&url; del deposito, ma devi usare l'opzione <link linkend="cmdline-svn-only"
>--svn-only</link
> per far sapere a &kdesvn-build; che è accettabile fare il passaggio. </para
></listitem>

<listitem
><para
>&kdesvn-build; può <link linkend="partial-builds"
>ritirare anche solo alcune porzioni di un modulo</link
>, per i casi in cui ti serve solo un programma da un grande modulo. </para
></listitem>

<listitem
><para
>Per gli sviluppatori: &kdesvn-build; vi <link linkend="ssh-agent-reminder"
>ricorderà</link
> se usate svn+ssh:// ma <application
>ssh-agent</application
> non è in esecuzione, visto che ciò porterebbe a richieste di password multiple da &ssh;. </para
></listitem>

<listitem
><para
>Può <link linkend="email-reports"
>inviare rapporti di errori via posta elettronica</link
> a un utente. </para
></listitem>

<listitem
><para
>Può <link linkend="deleting-build-dir"
>eliminare la cartella di generazione</link
> di un modulo dopo la sua installazione per risparmiare spazio a spese del tempo di una successiva compilazione. </para
></listitem>

<listitem
><para
>Gli indirizzi delle cartelle usate da &kdesvn-build; sono configurabili (anche per modulo). </para
></listitem>

<listitem
><para
>Può usare &sudo;, o un altro comando specificato dall'utente, per <link linkend="root-installation"
>installare i moduli</link
> in modo che &kdesvn-build; non richieda di essere eseguito dall'amministratore. </para
></listitem>

<listitem
><para
>&kdesvn-build;, come impostazione predefinita, gira a <link linkend="build-priority"
>priorità ridotta</link
> per permetterti di usare il computer mentre &kdesvn-build; sta lavorando. </para
></listitem>

<listitem
><para
>Ha supporto per usare <link linkend="using-branches"
>i tag e i rami</link
> del &subversion; di &kde;. </para
></listitem>

<listitem
><para
>&kdesvn-build; userà una serie di tecniche per <link linkend="building-successfully"
>verificare e garantire</link
> una generazione corretta. </para
></listitem>

<listitem
><para
>C'è supporto per <link linkend="resuming"
>riprendere una generazione</link
> da un modulo dato. Puoi anche <link linkend="ignoring-modules"
>ignorare temporaneamente alcuni moduli</link
> di una certa generazione. </para
></listitem>

<listitem
><para
>&kdesvn-build; può fare una <link linkend="partial-builds"
>generazione parziale</link
> rapida di un modulo direttamente dalla riga di comando, quando devi solo aggiornare parti di un modulo. </para
></listitem>

<listitem
><para
>&kdesvn-build; scaricherà e creerà automaticamente la necessaria cartella <filename class="directory"
>/admin</filename
> di un modulo se non è stata scaricata la prima volta per qualche ragione. Questo vale solo per i moduli di &kde; 3, perché <filename
>/admin</filename
> non è necessaria per qt-copy o per i moduli di &kde; 4. </para
></listitem>

<listitem
><para
>&kdesvn-build; mostrerà <link linkend="build-progress"
>l'avanzamento della generazione</link
> quando si usano &unsermake; e &cmake;, e terrà il tempo della generazione in modo da sapere quanto ci ha messo. </para
></listitem>

<listitem
><para
>Cerca automaticamente di rigenerare i moduli che usano il <command
>make</command
> incrementale, che tende a non riuscire dopo alcuni tipi di deposito. </para
></listitem>

<listitem
><para
>Ha già un insieme di opzioni predefinite appropriate per generare un'installazione monoutente di &kde; dal deposito anonimo di &subversion;. </para
></listitem>

<listitem
><para
>Ha supporto per &unsermake;. </para
></listitem>

<listitem
><para
>Espansione della tilde per le opzioni di configurazione. Per esempio, puoi specificare: <programlisting
>qtdir ~/kdesvn/build/qt-copy</programlisting>
</para
></listitem>

<listitem
><para
>Configura automaticamente un sistema di generazione, con la cartella sorgente non corrispondente alla cartella di generazione, in modo da tenere la prima pulita. </para
></listitem>

<listitem
><para
>Puoi specificare che le opzioni globali si applichino a ogni modulo da ritirare, e puoi anche specificare opzioni da applicare a singoli moduli. </para
></listitem>

<listitem
><para
>Siccome gli <application
>Autotools</application
> a volte non sono sincronizzati con le modifiche nell'albero del codice sorgente, puoi forzare la rigenerazione di un modulo creando un file <filename
>.refresh-me</filename
> nella cartella di generazione del modulo, o eseguendo &kdesvn-build; con l'opzione <option
>--refresh-build</option
>. </para
></listitem>

<listitem
><para
>Puoi specificare varie variabili d'ambiente da usare durante la generazione, incluse <envar
>KDEDIR</envar
>, <envar
>QTDIR</envar
>, <envar
>DO_NOT_COMPILE</envar
> e <envar
>CXXFLAGS</envar
>. </para
></listitem>

<listitem
><para
>I registri dei comandi hanno data e ora, in modo da avere sempre un registro dell'esecuzione dello script. Inoltre, uno speciale collegamento simbolico chiamato <filename
>latest</filename
> viene creato e punta sempre al file più recente della cartella dei registri. </para
></listitem>

<listitem
><para
>Se stai usando una versione utente di &kde; invece di una di sistema (per installare la quale devi essere amministratore), puoi usare lo script per installarla al posto tuo. Non ho verificato bene il codice, e fa ampio uso della chiamata <function
>system()</function
>, quindi non raccomanderei di usarlo come amministratore per ora. </para
></listitem>

<listitem
><para
>Puoi usare <link linkend="conf-make-install-prefix"
>make-install-prefix</link
> per prefissare la riga di comando di <userinput
><command
>make</command
> <option
>install</option
></userinput
> con un altro comando, cosa utile per &sudo;. </para
></listitem>

<listitem
><para
>Puoi ritirare anche solo una parte di un modulo &subversion; di &kde;. Per esempio, potresti ritirare solo <application
>taglib</application
> da <application
>kdesupport</application
>, o solo <application
>K3B</application
> da <application
>extragear/multimedia</application
>. Lo script includerà automaticamente <application
>kde-common</application
> quando necessario per far funzionare la generazione. </para
></listitem>

<listitem
><para
>Puoi <quote
>far finta</quote
> di fare le operazioni. Se passi le opzioni <option
>--pretend</option
> o <option
>-p</option
> sulla riga di comando, lo script darà una descrizione logorroica dei comandi che sta per eseguire, senza però eseguirli. </para
></listitem>

</itemizedlist>

</sect1>

<sect1 id="kdesvn-build-logging">
<title
>Registro della generazione di &kdesvn-build;</title>

<sect2 id="logging-overview">
<title
>Panoramica del registro</title>

<para
>La registrazione è una funzionalità di &kdesvn-build; grazie alla quale l'output di ogni comando eseguito da &kdesvn-build; viene salvato in un file per essere analizzato in seguito, se necessario. Ciò si fa perché è spesso necessario avere l'output di questi programmi in caso di un errore di generazione, perché ci sono molti motivi per cui una generazione potrebbe non riuscire.</para>

<sect3 id="log-directory-layout">
<title
>Schema della cartella di registro</title>

<para
>I registri sono sempre tenuti nella cartella di registro. L'indirizzo della cartella di registro è controllato dall'opzione <link linkend="conf-log-dir"
>log-dir</link
>, che ha come valore predefinito <filename class="directory"
><symbol
>${cartella_sorgente}</symbol
>/log</filename
> (dove <symbol
>${cartella_sorgente}</symbol
> è il valore dell'opzione <link linkend="conf-source-dir"
>source-dir</link
>); in questa sezione, verrà indicato con <symbol
>${cartella_registro}</symbol
>).</para>

<para
>Sotto <symbol
>${cartella_registro}</symbol
> c'è una serie di cartelle, una per ogni volta che è stato eseguito &kdesvn-build;. Ogni cartella ha per nome la data e il numero di esecuzione. Per esempio, la seconda volta che &kdesvn-build; è stato eseguito il 26 maggio 2004 verrebbe creata la cartella <filename
>2004-05-26-02</filename
>, dove 2004-05-26 è per la data e -02 per il numero dell'esecuzione.</para>

<para
>Per comodità, &kdesvn-build; creerà anche un collegamento ai registri dell'ultima esecuzione, chiamato <filename class="directory"
>latest</filename
>. Quindi i registri dell'ultima esecuzione di &kdesvn-build; saranno sempre sotto <filename class="directory"
><symbol
>${cartella_registro}</symbol
>/latest</filename
>. </para>

<para
>Ogni cartella di un'esecuzione di &kdesvn-build; conterrà a sua volta una serie di cartelle, una per ogni modulo di &kde; che &kdesvn-build; ha cercato di generare. Inoltre, la cartella conterrà un file <filename
>build-status</filename
>, che ti permette di determinare quali moduli sono stati generati correttamente e quali no.</para>

<note
><para
>Se il modulo contiene un sottomodulo (come extragear/multimedia, playground/utils, o KDE/kdelibs), ci sarà una struttura corrispondente nelle cartelle di registro. Per esempio, i registri di KDE/kdelibs dopo l'ultima esecuzione di &kdesvn-build; saranno in <filename class="directory"
><symbol
>${cartella_registro}</symbol
>latest/KDE/kdelibs</filename
>, e non in <filename class="directory"
><symbol
>${cartella_registro}</symbol
>/latest/kdelibs</filename
>. </para
></note>

<para
>In ogni cartella di registro dei moduli troverai una serie di file per ogni operazione effettuata da &kdesvn-build;. Se &kdesvn-build; aggiorna un modulo, potresti vedere dei file come <filename
>svn-co.log</filename
> (per il ritiro di un modulo) o <filename
>svn-up.log</filename
> (per l'aggiornamento di un modulo che è stato ritirato in precedenza). Se è stato eseguito il comando <command
>configure</command
>, dovresti aspettarti di vedere un <filename
>configure.log</filename
> nella cartella.</para>

<para
>Se si è verificato un errore, dovresti poterne vedere una spiegazione in uno dei file. Per aiutarti a capire quale file contiene l'errore, &kdesvn-build; creerà un collegamento dal file contenente l'errore (come <filename
>build-1.log</filename
>) a un file chiamato <filename
>error.log</filename
>.</para>

<para
>Insomma, per vedere perché un modulo non è stato generato dopo l'ultima esecuzione di &kdesvn-build; la prima cosa che devi guardare è il file <filename
><symbol
>${cartella_registro}</symbol
>/latest/<replaceable
>nome-modulo</replaceable
>/error.log</filename
>. </para>

<tip
><para
>Se il file <filename
>error.log</filename
> è vuoto (soprattutto dopo un'installazione), forse non c'è davvero stato nessun errore. Alcuni degli strumenti usati dal sistema di generazione di &kde; segnaleranno errori per sbaglio anche se in realtà non ce ne sono.</para>

<para
>Inoltre, alcuni comandi evaderanno il redirezionamento dell'output di &kdesvn-build; ed eviteranno il file di registro in certe circostanze (di solito quando si effettua il primo ritiro da &subversion;), e l'output di errore in quel caso non è nel file di registro ma nella &konsole; o nel terminale dove hai eseguito &kdesvn-build;.</para>
</tip>

</sect3>
</sect2>
</sect1>

</chapter>

<chapter id="kdesvn-buildrc">
<title
>Il formato di <filename
>.kdesvn-buildrc</filename
></title>

<para
>Per usare lo script, devi avere un file chiamato <filename
>.kdesvn-buildrc</filename
> nella tua cartella Home, il quale descrive i moduli che vuoi scaricare e generare. </para>

<para
>Parte con le opzioni globali, specificate come segue: </para>

<programlisting
>global
<replaceable
>nome-opzione valore-opzione</replaceable>
<replaceable
>[...]</replaceable>
end global
</programlisting>

<para
>Seguono quindi una o più sezioni per i moduli, specificate come segue: </para>

<programlisting
>module <replaceable
>nome-modulo</replaceable>
<replaceable
>nome-opzione valore-opzione</replaceable>
<replaceable
>[...]</replaceable>
end module
</programlisting>

<para
><replaceable
>nome-modulo</replaceable
> deve essere un modulo del deposito &subversion; di &kde; (per esempio, kdelibs o kdebase). Alcune opzioni sostituiscono quelle globali, alcune si aggiungono ad esse, e alcune opzioni globali non si possono sostituire. </para>

<para
>Segue un elenco alfabetico delle opzioni disponibili. Fai clic sull'opzione per saperne di più. Se ne trovi una non documentata, scrivi agli autori usando l'indirizzo che trovi <link linkend="authors"
>sopra</link
>. </para>

<itemizedlist>
<listitem
><para
><link linkend="conf-apply-qt-patches"
>apply-qt-patches</link
>, per migliorare qt-copy.</para
></listitem>
<listitem
><para
><link linkend="conf-async"
>async</link
>, per aggiornare e generare allo stesso tempo.</para
></listitem>
<listitem
><para
><link linkend="conf-binpath"
>binpath</link
>, per impostare la variabile <envar
>PATH</envar
>.</para
></listitem>
<listitem
><para
><link linkend="conf-branch"
>branch</link
>, per ritirare da un ramo invece che dal tronco principale.</para
></listitem>
<listitem
><para
><link linkend="conf-build-dir"
>build-dir</link
>, per impostare la cartella in cui generare.</para
></listitem>
<listitem
><para
><link linkend="conf-checkout-only"
>checkout-only</link
>, per ritirare soltanto alcune parti di un modulo.</para
></listitem>
<listitem
><para
><link linkend="conf-cmake-options"
>cmake-options</link
>, per definire quali flag con cui configurare un modulo usando &cmake;.</para
></listitem>
<listitem
><para
><link linkend="conf-colorful-output"
>colorful-output</link
>, per aggiungere del colore all'output dello script.</para
></listitem>
<listitem
><para
><link linkend="conf-configure-flags"
>configure-flags</link
>, per definire quali flag con cui configurare un modulo.</para
></listitem>
<listitem
><para
><link linkend="conf-cxxflags"
>cxxflags</link
>, per definire la variabile <envar
>CXXFLAGS</envar
>.</para
></listitem>
<listitem
><para
><link linkend="conf-dest-dir"
>dest-dir</link
>, per cambiare il nome della cartella di un modulo.</para
></listitem>
<listitem
><para
><link linkend="conf-disable-agent-check"
>disable-agent-check</link
>, per evitare che &kdesvn-build; controlli lo stato dell'agente &ssh;.</para
></listitem>
<listitem
><para
><link linkend="conf-do-not-compile"
>do-not-compile</link
>, per segnare le cartelle da non generare.</para
></listitem>
<listitem
><para
><link linkend="conf-inst-apps"
>inst-apps</link
>, per generare e installare solo alcune cartelle.</para
></listitem>
<listitem
><para
><link linkend="conf-install-after-build"
>install-after-build</link
>, per evitare di installare dopo il processo di generazione.</para
></listitem>
<listitem
><para
><link linkend="conf-kdedir"
>kdedir</link
>, per impostare la cartella in cui installare &kde;.</para
></listitem>
<listitem
><para
><link linkend="conf-kde-languages"
>kde-languages</link
>, per impostare i pacchetti di traduzione che vuoi scaricare e installare.</para
></listitem>
<listitem
><para
><link linkend="conf-libpath"
>libpath</link
>, per impostare la variabile <envar
>LD_LIBRARY_PATH</envar
>.</para
></listitem>
<listitem
><para
><link linkend="conf-make-install-prefix"
>make-install-prefix</link
>, per avviare un programma di aiuto (come &sudo;) durante <userinput
><command
>make</command
> <option
>install</option
></userinput
>.</para
></listitem>
<listitem
><para
><link linkend="conf-make-options"
>make-options</link
>, per passare opzioni al programma &make;.</para
></listitem>
<listitem
><para
><link linkend="conf-manual-build"
>manual-build</link
>, per evitare di generare il modulo automaticamente.</para
></listitem>
<listitem
><para
><link linkend="conf-manual-update"
>manual-update</link
>, per evitare di fare qualsiasi cosa sul modulo in automatico.</para
></listitem>
<listitem
><para
><link linkend="conf-module-base-path"
>module-base-path</link
>, per cambiare da dove scaricare il modulo (utile per rami e tag).</para
></listitem>
<listitem
><para
><link linkend="conf-niceness"
>niceness</link
>, per cambiare la priorità nell'uso della <hardware
>CPU</hardware
>.</para
></listitem>
<listitem
><para
><link linkend="conf-no-rebuild-on-fail"
>no-rebuild-on-fail</link
>, per evitare di far ripartire &make; se non riesce.</para
></listitem>
<listitem
><para
><link linkend="conf-qtdir"
>qtdir</link
>, per impostare il percorso alle librerie &Qt;.</para
></listitem>
<listitem
><para
><link linkend="conf-set-env"
>set-env</link
>, per impostare una variabile d'ambiente.</para
></listitem>
<listitem
><para
><link linkend="conf-source-dir"
>source-dir</link
>, per cambiare da dove scaricare il codice sorgente.</para
></listitem>
<listitem
><para
><link linkend="conf-stop-on-failure"
>stop-on-failure</link
>, per far fermare &kdesvn-build; non appena qualcosa non riesce.</para
></listitem>
<listitem
><para
><link linkend="conf-svn-server"
>svn-server</link
>, per cambiare il server da cui si scarica il codice sorgente.</para
></listitem>
<listitem
><para
><link linkend="conf-use-unsermake"
>use-unsermake</link
>, per usare il sistema di generazione avanzato &unsermake;.</para
></listitem>
</itemizedlist>


<para
>Questa è una tabella delle varie opzioni con alcuni commenti. Ogni opzione che ne sostituisca una globale sostituirà anche un'impostazione della riga di comando. </para>

<table id="option-table">
<title
>Tabella delle opzioni</title>
<tgroup cols="3">

<thead>
<row>
<entry
>Nome dell'opzione</entry>
<entry
>Sostituibilità</entry>
<entry
>Note</entry>
</row>
</thead>

<tbody>

<row id="conf-apidox">
<entry
>apidox</entry>
<entry
>Sostituisce globale</entry>
<entry
><para
>Questa opzione era usata per permettere di generare la documentazione dell'API dei moduli di &kde;. È stata rimossa in &kdesvn-build; 1.6.3 a causa del suo mancato supporto in &kde; 4. La documentazione dell'API è disponibile in rete su <ulink url="http://api.kde.org/"
>kde.org</ulink
>. Inoltre è possibile generare la documentazione dell'API di &kde; 4 usando uno script incluso nel modulo kdesdk (cartella <filename class="directory"
>scripts</filename
>). Vedi il sito <ulink url="http://techbase.kde.org/Development/Tools/apidox"
>TechBase di &kde;</ulink
> per maggiori dettagli. Ovviamente è sempre possibile generare a mano la documentazione dell'API per i moduli più vecchi.</para>
</entry>
</row>

<row id="conf-apply-qt-patches">
<entry
>apply-qt-patches</entry>
<entry
>Sostituisce globale</entry>
<entry
>Questa opzione è utile solo per qt-copy. Se è impostata ad un valore non nullo, lo script <filename
>apply-patches</filename
> sarà eseguito prima della generazione, per applicare le patch non ufficiali a qt-copy. Siccome queste patch sono normalmente la ragione per cui si installa qt-copy invece di un normale &Qt;, non dovrebbe far male abilitarle. L'impostazione predefinita è abilitare le patch.</entry>
</row>

<row id="conf-async">
<entry
>async</entry>
<entry
>Non sostituibile</entry>
<entry
><para
>Questa opzione attiva la modalità di operazione asincrona, nella quale l'aggiornamento del codice sorgente e il processo di generazione saranno effettuati in parallelo, invece che attendere la fine di tutti gli aggiornamenti prima di avviare il processo di generazione. Questa opzione, come valore predefinito, abilita la modalità asincrona. Per disattivarla, imposta questa opzione a <replaceable
>false</replaceable
>.</para>
<para
>Questa opzione è disponibile dal rilascio 1.6.</para
></entry>
</row>

<row id="conf-binpath">
<entry
>binpath</entry>
<entry
>Sostituisce globale</entry>
<entry
><para
>Imposta questa opzione per impostare la variabile d'ambiente <envar
>PATH</envar
> durante la generazione. Non puoi sostituire questa impostazione nelle opzioni di un modulo. Il valore predefinito è <filename class="directory"
>/bin:/usr/bin:/usr/local/bin:/usr/X11R6/bin</filename
>. Questa variabile d'ambiente dovrebbe includere i percorsi, separati da due punti, dei tuoi strumenti di sviluppo. I percorsi <filename class="directory"
>$<envar
>KDEDIR</envar
>/bin</filename
> e <filename class="directory"
>$<envar
>QTDIR</envar
>/bin</filename
> sono aggiunti automaticamente. Puoi usare la tilde (~) per qualsiasi percorso che aggiungi con questa opzione.</para>
</entry>
</row>

<row id="conf-branch">
<entry
>branch</entry>
<entry
>Sostituisce globale</entry>
<entry
><para
>Imposta questa opzione per ritirare i file da un ramo di &kde; invece che dal tronco, che è predefinito ed è dove avviene lo sviluppo di &kde;. Per esempio, per ritirare &kde; 3.4, imposteresti questa opzione a <replaceable
>3.4</replaceable
>.</para>
<para
>Nota che alcuni moduli usano un diverso nome su alcuni rami. In particolare, il modulo &arts; richiesto non segue i numeri di versione di &kde;. La versione di &arts; corrispondente a &kde; 3.4 era la versione 1.4.</para>
<para
>Se &kdesvn-build; non riesce a scaricare correttamente un ramo con questa opzione, potresti dover specificare manualmente l'&url; da cui scaricare usando l'opzione <link linkend="conf-override-url"
>override-url</link
>.</para>
</entry>
</row>

<row id="conf-build-dir">
<entry
>build-dir</entry>
<entry
>Sostituisce globale</entry>
<entry
>Usa questa opzione per cambiare la cartella che conterrà il codice costruito. Ci sono tre diversi modi di usarla: <itemizedlist
><listitem
><para
>Relativa alla cartella sorgente della cartella del codice sorgente &subversion; di &kde; (vedi <link linkend="conf-source-dir"
>l'opzione source-dir</link
>). Questo è il modo predefinito, e il modo in cui lo script ha funzionato fino alla versione 0.61. Questa modalità viene selezionata se scrivi un nome di cartella che non comincia per tilde (~) o sbarra (/).</para
><para
>Il valore predefinito è <filename class="directory"
>build</filename
>.</para
></listitem
><listitem
><para
>Percorso assoluto. Se specifichi un percorso che comincia per /, quel percorso sarà usato direttamente. Per esempio, <filename class="directory"
>/tmp/kde-obj-dir/</filename
>.</para
></listitem
><listitem
><para
>Relativo alla tua cartella Home. Se specifichi un percorso che comincia per ~, il percorso è inteso relativo alla tua cartella Home, analogamente all'espansione della tilde in una shell. Per esempio, <filename class="directory"
>~/builddir</filename
> imposterebbe la cartella di generazione a <filename class="directory"
>/home/nome-utente/builddir</filename
>.</para
></listitem
></itemizedlist
> Forse ti sorprenderà, ma questa opzione è effettivamente modificabile a seconda del modulo. </entry>
</row>

<row id="conf-checkout-only">
<entry
>checkout-only</entry>
<entry
>Sostituisce globale</entry>
<entry
>Imposta questa opzione per ritirare il codice sorgente &subversion; un pezzo alla volta. Il valore di questa opzione dovrebbe essere un elenco separato da spazi di cartelle da ritirare. Se non includi la cartella <filename
>admin</filename
>, essa verrà inclusa automaticamente (se necessario). Quando ritiri un pezzo alla volta, la cartella <filename
>admin</filename
> sarà presa da kde-common, che è dove si trova sul server &subversion;. Sebbene questa opzione sostituisca l'opzione globale, tieni presente che impostare questa opzione come globale non ha senso. </entry>
</row>

<row id="conf-cmake-options">
<entry
>cmake-options</entry>
<entry
>Si aggiunge alle opzioni globali (non applicabile a qt-copy)</entry>
<entry
><para
>Usa questa opzione per specificare quali flag passare a &cmake; quando crei il sistema di generazione per il modulo. Quando usata come opzione globale, viene applicata a tutti i moduli generati da questo script. Quando usata come opzione per un modulo, viene aggiunta in fondo alle opzioni globali. Ciò ti permette di specificare opzioni comuni di &cmake; nella sezione globale.</para>

<para
>Questa opzione sostituisce <link linkend="conf-configure-flags"
>configure-flags</link
> per tutti i moduli di &kde; 4, perché questi usano &cmake; per la generazione.</para>

<para
>Siccome queste opzioni sono passate direttamente alla riga di comando di &cmake;, dovrebbero essere date come sarebbero passate a &cmake;. Per esempio:</para>

<screen
>cmake-options -DCMAKE_BUILD_TYPE=RelWithDebInfo
</screen>

<para
>Siccome è un po' fastidioso, &kdesvn-build; si dà da fare per assicurarsi che, fintanto che le altre opzioni sono correttamente impostate, dovresti poter lasciare questa opzione in bianco.</para
></entry>
</row>

<row id="conf-configure-flags">
<entry
>configure-flags</entry>
<entry
>Si aggiunge alle opzioni globali (eccetto qt-copy)</entry>
<entry
><para
>Usa questa opzione per specificare quali flag passare a <command
>./configure</command
> quando crei il sistema di generazione per il modulo. Quando usata come opzione globale, viene applicata a tutti i moduli generati da questo script. qt-copy usa un insieme molto diverso di opzioni rispetto al resto di &kde;, quindi questa opzione <emphasis
>sostituisce</emphasis
> le impostazioni globali quando applicata a qt-copy. </para>

<para
>Questa opzione si applica a qt-copy e a tutti i moduli di &kde; 3. I moduli di &kde; 4 usano &cmake;, che viene controllato con l'opzione <link linkend="conf-cmake-options"
>cmake-options</link
>.</para>
</entry>
</row>

<row id="conf-colorful-output">
<entry
>colorful-output</entry>
<entry
>Non sostituibile</entry>
<entry
>Imposta questa opzione a <replaceable
>false</replaceable
> (falso) per disattivare l'output colorato di &kdesvn-build;. Questa opzione ha valore predefinito <replaceable
>true</replaceable
> (vero). Nota che &kdesvn-build; non passerà codici di colore a nient'altro che a un terminale (come <application
>xterm</application
>, &konsole;, o la normale console di &Linux;). </entry>
</row>

<row id="conf-cxxflags">
<entry
>cxxflags</entry>
<entry
>Si aggiunge alle opzioni globali</entry>
<entry
><para
>Usa questa opzione per specificare quali flag passare a <command
>./configure</command
> nella forma della variabile <envar
>CXXFLAGS</envar
> quando crei il sistema di generazione del modulo. Questa opzione viene specificata qui invece che con <link linkend="conf-configure-flags"
>configure-flags</link
> o <link linkend="conf-cmake-options"
>cmake-options</link
> perché questa opzione imposterà anche la variabile d'ambiente <envar
>CXXFLAGS</envar
> durante il processo di generazione.</para>

<para
>Nota che per &kde; 4 e ogni altro modulo che usi &cmake; è necessario impostare l'opzione <option
>CMAKE_BUILD_TYPE</option
> a <userinput
>none</userinput
> quando si configura il modulo. Questo si può fare usando l'opzione <link linkend="conf-cmake-options"
>cmake-options</link
>.</para>
</entry>
</row>

<row id="conf-dest-dir">
<entry
>dest-dir</entry>
<entry
>Sostituisce globale</entry>
<entry
>Usa questa opzione per cambiare il nome che viene dato a un modulo sul disco. Per esempio, se il modulo era extragear-network, usando questa opzione puoi rinominarlo a extragear-network. Nota che sebbene ciò cambi il nome del modulo sul disco, non è una buona idea includere cartelle o separatori di cartelle nel nome, perché ciò interferirà con le opzioni <link linkend="conf-build-dir"
>build-dir</link
> o <link linkend="conf-source-dir"
>source-dir</link
>. </entry>
</row>

<row id="conf-disable-agent-check">
<entry
>disable-agent-check</entry>
<entry
>Non sostituibile</entry>
<entry
>Normalmente, se stai usando &ssh; per scaricare i sorgenti da &subversion; (come nel caso in cui stessi usando il protocollo <filename
>svn+ssh</filename
>), &kdesvn-build; cercherà di assicurarsi che se stai usando <application
>ssh-agent</application
>, questo stia effettivamente gestendo delle identità &ssh;. Questo è per cercare di prevenire che &ssh; chieda la password per ogni modulo. Puoi disabilitare questa opzione impostando <option
>disable-agent-check</option
> a <replaceable
>true</replaceable
> (vero). </entry>
</row>

<row id="conf-do-not-compile">
<entry
>do-not-compile</entry>
<entry
>Sostituisce globale</entry>
<entry
><para
>Usa questa opzione per selezionare un insieme specifico di cartelle da generare in un modulo (invece che tutte). Le cartelle da generare dovrebbero essere separate da spazi.</para>

<para
>Questa funzionalità è supportata sia per &kde; 3 che 4. Il supporto per &kde; 4 è stato aggiunto in &kdesvn-build; 1.6.3.</para>

<para
>Nota che il codice sorgente dei programmi sarà comunque scaricato. Puoi usare la direttiva <link linkend="conf-checkout-only"
>checkout-only</link
> per scegliere le cartelle che vuoi ritirare.</para>

<para
>Per esempio, per evitare che &juk; e &kscd; del modulo kdemultimedia siano compilati, aggiungeresti <userinput
>do-not-compile juk kscd</userinput
> nelle impostazioni per kdemultimedia.</para>
</entry>
</row>

<row id="conf-email-address">
<entry
>email-address</entry>
<entry
>Non sostituibile</entry>
<entry>
<para
>Imposta questa opzione all'indirizzo di posta elettronica da cui &kdesvn-build; dovrebbe inviare una lettera se mai ne avesse bisogno. Non te ne devi curare se non usi nessuna funzionalità che usa la posta (come impostazione predefinita sono tutte disattivate). </para>

<para
>Attualmente solo <link linkend="conf-email-on-compile-error"
> email-on-compile-error</link
> ha bisogno di questa opzione. </para>
</entry>
</row>

<row id="conf-email-on-compile-error">
<entry
>email-on-compile-error</entry>
<entry
>Non sostituibile</entry>
<entry>
<para
>Puoi impostare questa opzione all'indirizzo di posta elettronica a cui mandare un rapporto quando un modulo non può essere generato. &kdesvn-build; aspetterà fino a quando tutti i moduli saranno stati generati e metterà assieme tutti i risultati in un rapporto. Il rapporto viene inviato solo se almeno un modulo non è potuto essere generato. </para>

<para
>Vedi anche l'opzione <link linkend="conf-email-address"
>email-address</link
> per impostare l'indirizzo da cui &kdesvn-build; dovrebbe inviare la lettera, perché il valore predefinito normalmente non è quello che vuoi. </para>
</entry>
</row>

<row id="conf-inst-apps">
<entry
>inst-apps</entry>
<entry
>Sostituisce globale</entry>
<entry
><para
>Questo è il contrario dell'opzione <link linkend="conf-do-not-compile"
>do-not-compile</link
>. Questa opzione fa in modo che solo le cartelle di massimo livello siano generate. Le cartelle devono essere separate da spazi.</para>

<para
>Nessun cambiamento avrà effetto fino alla prossima volta che verrà eseguito <command
>make <option
>-f</option
> <filename
>Makefile.cvs</filename
></command
>, automaticamente dallo script o a mano con le opzioni <link linkend="cmdline-refresh-build"
><option
>--refresh-build</option
></link
> o <link linkend="cmdline-recreate-configure"
><option
>--recreate-configure</option
></link
>. </para>

<important
><para
>Questa opzione non funziona ancora con i moduli generati con il sistema di generazione &cmake;.</para
></important>

<para
>Nota che il codice sorgente dei programmi sarà comunque scaricato. Puoi usare la direttiva <link linkend="conf-checkout-only"
>checkout-only</link
> per scegliere le cartelle che vuoi ritirare.</para>
</entry>
</row>

<row id="conf-install-after-build">
<entry
>install-after-build</entry>
<entry
>Sostituisce globale</entry>
<entry
>Questa opzione viene usata per installare il pacchetto a seguito di una generazione riuscita. Come impostazione predefinita, questa opzione è attiva. Se vuoi disattivarla, devi impostarla a <option
>0</option
> nel <link linkend="configure-data"
>file di configurazione</link
>. Puoi anche usare l'opzione <link linkend="cmdline-no-install"
><option
>--no-install</option
></link
> dalla riga di comando. </entry>
</row>

<row id="conf-kdedir">
<entry
>kdedir</entry>
<entry
>Sostituisce globale</entry>
<entry
>Questa opzione imposta la cartella in cui &kde; sarà installato dopo essere stato generato. Il suo valore predefinito è <filename class="directory"
>~/kde</filename
>. Se la cambi a una cartella che richiede accesso come amministratore di sistema, potresti essere interessato anche all'opzione <link linkend="conf-make-install-prefix"
>make-install-prefix</link
>.</entry>
</row>

<row id="conf-kde-languages">
<entry
>kde-languages</entry>
<entry
>Non sostituibile</entry>
<entry
><para
>Questa opzione ti permette di scegliere di scaricare e installare i pacchetti di localizzazione insieme a &kde;. Potresti farlo se vuoi che &kde; sia tradotto nella tua lingua.</para>

<para
>Per usare questa opzione, impostala a un elenco di lingue da installare separate da spazi. Ogni lingua ha un codice associato (<userinput
>it</userinput
> per l'italiano). Puoi vedere gli altri codici su <ulink url="http://i18n.kde.org/teams/"
>questa pagina</ulink
>. </para>

<para
>È anche possibile scegliere solo una lingua. Come impostazione predefinita non ne viene scaricata nessuna, il che vuol dire che &kde; sarà in inglese secondo l'ortografia americana.</para>

<para
>Per esempio, per installare l'italiano, devi impostare l'opzione a qualcosa come <userinput
><option
>kde-languages</option
> <replaceable
>it</replaceable
></userinput
>. Devi comunque ancora usare &kcontrol; per scegliere di attivare la lingua.</para>
</entry>
</row>

<row id="conf-libpath">
<entry
>libpath</entry>
<entry
>Sostituisce globale</entry>
<entry
>Imposta questa opzione per impostare la variabile d'ambiente <envar
>LD_LIBRARY_PATH</envar
>. Non puoi sostituire questa impostazione per un singolo modulo. Il valore predefinito è vuoto, ma i percorsi <filename class="directory"
>$<envar
>KDEDIR</envar
>/lib</filename
> e <filename class="directory"
>$<envar
>QTDIR</envar
>/lib</filename
> vengono aggiunti automaticamente. Puoi usare la tilde (~) per qualsiasi percorso che aggiungi con questa opzione. </entry>
</row>

<row id="conf-log-dir">
<entry
>log-dir</entry>
<entry
>Sostituisce globale</entry>
<entry
>Usa questa opzione per cambiare la cartella usata per contenere i file di registro generati dallo script. Questa opzione può essere impostata singolarmente per ogni modulo dalla versione 0.64 in avanti. </entry>
</row>

<row id="conf-make-install-prefix">
<entry
>make-install-prefix</entry>
<entry
>Sostituisce globale</entry>
<entry
>Imposta questa variabile a un elenco separato da spazi, che verrà interpretato come un comando con le sue opzioni con cui far precedere il comando <userinput
><command
>make</command
> <option
>install</option
></userinput
> usato per installare i moduli. È comodo per installare i pacchetti con per esempio &sudo;, ma sii cauto quando usi i privilegi di amministratore.</entry>
</row>

<row id="conf-make-options">
<entry
>make-options</entry>
<entry
>Sostituisce globale</entry>
<entry
>Imposta questa variabile per passare le opzioni della riga di comando al comando <command
>make</command
>. È utile per programmi come <ulink url="http://distcc.samba.org/"
><application
>distcc</application
></ulink
>. o sistemi con più di un nucleo nel processore. </entry>
</row>

<row id="conf-manual-build">
<entry
>manual-build</entry>
<entry
>Sostituisce globale</entry>
<entry
>Imposta il valore dell'opzione a <replaceable
>true</replaceable
> (vero) per impedire al processo di cercare di generare questo modulo. Sarà comunque aggiornato quando si aggiorna da &subversion;. Questa opzione è esattamente equivalente all'opzione da riga di comando <link linkend="cmdline-no-build"
><option
>--no-build</option
></link
>. </entry>
</row>

<row id="conf-manual-update">
<entry
>manual-update</entry>
<entry
>Sostituisce globale</entry>
<entry
>Imposta il valore dell'opzione a <replaceable
>true</replaceable
> (vero) per impedire che il processo di generazione cerchi di aggiornare (e di conseguenza generare o installare) questo modulo. Se imposti questa opzione per un modulo, lo stai in pratica escludendo. </entry>
</row>

<row id="conf-module-base-path">
<entry
>module-base-path</entry>
<entry
>Sostituisce globale</entry>
<entry
><para
>Imposta questa opzione per sostituire il percorso alla cartella predefinita di &kdesvn-build; per il modulo. Si può usare, per esempio, per ritirare particolari rami o versioni di alcune librerie. <ulink url="http://websvn.kde.org/"
>Il visore del sorgente di &kde;</ulink
> è utilissimo per capire quale percorso scegliere.</para>
<para
>Nota che &kdesvn-build; costruisce il percorso finale secondo il modello seguente: <varname
>$svn-server</varname
>/home/kde/<varname
>$module-base-path</varname
>/<varname
>$module-name</varname
>. </para>
<para
>Il valore predefinito è <option
>trunk</option
> o <option
>trunk/KDE</option
>, a seconda del nome del modulo.</para>
<tip
><para
>Usa piuttosto le opzioni <link linkend="conf-branch"
>branch</link
> e <link linkend="conf-tag"
>tag</link
> se possibile. </para
></tip>
</entry>
</row>

<row id="conf-niceness">
<entry
>niceness</entry>
<entry
>Non sostituibile</entry>
<entry
>Imposta questa opzione a un numero tra 20 e 0. Maggiore è il numero, minore la priorità che &kdesvn-build; si assegnerà. Il valore predefinito è 10. </entry>
</row>

<row id="conf-no-svn">
<entry
>no-svn</entry>
<entry
>Sostituisce globale</entry>
<entry
>Se questa opzione è impostata a <replaceable
>true</replaceable
>, &kdesvn-build; non aggiornerà automaticamente il codice sorgente del modulo. Cercherà ancora di generare il modulo se ci avrebbe provato comunque in condizioni normali.</entry>
</row>

<row id="conf-no-rebuild-on-fail">
<entry
>no-rebuild-on-fail</entry>
<entry
>Sostituisce globale</entry>
<entry
>Imposta questa opzione a <replaceable
>true</replaceable
> (vero) per impedire sempre che &kdesvn-build; cerchi di ricostruire questo modulo se una generazione incrementale non dovesse riuscire. Normalmente &kdesvn-build; cercherà di ricostruire il modulo da zero per annullare l'effetto di aggiornamenti &subversion; mancanti che danneggiano il sistema di generazione.</entry>
</row>

<row id="conf-override-url">
<entry
>override-url</entry>
<entry
>Sostituisce globale</entry>
<entry
>Se imposti questa opzione, &kdesvn-build; userà il suo valore come l'&url; da passare a &subversion; <emphasis
>esattamente com'è</emphasis
>. Generalmente dovresti usarla se vuoi scaricare un rilascio particolare ma &kdesvn-build; non riesce a capire quello che vuoi fare usando <link linkend="conf-branch"
>branch</link
>. </entry>
</row>

<row id="conf-qtdir">
<entry
>qtdir</entry>
<entry
>Sostituisce globale</entry>
<entry
>Imposta questa opzione per impostare la variabile d'ambiente <envar
>QTDIR</envar
> durante la generazione. Non puoi sostituire questa impostazione nelle opzioni di un modulo. Se non specifichi l'opzione, il suo valore predefinito sarà <filename class="directory"
><symbol
>${source-dir}</symbol
>/build/qt-copy</filename
>, che usa il modulo qt-copy incluso nel deposito sorgente di &kde;. Puoi usare una tilde (~) per rappresentare la tua cartella Home. </entry>
</row>

<row id="conf-remove-after-install">
<entry
>remove-after-install</entry>
<entry
>Sostituisce globale</entry>
<entry
><para
>Se hai poco spazio su disco, potrebbe interessarti questa opzione per eliminare automaticamente la cartella di generazione (o entrambe le cartelle del codice sorgente e di generazione per le installazioni singole) dopo che sarà riuscita l'installazione del modulo. </para>
<para
>I valori possibili di questa opzione sono: <itemizedlist>
<listitem
><para
><option
>none</option
> - Non eliminare nulla (predefinito).</para
></listitem>
<listitem
><para
><option
>builddir</option
> - Elimina la cartella di generazione, ma non il codice sorgente.</para
></listitem>
<listitem
><para
><option
>all</option
> - Elimina sia la cartella del codice sorgente che quella di generazione.</para
></listitem>
</itemizedlist>
</para>

<para
>Nota che l'uso di questa opzione può avere un significativo impatto negativo sul tuo uso di banda (se usi <replaceable
>all</replaceable
>) e sul tempo necessario a compilare &kde;, perché &kdesvn-build; non potrà effettuare generazioni incrementali.</para>
</entry>
</row>

<row id="conf-revision">
<entry
>revision</entry>
<entry
>Sostituisce globale</entry>
<entry
>Se questa opzione è impostata a un valore diverso da zero, &kdesvn-build; costringerà l'aggiornamento di &subversion; a portare un modulo all'esatta revisione data, anche se ci sono opzioni come <link linkend="conf-branch"
>branch</link
>. Se il modulo è già alla revisione data non sarà aggiornato di nuovo, a meno che questa opzione sia cambiata o rimossa dalla configurazione.</entry>
</row>

<row id="conf-set-env">
<entry
>set-env</entry>
<entry
>Sostituisce globale</entry>
<entry
><para
>Questa opzione accetta un insieme di valori separati da spazi, dove il primo è la variabile d'ambiente da impostare, e il resto i valori a cui vuoi impostarla. Per esempio, per impostare la variabile <envar
>PINCO</envar
> a <replaceable
>pallino</replaceable
>, inseriresti questo comando nella sezione opportuna:</para>
<screen
><command
>set-env</command
> <envar
>PINCO</envar
> <replaceable
>pallino</replaceable
></screen>
<para
>Questa opzione è speciale perché può essere ripetuta senza sostituire le impostazioni di set-env precedenti nella stessa sezione del <link linkend="configure-data"
>file di configurazione</link
>. In questo modo puoi impostare diverse variabili d'ambiente per modulo (o globalmente).</para>
</entry>
</row>

<row id="conf-source-dir">
<entry
>source-dir</entry>
<entry
>Sostituisce globale</entry>
<entry
>Questa opzione viene usata per impostare la cartelle in cui tenere il codice sorgente &subversion; di &kde; sul tuo computer. Se non specifichi questo valore, quello predefinito sarà <filename class="directory"
>~/kdesvn</filename
>. Se invece lo specifichi, usa un percorso assoluto. </entry>
</row>

<row id="conf-stop-on-failure">
<entry
>stop-on-failure</entry>
<entry
>Sostituisce globale</entry>
<entry
>Imposta questa opzione a <replaceable
>true</replaceable
> (vero) per far fermare l'esecuzione dello script a seguito del verificarsi di un errore durante il processo di generazione o installazione. Il valore predefinito di questa opzione è spento. </entry>
</row>

<row id="conf-svn-server">
<entry
>svn-server</entry>
<entry
>Sostituisce globale</entry>
<entry
>Questa opzione viene usata per impostare il server usato per ritirare i file da &subversion;. Il valore predefinito è il deposito &subversion; anonimo, <filename
>svn://anonsvn.kde.org/</filename
>.</entry>
</row>

<row id="conf-tag">
<entry
>tag</entry>
<entry
>Sostituisce globale</entry>
<entry
><para
>Usa questa opzione per scaricare un rilascio specifico di un modulo.</para>
<para
><emphasis
>Nota:</emphasis
> è molto probabile che usare questa opzione <emphasis
>non è quello che vuoi fare</emphasis
>. I rilasci di &kde; sono disponibili come tarball dal <ulink url="ftp://ftp.kde.org/"
>sito FTP di &kde;</ulink
> o da uno dei suoi <ulink url="http://download.kde.org/download.php"
>mirror</ulink
>.</para>
<para
>Se stai usando &kdesvn-build; perché hai dei problemi ad ottenere un rilascio di &kde; per la tua distribuzione, considera piuttosto lo <ulink url="http://developer.kde.org/build/konstruct/"
>strumento di generazione Konstruct</ulink
>, che funziona con le tarball dei rilasci.</para>
</entry>
</row>

<row id="conf-unsermake-options">
<entry
>unsermake-options</entry>
<entry
>Sostituisce globale</entry>
<entry
>Questa opzione è come <link linkend="conf-make-options"
>make-options</link
> ma per &unsermake;, che accetta alcune opzioni che &make; non capisce. </entry>
</row>

<row id="conf-use-cmake">
<entry
>use-cmake</entry>
<entry
>Sostituisce globale</entry>
<entry
>Questa opzione è stata rimossa a partire da &kdesvn-build; 1.4, perché tutti i moduli di &kde; 4 richiedono &cmake;, e l'uso di &cmake; non è permesso in nessun'altro modulo. </entry>
</row>

<row id="conf-use-qt-builddir-hack">
<entry
>use-qt-builddir-hack</entry>
<entry
>Sostituisce globale</entry>
<entry
>Sebbene questa opzione sostituisca quella globale, ha senso solo per qt-copy. Imposta questa opzione a <replaceable
>true</replaceable
> (vero) per abilitare la modalità dello script con srcdir diverso da builddir. Quando abilitata, &kdesvn-build; copierà il modulo del codice sorgente qt-copy nella cartella di generazione, ed effettuerà la generazione da lì. Ciò vuol dire che la tua variabile d'ambiente <envar
>QTDIR</envar
> dovrebbe invece essere impostata a <filename class="directory"
><symbol
>${qt-copy-build-dir}</symbol
>/qt-copy/lib</filename
>. Dovresti anche cambiare l'opzione <link linkend="conf-qtdir"
>qtdir</link
> corrispondentemente. La compilazione incrementale dovrebbe funzionare ancora in questa modalità, perché le date e le ore dei file saranno mantenute dopo la copia. Se usi l'opzione <link linkend="conf-apply-qt-patches"
>apply-qt-patches</link
>, le patch saranno applicate nella cartella di generazione, non in quella del codice sorgente. Questa opzione ha valore predefinito <replaceable
>true</replaceable
> (vero). </entry>
</row>

<row id="conf-use-stable-kde">
<entry
>use-stable-kde</entry>
<entry
>Non sostituibile</entry>
<entry
><para
>Siccome &kdesvn-build; supporta la generazione di &kde; 3 e 4, c'è bisogno di un modo in cui dire quale versione generare. Come impostazione predefinita &kdesvn-build; genererà la linea principale dello sviluppo di &kde;, chiamata <filename
>/trunk</filename
>. Però questo è &kde; 4, che non è ancora pronto per un rilascio esteso. </para>

<para
>Puoi usare l'opzione &branch; globalmente o per un modulo per scaricare per &kde; 3.5 (o 3.4, eccetera). Però, ciò non è molto comodo perché alcuni moduli (come kdesupport) sono condivisi tra 3.5 e 4. Inoltre, sono molte opzioni &branch; da aggiungere al file di configurazione.</para>

<para
>Perciò, se imposti questa opzione globale a <replaceable
>true</replaceable
>, &kdesvn-build; scaricherà automaticamente la versione 3.5 dei moduli di &kde; come kdelibs e qt-copy, invece di scaricare la versione 4 di &kde;. Puoi sempre usare le opzioni &branch; o &tag; per sostituire le impostazioni che &kdesvn-build; sceglie per un modulo. In questo modo puoi scegliere facilmente se scaricare &kde; 3.5 al posto del pre-rilascio di &kde; 4.</para>
</entry>
</row>

<row id="conf-use-unsermake">
<entry
>use-unsermake</entry>
<entry
>Sostituisce globale</entry>
<entry
><para
>Imposta questa opzione a <replaceable
>true</replaceable
> (vero) per usare il programma sperimentale &unsermake; invece di &automake; quando esegui lo script di configurazione. Ciò può portare a notevoli riduzioni del tempo di generazione, specialmente per i <ulink url="http://www.csh.rit.edu/slashdot/distcc.html"
>sistemi di generazione distribuiti</ulink
>. Questa opzione ha valore predefinito <replaceable
>true</replaceable
> (vero). </para>

<para
>Normalmente, se usi questa opzione &kdesvn-build; manterrà automaticamente &unsermake; aggiornato. Questo potrebbe essere fastidioso, specialmente se gestisci &unsermake; a mano. Se questo è il caso, puoi impostare questa opzione a <option
>self</option
>, e &kdesvn-build; userà ancora &unsermake;, ma non farà nulla di particolare per tenerlo aggiornato. </para>
</entry>
</row>

</tbody>

</tgroup>
</table>

</chapter>

<chapter id="cmdline">
<title
>Opzioni da riga di comando e variabili d'ambiente</title>

<para
>Questo script non usa variabili d'ambiente. se devi impostare delle variabili d'ambiente per il processo di generazione o installazione, vedi l'opzione <link linkend="conf-set-env"
>set-env</link
>. </para>

<para
>Lo script accetta le seguenti opzioni dalla riga di comando: </para>

<variablelist>

<varlistentry id="cmdline-async">
<term
><option
>--async</option
></term>
<listitem
><para
>Abilita la <link linkend="conf-async"
>modalità asincrona</link
> per aggiornare e generare allo stesso tempo. Questa è predefinita, devi specificare l'opzione solo se l'hai disattivata nella configurazione. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-help">
<term
><option
>--help</option
></term>
<listitem
><para
>Mostra soltanto un semplice aiuto sull'uso di questo script. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-version">
<term
><option
>--version</option
></term>
<listitem
><para
>Mostra la versione del programma. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-author">
<term
><option
>--author</option
></term>
<listitem
><para
>Mostra informazioni per contattare l'autore. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-color">
<term
><option
>--color</option
></term>
<listitem
><para
>Abilita l'output colorato. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-nice">
<term
><option
>--nice=<replaceable
>valore</replaceable
></option
></term>
<listitem
><para
>Imposta il valore di &niceness; a <replaceable
>valore</replaceable
> per questa esecuzione. Il <replaceable
>valore</replaceable
> dovrebbe essere tra 0 e 20. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-no-async">
<term
><option
>--no-async</option
></term>
<listitem
><para
>Disabilita la <link linkend="conf-async"
>modalità asincrona</link
> di aggiornamento. L'aggiornamento verrà invece interamente effettuato prima dell'inizio della generazione. Questa opzione rallenterà il processo complessivo, ma, se si verificano errori IPC durante l'esecuzione di &kdesvn-build;, prova ad usare questa opzione e invia una <ulink url="http://bugs.kde.org/"
>segnalazione di errore</ulink
>. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-no-color">
<term
><option
>--no-color</option
></term>
<listitem
><para
>Disabilita l'output colorato. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-pretend">
<term
><option
>--pretend</option
> (o <option
>-p</option
>)</term>
<listitem
><para
>Non fare nulla, fai solo finta di farlo. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-quiet">
<term
><option
>--quiet</option
> (o <option
>-q</option
>)</term>
<listitem
><para
>Non scrivere tanto output. Con questa opzione vengono scritte solo le cose fondamentali. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-really-quiet">
<term
><option
>--really-quiet</option
></term>
<listitem
><para
>scrivi solo avvertimenti ed errori. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-verbose">
<term
><option
>--verbose</option
></term>
<listitem
><para
>Scrivi molte cose su quello che sta succedendo, e su cosa sta facendo &kdesvn-build;. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-svn-only">
<term
><option
>--svn-only</option
></term>
<listitem
><para
>Fai solo l'aggiornamento del codice sorgente. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-build-only">
<term
><option
>--build-only</option
></term>
<listitem
><para
>Fai solo la generazione. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-ignore-modules">
<term
><option
>--ignore-modules</option
></term>
<listitem
><para
>Non includere i moduli passati sul resto della riga di comando nel processo di aggiornamento e generazione. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-no-svn">
<term
><option
>--no-svn</option
></term>
<listitem
><para
>Salta la connessione al server &subversion;. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-no-build">
<term
><option
>--no-build</option
></term>
<listitem
><para
>Salta il processo di generazione. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-no-install">
<term
><option
>--no-install</option
></term>
<listitem
><para
>Non installare automaticamente i pacchetti dopo averli generati. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-debug">
<term
><option
>--debug</option
></term>
<listitem
><para
>Abilita la modalità di debug per lo script. Attualmente ciò vuol dire che tutto l'output sarà riversato sullo standard output oltre ad essere registrato nella cartella di registro, come sarebbe normale. Inoltre, molte funzioni sono molto più verbose riguardo a quello che stanno facendo in modalità di debug. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-no-rebuild-on-fail">
<term
><option
>--no-rebuild-on-fail</option
></term>
<listitem
><para
>Non cercare di rigenerare da zero i moduli che non è stato possibile generare. &kdesvn-build; non cercherà mai di farlo con un modulo che si è già cercato di generare da zero. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-refresh-build">
<term
><option
>--refresh-build</option
></term>
<listitem
><para
>Ricrea il sistema di generazione e compila da zero. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-reconfigure">
<term
><option
>--reconfigure</option
></term>
<listitem
><para
>Esegui lo script di configurazione senza pulire la cartella di generazione. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-recreate-configure">
<term
><option
>--recreate-configure</option
></term>
<listitem
><para
>Esegui di nuovo <command
>make <option
>-f</option
> <filename
>Makefile.cvs</filename
></command
> per creare lo script di configurazione, e continua a generare come normalmente. Questa opzione implica  <option
><link linkend="cmdline-reconfigure"
>--reconfigure</link
></option
>. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-resume-from">
<term
><option
>--resume-from</option
></term>
<listitem
><para
>Questa opzione è usata per riprendere la generazione a partire dal modulo dato, che dovrebbe essere la prossima opzione sulla riga di comando. Questa opzione implica <link linkend="cmdline-no-svn"
><option
>--no-svn</option
></link
>. Non dovresti specificare altri nomi di moduli sulla riga di comando. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-rc-file">
<term
><option
>--rc-file</option
></term>
<listitem
><para
>interpreta il prossimo parametro della riga di comando come il file da cui leggere le opzioni di configurazione. Il valore predefinito di questo parametro è <filename
>~/.kdesvn-buildrc</filename
>. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-run">
<term
><option
>--run</option
></term>
<listitem
><para
>Questa opzione interpreta il prossimo elemento sulla riga di comando come un programma da eseguire; &kdesvn-build; finirà di leggere il file di configurazione, aggiornerà l'ambiente come normalmente, e poi eseguirà il programma dato.</para>

<para
>Nella maggior parte dei casi, tuttavia, ciò non funzionerà per avviare una shell con l'ambiente di &kdesvn-build;, perché le shell interattive di solito azzerano almeno parte delle variabili d'ambiente (come <envar
>PATH</envar
> e <envar
>KDEDIRS</envar
>) nella sequenza di avvio. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-prefix">
<term
><option
>--prefix=&lt;/percorso/a/kde&gt;</option
></term>
<listitem
><para
>Permette di cambiare la cartella in cui sarà installato &kde; dalla riga di comando. Questa opzione implica <link linkend="cmdline-reconfigure"
><option
>--reconfigure</option
></link
>. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-build-system-only">
<term
><option
>--build-system-only</option
></term>
<listitem
><para
>Ferma dopo aver eseguito <command
>make <option
>-f</option
> <filename
>Makefile.cvs</filename
></command
>. Lo script di configurazione dovrà ancora essere eseguito, cosa che &kdesvn-build; farà la volta successiva. Ciò ti permette di preparare tutti gli script di configurazione in una volta, in modo da poter eseguire <command
>./configure <option
>--help</option
></command
> per ogni modulo, e modificare i tuoi flag di configurazione opportunamente. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-install"
><term
><option
>--install</option
></term>
<listitem
><para
>Se questa è l'unica opzione dalla riga di comando, cerca di installare tutti i moduli contenuti nella cartella <filename
>successfully-built</filename
>, tranne per qt-copy che non richiede installazione. Se sono specificate opzioni da riga di comando dopo <option
>--install</option
>, sono considerate essere i moduli da installare. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-global-option">
<term
><option
>--&lt;nome-opzione&gt;=</option
></term>
<listitem
><para
>Puoi usare questa opzione per sostituire un'opzione nel tuo <link linkend="configure-data"
>file di configurazione</link
> per ogni modulo. Per esempio, per sostituire l'opzione <link linkend="conf-log-dir"
>log-dir</link
>, scriveresti: <userinput
><option
>--log-dir=<filename class="directory"
><replaceable
>/percorso/a/cartella</replaceable
></filename
></option
></userinput
>. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-module-option">
<term
><option
>--&lt;nome-modulo&gt;,&lt;nome-opzione&gt;=</option
></term>
<listitem
><para
>Puoi usare questa opzione per sostituire un'opzione nel tuo <link linkend="configure-data"
>file di configurazione</link
> per un modulo particolare. Per esempio, per sostituire l'opzione <link linkend="conf-use-unsermake"
>use-unsermake</link
> per kdemultimedia, scriveresti <option
>--kdemultimedia,use-unsermake=false</option
>. </para
></listitem>
</varlistentry>

</variablelist>

<para
>Tutte le altre opzioni da riga di comando sono considerate come moduli da aggiornare e generare. Non confondere la generazione con l'installazione. </para>

</chapter>

<chapter id="using-kdesvn-build">
<title
>Usare &kdesvn-build;</title>

<sect1 id="using-kdesvn-build-preface">
<title
>Prefazione</title>

<para
>Normalmente, usare &kdesvn-build; dopo essere passati dal<xref linkend="getting-started"/> è facile quanto fare quanto segue da un terminale:</para>

<screen
><prompt
>&percnt;</prompt
> <command
><userinput
>kdesvn-build</userinput
></command
>
</screen>

<para
>&kdesvn-build; quindi scaricherà il codice sorgente di &kde;, cercherà di configurarlo e generarlo, e infine di installarlo.</para>

<para
>Continua a leggere per scoprire come fa &kdesvn-build;, e cos'altro puoi fare con questo strumento.</para>

</sect1>

<sect1 id="basic-features">
<title
>Funzionalità di base di &kdesvn-build;</title>

<sect2 id="using-qt-copy">
<title
>Supporto per qt-copy</title>
<para
>&kdesvn-build; cerca di mantenere un eccellente supporto per il modulo qt-copy incluso nel deposito &subversion; di &kde;.</para>

<note
><para
>qt-copy è una copia del codice sorgente dell'ultimo rilascio delle librerie &Qt; usate da &kde;. Contiene anche una serie di modifiche e migliorie con ottimizazzioni e correzioni che possono essere applicate a scelta. Queste modifiche sono sempre compatibili con la libreria &Qt; in modo che il codice prodotto usando qt-copy funzionerà con le librerie &Qt; normali. </para
></note>

<para
>La maggior parte delle differenze necessarie per qt-copy sono gestite automaticamente da &kdesvn-build;. Tuttavia, ci sono alcune differenze di cui dovresti sapere.</para>

<itemizedlist>
<listitem
><para
>Normalmente il valore di &configure-flags; per un modulo è aggiunto alle impostazioni globali di &configure-flags;. Però, le impostazioni di &configure-flags; per qt-copy sostituiranno le impostazioni globali perché non sono righe di comando equivalenti. </para
></listitem>

<listitem
><para
>&kdesvn-build; definirà automaticamente alcune variabili d'ambiente aggiuntive per generare qt-copy che non sono normalmente necessarie per il resto di &kde;. </para
></listitem>

<listitem
><para
>qt-copy ha anche supporto per una serie di modifiche opzionali contenenti alcune correzioni e ottimizzazioni che non fanno ancora parte delle librerie &Qt; ufficiali. Per abilitarle, imposta l'opzione &apply-qt-patches; a <replaceable
>true</replaceable
>. Dopo aver fatto questa modifica potresti dover eseguire <userinput
><command
>kdesvn-build</command
> <option
>--refresh-build</option
> <option
>qt-copy</option
></userinput
>. </para
></listitem>

</itemizedlist>

</sect2>

<sect2 id="kdesvn-build-std-flags">
<title
>Flag standard aggiunti da &kdesvn-build;</title>
<para
>Per risparmiarti tempo, &kdesvn-build; aggiunge alcuni percorsi standard al tuo ambiente: </para>

<itemizedlist>
<listitem
><para
>I percorsi alle librerie &kde; e &Qt; vengono automaticamente aggiunti alla variabile <envar
>LD_LIBRARY_PATH</envar
>. Ciò vuol dire che non devi modificare &libpath; per includerle. </para
></listitem>

<listitem
><para
>I percorsi ai programmi di sviluppo di &kde; e &Qt; vengono automaticamente aggiunti alla variabile <envar
>PATH</envar
>. Ciò vuol dire che non devi modificare &binpath; per includerli. </para
></listitem>

<listitem
><para
>Il percorso al programma <application
>pkg-config</application
> fornito da &kde; viene aggiunto automaticamente a <envar
>PKG_CONFIG_PATH</envar
>. Ciò vuol dire che non devi modificare &set-env; per includerlo. </para
></listitem>

<listitem
><para
>L'impostazione di &kdedir; è automaticamente propagate alla variabile d'ambiente <envar
>KDEDIR</envar
> durante la generazione. <envar
>KDEDIRS</envar
> non viene modificata. </para
></listitem>

<listitem
><para
>L'impostazione di &qtdir; è automaticamente propagata alla variabile d'ambiente <envar
>QTDIR</envar
> durante la generazione. </para
></listitem>

<listitem
><para
>&kdesvn-build; regolerà automaticamente l'ambiente come necessario secondo l'impostazione dell'opzione &use-unsermake;. </para
></listitem>

</itemizedlist>

</sect2>

<sect2 id="build-priority">
<title
>Cambiare le priorità di generazione di &kdesvn-build;</title>
<para
>I programmi possono girare con diversi livelli di priorità sui moderni sistemi operativi, includi &Linux; e &BSD;. Ciò permette al sistema di allocare le risorse per i diversi programmi a seconda della loro importanza. </para>

<para
>Normalmente &kdesvn-build; si assegnerà una bassa priorità, in modo che gli altri programmi sul sistema non ne siano influenzati e gìrino normalmente. Con questa tecnica, &kdesvn-build; userà le risorse quando saranno disponibili. </para>

<para
>&kdesvn-build; manterrà comunque un livello di priorità abbastanza alto da girare prima dei processi di routine e prima di programmi di donazione di risorse come <ulink url="http://setiathome.ssl.berkeley.edu/"
>Seti@Home</ulink
>. </para>

<para
>Per modificare &kdesvn-build; in modo che usi permanentemente un livello di priorità più alto o più basso, devi regolare il valore di &niceness; nel <link linkend="configure-data"
>file di configurazione</link
>. L'impostazione di &niceness; controlla quant'è <quote
>cortese</quote
> &kdesvn-build; con gli altri programmi. In parole povere, un valore di &niceness; più alto dà a &kdesvn-build; una priorità minore. Perciò, per dare a &kdesvn-build; una priorità maggiore, devi ridurre il valore di &niceness; (e viceversa). Il valore di &niceness; può andare da 0 (per nulla cortese, priorità massima) a 20 (massima cortesia, priorità minima).</para>

<para
>Puoi anche cambiare temporaneamente la priorità di &kdesvn-build; usando <link linkend="cmdline"
>l'opzione da riga di comando</link
> &cmd-nice;. Il valore dell'opzione è usato esattamente come per il valore di &niceness;.</para>

<note
><para
>Per alcuni programmi eseguiti dall'amministratore è possibile avere un valore di &niceness; negativo, con una corrispondentemente maggiore priorità. Impostare un valore negativo (o anche zero) di &niceness; per &kdesvn-build; non è una buona idea, perché non migliorerà granché il tempo di generazione ma renderà molto lento il computer se lo dovessi ancora usare. </para
></note>

<informalexample>
<para
>Per eseguire &kdesvn-build; con un valore di &niceness; di 15 (una priorità minore del normale):</para>

<screen
><prompt
>&percnt;</prompt
> <userinput
><command
>kdesvn-build</command
> <option
>--nice=<replaceable
>15</replaceable
></option
></userinput
>
</screen>

<para
>Oppure puoi cambiare il <link linkend="configure-data"
>file di configurazione</link
> per rendere la modifica permanente:</para>

<screen
>&niceness; <replaceable
>15</replaceable
>
</screen>

</informalexample>
</sect2>

<sect2 id="root-installation">
<title
>Installazione come amministratore</title>
<para
>Potresti voler far girare &kdesvn-build; con privilegi di amministratore. Questo potrebbe essere per la (non raccomandata) installazione per tutto il sistema. È tuttavia utile anche quando si usa una generazione di &kde; a utente singolo: questo perché alcuni moduli (soprattutto kdebase) installano programmi che richiederanno brevemente dei permessi elevati per girare; questi ultimi non possono ottenere questi livelli di permessi a meno di essere installati con permessi elevati. </para>

<para
>Potresti semplicemente eseguire &kdesvn-build; direttamente come amministratore, ma ciò non è raccomandato, perché il programma non è stato verificato per un uso del genere. Anche se fa girare il programma in questo modo non dovrebbe essere pericoloso, è meglio evitare di usare i privilegi di amministratore quando è possibile.</para>

<para
>Per provvedere a ciò, &kdesvn-build; fornisce l'opzione &make-install-prefix;. Puoi usare questa opzione per specificare un comando da usare per effettuare l'installazione come un altro utente. Il modo raccomandato per usare questo comando è con il programma &sudo;, che eseguirà il comando di installazione come amministratore. </para>

<informalexample>
<para
>Per esempio, per installare tutti i moduli usando &sudo;, potresti fare qualcosa di simile:</para>

<screen
>global
  &make-install-prefix; <replaceable
>sudo</replaceable>
  # Altre opzioni
end global
</screen>

<para
>Per usare &make-install-prefix; per un solo modulo, questo dovrebbe funzionare: </para>

<screen
>module <replaceable
>kdemultimedia</replaceable>
  &make-install-prefix; <replaceable
>sudo</replaceable>
end module
</screen>
</informalexample>

</sect2>

<sect2 id="build-progress">
<title
>Mostrare il progresso della generazione di un modulo</title>
<para
>Questa funzionalità è sempre disponibile, ed è attivata automaticamente quando possibile. Quello che fa è visualizzare l'avanzamento stimato durante la generazione di un modulo; in questo modo puoi sapere quanto tempo ci vorrà per generarlo. </para>

<para
>Per poter usare questa funzionalità, l'opzione &use-unsermake; deve essere abilitata per il modulo. Questa opzione è normalmente abilitata come impostazione predefinita, ma alcuni moduli non la supportano e viene loro automaticamente impedito di usare &unsermake;. Quindi, se credi di aver abilitato &unsermake; ma ancora non vedi un segnale di avanzamento durante la generazione del modulo, potrebbe essere che il modulo non supporta &unsermake;.</para>
</sect2>

</sect1>

<sect1 id="advanced-features">
<title
>Funzionalità avanzate</title>

<sect2 id="partial-builds">
<title
>Generare parzialmente un modulo</title>
<para
>È possibile generare solo parti di un singolo modulo di &kde;. Per esempio, potresti voler compilare solo un programma di un modulo. &kdesvn-build; ha delle funzionalità per facilitare questa scelta; ci sono diversi modi per farlo. </para>

<sect3 id="checking-out-parts">
<title
>Ritirare parti di un modulo</title>

<para
>Questo è forse il modo migliore. Quando funziona, risparmierà tempo di scaricamento e spazio su disco. Quello che succede è che &kdesvn-build; scaricherà solo le parti di un modulo che specifichi. Ciò viene fatto usando l'opzione &checkout-only; per un modulo, che specificherà un elenco di cartelle da scaricare. </para>

<tip
><para
>Se non sai già cosa scaricare da un modulo, potrebbe essere una buona idea navigare la struttura di &subversion; di un modulo, usando <ulink url="http://websvn.kde.org/branches/KDE/3.5/"
>WebSVN</ulink
>. </para
></tip>

<informalexample>
<para
>Per prendere solo &kuser; e &kdat; da kdeadmin, potresti usare &checkout-only; in questo modo:</para>

<screen
>module <replaceable
>kdeadmin</replaceable>
  &checkout-only; <replaceable
>kuser kdat</replaceable>
end module
</screen>

</informalexample>

<important
><para
>Le cartelle saranno generate nell'ordine elencato nell'opzione. Se una delle cartelle ha bisogno di qualche altra parte del modulo per compilare, devi assicurarti che siano entrambe nella riga di &checkout-only;, e che la dipendenza richiesta sia prima della cartella che la richiede.</para>

<para
>Inoltre, a volte un'applicazione potrebbe aver bisogno di altre cartelle ed è difficile capire quali, il che potrebbe richiedere un po' di tentativi aggiungendo cartelle all'opzione per capire quali servono.</para>
</important>

<para
>Un'ultima nota su questa opzione. Se cambi il valore di questa opzione, dovresti usare <userinput
><command
>kdesvn-build</command
> <option
>&cmd-refresh-build;</option
> <option
><replaceable
>modulo</replaceable
></option
></userinput
> per assicurarti che il modulo sia correttamente configurato. Inoltre, &kdesvn-build; non rimuoverà mai dei file esistenti se togli delle cartelle dall'opzione &checkout-only;, o aggiungi l'opzione a un modulo che è stato già ritirato.</para>

</sect3>

<sect3 id="not-compiling">
<title
>Rimuovere delle cartelle da una generazione</title>
<para
>Invece di controllare cosa viene scaricato, è possibile scaricare tutto ma far trascurare al sistema alcune cartelle durante la generazione. Ciò potrebbe essere utile se una cartella non funziona mai e non serve al resto del modulo. </para>

<para
>Questo si fa con l'opzione &do-not-compile;. Funziona in modo simile all'opzione &checkout-only; appena descritta perché è semplicemente un elenco di cartelle da non compilare.</para>

<important
><para
>Analogamente a &checkout-only;, questa opzione richiede almeno che lo script <command
>configure</command
> sia eseguito di nuovo per il modulo dopo averlo cambiato. Questo si fa usando il comando <userinput
><command
>kdesvn-build</command
> <option
>&cmd-reconfigure;</option
> <option
><replaceable
>modulo</replaceable
></option
></userinput
>. </para
></important>

<informalexample>
<para
>Per rimuovere la cartella <filename
>dcoppython</filename
> dal processo di generazione di kdebindings:</para>

<screen
>module <replaceable
>kdebindings</replaceable>
  &do-not-compile; <replaceable
>dcoppython</replaceable>
end module
</screen>
</informalexample>

</sect3>

<sect3 id="limiting-using-inst-apps">
<title
>Compilare alcune cartelle da un modulo completo</title>

<para
>Puoi usare l'opzione &inst-apps; per specificare che solo alcune cartelle di un intero modulo devono essere generate (ma viene comunque scaricato tutto il modulo). </para>

<para
>Questa opzione è come una combinazione di &checkout-only; e &do-not-compile;: scarica tutto il modulo come &do-not-compile;, ma compila solo le cartelle che specifichi, come &checkout-only;. Perciò, di solito è meglio usare direttamente &checkout-only;. </para>

<para
>Valgono gli stessi avvertimenti delle altre due opzioni: devi riconfigurare il modulo se cambi il valore di &inst-apps;. </para>
</sect3>

</sect2>

<sect2 id="using-unsermake">
<title
>Usare &unsermake;</title>

<para
>&unsermake; è un'applicazione progettata per il sistema di generazione di &kde; e migliorarlo sostituendo alcuni degli strumenti normalmente usati (inclusi &automake; e &make;). È particolarmente utile per chi fa compilazione distribuita perché è molto più veloce del sistema di generazione normale in questa situazione. Però, &unsermake; è più veloce degli altri anche per una generazione singola. </para>

<para
>Inoltre, &unsermake; include supporto per stimare l'avanzamento dell'attuale processo di generazione. &kdesvn-build; se ne approfitta per dare un'indicazione dell'avanzamento durante la compilazione. Vedi anche <xref linkend="build-progress"/>. </para>

<para
>&kdesvn-build; fornisce automaticamente supporto per l'uso di &unsermake;. &kdesvn-build; userà &unsermake; come impostazione predefinita quando sarà possibile usarlo con un modulo. </para>

<informalexample>
<para
>Per disabilitare il supporto per &unsermake; per ogni modulo, fai come segue:</para>

<screen
>global
  use-unsermake false
end global
</screen>

<para
>Per abilitare &unsermake; per un singolo modulo, anche se è globalmente disabilitato, fai come segue:</para>

<screen
>module <replaceable
>nome-modulo</replaceable>
  use-unsermake true

  # altre opzioni qui...
end module
</screen>
</informalexample>

<note
><para
>&kdesvn-build; aggiornerà o ritirerà &unsermake; durante gli altri aggiornamenti. Se preferisci gestire da solo &unsermake;, è possibile farlo impostando il valore di &use-unsermake; a <replaceable
>self</replaceable
> invece di <replaceable
>true</replaceable
>.</para>

<para
>Quando l'avrai fatto, &kdesvn-build; proverà ancora a usare &unsermake;, ma non ne farà aggiornamenti. Puoi modificare &binpath; per farlo puntare alla corretta cartella di &unsermake;, o ritirare e aggiornare &unsermake; da te dal suo modulo (attualmente kdenonbeta/unsermake). </para
></note>

</sect2>

<sect2 id="using-branches">
<title
>Supporto per rami e tag in &kdesvn-build;</title>

<sect3 id="branches-and-tags">
<title
>Cosa sono i rami e i tag?</title>

<para
>&subversion; supporta la gestione della cronologia del codice di &kde;. &kde; usa questo supporto per creare rami di sviluppo e per segnare il deposito ogni volta che c'è un nuovo rilascio. </para>

<para
>Per esempio, gli sviluppatori di &kmail; potrebbero lavorare a una nuova funzionalità in un ramo diverso per non interferire con la versione usata dagli altri sviluppatori. Questo ramo contiene dei lavori in corso, mentre il ramo principale (detto tronco) potrebbe averne altri. </para>

<para
>Un tag, invece, è un'istantanea del deposito del codice sorgente in un certo momento. Ciò viene usato dalla squadra di amministrazione di &kde; per segnare una versione del codice sorgente adatta al rilascio, lasciando allo stesso tempo che gli sviluppatori possano lavorare sul codice. </para>

<para
>In &subversion; non ci sono differenze tra rami, tag o tronco nel codice. È solo una convenzione usata dagli sviluppatori. Ciò rende difficile supportare bene i rami e i tag con &kdesvn-build;. Tuttavia, alcune cose si possono fare. </para>

</sect3>

<sect3 id="branch-support">
<title
>Come usare rami e tag</title>

<para
>Il supporto per rami e tag viene gestito da una serie di opzioni, che vanno da una richiesta generica di una versione allo scaricamento di un &url; specifico per gli utenti avanzati. </para>

<para
>Il modo più semplice è usare le opzioni &branch; e &tag;. Devi solo usare l'opzione insieme al nome del ramo o tag voluto del modulo, e &kdesvn-build; cercherà di determinare la posizione giusta all'interno del deposito di &kde; da cui scaricare. Per la maggior parte dei moduli di &kde; funziona tutto bene.</para>

<informalexample>
<para
>Per scaricare kdelibs di &kde; 3.5 (che è noto semplicemente come il ramo 3.5): </para>

<screen
>module kdelibs
  branch <replaceable
>3.5</replaceable>
  # altre opzioni...
end module
</screen>

<para
>Oppure, per scaricare kdemultimedia per il rilascio &kde; 3.4.3:</para>

<screen
>module kdemultimedia
  tag <replaceable
>3.4.3</replaceable>
  # altre opzioni...
end module
</screen>

</informalexample>

<tip
><para
>Puoi specificare un valore globale per il ramo. Se lo fai, non dimenticarti di specificare un ramo diverso per i moduli che non dovrebbero usare quello globale! </para
></tip>
</sect3>

<sect3 id="advanced-branches">
<title
>Opzioni avanzate di supporto dei rami</title>

<para
>&kdesvn-build; supporta due opzioni per le situazioni dove &branch; e &tag; non indovinano il percorso giusto: &module-base-path; e &override-url;. </para>

<itemizedlist>
<listitem
><para
>&module-base-path; si usa per aiutare &kdesvn-build; a scrivere la parte mancante del percorso di un modulo. Nel deposito di &kde;, tutti i percorsi sono nella forma <filename class="directory"
>radiceSvn/percorso-base-modulo/<replaceable
>nome-modulo</replaceable
></filename
>. Normalmente &kdesvn-build; riesce a capire da sé la parte in mezzo. Quando non ci riesce, puoi usare &module-base-path;, così: </para>

<informalexample>
<screen
>module qt-copy
  # l'opzione branch non funziona ancora qui
  module-base-path branches/qt/3.3
end module
</screen>

<para
>Ciò farà scaricare a &kdesvn-build; qt-copy da (in questo esempio) <filename
>svn://anonsvn.kde.org/home/kde/<replaceable
>branches/qt/3.3</replaceable
>/qt-copy</filename
>. </para>
</informalexample>
</listitem>

<listitem
><para
>L'opzione &override-url;, invece, ti richiede di specificare il percorso esatto da cui scaricare. Però, ti permette di scaricare da percorsi che &kdesvn-build; non riuscirebbe mai a raggiungere. </para>

<informalexample>
<screen
>module qt-copy
  # Specifica percorso esatto da scaricare.
  override-url svn://anonsvn.kde.org/home/kde/branches/qt/3.3/qt-copy
end module
</screen>
</informalexample>

<important
><para
>&kdesvn-build; non toccherà né modificherà il valore che specifichi per &override-url;, quindi se cambi le tue impostazioni di &svn-server; dovresti cambiare anche questa. </para
></important>

</listitem>
</itemizedlist>

</sect3>

</sect2>

<sect2 id="building-successfully">
<title
>Come &kdesvn-build; cerca di far riuscire la generazione</title>

<sect3 id="automatic-rebuilds">
<title
>Rigerenerazioni automatiche</title>

<para
>A causa di vari problemi con il sistema di generazione di &kde;, alcuni dei quali possono essere ridotti con &unsermake;, &kdesvn-build; effettuerà automaticamente una serie di misure per cercare di far compilare un modulo quando non riesce.</para>

<orderedlist>
<listitem
><para
>Al primo intoppo, &kdesvn-build; farà semplicemente ripartire il comando <command
>make</command
>. Credici o no, a volte funziona davvero, e comunque ci mette poco a fermarsi se non funziona. </para
></listitem>

<listitem
><para
>Al secondo intoppo, &kdesvn-build; cercherà di riconfigurare il modulo e generarlo di nuovo. Di solito funziona nelle situazioni in cui è cambiato un file del sistema di generazione che richiede una riconfigurazione, ma il sistema di generazione non ha fatto automaticamente quell'operazione. </para>

<para
>La cartella di generazione del modulo non viene toccata in questo passo, quindi, con l'eccezione della riconfigurazione, anche questa operazione si fermerà presto se la generazione non è possibile. </para>
</listitem>

<listitem
><para
>Se il modulo non può ancora essere generato, &kdesvn-build; si arrenderà e andrà avanti con il prossimo. Tuttavia, Ci sono ancora cose che puoi fare per <link linkend="manual-rebuilds"
>cercare di far generare il modulo manualmente</link
>. </para
></listitem>
</orderedlist>

<note
><para
>&kdesvn-build; rileverà la maggior parte dei casi in cui il sistema di generazione deve essere riconfigurato, e in tal caso lo riconfigurerà automaticamente. </para>

<para
>Inoltre, se &kdesvn-build; stava generando il modulo per la prima volta, tutti questi passi vengono saltati, perché una generazione pulita di solito funziona sempre a meno che ci siano errori veri.</para>
</note>
</sect3>

<sect3 id="manual-rebuilds">
<title
>Rigenerare un modulo manualmente</title>
<para
>Se cambi le impostazioni di un'opzione di un modulo, o cambia il codice sorgente del modulo in un modo che &kdesvn-build; non riconosce, potresti dover rigenerare il modulo a mano.</para>

<para
>Per farlo basta eseguire <userinput
><command
>kdesvn-build</command
> <option
>--refresh-build</option
> <option
><replaceable
>modulo</replaceable
></option
></userinput
>. </para>

<para
>Se volessi invece che &kdesvn-build; rigenerasse il modulo automaticamente durante il prossimo aggiornamento normale della generazione, puoi creare un file speciale. Ogni modulo ha una cartella di generazione. Se crei un file di nome <filename
>refresh-me</filename
> nella cartella di generazione di un modulo, &kdesvn-build; rigenererà il modulo la prossima volta che partirà il processo di generazione, anche se normalmente avrebbe effettuato la più veloce generazione incrementale.</para>

<tip>
<para
>Come impostazione predefinita, la cartella di generazione è <filename class="directory"
>~/kdesvn/build/<replaceable
>modulo</replaceable
>/</filename
>. Se cambi l'impostazione dell'opzione &build-dir;, usa quella invece di <filename class="directory"
>~/kdesvn/build</filename
>.</para>
</tip>

<informalexample>
<para
>Rigenerazione usando <filename
>refresh-me</filename
> per il modulo <replaceable
>arts</replaceable
>:</para>
<screen
><prompt
>%</prompt
> <userinput
><command
>touch</command
> <filename class="directory"
>~/kdesvn/build/<replaceable
>arts</replaceable
></filename
></userinput>
<prompt
>%</prompt
> <userinput
><command
>kdesvn-build</command
></userinput
>
</screen>
</informalexample>
</sect3>

<sect3 id="controlling-rebuild-behavior">
<title
>Controllare il comportamento della rigenerazione</title>
<para
>Potresti non volere che &kdesvn-build; cerchi sempre di rigenerare un modulo. Puoi disattivare permanentemente questo comportamento cambiando l'opzione &no-rebuild-on-fail; al valore <replaceable
>true</replaceable
>.</para>

<para
>Puoi disattivare temporaneamente questo comportamento (per un comando) usando l'opzione da riga di comando &cmd-no-rebuild-on-fail;.</para>

<informalexample>
<screen
><prompt
>%</prompt
> <userinput
><command
>kdesvn-build</command
> <option
>--no-rebuild-on-fail</option
></userinput
>
</screen>
</informalexample>

</sect3>

</sect2>

<sect2 id="changing-environment">
<title
>Cambiare le impostazioni delle variabili d'ambiente</title>
<para
>&kdesvn-build; non legge l'ambiente del chiamante come la maggior parte dei programmi. Invece, usa le impostazioni che legge dal <link linkend="configure-data"
>file di configurazione</link
> per ricostruire l'ambiente. Questo viene fatto principalmente per assicurarsi che la generazione sia ripetibile. In altre parole, &kdesvn-build; può generare un modulo anche se ti sei dimenticato a cosa avevi impostato le variabili d'ambiente nella shell da cui hai lanciato &kdesvn-build;.</para>

<para
>Tuttavia, potresti voler cambiare le impostazioni delle variabili d'ambiente per cui &kdesvn-build; non fornisce direttamente un'opzione. Ciò è possibile con l'opzione &set-env;.</para>

<para
>Al contrario della maggior parte delle opzioni, può essere impostata più volte, e accetta due voci, separate da spazi. La prima è il nome della variabile d'ambiente da impostare, e il resto della riga è il suo valore.</para>

<informalexample>
<para
>Impostare <userinput
><envar
>DISTRO</envar
>=<replaceable
>BSD</replaceable
></userinput
> per tutti i moduli:</para>
<screen
>global
  set-env <replaceable
>DISTRO</replaceable
> <replaceable
>BSD</replaceable>
end global
</screen>
</informalexample>

</sect2>

<sect2 id="resuming">
<title
>Riprendere le generazioni</title>

<sect3 id="resuming-failed">
<title
>Riprendere una generazione non riuscita o annullata</title>

<para
>Puoi dire a &kdesvn-build; di iniziare a generare da un modulo diverso da quello che sceglierebbe normalmente. Ciò può essere utile quando una serie di moduli non è riuscita, o se hai annullato una generazione a metà. Puoi controllare questo comportamento usando l'opzione &cmd-resume-from;.</para>

<note
><para
>Usare &cmd-resume-from; salterà l'aggiornamento del codice sorgente.</para>
</note>

<informalexample>
<para
>Riavvio della generazione a partire da kdebase:</para>

<screen
><prompt
>%</prompt
> <userinput
><command
>kdesvn-build</command
> <option
>--resume-from=<replaceable
>kdebase</replaceable
></option
></userinput
>
</screen>
</informalexample>

</sect3>

<sect3 id="ignoring-modules">
<title
>Ignorare dei moduli in una generazione</title>

<para
>Analogamente a come si può <link linkend="resuming-failed"
>riprendere la generazione di un modulo</link
>, si può invece scegliere di aggiornare e generare tutto normalmente, ma ignorando una serie di moduli.</para>

<para
>Puoi farlo usando l'opzione &cmd-ignore-modules;. Questa opzione dice a &kdesvn-build; di ignorare tutti i moduli sulla riga di comando durante l'aggiornamento e la generazione.</para>

<informalexample>
<para
>Ignorare extragear/multimedia e kdenonbeta in un'esecuzione completa:</para>
<screen
><prompt
>%</prompt
> <userinput
><command
>kdesvn-build</command
> <option
>--ignore-modules</option
> <replaceable
>extragear/multimedia kdenonbeta</replaceable
></userinput
>
</screen>
</informalexample>

</sect3>
</sect2>

<sect2 id="changing-env-from-cmd-line">
<title
>Cambiare le opzioni dalla riga di comando</title>

<sect3 id="changing-global-opts">
<title
>Cambiare le opzioni globali</title>
<para
>Puoi cambiare le impostazioni delle opzioni lette dal <link linkend="configure-data"
>file di configurazione</link
> direttamente dalla riga di comando. Questa modifica si sostituirà alle impostazioni del file di configurazione, ma solo temporaneamente. Ha effetto solo fintanto che è presente sulla riga di comando.</para>

<para
>&kdesvn-build; ti permette di cambiare opzioni con un nome come <replaceable
>nome-opzione</replaceable
> passando un argomento sulla riga di comando nella forma <userinput
><option
>--<replaceable
>nome-opzione</replaceable
>=valore</option
></userinput
>. &kdesvn-build; capirà se l'opzione non è tra le proprie, e ne cercherà il nome nel suo elenco di opzioni. Se non lo troverà, ti avvertirà, altrimenti ricorderà il valore impostato e sostituirà qualsiasi impostazione del file di configurazione.</para>

<informalexample>
<para
>Impostare l'opzione &source-dir; a <filename
>/dev/null</filename
> per fare una prova:</para>

<screen
><prompt
>%</prompt
> <userinput
><command
>kdesvn-build</command
> <option
>--pretend</option
> <option
>--<replaceable
>source-dir</replaceable
>=<replaceable
>/dev/null</replaceable
></option
></userinput
>
</screen>

<para
>Disattivare &unsermake; dalla riga di comando. <option
>--refresh-build</option
> si usa per costringere le modifiche a &unsermake; ad avere effetto.</para>

<screen
><prompt
>%</prompt
> <userinput
><command
>kdesvn-build</command
> <option
>--pretend</option
> <option
>--refresh-build</option
> <option
>--<replaceable
>use-unsermake</replaceable
>=<replaceable
>false</replaceable
></option
></userinput
>
</screen>

</informalexample>

</sect3>

<sect3 id="changing-module-opts">
<title
>Cambiare le opzioni dei moduli</title>
<para
>È anche possibile cambiare le opzioni solo per un modulo specifico. La sintassi è simile: --<replaceable
>modulo</replaceable
>,<replaceable
>nome-opzione</replaceable
>=<replaceable
>valore</replaceable
>. </para>

<para
>Questa modifica si sostituisce a  qualsiasi impostazione simile per il modulo trovata nel <link linkend="configure-data"
>file di configurazione</link
>, e si applica solo quando l'opzione viene passata dalla riga di comando.</para>

<informalexample>
<para
>Usare una diversa cartella di generazione per il modulo kdeedu:</para>

<screen
><prompt
>%</prompt
> <userinput
><command
>kdesvn-build</command
> <option
>--<replaceable
>kdeedu</replaceable
>,<replaceable
>build-dir</replaceable
>=<replaceable
>diversa</replaceable
></option
></userinput
>
</screen>

</informalexample>

</sect3>

</sect2>

</sect1>

<sect1 id="developer-features">
<title
>Funzionalità per gli sviluppatori di &kde;</title>

<sect2 id="ssh-agent-reminder">
<title
>Controlli dell'agente &ssh;</title>
<para
>&kdesvn-build; può assicurare che gli sviluppatori di &kde; che usano &ssh; per accedere al deposito del codice sorgente di &kde; non dimentichino di tenere attivato l'agente &ssh;. Ciò potrebbe far fermare indefinitamente &kdesvn-build; in attesa della password &ssh; dello sviluppatore, quindi, come impostazione predefinita, &kdesvn-build; controllerà se l'agente è in esecuzione prima di aggiornare il codice sorgente. </para>

<note
><para
>Questo viene fatto solo per gli sviluppatori di &kde; che usano &ssh;. Questo perché non serve nessuna password per il ritiro anonimo predefinito. &subversion; gestirà le password per il secondo protocollo possibile per gli sviluppatori di &kde;, https. </para
></note>

<para
>Potresti voler disattivare il controllo dell'agente &ssh;, nel caso che si verifichino situazioni in cui &kdesvn-build; rilevi erroneamente la presenza dell'agente. Per disattivare il controllo dell'agente, imposta l'opzione <option
>disable-agent-check</option
> a <replaceable
>true</replaceable
>.</para>

<informalexample>
<para
>Disattivare il controllo dell'agente &ssh;:</para>
<screen
>global
  disable-agent-check true
end global
</screen>
</informalexample>

</sect2>

</sect1>

<sect1 id="other-features">
<title
>Altre funzionalità di &kdesvn-build;</title>

<sect2 id="changing-verbosity">
<title
>Cambiare la quantità di output da &kdesvn-build;</title>
<para
>&kdesvn-build; ha diverse opzioni per controllare la quantità di output generato dallo script. In ogni caso, gli errori saranno sempre segnalati.</para>

<itemizedlist>
<listitem
><para
>L'opzione <option
>--quiet</option
> (la sua forma breve è <option
>-q</option
>) fa stare &kdesvn-build; per lo più zitto. Solo i messaggi importanti, gli avvertimenti e gli errori saranno mostrati. Quando disponibile, il progresso della generazione sarà ancora mostrato.</para
></listitem>

<listitem
><para
>L'opzione <option
>--really-quiet</option
> (senza forma breve) fa visualizzare a &kdesvn-build; solo gli avvisi importanti o gli errori durante l'esecuzione.</para
></listitem>

<listitem
><para
>L'opzione <option
>--verbose</option
> (la sua forma breve è <option
>-v</option
>) fa generare a &kdesvn-build; dell'output molto dettagliato.</para
></listitem>

<listitem
><para
>L'opzione <option
>--debug</option
> è solo per scopi di prova e correzione, fa funzionare &kdesvn-build; come se <option
>--verbose</option
> fosse attiva, mette i comandi nell'output del terminale, e visualizzerà informazioni di debug per molte funzioni.</para
></listitem>
</itemizedlist>

</sect2>

<sect2 id="kdesvn-build-color">
<title
>Output colorato</title>
<para
>Anche se viene eseguito da &konsole; o da un altro terminale, &kdesvn-build; sarà normalmente visualizzato con del testo colorato.</para>

<para
>Puoi disattivarlo usando l'opzione <option
>--no-color</option
> sulla riga di comando, o impostando l'opzione &colorful-output; nel <link linkend="configure-data"
>file di configurazione</link
> a <replaceable
>false</replaceable
>. </para>

<informalexample>
<para
>Disattivare l'output colorato nel file di configurazione:</para>
<screen
>global
  colorful-output false
end global
</screen>
</informalexample>

</sect2>

<sect2 id="email-reports">
<title
>Inviare rapporti di generazioni non riuscite via posta elettronica</title>
<para
>&kdesvn-build; può inviare un rapporto a un indirizzo di posta elettronica di tua scelta quando un modulo non riesce a essere generato per qualsiasi motivo. Funziona scegliendo un indirizzo di posta da cui &kdesvn-build; invierà il messaggio, e un indirizzo cui mandarlo quando si verifica un errore.</para>

<para
>&kdesvn-build;, alla fine dell'esecuzione, scriverà un messaggio se ci sono dei moduli che non è stato possibile generare. Il messaggio conterrà un registro abbreviato degli errori per ogni modulo. Viene mandato solo un messaggio per ogni esecuzione, anche se ci fossero stati quindici moduli che non è stato possibile generare. </para>

<para
>Questa funzionalità non è predefinita. Per abilitarla, devi impostare entrambe le opzioni &email-address; e &email-on-compile-error;. <option
>email-address</option
> controlla l'indirizzo da cui &kdesvn-build; invia, e <option
>email-on-compile-error</option
> controlla dove mandare il messaggio. </para>

<tip>
<para
>&kdesvn-build; usa il modulo standard Mail::Mailer di Perl per inviare messaggi. È incluso con Perl 5.8, ed è installabile con Perl 5.6. Mail::Mailer supporta <application
>Sendmail</application
> (inclusi i client di posta elettronica compatibile con <application
>Sendmail</application
>), trasporto nativo <acronym
>SMTP</acronym
>, e <application
>qmail</application
>. </para>
</tip>

<informalexample>
<para
>Inviare un messaggio da pippo@esempio.it a topolino@esempio.it in caso di un errore di generazione:</para>

<screen
>global
  email-address          pippo@esempio.it    # Indirizzo del mittente per ogni messaggio da kdesvn-build
  email-on-compile-error topolino@example.com    # Indirizzo del destinatario in caso di errorie-mail
end global
</screen>
</informalexample>

</sect2>

<sect2 id="deleting-build-dir">
<title
>Rimuovere cartelle non necessarie dopo la generazione</title>
<para
>Se hai poco spazio su disco ma vuoi comunque avere l'ultimo codice sorgente di &kde;, &kdesvn-build; può ridurre l'occupazione del disco durante la generazione di &kde; da &subversion;.</para>

<note
><para
>Tieni presente che generare &kde; porta via molto spazio. Ci sono diverse parti ingombranti durante l'uso di &kdesvn-build;:</para
></note>

<orderedlist>
<listitem
><para
>Il codice sorgente stesso può portar via un bel po' di spazio. I moduli predefiniti portano via 1,6 gigabyte di spazio su disco. Puoi ridurre questa quantità assicurandoti di generare solo i moduli che vuoi davvero. &kdesvn-build; non eliminerà il codice sorgente dal disco anche se elimini la voce corrispondente dal <link linkend="configure-data"
>file di configurazione</link
>, quindi assicurati di eliminare il codice sorgente inutilizzato. Nota che i file sorgenti sono scaricati da Internet, e <emphasis
>non</emphasis
> dovresti eliminarli se li stai usando, almeno fino a quando non hai finito di usare &kdesvn-build;.</para>

<para
>Inoltre, se hai già una versione di &Qt; installata dalla tua distribuzione (e ce ne sono buone probabilità), probabilmente non hai bisogno di installare il modulo qt-copy. Ciò risparmierà circa 200 megabyte di spazio su disco.</para>

<para
>Una cosa da tener presente è il modo in cui funziona &subversion;: per ogni file ritirato dal deposito ci sono due file su disco. &kdesvn-build; al momento non ha codice per cercare di minimizzare la dimensione del codice sorgente quando non viene utilizzato. </para>
</listitem>

<listitem>
<para
>&kdesvn-build; creerà una cartella di generazione separata per generarci il codice sorgente. A volte &kdesvn-build; dovrà copiare una cartella di codice sorgente in una cartella di generazione finta. Quando questo succede, si usano dei collegamenti simbolici per risparmiare spazio, per cui non dovrebbe essere un problema. La cartella di generazione sarà di solito molto più grande della cartella del codice sorgente di un modulo. Per esempio, la cartella di generazione di kdebase è di circa 455 megabyte, mentre il codice sorgente di kdebase è solo di circa 195 megabyte.</para>

<para
>Fortunatamente, la cartella di generazione non è necessaria dopo che un modulo è stato correttamente generato e installato. &kdesvn-build; può rimuovere automaticamente la cartella di generazione dopo l'installazione di un modulo; vedi gli esempi sotto per maggiori informazioni. Nota che questo passo renderà impossibile a &kdesvn-build; l'uso di veloci generazioni incrementali.</para>
</listitem>

<listitem
><para
>Infine, c'è lo spazio necessario per l'installazione di &kde; stessa, che non va dalla cartella di generazione. Questa usa tipicamente meno spazio della cartella di generazione. È però difficile avere numeri esatti. </para
></listitem>
</orderedlist>

<para
>Come si riducono i requisiti di spazio di &kde;? Un modo è usare i flag di compilazione giusti, ottimizzando per ridurre lo spazio invece che per la velocità. Un altro modo che può avere un effetto notevole è rimuovere le informazioni di debug dalla generazione di &kde;. </para>

<warning
><para
>Dovresti sapere bene quello che stai facendo prima di decidere di rimuovere le informazioni di debug. Usare programmi di ultimissima generazione vuol dire che stai usando programmi potenzialmente molto più inclini ad andare in crash di un rilascio stabile. Se stai usando programmi senza informazioni di debug, potrebbe essere molto difficile creare una buona segnalazione di errori per far risolvere il problema, e probabilmente dovrai riabilitare il debug per l'applicazione affetta e rigenerarla per aiutare uno sviluppatore a correggere il problema. Quindi, rimuovi le informazioni di debug a tuo rischio e pericolo! </para
></warning>

<informalexample>
<para
>Rimuovere la cartella di generazione dopo l'installazione di un modulo. La cartella del codice sorgente è tenuta, e il debug è abilitato:</para>

<screen
>global
  configure-flags      --enable-debug
  remove-after-install builddir        # Rimuovi la cartella di generazione dopo l'installazione
end global
</screen>

<para
>Rimuovere la cartella di generazione dopo l'installazione, senza informazioni di debug, con ottimizzazione per le dimensioni.</para>

<screen
>global
  cxxflags             -Os             # Ottimizza per le dimensioni
  configure-flags      --disable-debug
  remove-after-install builddir        # Rimuovi la cartella di generazione dopo l'installazione
end global
</screen>
</informalexample>
</sect2>

</sect1>

</chapter>

<chapter id="kde-cmake">
<title
>&cmake;, il sistema di generazione di &kde; 4</title>

<sect1 id="kde-cmake-intro">
<title
>Introduzione a &cmake;</title>

<para
>Nel marzo 2006, il programma &cmake; sconfisse diversi concorrenti e fu selezionato per essere il sistema di generazione di &kde; 4, sostituendo il sistema basato sugli Autotools che &kde; aveva usato fin dall'inizio.</para>

<para
>È disponibile un'introduzione a &cmake; sul sito <ulink url="http://techbase.kde.org/Development/Tutorials/CMake"
>TechBase di &kde;</ulink
>. Fondamentalmente, invece di eseguire <userinput
><command
>make</command
> <option
>-f</option
> <filename
>Makefile.cvs</filename
></userinput
>, quindi <command
>configure</command
>, e infine &unsermake; (o &make;), dobbiamo semplicemente eseguire &cmake; e poi &make;. </para>

<para
>&kdesvn-build; supporta &cmake;. Alcune funzionalità di &kdesvn-build; erano in realtà funzionalità per il sistema di generazione sottostante, incluse <link linkend="conf-inst-apps"
>inst-apps</link
>, <link linkend="conf-configure-flags"
>configure-flags</link
> e <link linkend="conf-do-not-compile"
>do-not-compile</link
>. Quando sono disponibili funzionalità equivalenti, sono fornite. Per esempio, l'equivalente dell'opzione configure-flags è <link linkend="conf-cmake-options"
>cmake-options</link
>, e anche l'opzione <link linkend="conf-do-not-compile"
>do-not-compile</link
> è supportata per &cmake; nella versione 1.6.3 di &kdesvn-build;. </para>

<para
>Tuttavia, alcune opzioni (come <link linkend="conf-inst-apps"
>inst-apps</link
>) non hanno un equivalente diretto, e sono disattivate. Se dovessi trovare il modo di implementarle con &cmake; lo farò e riattiverò l'opzione. Tuttavia, più o meno tutto funziona allo stesso modo.</para>

</sect1>
</chapter>

<chapter id="credits-and-licenses">
<title
>Riconoscimenti e licenza</title>
&underFDL; </chapter>

</book>
