Browse Source
Author: doogie Date: 1999-12-10 03:20:21 GMT Removed the tl_* macros, as dpkg doesn't use them, so why should we? Added smp configure support detection, so on cpu >= 2, we compile in parallel. The default multiplier is 2(2 processes per cpu) on machines with more than one cpu. Non-smp boxen compile 1 process at a time.debian/1.8.y
Arch Librarian
19 years ago
5 changed files with 90 additions and 439 deletions
@ -1,209 +0,0 @@ |
|||
# Our own versions of the other canonicalizing stuff |
|||
|
|||
dnl replace AC_CANONICAL_xxx |
|||
|
|||
undefine([AC_CANONICAL_HOST]) |
|||
define([AC_CANONICAL_HOST], [tl_CANONICAL_HOST]) |
|||
undefine([AC_CANONICAL_BUILD]) |
|||
define([AC_CANONICAL_BUILD], [tl_CANONICAL_BUILD]) |
|||
undefine([AC_CANONICAL_TARGET]) |
|||
define([AC_CANONICAL_TARGET], [tl_CANONICAL_TARGET]) |
|||
undefine([AC_CANONICAL_SYSTEM]) |
|||
define([AC_CANONICAL_SYSTEM], [tl_CANONICAL_SYSTEM]) |
|||
|
|||
dnl Canonicalize the host, target, and build system types. |
|||
AC_DEFUN(tl_CANONICAL_SYSTEM, |
|||
[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl |
|||
AC_PROVIDE([AC_CANONICAL_SYSTEM])dnl |
|||
AC_BEFORE([$0], [AC_ARG_PROGRAM]) |
|||
# Do some error checking and defaulting for the host and target type. |
|||
# The inputs are: |
|||
# configure --host=HOST --target=TARGET --build=BUILD NONOPT |
|||
# |
|||
# The rules are: |
|||
# 1. You are not allowed to specify --host, --target, and nonopt at the |
|||
# same time. |
|||
# 2. Host defaults to nonopt. |
|||
# 3. If nonopt is not specified, then host defaults to the current host, |
|||
# as determined by config.guess. |
|||
# 4. Target and build default to nonopt. |
|||
# 5. If nonopt is not specified, then target and build default to host. |
|||
|
|||
# The aliases save the names the user supplied, while $host etc. |
|||
# will get canonicalized. |
|||
case $host---$target---$nonopt in |
|||
NONE---*---* | *---NONE---* | *---*---NONE) ;; |
|||
*) AC_MSG_ERROR(can only configure for one host and one target at a time) ;; |
|||
esac |
|||
|
|||
tl_CANONICAL_HOST |
|||
tl_CANONICAL_TARGET |
|||
tl_CANONICAL_BUILD |
|||
test "$host_alias" != "$target_alias" && |
|||
test "$program_prefix$program_suffix$program_transform_name" = \ |
|||
NONENONEs,x,x, && |
|||
program_prefix=${target_alias}- |
|||
AC_CHECK_TOOL_PREFIX |
|||
]) |
|||
|
|||
dnl Subroutines of tl_CANONICAL_SYSTEM. |
|||
|
|||
AC_DEFUN(tl_CANONICAL_HOST, |
|||
[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl |
|||
AC_PROVIDE([AC_CANONICAL_HOST])dnl |
|||
|
|||
# Make sure we can run config.sub. |
|||
if $ac_config_sub sun4 >/dev/null 2>&1; then : |
|||
else AC_MSG_ERROR(can not run $ac_config_sub) |
|||
fi |
|||
|
|||
AC_MSG_CHECKING(host system type) |
|||
|
|||
dnl Set host_alias. |
|||
|
|||
if test "${GCC-no}" = "yes" -a "$nonopt" = "NONE"; then |
|||
changequote(, )dnl |
|||
libgcc="`${CC} --print-libgcc-file-name`" |
|||
host_alias="`expr ${libgcc} : '.*/gcc-lib/\([^/]*\)/.*'`" |
|||
case ${host_alias} in |
|||
*-linux{,elf,aout}) |
|||
host_alias="`echo ${host_alias} | sed 's/\([^-]*\)-linux.*/\1/'`" |
|||
changequote([, ])dnl |
|||
if ar p "${libgcc}" __main.o 2>/dev/null | file - 2>/dev/null | grep ELF >/dev/null; then |
|||
host_alias="${host_alias}-linux" |
|||
else |
|||
host_alias="${host_alias}-linuxaout" |
|||
fi ;; |
|||
esac |
|||
host_guessed=y |
|||
else |
|||
host_alias=$host |
|||
case "$host_alias" in |
|||
NONE) |
|||
case "$nonopt" in |
|||
NONE) |
|||
if host_alias=`$ac_config_guess`; then host_guessed=y |
|||
else AC_MSG_ERROR(can not guess host type; you must specify one) |
|||
fi ;; |
|||
*) host_alias=$nonopt ;; |
|||
esac ;; |
|||
esac |
|||
fi |
|||
|
|||
dnl Set the other host vars. |
|||
changequote(<<, >>)dnl |
|||
host=`$ac_config_sub $host_alias` |
|||
host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` |
|||
host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` |
|||
host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` |
|||
changequote([, ])dnl |
|||
AC_MSG_RESULT($host) |
|||
AC_SUBST(host)dnl |
|||
AC_SUBST(host_alias)dnl |
|||
AC_SUBST(host_cpu)dnl |
|||
AC_SUBST(host_vendor)dnl |
|||
AC_SUBST(host_os)dnl |
|||
]) |
|||
|
|||
dnl Internal use only. |
|||
AC_DEFUN(tl_CANONICAL_TARGET, |
|||
[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl |
|||
AC_REQUIRE([AC_PROG_CC])dnl |
|||
AC_REQUIRE([AC_CANONICAL_HOST])dnl |
|||
AC_PROVIDE([AC_CANONICAL_TARGET])dnl |
|||
AC_MSG_CHECKING(target system type) |
|||
|
|||
dnl Set target_alias. |
|||
target_alias=$target |
|||
case "$target_alias" in |
|||
NONE) |
|||
case $nonopt in |
|||
NONE) |
|||
target_cpu="`dpkg --print-architecture`" |
|||
if test "$target_cpu" = ""; then |
|||
target_alias=$host_alias |
|||
else |
|||
target_alias="`echo ${host_alias} | sed 's/[^-]*-/${target_cpu}-/'`" |
|||
fi |
|||
;; |
|||
*) target_alias=$nonopt ;; |
|||
esac ;; |
|||
esac |
|||
|
|||
dnl Set the other target vars. |
|||
if test $target_alias = $host_alias; then |
|||
target=$host |
|||
target_cpu=$host_cpu |
|||
target_vendor=$host_vendor |
|||
target_os=$host_os |
|||
elif test $target_alias = "$build_alias"; then |
|||
target=$build |
|||
target_cpu=$build_cpu |
|||
target_vendor=$build_vendor |
|||
target_os=$build_os |
|||
else |
|||
changequote(<<, >>)dnl |
|||
target=`$ac_config_sub $target_alias` |
|||
target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` |
|||
target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` |
|||
target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` |
|||
changequote([, ])dnl |
|||
fi |
|||
AC_MSG_RESULT($target) |
|||
AC_SUBST(target)dnl |
|||
AC_SUBST(target_alias)dnl |
|||
AC_SUBST(target_cpu)dnl |
|||
AC_SUBST(target_vendor)dnl |
|||
AC_SUBST(target_os)dnl |
|||
]) |
|||
|
|||
AC_DEFUN(tl_CANONICAL_BUILD, |
|||
[AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl |
|||
AC_REQUIRE([AC_CANONICAL_HOST])dnl |
|||
AC_PROVIDE([AC_CANONICAL_BUILD])dnl |
|||
|
|||
# Make sure we can run config.sub. |
|||
#if $ac_config_sub sun4 >/dev/null 2>&1; then : |
|||
#else AC_MSG_ERROR(can not run $ac_config_sub) |
|||
#fi |
|||
|
|||
AC_MSG_CHECKING(build system type) |
|||
|
|||
dnl Set build_alias. |
|||
build_alias=$build |
|||
case "$build_alias" in |
|||
NONE) |
|||
case $nonopt in |
|||
NONE) |
|||
if test "$host_guessed" = "y"; then |
|||
build_alias=$host_alias |
|||
else |
|||
if build_alias=`$ac_config_guess`; then : |
|||
else build_alias=$host_alias |
|||
fi |
|||
fi ;; |
|||
*) build_alias=$nonopt ;; |
|||
esac ;; |
|||
esac |
|||
|
|||
dnl Set the other build vars. |
|||
if test $build_alias = $host_alias; then |
|||
build=$host |
|||
build_cpu=$host_cpu |
|||
build_vendor=$host_vendor |
|||
build_os=$host_os |
|||
else |
|||
changequote(<<, >>)dnl |
|||
build=`$ac_config_sub $build_alias` |
|||
build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` |
|||
build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` |
|||
build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` |
|||
changequote([, ])dnl |
|||
fi |
|||
AC_MSG_RESULT($build) |
|||
AC_SUBST(build)dnl |
|||
AC_SUBST(build_alias)dnl |
|||
AC_SUBST(build_cpu)dnl |
|||
AC_SUBST(build_vendor)dnl |
|||
AC_SUBST(build_os)dnl |
|||
]) |
|||
@ -1,231 +1,75 @@ |
|||
# tl_CHECK_TOOL_PREFIX will work _BEFORE_ AC_CANONICAL_HOST, etc., has been |
|||
# called. It should be called again after these have been called. |
|||
# |
|||
# Basically we want to check if the host alias specified by the user is |
|||
# different from the build alias. The rules work like this:- |
|||
# |
|||
# If host is not specified, it defaults to NONOPT |
|||
# If build is not specified, it defaults to NONOPT |
|||
# If nonopt is not specified, we guess all other values |
|||
|
|||
dnl Replace AC_CHECK_TOOL_PREFIX |
|||
undefine([AC_CHECK_TOOL_PREFIX]) |
|||
define([AC_CHECK_TOOL_PREFIX], [tl_CHECK_TOOL_PREFIX]) |
|||
|
|||
AC_DEFUN(tl_CHECK_TOOL_PREFIX, |
|||
[AC_PROVIDE([AC_CHECK_TOOL_PREFIX]) |
|||
AC_BEFORE([AC_CANONICAL_HOST]) |
|||
AC_BEFORE([AC_CANONICAL_BUILD]) |
|||
dnl Quick check |
|||
if test "$host_alias" = ""; then |
|||
if test $host = NONE; then |
|||
thost=$nonopt |
|||
else |
|||
thost=$host |
|||
fi |
|||
if test $thost != $build -a $thost != NONE; then |
|||
ac_tool_prefix=${thost}- |
|||
ac_tool_dir=${thost} |
|||
else |
|||
ac_tool_prefix= |
|||
ac_tool_dir= |
|||
fi |
|||
else |
|||
if test $host != $build; then |
|||
ac_tool_prefix=${host_alias}- |
|||
ac_tool_dir=${host_alias} |
|||
else |
|||
ac_tool_prefix= |
|||
ac_tool_dir= |
|||
fi |
|||
fi |
|||
]) |
|||
|
|||
dnl replacement for AC_CHECK_TOOL |
|||
undefine([AC_CHECK_TOOL]) |
|||
define([AC_CHECK_TOOL], [tl_CHECK_TOOL($1, $2, $3, $4)]) |
|||
|
|||
dnl tl_CHECK_TOOL - AC_CHECK_TOOL, with a couple of extra checks |
|||
dnl tl_CHECK_TOOL(VARIABLE, PROG-TO-CHECK-FOR[, VALUE-IF-NOT-FOUND [, PATH |
|||
dnl [, REJECT]]) |
|||
AC_DEFUN(tl_CHECK_TOOL, |
|||
[AC_REQUIRE([AC_CHECK_TOOL_PREFIX]) |
|||
AC_CHECK_PROG($1, ${ac_tool_prefix}$2, ${ac_tool_prefix}$2, |
|||
ifelse([$3], , [$2], ), $4, $5) |
|||
if test -z "$ac_cv_prog_$1_dir";then ac_cv_prog_$1_dir=""; fi |
|||
if test "$ac_tool_dir" != ""; then |
|||
if test -z "$ac_cv_prog_$1" -a "$5" != "/usr/${ac_tool_dir}/bin/$2" -a \ |
|||
"$5" != "/usr/local/${ac_tool_dir}/bin/$2"; then |
|||
if test -f /usr/${ac_tool_dir}/bin/$2; then $1="/usr/${ac_tool_dir}/bin/$2"; ac_cv_prog_$1_dir=/usr/${ac_tool_dir} |
|||
elif test -f /usr/local/${ac_tool_dir}/bin/$2; then $1="/usr/local/${ac_tool_dir}/bin/$2"; ac_cv_prog_$1_dir=/usr/local/${ac_tool_dir} |
|||
fi |
|||
fi |
|||
fi |
|||
ifelse([$3], , , [ |
|||
if test -z "$ac_cv_prog_$1"; then |
|||
if test -n "$ac_tool_prefix"; then |
|||
AC_CHECK_PROG($1, $2, $2, $3, $4, $5) |
|||
else |
|||
$1="$3" |
|||
fi |
|||
fi]) |
|||
]) |
|||
|
|||
dnl tl_CHECK_TOOLS - |
|||
dnl do a tl_CHECK_TOOL for multiple tools (like AC_CHECK_PROGS) |
|||
dnl tl_CHECK_TOOLS(VARIABLE, PROGS-TO-CHECK-FOR [, VALUE-IF-NOT-FOUND |
|||
dnl [, PATH]]) |
|||
AC_DEFUN(tl_CHECK_TOOLS, |
|||
[for ac_tool in $2 |
|||
do |
|||
tl_CHECK_TOOL($1, [$]ac_tool, [$]ac_tool, , $4) |
|||
test -n "[$]$1" && break |
|||
done |
|||
ifelse([$3], , , [test -n "[$]$1" || $1="$3" |
|||
])]) |
|||
|
|||
dnl replace AC_PROG_CC and AC_PROG_CXX |
|||
undefine([AC_PROG_CC]) |
|||
define([AC_PROG_CC], [tl_PROG_CC]) |
|||
undefine([AC_PROG_CXX]) |
|||
define([AC_PROG_CXX], [tl_PROG_CXX]) |
|||
|
|||
dnl tl_PROG_CC, tl_PROG_CXX - same as old AC_PROG_CC and AC_PROG_CXX, but |
|||
dnl use AC_CHECK_TOOL/tl_CHECK_TOOLS instead of AC_CHECK_PROG, etc. |
|||
AC_DEFUN(tl_PROG_CC, |
|||
[AC_BEFORE([$0], [AC_PROG_CPP])dnl |
|||
AC_PROVIDE([AC_PROG_CC])dnl |
|||
tl_CHECK_TOOL(CC, gcc, gcc) |
|||
if test -z "$CC"; then |
|||
AC_CHECK_TOOL(CC, cc, cc, , , /usr/ucb/cc) |
|||
test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH]) |
|||
fi |
|||
if test -n "$ac_tool_prefix" -a "`echo $CC | grep '$ac_tool_prefix'`" = "" \ |
|||
-a "`echo $CC | grep -- '-b'`" = ""; then |
|||
if test -z "$ac_cv_prog_CC_dir" && $CC -v 2>&1 | grep gcc >/dev/null 2>&1 ; then |
|||
AC_CACHE_CHECK([if $CC -b${ac_tool_dir} works], tl_cv_prog_cc_bhost,[ |
|||
old_cc="${CC}" |
|||
CC="${CC} -b${ac_tool_dir}" |
|||
AC_LANG_SAVE |
|||
AC_LANG_C |
|||
AC_TRY_COMPILER([main(){return(0);}], tl_cv_prog_cc_bhost, ac_cv_prog_cc_cross) |
|||
AC_LANG_RESTORE]) |
|||
if test $tl_cv_prog_cc_bhost = "yes"; then |
|||
ac_cv_prog_cc_works=yes |
|||
cctest=yes |
|||
else |
|||
CC="${old_cc}" |
|||
fi |
|||
fi |
|||
fi |
|||
|
|||
if test "$cctest" != "yes"; then |
|||
tl_PROG_CC_WORKS |
|||
fi |
|||
AC_PROG_CC_GNU |
|||
|
|||
if test $ac_cv_prog_gcc = yes; then |
|||
GCC=yes |
|||
dnl Check whether -g works, even if CFLAGS is set, in case the package |
|||
dnl plays around with CFLAGS (such as to build both debugging and |
|||
dnl normal versions of a library), tasteless as that idea is. |
|||
ac_test_CFLAGS="${CFLAGS+set}" |
|||
ac_save_CFLAGS="$CFLAGS" |
|||
CFLAGS= |
|||
AC_PROG_CC_G |
|||
if test "$ac_test_CFLAGS" = set; then |
|||
CFLAGS="$ac_save_CFLAGS" |
|||
elif test $ac_cv_prog_cc_g = yes; then |
|||
CFLAGS="-g -O2" |
|||
else |
|||
CFLAGS="-O2" |
|||
fi |
|||
else |
|||
GCC= |
|||
test "${CFLAGS+set}" = set || CFLAGS="-g" |
|||
fi |
|||
AC_DEFUN(ah_HAVE_GETCONF, |
|||
[AC_ARG_WITH(getconf, |
|||
[ --with-getconf Enable automagical buildtime configuration], |
|||
[if test "$withval" = "yes"; then |
|||
AC_PATH_PROG(GETCONF, getconf) |
|||
elif test ! "$withval" = "no";then |
|||
AC_MSG_CHECKING([getconf]) |
|||
AC_MSG_RESULT([$withval]) |
|||
GETCONF=$withval |
|||
fi], |
|||
[AC_PATH_PROG(GETCONF, getconf)] |
|||
) |
|||
AC_SUBST(GETCONF) |
|||
]) |
|||
|
|||
AC_DEFUN(tl_PROG_CXX, |
|||
[AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl |
|||
AC_PROVIDE([AC_PROG_CXX])dnl |
|||
tl_CHECK_TOOLS(CXX, $CCC c++ g++ gcc CC cxx cc++, gcc) |
|||
if test -n "$CXX"; then |
|||
if test -n "$ac_tool_prefix" -a "`echo $CXX | grep '$ac_tool_prefix'`" = "" \ |
|||
-a "`echo $CXX | grep -- '-b'`" = ""; then |
|||
if test -z "$ac_cv_prog_CXX_dir" && $CXX -v 2>&1 | grep gcc >/dev/null 2>&1; then |
|||
AC_CACHE_CHECK([if $CXX -b${ac_tool_dir} works], tl_cv_prog_cxx_bhost,[ |
|||
old_cxx="${CXX}" |
|||
CXX="${CXX} -b${ac_tool_dir}" |
|||
AC_LANG_SAVE |
|||
AC_LANG_CPLUSPLUS |
|||
AC_TRY_COMPILER([main(){return(0);}], tl_cv_prog_cxx_bhost, ac_cv_prog_cxx_cross) |
|||
AC_LANG_RESTORE]) |
|||
if test $tl_cv_prog_cxx_bhost = "yes"; then |
|||
ac_cv_prog_cxx_works=yes |
|||
cxxtest=yes |
|||
else |
|||
CXX="${old_cxx}" |
|||
fi |
|||
fi |
|||
fi |
|||
|
|||
if test "$cxxtest" != "yes"; then |
|||
tl_PROG_CXX_WORKS |
|||
fi |
|||
AC_PROG_CXX_GNU |
|||
|
|||
if test $ac_cv_prog_gxx = yes; then |
|||
GXX=yes |
|||
dnl Check whether -g works, even if CXXFLAGS is set, in case the package |
|||
dnl plays around with CXXFLAGS (such as to build both debugging and |
|||
dnl normal versions of a library), tasteless as that idea is. |
|||
ac_test_CXXFLAGS="${CXXFLAGS+set}" |
|||
ac_save_CXXFLAGS="$CXXFLAGS" |
|||
CXXFLAGS= |
|||
AC_PROG_CXX_G |
|||
if test "$ac_test_CXXFLAGS" = set; then |
|||
CXXFLAGS="$ac_save_CXXFLAGS" |
|||
elif test $ac_cv_prog_cxx_g = yes; then |
|||
CXXFLAGS="-g -O2" |
|||
else |
|||
CXXFLAGS="-O2" |
|||
fi |
|||
else |
|||
GXX= |
|||
test "${CXXFLAGS+set}" = set || CXXFLAGS="-g" |
|||
fi |
|||
fi |
|||
AC_DEFUN(ah_NUM_CPUS, |
|||
[AC_REQUIRE([ah_HAVE_GETCONF]) |
|||
AC_MSG_CHECKING([number of cpus]) |
|||
AC_ARG_WITH(cpus, |
|||
[ --with-cpus The number of cpus to be used for building(see --with-procs, default 1)], |
|||
[if test "$withval" = "yes"; then |
|||
if test "$GETCONF";then |
|||
NUM_CPUS=`$GETCONF _NPROCESSORS_ONLN 2>/dev/null` |
|||
else |
|||
NUM_CPUS=1 |
|||
fi |
|||
elif test ! "$withval" = "no";then |
|||
NUM_CPUS=$withval |
|||
fi], |
|||
[if test "$GETCONF";then |
|||
NUM_CPUS=`$GETCONF _NPROCESSORS_ONLN 2>/dev/null` |
|||
else |
|||
NUM_CPUS=1 |
|||
fi] |
|||
) |
|||
if test $NUM_CPUS = 1 ;then |
|||
default_PROC_MULTIPLY=1 |
|||
else |
|||
default_PROC_MULTIPLY=2 |
|||
fi |
|||
AC_MSG_RESULT([$NUM_CPUS]) |
|||
AC_SUBST(NUM_CPUS) |
|||
]) |
|||
|
|||
AC_DEFUN(tl_PROG_CC_WORKS, |
|||
[AC_PROVIDE(AC_PROG_CC_WORKS) |
|||
AC_CACHE_CHECK([whether the C compiler ($CC $CFLAGS $LDFLAGS) works], |
|||
ac_cv_prog_cc_works, [ |
|||
AC_LANG_SAVE |
|||
AC_LANG_C |
|||
AC_TRY_COMPILER([main(){return(0);}], ac_cv_prog_cc_works, ac_cv_prog_cc_cross) |
|||
AC_LANG_RESTORE |
|||
if test $ac_cv_prog_cc_works = no; then |
|||
AC_MSG_ERROR([installation or configuration problem: C compiler cannot create executables.]) |
|||
fi]) |
|||
AC_MSG_CHECKING([whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler]) |
|||
AC_MSG_RESULT($ac_cv_prog_cc_cross) |
|||
cross_compiling=$ac_cv_prog_cc_cross |
|||
AC_DEFUN(ah_PROC_MULTIPLY, |
|||
[AC_REQUIRE([ah_NUM_CPUS]) |
|||
AC_MSG_CHECKING([processor multiplier]) |
|||
AC_ARG_WITH(proc-multiply, |
|||
[ --with-proc-multiply Multiply this * number of cpus for parallel making(default 2).], |
|||
[if test "$withval" = "yes"; then |
|||
PROC_MULTIPLY=$default_PROC_MULTIPLY |
|||
elif test ! "$withval" = "no";then |
|||
PROC_MULTIPLY=$withval |
|||
fi], |
|||
[PROC_MULTIPLY=$default_PROC_MULTIPLY] |
|||
) |
|||
AC_MSG_RESULT([$PROC_MULTIPLY]) |
|||
AC_SUBST(PROC_MULTIPLY) |
|||
]) |
|||
|
|||
AC_DEFUN(tl_PROG_CXX_WORKS, |
|||
[AC_PROVIDE(AC_PROG_CXX_WORKS) |
|||
AC_CACHE_CHECK([whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) works], |
|||
ac_cv_prog_cxx_works, [ |
|||
AC_LANG_SAVE |
|||
AC_LANG_CPLUSPLUS |
|||
AC_TRY_COMPILER([main(){return(0);}], ac_cv_prog_cxx_works, ac_cv_prog_cxx_cross) |
|||
AC_LANG_RESTORE |
|||
if test $ac_cv_prog_cxx_works = no; then |
|||
AC_MSG_ERROR([installation or configuration problem: C++ compiler cannot create executables.]) |
|||
fi]) |
|||
AC_MSG_CHECKING([whether the C++ compiler ($CXX $CXXFLAGS $LDFLAGS) is a cross-compiler]) |
|||
AC_MSG_RESULT($ac_cv_prog_cxx_cross) |
|||
cross_compiling=$ac_cv_prog_cxx_cross |
|||
AC_DEFUN(ah_NUM_PROCS, |
|||
[AC_REQUIRE([ah_PROC_MULTIPLY]) |
|||
AC_REQUIRE([ah_NUM_CPUS]) |
|||
AC_MSG_CHECKING([number of processes to run during make]) |
|||
AC_ARG_WITH(procs, |
|||
[ --with-procs The number of processes to run in parallel during make(num_cpus * multiplier).], |
|||
[if test "$withval" = "yes"; then |
|||
let "NUM_PROCS=$NUM_CPUS*$PROC_MULTIPLY" |
|||
elif test ! "$withval" = "no";then |
|||
NUM_PROCS=$withval |
|||
fi], |
|||
[let "NUM_PROCS=$NUM_CPUS*$PROC_MULTIPLY"] |
|||
) |
|||
AC_MSG_RESULT([$NUM_PROCS]) |
|||
AC_SUBST(NUM_PROCS) |
|||
]) |
|||
|
|||
Loading…
Reference in new issue