alioth/nixpkgs
3
0
Fork 0
forked from mirrors/nixpkgs
Code Releases Activity

Revert #127736: stdenv changes towards an alternative shell

Browse source 
At least for now.  Such changes are risky (we have very many packages),
and apparently it needs more testing/review without blocking other
changes.

This reverts the whole range 4d0e3984918^..8752c327377,
except for one commit that got reverted in 6f239d7309 already.
(that MR didn't even get its merge commit)
This commit is contained in:
Vladimír Čunát 2021-07-17 20:27:52 +02:00
parent d6b748b2b3
commit 4bd38c330f
No known key found for this signature in database
GPG key ID: E747DF1F9575A3AA
9 changed files with 128 additions and 179 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
pkgs/build-support/bintools-wrapper/setup-hook.sh
View file

@ -1,4 +1,3 @@
# shellcheck shell=bash
# Binutils Wrapper hygiene
#
# See comments in cc-wrapper's setup hook. This works exactly the same way.
@ -15,9 +14,7 @@ bintoolsWrapper_addLDVars () {
getHostRoleEnvHook
if [[ -d "$1/lib64" && ! -L "$1/lib64" ]]; then
varName=NIX_LDFLAGS${role_post}
eval "$varName=\"${!varName:-} -L$1/lib64\""
export "${varName?}"
export NIX_LDFLAGS${role_post}+=" -L$1/lib64"
fi
if [[ -d "$1/lib" ]]; then
@ -27,9 +24,7 @@ bintoolsWrapper_addLDVars () {
# directories and bloats the size of the environment variable space.
local -a glob=( $1/lib/lib* )
if [ "${#glob[*]}" -gt 0 ]; then
varName=NIX_LDFLAGS${role_post}
eval "$varName=\"${!varName:-} -L$1/lib\""
export "${varName?}"
export NIX_LDFLAGS${role_post}+=" -L$1/lib"
fi
fi
}

1
pkgs/build-support/setup-hooks/auto-patchelf.sh
View file

@ -29,7 +29,6 @@ isExecutable() {
isExeResult="$(LANG=C $READELF -h -l "$1" 2> /dev/null \
| grep '^ *Type: *EXEC\>\|^ *INTERP\>')"
# not using grep -q, because it can cause Broken pipe
# https://unix.stackexchange.com/questions/305547/broken-pipe-when-grepping-output-but-only-with-i-flag
[ -n "$isExeResult" ]
}

3
pkgs/build-support/setup-hooks/autoreconf.sh
View file

@ -1,5 +1,4 @@
# shellcheck shell=bash
preConfigurePhases="${preConfigurePhases:-} autoreconfPhase"
preConfigurePhases+=" autoreconfPhase"
autoreconfPhase() {
runHook preAutoreconf

1
pkgs/build-support/setup-hooks/make-symlinks-relative.sh
View file

@ -1,4 +1,3 @@
# shellcheck shell=bash
fixupOutputHooks+=(_makeSymlinksRelative)
# For every symlink in $output that refers to another file in $output

7
pkgs/build-support/setup-hooks/move-docs.sh
View file

@ -6,7 +6,7 @@ preFixupHooks+=(_moveToShare)
_moveToShare() {
forceShare=${forceShare:=man doc info}
if [[ -z $forceShare || -z $out ]]; then return; fi
if [ -z "$forceShare" -o -z "$out" ]; then return; fi
for d in $forceShare; do
if [ -d "$out/$d" ]; then
@ -14,9 +14,10 @@ _moveToShare() {
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/"
mkdir -p $out/share
mv $out/$d $out/share/
fi
fi
done
}

14
pkgs/build-support/setup-hooks/multiple-outputs.sh
View file

@ -1,4 +1,3 @@
# shellcheck shell=bash
# The base package for automatic multiple-output splitting. Used in stdenv as well.
preConfigureHooks+=(_multioutConfig)
preFixupHooks+=(_multioutDocs)
@ -48,25 +47,22 @@ _overrideFirst outputInfo "info" "$outputBin"
# Add standard flags to put files into the desired outputs.
_multioutConfig() {
if [[ "$outputs" = "out" || -z "${setOutputFlags-1}" ]]; then
return
fi
if [ "$outputs" = "out" ] || [ -z "${setOutputFlags-1}" ]; then return; fi;
# try to detect share/doc/${shareDocName}
# Note: sadly, $configureScript detection comes later in configurePhase,
# and reordering would cause more trouble than worth.
if [ -z "$shareDocName" ]; then
local confScript="$configureScript"
if [[ -z "$confScript" && -x ./configure ]]; then
if [ -z "$confScript" ] && [ -x ./configure ]; then
confScript=./configure
fi
if [ -f "$confScript" ]; then
local shareDocName="$(sed -n "s/^PACKAGE_TARNAME='\(.*\)'$/\1/p" < "$confScript")"
# PACKAGE_TARNAME sometimes contains garbage.
# verify that shareDocName contains only valid characters
if ! [[ $shareDocName =~ ^[a-zA-Z0f9_-]+$ ]]; then
shareDocName="$(echo "$name" | sed 's/-[^a-zA-Z].*//')"
fi
# PACKAGE_TARNAME sometimes contains garbage.
if [ -z "$shareDocName" ] || echo "$shareDocName" | grep -q '[^a-zA-Z0-9_-]'; then
shareDocName="$(echo "$name" | sed 's/-[^a-zA-Z].*//')"
fi
fi

8
pkgs/build-support/setup-hooks/reproducible-builds.sh
View file

@ -1,13 +1,9 @@
# shellcheck disable=SC2148
# Use the last part of the out path as hash input for the build.
# This should ensure that it is deterministic across rebuilds of the same
# derivation and not easily collide with other builds.
# We also truncate the hash so that it cannot cause reference cycles.
# NIX_CFLAGS_COMPILE might not have been defined before
NIX_CFLAGS_COMPILE="${NIX_CFLAGS_COMPILE:-} -frandom-seed=$(
# shellcheck disable=SC2154
export NIX_CFLAGS_COMPILE+=" -frandom-seed=$(
outbase="${out##*/}"
randomseed="${outbase:0:10}"
echo "$randomseed"
echo $randomseed
)"
export NIX_CFLAGS_COMPILE

18
pkgs/stdenv/generic/builder.sh
View file

@ -4,20 +4,18 @@ for i in $initialPath; do
PATH=$PATH${PATH:+:}$i/bin
done
mkdir "$out"
mkdir $out
{
echo "export SHELL=$shell"
echo "initialPath=\"$initialPath\""
echo "defaultNativeBuildInputs=\"$defaultNativeBuildInputs\""
echo "defaultBuildInputs=\"$defaultBuildInputs\""
echo "$preHook"
cat "$setup"
} > "$out/setup"
echo "export SHELL=$shell" > $out/setup
echo "initialPath=\"$initialPath\"" >> $out/setup
echo "defaultNativeBuildInputs=\"$defaultNativeBuildInputs\"" >> $out/setup
echo "defaultBuildInputs=\"$defaultBuildInputs\"" >> $out/setup
echo "$preHook" >> $out/setup
cat "$setup" >> $out/setup
# Allow the user to install stdenv using nix-env and get the packages
# in stdenv.
mkdir $out/nix-support
if [ -n "${propagatedUserEnvPkgs:-}" ]; then
if [ "$propagatedUserEnvPkgs" ]; then
printf '%s ' $propagatedUserEnvPkgs > $out/nix-support/propagated-user-env-packages
fi

232
pkgs/stdenv/generic/setup.sh
View file

@ -1,4 +1,3 @@
# shellcheck shell=bash
set -eu
set -o pipefail
@ -12,7 +11,7 @@ if (( "${NIX_DEBUG:-0}" >= 6 )); then
set -x
fi
: "${outputs:=out}"
: ${outputs:=out}
######################################################################
@ -69,8 +68,7 @@ _callImplicitHook() {
local hookName="$2"
if declare -F "$hookName" > /dev/null; then
"$hookName"
elif test -e "$hookName" ; then
# shellcheck disable=SC1090
elif type -p "$hookName" > /dev/null; then
source "$hookName"
elif [ -n "${!hookName:-}" ]; then
eval "${!hookName}"
@ -124,14 +122,13 @@ exitHandler() {
if [ -n "${showBuildStats:-}" ]; then
times > "$NIX_BUILD_TOP/.times"
local -a buildTimesArray
IFS=" " read -r -a buildTimesArray < "$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: " "${buildTimesArray[@]}"
echo "build time elapsed: " "${times[@]}"
fi
if (( "$exitCode" != 0 )); then
@ -143,7 +140,6 @@ exitHandler() {
# normally. Otherwise, return the original exit code.
if [ -n "${succeedOnFailure:-}" ]; then
echo "build failed with exit code $exitCode (ignored)"
# shellcheck disable=SC2154
mkdir -p "$out/nix-support"
printf "%s" "$exitCode" > "$out/nix-support/failed"
exit 0
@ -236,7 +232,7 @@ printWords() {
# implementation uses zip archive and zip does not support dates going back to
# 1970.
export SOURCE_DATE_EPOCH
: "${SOURCE_DATE_EPOCH:=315532800}"
: ${SOURCE_DATE_EPOCH:=315532800}
# Wildcard expansions that don't match should expand to an empty list.
@ -246,10 +242,8 @@ shopt -s nullglob
# Set up the initial path.
# shellcheck disable=SC2123
PATH=
HOST_PATH=
# shellcheck disable=SC2154
for i in $initialPath; do
if [ "$i" = / ]; then i=; fi
addToSearchPath PATH "$i/bin"
@ -312,10 +306,6 @@ declare -a pkgTargetHookVars=(envTargetTargetHook)
declare -a pkgHookVarVars=(pkgBuildHookVars pkgHostHookVars pkgTargetHookVars)
# those variables are declared here, since where and if they are used varies
# shellcheck disable=SC2034
declare -a preFixupHooks fixupOutputHooks preConfigureHooks postFixupHooks postUnpackHooks unpackCmdHooks
# Add env hooks for all sorts of deps with the specified host offset.
addEnvHooks() {
local depHostOffset="$1"
@ -357,14 +347,14 @@ declare -a allPlatOffsets=(-1 0 1)
# implements.
findInputs() {
local -r pkg="$1"
local -r hostOffset="$2"
local -r targetOffset="$3"
local -ri hostOffset="$2"
local -ri targetOffset="$3"
# Sanity check
(( "$hostOffset" <= "$targetOffset" )) || exit 1
(( "$hostOffset" <= "$targetOffset" )) || exit -1
local varVar="${pkgAccumVarVars[$(( hostOffset + 1 ))]}"
local varRef="${varVar}[$(( targetOffset - hostOffset ))]"
local varVar="${pkgAccumVarVars[$hostOffset + 1]}"
local varRef="$varVar[\$targetOffset - \$hostOffset]"
local var="${!varRef}"
unset -v varVar varRef
@ -372,7 +362,7 @@ findInputs() {
# nix-shell doesn't use impure bash. This should replace the O(n)
# case with an O(1) hash map lookup, assuming bash is implemented
# well :D.
local varSlice="${var}[*]"
local varSlice="$var[*]"
# ${..-} to hack around old bash empty array problem
case "${!varSlice-}" in
*" $pkg "*) return 0 ;;
@ -389,28 +379,28 @@ findInputs() {
# The current package's host and target offset together
# provide a <=-preserving homomorphism from the relative
# offsets to current offset
local mapOffsetResult
local -i mapOffsetResult
function mapOffset() {
local -r inputOffset="$1"
local -ri inputOffset="$1"
if (( "$inputOffset" <= 0 )); then
local -r outputOffset=$(( inputOffset + hostOffset ))
local -ri outputOffset="$inputOffset + $hostOffset"
else
local -r outputOffset=$(( inputOffset - 1 + targetOffset ))
local -ri outputOffset="$inputOffset - 1 + $targetOffset"
fi
mapOffsetResult="$outputOffset"
}
# Host offset relative to that of the package whose immediate
# dependencies we are currently exploring.
local relHostOffset
local -i relHostOffset
for relHostOffset in "${allPlatOffsets[@]}"; do
# `+ 1` so we start at 0 for valid index
local files="${propagatedDepFilesVars[$(( relHostOffset + 1 ))]}"
local files="${propagatedDepFilesVars[$relHostOffset + 1]}"
# Host offset relative to the package currently being
# built---as absolute an offset as will be used.
mapOffset "$relHostOffset"
local hostOffsetNext="$mapOffsetResult"
mapOffset relHostOffset
local -i hostOffsetNext="$mapOffsetResult"
# Ensure we're in bounds relative to the package currently
# being built.
@ -418,18 +408,18 @@ findInputs() {
# Target offset relative to the *host* offset of the package
# whose immediate dependencies we are currently exploring.
local relTargetOffset
local -i relTargetOffset
for relTargetOffset in "${allPlatOffsets[@]}"; do
(( "$relHostOffset" <= "$relTargetOffset" )) || continue
local fileRef="${files}[$(( relTargetOffset - relHostOffset ))]"
local fileRef="${files}[$relTargetOffset - $relHostOffset]"
local file="${!fileRef}"
unset -v fileRef
# Target offset relative to the package currently being
# built.
mapOffset "$relTargetOffset"
local targetOffsetNext="$mapOffsetResult"
mapOffset relTargetOffset
local -i targetOffsetNext="$mapOffsetResult"
# Once again, ensure we're in bounds relative to the
# package currently being built.
@ -447,12 +437,12 @@ findInputs() {
}
# Make sure all are at least defined as empty
: "${depsBuildBuild=}" "${depsBuildBuildPropagated=}"
: "${nativeBuildInputs=}" "${propagatedNativeBuildInputs=}" "${defaultNativeBuildInputs=}"
: "${depsBuildTarget=}" "${depsBuildTargetPropagated=}"
: "${depsHostHost=}" "${depsHostHostPropagated=}"
: "${buildInputs=}" "${propagatedBuildInputs=}" "${defaultBuildInputs=}"
: "${depsTargetTarget=}" "${depsTargetTargetPropagated=}"
: ${depsBuildBuild=} ${depsBuildBuildPropagated=}
: ${nativeBuildInputs=} ${propagatedNativeBuildInputs=} ${defaultNativeBuildInputs=}
: ${depsBuildTarget=} ${depsBuildTargetPropagated=}
: ${depsHostHost=} ${depsHostHostPropagated=}
: ${buildInputs=} ${propagatedBuildInputs=} ${defaultBuildInputs=}
: ${depsTargetTarget=} ${depsTargetTargetPropagated=}
for pkg in $depsBuildBuild $depsBuildBuildPropagated; do
findInputs "$pkg" -1 -1
@ -483,14 +473,13 @@ done
# Add package to the future PATH and run setup hooks
activatePackage() {
local pkg="$1"
local -r hostOffset="$2"
local -r targetOffset="$3"
local -ri hostOffset="$2"
local -ri targetOffset="$3"
# Sanity check
(( "$hostOffset" <= "$targetOffset" )) || exit 1
(( "$hostOffset" <= "$targetOffset" )) || exit -1
if [ -f "$pkg" ]; then
# shellcheck disable=SC1090
source "$pkg"
fi
@ -514,19 +503,19 @@ activatePackage() {
fi
if [[ -f "$pkg/nix-support/setup-hook" ]]; then
# shellcheck disable=SC1091
source "$pkg/nix-support/setup-hook"
fi
}
_activatePkgs() {
local hostOffset targetOffset pkg
local -i hostOffset targetOffset
local pkg
for hostOffset in "${allPlatOffsets[@]}"; do
local pkgsVar="${pkgAccumVarVars[$(( hostOffset + 1 ))]}"
local pkgsVar="${pkgAccumVarVars[$hostOffset + 1]}"
for targetOffset in "${allPlatOffsets[@]}"; do
(( "$hostOffset" <= "$targetOffset" )) || continue
local pkgsRef="${pkgsVar}[$(( targetOffset - hostOffset ))]"
local pkgsRef="${pkgsVar}[$targetOffset - $hostOffset]"
local pkgsSlice="${!pkgsRef}[@]"
for pkg in ${!pkgsSlice+"${!pkgsSlice}"}; do
activatePackage "$pkg" "$hostOffset" "$targetOffset"
@ -547,14 +536,15 @@ _activatePkgs
# with this information to the relevant env hook array, but bash
# doesn't have closures, so it's easier to just pass this in.
_addToEnv() {
local depHostOffset depTargetOffset pkg
local -i depHostOffset depTargetOffset
local pkg
for depHostOffset in "${allPlatOffsets[@]}"; do
local hookVar="${pkgHookVarVars[$(( depHostOffset + 1 ))]}"
local pkgsVar="${pkgAccumVarVars[$(( depHostOffset + 1 ))]}"
local hookVar="${pkgHookVarVars[$depHostOffset + 1]}"
local pkgsVar="${pkgAccumVarVars[$depHostOffset + 1]}"
for depTargetOffset in "${allPlatOffsets[@]}"; do
(( "$depHostOffset" <= "$depTargetOffset" )) || continue
local hookRef="${hookVar}[$(( depTargetOffset - depHostOffset ))]"
local hookRef="${hookVar}[$depTargetOffset - $depHostOffset]"
if [[ -z "${strictDeps-}" ]]; then
# Keep track of which packages we have visited before.
@ -565,12 +555,12 @@ _addToEnv() {
#
# TODO(@Ericson2314): Don't special-case native compilation
for pkg in \
"${pkgsBuildBuild[@]}" \
"${pkgsBuildHost[@]}" \
"${pkgsBuildTarget[@]}" \
"${pkgsHostHost[@]}" \
"${pkgsHostTarget[@]}" \
"${pkgsTargetTarget[@]}"
${pkgsBuildBuild+"${pkgsBuildBuild[@]}"} \
${pkgsBuildHost+"${pkgsBuildHost[@]}"} \
${pkgsBuildTarget+"${pkgsBuildTarget[@]}"} \
${pkgsHostHost+"${pkgsHostHost[@]}"} \
${pkgsHostTarget+"${pkgsHostTarget[@]}"} \
${pkgsTargetTarget+"${pkgsTargetTarget[@]}"}
do
if [[ "$visitedPkgs" = *"$pkg"* ]]; then
continue
@ -579,7 +569,7 @@ _addToEnv() {
visitedPkgs+=" $pkg"
done
else
local pkgsRef="${pkgsVar}[$(( depTargetOffset - depHostOffset ))]"
local pkgsRef="${pkgsVar}[$depTargetOffset - $depHostOffset]"
local pkgsSlice="${!pkgsRef}[@]"
for pkg in ${!pkgsSlice+"${!pkgsSlice}"}; do
runHook "${!hookRef}" "$pkg"
@ -645,7 +635,7 @@ export NIX_INDENT_MAKE=1
if [ -z "${NIX_BUILD_CORES:-}" ]; then
NIX_BUILD_CORES="1"
elif (( "$NIX_BUILD_CORES" <= 0 )); then
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
:
@ -658,11 +648,11 @@ export NIX_BUILD_CORES
# Prevent SSL libraries from using certificates in /etc/ssl, unless set explicitly.
# Leave it in impure shells for convenience.
if [[ -z "${NIX_SSL_CERT_FILE:-}" && "${IN_NIX_SHELL:-}" != "impure" ]]; then
if [ -z "${NIX_SSL_CERT_FILE:-}" ] && [ "${IN_NIX_SHELL:-}" != "impure" ]; then
export NIX_SSL_CERT_FILE=/no-cert-file.crt
fi
# Another variant left for compatibility.
if [[ -z "${SSL_CERT_FILE:-}" && "${IN_NIX_SHELL:-}" != "impure" ]]; then
if [ -z "${SSL_CERT_FILE:-}" ] && [ "${IN_NIX_SHELL:-}" != "impure" ]; then
export SSL_CERT_FILE=/no-cert-file.crt
fi
@ -728,7 +718,6 @@ substituteStream() {
consumeEntire() {
# read returns non-0 on EOF, so we want read to fail
# shellcheck disable=SC2086
if IFS='' read -r -N 0 $1; then
echo "consumeEntire(): ERROR: Input null bytes, won't process" >&2
return 1
@ -900,7 +889,7 @@ unpackPhase() {
# Find the source directory.
# set to empty if unset
: "${sourceRoot=}"
: ${sourceRoot=}
if [ -n "${setSourceRoot:-}" ]; then
runOneHook setSourceRoot
@ -978,8 +967,8 @@ configurePhase() {
runHook preConfigure
# set to empty if unset
: "${configureScript=}"
: "${configureFlags=}"
: ${configureScript=}
: ${configureFlags=}
if [[ -z "$configureScript" && -x ./configure ]]; then
configureScript=./configure
@ -997,27 +986,25 @@ configurePhase() {
configureFlags="${prefixKey:---prefix=}$prefix $configureFlags"
fi
if [ -f "$configureScript" ]; then
# Add --disable-dependency-tracking to speed up some builds.
if [[ -z ${dontAddDisableDepTrack:-} ]]; then
if grep -q dependency-tracking "$configureScript"; then
if [ -z "${dontAddDisableDepTrack:-}" ]; then
if [ -f "$configureScript" ] && 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
if [ -z "${dontDisableStatic:-}" ]; then
if [ -f "$configureScript" ] && grep -q enable-static "$configureScript"; then
configureFlags="--disable-static $configureFlags"
fi
fi
fi
if [ -n "$configureScript" ]; then
IFS=" " read -r -a configureFlagsTemp <<< "$configureFlags"
local -a flagsArray=(
"${configureFlagsTemp[@]}"
"${configureFlagsArray[@]}"
# Old bash empty array hack
# shellcheck disable=SC2086
local flagsArray=(
$configureFlags ${configureFlagsArray+"${configureFlagsArray[@]}"}
)
echoCmd 'configure flags' "${flagsArray[@]}"
# shellcheck disable=SC2086
@ -1035,22 +1022,20 @@ buildPhase() {
runHook preBuild
# set to empty if unset
: "${makeFlags=}"
: ${makeFlags=}
if [[ -z "$makeFlags" && -z "${makefile:-}" && ! ( -e Makefile || -e makefile || -e GNUmakefile ) ]]; then
echo "no Makefile, doing nothing"
else
foundMakefile=1
IFS=" " read -r -a makeFlagsTemp <<< "$makeFlags"
# shellcheck disable=SC2154
IFS=" " read -r -a buildFlagsTemp <<< "$buildFlags"
local -a flagsArray=(
# Old bash empty array hack
# shellcheck disable=SC2086
local flagsArray=(
${enableParallelBuilding:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}}
SHELL="$SHELL"
"${makeFlagsTemp[@]}"
"${makeFlagsArray[@]}"
"${buildFlagsTemp[@]}"
"${buildFlagsArray[@]}"
SHELL=$SHELL
$makeFlags ${makeFlagsArray+"${makeFlagsArray[@]}"}
$buildFlags ${buildFlagsArray+"${buildFlagsArray[@]}"}
)
echoCmd 'build flags' "${flagsArray[@]}"
@ -1074,26 +1059,23 @@ checkPhase() {
if [[ -z "${checkTarget:-}" ]]; then
#TODO(@oxij): should flagsArray influence make -n?
if make -n ${makefile:+-f $makefile} check >/dev/null 2>&1; then
checkTarget="check"
checkTarget=check
elif make -n ${makefile:+-f $makefile} test >/dev/null 2>&1; then
checkTarget="test"
checkTarget=test
fi
fi
if [[ -z "${checkTarget:-}" ]]; then
echo "no check/test target in ${makefile:-Makefile}, doing nothing"
else
IFS=" " read -r -a makeFlagsTemp <<< "$makeFlags"
IFS=" " read -r -a checkFlagsTemp <<< "${checkFlags:-VERBOSE=y}"
IFS=" " read -r -a checkTargetTemp <<< "${checkTarget}"
local -a flagsArray=(
# Old bash empty array hack
# shellcheck disable=SC2086
local flagsArray=(
${enableParallelChecking:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}}
SHELL="$SHELL"
"${makeFlagsTemp[@]}"
"${makeFlagsArray[@]}"
"${checkFlagsTemp[@]}"
"${checkFlagsArray[@]}"
"${checkTargetTemp[@]}"
SHELL=$SHELL
$makeFlags ${makeFlagsArray+"${makeFlagsArray[@]}"}
${checkFlags:-VERBOSE=y} ${checkFlagsArray+"${checkFlagsArray[@]}"}
${checkTarget}
)
echoCmd 'check flags' "${flagsArray[@]}"
@ -1112,18 +1094,14 @@ installPhase() {
if [ -n "$prefix" ]; then
mkdir -p "$prefix"
fi
IFS=" " read -r -a makeFlagsTemp <<< "$makeFlags"
# shellcheck disable=SC2154
IFS=" " read -r -a installFlagsTemp <<< "$installFlags"
# shellcheck disable=SC2154
IFS=" " read -r -a installTargetsTemp <<< "${installTargets:-install}"
local -a flagsArray=(
SHELL="$SHELL"
"${makeFlagsTemp[@]}"
"${makeFlagsArray[@]}"
"${installFlagsTemp[@]}"
"${installFlagsArray[@]}"
"${installTargetsTemp[@]}"
# Old bash empty array hack
# shellcheck disable=SC2086
local flagsArray=(
SHELL=$SHELL
$makeFlags ${makeFlagsArray+"${makeFlagsArray[@]}"}
$installFlags ${installFlagsArray+"${installFlagsArray[@]}"}
${installTargets:-install}
)
echoCmd 'install flags' "${flagsArray[@]}"
@ -1178,7 +1156,6 @@ fixupPhase() {
[[ "${!propagatedInputsSlice}" ]] || continue
# shellcheck disable=SC2154
mkdir -p "${!outputDev}/nix-support"
# shellcheck disable=SC2086
printWords ${!propagatedInputsSlice} > "${!outputDev}/nix-support/$propagatedInputsFile"
@ -1195,8 +1172,6 @@ fixupPhase() {
mkdir -p "${!outputDev}/nix-support"
local hook
for hook in $setupHooks; do
# content is being assigned to in the following lines
# shellcheck disable=SC2034
local content
consumeEntire content < "$hook"
substituteAllStream content "file '$hook'" >> "${!outputDev}/nix-support/setup-hook"
@ -1208,7 +1183,6 @@ fixupPhase() {
# Propagate user-env packages into the output with binaries, TODO?
if [ -n "${propagatedUserEnvPkgs:-}" ]; then
# shellcheck disable=SC2154
mkdir -p "${!outputBin}/nix-support"
# shellcheck disable=SC2086
printWords $propagatedUserEnvPkgs > "${!outputBin}/nix-support/propagated-user-env-packages"
@ -1225,21 +1199,17 @@ installCheckPhase() {
echo "no Makefile or custom installCheckPhase, doing nothing"
#TODO(@oxij): should flagsArray influence make -n?
elif [[ -z "${installCheckTarget:-}" ]] \
&& ! make -n ${makefile:+-f $makefile} "${installCheckTarget:-installcheck}" >/dev/null 2>&1; then
&& ! make -n ${makefile:+-f $makefile} ${installCheckTarget:-installcheck} >/dev/null 2>&1; then
echo "no installcheck target in ${makefile:-Makefile}, doing nothing"
else
IFS=" " read -r -a makeFlagsTemp <<< "$makeFlags"
# shellcheck disable=SC2154
IFS=" " read -r -a installCheckFlagsTemp <<< "$installCheckFlags"
IFS=" " read -r -a installCheckTargetTemp <<< "${installCheckTarget:-installcheck}"
local -a flagsArray=(
# Old bash empty array hack
# shellcheck disable=SC2086
local flagsArray=(
${enableParallelChecking:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}}
SHELL="$SHELL"
"${makeFlagsTemp[@]}"
"${makeFlagsArray[@]}"
"${installCheckFlagsTemp[@]}"
"${installCheckFlagsArray[@]}"
"${installCheckTargetTemp[@]}"
SHELL=$SHELL
$makeFlags ${makeFlagsArray+"${makeFlagsArray[@]}"}
$installCheckFlags ${installCheckFlagsArray+"${installCheckFlagsArray[@]}"}
${installCheckTarget:-installcheck}
)
echoCmd 'installcheck flags' "${flagsArray[@]}"
@ -1254,13 +1224,10 @@ installCheckPhase() {
distPhase() {
runHook preDist
# shellcheck disable=SC2154
IFS=" " read -r -a distFlagsTemp <<< "$distFlags"
# Old bash empty array hack
# shellcheck disable=SC2086
local flagsArray=(
"${distFlagsTemp[@]}"
${distFlagsArray+"${distFlagsArray[@]}"}
"${distTarget:-dist}"
$distFlags ${distFlagsArray+"${distFlagsArray[@]}"} ${distTarget:-dist}
)
echo 'dist flags: %q' "${flagsArray[@]}"
@ -1297,7 +1264,6 @@ showPhaseHeader() {
genericBuild() {
if [ -f "${buildCommandPath:-}" ]; then
# shellcheck disable=SC1090
source "$buildCommandPath"
return
fi
@ -1325,7 +1291,7 @@ genericBuild() {
if [[ "$curPhase" = distPhase && -z "${doDist:-}" ]]; then continue; fi
if [[ -n $NIX_LOG_FD ]]; then
echo "@nix { \"action\": \"setPhase\", \"phase\": \"$curPhase\" }" >&"$NIX_LOG_FD"
echo "@nix { \"action\": \"setPhase\", \"phase\": \"$curPhase\" }" >&$NIX_LOG_FD
fi
showPhaseHeader "$curPhase"