898 lines
22 KiB
Nix
898 lines
22 KiB
Nix
with (import ../../lib/strings-with-deps.nix (import ../../lib/default-unstable.nix));
|
|
|
|
rec {
|
|
setStrictMode = noDepEntry "set -e;";
|
|
setNixGcc = noDepEntry "test -z \$NIX_GCC && NIX_GCC=@gcc@;";
|
|
|
|
initPath = noDepEntry "# Set up the initial path.
|
|
PATH=
|
|
for i in \$NIX_GCC @initialPath@; do
|
|
PATH=\$PATH\${PATH:+:}\$i/bin
|
|
done
|
|
|
|
if test \"\$NIX_DEBUG\" = \"1\"; then
|
|
echo \"Initial path: \$PATH\"
|
|
fi
|
|
";
|
|
|
|
execPreHook = FullDepEntry "# Execute the pre-hook.
|
|
export SHELL=@shell@
|
|
if test -z \"\$shell\"; then
|
|
export shell=@shell@
|
|
fi
|
|
param1=@param1@
|
|
param2=@param2@
|
|
param3=@param3@
|
|
param4=@param4@
|
|
param5=@param5@
|
|
if test -n \"@preHook@\"; then
|
|
source @preHook@
|
|
fi
|
|
" [initPath];
|
|
|
|
checkShellEnv = FullDepEntry "# Check that the pre-hook initialised SHELL.
|
|
if test -z \"\$SHELL\"; then echo \"SHELL not set\"; exit 1; fi
|
|
" [execPreHook];
|
|
|
|
gccSetupHook = FullDepEntry "# Hack: run gcc's setup hook.
|
|
envHooks=()
|
|
if test -f \$NIX_GCC/nix-support/setup-hook; then
|
|
source \$NIX_GCC/nix-support/setup-hook
|
|
fi
|
|
" [setNixGcc initPath execPreHook];
|
|
|
|
|
|
defEnsureDir = FullDepEntry "# Ensure that the given directories exists.
|
|
ensureDir() {
|
|
local dir
|
|
for dir in \"\$@\"; do
|
|
if ! test -x \"\$dir\"; then mkdir -p \"\$dir\"; fi
|
|
done
|
|
}
|
|
" [initPath];
|
|
|
|
defFail = FullDepEntry "# Called when some build action fails. If \$succeedOnFailure is set,
|
|
# create the file `\$out/nix-support/failed' to signal failure, and
|
|
# exit normally. Otherwise, exit with failure.
|
|
fail() {
|
|
exitCode=\$?
|
|
if test \"\$succeedOnFailure\" = 1; then
|
|
ensureDir \"\$out/nix-support\"
|
|
touch \"\$out/nix-support/failed\"
|
|
exit 0
|
|
else
|
|
exit \$?
|
|
fi
|
|
}
|
|
" [initPath];
|
|
|
|
runAddInputsHook = FullDepEntry "# 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).
|
|
eval \"\$addInputsHook\"
|
|
" [initPath gccSetupHook defFail];
|
|
|
|
defFindInputs = FullDepEntry "# Recursively find all build inputs.
|
|
findInputs()
|
|
{
|
|
local pkg=\$1
|
|
|
|
case \$pkgs in
|
|
*\ \$pkg\ *)
|
|
return 0
|
|
;;
|
|
esac
|
|
|
|
pkgs=\"\$pkgs \$pkg \"
|
|
|
|
if test -f \$pkg/nix-support/setup-hook; then
|
|
source \$pkg/nix-support/setup-hook
|
|
fi
|
|
|
|
if test -f \$pkg/nix-support/propagated-build-inputs; then
|
|
for i in \$(cat \$pkg/nix-support/propagated-build-inputs); do
|
|
findInputs \$i
|
|
done
|
|
fi
|
|
}
|
|
" [initPath];
|
|
|
|
getInputs = FullDepEntry "pkgs=\"\"
|
|
if test -n \"\$buildinputs\"; then
|
|
buildInputs=\"\$buildinputs\" # compatibility
|
|
fi
|
|
for i in \$buildInputs \$propagatedBuildInputs; do
|
|
findInputs \$i
|
|
done
|
|
" [defFindInputs runAddInputsHook];
|
|
|
|
defAddToEnv = FullDepEntry "# Set the relevant environment variables to point to the build inputs
|
|
# found above.
|
|
addToEnv()
|
|
{
|
|
local pkg=\$1
|
|
|
|
if test \"\$ignoreFailedInputs\" != \"1\" -a -e \$1/nix-support/failed; then
|
|
echo \"failed input \$1\" >&2
|
|
fail
|
|
fi
|
|
|
|
if test -d \$1/bin; then
|
|
export _PATH=\$_PATH\${_PATH:+:}\$1/bin
|
|
fi
|
|
|
|
for i in \"\${envHooks[@]}\"; do
|
|
\$i \$pkg
|
|
done
|
|
}
|
|
" [defFail];
|
|
|
|
preparePackageEnv = FullDepEntry "for i in \$pkgs; do
|
|
addToEnv \$i
|
|
done
|
|
" [getInputs defAddToEnv];
|
|
|
|
putOutInRpath = FullDepEntry "# Add the output as an rpath.
|
|
if test \"\$NIX_NO_SELF_RPATH\" != \"1\"; then
|
|
export NIX_LDFLAGS=\"-rpath \$out/lib \$NIX_LDFLAGS\"
|
|
fi
|
|
" [initPath];
|
|
|
|
setupStripping = FullDepEntry "# Strip debug information by default.
|
|
if test -z \"\$NIX_STRIP_DEBUG\"; then
|
|
export NIX_STRIP_DEBUG=1
|
|
export NIX_CFLAGS_STRIP=\"-g0 -Wl,--strip-debug\"
|
|
fi
|
|
" [initPath];
|
|
|
|
checkNixEnv = FullDepEntry "# Do we know where the store is? This is required for purity checking.
|
|
if test -z \"\$NIX_STORE\"; then
|
|
echo \"Error: you have an old version of Nix that does not set the\" \
|
|
\"NIX_STORE variable. Please upgrade.\" >&2
|
|
exit 1
|
|
fi
|
|
|
|
|
|
# We also need to know the root of the build directory for purity checking.
|
|
if test -z \"\$NIX_BUILD_TOP\"; then
|
|
echo \"Error: you have an old version of Nix that does not set the\" \
|
|
\"NIX_BUILD_TOP variable. Please upgrade.\" >&2
|
|
exit 1
|
|
fi
|
|
" [initPath];
|
|
|
|
setTZ = noDepEntry "# 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
|
|
" ;
|
|
|
|
setPrefix = FullDepEntry "# 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 test -z \"\$prefix\"; then
|
|
prefix=\"\$out\";
|
|
fi
|
|
|
|
if test \"\$useTempPrefix\" = \"1\"; then
|
|
prefix=\"\$NIX_BUILD_TOP/tmp_prefix\";
|
|
fi
|
|
" [checkNixEnv];
|
|
|
|
runPostHook = FullDepEntry "# Execute the post-hook.
|
|
if test -n \"@postHook@\"; then
|
|
source @postHook@
|
|
fi
|
|
" [setTZ setPrefix execPreHook gccSetupHook preparePackageEnv];
|
|
|
|
finalSetPath = FullDepEntry "PATH=\$_PATH\${_PATH:+:}\$PATH
|
|
if test \"\$NIX_DEBUG\" = \"1\"; then
|
|
echo \"Final path: \$PATH\"
|
|
fi
|
|
" [runPostHook];
|
|
|
|
defSubstitute = FullDepEntry "######################################################################
|
|
# Textual substitution functions.
|
|
|
|
|
|
# Some disgusting hackery to escape replacements in Sed substitutions.
|
|
# We should really have a tool that replaces literal values by other
|
|
# literal values, without any need for escaping.
|
|
escapeSed() {
|
|
local s=\"\$1\"
|
|
# The `tr' hack is to escape newlines. Sed handles newlines very
|
|
# badly, so we just replace newlines with the magic character 0xff
|
|
# (377 octal). So don't use that character in replacements :-P
|
|
echo -n \"\$1\" | tr '\012' '\377' | sed -e 's^\\^\\\\^g' -e 's^\xff^\\n^g' -e 's/\^/\\^/g' -e 's/&/\\&/g'
|
|
}
|
|
|
|
|
|
substitute() {
|
|
local input=\"\$1\"
|
|
local output=\"\$2\"
|
|
|
|
local -a params=(\"\$@\")
|
|
|
|
local sedScript=\$NIX_BUILD_TOP/.sedargs
|
|
rm -f \$sedScript
|
|
touch \$sedScript
|
|
|
|
local n p pattern replacement varName
|
|
|
|
for ((n = 2; n < \${#params[*]}; n += 1)); do
|
|
p=\${params[\$n]}
|
|
|
|
if test \"\$p\" = \"--replace\"; then
|
|
pattern=\"\${params[\$((n + 1))]}\"
|
|
replacement=\"\${params[\$((n + 2))]}\"
|
|
n=\$((n + 2))
|
|
fi
|
|
|
|
if test \"\$p\" = \"--subst-var\"; then
|
|
varName=\"\${params[\$((n + 1))]}\"
|
|
pattern=\"@\$varName@\"
|
|
replacement=\"\${!varName}\"
|
|
n=\$((n + 1))
|
|
fi
|
|
|
|
if test \"\$p\" = \"--subst-var-by\"; then
|
|
pattern=\"@\${params[\$((n + 1))]}@\"
|
|
replacement=\"\${params[\$((n + 2))]}\"
|
|
n=\$((n + 2))
|
|
fi
|
|
|
|
replacement=\"\$(escapeSed \"\$replacement\")\"
|
|
|
|
echo \"s^\$pattern^\$replacement^g\" >> \$sedScript
|
|
done
|
|
|
|
sed -f \$sedScript < \"\$input\" > \"\$output\".tmp
|
|
if test -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 test \"\$NIX_DEBUG\" = \"1\"; then
|
|
echo \"\$envVar -> \${!envVar}\"
|
|
fi
|
|
args=\"\$args --subst-var \$envVar\"
|
|
done
|
|
|
|
substitute \"\$input\" \"\$output\" \$args
|
|
}
|
|
" [initPath];
|
|
|
|
defNest = NoDepEntry "######################################################################
|
|
# What follows is the generic builder.
|
|
|
|
|
|
nestingLevel=0
|
|
|
|
startNest() {
|
|
nestingLevel=\$((\$nestingLevel + 1))
|
|
echo -en \"\e[\$1p\"
|
|
}
|
|
|
|
stopNest() {
|
|
nestingLevel=\$((\$nestingLevel - 1))
|
|
echo -en \"\e[q\"
|
|
}
|
|
|
|
header() {
|
|
startNest \"\$2\"
|
|
echo \"\$1\"
|
|
}
|
|
|
|
# Make sure that even when we exit abnormally, the original nesting
|
|
# level is properly restored.
|
|
closeNest() {
|
|
while test \$nestingLevel -gt 0; do
|
|
stopNest
|
|
done
|
|
}
|
|
|
|
trap \"closeNest\" EXIT
|
|
" ;
|
|
|
|
|
|
defDumpVars = FullDepEntry "# 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 test \"\$noDumpEnvVars\" != \"1\"; then
|
|
export > \$NIX_BUILD_TOP/env-vars
|
|
fi
|
|
}
|
|
" [checkNixEnv];
|
|
|
|
|
|
defStartStopLog = FullDepEntry "# Redirect stdout/stderr to a named pipe connected to a `tee' process
|
|
# that writes the specified file (and also to our original stdout).
|
|
# The original stdout is saved in descriptor 3.
|
|
startLog() {
|
|
local logFile=\${logNr}_\$1
|
|
logNr=\$((logNr + 1))
|
|
if test \"\$logPhases\" = 1; then
|
|
ensureDir \$logDir
|
|
|
|
exec 3>&1
|
|
|
|
if test \"\$dontLogThroughTee\" != 1; then
|
|
# This required named pipes (fifos).
|
|
logFifo=\$NIX_BUILD_TOP/log_fifo
|
|
test -p \$logFifo || mkfifo \$logFifo
|
|
startLogWrite \"\$logDir/\$logFile\" \"\$logFifo\"
|
|
exec > \$logFifo 2>&1
|
|
else
|
|
exec > \$logDir/\$logFile 2>&1
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# Factored into a separate function so that it can be overriden.
|
|
startLogWrite() {
|
|
tee \"\$1\" < \"\$2\" &
|
|
logWriterPid=\$!
|
|
}
|
|
|
|
# Restore the original stdout/stderr.
|
|
stopLog() {
|
|
if test \"\$logPhases\" = 1; then
|
|
exec >&3 2>&1
|
|
|
|
# Wait until the tee process has died. Otherwise output from
|
|
# different phases may be mixed up.
|
|
if test -n \"\$logWriterPid\"; then
|
|
wait \$logWriterPid
|
|
logWriterPid=
|
|
rm \$logFifo
|
|
fi
|
|
fi
|
|
}
|
|
|
|
|
|
" [setLogVars checkNixEnv ];
|
|
|
|
|
|
setLogVars = FullDepEntry "if test -z \"\$logDir\"; then
|
|
logDir=\$out/log
|
|
fi
|
|
|
|
logNr=0
|
|
" [initPath];
|
|
|
|
defStripHash = FullDepEntry "# 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
|
|
}
|
|
" [initPath];
|
|
|
|
defUnpack = FullDepEntry "
|
|
unpackFile() {
|
|
local file=\$1
|
|
local cmd
|
|
|
|
header \"unpacking source archive \$file\" 3
|
|
|
|
case \$file in
|
|
*.tar)
|
|
tar xvf \$file || fail
|
|
;;
|
|
*.tar.gz | *.tgz | *.tar.Z)
|
|
gunzip < \$file | tar xvf - || fail
|
|
;;
|
|
*.tar.bz2 | *.tbz2)
|
|
bunzip2 < \$file | tar xvf - || fail
|
|
;;
|
|
*.zip)
|
|
unzip \$file || fail
|
|
;;
|
|
*)
|
|
if test -d \"\$file\"; then
|
|
stripHash \$file
|
|
cp -prvd \$file \$strippedName || fail
|
|
else
|
|
if test -n \"\$findUnpacker\"; then
|
|
\$findUnpacker \$1;
|
|
fi
|
|
if test -z \"\$unpackCmd\"; then
|
|
echo \"source archive \$file has unknown type\"
|
|
exit 1
|
|
fi
|
|
eval \"\$unpackCmd\" || fail
|
|
fi
|
|
;;
|
|
esac
|
|
|
|
stopNest
|
|
}
|
|
" [preparePackageEnv];
|
|
|
|
defUnpackW = FullDepEntry "
|
|
unpackW() {
|
|
if test -n \"\$unpackPhase\"; then
|
|
eval \"\$unpackPhase\"
|
|
return
|
|
fi
|
|
|
|
if test -z \"\$srcs\"; then
|
|
if test -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 test -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 test -n \"\$setSourceRoot\"; then
|
|
eval \"\$setSourceRoot\"
|
|
else
|
|
sourceRoot=
|
|
for i in *; do
|
|
if test -d \"\$i\"; then
|
|
case \$dirsBefore in
|
|
*\ \$i\ *)
|
|
;;
|
|
*)
|
|
if test -n \"\$sourceRoot\"; then
|
|
echo \"unpacker produced multiple directories\"
|
|
exit 1
|
|
fi
|
|
sourceRoot=\$i
|
|
;;
|
|
esac
|
|
fi
|
|
done
|
|
fi
|
|
|
|
if test -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 test \"dontMakeSourcesWritable\" != 1; then
|
|
chmod -R +w \$sourceRoot
|
|
fi
|
|
|
|
eval \"\$postUnpack\"
|
|
}
|
|
" [defUnpack];
|
|
|
|
|
|
|
|
defUnpackPhase = FullDepEntry "
|
|
unpackPhase() {
|
|
sourceRoot=. # don't change to user dir homeless shelter if custom unpackSource does'nt set sourceRoot
|
|
header \"unpacking sources\"
|
|
startLog \"unpack\"
|
|
unpackW
|
|
stopLog
|
|
stopNest
|
|
cd \$sourceRoot
|
|
}
|
|
" [unpackW];
|
|
|
|
|
|
defPatchW = FullDepEntry "
|
|
patchW() {
|
|
if test -n \"\$patchPhase\"; then
|
|
eval \"\$patchPhase\"
|
|
return
|
|
fi
|
|
|
|
if test -z \"\$patchFlags\"; then
|
|
patchFlags=\"-p1\"
|
|
fi
|
|
|
|
for i in \$patches; do
|
|
header \"applying patch \$i\" 3
|
|
local uncompress=cat
|
|
case \$i in
|
|
*.gz)
|
|
uncompress=gunzip
|
|
;;
|
|
*.bz2)
|
|
uncompress=bunzip2
|
|
;;
|
|
esac
|
|
\$uncompress < \$i | patch \$patchFlags || fail
|
|
stopNest
|
|
done
|
|
}
|
|
" [getInputs]
|
|
|
|
defPatchPhase = FullDepEntry "
|
|
patchPhase() {
|
|
if test -z \"\$patchPhase\" -a -z \"\$patches\"; then return; fi
|
|
header \"patching sources\"
|
|
startLog \"patch\"
|
|
patchW
|
|
stopLog
|
|
stopNest
|
|
}
|
|
" [defPatchW];
|
|
|
|
defFixLibTool = FullDepEntry "fixLibtool() {
|
|
sed 's^eval sys_lib_.*search_path=.*^^' < \$1 > \$1.tmp
|
|
mv \$1.tmp \$1
|
|
}
|
|
" [initPath];
|
|
|
|
defConfigureW = FullDepEntry "
|
|
configureW() {
|
|
if test -n \"\$configurePhase\"; then
|
|
eval \"\$configurePhase\"
|
|
return
|
|
fi
|
|
|
|
eval \"\$preConfigure\"
|
|
|
|
if test -z \"\$configureScript\"; then
|
|
configureScript=./configure
|
|
if ! test -x \$configureScript; then
|
|
echo \"no configure script, doing nothing\"
|
|
return
|
|
fi
|
|
fi
|
|
|
|
if test -z \"\$dontFixLibtool\"; then
|
|
for i in \$(find . -name \"ltmain.sh\"); do
|
|
echo \"fixing libtool script \$i\"
|
|
fixLibtool \$i
|
|
done
|
|
fi
|
|
|
|
if test -z \"\$dontAddPrefix\"; then
|
|
configureFlags=\"--prefix=\$prefix \$configureFlags\"
|
|
fi
|
|
|
|
echo \"configure flags: \$configureFlags \${configureFlagsArray[@]}\"
|
|
\$configureScript \$configureFlags\"\${configureFlagsArray[@]}\" || fail
|
|
|
|
eval \"\$postConfigure\"
|
|
}
|
|
" [initPath];
|
|
|
|
|
|
defConfigurePhase = FullDepEntry "
|
|
configurePhase() {
|
|
header \"configuring\"
|
|
startLog \"configure\"
|
|
configureW
|
|
stopLog
|
|
stopNest
|
|
}
|
|
" [defConfigureW];
|
|
|
|
defBuildW = FullDepEntry "
|
|
buildW() {
|
|
if test -n \"\$buildPhase\"; then
|
|
eval \"\$buildPhase\"
|
|
return
|
|
fi
|
|
|
|
eval \"\$preBuild\"
|
|
|
|
echo \"make flags: \$makeFlags \${makeFlagsArray[@]} \$buildFlags \${buildFlagsArray[@]}\"
|
|
make \
|
|
\$makeFlags \"\${makeFlagsArray[@]}\" \
|
|
\$buildFlags \"\${buildFlagsArray[@]}\" || fail
|
|
|
|
eval \"\$postBuild\"
|
|
}
|
|
" [initPath];
|
|
|
|
defBuildPhase = FullDepEntry "
|
|
buildPhase() {
|
|
if test \"\$dontBuild\" = 1; then
|
|
return
|
|
fi
|
|
header \"building\"
|
|
startLog \"build\"
|
|
buildW
|
|
stopLog
|
|
stopNest
|
|
}
|
|
" [defBuildW];
|
|
|
|
|
|
defCheckW = FullDepEntry "
|
|
checkW() {
|
|
if test -n \"\$checkPhase\"; then
|
|
eval \"\$checkPhase\"
|
|
return
|
|
fi
|
|
|
|
if test -z \"\$checkTarget\"; then
|
|
checkTarget=\"check\"
|
|
fi
|
|
|
|
echo \"check flags: \$makeFlags \${makeFlagsArray[@]} \$checkFlags \${checkFlagsArray[@]}\"
|
|
make \
|
|
\$makeFlags \"\${makeFlagsArray[@]}\" \
|
|
\$checkFlags \"\${checkFlagsArray[@]}\" \$checkTarget || fail
|
|
}
|
|
" [initPath];
|
|
|
|
|
|
defCheckPhase = FullDepEntry "
|
|
checkPhase() {
|
|
if test \"\$doCheck\" != 1; then
|
|
return
|
|
fi
|
|
header \"checking\"
|
|
startLog \"check\"
|
|
checkW
|
|
stopLog
|
|
stopNest
|
|
}
|
|
" [checkPhase];
|
|
|
|
|
|
defPatchElf = FullDepEntry "
|
|
patchELF() {
|
|
# Patch all ELF executables and shared libraries.
|
|
header \"patching ELF executables and libraries\"
|
|
find \"\$prefix\" \( \
|
|
\( -type f -a -name \"*.so*\" \) -o \
|
|
\( -type f -a -perm +0100 \) \
|
|
\) -print -exec patchelf --shrink-rpath {} \;
|
|
stopNest
|
|
}
|
|
" [initPath defNest];
|
|
|
|
|
|
defInstallW = FullDepEntry "
|
|
installW() {
|
|
if test -n \"\$installPhase\"; then
|
|
eval \"\$installPhase\"
|
|
return
|
|
fi
|
|
|
|
eval \"\$preInstall\"
|
|
|
|
ensureDir \"\$prefix\"
|
|
|
|
if test -z \"\$installCommand\"; then
|
|
if test -z \"\$installTargets\"; then
|
|
installTargets=install
|
|
fi
|
|
echo \"install flags: \$installTargets \$makeFlags \${makeFlagsArray[@]} \$installFlags \${installFlagsArray[@]}\"
|
|
make \$installTargets \
|
|
\$makeFlags \"\${makeFlagsArray[@]}\" \
|
|
\$installFlags \"\${installFlagsArray[@]}\" || fail
|
|
else
|
|
eval \"\$installCommand\"
|
|
fi
|
|
|
|
eval \"\$postInstall\"
|
|
}
|
|
" [initPath];
|
|
|
|
|
|
defInstallPhase = FullDepEntry "
|
|
installPhase() {
|
|
if test \"\$dontInstall\" = 1; then
|
|
return
|
|
fi
|
|
header \"installing\"
|
|
startLog \"install\"
|
|
installW
|
|
stopLog
|
|
stopNest
|
|
}
|
|
" [defInstallW defNest defStartStopLog];
|
|
|
|
|
|
defFixupW = FullDepEntry "
|
|
# The fixup phase performs generic, package-independent, Nix-related
|
|
# stuff, like running patchelf and setting the
|
|
# propagated-build-inputs. It should rarely be overriden.
|
|
fixupW() {
|
|
if test -n \"\$fixupPhase\"; then
|
|
eval \"\$fixupPhase\"
|
|
return
|
|
fi
|
|
|
|
eval \"\$preFixup\"
|
|
|
|
forceShare=\${forceShare:=man doc info}
|
|
if test -n \"\$forceShare\"; then
|
|
for d in \$forceShare; do
|
|
if test -d \"\$prefix/\$d\"; then
|
|
if test -d \"\$prefix/share/\$d\"; then
|
|
echo \"Both \$d/ and share/\$d/ exists, aborting\"
|
|
else
|
|
ensureDir \$prefix/share
|
|
if test -w \$prefix/share; then
|
|
mv -v \$prefix/\$d \$prefix/share
|
|
ln -sv share/\$d \$prefix
|
|
fi
|
|
fi
|
|
fi
|
|
done;
|
|
fi
|
|
|
|
|
|
# TODO : strip _only_ ELF executables, and return || fail here...
|
|
if test -z \"\$dontStrip\"; then
|
|
test -d \"\$prefix/lib\" && stripDebug=\"\$prefix/lib\"
|
|
|
|
if test -n \"\$stripDebug\"; then
|
|
find \"\$stripDebug\" -type f -print0 |
|
|
xargs -0 strip --strip-debug --verbose || true
|
|
fi
|
|
|
|
test -d \"\$prefix/bin\" && stripAll=\"\$prefix/bin\"
|
|
test -d \"\$prefix/sbin\" && stripAll=\"\${stripAll} \$prefix/sbin\"
|
|
if test -n \"\$stripAll\"; then
|
|
find \"\$prefix/bin\" \"\$prefix/sbin\" -type f -print0 |
|
|
xargs -0 strip --strip-all --verbose || true
|
|
fi
|
|
fi
|
|
|
|
if test -z \"\$dontFixupShare\"; then
|
|
for dir in doc info man; do
|
|
if test -d \"\$prefix/\$dir\"; then
|
|
if test -d \"\$prefix/share/\$dir\"; then
|
|
echo Both \"\$prefix/\$dir\" and \"\$prefix/share/\$dir\" exists!
|
|
else
|
|
echo Fixing location of \$dir/ subdirectory
|
|
ensureDir \"\$prefix/share\"
|
|
if test -w \$prefix/share; then
|
|
mv -v \"\$prefix/\$dir\" \"\$prefix/share\"
|
|
ln -sv \"share/\$dir\" \"\$prefix\"
|
|
fi
|
|
fi
|
|
fi
|
|
done
|
|
fi
|
|
|
|
if test \"\$havePatchELF\" = 1 -a -z \"\$dontPatchELF\"; then
|
|
patchELF \"\$prefix\"
|
|
fi
|
|
|
|
if test -n \"\$propagatedBuildInputs\"; then
|
|
ensureDir \"\$out/nix-support\"
|
|
echo \"\$propagatedBuildInputs\" > \"\$out/nix-support/propagated-build-inputs\"
|
|
fi
|
|
|
|
if test -n \"\$setupHook\"; then
|
|
ensureDir \"\$out/nix-support\"
|
|
substituteAll \"\$setupHook\" \"\$out/nix-support/setup-hook\"
|
|
fi
|
|
|
|
eval \"\$postFixup\"
|
|
}
|
|
" [defPatchElf initPath];
|
|
|
|
|
|
defFixupPhase = FullDepEntry "
|
|
fixupPhase() {
|
|
if test \"\$dontFixup\" = 1; then
|
|
return
|
|
fi
|
|
header \"post-installation fixup\"
|
|
startLog \"fixup\"
|
|
fixupW
|
|
stopLog
|
|
stopNest
|
|
}
|
|
" [defFixupW defNest defStartStopLog];
|
|
|
|
|
|
defDistW = FullDepEntry "
|
|
distW() {
|
|
if test -n \"\$distPhase\"; then
|
|
eval \"\$distPhase\"
|
|
return
|
|
fi
|
|
|
|
eval \"\$preDist\"
|
|
|
|
if test -z \"\$distTarget\"; then
|
|
distTarget=\"dist\"
|
|
fi
|
|
|
|
echo \"dist flags: \$distFlags \${distFlagsArray[@]}\"
|
|
make \$distFlags \"\${distFlagsArray[@]}\" \$distTarget || fail
|
|
|
|
if test \"\$dontCopyDist\" != 1; then
|
|
ensureDir \"\$out/tarballs\"
|
|
|
|
if test -z \"\$tarballs\"; then
|
|
tarballs=\"*.tar.gz\"
|
|
fi
|
|
|
|
# Note: don't quote \$tarballs, since we explicitly permit
|
|
# wildcards in there.
|
|
cp -pvd \$tarballs \$out/tarballs
|
|
fi
|
|
|
|
eval \"\$postDist\"
|
|
}
|
|
" [initPath ];
|
|
|
|
|
|
defDistPhase = FullDepEntry "
|
|
distPhase() {
|
|
if test \"\$doDist\" != 1; then
|
|
return
|
|
fi
|
|
header \"creating distribution\"
|
|
startLog \"dist\"
|
|
distW
|
|
stopLog
|
|
stopNest
|
|
}
|
|
" [defDistW defNest defStartStopLog];
|
|
|
|
defGenericBuild = FullDepEntry "
|
|
genericBuild() {
|
|
header \"building \$out\"
|
|
|
|
if test -n \"\$buildCommand\"; then
|
|
eval \"\$buildCommand\"
|
|
return
|
|
fi
|
|
|
|
if test -z \"\$phases\"; then
|
|
phases=\"unpackPhase patchPhase configurePhase buildPhase checkPhase \
|
|
installPhase fixupPhase distPhase\";
|
|
fi
|
|
|
|
for i in \$phases; do
|
|
dumpVars
|
|
eval \"\$i\"
|
|
done
|
|
|
|
stopNest
|
|
}
|
|
" [defUnpackPhase defBuildPhase defInstallPhase];
|
|
|
|
doDumpVars = FullDepEntry "
|
|
dumpVars
|
|
" [defDumpVars];
|