Provided by: dpkg-dev_1.16.1.2ubuntu7_all bug

NAMN

       dpkg-architecture - ställ in och bestäm arkitektur för paket som byggs

SYNOPS

       dpkg-architecture [flagga...] [åtgärd]

BESKRIVNING

       dpkg-architecture  innehåller  en  funktion  för  att  bestämma  och  ställa  in bygg- och
       värdarkitekturerna för att bygga paket.

       Byggarkitekturen bestäms alltid av ett externt anrop till dpkg(1) och kan inte ställas  in
       på kommandoraden.

       Du kan ange värdarkitektur genom att ange en av, eller båda, flaggorna -a och -t. Förvalet
       bestäms av ett externt anrop till gcc(1), eller är detsamma som byggarkitekturen varken CC
       eller gcc är tillgängliga. Det räcker att ange en av -a och -t, värdet på den andra kommer
       ställas in till ett fungerande förval. Det är faktiskt oftast bättre att bara ange den ena
       eftersom dpkg-architecture kommer varna dig om ditt val inte överensstämmer med förvalet.

KOMMANDON

       -l     Skriv  miljövariabler,  en  per  rad,  på formatet VARIABEL=värde. Detta är förvald
              åtgärd.

       -edebianarkitektur
              Kontrollera arkitektur för likhet. Som standard jämförs  debianarkitektur  mot  den
              aktuella  Debianarkitekturen,  som  är värd. Åtgärden expanderar inte jokertecken i
              arkitekturer. Kommandet avslutar med status 0 om det är en träff, 1 om det inte  är
              en träff.

       -iarkitektursökmönster
              Kontrollera  identitet på arkitekturen genom att expandera arkitektursökmönster som
              ett  arkitektursökmönster  med  jokertecken,   och   jämföra   med   den   aktuella
              Debianarkitekturen. Kommandot avslutas med status 0 vid träff, 1 om inte träff.

       -qvariabelnamn
              Skriv värdet på en enkel variabel.

       -s     Visar ett exportkommando. Detta kan användas för att sätta miljövariabler med eval.

       -u     Visar ett kommando liknande -s som för att nollställa alla variabler.

       -c kommando
              Exekvera  ett  kommando  i  en miljö som har alla variabler satta till det bestämda
              värdet.

       -L     Visa en lista över giltiga arkitekturnamn.

       --help Visar hjälpskärm och avslutar.

       --version
              Visar version och avslutar.

FLAGGOR

       -adebianarkitektur
              Välj Debianarkitektur.

       -tgnu-systemtyp
              Välj GNU-systemtyp.

       -f     Värden som sätts av befintliga miljövariabler med samma namn som de som används  av
              skriptet  används  (t.ex  av dpkg-architecture), såvida inte denna tvingande flagga
              anges. Det gör det möjligt för användaren att överstyra ett värde även  om  anropet
              till  dpkg-architecture  är  begravt  djupt  inuti  ett  annat skript (till exempel
              dpkg-buildpackage(1)).

TERMINOLOGI

       byggmaskin
           Maskinen paketet byggs på.

       värdmaskin
           Maskinen paketet byggs för.

       Debianarkitektur
           Debianarkitektursträngen, vilken anger binärträdet  i  -s1FT-arkivet.  Exempel:  i386,
           sparc, hurd-i386.

       arkitektursökmönster
           Ett  arkitektursökmönster  är  en  speciell  arkitektursträng  som  matchar  alla äkta
           arkitekturer som finns i den. Den genella formen är <kärna>-<cpu>. Exempel: linux-any,
           any-i386, hurd-any.

       GNU-systemtyp
           En  arkitekturspecificeringssträng  består  av  två  delar,  avdelade med bindestreck:
           processor   och   system.   Exempel:   i386-linux-gnu,   sparc-linux-gnu,    i386-gnu,
           x86_64-netbsd.

VARIABLER

       Följande variabler sätts av dpkg-architecture:

       DEB_BUILD_ARCH
           Debianarkitekturen för byggmaskinen.

       DEB_BUILD_ARCH_OS
           Debiansystemnamnet för byggmaskinen.

       DEB_BUILD_ARCH_CPU
           Debian-processornamnet för byggmaskinen.

       DEB_BUILD_ARCH_BITS
           Pekarstorleken för byggmaskinen (i bitar).

       DEB_BUILD_ARCH_ENDIAN
           Endian för byggmaskinen (little / big).

       DEB_BUILD_GNU_CPU
           CPU-delen av DEB_BUILD_GNU_TYPE.

       DEB_BUILD_GNU_SYSTEM
           Systemdelen av DEB_BUILD_GNU_TYPE.

       DEB_BUILD_GNU_TYPE
           GNU-systemtypen för byggmaskinen.

       DEB_BUILD_MULTIARCH
           Den förtydligade GNU-systemtypen för byggmaskinen, används för sökvägar i filsystemet.

       DEB_HOST_ARCH
           Debianarkitekturen för värdmaskinen.

       DEB_HOST_ARCH_OS
           Debiansystemnamnet för värdmaskinen.

       DEB_HOST_ARCH_CPU
           Debian-processornamnet för värdmaskinen.

       DEB_HOST_ARCH_BITS
           Pekarstorleken för värdmaskinen (i bitar).

       DEB_HOST_ARCH_ENDIAN
           Endian för värdmaskinen (little / big).

       DEB_HOST_GNU_CPU
           CPU-delen av DEB_HOST_GNU_TYPE.

       DEB_HOST_GNU_SYSTEM
           Systemdelen av DEB_HOST_GNU_TYPE.

       DEB_HOST_GNU_TYPE
           GNU-systemtypen för värdmaskinen.

       DEB_HOST_MULTIARCH
           Den förtydligade GNU-systemtypen för värdmaskinen, används för sökvägar i filsystemet.

DEBIAN/RULES

       Miljövariablerna som sätts av dpkg-architecture sänds till debian/rules som make-variabler
       (se dokumentationen för make). Du bör dock inte bero  på  dem  eftersom  detta  förhindrar
       manuella  anrop  till  skriptet. Du bör istället alltid initiera dem med dpkg-architecture
       med -q-flaggan. Här är några exempel, vilka även visar hur du  kan  förbättra  stödet  för
       korskompilering i ditt paket:

       Istället för:

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

       använder du följande:

              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)

       Istället för:

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

       använder du:

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

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

       eller,   om   du   bara   vill  testa  på  processor-  eller  OS-typ,  använd  variablerna
       DEB_HOST_ARCH_CPU eller DEB_HOST_ARCH_OS.

       Generellt rekommenderas det inte att anropa dpkg i rules-filen för att  hämta  information
       om  arkitekturen  (såvida  du  inte  vill  tillhandahålla  bakåtkompatibilitet, se nedan).
       Speciellt  går  det  inte  att  lita  på  flaggan  --print-architecture  eftersom  vi  har
       Debianarkitekturer som inte är identiskt med namnet på processorn.

BAKÅTKOMPATIBILITET

       Variablerna  DEB_*_ARCH_BITS och DEB_*_ARCH_ENDIAN introducerades i dpkg-dev 1.15.4. Om de
       används i debian/rules måste därför ett byggberoende deklareras på dpkg-dev (>= 1.15.4).

       Variablerna  DEB_HOST_ARCH_CPU  och  DEB_HOST_ARCH_OS  introduceras  i  dpkg-dev   1.13.2.
       Tidigare  såg  debian/rules-filer  oftast på innehållet i variablerna DEB_HOST_GNU_CPU och
       DEB_HOST_GNU_TYPE, vilka har kunnat ändra på sig.

       Om debian/rules ser på dessa variabler för att välja hur eller vad  som  skall  kompileras
       bör detta uppdateras till att använda de nya variablerna och värdena. Om du vill bibehålla
       bakåtkompatibilitet med tidigare versioner av dpkg-dev kan du använda följande kod:

              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)

              # Ta gammalt utdataformat från dpkg-architecture i beaktning.
              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

       Och på motsvarande sätt för DEB_BUILD_ARCH_CPU och DEB_BUILD_ARCH_OS.

       Om du fortfarande vill stöda versioner av dpkg-dev  som  inte  innehöll  dpkg-architecture
       fungerar följande:

              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)

       Lägg  in  en  delmängd  av  dessa rader överst i din debian/rules-fil. Standardvariablerna
       kommer skrivas över om dpkg-architecture används.

       Du behöver inte alla. Välj en konsistent delmängd som innehåller de värden du  använder  i
       rules-filen.  Om  du  till  exempel  bara  behöver  värd-Debianarkitekturen räcker det med
       "DEB_HOST_ARCH=`dpkg   --print-architecture`"   (ja,   det   är   Debianarkitekturen    på
       byggmaskinen,  men  kom  ihåg att vi bara försöker vara bakåtkompatibel med kompilering på
       samma plattform).

       Flaggorna -e och -i  introducerades  i  dpkg-architecture  relativt  nyligen  (sedan  dpkg
       1.13.13).

EXEMPEL

       dpkg-architecture  godtar  flaggan  -a och sänder den vidare till dpkg-architecture. Andra
       exempel:

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

              eval `dpkg-architecture -u`

       Kontrollera om en arkitektur är samma som den nuvarande eller en given:

              dpkg-architecture -elinux-alpha

              dpkg-architecture -amips -elinux-mips

       Se om den aktuella arkitekturen eller en arkitektur som anges med -a är ett Linuxsystem:

              dpkg-architecture -ilinux-any

              dpkg-architecture -ai386 -ilinux-any

FILER

       Alla dessa filer måste finnas för att dpkg-architecture måste finnas. Deras placering  kan
       överstyras vid körning med miljövariabeln DPKG_DATADIR.

       /usr/share/dpkg/cputable
              Tabell över kända processornamn och deras motsvarande GNU-namn.

       /usr/share/dpkg/ostable
              Tabell över kända operativsystemsnamn och deras motsvarande GNU-namn.

       /usr/share/dpkg/triplettable
              Tabell över Debianarkitekturtripplar och deras motsvarande Debianarkitekturnamn.

SE ÄVEN

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

FÖRFATTARE

       dpkg-architecture   och   denna   manualsida  skrevs  ursprungligen  av  Markus  Brinkmann
       <brinkmd@debian.org>.

ÖVERSÄTTNING

       Peter Krefting och Daniel Nylander.