Provided by: dpkg-dev_1.15.5.6ubuntu4_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_ARCH_BITS
           Taille de pointeur de la machine de construction (en bits).

       DEB_BUILD_ARCH_ENDIAN
           «\ Endianness»\ de la machine de construction (little ou big).

       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_BUILD_ARCH_BITS
           Taille de pointeur de la machine hôte (en bits).

       DEB_BUILD_ARCH_ENDIAN
           «\ Endianess\ » de la machine hôte (little ou big).

       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

       The  DEB_*_ARCH_BITS and DEB_*_ARCH_ENDIAN variables were introduced in
       dpkg-dev  1.15.4.  Using  them  in   debian/rules   thus   requires   a
       build-dependency on dpkg-dev (>= 1.15.4).

       The DEB_HOST_ARCH_CPU and DEB_HOST_ARCH_OS variables were introduced in
       dpkg-dev 1.13.2. Before this debian/rules files  tended  to  check  the
       values  of  the  DEB_HOST_GNU_CPU  or DEB_HOST_GNU_TYPE variables which
       have been subject to change.

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