Merge master into stdenv-updates

Conflicts (simple):
	pkgs/development/tools/misc/binutils/default.nix
	pkgs/tools/package-management/disnix/default.nix
	pkgs/top-level/all-packages.nix

1 files changed, 876 insertions, 0 deletions

diff --git a/pkgs/stdenv/generic/setup-repeatable.sh b/pkgs/stdenv/generic/setup-repeatable.sh
new file mode 100644
index 000000000000..3b2e01519320
--- /dev/null
+++ b/pkgs/stdenv/generic/setup-repeatable.sh
@@ -0,0 +1,876 @@
+# Run the named hook, either by calling the function with that name or
+# by evaluating the variable with that name.  This allows convenient
+# setting of hooks both from Nix expressions (as attributes /
+# environment variables) and from shell scripts (as functions).
+runHook() {
+    local hookName="$1"
+    case "$(type -t $hookName)" in
+        (function|alias|builtin) $hookName;;
+        (file) source $hookName;;
+        (keyword) :;;
+        (*) eval "${!hookName}";;
+    esac
+}
+
+
+exitHandler() {
+    exitCode=$?
+    set +e
+
+    closeNest
+
+    if [ -n "$showBuildStats" ]; then
+        times > "$NIX_BUILD_TOP/.times"
+        local -a times=($(cat "$NIX_BUILD_TOP/.times"))
+        # Print the following statistics:
+        # - user time for the shell
+        # - system time for the shell
+        # - user time for all child processes
+        # - system time for all child processes
+        echo "build time elapsed: " ${times[*]}
+    fi
+
+    if [ $exitCode != 0 ]; then
+        runHook failureHook
+
+        # If the builder had a non-zero exit code and
+        # $succeedOnFailure is set, create the file
+        # `$out/nix-support/failed' to signal failure, and exit
+        # normally.  Otherwise, return the original exit code.
+        if [ -n "$succeedOnFailure" ]; then
+            echo "build failed with exit code $exitCode (ignored)"
+            mkdir -p "$out/nix-support"
+            echo -n $exitCode > "$out/nix-support/failed"
+            exit 0
+        fi
+
+    else
+        runHook exitHook
+    fi
+
+    exit $exitCode
+}
+
+trap "exitHandler" EXIT
+
+
+######################################################################
+# Helper functions that might be useful in setup hooks.
+
+
+addToSearchPathWithCustomDelimiter() {
+    local delimiter=$1
+    local varName=$2
+    local dir=$3
+    if [ -d "$dir" ]; then
+        eval export ${varName}=${!varName}${!varName:+$delimiter}${dir}
+    fi
+}
+
+PATH_DELIMITER=':'
+
+addToSearchPath() {
+    addToSearchPathWithCustomDelimiter "${PATH_DELIMITER}" "$@"
+}
+
+
+######################################################################
+# Initialisation.
+
+set -e
+
+[ -z $NIX_GCC ] && NIX_GCC=@gcc@
+
+
+# Wildcard expansions that don't match should expand to an empty list.
+# This ensures that, for instance, "for i in *; do ...; done" does the
+# right thing.
+shopt -s nullglob
+
+
+# Set up the initial path.
+PATH=
+for i in $NIX_GCC @initialPath@; do
+    if [ "$i" = / ]; then i=; fi
+    addToSearchPath PATH $i/bin
+done
+
+if [ "$NIX_DEBUG" = 1 ]; then
+    echo "initial path: $PATH"
+fi
+
+
+# Execute the pre-hook.
+export SHELL=@shell@
+if [ -z "$shell" ]; then export shell=@shell@; fi
+runHook preHook
+
+
+# Check that the pre-hook initialised SHELL.
+if [ -z "$SHELL" ]; then echo "SHELL not set"; exit 1; fi
+
+
+# Hack: run gcc's setup hook.
+envHooks=()
+crossEnvHooks=()
+if [ -f $NIX_GCC/nix-support/setup-hook ]; then
+    source $NIX_GCC/nix-support/setup-hook
+fi
+
+
+# Ensure that the given directories exists.
+ensureDir() {
+    local dir
+    for dir in "$@"; do
+        if ! [ -x "$dir" ]; then mkdir -p "$dir"; fi
+    done
+}
+
+installBin() {
+    mkdir -p $out/bin
+    cp "$@" $out/bin
+}
+
+
+# Allow the caller to augment buildInputs (it's not always possible to
+# do this before the call to setup.sh, since the PATH is empty at that
+# point; here we have a basic Unix environment).
+runHook addInputsHook
+
+
+# Recursively find all build inputs.
+findInputs() {
+    local pkg=$1
+    local var=$2
+    local propagatedBuildInputsFile=$3
+
+    case ${!var} in
+        *\ $pkg\ *)
+            return 0
+            ;;
+    esac
+
+    eval $var="'${!var} $pkg '"
+
+    if [ -f $pkg/nix-support/setup-hook ]; then
+        source $pkg/nix-support/setup-hook
+    fi
+
+    if [ -f $pkg/nix-support/$propagatedBuildInputsFile ]; then
+        for i in $(cat $pkg/nix-support/$propagatedBuildInputsFile); do
+            findInputs $i $var $propagatedBuildInputsFile
+        done
+    fi
+}
+
+crossPkgs=""
+for i in $buildInputs $propagatedBuildInputs; do
+    findInputs $i crossPkgs propagated-build-inputs
+done
+
+nativePkgs=""
+for i in $nativeBuildInputs $propagatedNativeBuildInputs; do
+    findInputs $i nativePkgs propagated-native-build-inputs
+done
+
+
+# Set the relevant environment variables to point to the build inputs
+# found above.
+addToNativeEnv() {
+    local pkg=$1
+
+    if [ -d $1/bin ]; then
+        addToSearchPath _PATH $1/bin
+    fi
+
+    # Run the package-specific hooks set by the setup-hook scripts.
+    for i in "${envHooks[@]}"; do
+        $i $pkg
+    done
+}
+
+for i in $nativePkgs; do
+    addToNativeEnv $i
+done
+
+addToCrossEnv() {
+    local pkg=$1
+
+    # Some programs put important build scripts (freetype-config and similar)
+    # into their crossDrv bin path. Intentionally these should go after
+    # the nativePkgs in PATH.
+    if [ -d $1/bin ]; then
+        addToSearchPath _PATH $1/bin
+    fi
+
+    # Run the package-specific hooks set by the setup-hook scripts.
+    for i in "${crossEnvHooks[@]}"; do
+        $i $pkg
+    done
+}
+
+for i in $crossPkgs; do
+    addToCrossEnv $i
+done
+
+
+# Add the output as an rpath.
+if [ "$NIX_NO_SELF_RPATH" != 1 ]; then
+    export NIX_LDFLAGS="-rpath $out/lib $NIX_LDFLAGS"
+    if [ -n "$NIX_LIB64_IN_SELF_RPATH" ]; then
+        export NIX_LDFLAGS="-rpath $out/lib64 $NIX_LDFLAGS"
+    fi
+    if [ -n "$NIX_LIB32_IN_SELF_RPATH" ]; then
+        export NIX_LDFLAGS="-rpath $out/lib32 $NIX_LDFLAGS"
+    fi
+fi
+
+
+# Set the TZ (timezone) environment variable, otherwise commands like
+# `date' will complain (e.g., `Tue Mar 9 10:01:47 Local time zone must
+# be set--see zic manual page 2004').
+export TZ=UTC
+
+
+# Set the prefix.  This is generally $out, but it can be overriden,
+# for instance if we just want to perform a test build/install to a
+# temporary location and write a build report to $out.
+if [ -z "$prefix" ]; then
+    prefix="$out";
+fi
+
+if [ "$useTempPrefix" = 1 ]; then
+    prefix="$NIX_BUILD_TOP/tmp_prefix";
+fi
+
+
+PATH=$_PATH${_PATH:+:}$PATH
+if [ "$NIX_DEBUG" = 1 ]; then
+    echo "final path: $PATH"
+fi
+
+
+# Make GNU Make produce nested output.
+export NIX_INDENT_MAKE=1
+
+
+# Normalize the NIX_BUILD_CORES variable. The value might be 0, which
+# means that we're supposed to try and auto-detect the number of
+# available CPU cores at run-time.
+
+if [ -z "${NIX_BUILD_CORES:-}" ]; then
+  NIX_BUILD_CORES="1"
+elif [ "$NIX_BUILD_CORES" -le 0 ]; then
+  NIX_BUILD_CORES=$(nproc 2>/dev/null || true)
+  if expr >/dev/null 2>&1 "$NIX_BUILD_CORES" : "^[0-9][0-9]*$"; then
+    :
+  else
+    NIX_BUILD_CORES="1"
+  fi
+fi
+export NIX_BUILD_CORES
+
+
+######################################################################
+# Misc. helper functions.
+
+
+stripDirs() {
+    local dirs="$1"
+    local stripFlags="$2"
+    local dirsNew=
+
+    for d in ${dirs}; do
+        if [ -d "$prefix/$d" ]; then
+            dirsNew="${dirsNew} $prefix/$d "
+        fi
+    done
+    dirs=${dirsNew}
+
+    if [ -n "${dirs}" ]; then
+        header "stripping (with flags $stripFlags) in $dirs"
+        find $dirs -type f -print0 | xargs -0 ${xargsFlags:--r} strip $stripFlags || true
+        stopNest
+    fi
+}
+
+
+######################################################################
+# Textual substitution functions.
+
+
+substitute() {
+    local input="$1"
+    local output="$2"
+
+    local -a params=("$@")
+
+    local n p pattern replacement varName
+
+    local content="$(cat $input)"
+
+    for ((n = 2; n < ${#params[*]}; n += 1)); do
+        p=${params[$n]}
+
+        if [ "$p" = --replace ]; then
+            pattern="${params[$((n + 1))]}"
+            replacement="${params[$((n + 2))]}"
+            n=$((n + 2))
+        fi
+
+        if [ "$p" = --subst-var ]; then
+            varName="${params[$((n + 1))]}"
+            pattern="@$varName@"
+            replacement="${!varName}"
+            n=$((n + 1))
+        fi
+
+        if [ "$p" = --subst-var-by ]; then
+            pattern="@${params[$((n + 1))]}@"
+            replacement="${params[$((n + 2))]}"
+            n=$((n + 2))
+        fi
+
+        content="${content//"$pattern"/$replacement}"
+    done
+
+    # !!! This doesn't work properly if $content is "-n".
+    echo -n "$content" > "$output".tmp
+    if [ -x "$output" ]; then chmod +x "$output".tmp; fi
+    mv -f "$output".tmp "$output"
+}
+
+
+substituteInPlace() {
+    local fileName="$1"
+    shift
+    substitute "$fileName" "$fileName" "$@"
+}
+
+
+substituteAll() {
+    local input="$1"
+    local output="$2"
+
+    # Select all environment variables that start with a lowercase character.
+    for envVar in $(env | sed "s/^[^a-z].*//" | sed "s/^\([^=]*\)=.*/\1/"); do
+        if [ "$NIX_DEBUG" = "1" ]; then
+            echo "$envVar -> ${!envVar}"
+        fi
+        args="$args --subst-var $envVar"
+    done
+
+    substitute "$input" "$output" $args
+}
+
+
+substituteAllInPlace() {
+    local fileName="$1"
+    shift
+    substituteAll "$fileName" "$fileName" "$@"
+}
+
+
+######################################################################
+# What follows is the generic builder.
+
+
+nestingLevel=0
+
+startNest() {
+    nestingLevel=$(($nestingLevel + 1))
+    echo -en "\033[$1p"
+}
+
+stopNest() {
+    nestingLevel=$(($nestingLevel - 1))
+    echo -en "\033[q"
+}
+
+header() {
+    startNest "$2"
+    echo "$1"
+}
+
+# Make sure that even when we exit abnormally, the original nesting
+# level is properly restored.
+closeNest() {
+    while [ $nestingLevel -gt 0 ]; do
+        stopNest
+    done
+}
+
+
+# This function is useful for debugging broken Nix builds.  It dumps
+# all environment variables to a file `env-vars' in the build
+# directory.  If the build fails and the `-K' option is used, you can
+# then go to the build directory and source in `env-vars' to reproduce
+# the environment used for building.
+dumpVars() {
+    if [ "$noDumpEnvVars" != 1 ]; then
+        export > "$NIX_BUILD_TOP/env-vars"
+    fi
+}
+
+
+# Utility function: return the base name of the given path, with the
+# prefix `HASH-' removed, if present.
+stripHash() {
+    strippedName=$(basename $1);
+    if echo "$strippedName" | grep -q '^[a-z0-9]\{32\}-'; then
+        strippedName=$(echo "$strippedName" | cut -c34-)
+    fi
+}
+
+
+unpackFile() {
+    curSrc="$1"
+    local cmd
+
+    header "unpacking source archive $curSrc" 3
+
+    case "$curSrc" in
+        *.tar.xz | *.tar.lzma)
+            # Don't rely on tar knowing about .xz.
+            xz -d < $curSrc | tar xf -
+            ;;
+        *.tar | *.tar.* | *.tgz | *.tbz2)
+            # GNU tar can automatically select the decompression method
+            # (info "(tar) gzip").
+            tar xf $curSrc
+            ;;
+        *.zip)
+            unzip -qq $curSrc
+            ;;
+        *)
+            if [ -d "$curSrc" ]; then
+                stripHash $curSrc
+                cp -prd --no-preserve=timestamps $curSrc $strippedName
+            else
+                if [ -z "$unpackCmd" ]; then
+                    echo "source archive $curSrc has unknown type"
+                    exit 1
+                fi
+                runHook unpackCmd
+            fi
+            ;;
+    esac
+
+    stopNest
+}
+
+
+unpackPhase() {
+    runHook preUnpack
+
+    if [ -z "$srcs" ]; then
+        if [ -z "$src" ]; then
+            echo 'variable $src or $srcs should point to the source'
+            exit 1
+        fi
+        srcs="$src"
+    fi
+
+    # To determine the source directory created by unpacking the
+    # source archives, we record the contents of the current
+    # directory, then look below which directory got added.  Yeah,
+    # it's rather hacky.
+    local dirsBefore=""
+    for i in *; do
+        if [ -d "$i" ]; then
+            dirsBefore="$dirsBefore $i "
+        fi
+    done
+
+    # Unpack all source archives.
+    for i in $srcs; do
+        unpackFile $i
+    done
+
+    # Find the source directory.
+    if [ -n "$setSourceRoot" ]; then
+        runHook setSourceRoot
+    elif [ -z "$sourceRoot" ]; then
+        sourceRoot=
+        for i in *; do
+            if [ -d "$i" ]; then
+                case $dirsBefore in
+                    *\ $i\ *)
+                        ;;
+                    *)
+                        if [ -n "$sourceRoot" ]; then
+                            echo "unpacker produced multiple directories"
+                            exit 1
+                        fi
+                        sourceRoot="$i"
+                        ;;
+                esac
+            fi
+        done
+    fi
+
+    if [ -z "$sourceRoot" ]; then
+        echo "unpacker appears to have produced no directories"
+        exit 1
+    fi
+
+    echo "source root is $sourceRoot"
+
+    # By default, add write permission to the sources.  This is often
+    # necessary when sources have been copied from other store
+    # locations.
+    if [ "$dontMakeSourcesWritable" != 1 ]; then
+        chmod -R u+w "$sourceRoot"
+    fi
+
+    runHook postUnpack
+}
+
+
+patchPhase() {
+    runHook prePatch
+
+    for i in $patches; do
+        header "applying patch $i" 3
+        local uncompress=cat
+        case $i in
+            *.gz)
+                uncompress="gzip -d"
+                ;;
+            *.bz2)
+                uncompress="bzip2 -d"
+                ;;
+            *.lzma)
+                uncompress="lzma -d"
+                ;;
+        esac
+        $uncompress < $i | patch ${patchFlags:--p1}
+        stopNest
+    done
+
+    runHook postPatch
+}
+
+
+fixLibtool() {
+    sed -i -e 's^eval sys_lib_.*search_path=.*^^' "$1"
+}
+
+
+configurePhase() {
+    runHook preConfigure
+
+    if [ -z "$configureScript" ]; then
+        configureScript=./configure
+        if ! [ -x $configureScript ]; then
+            echo "no configure script, doing nothing"
+            return
+        fi
+    fi
+
+    if [ -z "$dontFixLibtool" ]; then
+        for i in $(find . -name "ltmain.sh"); do
+            echo "fixing libtool script $i"
+            fixLibtool $i
+        done
+    fi
+
+    if [ -z "$dontAddPrefix" ]; then
+        configureFlags="${prefixKey:---prefix=}$prefix $configureFlags"
+    fi
+
+    # Add --disable-dependency-tracking to speed up some builds.
+    if [ -z "$dontAddDisableDepTrack" ]; then
+        if grep -q dependency-tracking $configureScript; then
+            configureFlags="--disable-dependency-tracking $configureFlags"
+        fi
+    fi
+
+    # By default, disable static builds.
+    if [ -z "$dontDisableStatic" ]; then
+        if grep -q enable-static $configureScript; then
+            configureFlags="--disable-static $configureFlags"
+        fi
+    fi
+
+    echo "configure flags: $configureFlags ${configureFlagsArray[@]}"
+    $configureScript $configureFlags "${configureFlagsArray[@]}"
+
+    runHook postConfigure
+}
+
+
+buildPhase() {
+    runHook preBuild
+
+    if [ -z "$makeFlags" ] && ! [ -n "$makefile" -o -e "Makefile" -o -e "makefile" -o -e "GNUmakefile" ]; then
+        echo "no Makefile, doing nothing"
+        return
+    fi
+
+    echo "make flags: $makeFlags ${makeFlagsArray[@]} $buildFlags ${buildFlagsArray[@]}"
+    make ${makefile:+-f $makefile} \
+        ${enableParallelBuilding:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}} \
+        $makeFlags "${makeFlagsArray[@]}" \
+        $buildFlags "${buildFlagsArray[@]}"
+
+    runHook postBuild
+}
+
+
+checkPhase() {
+    runHook preCheck
+
+    echo "check flags: $makeFlags ${makeFlagsArray[@]} $checkFlags ${checkFlagsArray[@]}"
+    make ${makefile:+-f $makefile} \
+        ${enableParallelBuilding:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}} \
+        $makeFlags "${makeFlagsArray[@]}" \
+        ${checkFlags:-VERBOSE=y} "${checkFlagsArray[@]}" ${checkTarget:-check}
+
+    runHook postCheck
+}
+
+
+patchELF() {
+    # Patch all ELF executables and shared libraries.
+    header "patching ELF executables and libraries"
+    if [ -e "$prefix" ]; then
+        find "$prefix" \( \
+            \( -type f -a -name "*.so*" \) -o \
+            \( -type f -a -perm +0100 \) \
+            \) -print -exec patchelf --shrink-rpath {} \;
+    fi
+    stopNest
+}
+
+
+patchShebangs() {
+    # Rewrite all script interpreter file names (`#! /path') under the
+    # specified  directory tree to paths found in $PATH.  E.g.,
+    # /bin/sh will be rewritten to /nix/store/<hash>-some-bash/bin/sh.
+    # Interpreters that are already in the store are left untouched.
+    header "patching script interpreter paths"
+    local dir="$1"
+    local f
+    for f in $(find "$dir" -type f -perm +0100); do
+        local oldPath=$(sed -ne '1 s,^#![ ]*\([^ ]*\).*$,\1,p' "$f")
+        if [ -n "$oldPath" -a "${oldPath:0:${#NIX_STORE}}" != "$NIX_STORE" ]; then
+            local newPath=$(type -P $(basename $oldPath) || true)
+            if [ -n "$newPath" -a "$newPath" != "$oldPath" ]; then
+                echo "$f: interpreter changed from $oldPath to $newPath"
+                sed -i -e "1 s,$oldPath,$newPath," "$f"
+            fi
+        fi
+    done
+    stopNest
+}
+
+
+installPhase() {
+    runHook preInstall
+
+    mkdir -p "$prefix"
+
+    installTargets=${installTargets:-install}
+    echo "install flags: $installTargets $makeFlags ${makeFlagsArray[@]} $installFlags ${installFlagsArray[@]}"
+    make ${makefile:+-f $makefile} $installTargets \
+        $makeFlags "${makeFlagsArray[@]}" \
+        $installFlags "${installFlagsArray[@]}"
+
+    runHook postInstall
+}
+
+
+# The fixup phase performs generic, package-independent, Nix-related
+# stuff, like running patchelf and setting the
+# propagated-build-inputs.  It should rarely be overriden.
+fixupPhase() {
+    runHook preFixup
+
+    # Put man/doc/info under $out/share.
+    forceShare=${forceShare:=man doc info}
+    if [ -n "$forceShare" ]; then
+        for d in $forceShare; do
+            if [ -d "$prefix/$d" ]; then
+                if [ -d "$prefix/share/$d" ]; then
+                    echo "both $d/ and share/$d/ exists!"
+                else
+                    echo "fixing location of $d/ subdirectory"
+                    mkdir -p $prefix/share
+                    if [ -w $prefix/share ]; then
+                        mv -v $prefix/$d $prefix/share
+                        ln -sv share/$d $prefix
+                    fi
+                fi
+            fi
+        done;
+    fi
+
+    if [ -z "$dontGzipMan" ]; then
+        GLOBIGNORE=.:..:*.gz:*.bz2
+        for f in $out/share/man/*/* $out/share/man/*/*/*; do
+            if [ -f $f ]; then
+                if gzip -c -n $f > $f.gz; then
+                    rm $f
+                else
+                    rm $f.gz
+                fi
+            fi
+        done
+        unset GLOBIGNORE
+    fi
+
+    # TODO: strip _only_ ELF executables, and return || fail here...
+    if [ -z "$dontStrip" ]; then
+        stripDebugList=${stripDebugList:-lib lib32 lib64 libexec bin sbin}
+        if [ -n "$stripDebugList" ]; then
+            stripDirs "$stripDebugList" "${stripDebugFlags:--S --enable-deterministic-archives}"
+        fi
+
+        stripAllList=${stripAllList:-}
+        if [ -n "$stripAllList" ]; then
+            stripDirs "$stripAllList" "${stripAllFlags:--s --enable-deterministic-archives}"
+        fi
+    fi
+
+    if [ "$havePatchELF" = 1 -a -z "$dontPatchELF" ]; then
+        patchELF "$prefix"
+    fi
+
+    if [ -z "$dontPatchShebangs" ]; then
+        patchShebangs "$prefix"
+    fi
+
+    if [ -n "$propagatedBuildInputs" ]; then
+        mkdir -p "$out/nix-support"
+        echo "$propagatedBuildInputs" > "$out/nix-support/propagated-build-inputs"
+    fi
+
+    if [ -n "$propagatedNativeBuildInputs" ]; then
+        mkdir -p "$out/nix-support"
+        echo "$propagatedNativeBuildInputs" > "$out/nix-support/propagated-native-build-inputs"
+    fi
+
+    if [ -n "$propagatedUserEnvPkgs" ]; then
+        mkdir -p "$out/nix-support"
+        echo "$propagatedUserEnvPkgs" > "$out/nix-support/propagated-user-env-packages"
+    fi
+
+    if [ -n "$setupHook" ]; then
+        mkdir -p "$out/nix-support"
+        substituteAll "$setupHook" "$out/nix-support/setup-hook"
+    fi
+
+    runHook postFixup
+}
+
+
+installCheckPhase() {
+    runHook preInstallCheck
+
+    echo "installcheck flags: $makeFlags ${makeFlagsArray[@]} $installCheckFlags ${installCheckFlagsArray[@]}"
+    make ${makefile:+-f $makefile} \
+        ${enableParallelBuilding:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}} \
+        $makeFlags "${makeFlagsArray[@]}" \
+        $installCheckFlags "${installCheckFlagsArray[@]}" ${installCheckTarget:-installcheck}
+
+    runHook postInstallCheck
+}
+
+
+distPhase() {
+    runHook preDist
+
+    echo "dist flags: $distFlags ${distFlagsArray[@]}"
+    make ${makefile:+-f $makefile} $distFlags "${distFlagsArray[@]}" ${distTarget:-dist}
+
+    if [ "$dontCopyDist" != 1 ]; then
+        mkdir -p "$out/tarballs"
+
+        # Note: don't quote $tarballs, since we explicitly permit
+        # wildcards in there.
+        cp -pvd ${tarballs:-*.tar.gz} $out/tarballs
+    fi
+
+    runHook postDist
+}
+
+
+showPhaseHeader() {
+    local phase="$1"
+    case $phase in
+        unpackPhase) header "unpacking sources";;
+        patchPhase) header "patching sources";;
+        configurePhase) header "configuring";;
+        buildPhase) header "building";;
+        checkPhase) header "running tests";;
+        installPhase) header "installing";;
+        fixupPhase) header "post-installation fixup";;
+        installCheckPhase) header "running install tests";;
+        *) header "$phase";;
+    esac
+}
+
+
+genericBuild() {
+    header "building $out"
+
+    if [ -n "$buildCommand" ]; then
+        eval "$buildCommand"
+        return
+    fi
+
+    if [ -z "$phases" ]; then
+        phases="$prePhases unpackPhase patchPhase $preConfigurePhases \
+            configurePhase $preBuildPhases buildPhase checkPhase \
+            $preInstallPhases installPhase fixupPhase installCheckPhase \
+            $preDistPhases distPhase $postPhases";
+    fi
+
+    for curPhase in $phases; do
+        if [ "$curPhase" = buildPhase -a -n "$dontBuild" ]; then continue; fi
+        if [ "$curPhase" = checkPhase -a -z "$doCheck" ]; then continue; fi
+        if [ "$curPhase" = installPhase -a -n "$dontInstall" ]; then continue; fi
+        if [ "$curPhase" = fixupPhase -a -n "$dontFixup" ]; then continue; fi
+        if [ "$curPhase" = installCheckPhase -a -z "$doInstallCheck" ]; then continue; fi
+        if [ "$curPhase" = distPhase -a -z "$doDist" ]; then continue; fi
+
+        if [ -n "$tracePhases" ]; then
+            echo
+            echo "@ phase-started $out $curPhase"
+        fi
+
+        showPhaseHeader "$curPhase"
+        dumpVars
+
+        # Evaluate the variable named $curPhase if it exists, otherwise the
+        # function named $curPhase.
+        eval "${!curPhase:-$curPhase}"
+
+        if [ "$curPhase" = unpackPhase ]; then
+            cd "${sourceRoot:-.}"
+        fi
+
+        if [ -n "$tracePhases" ]; then
+            echo
+            echo "@ phase-succeeded $out $curPhase"
+        fi
+
+        stopNest
+    done
+
+    stopNest
+}
+
+
+# Execute the post-hook.
+runHook postHook
+
+
+# Execute the global user hook (defined through the Nixpkgs
+# configuration option ‘stdenv.userHook’).  This can be used to set
+# global compiler optimisation flags, for instance.
+runHook userHook
+
+
+dumpVars