dnl
dnl/*D
dnl AC_CACHE_LOAD - Replacement for autoconf cache load
dnl
dnl Notes:
dnl Caching in autoconf is broken (at least through version 2.13).
dnl The problem is that the cache is read
dnl without any check for whether it makes any sense to read it.
dnl A common problem is a build on a shared file system; connecting to
dnl a different computer and then building within the same directory will
dnl lead to at best error messages from configure and at worse a build that
dnl is wrong but fails only at run time (e.g., wrong datatype sizes used).
dnl Later versions of autoconf do include some checks for changes in the
dnl environment that impact the choices, but still misses problems with
dnl multiple different systems.
dnl
dnl This fixes that by requiring the user to explicitly enable caching
dnl before the cache file will be loaded.
dnl
dnl To use this version of 'AC_CACHE_LOAD', you need to include
dnl 'aclocal_cache.m4' in your 'aclocal.m4' file. The sowing 'aclocal.m4'
dnl file includes this file.
dnl
dnl If no --enable-cache or --disable-cache option is selected, the
dnl command causes configure to keep track of the system being configured
dnl in a config.system file; if the current system matches the value stored
dnl in that file (or there is neither a config.cache nor config.system file),
dnl configure will enable caching. In order to ensure that the configure
dnl tests make sense, the values of CC, F77, F90, and CXX are also included
dnl in the config.system file. In addition, the value of PATH is included
dnl to ensure that changes in the PATH that might select a different version
dnl of a program with the same name (such as a native make versus gnumake)
dnl are detected.
dnl
dnl Bugs:
dnl This does not work with the Cygnus configure because the enable arguments
dnl are processed *after* AC_CACHE_LOAD (!). To address this, we avoid
dnl changing the value of enable_cache, and use real_enable_cache, duplicating
dnl the "notgiven" value.
dnl
dnl The environment variable CONFIGURE_DEBUG_CACHE, if set to yes,
dnl will cause additional data to be written out during the configure process.
dnl This can be helpful in debugging the cache file process.
dnl
dnl See Also:
dnl PAC_ARG_CACHING
dnl D*/
define([AC_CACHE_LOAD],
[if test "$CONFIGURE_DEBUG_CACHE" = yes ; then
oldopts="$-"
clearMinusX=no
set -x
if test "$oldopts" != "$-" ; then
clearMinusX=yes
fi
fi
if test "X$cache_system" = "X" ; then
# A default file name, just in case
cache_system="config.system"
if test "$cache_file" != "/dev/null" ; then
# Get the directory for the cache file, if any
changequote(,)
dnl Be careful to ensure that there is no doubled slash
cache_system=`echo $cache_file | sed -e 's%^\(.*/\)[^/]*%\1config.system%'`
changequote([,])
test "x$cache_system" = "x$cache_file" && cache_system="config.system"
# else
# We must *not* set enable_cache to no because we need to know if
# enable_cache was not set.
# enable_cache=no
fi
fi
dnl
dnl The "action-if-not-given" part of AC_ARG_ENABLE is not executed until
dnl after the AC_CACHE_LOAD is executed (!). Thus, the value of
dnl enable_cache if neither --enable-cache or --disable-cache is selected
dnl is null. Just in case autoconf ever fixes this, we test both cases.
dnl
dnl Include PATH in the cache.system file since changing the path can
dnl change which versions of programs are found (such as vendor make
dnl or GNU make).
dnl
#
# Get a test value and flag whether we should remove/replace the
# cache_system file (do so unless cache_system_ok is yes)
# FC and F77 should be synonyms. Save both in case
# We include the xxxFLAGS in case the user is using the flags to change
# the language (either input or output) of the compiler. E.g.,
# using -xarch=v9 on Solaris to select 64 bit output or using -D_BSD_SOURCE
# with gcc to get different header files on input.
cleanargs=`echo "$CC $F77 $FC $CXX $F90 $CFLAGS $FFLAGS $CXXFLAGS $F90FLAGS $PATH" | tr '"' ' '`
if uname -srm >/dev/null 2>&1 ; then
cache_system_text="`uname -srm` $cleanargs"
else
cache_system_text="-no-uname- $cleanargs"
fi
cache_system_ok=no
#
if test -z "$real_enable_cache" ; then
real_enable_cache=$enable_cache
if test -z "$real_enable_cache" ; then real_enable_cache="notgiven" ; fi
fi
if test "X$real_enable_cache" = "Xnotgiven" ; then
# check for valid cache file
if test -z "$cache_system" ; then cache_system="config.system" ; fi
if uname -srm >/dev/null 2>&1 ; then
if test -f "$cache_system" -a -n "$cache_system_text" ; then
if test "$cache_system_text" = "`cat $cache_system`" ; then
real_enable_cache="yes"
cache_system_ok=yes
fi
elif test ! -f "$cache_system" -a -n "$cache_system_text" ; then
# remove the cache file because it may not correspond to our
# system
if test "$cache_file" != "/dev/null" ; then
rm -f $cache_file
fi
real_enable_cache="yes"
fi
fi
fi
if test "X$real_enable_cache" = "Xyes" -a "$cache_file" = "/dev/null" ; then
real_enable_cache=no
fi
if test "X$real_enable_cache" = "Xyes" ; then
if test -r "$cache_file" ; then
echo "loading cache $cache_file"
if test -w "$cache_file" ; then
# Clean the cache file (ergh)
PAC_CACHE_CLEAN
fi
. $cache_file
else
echo "Configure in `pwd` creating cache $cache_file"
> $cache_file
rm -f $cache_system
fi
else
cache_file="/dev/null"
fi
# Remember our location and the name of the cachefile
pac_cv_my_conf_dir=`pwd`
dnl do not include the cachefile name, since this may contain the process
dnl number and cause comparisons looking for changes to the cache file
dnl to detect a change that isn't real.
dnl pac_cv_my_cachefile=$cachefile
#
# Update the cache_system file if necessary
if test "$cache_system_ok" != yes ; then
if test -n "$cache_system" ; then
rm -f $cache_system
echo $cache_system_text > $cache_system
fi
fi
if test "$clearMinusX" = yes ; then
set +x
fi
])
dnl
dnl/*D
dnl PAC_ARG_CACHING - Enable caching of results from a configure execution
dnl
dnl Synopsis:
dnl PAC_ARG_CACHING
dnl
dnl Output Effects:
dnl Adds '--enable-cache' and '--disable-cache' to the command line arguments
dnl accepted by 'configure'.
dnl
dnl See Also:
dnl AC_CACHE_LOAD
dnl D*/
dnl Add this call to the other ARG_ENABLE calls. Note that the values
dnl set here are redundant; the LOAD_CACHE call relies on the way autoconf
dnl initially processes ARG_ENABLE commands.
AC_DEFUN([PAC_ARG_CACHING],[
AC_ARG_ENABLE(cache,
AC_HELP_STRING([--enable-cache], [Turn on configure caching]),,
[enable_cache="notgiven"])
])
dnl Clean the cache of extraneous quotes that AC_CACHE_SAVE may add
dnl
AC_DEFUN([PAC_CACHE_CLEAN],[
rm -f confcache
sed -e "s/'\\\\''//g" -e "s/'\\\\/'/" -e "s/\\\\'/'/" \
-e "s/'\\\\''//g" $cache_file > confcache
if cmp -s $cache_file confcache ; then
:
else
if test -w $cache_file ; then
echo "updating cache $cache_file"
cat confcache > $cache_file
else
echo "not updating unwritable cache $cache_file"
fi
fi
rm -f confcache
if test "$DEBUG_AUTOCONF_CACHE" = "yes" ; then
echo "Results of cleaned cache file:"
echo "--------------------------------------------------------"
cat $cache_file
echo "--------------------------------------------------------"
fi
])
dnl/*D
dnl PAC_SUBDIR_CACHE - Create a cache file before ac_output for subdirectory
dnl configures.
dnl
dnl Synopsis:
dnl PAC_SUBDIR_CACHE(when)
dnl
dnl Input Parameter:
dnl . when - Indicates when the cache should be created (optional)
dnl If 'always', create a new cache file. This option
dnl should be used if any of the cache parameters (such as
dnl CFLAGS or LDFLAGS) may have changed.
dnl
dnl Output Effects:
dnl
dnl Create a cache file before ac_output so that subdir configures don't
dnl make mistakes.
dnl We can't use OUTPUT_COMMANDS to remove the cache file, because those
dnl commands are executed *before* the subdir configures.
dnl
dnl D*/
AC_DEFUN([PAC_SUBDIR_CACHE],[])
AC_DEFUN([PAC_SUBDIR_CACHE_OLD],[
if test "x$1" = "xalways" -o \( "$cache_file" = "/dev/null" -a "X$real_enable_cache" = "Xnotgiven" \) ; then
# Use an absolute directory to help keep the subdir configures from getting
# lost
cache_file=`pwd`/$$conf.cache
touch $cache_file
dnl
dnl For Autoconf 2.52+, we should ensure that the environment is set
dnl for the cache. Make sure that we get the values and set the
dnl xxx_set variables properly
ac_cv_env_CC_set=set
ac_cv_env_CC_value=$CC
ac_cv_env_CFLAGS_set=${CFLAGS+set}
ac_cv_env_CFLAGS_value=$CFLAGS
ac_cv_env_CPP_set=set
ac_cv_env_CPP_value=$CPP
ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
ac_cv_env_CPPFLAGS_value=$CPPFLAGS
ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
ac_cv_env_LDFLAGS_value=$LDFLAGS
ac_cv_env_LIBS_set=${LIBS+set}
ac_cv_env_LIBS_value=$LIBS
ac_cv_env_FC_set=${FC+set}
ac_cv_env_FC_value=$FC
ac_cv_env_F77_set=${F77+set}
ac_cv_env_F77_value=$F77
ac_cv_env_F90_set=${F90+set}
ac_cv_env_F90_value=$F90
ac_cv_env_FFLAGS_set=${FFLAGS+set}
ac_cv_env_FFLAGS_value=$FFLAGS
ac_cv_env_CXX_set=${CXX+set}
ac_cv_env_CXX_value=$CXX
ac_env_CC_set=set
ac_env_CC_value=$CC
ac_env_CFLAGS_set=${CFLAGS+set}
ac_env_CFLAGS_value=$CFLAGS
ac_env_CPP_set=set
ac_env_CPP_value=$CPP
ac_env_CPPFLAGS_set=${CPPFLAGS+set}
ac_env_CPPFLAGS_value=$CPPFLAGS
ac_env_LDFLAGS_set=${LDFLAGS+set}
ac_env_LDFLAGS_value=$LDFLAGS
ac_env_LIBS_set=${LIBS+set}
ac_env_LIBS_value=$LIBS
ac_env_FC_set=${FC+set}
ac_env_FC_value=$FC
ac_env_F77_set=${F77+set}
ac_env_F77_value=$F77
ac_env_F90_set=${F90+set}
ac_env_F90_value=$F90
ac_env_FFLAGS_set=${FFLAGS+set}
ac_env_FFLAGS_value=$FFLAGS
ac_env_CXX_set=${CXX+set}
ac_env_CXX_value=$CXX
dnl other parameters are
dnl build_alias, host_alias, target_alias
# It turns out that A C CACHE_SAVE can't be invoked more than once
# with data that contains blanks. What happens is that the quotes
# that it adds get quoted and then added again. To avoid this,
# we strip off the outer quotes for all cached variables
dnl We add pac_cv_my_conf_dir to give the source of this cachefile,
dnl and pac_cv_my_cachefile to indicate how it chose the cachefile.
pac_cv_my_conf_dir=`pwd`
pac_cv_my_cachefile=$cachefile
AC_CACHE_SAVE
PAC_CACHE_CLEAN
ac_configure_args="$ac_configure_args -enable-cache"
fi
dnl Unconditionally export these values. Subdir configures break otherwise
export CC
export CFLAGS
export LDFLAGS
export LIBS
export CPPFLAGS
export CPP
export FC
export F77
export F90
export CXX
export FFLAGS
export CCFLAGS
])
AC_DEFUN([PAC_SUBDIR_CACHE_CLEANUP],[])
AC_DEFUN([PAC_SUBDIR_CACHE_CLEANUP_OLD],[
if test "$cache_file" != "/dev/null" -a "X$real_enable_cache" = "Xnotgiven" ; then
rm -f $cache_file
cache_file=/dev/null
fi
])
dnl
dnl The following three macros support the sharing of configure results
dnl by configure scripts, including ones that are not run with
dnl AC_CONFIG_SUBDIRS (the cachefiles managed by --enable-cache can
dnl only be used with AC_CONFIG_SUBDIRS; creating a autoconf-style
dnl cachefile before the the end of the autoconf process will often
dnl cause problems.
dnl
AC_DEFUN([PAC_CREATE_BASE_CACHE],[
AC_ARG_ENABLE(base-cache,
AC_HELP_STRING([--enable-base-cache],
[Enable the use of a simple cache for the subsidiary
configure scripts]),,enable_base_cache=default)
# The default case is controlled by the environment variable CONF_USE_CACHEFILE
if test "$enable_base_cache" = "default" ; then
if test "$CONF_USE_CACHEFILE" = yes ; then
enable_base_cache=yes
else
enable_base_cache=no
fi
fi
if test "$enable_base_cache" != no ; then
if test "$enable_base_cache" = yes ; then
basecachefile=`pwd`/cache.base
else
basecachefile=`pwd`/$enable_base_cache
fi
set | grep ac_cv > $basecachefile
# Tell other configures to load this file
echo "Creating and exporting the base cache file $basecachefile"
CONF_BASE_CACHEFILE=$basecachefile
export CONF_BASE_CACHEFILE
fi
])
AC_DEFUN([PAC_LOAD_BASE_CACHE],[
if test -n "$CONF_BASE_CACHEFILE" -a -s "$CONF_BASE_CACHEFILE" ; then
echo "Loading base cachefile $CONF_BASE_CACHEFILE"
. $CONF_BASE_CACHEFILE
export CONF_BASE_CACHEFILE
fi
])
AC_DEFUN([PAC_UPDATE_BASE_CACHE],[
if test -n "$CONF_BASE_CACHEFILE" -a -s "$CONF_BASE_CACHEFILE" ; then
set | grep ac_cv > $CONF_BASE_CACHEFILE.new
if cmp -s $CONF_BASE_CACHEFILE.new $CONF_BASE_CACHEFILE ; then
:
else
echo "Replacing $CONF_BASE_CACHEFILE"
mv $CONF_BASE_CACHEFILE.new $CONF_BASE_CACHEFILE
fi
fi
])