|
|
unset shellHook |
|
|
nix_saved_PATH="$PATH" |
|
|
AR='ar' |
|
|
export AR |
|
|
AS='as' |
|
|
export AS |
|
|
BASH='/nix/store/pbfraw351mksnkp2ni9c4rkc9cpp89iv-bash-5.1-p12/bin/bash' |
|
|
CC='gcc' |
|
|
export CC |
|
|
CONFIG_SHELL='/nix/store/pbfraw351mksnkp2ni9c4rkc9cpp89iv-bash-5.1-p12/bin/bash' |
|
|
export CONFIG_SHELL |
|
|
CXX='g++' |
|
|
export CXX |
|
|
EPOCHREALTIME='1643054257.339516' |
|
|
EPOCHSECONDS='1643054257' |
|
|
HOSTTYPE='x86_64' |
|
|
HOST_PATH='/nix/store/176gh50y24c0lx2bnnmsvf9wazb73php-coreutils-9.0/bin:/nix/store/g0hhds9sdiqds0xxgpn7v4pwcv89varr-findutils-4.8.0/bin:/nix/store/ywy7hggaj6vvgw86vbnyirll697ic5jx-diffutils-3.8/bin:/nix/store/4na05j9gmpp3dwhmnc1q0a108ymf2qjy-gnused-4.8/bin:/nix/store/pkj79ap8x2dalzl63ndpdmxg2crxpjl8-gnugrep-3.7/bin:/nix/store/yabl1gmn7balb15hbcj613jcz0cxny42-gawk-5.1.1/bin:/nix/store/sdpqvnmahizaxbs3nnzmgfgyqsdxb1bw-gnutar-1.34/bin:/nix/store/7f3bipp5x4yiqghnkkv88rfsqzs6fl9z-gzip-1.11/bin:/nix/store/2ccy5zc89zpc2aznqxgvzp4wm1bwj05n-bzip2-1.0.6.0.2-bin/bin:/nix/store/vhsx8rivchbvc6xnymyc45vvk7c7dz25-gnumake-4.3/bin:/nix/store/pbfraw351mksnkp2ni9c4rkc9cpp89iv-bash-5.1-p12/bin:/nix/store/hjg2fnn41awrq6xzaq3cjfar6jwfcbw6-patch-2.7.6/bin:/nix/store/cxd7laqdidlqvqrlzsd4cls8470h6rwb-xz-5.2.5-bin/bin' |
|
|
export HOST_PATH |
|
|
IFS=' |
|
|
' |
|
|
IN_NIX_SHELL='impure' |
|
|
export IN_NIX_SHELL |
|
|
LD='ld' |
|
|
export LD |
|
|
LINENO='73' |
|
|
MACHTYPE='x86_64-pc-linux-gnu' |
|
|
NIX_BINTOOLS='/nix/store/w327j7z9wlv7hym4spjzagax7c5hqvrf-binutils-wrapper-2.35.2' |
|
|
export NIX_BINTOOLS |
|
|
NIX_BINTOOLS_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu='1' |
|
|
export NIX_BINTOOLS_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu |
|
|
NIX_BUILD_CORES='12' |
|
|
export NIX_BUILD_CORES |
|
|
NIX_CC='/nix/store/npm4g1zsj5yzygf6bq46pbi9fqhxisha-gcc-wrapper-10.3.0' |
|
|
export NIX_CC |
|
|
NIX_CC_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu='1' |
|
|
export NIX_CC_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu |
|
|
NIX_CFLAGS_COMPILE=' -frandom-seed=h22lwjkqqc' |
|
|
export NIX_CFLAGS_COMPILE |
|
|
NIX_ENFORCE_NO_NATIVE='1' |
|
|
export NIX_ENFORCE_NO_NATIVE |
|
|
NIX_HARDENING_ENABLE='fortify stackprotector pic strictoverflow format relro bindnow' |
|
|
export NIX_HARDENING_ENABLE |
|
|
NIX_INDENT_MAKE='1' |
|
|
export NIX_INDENT_MAKE |
|
|
NIX_LDFLAGS='-rpath /home/kristof/prv/git/blog/outputs/out/lib64 -rpath /home/kristof/prv/git/blog/outputs/out/lib ' |
|
|
export NIX_LDFLAGS |
|
|
NIX_LIB64_IN_SELF_RPATH='1' |
|
|
NIX_NO_SELF_RPATH='1' |
|
|
NIX_STORE='/nix/store' |
|
|
export NIX_STORE |
|
|
NM='nm' |
|
|
export NM |
|
|
OBJCOPY='objcopy' |
|
|
export OBJCOPY |
|
|
OBJDUMP='objdump' |
|
|
export OBJDUMP |
|
|
OLDPWD='' |
|
|
export OLDPWD |
|
|
OPTERR='1' |
|
|
OSTYPE='linux-gnu' |
|
|
PATH='/nix/store/bhk8r97h4n6ag1qrplb9q8vjnkfqnq91-hugo-0.92.0/bin:/nix/store/9wjacdm5cy68ixhj6fd567hk5lldca30-patchelf-0.14.3/bin:/nix/store/npm4g1zsj5yzygf6bq46pbi9fqhxisha-gcc-wrapper-10.3.0/bin:/nix/store/mlfy9ifzszg7z2q6aiblvm5qkfn3bmwb-gcc-10.3.0/bin:/nix/store/4687f3vcym7a3ipjh0lfm5qlr12m76nr-glibc-2.33-59-bin/bin:/nix/store/176gh50y24c0lx2bnnmsvf9wazb73php-coreutils-9.0/bin:/nix/store/w327j7z9wlv7hym4spjzagax7c5hqvrf-binutils-wrapper-2.35.2/bin:/nix/store/cdm6zywd51mbabxhklsixwcskv4n70s3-binutils-2.35.2/bin:/nix/store/176gh50y24c0lx2bnnmsvf9wazb73php-coreutils-9.0/bin:/nix/store/g0hhds9sdiqds0xxgpn7v4pwcv89varr-findutils-4.8.0/bin:/nix/store/ywy7hggaj6vvgw86vbnyirll697ic5jx-diffutils-3.8/bin:/nix/store/4na05j9gmpp3dwhmnc1q0a108ymf2qjy-gnused-4.8/bin:/nix/store/pkj79ap8x2dalzl63ndpdmxg2crxpjl8-gnugrep-3.7/bin:/nix/store/yabl1gmn7balb15hbcj613jcz0cxny42-gawk-5.1.1/bin:/nix/store/sdpqvnmahizaxbs3nnzmgfgyqsdxb1bw-gnutar-1.34/bin:/nix/store/7f3bipp5x4yiqghnkkv88rfsqzs6fl9z-gzip-1.11/bin:/nix/store/2ccy5zc89zpc2aznqxgvzp4wm1bwj05n-bzip2-1.0.6.0.2-bin/bin:/nix/store/vhsx8rivchbvc6xnymyc45vvk7c7dz25-gnumake-4.3/bin:/nix/store/pbfraw351mksnkp2ni9c4rkc9cpp89iv-bash-5.1-p12/bin:/nix/store/hjg2fnn41awrq6xzaq3cjfar6jwfcbw6-patch-2.7.6/bin:/nix/store/cxd7laqdidlqvqrlzsd4cls8470h6rwb-xz-5.2.5-bin/bin' |
|
|
export PATH |
|
|
PS4='+ ' |
|
|
RANLIB='ranlib' |
|
|
export RANLIB |
|
|
READELF='readelf' |
|
|
export READELF |
|
|
SHELL='/nix/store/pbfraw351mksnkp2ni9c4rkc9cpp89iv-bash-5.1-p12/bin/bash' |
|
|
export SHELL |
|
|
SIZE='size' |
|
|
export SIZE |
|
|
SOURCE_DATE_EPOCH='315532800' |
|
|
export SOURCE_DATE_EPOCH |
|
|
STRINGS='strings' |
|
|
export STRINGS |
|
|
STRIP='strip' |
|
|
export STRIP |
|
|
XDG_DATA_DIRS='/nix/store/bhk8r97h4n6ag1qrplb9q8vjnkfqnq91-hugo-0.92.0/share:/nix/store/9wjacdm5cy68ixhj6fd567hk5lldca30-patchelf-0.14.3/share' |
|
|
export XDG_DATA_DIRS |
|
|
buildInputs='' |
|
|
export buildInputs |
|
|
buildPhase='echo "------------------------------------------------------------" >>$out |
|
|
echo " WARNING: the existence of this path is not guaranteed." >>$out |
|
|
echo " It is an internal implementation detail for pkgs.mkShell." >>$out |
|
|
echo "------------------------------------------------------------" >>$out |
|
|
echo >> $out |
|
|
# Record all build inputs as runtime dependencies |
|
|
export >> $out |
|
|
' |
|
|
export buildPhase |
|
|
builder='/nix/store/pbfraw351mksnkp2ni9c4rkc9cpp89iv-bash-5.1-p12/bin/bash' |
|
|
export builder |
|
|
configureFlags='' |
|
|
export configureFlags |
|
|
defaultBuildInputs='' |
|
|
defaultNativeBuildInputs='/nix/store/9wjacdm5cy68ixhj6fd567hk5lldca30-patchelf-0.14.3 /nix/store/59jmzisg8fkm9c125fw384dqq1np602l-move-docs.sh /nix/store/kxw6q8v6isaqjm702d71n2421cxamq68-make-symlinks-relative.sh /nix/store/m54bmrhj6fqz8nds5zcj97w9s9bckc9v-compress-man-pages.sh /nix/store/bkxq1nfi6grmww5756ynr1aph7w04lkk-strip.sh /nix/store/bnj8d7mvbkg3vdb07yz74yhl3g107qq5-patch-shebangs.sh /nix/store/cickvswrvann041nqxb0rxilc46svw1n-prune-libtool-files.sh /nix/store/8zxndz5ag0p6s526c2xyllhk1nrn4c3i-audit-tmpdir.sh /nix/store/c8n9kcdddp9np665xz6ri61b383nxvz8-move-systemd-user-units.sh /nix/store/1i5y55x4b4m9qkx5dqbmr1r6bvrqbanw-multiple-outputs.sh /nix/store/kd4xwxjpjxi71jkm6ka0np72if9rm3y0-move-sbin.sh /nix/store/fyaryjvghbkpfnsyw97hb3lyb37s1pd6-move-lib64.sh /nix/store/ngg1cv31c8c7bcm2n8ww4g06nq7s4zhm-set-source-date-epoch-to-latest.sh /nix/store/wlwcf1nw2b21m4gghj70hbg1v7x53ld8-reproducible-builds.sh /nix/store/npm4g1zsj5yzygf6bq46pbi9fqhxisha-gcc-wrapper-10.3.0' |
|
|
depsBuildBuild='' |
|
|
export depsBuildBuild |
|
|
depsBuildBuildPropagated='' |
|
|
export depsBuildBuildPropagated |
|
|
depsBuildTarget='' |
|
|
export depsBuildTarget |
|
|
depsBuildTargetPropagated='' |
|
|
export depsBuildTargetPropagated |
|
|
depsHostHost='' |
|
|
export depsHostHost |
|
|
depsHostHostPropagated='' |
|
|
export depsHostHostPropagated |
|
|
depsTargetTarget='' |
|
|
export depsTargetTarget |
|
|
depsTargetTargetPropagated='' |
|
|
export depsTargetTargetPropagated |
|
|
doCheck='' |
|
|
export doCheck |
|
|
doInstallCheck='' |
|
|
export doInstallCheck |
|
|
dontAddDisableDepTrack='1' |
|
|
export dontAddDisableDepTrack |
|
|
declare -a envBuildBuildHooks=() |
|
|
declare -a envBuildHostHooks=() |
|
|
declare -a envBuildTargetHooks=() |
|
|
declare -a envHostHostHooks=('ccWrapper_addCVars' 'bintoolsWrapper_addLDVars' ) |
|
|
declare -a envHostTargetHooks=('ccWrapper_addCVars' 'bintoolsWrapper_addLDVars' ) |
|
|
declare -a envTargetTargetHooks=() |
|
|
declare -a fixupOutputHooks=('if [ -z "${dontPatchELF-}" ]; then patchELF "$prefix"; fi' '_makeSymlinksRelative' 'if [ -z "${dontGzipMan-}" ]; then compressManPages "$prefix"; fi' '_doStrip' 'patchShebangsAuto' '_pruneLibtoolFiles' 'if [[ -z "${noAuditTmpdir-}" && -e "$prefix" ]]; then auditTmpdir "$prefix"; fi' '_moveSystemdUserUnits' '_moveSbin' '_moveLib64' ) |
|
|
guess='12' |
|
|
initialPath='/nix/store/176gh50y24c0lx2bnnmsvf9wazb73php-coreutils-9.0 /nix/store/g0hhds9sdiqds0xxgpn7v4pwcv89varr-findutils-4.8.0 /nix/store/ywy7hggaj6vvgw86vbnyirll697ic5jx-diffutils-3.8 /nix/store/4na05j9gmpp3dwhmnc1q0a108ymf2qjy-gnused-4.8 /nix/store/pkj79ap8x2dalzl63ndpdmxg2crxpjl8-gnugrep-3.7 /nix/store/yabl1gmn7balb15hbcj613jcz0cxny42-gawk-5.1.1 /nix/store/sdpqvnmahizaxbs3nnzmgfgyqsdxb1bw-gnutar-1.34 /nix/store/7f3bipp5x4yiqghnkkv88rfsqzs6fl9z-gzip-1.11 /nix/store/2ccy5zc89zpc2aznqxgvzp4wm1bwj05n-bzip2-1.0.6.0.2-bin /nix/store/vhsx8rivchbvc6xnymyc45vvk7c7dz25-gnumake-4.3 /nix/store/pbfraw351mksnkp2ni9c4rkc9cpp89iv-bash-5.1-p12 /nix/store/hjg2fnn41awrq6xzaq3cjfar6jwfcbw6-patch-2.7.6 /nix/store/cxd7laqdidlqvqrlzsd4cls8470h6rwb-xz-5.2.5-bin' |
|
|
name='nix-shell' |
|
|
export name |
|
|
nativeBuildInputs='/nix/store/bhk8r97h4n6ag1qrplb9q8vjnkfqnq91-hugo-0.92.0' |
|
|
export nativeBuildInputs |
|
|
out='/home/kristof/prv/git/blog/outputs/out' |
|
|
export out |
|
|
outputBin='out' |
|
|
outputDev='out' |
|
|
outputDevdoc='REMOVE' |
|
|
outputDevman='out' |
|
|
outputDoc='out' |
|
|
outputInclude='out' |
|
|
outputInfo='out' |
|
|
outputLib='out' |
|
|
outputMan='out' |
|
|
outputs='out' |
|
|
export outputs |
|
|
patches='' |
|
|
export patches |
|
|
phases='buildPhase' |
|
|
export phases |
|
|
pkg='/nix/store/npm4g1zsj5yzygf6bq46pbi9fqhxisha-gcc-wrapper-10.3.0' |
|
|
declare -a pkgsBuildBuild=() |
|
|
declare -a pkgsBuildHost=('/nix/store/bhk8r97h4n6ag1qrplb9q8vjnkfqnq91-hugo-0.92.0' '/nix/store/9wjacdm5cy68ixhj6fd567hk5lldca30-patchelf-0.14.3' '/nix/store/59jmzisg8fkm9c125fw384dqq1np602l-move-docs.sh' '/nix/store/kxw6q8v6isaqjm702d71n2421cxamq68-make-symlinks-relative.sh' '/nix/store/m54bmrhj6fqz8nds5zcj97w9s9bckc9v-compress-man-pages.sh' '/nix/store/bkxq1nfi6grmww5756ynr1aph7w04lkk-strip.sh' '/nix/store/bnj8d7mvbkg3vdb07yz74yhl3g107qq5-patch-shebangs.sh' '/nix/store/cickvswrvann041nqxb0rxilc46svw1n-prune-libtool-files.sh' '/nix/store/8zxndz5ag0p6s526c2xyllhk1nrn4c3i-audit-tmpdir.sh' '/nix/store/c8n9kcdddp9np665xz6ri61b383nxvz8-move-systemd-user-units.sh' '/nix/store/1i5y55x4b4m9qkx5dqbmr1r6bvrqbanw-multiple-outputs.sh' '/nix/store/kd4xwxjpjxi71jkm6ka0np72if9rm3y0-move-sbin.sh' '/nix/store/fyaryjvghbkpfnsyw97hb3lyb37s1pd6-move-lib64.sh' '/nix/store/ngg1cv31c8c7bcm2n8ww4g06nq7s4zhm-set-source-date-epoch-to-latest.sh' '/nix/store/wlwcf1nw2b21m4gghj70hbg1v7x53ld8-reproducible-builds.sh' '/nix/store/npm4g1zsj5yzygf6bq46pbi9fqhxisha-gcc-wrapper-10.3.0' '/nix/store/w327j7z9wlv7hym4spjzagax7c5hqvrf-binutils-wrapper-2.35.2' ) |
|
|
declare -a pkgsBuildTarget=() |
|
|
declare -a pkgsHostHost=() |
|
|
declare -a pkgsHostTarget=() |
|
|
declare -a pkgsTargetTarget=() |
|
|
declare -a postFixupHooks=('_multioutPropagateDev' ) |
|
|
declare -a postUnpackHooks=('_updateSourceDateEpochFromSourceRoot' ) |
|
|
declare -a preConfigureHooks=('_multioutConfig' ) |
|
|
declare -a preFixupHooks=('_moveToShare' '_multioutDocs' '_multioutDevs' ) |
|
|
prefix='/home/kristof/prv/git/blog/outputs/out' |
|
|
declare -a propagatedBuildDepFiles=('propagated-build-build-deps' 'propagated-native-build-inputs' 'propagated-build-target-deps' ) |
|
|
propagatedBuildInputs='' |
|
|
export propagatedBuildInputs |
|
|
declare -a propagatedHostDepFiles=('propagated-host-host-deps' 'propagated-build-inputs' ) |
|
|
propagatedNativeBuildInputs='' |
|
|
export propagatedNativeBuildInputs |
|
|
declare -a propagatedTargetDepFiles=('propagated-target-target-deps' ) |
|
|
shell='/nix/store/pbfraw351mksnkp2ni9c4rkc9cpp89iv-bash-5.1-p12/bin/bash' |
|
|
export shell |
|
|
shellHook='' |
|
|
export shellHook |
|
|
stdenv='/nix/store/1sa0afk52ww5by5ibrv3v54l90wzk480-stdenv-linux' |
|
|
export stdenv |
|
|
strictDeps='' |
|
|
export strictDeps |
|
|
system='x86_64-linux' |
|
|
export system |
|
|
declare -a unpackCmdHooks=('_defaultUnpack' ) |
|
|
_activatePkgs () |
|
|
{ |
|
|
|
|
|
local hostOffset targetOffset; |
|
|
local pkg; |
|
|
for hostOffset in "${allPlatOffsets[@]}"; |
|
|
do |
|
|
local pkgsVar="${pkgAccumVarVars[hostOffset + 1]}"; |
|
|
for targetOffset in "${allPlatOffsets[@]}"; |
|
|
do |
|
|
(( hostOffset <= targetOffset )) || continue; |
|
|
local pkgsRef="${pkgsVar}[$targetOffset - $hostOffset]"; |
|
|
local pkgsSlice="${!pkgsRef}[@]"; |
|
|
for pkg in ${!pkgsSlice+"${!pkgsSlice}"}; |
|
|
do |
|
|
activatePackage "$pkg" "$hostOffset" "$targetOffset"; |
|
|
done; |
|
|
done; |
|
|
done |
|
|
} |
|
|
_addRpathPrefix () |
|
|
{ |
|
|
|
|
|
if [ "${NIX_NO_SELF_RPATH:-0}" != 1 ]; then |
|
|
export NIX_LDFLAGS="-rpath $1/lib ${NIX_LDFLAGS-}"; |
|
|
if [ -n "${NIX_LIB64_IN_SELF_RPATH:-}" ]; then |
|
|
export NIX_LDFLAGS="-rpath $1/lib64 ${NIX_LDFLAGS-}"; |
|
|
fi; |
|
|
if [ -n "${NIX_LIB32_IN_SELF_RPATH:-}" ]; then |
|
|
export NIX_LDFLAGS="-rpath $1/lib32 ${NIX_LDFLAGS-}"; |
|
|
fi; |
|
|
fi |
|
|
} |
|
|
_addToEnv () |
|
|
{ |
|
|
|
|
|
local depHostOffset depTargetOffset; |
|
|
local pkg; |
|
|
for depHostOffset in "${allPlatOffsets[@]}"; |
|
|
do |
|
|
local hookVar="${pkgHookVarVars[depHostOffset + 1]}"; |
|
|
local pkgsVar="${pkgAccumVarVars[depHostOffset + 1]}"; |
|
|
for depTargetOffset in "${allPlatOffsets[@]}"; |
|
|
do |
|
|
(( depHostOffset <= depTargetOffset )) || continue; |
|
|
local hookRef="${hookVar}[$depTargetOffset - $depHostOffset]"; |
|
|
if [[ -z "${strictDeps-}" ]]; then |
|
|
local visitedPkgs=""; |
|
|
for pkg in "${pkgsBuildBuild[@]}" "${pkgsBuildHost[@]}" "${pkgsBuildTarget[@]}" "${pkgsHostHost[@]}" "${pkgsHostTarget[@]}" "${pkgsTargetTarget[@]}"; |
|
|
do |
|
|
if [[ "$visitedPkgs" = *"$pkg"* ]]; then |
|
|
continue; |
|
|
fi; |
|
|
runHook "${!hookRef}" "$pkg"; |
|
|
visitedPkgs+=" $pkg"; |
|
|
done; |
|
|
else |
|
|
local pkgsRef="${pkgsVar}[$depTargetOffset - $depHostOffset]"; |
|
|
local pkgsSlice="${!pkgsRef}[@]"; |
|
|
for pkg in ${!pkgsSlice+"${!pkgsSlice}"}; |
|
|
do |
|
|
runHook "${!hookRef}" "$pkg"; |
|
|
done; |
|
|
fi; |
|
|
done; |
|
|
done |
|
|
} |
|
|
_allFlags () |
|
|
{ |
|
|
|
|
|
for varName in $(awk 'BEGIN { for (v in ENVIRON) if (v ~ /^[a-z][a-zA-Z0-9_]*$/) print v }'); |
|
|
do |
|
|
if (( "${NIX_DEBUG:-0}" >= 1 )); then |
|
|
printf "@%s@ -> %q\n" "${varName}" "${!varName}"; |
|
|
fi; |
|
|
args+=("--subst-var" "$varName"); |
|
|
done |
|
|
} |
|
|
_assignFirst () |
|
|
{ |
|
|
|
|
|
local varName="$1"; |
|
|
local REMOVE=REMOVE; |
|
|
shift; |
|
|
while (( $# )); do |
|
|
if [ -n "${!1-}" ]; then |
|
|
eval "${varName}"="$1"; |
|
|
return; |
|
|
fi; |
|
|
shift; |
|
|
done; |
|
|
echo "Error: _assignFirst found no valid variant!"; |
|
|
return 1 |
|
|
} |
|
|
_callImplicitHook () |
|
|
{ |
|
|
|
|
|
local def="$1"; |
|
|
local hookName="$2"; |
|
|
if declare -F "$hookName" > /dev/null; then |
|
|
"$hookName"; |
|
|
else |
|
|
if type -p "$hookName" > /dev/null; then |
|
|
source "$hookName"; |
|
|
else |
|
|
if [ -n "${!hookName:-}" ]; then |
|
|
eval "${!hookName}"; |
|
|
else |
|
|
return "$def"; |
|
|
fi; |
|
|
fi; |
|
|
fi |
|
|
} |
|
|
_defaultUnpack () |
|
|
{ |
|
|
|
|
|
local fn="$1"; |
|
|
if [ -d "$fn" ]; then |
|
|
cp -pr --reflink=auto -- "$fn" "$(stripHash "$fn")"; |
|
|
else |
|
|
case "$fn" in |
|
|
*.tar.xz | *.tar.lzma | *.txz) |
|
|
xz -d < "$fn" | tar xf - --warning=no-timestamp |
|
|
;; |
|
|
*.tar | *.tar.* | *.tgz | *.tbz2 | *.tbz) |
|
|
tar xf "$fn" --warning=no-timestamp |
|
|
;; |
|
|
*) |
|
|
return 1 |
|
|
;; |
|
|
esac; |
|
|
fi |
|
|
} |
|
|
_doStrip () |
|
|
{ |
|
|
|
|
|
local -ra flags=(dontStripHost dontStripTarget); |
|
|
local -ra stripCmds=(STRIP TARGET_STRIP); |
|
|
if [[ "${STRIP-}" == "${TARGET_STRIP-}" ]]; then |
|
|
dontStripTarget+=1; |
|
|
fi; |
|
|
local i; |
|
|
for i in ${!stripCmds[@]}; |
|
|
do |
|
|
local -n flag="${flags[$i]}"; |
|
|
local -n stripCmd="${stripCmds[$i]}"; |
|
|
if [[ -n "${dontStrip-}" || -n "${flag-}" ]] || ! type -f "${stripCmd-}" 2> /dev/null; then |
|
|
continue; |
|
|
fi; |
|
|
stripDebugList=${stripDebugList:-lib lib32 lib64 libexec bin sbin}; |
|
|
if [ -n "$stripDebugList" ]; then |
|
|
stripDirs "$stripCmd" "$stripDebugList" "${stripDebugFlags:--S}"; |
|
|
fi; |
|
|
stripAllList=${stripAllList:-}; |
|
|
if [ -n "$stripAllList" ]; then |
|
|
stripDirs "$stripCmd" "$stripAllList" "${stripAllFlags:--s}"; |
|
|
fi; |
|
|
done |
|
|
} |
|
|
_eval () |
|
|
{ |
|
|
|
|
|
if declare -F "$1" > /dev/null 2>&1; then |
|
|
"$@"; |
|
|
else |
|
|
eval "$1"; |
|
|
fi |
|
|
} |
|
|
_makeSymlinksRelative () |
|
|
{ |
|
|
|
|
|
local symlinkTarget; |
|
|
if [ -n "${dontRewriteSymlinks-}" ]; then |
|
|
return 0; |
|
|
fi; |
|
|
while IFS= read -r -d '' f; do |
|
|
symlinkTarget=$(readlink "$f"); |
|
|
if [[ "$symlinkTarget"/ != "$prefix"/* ]]; then |
|
|
continue; |
|
|
fi; |
|
|
if [ ! -e "$symlinkTarget" ]; then |
|
|
echo "the symlink $f is broken, it points to $symlinkTarget (which is missing)"; |
|
|
fi; |
|
|
echo "rewriting symlink $f to be relative to $prefix"; |
|
|
ln -snrf "$symlinkTarget" "$f"; |
|
|
done < <(find $prefix -type l -print0) |
|
|
} |
|
|
_moveLib64 () |
|
|
{ |
|
|
|
|
|
if [ "${dontMoveLib64-}" = 1 ]; then |
|
|
return; |
|
|
fi; |
|
|
if [ ! -e "$prefix/lib64" -o -L "$prefix/lib64" ]; then |
|
|
return; |
|
|
fi; |
|
|
echo "moving $prefix/lib64/* to $prefix/lib"; |
|
|
mkdir -p $prefix/lib; |
|
|
shopt -s dotglob; |
|
|
for i in $prefix/lib64/*; |
|
|
do |
|
|
mv --no-clobber "$i" $prefix/lib; |
|
|
done; |
|
|
shopt -u dotglob; |
|
|
rmdir $prefix/lib64; |
|
|
ln -s lib $prefix/lib64 |
|
|
} |
|
|
_moveSbin () |
|
|
{ |
|
|
|
|
|
if [ "${dontMoveSbin-}" = 1 ]; then |
|
|
return; |
|
|
fi; |
|
|
if [ ! -e "$prefix/sbin" -o -L "$prefix/sbin" ]; then |
|
|
return; |
|
|
fi; |
|
|
echo "moving $prefix/sbin/* to $prefix/bin"; |
|
|
mkdir -p $prefix/bin; |
|
|
shopt -s dotglob; |
|
|
for i in $prefix/sbin/*; |
|
|
do |
|
|
mv "$i" $prefix/bin; |
|
|
done; |
|
|
shopt -u dotglob; |
|
|
rmdir $prefix/sbin; |
|
|
ln -s bin $prefix/sbin |
|
|
} |
|
|
_moveSystemdUserUnits () |
|
|
{ |
|
|
|
|
|
if [ "${dontMoveSystemdUserUnits:-0}" = 1 ]; then |
|
|
return; |
|
|
fi; |
|
|
if [ ! -e "${prefix:?}/lib/systemd/user" ]; then |
|
|
return; |
|
|
fi; |
|
|
local source="$prefix/lib/systemd/user"; |
|
|
local target="$prefix/share/systemd/user"; |
|
|
echo "moving $source/* to $target"; |
|
|
mkdir -p "$target"; |
|
|
( shopt -s dotglob; |
|
|
for i in "$source"/*; |
|
|
do |
|
|
mv "$i" "$target"; |
|
|
done ); |
|
|
rmdir "$source"; |
|
|
ln -s "$target" "$source" |
|
|
} |
|
|
_moveToShare () |
|
|
{ |
|
|
|
|
|
forceShare=${forceShare:=man doc info}; |
|
|
if [[ -z "$out" ]]; then |
|
|
return; |
|
|
fi; |
|
|
for d in $forceShare; |
|
|
do |
|
|
if [ -d "$out/$d" ]; then |
|
|
if [ -d "$out/share/$d" ]; then |
|
|
echo "both $d/ and share/$d/ exist!"; |
|
|
else |
|
|
echo "moving $out/$d to $out/share/$d"; |
|
|
mkdir -p $out/share; |
|
|
mv $out/$d $out/share/; |
|
|
fi; |
|
|
fi; |
|
|
done |
|
|
} |
|
|
_multioutConfig () |
|
|
{ |
|
|
|
|
|
if [ "$outputs" = "out" ] || [ -z "${setOutputFlags-1}" ]; then |
|
|
return; |
|
|
fi; |
|
|
if [ -z "$shareDocName" ]; then |
|
|
local confScript="$configureScript"; |
|
|
if [ -z "$confScript" ] && [ -x ./configure ]; then |
|
|
confScript=./configure; |
|
|
fi; |
|
|
if [ -f "$confScript" ]; then |
|
|
local shareDocName="$(sed -n "s/^PACKAGE_TARNAME='\(.*\)'$/\1/p" < "$confScript")"; |
|
|
fi; |
|
|
if [ -z "$shareDocName" ] || echo "$shareDocName" | grep -q '[^a-zA-Z0-9_-]'; then |
|
|
shareDocName="$(echo "$name" | sed 's/-[^a-zA-Z].*//')"; |
|
|
fi; |
|
|
fi; |
|
|
configureFlags=" --bindir=${!outputBin}/bin --sbindir=${!outputBin}/sbin --includedir=${!outputInclude}/include --oldincludedir=${!outputInclude}/include --mandir=${!outputMan}/share/man --infodir=${!outputInfo}/share/info --docdir=${!outputDoc}/share/doc/${shareDocName} --libdir=${!outputLib}/lib --libexecdir=${!outputLib}/libexec --localedir=${!outputLib}/share/locale $configureFlags"; |
|
|
installFlags=" pkgconfigdir=${!outputDev}/lib/pkgconfig m4datadir=${!outputDev}/share/aclocal aclocaldir=${!outputDev}/share/aclocal $installFlags" |
|
|
} |
|
|
_multioutDevs () |
|
|
{ |
|
|
|
|
|
if [ "$outputs" = "out" ] || [ -z "${moveToDev-1}" ]; then |
|
|
return; |
|
|
fi; |
|
|
moveToOutput include "${!outputInclude}"; |
|
|
moveToOutput lib/pkgconfig "${!outputDev}"; |
|
|
moveToOutput share/pkgconfig "${!outputDev}"; |
|
|
moveToOutput lib/cmake "${!outputDev}"; |
|
|
moveToOutput share/aclocal "${!outputDev}"; |
|
|
for f in "${!outputDev}"/{lib,share}/pkgconfig/*.pc; |
|
|
do |
|
|
echo "Patching '$f' includedir to output ${!outputInclude}"; |
|
|
sed -i "/^includedir=/s,=\${prefix},=${!outputInclude}," "$f"; |
|
|
done |
|
|
} |
|
|
_multioutDocs () |
|
|
{ |
|
|
|
|
|
local REMOVE=REMOVE; |
|
|
moveToOutput share/info "${!outputInfo}"; |
|
|
moveToOutput share/doc "${!outputDoc}"; |
|
|
moveToOutput share/gtk-doc "${!outputDevdoc}"; |
|
|
moveToOutput share/devhelp/books "${!outputDevdoc}"; |
|
|
moveToOutput share/man "${!outputMan}"; |
|
|
moveToOutput share/man/man3 "${!outputDevman}" |
|
|
} |
|
|
_multioutPropagateDev () |
|
|
{ |
|
|
|
|
|
if [ "$outputs" = "out" ]; then |
|
|
return; |
|
|
fi; |
|
|
local outputFirst; |
|
|
for outputFirst in $outputs; |
|
|
do |
|
|
break; |
|
|
done; |
|
|
local propagaterOutput="$outputDev"; |
|
|
if [ -z "$propagaterOutput" ]; then |
|
|
propagaterOutput="$outputFirst"; |
|
|
fi; |
|
|
if [ -z "${propagatedBuildOutputs+1}" ]; then |
|
|
local po_dirty="$outputBin $outputInclude $outputLib"; |
|
|
set +o pipefail; |
|
|
propagatedBuildOutputs=`echo "$po_dirty" | tr -s ' ' '\n' | grep -v -F "$propagaterOutput" | sort -u | tr '\n' ' ' `; |
|
|
set -o pipefail; |
|
|
fi; |
|
|
if [ -z "$propagatedBuildOutputs" ]; then |
|
|
return; |
|
|
fi; |
|
|
mkdir -p "${!propagaterOutput}"/nix-support; |
|
|
for output in $propagatedBuildOutputs; |
|
|
do |
|
|
echo -n " ${!output}" >> "${!propagaterOutput}"/nix-support/propagated-build-inputs; |
|
|
done |
|
|
} |
|
|
_overrideFirst () |
|
|
{ |
|
|
|
|
|
if [ -z "${!1-}" ]; then |
|
|
_assignFirst "$@"; |
|
|
fi |
|
|
} |
|
|
_pruneLibtoolFiles () |
|
|
{ |
|
|
|
|
|
if [ "${dontPruneLibtoolFiles-}" ] || [ ! -e "$prefix" ]; then |
|
|
return; |
|
|
fi; |
|
|
find "$prefix" -type f -name '*.la' -exec grep -q '^# Generated by .*libtool' {} \; -exec grep -q "^old_library=''" {} \; -exec sed -i {} -e "/^dependency_libs='[^']/ c dependency_libs='' #pruned" \; |
|
|
} |
|
|
_updateSourceDateEpochFromSourceRoot () |
|
|
{ |
|
|
|
|
|
if [ -n "$sourceRoot" ]; then |
|
|
updateSourceDateEpoch "$sourceRoot"; |
|
|
fi |
|
|
} |
|
|
activatePackage () |
|
|
{ |
|
|
|
|
|
local pkg="$1"; |
|
|
local -r hostOffset="$2"; |
|
|
local -r targetOffset="$3"; |
|
|
(( hostOffset <= targetOffset )) || exit -1; |
|
|
if [ -f "$pkg" ]; then |
|
|
source "$pkg"; |
|
|
fi; |
|
|
if [[ -z "${strictDeps-}" || "$hostOffset" -le -1 ]]; then |
|
|
addToSearchPath _PATH "$pkg/bin"; |
|
|
fi; |
|
|
if (( hostOffset <= -1 )); then |
|
|
addToSearchPath _XDG_DATA_DIRS "$pkg/share"; |
|
|
fi; |
|
|
if [[ "$hostOffset" -eq 0 && -d "$pkg/bin" ]]; then |
|
|
addToSearchPath _HOST_PATH "$pkg/bin"; |
|
|
fi; |
|
|
if [[ -f "$pkg/nix-support/setup-hook" ]]; then |
|
|
source "$pkg/nix-support/setup-hook"; |
|
|
fi |
|
|
} |
|
|
addEnvHooks () |
|
|
{ |
|
|
|
|
|
local depHostOffset="$1"; |
|
|
shift; |
|
|
local pkgHookVarsSlice="${pkgHookVarVars[$depHostOffset + 1]}[@]"; |
|
|
local pkgHookVar; |
|
|
for pkgHookVar in "${!pkgHookVarsSlice}"; |
|
|
do |
|
|
eval "${pkgHookVar}s"'+=("$@")'; |
|
|
done |
|
|
} |
|
|
addToSearchPath () |
|
|
{ |
|
|
|
|
|
addToSearchPathWithCustomDelimiter ":" "$@" |
|
|
} |
|
|
addToSearchPathWithCustomDelimiter () |
|
|
{ |
|
|
|
|
|
local delimiter="$1"; |
|
|
local varName="$2"; |
|
|
local dir="$3"; |
|
|
if [[ -d "$dir" && "${!varName:+${delimiter}${!varName}${delimiter}}" != *"${delimiter}${dir}${delimiter}"* ]]; then |
|
|
export "${varName}=${!varName:+${!varName}${delimiter}}${dir}"; |
|
|
fi |
|
|
} |
|
|
auditTmpdir () |
|
|
{ |
|
|
|
|
|
local dir="$1"; |
|
|
[ -e "$dir" ] || return 0; |
|
|
header "checking for references to $TMPDIR/ in $dir..."; |
|
|
local i; |
|
|
while IFS= read -r -d '' i; do |
|
|
if [[ "$i" =~ .build-id ]]; then |
|
|
continue; |
|
|
fi; |
|
|
if isELF "$i"; then |
|
|
if { |
|
|
printf :; |
|
|
patchelf --print-rpath "$i" |
|
|
} | grep -q -F ":$TMPDIR/"; then |
|
|
echo "RPATH of binary $i contains a forbidden reference to $TMPDIR/"; |
|
|
exit 1; |
|
|
fi; |
|
|
fi; |
|
|
if isScript "$i"; then |
|
|
if [ -e "$(dirname "$i")/.$(basename "$i")-wrapped" ]; then |
|
|
if grep -q -F "$TMPDIR/" "$i"; then |
|
|
echo "wrapper script $i contains a forbidden reference to $TMPDIR/"; |
|
|
exit 1; |
|
|
fi; |
|
|
fi; |
|
|
fi; |
|
|
done < <(find "$dir" -type f -print0); |
|
|
stopNest |
|
|
} |
|
|
bintoolsWrapper_addLDVars () |
|
|
{ |
|
|
|
|
|
local role_post; |
|
|
getHostRoleEnvHook; |
|
|
if [[ -d "$1/lib64" && ! -L "$1/lib64" ]]; then |
|
|
export NIX_LDFLAGS${role_post}+=" -L$1/lib64"; |
|
|
fi; |
|
|
if [[ -d "$1/lib" ]]; then |
|
|
local -a glob=($1/lib/lib*); |
|
|
if [ "${#glob[*]}" -gt 0 ]; then |
|
|
export NIX_LDFLAGS${role_post}+=" -L$1/lib"; |
|
|
fi; |
|
|
fi |
|
|
} |
|
|
buildPhase () |
|
|
{ |
|
|
|
|
|
runHook preBuild; |
|
|
: ${makeFlags=}; |
|
|
if [[ -z "$makeFlags" && -z "${makefile:-}" && ! ( -e Makefile || -e makefile || -e GNUmakefile ) ]]; then |
|
|
echo "no Makefile, doing nothing"; |
|
|
else |
|
|
foundMakefile=1; |
|
|
local flagsArray=(${enableParallelBuilding:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}} SHELL=$SHELL $makeFlags "${makeFlagsArray[@]}" $buildFlags "${buildFlagsArray[@]}"); |
|
|
echoCmd 'build flags' "${flagsArray[@]}"; |
|
|
make ${makefile:+-f $makefile} "${flagsArray[@]}"; |
|
|
unset flagsArray; |
|
|
fi; |
|
|
runHook postBuild |
|
|
} |
|
|
ccWrapper_addCVars () |
|
|
{ |
|
|
|
|
|
local role_post; |
|
|
getHostRoleEnvHook; |
|
|
if [ -d "$1/include" ]; then |
|
|
export NIX_CFLAGS_COMPILE${role_post}+=" -isystem $1/include"; |
|
|
fi; |
|
|
if [ -d "$1/Library/Frameworks" ]; then |
|
|
export NIX_CFLAGS_COMPILE${role_post}+=" -iframework $1/Library/Frameworks"; |
|
|
fi |
|
|
} |
|
|
checkPhase () |
|
|
{ |
|
|
|
|
|
runHook preCheck; |
|
|
if [[ -z "${foundMakefile:-}" ]]; then |
|
|
echo "no Makefile or custom checkPhase, doing nothing"; |
|
|
runHook postCheck; |
|
|
return; |
|
|
fi; |
|
|
if [[ -z "${checkTarget:-}" ]]; then |
|
|
if make -n ${makefile:+-f $makefile} check > /dev/null 2>&1; then |
|
|
checkTarget=check; |
|
|
else |
|
|
if make -n ${makefile:+-f $makefile} test > /dev/null 2>&1; then |
|
|
checkTarget=test; |
|
|
fi; |
|
|
fi; |
|
|
fi; |
|
|
if [[ -z "${checkTarget:-}" ]]; then |
|
|
echo "no check/test target in ${makefile:-Makefile}, doing nothing"; |
|
|
else |
|
|
local flagsArray=(${enableParallelChecking:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}} SHELL=$SHELL $makeFlags "${makeFlagsArray[@]}" ${checkFlags:-VERBOSE=y} "${checkFlagsArray[@]}" ${checkTarget}); |
|
|
echoCmd 'check flags' "${flagsArray[@]}"; |
|
|
make ${makefile:+-f $makefile} "${flagsArray[@]}"; |
|
|
unset flagsArray; |
|
|
fi; |
|
|
runHook postCheck |
|
|
} |
|
|
closeNest () |
|
|
{ |
|
|
|
|
|
true |
|
|
} |
|
|
compressManPages () |
|
|
{ |
|
|
|
|
|
local dir="$1"; |
|
|
if [ -L "$dir"/share ] || [ -L "$dir"/share/man ] || [ ! -d "$dir/share/man" ]; then |
|
|
return; |
|
|
fi; |
|
|
echo "gzipping man pages under $dir/share/man/"; |
|
|
find "$dir"/share/man/ -type f -a '!' -regex '.*\.\(bz2\|gz\|xz\)$' -print0 | while IFS= read -r -d '' f; do |
|
|
if gzip -c -n "$f" > "$f".gz; then |
|
|
rm "$f"; |
|
|
else |
|
|
rm "$f".gz; |
|
|
fi; |
|
|
done; |
|
|
find "$dir"/share/man/ -type l -a '!' -regex '.*\.\(bz2\|gz\|xz\)$' -print0 | sort -z | while IFS= read -r -d '' f; do |
|
|
local target; |
|
|
target="$(readlink -f "$f")"; |
|
|
if [ -f "$target".gz ]; then |
|
|
ln -sf "$target".gz "$f".gz && rm "$f"; |
|
|
fi; |
|
|
done |
|
|
} |
|
|
configurePhase () |
|
|
{ |
|
|
|
|
|
runHook preConfigure; |
|
|
: ${configureScript=}; |
|
|
: ${configureFlags=}; |
|
|
if [[ -z "$configureScript" && -x ./configure ]]; then |
|
|
configureScript=./configure; |
|
|
fi; |
|
|
if [ -z "${dontFixLibtool:-}" ]; then |
|
|
export lt_cv_deplibs_check_method="${lt_cv_deplibs_check_method-pass_all}"; |
|
|
local i; |
|
|
find . -iname "ltmain.sh" -print0 | while IFS='' read -r -d '' i; do |
|
|
echo "fixing libtool script $i"; |
|
|
fixLibtool "$i"; |
|
|
done; |
|
|
fi; |
|
|
if [[ -z "${dontAddPrefix:-}" && -n "$prefix" ]]; then |
|
|
configureFlags="${prefixKey:---prefix=}$prefix $configureFlags"; |
|
|
fi; |
|
|
if [[ -f "$configureScript" ]]; then |
|
|
if [ -z "${dontAddDisableDepTrack:-}" ]; then |
|
|
if grep -q dependency-tracking "$configureScript"; then |
|
|
configureFlags="--disable-dependency-tracking $configureFlags"; |
|
|
fi; |
|
|
fi; |
|
|
if [ -z "${dontDisableStatic:-}" ]; then |
|
|
if grep -q enable-static "$configureScript"; then |
|
|
configureFlags="--disable-static $configureFlags"; |
|
|
fi; |
|
|
fi; |
|
|
fi; |
|
|
if [ -n "$configureScript" ]; then |
|
|
local flagsArray=($configureFlags "${configureFlagsArray[@]}"); |
|
|
echoCmd 'configure flags' "${flagsArray[@]}"; |
|
|
$configureScript "${flagsArray[@]}"; |
|
|
unset flagsArray; |
|
|
else |
|
|
echo "no configure script, doing nothing"; |
|
|
fi; |
|
|
runHook postConfigure |
|
|
} |
|
|
consumeEntire () |
|
|
{ |
|
|
|
|
|
if IFS='' read -r -d '' $1; then |
|
|
echo "consumeEntire(): ERROR: Input null bytes, won't process" 1>&2; |
|
|
return 1; |
|
|
fi |
|
|
} |
|
|
distPhase () |
|
|
{ |
|
|
|
|
|
runHook preDist; |
|
|
local flagsArray=($distFlags "${distFlagsArray[@]}" ${distTarget:-dist}); |
|
|
echo 'dist flags: %q' "${flagsArray[@]}"; |
|
|
make ${makefile:+-f $makefile} "${flagsArray[@]}"; |
|
|
if [ "${dontCopyDist:-0}" != 1 ]; then |
|
|
mkdir -p "$out/tarballs"; |
|
|
cp -pvd ${tarballs:-*.tar.gz} "$out/tarballs"; |
|
|
fi; |
|
|
runHook postDist |
|
|
} |
|
|
dumpVars () |
|
|
{ |
|
|
|
|
|
if [ "${noDumpEnvVars:-0}" != 1 ]; then |
|
|
export 2> /dev/null >| "$NIX_BUILD_TOP/env-vars" || true; |
|
|
fi |
|
|
} |
|
|
echoCmd () |
|
|
{ |
|
|
|
|
|
printf "%s:" "$1"; |
|
|
shift; |
|
|
printf ' %q' "$@"; |
|
|
echo |
|
|
} |
|
|
exitHandler () |
|
|
{ |
|
|
|
|
|
exitCode="$?"; |
|
|
set +e; |
|
|
if [ -n "${showBuildStats:-}" ]; then |
|
|
read -r -d '' -a buildTimes < <(times); |
|
|
echo "build times:"; |
|
|
echo "user time for the shell ${buildTimes[0]}"; |
|
|
echo "system time for the shell ${buildTimes[1]}"; |
|
|
echo "user time for all child processes ${buildTimes[2]}"; |
|
|
echo "system time for all child processes ${buildTimes[3]}"; |
|
|
fi; |
|
|
if (( "$exitCode" != 0 )); then |
|
|
runHook failureHook; |
|
|
if [ -n "${succeedOnFailure:-}" ]; then |
|
|
echo "build failed with exit code $exitCode (ignored)"; |
|
|
mkdir -p "$out/nix-support"; |
|
|
printf "%s" "$exitCode" > "$out/nix-support/failed"; |
|
|
exit 0; |
|
|
fi; |
|
|
else |
|
|
runHook exitHook; |
|
|
fi; |
|
|
exit "$exitCode" |
|
|
} |
|
|
findInputs () |
|
|
{ |
|
|
|
|
|
local -r pkg="$1"; |
|
|
local -r hostOffset="$2"; |
|
|
local -r targetOffset="$3"; |
|
|
(( hostOffset <= targetOffset )) || exit -1; |
|
|
local varVar="${pkgAccumVarVars[hostOffset + 1]}"; |
|
|
local varRef="$varVar[$((targetOffset - hostOffset))]"; |
|
|
local var="${!varRef}"; |
|
|
unset -v varVar varRef; |
|
|
local varSlice="$var[*]"; |
|
|
case "${!varSlice-}" in |
|
|
*" $pkg "*) |
|
|
return 0 |
|
|
;; |
|
|
esac; |
|
|
unset -v varSlice; |
|
|
eval "$var"'+=("$pkg")'; |
|
|
if ! [ -e "$pkg" ]; then |
|
|
echo "build input $pkg does not exist" 1>&2; |
|
|
exit 1; |
|
|
fi; |
|
|
function mapOffset () |
|
|
{ |
|
|
local -r inputOffset="$1"; |
|
|
local -n outputOffset="$2"; |
|
|
if (( inputOffset <= 0 )); then |
|
|
outputOffset=$((inputOffset + hostOffset)); |
|
|
else |
|
|
outputOffset=$((inputOffset - 1 + targetOffset)); |
|
|
fi |
|
|
}; |
|
|
local relHostOffset; |
|
|
for relHostOffset in "${allPlatOffsets[@]}"; |
|
|
do |
|
|
local files="${propagatedDepFilesVars[relHostOffset + 1]}"; |
|
|
local hostOffsetNext; |
|
|
mapOffset "$relHostOffset" hostOffsetNext; |
|
|
(( -1 <= hostOffsetNext && hostOffsetNext <= 1 )) || continue; |
|
|
local relTargetOffset; |
|
|
for relTargetOffset in "${allPlatOffsets[@]}"; |
|
|
do |
|
|
(( "$relHostOffset" <= "$relTargetOffset" )) || continue; |
|
|
local fileRef="${files}[$relTargetOffset - $relHostOffset]"; |
|
|
local file="${!fileRef}"; |
|
|
unset -v fileRef; |
|
|
local targetOffsetNext; |
|
|
mapOffset "$relTargetOffset" targetOffsetNext; |
|
|
(( -1 <= hostOffsetNext && hostOffsetNext <= 1 )) || continue; |
|
|
[[ -f "$pkg/nix-support/$file" ]] || continue; |
|
|
local pkgNext; |
|
|
read -r -d '' pkgNext < "$pkg/nix-support/$file" || true; |
|
|
for pkgNext in $pkgNext; |
|
|
do |
|
|
findInputs "$pkgNext" "$hostOffsetNext" "$targetOffsetNext"; |
|
|
done; |
|
|
done; |
|
|
done |
|
|
} |
|
|
fixLibtool () |
|
|
{ |
|
|
|
|
|
local search_path; |
|
|
for flag in $NIX_LDFLAGS; |
|
|
do |
|
|
case $flag in |
|
|
-L*) |
|
|
search_path+=" ${flag#-L}" |
|
|
;; |
|
|
esac; |
|
|
done; |
|
|
sed -i "$1" -e "s^eval \(sys_lib_search_path=\).*^\1'$search_path'^" -e 's^eval sys_lib_.+search_path=.*^^' |
|
|
} |
|
|
fixupPhase () |
|
|
{ |
|
|
|
|
|
local output; |
|
|
for output in $outputs; |
|
|
do |
|
|
if [ -e "${!output}" ]; then |
|
|
chmod -R u+w "${!output}"; |
|
|
fi; |
|
|
done; |
|
|
runHook preFixup; |
|
|
local output; |
|
|
for output in $outputs; |
|
|
do |
|
|
prefix="${!output}" runHook fixupOutput; |
|
|
done; |
|
|
declare -ra flatVars=(depsBuildBuildPropagated propagatedNativeBuildInputs depsBuildTargetPropagated depsHostHostPropagated propagatedBuildInputs depsTargetTargetPropagated); |
|
|
declare -ra flatFiles=("${propagatedBuildDepFiles[@]}" "${propagatedHostDepFiles[@]}" "${propagatedTargetDepFiles[@]}"); |
|
|
local propagatedInputsIndex; |
|
|
for propagatedInputsIndex in "${!flatVars[@]}"; |
|
|
do |
|
|
local propagatedInputsSlice="${flatVars[$propagatedInputsIndex]}[@]"; |
|
|
local propagatedInputsFile="${flatFiles[$propagatedInputsIndex]}"; |
|
|
[[ -n "${!propagatedInputsSlice}" ]] || continue; |
|
|
mkdir -p "${!outputDev}/nix-support"; |
|
|
printWords ${!propagatedInputsSlice} > "${!outputDev}/nix-support/$propagatedInputsFile"; |
|
|
done; |
|
|
if [ -n "${setupHook:-}" ]; then |
|
|
mkdir -p "${!outputDev}/nix-support"; |
|
|
substituteAll "$setupHook" "${!outputDev}/nix-support/setup-hook"; |
|
|
fi; |
|
|
if [ -n "${setupHooks:-}" ]; then |
|
|
mkdir -p "${!outputDev}/nix-support"; |
|
|
local hook; |
|
|
for hook in $setupHooks; |
|
|
do |
|
|
local content; |
|
|
consumeEntire content < "$hook"; |
|
|
substituteAllStream content "file '$hook'" >> "${!outputDev}/nix-support/setup-hook"; |
|
|
unset -v content; |
|
|
done; |
|
|
unset -v hook; |
|
|
fi; |
|
|
if [ -n "${propagatedUserEnvPkgs:-}" ]; then |
|
|
mkdir -p "${!outputBin}/nix-support"; |
|
|
printWords $propagatedUserEnvPkgs > "${!outputBin}/nix-support/propagated-user-env-packages"; |
|
|
fi; |
|
|
runHook postFixup |
|
|
} |
|
|
genericBuild () |
|
|
{ |
|
|
|
|
|
if [ -f "${buildCommandPath:-}" ]; then |
|
|
source "$buildCommandPath"; |
|
|
return; |
|
|
fi; |
|
|
if [ -n "${buildCommand:-}" ]; then |
|
|
eval "$buildCommand"; |
|
|
return; |
|
|
fi; |
|
|
if [ -z "${phases:-}" ]; then |
|
|
phases="${prePhases:-} unpackPhase patchPhase ${preConfigurePhases:-} configurePhase ${preBuildPhases:-} buildPhase checkPhase ${preInstallPhases:-} installPhase ${preFixupPhases:-} fixupPhase installCheckPhase ${preDistPhases:-} distPhase ${postPhases:-}"; |
|
|
fi; |
|
|
for curPhase in $phases; |
|
|
do |
|
|
if [[ "$curPhase" = unpackPhase && -n "${dontUnpack:-}" ]]; then |
|
|
continue; |
|
|
fi; |
|
|
if [[ "$curPhase" = patchPhase && -n "${dontPatch:-}" ]]; then |
|
|
continue; |
|
|
fi; |
|
|
if [[ "$curPhase" = configurePhase && -n "${dontConfigure:-}" ]]; then |
|
|
continue; |
|
|
fi; |
|
|
if [[ "$curPhase" = buildPhase && -n "${dontBuild:-}" ]]; then |
|
|
continue; |
|
|
fi; |
|
|
if [[ "$curPhase" = checkPhase && -z "${doCheck:-}" ]]; then |
|
|
continue; |
|
|
fi; |
|
|
if [[ "$curPhase" = installPhase && -n "${dontInstall:-}" ]]; then |
|
|
continue; |
|
|
fi; |
|
|
if [[ "$curPhase" = fixupPhase && -n "${dontFixup:-}" ]]; then |
|
|
continue; |
|
|
fi; |
|
|
if [[ "$curPhase" = installCheckPhase && -z "${doInstallCheck:-}" ]]; then |
|
|
continue; |
|
|
fi; |
|
|
if [[ "$curPhase" = distPhase && -z "${doDist:-}" ]]; then |
|
|
continue; |
|
|
fi; |
|
|
if [[ -n $NIX_LOG_FD ]]; then |
|
|
echo "@nix { \"action\": \"setPhase\", \"phase\": \"$curPhase\" }" 1>&$NIX_LOG_FD; |
|
|
fi; |
|
|
showPhaseHeader "$curPhase"; |
|
|
dumpVars; |
|
|
eval "${!curPhase:-$curPhase}"; |
|
|
if [ "$curPhase" = unpackPhase ]; then |
|
|
cd "${sourceRoot:-.}"; |
|
|
fi; |
|
|
done |
|
|
} |
|
|
getHostRole () |
|
|
{ |
|
|
|
|
|
getRole "$hostOffset" |
|
|
} |
|
|
getHostRoleEnvHook () |
|
|
{ |
|
|
|
|
|
getRole "$depHostOffset" |
|
|
} |
|
|
getRole () |
|
|
{ |
|
|
|
|
|
case $1 in |
|
|
-1) |
|
|
role_post='_FOR_BUILD' |
|
|
;; |
|
|
0) |
|
|
role_post='' |
|
|
;; |
|
|
1) |
|
|
role_post='_FOR_TARGET' |
|
|
;; |
|
|
*) |
|
|
echo "binutils-wrapper-2.35.2: used as improper sort of dependency" 1>&2; |
|
|
return 1 |
|
|
;; |
|
|
esac |
|
|
} |
|
|
getTargetRole () |
|
|
{ |
|
|
|
|
|
getRole "$targetOffset" |
|
|
} |
|
|
getTargetRoleEnvHook () |
|
|
{ |
|
|
|
|
|
getRole "$depTargetOffset" |
|
|
} |
|
|
getTargetRoleWrapper () |
|
|
{ |
|
|
|
|
|
case $targetOffset in |
|
|
-1) |
|
|
export NIX_BINTOOLS_WRAPPER_TARGET_BUILD_x86_64_unknown_linux_gnu=1 |
|
|
;; |
|
|
0) |
|
|
export NIX_BINTOOLS_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu=1 |
|
|
;; |
|
|
1) |
|
|
export NIX_BINTOOLS_WRAPPER_TARGET_TARGET_x86_64_unknown_linux_gnu=1 |
|
|
;; |
|
|
*) |
|
|
echo "binutils-wrapper-2.35.2: used as improper sort of dependency" 1>&2; |
|
|
return 1 |
|
|
;; |
|
|
esac |
|
|
} |
|
|
header () |
|
|
{ |
|
|
|
|
|
echo "$1" |
|
|
} |
|
|
installCheckPhase () |
|
|
{ |
|
|
|
|
|
runHook preInstallCheck; |
|
|
if [[ -z "${foundMakefile:-}" ]]; then |
|
|
echo "no Makefile or custom installCheckPhase, doing nothing"; |
|
|
else |
|
|
if [[ -z "${installCheckTarget:-}" ]] && ! make -n ${makefile:+-f $makefile} ${installCheckTarget:-installcheck} > /dev/null 2>&1; then |
|
|
echo "no installcheck target in ${makefile:-Makefile}, doing nothing"; |
|
|
else |
|
|
local flagsArray=(${enableParallelChecking:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}} SHELL=$SHELL $makeFlags "${makeFlagsArray[@]}" $installCheckFlags "${installCheckFlagsArray[@]}" ${installCheckTarget:-installcheck}); |
|
|
echoCmd 'installcheck flags' "${flagsArray[@]}"; |
|
|
make ${makefile:+-f $makefile} "${flagsArray[@]}"; |
|
|
unset flagsArray; |
|
|
fi; |
|
|
fi; |
|
|
runHook postInstallCheck |
|
|
} |
|
|
installPhase () |
|
|
{ |
|
|
|
|
|
runHook preInstall; |
|
|
if [ -n "$prefix" ]; then |
|
|
mkdir -p "$prefix"; |
|
|
fi; |
|
|
local flagsArray=(SHELL=$SHELL $makeFlags "${makeFlagsArray[@]}" $installFlags "${installFlagsArray[@]}" ${installTargets:-install}); |
|
|
echoCmd 'install flags' "${flagsArray[@]}"; |
|
|
make ${makefile:+-f $makefile} "${flagsArray[@]}"; |
|
|
unset flagsArray; |
|
|
runHook postInstall |
|
|
} |
|
|
isELF () |
|
|
{ |
|
|
|
|
|
local fn="$1"; |
|
|
local fd; |
|
|
local magic; |
|
|
exec {fd}< "$fn"; |
|
|
read -r -n 4 -u "$fd" magic; |
|
|
exec {fd}>&-; |
|
|
if [ "$magic" = 'ELF' ]; then |
|
|
return 0; |
|
|
else |
|
|
return 1; |
|
|
fi |
|
|
} |
|
|
isMachO () |
|
|
{ |
|
|
|
|
|
local fn="$1"; |
|
|
local fd; |
|
|
local magic; |
|
|
exec {fd}< "$fn"; |
|
|
read -r -n 4 -u "$fd" magic; |
|
|
exec {fd}>&-; |
|
|
if [[ "$magic" = $(echo -ne "\xfe\xed\xfa\xcf") || "$magic" = $(echo -ne "\xcf\xfa\xed\xfe") ]]; then |
|
|
return 0; |
|
|
else |
|
|
if [[ "$magic" = $(echo -ne "\xfe\xed\xfa\xce") || "$magic" = $(echo -ne "\xce\xfa\xed\xfe") ]]; then |
|
|
return 0; |
|
|
else |
|
|
if [[ "$magic" = $(echo -ne "\xca\xfe\xba\xbe") || "$magic" = $(echo -ne "\xbe\xba\xfe\xca") ]]; then |
|
|
return 0; |
|
|
else |
|
|
return 1; |
|
|
fi; |
|
|
fi; |
|
|
fi |
|
|
} |
|
|
isScript () |
|
|
{ |
|
|
|
|
|
local fn="$1"; |
|
|
local fd; |
|
|
local magic; |
|
|
exec {fd}< "$fn"; |
|
|
read -r -n 2 -u "$fd" magic; |
|
|
exec {fd}>&-; |
|
|
if [[ "$magic" =~ \#! ]]; then |
|
|
return 0; |
|
|
else |
|
|
return 1; |
|
|
fi |
|
|
} |
|
|
mapOffset () |
|
|
{ |
|
|
|
|
|
local -r inputOffset="$1"; |
|
|
local -n outputOffset="$2"; |
|
|
if (( inputOffset <= 0 )); then |
|
|
outputOffset=$((inputOffset + hostOffset)); |
|
|
else |
|
|
outputOffset=$((inputOffset - 1 + targetOffset)); |
|
|
fi |
|
|
} |
|
|
moveToOutput () |
|
|
{ |
|
|
|
|
|
local patt="$1"; |
|
|
local dstOut="$2"; |
|
|
local output; |
|
|
for output in $outputs; |
|
|
do |
|
|
if [ "${!output}" = "$dstOut" ]; then |
|
|
continue; |
|
|
fi; |
|
|
local srcPath; |
|
|
for srcPath in "${!output}"/$patt; |
|
|
do |
|
|
if [ ! -e "$srcPath" ] && [ ! -L "$srcPath" ]; then |
|
|
continue; |
|
|
fi; |
|
|
if [ "$dstOut" = REMOVE ]; then |
|
|
echo "Removing $srcPath"; |
|
|
rm -r "$srcPath"; |
|
|
else |
|
|
local dstPath="$dstOut${srcPath#${!output}}"; |
|
|
echo "Moving $srcPath to $dstPath"; |
|
|
if [ -d "$dstPath" ] && [ -d "$srcPath" ]; then |
|
|
rmdir "$srcPath" --ignore-fail-on-non-empty; |
|
|
if [ -d "$srcPath" ]; then |
|
|
mv -t "$dstPath" "$srcPath"/*; |
|
|
rmdir "$srcPath"; |
|
|
fi; |
|
|
else |
|
|
mkdir -p "$(readlink -m "$dstPath/..")"; |
|
|
mv "$srcPath" "$dstPath"; |
|
|
fi; |
|
|
fi; |
|
|
local srcParent="$(readlink -m "$srcPath/..")"; |
|
|
if rmdir "$srcParent"; then |
|
|
echo "Removing empty $srcParent/ and (possibly) its parents"; |
|
|
rmdir -p --ignore-fail-on-non-empty "$(readlink -m "$srcParent/..")" 2> /dev/null || true; |
|
|
fi; |
|
|
done; |
|
|
done |
|
|
} |
|
|
patchELF () |
|
|
{ |
|
|
|
|
|
local dir="$1"; |
|
|
[ -e "$dir" ] || return 0; |
|
|
header "shrinking RPATHs of ELF executables and libraries in $dir"; |
|
|
local i; |
|
|
while IFS= read -r -d '' i; do |
|
|
if [[ "$i" =~ .build-id ]]; then |
|
|
continue; |
|
|
fi; |
|
|
if ! isELF "$i"; then |
|
|
continue; |
|
|
fi; |
|
|
echo "shrinking $i"; |
|
|
patchelf --shrink-rpath "$i" || true; |
|
|
done < <(find "$dir" -type f -print0); |
|
|
stopNest |
|
|
} |
|
|
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" |
|
|
;; |
|
|
*.xz) |
|
|
uncompress="xz -d" |
|
|
;; |
|
|
*.lzma) |
|
|
uncompress="lzma -d" |
|
|
;; |
|
|
esac; |
|
|
$uncompress < "$i" 2>&1 | patch ${patchFlags:--p1}; |
|
|
done; |
|
|
runHook postPatch |
|
|
} |
|
|
patchShebangs () |
|
|
{ |
|
|
|
|
|
local pathName; |
|
|
if [[ "$1" == "--host" ]]; then |
|
|
pathName=HOST_PATH; |
|
|
shift; |
|
|
else |
|
|
if [[ "$1" == "--build" ]]; then |
|
|
pathName=PATH; |
|
|
shift; |
|
|
fi; |
|
|
fi; |
|
|
echo "patching script interpreter paths in $@"; |
|
|
local f; |
|
|
local oldPath; |
|
|
local newPath; |
|
|
local arg0; |
|
|
local args; |
|
|
local oldInterpreterLine; |
|
|
local newInterpreterLine; |
|
|
if [[ $# -eq 0 ]]; then |
|
|
echo "No arguments supplied to patchShebangs" 1>&2; |
|
|
return 0; |
|
|
fi; |
|
|
local f; |
|
|
while IFS= read -r -d '' f; do |
|
|
isScript "$f" || continue; |
|
|
read -r oldInterpreterLine < "$f"; |
|
|
read -r oldPath arg0 args <<< "${oldInterpreterLine:2}"; |
|
|
if [[ -z "$pathName" ]]; then |
|
|
if [[ -n $strictDeps && $f == "$NIX_STORE"* ]]; then |
|
|
pathName=HOST_PATH; |
|
|
else |
|
|
pathName=PATH; |
|
|
fi; |
|
|
fi; |
|
|
if [[ "$oldPath" == *"/bin/env" ]]; then |
|
|
if [[ $arg0 == "-"* || $arg0 == *"="* ]]; then |
|
|
echo "$f: unsupported interpreter directive \"$oldInterpreterLine\" (set dontPatchShebangs=1 and handle shebang patching yourself)" 1>&2; |
|
|
exit 1; |
|
|
fi; |
|
|
newPath="$(PATH="${!pathName}" command -v "$arg0" || true)"; |
|
|
else |
|
|
if [[ -z $oldPath ]]; then |
|
|
oldPath="/bin/sh"; |
|
|
fi; |
|
|
newPath="$(PATH="${!pathName}" command -v "$(basename "$oldPath")" || true)"; |
|
|
args="$arg0 $args"; |
|
|
fi; |
|
|
newInterpreterLine="$newPath $args"; |
|
|
newInterpreterLine=${newInterpreterLine%${newInterpreterLine##*[![:space:]]}}; |
|
|
if [[ -n "$oldPath" && "${oldPath:0:${#NIX_STORE}}" != "$NIX_STORE" ]]; then |
|
|
if [[ -n "$newPath" && "$newPath" != "$oldPath" ]]; then |
|
|
echo "$f: interpreter directive changed from \"$oldInterpreterLine\" to \"$newInterpreterLine\""; |
|
|
escapedInterpreterLine=${newInterpreterLine//\\/\\\\}; |
|
|
timestamp=$(stat --printf "%y" "$f"); |
|
|
sed -i -e "1 s|.*|#\!$escapedInterpreterLine|" "$f"; |
|
|
touch --date "$timestamp" "$f"; |
|
|
fi; |
|
|
fi; |
|
|
done < <(find "$@" -type f -perm -0100 -print0); |
|
|
stopNest |
|
|
} |
|
|
patchShebangsAuto () |
|
|
{ |
|
|
|
|
|
if [[ -z "${dontPatchShebangs-}" && -e "$prefix" ]]; then |
|
|
if [[ "$output" != out && "$output" = "$outputDev" ]]; then |
|
|
patchShebangs --build "$prefix"; |
|
|
else |
|
|
patchShebangs --host "$prefix"; |
|
|
fi; |
|
|
fi |
|
|
} |
|
|
printLines () |
|
|
{ |
|
|
|
|
|
(( "$#" > 0 )) || return 0; |
|
|
printf '%s\n' "$@" |
|
|
} |
|
|
printWords () |
|
|
{ |
|
|
|
|
|
(( "$#" > 0 )) || return 0; |
|
|
printf '%s ' "$@" |
|
|
} |
|
|
runHook () |
|
|
{ |
|
|
|
|
|
local hookName="$1"; |
|
|
shift; |
|
|
local hooksSlice="${hookName%Hook}Hooks[@]"; |
|
|
local hook; |
|
|
for hook in "_callImplicitHook 0 $hookName" ${!hooksSlice+"${!hooksSlice}"}; |
|
|
do |
|
|
_eval "$hook" "$@"; |
|
|
done; |
|
|
return 0 |
|
|
} |
|
|
runOneHook () |
|
|
{ |
|
|
|
|
|
local hookName="$1"; |
|
|
shift; |
|
|
local hooksSlice="${hookName%Hook}Hooks[@]"; |
|
|
local hook ret=1; |
|
|
for hook in "_callImplicitHook 1 $hookName" ${!hooksSlice+"${!hooksSlice}"}; |
|
|
do |
|
|
if _eval "$hook" "$@"; then |
|
|
ret=0; |
|
|
break; |
|
|
fi; |
|
|
done; |
|
|
return "$ret" |
|
|
} |
|
|
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 |
|
|
} |
|
|
stopNest () |
|
|
{ |
|
|
|
|
|
true |
|
|
} |
|
|
stripDirs () |
|
|
{ |
|
|
|
|
|
local cmd="$1"; |
|
|
local dirs="$2"; |
|
|
local stripFlags="$3"; |
|
|
local dirsNew=; |
|
|
local d; |
|
|
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 command $cmd and flags $stripFlags) in$dirs"; |
|
|
find $dirs -type f -exec $cmd $stripFlags '{}' \; 2> /dev/null; |
|
|
stopNest; |
|
|
fi |
|
|
} |
|
|
stripHash () |
|
|
{ |
|
|
|
|
|
local strippedName casematchOpt=0; |
|
|
strippedName="$(basename -- "$1")"; |
|
|
shopt -q nocasematch && casematchOpt=1; |
|
|
shopt -u nocasematch; |
|
|
if [[ "$strippedName" =~ ^[a-z0-9]{32}- ]]; then |
|
|
echo "${strippedName:33}"; |
|
|
else |
|
|
echo "$strippedName"; |
|
|
fi; |
|
|
if (( casematchOpt )); then |
|
|
shopt -s nocasematch; |
|
|
fi |
|
|
} |
|
|
substitute () |
|
|
{ |
|
|
|
|
|
local input="$1"; |
|
|
local output="$2"; |
|
|
shift 2; |
|
|
if [ ! -f "$input" ]; then |
|
|
echo "substitute(): ERROR: file '$input' does not exist" 1>&2; |
|
|
return 1; |
|
|
fi; |
|
|
local content; |
|
|
consumeEntire content < "$input"; |
|
|
if [ -e "$output" ]; then |
|
|
chmod +w "$output"; |
|
|
fi; |
|
|
substituteStream content "file '$input'" "$@" > "$output" |
|
|
} |
|
|
substituteAll () |
|
|
{ |
|
|
|
|
|
local input="$1"; |
|
|
local output="$2"; |
|
|
local -a args=(); |
|
|
_allFlags; |
|
|
substitute "$input" "$output" "${args[@]}" |
|
|
} |
|
|
substituteAllInPlace () |
|
|
{ |
|
|
|
|
|
local fileName="$1"; |
|
|
shift; |
|
|
substituteAll "$fileName" "$fileName" "$@" |
|
|
} |
|
|
substituteAllStream () |
|
|
{ |
|
|
|
|
|
local -a args=(); |
|
|
_allFlags; |
|
|
substituteStream "$1" "$2" "${args[@]}" |
|
|
} |
|
|
substituteInPlace () |
|
|
{ |
|
|
|
|
|
local fileName="$1"; |
|
|
shift; |
|
|
substitute "$fileName" "$fileName" "$@" |
|
|
} |
|
|
substituteStream () |
|
|
{ |
|
|
|
|
|
local var=$1; |
|
|
local description=$2; |
|
|
shift 2; |
|
|
while (( "$#" )); do |
|
|
case "$1" in |
|
|
--replace) |
|
|
pattern="$2"; |
|
|
replacement="$3"; |
|
|
shift 3; |
|
|
local savedvar; |
|
|
savedvar="${!var}"; |
|
|
eval "$var"'=${'"$var"'//"$pattern"/"$replacement"}'; |
|
|
if [ "$pattern" != "$replacement" ]; then |
|
|
if [ "${!var}" == "$savedvar" ]; then |
|
|
echo "substituteStream(): WARNING: pattern '$pattern' doesn't match anything in $description" 1>&2; |
|
|
fi; |
|
|
fi |
|
|
;; |
|
|
--subst-var) |
|
|
local varName="$2"; |
|
|
shift 2; |
|
|
if ! [[ "$varName" =~ ^[a-zA-Z_][a-zA-Z0-9_]*$ ]]; then |
|
|
echo "substituteStream(): ERROR: substitution variables must be valid Bash names, \"$varName\" isn't." 1>&2; |
|
|
return 1; |
|
|
fi; |
|
|
if [ -z ${!varName+x} ]; then |
|
|
echo "substituteStream(): ERROR: variable \$$varName is unset" 1>&2; |
|
|
return 1; |
|
|
fi; |
|
|
pattern="@$varName@"; |
|
|
replacement="${!varName}"; |
|
|
eval "$var"'=${'"$var"'//"$pattern"/"$replacement"}' |
|
|
;; |
|
|
--subst-var-by) |
|
|
pattern="@$2@"; |
|
|
replacement="$3"; |
|
|
eval "$var"'=${'"$var"'//"$pattern"/"$replacement"}'; |
|
|
shift 3 |
|
|
;; |
|
|
*) |
|
|
echo "substituteStream(): ERROR: Invalid command line argument: $1" 1>&2; |
|
|
return 1 |
|
|
;; |
|
|
esac; |
|
|
done; |
|
|
printf "%s" "${!var}" |
|
|
} |
|
|
unpackFile () |
|
|
{ |
|
|
|
|
|
curSrc="$1"; |
|
|
header "unpacking source archive $curSrc" 3; |
|
|
if ! runOneHook unpackCmd "$curSrc"; then |
|
|
echo "do not know how to unpack source archive $curSrc"; |
|
|
exit 1; |
|
|
fi |
|
|
} |
|
|
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; |
|
|
local dirsBefore=""; |
|
|
for i in *; |
|
|
do |
|
|
if [ -d "$i" ]; then |
|
|
dirsBefore="$dirsBefore $i "; |
|
|
fi; |
|
|
done; |
|
|
for i in $srcs; |
|
|
do |
|
|
unpackFile "$i"; |
|
|
done; |
|
|
: ${sourceRoot=}; |
|
|
if [ -n "${setSourceRoot:-}" ]; then |
|
|
runOneHook setSourceRoot; |
|
|
else |
|
|
if [ -z "$sourceRoot" ]; then |
|
|
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; |
|
|
fi; |
|
|
if [ -z "$sourceRoot" ]; then |
|
|
echo "unpacker appears to have produced no directories"; |
|
|
exit 1; |
|
|
fi; |
|
|
echo "source root is $sourceRoot"; |
|
|
if [ "${dontMakeSourcesWritable:-0}" != 1 ]; then |
|
|
chmod -R u+w -- "$sourceRoot"; |
|
|
fi; |
|
|
runHook postUnpack |
|
|
} |
|
|
updateSourceDateEpoch () |
|
|
{ |
|
|
|
|
|
local path="$1"; |
|
|
local -a res=($(find "$path" -type f -not -newer "$NIX_BUILD_TOP/.." -printf '%T@ %p\0' | sort -n --zero-terminated | tail -n1 --zero-terminated | head -c -1)); |
|
|
local time="${res[0]//\.[0-9]*/}"; |
|
|
local newestFile="${res[1]}"; |
|
|
if [ "${time:-0}" -gt "$SOURCE_DATE_EPOCH" ]; then |
|
|
echo "setting SOURCE_DATE_EPOCH to timestamp $time of file $newestFile"; |
|
|
export SOURCE_DATE_EPOCH="$time"; |
|
|
local now="$(date +%s)"; |
|
|
if [ "$time" -gt $((now - 60)) ]; then |
|
|
echo "warning: file $newestFile may be generated; SOURCE_DATE_EPOCH may be non-deterministic"; |
|
|
fi; |
|
|
fi |
|
|
} |
|
|
PATH="$PATH:$nix_saved_PATH" |
|
|
export NIX_BUILD_TOP="$(mktemp -d -t nix-shell.XXXXXX)" |
|
|
export TMP="$NIX_BUILD_TOP" |
|
|
export TMPDIR="$NIX_BUILD_TOP" |
|
|
export TEMP="$NIX_BUILD_TOP" |
|
|
export TEMPDIR="$NIX_BUILD_TOP"
|
|
|
|
