path: root/man/sv/dpkg-buildflags.pod

        *****************************************************
        *           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 NAMN

dpkg-buildflags - returnerar byggflaggor att använda för att bygga paket

=head1 SYNOPS

B<dpkg-buildflags> [I<flagga>...] I<kommando>

=head1 BESKRIVNING

B<dpkg-buildflags> är ett verktyg för att hämta kompileringsflaggor att
använda för att bygga Debianpaket.

De förvalda flaggorna anges av leverantören, men de kan utökas/överstyras på
flera sätt:

=over 

=item 1.

på hela systemet med B<%PKGCONFDIR%/buildflags.conf>;

=item 2.

för den nuvarande användaren med B<$XDG_CONFIG_HOME/dpkg/buildflags.conf>
där B<$XDG_CONFIG_HOME> har standardvärdet B<$HOME/.config>;

=item 3.

temporärt av användaren med miljövariabler (se stycket B<MILJÖ>).

=item 4.

dynamiskt av paketansvariga med miljövariabler som sätts via B<debian/rules>
(se stycket B<MILJÖ>).

=back

Konfigurationsfilerna kan innehålla fyra sorters direktiv:

=over 

=item B<SET> I<flagga värde>

Överstyr flaggan I<flagga> till att ha värdet I<värde>.

=item B<STRIP> I<flagga värde>

Ta bort alla flaggor som listas i I<värde> från flaggan som anges i
I<flagga>.

=item B<APPEND> I<flagga värde>

Utöka flaggan I<flagga> genom att lägga till alternativen som anges i
I<värde>. Ett blanksteg läggs till före värdet om flaggans nuvarande värde
inte är tomt.

=item B<PREPEND> I<flagga värde>

Utöka flaggan I<flagga> genom att lägga till alternativen som anges i
I<värde> först. Ett blanksteg läggs till efter värdet om flaggans nuvarande
värde inte är tomt.

=back

Konfigurationsfilerna kan innehålla kommentarer på rader som börjar med ett
nummertecken (#). Även tomma rader ignoreras.

=head1 KOMMANDON

=over 

=item B<--dump>

Skriv alla kompileringsflaggor och deras värde på standard ut. En flagga
skrivs per rad, avdelade från sitt värde med ett likamedtecken
(”I<flagga>=I<värde>”). Detta är standardåtgärden.

=item B<--list>

Skriv ut listan över flaggor som stöds av den aktuella leverantören (en per
rad). Se stycket B<FLAGGOR SOM STÖDS> för mer information om dem.

=item B<--status>

Visa information som kan vara användbar för att förklara B<dpkg-buildflags>
beteende (sedan dpkg 1.16.5): relevanta miljövariabler, aktuell
återförsäljare, status för alla funktionsflaggor. Skriv även ut slutgiltiga
kompilatorflaggor och deras källa.

Detta är tänkt att köras från B<debian/rules> så att byggloggen innehåller
ett tydligt spår över de använda byggflaggorna. Det kan vara användbart för
att diagnostisera problem rörande dessa.

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

Skriv kommandon som kan användas för att exportera alla kompileringsflaggor
för något specifikt verktyg. Om I<format> inte anges antas B<sh>. Endast
kompileringsflaggor som börjar med en stor bokstav tas med, andra antas att
inte vara lämpliga för miljön. Format som stöds:

=over 

=item B<sh>

Skalkommandon för att sätta och exportera alla kompileringsflaggor i
miljön. Flaggvärdena citeras så att utdata är redo att utvärderas av ett
skal.

=item B<cmdline>

Argument att sända till byggprogrammets kommandorad för att använda alla
kompileringsflaggor (sedan dpkg 1.17.0). Flaggornas värde citeras enligt
skalsyntax.

=item B<configure>

Detta är ett gammalt alias för B<cmdline>.

=item B<make>

Make-direktiv för att sätta och exportera alla kompileringsflaggor i
miljön. Utdata kan skrivas till ett makefil-fragment och utvärderas med ett
B<include>-direktiv.

=back

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

Skriv ut värdet på flaggan på standard ut. Avslutar med 0 om flaggan är
känd, om inte avslutar den med 1.

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

Anger ursprunget till flaggan som returneras av B<--get>. Avslutar med 0 om
flaggan är känd, om inte avslutar med 1. Ursprunget kan vara ett av följande
värden:

=over 

=item B<vendor>

originalflagga satt av leverantören returneras;

=item B<system>

flaggan är satt/modifierad av systemkonfigurationen;

=item B<user>

flaggan är satt/modifierad av användarkonfigurationen;

=item B<env>

flaggan är satt/modifierad av en miljöspecifik konfiguration.

=back

=item B<--query>

Srkiv ut information som kan vara användbar för att förklara programmets
beteende: aktuell återförsäljare, relevanta miljövariabler,
funktionsområden, status för alla funktionsflaggor, och kompilatorflaggorna
med sina ursprung (sedan dpkg 1.19.0).

Till exempel:

 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<område>

Skriv ut funktioner aktiverade för ett givet område (sedan dpkg 1.16.2). De
enda för närvarande kända områdena på Debian och dess derivat är B<future>,
B<qa>, B<reproducible>, B<sanitize> och B<hardening>, se avsnittet
B<FUNKTIONSOMRÅDEN> för fler detaljer. Avslutar med 0 om området är känt,
avslutar annars med 1.

Utdata är på RFC822-headerformat, med en sektion per funktion. Till exempel:

 Feature: pie
 Enabled: yes

 Feature: stackprotector
 Enabled: yes

=item B<--help>

Visar hjälpskärm och avslutar.

=item B<--version>

Visar version och avslutar.

=back

=head1 FLAGGOR SOM STÖDS

=over 

=item B<CFLAGS>

Flaggor för C-kompilatorn. Standardvärdet som satts av leverantören
innehåller B<-g> och den förvalda optimeringsnivån (vanligtvis B<-O2>, eller
B<-O0> om miljövariabeln B<DEB_BUILD_OPTIONS> definierar I<noopt>).

=item B<CPPFLAGS>

Flaggor för C-förprocesseraren. Förvalt värde: tomt.

=item B<CXXFLAGS>

Flaggor för C++-kompilatorn. Samma som B<CFLAGS>.

=item B<OBJCFLAGS>

Flaggor för Objective C-kompilatorn. Samma som B<CFLAGS>.

=item B<OBJCXXFLAGS>

Flaggor för Objective C++-kompilatorn. Samma som B<CFLAGS>.

=item B<GCJFLAGS>

Flaggor för GNU Java-kompilatorn (gcj). En delmängd av B<CFLAGS>.

=item B<DFLAGS>

Flaggor för D-kompilatorn (ldc eller gdc). Sedan dpkg 1.20.6.

=item B<FFLAGS>

Flaggor för Fortran 77-kompilatorn. En delmängd av B<CFLAGS>.

=item B<FCFLAGS>

Flaggor för Fortran 9x-kompilatorn. Samma som B<FFLAGS>.

=item B<LDFLAGS>

Flaggor som sänds till kompilatorn vid länkning av binärer eller delade
objekt (om länkaren anropas direkt måste B<-Wl> och B<,> tas bort från dessa
flaggor). Standardvärde: tomt.

=back

Nya flaggor kan komma att läggas till i framtiden om behovet uppstår (till
exempel för att stöda andra språk).

=head1 FUNKTIONSOMRÅDEN

Varje områdesfunktion kan aktiveras och inaktiveras i områdesvärdet i
miljövariablerna B<DEB_BUILD_OPTIONS> och B<DEB_BUILD_MAINT_OPTIONS>
modifierarna ”B<+>” och ”B<->”. Till exempel, för att aktivera
B<hardening>-funktionen ”pie” och inaktivera funktionen ”fortify” genom att
ange detta i B<debian/rules>:

    export DEB_BUILD_MAINT_OPTIONS=hardening=+pie,-fortify

Den speciella funktionen B<all> kan användas för att aktivera eller
inaktivera alla områdesfunktioner samtidigt. Du kan till exempel inaktivera
allt i området B<hardening> och endast aktivera ”format” och ”fortify” med:

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

=head2 future

Flera kommandoradsflaggor (beskrivna nedan) kan användas för att aktivera
funktioner som borde vara aktiverade som standard, men som inte kan vara det
på grund av bakåtkompatibilitetsorsaker.

=over 

=item B<lfs>

Den här inställningen (inaktiverad som förval) aktiverar stöd för stora
filer på 32-bitars-arkitekturer där deras ABI inte som förval inkluderar
LFS, genom att lägga till B<-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64> till
B<CPPFLAGS>.

=back

=head2 qa

Flera kommandoradsflaggor (beskrivna nedan) kan användas för att göra det
lättare att hitta problem i källkoden eller byggsystemet.

=over 

=item B<bug>

Inställningen (inaktiverad som förval) lägger till ytterligare varningar som
pålitligt upptäcket problematisk källkod. Varningarna är ödesdigra. De enda
flaggor som för närvarande stöds är B<CFLAGS> och B<CXXFLAGS> med flaggorna
satt till B<-Werror=array-bounds>, B<-Werror=clobbered>,
B<-Werror=implicit-function-declaration> och
B<-Werror=volatile-register-var>.

=item B<canary>

Den här inställningen (inaktiverad som förval) lägger till overksamma
tjallarflaggor till byggflaggorna, så att byggloggarna kan kontrolleras för
att se hur byggflaggor vidarebefordras för att göra det enklare att hitta
när vanliga byggflagor utesluts. De enda flaggor som stöds är för närvarande
B<CPPFLAGS>, B<CFLAGS>, B<OBJCFLAGS>, B<CXXFLAGS> och B<OBJCXXFLAGS> med
flaggorna satta till B<-D__DEB_CANARY_>I<flag>_I<slumpmässigt-id>B<__>, och
B<LDFLAGS> satt till B<-Wl,-z,deb-canary->I<slumpmässigt-id>.

=back

=head2 sanitize

Du kan använda flera kompileringsflaggor (se detaljer nedan) för att sanera
den färdiga binären mot minnesfördärvningsar, minnesläckor, användning efter
frigivning, datakapplöpningsfel i trådar och fel i förbindels med
odefinierat beteende. B<Observera>: dessa flaggor bör B<inte> användas för
produktionsbygg eftersom de kan minska pålitligheten för korrekt kod, minska
säkerheten eller till och med funktionsrikedomen.

=over 

=item B<address>

Den här inställningen (inaktiverad som förval) lägger till
B<-fsanitize=address> till B<LDFLAGS> och B<-fsanitize=address
-fno-omit-frame-pointer> till B<CFLAGS> och B<CXXFLAGS>.

=item B<thread>

Den här inställningen (inaktiverad som förval) lägger till
B<-fsanitize=thread> till B<CFLAGS>, B<CXXFLAGS> och B<LDFLAGS>.

=item B<leak>

Den här inställningen (inaktiverad som förval) lägger till
B<-fsanitize=leak> till B<LDFLAGS>. Den inaktiveras automatiskt om antingen
funktionen B<address> eller B<thread> aktiveras, eftersom de implicerar den.

=item B<undefined>

Den här inställningen (inaktiverad som förval) lägger till
B<-fsanitize=undefined> till B<CFLAGS>, B<CXXFLAGS> och B<LDFLAGS>.

=back

=head2 hardening

Du kan använda flera kompileringsflaggor (se detaljer nedan) för att härda
den färdiga binären mot minnesfördärvningsangrepp, eller för att ge
ytterligare varningsmeddelanden under kompileringen. Förutom det som anges
nedan aktiveras dessa som standard för arkitekturer som stöder dem.

=over 

=item B<format>

Inställningen (aktiverad som förval) lägger till B<-Wformat
-Werror=format-security> till B<CFLAGS>, B<CXXFLAGS>, B<OBJCFLAGS> och
B<OBJCXXFLAGS>. Detta kommer att varna om olämplig användning av
formatsträngar, och att misslyckas när formatfunktionerna används på ett
sätt som representerar möjliga säkerhetsproblem. För närvarande varnar detta
om anrop till funktionerna B<printf> och B<scanf> där formatsträngen inte är
en fast sträng och när det inte finns några formatargument, som i
B<printf(foo);> istället för B<printf("%s", foo);> Detta kan vara ett
säkerhetshål om formatsträngen kommer från en obetrodd källa och innehåller
”%n”.

=item B<fortify>

Inställningen (aktiverad som förval) lägger till  B<-D_FORTIFY_SOURCE=2>
till B<CPPFLAGS>. Kompilatorn har under kodgenereringen kännedom om en hel
del information om buffertstorlekar (där tillämpligt) och försöker ersätta
osäkra funktionsanrop med obegränsade buffertlängder med längdbegränsade
dito. Det här är speciellt användbart för gammal, skräpig kod. Dessutom
blockeras formatsträngar i skrivbart minne som innehåller ”%n”. Om ett
program är beroende av en sådan formatsträng måste det gås runt i kod.

Observera att för att den här flaggan ska ha någon funktion måste källkoden
också kompileras med B<-O1> eller högre. Om miljövariabeln
B<DEB_BUILD_OPTIONS> innehåller I<noopt> kommer stödet för B<fortify> att
inaktiverats, på grund av nya varningar som ges av glibc 2.16 och senare.

=item B<stackprotector>

Inställningen (aktiverad som förval om stackprotectorstrong inte används)
lägger till B<-fstack-protector --param=ssp-buffer-size=4> till B<CFLAGS>,
B<CXXFLAGS>, B<OBJCFLAGS>, B<OBJCXXFLAGS>, B<GCJFLAGS>, B<FFLAGS> och
B<FCFLAGS>. Detta lägger till säkerhetskontroller mot stacköverskrivningar,
vilket gör att många möjliga kodinjiceringsangrepp istället avbryter
programmet. I det bästa fallet gör det kodinjiceringsangrepp till
överbelastnignsangrepp eller icke-problem (beroende på programmet).

Den här funktionen kräver länkning mot glibc (eller ett annat bibliotek som
tillhandahåller B<__stack_chk_fail>), så det måste inaktiveras när du bygger
med B<-nostdlib> eller B<-ffreestanding> eller liknande.

=item B<stackprotectorstrong>

Inställningen (aktiverad som förval) lägger till B<-fstack-protector-strong>
till B<CFLAGS>, B<CXXFLAGS>, B<OBJCFLAGS>, B<OBJCXXFLAGS>, B<GCJFLAGS>,
B<FFLAGS> och B<FCFLAGS>. Detta är en starkare variant av B<stackprotector>,
men utan markanta prestandaminskningar.

Om du inaktiverar B<stackprotector> inaktiveras även denna inställning.

Funktionen har samma krav som B<stackprotector>, och kräver dessutom gcc 4.9
eller senare.

=item B<relro>

Inställningen (aktiverad som förval) lägger till B<-Wl,-z,relro> till
B<LDFLAGS>. Vid inläsning av programmet måste länkaren skriva till flera
ELF-minnessektioner. Den här inställningen flaggar till inläsaren att dessa
sektioner ska göras skrivskyddade innan programmet får kontroll. Detta
skyddar huvudsaklingen mot GOT-överskrivningsangrepp. Om inställningen
inaktiveras kommer även B<bindnow> att inaktiveras.

=item B<bindnow>

Inställningen (inaktiverad som förval) lägger till B<-Wl,-z,bindnow> till
B<LDFLAGS>. Vid inläsning av programmet löses alla dynamiska symboler,
vilket gör att hela PLT kan markeras som skrivskyddad (på grund av B<relro>
ovan). Inställningen kan inte aktiveras om B<relro> inte är aktiverad.

=item B<pie>

Den här inställningen (utan globalt förval sedan dpkg 1.18.23, eftersom den
aktiveras som förval numera av gcc på Debianarkitekturerna amd64, arm64,
armel, armhf, hurd-i386, i386, kfreebsd-amd64, kfreebsd-i386, mips, mipsel,
mips64el, powerpc, ppc64, ppc64el, riscv64, s390x, sparc och sparc64) lägger
till de flaggor som krävs för att aktivera eller inaktivera PIE via
gcc-specifikationsfiler, om det behövs, beroende på om gcc lägger till
flaggorna själv på arkitekturen eller inte. Om inställningen aktiveras och
gcc injicerar flaggorna lägger den inte till Någonting. Om inställningen är
aktiverad och gcc inte injicerar flaggorna, lägger den till B<-fPIE> (via
I<%PKGDATADIR%/pie-compiler.specs>) till B<CFLAGS>, B<CXXFLAGS>,
B<OBJCFLAGS>, B<OBJCXXFLAGS>, B<GCJFLAGS>, B<FFLAGS> och B<FCFLAGS>, och
B<-fPIE -pie> (via I<%PKGDATADIR%/pie-link.specs>) till B<LDFLAGS>. När
inställningen är inaktiverad och gcc injicerar flaggorna, lägger den till
B<-fno-PIE> (via I<%PKGDATADIR%/no-pie-compile.specs>) to B<CFLAGS>,
B<CXXFLAGS>, B<OBJCFLAGS>, B<OBJCXXFLAGS>, B<GCJFLAGS>, B<FFLAGS> till
B<FCFLAGS>, och B<-fno-PIE -no-pie> (via I<%PKGDATADIR%/no-pie-link.specs>)
till B<LDFLAGS>.

Positionsoberoende exekverbara program (PIE) behövs för att dra fördel av
slumpmässig adressrymd (ASLR), vilket stöds av vissa versioner av
kärnan. Medan ASLR redan kan användas för datautrymmen i stacken och heap:en
(brk och mmap), måste kodområden först kompileras som
positionsoberoende. Delade bibliotek gör redan detta (-fPIC), så de drar
automatiskt fördel av ASLR medan binära .text-regioner måste byggas med PIE
för att uppnå ASLR. När detta sker är ROP-angrepp (Return Oriented
Programming) mycket svårare eftersom det inte finns några statiska platser
att studsa från i ett minnesfördärvningsangrepp.

PIE är inte kompatibelt med B<-fPIC>, så allmän försiktighet måste tas vid
bygge av delade objekt. Men eftersom PIE-flaggorna som skapas injiceras via
gcc-specifikationsfiler bör det alltid vara säkert att ovillkorligen sätta
dem oberoende av typen av objekt som kompileras eller länkas.

Statiska bibliotek kan användas av program eller andra delade
bibliotek. Beroende på vilka flaggor som används för att kompilera objekten
inuti ett statisk bibliotek kan dessa vara användas av olika uppsättningar
objekt:

=over 

=item inget

Kan varken länkas till ett PIE-program eller ett delat bibliotek.

=item B<-fPIE>

Kan länkas till alla program, men inte ett delat bibliotek (rekommenderas).

=item B<-fPIC>

Kan länkas till alla program och delade bibliotek.

=back

Om flaggorna behöver sättas manuellt och gcc:s spec-injektion förbigås,
finns det flera saker man behöver tänka på. Att ovillkorligen och explicit
sända B<-fPIE>, B<-fpie> eller B<-pie> till ett byggsystem som använder
libtool är säkert eftersom flaggorna kommer skalas av när delade bibliotek
byggs. På projekt som bygger både program och delade bibliotek kan du annars
behöva se till att B<-fPIC> alltid sänds sist i kompileringsflaggor såsom
B<CFLAGS> när delade bibliotek byggs (så att den överstyre en tidigare
angiven B<-PIE>), och att B<-shared> sänds sist till länkflaggor såsom
B<LDFLAGS> (så att den överstyr en tidigare angiven B<-pie>). B<Observera:>
Detta behöver inte göras med standard-gcc-specifikationsmaskineriet.

Eftersom PIE i tillägg implementeras med ett generellt register kan vissa
arkitekturer med få register (men inte längre i386 eftersom optimeringar
implementerats i gcc E<gt>= 5) se prestandaförluster upp till 15% i väldigt
textsegment-tunga programs körning; de flesta körningar ser mindre än
1%. Arkitekturer med många generella register (t.ex amd64) ser inte en lika
stor värsta falls-förlust.

=back

=head2 reproducible

Kompileringsflaggorna som anges nedan kan användas för att göra det lättare
att reproducera byggbarhet eller tillhandahålla ytterligare varningsflaggor
under kompileringen. Förutom det som anges nedan aktiveras dessa som
standard för arkitekturer som stöder dem.

=over 

=item B<timeless>

Inställningen (aktiverad som förval) lägger till B<-Wdate-time> till
B<CPPFLAGS>. Detta ger varningar när makrona B<__TIME__>, B<__DATE__> eller
B<__TIMESTAMP__> används.

=item B<fixfilepath>

Inställningen (aktiverad som förval) lägger till
B<-ffile-prefix-map=>I<BYGGSÖKVÄG>B<=.> till B<CFLAGS>, B<CXXFLAGS>,
B<OBJCFLAGS>, B<OBJCXXFLAGS>, B<GCJFLAGS>, B<FFLAGS> och B<FCFLAGS> där
B<BYGGSÖKVÄG>. Detta får till effekt att byggsökvägen försvinner från alla
genererade filer.

Om både B<fixdebugpath> och B<fixfilepath> anges tar denna flagga företräde,
eftersom den är en övermängd av den förstnämnda.

=item B<fixdebugpath>

Inställningen (aktiverad som förval) lägger till
B<-fdebug-prefix-map=>I<BYGGSÖKVÄG>B<=.> till till B<CFLAGS>, B<CXXFLAGS>,
B<OBJCFLAGS>, B<OBJCXXFLAGS>, B<GCJFLAGS>, B<FFLAGS> och B<FCFLAGS>. Detta
får till effekt att byggsökvägen försvinner från alla genererade
felsökningssymboler.

=back

=head1 MILJÖVARIABLER

Det finns två uppsättningar miljövariabler som utför samma operationer, den
första (DEB_I<flagga>_I<op>) bör aldrig användas inuti B<debian/rules>). Den
är tänkt för användare som vill bygga om källkodspaketet med andra
byggflaggor. Den andra uppsättningen (DEB_I<flagga>_MAINT_I<op>) bör endast
användas i B<debian/rules> av paketansvariga för att ändra de slutgiltiga
byggflaggorna.

=over 

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

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

Denna variabel kan användas för att tvinga fram värdet som returneras för
given I<flagga>.

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

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

Denna variabel kan användas för att tillhandahålla en blankstegsavdelad
lista med flaggor som kommer att tas bort från uppsättningen flaggor som ges
för given I<flagga>.

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

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

Denna variabel kan användas för att lägga till ytterligare flaggor till
värdet som returneras för given I<flagga>.

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

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

Denna variabel kan användas för att lägga till ytterligare flaggor först i
värdet som returneras för given I<flagga>.

=item B<DEB_BUILD_OPTIONS>

=item B<DEB_BUILD_MAINT_OPTIONS>

De här variablerna kan användas av en användare eller utvecklare för att slå
av/på olika områdesfunktioner som påverkar byggflaggorna. Variabeln
B<DEB_BUILD_MAINT_OPTIONS>-variabeln överstyr alla inställningar i
funktionsområden i B<DEB_BUILD_OPTIONS>. Se avsnittet B<FUNKTIONSOMRÅDEN>
för mer information.

=item B<DEB_VENDOR>

Inställningen anger den aktuella återförsäljaren. Om den inte är satt kommer
återförsäljaren att identifieras genom att läsa
B<%PKGCONFDIR%/origins/default>.

=item B<DEB_BUILD_PATH>

Den här variabeln anger byggsökvägen (sedan dpkg 1.18.8) att använda i
funktioner såsom B<fixdebugpath> så att de kan styras av
anroparen. Variabeln är för närvarande specifik för Debian och dess derivat.

=item B<DPKG_COLORS>

Väljer färgläge (sedan dpkg 1.18.5). För närvarande godtas följande värden:
B<auto> (förval), B<always> och B<never>.

=item B<DPKG_NLS>

Om satt, används för att bestämma om lokalt språkstöd ska aktiveras, även
känt som internationaliseringsstöd (eller i18n) (sedan dpkg
1.19.0). Tillåtna värden är: B<0> och B<1> (förval).

=back

=head1 FILER

=head2 Konfigurationsfiler

=over 

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

Konfigurationsfil för hela systemet.

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

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

Användarens konfigurationsfil.

=back

=head2 Paketeringsstöd

=over 

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

Makefile-klipp som läser in (och eventuellt exporterar) alla flaggor som
stöd av B<dpkg-buildflags> till variabler (sedan dpkg 1.16.1).

=back

=head1 EXEMPEL

För att sända byggflaggor till en byggkommandorad i en makefil:

=over 

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

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

=back

För att sätta byggflaggor i ett skalskript eller skalfragment kan B<eval>
användas för att tolka utdata och exportera flaggorna i miljön:

=over 

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

=back

eller för att sätta positionsparametrarna för att sända till ett kommando:

=over 

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

=back

=head2 Använda i debian/rules

Du bör anropa B<dpkg-buildflags> eller inkludera B<buildflags.mk> från filen
B<debian/rules> för att hämta de byggflaggor det är nödvändigt att sända
till byggsystemet. Observera att äldre versioner av B<dpkg-buildpackages>
(före dpkg 1.16.1) exporterade dessa flaggor automatiskt. Du bör dock inte
bero på detta, eftersom detta förhindrar körning av B<debian/rules>
manuellt.

För paket med autoconf-liknande byggsystem kan du sända relevanta flaggor
direkt till configure eller B<make>(1), som visas ovan.

I andra byggsystem, eller om du vill ha mer finkorning styrning av vilka
flaggor som sänds vart, kan du använda B<--get>. Eller så kan du istället
inkludera B<buildflags.mk>, som tar hand om anropet till B<dpkg-buildflags>
och lagringen av byggflaggorna i make-variabler.

Om du vill exportera alla byggflaggor till miljön (där de kan fångas upp av
ditt byggsystem):

=over 

 DPKG_EXPORT_BUILDFLAGS = 1
 include %PKGDATADIR%/buildflags.mk

=back

För extra styrning av vad som expoteras kan du manuellt exportera
variablerna (eftersom inga av dem exporteras som standard):

=over 

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

=back

Du kan naturligtvis dessutom manuellt sända flaggorna till kommandon:

=over 

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

=back


=head1 ÖVERSÄTTNING

Peter Krefting och Daniel Nylander.