nixpkgs/pkgs/stdenv/generic/setup.sh

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1615 lines
47 KiB
Bash
Raw Normal View History

# shellcheck shell=bash
# shellcheck disable=1090,2154,2123,2034,2178,2048,2068,1091
__nixpkgs_setup_set_original=$-
set -eu
2014-10-10 09:50:25 +00:00
set -o pipefail
if [[ -n "${BASH_VERSINFO-}" && "${BASH_VERSINFO-}" -lt 4 ]]; then
echo "Detected Bash version that isn't supported by Nixpkgs (${BASH_VERSION})"
echo "Please install Bash 4 or greater to continue."
exit 1
fi
shopt -s inherit_errexit
if (( "${NIX_DEBUG:-0}" >= 6 )); then
set -x
fi
stdenv: refactor `.attrs.sh` detection Relying on `.attrs.sh` to exist in `$NIX_BUILD_TOP` is problematic because that's not compatible with how `nix-shell(1)` behaves. It places `.attrs.{json,sh}` into a temporary directory and makes them accessible via `$NIX_ATTRS_{SH,JSON}_FILE` in the environment[1]. The sole reason that `nix-shell(1)` still works with structured-attrs enabled derivations is that the contents of `.attrs.sh` are sourced into the shell before sourcing `$stdenv/setup` (if `$stdenv` exists) by `nix-shell`. However, the assumption that two files called `.attrs.sh` and `.attrs.json` exist in `$NIX_BUILD_TOP` is wrong in an interactive shell session and thus an inconsistency between shell debug session and actual builds which can lead to unexpected problems. To be precise, we currently have the following problem: an expression like with import ./. {}; runCommand "foo" { __structuredAttrs = true; foo.bar = [ 1 2 3 ]; } '' echo "''${__structuredAttrs@Q}" touch $out '' prints `1` in its build-log. However when building interactively in a `nix-shell`, it doesn't. Because of that, I'm considering to propose a full deprecation of `$NIX_BUILD_TOP/.attrs.{json,sh}`. A first step is to only mention the environment variables, but not the actual paths anymore in Nix's manual[2]. The second step - this patch - is to fix nixpkgs' stdenv accordingly. Please note that we cannot check for `-e "$NIX_ATTRS_JSON_FILE"` because certain outdated Nix minors (that are still in the range of supported Nix versions in `nixpkgs`) have a bug where `NIX_ATTRS_JSON_FILE` points to the wrong file while building[3]. Also, for compatibility with Nix 2.3 which doesn't provide these environment variables at all we still need to check for the existence of .attrs.json/.attrs.sh here. As soon as we bump nixpkgs' minver to 2.4, this can be dropped. Finally, dropped the check for ATTRS_SH_FILE because that was never relevant. In nix#4770 the ATTRS_SH_FILE variable was introduced[4] and in a review iteration prefixed with NIX_[5]. In other words, these variables were never part of a release and you'd only have this problem if you'd use a Nix from a git revision of my branch from back then. In other words, that's dead code. [1] https://github.com/nixos/nix/pull/4770#issuecomment-834718851 [2] https://github.com/NixOS/nix/pull/9032 [3] https://github.com/NixOS/nix/issues/6736 [4] https://github.com/NixOS/nix/pull/4770/commits/3944a120ec6986c723bf36bfade9b331dd4af68a [5] https://github.com/NixOS/nix/pull/4770/commits/27ce722638eeabb987bc9b4a1234c2818c5bf401
2023-09-28 09:05:52 +00:00
if [ -f .attrs.sh ] || [[ -n "${NIX_ATTRS_JSON_FILE:-}" ]]; then
__structuredAttrs=1
echo "structuredAttrs is enabled"
for outputName in "${!outputs[@]}"; do
# ex: out=/nix/store/...
export "$outputName=${outputs[$outputName]}"
done
# $NIX_ATTRS_JSON_FILE pointed to the wrong location in sandbox
# https://github.com/NixOS/nix/issues/6736; please keep around until the
# fix reaches *every patch version* that's >= lib/minver.nix
if ! [[ -e "${NIX_ATTRS_JSON_FILE:-}" ]]; then
export NIX_ATTRS_JSON_FILE="$NIX_BUILD_TOP/.attrs.json"
fi
if ! [[ -e "${NIX_ATTRS_SH_FILE:-}" ]]; then
export NIX_ATTRS_SH_FILE="$NIX_BUILD_TOP/.attrs.sh"
fi
else
stdenv: refactor `.attrs.sh` detection Relying on `.attrs.sh` to exist in `$NIX_BUILD_TOP` is problematic because that's not compatible with how `nix-shell(1)` behaves. It places `.attrs.{json,sh}` into a temporary directory and makes them accessible via `$NIX_ATTRS_{SH,JSON}_FILE` in the environment[1]. The sole reason that `nix-shell(1)` still works with structured-attrs enabled derivations is that the contents of `.attrs.sh` are sourced into the shell before sourcing `$stdenv/setup` (if `$stdenv` exists) by `nix-shell`. However, the assumption that two files called `.attrs.sh` and `.attrs.json` exist in `$NIX_BUILD_TOP` is wrong in an interactive shell session and thus an inconsistency between shell debug session and actual builds which can lead to unexpected problems. To be precise, we currently have the following problem: an expression like with import ./. {}; runCommand "foo" { __structuredAttrs = true; foo.bar = [ 1 2 3 ]; } '' echo "''${__structuredAttrs@Q}" touch $out '' prints `1` in its build-log. However when building interactively in a `nix-shell`, it doesn't. Because of that, I'm considering to propose a full deprecation of `$NIX_BUILD_TOP/.attrs.{json,sh}`. A first step is to only mention the environment variables, but not the actual paths anymore in Nix's manual[2]. The second step - this patch - is to fix nixpkgs' stdenv accordingly. Please note that we cannot check for `-e "$NIX_ATTRS_JSON_FILE"` because certain outdated Nix minors (that are still in the range of supported Nix versions in `nixpkgs`) have a bug where `NIX_ATTRS_JSON_FILE` points to the wrong file while building[3]. Also, for compatibility with Nix 2.3 which doesn't provide these environment variables at all we still need to check for the existence of .attrs.json/.attrs.sh here. As soon as we bump nixpkgs' minver to 2.4, this can be dropped. Finally, dropped the check for ATTRS_SH_FILE because that was never relevant. In nix#4770 the ATTRS_SH_FILE variable was introduced[4] and in a review iteration prefixed with NIX_[5]. In other words, these variables were never part of a release and you'd only have this problem if you'd use a Nix from a git revision of my branch from back then. In other words, that's dead code. [1] https://github.com/nixos/nix/pull/4770#issuecomment-834718851 [2] https://github.com/NixOS/nix/pull/9032 [3] https://github.com/NixOS/nix/issues/6736 [4] https://github.com/NixOS/nix/pull/4770/commits/3944a120ec6986c723bf36bfade9b331dd4af68a [5] https://github.com/NixOS/nix/pull/4770/commits/27ce722638eeabb987bc9b4a1234c2818c5bf401
2023-09-28 09:05:52 +00:00
__structuredAttrs=
: "${outputs:=out}"
fi
2014-06-25 14:47:58 +00:00
getAllOutputNames() {
if [ -n "$__structuredAttrs" ]; then
echo "${!outputs[*]}"
else
echo "$outputs"
fi
}
2014-06-25 14:47:58 +00:00
######################################################################
# Hook handling.
# Run all hooks with the specified name in the order in which they
# were added, stopping if any fails (returns a non-zero exit
# code). The hooks for <hookName> are the shell function or variable
# <hookName>, and the values of the shell array <hookName>Hooks.
runHook() {
local hookName="$1"
shift
local hooksSlice="${hookName%Hook}Hooks[@]"
local hook
# Hack around old bash being bad and thinking empty arrays are
# undefined.
for hook in "_callImplicitHook 0 $hookName" ${!hooksSlice+"${!hooksSlice}"}; do
_eval "$hook" "$@"
done
return 0
}
# Run all hooks with the specified name, until one succeeds (returns a
# zero exit code). If none succeed, return a non-zero exit code.
runOneHook() {
local hookName="$1"
shift
local hooksSlice="${hookName%Hook}Hooks[@]"
local hook ret=1
# Hack around old bash like above
for hook in "_callImplicitHook 1 $hookName" ${!hooksSlice+"${!hooksSlice}"}; do
if _eval "$hook" "$@"; then
ret=0
break
fi
done
return "$ret"
}
# Run the named hook, either by calling the function with that name or
# by evaluating the variable with that name. This allows convenient
# setting of hooks both from Nix expressions (as attributes /
# environment variables) and from shell scripts (as functions). If you
# want to allow multiple hooks, use runHook instead.
_callImplicitHook() {
local def="$1"
local hookName="$2"
if declare -F "$hookName" > /dev/null; then
"$hookName"
elif type -p "$hookName" > /dev/null; then
source "$hookName"
elif [ -n "${!hookName:-}" ]; then
eval "${!hookName}"
else
return "$def"
fi
# `_eval` expects hook to need nounset disable and leave it
# disabled anyways, so Ok to to delegate. The alternative of a
# return trap is no good because it would affect nested returns.
}
# A function wrapper around eval that ensures that return inside
# hooks exits the hook, not the caller. Also will only pass args if
# command can take them
_eval() {
2019-09-19 09:43:34 +00:00
if declare -F "$1" > /dev/null 2>&1; then
"$@" # including args
else
eval "$1"
fi
}
######################################################################
# Logging.
# Prints a command such that all word splits are unambiguous. We need
# to split the command in three parts because the middle format string
# will be, and must be, repeated for each argument. The first argument
# goes before the ':' and is just for convenience.
echoCmd() {
printf "%s:" "$1"
shift
printf ' %q' "$@"
echo
}
######################################################################
# Error handling.
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
2012-12-28 15:41:56 +00:00
if (( "$exitCode" != 0 )); then
runHook failureHook
2012-12-28 15:41:56 +00:00
# If the builder had a non-zero exit code and
# $succeedOnFailure is set, create the file
# $out/nix-support/failed to signal failure, and exit
# normally. Otherwise, return the original exit code.
if [ -n "${succeedOnFailure:-}" ]; then
echo "build failed with exit code $exitCode (ignored)"
mkdir -p "$out/nix-support"
printf "%s" "$exitCode" > "$out/nix-support/failed"
2022-11-12 18:25:14 +00:00
exit 0
fi
2012-12-28 15:41:56 +00:00
else
runHook exitHook
fi
2012-12-28 15:41:56 +00:00
return "$exitCode"
}
trap "exitHandler" EXIT
######################################################################
# Helper functions.
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
}
addToSearchPath() {
addToSearchPathWithCustomDelimiter ":" "$@"
}
# Prepend elements to variable "$1", which may come from an attr.
#
# This is useful in generic setup code, which must (for now) support
# both derivations with and without __structuredAttrs true, so the
# variable may be an array or a space-separated string.
#
# Expressions for individual packages should simply switch to array
# syntax when they switch to setting __structuredAttrs = true.
prependToVar() {
local -n nameref="$1"
local useArray type
if [ -n "$__structuredAttrs" ]; then
useArray=true
else
useArray=false
fi
# check if variable already exist and if it does then do extra checks
if declare -p "$1" 2> /dev/null | grep -q '^'; then
type="$(declare -p "$1")"
if [[ "$type" =~ "declare -A" ]]; then
echo "prependToVar(): ERROR: trying to use prependToVar on an associative array." >&2
return 1
elif [[ "$type" =~ "declare -a" ]]; then
useArray=true
else
useArray=false
fi
fi
shift
if $useArray; then
nameref=( "$@" ${nameref+"${nameref[@]}"} )
else
nameref="$* ${nameref-}"
fi
}
# Same as above
appendToVar() {
local -n nameref="$1"
local useArray type
if [ -n "$__structuredAttrs" ]; then
useArray=true
else
useArray=false
fi
# check if variable already exist and if it does then do extra checks
if declare -p "$1" 2> /dev/null | grep -q '^'; then
type="$(declare -p "$1")"
if [[ "$type" =~ "declare -A" ]]; then
echo "appendToVar(): ERROR: trying to use appendToVar on an associative array, use variable+=([\"X\"]=\"Y\") instead." >&2
return 1
elif [[ "$type" =~ "declare -a" ]]; then
useArray=true
else
useArray=false
fi
fi
shift
if $useArray; then
nameref=( ${nameref+"${nameref[@]}"} "$@" )
else
nameref="${nameref-} $*"
fi
}
# Accumulate into `flagsArray` the flags from the named variables.
#
# If __structuredAttrs, the variables are all treated as arrays
# and simply concatenated onto `flagsArray`.
#
# If not __structuredAttrs, then:
# * Each variable is treated as a string, and split on whitespace;
# * except variables whose names end in "Array", which are treated
# as arrays.
_accumFlagsArray() {
local name
if [ -n "$__structuredAttrs" ]; then
for name in "$@"; do
local -n nameref="$name"
flagsArray+=( ${nameref+"${nameref[@]}"} )
done
else
for name in "$@"; do
local -n nameref="$name"
case "$name" in
*Array)
flagsArray+=( ${nameref+"${nameref[@]}"} ) ;;
*)
flagsArray+=( ${nameref-} ) ;;
esac
done
fi
}
2014-08-25 13:30:46 +00:00
# Add $1/lib* into rpaths.
# The function is used in multiple-outputs.sh hook,
# so it is defined here but tried after the hook.
_addRpathPrefix() {
if [ "${NIX_NO_SELF_RPATH:-0}" != 1 ]; then
export NIX_LDFLAGS="-rpath $1/lib ${NIX_LDFLAGS-}"
2014-08-25 13:30:46 +00:00
fi
}
# Return success if the specified file is an ELF object.
isELF() {
local fn="$1"
local fd
local magic
exec {fd}< "$fn"
read -r -n 4 -u "$fd" magic
exec {fd}<&-
if [ "$magic" = $'\177ELF' ]; then return 0; else return 1; fi
}
# Return success if the specified file is a Mach-O object.
isMachO() {
local fn="$1"
local fd
local magic
exec {fd}< "$fn"
read -r -n 4 -u "$fd" magic
exec {fd}<&-
# nix uses 'declare -F' in get-env.sh to retrieve the loaded functions.
# If we use the $'string' syntax instead of 'echo -ne' then 'declare' will print the raw characters and break nix.
# See https://github.com/NixOS/nixpkgs/pull/138334 and https://github.com/NixOS/nix/issues/5262.
# https://opensource.apple.com/source/lldb/lldb-310.2.36/examples/python/mach_o.py.auto.html
if [[ "$magic" = $(echo -ne "\xfe\xed\xfa\xcf") || "$magic" = $(echo -ne "\xcf\xfa\xed\xfe") ]]; then
# MH_MAGIC_64 || MH_CIGAM_64
return 0;
elif [[ "$magic" = $(echo -ne "\xfe\xed\xfa\xce") || "$magic" = $(echo -ne "\xce\xfa\xed\xfe") ]]; then
# MH_MAGIC || MH_CIGAM
return 0;
elif [[ "$magic" = $(echo -ne "\xca\xfe\xba\xbe") || "$magic" = $(echo -ne "\xbe\xba\xfe\xca") ]]; then
# FAT_MAGIC || FAT_CIGAM
return 0;
else
return 1;
fi
}
# Return success if the specified file is a script (i.e. starts with
# "#!").
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
}
# printf unfortunately will print a trailing newline regardless
printLines() {
(( "$#" > 0 )) || return 0
printf '%s\n' "$@"
}
printWords() {
(( "$#" > 0 )) || return 0
printf '%s ' "$@"
}
######################################################################
# Initialisation.
# If using structured attributes, export variables from `env` to the environment.
# When not using structured attributes, those variables are already exported.
if [[ -n $__structuredAttrs ]]; then
for envVar in "${!env[@]}"; do
declare -x "${envVar}=${env[${envVar}]}"
done
fi
# Set a fallback default value for SOURCE_DATE_EPOCH, used by some build tools
# to provide a deterministic substitute for the "current" time. Note that
# 315532800 = 1980-01-01 12:00:00. We use this date because python's wheel
# implementation uses zip archive and zip does not support dates going back to
# 1970.
export SOURCE_DATE_EPOCH
: "${SOURCE_DATE_EPOCH:=315532800}"
# Wildcard expansions that don't match should expand to an empty list.
# This ensures that, for instance, "for i in *; do ...; done" does the
# right thing.
shopt -s nullglob
# Set up the initial path.
PATH=
HOST_PATH=
for i in $initialPath; do
if [ "$i" = / ]; then i=; fi
addToSearchPath PATH "$i/bin"
# For backward compatibility, we add initial path to HOST_PATH so
# it can be used in auto patch-shebangs. Unfortunately this will
# not work with cross compilation.
if [ -z "${strictDeps-}" ]; then
addToSearchPath HOST_PATH "$i/bin"
fi
done
unset i
if (( "${NIX_DEBUG:-0}" >= 1 )); then
echo "initial path: $PATH"
fi
# Check that the pre-hook initialised SHELL.
if [ -z "${SHELL:-}" ]; then echo "SHELL not set"; exit 1; fi
BASH="$SHELL"
export CONFIG_SHELL="$SHELL"
# Execute the pre-hook.
if [ -z "${shell:-}" ]; then export shell="$SHELL"; fi
runHook preHook
# Allow the caller to augment buildInputs (it's not always possible to
# do this before the call to setup.sh, since the PATH is empty at that
# point; here we have a basic Unix environment).
runHook addInputsHook
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Package accumulators
declare -a pkgsBuildBuild pkgsBuildHost pkgsBuildTarget
declare -a pkgsHostHost pkgsHostTarget
declare -a pkgsTargetTarget
declare -a pkgBuildAccumVars=(pkgsBuildBuild pkgsBuildHost pkgsBuildTarget)
declare -a pkgHostAccumVars=(pkgsHostHost pkgsHostTarget)
declare -a pkgTargetAccumVars=(pkgsTargetTarget)
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
declare -a pkgAccumVarVars=(pkgBuildAccumVars pkgHostAccumVars pkgTargetAccumVars)
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Hooks
declare -a envBuildBuildHooks envBuildHostHooks envBuildTargetHooks
declare -a envHostHostHooks envHostTargetHooks
declare -a envTargetTargetHooks
declare -a pkgBuildHookVars=(envBuildBuildHook envBuildHostHook envBuildTargetHook)
declare -a pkgHostHookVars=(envHostHostHook envHostTargetHook)
declare -a pkgTargetHookVars=(envTargetTargetHook)
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
declare -a pkgHookVarVars=(pkgBuildHookVars pkgHostHookVars pkgTargetHookVars)
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
2021-07-19 05:55:56 +00:00
# those variables are declared here, since where and if they are used varies
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"
shift
local pkgHookVarsSlice="${pkgHookVarVars[$depHostOffset + 1]}[@]"
local pkgHookVar
for pkgHookVar in "${!pkgHookVarsSlice}"; do
eval "${pkgHookVar}s"'+=("$@")'
done
}
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Propagated dep files
declare -a propagatedBuildDepFiles=(
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
propagated-build-build-deps
propagated-native-build-inputs # Legacy name for back-compat
propagated-build-target-deps
)
declare -a propagatedHostDepFiles=(
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
propagated-host-host-deps
propagated-build-inputs # Legacy name for back-compat
)
declare -a propagatedTargetDepFiles=(
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
propagated-target-target-deps
)
declare -a propagatedDepFilesVars=(
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
propagatedBuildDepFiles
propagatedHostDepFiles
propagatedTargetDepFiles
)
# Platform offsets: build = -1, host = 0, target = 1
declare -a allPlatOffsets=(-1 0 1)
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Mutually-recursively find all build inputs. See the dependency section of the
# stdenv chapter of the Nixpkgs manual for the specification this algorithm
# implements.
findInputs() {
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
local -r pkg="$1"
2021-08-17 14:02:11 +00:00
local -r hostOffset="$2"
local -r targetOffset="$3"
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Sanity check
(( hostOffset <= targetOffset )) || exit 1
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
2021-08-17 14:02:11 +00:00
local varVar="${pkgAccumVarVars[hostOffset + 1]}"
local varRef="$varVar[$((targetOffset - hostOffset))]"
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
local var="${!varRef}"
unset -v varVar varRef
# TODO(@Ericson2314): Restore using associative array once Darwin
# 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[*]"
# ${..-} to hack around old bash empty array problem
case "${!varSlice-}" in
*" $pkg "*) return 0 ;;
esac
unset -v varSlice
eval "$var"'+=("$pkg")'
if ! [ -e "$pkg" ]; then
echo "build input $pkg does not exist" >&2
exit 1
fi
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# The current package's host and target offset together
# provide a <=-preserving homomorphism from the relative
# offsets to current offset
function mapOffset() {
2021-08-17 14:02:11 +00:00
local -r inputOffset="$1"
local -n outputOffset="$2"
2021-08-17 14:02:11 +00:00
if (( inputOffset <= 0 )); then
outputOffset=$((inputOffset + hostOffset))
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
else
outputOffset=$((inputOffset - 1 + targetOffset))
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
fi
}
# Host offset relative to that of the package whose immediate
# dependencies we are currently exploring.
2021-08-17 14:02:11 +00:00
local relHostOffset
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
for relHostOffset in "${allPlatOffsets[@]}"; do
# `+ 1` so we start at 0 for valid index
2021-08-17 14:02:11 +00:00
local files="${propagatedDepFilesVars[relHostOffset + 1]}"
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Host offset relative to the package currently being
# built---as absolute an offset as will be used.
local hostOffsetNext
mapOffset "$relHostOffset" hostOffsetNext
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Ensure we're in bounds relative to the package currently
# being built.
(( -1 <= hostOffsetNext && hostOffsetNext <= 1 )) || continue
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Target offset relative to the *host* offset of the package
# whose immediate dependencies we are currently exploring.
local relTargetOffset
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
for relTargetOffset in "${allPlatOffsets[@]}"; do
(( "$relHostOffset" <= "$relTargetOffset" )) || continue
local fileRef="${files}[$relTargetOffset - $relHostOffset]"
local file="${!fileRef}"
unset -v fileRef
# Target offset relative to the package currently being
# built.
local targetOffsetNext
mapOffset "$relTargetOffset" targetOffsetNext
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Once again, ensure we're in bounds relative to the
# package currently being built.
(( -1 <= hostOffsetNext && hostOffsetNext <= 1 )) || continue
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
[[ -f "$pkg/nix-support/$file" ]] || continue
local pkgNext
read -r -d '' pkgNext < "$pkg/nix-support/$file" || true
for pkgNext in $pkgNext; do
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
findInputs "$pkgNext" "$hostOffsetNext" "$targetOffsetNext"
done
done
done
}
# The way we handle deps* and *Inputs works with structured attrs
# either enabled or disabled. For this it's convenient that the items
# in each list must be store paths, and therefore space-free.
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Make sure all are at least defined as empty
: "${depsBuildBuild=}" "${depsBuildBuildPropagated=}"
: "${nativeBuildInputs=}" "${propagatedNativeBuildInputs=}" "${defaultNativeBuildInputs=}"
: "${depsBuildTarget=}" "${depsBuildTargetPropagated=}"
: "${depsHostHost=}" "${depsHostHostPropagated=}"
: "${buildInputs=}" "${propagatedBuildInputs=}" "${defaultBuildInputs=}"
: "${depsTargetTarget=}" "${depsTargetTargetPropagated=}"
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
for pkg in ${depsBuildBuild[@]} ${depsBuildBuildPropagated[@]}; do
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
findInputs "$pkg" -1 -1
done
for pkg in ${nativeBuildInputs[@]} ${propagatedNativeBuildInputs[@]}; do
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
findInputs "$pkg" -1 0
done
for pkg in ${depsBuildTarget[@]} ${depsBuildTargetPropagated[@]}; do
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
findInputs "$pkg" -1 1
done
for pkg in ${depsHostHost[@]} ${depsHostHostPropagated[@]}; do
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
findInputs "$pkg" 0 0
done
for pkg in ${buildInputs[@]} ${propagatedBuildInputs[@]} ; do
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
findInputs "$pkg" 0 1
done
for pkg in ${depsTargetTarget[@]} ${depsTargetTargetPropagated[@]}; do
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
findInputs "$pkg" 1 1
done
# Default inputs must be processed last
for pkg in ${defaultNativeBuildInputs[@]}; do
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
findInputs "$pkg" -1 0
done
for pkg in ${defaultBuildInputs[@]}; do
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
findInputs "$pkg" 0 1
done
# Add package to the future PATH and run setup hooks
activatePackage() {
local pkg="$1"
2021-08-17 14:02:11 +00:00
local -r hostOffset="$2"
local -r targetOffset="$3"
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Sanity check
(( hostOffset <= targetOffset )) || exit 1
if [ -f "$pkg" ]; then
source "$pkg"
fi
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Only dependencies whose host platform is guaranteed to match the
# build platform are included here. That would be `depsBuild*`,
# and legacy `nativeBuildInputs`, in general. If we aren't cross
# compiling, however, everything can be put on the PATH. To ease
2021-07-19 05:49:47 +00:00
# the transition, we do include everything in that case.
#
# TODO(@Ericson2314): Don't special-case native compilation
if [[ -z "${strictDeps-}" || "$hostOffset" -le -1 ]]; then
addToSearchPath _PATH "$pkg/bin"
fi
2021-08-17 14:02:11 +00:00
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
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
if [[ -f "$pkg/nix-support/setup-hook" ]]; then
source "$pkg/nix-support/setup-hook"
fi
}
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
_activatePkgs() {
2021-08-17 14:02:11 +00:00
local hostOffset targetOffset
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
local pkg
for hostOffset in "${allPlatOffsets[@]}"; do
2021-08-17 14:02:11 +00:00
local pkgsVar="${pkgAccumVarVars[hostOffset + 1]}"
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
for targetOffset in "${allPlatOffsets[@]}"; do
2021-08-17 14:02:11 +00:00
(( hostOffset <= targetOffset )) || continue
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
local pkgsRef="${pkgsVar}[$targetOffset - $hostOffset]"
local pkgsSlice="${!pkgsRef}[@]"
for pkg in ${!pkgsSlice+"${!pkgsSlice}"}; do
activatePackage "$pkg" "$hostOffset" "$targetOffset"
done
done
done
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
}
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Run the package setup hooks and build _PATH
_activatePkgs
# Set the relevant environment variables to point to the build inputs
# found above.
#
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# These `depOffset`s, beyond indexing the arrays, also tell the env
# hook what sort of dependency (ignoring propagatedness) is being
# passed to the env hook. In a real language, we'd append a closure
# 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() {
2021-08-17 14:02:11 +00:00
local depHostOffset depTargetOffset
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
local pkg
for depHostOffset in "${allPlatOffsets[@]}"; do
2021-08-17 14:02:11 +00:00
local hookVar="${pkgHookVarVars[depHostOffset + 1]}"
local pkgsVar="${pkgAccumVarVars[depHostOffset + 1]}"
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
for depTargetOffset in "${allPlatOffsets[@]}"; do
2021-08-17 14:02:11 +00:00
(( depHostOffset <= depTargetOffset )) || continue
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
local hookRef="${hookVar}[$depTargetOffset - $depHostOffset]"
if [[ -z "${strictDeps-}" ]]; then
# Keep track of which packages we have visited before.
local visitedPkgs=""
# Apply environment hooks to all packages during native
# compilation to ease the transition.
#
# TODO(@Ericson2314): Don't special-case native compilation
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
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
done
done
}
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
# Run the package-specific hooks set by the setup-hook scripts.
_addToEnv
# Unset setup-specific declared variables
unset allPlatOffsets
unset pkgBuildAccumVars pkgHostAccumVars pkgTargetAccumVars pkgAccumVarVars
unset pkgBuildHookVars pkgHostHookVars pkgTargetHookVars pkgHookVarVars
unset propagatedDepFilesVars
_addRpathPrefix "$out"
# Set the TZ (timezone) environment variable, otherwise commands like
# `date' will complain (e.g., `Tue Mar 9 10:01:47 Local time zone must
# be set--see zic manual page 2004').
export TZ=UTC
# Set the prefix. This is generally $out, but it can be overriden,
# for instance if we just want to perform a test build/install to a
# temporary location and write a build report to $out.
if [ -z "${prefix:-}" ]; then
prefix="$out";
fi
if [ "${useTempPrefix:-}" = 1 ]; then
prefix="$NIX_BUILD_TOP/tmp_prefix";
fi
PATH="${_PATH-}${_PATH:+${PATH:+:}}$PATH"
HOST_PATH="${_HOST_PATH-}${_HOST_PATH:+${HOST_PATH:+:}}$HOST_PATH"
export XDG_DATA_DIRS="${_XDG_DATA_DIRS-}${_XDG_DATA_DIRS:+${XDG_DATA_DIRS:+:}}${XDG_DATA_DIRS-}"
if (( "${NIX_DEBUG:-0}" >= 1 )); then
echo "final path: $PATH"
echo "final host path: $HOST_PATH"
echo "final data dirs: $XDG_DATA_DIRS"
fi
unset _PATH
unset _HOST_PATH
unset _XDG_DATA_DIRS
# Normalize the NIX_BUILD_CORES variable. The value might be 0, which
# means that we're supposed to try and auto-detect the number of
# available CPU cores at run-time.
NIX_BUILD_CORES="${NIX_BUILD_CORES:-1}"
if ((NIX_BUILD_CORES <= 0)); then
guess=$(nproc 2>/dev/null || true)
((NIX_BUILD_CORES = guess <= 0 ? 1 : guess))
fi
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
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
export SSL_CERT_FILE=/no-cert-file.crt
fi
######################################################################
# Textual substitution functions.
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" >&2
fi
fi
;;
--subst-var)
local varName="$2"
shift 2
# check if the used nix attribute name is a valid bash name
if ! [[ "$varName" =~ ^[a-zA-Z_][a-zA-Z0-9_]*$ ]]; then
echo "substituteStream(): ERROR: substitution variables must be valid Bash names, \"$varName\" isn't." >&2
return 1
fi
if [ -z ${!varName+x} ]; then
echo "substituteStream(): ERROR: variable \$$varName is unset" >&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" >&2
return 1
;;
esac
done
printf "%s" "${!var}"
}
# put the content of a file in a variable
# fail loudly if provided with a binary (containing null bytes)
consumeEntire() {
# read returns non-0 on EOF, so we want read to fail
if IFS='' read -r -d '' "$1" ; then
echo "consumeEntire(): ERROR: Input null bytes, won't process" >&2
return 1
fi
}
substitute() {
local input="$1"
local output="$2"
shift 2
if [ ! -f "$input" ]; then
echo "substitute(): ERROR: file '$input' does not exist" >&2
return 1
fi
local content
consumeEntire content < "$input"
if [ -e "$output" ]; then chmod +w "$output"; fi
substituteStream content "file '$input'" "$@" > "$output"
}
substituteInPlace() {
local -a fileNames=()
for arg in "$@"; do
if [[ "$arg" = "--"* ]]; then
break
fi
fileNames+=("$arg")
shift
done
for file in "${fileNames[@]}"; do
substitute "$file" "$file" "$@"
done
}
_allFlags() {
# export some local variables for the awk below
# so some substitutions such as name don't have to be in the env attrset
# when __structuredAttrs is enabled
export system pname name version
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}" >&2
fi
args+=("--subst-var" "$varName")
done
}
substituteAllStream() {
local -a args=()
_allFlags
substituteStream "$1" "$2" "${args[@]}"
}
# Substitute all environment variables that start with a lowercase character and
# are valid Bash names.
substituteAll() {
local input="$1"
local output="$2"
local -a args=()
_allFlags
substitute "$input" "$output" "${args[@]}"
}
substituteAllInPlace() {
local fileName="$1"
shift
substituteAll "$fileName" "$fileName" "$@"
}
######################################################################
# What follows is the generic builder.
# This function is useful for debugging broken Nix builds. It dumps
# all environment variables to a file `env-vars' in the build
# directory. If the build fails and the `-K' option is used, you can
# then go to the build directory and source in `env-vars' to reproduce
# the environment used for building.
dumpVars() {
if [ "${noDumpEnvVars:-0}" != 1 ]; then
export 2>/dev/null >| "$NIX_BUILD_TOP/env-vars" || true
fi
}
2016-10-12 20:29:38 +00:00
# Utility function: echo the base name of the given path, with the
# prefix `HASH-' removed, if present.
stripHash() {
local strippedName casematchOpt=0
# On separate line for `set -e`
strippedName="$(basename -- "$1")"
shopt -q nocasematch && casematchOpt=1
shopt -u nocasematch
if [[ "$strippedName" =~ ^[a-z0-9]{32}- ]]; then
echo "${strippedName:33}"
2016-10-12 20:29:38 +00:00
else
echo "$strippedName"
fi
if (( casematchOpt )); then shopt -s nocasematch; fi
}
recordPropagatedDependencies() {
# Propagate dependencies into the development output.
declare -ra flatVars=(
# Build
depsBuildBuildPropagated
propagatedNativeBuildInputs
depsBuildTargetPropagated
# Host
depsHostHostPropagated
propagatedBuildInputs
# Target
depsTargetTargetPropagated
)
declare -ra flatFiles=(
"${propagatedBuildDepFiles[@]}"
"${propagatedHostDepFiles[@]}"
"${propagatedTargetDepFiles[@]}"
)
local propagatedInputsIndex
for propagatedInputsIndex in "${!flatVars[@]}"; do
local propagatedInputsSlice="${flatVars[$propagatedInputsIndex]}[@]"
local propagatedInputsFile="${flatFiles[$propagatedInputsIndex]}"
[[ "${!propagatedInputsSlice}" ]] || continue
mkdir -p "${!outputDev}/nix-support"
# shellcheck disable=SC2086
printWords ${!propagatedInputsSlice} > "${!outputDev}/nix-support/$propagatedInputsFile"
done
}
unpackCmdHooks+=(_defaultUnpack)
_defaultUnpack() {
local fn="$1"
local destination
if [ -d "$fn" ]; then
destination="$(stripHash "$fn")"
if [ -e "$destination" ]; then
echo "Cannot copy $fn to $destination: destination already exists!"
echo "Did you specify two \"srcs\" with the same \"name\"?"
return 1
fi
# We can't preserve hardlinks because they may have been
# introduced by store optimization, which might break things
# in the build.
cp -pr --reflink=auto -- "$fn" "$destination"
else
case "$fn" in
*.tar.xz | *.tar.lzma | *.txz)
# Don't rely on tar knowing about .xz.
2021-09-09 18:13:21 +00:00
xz -d < "$fn" | tar xf - --warning=no-timestamp
;;
*.tar | *.tar.* | *.tgz | *.tbz2 | *.tbz)
# GNU tar can automatically select the decompression method
# (info "(tar) gzip").
2021-09-09 18:13:21 +00:00
tar xf "$fn" --warning=no-timestamp
;;
*)
return 1
;;
esac
fi
}
unpackFile() {
curSrc="$1"
echo "unpacking source archive $curSrc"
if ! runOneHook unpackCmd "$curSrc"; then
echo "do not know how to unpack source archive $curSrc"
exit 1
fi
}
unpackPhase() {
runHook preUnpack
2012-12-28 15:41:56 +00:00
if [ -z "${srcs:-}" ]; then
if [ -z "${src:-}" ]; then
# shellcheck disable=SC2016
echo 'variable $src or $srcs should point to the source'
exit 1
fi
srcs="$src"
fi
local -a srcsArray
if [ -n "$__structuredAttrs" ]; then
srcsArray=( "${srcs[@]}" )
else
srcsArray=( $srcs )
fi
# To determine the source directory created by unpacking the
# source archives, we record the contents of the current
# directory, then look below which directory got added. Yeah,
# it's rather hacky.
local dirsBefore=""
for i in *; do
if [ -d "$i" ]; then
dirsBefore="$dirsBefore $i "
fi
done
# Unpack all source archives.
for i in "${srcsArray[@]}"; do
unpackFile "$i"
done
# Find the source directory.
# set to empty if unset
: "${sourceRoot=}"
if [ -n "${setSourceRoot:-}" ]; then
runOneHook setSourceRoot
elif [ -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
if [ -z "$sourceRoot" ]; then
echo "unpacker appears to have produced no directories"
exit 1
fi
echo "source root is $sourceRoot"
# By default, add write permission to the sources. This is often
# necessary when sources have been copied from other store
# locations.
if [ "${dontMakeSourcesWritable:-0}" != 1 ]; then
2018-02-15 16:50:24 +00:00
chmod -R u+w -- "$sourceRoot"
fi
runHook postUnpack
}
patchPhase() {
runHook prePatch
2012-12-28 15:41:56 +00:00
local -a patchesArray
if [ -n "$__structuredAttrs" ]; then
patchesArray=( ${patches:+"${patches[@]}"} )
else
patchesArray=( ${patches:-} )
fi
for i in "${patchesArray[@]}"; do
echo "applying patch $i"
local uncompress=cat
2014-10-09 19:41:56 +00:00
case "$i" in
*.gz)
uncompress="gzip -d"
;;
*.bz2)
uncompress="bzip2 -d"
;;
2013-08-07 13:45:21 +00:00
*.xz)
uncompress="xz -d"
;;
*.lzma)
uncompress="lzma -d"
;;
esac
local -a flagsArray
if [ -n "$__structuredAttrs" ]; then
flagsArray=( "${patchFlags[@]:--p1}" )
else
# shellcheck disable=SC2086
flagsArray=( ${patchFlags:--p1} )
fi
# "2>&1" is a hack to make patch fail if the decompressor fails (nonexistent patch, etc.)
# shellcheck disable=SC2086
$uncompress < "$i" 2>&1 | patch "${flagsArray[@]}"
done
runHook postPatch
}
fixLibtool() {
stdenv/setup: tell libtool about library paths Packages that use libtool run it as a wrapper around the linker. Before calling the linker, libtool will determine what libraries would be linked, and check if there's a corresponding libtool archive (libfoo.la) file in the same directory . This file contains extra information about the library. This is especially important for static linking, because static archives don't contain dependency information, so we need libtool to use the .la files to figure out which libraries actually need to be linked against. But in Nixpkgs, this has never worked. libtool isn't able to find any libraries, because only the compiler wrapper knows how to find them, and the compiler wrapper is opaque to libtool. This is why pkgsStatic.util-linuxMinimal doesn't build prior to this patch — it depends on libpam, which depends on libaudit, and if libtool can't find the .la file, nothing will tell the linker to also link against libaudit when linking libpam. (It was previously possible to build a static util-linux, because linux-pam only recently had the audit dependency added.) There are a couple of ways we could fix this, so that libtool knows where to look for .la files. * Set LD_LIBRARY_PATH/DYLD_LIBRARY_PATH/whatever, which libtool will examine. This would have major side effects though, because the dynamic linker looks at it too. * Inject libtool scripts with the appropriate information. That's what I've done here. It was the obvious choice because we're already finding and modifying the libtool scripts, to remove paths outside the Nix store that libtool might check in unsandboxed builds. Instead of emptying out the system paths, we can repopulate it with our own library paths. (We can't use a wrapper like we do for other tools in Nixpkgs, because libtool scripts are often distributed in source tarballs, so we can't just add a wrapped version of libtool as a dependency. That's why there's already the fixLibtool function in stdenv.) With this change, libtool is able to discover .la files, and pkgsStatic.util-linuxMinimal can build again, linking correctly against libpam and libaudit.
2021-11-05 13:48:14 +00:00
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:-}'^" \
stdenv/setup: tell libtool about library paths Packages that use libtool run it as a wrapper around the linker. Before calling the linker, libtool will determine what libraries would be linked, and check if there's a corresponding libtool archive (libfoo.la) file in the same directory . This file contains extra information about the library. This is especially important for static linking, because static archives don't contain dependency information, so we need libtool to use the .la files to figure out which libraries actually need to be linked against. But in Nixpkgs, this has never worked. libtool isn't able to find any libraries, because only the compiler wrapper knows how to find them, and the compiler wrapper is opaque to libtool. This is why pkgsStatic.util-linuxMinimal doesn't build prior to this patch — it depends on libpam, which depends on libaudit, and if libtool can't find the .la file, nothing will tell the linker to also link against libaudit when linking libpam. (It was previously possible to build a static util-linux, because linux-pam only recently had the audit dependency added.) There are a couple of ways we could fix this, so that libtool knows where to look for .la files. * Set LD_LIBRARY_PATH/DYLD_LIBRARY_PATH/whatever, which libtool will examine. This would have major side effects though, because the dynamic linker looks at it too. * Inject libtool scripts with the appropriate information. That's what I've done here. It was the obvious choice because we're already finding and modifying the libtool scripts, to remove paths outside the Nix store that libtool might check in unsandboxed builds. Instead of emptying out the system paths, we can repopulate it with our own library paths. (We can't use a wrapper like we do for other tools in Nixpkgs, because libtool scripts are often distributed in source tarballs, so we can't just add a wrapped version of libtool as a dependency. That's why there's already the fixLibtool function in stdenv.) With this change, libtool is able to discover .la files, and pkgsStatic.util-linuxMinimal can build again, linking correctly against libpam and libaudit.
2021-11-05 13:48:14 +00:00
-e 's^eval sys_lib_.+search_path=.*^^'
}
configurePhase() {
runHook preConfigure
# set to empty if unset
: "${configureScript=}"
if [[ -z "$configureScript" && -x ./configure ]]; then
configureScript=./configure
fi
if [ -z "${dontFixLibtool:-}" ]; then
stdenv/setup: force libtool to skip dep checks When we "fix" libtool, we empty out its system library path to avoid it discovering libraries in e.g. /usr when the sandbox is disabled. But this also means that the checks libtool does to make sure it can find the libraries its supposed to be linking to won't work. On Linux and Darwin, this isn't a problem, because libtool doesn't actually perform any checks, but it is on at least NetBSD and Cygwin[1]. So, we force libtool not to do these checks on any platform, bringing the more exotic platforms into line with the existing behaviour on Linux and Darwin. Without this change, lots of library packages produce warnings like this in their build output on the platforms with checks by default: *** Warning: linker path does not have real file for library -lz. *** I have the capability to make that library automatically link in when *** you link to this library. But I can only do this if you have a *** shared version of the library, which you do not appear to have *** because I did check the linker path looking for a file starting *** with libz but no candidates were found. (...for regex pattern test) *** The inter-library dependencies that have been dropped here will be *** automatically added whenever a program is linked with this library *** or is declared to -dlopen it. And dependent packages break because libtool doesn't link their transitive dependencies. So making this change fixes _lots_ of packages on those platforms. [1]: https://git.savannah.gnu.org/cgit/libtool.git/tree/m4/libtool.m4?id=544fc0e2c2a03129a540aebef41ad32bfb5c06b8#n3445
2021-07-24 21:56:01 +00:00
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
fixLibtool(): patch ./configure, add `file` to common-path.nix libtool's libtool.m4 script assumes that `file` is available, and can be found at `/usr/bin/file` (this path is hardwired). Furthermore, the script with this assumption is vendored into the ./configure scripts of an enormous number of packages. Without this commit, you will frequently see errors like this during the configurePhase with the sandbox enabled: ./configure: line 9595: /usr/bin/file: command not found Due mostly to luck, this error does not affect native compiles on nixpkgs' two most popular platforms, x86_64-linux and aarch64-linux. However it will cause incorrect linker flag detection and a failure to generate shared libraries for sandboxed cross-builds to a x86_64-linux host as well as any sandboxed build (cross or native) for the following hosts: x86_64-freebsd, *-hpux, *-irix, mips64*-linux, powerpc*-linux, s390x-linux, s390x-tpf, sparc-linux, and *-solaris. This commit fixes the problem by adding an extra line to fixLibtool() in pkgs/stdenv/generic/setup.sh. This extra line will scan the unpacked source code for executable files named "configure" which contain the following text: 'GNU Libtool is free software; you can redistribute it and/or modify' This text is taken to be an indicator of a vendored libtool.m4. When it is found, the configure script containing it is subjected to `sed -i s_/usr/bin/file_file_` which replaces all occurrences of `/usr/bin/file` with `file`. Additionally, the `file` package is now considered to be part of `stdenv`. It has been added to `common-path.nix` so that the `file` binary will be found in the `$PATH` of every build, except for the bootstrap-tools and the first few stages of stdenv boostrapping. Verified no regressions under: nix-build --arg pkgs 'import ./. {}' ./lib/tests/release.nix This commit allows the following commands to complete, which should enable Hydra to produce bootstrap-files for mips64el: nix-build \ --option sandbox true \ --option sandbox-fallback false \ pkgs/top-level/release-cross.nix \ -A bootstrapTools.mips64el-linux-gnuabi64.build nix-build \ --option sandbox true \ --option sandbox-fallback false \ . \ -A pkgsCross.mips64el-linux-gnuabi64.nix_2_4
2022-04-12 21:46:57 +00:00
# replace `/usr/bin/file` with `file` in any `configure`
# scripts with vendored libtool code. Preserve mtimes to
# prevent some packages (e.g. libidn2) from spontaneously
# autoreconf'ing themselves
CONFIGURE_MTIME_REFERENCE=$(mktemp configure.mtime.reference.XXXXXX)
fixLibtool(): patch ./configure, add `file` to common-path.nix libtool's libtool.m4 script assumes that `file` is available, and can be found at `/usr/bin/file` (this path is hardwired). Furthermore, the script with this assumption is vendored into the ./configure scripts of an enormous number of packages. Without this commit, you will frequently see errors like this during the configurePhase with the sandbox enabled: ./configure: line 9595: /usr/bin/file: command not found Due mostly to luck, this error does not affect native compiles on nixpkgs' two most popular platforms, x86_64-linux and aarch64-linux. However it will cause incorrect linker flag detection and a failure to generate shared libraries for sandboxed cross-builds to a x86_64-linux host as well as any sandboxed build (cross or native) for the following hosts: x86_64-freebsd, *-hpux, *-irix, mips64*-linux, powerpc*-linux, s390x-linux, s390x-tpf, sparc-linux, and *-solaris. This commit fixes the problem by adding an extra line to fixLibtool() in pkgs/stdenv/generic/setup.sh. This extra line will scan the unpacked source code for executable files named "configure" which contain the following text: 'GNU Libtool is free software; you can redistribute it and/or modify' This text is taken to be an indicator of a vendored libtool.m4. When it is found, the configure script containing it is subjected to `sed -i s_/usr/bin/file_file_` which replaces all occurrences of `/usr/bin/file` with `file`. Additionally, the `file` package is now considered to be part of `stdenv`. It has been added to `common-path.nix` so that the `file` binary will be found in the `$PATH` of every build, except for the bootstrap-tools and the first few stages of stdenv boostrapping. Verified no regressions under: nix-build --arg pkgs 'import ./. {}' ./lib/tests/release.nix This commit allows the following commands to complete, which should enable Hydra to produce bootstrap-files for mips64el: nix-build \ --option sandbox true \ --option sandbox-fallback false \ pkgs/top-level/release-cross.nix \ -A bootstrapTools.mips64el-linux-gnuabi64.build nix-build \ --option sandbox true \ --option sandbox-fallback false \ . \ -A pkgsCross.mips64el-linux-gnuabi64.nix_2_4
2022-04-12 21:46:57 +00:00
find . \
-executable \
-type f \
-name configure \
-exec grep -l 'GNU Libtool is free software; you can redistribute it and/or modify' {} \; \
-exec touch -r {} "$CONFIGURE_MTIME_REFERENCE" \; \
-exec sed -i s_/usr/bin/file_file_g {} \; \
-exec touch -r "$CONFIGURE_MTIME_REFERENCE" {} \;
fixLibtool(): patch ./configure, add `file` to common-path.nix libtool's libtool.m4 script assumes that `file` is available, and can be found at `/usr/bin/file` (this path is hardwired). Furthermore, the script with this assumption is vendored into the ./configure scripts of an enormous number of packages. Without this commit, you will frequently see errors like this during the configurePhase with the sandbox enabled: ./configure: line 9595: /usr/bin/file: command not found Due mostly to luck, this error does not affect native compiles on nixpkgs' two most popular platforms, x86_64-linux and aarch64-linux. However it will cause incorrect linker flag detection and a failure to generate shared libraries for sandboxed cross-builds to a x86_64-linux host as well as any sandboxed build (cross or native) for the following hosts: x86_64-freebsd, *-hpux, *-irix, mips64*-linux, powerpc*-linux, s390x-linux, s390x-tpf, sparc-linux, and *-solaris. This commit fixes the problem by adding an extra line to fixLibtool() in pkgs/stdenv/generic/setup.sh. This extra line will scan the unpacked source code for executable files named "configure" which contain the following text: 'GNU Libtool is free software; you can redistribute it and/or modify' This text is taken to be an indicator of a vendored libtool.m4. When it is found, the configure script containing it is subjected to `sed -i s_/usr/bin/file_file_` which replaces all occurrences of `/usr/bin/file` with `file`. Additionally, the `file` package is now considered to be part of `stdenv`. It has been added to `common-path.nix` so that the `file` binary will be found in the `$PATH` of every build, except for the bootstrap-tools and the first few stages of stdenv boostrapping. Verified no regressions under: nix-build --arg pkgs 'import ./. {}' ./lib/tests/release.nix This commit allows the following commands to complete, which should enable Hydra to produce bootstrap-files for mips64el: nix-build \ --option sandbox true \ --option sandbox-fallback false \ pkgs/top-level/release-cross.nix \ -A bootstrapTools.mips64el-linux-gnuabi64.build nix-build \ --option sandbox true \ --option sandbox-fallback false \ . \ -A pkgsCross.mips64el-linux-gnuabi64.nix_2_4
2022-04-12 21:46:57 +00:00
rm -f "$CONFIGURE_MTIME_REFERENCE"
fi
if [[ -z "${dontAddPrefix:-}" && -n "$prefix" ]]; then
prependToVar configureFlags "${prefixKey:---prefix=}$prefix"
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
prependToVar configureFlags --disable-dependency-tracking
fi
fi
# By default, disable static builds.
if [ -z "${dontDisableStatic:-}" ]; then
if grep -q enable-static "$configureScript"; then
prependToVar configureFlags --disable-static
fi
fi
fi
if [ -n "$configureScript" ]; then
local -a flagsArray
_accumFlagsArray configureFlags configureFlagsArray
echoCmd 'configure flags' "${flagsArray[@]}"
# shellcheck disable=SC2086
$configureScript "${flagsArray[@]}"
unset flagsArray
else
echo "no configure script, doing nothing"
fi
runHook postConfigure
}
buildPhase() {
runHook preBuild
if [[ -z "${makeFlags-}" && -z "${makefile:-}" && ! ( -e Makefile || -e makefile || -e GNUmakefile ) ]]; then
echo "no Makefile or custom buildPhase, doing nothing"
else
foundMakefile=1
# shellcheck disable=SC2086
local flagsArray=(
${enableParallelBuilding:+-j${NIX_BUILD_CORES}}
SHELL=$SHELL
)
_accumFlagsArray makeFlags makeFlagsArray buildFlags buildFlagsArray
echoCmd 'build flags' "${flagsArray[@]}"
make ${makefile:+-f $makefile} "${flagsArray[@]}"
unset flagsArray
fi
runHook postBuild
}
checkPhase() {
runHook preCheck
if [[ -z "${foundMakefile:-}" ]]; then
echo "no Makefile or custom checkPhase, doing nothing"
runHook postCheck
return
fi
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
elif make -n ${makefile:+-f $makefile} test >/dev/null 2>&1; then
checkTarget=test
fi
fi
if [[ -z "${checkTarget:-}" ]]; then
echo "no check/test target in ${makefile:-Makefile}, doing nothing"
else
# Old bash empty array hack
# shellcheck disable=SC2086
local flagsArray=(
${enableParallelChecking:+-j${NIX_BUILD_CORES}}
SHELL=$SHELL
)
_accumFlagsArray makeFlags makeFlagsArray
if [ -n "$__structuredAttrs" ]; then
flagsArray+=( "${checkFlags[@]:-VERBOSE=y}" )
else
flagsArray+=( ${checkFlags:-VERBOSE=y} )
fi
_accumFlagsArray checkFlagsArray
flagsArray+=( ${checkTarget} )
echoCmd 'check flags' "${flagsArray[@]}"
make ${makefile:+-f $makefile} "${flagsArray[@]}"
unset flagsArray
fi
runHook postCheck
}
installPhase() {
runHook preInstall
# Dont reuse 'foundMakefile' set in buildPhase, a makefile may have been created in buildPhase
if [[ -z "${makeFlags-}" && -z "${makefile:-}" && ! ( -e Makefile || -e makefile || -e GNUmakefile ) ]]; then
echo "no Makefile or custom installPhase, doing nothing"
runHook postInstall
return
else
foundMakefile=1
fi
2014-08-25 13:30:46 +00:00
if [ -n "$prefix" ]; then
mkdir -p "$prefix"
fi
# shellcheck disable=SC2086
local flagsArray=(
${enableParallelInstalling:+-j${NIX_BUILD_CORES}}
SHELL=$SHELL
)
_accumFlagsArray makeFlags makeFlagsArray installFlags installFlagsArray
if [ -n "$__structuredAttrs" ]; then
flagsArray+=( "${installTargets[@]:-install}" )
else
flagsArray+=( ${installTargets:-install} )
fi
echoCmd 'install flags' "${flagsArray[@]}"
make ${makefile:+-f $makefile} "${flagsArray[@]}"
unset flagsArray
runHook postInstall
}
2014-06-25 14:47:58 +00:00
# The fixup phase performs generic, package-independent stuff, like
# stripping binaries, running patchelf and setting
# propagated-build-inputs.
fixupPhase() {
# Make sure everything is writable so "strip" et al. work.
stdenv: Fix handling of dependencies and hooks 4 far-reaching changes: Smaller PATH, New vars, different propagation logic, and different hook logic Smaller PATH ------------ `buildInputs` no longer go on the PATH at build time, as they cannot be run when cross compiling and we don't want to special case. Simply make a `nativeBuildInput` too if one needs them on the PATH. Fixes #21191. Many new depedendency variables ------------------------------- See the stdenv chapter of the nixpkgs manual. I pulled out the existing documentation of dependency specification into a new section, and added language for these two (and their propagated equivalents) along side the others'. More complex propagation logic ------------------------------ Before a propagated*XXX*Input always acted as if it was specified directly as a *XXX*Input downstream. That's simple enough, but violates the intended roles of each sort of dep, which has functional and not just stylistic consequences. The new algorithm is detailed in the manual, and ensures everything ends up in the right place. I tried to give both an informal and formal description, but I suspect in practice it will not make much sense until one tries cross compiling, after which it will immediately make sense as the only sane option. Simplified hook logic --------------------- Rather than `envHook` and `crossEnvHook`, whose behavior differs depending on whether we are cross compiling or not, there is now one hook per sort (or rather non-propagated and propagated pair of sorts) of dependency. These new hooks have the same meaning regardless of cross compilation. See the setup hook section of stdenv chapter of the Nixpkgs manual for more details.
2017-09-11 16:20:20 +00:00
local output
for output in $(getAllOutputNames); do
if [ -e "${!output}" ]; then chmod -R u+w "${!output}"; fi
2014-06-25 14:47:58 +00:00
done
runHook preFixup
2014-06-25 14:47:58 +00:00
# Apply fixup to each output.
local output
for output in $(getAllOutputNames); do
prefix="${!output}" runHook fixupOutput
2014-06-25 14:47:58 +00:00
done
# record propagated dependencies & setup hook into the development output.
recordPropagatedDependencies
if [ -n "${setupHook:-}" ]; then
mkdir -p "${!outputDev}/nix-support"
substituteAll "$setupHook" "${!outputDev}/nix-support/setup-hook"
2014-06-25 14:47:58 +00:00
fi
# TODO(@Ericson2314): Remove after https://github.com/NixOS/nixpkgs/pull/31414
if [ -n "${setupHooks:-}" ]; then
mkdir -p "${!outputDev}/nix-support"
local hook
# have to use ${setupHooks[@]} without quotes because it needs to support setupHooks being a array or a whitespace separated string
# # values of setupHooks won't have spaces so it won't cause problems
# shellcheck disable=2068
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
# Propagate user-env packages into the output with binaries, TODO?
if [ -n "${propagatedUserEnvPkgs:-}" ]; then
mkdir -p "${!outputBin}/nix-support"
# shellcheck disable=SC2086
printWords $propagatedUserEnvPkgs > "${!outputBin}/nix-support/propagated-user-env-packages"
2014-06-25 14:47:58 +00:00
fi
runHook postFixup
}
installCheckPhase() {
runHook preInstallCheck
if [[ -z "${foundMakefile:-}" ]]; then
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
echo "no installcheck target in ${makefile:-Makefile}, doing nothing"
else
# Old bash empty array hack
# shellcheck disable=SC2086
local flagsArray=(
${enableParallelChecking:+-j${NIX_BUILD_CORES}}
SHELL=$SHELL
)
_accumFlagsArray makeFlags makeFlagsArray \
installCheckFlags installCheckFlagsArray
flagsArray+=( ${installCheckTarget:-installcheck} )
echoCmd 'installcheck flags' "${flagsArray[@]}"
make ${makefile:+-f $makefile} "${flagsArray[@]}"
unset flagsArray
fi
runHook postInstallCheck
}
distPhase() {
runHook preDist
local flagsArray=()
_accumFlagsArray distFlags distFlagsArray
flagsArray+=( ${distTarget:-dist} )
echo 'dist flags: %q' "${flagsArray[@]}"
make ${makefile:+-f $makefile} "${flagsArray[@]}"
if [ "${dontCopyDist:-0}" != 1 ]; then
mkdir -p "$out/tarballs"
# Note: don't quote $tarballs, since we explicitly permit
# wildcards in there.
# shellcheck disable=SC2086
cp -pvd ${tarballs[*]:-*.tar.gz} "$out/tarballs"
fi
runHook postDist
}
showPhaseHeader() {
local phase="$1"
case "$phase" in
unpackPhase) echo "unpacking sources";;
patchPhase) echo "patching sources";;
configurePhase) echo "configuring";;
buildPhase) echo "building";;
checkPhase) echo "running tests";;
installPhase) echo "installing";;
fixupPhase) echo "post-installation fixup";;
installCheckPhase) echo "running install tests";;
*) echo "$phase";;
esac
}
showPhaseFooter() {
local phase="$1"
local startTime="$2"
local endTime="$3"
local delta=$(( endTime - startTime ))
(( delta < 30 )) && return
local H=$((delta/3600))
local M=$((delta%3600/60))
local S=$((delta%60))
echo -n "$phase completed in "
(( H > 0 )) && echo -n "$H hours "
(( M > 0 )) && echo -n "$M minutes "
echo "$S seconds"
}
runPhase() {
local curPhase="$*"
if [[ "$curPhase" = unpackPhase && -n "${dontUnpack:-}" ]]; then return; fi
if [[ "$curPhase" = patchPhase && -n "${dontPatch:-}" ]]; then return; fi
if [[ "$curPhase" = configurePhase && -n "${dontConfigure:-}" ]]; then return; fi
if [[ "$curPhase" = buildPhase && -n "${dontBuild:-}" ]]; then return; fi
if [[ "$curPhase" = checkPhase && -z "${doCheck:-}" ]]; then return; fi
if [[ "$curPhase" = installPhase && -n "${dontInstall:-}" ]]; then return; fi
if [[ "$curPhase" = fixupPhase && -n "${dontFixup:-}" ]]; then return; fi
if [[ "$curPhase" = installCheckPhase && -z "${doInstallCheck:-}" ]]; then return; fi
if [[ "$curPhase" = distPhase && -z "${doDist:-}" ]]; then return; fi
if [[ -n $NIX_LOG_FD ]]; then
echo "@nix { \"action\": \"setPhase\", \"phase\": \"$curPhase\" }" >&"$NIX_LOG_FD"
fi
showPhaseHeader "$curPhase"
dumpVars
local startTime=$(date +"%s")
# Evaluate the variable named $curPhase if it exists, otherwise the
# function named $curPhase.
eval "${!curPhase:-$curPhase}"
local endTime=$(date +"%s")
showPhaseFooter "$curPhase" "$startTime" "$endTime"
if [ "$curPhase" = unpackPhase ]; then
# make sure we can cd into the directory
[ -n "${sourceRoot:-}" ] && chmod +x "${sourceRoot}"
cd "${sourceRoot:-.}"
fi
}
genericBuild() {
# variable used by our gzip wrapper to add -n.
# gzip is in common-path.nix and is added to nix-shell but we only want to change its behaviour in nix builds. do not move to a setupHook in gzip.
export GZIP_NO_TIMESTAMPS=1
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
# The use of ${phases[*]} gives the correct behavior both with and
# without structured attrs. This relies on the fact that each
# phase name is space-free, which it must be because it's the name
# of either a shell variable or a shell function.
for curPhase in ${phases[*]}; do
runPhase "$curPhase"
done
}
2014-01-07 08:48:23 +00:00
# Execute the post-hooks.
runHook postHook
# Execute the global user hook (defined through the Nixpkgs
# configuration option stdenv.userHook). This can be used to set
# global compiler optimisation flags, for instance.
runHook userHook
dumpVars
# Restore the original options for nix-shell
[[ $__nixpkgs_setup_set_original == *e* ]] || set +e
[[ $__nixpkgs_setup_set_original == *u* ]] || set +u
unset -v __nixpkgs_setup_set_original