
        *****************************************************
        *           GENERATED FILE, DO NOT EDIT             *
        * THIS IS NO SOURCE FILE, BUT RESULT OF COMPILATION *
        *****************************************************

This file was generated by po4a(7). Do not store it (in VCS, for example),
but store the PO file used as source file by po4a-translate.

In fact, consider this as a binary, and the PO file as a regular .c file:
If the PO get lost, keeping this translation up-to-date will be harder.

=encoding UTF-8

=head1 NOME

dpkg-buildflags - retorna flags de compilação para usar durante a compilação
de pacotes

=head1 SINOPSE

B<dpkg-buildflags> [I<option>...] [I<command>]

=head1 DESCRIÇÃO

B<dpkg-buildflags> é uma ferramenta para obter flags de compilação para usar
durante a compilação de pacotes Debian.

As flags predefinidas são definidas pelo fornecedor mas podem ser
estendidas/sobrepostas de várias maneiras:

=over 

=item 1.

de todo o sistema com B<%PKGCONFDIR%/buildflags.conf>;

=item 2.

para o utilizador actual com B<$XDG_CONFIG_HOME/dpkg/buildflags.conf> onde
B<$XDG_CONFIG_HOME> usa por predefinição B<$HOME/.config>;

=item 3.

temporariamente pelo utilizador com variáveis de ambiente (veja a secção
B<AMBIENTE>);

=item 4.

dinamicamente pelo maintainer do pacote com variáveis de ambiente definidas
via B<debian/rules> (veja a secção B<AMBIENTE>).

=back

Os ficheiros de configuração podem conter quatro tipos de directivas:

=over 

=item B<SET> I<flag value>

Sobrescreve a flag chamada I<flag> para ter o valor I<valor>.

=item B<STRIP> I<flag value>

Despoja da flag chamada I<flag> todas as flags de compilação listadas em
I<valor>.

=item B<APPEND> I<flag value>

Estende a flag chamada I<flag> ao acrescentar as opções dadas em I<valor>. É
usado um espaço a preceder o valor acrescentado se o valor da flag actual
não estiver vazio.

=item B<PREPEND> I<flag value>

Estende a flag chamada I<flag> ao precedê-la com as opções dadas em
I<valor>. É acrescentado um espaço ao valor precedido se o valor da flag
actual não estiver vazio.

=back

Os ficheiros de configuração podem conter comentários nas linhas que começam
com um cardinal (#). As linhas vazias também são ignoradas.

=head1 COMANDOS

=over 

=item B<--dump>

Escreve na saída standard todas as bandeiras de compilação e os seus
valores. Escreve uma bandeira por linha separada do seu valor por um sinal
de igual ("I<flag>=I<value>"). Esta é a acção predefinida.

=item B<--list>

Escreve a lista das flags suportadas pelo fornecedor actual (uma por cada
linha). Veja a secção B<FLAGS SUPORTADAS> para mais informação sobre elas.

=item B<--status>

Mostra qualquer informação que possa ser útil para explicar o comportamento
de B<dpkg-buildflags> (desde dpkg 1.16.5): variáveis de ambiente relevantes,
fornecedor actual, estado de todas as bandeiras de funcionalidades. Também
escreve as bandeira de compilação resultantes com as suas origens.

Isto destina-se a ser corrido a partir de B<debian/rules>, para que os
relatórios de compilação mantenham um rasto claro das bandeiras de
compilação usadas. Isto pode ser útil para diagnosticar problemas
relacionados com elas.

=item B<--export=>I<format>

Escreve na saída standard comandos que podem ser usados para exportar todas
as bandeiras de compilação para alguma ferramenta particular. Se o valor
I<format> não for fornecido, é assumido B<sh>. Apenas são incluídas
bandeiras que comecem com um caractere maiúsculo, as outras são assumidas
como não apropriadas para o ambiente. Formatos suportados:

=over 

=item B<sh>

Comandos de shell para definir e exportar todas as bandeiras de compilação
no ambiente. Os valores das bandeiras são citados para que o resultado
esteja pronto para avaliação pela shell.

=item B<cmdline>

Argumentos a passar para a linha de comandos dos programas de compilação
para se usar todas as bandeiras de compilação (desde dpkg 1.17.0). Os
valores das bandeiras são citados na sintaxe da shell.

=item B<configure>

Este é um nome alternativo antigo para B<cmdline>.

=item B<make>

Faz as directivas definir e exportar todas as bandeiras de compilação no
ambiente. O resultado pode ser escrito para o fragmento do Makefile e
avaliado usando uma directiva B<include>.

=back

=item B<--get> I<flag>

Escreve o valor da flag na saída standard. Termina com 0 se a flag for
conhecida, caso contrário termina com 1.

=item B<--origin> I<flag>

Escreve a origem do valor que é devolvido por B<--get>. Termina com 0 se a
flag for conhecida, caso contrário termina com 1. A origem pode ser um dos
seguintes valores:

=over 

=item B<vendor>

é devolvida a flag origina definida pelo fornecedor;

=item B<system>

a flag é definida/modifica por uma configuração de todo o sistema;

=item B<user>

a flag é definida/modifica por uma configuração específica do utilizador;

=item B<env>

a flag é definida/modifica por uma configuração específica do ambiente;

=back

=item B<--query>

Escreve qualquer informação que possa ser útil para explicar o comportamento
do programa: fornecedor actual, variáveis de ambiente relevantes, áreas de
funcionalidades, estada das bandeiras de funcionalidades, e as bandeiras de
compilação com as suas origens (desde dpkg 1.19.0).

Por exemplo:

 Vendor: Debian
 Environment:
  DEB_CFLAGS_SET=-O0 -Wall

 Area: qa
 Features:
  bug=no
  canary=no

 Area: reproducible
 Features:
  timeless=no

 Flag: CFLAGS
 Value: -O0 -Wall
 Origin: env

 Flag: CPPFLAGS
 Value: -D_FORTIFY_SOURCE=2
 Origin: vendor

=item B<--query-features> I<area>

Escreve as funcionalidades activadas para uma dada área (desde dpkg
1.16.2). As únicas áreas actualmente reconhecidas em Debian e derivados são
B<future>, B<qa>, B<reproducible>, B<sanitize> e B<hardening>, veja a secção
B<ÁREAS DE CARACTERÍSTICAS> para mais detalhes. Termina com 0 se a área é
conhecida caso contrário termina com 1.

O resultado está em formato RFC822, com uma secção por característica. Por
exemplo:

 Feature: pie
 Enabled: yes

 Feature: stackprotector
 Enabled: yes

=item B<--help>

Mostra a mensagem de utilização e termina.

=item B<--version>

Mostra a versão e termina.

=back

=head1 FLAGS SUPORTADAS

=over 

=item B<CFLAGS>

Opções para o compilador de C. O valor predefinido regulado pelo fornecedor
inclui B<-g> e o nível de optimização predefinido (geralmente B<-O2>, ou
B<-O0> se a variável de ambiente B<DEB_BUILD_OPTIONS> definir I<noopt>).

=item B<CPPFLAGS>

Opções para o pré-processador de C. Valor predefinido: vazio.

=item B<CXXFLAGS>

Opções para o compilador de C++. O mesmo que B<CFLAGS>.

=item B<OBJCFLAGS>

Opções para o compilador Objective C. O mesmo que B<CFLAGS>.

=item B<OBJCXXFLAGS>

Opções para o compilador Objective C++. O mesmo que B<CXXFLAGS>.

=item B<GCJFLAGS>

Opções para o compilador de Java do GNU (gcj). Um subconjunto de B<CFLAGS>.

=item B<DFLAGS>

Opções para o compilador D (ldc ou gdc). Desde dpkg 1.20.6.

=item B<FFLAGS>

Opções para o compilador Fortran 77. Um subconjunto de B<CFLAGS>.

=item B<FCFLAGS>

Opções para o compilador Fortran 9x. O mesmo que B<FFLAGS>.

=item B<LDFLAGS>

Opções passadas ao compilador quando faz link a executáveis ou objetos
partilhados (se o vinculador (linker) for chamado directamente, então B<-Wl>
e B<,> têm de ser cortados destas opções). Valor predefinido: empty.

=back

Podem ser adicionadas novas bandeiras no futuro se a necessidade surgir (por
exemplo para suportar outras linguagens).

=head1 ÁREAS DE CARACTERÍSTICAS

Cada funcionalidade de área pode ser activada ou desactivada no valor da
área das variáveis de ambiente B<DEB_BUILD_OPTIONS> e
B<DEB_BUILD_MAINT_OPTIONS> com o modificador ‘B<+>’ e ‘B<->’. Por exemplo,
par activar a funcionalidade "pie" de B<hardening> e desactivar a
funcionalidade “fortify” você pode fazer isto em B<debian/rules>:

    export DEB_BUILD_MAINT_OPTIONS=hardening=+pie,-fortify

A funcionalidade especial B<all> (válida em qualquer área) pode ser usada
para activar ou desactivar todas as funcionalidades de área ao mesmo
tempo. Assim desactivar tudo na área B<hardening> e activar apenas apenas
“format” e “fortify” pode ser obtido com:

    export DEB_BUILD_MAINT_OPTIONS=hardening=-all,+format,+fortify

=head2 future

Várias opções de tempo de compilação (detalhado em baixo) podem ser usadas
para activar funcionalidades que deveria estar activadas por predefinição,
mas não podem estar por razões de compatibilidade com versões anteriores.

=over 

=item B<lfs>

Esta definição (desactivada por predefinição) activa Suporte Ficheiros
Longos em arquitecturas de 32-bit onde o seu ABI não inclui LFS (Large File
Support) por predefinição, ao adicionar B<-D_LARGEFILE_SOURCE
-D_FILE_OFFSET_BITS=64> a B<CPPFLAGS>.

=back

=head2 qa

Várias opções de tempo de compilação (detalhado em baixo) podem ser usadas
para ajudar a detectar no código fonte ou no sistema de compilação.

=over 

=item B<bug>

Esta definição (desactivada por predefinição) adiciona qualquer opção de
aviso de detecção de fiabilidade problemática no código fonte. Os avisos são
fatais. As únicas bandeiras presentemente suportadas são B<CFLAGS> e
B<CXXFLAGS> com bandeiras definidas para B<-Werror=array-bounds>,
B<-Werror=clobbered>, B<-Werror=implicit-function-declaration> e
B<-Werror=volatile-register-var>.

=item B<canary>

Esta definição (desactivada por predefinição) adiciona opções canary
fantoches às bandeiras de compilação, para que os relatórios de compilação
possam ser verificados em como as bandeiras de compilação de propagam e para
permitir encontrar qualquer omissão de definições normais de bandeiras de
compilação. As únicas bandeiras actualmente suportadas são B<CPPFLAGS>,
B<CFLAGS>, B<OBJCFLAGS>, B<CXXFLAGS> e B<OBJCXXFLAGS> com bandeiras
definidas para B<-D__DEB_CANARY_>I<flag>_I<random-id>B<__>, e B<LDFLAGS>
definida para B<-Wl,-z,deb-canary->I<random-id>.

=back

=head2 sanitize

Várias opções de tempo de compilação (detalhado em baixo) podem ser usadas
para ajudar a higienizar um binário resultante contra corrupções de memória,
fugas de memória, utilização após livre, segmentação de dados e bugs de
comportamento indefinido.  B<Nota>: estas opções B<não> devem ser usadas
para compilações de produção pois elas podem reduzir a confiança na
conformidade do código, reduzir a segurança ou mesmo a funcionalidade.

=over 

=item B<address>

Esta definição (desactivada por predefinição) adiciona B<-fsanitize=address>
a B<LDFLAGS> e B<-fsanitize=address -fno-omit-frame-pointer> a B<CFLAGS> e
B<CXXFLAGS>.

=item B<thread>

Esta definição (desactivada por predefinição) adiciona B<-fsanitize=thread>
a B<CFLAGS>, B<CXXFLAGS> e B<LDFLAGS>.

=item B<leak>

Esta definição (desactivada por predefinição) adiciona B<-fsanitize=leak> a
B<LDFLAGS>. fica automaticamente desactivada se as funcionalidades
B<address> ou B<thread> estiverem activas, pois elas já implicam isto.

=item B<undefined>

Esta definição (desactivada por predefinição) adiciona
B<-fsanitize=undefined> a B<CFLAGS>, B<CXXFLAGS> e B<LDFLAGS>.

=back

=head2 endurecimento

Várias opções de tempo de compilação (detalhado em baixo) podem ser usadas
para ajudar a endurecer um binário resultante contra ataques de corrupção de
memória, ou disponibilizar mensagens de aviso adicionais durante a
compilação. Excepto como notado em baixo, estas estão activadas por
predefinição para as arquitecturas que as suportam.

=over 

=item B<format>

Esta definição (activada por predefinição) adiciona B<-Wformat
-Werror=format-security> a B<CFLAGS>, B<CXXFLAGS>, B<OBJCFLAGS> e
B<OBJCXXFLAGS>.  Isto irá avisar sobre uso de strings de formato impróprias,
e irá falhar quando funções de formato forem usadas em modo que representem
possíveis problemas de segurança. Presentemente, isto avisa sobre chamadas a
funções B<printf> e B<scanf> onde a string de formato não é uma string
literal e não existem argumentos de formato, como em B<printf(foo);> em vez
de B<printf("%s", foo);> Isto pode ser um buraco de segurança se a string de
formato vier de uma entrada não confiável e conter ‘%n’.

=item B<fortify>

Esta definição (activada por predefinição) adiciona B<-D_FORTIFY_SOURCE=2> a
B<CPPFLAGS>. Durante a geração de código o compilador sabe muita informação
sobre tamanhos de buffer (onde possível), e tenta substituir chamadas de
função buffer de comprimento ilimitadas e inseguras por umas limitadas em
comprimento. Isto é especialmente útil para código antigo,
desnecessariamente complicado. Adicionalmente, as strings de formato em
memória gravável que contêm ‘%n’ são bloqueadas. Se uma aplicação depender
de tal string de formato, isso terá que ser contornado.

Note que para esta opção ter algum efeito, a fonte tem de também ser
compilada com B<-O1> ou superior. Se a variável de ambiente
B<DEB_BUILD_OPTIONS> conter I<noopt>, então o suporte a B<fortify> será
desactivado, devido a novos avisos serem emitidos pelo glibc 2.16 e
posterior.

=item B<stackprotector>

Esta definição (activada por predefinição se stackprotectorstrong não
estiver em uso) adiciona B<-fstack-protector --param=ssp-buffer-size=4> a
B<CFLAGS>, B<CXXFLAGS>, B<OBJCFLAGS>, B<OBJCXXFLAGS>, B<GCJFLAGS>, B<FFLAGS>
e B<FCFLAGS>. Isto adiciona verificações de segurança contra sobreposições
de empilhamento. Isto renderiza muitos potenciais ataques de injeções de
código em situações de abortar. No melhor caso, isto transforma
vulnerabilidades de injeção de código em negação de serviço ou em
não-problemas (dependendo da aplicação).

Esta funcionalidade requer ligação (link) a glibc (ou outro fornecedor de
B<__stack_chk_fail>), portanto precisa de ser desactivada quando se compila
com B<-nostdlib> ou B<-ffreestanding> ou semelhante.

=item B<stackprotectorstrong>

Esta definição (activada por predefinição) adiciona
B<-fstack-protector-strong> a B<CFLAGS>, B<CXXFLAGS>, B<OBJCFLAGS>,
B<OBJCXXFLAGS>, B<GCJFLAGS>, B<FFLAGS> e B<FCFLAGS>. Esta á uma variante
mais forte de B<stackprotector>, mas sem penalidades de performance
significativas.

Desactivar B<stackprotector> irá também desactivar esta definição.

Esta funcionalidade tem os mesmos requerimentos que B<stackprotector>, e
adicionalmente também requer gcc 4.9 e posterior.

=item B<relro>

Esta definição (activada por predefinição) adiciona B<-Wl,-z,relro> a
B<LDFLAGS>. Durante o carregamento do programa, várias secções de memória
ELF precisam de ser escritas pelo vinculador. Isto sinaliza ao carregador
para tornar estas secções só-leitura antes de entregar o controlo ao
programa. Mais notavelmente isto previne ataques de sobrescrita GOT. Se esta
opção for desactivada, B<bindnow> irá ficar também desactivado.

=item B<bindnow>

Esta definição (desactivada por predefinição) adiciona B<-Wl,-z,now> a
B<LDFLAGS>. Durante o carregamento do programa, todos os símbolos dinâmicos
são resolvidos, permitindo que todo o PLT seja marcado só-leitura (devido ao
B<relro> em cima). A opção pode ser activada se B<relro> não for activado.

=item B<pie>

Esta definição (sem uma predefinição global desde dpkg 1.18.23, pois é agora
activa por predefinição pelo gcc nas arquitecturas Debian amd64, arm64,
armel, armhf, hurd-i386, i386, kfreebsd-amd64, kfreebsd-i386, mips, mipsel,
mips64el, powerpc, ppc64, ppc64el, riscv64, s390x, sparc e sparc64) adiciona
as opções requeridas para activar ou desactivar PIE via ficheiros de
especificações do gcc, Se necessário, dependendo de se o gcc injeta nessa
arquitectura as bandeiras por ele próprio ou não. Quando a definição está
activa e o gcc injeta as bandeiras, não adiciona nada. Quando a definição
está activa e o gcc não injeta as bandeiras, adiciona B<-fPIE> (via
I<%PKGDATADIR%/pie-compiler.specs>) to B<CFLAGS>, B<CXXFLAGS>, B<OBJCFLAGS>,
B<OBJCXXFLAGS>, B<GCJFLAGS>, B<FFLAGS> e B<FCFLAGS>, e B<-fPIE -pie> (via
I<%PKGDATADIR%/pie-link.specs>) a B<LDFLAGS>. Quando a definição está
desactivada e o gcc injeta as bandeiras, adiciona B<-fno-PIE> (via
I<%PKGDATADIR%/no-pie-compile.specs>) a B<CFLAGS>, B<CXXFLAGS>,
B<OBJCFLAGS>, B<OBJCXXFLAGS>, B<GCJFLAGS>, B<FFLAGS> e B<FCFLAGS>, e
B<-fno-PIE -no-pie> (via I<%PKGDATADIR%/no-pie-link.specs>) a B<LDFLAGS>.

Position Independent Executable é necessário para tirar vantagem de Address
Space Layout Randomization, suportado por algumas versões de
kernel. Enquanto ASLR já pode ser aplicada para áreas de dados na stack e
heap (brk e mmap), as áreas de código têm de ser compiladas como
independente-de-posição. As bibliotecas partilhadas já fazem isto
(B<-fPIC>), assim elas ganham ASLR automaticamente, mas as regiões de texto
binários precisam de ser compiladas com PIE para ganhar ASLR. Quando isto
acontece, os ataques ROP (Return Oriented Programming) são mais difíceis
pois não são localizações estáticas para ressaltar durante um ataque de
corrupção de memória.

PIE não é compatível com B<-fPIC>, assim em geral é preciso cuidado qo
compilar objectos partilhados. Mas porque as bandeiras PIE emitidas são
injetadas via ficheiros specs de gcc, deverá ser sempre seguro defini-las
incondicionalmente independentemente do tipo de objecto a ser compilado ou
ligado em link.

Bibliotecas estáticas pode ser usadas por programas ou outras bibliotecas
partilhadas. Dependendo das bandeiras usadas para compilar todos os objectos
dentro de uma biblioteca estática, estas bibliotecas serão utilizáveis por
conjuntos diferentes de objectos:

=over 

=item none

Não pode ser vinculado a um programa PIE, não é uma biblioteca partilhada.

=item B<-fPIE>

Pode ser vinculado a qualquer programa, mas não a uma biblioteca partilhada
(recomendado).

=item B<-fPIC>

Pode ser vinculado a qualquer programa e biblioteca partilhada.

=back

Se existir a necessidade de definir estas bandeiras manualmente, fazendo
bypass à injeção de spec gcc, há varias coisas a ter em conta. Passar
incondicionalmente e explicitamente B<-fPIE>, B<-fpie> ou B<-pie> a um
sistema de compilação usando libtool é seguro pois estas bandeiras irão ser
despojadas quando se compila bibliotecas partilhadas. Caso contrário em
projetos que compilam ambos programas e bibliotecas partilhadas você pode
precisar de certificar que quando compila as bibliotecas partilhadas,
B<-fPIC> seja sempre passado em último (para que sobreponha qualquer B<-PIE>
anterior) às bandeiras de compilação tais como B<CFLAGS>, e B<-shared> é
passado em último (para que sobreponha qualquer B<-pie> anterior) para ligar
em link bandeiras tais como B<LDFLAGS>. B<Nota:> Isto não deve ser
necessário com a maquinaria de specs gcc predefinida.

Adicionalmente, como PIE é implementado via registo geral, algumas
arquitecturas com falta de registo (mas não incluindo mais a i386 desde as
optimizações implementadas no gcc E<gt>= 5) podem ver perdas de performance
até aos 15% em grandes cargas de aplicações de segmentos de texto pesados; a
maioria das cargas vêm menos de 1%. Arquitecturas com registos mais gerais
(ex. amd64) não vêm mais alto que uma penalidade de pior caso.

=back

=head2 reproducible

As opções de tempo de compilação detalhadas em baixo  podem ser usadas para
ajudar a melhorar a reprodutibilidade de compilação ou fornecer mensagens de
aviso adicionais durante a compilação. Excepto como notado em baixo, estas
estão activadas por predefinição para as arquitecturas que as suportam.

=over 

=item B<timeless>

Esta definição (activada por predefinição) adiciona B<-Wdate-time> a
B<CPPFLAGS>. Isto irá causar avisos quando as macros B<__TIME__>,
B<__DATE__> e B<__TIMESTAMP__> são usadas.

=item B<fixfilepath>

Esta definição (activada por predefinição) adiciona
B<-ffile-prefix-map=>I<BUILDPATH>B<=.> a B<CFLAGS>, B<CXXFLAGS>,
B<OBJCFLAGS>, B<OBJCXXFLAGS>, B<GCJFLAGS>, B<FFLAGS> e B<FCFLAGS> quando
B<BUILDPATH> está definido para o directório de nível de topo do pacote a
ser compilado. Isto tem o efeito de remover o caminho de compilação de
qualquer ficheiro gerado.

Se ambas B<fixdebugpath> e B<fixfilepath> forem definidas, esta opção toma
precedência, porque é um superconjunto do anterior.

=item B<fixdebugpath>

Esta definição (activada por predefinição) adiciona
B<-fdebug-prefix-map=>I<BUILDPATH>B<=.> a B<CFLAGS>, B<CXXFLAGS>,
B<OBJCFLAGS>, B<OBJCXXFLAGS>, B<GCJFLAGS>, B<FFLAGS> e B<FCFLAGS> quando
B<BUILDPATH> está definido para o directório de nível de topo do pacote a
ser compilado. Isto tem o efeito de remover o caminho de compilação de
qualquer símbolo de depuração ficheiro gerado.

=back

=head1 AMBIENTE

Existem 2 conjuntos de variáveis de ambiente a fazer as mesmas operações, O
primeiro (DEB_I<flag>_I<op>) nunca deve ser usada dentro de
B<debian/rules>. Destina-se a qualquer utilizador que queria recompilar o
pacote fonte com bandeiras de compilação diferentes. O segundo conjunto
(DEB_I<flag>_MAINT_I<op>) só deve ser usado em B<debian/rules> pelos
maintainers de pacotes para alterar as bandeiras de compilação resultantes.

=over 

=item B<DEB_>I<flag>B<_SET>

=item B<DEB_>I<flag>B<_MAINT_SET>

Esta variável pode ser usada para forçar o valor retornado para a <flag>
fornecida.

=item B<DEB_>I<flag>B<_STRIP>

=item B<DEB_>I<flag>B<_MAINT_STRIP>

Esta variável pode ser usada para disponibilizar uma lista separada por
espaços das opções que irão ser despojadas do conjunto de flags retornado
para a I<flag> fornecida.

=item B<DEB_>I<flag>B<_APPEND>

=item B<DEB_>I<flag>B<_MAINT_APPEND>

Esta variável pode ser usada para acrescentar opções suplementares ao valor
retornado para a I<flag> fornecida.

=item B<DEB_>I<flag>B<_PREPEND>

=item B<DEB_>I<flag>B<_MAINT_PREPEND>

Esta variável pode ser usada para adicionar opções suplementares ao inicio
do valor retornado  para a I<flag> fornecida.

=item B<DEB_BUILD_OPTIONS>

=item B<DEB_BUILD_MAINT_OPTIONS>

Estas variáveis podem ser usadas por um utilizador ou maintainer para
desactivar/activar várias funcionalidades de área que afectam bandeiras de
compilação. A variável B<DEB_BUILD_MAINT_OPTIONS> sobrepõe qualquer
definição nas áreas de funcionalidade de B<DEB_BUILD_OPTIONS>. Veja a secção
B<ÁREAS DE CARACTERÍSTICAS> para detalhes.

=item B<DEB_VENDOR>

Esta definição define o fornecedor actual. Se não definida, irá descobrir o
fornecedor actual ao ler B<%PKGCONFDIR%/origins/default>.

=item B<DEB_BUILD_PATH>

Esta variável define o caminho de compilação (desde dpkg 1.18.8) a usar em
funcionalidades como B<fixdebugpath> para que possam ser controladas pelo
chamador. Esta variável é actualmente específica de Debian e derivados.

=item B<DPKG_COLORS>

Define o modo de cor (desde dpkg 1.18.5). Os valores actualmente aceites
são: B<auto> (predefinido), B<always> e B<never>.

=item B<DPKG_NLS>

Se definida, será usada para decidir se deve activar o Suporte a Linguagem
Nativa. Também como conhecido como suporte de internacionalização (ou i18n)
(desde dpkg 1.19.0). Os valores aceites são B<0> e B<1> (predefinição).

=back

=head1 FICHEIROS

=head2 Ficheiros de configuração

=over 

=item B<%PKGCONFDIR%/buildflags.conf>

Ficheiro de configuração geral do sistema.

=item B<$XDG_CONFIG_HOME/dpkg/buildflags.conf> ou

=item B<$HOME/.config/dpkg/buildflags.conf>

Ficheiro de configuração do utilizador.

=back

=head2 Suporte a empacotamento

=over 

=item B<%PKGDATADIR%/buildflags.mk>

trecho do Makefile que irá carregar (e opcionalmente exportar) todas as
bandeiras suportadas pelo B<dpkg-buildflags> em variáveis (desde dpkg
1.16.1).

=back

=head1 EXEMPLOS

Para passar flags de compilação a um comando de compilação dentro de um
Makefile:

=over 

 $(MAKE) $(shell dpkg-buildflags --export=cmdline)

 ./configure $(shell dpkg-buildflags --export=cmdline)

=back

Para definir bandeiras de compilação num script de shell ou num fragmento de
shell, por ser usado o B<eval> para interpretar o resultado e para exportar
as bandeiras no ambiente:

=over 

 eval "$(dpkg-buildflags --export=sh)" && make

=back

ou para definir os parâmetros posicionais a passar a um comando:

=over 

 eval "set -- $(dpkg-buildflags --export=cmdline)"
 for dir in a b c; do (cd $dir && ./configure "$@" && make); done

=back

=head2 Utilização em debian/rules

Você deve chamar B<dpkg-buildflags> ou incluir B<buildflags.mk> do ficheiro
B<debian/rules> para obter as bandeiras de compilação necessárias para
passar ao sistema de compilação. Note que versões antigas do
B<dpkg-buildpackage> (antes do dpkg 1.16.1) exportavam estas bandeiras
automaticamente. No entanto, você não deve confiar nisto, pois isto quebra a
invocação manual de B<debian/rules>.

Para pacotes com sistemas de compilação tipo autoconf, você pode passar as
opções relevantes ao configure ou B<make>(1) directamente, como mostrado em
cima.

Para outros sistemas de compilação, ou quando precisa de um controle mais
afinado acerca de quais bandeiras são passadas para onde, você pode usar
B<--get>. Ou você pode incluir B<buildflags.mk> em vez disto, o que toma
conta de chamar B<dpkg-buildflags> e guardar as bandeiras de compilação em
variáveis do make.

Se você quiser exportar todas as bandeiras de compilação para o ambiente
(onde elas pode ser colhidas pelo seu sistema de compilação):

=over 

 DPKG_EXPORT_BUILDFLAGS = 1
 include %PKGDATADIR%/buildflags.mk

=back

Para algum controle extra sobre o que é exportado, você pode exportar
manualmente as variáveis (pois nenhuma é exportada por predefinição).

=over 

 include %PKGDATADIR%/buildflags.mk
 export CPPFLAGS CFLAGS LDFLAGS

=back

E claro que você pode passar as bandeiras aos comandos manualmente:

=over 

 include %PKGDATADIR%/buildflags.mk
 build-arch:
 	$(CC) -o hello hello.c $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)

=back


=head1 TRADUÇÃO

Américo Monteiro

Se encontrar algum erro na tradução deste documento, por favor comunique para
Américo Monteiro <a_monteiro@gmx.com>.
