Provided by: dpkg-dev_1.14.24ubuntu1_all bug

NOM

       dpkg-architecture   -   Fixer  et  déterminer  l’architecture  pour  la
       construction d’un paquet

SYNOPSIS

       dpkg-architecture [options] [commandes]

DESCRIPTION

       dpkg-architecture aide  à  déterminer  et  à  fixer  l’architecture  de
       construction et l’architecture hôte pour la création d’un paquet.

       L’architecture  de  construction  est  toujours déterminée par un appel
       externe à dpkg(1).  Elle  ne  peut  pas  être  spécifiée  en  ligne  de
       commande.

       Vous  pouvez  spécifier  une  architecture  hôte  en  utilisant une des
       options -a et -t (ou les deux). Par défaut, la  valeur  est  déterminée
       par  un  appel à gcc(1), ou en utilisant l’architecture de construction
       si CC ou gcc ne sont pas disponibles. Utiliser une seule des options -a
       et  -t  est suffisant, la valeur de l’une est utilisée comme valeur par
       défaut de l’autre. Bien sûr, il est préférable de n’en préciser  qu’une
       seule, puisque dpkg-architecture affichera un avertissement si le choix
       ne correspond pas à la valeur par défaut.

COMMANDES

       -l     Affiche  les  variables  d’environnement,  une  par  ligne,   en
              utilisant  le format VARIABLE=valeur. C’est l’action par défaut.

       -earchitecture-debian
              Vérifie     l’égalité     d’architectures.      Par      défaut,
              architecture-debian   est   comparée   à  l’architecture  Debian
              actuelle, qui est celle de la  machine  hôte.  Cette  action  ne
              développe  pas  les architectures joker. La commande quitte avec
              un code de retour de 0 si l’architecture correspond et de 1 dans
              le cas contraire.

       -iarchitecture-joker
              Vérifie     l’égalité     d’architectures     en     développant
              architecture-joker  et  en  comparant  à  l’architecture  Debian
              actuelle.  La  commande  quitte  avec  un code de retour de 0 si
              l’architecture correspond et de 1 dans le cas contraire.

       -qnom-de-variable
              Affiche la valeur d’une seule variable.

       -s     Produit une commande, qui peut être  utilisée  pour  positionner
              les variables d’environnement avec « eval ».

       -u     Produit  une  commande  similaire  à celle produite par -s, mais
              pour supprimer les variables de l’environnement.

       -c commande
              Exécute  une  commande  dans  un  environnement  où  toutes  les
              variables sont positionnées aux valeurs spécifiées.

       -L     Affiche une liste des architectures valables.

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

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

OPTIONS

       -aarchitecture-debian
              Fixe l’architecture Debian.

       -ttype-de-systme-gnu
              Fixe le type de système GNU.

       -f     Les valeurs positionnées par les variables d’environnement ayant
              le même nom que celles utilisées par les scripts sont prises  en
              compte  (c’est-à-dire  utilisée  par dpkg-architecture), sauf si
              cette option est présente.  Ceci  permet  à  un  utilisateur  de
              surcharger  une  valeur même lorsque l’appel à dpkg-architecture
              est   inclus    dans    un    autre    script    (par    exemple
              dpkg-buildpackage(1)).

TERMINOLOGIE

       Machine de construction
           Machine sur laquelle le paquet est construit.

       Machine hôte
           Machine pour laquelle le paquet est construit.

       Architecture Debian
           Chaîne   de  caractères  de  l’architecture  Debian,  qui  spécifie
           l’emplacement  dans  l’archive  FTP.  Par  exemple :  i386,  sparc,
           hurd-i386.

       Architecture joker
           Une architecture joker est une architecture spéciale qui correspond
           à toutes les architectures réelles qui en font partie.  Il  est  en
           général  de la forme <noyau>-<processeur>. Par exemple : linux-any,
           any-i386, hurd-any.

       Type de système GNU
           Chaîne de caractères définissant l’architecture  et  constituée  de
           deux  parties  séparées  par  un tiret : processeur et système. Par
           exemple : i386-linux-gnu, sparc-linux-gnu, i386-gnu, x86_64-netbsd.

VARIABLES DENVIRONNEMENT
       Les variables suivantes sont positionnées par dpkg-architecture :

       DEB_BUILD_ARCH
           Architecture Debian de la machine de construction.

       DEB_BUILD_ARCH_OS
           Nom du système Debian de la machine de construction.

       DEB_BUILD_ARCH_CPU
           Nom de processeur Debian de la machine de construction.

       DEB_BUILD_GNU_TYPE
           Type de système GNU de la machine de construction.

       DEB_BUILD_GNU_CPU
           Partie « processeur » de DEB_BUILD_GNU_TYPE.

       DEB_BUILD_GNU_SYSTEM
           Partie « système » de DEB_BUILD_GNU_TYPE.

       DEB_HOST_ARCH
           Architecture Debian de la machine hôte.

       DEB_HOST_ARCH_OS
           Nom du système Debian de la machine hôte.

       DEB_HOST_ARCH_CPU
           Nom du processeur Debian de la machine hôte.

       DEB_HOST_GNU_TYPE
           Type de système GNU de la machine hôte.

       DEB_HOST_GNU_CPU
           Partie « processeur » de DEB_HOST_GNU_TYPE.

       DEB_HOST_GNU_SYSTEM
           Partie « système » de DEB_HOST_GNU_TYPE.

DEBIAN/RULES

       Les  variables  d’environnement  définies  par  dpkg-architecture  sont
       fournies  à  debian/rules  comme  variables  pour  make  (consultez  la
       documentation  de make). Cependant, vous ne devez pas compter là-dessus
       puisque cela empêche les appels manuels à ce script. À la  place,  vous
       devez  toujours  les  initialiser  en  utilisant dpkg-architecture avec
       l’option -q. Voici  quelques  exemples,  qui  indiquent  aussi  comment
       améliorer la gestion des compilations croisées de votre paquet :

       Au lieu de :

              ARCH=`dpkg --print-architecture`
              configure $(ARCH)-linux

       Veuillez utiliser :

              DEB_BUILD_GNU_TYPE := $(shell dpkg-architecture -qDEB_BUILD_GNU_TYPE)
              DEB_HOST_GNU_TYPE := $(shell dpkg-architecture -qDEB_HOST_GNU_TYPE)

              configure --build=$(DEB_BUILD_GNU_TYPE) --host=$(DEB_HOST_GNU_TYPE)

       Au lieu de :

              ARCH=`dpkg --print-architecture`
              ifeq ($(ARCH),alpha)
                ...
              endif

       Veuillez utiliser :

              DEB_HOST_ARCH := $(shell dpkg-architecture -qDEB_HOST_ARCH)

              ifeq ($(DEB_HOST_ARCH),alpha)
                ...
              endif

       Ou,  si  vous n’avez besoin que de vérifier le type du processeur et du
       système, utilisez les variables DEB_HOST_ARCH_CPU ou  DEB_HOST_ARCH_OS.

       Appeler  dpkg dans les fichiers « rules » pour obtenir les informations
       sur  l’architecture  est  déconseillé  (sauf  pour   des   raisons   de
       compatibilité  arrière,  voyez  ci-dessous).  En  particulier, l’option
       --print-architecture n’est pas fiable puisque  certaines  architectures
       Debian ne correspondent à aucun nom de processeur.

COMPATIBILITÉ ARRIÈRE

       Les  variables DEB_HOST_ARCH_CPU et DEB_HOST_ARCH_OS n’ont été ajoutées
       à dpkg-architecture que récemment (depuis la version 1.13.2  de  dpkg).
       Auparavant,   les   fichiers  debian/rules  utilisaient  les  variables
       DEB_HOST_GNU_CPU ou DEB_HOST_GNU_TYPE qui ont eu tendance à varier dans
       le temps.

       Si  ces  variables  sont  encore utilisées dans un fichier debian/rules
       pour décider quoi construire et comment, il faut les remplacer par  les
       nouvelles  variables.  Vous  pouvez rester compatible avec les versions
       précédentes de dpkg-dev en utilisant le code suivant :

              DEB_HOST_ARCH_CPU := $(shell dpkg-architecture -qDEB_HOST_ARCH_CPU 2>/dev/null)
              DEB_HOST_ARCH_OS := $(shell dpkg-architecture -qDEB_HOST_ARCH_OS 2>/dev/null)

              # Prise en compte des anciennes versions de dpkg-architecture.
              ifeq ($(DEB_HOST_ARCH_CPU),)
                DEB_HOST_ARCH_CPU := $(shell dpkg-architecture -qDEB_HOST_GNU_CPU)
                ifeq ($(DEB_HOST_ARCH_CPU),x86_64)
                  DEB_HOST_ARCH_CPU := amd64
                endif
              endif
              ifeq ($(DEB_HOST_ARCH_OS),)
                DEB_HOST_ARCH_OS := $(subst -gnu,,$(shell dpkg-architecture -qDEB_HOST_GNU_SYSTEM))
                ifeq ($(DEB_HOST_ARCH_OS),gnu)
                  DEB_HOST_ARCH_OS := hurd
                endif
              endif

       Et de la même façon pour DEB_BUILD_ARCH_CPU et DEB_BUILD_ARCH_OS.

       Pour accepter encore  les  versions  de  dpkg-dev  qui  n’incluent  pas
       dpkg-architecture, vous pouvez utiliser :

              DEB_BUILD_ARCH := $(shell dpkg --print-architecture)
              DEB_BUILD_GNU_CPU := $(patsubst hurd-%,%,$(DEB_BUILD_ARCH))
              ifeq ($(filter-out hurd-%,$(DEB_BUILD_ARCH)),)
                DEB_BUILD_GNU_SYSTEM := gnu
              else
                DEB_BUILD_GNU_SYSTEM := linux-gnu
              endif
              DEB_BUILD_GNU_TYPE=$(DEB_BUILD_GNU_CPU)-$(DEB_BUILD_GNU_SYSTEM)

              DEB_HOST_ARCH := $(DEB_BUILD_ARCH)
              DEB_HOST_GNU_CPU := $(DEB_BUILD_GNU_CPU)
              DEB_HOST_GNU_SYSTEM := $(DEB_BUILD_GNU_SYSTEM)
              DEB_HOST_GNU_TYPE := $(DEB_BUILD_GNU_TYPE)

       Vous   pouvez  placer  certaines  de  ces  lignes  au  début  de  votre
       debian/rules.   Ces   valeurs   par   défaut   seront    écrasées    si
       dpkg-architecture est utilisé.

       Vous  n’avez pas besoin de toutes ces lignes. Choisissez uniquement les
       variables que vous utilisez dans votre fichier « rules ». Par  exemple,
       si   vous   n’avez   besoin   que   de   l’architecture   hôte  Debian,
       ‘DEB_HOST_ARCH=`dpkg --print-architecture`’ est  suffisant  (il  s’agit
       bien  sûr  de l’architecture Debian de la machine de construction, mais
       le but est ici de rester compatible  avec  les  anciennes  compilations
       natives).

       Les  options  -e  et -i n’ont été ajoutées que relativement récemment à
       dpkg-architecture (depuis la version 1.13.13 de dpkg).

EXEMPLES

       dpkg-buildpackage accepte l’option -a, et la passe à dpkg-architecture.
       Voici d’autres exemples :

              CC=i386-gnu-gcc dpkg-architecture -c debian/rules build

              eval `dpkg-architecture -u`

       Vérifie  si une architecture est identique à l’architecture actuelle ou
       à celle spécifiée :

              dpkg-architecture -elinux-alpha

              dpkg-architecture -amips -elinux-mips

       Vérifie  si  l’architecture  actuelle  ou  celle  spécifiée   avec   -a
       correspond à un système Linux :

              dpkg-architecture -ilinux-any

              dpkg-architecture -ai386 -ilinux-any

FICHIERS

       Tous  ces  fichiers  sont nécessaires afin que dpkg-architecture puisse
       fonctionner.  Leurs  emplacements  peuvent  être   modifiés   lors   du
       traitement via la variable d’environnement DPKG_DATADIR.

       /usr/share/dpkg/cputable
              Table  des  noms  de processeurs connus et liaison avec leur nom
              GNU.

       /usr/share/dpkg/ostable
              Table des noms des systèmes  d’exploitation  connus  et  liaison
              avec leurs noms GNU.

       /usr/share/dpkg/triplettable
              Correspondances  entre  les triplets de l’architecture Debian et
              les noms des architectures Debian.

VOIR AUSSI

       dpkg-buildpackage(1), dpkg-cross(1).

AUTEUR

       dpkg-architecture et cette page de manuel ont été  initialement  écrits
       par Marcus Brinkmann <brinkmd@debian.org>.

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>.