This means that (on Linux) strip uses "--enable-deterministic-archives" and ld uses the BFD_DETERMINISTIC_OUTPUT flag.wip/yesman
Eelco Dolstra
11 years ago
parent
fa15851318
commit
320209a618
@ -1,876 +0,0 @@ |
||||
# 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" |
||||
case "$(type -t $hookName)" in |
||||
(function|alias|builtin) $hookName;; |
||||
(file) source $hookName;; |
||||
(keyword) :;; |
||||
(*) eval "${!hookName}";; |
||||
esac |
||||
} |
||||
|
||||
|
||||
exitHandler() { |
||||
exitCode=$? |
||||
set +e |
||||
|
||||
closeNest |
||||
|
||||
if [ -n "$showBuildStats" ]; then |
||||
times > "$NIX_BUILD_TOP/.times" |
||||
local -a times=($(cat "$NIX_BUILD_TOP/.times")) |
||||
# 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 |
||||
|
||||
if [ $exitCode != 0 ]; then |
||||
runHook failureHook |
||||
|
||||
# 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. |
||||
if [ -n "$succeedOnFailure" ]; then |
||||
echo "build failed with exit code $exitCode (ignored)" |
||||
mkdir -p "$out/nix-support" |
||||
echo -n $exitCode > "$out/nix-support/failed" |
||||
exit 0 |
||||
fi |
||||
|
||||
else |
||||
runHook exitHook |
||||
fi |
||||
|
||||
exit $exitCode |
||||
} |
||||
|
||||
trap "exitHandler" EXIT |
||||
|
||||
|
||||
###################################################################### |
||||
# Helper functions that might be useful in setup hooks. |
||||
|
||||
|
||||
addToSearchPathWithCustomDelimiter() { |
||||
local delimiter=$1 |
||||
local varName=$2 |
||||
local dir=$3 |
||||
if [ -d "$dir" ]; then |
||||
eval export ${varName}=${!varName}${!varName:+$delimiter}${dir} |
||||
fi |
||||
} |
||||
|
||||
PATH_DELIMITER=':' |
||||
|
||||
addToSearchPath() { |
||||
addToSearchPathWithCustomDelimiter "${PATH_DELIMITER}" "$@" |
||||
} |
||||
|
||||
|
||||
###################################################################### |
||||
# Initialisation. |
||||
|
||||
set -e |
||||
|
||||
[ -z $NIX_GCC ] && NIX_GCC=@gcc@ |
||||
|
||||
|
||||
# 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 |
||||
|
||||
|
||||
# Set up the initial path. |
||||
PATH= |
||||
for i in $NIX_GCC @initialPath@; do |
||||
if [ "$i" = / ]; then i=; fi |
||||
addToSearchPath PATH $i/bin |
||||
done |
||||
|
||||
if [ "$NIX_DEBUG" = 1 ]; then |
||||
echo "initial path: $PATH" |
||||
fi |
||||
|
||||
|
||||
# Execute the pre-hook. |
||||
export SHELL=@shell@ |
||||
if [ -z "$shell" ]; then export shell=@shell@; fi |
||||
runHook preHook |
||||
|
||||
|
||||
# Check that the pre-hook initialised SHELL. |
||||
if [ -z "$SHELL" ]; then echo "SHELL not set"; exit 1; fi |
||||
|
||||
|
||||
# Hack: run gcc's setup hook. |
||||
envHooks=() |
||||
crossEnvHooks=() |
||||
if [ -f $NIX_GCC/nix-support/setup-hook ]; then |
||||
source $NIX_GCC/nix-support/setup-hook |
||||
fi |
||||
|
||||
|
||||
# Ensure that the given directories exists. |
||||
ensureDir() { |
||||
local dir |
||||
for dir in "$@"; do |
||||
if ! [ -x "$dir" ]; then mkdir -p "$dir"; fi |
||||
done |
||||
} |
||||
|
||||
installBin() { |
||||
mkdir -p $out/bin |
||||
cp "$@" $out/bin |
||||
} |
||||
|
||||
|
||||
# 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). |
||||
runHook addInputsHook |
||||
|
||||
|
||||
# Recursively find all build inputs. |
||||
findInputs() { |
||||
local pkg=$1 |
||||
local var=$2 |
||||
local propagatedBuildInputsFile=$3 |
||||
|
||||
case ${!var} in |
||||
*\ $pkg\ *) |
||||
return 0 |
||||
;; |
||||
esac |
||||
|
||||
eval $var="'${!var} $pkg '" |
||||
|
||||
if [ -f $pkg/nix-support/setup-hook ]; then |
||||
source $pkg/nix-support/setup-hook |
||||
fi |
||||
|
||||
if [ -f $pkg/nix-support/$propagatedBuildInputsFile ]; then |
||||
for i in $(cat $pkg/nix-support/$propagatedBuildInputsFile); do |
||||
findInputs $i $var $propagatedBuildInputsFile |
||||
done |
||||
fi |
||||
} |
||||
|
||||
crossPkgs="" |
||||
for i in $buildInputs $propagatedBuildInputs; do |
||||
findInputs $i crossPkgs propagated-build-inputs |
||||
done |
||||
|
||||
nativePkgs="" |
||||
for i in $nativeBuildInputs $propagatedNativeBuildInputs; do |
||||
findInputs $i nativePkgs propagated-native-build-inputs |
||||
done |
||||
|
||||
|
||||
# Set the relevant environment variables to point to the build inputs |
||||
# found above. |
||||
addToNativeEnv() { |
||||
local pkg=$1 |
||||
|
||||
if [ -d $1/bin ]; then |
||||
addToSearchPath _PATH $1/bin |
||||
fi |
||||
|
||||
# Run the package-specific hooks set by the setup-hook scripts. |
||||
for i in "${envHooks[@]}"; do |
||||
$i $pkg |
||||
done |
||||
} |
||||
|
||||
for i in $nativePkgs; do |
||||
addToNativeEnv $i |
||||
done |
||||
|
||||
addToCrossEnv() { |
||||
local pkg=$1 |
||||
|
||||
# Some programs put important build scripts (freetype-config and similar) |
||||
# into their crossDrv bin path. Intentionally these should go after |
||||
# the nativePkgs in PATH. |
||||
if [ -d $1/bin ]; then |
||||
addToSearchPath _PATH $1/bin |
||||
fi |
||||
|
||||
# Run the package-specific hooks set by the setup-hook scripts. |
||||
for i in "${crossEnvHooks[@]}"; do |
||||
$i $pkg |
||||
done |
||||
} |
||||
|
||||
for i in $crossPkgs; do |
||||
addToCrossEnv $i |
||||
done |
||||
|
||||
|
||||
# Add the output as an rpath. |
||||
if [ "$NIX_NO_SELF_RPATH" != 1 ]; then |
||||
export NIX_LDFLAGS="-rpath $out/lib $NIX_LDFLAGS" |
||||
if [ -n "$NIX_LIB64_IN_SELF_RPATH" ]; then |
||||
export NIX_LDFLAGS="-rpath $out/lib64 $NIX_LDFLAGS" |
||||
fi |
||||
if [ -n "$NIX_LIB32_IN_SELF_RPATH" ]; then |
||||
export NIX_LDFLAGS="-rpath $out/lib32 $NIX_LDFLAGS" |
||||
fi |
||||
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 |
||||
|
||||
|
||||
# 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. |
||||
if [ -z "$prefix" ]; then |
||||
prefix="$out"; |
||||
fi |
||||
|
||||
if [ "$useTempPrefix" = 1 ]; then |
||||
prefix="$NIX_BUILD_TOP/tmp_prefix"; |
||||
fi |
||||
|
||||
|
||||
PATH=$_PATH${_PATH:+:}$PATH |
||||
if [ "$NIX_DEBUG" = 1 ]; then |
||||
echo "final path: $PATH" |
||||
fi |
||||
|
||||
|
||||
# Make GNU Make produce nested output. |
||||
export NIX_INDENT_MAKE=1 |
||||
|
||||
|
||||
# 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. |
||||
|
||||
if [ -z "${NIX_BUILD_CORES:-}" ]; then |
||||
NIX_BUILD_CORES="1" |
||||
elif [ "$NIX_BUILD_CORES" -le 0 ]; then |
||||
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 |
||||
|
||||
|
||||
###################################################################### |
||||
# Misc. helper functions. |
||||
|
||||
|
||||
stripDirs() { |
||||
local dirs="$1" |
||||
local stripFlags="$2" |
||||
local dirsNew= |
||||
|
||||
for d in ${dirs}; do |
||||
if [ -d "$prefix/$d" ]; then |
||||
dirsNew="${dirsNew} $prefix/$d " |
||||
fi |
||||
done |
||||
dirs=${dirsNew} |
||||
|
||||
if [ -n "${dirs}" ]; then |
||||
header "stripping (with flags $stripFlags) in $dirs" |
||||
find $dirs -type f -print0 | xargs -0 ${xargsFlags:--r} strip $stripFlags || true |
||||
stopNest |
||||
fi |
||||
} |
||||
|
||||
|
||||
###################################################################### |
||||
# Textual substitution functions. |
||||
|
||||
|
||||
substitute() { |
||||
local input="$1" |
||||
local output="$2" |
||||
|
||||
local -a params=("$@") |
||||
|
||||
local n p pattern replacement varName |
||||
|
||||
local content="$(cat $input)" |
||||
|
||||
for ((n = 2; n < ${#params[*]}; n += 1)); do |
||||
p=${params[$n]} |
||||
|
||||
if [ "$p" = --replace ]; then |
||||
pattern="${params[$((n + 1))]}" |
||||
replacement="${params[$((n + 2))]}" |
||||
n=$((n + 2)) |
||||
fi |
||||
|
||||
if [ "$p" = --subst-var ]; then |
||||
varName="${params[$((n + 1))]}" |
||||
pattern="@$varName@" |
||||
replacement="${!varName}" |
||||
n=$((n + 1)) |
||||
fi |
||||
|
||||
if [ "$p" = --subst-var-by ]; then |
||||
pattern="@${params[$((n + 1))]}@" |
||||
replacement="${params[$((n + 2))]}" |
||||
n=$((n + 2)) |
||||
fi |
||||
|
||||
content="${content//"$pattern"/$replacement}" |
||||
done |
||||
|
||||
# !!! This doesn't work properly if $content is "-n". |
||||
echo -n "$content" > "$output".tmp |
||||
if [ -x "$output" ]; then chmod +x "$output".tmp; fi |
||||
mv -f "$output".tmp "$output" |
||||
} |
||||
|
||||
|
||||
substituteInPlace() { |
||||
local fileName="$1" |
||||
shift |
||||
substitute "$fileName" "$fileName" "$@" |
||||
} |
||||
|
||||
|
||||
substituteAll() { |
||||
local input="$1" |
||||
local output="$2" |
||||
|
||||
# Select all environment variables that start with a lowercase character. |
||||
for envVar in $(env | sed "s/^[^a-z].*//" | sed "s/^\([^=]*\)=.*/\1/"); do |
||||
if [ "$NIX_DEBUG" = "1" ]; then |
||||
echo "$envVar -> ${!envVar}" |
||||
fi |
||||
args="$args --subst-var $envVar" |
||||
done |
||||
|
||||
substitute "$input" "$output" $args |
||||
} |
||||
|
||||
|
||||
substituteAllInPlace() { |
||||
local fileName="$1" |
||||
shift |
||||
substituteAll "$fileName" "$fileName" "$@" |
||||
} |
||||
|
||||
|
||||
###################################################################### |
||||
# What follows is the generic builder. |
||||
|
||||
|
||||
nestingLevel=0 |
||||
|
||||
startNest() { |
||||
nestingLevel=$(($nestingLevel + 1)) |
||||
echo -en "\033[$1p" |
||||
} |
||||
|
||||
stopNest() { |
||||
nestingLevel=$(($nestingLevel - 1)) |
||||
echo -en "\033[q" |
||||
} |
||||
|
||||
header() { |
||||
startNest "$2" |
||||
echo "$1" |
||||
} |
||||
|
||||
# Make sure that even when we exit abnormally, the original nesting |
||||
# level is properly restored. |
||||
closeNest() { |
||||
while [ $nestingLevel -gt 0 ]; do |
||||
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() { |
||||
if [ "$noDumpEnvVars" != 1 ]; then |
||||
export > "$NIX_BUILD_TOP/env-vars" |
||||
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() { |
||||
curSrc="$1" |
||||
local cmd |
||||
|
||||
header "unpacking source archive $curSrc" 3 |
||||
|
||||
case "$curSrc" in |
||||
*.tar.xz | *.tar.lzma) |
||||
# Don't rely on tar knowing about .xz. |
||||
xz -d < $curSrc | tar xf - |
||||
;; |
||||
*.tar | *.tar.* | *.tgz | *.tbz2) |
||||
# GNU tar can automatically select the decompression method |
||||
# (info "(tar) gzip"). |
||||
tar xf $curSrc |
||||
;; |
||||
*.zip) |
||||
unzip -qq $curSrc |
||||
;; |
||||
*) |
||||
if [ -d "$curSrc" ]; then |
||||
stripHash $curSrc |
||||
cp -prd --no-preserve=timestamps $curSrc $strippedName |
||||
else |
||||
if [ -z "$unpackCmd" ]; then |
||||
echo "source archive $curSrc has unknown type" |
||||
exit 1 |
||||
fi |
||||
runHook unpackCmd |
||||
fi |
||||
;; |
||||
esac |
||||
|
||||
stopNest |
||||
} |
||||
|
||||
|
||||
unpackPhase() { |
||||
runHook preUnpack |
||||
|
||||
if [ -z "$srcs" ]; then |
||||
if [ -z "$src" ]; then |
||||
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 |
||||
if [ -d "$i" ]; then |
||||
dirsBefore="$dirsBefore $i " |
||||
fi |
||||
done |
||||
|
||||
# Unpack all source archives. |
||||
for i in $srcs; do |
||||
unpackFile $i |
||||
done |
||||
|
||||
# Find the source directory. |
||||
if [ -n "$setSourceRoot" ]; then |
||||
runHook setSourceRoot |
||||
elif [ -z "$sourceRoot" ]; then |
||||
sourceRoot= |
||||
for i in *; do |
||||
if [ -d "$i" ]; then |
||||
case $dirsBefore in |
||||
*\ $i\ *) |
||||
;; |
||||
*) |
||||
if [ -n "$sourceRoot" ]; then |
||||
echo "unpacker produced multiple directories" |
||||
exit 1 |
||||
fi |
||||
sourceRoot="$i" |
||||
;; |
||||
esac |
||||
fi |
||||
done |
||||
fi |
||||
|
||||
if [ -z "$sourceRoot" ]; then |
||||
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. |
||||
if [ "$dontMakeSourcesWritable" != 1 ]; then |
||||
chmod -R u+w "$sourceRoot" |
||||
fi |
||||
|
||||
runHook postUnpack |
||||
} |
||||
|
||||
|
||||
patchPhase() { |
||||
runHook prePatch |
||||
|
||||
for i in $patches; do |
||||
header "applying patch $i" 3 |
||||
local uncompress=cat |
||||
case $i in |
||||
*.gz) |
||||
uncompress="gzip -d" |
||||
;; |
||||
*.bz2) |
||||
uncompress="bzip2 -d" |
||||
;; |
||||
*.lzma) |
||||
uncompress="lzma -d" |
||||
;; |
||||
esac |
||||
$uncompress < $i | patch ${patchFlags:--p1} |
||||
stopNest |
||||
done |
||||
|
||||
runHook postPatch |
||||
} |
||||
|
||||
|
||||
fixLibtool() { |
||||
sed -i -e 's^eval sys_lib_.*search_path=.*^^' "$1" |
||||
} |
||||
|
||||
|
||||
configurePhase() { |
||||
runHook preConfigure |
||||
|
||||
if [ -z "$configureScript" ]; then |
||||
configureScript=./configure |
||||
if ! [ -x $configureScript ]; then |
||||
echo "no configure script, doing nothing" |
||||
return |
||||
fi |
||||
fi |
||||
|
||||
if [ -z "$dontFixLibtool" ]; then |
||||
for i in $(find . -name "ltmain.sh"); do |
||||
echo "fixing libtool script $i" |
||||
fixLibtool $i |
||||
done |
||||
fi |
||||
|
||||
if [ -z "$dontAddPrefix" ]; then |
||||
configureFlags="${prefixKey:---prefix=}$prefix $configureFlags" |
||||
fi |
||||
|
||||
# Add --disable-dependency-tracking to speed up some builds. |
||||
if [ -z "$dontAddDisableDepTrack" ]; then |
||||
if grep -q dependency-tracking $configureScript; then |
||||
configureFlags="--disable-dependency-tracking $configureFlags" |
||||
fi |
||||
fi |
||||
|
||||
# By default, disable static builds. |
||||
if [ -z "$dontDisableStatic" ]; then |
||||
if grep -q enable-static $configureScript; then |
||||
configureFlags="--disable-static $configureFlags" |
||||
fi |
||||
fi |
||||
|
||||
echo "configure flags: $configureFlags ${configureFlagsArray[@]}" |
||||
$configureScript $configureFlags "${configureFlagsArray[@]}" |
||||
|
||||
runHook postConfigure |
||||
} |
||||
|
||||
|
||||
buildPhase() { |
||||
runHook preBuild |
||||
|
||||
if [ -z "$makeFlags" ] && ! [ -n "$makefile" -o -e "Makefile" -o -e "makefile" -o -e "GNUmakefile" ]; then |
||||
echo "no Makefile, doing nothing" |
||||
return |
||||
fi |
||||
|
||||
echo "make flags: $makeFlags ${makeFlagsArray[@]} $buildFlags ${buildFlagsArray[@]}" |
||||
make ${makefile:+-f $makefile} \ |
||||
${enableParallelBuilding:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}} \ |
||||
$makeFlags "${makeFlagsArray[@]}" \ |
||||
$buildFlags "${buildFlagsArray[@]}" |
||||
|
||||
runHook postBuild |
||||
} |
||||
|
||||
|
||||
checkPhase() { |
||||
runHook preCheck |
||||
|
||||
echo "check flags: $makeFlags ${makeFlagsArray[@]} $checkFlags ${checkFlagsArray[@]}" |
||||
make ${makefile:+-f $makefile} \ |
||||
${enableParallelBuilding:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}} \ |
||||
$makeFlags "${makeFlagsArray[@]}" \ |
||||
${checkFlags:-VERBOSE=y} "${checkFlagsArray[@]}" ${checkTarget:-check} |
||||
|
||||
runHook postCheck |
||||
} |
||||
|
||||
|
||||
patchELF() { |
||||
# Patch all ELF executables and shared libraries. |
||||
header "patching ELF executables and libraries" |
||||
if [ -e "$prefix" ]; then |
||||
find "$prefix" \( \ |
||||
\( -type f -a -name "*.so*" \) -o \ |
||||
\( -type f -a -perm +0100 \) \ |
||||
\) -print -exec patchelf --shrink-rpath {} \; |
||||
fi |
||||
stopNest |
||||
} |
||||
|
||||
|
||||
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") |
||||
if [ -n "$oldPath" -a "${oldPath:0:${#NIX_STORE}}" != "$NIX_STORE" ]; then |
||||
local newPath=$(type -P $(basename $oldPath) || true) |
||||
if [ -n "$newPath" -a "$newPath" != "$oldPath" ]; then |
||||
echo "$f: interpreter changed from $oldPath to $newPath" |
||||
sed -i -e "1 s,$oldPath,$newPath," "$f" |
||||
fi |
||||
fi |
||||
done |
||||
stopNest |
||||
} |
||||
|
||||
|
||||
installPhase() { |
||||
runHook preInstall |
||||
|
||||
mkdir -p "$prefix" |
||||
|
||||
installTargets=${installTargets:-install} |
||||
echo "install flags: $installTargets $makeFlags ${makeFlagsArray[@]} $installFlags ${installFlagsArray[@]}" |
||||
make ${makefile:+-f $makefile} $installTargets \ |
||||
$makeFlags "${makeFlagsArray[@]}" \ |
||||
$installFlags "${installFlagsArray[@]}" |
||||
|
||||
runHook postInstall |
||||
} |
||||
|
||||
|
||||
# The fixup phase performs generic, package-independent, Nix-related |
||||
# stuff, like running patchelf and setting the |
||||
# propagated-build-inputs. It should rarely be overriden. |
||||
fixupPhase() { |
||||
runHook preFixup |
||||
|
||||
# Put man/doc/info under $out/share. |
||||
forceShare=${forceShare:=man doc info} |
||||
if [ -n "$forceShare" ]; then |
||||
for d in $forceShare; do |
||||
if [ -d "$prefix/$d" ]; then |
||||
if [ -d "$prefix/share/$d" ]; then |
||||
echo "both $d/ and share/$d/ exists!" |
||||
else |
||||
echo "fixing location of $d/ subdirectory" |
||||
mkdir -p $prefix/share |
||||
if [ -w $prefix/share ]; then |
||||
mv -v $prefix/$d $prefix/share |
||||
ln -sv share/$d $prefix |
||||
fi |
||||
fi |
||||
fi |
||||
done; |
||||
fi |
||||
|
||||
if [ -z "$dontGzipMan" ]; then |
||||
GLOBIGNORE=.:..:*.gz:*.bz2 |
||||
for f in $out/share/man/*/* $out/share/man/*/*/*; do |
||||
if [ -f $f ]; then |
||||
if gzip -c -n $f > $f.gz; then |
||||
rm $f |
||||
else |
||||
rm $f.gz |
||||
fi |
||||
fi |
||||
done |
||||
unset GLOBIGNORE |
||||
fi |
||||
|
||||
# TODO: strip _only_ ELF executables, and return || fail here... |
||||
if [ -z "$dontStrip" ]; then |
||||
stripDebugList=${stripDebugList:-lib lib32 lib64 libexec bin sbin} |
||||
if [ -n "$stripDebugList" ]; then |
||||
stripDirs "$stripDebugList" "${stripDebugFlags:--S --enable-deterministic-archives}" |
||||
fi |
||||
|
||||
stripAllList=${stripAllList:-} |
||||
if [ -n "$stripAllList" ]; then |
||||
stripDirs "$stripAllList" "${stripAllFlags:--s --enable-deterministic-archives}" |
||||
fi |
||||
fi |
||||
|
||||
if [ "$havePatchELF" = 1 -a -z "$dontPatchELF" ]; then |
||||
patchELF "$prefix" |
||||
fi |
||||
|
||||
if [ -z "$dontPatchShebangs" ]; then |
||||
patchShebangs "$prefix" |
||||
fi |
||||
|
||||
if [ -n "$propagatedBuildInputs" ]; then |
||||
mkdir -p "$out/nix-support" |
||||
echo "$propagatedBuildInputs" > "$out/nix-support/propagated-build-inputs" |
||||
fi |
||||
|
||||
if [ -n "$propagatedNativeBuildInputs" ]; then |
||||
mkdir -p "$out/nix-support" |
||||
echo "$propagatedNativeBuildInputs" > "$out/nix-support/propagated-native-build-inputs" |
||||
fi |
||||
|
||||
if [ -n "$propagatedUserEnvPkgs" ]; then |
||||
mkdir -p "$out/nix-support" |
||||
echo "$propagatedUserEnvPkgs" > "$out/nix-support/propagated-user-env-packages" |
||||
fi |
||||
|
||||
if [ -n "$setupHook" ]; then |
||||
mkdir -p "$out/nix-support" |
||||
substituteAll "$setupHook" "$out/nix-support/setup-hook" |
||||
fi |
||||
|
||||
runHook postFixup |
||||
} |
||||
|
||||
|
||||
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 |
||||
} |
||||
|
||||
|
||||
distPhase() { |
||||
runHook preDist |
||||
|
||||
echo "dist flags: $distFlags ${distFlagsArray[@]}" |
||||
make ${makefile:+-f $makefile} $distFlags "${distFlagsArray[@]}" ${distTarget:-dist} |
||||
|
||||
if [ "$dontCopyDist" != 1 ]; then |
||||
mkdir -p "$out/tarballs" |
||||
|
||||
# Note: don't quote $tarballs, since we explicitly permit |
||||
# wildcards in there. |
||||
cp -pvd ${tarballs:-*.tar.gz} $out/tarballs |
||||
fi |
||||
|
||||
runHook postDist |
||||
} |
||||
|
||||
|
||||
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";; |
||||
installCheckPhase) header "running install tests";; |
||||
*) header "$phase";; |
||||
esac |
||||
} |
||||
|
||||
|
||||
genericBuild() { |
||||
header "building $out" |
||||
|
||||
if [ -n "$buildCommand" ]; then |
||||
eval "$buildCommand" |
||||
return |
||||
fi |
||||
|
||||
if [ -z "$phases" ]; then |
||||
phases="$prePhases unpackPhase patchPhase $preConfigurePhases \ |
||||
configurePhase $preBuildPhases buildPhase checkPhase \ |
||||
$preInstallPhases installPhase fixupPhase installCheckPhase \ |
||||
$preDistPhases distPhase $postPhases"; |
||||
fi |
||||
|
||||
for curPhase in $phases; do |
||||
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 |
||||
if [ "$curPhase" = installCheckPhase -a -z "$doInstallCheck" ]; then continue; fi |
||||
if [ "$curPhase" = distPhase -a -z "$doDist" ]; then continue; fi |
||||
|
||||
if [ -n "$tracePhases" ]; then |
||||
echo |
||||
echo "@ phase-started $out $curPhase" |
||||
fi |
||||
|
||||
showPhaseHeader "$curPhase" |
||||
dumpVars |
||||
|
||||
# Evaluate the variable named $curPhase if it exists, otherwise the |
||||
# function named $curPhase. |
||||
eval "${!curPhase:-$curPhase}" |
||||
|
||||
if [ "$curPhase" = unpackPhase ]; then |
||||
cd "${sourceRoot:-.}" |
||||
fi |
||||
|
||||
if [ -n "$tracePhases" ]; then |
||||
echo |
||||
echo "@ phase-succeeded $out $curPhase" |
||||
fi |
||||
|
||||
stopNest |
||||
done |
||||
|
||||
stopNest |
||||
} |
||||
|
||||
|
||||
# Execute the post-hook. |
||||
runHook postHook |
||||
|
||||
|
||||
# Execute the global user hook (defined through the Nixpkgs |
||||
# configuration option ‘stdenv.userHook’). This can be used to set |
||||
# global compiler optimisation flags, for instance. |
||||
runHook userHook |
||||
|
||||
|
||||
dumpVars |
||||
Loading…
Reference in new issue