dpkg-architecture(1)		dpkg utilities		  dpkg-architecture(1)



NAME
       dpkg-architecture  -  set  and  determine  the architecture for package
       building

SYNOPSIS
       dpkg-architecture [options] [action]


DESCRIPTION
       dpkg-architecture does provide a facility  to  determine  and  set  the
       build and host architecture for package building.

       The  build  architecture  is  always  determined by an external call to
       dpkg(1), and can not be set at the command line.

       You can specify the host architecture by providing one or both  of  the
       options	-a  and  -t.  The default is determined by an external call to
       gcc(1), or the same as the build architecture if CC or gcc are both not
       available.  One	out of -a and -t is sufficient, the value of the other
       will be set to a usable default. Indeed, it is  often  better  to  only
       specify	one,  because  dpkg-architecture  will warn you if your choice
       does not match the default.

OPTIONS
       -adebian-architecture
	      Set the Debian architecture.

       -tgnu-system-type
	      Set the GNU system type.

       -f     Values set by existing environment variables with the same  name
	      as  used by the scripts are honored (i.e. used by dpkg-architec
	      ture), except if this force flag is  present.  This  allows  the
	      user to override a value even when the call to dpkg-architecture
	      is buried in some  other	script	(for  example  dpkg-buildpack
	      age(1)).

ACTIONS
       -l     Print  the  environment  variables, one each line, in the format
	      VARIABLE=value. This is the default action.

       -edebian-architecture
	      Check for equality of architecture. By default  debian-architec
	      ture  is compared against the current Debian architecture, being
	      the host.  This action will not expand  the  architecture  wild
	      cards.  Command  finishes with an exit status of 0 if matched, 1
	      if not matched.

       -iarchitecture-wildcard
	      Check for identity of architecture  by  expanding  architecture-
	      wildcard	as  an architecture wildcard and comparing against the
	      current Debian architecture. Command finishes with an exit  sta
	      tus of 0 if matched, 1 if not matched.

       -qvariable-name
	      Print the value of a single variable.

       -s     Print an export command. This can be used to set the environment
	      variables using eval.

       -u     Print a similar command to -s but to unset all variables.

       -c command
	      Execute a command in an environment which has all variables  set
	      to the determined value.

       -L     Print a list of valid architecture names.

       --help Print a usage message.

       --version
	      Print program version.

TERMS
       build machine
	   The machine the package is built on.

       host machine
	   The machine the package is built for.

       Debian architecture
	   The	Debian architecture string, which specifies the binary tree in
	   the FTP archive. Examples: i386, sparc, hurd-i386.

       architecture wildcard
	   An architecture wildcard is a special architecture string that will
	   match  any  real architecture being part of it. The general form is
	   -.  Examples: linux-any, any-i386, hurd-any.

       GNU system type
	   An architecture specification string consisting of two parts  sepa
	   rated   by  a  dash:  cpu  and  system.  Examples:  i386-linux-gnu,
	   sparc-linux-gnu, i386-gnu, x86_64-netbsd.

EXAMPLES
       dpkg-buildpackage accepts the -a option and passes it to dpkg-architec
       ture. Other examples:

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

       eval `dpkg-architecture -u`

       Check  if  an  architecture  is	equal to the current architecture or a
       given one:

       dpkg-architecture -elinux-alpha

       dpkg-architecture -amips -elinux-mips

       Check if the current architecture or an architecture provided  with  -a
       are Linux systems:

       dpkg-architecture -ilinux-any

       dpkg-architecture -ai386 -ilinux-any

VARIABLES
       The following variables are set by dpkg-architecture:

       DEB_BUILD_ARCH
	   The Debian architecture of the build machine.

       DEB_BUILD_ARCH_OS
	   The Debian system name of the build machine.

       DEB_BUILD_ARCH_CPU
	   The Debian cpu name of the build machine.

       DEB_BUILD_GNU_TYPE
	   The GNU system type of the build machine.

       DEB_BUILD_GNU_CPU
	   The CPU part of DEB_BUILD_GNU_TYPE

       DEB_BUILD_GNU_SYSTEM
	   The System part of DEB_BUILD_GNU_TYPE.

       DEB_HOST_ARCH
	   The Debian architecture of the host machine.

       DEB_HOST_ARCH_OS
	   The Debian system name of the host machine.

       DEB_HOST_ARCH_CPU
	   The Debian cpu name of the host machine.

       DEB_HOST_GNU_TYPE
	   The GNU system type of the host machine.

       DEB_HOST_GNU_CPU
	   The CPU part of DEB_HOST_GNU_TYPE.

       DEB_HOST_GNU_SYSTEM
	   The System part of DEB_HOST_GNU_TYPE.

DEBIAN/RULES
       The  environment  variables  set  by  dpkg-architecture	are  passed to
       debian/rules as make variables (see make documentation).  However,  you
       should  not  rely  on  them,  as  this  breaks manual invocation of the
       script. Instead, you should always initialize them using dpkg-architec
       ture  with  the	-q option. Here are some examples, which also show how
       you can improve the cross compilation support in your package:


       Instead of:

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

       please use the following:

	      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)


       Instead of:

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

       please use:

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

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

       or  if  you  only  need	to  check  the	CPU  or  OS  type,   use   the
       DEB_HOST_ARCH_CPU or DEB_HOST_ARCH_OS variables.

       In general, calling dpkg in the rules file to get architecture informa
       tion is deprecated (unless you want to provide backward	compatibility,
       see  below).   Especially the --print-architecture option is unreliable
       since we have Debian architectures which dont equal a processor	name.

BACKWARD COMPATIBILITY
       The  DEB_HOST_ARCH_CPU  and DEB_HOST_ARCH_OS variables were only intro
       duced in relatively recent versions of  dpkg-architecture  (since  dpkg
       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.

       Where debian/rules files check these variables to decide how or what to
       compile, this should be updated to use the new  variables  and  values.
       You  may  wish  to retain backwards compatibility with older version of
       dpkg-dev by using the following code:

	      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)

	      # Take account of old dpkg-architecture output.
	      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

       And similarly for DEB_BUILD_ARCH_CPU and DEB_BUILD_ARCH_OS.

       If you still wish to support versions of dpkg-dev that did not  include
       dpkg-architecture, the following does the job:

	      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)

       Put a subset of these lines at the top of your debian/rules file; these
       default values will be overwritten if dpkg-architecture is used.

       You dont need the full set. Choose a consistent set which contains the
       values  you  use  in  the rules file. For example, if you only need the
       host Debian architecture,  DEB_HOST_ARCH=`dpkg  --print-architecture`
       is  sufficient  (this  is  indeed  the Debian architecture of the build
       machine, but remember that we are only trying to be backward compatible
       with native compilation).

       The  -e	and  -i options were only introduced in relatively recent ver
       sions of dpkg-architecture (since dpkg 1.13.13).

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

AUTHOR
       dpkg-architecture and this man page were initially  written  by	Marcus
       Brinkmann .




Debian Project			  2006-06-17		  dpkg-architecture(1)