#
# Copyright (c) 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Lucía Andrea Illanes Albornoz <lucia@luciaillanes.de>
# set +o errexit -o noglob -o nounset is assumed.
#
# Package {configure,make} command execution
#

#
# ex_rtl_configure() - run configure script
# @_ar:				ar(1) command name or pathname
# @_cc:				C compiler command name or pathname
# @_configure:			configure script command name or pathname
# @_cxx:			C++ compiler command name or pathname
# @_ld:				ld(1) command name or pathname
# @_libtool:			libtool(1) command name or pathname or "none"
# @_pkg_config:			pkg-config(1) command name or pathname
# @_python:			python command name or pathname
# @_ranlib:			ranlib(1) command name or pathname
# @--:				(ignored)
# @_flags:			configure script flags as a whitespace-separated list
# @_flags_extra:		extra configure script flags as a whitespace-separated likst
# @_flags_list:			configure script flags as a :-separated list
# @_flags_extra_list:		extra configure script flags as a :-separated list
# @--:				(ignored)
# @_cflags:			$CFLAGS
# @_cflags_extra:		extra $CFLAGS
# @_cppflags:			$CPPFLAGS
# @_cppflags_extra:		extra $CPPFLAGS
# @_cxxflags:			$CXXFLAGS
# @_cxxflags_extra:		extra $CXXFLAGS
# @_ldflags:			$LDFLAGS
# @_ldflags_extra:		extra $LDFLAGS
# @_pkg_config_libdir:		pkg-config(1) search directory
#
# Returns:			zero (0) on success, non-zero (>0) on failure
#
ex_rtl_configure() {
	local	_erc_ar="${1}" _erc_cc="${2}" _erc_configure="${3}" _erc_cxx="${4}" _erc_ld="${5}"	\
		_erc_libtool="${6}" _erc_pkg_config="${7}" _erc_python="${8}" _erc_ranlib="${9}"	\
		_erc_ignored="${10}"									\
		_erc_flags="${11}" _erc_flags_extra="${12}"						\
		_erc_flags_list="${13}" _erc_flags_extra_list="${14}"					\
		_erc_ignored="${15}"									\
		_erc_cflags="${16}" _erc_cflags_extra="${17}" _erc_cppflags="${18}"			\
		_erc_cppflags_extra="${19}" _erc_cxxflags="${20}" _erc_cxxflags_extra="${21}"	\
		_erc_ldflags="${22}" _erc_ldflags_extra="${23}" _erc_pkg_config_libdir="${24}"	\
		_erc_rc=0;

	case "${_erc_libtool:-}" in
	none) _erc_libtool=""; ;;
	esac;

	[ "${_erc_cflags_extra:+1}" = 1 ] && _erc_cflags="${_erc_cflags:+${_erc_cflags} }${_erc_cflags_extra}";
	[ "${_erc_cppflags_extra:+1}" = 1 ] && _erc_cppflags="${_erc_cppflags:+${_erc_cppflags} }${_erc_cppflags_extra}";
	[ "${_erc_cxxflags_extra:+1}" = 1 ] && _erc_cxxflags="${_erc_cxxflags:+${_erc_cxxflags} }${_erc_cxxflags_extra}";
	[ "${_erc_ldflags_extra:+1}" = 1 ] && _erc_ldflags="${_erc_ldflags:+${_erc_ldflags} }${_erc_ldflags_extra}";

(
	if [ "${_erc_libtool:+1}" = 1 ]; then
		export MAKE="make LIBTOOL=${_erc_libtool}";
	fi;

	[ "${_erc_ar:+1}" = 1 ] && export AR="${_erc_ar}";
	[ "${_erc_cc:+1}" = 1 ] && export CC="${_erc_cc}";
	[ "${_erc_cxx:+1}" = 1 ] && export CXX="${_erc_cxx}";
	[ "${_erc_ld:+1}" = 1 ] && export LD="${_erc_ld}";
	[ "${_erc_libtool:+1}" = 1 ] && export LIBTOOL="${_erc_libtool}";
	[ "${_erc_pkg_config:+1}" = 1 ] && export PKG_CONFIG="${_erc_pkg_config}";
	[ "${_erc_python:+1}" = 1 ] && export PYTHON="${_erc_python}";
	[ "${_erc_ranlib:+1}" = 1 ] && export RANLIB="${_erc_ranlib}";

	[ "${_erc_cflags:+1}" = 1 ] && export CFLAGS="${_erc_cflags}";
	[ "${_erc_cppflags:+1}" = 1 ] && export CPPFLAGS="${_erc_cppflags}";
	[ "${_erc_cxxflags:+1}" = 1 ] && export CXXFLAGS="${_erc_cxxflags}";
	[ "${_erc_ldflags:+1}" = 1 ] && export LDFLAGS="${_erc_ldflags}";
	[ "${_erc_pkg_config_libdir:+1}" = 1 ] && export PKG_CONFIG_LIBDIR="${_erc_pkg_config_libdir}";

	if [ "${_erc_flags_list:+1}" = 1 ]; then
		rtl_run_cmdlineV ":" "${_erc_configure}"	\
			"${_erc_flags_list}"			\
			"${_erc_flags_extra_list:-}"		\
			;
		exit "${?}";
	elif [ "${_erc_flags_extra_list:+1}" = 1 ]; then
		rtl_run_cmdlineV ":" "${_erc_configure}"	\
			${_erc_flags:-}				\
			"${_erc_flags_extra_list:-}"		\
			;
		exit "${?}";
	else
		rtl_run_cmdlineV ":" "${_erc_configure}"	\
			${_erc_flags:-}				\
			${_erc_flags_extra:-}			\
			;
		exit "${?}";
	fi;
);
	_erc_rc="${?}";

	return "${_erc_rc}";
};

#
# ex_rtl_configure_cmake() - configure CMake build
# @_ar:				ar(1) command name or pathname
# @_cc:				C compiler command name or pathname
# @_cmake:			CMake command name or pathname
# @_cxx:			C++ compiler command name or pathname
# @_ld:				ld(1) command name or pathname
# @_pkg_config:			pkg-config(1) command name or pathname
# @_python:			python command name or pathname
# @_ranlib:			ranlib(1) command name or pathname
# @--:				(ignored)
# @_build_kind:			build kind (Debug, Release)
# @_build_type:			CMake build type (host, cross, native)
# @_cmake_args:			additional CMake arguments as a whitespace-separated list
# @_cmake_args_extra:		additional CMake extra arguments as a whitespace-separated likst
# @_prefix:			build prefix pathname
# @_subdir:			CMake build directory pathname
# @_system_name:		CMake system name
# @_system_processor:		CMake system processor
# @--:				(ignored)
# @_cflags:			$CFLAGS
# @_cflags_extra:		extra $CFLAGS
# @_cppflags:			$CPPFLAGS
# @_cppflags_extra:		extra $CPPFLAGS
# @_cxxflags:			$CXXFLAGS
# @_cxxflags_extra:		extra $CXXFLAGS
# @_ldflags:			$LDFLAGS
# @_ldflags_extra:		extra $LDFLAGS
# @_pkg_config_libdir:		pkg-config(1) search directory
#
# Returns:			zero (0) on success, non-zero (>0) on failure
#
ex_rtl_configure_cmake() {
	local	_ercc_ar="${1}" _ercc_cc="${2}" _ercc_cmake="${3}"					\
		_ercc_cxx="${4}" _ercc_ld="${5}" _ercc_pkg_config="${6}" _ercc_python="${7}"		\
		_ercc_ranlib="${8}"									\
		_ercc_ignored="${9}"									\
		_ercc_build_kind="${10}" _ercc_build_type="${11}"					\
		_ercc_cmake_args="${12}" _ercc_cmake_args_extra="${13}"					\
		_ercc_prefix="${14}" _ercc_subdir="${15}"						\
		_ercc_system_name="${16}" _ercc_system_processor="${17}"				\
		_ercc_ignored="${18}"									\
		_ercc_cflags="${19}" _ercc_cflags_extra="${20}" _ercc_cppflags="${21}"			\
		_ercc_cppflags_extra="${22}" _ercc_cxxflags="${23}" _ercc_cxxflags_extra="${24}"	\
		_ercc_ldflags="${25}" _ercc_ldflags_extra="${26}" _ercc_pkg_config_libdir="${27}"	\
		_ercc_cmd_name="" _ercc_cmake_args_auto="" _ercc_rc=0 _ercc_vname="" _ercc_vval=""

	[ "${_ercc_cflags_extra:+1}" = 1 ] && _ercc_cflags="${_ercc_cflags:+${_ercc_cflags} }${_ercc_cflags_extra}";
	[ "${_ercc_cppflags_extra:+1}" = 1 ] && _ercc_cppflags="${_ercc_cppflags:+${_ercc_cppflags} }${_ercc_cppflags_extra}";
	[ "${_ercc_cxxflags_extra:+1}" = 1 ] && _ercc_cxxflags="${_ercc_cxxflags:+${_ercc_cxxflags} }${_ercc_cxxflags_extra}";
	[ "${_ercc_ldflags_extra:+1}" = 1 ] && _ercc_ldflags="${_ercc_ldflags:+${_ercc_ldflags} }${_ercc_ldflags_extra}";

(
	[ "${_ercc_pkg_config:+1}" = 1 ] && export PKG_CONFIG="${_ercc_pkg_config}";
	[ "${_ercc_pkg_config_libdir:+1}" = 1 ] && export PKG_CONFIG_LIBDIR="${_ercc_pkg_config_libdir}";
	[ "${_ercc_python:+1}" = 1 ] && export PYTHON="${_ercc_python}";

	for _ercc_vname in ar cc cxx ld pkg_config ranlib; do
		_ercc_vname="_ercc_${_ercc_vname}";

		if eval [ '"${'"${_ercc_vname}"':+1}"' = 1 ]\
		&& eval [ '"${'"${_ercc_vname}"'#/}"' = '"${'"${_ercc_vname}"'}"' ]; then
			eval _ercc_cmd_name="\${${_ercc_vname}% *}";
			eval _ercc_vval="\${${_ercc_vname}#* }";
			eval ${_ercc_vname}='$(which "${_ercc_cmd_name}")' || return 1;
		fi;
	done;

	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_AR=${_ercc_ar}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_BUILD_TYPE=${_ercc_build_kind}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_C_COMPILER=${_ercc_cc}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_C_FLAGS=${_ercc_cflags}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_COMMAND=${_ercc_cmake}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_CPP_FLAGS=${_ercc_cppflags}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_CXX_COMPILER=${_ercc_cxx}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_CXX_FLAGS=${_ercc_cxxflags}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_EXE_LINKER_FLAGS=${_ercc_ldflags}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_FIND_ROOT_PATH=${_ercc_prefix}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_INSTALL_PREFIX=" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_LINKER=${_ercc_ld}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_MODULE_LINKER_FLAGS=${_ercc_ldflags}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_RANLIB=${_ercc_ranlib}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_SHARED_LINKER_FLAGS=${_ercc_ldflags}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_SYSTEM_PROCESSOR=${_ercc_system_processor}" "|";
	rtl_lconcat \$_ercc_cmake_args_auto "-DPKG_CONFIG_EXECUTABLE=${_ercc_pkg_config}" "|";

	case "${_ercc_build_type}" in
	native)
		rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_SYSROOT=${_ercc_prefix}" "|";
		rtl_lconcat \$_ercc_cmake_args_auto "-DCMAKE_SYSTEM_NAME=${_ercc_system_name}" "|";
		;;
	esac;

	rtl_llift \$_ercc_cmake_args " 
" "|";
	rtl_llift \$_ercc_cmake_args_extra " 
" "|";

	rtl_run_cmdlineV "|" "${_ercc_cmake}"	\
		"${_ercc_cmake_args_auto}"	\
		${_ercc_cmake_args:-}		\
		${_ercc_cmake_args_extra:-}	\
		"${_ercc_subdir}";
	exit "${?}";
);
	_ercc_rc="${?}";

	return "${_ercc_rc}";
};

#
# ex_rtl_configure_prepare() - prepare configure script for running
# @_build_type:			build type (host, native)
# @_builddir:			build directory pathname
# @_config_cache:		optional configuration cache directives
# @_config_cache_local:		optional local configuration cache directives
# @_config_cache_extra:		optional extra configuration cache directives
# @_config_guess_fname:		config.guess file pathname
# @_config_sub_global_fname:	global config.sub file pathname
# @_copy_config_guess:		copy config.guess (copy) or keep local config.guess (keep)
# @_force_autoreconf:		1 to force reconfiguration if already configured, 0 otherwise
# @_subdir:			subdirectory pathname
# @_pkg_config:			pkg-config(1) command name or pathname
# @_pkg_config_libdir:		pkg-config(1) search directory
# @_prefix:			prefix pathname
#
# Returns:			zero (0) on success, non-zero (>0) on failure
#
ex_rtl_configure_prepare() {
	local	_ercp_build_type="${1}" _ercp_builddir="${2}" _ercp_config_cache="${3}"		\
		_ercp_config_cache_local="${4}" _ercp_config_cache_extra="${5}"			\
		_ercp_config_guess_fname="${6}" _ercp_config_sub_global_fname="${7}"		\
		_ercp_copy_config_guess=="${8}" _ercp_force_autoreconf="${9}"			\
		_ercp_subdir="${10}" _ercp_pkg_config="${11}" _ercp_pkg_config_libdir="${12}"	\
		_ercp_prefix="${13}";

	if rtl_exists_any "${_ercp_subdir}"	\
			"configure.ac"		\
			"configure.in"		\
			"configure";
	then
		rtl_export_vars							\
			PKG_CONFIG		"${_ercp_pkg_config}"		\
			PKG_CONFIG_LIBDIR	"${_ercp_pkg_config_libdir}";

		if [ "${_ercp_force_autoreconf:-0}" -eq 1 ]\
		&& ! (cd "${_ercp_subdir}" && autoreconf -fiv); then
			return 1;
		fi;

		if [ -e "${_ercp_subdir}/configure.ac" ]\
		&& [ ! -e "${_ercp_subdir}/configure" ]; then
			for _ercp_fname in bootstrap bootstrap.sh autogen.sh; do
				if [ -e "${_ercp_subdir}/${_ercp_fname}" ]; then
					for _ercp_subdir_tgt in 			\
							"${_ercp_subdir}/build-aux"	\
							"${_ercp_subdir}";
					do	if [ -e "${_ercp_subdir_tgt}" ]; then
							if ! rtl_fileop install -m 0700				\
									"${_ercp_config_sub_global_fname}"	\
									"${_ercp_subdir_tgt}/config.sub"; then
								return 1;
							fi;

							if [ "${_ercp_copy_config_guess}" = "copy" ]; then
								if ! rtl_fileop install -m 0700			\
										"${_ercp_config_guess_fname}"	\
										"${_ercp_subdir_tgt}/config.guess"; then
									return 1;
								else
									break;
								fi;
							fi;
						fi;
					done;

					if ! (rtl_fileop cd "${_ercp_subdir}" &&	\
							/bin/sh "${_ercp_fname}"); then
						return 1;
					else
						break;
					fi;
				fi;
			done;

			if ! (rtl_fileop cd "${_ercp_subdir}" && autoconf); then
				return 1;
			fi;
		fi;

		for _ercp_fname in $(find "${_ercp_subdir}" -name config.sub); do
			if ! rtl_fileop mv "${_ercp_fname}" "${_ercp_fname}.orig"\
			|| ! rtl_fileop install -m 0700 "${_ercp_config_sub_global_fname}" "${_ercp_fname}"; then
				return 1;
			fi;
		done;

		if [ "${_ercp_copy_config_guess}" = "copy" ]; then
			for _ercp_fname in $(find "${_ercp_subdir}" -name config.guess); do
				if ! rtl_fileop mv "${_ercp_fname}" "${_ercp_fname}.orig"\
				|| ! rtl_fileop install -m 0700 "${_ercp_config_guess_fname}" "${_ercp_fname}"; then
					return 1;
				fi;
			done;
		fi;

		if [ "${_ercp_build_type}" != host ]; then
			if ! rtl_fileop touch "${_ercp_builddir}/config.cache"; then
				return 1;
			else
				for _ercp_config_cache in 			\
						"${_ercp_config_cache:-}"	\
						"${_ercp_config_cache_local:-}"	\
						"${_ercp_config_cache_extra:-}";
				do
					if [ "${_ercp_config_cache:+1}" = 1 ]\
					&& ! printf "%s\n" "${_ercp_config_cache}" |\
							tr " " "\n" >> "${_ercp_builddir}/config.cache"; then
						return 1;
					fi;
				done;

				if ! sed -i"" "s,%PREFIX%,${_ercp_prefix},g" "${_ercp_builddir}/config.cache"; then
					return 1;
				fi;
			fi;
		fi;

		rtl_export_vars -u						\
			PKG_CONFIG		"${_ercp_pkg_config}"		\
			PKG_CONFIG_LIBDIR	"${_ercp_pkg_config_libdir}";
	fi;

	return 0;
};

#
# ex_rtl_configure_sofort() - configure sofort build
# @_ar:				ar(1) command name or pathname
# @_cc:				C compiler command name or pathname
# @_configure:			configure script command name or pathname
# @_cxx:			C++ compiler command name or pathname
# @_ld:				ld(1) command name or pathname
# @_ranlib:			ranlib(1) command name or pathname
# @--:				(ignored)
# @_native_ar:			native ar(1) command name or pathname
# @_native_cc:			native C compiler command name or pathname
# @_native_cxx:			native C++ compiler command name or pathname
# @_native_ld:			native ld(1) command name or pathname
# @_native_ranlib:		native ranlib(1) command name or pathname
# @--:				(ignored)
# @_flags:			configure script flags as a whitespace-separated list
# @_flags_extra:		extra configure script flags as a whitespace-separated likst
# @--:				(ignored)
# @_cflags:			$CFLAGS
# @_cflags_extra:		extra $CFLAGS
# @_cppflags:			$CPPFLAGS
# @_cppflags_extra:		extra $CPPFLAGS
# @_cxxflags:			$CXXFLAGS
# @_cxxflags_extra:		extra $CXXFLAGS
# @_ldflags:			$LDFLAGS
# @_ldflags_extra:		extra $LDFLAGS
# @--:				(ignored)
# @_native_cflags:		native $CFLAGS
# @_native_cflags_extra:	native extra $CFLAGS
# @_native_cppflags:		native $CPPFLAGS
# @_native_cppflags_extra:	native extra $CPPFLAGS
# @_native_cxxflags:		native $CXXFLAGS
# @_native_cxxflags_extra:	native extra $CXXFLAGS
# @_native_ldflags:		native $LDFLAGS
# @_native_ldflags_extra:	native extra $LDFLAGS
#
# Returns:		zero (0) on success, non-zero (>0) on failure
#
ex_rtl_configure_sofort() {
	local	_ercs_ar="${1}" _ercs_cc="${2}" _ercs_configure="${3}" _ercs_cxx="${4}" _ercs_ld="${5}" _ercs_ranlib="${6}"	\
		_ercs_ignored="${7}"												\
		_ercs_native_ar="${8}" _ercs_native_cc="${9}" _ercs_native_cxx="${10}" _ercs_native_ld="${11}"			\
		_ercs_native_ranlib="${12}"											\
		_ercs_ignored="${13}"												\
		_ercs_flags="${14}" _ercs_flags_extra="${15}"									\
		_ercs_ignored="${16}"												\
		_ercs_cflags="${17}" _ercs_cflags_extra="${18}" _ercs_cppflags="${19}"						\
		_ercs_cppflags_extra="${20}" _ercs_cxxflags="${21}" _ercs_cxxflags_extra="${22}"				\
		_ercs_ldflags="${23}" _ercs_ldflags_extra="${24}"								\
		_ercs_ignored="${25}"												\
		_ercs_native_cflags="${26}" _ercs_native_cflags_extra="${27}" _ercs_native_cppflags="${28}"			\
		_ercs_native_cppflags_extra="${29}" _ercs_native_cxxflags="${30}" _ercs_native_cxxflags_extra="${31}"		\
		_ercs_native_ldflags="${32}" _ercs_native_ldflags_extra="${33}"							\
		_ercs_vname="" _ercs_rc=0;

	[ "${_ercs_cflags_extra:+1}" = 1 ] && _ercs_cflags="${_ercs_cflags:+${_ercs_cflags} }${_ercs_cflags_extra}";
	[ "${_ercs_cppflags_extra:+1}" = 1 ] && _ercs_cppflags="${_ercs_cppflags:+${_ercs_cppflags} }${_ercs_cppflags_extra}";
	[ "${_ercs_cxxflags_extra:+1}" = 1 ] && _ercs_cxxflags="${_ercs_cxxflags:+${_ercs_cxxflags} }${_ercs_cxxflags_extra}";
	[ "${_ercs_ldflags_extra:+1}" = 1 ] && _ercs_ldflags="${_ercs_ldflags:+${_ercs_ldflags} }${_ercs_ldflags_extra}";

	[ "${_ercs_native_cflags_extra:+1}" = 1 ] && _ercs_native_cflags="${_ercs_native_cflags:+${_ercs_native_cflags} }${_ercs_native_cflags_extra}";
	[ "${_ercs_native_cppflags_extra:+1}" = 1 ] && _ercs_native_cppflags="${_ercs_native_cppflags:+${_ercs_native_cppflags} }${_ercs_native_cppflags_extra}";
	[ "${_ercs_native_cxxflags_extra:+1}" = 1 ] && _ercs_native_cxxflags="${_ercs_native_cxxflags:+${_ercs_native_cxxflags} }${_ercs_native_cxxflags_extra}";
	[ "${_ercs_native_ldflags_extra:+1}" = 1 ] && _ercs_native_ldflags="${_ercs_native_ldflags:+${_ercs_native_ldflags} }${_ercs_native_ldflags_extra}";

(
	[ "${_ercs_ar:+1}" = 1 ] && export AR="${_ercs_ar}";
	[ "${_ercs_cc:+1}" = 1 ] && export CC="${_ercs_cc}";
	[ "${_ercs_cxx:+1}" = 1 ] && export CXX="${_ercs_cxx}";
	[ "${_ercs_ld:+1}" = 1 ] && export LD="${_ercs_ld}";
	[ "${_ercs_ranlib:+1}" = 1 ] && export RANLIB="${_ercs_ranlib}";

	[ "${_ercs_native_ar:+1}" = 1 ] && export NATIVE_AR="${_ercs_native_ar}";
	[ "${_ercs_native_cc:+1}" = 1 ] && export NATIVE_CC="${_ercs_native_cc}";
	[ "${_ercs_native_cxx:+1}" = 1 ] && export NATIVE_CXX="${_ercs_native_cxx}";
	[ "${_ercs_native_ld:+1}" = 1 ] && export NATIVE_LD="${_ercs_native_ld}";
	[ "${_ercs_native_ranlib:+1}" = 1 ] && export NATIVE_RANLIB="${_ercs_native_ranlib}";

	[ "${_ercs_cflags:+1}" = 1 ] && export CFLAGS="${_ercs_cflags}" CFLAGS_SHARED="${_ercs_cflags}" CFLAGS_STATIC="${_ercs_cflags}";
	[ "${_ercs_cppflags:+1}" = 1 ] && export CPPFLAGS="${_ercs_cppflags}" CPPFLAGS_SHARED="${_ercs_cppflags}" CPPFLAGS_STATIC="${_ercs_cppflags}";
	[ "${_ercs_cxxflags:+1}" = 1 ] && export CXXFLAGS="${_ercs_cxxflags}" CXXFLAGS_SHARED="${_ercs_cxxflags}" CXXFLAGS_STATIC="${_ercs_cxxflags}";
	[ "${_ercs_ldflags:+1}" = 1 ] && export LDFLAGS="${_ercs_ldflags}" LDFLAGS_SHARED="${_ercs_ldflags}" LDFLAGS_STATIC="${_ercs_ldflags}";

	[ "${_ercs_native_cflags:+1}" = 1 ] && export NATIVE_CFLAGS="${_ercs_native_cflags}";
	[ "${_ercs_native_cppflags:+1}" = 1 ] && export NATIVE_CPPFLAGS="${_ercs_native_cppflags}";
	[ "${_ercs_native_cxxflags:+1}" = 1 ] && export NATIVE_CXXFLAGS="${_ercs_native_cxxflags}";
	[ "${_ercs_native_ldflags:+1}" = 1 ] && export NATIVE_LDFLAGS="${_ercs_native_ldflags}";

	"${_ercs_configure}"		\
		${_ercs_flags:-}	\
		${_ercs_flags_extra:-};
	exit $((${?} ? 1 : ${_ercs_rc}));
);
	_ercs_rc="${?}";

	return "${_ercs_rc}";
};

# vim:filetype=sh textwidth=0