Provided by: dpkg-dev_1.19.7ubuntu2_all bug

NOM

       dpkg-buildflags  -  Renvoie  les options de compilation à utiliser pour la construction du
       paquet

SYNOPSIS

       dpkg-buildflags [option...] [commande]

DESCRIPTION

       dpkg-buildflags est un script qui  permet  de  récupérer  les  options  de  compilation  à
       utiliser  pour  la  construction  d'un paquet. Les drapeaux par défaut sont définis par le
       distributeur mais peuvent être étendus ou remplacés de plusieurs façons :

       1.     pour tout le système avec /etc/dpkg/buildflags.conf ;

       2.     pour l'utilisateur courant avec $XDG_CONFIG_HOME/dpkg/buildflags.conf où la  valeur
              par défaut de $XDG_CONFIG_HOME est $HOME/.config ;

       3.     temporairement par l'utilisateur avec des variables d'environnement (voir VARIABLES
              D'ENVIRONNEMENT) ;

       4.     dynamiquement par le responsable du paquet avec  des  variables  d'environnement  à
              l'aide de debian/rules (voir VARIABLES D'ENVIRONNEMENT).

       Les fichiers de configuration peuvent contenir quatre types de directives :

       SET drapeau valeur
              Remplace le drapeau drapeau par la valeur valeur.

       STRIP drapeau valeur
              Retire du drapeau drapeau tous les drapeaux de construction listés dans valeur.

       APPEND drapeau valeur
              Étend  le  drapeau  drapeau  avec les options indiquées dans valeur. Une espace est
              ajoutée au début de ce qui est ajouté si la valeur actuelle du  drapeau  n'est  pas
              vide.

       PREPEND drapeau valeur
              Préfixe  le  drapeau drapeau avec les options indiquées dans valeur. Une espace est
              ajoutée au début de ce qui est ajouté si la valeur actuelle du  drapeau  n'est  pas
              vide.

       Les  fichiers de configuration peuvent contenir des commentaires sur les lignes commençant
       par un dièse (#). Les lignes vides sont également ignorées.

COMMANDES

       --dump Affiche sur la sortie standard tous les drapeaux de compilation et  leurs  valeurs.
              Un  drapeau  par  ligne  est  affiché, suivi de sa valeur, séparée par le caractère
              « égal » (« drapeau=valeur »). Il s'agit de l'action par défaut.

       --list Affiche la liste des drapeaux gérés par le distributeur actuel (un par ligne). Voir
              la section DRAPEAUX GÉRÉS pour plus d'informations sur chacun d'eux.

       --status
              Affiche  toute  information utile pour expliquer le comportement de dpkg-buildflags
              (depuis dpkg 1.16.5) : variables d'environnement, distributeur actuel, état de tous
              les  drapeaux  de  fonctionnalités.  Affiche  également les drapeaux de compilation
              résultants ainsi que leur origine.

              Cette option est destinée à être utilisée depuis debian/rules, afin de garder  dans
              le  journal  de construction une trace claire des drapeaux de compilation utilisés.
              Cela peut être utile pour diagnostiquer des problèmes qui y seraient liés.

       --export=format
              Affiche sur la sortie standard les commandes qui  permettent  d'exporter  tous  les
              drapeaux de compilation pour un outil particulier. Si format n'est pas spécifié, sa
              valeur est sh. Seuls les drapeaux de compilation commençant par une majuscule  sont
              inclus,  les  autres  étant  supposés  inadaptés à l'environnement. Formats pris en
              charge :

              sh     Commandes shell pour définir et exporter tous les  drapeaux  de  compilation
                     dans  l'environnement. Les valeurs drapeau sont protégées et ainsi la sortie
                     est prête à être évaluée par un shell.

              cmdline
                     Arguments à passer à la ligne de commande  d'un  programme  de  construction
                     pour  utiliser  tous  les  drapeaux de compilation (depuis dpkg 1.17.0). Les
                     valeurs drapeau sont protégées dans la syntaxe du shell.

              configure
                     C'est un ancien alias pour cmdline.

              make   Directives de make pour définir et exporter tous les drapeaux de compilation
                     dans  l'environnement.  La  sortie  peut  être  écrite  dans  un fragment de
                     Makefile et évaluée en utilisant une directive include.

       --get drapeau
              Affiche la valeur de ce drapeau sur la sortie standard. Retourne un code de  sortie
              0 si le drapeau est connu et 1 s'il est inconnu.

       --origin drapeau
              Affiche  l'origine de la valeur renvoyée par --get. Retourne un code de sortie 0 si
              le drapeau est connu  et  1  s'il  est  inconnu.  L'origine  est  une  des  valeurs
              suivantes :

              vendor le drapeau défini à l'origine par le distributeur est renvoyé ;

              system le drapeau est placé ou modifié par un réglage système ;

              user   le  drapeau  est  placé  ou  modifié  par  une  configuration  spécifique  à
                     l'utilisateur ;

              env    le drapeau est placé  ou  modifié  par  une  configuration  spécifique  dans
                     l'environnement.

       --query
              Affiche  toute  information  utile  pour  expliquer  le comportement du programme :
              distributeur actuel, variables d'environnement, domaines des fonctionnalités,  état
              de  tous  les  drapeaux  de  fonctionnalités.  Affiche  également  les  drapeaux de
              compilation résultants ainsi que leur origine (depuis dpkg 1.19.0).

              Par exemple :
                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

       --query-features domaine
              Affiche les fonctionnalités activées pour un domaine  donné  (depuis  dpkg 1.16.2).
              Les seuls domaines reconnus actuellement sur Debian et ses dérivés sont future, qa,
              reproducible, sanitize et hardening, voir la section ZONES D'OPTION  pour  plus  de
              détails.  Retourne  un  code  de  sortie  0  si  le domaine est connu et 1 s'il est
              inconnu.

              L'affichage est dans le format RFC822, avec une  section  par  fonctionnalité.  Par
              exemple :

                Feature: pie
                Enabled: yes

                Feature: stackprotector
                Enabled: yes

       --help Affiche un message d'aide puis quitte.

       --version
              Affiche le numéro de version puis quitte.

DRAPEAUX GÉRÉS

       CFLAGS Options du compilateur C. La valeur par défaut définie par le distributeur comporte
              -g et le niveau d'optimisation par défaut (-O2 en général, ou -O0  si  la  variable
              d'environnement DEB_BUILD_OPTIONS contient noopt).

       CPPFLAGS
              Options du préprocesseur C. Valeur par défaut : aucune.

       CXXFLAGS
              Options du compilateur C++. Analogue à CFLAGS.

       OBJCFLAGS
              Options du compilateur Objective C. Analogue à CFLAGS.

       OBJCXXFLAGS
              Options du compilateur Objective C++. Analogue à CXXFLAGS.

       GCJFLAGS
              Options du compilateur Java GNU (gcj). Un sous-ensemble de CFLAGS.

       FFLAGS Options du compilateur Fortran 77. Un sous-ensemble de CFLAGS.

       FCFLAGS
              Options du compilateur Fortran 9x. Analogue à FFLAGS.

       LDFLAGS
              Options  passées au compilateur lors du processus de liaison des exécutables ou des
              objets partagés (si le linker est appelé directement, alors -Wl et ,  doivent  être
              retirés de ces options). Valeur par défaut : aucune.

       De  nouveaux  drapeaux  pourront  être ajoutés si besoin est (par exemple pour la prise en
       charge de nouveaux langages).

ZONES D'OPTION

       Chaque option de zone peut être activée ou désactivée avec les  valeurs  DEB_BUILD_OPTIONS
       et DEB_BUIL_MAINT_OPTIONS de l'espace de variables d'environnement grâce aux modificateurs
       « + » et « - ». Par  exemple,  pour  activer  l'option  hardening  « pie »  et  désactiver
       l'option « fortify », il est possible d'indiquer cela dans debian/rules :

         export DEB_BUILD_MAINT_OPTIONS=hardening=+pie,-fortify

       L'option  spéciale  all (valable dans toutes les zones) peut être utilisée pour activer ou
       désactiver toutes les options de la zone à la fois. Ainsi, tout désactiver  dans  la  zone
       hardening en n'activant que « format » et « fortify » peut être réalisé avec :

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

   future
       Plusieurs  options  de  compilation  (détaillées  ci-dessous)  peuvent être utilisées pour
       activer des fonctionnalités qui devraient être activées par défaut, mais  ne  peuvent  pas
       l'être pour des raisons de compatibilité avec les versions précédentes.

       lfs    Ce  paramètre  (désactivé  par  défaut) active la prise en charge des gros fichiers
              (LFS) sur les architectures 32 bits où  l'ABI  n'inclut  pas  LFS  par  défaut,  en
              ajoutant -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 à CPPFLAGS.

   qa
       Plusieurs  options  de  compilation  (détaillées  ci-dessous)  peuvent être utilisées pour
       détecter des problèmes dans le code source ou dans le système de construction.

       bug    Ce paramètre (désactivé par  défaut)  ajoute  toutes  les  options  d'avertissement
              détectant  de  façon  fiable  du code source problématique. Les avertissements sont
              fatals. Les seuls drapeaux actuellement gérés sont  CFLAGS  et  CXXFLAGS  avec  des
              drapeaux       définis       à       -Werror=array-bounds,       -Werror=clobbered,
              -Werror=implicit-function-declaration et -Werror=volatile-register-var.

       canary Ce paramètre (désactivé par  défaut)  ajoute  des  options  détectrices  « canary »
              factices  aux  drapeaux  de  construction  de  telle  sorte  que  les  rapports  de
              compilation permettront de vérifier la façon dont ces drapeaux se propagent  et  de
              repérer   toute  omission  des  paramètres  de  drapeaux  habituels.  Les  drapeaux
              actuellement pris en charge sont CPPFLAGS, CFLAGS, OBJCFLAGS,  CXXFLAGS  ainsi  que
              OBJCXXFLAGS,  avec  les  drapeaux  définis  à  -D__DEB_CANARY_flag_random-id__,  et
              LDFLAGS paramétré à -Wl,-z,deb-canary-random-id.

   sanitize
       Plusieurs options de compilation (détaillées ci-dessous) peuvent être utilisées pour aider
       à nettoyer le binaire compilé face aux corruptions de la mémoire, aux fuites de mémoire, à
       l'utilisation de mémoire après libération et à des bogues au comportement indéfini. Note :
       ces options ne devraient pas être utilisées pour des constructions en production car elles
       peuvent réduire la fiabilité du code, réduire la sécurité ou même les fonctionnalités.

       address
              Ce  paramètre  (désactivé  par  défaut)  ajoute  -fsanitize=address  à  LDFLAGS  et
              -fsanitize=address -fno-omit-frame-pointer à CFLAGS et CXXFLAGS.

       thread Ce  paramètre (désactivé par défaut) ajoute -fsanitize=thread à CFLAGS, CXXFLAGS et
              LDFLAGS.

       leak   Ce paramètre (désactivé par  défaut)  ajoute  -fsanitize=leak  à  LDFLAGS.  Il  est
              automatiquement  désactivé  si les fonctions address ou thread sont activées, parce
              qu'elles l'impliquent.

       undefined
              Ce paramètre (désactivé par défaut) ajoute -fsanitize=undefined à CFLAGS,  CXXFLAGS
              et LDFLAGS.

   compilation renforcée
       Plusieurs  options  de  compilation  (détaillées  ci-dessous)  peuvent être utilisées pour
       accroître la résistance du binaire compilé face aux attaques par corruption de la  mémoire
       ou  fournir  des  messages  d'avertissement  supplémentaires  lors de la compilation. Sauf
       mention contraire (voir ci-dessous),  ces  options  sont  activées  par  défaut  pour  les
       architectures qui les gèrent.

       format Ce  réglage,  activé  par défaut, ajoute -Wformat -Werror=format-security à CFLAGS,
              CXXFLAGS,  OBJCFLAGS  et  OBJCXXFLAGS.  Cela  provoquera  l'avertissement  en   cas
              d'utilisation  de  chaînes de formatage incorrectes et échouera si les fonctions de
              formatage sont utilisées d'une façon qui présente des  risques  pour  la  sécurité.
              Actuellement,  ce  réglage  crée  des  avertissements pour les appels des fonctions
              printf et scanf lorsque la chaîne de formatage n'est pas une  chaîne  littérale  et
              qu'aucun  paramètre  de  formatage  n'est utilisé (par exemple dans printf(foo); au
              lieu de printf("%s", foo);. Ce type de syntaxe peut créer un problème  de  sécurité
              si la chaîne de formatage vient d'une source non sûre et contient « %n ».

       fortify
              Ce  réglage,  activé  par défaut, ajoute -D_FORTIFY_SOURCE=2 à CPPFLAGS. Lors de la
              création du  code,  le  compilateur  connaît  un  nombre  important  d'informations
              relatives aux tailles de tampons (quand c'est possible) et tente alors de remplacer
              des appels de fonctions avec une taille illimitée de tampons,  peu  sûrs,  par  des
              appels   avec   des   tampons   de   taille   limitée.   Cette  fonctionnalité  est
              particulièrement utile pour du code ancien et mal écrit. De plus,  les  chaînes  de
              formatage  dans  la  mémoire  accessible  en  écriture  qui contiennent « %n » sont
              bloquées.  Si  une  application  dépend  de  telles  chaînes   de   formatage,   un
              contournement devra être mis en place.

              Veuillez  noter  que  pour que cette option fasse effet, la source devra aussi être
              compilée avec  -O1  ou  plus.  Si  la  variable  d'environnement  DEB_BUILD_OPTIONS
              contient  noopt, la prise en charge de fortify sera désactivée du fait des nouveaux
              avertissements émis par glibc version 2.16 et ultérieure.

       stackprotector
              Ce réglage (activé par défaut si stackprotectorstrong n'est  pas  employé),  ajoute
              -fstack-protector   --param=ssp-buffer-size=4   à   CFLAGS,   CXXFLAGS,  OBJCFLAGS,
              OBJCXXFLAGS, GCJFLAGS,  FFLAGS  et  FCFLAGS.  Il  ajoute  des  contrôles  liés  aux
              réécritures  de piles. Cela conduit des tentatives d'attaques par injection de code
              à terminer en échec. Dans le meilleur des  cas,  cette  protection  transforme  une
              vulnérabilité  d'injection de code en déni de service ou en non-problème (selon les
              applications).

              Cette fonctionnalité impose de lier le code à glibc (ou  toute  autre  bibliothèque
              fournissant  __stack_chk_fail)  et  doit  donc  être désactivée lorsque le code est
              construit avec -nostdlib, -ffreestanding ou équivalents.

       stackprotectorstrong
              Ce réglage, activé par défaut, ajoute -fstack-protector-strong à CFLAGS,  CXXFLAGS,
              OBJCFLAGS,  OBJCXXFLAGS,  GCJFLAGS,  FFLAGS  et  FCFLAGS.  Il  s'agit d'une version
              renforcée  de  stackprotector  qui  n'affecte  pas  les  performances  de   manière
              importante.

              Désactiver stackprotector désactive également ce paramètre.

              Cette fonctionnalité a les même exigences que stackprotector, en plus de nécessiter
              gcc 4.9 ou plus récent.

       relro  Ce réglage, activé par défaut, ajoute -Wl,-z,relro à LDFLAGS. Lors du chargement du
              programme,  plusieurs  parties de la mémoire ELF doivent être écrites par l'éditeur
              de liens. Ce réglage indique au chargeur de mettre ces sections  en  lecture  seule
              avant  de  rendre  le contrôle au programme. L'utilisation habituelle de ce réglage
              est la protection contre les attaques par  réécriture  GOT.  Si  cette  option  est
              désactivée, l'option bindnow sera également désactivée.

       bindnow
              Ce  réglage,  désactivé par défaut, ajoute -Wl,-z,now à LDFLAGS. Lors du chargement
              du programme, tous les symboles dynamiques sont  résolus,  ce  qui  permet  au  PLT
              (Procedure  Linkage Table) entier d'être en lecture seule (du fait du réglage relro
              ci-dessus). Cette option ne peut être activée si relro ne l'est pas.

       pie    Ce réglage (sans option globale par défaut depuis  dpkg 1.18.23,  parce  qu'il  est
              maintenant  activé  par  défaut par gcc dans les architectures Debian amd64, arm64,
              armel,  armhf,  hurd-i386,  i386,  kfreebsd-amd64,  kfreebsd-i386,  mips,   mipsel,
              mips64el,  powerpc,  ppc64,  ppc64el,  riscv64, s390x, sparc et sparc64) ajoute les
              options  requises  pour  activer  ou  désactiver  PIE  (exécutable  indépendant  de
              l'emplacement) au moyen des fichiers de spécifications de gcc, si nécessaire, selon
              que gcc injecte sur cette architecture les drapeaux par  lui-même  ou  non.  Si  le
              réglage est activé et que gcc injecte les drapeaux, il n'ajoute rien. Si le réglage
              est activé et que gcc n'injecte pas les drapeaux, il  ajoute  -fPIE  (au  moyen  de
              /usr/share/dpkg/pie-compiler.specs)  à  CFLAGS,  CXXFLAGS,  OBJCFLAGS, OBJCXXFLAGS,
              GCJFLAGS,    FFLAGS    et    FCFLAGS,    et    -fPIE    -pie    (au    moyen     de
              /usr/share/dpkg/pie-link.specs)  à  LDFLAGS. Si le réglage est désactivé et que gcc
              injecte    les    drapeaux,     il     ajoute     -fno-PIE     (au     moyen     de
              /usr/share/dpkg/no-pie-compile.specs)  à  CFLAGS, CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS,
              GCJFLAGS,   FFLAGS   et   FCFLAGS,   et   -fno-PIE    -no-pie    (au    moyen    de
              /usr/share/dpkg/no-pie-link.specs) à LDFLAGS.

              Les  exécutables  à  position  indépendante  (« Position  Independent Executable »)
              permettent d'utiliser la randomisation de l'organisation  de  l'espace  d'adressage
              (ASLR : « Address  Space  Layout  Randomization »),  qui  est  gérée  par certaines
              versions du noyau. Bien que ASLR puisse déjà être mise en œuvre pour les  zones  de
              données  dans  la  pile et le tampon (brk et mmap), les zones de codes doivent être
              compilées comme indépendantes de la position. Les bibliothèques partagées font déjà
              cela  (-fPIC) ce qui permet automatiquement d'utiliser ASLR. Par contre les régions
              .text binaires doivent être construites en mode PIE pour mettre en œuvre ASLR.  Une
              fois  cela  réalisé,  les attaques ROP (« Return Oriented Programming ») deviennent
              plus difficiles car il n'existe pas d'emplacement statique  d'où  rebondir  pendant
              une attaque par corruption de la mémoire.

              PIE n'est pas compatible avec fPIC, aussi, en général, des précautions doivent être
              prises lors de la construction d'objets partagés. Mais comme les drapeaux PIE  émis
              sont  injectés  par des fichiers de spécifications de gcc, il devrait toujours être
              sûr de les définir sans condition indépendamment du type d'objet  en  train  d'être
              compilé ou lié.

              Les  bibliothèques  statiques peuvent être utilisées par des programmes ou d'autres
              bibliothèques partagées. Selon les drapeaux utilisés pour compiler tous les  objets
              d'une  bibliothèque  statique,  ces  bibliothèques  seront  utilisables  par divers
              ensembles d'objets :

              none   Ne peut être lié ni à un programme PIE, ni à une bibliothèque partagée.

              -fPIE  Peut être lié à  tout  programme,  mais  pas  à  une  bibliothèque  partagée
                     (recommandé).

              -fPIC  Peut être lié à tout programme et toute bibliothèque partagée.

              S'il   est   nécessaire   de  régler  ces  drapeaux  manuellement,  en  contournant
              l'injonction des spécifications de gcc, il  y  a  plusieurs  choses  à  prendre  en
              compte.  Le  passage sans condition et de façon explicite de -fPIE, -fpie ou -pie à
              un système de construction en utilisant libtool est  sûr  dans  la  mesure  où  ces
              drapeaux  seront retirés lors de la construction de bibliothèques partagées. Sinon,
              sur les projets qui construisent à la fois  des  programmes  et  des  bibliothèques
              partagées,  il  faudrait  s'assurer  que, lors de la construction des bibliothèques
              partagées, -fPIC soit toujours passé en dernier aux drapeaux  de  compilation  tels
              que CFLAGS (de sorte qu'il remplace tout -PIE antérieur), et que -shared soit passé
              en dernier aux drapeaux de création de  lien  tels  que  LDFLAGS  (de  sorte  qu'il
              remplace  tout -pie antérieur). Note : Cela ne devrait pas être nécessaire avec les
              mécanismes de spécification de gcc par défaut.

              De plus, comme la protection PIE est mise en œuvre à l'aide d'un  registre  global,
              certaines   architectures   privées   de   registre  (mais  plus  i386  depuis  les
              optimisations  mises  en  œuvre  dans  gcc >= 5)  peuvent  souffrir  de  pertes  de
              performances allant jusqu'à 15 % sur des charges d'applications utilisant largement
              les segments de texte ; le plus souvent, cette  perte  de  performances  n’excédera
              pas 1 %.  Pour  des  architectures  offrant  plus de registres globaux (par exemple
              amd64), cette pénalisation n'existe pratiquement pas.

   reproductible
       Les  options  de  compilation  (détaillées  ci-dessous)  peuvent  aider  à  améliorer   la
       reproductibilité   de   la   construction   ou   fournir   des   messages  d'avertissement
       supplémentaires lors de la compilation. Sauf  mention  contraire  (voir  ci-dessous),  ces
       options sont activées par défaut pour les architectures qui les gèrent.

       timeless
              Ce paramètre, activé par défaut, ajoute -Wdate-time à CPPFLAGS. Cela provoquera des
              avertissements quand les macros __TIME__, __DATE__ et __TIMESTAMP__ sont utilisées.

       fixfilepath
              Ce paramètre, désactivé par défaut, ajoute -ffile-prefix-map=BUILDPATH=. à  CFLAGS,
              CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, GCJFLAGS, FFLAGS et FCFLAGSBUILDPATH est fixé
              sur le répertoire de plus haut niveau du paquet en construction. Cela a pour  effet
              de retirer le chemin de construction de tout fichier généré.

              Si  à  la fois fixdebugpath et fixfilepath sont définis, cette option a la priorité
              parce c'est un sur-ensemble du premier.

       fixdebugpath
              Ce réglage, activé par  défaut,  ajoute  -fdebug-prefix-map=BUILDPATH=.  à  CFLAGS,
              CXXFLAGS, OBJCFLAGS, OBJCXXFLAGS, GCJFLAGS, FFLAGS et FCFLAGSBUILDPATH est fixé
              sur le répertoire de plus haut niveau du paquet en construction. Cela a pour  effet
              de retirer le chemin de construction de tous les symboles de débogage générés.

ENVIRONNEMENT

       Deux  jeux  de  variables  d'environnement  effectuent  les  mêmes  opérations. Le premier
       (DEB_drapeau_opération) ne devrait jamais être utilisé depuis debian/rules. Il est destiné
       aux  utilisateurs  souhaitant recompiler le paquet source avec des drapeaux de compilation
       modifiés.  Le  second  (DEB_drapeau_MAINT_opération)  ne  doit  être  utilisé   que   dans
       debian/rules  par  les  responsables  de paquets pour modifier les drapeaux de compilation
       concernés.

       DEB_drapeau_SET
       DEB_drapeau_MAINT_SET
              Cette variable permet de forcer la valeur renvoyée pour le drapeau indiqué.

       DEB_drapeau_STRIP
       DEB_drapeau_MAINT_STRIP
              Cette variable peut être utilisée pour fournir une liste  d'options  (séparées  par
              des  espaces)  qui  seront  retirées  du  jeu  de  drapeaux renvoyé pour le drapeau
              indiqué.

       DEB_drapeau_APPEND
       DEB_drapeau_MAINT_APPEND
              Cette variable permet d'ajouter des options à la valeur renvoyée  pour  le  drapeau
              indiqué.

       DEB_drapeau_PREPEND
       DEB_drapeau_MAINT_PREPEND
              Cette  variable  permet  de préfixer la valeur renvoyée pour le drapeau indiqué par
              des options supplémentaires.

       DEB_BUILD_OPTIONS
       DEB_BUILD_MAINT_OPTIONS
              Ces variables peuvent être utilisées par un utilisateur ou un responsable de paquet
              pour  activer  ou désactiver différentes options de zone qui affectent les drapeaux
              de construction. La variable DEB_BUILD_MAINT_OPTIONS outrepasse tous les paramètres
              de la zone d'options DEB_BUILD_OPTIONS. Voir la section ZONES D'OPTION pour plus de
              détails.

       DEB_VENDOR
              Ce réglage définit l'éditeur (« vendor ») actuel. Si  cette  valeur  est  vide,  le
              contenu du fichier /etc/dpkg/origins/default est utilisé.

       DEB_BUILD_PATH
              Cette  variable configure le chemin de construction (depuis dpkg 1.18.8) à utiliser
              avec  des  fonctions  telles  que  fixdebugpath  de  telle  sorte  qu'elles  soient
              contrôlées par l'appelant. Cette variable est actuellement spécifique à Debian et à
              ses dérivés.

       DPKG_COLORS
              Définit le mode de couleur (depuis dpkg 1.18.5). Les valeurs actuellement acceptées
              sont auto (par défaut), always et never.

       DPKG_NLS
              Si  cette  variable est définie, elle sera utilisée pour décider l'activation de la
              prise en charge des langues (NLS – Native Language Support), connu aussi  comme  la
              gestion  de  l'internationalisation  (ou  i18n)  (depuis  dpkg 1.19.0). Les valeurs
              permises sont : 0 et 1 (par défaut).

FICHIERS

   Fichiers de configuration.
       /etc/dpkg/buildflags.conf
              Fichier de configuration pour l'ensemble du système.

       $XDG_CONFIG_HOME/dpkg/buildflags.conf ou
       $HOME/.config/dpkg/buildflags.conf
              Fichier de configuration propre à l'utilisateur

   Gestion de l'empaquetage
       /usr/share/dpkg/buildflags.mk
              Fragment de fichier Makefile qui chargera (et facultativement exportera)  dans  les
              variables   (depuis   dpkg 1.16.1)   tous   les   drapeaux   pris   en  charge  par
              dpkg-buildflags.

EXEMPLES

       Pour passer des drapeaux de compilation à une commande de compilation dans un Makefile :

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

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

       Pour définir les drapeaux de compilation dans un script shell ou un fragment de shell,  on
       peut   utiliser   eval   pour   interpréter  la  sortie  et  exporter  les  drapeaux  dans
       l'environnement :

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

       ou définir les paramètres de position à passer à la commande :

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

   Utilisation dans debian/rules
       Il faut appeler dpkg-buildflags ou inclure buildflags.mk à partir du fichier  debian/rules
       pour  obtenir les drapeaux de compilation nécessaires à passer au système de construction.
       Veuillez noter que les anciennes versions de dpkg-buildpackage (antérieures à dpkg 1.16.1)
       exportaient  ces drapeaux automatiquement. Néanmoins, il est déconseillé de dépendre de ce
       comportement parce qu'il casse l'appel manuel de debian/rules.

       Pour les paquets avec des systèmes de construction du style autoconf, il est  possible  de
       passer les options appropriées à configure ou make(1) directement, comme vu ci-dessus.

       Pour  d'autres  systèmes  de construction ou si on souhaite un contrôle extrêmement précis
       sur le choix et la position  où  sont  passés  les  drapeaux,  --get  peut  être  utilisé.
       Autrement,   il   est   possible  d'inclure  buildflags.mk  qui  s'occupe  de  l'appel  de
       dpkg-buildflags et du placement des drapeaux de compilation dans les variables de make.

       Si vous voulez exporter tous les drapeaux  de  compilation  dans  l'environnement  (où  le
       système de construction peut les récupérer) :

           DPKG_EXPORT_BUILDFLAGS = 1
           include /usr/share/dpkg/buildflags.mk

       Pour  un contrôle supplémentaire sur ce qui est exporté, vous pouvez exporter manuellement
       les variables (puisque aucune n'est exportée par défaut) :

           include /usr/share/dpkg/buildflags.mk
           export CPPFLAGS CFLAGS LDFLAGS

       Et enfin, vous pouvez bien sûr passer manuellement les drapeaux aux commandes :

           include /usr/share/dpkg/buildflags.mk
           build-arch:
                $(CC) -o hello hello.c $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)

TRADUCTION

       Ariel VARDI <ariel.vardi@freesbee.fr>, 2002. Philippe Batailler, 2006.  Nicolas  François,
       2006. Veuillez signaler toute erreur à <debian-l10n-french@lists.debian.org>.