installmpc

#!/bin/sh
############################# MPC License ##############################
# Wed Nov 19 15:19:19 CET 2008                                         #
# Copyright or (C) or Copr. Commissariat a l'Energie Atomique          #
#                                                                      #
# IDDN.FR.001.230040.000.S.P.2007.000.10000                            #
# This file is part of the MPC Runtime.                                #
#                                                                      #
# This software is governed by the CeCILL-C license under French law   #
# and abiding by the rules of distribution of free software.  You can  #
# use, modify and/ or redistribute the software under the terms of     #
# the CeCILL-C license as circulated by CEA, CNRS and INRIA at the     #
# following URL http://www.cecill.info.                                #
#                                                                      #
# The fact that you are presently reading this means that you have     #
# had knowledge of the CeCILL-C license and that you accept its        #
# terms.                                                               #
#                                                                      #
# Authors:                                                             #
#   - CARRIBAULT Patrick patrick.carribault@cea.fr                     #
#   - PERACHE Marc marc.perache@cea.fr                                 #
#   - JAEGER Julien julien.jaeger@cea.fr                               #
#                                                                      #
########################################################################

# Path to the configure script
SCRIPT=$(readlink -f "$0")
# Directory containing configure
SCRIPTPATH=$(dirname "$SCRIPT")
# Where MPC is currently being BUILT
PROJECT_BUILD_DIR=$(readlink -f "$PWD")

USE_COLOR="no"

####################
# BUILD PARAMETERS #
####################

LSP="no"
MAKE_J=""
# NOTE: these are only meaningful when not using spack
ALL_PACKAGE_ARGS=""
MPC_COMP_ADD_BUILD_PARAMETERS=""
OPENPA_BUILD_PARAMETERS=""
MPCALLOC_BUILD_PARAMETERS=""
OFI_BUILD_PARAMETERS=""
HWLOC_BUILD_PARAMETERS="--disable-werror --enable-static"
HYDRA_BUILD_PARAMETERS=""
MPC_DMTCP_BUILD_PARAMETERS="--enable-pthread-mutex-wrappers"
MPC_GDB_BUILD_PARAMETERS="--without-zlib --disable-werror"

# Stop on error
set -e

#
# Utilities
#

#
# Output MGT
#

# Print an error message and exit
# Args:
# -$1 : Message to print
die(){
	echo "================ ERROR ================"
	echo "$1"
	echo "======================================="
	exit 1
}

#
# Check call return code
# Args:
# - $1: retcode to check
# - $2: error if NOK (no error if not given)
check_retcode()
{
	if test "x$1" = "x0"; then
		ok
	else
		nok
		if test -n "$2"; then
			die "$2"
		fi
	fi
}

#
# Ensures the prefix has not been emptied
# and remove marker file if so
# Args:
# - $1: prefix to check
#
check_prefix_is_clean()
{
	if test -d "$PREFIX/lib/" -a -d "$PREFIX/bin/"; then
		return
	else
		# Apparently prefix was cleared somehow
		# Make sure deps are reinstalled
		rm -fr "$PREFIX"/.mpc-installed-*
		info "Prefix seems to be incomplete, forcing reinstall."
	fi
}

#
# Output helpers
#
set_color_model()
{
	if test "x$USE_COLOR" = "xyes"; then
		colRESET="\e[0m"
		colGRAY="\e[90m"
		colRED="\e[31m"
		colGREEN="\e[32m"
		colMAGENTA="\e[35m"
		colYELLOW="\e[33m"
		colbgGRAY="\e[100m"
		colbgMAGENTA="\e[45m"
		colBLINK="\e[5m"
		UNDERLINE="\e[4m"
	fi
}


PENDING_LB=""
STEP_WRAPPER_VERBOSE=0

show_run_cmd()
{
	if test $STEP_WRAPPER_VERBOSE -gt 0; then
		test -n "${PENDING_LB}" && echo ""
		PENDING_LB=""
		echo "$ $*"
	fi
}

info()
{
	printf "${colbgGRAY}==>${colRESET}${colGRAY} $1${colRESET}\n"
}

LAST_RESULT=""

checking()
{
	LAST_RESULT=""
	PENDING_LB="yes"
	printf "${colbgMAGENTA}==>${colRESET}${colMAGENTA} $1... ${colRESET}"
}

ok()
{
	PENDING_LB=""
	LAST_RESULT="ok"
	if test $STEP_WRAPPER_VERBOSE -eq 0; then
		printf "${colGREEN}SUCCESS${colRESET}\n"
	fi
}

nok()
{
	PENDING_LB=""
	LAST_RESULT="nok"
	printf "${UNDERLINE}${colBLINK}${colRED}FAIL${colRESET}\n"
}

skip()
{
	PENDING_LB=""
	LAST_RESULT="skip"
	printf "${UNDERLINE}${colBLINK}${colYELLOW}SKIPPED${colRESET}\n"
}

notapplicable()
{
	PENDING_LB=""
	LAST_RESULT="na"
	printf "${colbgGRAY}NA${colRESET}\n"
}

#
# Check for common commands
#

LIST_OF_FOUND_CMD=""
COMMON_CMD="bear cmake spack patch cut ls pwd grep rm rev basename dirname make bzip2 gcc g++ ldd pkg-config mktemp getconf nproc lscpu wget curl"
check_for_commands()
{
	# Check already done
	test -n "$LIST_OF_FOUND_CMD" && return

	set +e

	for c in $COMMON_CMD; do

		command -v "$c" > /dev/null 2>&1

		if test "x$?" = "x0"; then
			LIST_OF_FOUND_CMD="$LIST_OF_FOUND_CMD $c"
		else
			checking "locate '$c' command in PATH"
			nok
		fi
	done

	set -e
}

have_cmd()
{
	set +e

	echo "$LIST_OF_FOUND_CMD" | grep "$1" > /dev/null 2>&1

	if test "x$?" = "x0"; then
		HAVE_CMD="yes"
	else
		HAVE_CMD="no"
	fi

	set -e
}

assert_cmd()
{
	check_for_commands

	have_cmd "$1"

	if test "x${HAVE_CMD}" = "xno"; then
		checking "$1 is in path"
		nok
		die "$1 could not be found in path"
	fi

}

guess_cpu_count()
{
	checking "Looking for number of CPUs"

	if test -f "/proc/cpuinfo"; then
		show_run_cmd "grep -c processor < /proc/cpuinfo"
		TMP=$(grep -c "processor" < "/proc/cpuinfo" 2>/dev/null)

		if test "x${TMP}" != "x0"; then
			ok
			NCPU="$TMP"
			return
		fi
	fi

	have_cmd "nproc"

	if test "x${HAVE_CMD}" = "xyes"; then
		show_run_cmd "nproc"
		TMP=$(nproc 2> /dev/null || true)

		if test "x${?}" = "x0"; then
			ok
			NCPU="$TMP"
			return
		fi
	fi

	# Could not guess stay serial
	nok
	NCPU="1"
	info "Failed at guessing number of cores use -jX for parallel build"
}

#Extract parameter value and put in given variable
#Args :
# -$1 : Output variable name
# -$2 : parameter name (without --, eg. --with-XXX => 'with-XXX')
# -$3 : User value (--with-XXX=blablable)
extractParamValue()
{
	#extract in local vars
	outputvar="$1"
	name="$2"
	arg="$3"

	value=$(echo "$arg" | sed -e "s/^--${name}=//g")
	eval "${outputvar}=\"${value}\""
}

######################################################
#Extract parameter value and put in given variable
#Args :
# -$1 : Output variable name
# -$2 : parameter name (without -, eg. -XXX)
# -$3 : User value (-XXX=value)
extractParamValueAlt()
{
	#extract in local vars
	outputvar="$1"
	name="$2"
	arg="$3"

	value=$(echo "$arg" | sed -e "s/^-${name}//g")
	eval "${outputvar}=\"${value}\""
}

# Set a var to a value if not already set
#args :
# -$1 : output variable name
# -$2 : value triggering a set
# -$3 : value to set
enableParamIfNot()
{
	#extract in local vars
	outputvar="$1"
	output="$2"
	trigger="$3"
	value="$4"

	if [ "${output}" = "${trigger}" ]
	then
		eval "${outputvar}=\"${value}\""
	fi
}

#Extract parameter value and put in given variable
#Args :
# -$1 : Output variable name
# -$2 : parameter prefix (eg --libxml2-XXXX to add --XXX to libxml2 params)
# -$3 : User value (--libxml2-XXXX)
extractAndAddPackageOption()
{
	#extract in local vars
	outputvar="$1"
	name="$2"
	arg="$3"

	value=$(echo "$arg" | sed -e "s/^--${name}//g")
	eval "${outputvar}=\"\$${outputvar} ${value}\""
}



wrap_output()
{
	assert_cmd "mktemp"

	outfile=$(mktemp)

	set +e

	show_run_cmd "$@"

	if test $STEP_WRAPPER_VERBOSE -eq 3; then
		"$@"
	else
		"$@" > "$outfile" 2>&1
	fi

	if test "x$?" = "x0"; then
		rm "$outfile"
	else
		nok

		if test $STEP_WRAPPER_VERBOSE -gt 0; then
			cat "$outfile"
		fi

		die "See $outfile an error occurred when running $*"
	fi

	set -e
}


#
# Helper to export build environment
#


propagate_build_env()
{
	export PATH
	export PKG_CONFIG_PATH
	export CPATH
	export CMAKE_PREFIX_PATH
	export SPACK_LOADED_HASHES
	export ACLOCAL_PATH
	export MANPATH
	export LD_LIBRARY_PATH
}

# Build spack package name
# Args:
# -$1 : package
# -$2 : version
# -$3 : variant
#
SPECIFY_SPACK_ARCH="yes"
ENABLE_GENERIC_SPACK_BUILD="no"
FORCE_SPACK_ARCH=""
build_package_name()
{
	SPACK_ARCH=""

	if test -n "$FORCE_SPACK_ARCH"; then
		SPACK_ARCH=" arch=$FORCE_SPACK_ARCH"
	else
		GENERIC_FLAG=""

		if test "x${ENABLE_GENERIC_SPACK_BUILD}" = "xyes"; then
			GENERIC_FLAG=" -g "
		fi

		if test "x${SPECIFY_SPACK_ARCH}" = "xyes"; then

			set +e
			spack arch $GENERIC_FLAG > /dev/null 2>&1

			if test "x$?" = "x0"; then
				SPACK_ARCH=" arch=$(spack arch $GENERIC_FLAG)"
			fi

			set -e

		fi
	fi

	VARIANT=""

	if test -n "$3"; then
		VARIANT=" $3"
	fi


	if test -n "$2"; then
		echo "${1}@${2}${VARIANT}${SPACK_ARCH}"
	else
		echo "$1${VARIANT}${SPACK_ARCH}"
	fi
}

# The --force-spack-package=* option allows to force the use
# of a given spack package for installing a given dependency
# usually for testing or development purposes of when there are version conflicts
#
# Syntax is :
#     DEP:SPACK_DESC,DEP:SPACK_DESC...
# For example:
#     libxml2:/dzadzad,openpa:openpa@9.9.9
#
# Args:
#  -$1 package name
#  -$2 package version
#  -$3 variant
#
# Fils in concretized_package with either $1@$2 or overrid if exists
#
OVERRIDEN_SPACK_PKGS=""
#
check_if_spack_package_is_overriden()
{
	concretized_package="$(build_package_name "$1" "$2" "$3")"

	if test -z "$OVERRIDEN_SPACK_PKGS"; then
		return
	fi

	for override in $(echo "$OVERRIDEN_SPACK_PKGS" | sed "s/,/\n/g")
	do
		DEP=$(echo "$override" | cut -d ':' -f 1)
		SPACK_DESC=$(echo "$override" | cut -d ':' -f 2)

		if test "x${DEP}" = "x${SPACK_DESC}" -o -z "${SPACK_DESC}"; then
			nok
			die "No forced spack descriptor provided to dependency ${DEP}\n--force-spack-package=$OVERRIDEN_SPACK_PKGS"
		fi

		if test "x${DEP}" = "x${1}"; then
			checking "overriden with ${SPACK_DESC}"
			concretized_package="${SPACK_DESC}"

			if echo "$concretized_package" | grep "^/" > /dev/null; then
				#This is a hash so package must exist at load time
					set +e
					spack find "$TO_LOAD_NAME" > /dev/null 2>&1

					if test "x$?" != "x0"; then
						nok
						die "Failed loading forced spack dependency ${SPACK_DESC} for ${DEP}"
					fi

					set -e
			fi
		fi
	done
}


# Try to find a dep using spack
# Args:
# -$1 : package
# -$2 : version
# -$3 : variant (optional)
#
DEP_FOUND="no"
find_dep_with_spack()
{
	DEP_FOUND="no"

	have_cmd "spack"

	if test "x${HAVE_CMD}" = "xno"; then
		return
	fi

	PKG_NAME="$(build_package_name "$1" "$2" "$3")"

	checking "load $PKG_NAME using spack"

	show_run_cmd "spack info  $1"
	spack info "$1" > /dev/null 2>&1 || notapplicable

	if test "x${LAST_RESULT}" = "xna"; then
		return
	fi

	# Now check if dependency has been forced
	check_if_spack_package_is_overriden "$1" "$2" "$3"
	TO_LOAD_NAME="$concretized_package"

	show_run_cmd "spack load --sh $TO_LOAD_NAME"

	set +e

	LOAD_CMD=$(spack load --sh $TO_LOAD_NAME 2> /dev/null)
	check_retcode "$?"

	set -e

	if test "x${LAST_RESULT}" = "xok"; then
		eval "$LOAD_CMD"
		DEP_FOUND="yes"
	fi

	propagate_build_env
}

# Try to install a package using spack
#
#
install_dep_with_spack()
{
	assert_cmd "spack"

	PKG_NAME="$(build_package_name "$1" "$2" "$3")"
	checking "install $PKG_NAME using spack"

	check_if_spack_package_is_overriden "$1" "$2" "$3"
	PKG_NAME="$concretized_package"

	show_run_cmd "spack info  $PKG_NAME"
	spack info  "$PKG_NAME" > /dev/null 2>&1 || notapplicable

	if test "x${LAST_RESULT}" = "xna"; then
		return
	fi

	show_run_cmd "spack install -j ${MAKE_J} $PKG_NAME"
	# We need to allow expansion here as PKG_NAME can contain multiple params
	wrap_output spack install -j "${MAKE_J}" $PKG_NAME
	check_retcode "$?"

	if test "x${LAST_RESULT}" = "xok"; then
		find_dep_with_spack "$1" "$2" "$3"
	fi
}


#
# Remove duplicates from an env type var (outputs on stdout)
# Args:
#   - $1: variable to clean
#
clean_env_path_var()
{
	var_data=$1

	new_data_list=$(echo "$var_data" | sed "s/\\:/\\n/g" | sort | uniq | xargs echo)

	ret=""
	for entry in $new_data_list
	do
		ret="${ret}:${entry}"
	done

	echo "$ret"
}

#
# Load a prefix by appending a given directory
# Args:
# - $1: prefix to insert
#
load_prefix()
{
	if test ! -d "$1"; then
		nok
		die "Could not locate prefix directory $1"
	fi

	test -d "$1/bin" && PATH=$(clean_env_path_var "$1/bin:$PATH")
	test -d "$1/lib" && LD_LIBRARY_PATH=$(clean_env_path_var "$1/lib:$LD_LIBRARY_PATH")
	test -d "$1/lib64" && LD_LIBRARY_PATH=$(clean_env_path_var "$1/lib64:$LD_LIBRARY_PATH")
	test -d "$1/include" && CPATH=$(clean_env_path_var "$1/include:$CPATH")
	test -d "$1/lib/pkgconfig/" && PKG_CONFIG_PATH=$(clean_env_path_var "$1/lib/pkgconfig/:$PKG_CONFIG_PATH")
	test -d "$1/lib64/pkgconfig/" && PKG_CONFIG_PATH=$(clean_env_path_var "$1/lib64/pkgconfig/:$PKG_CONFIG_PATH")
	test -d "$1/share/man/" && MANPATH=$(clean_env_path_var "$1/share/man/:$MANPATH")

	propagate_build_env
}

# Check if an entry is in a list
#
# Args:
# - 1: needle
# - 2: haystack
in_list()
{
	echo "$2" | grep "$1" > /dev/null
}

# Cat a file filtering lines starting with #
# Args:
#   - Path to file
#
_config_file_clean()
{
    grep -v '^#' < "$1" | sed -E "s/\s+/ /g"
}

# Get package list from source.txt
package_list()
{
    _config_file_clean "${SCRIPTPATH}/config/source.txt" | cut -d " " -f 1
}

# Assert package is known
# Args:
# - 1: package name
assert_package()
{
	if in_list "$1" "$(package_list)"; then
		true
	else
		die "No such package $1."
	fi
}

# Get package list from version.txt
vesion_list()
{
    _config_file_clean "${SCRIPTPATH}/config/version.txt" | cut -d " " -f 1
}

# Assert package version is known
# Args:
# - 1: package name
assert_version()
{
	if in_list "$1" "$(vesion_list)"; then
		true
	else
		die "No such package $1 in version.txt."
	fi
}

# Get package version
# Args:
# - 1: package name
# - 2: version
#
package_version()
{
	assert_version "$1"
	_config_file_clean "${SCRIPTPATH}/config/version.txt" | grep "$1" | cut -d " " -f 2
}

# Get package URL
# Args:
# - 1: package name
# - 2: version
#
package_download_address()
{
	VERSION=${2}
	VERSION_SHORT=$(echo "${VERSION}" | sed "s/.[0-9]*$//")
	_config_file_clean "${SCRIPTPATH}/config/source.txt" | grep "$1" | cut -d " " -f 2 \
	| sed "s/VERSION_SHORT/${VERSION_SHORT}/g" \
	| sed "s/VERSION/${VERSION}/g"
}

# Package Filename
# - 1: package name
# - 2: version
#
package_filename()
{
	package_download_address "$1" "$2" | rev | cut -d "/" -f 1 | rev
}

# Download a dependency
# Args:
# - 1 : package name
# - 2 : package version
# Returns in ENV:
# TARBALL_PATH where the tarball is
download_package()
{
	PKG=$1
	VERS=$2

	cd "$PROJECT_BUILD_DIR" || die "Could not go back to builddir"

	assert_package "$PKG"

	FNAME=$(package_filename "$PKG" "${VERS}")

	checking "Downloading $PKG-$VERS"

	have_cmd "wget"
	if test "x${HAVE_CMD}" = "xyes"; then
		wrap_output wget "$(package_download_address "$PKG" "${VERS}")"
	else
		have_cmd "curl"
		if test "x${HAVE_CMD}" = "xyes"; then
			wrap_output curl -L "$(package_download_address "$PKG" "${VERS}")" -o "./${FNAME}"
		else
			nok
			die "Curl or wget is required for dep download or use --download."
		fi
	fi
	ok

	#(TARBALL_PATH is the return value)
	TARBALL_PATH="${PWD}/${FNAME}"
}

# Build a compiler additions tarball from git repo url pass as env variable
build_compiler_additions_tarball()
{
	tmpdir=$(mktemp -d) || exit 42
	git clone "$COMPILER_ADDITIONS_GIT_REPO" -b "$COMPILER_ADDITIONS_GIT_BRANCH" "$tmpdir"

	PPWD="$PWD"
	cd "$tmpdir"
	./gen_archive.sh --gcc-version=$GCC_VERSION
	cd "$PPWD"

	mv "$tmpdir"/$(package_filename "mpc-compiler-additions" "${VERSION}") ./
	TARBALL_PATH=./$(package_filename "mpc-compiler-additions" "${VERSION}")

	rm -rf "$tmpdir"
}

# Locate tarball for a dependency (or download it)
# Args:
# - 1 : package name
# - 2 : package version
# Returns in ENV:
# TARBALL_PATH where the tarball is
locate_tarball()
{
	PKG=$1
	VERS=$2

	if [ "$PKG" = "mpc-compiler-additions" -a "x$COMPILER_ADDITIONS_GIT_REPO" != "x" -a "x$COMPILER_ADDITIONS_GIT_BRANCH" != "x" ]
	then
		build_compiler_additions_tarball
		return
	fi

	# Now attempt to locate archive
	tarball="$PKG-$VERS"

	TARBALL_PATH=$( (find "$HOME/.mpcdep/" -iname "${tarball}*tar*" 2> /dev/null | head -n 1) || true)

	if test -f "$TARBALL_PATH"; then
		# Found in .mpcdep in $HOME
		return
	fi

	TARBALL_PATH=$(find "$SCRIPTPATH/deps/$package/" -iname "${tarball}*tar*" 2> /dev/null || true)

	if test -f "$TARBALL_PATH"; then
		# Found in dependency patch dir
		return
	fi

	TARBALL_PATH=$(find "${PROJECT_BUILD_DIR}/"  -iname "${tarball}*tar*" 2> /dev/null || true)

	if test -f "$TARBALL_PATH"; then
		# Found in build dir
		return
	fi

	TARBALL_PATH=$(find "$SCRIPTPATH/deps/" -iname "${tarball}*tar*" 2> /dev/null || true)

	if test -f "$TARBALL_PATH"; then
		# Found in flat deps dir
		return
	fi

	TARBALL_PATH=$(find "${SCRIPTPATH}/" -iname "${tarball}*tar*" 2> /dev/null || true)

	if test -f "$TARBALL_PATH"; then
		# Found in root source dir
		return
	fi

	download_package "$PKG" "$VERS"
}

# Download all deps for MPC
download_all_missing_deps()
{
	DEP_LIST=""
	for p in $(package_list)
	do
		VERSION="$(package_version "$p")"
		FNAME=$(package_filename "$p" "${VERSION}")
		locate_tarball "$p" "$VERSION"

		# Copy from other place to here if not present
		if test ! -f "./${FNAME}"; then
			checking "Copying tarball from ${TARBALL_PATH}"
			wrap_output cp ${TARBALL_PATH} ./${FNAME}
			ok
		fi

		DEP_LIST="./${FNAME} ${DEP_LIST}"
	done
	echo "DEP_LIST=${DEP_LIST}"
}



#
# Find a package prefix from env
#    $1 Package name
#    $2 Package version
#    $3 Package manual prefix
#
#    Return PACK_PREFIX (set to "" if not resolved)
#
find_package_prefix()
{
	PACK_PREFIX=""

	if test -d "$3"; then
		PACK_PREFIX="$3"
		return
	fi

	have_cmd spack
	if [ "x${HAVE_CMD}" = "xno" ]
	then
		return
	fi

	# Do not forget to trim as spack has 2 spaces in its separator
	SPACKFIND=$(spack find -p ${1}@${2} | grep "${1}@${2}" | cut -d " " -f 2- | awk '{$1=$1};1' 2> /dev/null || true)

	if test "x$?" != "x0"; then
		return
	fi

	if test -d "$SPACKFIND"; then
		PACK_PREFIX="$SPACKFIND"
	fi
}


#
# Build a configure based package
#
# Args:
#  - $1: package name
#  - $2: package version
#  - $3: extra arguments for configure
#
BUILD_IS_DISABLED="no"

build_configure_based_package()
{
	package="$1"
	version="$2"
	extra_config_args=$3

	if test "x${BUILD_IS_DISABLED}" = "xyes"; then
		die "--disable-build was passed and a package was not provided through spack"
	fi


	#
	# INSTALL FLAG MANAGEMENT
	#

	assert_cmd "cut"
	assert_cmd "rev"
	assert_cmd "grep"

	# Check if another version of the dependency is not already installed
	installed_vers=$(ls "${PREFIX}/.mpc-installed-${package}-*" 2> /dev/null || true)

	if test -n "$installed_vers"; then
		# There is already a version
		installed_version=$(echo "$installed_vers" | rev | cut -d "-" -f 1 | rev)
		if test "x${installed_version}" != "x${version}"; then
			info "there is $package $installed_version in $PREFIX and MPC provides $version"
			die "MPC does not support installing mismatching $package versions in the same prefix"
		fi
	fi

	# The flag to determine if a dependency is already in prefix
	DEP_FLAG=${PREFIX}/.mpc-installed-$package-$version

	# If already deployed no need to redo
	if test -f "$DEP_FLAG"; then
		checking "Installing $package-$version"
		skip
		load_prefix "$PREFIX"
		return
	fi

	#
	# Tarball Extraction
	#

	# Where the tarball is extracted (depends on inner tarball dir name)
	ORIG_PKG_SOURCE_DIR=${PROJECT_BUILD_DIR}/${package}-${version}/
	# Where we move it in MPC to simplify deletion thanks to dep-* prefix
	PKG_SOURCE_DIR=${PROJECT_BUILD_DIR}/dep-${package}-${version}/

	if test ! -d "$PKG_SOURCE_DIR"; then
		pkg_dir="$SCRIPTPATH/config/deps/$package"

		locate_tarball "$package" "$version"

		checking "Extracting $package-$version"


		if test ! -f "$TARBALL_PATH"; then
			nok
			die "Could not locate a tarball for $package-$version in $pkg_dir"
		fi

		wrap_output tar xf "$TARBALL_PATH"

		if test ! -d "$ORIG_PKG_SOURCE_DIR"; then
			nok
			die "Could not locate sources in $PKG_SOURCE_DIR after extracting $TARBALL_PATH"
		else
			show_run_cmd "mv $ORIG_PKG_SOURCE_DIR $PKG_SOURCE_DIR"
			# Rename to $PKG_SOURCE_DIR
			mv "$ORIG_PKG_SOURCE_DIR" "$PKG_SOURCE_DIR"
			ok
		fi

		#
		# Patching (when needed)
		#

		PACKAGE_PATCH=$pkg_dir/${package}-${version}.patch

		if test -f "$PACKAGE_PATCH"; then
			checking "Patching $package $version"
			show_run_cmd "cd $PKG_SOURCE_DIR"
			cd "$PKG_SOURCE_DIR"

			show_run_cmd "patch -p 1 < $PACKAGE_PATCH"
			patch -p 1 < "$PACKAGE_PATCH" > /dev/null
			check_retcode "$?" "Failed to patch $package $version"

			info "PATCH: ${PACKAGE_PATCH}"


			show_run_cmd "cd $PROJECT_BUILD_DIR"
			cd "${PROJECT_BUILD_DIR}"
		fi
	else
        checking "Tarball for ${package}-${version} already extracted"
        skip
	fi

	#
	# Actual BUILD
	#


	if test ! -d "${PKG_SOURCE_DIR}/BUILD"; then
		show_run_cmd "mkdir ${PKG_SOURCE_DIR}/BUILD"
		mkdir "${PKG_SOURCE_DIR}/BUILD"
	fi

	show_run_cmd "cd ${PKG_SOURCE_DIR}/BUILD"
	cd "${PKG_SOURCE_DIR}/BUILD"

	if test -f "${PKG_SOURCE_DIR}/configure"; then
		# Regular configure / make / make install
		checking "Configuring $package-$version"
		# we want parameter expansion
		# shellcheck disable=SC2086
		wrap_output "${PKG_SOURCE_DIR}/configure" "--prefix=${PREFIX}" $extra_config_args $ALL_PACKAGE_ARGS
		ok

		checking "Building $package-$version"
		wrap_output make "-j${MAKE_J}"
		ok

		checking "Installing $package-$version"
		wrap_output make install
		ok
	else
		die "Could not locate ./configure in ${PKG_SOURCE_DIR}"
	fi

	show_run_cmd "cd ${PROJECT_BUILD_DIR}"
	cd "${PROJECT_BUILD_DIR}"

	#
	# Prefix loading
	#

	load_prefix "$PREFIX"


	#
	# Flag as installed
	#

	# if we are here flag all success
	show_run_cmd "touch ${DEP_FLAG}"
	touch "${DEP_FLAG}"
}

# Check if a prefix exists and then insert it in env if it does
# Args:
#    - $1 prefix
#
# Return: 0 if prefix found (for use in if)
#
check_and_then_load_prefix()
{
	candidate_prefix="$1"
	if test -d "$candidate_prefix"; then
		load_prefix "$candidate_prefix"
		return 0
	fi
	return 1
}

# Deploy an MPC dependency using various methods (spack or not)
# Args:
# - $1: package name
# - $2: package version
# - $3: can build
# - $4: candidate prefix can be:
#	* "PATH" to a prefix which is then used
#	* "nobuild" meaning that we only try with spack load
#       * "spackonly" meaning that we only wish to install through spack if present
#       * "" meaning that we also try to build from sources (using local deps)
# - $5 : the spack variant to pass around


SPACK_LOCATE_DEPENDENCY="yes"
SPACK_INSTALL_DEPENDENCY="no"

find_in_prefix_or_use_spack_internal()
{
	package="$1"
	version="$2"
	can_build="$3"
	candidate_prefix="$4"
	variant="$5"

	if test "x${candidate_prefix}" = "xdisabled"; then
		#Not an error (disable legacy build also)
		DEP_FOUND="yes"
		info "$package is disabled"
		return
	fi

	DEP_FOUND="no"

	if check_and_then_load_prefix "$candidate_prefix"; then
		# Assume dep found
		DEP_FOUND="yes"
	fi

	# use spack to locate in existing packages
	if test "x${SPACK_LOCATE_DEPENDENCY}" = "xyes"; then
		find_dep_with_spack "$package" "$version" "$variant"
	fi

	# If dep is found we are done
	test "x${DEP_FOUND}" = "xyes" && return


	# We stop here if we are not alowed to build
	test "x${can_build}" = "xnobuild" && return


	if test "x${SPACK_INSTALL_DEPENDENCY}" = "xyes"; then
		install_dep_with_spack "$package" "$version" "$variant"
	fi

	# Did we install with spack ?
	test "x${DEP_FOUND}" = "xyes" && return

	# Do a source level build only when required to
	if test "x${can_build}" = "xspackonly"; then
		info "$package is configured to be installed using spack"
	fi
}


# Deploy an MPC dependency using various methods (spack or not)
# Args:
# - $1: package name
# - $2: package version
# - $3: candidate_prefix
# - $4: variant (optional)

find_in_prefix_or_use_spack()
{
	find_in_prefix_or_use_spack_internal "$1" "$2" "yes" "$3" "$4"
}

# Deploy an MPC dependency using various methods (spack or not)
# Args:
# - $1: package name
# - $2: package version
# - $3: candidate_prefix
# - $4: variant (optional)
find_in_prefix_or_use_spack_optional()
{
	required="no"
	candidate_prefix="$3"

	find_in_prefix_or_use_spack_internal "$1" "$2" "$required" "$candidate_prefix" "$4"
}


# Print usage for configure
showHelp()
{
cat << EOF

MPC Meta-Build script

Usage: ./installmpc [OPTION]... [VAR=VALUE]...

Defaults for the options are specified in brackets.

Note that depending on your build settings this script might download dependencies.
You may track issued commands using the "-v" flag.

# Information
  --help|-h|-?                            : Display this help and exit
  --version                               : Report version number and exit

# Build & Installation
  --prefix=PREFIX                         : Install architecture-independent files in PREFIX [/usr/local]
  --disable-prefix-check                  : Force install of MPC over an existing install (not recommended)
  --download-missing-deps                 : Ask MPC to download dependencies for offline install
  --verbose=1|2|3                         : Level of verbosity
  -v|-vv|-vvv                             : Level of verbosity
  -jN                                     : Allow N jobs at once (parallel install)
  --enable-lsp                            : Use bear to generate a compile_commands.json file, used by Language Server Protocols
  --disable-lsp                           : Do not generate a compile_commands.json file (default)

# Features
  --with-slurm[=prefix]                   : Build MPC with PMI support (detect 1 and x)
  --with-pmi1[=prefix]                    : Build MPC with PMI1 support
  --with-pmix[=prefix]                    : Build MPC with PMIX support
  --process-mode                          : Build MPC in process-mode (1 MPI process = 1 UNIX process)
  --{enable,disable}-mpc-ft               : Activate/Deactivate checkpoint/restart support
  --{enable,disable}-color                : Disable colors in display
  --enable-debug                          : Enable maximum debug (symbols, messages)
  --enable-topology-simulation            : Enable fake network topology simulation

# Disable sub packages
  --disable-ofi                           : Disable libfabric support
  --disable-mpc-comp                      : Disable MPC compiler additions support
  --disable-mpcalloc                      : Disable MPC allocator
  --disable-fortran                       : Disable fortran
  --disable-hydra                         : Disable Hydra
  --disable-romio                         : Disable ROMIO MPI-IO support
  --enable-ck                             : Enable Concurrency-Kit (spack only)
  --{enable,disable}-gdb                  : Enable/Disable gdb
  --{enable,disable}-tbb                  : Enable/Disable TBB

# Specify system subpackages
  --with-mpc-comp=*                       : Specify mpc compiler additions prefix on the system
  --with-openpa=*                         : Specify openpa prefix on the system
  --with-hwloc=*                          : Specify hwloc prefix on the system
  --with-cuda=*                           : Specify Cuda prefix on the system
  --with-openacc=*                        : Specify OpenACC prefix on the system (NIMPL)
  --with-opencl=*                         : Specify OpenCL prefix on the system (NIMPL)
  --with-hydra=*                          : Specify Hydra prefix on the system
  --with-tbb=*                            : Specify TBB prefix on the system
  --with-{dmtcp,hbict}=*                  : Specify DMTCP/HBICT prefix on the system

# MPC Compiler Additions specifics (requires mpc-compiler-additions)

  --gcc-version=X.X.X                     : Compile mpc-compiler-additions with a given GCC version (default otherwise)

# Spack Related Options
  --enable-spack                          : Allow MPC to use spack for locating depencies (default)
  --disable-spack                         : Force MPC not to use spack to locate dependencies
  --enable-spack-build                    : Allow MPC to build dependencies with spack
  --disable-spack-build                   : Disallow MPC to build dependencies using spack (default)
  --disable-build                         : Prevent MPC from compiling embedded version of its dependencies
  --force-spack-package=*                 : Force a given version of dependencies loaded/installed with spack
                                            syntax is comma a separated list of DEP:SPACK descriptors for example
                                            openpa:/ffefdkk,mpc-compiler-additions:mpc-compiler-additions@2.0.0, ...
  --enable-spack-arch                     : add architecture specifiers to spack descriptors (default)
  --disable-spack-arch                    : do not pass architecture specifiers to spack descriptors
  --disable-generic-spack-build           : do not build generic spack packages (portable on target) (default)
  --enable-generic-spack-build            : build portable for target
  --force-spack-arch=*                    : overrides architecture flag (passes it to packages for example x86_64_v2)

# Options to transmit to subpackages (only if not using SPACK)
  --mpc-comp=*                            : Add options to mpc-compiler-additions' configure
  --gdb=*                                 : Add options to gdb configure
  --openpa=*                              : Add options to openpa configure
  --hydra=*                               : Add options to Hydra configure
  --hwloc=*                               : Add options to hwloc configure
  --mpcalloc=*                            : Add options to MPCALLOC configure
  --ofi=*                                 : Add options to OFI configure
  --dmtpc=*                               : Add options to DMTCP/HBICT configure
  --mpcframework=*                        : Add options to mpc framework configure
EOF
}

####################################################
#                                                  #
# MPC WRAPPER FOR BUILD                            #
#                                                  #
####################################################
#
# Disable all optional dependencies by default
#

# Possible values are:
#	* "PATH" to a prefix which is then used
#	* "nobuild" meaning that we only try with spack load
#       * "spackonly" meaning that we only wish to install through spack if present
#       * "" meaning that we also try to build from sources (using local deps)

OPENPA_PREFIX=""

MPCALLOC_PREFIX=""

OFI_PREFIX=""

MPC_DMTCP_PREFIX="disabled"
MPC_GDB_PREFIX='disabled'
TBB_PREFIX="disabled"
# Concurrency Kit disabled by default
CK_PREFIX="disabled"

# Empty means mpc-compiler-additions's default
[ "x$GCC_VERSION" = "x" ] && GCC_VERSION=""
WORKSHARE_ENABLED="no"

#
# Argument parsing
#

add_process_mode_flag_to_mpc()
{
	MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --enable-process-mode"
}

enable_debug()
{
	MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --enable-debug"
	MPC_COMP_ADD_BUILD_PARAMETERS="${MPC_COMP_ADD_BUILD_PARAMETERS} --opts=--enable-debug"
	OFI_BUILD_PARAMETERS="${OFI_BUILD_PARAMETERS} --enable-debug"
}

#
# Locate common tools ahead of time
#
check_for_commands


for arg in "$@"
do
	case "$arg" in
		################# HYDRA #################
		--with-hydra=*)
			extractParamValue 'HYDRA_PREFIX' 'with-hydra' "$arg"
			;;
		--hydra=*)
			extractAndAddPackageOption 'HYDRA_BUILD_PARAMETERS' 'hydra=' "$arg"
			;;
		--disable-mpc-hydra|--disable-hydra)
			HYDRA_PREFIX='disabled'
			;;
		#################### OPENPA #################
		--with-openpa=*)
			extractParamValue 'OPENPA_PREFIX' 'with-openpa' "$arg"
			;;
		--openpa=*)
			extractAndAddPackageOption 'OPENPA_BUILD_PARAMETERS' 'openpa=' "$arg"
			;;
		################### MPC GDB #################
		--with-gdb=*)
			extractParamValue 'MPC_GDB_PREFIX' 'with-gdb' "$arg"
			;;
		--gdb=*)
			extractAndAddPackageOption 'MPC_GDB_BUILD_PARAMETERS' 'gdb=' "$arg"
			;;
		--disable-gdb)
			MPC_GDB_PREFIX='disabled'
			;;
		--enable-gdb|--enable-mpc-gdb)
			enableParamIfNot 'MPC_GDB_PREFIX' "$MPC_GDB_PREFIX" 'disabled' 'internal'
			enable_debug
			;;
		################### MPC GCC #################
		--gcc-version=*)
			extractParamValue 'GCC_VERSION' 'gcc-version' "$arg"
			;;
		--with-mpc-comp=*)
			extractParamValue 'MPC_COMP_ADD_PREFIX' 'with-mpc-comp' "$arg"
			;;
		--with-autopriv=*)
			extractParamValue 'MPC_COMP_ADD_PREFIX' 'with-autopriv' "$arg"
			;;
		--mpc-comp=*)
			extractAndAddPackageOption 'MPC_COMP_ADD_BUILD_PARAMETERS' 'mpc-comp=' "$arg"
			;;
		--mpc-autopriv=*)
			extractAndAddPackageOption 'MPC_COMP_ADD_BUILD_PARAMETERS' 'mpc-autopriv=' "$arg"
			;;
		--autopriv=*)
			extractAndAddPackageOption 'MPC_COMP_ADD_BUILD_PARAMETERS' 'autopriv=' "$arg"
			;;
		--disable-mpc-gcc|--disable-mpc-comp|--disable-autopriv|--disable-mpc-autopriv|--process-mode|--mpc-process-mode)
			MPC_COMP_ADD_PREFIX='disabled'
			add_process_mode_flag_to_mpc
			;;
		################# FORTRAN GCC ###############
		--disable-mpc-fortran|--disable-fortran)
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --disable-fortran"
			;;
		################### HWLOC ###################
		--with-hwloc=*)
			extractParamValue 'HWLOC_PREFIX' 'with-hwloc' "$arg"
			;;
		--hwloc=*)
			extractAndAddPackageOption 'HWLOC_BUILD_PARAMETERS' 'hwloc=' "$arg"
			;;
		################### CUDA ###################
		--with-cuda=*)
			extractParamValue 'CUDA_PREFIX' 'with-cuda' "$arg"
			;;
		--with-openacc=*)
			extractParamValue 'OPENACC_PREFIX' 'with-openacc' "$arg"
			;;
		--with-opencl=*)
			extractParamValue 'OPENCL_PREFIX' 'with-opencl' "$arg"
			;;
		################### TBB ###################
		--with-tbb=*)
			extractParamValue 'TBB_PREFIX' 'with-tbb' "$arg"
			;;
		--tbb=*)
			extractAndAddPackageOption 'TBB_BUILD_PARAMETERS' 'tbb=' "$arg"
			;;
		--enable-mpc-tbb)
			enableParamIfNot 'TBB_PREFIX' "$TBB_PREFIX" 'disabled' 'internal'
			;;
		--disable-mpc-tbb)
			TBB_PREFIX="disabled"
			;;
		#### OFI ##########
		--enable-ofi|--enable-libfabric)
			OFI_PREFIX=""
			;;
		--disable-ofi|--disable-libfabric)
			OFI_PREFIX="disabled"
			;;
		#################### Concurrency Kit #################
		--enable-ck)
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --enable-ck"
            CK_PREFIX="enabled"
			;;
		--ofi=*)
			extractAndAddPackageOption 'OFI_BUILD_PARAMETERS' 'ofi=' "$arg"
			;;
		#### MPC Allocator ##########
		--enable-mpc-allocator|--enable-mpcalloc)
			MPCALLOC_PREFIX=""
			;;
		--disable-mpc-allocator|--disable-mpcalloc)
			MPCALLOC_PREFIX="disabled"
			;;
		--mpcalloc=*)
			extractAndAddPackageOption 'MPCALLOC_BUILD_PARAMETERS' 'mpcalloc=' "$arg"
			;;
		################### DMTCP ###################
		--with-dmtcp=*)
			extractParamValue 'MPC_DMTCP_PREFIX' 'with-dmtcp' "$arg"
			;;
		--dmtcp=*)
			extractAndAddPackageOption 'MPC_DMTCP_BUILD_PARAMETERS' 'dmtcp=' "$arg"
			;;
		################### GENERIC FT ###################
		--enable-mpc-ft)
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --with-dmtcp"
			enableParamIfNot 'MPC_DMTCP_PREFIX' "$MPC_DMTCP_PREFIX" 'disabled' 'internal'
			;;
		--disable-mpc-ft)
			MPC_DMTCP_PREFIX="disabled"
			;;
		################# COMPILER ##################
		--compiler=*)
			extractParamValue 'MPC_COMPILER' 'compiler' "$arg"
			ALL_PACKAGE_ARGS="$ALL_PACKAGE_ARGS CC=${MPC_COMPILER}"
			;;
		############### MPCFRAMEWORK ################
		--enable-color)
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --enable-shell-colors"
			MPC_COMP_ADD_BUILD_PARAMETERS="${MPC_COMP_ADD_BUILD_PARAMETERS} --opts=--enable-color"
			USE_COLOR="yes"
			;;
		--disable-color)
			MPCFRAMEWORK_BUILD_PARAMETERS=$(echo "$MPCFRAMEWORK_BUILD_PARAMETERS" | sed "s/--enable-shell-colors//")
			USE_COLOR="no"
			;;
		--enable-debug)
			enable_debug
			;;
		--enable-topology-simulation)
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --enable-topology-simulation"
			;;
		--with-pmi1=*)
			PMIX_PREFIX=""
			extractParamValue 'PMIX_PREFIX' 'with-pmi1=' "$arg"
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} ${PMIX_PREFIX}"
			# No need for hydra
			HYDRA_PREFIX='disabled'
			;;
		--with-pmi1)
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --with-pmi1"
			# No need for hydra
			HYDRA_PREFIX='disabled'
			;;
		--with-pmix=*)
			PMIX_PREFIX=""
			extractParamValue 'PMIX_PREFIX' 'with-pmix=' "$arg"
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} ${PMIX_PREFIX}"
			# No need for hydra
			HYDRA_PREFIX='disabled'
			;;
		--with-pmix)
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --with-pmix"
			# No need for hydra
			HYDRA_PREFIX='disabled'
			;;
		--with-slurm=*)
			SLURM_PREFIX=""
			extractParamValue 'SLURM_PREFIX' 'with-slurm=' "$arg"
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} ${SLURM_PREFIX}"
			# No need for hydra
			HYDRA_PREFIX='disabled'
			;;
		--with-slurm)
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --with-slurm"
			# No need for hydra
			HYDRA_PREFIX='disabled'
			;;
		--disable-MPC_MPI|--lib-mode)
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --disable-mpi"
			;;
		--disable-romio)
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --disable-mpiio"
			;;
		--disable-prefix-check|--disable-check-install)
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --disable-prefix-check"
			;;
		--mpcframework=*)
			# Pass extra options to MPC
			extractAndAddPackageOption 'MPCFRAMEWORK_BUILD_PARAMETERS' 'mpcframework=' "$arg"
			;;
		--mpc-option=*)
			extractAndAddPackageOption 'MPCFRAMEWORK_BUILD_PARAMETERS' 'mpc-option=' "$arg"
			;;
		################## COMMON ###################
		-v | --verbose | --verbose=1)
			STEP_WRAPPER_VERBOSE=1
			export STEP_WRAPPER_VERBOSE
			;;
		-vv | --verbose=2)
			STEP_WRAPPER_VERBOSE=2
			export STEP_WRAPPER_VERBOSE
			;;
		-vvv | --verbose=3)
			STEP_WRAPPER_VERBOSE=3
			export STEP_WRAPPER_VERBOSE
			;;
		-j*)
			extractParamValueAlt 'MAKE_J' 'j' "$arg"
			if test "x${LSP}" = "xyes"; then
				info "--enable-lsp is set, -j will be ignored when building MPC"
			fi
			;;
		--prefix=*)
			extractParamValue 'PREFIX' 'prefix' "$arg"
			if [ ! -d "${PREFIX}" ]; then
				mkdir -p "${PREFIX}"
			else
				check_prefix_is_clean "${PREFIX}"
			fi
			;;
		--help|-h|-?)
			showHelp
			exit 0
			;;
		--download|--download-missing-deps)
			download_all_missing_deps
			exit 0
		;;
		--enable-lsp)
			assert_cmd "bear"
			LSP="yes"
			if [ -n "$MAKE_J" ]; then
				info "--enable-lsp is set, -j will be ignored when building MPC"
			fi
			;;
		--disable-lsp)
			LSP="no"
			;;
		--spack|--enable-spack)
			assert_cmd "spack"
			SPACK_LOCATE_DEPENDENCY="yes"
			;;
		--disable-spack|--enable-all-internals)
			SPACK_LOCATE_DEPENDENCY="no"
			SPACK_INSTALL_DEPENDENCY="no"
			;;
		--spack-build|--enable-spack-build)
			assert_cmd "spack"
			SPACK_LOCATE_DEPENDENCY="yes"
			SPACK_INSTALL_DEPENDENCY="yes"
			;;
		--disable-spack-build)
			SPACK_INSTALL_DEPENDENCY="no"
			;;
		--enable-spack-arch)
			SPECIFY_SPACK_ARCH="yes"
			;;
		--disable-spack-arch)
			SPECIFY_SPACK_ARCH="no"
			;;
		--enable-generic-spack-build)
			ENABLE_GENERIC_SPACK_BUILD="yes"
			;;
		--disable-generic-spack-build)
			ENABLE_GENERIC_SPACK_BUILD="no"
			;;
		--force-spack-arch=*)
			extractParamValue 'FORCE_SPACK_ARCH' 'force-spack-arch' "$arg"
			;;
		--disable-build)
			BUILD_IS_DISABLED="yes"
			;;
		--force-spack-package=*)
			extractParamValue 'OVERRIDEN_SPACK_PKGS' 'force-spack-package' "$arg"
			;;
    	--enable-workshare)
			MPCFRAMEWORK_BUILD_PARAMETERS="${MPCFRAMEWORK_BUILD_PARAMETERS} --enable-workshare"
			WORKSHARE_ENABLED="yes"
			# Workshare is only on 7.3.0 try to force it
			GCC_VERSION="7.3.0"
      	;;
		# Build wrappers
		--version)
			printf "%s\n" "$("$SCRIPTPATH/utils/get_version")"
			exit 0
			;;
		clean)
			make clean
			;;
		distclean)
			make distclean
			;;
		# Deprecated options
		--mirror=*|--with-sctk-arch=*|--sctk-arch-*|--with-mpfr=*|--mpfr-*|--with-gmp=*|--with-hbict=*|--hbict-*|--gmp-*|--with-mpc-binutils=*|--mpc-binutils-*|--disable-mpc-binutils|--with-libextls=*|--libextls-*|--with-mpc=*|--enable-check-deps|--disable-check-deps|--host=*|--target=*|--arch-library-path=*|--with-sysroot=*|--with-libxml2=*|--libxml2=*)
			info "$arg is deprecated"
			;;
		*)
			echo "Invalid argument '$arg', please check your command line or get help with --help." 1>&2
			exit 1
	esac
done

#
# Enable output color if set
#
set_color_model

# Build directory check
#

# Make sure we do not install inside the source directory

if test "x${SCRIPTPATH}" = "x${PROJECT_BUILD_DIR}"; then
	die "MPC cannot be configured inside the source directory"
fi


# Make sure we have a prefix
test -z "$PREFIX" && die "Please provide a prefix where to install MPC"

PREFIX=$(readlink -f "$PREFIX")

if test "x${PREFIX}" = "x${PROJECT_BUILD_DIR}"; then
	die "You cannot install MPC in its build directory"
fi

# Ensure cores used to build is configured

if test -z "$MAKE_J"; then
	guess_cpu_count

	info "Building with ${NCPU} cores use -jX to change"
	MAKE_J="$NCPU"
else
	info "Building with ${MAKE_J} cores"
fi

#
# Can we use spack ? provide information message
#

have_cmd "spack"

if test "x${HAVE_CMD}" = "xyes"; then

	if test "x${SPACK_LOCATE_DEPENDENCY}" = "xno"; then
		info "Not locating packages with spack as --disable-spack was passed"
	else
		# Display warning if not building with spack
		if test "x${SPACK_INSTALL_DEPENDENCY}" = "xno"; then
			info "Not building using spack as --enable-spack-build not passed"
		fi

	fi
else
	info "spack is not present MPC will rely on built-in packages"
fi

#
# These commands are compulsory
#

assert_cmd "make"
assert_cmd "patch"
assert_cmd "bzip2"
assert_cmd "pkg-config"

# Basic dependencies
find_in_prefix_or_use_spack "openpa" "$(package_version "openpa")" "${OPENPA_PREFIX}"

if test "x${DEP_FOUND}" = "xno"; then
	# Could not use spack now installing manually
	build_configure_based_package "openpa" "$(package_version "openpa")" "$OPENPA_BUILD_PARAMETERS"
fi

find_in_prefix_or_use_spack "concurrency-kit" "$(package_version "concurrency-kit")" "${CK_PREFIX}"

# Concurrency Kit only available through spack
if test "x${DEP_FOUND}" = "xno" && test "x$CK_PREFIX" != "xdisabled"; then
	build_configure_based_package "concurrency-kit" "$(package_version "concurrency-kit")" "$ck_build_parameters"
fi

find_in_prefix_or_use_spack "hwloc" "$(package_version "hwloc")" "${HWLOC_PREFIX}" "-libudev"

if test "x${DEP_FOUND}" = "xno"; then
	# Could not use spack now installing manually
	# hwloc has bugs on inti when building with rocm at least from hwloc 2.7.0 to 2.9.0. the --without-rocm flag make build crash with
	build_configure_based_package "hwloc" "$(package_version "hwloc")" "$HWLOC_BUILD_PARAMETERS --disable-rocm --disable-cuda --disable-opencl --disable-libudev"
fi

# We cannot use spack as the spack package uses an internal hwloc of previous version
if check_and_then_load_prefix "$HYDRA_PREFIX"; then
	# Make sure hydra seems to be in the path
	assert_cmd "mpiexec.hydra"
else

	if test "x$HYDRA_PREFIX" != "xdisabled"; then
		info "Hydra must be built and patched localy for HWLOC 2+ support (no spack support)"
		# Here we need to build hydra and we try to target our own HWLOC
		find_package_prefix "hwloc" "$(package_version "hwloc")" "${HWLOC_PREFIX}"

		if test -n "${PACK_PREFIX}"; then
			HYDRA_BUILD_PARAMETERS="--with-hwloc-prefix=${PACK_PREFIX} ${HYDRA_BUILD_PARAMETERS}"
		fi

		build_configure_based_package "hydra" "$(package_version "hydra")" "$HYDRA_BUILD_PARAMETERS"
	fi
fi


find_in_prefix_or_use_spack "gdb" "$(package_version "gdb")" "${MPC_GDB_PREFIX}"

if test "x${DEP_FOUND}" = "xno"; then
	# Could not use spack now installing manually
	build_configure_based_package "gdb" "$(package_version "gdb")" "$MPC_GDB_BUILD_PARAMETERS"
fi


find_in_prefix_or_use_spack "mpc-dmtcp" "$(package_version "mpc-dmtcp")" "${MPC_DMTCP_PREFIX}"

if test "x${DEP_FOUND}" = "xno"; then
	# Could not use spack now installing manually
	build_configure_based_package "mpc-dmtcp" "$(package_version "mpc-dmtcp")" "$MPC_DMTCP_BUILD_PARAMETERS"
fi


find_in_prefix_or_use_spack "mpcalloc" "$(package_version "mpcalloc")" "$MPCALLOC_PREFIX" "^hwloc@$(package_version 'hwloc')"

if test "x${DEP_FOUND}" = "xno" && test "x$MPCALLOC_PREFIX" != "xdisabled"; then
	assert_cmd "cmake"
	# Could not use spack now installing manually
	build_configure_based_package "mpcalloc" "$(package_version "mpcalloc")" "$MPCALLOC_BUILD_PARAMETERS"
fi


find_in_prefix_or_use_spack "libfabric" "$(package_version "libfabric")" "$OFI_PREFIX" "fabrics=sockets,tcp,verbs"

if test "x${DEP_FOUND}" = "xno" && test "x$OFI_PREFIX" != "xdisabled"; then
	# Could not use spack now installing manually
	build_configure_based_package "libfabric" "$(package_version "libfabric")" "$ofi_build_parameters"
fi

#
# Check for avoiding GLIBC 2.28 for GCC 7.3.0
#
check_glibc_is_compatible()
{
       have_cmd "ldd"

       if test "x${MPC_NOGLIBC_CHECK}" = "x1"; then
               return
       fi

       if test "x${HAVE_CMD}" = "xyes"; then
               GLIBC=$(ldd --version | head -n 1 | rev | cut -d " " -f 1 | rev | sed "s/\.//g")
               # Check for incompatibilities in versions >= 2.27
               if test $GLIBC -gt 227; then
			   			if test "${WORKSHARE_ENABLED}" = "yes"; then
							info "GCC 7.3.0 is required to enable workshare consider disabling this option"
						fi
			   		    if test "x${GCC_VERSION}" = "x7.3.0"; then
                       		die "GLIBC $GLIBC not compatible with GCC 7.3.0 you may choose another version with --gcc-version=10.2.0 for example)"
						fi
               fi
       fi
}

check_glibc_is_compatible

#If a default GCC version is passed
GCC_VERSION_SPACK=""
GCC_VERSION_ARG=""
if test -n "${GCC_VERSION}"; then

	DISABLE_WORKSHARE=""
	DISABLE_WORKSHARE_ARG=""

	if test "x${GCC_VERSION}" != "x7.3.0"; then

		if test "${WORKSHARE_ENABLED}" = "yes"; then
			die "GCC 7.3.0 is required to enable workshare consider disabling this option"
		fi

		info "Building GCC ${GCC_VERSION}: disabling workshare extensions only supported in GCC 7.3.0"
		DISABLE_WORKSHARE=" -workshare"
		DISABLE_WORKSHARE_ARG=" --disable-workshare"
	fi

	GCC_VERSION_SPACK=" ${DISABLE_WORKSHARE} gcc_version=${GCC_VERSION}"
	GCC_VERSION_ARG="--gcc-version=${GCC_VERSION} ${DISABLE_WORKSHARE_ARG}"
fi


# Dependencies which can be deactivated
VERSION="$(package_version "mpc-compiler-additions")"

find_in_prefix_or_use_spack "mpc-compiler-additions" "${VERSION}" "${MPC_COMP_ADD_PREFIX}" "$GCC_VERSION_SPACK ^hwloc@$(package_version 'hwloc')"

if test "x${DEP_FOUND}" = "xno"; then
	assert_cmd "gcc"
	assert_cmd "g++"

	find_package_prefix "hwloc" "$(package_version "hwloc")" "${HWLOC_PREFIX}"

	AUTOPRIV_HWLOC_BUILD_PARAMETERS=""
	if test -n "${PACK_PREFIX}"; then
		AUTOPRIV_HWLOC_BUILD_PARAMETERS="--with-hwloc=${PACK_PREFIX}"
	fi
	# Could not use spack now installing manually
	build_configure_based_package "mpc-compiler-additions" "${VERSION}" "$MPC_COMP_ADD_BUILD_PARAMETERS $GCC_VERSION_ARG $AUTOPRIV_HWLOC_BUILD_PARAMETERS"
fi


# Make sure to load libunwind after compiler-additions (https://trac.macports.org/ticket/43869)
find_in_prefix_or_use_spack_optional "libunwind" "" "spackonly" "${LIBUNWIND_PREFIX}"

# It is now time to configure MPC


propagate_build_env

BUILD_CONF_PATH=${PROJECT_BUILD_DIR}/src/bin/mpc_build_env.sh

if test -f "${BUILD_CONF_PATH}" ; then
	checking "remove previous MPC configuration state"
	show_run_cmd "rm -fr $BUILD_CONF_PATH"
	rm -fr "${BUILD_CONF_PATH}"
	ok
fi

MPC_CONFIGURE_OPTS="--prefix=${PREFIX} $MPCFRAMEWORK_BUILD_PARAMETERS"

#
# Autogen MPC
#

checking "Autogen MPC"

wrap_output "$SCRIPTPATH/autogen.sh" $SCRIPTPATH
printf "\n"

#
# Configure MPC
#

checking "Configuring MPC"

if test "${MPC_COMP_ADD_PREFIX}" = "disabled"; then
	# we want parameter expansion
	# shellcheck disable=SC2086
	wrap_output "$SCRIPTPATH/configure" $MPC_CONFIGURE_OPTS $ALL_PACKAGE_ARGS
	ok
else
	# We have mpc-compiler-additions so we explicitly set CC CXX and FC
	# we want parameter expansion
	# shellcheck disable=SC2086
	wrap_output "$SCRIPTPATH/configure" $MPC_CONFIGURE_OPTS CC="$(command -v apcc)" CXX="$(command -v ap++)" FC="$(command -v apfortran)"
	ok
fi


#
# Display MPC status if present (and not already displayed)
#

if test $STEP_WRAPPER_VERBOSE -gt 0; then
	if test -f ./src/bin/mpc_status; then
		show_run_cmd "sh ./src/bin/mpc_status"
		sh ./src/bin/mpc_status
	fi
fi

if test "x${LSP}" = "xyes"; then
	checking "Building & Installing MPC with Bear"
	echo ""
	info "This will take longer than a regular build"

	# Parallel make with bear may access too many files
	# at the same time and never finish.
	wrap_output bear -- make install -j 1
	ok

	checking "Copying compile_commands.json to the source directory"
	wrap_output cp ${PROJECT_BUILD_DIR}/compile_commands.json ${SCRIPTPATH}
	ok
else
	checking "Building MPC"
	wrap_output make -j ${MAKE_J}
	ok

	checking "Installing MPC"
	wrap_output make install -j ${MAKE_J}
	ok
fi