2009-02-01 21:28:02 +00:00
|
|
|
# Run the named hook, either by calling the function with that name or
|
|
|
|
# by evaluating the variable with that name. This allows convenient
|
|
|
|
# setting of hooks both from Nix expressions (as attributes /
|
|
|
|
# environment variables) and from shell scripts (as functions).
|
|
|
|
runHook() {
|
|
|
|
local hookName="$1"
|
2009-11-19 17:19:32 +00:00
|
|
|
case "$(type -t $hookName)" in
|
|
|
|
(function|alias|builtin) $hookName;;
|
|
|
|
(file) source $hookName;;
|
|
|
|
(keyword) :;;
|
|
|
|
(*) eval "${!hookName}";;
|
|
|
|
esac
|
2009-02-01 21:28:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-04-23 08:19:48 +01:00
|
|
|
exitHandler() {
|
|
|
|
exitCode=$?
|
|
|
|
set +e
|
|
|
|
|
|
|
|
closeNest
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$showBuildStats" ]; then
|
2009-07-02 10:01:37 +01:00
|
|
|
times > "$NIX_BUILD_TOP/.times"
|
|
|
|
local -a times=($(cat "$NIX_BUILD_TOP/.times"))
|
2008-04-23 08:19:48 +01:00
|
|
|
# Print the following statistics:
|
|
|
|
# - user time for the shell
|
|
|
|
# - system time for the shell
|
|
|
|
# - user time for all child processes
|
|
|
|
# - system time for all child processes
|
|
|
|
echo "build time elapsed: " ${times[*]}
|
|
|
|
fi
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ $exitCode != 0 ]; then
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook failureHook
|
2008-04-23 08:19:48 +01:00
|
|
|
|
|
|
|
# If the builder had a non-zero exit code and
|
|
|
|
# $succeedOnFailure is set, create the file
|
|
|
|
# `$out/nix-support/failed' to signal failure, and exit
|
|
|
|
# normally. Otherwise, return the original exit code.
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$succeedOnFailure" ]; then
|
2008-04-23 08:19:48 +01:00
|
|
|
echo "build failed with exit code $exitCode (ignored)"
|
2012-01-18 20:16:00 +00:00
|
|
|
mkdir -p "$out/nix-support"
|
2008-04-23 08:19:48 +01:00
|
|
|
echo -n $exitCode > "$out/nix-support/failed"
|
|
|
|
exit 0
|
|
|
|
fi
|
|
|
|
|
|
|
|
else
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook exitHook
|
2008-04-23 08:19:48 +01:00
|
|
|
fi
|
|
|
|
|
|
|
|
exit $exitCode
|
|
|
|
}
|
|
|
|
|
|
|
|
trap "exitHandler" EXIT
|
|
|
|
|
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
######################################################################
|
2008-02-13 14:23:09 +00:00
|
|
|
# Helper functions that might be useful in setup hooks.
|
2006-08-07 14:31:18 +01:00
|
|
|
|
2007-11-17 14:34:27 +00:00
|
|
|
|
|
|
|
addToSearchPathWithCustomDelimiter() {
|
2007-11-17 14:34:49 +00:00
|
|
|
local delimiter=$1
|
|
|
|
local varName=$2
|
2009-04-18 23:22:51 +01:00
|
|
|
local dir=$3
|
|
|
|
if [ -d "$dir" ]; then
|
|
|
|
eval export ${varName}=${!varName}${!varName:+$delimiter}${dir}
|
2007-11-17 14:34:49 +00:00
|
|
|
fi
|
2007-11-17 14:34:27 +00:00
|
|
|
}
|
|
|
|
|
2009-04-18 23:22:51 +01:00
|
|
|
PATH_DELIMITER=':'
|
|
|
|
|
2008-04-23 08:19:48 +01:00
|
|
|
addToSearchPath() {
|
2007-11-17 14:34:49 +00:00
|
|
|
addToSearchPathWithCustomDelimiter "${PATH_DELIMITER}" "$@"
|
2007-11-17 14:34:27 +00:00
|
|
|
}
|
2006-08-07 14:31:18 +01:00
|
|
|
|
2008-02-13 14:23:09 +00:00
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
######################################################################
|
|
|
|
# Initialisation.
|
|
|
|
|
2006-08-07 14:31:18 +01:00
|
|
|
set -e
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
[ -z $NIX_GCC ] && NIX_GCC=@gcc@
|
2006-08-07 14:31:18 +01:00
|
|
|
|
|
|
|
|
2009-04-18 23:22:51 +01:00
|
|
|
# Wildcard expansions that don't match should expand to an empty list.
|
|
|
|
# This ensures that, for instance, "for i in *; do ...; done" does the
|
|
|
|
# right thing.
|
|
|
|
shopt -s nullglob
|
|
|
|
|
|
|
|
|
2006-08-07 14:31:18 +01:00
|
|
|
# Set up the initial path.
|
|
|
|
PATH=
|
|
|
|
for i in $NIX_GCC @initialPath@; do
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ "$i" = / ]; then i=; fi
|
2009-04-18 23:22:51 +01:00
|
|
|
addToSearchPath PATH $i/bin
|
2006-08-07 14:31:18 +01:00
|
|
|
done
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ "$NIX_DEBUG" = 1 ]; then
|
2008-02-20 23:02:41 +00:00
|
|
|
echo "initial path: $PATH"
|
2006-08-07 14:31:18 +01:00
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Execute the pre-hook.
|
|
|
|
export SHELL=@shell@
|
2012-01-19 15:39:12 +00:00
|
|
|
if [ -z "$shell" ]; then export shell=@shell@; fi
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook preHook
|
2006-08-07 14:31:18 +01:00
|
|
|
|
|
|
|
|
|
|
|
# Check that the pre-hook initialised SHELL.
|
2012-01-19 15:29:20 +00:00
|
|
|
if [ -z "$SHELL" ]; then echo "SHELL not set"; exit 1; fi
|
2006-08-07 14:31:18 +01:00
|
|
|
|
|
|
|
|
|
|
|
# Hack: run gcc's setup hook.
|
|
|
|
envHooks=()
|
Big fixes in the cross build:
- Before this changes, cflags and ldflags for the native and the cross compiler
got mixed. Not all the gcc-wrapper/gcc-cross-wrapper variables are
independant now, but enough, I think.
- Fixed the generic stdenv expression, which did a big mess on buildInputs and
buildNativeInputs. Now it distinguishes when there is a stdenvCross or not.
Maybe we should have a single stdenv and forget about the stdenvCross
adapter - this could end in a stdenv a bit complex, but simpler than the
generic stdenv + adapter.
- Added basic support in pkgconfig for cross-builds: a single PKG_CONFIG_PATH
now works for both the cross and the native compilers, but I think this
should work well for most cases I can think of.
- I tried to fix the guile expression to cross-biuld; guile is built, but not
its manual, so the derivation still fails. Guile requires patching to
cross-build, as far as I understnad.
- Made the glibcCross build to be done through the usage of a
gcc-cross-wrapper over the gcc-cross-stage-static, instead of using it
directly.
- Trying to make physfs (a neverball dependency) cross build.
- Updated the gcc expression to support building a cross compiler without getting
derivation variables mixed with those of the stdenvCross.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18534
2009-11-22 19:51:45 +00:00
|
|
|
crossEnvHooks=()
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -f $NIX_GCC/nix-support/setup-hook ]; then
|
2006-08-07 14:31:18 +01:00
|
|
|
source $NIX_GCC/nix-support/setup-hook
|
|
|
|
fi
|
|
|
|
|
2007-11-17 14:34:27 +00:00
|
|
|
|
2007-05-24 16:29:32 +01:00
|
|
|
# Ensure that the given directories exists.
|
2006-08-07 14:31:18 +01:00
|
|
|
ensureDir() {
|
2007-05-24 16:29:32 +01:00
|
|
|
local dir
|
|
|
|
for dir in "$@"; do
|
2012-01-19 16:14:09 +00:00
|
|
|
if ! [ -x "$dir" ]; then mkdir -p "$dir"; fi
|
2007-05-24 16:29:32 +01:00
|
|
|
done
|
2006-08-07 14:31:18 +01:00
|
|
|
}
|
|
|
|
|
2007-11-17 14:34:27 +00:00
|
|
|
installBin() {
|
2012-01-18 20:16:00 +00:00
|
|
|
mkdir -p $out/bin
|
2009-04-18 23:22:51 +01:00
|
|
|
cp "$@" $out/bin
|
2007-11-17 14:34:27 +00:00
|
|
|
}
|
2006-08-07 14:31:18 +01:00
|
|
|
|
|
|
|
|
|
|
|
# Allow the caller to augment buildInputs (it's not always possible to
|
|
|
|
# do this before the call to setup.sh, since the PATH is empty at that
|
|
|
|
# point; here we have a basic Unix environment).
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook addInputsHook
|
2006-08-07 14:31:18 +01:00
|
|
|
|
|
|
|
|
|
|
|
# Recursively find all build inputs.
|
2008-04-23 08:19:48 +01:00
|
|
|
findInputs() {
|
2006-08-07 14:31:18 +01:00
|
|
|
local pkg=$1
|
2009-11-18 18:16:35 +00:00
|
|
|
local var=$2
|
Attention, people who care on the builders for native builds. In the stdenv
derivation, the "buildInputs" in every stdenv mkDerivation don't map now
directly to the environment
variable "buildInputs" in the builder, but "buildNativeInputs". So, the inputs
build by the native compiler.
When cross compiling, they will map to the environment variable "buildInputs"
(yes, now the same name), which means does to be built with the cross compiler.
I think I improved the naming of variables a bit. There was a big mess,
specially in the stdenv adapter for cross building, and also in the default
builder script.
I also tried to add proper manager of propagatedInputBuilds, these being
propagated considering the host or build origin of that input build (so, at the
end, being those propagatedInputBuilds being propagated properly to the native
or the cross compiler.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18477
2009-11-19 23:05:11 +00:00
|
|
|
local propagatedBuildInputsFile=$3
|
2006-08-07 14:31:18 +01:00
|
|
|
|
2009-11-18 18:16:35 +00:00
|
|
|
case ${!var} in
|
2006-08-07 14:31:18 +01:00
|
|
|
*\ $pkg\ *)
|
|
|
|
return 0
|
|
|
|
;;
|
|
|
|
esac
|
2007-11-17 14:34:27 +00:00
|
|
|
|
2009-11-18 19:25:57 +00:00
|
|
|
eval $var="'${!var} $pkg '"
|
2006-08-07 14:31:18 +01:00
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -f $pkg/nix-support/setup-hook ]; then
|
2006-08-07 14:31:18 +01:00
|
|
|
source $pkg/nix-support/setup-hook
|
|
|
|
fi
|
2007-11-17 14:34:27 +00:00
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -f $pkg/nix-support/$propagatedBuildInputsFile ]; then
|
Attention, people who care on the builders for native builds. In the stdenv
derivation, the "buildInputs" in every stdenv mkDerivation don't map now
directly to the environment
variable "buildInputs" in the builder, but "buildNativeInputs". So, the inputs
build by the native compiler.
When cross compiling, they will map to the environment variable "buildInputs"
(yes, now the same name), which means does to be built with the cross compiler.
I think I improved the naming of variables a bit. There was a big mess,
specially in the stdenv adapter for cross building, and also in the default
builder script.
I also tried to add proper manager of propagatedInputBuilds, these being
propagated considering the host or build origin of that input build (so, at the
end, being those propagatedInputBuilds being propagated properly to the native
or the cross compiler.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18477
2009-11-19 23:05:11 +00:00
|
|
|
for i in $(cat $pkg/nix-support/$propagatedBuildInputsFile); do
|
2009-11-23 19:45:18 +00:00
|
|
|
findInputs $i $var $propagatedBuildInputsFile
|
2006-08-07 14:31:18 +01:00
|
|
|
done
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
Attention, people who care on the builders for native builds. In the stdenv
derivation, the "buildInputs" in every stdenv mkDerivation don't map now
directly to the environment
variable "buildInputs" in the builder, but "buildNativeInputs". So, the inputs
build by the native compiler.
When cross compiling, they will map to the environment variable "buildInputs"
(yes, now the same name), which means does to be built with the cross compiler.
I think I improved the naming of variables a bit. There was a big mess,
specially in the stdenv adapter for cross building, and also in the default
builder script.
I also tried to add proper manager of propagatedInputBuilds, these being
propagated considering the host or build origin of that input build (so, at the
end, being those propagatedInputBuilds being propagated properly to the native
or the cross compiler.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18477
2009-11-19 23:05:11 +00:00
|
|
|
crossPkgs=""
|
2006-08-07 14:31:18 +01:00
|
|
|
for i in $buildInputs $propagatedBuildInputs; do
|
Attention, people who care on the builders for native builds. In the stdenv
derivation, the "buildInputs" in every stdenv mkDerivation don't map now
directly to the environment
variable "buildInputs" in the builder, but "buildNativeInputs". So, the inputs
build by the native compiler.
When cross compiling, they will map to the environment variable "buildInputs"
(yes, now the same name), which means does to be built with the cross compiler.
I think I improved the naming of variables a bit. There was a big mess,
specially in the stdenv adapter for cross building, and also in the default
builder script.
I also tried to add proper manager of propagatedInputBuilds, these being
propagated considering the host or build origin of that input build (so, at the
end, being those propagatedInputBuilds being propagated properly to the native
or the cross compiler.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18477
2009-11-19 23:05:11 +00:00
|
|
|
findInputs $i crossPkgs propagated-build-inputs
|
2006-08-07 14:31:18 +01:00
|
|
|
done
|
|
|
|
|
Attention, people who care on the builders for native builds. In the stdenv
derivation, the "buildInputs" in every stdenv mkDerivation don't map now
directly to the environment
variable "buildInputs" in the builder, but "buildNativeInputs". So, the inputs
build by the native compiler.
When cross compiling, they will map to the environment variable "buildInputs"
(yes, now the same name), which means does to be built with the cross compiler.
I think I improved the naming of variables a bit. There was a big mess,
specially in the stdenv adapter for cross building, and also in the default
builder script.
I also tried to add proper manager of propagatedInputBuilds, these being
propagated considering the host or build origin of that input build (so, at the
end, being those propagatedInputBuilds being propagated properly to the native
or the cross compiler.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18477
2009-11-19 23:05:11 +00:00
|
|
|
nativePkgs=""
|
|
|
|
for i in $buildNativeInputs $propagatedBuildNativeInputs; do
|
|
|
|
findInputs $i nativePkgs propagated-build-native-inputs
|
2009-11-18 18:16:35 +00:00
|
|
|
done
|
2006-08-07 14:31:18 +01:00
|
|
|
|
2012-01-19 15:56:17 +00:00
|
|
|
|
2006-08-07 14:31:18 +01:00
|
|
|
# Set the relevant environment variables to point to the build inputs
|
|
|
|
# found above.
|
Attention, people who care on the builders for native builds. In the stdenv
derivation, the "buildInputs" in every stdenv mkDerivation don't map now
directly to the environment
variable "buildInputs" in the builder, but "buildNativeInputs". So, the inputs
build by the native compiler.
When cross compiling, they will map to the environment variable "buildInputs"
(yes, now the same name), which means does to be built with the cross compiler.
I think I improved the naming of variables a bit. There was a big mess,
specially in the stdenv adapter for cross building, and also in the default
builder script.
I also tried to add proper manager of propagatedInputBuilds, these being
propagated considering the host or build origin of that input build (so, at the
end, being those propagatedInputBuilds being propagated properly to the native
or the cross compiler.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18477
2009-11-19 23:05:11 +00:00
|
|
|
addToNativeEnv() {
|
2006-08-07 14:31:18 +01:00
|
|
|
local pkg=$1
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -d $1/bin ]; then
|
2009-04-18 23:22:51 +01:00
|
|
|
addToSearchPath _PATH $1/bin
|
2006-08-07 14:31:18 +01:00
|
|
|
fi
|
|
|
|
|
2009-04-18 23:22:51 +01:00
|
|
|
# Run the package-specific hooks set by the setup-hook scripts.
|
2006-08-07 14:31:18 +01:00
|
|
|
for i in "${envHooks[@]}"; do
|
|
|
|
$i $pkg
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
Attention, people who care on the builders for native builds. In the stdenv
derivation, the "buildInputs" in every stdenv mkDerivation don't map now
directly to the environment
variable "buildInputs" in the builder, but "buildNativeInputs". So, the inputs
build by the native compiler.
When cross compiling, they will map to the environment variable "buildInputs"
(yes, now the same name), which means does to be built with the cross compiler.
I think I improved the naming of variables a bit. There was a big mess,
specially in the stdenv adapter for cross building, and also in the default
builder script.
I also tried to add proper manager of propagatedInputBuilds, these being
propagated considering the host or build origin of that input build (so, at the
end, being those propagatedInputBuilds being propagated properly to the native
or the cross compiler.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18477
2009-11-19 23:05:11 +00:00
|
|
|
for i in $nativePkgs; do
|
|
|
|
addToNativeEnv $i
|
2006-08-07 14:31:18 +01:00
|
|
|
done
|
|
|
|
|
Attention, people who care on the builders for native builds. In the stdenv
derivation, the "buildInputs" in every stdenv mkDerivation don't map now
directly to the environment
variable "buildInputs" in the builder, but "buildNativeInputs". So, the inputs
build by the native compiler.
When cross compiling, they will map to the environment variable "buildInputs"
(yes, now the same name), which means does to be built with the cross compiler.
I think I improved the naming of variables a bit. There was a big mess,
specially in the stdenv adapter for cross building, and also in the default
builder script.
I also tried to add proper manager of propagatedInputBuilds, these being
propagated considering the host or build origin of that input build (so, at the
end, being those propagatedInputBuilds being propagated properly to the native
or the cross compiler.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18477
2009-11-19 23:05:11 +00:00
|
|
|
addToCrossEnv() {
|
2009-11-18 18:16:35 +00:00
|
|
|
local pkg=$1
|
|
|
|
|
Big fixes in the cross build:
- Before this changes, cflags and ldflags for the native and the cross compiler
got mixed. Not all the gcc-wrapper/gcc-cross-wrapper variables are
independant now, but enough, I think.
- Fixed the generic stdenv expression, which did a big mess on buildInputs and
buildNativeInputs. Now it distinguishes when there is a stdenvCross or not.
Maybe we should have a single stdenv and forget about the stdenvCross
adapter - this could end in a stdenv a bit complex, but simpler than the
generic stdenv + adapter.
- Added basic support in pkgconfig for cross-builds: a single PKG_CONFIG_PATH
now works for both the cross and the native compilers, but I think this
should work well for most cases I can think of.
- I tried to fix the guile expression to cross-biuld; guile is built, but not
its manual, so the derivation still fails. Guile requires patching to
cross-build, as far as I understnad.
- Made the glibcCross build to be done through the usage of a
gcc-cross-wrapper over the gcc-cross-stage-static, instead of using it
directly.
- Trying to make physfs (a neverball dependency) cross build.
- Updated the gcc expression to support building a cross compiler without getting
derivation variables mixed with those of the stdenvCross.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18534
2009-11-22 19:51:45 +00:00
|
|
|
# Some programs put important build scripts (freetype-config and similar)
|
|
|
|
# into their hostDrv bin path. Intentionally these should go after
|
|
|
|
# the nativePkgs in PATH.
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -d $1/bin ]; then
|
Big fixes in the cross build:
- Before this changes, cflags and ldflags for the native and the cross compiler
got mixed. Not all the gcc-wrapper/gcc-cross-wrapper variables are
independant now, but enough, I think.
- Fixed the generic stdenv expression, which did a big mess on buildInputs and
buildNativeInputs. Now it distinguishes when there is a stdenvCross or not.
Maybe we should have a single stdenv and forget about the stdenvCross
adapter - this could end in a stdenv a bit complex, but simpler than the
generic stdenv + adapter.
- Added basic support in pkgconfig for cross-builds: a single PKG_CONFIG_PATH
now works for both the cross and the native compilers, but I think this
should work well for most cases I can think of.
- I tried to fix the guile expression to cross-biuld; guile is built, but not
its manual, so the derivation still fails. Guile requires patching to
cross-build, as far as I understnad.
- Made the glibcCross build to be done through the usage of a
gcc-cross-wrapper over the gcc-cross-stage-static, instead of using it
directly.
- Trying to make physfs (a neverball dependency) cross build.
- Updated the gcc expression to support building a cross compiler without getting
derivation variables mixed with those of the stdenvCross.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18534
2009-11-22 19:51:45 +00:00
|
|
|
addToSearchPath _PATH $1/bin
|
|
|
|
fi
|
|
|
|
|
2009-11-18 18:16:35 +00:00
|
|
|
# Run the package-specific hooks set by the setup-hook scripts.
|
Attention, people who care on the builders for native builds. In the stdenv
derivation, the "buildInputs" in every stdenv mkDerivation don't map now
directly to the environment
variable "buildInputs" in the builder, but "buildNativeInputs". So, the inputs
build by the native compiler.
When cross compiling, they will map to the environment variable "buildInputs"
(yes, now the same name), which means does to be built with the cross compiler.
I think I improved the naming of variables a bit. There was a big mess,
specially in the stdenv adapter for cross building, and also in the default
builder script.
I also tried to add proper manager of propagatedInputBuilds, these being
propagated considering the host or build origin of that input build (so, at the
end, being those propagatedInputBuilds being propagated properly to the native
or the cross compiler.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18477
2009-11-19 23:05:11 +00:00
|
|
|
for i in "${crossEnvHooks[@]}"; do
|
2009-11-18 18:16:35 +00:00
|
|
|
$i $pkg
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
Attention, people who care on the builders for native builds. In the stdenv
derivation, the "buildInputs" in every stdenv mkDerivation don't map now
directly to the environment
variable "buildInputs" in the builder, but "buildNativeInputs". So, the inputs
build by the native compiler.
When cross compiling, they will map to the environment variable "buildInputs"
(yes, now the same name), which means does to be built with the cross compiler.
I think I improved the naming of variables a bit. There was a big mess,
specially in the stdenv adapter for cross building, and also in the default
builder script.
I also tried to add proper manager of propagatedInputBuilds, these being
propagated considering the host or build origin of that input build (so, at the
end, being those propagatedInputBuilds being propagated properly to the native
or the cross compiler.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18477
2009-11-19 23:05:11 +00:00
|
|
|
for i in $crossPkgs; do
|
|
|
|
addToCrossEnv $i
|
2009-11-18 18:16:35 +00:00
|
|
|
done
|
|
|
|
|
2006-08-07 14:31:18 +01:00
|
|
|
|
|
|
|
# Add the output as an rpath.
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ "$NIX_NO_SELF_RPATH" != 1 ]; then
|
2006-08-07 14:31:18 +01:00
|
|
|
export NIX_LDFLAGS="-rpath $out/lib $NIX_LDFLAGS"
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$NIX_LIB64_IN_SELF_RPATH" ]; then
|
2009-03-25 17:34:38 +00:00
|
|
|
export NIX_LDFLAGS="-rpath $out/lib64 $NIX_LDFLAGS"
|
|
|
|
fi
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$NIX_LIB32_IN_SELF_RPATH" ]; then
|
2010-08-08 19:53:00 +01:00
|
|
|
export NIX_LDFLAGS="-rpath $out/lib32 $NIX_LDFLAGS"
|
|
|
|
fi
|
2006-08-07 14:31:18 +01:00
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
|
|
# Set the TZ (timezone) environment variable, otherwise commands like
|
|
|
|
# `date' will complain (e.g., `Tue Mar 9 10:01:47 Local time zone must
|
|
|
|
# be set--see zic manual page 2004').
|
|
|
|
export TZ=UTC
|
|
|
|
|
|
|
|
|
2006-12-28 21:12:44 +00:00
|
|
|
# Set the prefix. This is generally $out, but it can be overriden,
|
|
|
|
# for instance if we just want to perform a test build/install to a
|
|
|
|
# temporary location and write a build report to $out.
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$prefix" ]; then
|
2006-12-28 21:12:44 +00:00
|
|
|
prefix="$out";
|
|
|
|
fi
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ "$useTempPrefix" = 1 ]; then
|
2006-12-28 21:12:44 +00:00
|
|
|
prefix="$NIX_BUILD_TOP/tmp_prefix";
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
2006-08-07 14:31:18 +01:00
|
|
|
PATH=$_PATH${_PATH:+:}$PATH
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ "$NIX_DEBUG" = 1 ]; then
|
2008-02-20 23:02:41 +00:00
|
|
|
echo "final path: $PATH"
|
2006-08-07 14:31:18 +01:00
|
|
|
fi
|
|
|
|
|
|
|
|
|
2009-01-19 20:31:02 +00:00
|
|
|
# Make GNU Make produce nested output.
|
|
|
|
export NIX_INDENT_MAKE=1
|
|
|
|
|
|
|
|
|
2010-06-23 15:34:59 +01:00
|
|
|
# Normalize the NIX_BUILD_CORES variable. The value might be 0, which
|
|
|
|
# means that we're supposed to try and auto-detect the number of
|
|
|
|
# available CPU cores at run-time.
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "${NIX_BUILD_CORES:-}" ]; then
|
2010-06-23 15:34:59 +01:00
|
|
|
NIX_BUILD_CORES="1"
|
2012-01-19 16:14:09 +00:00
|
|
|
elif [ "$NIX_BUILD_CORES" -le 0 ]; then
|
2010-06-23 15:34:59 +01:00
|
|
|
NIX_BUILD_CORES=$(nproc 2>/dev/null || true)
|
|
|
|
if expr >/dev/null 2>&1 "$NIX_BUILD_CORES" : "^[0-9][0-9]*$"; then
|
|
|
|
:
|
|
|
|
else
|
|
|
|
NIX_BUILD_CORES="1"
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
export NIX_BUILD_CORES
|
|
|
|
|
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
######################################################################
|
|
|
|
# Misc. helper functions.
|
|
|
|
|
|
|
|
|
2007-11-17 14:34:27 +00:00
|
|
|
stripDirs() {
|
2007-11-17 14:34:49 +00:00
|
|
|
local dirs="$1"
|
|
|
|
local stripFlags="$2"
|
|
|
|
local dirsNew=
|
2007-11-17 14:34:27 +00:00
|
|
|
|
2007-11-17 14:34:49 +00:00
|
|
|
for d in ${dirs}; do
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -d "$prefix/$d" ]; then
|
2007-11-17 14:34:49 +00:00
|
|
|
dirsNew="${dirsNew} $prefix/$d "
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
dirs=${dirsNew}
|
2007-11-17 14:34:27 +00:00
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "${dirs}" ]; then
|
2008-03-20 10:54:58 +00:00
|
|
|
header "stripping (with flags $stripFlags) in $dirs"
|
2008-12-10 10:21:05 +00:00
|
|
|
find $dirs -type f -print0 | xargs -0 ${xargsFlags:--r} strip $stripFlags || true
|
2008-03-20 10:54:58 +00:00
|
|
|
stopNest
|
2007-11-17 14:34:49 +00:00
|
|
|
fi
|
2007-11-17 14:34:27 +00:00
|
|
|
}
|
2006-08-07 14:31:18 +01:00
|
|
|
|
2008-02-13 14:23:09 +00:00
|
|
|
|
2006-12-27 18:14:57 +00:00
|
|
|
######################################################################
|
|
|
|
# Textual substitution functions.
|
|
|
|
|
|
|
|
|
|
|
|
substitute() {
|
|
|
|
local input="$1"
|
|
|
|
local output="$2"
|
|
|
|
|
2006-12-28 11:15:12 +00:00
|
|
|
local -a params=("$@")
|
2006-12-27 18:14:57 +00:00
|
|
|
|
|
|
|
local n p pattern replacement varName
|
2007-11-17 14:34:27 +00:00
|
|
|
|
2012-01-19 13:47:26 +00:00
|
|
|
local content="$(cat $input)"
|
|
|
|
|
2006-12-27 18:14:57 +00:00
|
|
|
for ((n = 2; n < ${#params[*]}; n += 1)); do
|
|
|
|
p=${params[$n]}
|
|
|
|
|
2012-01-19 13:47:26 +00:00
|
|
|
if [ "$p" = --replace ]; then
|
2007-11-17 14:34:27 +00:00
|
|
|
pattern="${params[$((n + 1))]}"
|
|
|
|
replacement="${params[$((n + 2))]}"
|
2006-12-27 18:14:57 +00:00
|
|
|
n=$((n + 2))
|
|
|
|
fi
|
|
|
|
|
2012-01-19 13:47:26 +00:00
|
|
|
if [ "$p" = --subst-var ]; then
|
2007-11-17 14:34:27 +00:00
|
|
|
varName="${params[$((n + 1))]}"
|
|
|
|
pattern="@$varName@"
|
|
|
|
replacement="${!varName}"
|
2006-12-27 18:14:57 +00:00
|
|
|
n=$((n + 1))
|
|
|
|
fi
|
|
|
|
|
2012-01-19 13:47:26 +00:00
|
|
|
if [ "$p" = --subst-var-by ]; then
|
2007-11-17 14:34:27 +00:00
|
|
|
pattern="@${params[$((n + 1))]}@"
|
|
|
|
replacement="${params[$((n + 2))]}"
|
2006-12-27 18:14:57 +00:00
|
|
|
n=$((n + 2))
|
|
|
|
fi
|
|
|
|
|
2012-01-19 13:47:26 +00:00
|
|
|
content="${content//"$pattern"/$replacement}"
|
2006-12-27 18:14:57 +00:00
|
|
|
done
|
|
|
|
|
2012-01-19 13:47:26 +00:00
|
|
|
# !!! This doesn't work properly if $content is "-n".
|
|
|
|
echo -n "$content" > "$output".tmp
|
|
|
|
if [ -x "$output" ]; then chmod +x "$output".tmp; fi
|
2006-12-27 18:14:57 +00:00
|
|
|
mv -f "$output".tmp "$output"
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
substituteInPlace() {
|
|
|
|
local fileName="$1"
|
|
|
|
shift
|
|
|
|
substitute "$fileName" "$fileName" "$@"
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
substituteAll() {
|
|
|
|
local input="$1"
|
|
|
|
local output="$2"
|
2007-11-17 14:34:27 +00:00
|
|
|
|
2006-12-27 18:14:57 +00:00
|
|
|
# Select all environment variables that start with a lowercase character.
|
|
|
|
for envVar in $(env | sed "s/^[^a-z].*//" | sed "s/^\([^=]*\)=.*/\1/"); do
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ "$NIX_DEBUG" = "1" ]; then
|
2006-12-27 18:14:57 +00:00
|
|
|
echo "$envVar -> ${!envVar}"
|
|
|
|
fi
|
|
|
|
args="$args --subst-var $envVar"
|
|
|
|
done
|
|
|
|
|
|
|
|
substitute "$input" "$output" $args
|
2007-11-17 14:34:27 +00:00
|
|
|
}
|
2006-12-27 18:14:57 +00:00
|
|
|
|
|
|
|
|
2011-07-28 21:28:37 +01:00
|
|
|
substituteAllInPlace() {
|
|
|
|
local fileName="$1"
|
|
|
|
shift
|
|
|
|
substituteAll "$fileName" "$fileName" "$@"
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-08-07 14:31:18 +01:00
|
|
|
######################################################################
|
|
|
|
# What follows is the generic builder.
|
|
|
|
|
|
|
|
|
|
|
|
nestingLevel=0
|
|
|
|
|
|
|
|
startNest() {
|
|
|
|
nestingLevel=$(($nestingLevel + 1))
|
2012-01-19 10:24:26 +00:00
|
|
|
echo -en "\033[$1p"
|
2006-08-07 14:31:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
stopNest() {
|
|
|
|
nestingLevel=$(($nestingLevel - 1))
|
2012-01-19 10:24:26 +00:00
|
|
|
echo -en "\033[q"
|
2006-08-07 14:31:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
header() {
|
|
|
|
startNest "$2"
|
|
|
|
echo "$1"
|
|
|
|
}
|
|
|
|
|
|
|
|
# Make sure that even when we exit abnormally, the original nesting
|
|
|
|
# level is properly restored.
|
|
|
|
closeNest() {
|
2012-01-19 16:14:09 +00:00
|
|
|
while [ $nestingLevel -gt 0 ]; do
|
2006-08-07 14:31:18 +01:00
|
|
|
stopNest
|
|
|
|
done
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
# This function is useful for debugging broken Nix builds. It dumps
|
|
|
|
# all environment variables to a file `env-vars' in the build
|
|
|
|
# directory. If the build fails and the `-K' option is used, you can
|
|
|
|
# then go to the build directory and source in `env-vars' to reproduce
|
|
|
|
# the environment used for building.
|
|
|
|
dumpVars() {
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ "$noDumpEnvVars" != 1 ]; then
|
2009-07-02 10:01:37 +01:00
|
|
|
export > "$NIX_BUILD_TOP/env-vars"
|
2006-08-07 14:31:18 +01:00
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
# Utility function: return the base name of the given path, with the
|
|
|
|
# prefix `HASH-' removed, if present.
|
|
|
|
stripHash() {
|
|
|
|
strippedName=$(basename $1);
|
|
|
|
if echo "$strippedName" | grep -q '^[a-z0-9]\{32\}-'; then
|
|
|
|
strippedName=$(echo "$strippedName" | cut -c34-)
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
unpackFile() {
|
2008-10-07 18:33:20 +01:00
|
|
|
curSrc="$1"
|
2006-08-07 14:31:18 +01:00
|
|
|
local cmd
|
|
|
|
|
2008-10-07 18:33:20 +01:00
|
|
|
header "unpacking source archive $curSrc" 3
|
2006-08-07 14:31:18 +01:00
|
|
|
|
2008-10-07 18:33:20 +01:00
|
|
|
case "$curSrc" in
|
2012-01-19 17:33:33 +00:00
|
|
|
*.tar.xz | *.tar.lzma)
|
|
|
|
# Don't rely on tar knowing about .xz.
|
2012-04-04 20:45:01 +01:00
|
|
|
xz -d < $curSrc | tar xf -
|
2012-01-19 17:33:33 +00:00
|
|
|
;;
|
2009-11-20 17:10:00 +00:00
|
|
|
*.tar | *.tar.* | *.tgz | *.tbz2)
|
2011-10-27 17:32:46 +01:00
|
|
|
# GNU tar can automatically select the decompression method
|
|
|
|
# (info "(tar) gzip").
|
2012-04-04 17:25:17 +01:00
|
|
|
tar xf $curSrc
|
2006-08-07 14:31:18 +01:00
|
|
|
;;
|
|
|
|
*.zip)
|
2012-04-04 17:25:17 +01:00
|
|
|
unzip -qq $curSrc
|
2006-08-07 14:31:18 +01:00
|
|
|
;;
|
|
|
|
*)
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -d "$curSrc" ]; then
|
2008-10-07 18:33:20 +01:00
|
|
|
stripHash $curSrc
|
|
|
|
cp -prvd $curSrc $strippedName
|
2006-08-07 14:31:18 +01:00
|
|
|
else
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$unpackCmd" ]; then
|
2008-10-07 18:33:20 +01:00
|
|
|
echo "source archive $curSrc has unknown type"
|
2006-08-07 14:31:18 +01:00
|
|
|
exit 1
|
|
|
|
fi
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook unpackCmd
|
2006-08-07 14:31:18 +01:00
|
|
|
fi
|
|
|
|
;;
|
|
|
|
esac
|
|
|
|
|
|
|
|
stopNest
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
unpackPhase() {
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook preUnpack
|
2008-03-18 11:03:35 +00:00
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$srcs" ]; then
|
|
|
|
if [ -z "$src" ]; then
|
2006-08-07 14:31:18 +01:00
|
|
|
echo 'variable $src or $srcs should point to the source'
|
|
|
|
exit 1
|
|
|
|
fi
|
|
|
|
srcs="$src"
|
|
|
|
fi
|
|
|
|
|
|
|
|
# To determine the source directory created by unpacking the
|
|
|
|
# source archives, we record the contents of the current
|
|
|
|
# directory, then look below which directory got added. Yeah,
|
|
|
|
# it's rather hacky.
|
|
|
|
local dirsBefore=""
|
|
|
|
for i in *; do
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -d "$i" ]; then
|
2006-08-07 14:31:18 +01:00
|
|
|
dirsBefore="$dirsBefore $i "
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
|
|
|
|
# Unpack all source archives.
|
|
|
|
for i in $srcs; do
|
|
|
|
unpackFile $i
|
|
|
|
done
|
|
|
|
|
|
|
|
# Find the source directory.
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$setSourceRoot" ]; then
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook setSourceRoot
|
2012-01-19 16:14:09 +00:00
|
|
|
elif [ -z "$sourceRoot" ]; then
|
2006-08-07 14:31:18 +01:00
|
|
|
sourceRoot=
|
|
|
|
for i in *; do
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -d "$i" ]; then
|
2006-08-07 14:31:18 +01:00
|
|
|
case $dirsBefore in
|
|
|
|
*\ $i\ *)
|
|
|
|
;;
|
|
|
|
*)
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$sourceRoot" ]; then
|
2006-08-07 14:31:18 +01:00
|
|
|
echo "unpacker produced multiple directories"
|
|
|
|
exit 1
|
|
|
|
fi
|
2008-11-14 10:22:15 +00:00
|
|
|
sourceRoot="$i"
|
2006-08-07 14:31:18 +01:00
|
|
|
;;
|
|
|
|
esac
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
fi
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$sourceRoot" ]; then
|
2006-08-07 14:31:18 +01:00
|
|
|
echo "unpacker appears to have produced no directories"
|
|
|
|
exit 1
|
|
|
|
fi
|
|
|
|
|
|
|
|
echo "source root is $sourceRoot"
|
|
|
|
|
|
|
|
# By default, add write permission to the sources. This is often
|
|
|
|
# necessary when sources have been copied from other store
|
|
|
|
# locations.
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ "$dontMakeSourcesWritable" != 1 ]; then
|
2008-11-14 10:22:15 +00:00
|
|
|
chmod -R u+w "$sourceRoot"
|
2006-08-07 14:31:18 +01:00
|
|
|
fi
|
* Hook variables in the generic builder are now executed using eval.
This has a major advantage: you can write hooks directly in Nix
expressions. For instance, rather than write a builder like this:
source $stdenv/setup
postInstall=postInstall
postInstall() {
ln -sf gzip $out/bin/gunzip
ln -sf gzip $out/bin/zcat
}
genericBuild
(the gzip builder), you can just add this attribute to the
derivation:
postInstall = "ln -sf gzip $out/bin/gunzip; ln -sf gzip $out/bin/zcat";
and so a separate build script becomes unnecessary. This should
allow us to get rid of most builders in Nixpkgs.
* Allow configure and make arguments to contain whitespace.
Previously, you could say, for instance
configureFlags="CFLAGS=-O0"
but not
configureFlags="CFLAGS=-O0 -g"
since the `-g' would be interpreted as a separate argument to
configure. Now you can say
configureFlagsArray=("CFLAGS=-O0 -g")
or similarly
configureFlagsArray=("CFLAGS=-O0 -g" "LDFLAGS=-L/foo -L/bar")
which does the right thing. Idem for makeFlags, installFlags,
checkFlags and distFlags.
Unfortunately you can't pass arrays to Bash through the environment,
so you can't put the array above in a Nix expression, e.g.,
configureFlagsArray = ["CFLAGS=-O0 -g"];
since it would just be flattened to a since string. However, you
can use the inline hooks described above:
preConfigure = "configureFlagsArray=(\"CFLAGS=-O0 -g\")";
svn path=/nixpkgs/trunk/; revision=6863
2006-10-26 23:20:25 +01:00
|
|
|
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook postUnpack
|
2006-08-07 14:31:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
patchPhase() {
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook prePatch
|
2008-03-18 11:03:35 +00:00
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$patchPhase" -a -z "$patches" ]; then return; fi
|
2008-02-20 23:02:41 +00:00
|
|
|
|
2006-08-07 14:31:18 +01:00
|
|
|
for i in $patches; do
|
|
|
|
header "applying patch $i" 3
|
2006-12-27 18:14:57 +00:00
|
|
|
local uncompress=cat
|
|
|
|
case $i in
|
|
|
|
*.gz)
|
2007-12-03 17:55:41 +00:00
|
|
|
uncompress="gzip -d"
|
2006-12-27 18:14:57 +00:00
|
|
|
;;
|
|
|
|
*.bz2)
|
2007-12-03 17:55:41 +00:00
|
|
|
uncompress="bzip2 -d"
|
2006-12-27 18:14:57 +00:00
|
|
|
;;
|
2009-12-18 11:26:36 +00:00
|
|
|
*.lzma)
|
|
|
|
uncompress="lzma -d"
|
|
|
|
;;
|
2006-12-27 18:14:57 +00:00
|
|
|
esac
|
2008-10-07 18:33:20 +01:00
|
|
|
$uncompress < $i | patch ${patchFlags:--p1}
|
2006-08-07 14:31:18 +01:00
|
|
|
stopNest
|
|
|
|
done
|
2008-03-18 11:03:35 +00:00
|
|
|
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook postPatch
|
2006-08-07 14:31:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
fixLibtool() {
|
2008-06-11 15:08:01 +01:00
|
|
|
sed -i -e 's^eval sys_lib_.*search_path=.*^^' "$1"
|
2006-08-07 14:31:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
configurePhase() {
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook preConfigure
|
2006-08-07 14:31:18 +01:00
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$configureScript" ]; then
|
2006-08-07 14:31:18 +01:00
|
|
|
configureScript=./configure
|
2012-01-19 16:14:09 +00:00
|
|
|
if ! [ -x $configureScript ]; then
|
2006-08-07 14:31:18 +01:00
|
|
|
echo "no configure script, doing nothing"
|
|
|
|
return
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$dontFixLibtool" ]; then
|
2006-08-07 14:31:18 +01:00
|
|
|
for i in $(find . -name "ltmain.sh"); do
|
|
|
|
echo "fixing libtool script $i"
|
|
|
|
fixLibtool $i
|
|
|
|
done
|
|
|
|
fi
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$dontAddPrefix" ]; then
|
2007-11-17 14:34:27 +00:00
|
|
|
configureFlags="${prefixKey:---prefix=}$prefix $configureFlags"
|
2006-08-07 14:31:18 +01:00
|
|
|
fi
|
|
|
|
|
2008-02-13 18:27:19 +00:00
|
|
|
# Add --disable-dependency-tracking to speed up some builds.
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$dontAddDisableDepTrack" ]; then
|
2008-02-13 18:27:19 +00:00
|
|
|
if grep -q dependency-tracking $configureScript; then
|
2008-03-18 10:26:43 +00:00
|
|
|
configureFlags="--disable-dependency-tracking $configureFlags"
|
2008-02-13 18:27:19 +00:00
|
|
|
fi
|
2006-08-07 14:31:18 +01:00
|
|
|
fi
|
|
|
|
|
2009-04-21 23:40:12 +01:00
|
|
|
# By default, disable static builds.
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$dontDisableStatic" ]; then
|
2009-04-21 23:40:12 +01:00
|
|
|
if grep -q enable-static $configureScript; then
|
|
|
|
configureFlags="--disable-static $configureFlags"
|
|
|
|
fi
|
|
|
|
fi
|
|
|
|
|
* Hook variables in the generic builder are now executed using eval.
This has a major advantage: you can write hooks directly in Nix
expressions. For instance, rather than write a builder like this:
source $stdenv/setup
postInstall=postInstall
postInstall() {
ln -sf gzip $out/bin/gunzip
ln -sf gzip $out/bin/zcat
}
genericBuild
(the gzip builder), you can just add this attribute to the
derivation:
postInstall = "ln -sf gzip $out/bin/gunzip; ln -sf gzip $out/bin/zcat";
and so a separate build script becomes unnecessary. This should
allow us to get rid of most builders in Nixpkgs.
* Allow configure and make arguments to contain whitespace.
Previously, you could say, for instance
configureFlags="CFLAGS=-O0"
but not
configureFlags="CFLAGS=-O0 -g"
since the `-g' would be interpreted as a separate argument to
configure. Now you can say
configureFlagsArray=("CFLAGS=-O0 -g")
or similarly
configureFlagsArray=("CFLAGS=-O0 -g" "LDFLAGS=-L/foo -L/bar")
which does the right thing. Idem for makeFlags, installFlags,
checkFlags and distFlags.
Unfortunately you can't pass arrays to Bash through the environment,
so you can't put the array above in a Nix expression, e.g.,
configureFlagsArray = ["CFLAGS=-O0 -g"];
since it would just be flattened to a since string. However, you
can use the inline hooks described above:
preConfigure = "configureFlagsArray=(\"CFLAGS=-O0 -g\")";
svn path=/nixpkgs/trunk/; revision=6863
2006-10-26 23:20:25 +01:00
|
|
|
echo "configure flags: $configureFlags ${configureFlagsArray[@]}"
|
2008-10-30 15:54:29 +00:00
|
|
|
$configureScript $configureFlags "${configureFlagsArray[@]}"
|
2006-08-07 14:31:18 +01:00
|
|
|
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook postConfigure
|
2006-08-07 14:31:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
buildPhase() {
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook preBuild
|
2007-11-17 14:34:27 +00:00
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$makeFlags" ] && ! [ -n "$makefile" -o -e "Makefile" -o -e "makefile" -o -e "GNUmakefile" ]; then
|
2008-02-20 23:02:41 +00:00
|
|
|
echo "no Makefile, doing nothing"
|
|
|
|
return
|
|
|
|
fi
|
|
|
|
|
2010-06-19 16:52:28 +01:00
|
|
|
echo "make flags: $makeFlags ${makeFlagsArray[@]} $buildFlags ${buildFlagsArray[@]}"
|
|
|
|
make ${makefile:+-f $makefile} \
|
2010-06-23 15:34:59 +01:00
|
|
|
${enableParallelBuilding:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}} \
|
2010-06-19 16:52:28 +01:00
|
|
|
$makeFlags "${makeFlagsArray[@]}" \
|
2008-04-23 08:19:48 +01:00
|
|
|
$buildFlags "${buildFlagsArray[@]}"
|
2006-08-07 14:31:18 +01:00
|
|
|
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook postBuild
|
2006-08-07 14:31:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
checkPhase() {
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook preCheck
|
2008-03-18 11:03:35 +00:00
|
|
|
|
2010-06-19 16:52:28 +01:00
|
|
|
echo "check flags: $makeFlags ${makeFlagsArray[@]} $checkFlags ${checkFlagsArray[@]}"
|
|
|
|
make ${makefile:+-f $makefile} \
|
2010-06-23 15:34:59 +01:00
|
|
|
${enableParallelBuilding:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}} \
|
2010-06-19 16:52:28 +01:00
|
|
|
$makeFlags "${makeFlagsArray[@]}" \
|
2008-10-07 18:33:20 +01:00
|
|
|
$checkFlags "${checkFlagsArray[@]}" ${checkTarget:-check}
|
2008-03-18 11:03:35 +00:00
|
|
|
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook postCheck
|
2006-08-07 14:31:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
patchELF() {
|
|
|
|
# Patch all ELF executables and shared libraries.
|
|
|
|
header "patching ELF executables and libraries"
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -e "$prefix" ]; then
|
2008-03-18 10:28:17 +00:00
|
|
|
find "$prefix" \( \
|
|
|
|
\( -type f -a -name "*.so*" \) -o \
|
|
|
|
\( -type f -a -perm +0100 \) \
|
|
|
|
\) -print -exec patchelf --shrink-rpath {} \;
|
|
|
|
fi
|
2006-08-07 14:31:18 +01:00
|
|
|
stopNest
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-06-11 12:22:54 +01:00
|
|
|
patchShebangs() {
|
|
|
|
# Rewrite all script interpreter file names (`#! /path') under the
|
|
|
|
# specified directory tree to paths found in $PATH. E.g.,
|
|
|
|
# /bin/sh will be rewritten to /nix/store/<hash>-some-bash/bin/sh.
|
|
|
|
# Interpreters that are already in the store are left untouched.
|
|
|
|
header "patching script interpreter paths"
|
|
|
|
local dir="$1"
|
|
|
|
local f
|
|
|
|
for f in $(find "$dir" -type f -perm +0100); do
|
|
|
|
local oldPath=$(sed -ne '1 s,^#![ ]*\([^ ]*\).*$,\1,p' "$f")
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$oldPath" -a "${oldPath:0:${#NIX_STORE}}" != "$NIX_STORE" ]; then
|
2008-06-11 12:22:54 +01:00
|
|
|
local newPath=$(type -P $(basename $oldPath) || true)
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$newPath" -a "$newPath" != "$oldPath" ]; then
|
2008-06-11 12:22:54 +01:00
|
|
|
echo "$f: interpreter changed from $oldPath to $newPath"
|
2008-06-11 15:08:01 +01:00
|
|
|
sed -i -e "1 s,$oldPath,$newPath," "$f"
|
2008-06-11 12:22:54 +01:00
|
|
|
fi
|
|
|
|
fi
|
|
|
|
done
|
|
|
|
stopNest
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
installPhase() {
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook preInstall
|
2006-08-07 14:31:18 +01:00
|
|
|
|
2012-01-18 20:16:00 +00:00
|
|
|
mkdir -p "$prefix"
|
2006-12-27 18:14:57 +00:00
|
|
|
|
2008-10-07 18:33:20 +01:00
|
|
|
installTargets=${installTargets:-install}
|
2010-06-19 16:52:28 +01:00
|
|
|
echo "install flags: $installTargets $makeFlags ${makeFlagsArray[@]} $installFlags ${installFlagsArray[@]}"
|
|
|
|
make ${makefile:+-f $makefile} $installTargets \
|
2008-10-07 18:33:20 +01:00
|
|
|
$makeFlags "${makeFlagsArray[@]}" \
|
|
|
|
$installFlags "${installFlagsArray[@]}"
|
2006-08-07 14:31:18 +01:00
|
|
|
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook postInstall
|
2006-12-27 18:14:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
# The fixup phase performs generic, package-independent, Nix-related
|
|
|
|
# stuff, like running patchelf and setting the
|
|
|
|
# propagated-build-inputs. It should rarely be overriden.
|
2008-02-20 23:02:41 +00:00
|
|
|
fixupPhase() {
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook preFixup
|
2006-12-27 18:14:57 +00:00
|
|
|
|
2008-02-13 14:23:09 +00:00
|
|
|
# Put man/doc/info under $out/share.
|
|
|
|
forceShare=${forceShare:=man doc info}
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$forceShare" ]; then
|
2008-02-13 14:23:09 +00:00
|
|
|
for d in $forceShare; do
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -d "$prefix/$d" ]; then
|
|
|
|
if [ -d "$prefix/share/$d" ]; then
|
2008-02-20 23:02:41 +00:00
|
|
|
echo "both $d/ and share/$d/ exists!"
|
2008-02-13 14:23:09 +00:00
|
|
|
else
|
2008-02-20 23:02:41 +00:00
|
|
|
echo "fixing location of $d/ subdirectory"
|
2012-01-18 20:16:00 +00:00
|
|
|
mkdir -p $prefix/share
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -w $prefix/share ]; then
|
2008-02-13 14:23:09 +00:00
|
|
|
mv -v $prefix/$d $prefix/share
|
|
|
|
ln -sv share/$d $prefix
|
2007-11-17 14:34:49 +00:00
|
|
|
fi
|
2008-02-13 14:23:09 +00:00
|
|
|
fi
|
|
|
|
fi
|
|
|
|
done;
|
|
|
|
fi
|
2007-11-17 14:34:27 +00:00
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$dontGzipMan" ]; then
|
2011-03-09 22:17:18 +00:00
|
|
|
GLOBIGNORE=.:..:*.gz:*.bz2
|
|
|
|
for f in $out/share/man/*/* $out/share/man/*/*/*; do
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -f $f ]; then
|
2011-03-09 22:17:18 +00:00
|
|
|
if gzip -c $f > $f.gz; then
|
|
|
|
rm $f
|
|
|
|
else
|
|
|
|
rm $f.gz
|
|
|
|
fi
|
|
|
|
fi
|
2011-03-09 20:10:47 +00:00
|
|
|
done
|
2011-03-09 22:17:18 +00:00
|
|
|
unset GLOBIGNORE
|
2011-03-09 20:10:47 +00:00
|
|
|
fi
|
|
|
|
|
2008-02-13 14:23:09 +00:00
|
|
|
# TODO: strip _only_ ELF executables, and return || fail here...
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$dontStrip" ]; then
|
2009-03-25 17:34:38 +00:00
|
|
|
stripDebugList=${stripDebugList:-lib lib64 libexec bin sbin}
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$stripDebugList" ]; then
|
2008-02-21 16:20:51 +00:00
|
|
|
stripDirs "$stripDebugList" "${stripDebugFlags:--S}"
|
|
|
|
fi
|
|
|
|
|
|
|
|
stripAllList=${stripAllList:-}
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$stripAllList" ]; then
|
2008-02-21 16:20:51 +00:00
|
|
|
stripDirs "$stripAllList" "${stripAllFlags:--s}"
|
|
|
|
fi
|
2006-08-07 14:31:18 +01:00
|
|
|
fi
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ "$havePatchELF" = 1 -a -z "$dontPatchELF" ]; then
|
2006-08-07 14:31:18 +01:00
|
|
|
patchELF "$prefix"
|
|
|
|
fi
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$dontPatchShebangs" ]; then
|
2008-06-11 12:22:54 +01:00
|
|
|
patchShebangs "$prefix"
|
|
|
|
fi
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$propagatedBuildInputs" ]; then
|
2012-01-18 20:16:00 +00:00
|
|
|
mkdir -p "$out/nix-support"
|
2006-08-07 14:31:18 +01:00
|
|
|
echo "$propagatedBuildInputs" > "$out/nix-support/propagated-build-inputs"
|
|
|
|
fi
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$propagatedBuildNativeInputs" ]; then
|
2012-01-18 20:16:00 +00:00
|
|
|
mkdir -p "$out/nix-support"
|
Attention, people who care on the builders for native builds. In the stdenv
derivation, the "buildInputs" in every stdenv mkDerivation don't map now
directly to the environment
variable "buildInputs" in the builder, but "buildNativeInputs". So, the inputs
build by the native compiler.
When cross compiling, they will map to the environment variable "buildInputs"
(yes, now the same name), which means does to be built with the cross compiler.
I think I improved the naming of variables a bit. There was a big mess,
specially in the stdenv adapter for cross building, and also in the default
builder script.
I also tried to add proper manager of propagatedInputBuilds, these being
propagated considering the host or build origin of that input build (so, at the
end, being those propagatedInputBuilds being propagated properly to the native
or the cross compiler.
svn path=/nixpkgs/branches/stdenv-updates/; revision=18477
2009-11-19 23:05:11 +00:00
|
|
|
echo "$propagatedBuildNativeInputs" > "$out/nix-support/propagated-build-native-inputs"
|
|
|
|
fi
|
|
|
|
|
2012-02-17 21:37:15 +00:00
|
|
|
if [ -n "$propagatedUserEnvPkgs" ]; then
|
|
|
|
mkdir -p "$out/nix-support"
|
|
|
|
echo "$propagatedUserEnvPkgs" > "$out/nix-support/propagated-user-env-packages"
|
|
|
|
fi
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$setupHook" ]; then
|
2012-01-18 20:16:00 +00:00
|
|
|
mkdir -p "$out/nix-support"
|
2007-11-17 14:34:49 +00:00
|
|
|
substituteAll "$setupHook" "$out/nix-support/setup-hook"
|
2006-08-07 14:31:18 +01:00
|
|
|
fi
|
2007-11-17 14:34:27 +00:00
|
|
|
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook postFixup
|
2006-08-07 14:31:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-05-01 22:00:30 +01:00
|
|
|
installCheckPhase() {
|
|
|
|
runHook preInstallCheck
|
|
|
|
|
|
|
|
echo "installcheck flags: $makeFlags ${makeFlagsArray[@]} $installCheckFlags ${installCheckFlagsArray[@]}"
|
|
|
|
make ${makefile:+-f $makefile} \
|
|
|
|
${enableParallelBuilding:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}} \
|
|
|
|
$makeFlags "${makeFlagsArray[@]}" \
|
|
|
|
$installCheckFlags "${installCheckFlagsArray[@]}" ${installCheckTarget:-installcheck}
|
|
|
|
|
|
|
|
runHook postInstallCheck
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
distPhase() {
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook preDist
|
2007-11-17 14:34:27 +00:00
|
|
|
|
2010-06-19 16:52:28 +01:00
|
|
|
echo "dist flags: $distFlags ${distFlagsArray[@]}"
|
|
|
|
make ${makefile:+-f $makefile} $distFlags "${distFlagsArray[@]}" ${distTarget:-dist}
|
2006-08-07 14:31:18 +01:00
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ "$dontCopyDist" != 1 ]; then
|
2012-01-18 20:16:00 +00:00
|
|
|
mkdir -p "$out/tarballs"
|
2006-08-07 14:31:18 +01:00
|
|
|
|
|
|
|
# Note: don't quote $tarballs, since we explicitly permit
|
|
|
|
# wildcards in there.
|
2008-10-07 18:33:20 +01:00
|
|
|
cp -pvd ${tarballs:-*.tar.gz} $out/tarballs
|
2006-08-07 14:31:18 +01:00
|
|
|
fi
|
|
|
|
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook postDist
|
2006-08-07 14:31:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
showPhaseHeader() {
|
|
|
|
local phase="$1"
|
|
|
|
case $phase in
|
|
|
|
unpackPhase) header "unpacking sources";;
|
|
|
|
patchPhase) header "patching sources";;
|
|
|
|
configurePhase) header "configuring";;
|
|
|
|
buildPhase) header "building";;
|
|
|
|
checkPhase) header "running tests";;
|
|
|
|
installPhase) header "installing";;
|
|
|
|
fixupPhase) header "post-installation fixup";;
|
2012-05-01 22:00:30 +01:00
|
|
|
installCheckPhase) header "running install tests";;
|
2008-02-20 23:02:41 +00:00
|
|
|
*) header "$phase";;
|
|
|
|
esac
|
2006-08-07 14:31:18 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
genericBuild() {
|
|
|
|
header "building $out"
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -n "$buildCommand" ]; then
|
2006-12-27 18:14:57 +00:00
|
|
|
eval "$buildCommand"
|
|
|
|
return
|
|
|
|
fi
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ -z "$phases" ]; then
|
2008-03-20 10:59:47 +00:00
|
|
|
phases="$prePhases unpackPhase patchPhase $preConfigurePhases \
|
|
|
|
configurePhase $preBuildPhases buildPhase checkPhase \
|
2012-05-01 22:00:30 +01:00
|
|
|
$preInstallPhases installPhase fixupPhase installCheckPhase \
|
2008-03-20 10:59:47 +00:00
|
|
|
$preDistPhases distPhase $postPhases";
|
2008-02-20 23:02:41 +00:00
|
|
|
fi
|
|
|
|
|
|
|
|
for curPhase in $phases; do
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ "$curPhase" = buildPhase -a -n "$dontBuild" ]; then continue; fi
|
|
|
|
if [ "$curPhase" = checkPhase -a -z "$doCheck" ]; then continue; fi
|
|
|
|
if [ "$curPhase" = installPhase -a -n "$dontInstall" ]; then continue; fi
|
|
|
|
if [ "$curPhase" = fixupPhase -a -n "$dontFixup" ]; then continue; fi
|
2012-05-01 22:00:30 +01:00
|
|
|
if [ "$curPhase" = installCheckPhase -a -z "$doInstallCheck" ]; then continue; fi
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ "$curPhase" = distPhase -a -z "$doDist" ]; then continue; fi
|
2011-10-27 17:32:46 +01:00
|
|
|
|
|
|
|
if [ -n "$tracePhases" ]; then
|
|
|
|
echo
|
|
|
|
echo "@ phase-started $out $curPhase"
|
|
|
|
fi
|
2011-02-25 15:28:11 +00:00
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
showPhaseHeader "$curPhase"
|
2006-08-07 14:31:18 +01:00
|
|
|
dumpVars
|
2008-02-20 23:02:41 +00:00
|
|
|
|
|
|
|
# Evaluate the variable named $curPhase if it exists, otherwise the
|
|
|
|
# function named $curPhase.
|
|
|
|
eval "${!curPhase:-$curPhase}"
|
|
|
|
|
2012-01-19 16:14:09 +00:00
|
|
|
if [ "$curPhase" = unpackPhase ]; then
|
2008-02-20 23:02:41 +00:00
|
|
|
cd "${sourceRoot:-.}"
|
|
|
|
fi
|
|
|
|
|
2011-10-27 17:32:46 +01:00
|
|
|
if [ -n "$tracePhases" ]; then
|
|
|
|
echo
|
|
|
|
echo "@ phase-succeeded $out $curPhase"
|
|
|
|
fi
|
2011-02-25 15:28:11 +00:00
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
stopNest
|
2006-08-07 14:31:18 +01:00
|
|
|
done
|
2007-11-17 14:34:27 +00:00
|
|
|
|
2006-08-07 14:31:18 +01:00
|
|
|
stopNest
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-20 23:02:41 +00:00
|
|
|
# Execute the post-hook.
|
2009-02-01 21:28:02 +00:00
|
|
|
runHook postHook
|
2008-02-20 23:02:41 +00:00
|
|
|
|
|
|
|
|
2006-08-07 14:31:18 +01:00
|
|
|
dumpVars
|