<?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 % Brazilian-Portuguese "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 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
>'>

  <!-- 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
>Manual do '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
>Marcus</firstname
><surname
>Gama</surname
><affiliation
><address
><email
>marcus.gama@gmail.com</email
></address
></affiliation
><contrib
>Tradução</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
>2009-03-13</date>
<releaseinfo
>1.8</releaseinfo>

<abstract>
<para
>O &kdesvn-build; é um programa que compila e instala o &kde; diretamente a partir do código existente no repositório &subversion; do &kde;.</para>
</abstract>

<keywordset>
<keyword
>KDE</keyword>
<keyword
>kdesdk</keyword>
<keyword
>SVN</keyword>
<keyword
>Subversion</keyword>
<keyword
>Desenvolvimento KDE</keyword>
</keywordset>

</bookinfo>

<chapter id="introduction">
<title
>Introdução</title>

<para
>O &kdesvn-build; é um programa que ajuda os usuários a instalar o <ulink url="http://www.kde.org/"
>&kde;</ulink
> a partir do <ulink url="http://subversion.tigris.org/"
>&subversion;</ulink
>. </para>

<para
>Será documentado aqui a sintaxe e opções do <link linkend="configure-data"
>arquivo de configuração</link
> do &kdesvn-build;, as suas <link linkend="cmdline"
>opções da linha de comando</link
>, as <link linkend="features"
>funcionalidades</link
> e uma <link linkend="getting-started"
>visão geral</link
> de todos os passos necessários para compilar o &kde; a partir do código, incluindo os passos que você deverá efetuar ao usar as outras ferramentas ou, em outras palavras, os passos que não são efetuados automaticamente pelo programa &kdesvn-build;. </para>

</chapter>

<chapter id="getting-started">
<title
>Começando</title>

<para
>Neste capítulo, será apresentada a forma de utilização do &kdesvn-build; para obter os módulos do repositório do &kde; e compilá-los. Nós daremos também uma explicação básica da estrutura de &subversion; do &kde; e os passos que você terá que efetuar antes de executar o programa. </para>

<para
>Todos os tópicos presentes neste capítulo são cobertos com ainda mais detalhes na seção <ulink url="http://techbase.kde.org/Getting_Started/Build/KDE4"
> Compilando o &kde; 4 a partir do Código-Fonte</ulink
>, na <ulink url="http://techbase.kde.org/"
> Página Web da Base Técnica do &kde;</ulink
>. Se você estiver compilando o &kde; pela primeira vez, é uma boa ideia lê-lo ou consultá-lo como fonte de referência. Você irá encontrar informações detalhadas sobre as ferramentas de empacotamento e os requisitos, os problemas de compilação comuns e as estratégias e informações sobre a execução da instalação do seu novo &kde;. </para>

<sect1 id="before-building">
<title
>Preparando o Sistema para Compilar o &kde;</title>

<sect2 id="before-building-users">
<title
>Configurar uma nova conta de usuário</title>

<para
>É recomendável que você baixe e compile o &kde; com uma conta de usuário separada. Se você já tiver os pacotes do &kde; instalados, a melhor opção será criar um usuário diferente (dedicado) para compilar e executar o novo &kde;. A vantagem de compilar o &kde; com um usuário dedicado é que você evitará o risco de corrupção do sistema base e terá sempre uma forma de trabalhar confortavelmente quando as coisas derem errado. </para>

<para
>Mais tarde, você poderá fazer uma instalação de sistema se desejar. Este documento não cobre uma instalação a nível do sistema. Se estiver efetuando uma instalação a nível do sistema, provavelmente já deverá saber o que está fazendo. Caso contrário, recomenda-se consultar a documentação ou páginas de ajuda da sua distribuição, para saber como preparar e usar a instalação do sistema corretamente. </para>

</sect2>
<sect2 id="before-building-preparation">
<title
>Certifique-se de que o seu sistema está pronto para compilar o código do &kde;</title>

<para
>Antes de usar o programa &kdesvn-build; (ou qualquer outra estratégia de compilação), você deverá instalar as ferramentas de desenvolvimento e bibliotecas necessárias para o &kde;. A lista completa das ferramentas necessárias poderá ser encontrada em <ulink url="http://www.kde.org/info/requirements/3.5.php"
>Requisitos de Compilação do &kde;</ulink
>. Os requisitos para a série &kde; 4 podem ser obtidas a partir de <ulink url="http://techbase.kde.org/"
>KDE TechBase</ulink
>. </para>

<para
>Aqui está uma lista das coisas que você irá precisar:</para>
<itemizedlist>

<listitem
><para
>Se você estiver compilando o &kde; 3, irá precisar das Autotools da GNU (i.e., o &automake; e o &autoconf;).</para
></listitem>

<listitem
><para
>Se você estiver compilando o &kde; 4, irá precisar do &cmake;. A versão necessária irá variar, dependendo da versão do &kde; 4 que estiver compilando; veja a TechBase para detalhes mais específicos.</para
></listitem>

<listitem
><para
>O programa cliente de &subversion;, incluindo o suporte para HTTP Seguro (HTTPS). Para certificar-se do suporte necessário, você pode executar <userinput
><command
>svn <option
>--version</option
></command
></userinput
>. Se a saída informar que ele manipula o esquema https (para acesso de escrita ao svn.kde.org) ou o esquema svn (para acesso somente leitura do anonsvn.kde.org) então o cliente deve funcionar.</para
></listitem>

<listitem
><para
>O compilador <application
>gcc</application
>, com suporte para C++. A versão 3.3 ou superiores são as que oferecem o melhor suporte.</para
></listitem>

<listitem
><para
>Certifique-se de que verificou a página dos <ulink url="http://www.kde.org/info/requirements/3.5.php"
>Requisitos de Compilação do &kde;</ulink
> para ter certeza de que todas as outras bibliotecas necessárias estão incluídas.</para
></listitem>

</itemizedlist>

<para
>Uma exceção é a biblioteca &Qt;. O &kdesvn-build; irá instalar normalmente uma cópia do &Qt;, quer já a tenha instalado ou não. Assim, não é necessário possuí-la. Se você não quiser usar a cópia do &Qt;, terá que fazer o seguinte: </para>

<itemizedlist>
<listitem>
  <para
>Certifique-se de que removeu o módulo 'qt-copy' do seu <link linkend="configure-data"
>arquivo de configuração</link
>, uma vez que você não irá precisar dele e, se possuí-lo, isso só vai adicionar um tempo adicional à sua compilação.</para>
</listitem>

<listitem>
  <para
>Mude a configuração da opção <link linkend="conf-qtdir"
>qtdir</link
> no seu <link linkend="configure-data"
>arquivo de configuração</link
>, de modo a apontar para o seu &Qt; de sistema. Isto normalmente equivale à configuração do $<envar
>QTDIR</envar
> no seu sistema.</para>
</listitem>

<listitem>
  <para
>Se você não tiver já o &Qt; instalado, instale-o, incluindo os pacotes -dev ou -devel necessários. Você deverá ter pelo menos o &Qt; 3.3, se for compilar o &kde; 3.5, ou o &Qt; 4.5 se for compilar o &kde; 4.</para>

  <note
><para
>Se você estiver compilando o &kde; 4, é altamente recomendado que use a versão 'qt-copy' do &Qt;, certificando-se de aplicar as correções ('patches') recomendadas - este é o comportamento padrão, controlado pela <link linkend="conf-apply-qt-patches"
>opção apply-qt-patches</link
>).</para
></note>
</listitem>
</itemizedlist>

<para
>Alguns destes pacotes estão divididos em bibliotecas, programas ou utilitários e pacotes de desenvolvimento. Você precisará, pelo menos, do programa ou biblioteca e do seu pacote de desenvolvimento. Se tiver dúvidas, instale tudo. As bibliotecas que necessita irão variar de acordo com os módulos que pretende compilar, uma vez que cada módulo possui os seus próprios requisitos. O <ulink url="http://techbase.kde.org/Getting_Started/Build/KDE4#Required_packages_from_your_distribution"
> TechBase do &kde;</ulink
> tem mais detalhes sobre as ferramentas e técnicas específicas usadas para instalar e encontrar o 'software' necessário. </para>

</sect2>

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

<sect3 id="get-kdesvn-build">
<title
>Instalar o &kdesvn-build;</title>
<para
>Você provavelmente já tem uma versão do programa &kdesvn-build; instalada no seu sistema. Contudo, se não tiver, poderá obtê-lo na <ulink url="http://kdesvn-build.kde.org/"
>página do &kdesvn-build;</ulink
> ou poderá encontrá-lo no seu local original, no repositório de código do &kde;.</para>

<note
><para
>O &kdesvn-build; vem incluído no módulo 'kdesdk', sendo este módulo normalmente já incluído nas distribuições. Se você tiver baixado o &kdesvn-build;, certifique-se de que está usando a versão que baixou. Você poderá usar a opção --version para garantir que está usando a versão correta.</para
></note>

<orderedlist>
<listitem
><para
>Para baixar o &kdesvn-build; a partir de de sua página, basta ir para a <ulink url="http://kdesvn-build.kde.org/"
>página do &kdesvn-build;</ulink
> e transferir a versão mais recente. A versão está dentro de um um pacote TAR comprimido, que poderá extrair com o &ark; ou o <command
>tar</command
>. O conteúdo do pacote inclui o programa &kdesvn-build; atual e um arquivo de configuração de exemplo (<filename
>kdesvn-buildrc-sample</filename
>).</para
></listitem>

<listitem
><para
>Ou você poderá obter o &kdesvn-build; do seu repositório de código, localizado em: <ulink url="http://websvn.kde.org/trunk/KDE/kdesdk/scripts/"
>http://websvn.kde.org/trunk/KDE/kdesdk/scripts/</ulink
>. Esta é a pasta do Kit de Desenvolvimento de Software do &kde;, que é o berço do &kdesvn-build;. Você poderá clicar no item <filename
>kdesvn-build</filename
>, que lhe mostrará uma página onde poderá obter a última versão. Faça isso e salve-o num local conveniente no seu disco rígido. Faça mesmo para o <filename
>kdesvn-buildrc-sample</filename
> se precisar.</para
></listitem>
</orderedlist>

<para
>Independentemente da técnica que usar, você deverá certificar-se de que o arquivo <filename
>kdesvn-build</filename
> é executável. Por conveniência, deverá colocá-lo em uma pasta que esteja definida na variável de ambiente <envar
>PATH</envar
>, caso contrário, poderá obter mensagens que indiquem que o comando não foi encontrado ou que está rodando uma versão errada por engano.</para>
</sect3>

<sect3 id="setup-rcfile">
<title
>Preparar o arquivo de configuração</title>

<para
>Ainda que o &kdesvn-build; não necessite que você crie um <link linkend="configure-data"
>arquivo de configuração</link
>, isto torna o trabalho muito mais simples. Se usar um <link linkend="configure-data"
>arquivo de configuração</link
>, você poderá controlar os módulos que são instalados ou remover módulos que não deseja instalar. O &kdesvn-build;, por padrão, instala uma instalação utilizável do &kde; que usa opções de instalação muito genéricas, o que poderá não atender as suas necessidades. Assim, é melhor usar um <link linkend="configure-data"
>arquivo de configuração</link
>. </para>

<para
>O <link linkend="configure-data"
>arquivo de configuração</link
> deverá se chamar <filename
>.kdesvn-buildrc</filename
>. Este arquivo deverá ser instalado na pasta pessoal (<filename class="directory"
>~/</filename
>), e contém todos os dados de configuração necessários para o programa rodar, como as opções de configuração, compilação, a localização do código, o destino da instalação (prefixo), os módulos que serão compilados, &etc;. Os dados de configuração padrão são oferecidos pelo arquivo <filename
>kdesvn-buildrc-sample</filename
>, que você poderá copiar para o <filename
>~/.kdesvn-buildrc</filename
> e depois editá-lo. </para>

<para
>Você poderá encontrar mais informações sobre a sintaxe do <link linkend="configure-data"
>arquivo de configuração</link
> em <xref linkend="configure-data"/> e em <xref linkend="kdesvn-buildrc"/>. </para>

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

<sect1 id="configure-data">
<title
>Definindo os Dados de Configuração</title>

<para
>Para usar o &kdesvn-build;, você deverá ter um arquivo na sua pasta pessoal chamado <filename
>.kdesvn-buildrc</filename
>, que define as opções gerais e os módulos que deseja baixar e compilar. </para>

<note
><para
>É possível usar arquivos de configuração diferentes para o &kdesvn-build;, que estão descritos em <xref linkend="kdesvn-buildrc"/>. Se você precisar usar várias configurações, veja por favor essa seção. Aqui, nós consideraremos que a configuração está salva em <filename
>~/.kdesvn-buildrc</filename
>.</para
></note>

<para
>A forma mais simples de prosseguir é usar o arquivo <filename
>kdesvn-buildrc-sample</filename
> como modelo, definir as opções globais de acordo com as suas necessidades e a lista dos módulos que deseja compilar. </para>

<para
>A configuração padrão já deverá ser apropriada para efetuar uma compilação do &kde;. Algumas opções que você poderá querer alterar incluem: <itemizedlist>
<listitem
><para
><link linkend="conf-binpath"
>binpath</link
>, para alterar a lista de pastas que serão percorridas na procura de comandos. É exatamente igual à variável <envar
>PATH</envar
> da linha de comando.</para
></listitem>

<listitem
><para
><link linkend="conf-use-stable-kde"
>use-stable-kde</link
> para mudar a versão padrão dos módulos do &kde;. Por padrão, o &kdesvn-build; irá compilar a versão 'trunk' do &kde; (atualmente é a &kde; 4). Se você quiser compilar a última versão estável do &kde; em vez de usar os seus pacotes da distribuição (atualmente, a versão estável é a 3.5), você deverá configurar esta opção como <replaceable
>true</replaceable
> (verdadeira). </para
></listitem>

<listitem
><para
><link linkend="conf-kdedir"
>kdedir</link
>, que muda a pasta de destino para onde o &kde; será instalado. Ela é por padrão a <filename class="directory"
>~/kde</filename
>, que é uma instalação para um único usuário.</para
></listitem>

<listitem
><para
><link linkend="conf-qtdir"
>qtdir</link
>, que controla o local da instalação &Qt; a usar. Por padrão, usa o módulo 'qt-copy' do repositório de &subversion; do &kde; (<filename class="directory"
>~/kdesvn/build/qt-copy</filename
>).</para>

<para
>Para as versões do Qt que suportam a instalação, isto também controla onde instalar o 'qt-copy'.</para
></listitem>

<listitem
><para
><link linkend="conf-svn-server"
>svn-server</link
>, que seleciona o &url; de onde baixar o código. Isto é útil se você for um programador com uma <ulink url="http://techbase.kde.org/Contribute/First_Steps_with_your_KDE_SVN_Account"
>conta &subversion; para o &kde;</ulink
>.</para
></listitem>
</itemizedlist>
</para>

<para
>Depois da seção global, existe uma lista de módulos a compilar, delimitados por 'module ... end module'. Verifique se os módulos indicados são, de fato, os módulos que deseja compilar. As opções padrão do arquivo <filename
>kdesvn-buildrc-sample</filename
> deverão ser suficientes para obter uma instalação relativamente completa do &kde;. Salve o resultado como <filename
>.kdesvn-buildrc</filename
> na sua pasta pessoal. </para>

<para
>Se você desejar fazer um ajuste fino do seu arquivo <filename
>.kdesvn-buildrc</filename
>, consulte o <xref linkend="kdesvn-buildrc"/> para obter informações mais detalhadas sobre todas as opções de configuração. </para>

</sect1>

<sect1 id="building-and-troubleshooting">
<title
>Usando o 'script' &kdesvn-build;</title>

<para
>Agora você está pronto para executar o programa. A partir de uma janela de terminal, autentique-se com o usuário que usará para compilar o &kde; e execute o programa: <screen
><prompt
>&percnt;</prompt
><command
>su</command
> <option
>-</option
> <replaceable
>usuário</replaceable>
<prompt
>&percnt;</prompt
><command
>kdesvn-build</command
>
</screen>
</para>

<para
>Agora, o programa deverá começar a baixar o código e a compilá-lo. Dependendo dos módulos que baixar, poderá ser possível que o &kdesvn-build; não consiga ser bem-sucedido na primeira vez que compilar o &kde;. Não se desespere! </para>

<para
>O &kdesvn-build; registra o resultado de todos os comandos que executa. Por padrão, os arquivos de registro são mantidos em <filename class="directory"
>~/kdesvn/log</filename
>. Para ver o que causou um determinado erro num módulo, no último comando do &kdesvn-build;, normalmente é suficiente ver o <filename class="directory"
>~/kdesvn/log/latest/<replaceable
>nome-módulo</replaceable
>/error.log</filename
>.</para>

<para
>Nesse arquivo, você verá o erro que fez com que a compilação falhasse para esse módulo. Se o arquivo disser (no fim) que lhe faltam alguns pacotes, tente instalar o pacote (incluindo os pacotes -dev apropriados) antes de tentar compilar esse módulo e passe a opção <link linkend="cmdline-reconfigure"
>--reconfigure</link
> depois de instalar os pacotes faltantes.</para>

<para
>Ou, se o erro parecer ser um erro de compilação do código do &kde;, pode ser que isso seja resolvido dentro de alguns dias. Se não for resolvido em tempo útil, sinta-se à vontade para enviar um e-mail para <email
>kde-devel@kde.org</email
> (poderá ser necessário inscrever-se) para comunicar o erro de compilação.</para>

<para
>Você poderá encontrar mais exemplos comuns das coisas que poderão correr mal e as suas soluções, assim como algumas sugestões e estratégias gerais para compilar o &kde;, no <ulink url="http://techbase.kde.org/Getting_Started/Build/KDE4"
>Compilando o &kde; 4 a Partir do Código</ulink
>. </para>

<note
><para
>Para mais informações sobre as funcionalidades de registro do &kdesvn-build;, vá a <xref linkend="kdesvn-build-logging"/>.</para
></note>

</sect1>

<sect1 id="environment">
<title
>Configurando o Ambiente para Executar o seu &kde; Novo</title>

<para
>Assumindo que você está usando um usuário dedicado para compilar o &kde; e já possui uma versão do &kde; instalada, a execução do seu &kde; novo precisará de alguns truques, uma vez que o &kde; novo terá de ter precedência sobre o antigo. Mude as variáveis de ambiente para garantir que isso aconteça. </para>

<sect2 id="changing-profile">
<title
>Alterando a configuração do seu perfil inicial</title>

<important
><para
>O arquivo <filename
>.bash_profile</filename
> é o arquivo de configuração do usuário na linha de comando <application
>bash</application
>, que é usada por muitas distribuições &Linux;. Se você usar uma linha de comando diferente, então poderá ter que ajustar os exemplos dados nesta seção, para a sua linha de comando em particular.</para
></important>

<para
>Abra ou crie o arquivo <filename
>.bash_profile</filename
> na pasta pessoal com o seu editor favorito e adicione ao fim do arquivo: Se você estiver compilando o módulo 'qt-copy' (o padrão), adicione em alternativa: <programlisting>
QTDIR=(local da qtdir)   # Por padrão, ~/kdesvn/build/qt-copy.
KDEDIR=(local da kdedir) # Por padrão ~/kde.
KDEDIRS=$KDEDIR
PATH=$KDEDIR/bin:$QTDIR/bin:$PATH
MANPATH=$QTDIR/doc/man:$MANPATH

# Atuar adequadamente se a LD_LIBRARY_PATH não estiver definida
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
> ou, se não estiver compilando o 'qt-copy' (e usar o &Qt; do seu sistema), adicione isto em alternativa: <programlisting
>KDEDIR=(local da kdedir)  # Por padrão ~/kde.
KDEDIRS=$KDEDIR
PATH=$KDEDIR/bin:$QTDIR/bin:$PATH

# Atuar adequadamente se a LD_LIBRARY_PATH não estiver definida.
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 você não estiver usando um usuário dedicado, defina um novo <envar
>$KDEHOME</envar
> para o seu novo ambiente no seu arquivo <filename
>.bash_profile</filename
>: <programlisting
>export KDEHOME="${HOME}/.kde-svn"

# Criar a pasta se necessário
[ ! -e ~/.kde-svn ] &amp;&amp; mkdir ~/.kde-svn
</programlisting>
</para>

<note>
<para
>Se, mais tarde, o seu Menu K estiver vazio ou completamente cheio de aplicativos da sua distribuição, você poderá ter que definir as suas variáveis de ambiente do <acronym
>XDG</acronym
> no seu <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
>Iniciando o &kde;</title>

<para
>Agora que você ajustou a sua configuração do ambiente para usar o &kde; correto, é importante certificar-se de que o programa <command
>startkde</command
> correto seja usado também. </para>

<para
>Abra o arquivo de texto <filename
>.xinitrc</filename
> da sua pasta pessoal, ou crie-o se necessário. Adicione a linha: <programlisting
><command
>exec</command
> <option
>${KDEDIR}/bin/startkde</option
>
</programlisting>
</para>

<important
><para
>Em algumas distribuições, poderá ser necessário efetuar os mesmos passos com o arquivo <filename
>.xsession</filename
>, também na pasta pessoal. Isto aplica-se especialmente nos gerenciadores de login gráficos como o &kdm;, o <application
>gdm</application
> ou o <application
>xdm</application
>.</para>
</important>

<para
>Agora inicie o seu novo &kde;: nos sistemas &BSD; e &Linux;, com o suporte para terminais virtuais, os atalhos <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F1</keycap
></keycombo
> ... <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F12</keycap
></keycombo
> são usados para mudar para o Console Virtual 1 a 12. Isto permite-lhe executar mais de um ambiente gráfico ao mesmo tempo. Os primeiros seis são terminais de texto e os seis seguintes são gráficos. </para>

<para
>Se, quando você iniciar o seu computador, aparecer o gerenciador gráfico de login, você poderá usar o novo ambiente do &kde;, mesmo que não apareça como uma opção. A maioria dos gerenciadores de login, incluindo o &kdm;, possuem uma opção para usar uma <quote
>Sessão Personalizada</quote
> ao se logar. Com esta opção, a sua configuração de sessões é carregada do arquivo <filename
>.xsession</filename
> da sua pasta pessoal. Se você já tiver modificado este arquivo como descrito acima, esta opção deverá carregar a sua nova instalação do &kde;. </para>

<para
>Caso contrário, existe algo que você poderá tentar que normalmente funciona: Pressione <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F2</keycap
></keycombo
>, para que apareça um terminal de texto. Logue-se com o usuário dedicado e digite: </para>

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

<tip>
<para
>Você poderá executar o &kde; a partir do código e o &kde; antigo ao mesmo tempo! Logue-se com o seu usuário normal e inicie o ambiente de trabalho do &kde; estável. Pressione <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F2</keycap
></keycombo
> (ou <keycap
>F1</keycap
>, <keycap
>F3</keycap
>, etc..), e verá um terminal de texto. Logue-se com o usuário dedicado ao &subversion; do &kde; e digite:</para>

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

<para
>Você poderá voltar ao ambiente de trabalho do &kde; do seu usuário normal pressionando a tecla de atalho do ambiente já em execução. Ela é normalmente o <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F7</keycap
></keycombo
>, sendo que você poderá também precisar usar o <keycap
>F6</keycap
> ou o <keycap
>F8</keycap
> em alternativa. Para voltar ao seu &kde; compilado pelo &kdesvn-build;, irá usar a mesma sequência, usando no entanto a tecla de função seguinte. Por exemplo, se você precisar inserir <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F7</keycap
></keycombo
> para mudar para o seu &kde; normal, poderá ter que inserir <keycombo action="simul"
>&Ctrl;&Alt;<keycap
>F8</keycap
></keycombo
> para voltar ao seu &kde; do &kdesvn-build;.</para>
</tip>

</sect2>
</sect1>

</chapter>

<chapter id="features">
<title
>Funcionalidades do Programa</title>

<sect1 id="features-overview">
<title
>Visão Geral das Funcionalidades</title>

<para
>As funcionalidades do &kdesvn-build; incluem: </para>

<itemizedlist>

<listitem
><para
>Suporta os <link linkend="changing-verbosity"
>níveis de mensagens de resultado</link
>, desde o mais silencioso até à depuração completa. </para
></listitem>

<listitem
><para
>O &kdesvn-build; pode, com a assistência da <ulink url="http://kdesvn-build.kde.org/"
>página Web do &kdesvn-build;</ulink
> e com o servidor de FTP do &kde; (FTP desde o &kdesvn-build; 1.4), permitir extrações rápidas de alguns módulos. Se o módulo que estiver extraindo já possuir um pacote equivalente na página Web, então o &kdesvn-build; irá baixar essa imagem e prepará-la para o seu computador. </para>

<para
>Isto é mais rápido para você, e ajuda a liberar alguma carga nos servidores anônimos de &subversion; do kde.org.</para>
</listitem>

<listitem
><para
>Outra melhoria de performance é conseguida ao iniciar o processo de compilação de um módulo assim que o código-fonte desse módulo tenha sido transferido. (Disponível desde a versão 1.6) </para
></listitem>

<listitem
><para
>Tem um excelente suporte para o <link linkend="using-qt-copy"
>módulo 'qt-copy'</link
>, incluindo a aplicação opcional de correções e otimizações no módulo 'qt-copy'. </para
></listitem>

<listitem
><para
>O &kdesvn-build; tem <link linkend="kdesvn-build-color"
>mensagens de resultado coloridas</link
>. </para
></listitem>

<listitem
><para
>O &kdesvn-build; não precisa de uma <acronym
>GUI</acronym
> presente para funcionar. Por isso, você poderá compilar o &kde; sem precisar de um ambiente gráfico alternativo. </para
></listitem>

<listitem
><para
>Suporta a definição de opções padrão para todos os módulos (como as opções de  compilação ou de configuração). Essas opções também poderão ser modificadas normalmente para módulos específicos.</para>

<para
>Do mesmo modo, o &kdesvn-build; irá <link linkend="kdesvn-build-std-flags"
>adicionar opções padrão</link
>, como for apropriado, para lhe poupar trabalho e alguns erros possíveis, definindo-as você mesmo. </para
></listitem>

<listitem
><para
>O &kdesvn-build; poderá baixar uma <link linkend="using-branches"
>marca ou ramificação específica</link
> de um módulo. Você poderá também ter a certeza de que é usada uma <link linkend="conf-revision"
>versão</link
> específica em vez de um módulo. </para
></listitem>

<listitem
><para
>O &kdesvn-build; poderá mudar automaticamente a pasta de origem para baixar a partir de um repositório, ramificação ou marca diferentes. Isto acontece automaticamente quando você mudar alguma opção que altere o &url; do repositório, se bem que você deve usar a opção <link linkend="cmdline-svn-only"
>--svn-only</link
> para deixar que o &kdesvn-build; saiba que é aceitável efetuar a mudança. </para
></listitem>

<listitem
><para
>O &kdesvn-build; pode <link linkend="partial-builds"
>obter apenas partes de um módulo</link
>, naquelas situações em que você só precisa de um programa de um módulo maior. </para
></listitem>

<listitem
><para
>Para os programadores: O &kdesvn-build; irá <link linkend="ssh-agent-reminder"
>lembrar de você</link
> se você usar o svn+ssh:// mas o <application
>ssh-agent</application
> não estiver rodando, uma vez que isso levará a pedidos de senha repetidos do &ssh;. </para
></listitem>

<listitem
><para
>Pode <link linkend="email-reports"
>enviar relatórios por e-mail</link
> dos erros a um determinado usuário. </para
></listitem>

<listitem
><para
>Pode <link linkend="deleting-build-dir"
>remover a pasta de compilação</link
> de um módulo, após a sua instalação, para poupar espaço, em detrimento de um maior tempo de compilação. </para
></listitem>

<listitem
><para
>Os locais das pastas usadas pelo &kdesvn-build; são configuráveis (até mesmo por módulo). </para
></listitem>

<listitem
><para
>Pode usar o &sudo; ou um comando definido pelo usuário para <link linkend="root-installation"
>instalar os módulos</link
>, para que o &kdesvn-build; não precise ser executado como super-usuário. </para
></listitem>

<listitem
><para
>O &kdesvn-build; roda <link linkend="build-priority"
>com prioridade reduzida</link
>, por padrão, para lhe permitir ainda usar o seu computador, enquanto o &kdesvn-build; estiver trabalhando. </para
></listitem>

<listitem
><para
>Possui suporte para usar as <link linkend="using-branches"
>marcas e ramificações</link
> do &subversion; do &kde;. </para
></listitem>

<listitem
><para
>O &kdesvn-build; irá usar um conjunto de técnicas para <link linkend="building-successfully"
>tentar e garantir</link
> uma compilação com sucesso. </para
></listitem>

<listitem
><para
>Existe o suporte para <link linkend="resuming"
>prosseguir com uma compilação</link
> de um determinado módulo. Você pode até <link linkend="ignoring-modules"
>ignorar alguns módulos</link
> temporariamente para uma determinada compilação. </para
></listitem>

<listitem
><para
>O &kdesvn-build; pode efetuar rapidamente uma <link linkend="partial-builds"
>compilação parcial</link
> de um módulo, diretamente a partir da linha de comando, quando só precisar atualizar parte de um módulo. </para
></listitem>

<listitem
><para
>O &kdesvn-build; irá baixar automaticamente e criar a pasta <filename class="directory"
>/admin</filename
> necessária, se ela não tiver sido obtida do &subversion; da primeira vez, por alguma razão. Isto só se aplica aos módulos do &kde; 3, uma vez que o /admin não é necessário nos módulos 'qt-copy' ou do &kde; 4. </para
></listitem>

<listitem
><para
>O &kdesvn-build; irá mostrar o <link linkend="build-progress"
>progresso da sua compilação</link
> ao usar o &cmake;, e irá medir sempre o tempo do processo de compilação, para que você saiba no fim quanto tempo levou de fato. </para
></listitem>

<listitem
><para
>Tenta automaticamente compilar de novo os módulos que foram compilados com o 'make' incremental, que está sujeito a erros ao fim de algumas modificações. </para
></listitem>

<listitem
><para
>Vem com um conjunto seguro de opções padrão, apropriadas para compilar uma instalação mono-usuário básica do &kde; a partir do repositório de &subversion; anónimo. </para
></listitem>

<listitem
><para
>Expansão do til (~) para as suas opções de configuração. Por exemplo, você poderá especificar: <programlisting
>qtdir ~/kdesvn/build/qt-copy</programlisting>
</para
></listitem>

<listitem
><para
>Configura automaticamente um sistema de compilação, onde a pasta de código não é a mesma que a pasta de compilação, para que você mantenha as suas pastas de origem limpas. </para
></listitem>

<listitem
><para
>Você poderá indicar as opções globais a aplicar a todos os módulos a serem obtidos, assim como poderá indicar opções para serem aplicadas aos módulos individualmente. </para
></listitem>

<listitem
><para
>Uma vez que as ferramentas 'auto*' normalmente perdem a sincronização com as modificações na árvore de código, você poderá forçar uma nova compilação de um módulo, se criar um arquivo chamado '.refresh-me' na pasta de compilação do módulo em questão ou executando o &kdesvn-build; com a opção <option
>--refresh-build</option
>. </para
></listitem>

<listitem
><para
>Você poderá indicar vários valores de ambiente a usar durante a compilação, incluindo o <envar
>KDEDIR</envar
>, o <envar
>QTDIR</envar
>, o <envar
>DO_NOT_COMPILE</envar
> e o <envar
>CXXFLAGS</envar
>. </para
></listitem>

<listitem
><para
>Registro dos comandos. Os arquivos de registro são datados e numerados, para que você tenha sempre um relatório de execução de um programa. Do mesmo modo, é criada uma ligação simbólica 'latest' para apontar sempre para o item de registro mais recente na respectiva pasta. </para
></listitem>

<listitem
><para
>Se você estiver usando uma compilação de usuário do &kde;, em vez de uma instalação do sistema (para a qual precisa ser o 'root' para instalar), você poderá usar o programa para instalá-lo para você. O código não foi ainda validado e ele faz uma utilização ampla da chamada <function
>system()</function
>, assim, eu não recomendo executá-lo como 'root' por enquanto. </para
></listitem>

<listitem
><para
>Você poderá usar o <link linkend="conf-make-install-prefix"
>make-install-prefix</link
> para anteceder o comando <userinput
><command
>make</command
> <option
>install</option
></userinput
> com um comando separado, o que poderá ser útil para o &sudo;. </para
></listitem>

<listitem
><para
>Você poderá obter apenas uma parte de um módulo do &kde; no &subversion;. Por exemplo, poderá obter apenas a biblioteca <application
>taglib</application
> do <application
>kdesupport</application
> ou apenas o <application
>K3B</application
> do <application
>extragear/multimedia</application
>. O programa irá obter automaticamente o <application
>kde-common</application
>, se for necessário para fazer a compilação funcionar. </para
></listitem>

<listitem
><para
>Você poderá <quote
>fingir</quote
> efetuar as operações. Se passar a opção <option
>--pretend</option
> ou <option
>-p</option
> na linha de comando, o programa fornecerá uma descrição mais completa dos comandos que está prestes a executar, sem executá-los de fato. </para
></listitem>

</itemizedlist>

</sect1>

<sect1 id="kdesvn-build-logging">
<title
>Registro de compilação do &kdesvn-build;</title>

<sect2 id="logging-overview">
<title
>Visão geral do registro</title>

<para
>O registro é uma funcionalidade do &kdesvn-build; que consiste no fato do resultado de todos os comandos que o &kdesvn-build; executa serem salvos em um arquivo para serem posteriormente examinados, se necessário. Isto é feito porque muitas vezes é necessário ter o resultado destes programas quando houver um erro de compilação, uma vez que poderão existir várias razões para a compilação falhar, em primeiro lugar.</para>

<sect3 id="log-directory-layout">
<title
>Disposição da pasta de registro</title>

<para
>Os registros são sempre salvos sob a pasta de registro. O destino da pasta de registro é controlado pela opção <link linkend="conf-log-dir"
>log-dir</link
>, que por padrão é <filename class="directory"
><symbol
>${source-dir}</symbol
>/log</filename
> (onde o <symbol
>${source-dir}</symbol
> é o valor da opção <link linkend="conf-source-dir"
>source-dir</link
>. No resto desta seção, este valor será referido como <symbol
>${log-dir}</symbol
>).</para>

<para
>Sob a <symbol
>${log-dir}</symbol
>, existe um conjunto de pastas, uma por cada vez que o &kdesvn-build; foi executado. Cada pasta possui como nome a data e o número da execução. Por exemplo, a segunda vez que o &kdesvn-build; foi executado em 26 de Maio de 2004 irá criar uma pasta chamada <filename
>2004-05-26-02</filename
>, onde o 2004-05-26 corresponde à data e o -02 é o número da execução.</para>

<para
>Para sua conveniência, o &kdesvn-build; irá também criar uma ligação para os registros da sua última execução, chamada <filename class="directory"
>latest</filename
>. Assim, os registros da execução mais recente do &kdesvn-build; deverão estar sempre sob a <filename class="directory"
><symbol
>${log-dir}</symbol
>/latest</filename
>. </para>

<para
>Agora, cada pasta de uma execução do &kdesvn-build; irá conter, por sua vez, um conjunto de pastas, uma por cada módulo &kde; que o &kdesvn-build; tenta compilar. Do mesmo modo, irá conter um arquivo chamado <filename
>build-status</filename
> nessa pasta, que lhe permitirá determinar quais os módulos que compilaram bem e os que falharam.</para>

<note
><para
>Se um módulo em si tiver um sub-módulo (como o extragear/multimedia, playground/utils ou KDE/kdelibs), então, haverá uma disposição equivalente na pasta de registros. Por exemplo, os registros do KDE/kdelibs, após a última execução do &kdesvn-build;, irão aparecer em <filename class="directory"
><symbol
>${log-dir}</symbol
>/latest/KDE/kdelibs</filename
> e não em <filename class="directory"
><symbol
>${log-dir}</symbol
>/latest/kdelibs</filename
>. </para
></note>

<para
>Na pasta de registro de cada módulo, você irá encontrar um conjunto de arquivos para cada operação que o &kdesvn-build; efetuar. Se o &kdesvn-build; atualizar um módulo, você verá arquivos chamados <filename
>svn-co.log</filename
> (para um módulo extraído por completo) ou <filename
>svn-up.log</filename
> (ao atualizar um módulo que já tinha sido extraído). Se o comando <command
>configure</command
> foi executado, então você provavelmente verá um arquivo <filename
>configure.log</filename
> nessa pasta.</para>

<para
>Se um erro ocorreu, você deverá ser capaz de ver uma explicação da razão num dos arquivos. Para ajudá-lo a determinar qual o arquivo que contém o erro, o &kdesvn-build; irá criar uma ligação do arquivo que contém o erro (do tipo <filename
>build-1.log</filename
> para um arquivo chamado <filename
>error.log</filename
>).</para>

<para
>A vantagem de tudo isto é que, para ver onde um arquivo falhou na compilação, após a sua última execução do &kdesvn-build;, o arquivo que deverá ver primeiro é o <filename
><symbol
>${log-dir}</symbol
>/latest/<replaceable
>nome-módulo</replaceable
>/error.log</filename
>. </para>

<tip
><para
>Se o arquivo <filename
>error.log</filename
> estiver em branco (especialmente após uma instalação), então provavelmente não houve qualquer erro. Algumas das ferramentas usadas pelo sistema de compilação do &kde; irão comunicar por engano um erro quando não ocorreu nada.</para>

<para
>Do mesmo modo, alguns comandos poderão fugir ao redirecionamento do resultado do &kdesvn-build; e ignorar o arquivo de registro em certas circunstâncias (normalmente ao obter o conteúdo do &subversion; na primeira vez), e o resultado do erro, nesse caso, não estará no arquivo de registro mas sim no &konsole; ou no terminal onde executou o &kdesvn-build;.</para>
</tip>

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

</chapter>

<chapter id="kdesvn-buildrc">
<title
>O Formato do '.kdesvn-buildrc'</title>

<para
>Para usar o programa, você deverá ter um arquivo na sua pasta pessoal <filename
>.kdesvn-buildrc</filename
>, que descreve os módulos que deseja obter e compilar. </para>

<para
>Ele começa com as opções globais, indicadas da seguinte forma: </para>

<programlisting
>global
<replaceable
>nome-opção valor-opção</replaceable>
<replaceable
>[...]</replaceable>
end global
</programlisting>

<para
>Segue-se então uma ou mais seções dos módulos, organizadas da seguinte forma: </para>

<programlisting
>module <replaceable
>nome-módulo</replaceable>
<replaceable
>nome-opção valor-opção</replaceable>
<replaceable
>[...]</replaceable>
end module
</programlisting>

<para
>O <replaceable
>nome-módulo</replaceable
> deverá ser um módulo do repositório de &subversion; do &kde; (por exemplo, o 'kdelibs' ou o 'kdebase'). Algumas das opções sobrepõem-se às globais, algumas adicionam-se às opções globais e algumas opções globais simplesmente não podem ser sobrepostas. </para>

<para
>Segue-se uma lista ordenada alfabeticamente das opções que poderá usar. Clique na opção para descobrir mais sobre ela. Se alguma não estiver documentada, envie por favor um e-mail aos autores, usando o endereço que poderá encontrar <link linkend="authors"
>acima</link
>. </para>

<itemizedlist>
<listitem
><para
><link linkend="conf-apply-qt-patches"
>apply-qt-patches</link
>, para melhorar o 'qt-copy'.</para
></listitem>
<listitem
><para
><link linkend="conf-async"
>async</link
>, para atualizar e compilar ao mesmo tempo.</para
></listitem>
<listitem
><para
><link linkend="conf-binpath"
>binpath</link
>, para definir a variável <envar
>PATH</envar
>.</para
></listitem>
<listitem
><para
><link linkend="conf-branch"
>branch</link
>, para obter uma determinada ramificação, em vez da '/trunk'.</para
></listitem>
<listitem
><para
><link linkend="conf-build-dir"
>build-dir</link
>, para definir a pasta onde será feita a compilação.</para
></listitem>
<listitem
><para
><link linkend="conf-checkout-only"
>checkout-only</link
>, para transferir apenas as partes de um módulo.</para
></listitem>
<listitem
><para
><link linkend="conf-cmake-options"
>cmake-options</link
> para definir as opções com que um módulo poderá ser configurado com o &cmake;.</para
></listitem>
<listitem
><para
><link linkend="conf-colorful-output"
>colorful-output</link
> para colorir o resultado do programa.</para
></listitem>
<listitem
><para
><link linkend="conf-configure-flags"
>configure-flags</link
> para definir as opções com que um módulo poderá ser configurado.</para
></listitem>
<listitem
><para
><link linkend="conf-cxxflags"
>cxxflags</link
> para definir a variável <envar
>CXXFLAGS</envar
>.</para
></listitem>
<listitem
><para
><link linkend="conf-dest-dir"
>dest-dir</link
> para mudar a pasta de instalação de um módulo.</para
></listitem>
<listitem
><para
><link linkend="conf-disable-agent-check"
>disable-agent-check</link
>, para impedir que o &kdesvn-build; verifique o estado do 'ssh-agent'.</para
></listitem>
<listitem
><para
><link linkend="conf-do-not-compile"
>do-not-compile</link
>, para marcar as pastas que não serão compiladas.</para
></listitem>
<listitem
><para
><link linkend="conf-inst-apps"
>inst-apps</link
>, para só compilar e instalar algumas pastas.</para
></listitem>
<listitem
><para
><link linkend="conf-install-after-build"
>install-after-build</link
>, para evitar a instalação após o processo de compilação.</para
></listitem>
<listitem
><para
><link linkend="conf-kdedir"
>kdedir</link
>, para indicar a pasta onde o &kde; será instalado.</para
></listitem>
<listitem
><para
><link linkend="conf-kde-languages"
>kde-languages</link
>, para definir os pacotes de traduções a baixar e instalar.</para
></listitem>
<listitem
><para
><link linkend="conf-libpath"
>libpath</link
>, para configurar a variável <envar
>LD_LIBRARY_PATH</envar
>.</para
></listitem>
<listitem
><para
><link linkend="conf-make-install-prefix"
>make-install-prefix</link
>, para executar um programa auxiliar (como o &sudo;) durante o <userinput
><command
>make</command
> <option
>install</option
></userinput
>.</para
></listitem>
<listitem
><para
><link linkend="conf-make-options"
>make-options</link
>, para passar opções ao programa &make;.</para
></listitem>
<listitem
><para
><link linkend="conf-manual-build"
>manual-build</link
>, para evitar que o módulo seja compilado automaticamente.</para
></listitem>
<listitem
><para
><link linkend="conf-manual-update"
>manual-update</link
>, para evitar que seja feito, seja o que for, ao módulo de forma automática.</para
></listitem>
<listitem
><para
><link linkend="conf-module-base-path"
>module-base-path</link
>, para mudar o local de onde transferir o módulo (útil para as ramificações - 'branches' -, e marcas - 'tags').</para
></listitem>
<listitem
><para
><link linkend="conf-niceness"
>niceness</link
>, para mudar a prioridade da CPU.</para
></listitem>
<listitem
><para
><link linkend="conf-no-rebuild-on-fail"
>no-rebuild-on-fail</link
>, para evitar a execução do &make; novamente se algo falhar.</para
></listitem>
<listitem
><para
><link linkend="conf-qtdir"
>qtdir</link
>, para definir a localização do &Qt;.</para
></listitem>
<listitem
><para
><link linkend="conf-set-env"
>set-env</link
>, para configurar uma variável de ambiente.</para
></listitem>
<listitem
><para
><link linkend="conf-source-dir"
>source-dir</link
>, para mudar o local onde colocar o código transferido.</para
></listitem>
<listitem
><para
><link linkend="conf-stop-on-failure"
>stop-on-failure</link
>, para fazer com que o &kdesvn-build; pare o mais cedo possível, após encontrar um problema.</para
></listitem>
<listitem
><para
><link linkend="conf-svn-server"
>svn-server</link
>, para mudar o servidor de onde é transferido o código.</para
></listitem>
</itemizedlist>


<para
>Aqui está uma tabela com as opções globais, bem como alguns comentários sobre elas. As opções que se sobreporem às globais irão também sobrepor-se a uma configuração da linha de comando. </para>

<table id="option-table">
<title
>Tabela de Opções</title>
<tgroup cols="3">

<thead>
<row>
<entry
>Nome da Opção</entry>
<entry
>Comportamento do Módulo -&gt; Global</entry>
<entry
>Notas</entry>
</row>
</thead>

<tbody>

<row id="conf-apidox">
<entry
>apidox</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
><para
>Esta opção foi usada para permitir compilar a documentação da API do módulo do KDE. Ela foi removida do &kdesvn-build; 1.6.3 devido a não ser suportada no KDE 4. A documentação 'online' da API está disponível em <ulink url="http://api.kde.org/"
>kde.org</ulink
>. Além disso, é possível compilar a documentação da API do KDE 4 com um programa que vem incluído no módulo 'kdesdk' (na pasta '/scripts'). Veja o <ulink url="http://techbase.kde.org/Development/Tools/apidox"
>TechBase do KDE</ulink
> para mais detalhes. Obviamente, ainda é possível compilar manualmente a documentação da API para os módulos mais antigos.</para>
</entry>
</row>

<row id="conf-apply-qt-patches">
<entry
>apply-qt-patches</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Esta opção só é útil para o 'qt-copy'. Se for um valor diferente de zero, então o programa 'apply-patches' do 'qt-copy' será executado antes da compilação, para aplicar as alterações não oficiais no 'qt-copy'. Uma vez que estas alterações são normalmente a razão para usar o 'qt-copy', em vez de um &Qt; oficial, não deverá haver qualquer problema em ativá-las. Por padrão, está ativada a aplicação destas correções.</entry>
</row>

<row id="conf-async">
<entry
>async</entry>
<entry
>Não poderá ser sobreposta</entry>
<entry
><para
>Esta opção ativa o modo de operação assíncrono, onde a atualização do código fonte e o processo de compilação são executados em paralelo, ao invés de esperar por toda a atualização do código antes de iniciar o processo de compilação. O padrão é o modo assíncrono ativado. Para desativar, configure a opção para <replaceable
>false</replaceable
></para>
<para
>Esta opção está disponível desde a versão 1.6.</para
></entry>
</row>

<row id="conf-binpath">
<entry
>binpath</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
><para
>Ative esta opção para modificar a variável de ambiente PATH durante a compilação. Não poderá sobrepor esta opção numa opção do módulo. O valor padrão é o <filename class="directory"
>/bin:/usr/bin:/usr/local/bin:/usr/X11R6/bin</filename
>. Esta variável de ambiente deverá incluir os locais, separados por dois-pontos das suas ferramentas de desenvolvimento. Os locais <filename class="directory"
>$<envar
>KDEDIR</envar
>/bin</filename
> e <filename class="directory"
>$<envar
>QTDIR</envar
>/bin</filename
> são adicionados automaticamente. Você poderá usar o til (~) para os locais que adicionar com esta opção.</para>
</entry>
</row>

<row id="conf-branch">
<entry
>branch</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
><para
>Altere esta opção para obter uma ramificação do &kde;, em vez do valor padrão<replaceable
>trunk</replaceable
>, onde o desenvolvimento do &kde; está em curso. Por exemplo, para obter a ramificação do &kde; 3.4, você deverá configurar esta opção como <replaceable
>3.4</replaceable
>.</para>
<para
>Lembre-se que alguns módulos usam um nome de ramificação diferente. Notavelmente, o módulo obrigatório 'arts' não segue os números de versões do &kde;. O 'arts' que acompanhava o &kde; 3.4 era o 1.4.</para>
<para
>Se o &kdesvn-build; não conseguir obter adequadamente uma ramificação com esta opção, você poderá ter que indicar manualmente o &url; de onde baixar, com a opção <link linkend="conf-override-url"
>override-url</link
>.</para>
</entry>
</row>

<row id="conf-build-dir">
<entry
>build-dir</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Use esta opção para mudar a pasta que contém o código compilado. Existem três formas diferentes de usá-la: <itemizedlist
> <listitem
><para
>Relativa à pasta de código do &kde; no &subversion; (ver a <link linkend="conf-source-dir"
>opção 'source-dir'</link
>). Esta é a opção padrão e a forma como funcionou o programa até à versão 0.61. Este modo fica selecionado se digitar o nome de uma pasta que não comece por um til (~) ou uma barra (/).</para
> <para
>O valor padrão é <filename class="directory"
>build</filename
>.</para
></listitem
> <listitem
><para
>Um local absoluto. Se indicar um local que comece por um /, então será usado esse local diretamente. Por exemplo, o <filename class="directory"
>/tmp/kde-obj-dir/</filename
>.</para
></listitem
> <listitem
><para
>Relativo à sua pasta pessoal. Se indicar uma pasta que comece com um '~', então o local será usado em relação à sua pasta pessoal, de forma semelhante à expansão do til da linha de comando. Por exemplo, o <filename class="directory"
>~/builddir</filename
> irá configurar a pasta de compilação como <filename class="directory"
>/home/usuário/builddir</filename
>.</para
></listitem
> </itemizedlist
> Surpreendentemente, esta opção poderá ser alterada por módulo. </entry>
</row>

<row id="conf-checkout-only">
<entry
>checkout-only</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Altere esta opção para obter o código do &subversion; passo-a-passo. O valor desta opção deverá ser uma lista separada por espaços das pastas a transferir. Se não incluir a pasta 'admin', ela será incluída automaticamente (se necessário). Ao transferir passo-a-passo, a pasta 'admin' será obtida do 'kde-common', que é onde se encontra no servidor do &subversion;. Ainda que esta opção se sobreponha à global, observe que esta opção, como global, não faz sentido. </entry>
</row>

<row id="conf-cmake-options">
<entry
>cmake-options</entry>
<entry
>Adiciona às opções globais (exceto no 'qt-copy')</entry>
<entry
><para
>Use esta opção para indicar quais opções passar ao &cmake; quando criar o sistema de compilação do módulo. Quando isto é usado como uma opção global, é aplicada a todos os módulos onde este programa se compila. Quando é usado como uma opção de um módulo, é adicionada ao fim das opções globais. Isto permite-lhe definir opções comuns do &cmake; na seção global.</para>

<para
>Esta opção substitui as <link linkend="conf-configure-flags"
>configure-flags</link
> para todos os módulos do &kde; 4, já que eles usam o &cmake; na compilação.</para>

<para
>Uma vez que estas opções são passadas diretamente à linha de comando do &cmake;, deverão ser indicados como seriam passados no &cmake;. Por exemplo:</para>

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

<para
>Já que isto é muito trabalhoso, o &kdesvn-build; faz tudo para que as opções restantes sejam definidas corretamente. Assim, você poderá deixar esta opção em branco.</para
></entry>
</row>

<row id="conf-configure-flags">
<entry
>configure-flags</entry>
<entry
>Adiciona às opções globais (exceto no 'qt-copy')</entry>
<entry
><para
>Use esta opção para indicar quais opções passar ao './configure' quando criar o sistema de compilação do módulo. Quando isto é usado como uma opção global, é aplicada a todos os módulos onde este programa se compila. O 'qt-copy' usa um conjunto muito diferente de opções do 'configure' do resto do &kde;, assim esta opção <emphasis
>sobrepõe</emphasis
> as opções globais, quando é aplicada ao 'qt-copy'. </para>

<para
>Esta opção aplica-se ao 'qt-copy' e a todos os módulos do &kde; 3. Os módulos do &kde; 4 usam o &cmake;, que é controlado pela opção <link linkend="conf-cmake-options"
>cmake-options</link
>.</para>
</entry>
</row>

<row id="conf-colorful-output">
<entry
>colorful-output</entry>
<entry
>Não poderá ser sobreposta</entry>
<entry
>Configure esta opção como <replaceable
>false</replaceable
> para desativar o resultado colorido do &kdesvn-build;. Por padrão é <replaceable
>true</replaceable
>. Lembre-se que o &kdesvn-build; não irá mostrar os códigos de cores em nada que não seja um terminal (como o 'xterm', o &konsole; ou o console normal do &Linux;). </entry>
</row>

<row id="conf-cxxflags">
<entry
>cxxflags</entry>
<entry
>Adiciona-se à opção global</entry>
<entry
><para
>Use esta opção para indicar as opções a passar ao <command
>./configure</command
> como <envar
>CXXFLAGS</envar
>, ao criar o sistema de compilação do módulo. Esta opção é indicada aqui em vez do <link linkend="conf-configure-flags"
>configure-flags</link
> ou do <link linkend="conf-cmake-options"
>cmake-options</link
>, uma vez que esta opção irá também definir a variável de ambiente <envar
>CXXFLAGS</envar
> durante o processo de compilação.</para>

<para
>Observe que para o &kde; 4 e qualquer outro módulo que use o &cmake;, é necessário configurar a opção CMAKE_BUILD_TYPE para "none" ao configurar o módulo. Isto pode ser feito usando a opção <link linkend="conf-cmake-options"
>cmake-options</link
>.</para>
</entry>
</row>

<row id="conf-dest-dir">
<entry
>dest-dir</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Use esta opção para mudar o nome de um módulo no disco. Por exemplo, se o seu módulo era 'extragear/network', você pode mudá-lo para 'extragear-network' com esta opção. Repare que, ainda que isto mude o nome do módulo no disco, não é uma boa ideia incluir pastas ou separadores de pastas no nome, uma vez que isso irá interferir com as opções <link linkend="conf-build-dir"
>build-dir</link
> ou <link linkend="conf-source-dir"
>source-dir</link
>. </entry>
</row>

<row id="conf-disable-agent-check">
<entry
>disable-agent-check</entry>
<entry
>Não poderá ser sobreposta</entry>
<entry
>Normalmente, se você estiver usando o &ssh; para baixar o código do &subversion; (se, por exemplo, estiver usando o protocolo 'svn+ssh'), o &kdesvn-build; irá tentar certificar-se de que, se estiver usando o 'ssh-agent', ele está de fato gerenciando algumas identidades do &ssh;. Isto é para tentar evitar que o &ssh; pergunte a sua frase-senha para todos os módulos. Você poderá desativar esta opção configurar a opção <option
>disable-agent-check</option
> como <replaceable
>true</replaceable
>. </entry>
</row>

<row id="conf-do-not-compile">
<entry
>do-not-compile</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
><para
>Use esta opção para especificar um conjunto de pastas para não ser compilado num módulo (em vez de serem todas). As pastas que não serão compiladas deverão estar separadas por espaços.</para>

<para
>Esta funcionalidade tanto é suportada pelo &kde; 3 como pelo &kde; 4. O suporte para o KDE 4 foi adicionado no &kdesvn-build; 1.6.3.</para>

<para
>Lembre-se que o código dos programas será ainda transferido. Você poderá usar a instrução <link linkend="conf-checkout-only"
>checkout-only</link
> para escolher as pastas que deseja obter.</para>

<para
>Por exemplo, para manter o &juk; e o &kscd; no módulo 'kdemultimedia' sem serem compilados, você poderá adicionar "do-not-compile juk kscd" no seu módulo 'kdemultimedia'.</para>
</entry>
</row>

<row id="conf-email-address">
<entry
>email-address</entry>
<entry
>Não poderá ser sobreposta</entry>
<entry>
<para
>Configure esta opção com o endereço de e-mail que o &kdesvn-build; deverá enviar, no caso dele precisar enviar mensagens de e-mail. Você não terá que se preocupar com isto se não usar qualquer funcionalidade que envie e-mails. (Elas estão todas desativadas por padrão). </para>

<para
>Atualmente, somente o <link linkend="conf-email-on-compile-error"
>email-on-compile-error</link
> necessita desta opção. </para>
</entry>
</row>

<row id="conf-email-on-compile-error">
<entry
>email-on-compile-error</entry>
<entry
>Não poderá ser sobreposta</entry>
<entry>
<para
>Você poderá configurar esta opção com o endereço de e-mail para onde enviar um relatório, sempre que um módulo não conseguir ser compilado. O &kdesvn-build; irá esperar até que todos os módulos terminem e irá recolher todos os resultados no relatório. Ele só é enviado se um módulo se recusar a compilar. </para>

<para
>Por favor, veja a opção <link linkend="conf-email-address"
>email-address</link
> para configurar o endereço que o &kdesvn-build; irá usar para envio, uma vez que o valor padrão não é normalmente o que você deseja. </para>
</entry>
</row>

<row id="conf-inst-apps">
<entry
>inst-apps</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
><para
>Esta é o oposto da opção <link linkend="conf-do-not-compile"
>do-not-compile</link
>. Serve para indicar que apenas as pastas de topo referidas serão compiladas. As pastas deverão estar separadas por espaços.</para>

<para
>As alterações não farão efeito até à próxima vez que o <command
>make <option
>-f</option
> Makefile.cvs</command
> seja executado, quer automaticamente pelo programa, quer manualmente pelas opções <link linkend="cmdline-refresh-build"
><option
>--refresh-build</option
></link
> ou <link linkend="cmdline-recreate-configure"
><option
>--recreate-configure</option
></link
>. </para>

<important
><para
>Esta opção não funciona ainda para os módulos que usam o sistema de compilação &cmake;.</para
></important>

<para
>Lembre-se que o código dos programas será ainda transferido. Você poderá usar a instrução <link linkend="conf-checkout-only"
>checkout-only</link
> para escolher as pastas que deseja obter.</para>
</entry>
</row>

<row id="conf-install-after-build">
<entry
>install-after-build</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Esta opção é usada para instalar o pacote depois dele ser compilado com sucesso. Esta opção está ativa por padrão. Se quiser desativá-la, terá que configurar esta opção como 0 no <link linkend="configure-data"
>arquivo de configuração</link
>. Você poderá também usar a opção da linha de comando <link linkend="cmdline-no-install"
><option
>--no-install</option
></link
>. </entry>
</row>

<row id="conf-kdedir">
<entry
>kdedir</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Esta opção define a pasta em que o &kde; será instalado após a compilação. Por padrão, será em <filename class="directory"
>~/kde</filename
>. Se mudar isto para uma pasta que precise do acesso do 'root', será útil também ler algumas informações sobre a opção <link linkend="conf-make-install-prefix"
>make-install-prefix</link
>.</entry>
</row>

<row id="conf-kde-languages">
<entry
>kde-languages</entry>
<entry
>Não poderá ser sobreposta</entry>
<entry
><para
>Esta opção permite-lhe selecionar os pacote de localização baixados e instalados juntamente com o &kde;. Você poderá fazer isto se não morar nos Estados Unidos e quiser o &kde; traduzido para o seu idioma nativo.</para>

<para
>Para usar esta opção, configure-a como uma lista separada por espaços dos idiomas a instalar. Cada língua possui um código associado a ele, que poderá ser encontrado nesta página: <ulink url="http://i18n.kde.org/teams/"
>http://i18n.kde.org/teams/</ulink
>. </para>

<para
>É aceitável escolher apenas uma língua. Por padrão, não é baixada nenhuma, o que significa que o &kde; irá aparecer em Inglês dos EUA.</para>

<para
>Por exemplo, para optar por instalar o Português Brasileiro, você deverá configurar a opção com algo do tipo: <userinput
><option
>kde-languages</option
> <replaceable
>pt_BR</replaceable
></userinput
>. Terá ainda que usar o &systemsettings; para escolher o idioma Português do Brasil, todavia.</para>
</entry>
</row>

<row id="conf-libpath">
<entry
>libpath</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Configure esta opção para definir a variável de ambiente LD_LIBRARY_PATH, enquanto efetua a compilação. Você não poderá sobrepor esta opção num módulo. O valor padrão está em branco, mas os locais <filename class="directory"
>$<envar
>KDEDIR</envar
>/lib</filename
> e <filename class="directory"
>$<envar
>QTDIR</envar
>/lib</filename
> são adicionados automaticamente. Você poderá usar o til (~) para os locais que adicionar com esta opção. </entry>
</row>

<row id="conf-log-dir">
<entry
>log-dir</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Use esta opção para mudar a pasta que irá conter os arquivos de registro gerados pelo programa. Esta opção poderá ser definida para cada módulo, a partir da versão 0.64. </entry>
</row>

<row id="conf-make-install-prefix">
<entry
>make-install-prefix</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Configure esta variável com uma lista separada por espaços, que será interpretada como um comando e as suas opções, para anteceder o comando <userinput
><command
>make</command
> <option
>install</option
></userinput
>, que é usado para instalar os módulos. Isto é útil para instalar os pacotes com o &sudo;, por exemplo, mas tenha cuidado ao trabalhar com os privilégios do 'root'.</entry>
</row>

<row id="conf-make-options">
<entry
>make-options</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Configure esta variável para passar as opções da linha de comando ao comando <command
>make</command
>. Isto é útil para os programas, como o <ulink url="http://distcc.samba.org/"
><application
>distcc</application
></ulink
> ou para os sistemas com mais de um núcleo de processamento. </entry>
</row>

<row id="conf-manual-build">
<entry
>manual-build</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Configure o valor da opção como <replaceable
>true</replaceable
> para evitar que o processo de compilação tente compilar este módulo. Ele ainda será mantido atualizado ao atualizar a partir do &subversion;. Esta opção é exatamente equivalente à opção da linha de comando <link linkend="cmdline-no-build"
><option
>--no-build</option
></link
>. </entry>
</row>

<row id="conf-manual-update">
<entry
>manual-update</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Configure o valor da opção como <replaceable
>true</replaceable
> para evitar que o processo de compilação tente atualizar (e, por conseguinte, compilar ou instalar) este módulo. Se definir esta opção para um módulo, também poderá tê-la comentada. </entry>
</row>

<row id="conf-module-base-path">
<entry
>module-base-path</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
><para
>Configure esta opção para se sobrepor à pasta padrão do &kdesvn-build; para o módulo em questão. Isto poderá ser usado, por exemplo, para usar ramificações ou marcas específicas de determinadas bibliotecas. O <ulink url="http://websvn.kde.org/"
>Visualizador de Código do &kde;</ulink
> é extremamente valioso para ajudá-lo a escolher o local correto.</para>
<para
>Lembre-se que o &kdesvn-build; constrói o local final de acordo com o seguinte modelo: <varname
>$svn-server</varname
>/home/kde/<varname
>$module-base-path</varname
>/<varname
>$module-name</varname
>. </para>
<para
>O valor padrão tanto pode ser o <quote
>trunk</quote
> como o <quote
>trunk/KDE</quote
>, dependendo do nome do módulo.</para>
<tip
><para
>Use as opções <link linkend="conf-branch"
>branch</link
> ou <link linkend="conf-tag"
>tag</link
> em alternativa, sempre que forem aplicáveis. </para
></tip>
</entry>
</row>

<row id="conf-niceness">
<entry
>niceness</entry>
<entry
>Não poderá ser sobreposta</entry>
<entry
>Configure esta opção com um valor entre 20 e 0. Quanto mais alto o número, menor prioridade terá o &kdesvn-build;. O valor padrão é 10. </entry>
</row>

<row id="conf-no-svn">
<entry
>no-svn</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Se esta opção for igual a 'true', então o &kdesvn-build; não irá atualizar o código-fonte do módulo automaticamente. Ele ainda tentará compilar o módulo, caso já não tenha tentado anteriormente.</entry>
</row>

<row id="conf-no-rebuild-on-fail">
<entry
>no-rebuild-on-fail</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Configure o valor desta opção como <replaceable
>true</replaceable
> para evitar que o &kdesvn-build; sempre tente compilar de novo este módulo, se falhar numa compilação incremental. Normalmente, o &kdesvn-build; irá tentar compilar de novo o módulo do zero, para lidar com o efeito de uma atualização do &subversion; inválida que confunda o sistema de compilação.</entry>
</row>

<row id="conf-override-url">
<entry
>override-url</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Se configurar esta opção, o 'kdesvn-build' irá usar o seu valor como o &url; a passar ao &subversion;,  <emphasis
>sem qualquer alteração</emphasis
>. Você geralmente deverá usar esta opção, se quiser obter uma versão específica, mas o &kdesvn-build; não conseguir descobrir o que você quer dizer ao usar a opção <link linkend="conf-branch"
>branch</link
>. </entry>
</row>

<row id="conf-qtdir">
<entry
>qtdir</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Configure esta opção para definir a variável de ambiente <envar
>QTDIR</envar
> enquanto compila. Você poderá sobrepor esta configuração numa opção de um módulo. Se não indicar esta opção, será por padrão a <filename class="directory"
><symbol
>${source-dir}</symbol
>/build/qt-copy</filename
>, que irá usar o módulo 'qt-copy' que está incluído no repositório de código do &kde;. Você poderá usar um til (~) que representa a sua pasta pessoal. </entry>
</row>

<row id="conf-remove-after-install">
<entry
>remove-after-install</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
><para
>Se estiver com pouco espaço em disco, você poderá querer usar esta opção para remover automaticamente a pasta de compilação (ou as pastas de compilação e de código, para instalações episódicas), após o módulo ter sido instalado com sucesso. </para>
<para
>Os valores possíveis para esta opção são: <itemizedlist>
<listitem
><para
>none - Não remove nada (Este é o valor padrão).</para
></listitem>
<listitem
><para
>builddir - Remove a pasta de compilação, mas não o código.</para
></listitem>
<listitem
><para
>all - Remove tanto o código-fonte como a pasta de compilação.</para
></listitem>
</itemizedlist>
</para>

<para
>Note que a utilização desta opção poderá ter um grande impacto na utilização da sua largura de banda (se usar o <replaceable
>all</replaceable
>) e o tempo que dura a compilação do &kde;, uma vez que o &kdesvn-build; será incapaz de efetuar compilações incrementais.</para>
</entry>
</row>

<row id="conf-revision">
<entry
>revision</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Se esta opção for configurada com um valor diferente de 0 (zero), o &kdesvn-build; irá obrigar a atualização do &subversion; ao obter o módulo que tenha exatamente esse número de versão, mesmo que as opções como o <link linkend="conf-branch"
>branch</link
> estejam em efeito. Se o módulo já estiver na versão indicada, então não será mais atualizado, a menos que esta opção seja alterada ou removida da configuração.</entry>
</row>

<row id="conf-set-env">
<entry
>set-env</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
><para
>Esta opção aceita um conjunto de valores separados por espaços, onde o primeiro valor é a variável de ambiente a definir e o resto dos valores é o que deseja atribuir à sua variável. Por exemplo, para configurar a variável <envar
>RONALD</envar
> como McDonald, você deve colocar este comando na seção apropriada:</para>
<screen
><command
>set-env</command
> <envar
>RONALD</envar
> <userinput
>McDonald</userinput
></screen>
<para
>Esta opção é especial, na medida em que poderá ser repetida sem sobrepor a configuração anterior do 'set-env' na mesma seção do <link linkend="configure-data"
>arquivo de configuração</link
>. Desta forma, você poderá definir mais de uma variável de ambiente por módulo (ou a nível global).</para>
</entry>
</row>

<row id="conf-source-dir">
<entry
>source-dir</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Esta opção é usada para definir a pasta do seu computador onde será guardado o código-fonte do &subversion; do &kde;. Se não indicar este valor, será usado o valor padrão <filename class="directory"
>~/kdesvn</filename
>. Se você especificar este valor, use um local absoluto. </entry>
</row>

<row id="conf-stop-on-failure">
<entry
>stop-on-failure</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Configure o valor desta opção como <replaceable
>true</replaceable
> para fazer com que o programa pare a execução, após ocorrer um erro durante o processo de compilação ou instalação. Esta opção está desativada por padrão. </entry>
</row>

<row id="conf-svn-server">
<entry
>svn-server</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Esta opção é usada para definir o servidor usado para obter o código do &subversion;. Por padrão, é usado o repositório anónimo de &subversion;, em <filename
>svn://anonsvn.kde.org/</filename
></entry>
</row>

<row id="conf-tag">
<entry
>tag</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
><para
>Use esta opção para obter uma versão específica de um módulo.</para>
<para
><emphasis
>Nota:</emphasis
> As chances serão muito boas quando <emphasis
>não quiser</emphasis
> usar esta opção. As versões do &kde; estão disponíveis em pacotes compactados no <ulink url="ftp://ftp.kde.org/"
>servidor de FTP do &kde;</ulink
> ou num dos seus <ulink url="http://download.kde.org/download.php"
>servidores espelho</ulink
>.</para>
<para
>Se você estiver usando o &kdesvn-build; porque está com problemas para obter uma versão do &kde; para compilar na sua distribuição, pense em usar a <ulink url="http://techbase.kde.org/Getting_Started/Build/Konstruct"
>ferramenta de compilação Konstruct</ulink
> em alternativa, que funciona a partir dos pacotes de lançamento.</para>
</entry>
</row>

<row id="conf-use-cmake">
<entry
>use-cmake</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Esta opção foi removida no &kdesvn-build; 1.4, uma vez que todos os módulos do &kde; 4 necessitam do  e a &cmake;utilização do &cmake; não é permitida em mais nenhum módulo. </entry>
</row>

<row id="conf-use-qt-builddir-hack">
<entry
>use-qt-builddir-hack</entry>
<entry
>Sobrepõe-se à global</entry>
<entry
>Ainda que esta opção se sobreponha à global, só fará sentido para o 'qt-copy'. Configure esta opção como <replaceable
>true</replaceable
> para ativar o modo de 'srcdir' != 'builddir'. Se estiver ativada, o &kdesvn-build; irá copiar o módulo de código do 'qt-copy' para a pasta de compilação e efetuar as compilações a partir daí. Isto significa que a sua variável de ambiente <envar
>QTDIR</envar
> ficará igual a <filename class="directory"
>$<symbol
>{qt-copy-build-dir}</symbol
>/qt-copy/lib</filename
> em alternativa. Você deverá também mudar a sua opção <link linkend="conf-qtdir"
>qtdir</link
> em função disso. O &make; incremental deverá ainda funcionar neste modo, uma vez que as datas serão preservadas após a cópia. Se usar a opção <link linkend="conf-apply-qt-patches"
>apply-qt-patches</link
>, as atualizações serão aplicadas na pasta de compilação, não na pasta de código. Esta opção é igual a <replaceable
>true</replaceable
>, por padrão. </entry>
</row>

<row id="conf-use-stable-kde">
<entry
>use-stable-kde</entry>
<entry
>Não poderá ser sobreposta</entry>
<entry
><para
>Uma vez que o &kdesvn-build; possui suporte para compilar o &kde; 3 e o 4, deverá haver alguma forma de indicar qual a versão compilar. Por padrão, o &kdesvn-build; irá compilar a ramificação principal de desenvolvimento do &kde; (chamada de /trunk). Mas este é o &kde; 4, que ainda não está ainda pronto para ser lançado. </para>

<para
>Você pode usar a opção &branch; a nível global ou para cada módulo, para baixar do &kde; 3.5 (ou 3.4, etc.). Contudo, isto não é conveniente porque alguns módulos (como o 'kdesupport') são compartilhados entre o 3.5 e o 4. Além disso, é necessário adicionar muitas opções 'branch' ao arquivo de configuração.</para>

<para
>Assim, se você configurar esta opção global como <replaceable
>true</replaceable
>, o &kdesvn-build; irá baixar automaticamente a versão para o &kde; 3.5 dos módulos, como o 'kdelibs' e o 'qt-copy', em vez de baixar a versão para &kde; 4. Você poderá ainda usar as opções &branch; ou &tag; para um módulo, de modo a substituir a configuração que o &kdesvn-build; escolhe. Desta forma, você poderá optar por baixar o &kde; 3.5 em vez da versão do &kde; 4,.</para>
</entry>
</row>

</tbody>

</tgroup>
</table>

</chapter>

<chapter id="cmdline">
<title
>Opções da Linha de Comando e Variáveis de Ambiente</title>

<para
>Este programa não usa variáveis de ambiente. Se você precisar definir variáveis de ambiente para o ambiente de compilação ou de instalação, veja a opção <link linkend="conf-set-env"
>set-env</link
>. </para>

<para
>O programa aceita as seguintes opções da linha de comando: </para>

<variablelist>

<varlistentry id="cmdline-async">
<term
><option
>--async</option
></term>
<listitem
><para
>Ativa o <link linkend="conf-async"
>modo assíncrono</link
> para atualizar e compilar ao mesmo tempo. Isto é o padrão, e esta opção somente precisa ser especificada se você quiser desabilitá-la na configuração. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-help">
<term
><option
>--help</option
></term>
<listitem
><para
>Mostra apenas uma ajuda simples deste programa. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-version">
<term
><option
>--version</option
></term>
<listitem
><para
>Mostra a versão do programa. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-author">
<term
><option
>--author</option
></term>
<listitem
><para
>Mostra as informações de contato do autor. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-color">
<term
><option
>--color</option
></term>
<listitem
><para
>Ativa o resultado do programa à cores. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-nice">
<term
><option
>--nice=<replaceable
>valor</replaceable
></option
></term>
<listitem
><para
>Configura o valor de &niceness; como <replaceable
>valor</replaceable
>, durante esta execução. O <replaceable
>valor</replaceable
> deverá estar entre 0 e 20. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-no-async">
<term
><option
>--no-async</option
></term>
<listitem
><para
>Desativa o <link linkend="conf-async"
>modo assíncrono</link
> de atualização. Ao invés da atualização ser realizada completamente antes da compilação iniciar. Esta opção irá aumentar o tempo de todo o processo, mas se você encontrar erros de IPC ao rodar o &kdesvn-build; tente usar esta opção e submeter um <ulink url="http://bugs.kde.org/"
>relatório de erro</ulink
>. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-no-color">
<term
><option
>--no-color</option
></term>
<listitem
><para
>Desativa o resultado do programa à cores. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-pretend">
<term
><option
>--pretend</option
> (ou <option
>-p</option
>)</term>
<listitem
><para
>Não faz <emphasis
>nada</emphasis
> de fato, mas funciona como se você fizesse. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-quiet">
<term
><option
>--quiet</option
> (ou <option
>-q</option
>)</term>
<listitem
><para
>Não é tão descritivo com o resultado exibido pela compilação. Com esta opção, somente as mensagens básicas são apresentadas. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-really-quiet">
<term
><option
>--really-quiet</option
></term>
<listitem
><para
>Só mostra as mensagens de avisos e erros. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-verbose">
<term
><option
>--verbose</option
></term>
<listitem
><para
>Torna-se bastante descritivo com o que está acontecendo e o que o &kdesvn-build; está fazendo. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-svn-only">
<term
><option
>--svn-only</option
></term>
<listitem
><para
>Efetua apenas a atualização do código. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-build-only">
<term
><option
>--build-only</option
></term>
<listitem
><para
>Efetua apenas o processo de compilação. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-ignore-modules">
<term
><option
>--ignore-modules</option
></term>
<listitem
><para
>Não inclui os módulos passados no resto da linha de comando no processo de atualização/compilação. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-no-svn">
<term
><option
>--no-svn</option
></term>
<listitem
><para
>Ignora o passo de contacto do servidor do &subversion;. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-no-build">
<term
><option
>--no-build</option
></term>
<listitem
><para
>Salta o processo de compilação. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-no-install">
<term
><option
>--no-install</option
></term>
<listitem
><para
>Não instala automaticamente os pacotes, após a sua compilação. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-debug">
<term
><option
>--debug</option
></term>
<listitem
><para
>Ativa o modo de depuração para o programa. Atualmente, isto significa que todo o resultado será enviado para o saída padrão, além de ficar registrado na pasta de registro normalmente. Do mesmo modo, muitas das funções tornar-se-ão mais descritivas sobre o que estão fazendo no modo de depuração. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-no-rebuild-on-fail">
<term
><option
>--no-rebuild-on-fail</option
></term>
<listitem
><para
>Não tenta compilar de novo os módulos que não conseguiram ser compilados do zero. O &kdesvn-build; nunca irá tentar fazer isto num módulo que já se tentou compilar do zero. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-refresh-build">
<term
><option
>--refresh-build</option
></term>
<listitem
><para
>Recria o sistema de compilação e compila a partir do zero. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-reconfigure">
<term
><option
>--reconfigure</option
></term>
<listitem
><para
>Executa o programa 'configure' novamente sem limpar a pasta de compilação. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-recreate-configure">
<term
><option
>--recreate-configure</option
></term>
<listitem
><para
>Executa o <command
>make <option
>-f</option
> Makefile.cvs</command
> novamente para criar o programa 'configure' e continua a compilação normalmente. Esta opção implica a <option
><link linkend="cmdline-reconfigure"
>--reconfigure</link
></option
>. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-resume-from">
<term
><option
>--resume-from</option
></term>
<listitem
><para
>Esta opção é usada para prosseguir com a compilação a partir do módulo indicado, que é o parâmetro seguinte na linha de comando. Esta opção implica a <link linkend="cmdline-no-svn"
><option
>--no-svn</option
></link
>. Você não deverá indicar os nomes dos outros módulos na linha de comando. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-rc-file">
<term
><option
>--rc-file</option
></term>
<listitem
><para
>interpreta o próximo parâmetro da linha de comando como o arquivo de onde ler as opções de configuração. O valor padrão deste parâmetro é '~/.kdesvn-buildrc'. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-run">
<term
><option
>--run</option
></term>
<listitem
><para
>Esta opção interpreta o item a seguir na linha de comando como um programa a executar, fazendo com que o &kdesvn-build; acabe de ler o arquivo de configuração normalmente e depois execute o programa indicado.</para>

<para
>Isto não irá funcionar para iniciar uma linha de comando com o ambiente do &kdesvn-build;, contudo, uma vez que as linhas de comando interativas tipicamente limpam algumas partes das variáveis de ambiente (como a <envar
>PATH</envar
> e a <envar
>KDEDIRS</envar
>) na sequência de inicialização. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-prefix">
<term
><option
>--prefix=&lt;/localização/do/kde&gt;</option
></term>
<listitem
><para
>Permite-lhe mudar a pasta onde o &kde; será instalado na linha de comando. Esta opção implica a <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
>Pára após a execução do <command
>make <option
>-f</option
> Makefile.cvs</command
>. O programa 'configure' precisará ainda ser executado, coisa que o &kdesvn-build; irá fazer da próxima vez. Isto permite-lhe preparar todos os programas 'configure' de uma vez, para que você possa ver o <command
>./configure <option
>--help</option
></command
> de cada módulo e editar as suas opções do 'configure' adequadamente. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-install"
><term
><option
>--install</option
></term>
<listitem
><para
>Se esta for a única opção da linha de comando, ele irá tentar instalar todos os módulo incluídos em 'successfully-built', exceto o 'qt-copy', que não precisa de instalação. Se as opções da linha de comando forem indicadas após o <option
>--install</option
>, então assumem-se que são módulos para instalar. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-global-option">
<term
><option
>--&lt;nome-da-opção&gt;=</option
></term>
<listitem
><para
>Você poderá usar esta opção para sobrepor outra opção no seu <link linkend="configure-data"
>arquivo de configuração</link
> para todos os módulos. Por exemplo, para sobrepor a opção <link linkend="conf-log-dir"
>log-dir</link
>, você deverá digitar: <userinput
><option
>--log-dir=<filename class="directory"
><replaceable
>/local/da/pasta</replaceable
></filename
></option
></userinput
>. </para
></listitem>
</varlistentry>

<varlistentry id="cmdline-module-option">
<term
><option
>--&lt;nome-módulo&gt;,&lt;nome-opção&gt;=</option
></term>
<listitem
><para
>Ou você poderá usar esta opção para substituir outra no seu <link linkend="configure-data"
>arquivo de configuração</link
>, para um determinado módulo. </para
></listitem>
</varlistentry>

</variablelist>

<para
>Todas as outras opções da linha de comando assumem-se como sendo módulos para atualizar e compilar. Por favor, não misture a compilação com a instalação. </para>

</chapter>

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

<sect1 id="using-kdesvn-build-preface">
<title
>Prefácio</title>

<para
>Normalmente, a utilização do &kdesvn-build; após ter passado pelo <xref linkend="getting-started"/> é tão simples como fazer o seguinte, a partir de uma linha de comando:</para>

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

<para
>O &kdesvn-build; irá então baixar o código do &kde;, tentará configurá-lo e compilá-lo e, no fim, tentará instalá-lo.</para>

<para
>Leia mais para saber como o &kdesvn-build; faz isso, assim como o que você poderá fazer com esta ferramenta.</para>

</sect1>

<sect1 id="basic-features">
<title
>Funcionalidades básicas do &kdesvn-build;</title>

<sect2 id="using-qt-copy">
<title
>Suporte para o 'qt-copy'</title>
<para
>O &kdesvn-build; tenta manter um suporte excelente para o módulo 'qt-copy' que vem incluído no repositório de &subversion; do &kde;.</para>

<note
><para
>O 'qt-copy' é uma cópia do código-fonte da última versão do &Qt;, usada pelo &kde;. Contém também um conjunto de atualizações para otimizações e correções de erros que, opcionalmente, poderão ser aplicadas. Estas atualizações são compatíveis com a biblioteca &Qt;, assim o código produzido com o 'qt-copy' funciona corretamente com o &Qt; normal. </para
></note>

<para
>A maior parte das diferenças necessárias para o 'qt-copy' são tratadas automaticamente pelo &kdesvn-build;. Contudo, existem algumas diferenças que você poderá ter que conhecer.</para>

<itemizedlist>
<listitem
><para
>Normalmente, o valor das &configure-flags; de um módulo é adicionado à configuração global das &configure-flags;. Contudo a opção &configure-flags; do 'qt-copy' irá substituir a configuração global, uma vez que não são linhas de comando equivalentes. </para
></listitem>

<listitem
><para
>O &kdesvn-build; irá definir automaticamente algumas variáveis de ambiente extras para compilar o 'qt-copy', que não são normalmente necessárias para o resto do &kde;. </para
></listitem>

<listitem
><para
>O 'qt-copy' também tem suporte para um conjunto de atualizações opcionais com algumas correções de erros e otimizações que ainda não entraram no &Qt; oficial. Para ativá-las, configure a opção &apply-qt-patches; como <replaceable
>true</replaceable
>. Depois de fazer esta alteração, você poderá ter que executar o <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
>Opções normais adicionadas pelo &kdesvn-build;</title>
<para
>Para lhe poupar tempo, o &kdesvn-build; adiciona alguns locais padrão ao seu ambiente: </para>

<itemizedlist>
<listitem
><para
>O local das bibliotecas do &kde; e do &Qt; é adicionado automaticamente à variável <envar
>LD_LIBRARY_PATH</envar
>. Isto significa que não irá precisar editar a &libpath; para incluí-los. </para
></listitem>

<listitem
><para
>O local dos programas de suporte ao desenvolvimento do &kde; e do &Qt; é adicionado automaticamente à variável <envar
>PATH</envar
>. Isto significa que não irá precisar editar a &binpath; para incluir. </para
></listitem>

<listitem
><para
>O local do <application
>pkg-config</application
> fornecido com o &kde; é adicionado automaticamente ao <envar
>PKG_CONFIG_PATH</envar
>. Isto significa que não terá de usar o &set-env; para os incluí-los. </para
></listitem>

<listitem
><para
>A configuração do &kdedir; é propagada automaticamente para a variável de ambiente <envar
>KDEDIR</envar
> durante a compilação. (O <envar
>KDEDIRS</envar
> não é afetado). </para
></listitem>

<listitem
><para
>A configuração do &qtdir; é propagada automaticamente para a variável de ambiente <envar
>QTDIR</envar
> durante a compilação. </para
></listitem>

</itemizedlist>

</sect2>

<sect2 id="build-priority">
<title
>Mudando a prioridade de compilação do &kdesvn-build;</title>
<para
>Os programas poderão ser executados com diferentes níveis de prioridades nos Sistemas Operacionais atuais, incluindo o &Linux; e o &BSD;. Isto permite ao sistema reservar tempo para os diferentes programas, de acordo com a sua importância. </para>

<para
>O &kdesvn-build; irá reservar uma prioridade baixa para si próprio, para que o resto dos programas do seu sistema não sejam afetados e possam rodar normalmente. Com esta técnica, o &kdesvn-build; irá usar CPU extra quando estiver disponível. </para>

<para
>O &kdesvn-build; irá ainda manter uma prioridade suficientemente alta, para que se execute antes dos processos rotineiros e antes dos programas de doação de CPU, como o <ulink url="http://setiathome.ssl.berkeley.edu/"
>Seti@Home</ulink
>. </para>

<para
>Para alterar o &kdesvn-build;, de modo a usar um nível de prioridade maior ou menor de forma permanente, então você terá que ajustar a opção &niceness; no <link linkend="configure-data"
>arquivo de configuração</link
>. A opção &niceness; controla quão <quote
>legal</quote
> é o &kdesvn-build; com os outros programas. Em outras palavras, um &niceness; maior, dará ao &kdesvn-build; uma prioridade menor. Assim, para dar ao &kdesvn-build; uma maior prioridade, reduza o &niceness; (e vice-versa). O &niceness; pode ir de 0 (nada legal, prioridade máxima) até 20 (super-legal, prioridade mínima).</para>

<para
>Você poderá também mudar temporariamente a prioridade do &kdesvn-build; ao usar a <link linkend="cmdline"
>opção de linha de comando</link
> &cmd-nice;. O valor da opção é usado da mesma forma que no &niceness;.</para>

<note
><para
>É possível para alguns programas executados pelo super-usuário ter um valor de prioridade negativo, com uma prioridade de sistema corresponde ainda maior para alguns programas. A configuração de um valor negativo (ou mesmo 0) do &niceness; para o &kdesvn-build; não é uma boa ideia, uma vez que não irá melhorar muito o tempo de compilação, mas tornará o seu computador muito lento, se ainda precisar usá-lo. </para
></note>

<informalexample>
<para
>Para executar o &kdesvn-build; com uma prioridade igual a 15 (menor que o normal):</para>

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

<para
>Ou você poderá editar o <link linkend="configure-data"
>arquivo de configuração</link
> para tornar a mudança permanente:</para>

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

</informalexample>
</sect2>

<sect2 id="root-installation">
<title
>Instalação como super-usuário</title>
<para
>Você poderá ter o &kdesvn-build; executando a instalação com privilégios de super-usuário. Isto pode acontecer no caso da instalação a nível do sistema (não recomendada). Também é útil se você usar uma instalação normal para um único usuário, todavia. Isto acontece porque alguns módulos (especialmente o 'kdebase') instalam programas que, por breves instantes, irão necessitar de permissões elevadas ao serem executados. Eles não conseguirão obter esses níveis de permissões, a menos que tenham sido instalados com as permissões elevadas. </para>

<para
>Você poderá simplesmente executar o &kdesvn-build; diretamente como super-usuário, mas isto não é recomendável, uma vez que o programa não foi testado para esse tipo de utilização. Ainda que possa ser seguro executá-lo dessa forma, é melhor evitar executar este programa como super-usuário, sempre que possível.</para>

<para
>Para tomar conta disto, o &kdesvn-build; oferece a opção &make-install-prefix;. Você poderá usar esta opção para indicar um comando a usar para efetuar a instalação como outro usuário. A forma recomendada de usar este comando é com o programa &sudo;, que irá então executar o comando de instalação como super-usuário. </para>

<informalexample>
<para
>Por exemplo, para instalar todos os módulos com o &sudo;, você poderá fazer algo como:</para>

<screen
>global
  &make-install-prefix; <replaceable
>sudo</replaceable>
  # Outras opções
end global
</screen>

<para
>Para usar o &make-install-prefix; apenas num módulo, isto irá funcionar: </para>

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

</sect2>

<sect2 id="build-progress">
<title
>Mostrando o progresso da compilação de um módulo</title>
<para
>Esta funcionalidade está sempre disponível e está ativada automaticamente, sempre que possível. O que isto faz é mostrar o progresso estimado da compilação ao compilar um módulo, para que você saiba desta forma quanto tempo mais irá levar para compilar um módulo. </para>

</sect2>

</sect1>

<sect1 id="advanced-features">
<title
>Funcionalidades avançadas</title>

<sect2 id="partial-builds">
<title
>Compilar parcialmente um módulo</title>
<para
>É possível compilar apenas partes de um único módulo do &kde;. Por exemplo, você pode querer compilar apenas um programa de um módulo. O &kdesvn-build; possui funcionalidades para simplificar isto. Existem várias formas complementares de fazer esta tarefa. </para>

<sect3 id="checking-out-parts">
<title
>Extrair partes de um módulo</title>

<para
>Esta será talvez a melhor forma de fazer isto. Quando funciona, lhe poupará tempo de transferência e espaço em disco. O que acontece é que o &kdesvn-build; irá baixar apenas as partes do módulo que indicar. Isto é feito com a opção &checkout-only; para um determinado módulo, que irá indicar uma lista das pastas a baixar. </para>

<tip
><para
>Se você ainda não souber o que vai transferir de um determinado módulo, poderá ser uma boa ideia navegar pela disposição no &subversion; para um módulo, em primeiro lugar, usando o <ulink url="http://websvn.kde.org/branches/KDE/3.5/"
>WebSVN</ulink
>. </para
></tip>

<informalexample>
<para
>Para obter apenas o &kuser; e o &kdat; do 'kdeadmin', você poderá usar o &checkout-only; da seguinte forma:</para>

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

</informalexample>

<important
><para
>As pastas serão compiladas na ordem que forem indicadas na opção. Se uma das pastas necessitar de alguma coisa além do módulo para compilar, então você terá que garantir que ambas se encontram na linha &checkout-only; e que a dependência necessária venha antes da pasta que necessita dela.</para>

<para
>Da mesma forma, algumas vezes um aplicativo poderá necessitar de outras pastas e isso pode ser difícil de descobrir. Isto poderá ser solucionado através de tentativa e erro, adicionando constantemente pastas à opção para descobrir qual é a necessária.</para>
</important>

<para
>Uma nota final sobre esta opção: Se você alterar esta opção deverá usar o <userinput
><command
>kdesvn-build</command
> <option
>&cmd-refresh-build;</option
> <option
><replaceable
>módulo</replaceable
></option
></userinput
> para garantir que o módulo é configurado de novo convenientemente. Além disso, o &kdesvn-build; nunca irá remover os arquivos existentes, se você retirar o número de pastas da sua opção &checkout-only; ou adicionar a opção a um módulo que já foi extraído.</para>

</sect3>

<sect3 id="not-compiling">
<title
>Removendo pastas de uma compilação</title>
<para
>Em vez de restringir o que é baixado, é possível transferir tudo mas fazer com que o sistema de compilação deixe de fora algumas pastas ao compilar. Isto pode ser útil se uma pasta estiver sempre invalidando a compilação e for desnecessária para o resto do módulo. </para>

<para
>Isto é controlado com a opção &do-not-compile;. Funciona de forma semelhante à opção &checkout-only; descrita acima, e é apenas uma lista das pastas que não deverão ser compiladas.</para>

<important
><para
>Da mesma forma que no &checkout-only;, esta opção necessita pelo menos que o programa <command
>configure</command
> seja executado novamente para o módulo, após a alteração. Isto é feito com o comando <userinput
><command
>kdesvn-build</command
> <option
>&cmd-reconfigure;</option
> <option
><replaceable
>módulo</replaceable
></option
></userinput
>. </para
></important>

<informalexample>
<para
>Para remover a pasta <filename
>dcoppython</filename
> do processo de compilação do '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
>Compilando algumas pastas de um módulo completo</title>

<para
>Você poderá usar o &inst-apps; para especificar que apenas algumas pastas de um módulo completo serão instaladas (embora o módulo inteiro seja baixado). </para>

<para
>Esta opção funciona como uma combinação do &checkout-only; e do &do-not-compile;: ela baixa o módulo inteiro, como o &do-not-compile;, mas compila apenas as pastas que indicar, como o &checkout-only;. Assim, é normalmente melhor usar simplesmente o &checkout-only;. </para>

<para
>Os mesmos alertas se aplicam como nas outras duas opções. Assim você terá que reconfigurar o módulo, se você alterar o valor do &inst-apps;. </para>
</sect3>

</sect2>

<sect2 id="using-branches">
<title
>Suporte de marcas e ramificações do &kdesvn-build;</title>

<sect3 id="branches-and-tags">
<title
>O que são ramificações e marcas?</title>

<para
>O  supo&subversion;rta o gerenciamento do histórico do código do &kde;. O &kde; usa esse suporte para criar ramificações ('branches') para desenvolvimento e para marcar o repositório com marcas ('tags'), sempre que lança uma nova versão. </para>

<para
>Por exemplo, os programadores do &kmail; poderão estar trabalhando numa nova funcionalidade, numa ramificação diferente, para evitar corromper a versão que está em uso pela maioria dos programadores. Esta ramificação tem desenvolvimentos em curso nela, mesmo quando a ramificação principal (chamada de /trunk) também possua desenvolvimentos em curso nela. </para>

<para
>Uma marca, por outro lado, é uma imagem do repositório de código numa determinada posição no tempo. Isto é usado pela equipe de administração do &kde; para marcar uma versão do código adequada para lançamento, permitindo ainda aos programadores trabalharem no código. </para>

<para
>No &subversion;, não existem diferenças entre ramificações, marcas ou o 'trunk' no código. É apenas uma convenção usada pelos programadores. Isso torna difícil suportar convenientemente as ramificações e marcas no &kdesvn-build;. Contudo, existem algumas coisas que poderão ser feitas. </para>

</sect3>

<sect3 id="branch-support">
<title
>Como usar as ramificações e marcas</title>

<para
>O suporte para ramificações e marcas é tratado por um conjunto de opções, que vão desde um simples pedido de uma versão até um &url; específico de transferência, para os usuários mais avançados. </para>

<para
>O método mais simples é usar as opções &branch; e &tag;. Você poderá usar a opção em conjunto com o nome da marca ou ramificação de um módulo, para que o &kdesvn-build; determine o local apropriado, dentro do repositório do &kde;, de onde deve baixar. Na maioria dos módulos do &kde;, isto funciona muito bem.</para>

<informalexample>
<para
>Para baixar o 'kdelibs' do &kde; 3.5 (que é simplesmente conhecido pela ramificação '3.5'): </para>

<screen
>module kdelibs
  branch <replaceable
>3.5</replaceable>
  # outras opções...
end module
</screen>

<para
>Ou, para baixar o 'kdemultimedia' como foi lançado no &kde; 3.4.3:</para>

<screen
>module kdemultimedia
  tag <replaceable
>3.4.3</replaceable>
  # outras opções...
end module
</screen>

</informalexample>

<tip
><para
>Você poderá definir aqui um valor global para o 'branch'. Mas, se o fizer, não se esqueça de indicar uma ramificação diferente para os módulos que não devem usar a ramificação global! </para
></tip>
</sect3>

<sect3 id="advanced-branches">
<title
>Opções avançadas de suporte a ramificações</title>

<para
>O &kdesvn-build; suporta duas opções para as situações em que o &branch; e o &tag; adivinham o local de forma incorreta: o &module-base-path; e o &override-url;. </para>

<itemizedlist>
<listitem
><para
>O &module-base-path; é usado para ajudar o &kdesvn-build; a preencher a parte faltante da localização de um módulo. No repositório do &kde;, todos os locais possuem o formato <filename class="directory"
>raizSvn/caminho-módulo-base/<replaceable
>nome-módulo</replaceable
></filename
>. Normalmente, o &kdesvn-build; pode descobrir a parte intermediária apropriada por si só. Quando não conseguir, você poderá usar o 'caminho-módulo-base' ou &module-base-path; da seguinte forma: </para>

<informalexample>
<screen
>module qt-copy
  # a ramificação não funciona aqui ainda
  module-base-path branches/qt/3.3
end module
</screen>

<para
>Isto deverá fazer com que o &kdesvn-build; baixe o 'qt-copy' de (neste exemplo) <filename
>svn://anonsvn.kde.org/home/kde/<replaceable
>branches/qt/3.3</replaceable
>/qt-copy</filename
> </para>
</informalexample>
</listitem>

<listitem
><para
>A opção &override-url;, por outro lado, necessita que você indique o local exato de onde baixar. Contudo, isto permite-lhe transferir dos locais onde o &kdesvn-build; não terá chances de adivinhar. </para>

<informalexample>
<screen
>module qt-copy
  # Indique o local exato de onde obter.
  override-url svn://anonsvn.kde.org/home/kde/branches/qt/3.3/qt-copy
end module
</screen>
</informalexample>

<important
><para
>O &kdesvn-build; não irá mexer ou corrigir o valor que indicar no &override-url;, por isso, se mudar a sua configuração do &svn-server;, também terá que atualizar isto. </para
></important>

</listitem>
</itemizedlist>

</sect3>

</sect2>

<sect2 id="building-successfully">
<title
>Como o &kdesvn-build; tenta garantir uma compilação com sucesso</title>

<sect3 id="automatic-rebuilds">
<title
>Recompilações automáticas</title>

<para
>Devido a várias questões com o sistema de compilação do &kde;, o &kdesvn-build; irá efetuar automaticamente uma série de passos para tentar automaticamente obter um módulo para compilar quando ele falhar.</para>

<orderedlist>
<listitem
><para
>Na primeira tentativa falhada, o &kdesvn-build; irá simplesmente executar de novo o <command
>make</command
>. Acredite ou não, mas isto de vez em quando funciona de fato, e é rápido ao falhar se não funcionar novamente. </para
></listitem>

<listitem
><para
>Em caso de uma segunda falha, o &kdesvn-build; irá tentar configurar de novo o módulo e compilá-lo outra vez. Isto resolve normalmente situações em que um arquivo do sistema de compilações, que necessita de ser configurado de novo, não foi configurado automaticamente pelo sistema de compilação. </para>

<para
>A pasta de compilação do módulo é deixada intacta nesse passo, exceto no caso de nova configuração; essa situação irá também falhar depressa se a compilação não puder ser efetuada. </para>
</listitem>

<listitem
><para
>Se o módulo continuar a não compilar, o &kdesvn-build; irá desistir e passar ao próximo módulo. Todavia, existem ainda algumas coisas que você poderá fazer para <link linkend="manual-rebuilds"
>tentar fazer o módulo compilar manualmente</link
>. </para
></listitem>
</orderedlist>

<note
><para
>O &kdesvn-build; irá detectar a maioria dos casos onde o sistema de compilação precisa de ser configurado de novo, tentando nesse caso executar o 'configure' de novo. </para>

<para
>Da mesma forma, se o &kdesvn-build; estiver compilando o módulo pela primeira vez, todos esses passos são ignorados, uma vez que a nova compilação do zero não irá falhar normalmente, exceto no caso de um erro verdadeiro.</para>
</note>
</sect3>

<sect3 id="manual-rebuilds">
<title
>Recompilando manualmente um módulo</title>
<para
>Se você tiver feito alterações em alguma opção de um módulo, ou se o código-fonte do módulo mudar de uma forma que o &kdesvn-build; não reconheça, você poderá ter que recompilar o módulo manualmente.</para>

<para
>Você poderá se isto executando simplesmente o <userinput
><command
>kdesvn-build</command
> <option
>--refresh-build</option
> <option
><replaceable
>módulo</replaceable
></option
></userinput
>. </para>

<para
>Se você quiser que o &kdesvn-build; recompile de forma automática o módulo, durante a próxima atualização normal, você poderá criar um arquivo especial. Cada módulo possui uma pasta de compilação. Se você criar um arquivo chamado <filename
>.refresh-me</filename
> na pasta de compilação de um módulo, o &kdesvn-build; irá reconstruir o módulo da próxima vez que o processo de compilação rodar, mesmo que fosse executar normalmente a compilação incremental.</para>

<tip>
<para
>Por padrão, a pasta de compilação é a <filename class="directory"
>~/kdesvn/build/<replaceable
>módulo</replaceable
>/</filename
>. Se você mudar a opção &build-dir;, então use essa em vez da <filename class="directory"
>~/kdesvn/build</filename
>.</para>
</tip>

<informalexample>
<para
>Recompilar usando o <filename
>.refresh-me</filename
> para o módulo <replaceable
>arts</replaceable
>:</para>
<screen
><prompt
>%</prompt
> <userinput
><command
>touch</command
> <filename class="directory"
>~/kdesvn/build/<replaceable
>arts</replaceable
>.refresh-me</filename
></userinput>
<prompt
>%</prompt
> <userinput
><command
>kdesvn-build</command
></userinput
>
</screen>
</informalexample>
</sect3>

<sect3 id="controlling-rebuild-behavior">
<title
>Controlando o comportamento de recompilação</title>
<para
>Você poderá não querer que o &kdesvn-build; tente sempre reconstruir um módulo. Então poderá desativar, a título permanente, esse comportamento, alterando a opção &no-rebuild-on-fail; para o valor <replaceable
>true.            </replaceable
></para>

<para
>Você poderá desativar temporariamente este comportamento (para um comando) se usar a opção &cmd-no-rebuild-on-fail; da linha de comando.</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
>Mudando a configuração das variáveis de ambiente</title>
<para
>O &kdesvn-build; não lê o ambiente de quem o chama, como a maior parte dos programas. Em vez disso, usa a configuração que ele obtém do <link linkend="configure-data"
>arquivo de configuração</link
> para construir o ambiente. Isto é feito principalmente para garantir que a compilação possa ser repetida. Em outras palavras, o &kdesvn-build; poderá compilar um módulo, mesmo que você tenha se esquecido como configurou as suas variáveis de ambiente na linha de comando onde executou o &kdesvn-build;.</para>

<para
>Contudo, você poderá desejar alterar a configuração das variáveis de ambiente para as quais o &kdesvn-build; não possui uma opção direta. Isto é possível com a opção &set-env;.</para>

<para
>Ao contrário da maioria das opções, ela poderá ser definida mais de uma vez e aceita dois itens separados por um espaço. O primeiro item é o nome da variável de ambiente a definir e o resto da linha é o valor.</para>

<informalexample>
<para
>Configura a <userinput
><envar
>DISTRO</envar
>=<replaceable
>BSD</replaceable
></userinput
> para todos os módulos:</para>
<screen
>global
  set-env <replaceable
>DISTRO</replaceable
> <replaceable
>BSD</replaceable>
end global
</screen>
</informalexample>

</sect2>

<sect2 id="resuming">
<title
>Prosseguir com as compilações</title>

<sect3 id="resuming-failed">
<title
>Prosseguir uma compilação falhada ou cancelada</title>

<para
>Você poderá indicar ao &kdesvn-build; para começar a compilar a partir de um módulo diferente daquele onde iria prosseguir. Isto poderá ser útil quando falhou um conjunto de módulos ou se tiver cancelado a execução de uma compilação no meio. Você poderá controlar isto com a opção &cmd-resume-from;.</para>

<note
><para
>Usar o &cmd-resume-from;, irá pular a atualização do código-fonte.</para>
</note>

<informalexample>
<para
>Prosseguir a compilação começando no '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
>Ignorando os módulos numa compilação</title>

<para
>Como acontece quando deseja <link linkend="resuming-failed"
>prosseguir com a compilação de um módulo</link
>, você poderá optar em alternativa por atualizar e compilar tudo normalmente, só que ignorando um conjunto de módulos.</para>

<para
>Você poderá fazer isso com a opção &cmd-ignore-modules;. Esta opção diz ao &kdesvn-build; para ignorar todos os módulos da linha de comando, ao efetuar a atualização e a compilação.</para>

<informalexample>
<para
>Ignorar o extragear/multimedia e o kdereview numa execução completa:</para>
<screen
><prompt
>%</prompt
> <userinput
><command
>kdesvn-build</command
> <option
>--ignore-modules</option
> <replaceable
>extragear/multimedia kdereview</replaceable
></userinput
>
</screen>
</informalexample>

</sect3>
</sect2>

<sect2 id="changing-env-from-cmd-line">
<title
>Mudando as opções na linha de comando</title>

<sect3 id="changing-global-opts">
<title
>Modificando as opções globais</title>
<para
>Você poderá alterar a configuração das opções lidas do <link linkend="configure-data"
>arquivo de configuração</link
> diretamente a partir da linha de comando. Esta alteração irá substituir a configuração do arquivo, mas é apenas temporária. Só terá efeito enquanto ainda estiver presente na linha de comando.</para>

<para
>O &kdesvn-build; permite-lhe alterar as opções com nome do tipo <replaceable
>nome-opção</replaceable
> passando um argumento na linha de comando com o formato <userinput
><option
>--<replaceable
>nome-opção</replaceable
>=valor</option
></userinput
>. O &kdesvn-build; irá reconhecer se não souber qual a opção, e irá procurar o nome na sua lista de nomes de opções. Se não reconhecer o nome, ele irá avisá-lo, caso contrário irá recordar o valor que definiu e substituir o valor do arquivo de configuração.</para>

<informalexample>
<para
>Configurar o &source-dir; como <filename
>/dev/null</filename
> para fins de teste:</para>

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

</informalexample>

</sect3>

<sect3 id="changing-module-opts">
<title
>Mudando as opções do módulo</title>
<para
>Também é possível alterar as opções apenas para um módulo específico. A sintaxe é semelhante: --<replaceable
>módulo</replaceable
>,<replaceable
>nome-opção</replaceable
>=<replaceable
>valor</replaceable
>. </para>

<para
>Esta alteração substitui qualquer opção duplicada do módulo encontrado no <link linkend="configure-data"
>arquivo de configuração</link
> e só se aplica enquanto a opção for passada na linha de comando.</para>

<informalexample>
<para
>Usando uma pasta de compilação diferente para o módulo 'kdeedu':</para>

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

</informalexample>

</sect3>

</sect2>

</sect1>

<sect1 id="developer-features">
<title
>Funcionalidades para os programadores do &kde;</title>

<sect2 id="ssh-agent-reminder">
<title
>Verificações do Agente do &ssh;</title>
<para
>O &kdesvn-build; poderá certificar-se de que os programadores do &kde; que usem o &ssh; para acessar ao repositório de código do &kde; não se esqueçam acidentalmente da ferramenta &ssh;-Agent ligada. Isto poderá fazer com que o &kdesvn-build; fique eternamente à espera que o programador insira a sua senha de &ssh;, por isso e por padrão, o &kdesvn-build; irá verificar se o Agente está rodando antes de efetuar as atualizações do código. </para>

<note
><para
>Isto só é feito para os programadores do &kde; que usam o &ssh;. Isto acontece porque não é necessária qualquer senha para a atualização e extração de código anônima do repositório. O &subversion; irá lidar com as senhas para o segundo protocolo possível dos programadores do &kde;, o HTTPS. </para
></note>

<para
>Você poderá querer desativar a verificação do Agente do &ssh;, no caso das situações em que o &kdesvn-build; não detecte bem a presença de um agente. Para desativar a verificação do agente, configure a opção <option
>disable-agent-check</option
> como <replaceable
>true</replaceable
>.</para>

<informalexample>
<para
>Desativando a verificação do agente do &ssh;:</para>
<screen
>global
  disable-agent-check true
end global
</screen>
</informalexample>

</sect2>

</sect1>

<sect1 id="other-features">
<title
>Outras funcionalidades do &kdesvn-build;</title>

<sect2 id="changing-verbosity">
<title
>Mudando a quantidade de mensagens do resultado do &kdesvn-build;</title>
<para
>O &kdesvn-build; possui várias opções para controlar a quantidade de dados de saída que o programa gera. Em qualquer caso, os erros serão sempre apresentados.</para>

<itemizedlist>
<listitem
><para
>A opção <option
>--quiet</option
> (o seu formato curto é o <option
>-q</option
>) faz com que o &kdesvn-build; seja majoritariamente silencioso. Só as mensagens importantes, avisos ou erros serão apresentados. Quando estiver disponível, a informação de progresso é apresentada.</para
></listitem>

<listitem
><para
>A opção <option
>--really-quiet</option
> (sem formato curto) faz com que o &kdesvn-build; mostre apenas os avisos importantes ou os erros, enquanto estiver em execução.</para
></listitem>

<listitem
><para
>A opção <option
>--verbose</option
> (o formato curto é o <option
>-v</option
>) faz com que o &kdesvn-build; seja muito detalhado nos seus resultados.</para
></listitem>

<listitem
><para
>A opção <option
>--debug</option
> serve apenas para fins de depuração, uma vez que faz com que o &kdesvn-build; atue como se o <option
>--verbose</option
> estivesse ativo, fazendo com que os comandos sejam também apresentados no terminal e mostrando a informação de depuração para várias funções.</para
></listitem>
</itemizedlist>

</sect2>

<sect2 id="kdesvn-build-color">
<title
>Resultado colorido</title>
<para
>Ao ser executado a partir do &konsole; ou de um terminal diferente, o &kdesvn-build; irá mostrar normalmente o texto a cores.</para>

<para
>Você poderá desativar isto com a opção <option
>--no-color</option
> na linha de comando ou configurando a opção &colorful-output; no <link linkend="configure-data"
>arquivo de configuração</link
> como <replaceable
>false</replaceable
>. </para>

<informalexample>
<para
>Desativando as mensagens a cores no arquivo de configuração:</para>
<screen
>global
  colorful-output false
end global
</screen>
</informalexample>

</sect2>

<sect2 id="email-reports">
<title
>Envio por e-mail dos relatórios de erros da compilação</title>
<para
>O &kdesvn-build; poderá enviar um relatório por e-mail para um determinado endereço à sua escolha, quando um módulo não conseguir compilar por alguma razão. A forma como funciona é através da indicação de um endereço de e-mail de onde o &kdesvn-build; irá enviar os dados e um endereço de e-mail para notificar quando ocorrer algum erro.</para>

<para
>O &kdesvn-build; irá então, no fim de uma execução completa, construir uma mensagem de e-mail se existirem alguns módulos que não conseguiram ser compilados. O e-mail irá conter um registro de erros abreviado para cada módulo. Só é enviada uma mensagem de e-mail para uma determinada execução, mesmo que falhe a compilação de 15 módulos. </para>

<para
>Esta funcionalidade não está ativada por padrão. Para ativá-la, você terá que definir tanto as opções &email-address; e &email-on-compile-error;. O <option
>email-address</option
> controla o endereço de onde o &kdesvn-build; envia os dados e o <option
>email-on-compile-error</option
> controla para onde enviar a mensagem. </para>

<tip>
<para
>O &kdesvn-build; usa o módulo-padrão do Perl Mail::Mailer para enviar a mensagem. Ele vem incluído com o Perl 5.8 e é instalável com o Perl 5.6. O Mail::Mailer suporta o <application
>Sendmail</application
> (incluindo os clientes de e-mail compatíveis com o <application
>Sendmail</application
>), o transporte de <acronym
>SMTP</acronym
> nativo e o <application
>qmail</application
>. </para>
</tip>

<informalexample>
<para
>Enviando um e-mail de envio@exemplo.com para recepcao@exemplo.com em caso de erro na compilação:</para>

<screen
>global
  email-address          envio@exemplo.com    # O endereço De: para qualquer e-mail do kdesvn-build
  email-on-compile-error recepcao@exemplo.com    # O endereço Para: do e-mail de erros da compilação
end global
</screen>
</informalexample>

</sect2>

<sect2 id="deleting-build-dir">
<title
>Removendo as pastas desnecessárias após uma compilação</title>
<para
>Você está com falta de espaço em disco mas deseja ainda fazer uma extração atualizada do &kde;? O &kdesvn-build; poderá ajudar a reduzir o uso do seu disco ao compilar o &kde; a partir do &subversion;.</para>

<note
><para
>Tenha em mente que a compilação do &kde; ocupa bastante espaço. Existem muitos componentes grandes em termos de espaço ao usar o &kdesvn-build;:</para
></note>

<orderedlist>
<listitem
><para
>A extração de código atual poderá levar bastante espaço. Os módulos padrão possuem cerca de 1,6 gigabytes de espaço em disco. Você poderá reduzir esta quantidade, se tiver certeza que só vai compilar os módulos que deseja de fato. O &kdesvn-build; não irá remover o código-fonte do disco, mesmo que remova o item do <link linkend="configure-data"
>arquivo de configuração</link
>, assim certifique-se de que são apagados os módulos extraídos e não usados da pasta de código. Lembre-se que os arquivos de código são obtidos da Internet, assim você <emphasis
>não deverá</emphasis
> removê-los se for usar estes arquivos de fato, pelo menos até acabar de usar o &kdesvn-build;.</para>

<para
>Da mesma forma, se você já tiver um &Qt; instalado pela sua distribuição (e é bastante possível que isso aconteça), provavelmente não irá necessitar instalar o módulo 'qt-copy'. Isso irá poupar cerca de 200 MB do código no disco.</para>

<para
>Uma coisa a observar é que, devido à forma como o &subversion; funciona: existem de fato dois arquivos no disco para cada arquivo extraído do repositório. O &kdesvn-build; não está apto por enquanto a minimizar o tamanho do código, quando ele não estiver sendo usado. </para>
</listitem>

<listitem>
<para
>O &kdesvn-build; irá criar uma pasta de compilação separada, para onde irá compilar o código-fonte. Algumas vezes o &kdesvn-build; terá que copiar uma pasta de código para criar uma pasta de compilação falsa. Quando isso acontecer, são usadas as ligações simbólicas, caracterizadas por poupar espaço, assim isso não deverá ser um problema a nível de espaço em disco. A pasta de compilação será tipicamente muito maior que a pasta de código de um módulo. Por exemplo, a pasta de compilação do 'kdebase' ocupa cerca de 1050 megabytes, enquanto o código do 'kdebase' ocupa apenas cerca de 550 megabytes.</para>

<para
>Felizmente, a pasta de compilação não é necessária após um módulo ter sido compilado e instalado com sucesso. O &kdesvn-build; poderá remover automaticamente a pasta de compilação após a instalação de um módulo; veja os exemplos abaixo para mais informações. Lembre-se que a utilização deste passo tornará impossível ao &kdesvn-build; efetuar as compilações incrementais que poupam tempo.</para>
</listitem>

<listitem
><para
>Finalmente, existe o espaço em disco necessário para a própria instalação do &kde;, que não se executa a partir da pasta de compilação. Este espaço é normalmente menor que o da pasta de compilação. É mais difícil ter os valores exatos, de qualquer forma. </para
></listitem>
</orderedlist>

<para
>Como reduz os requisitos de espaço do &kde;? Uma forma é usar as opções de compilação adequadas, para otimizar a redução de espaço em vez da velocidade. Outra forma, que poderá ser bem eficaz, é remover a informação de depuração da sua compilação do &kde;. </para>

<warning
><para
>Você deverá saber bem o que está fazendo, antes de decidir remover a informação de depuração. A execução de aplicativos muito atuais significa que está rodando programas que, potencialmente, poderão ter tendência a travar, algo que não acontece numa versão estável. Se você estiver rodando 'software' sem informações de depuração, poderá ser bastante difícil criar um bom relatório de erros para que o seu erro seja resolvido; assim, é possível que tenha que reativar a informação de depuração do aplicativo afetado e recompilá-lo para ajudar um programador a resolver o problema. Então, remova a informação de depuração por sua conta e risco! </para
></warning>

<informalexample>
<para
>A remoção da pasta de compilação, após a instalação de um módulo. A pasta do código é ainda mantida e a depuração fica ativa:</para>

<screen
>global
  configure-flags      --enable-debug
  remove-after-install builddir        # Remover a pasta de compilação após a instalação
end global
</screen>

<para
>A remoção da pasta de compilação após a instalação, sem informações de depuração e com otimizações do tamanho.</para>

<screen
>global
  cxxflags             -Os             # Otimizar o tamanho
  configure-flags      --disable-debug
  remove-after-install builddir        # Remover a pasta de compilação após a instalação
end global
</screen>
</informalexample>
</sect2>

</sect1>

</chapter>

<chapter id="kde-cmake">
<title
>, o s&cmake;istema de compilação do &kde; 4</title>

<sect1 id="kde-cmake-intro">
<title
>Introdução ao &cmake;</title>

<para
>Em Março de 2006, o programa &cmake; ultrapassou os vários adversários e foi selecionado para ser o sistema de compilação do &kde; 4, substituindo o sistema baseado nas 'autotools' que o &kde; tem usado desde o início.</para>

<para
>Está disponível uma página de introdução ao &cmake; no <ulink url="http://techbase.kde.org/Development/Tutorials/CMake"
>TechBase do &kde;</ulink
>. Basicamente, em vez de rodar o <userinput
><command
>make</command
> <option
>-f</option
> <filename
>Makefile.cvs</filename
></userinput
>, depois o <command
>configure</command
> e depois o &make;, basta simplesmente rodar o &cmake; e depois o &make;. </para>

<para
>O &kdesvn-build; possui suporte para o &cmake;. Algumas funcionalidades do &kdesvn-build; são realmente funcionalidades do sistema de compilação subjacente, incluindo o <link linkend="conf-inst-apps"
>inst-apps</link
>, o <link linkend="conf-configure-flags"
>configure-flags</link
> e o <link linkend="conf-do-not-compile"
>do-not-compile</link
>. Quando estiverem disponíveis funcionalidades equivalentes, serão disponibilizadas. Por exemplo, a equivalente da opção 'configure-flags' é a <link linkend="conf-cmake-options"
>cmake-options</link
>, e a opção <link linkend="conf-do-not-compile"
>do-not-compile</link
> também é suportada para o &cmake; desde a versão 1.6.3 do &kdesvn-build;. </para>

<para
>Contudo, algumas opções (como a <link linkend="conf-inst-apps"
>inst-apps</link
>) não possuem equivalente direto estando assim desativadas. Quando se arranjar uma forma de implementá-las com o &cmake;, isto será feito e estas opções então voltarão a ser ativadas. Contudo, de resto funciona quase tudo da mesma forma.</para>

</sect1>
</chapter>

<chapter id="credits-and-licenses">
<title
>Créditos e Licenças</title>

<para
>Tradução de Marcus Gama<email
>marcus.gama@gmail.com</email
></para
> 
&underFDL; </chapter>

</book>
