configure.in

# initialize autoconf
AC_INIT()

# blurb
echo "vcl configure: CC=$CC"
echo "vcl configure: CCFLAGS=$CCFLAGS"
echo "vcl configure: CXX=$CXX"
echo "vcl configure: CXXFLAGS=$CXXFLAGS"
echo "vcl configure: TXXFLAGS=$TXXFLAGS"

## we need to use the scripts in ./shell
#no_we_dont AC_CONFIG_AUX_DIR(shell)

#--------------------------------------------------------------------------------
# COMPILERS

# check the C compiler
AC_PROG_CC

# check the Fortran compiler
F77="g77" # FIXME:autoconf 2.12 doesn't recognise AC_PROG_F77

# check the C++ compiler
AC_PROG_CXX

# check the C++ preprocessor
AC_PROG_CXXCPP

# remember these
given_CXXFLAGS="$CXXFLAGS"; export given_CXXFLAGS
given_TXXFLAGS="$TXXFLAGS"; export given_TXXFLAGS
#echo "Compiling non-template code  with: $CXX $CXXFLAGS";
#echo "Compiling template instances with: $CXX $TXXFLAGS";

## check for known compilers
#FMK_CXX_IS_EGCS
#FMK_CXX_IS_SUNPRO50
#FMK_CXX_IS_NATIVE_SGI7

#===========================================================================
# VXL STUFF

# from vcl/configure.in

#--------------------------------------------------------------------------------
# MANUAL OPTIONS

# use native STL? default is yes.
AC_ARG_ENABLE(emulation-stl,
[  --enable-emulation-stl  use the STL that comes with vcl],
[VCL_USE_NATIVE_STL=0],
[VCL_USE_NATIVE_STL=1])

# use native complex<>? default is yes.
AC_ARG_ENABLE(emulation-complex,
[  --enable-emulation-complex  use the complex<> that comes with vcl],
[VCL_USE_NATIVE_COMPLEX=0],
[VCL_USE_NATIVE_COMPLEX=1])

# use implicit template instantiation?
AC_ARG_ENABLE(implicit-templates,[
  --enable-implicit-templates        enable implicit template instantiation (default)
  --disable-implicit-templates       disable implicit template instantiation
],[
if test "$enable_implicit_templates" = yes; then
  VCL_USE_IMPLICIT_TEMPLATES=1
else
  VCL_USE_IMPLICIT_TEMPLATES=0
fi
export VCL_USE_IMPLICIT_TEMPLATES
],[
VCL_USE_IMPLICIT_TEMPLATES=1
export VCL_USE_IMPLICIT_TEMPLATES
])

# enable vnl bounds checking? default is yes.
AC_ARG_ENABLE(vnl_bounds_checking,[
  --enable-vnl-bounds-checking   enable bound checks in the vnl [] and () operators (default)
  --disable-vnl-bounds-checking  disable bound checks in the vnl [] and () operators],
[if test "$enable_vnl_bounds_checking" = yes; then
  VNL_CONFIG_CHECK_BOUNDS=1
else
  VNL_CONFIG_CHECK_BOUNDS=0
fi
export VNL_CONFIG_CHECK_BOUNDS
],[
VNL_CONFIG_CHECK_BOUNDS=1
export VNL_CONFIG_CHECK_BOUNDS
])

# enable certain old methods in vnl? default is no.
AC_ARG_ENABLE(vnl_legacy_methods,[
  --enable-vnl-legacy-methods   enable bound checks in the vnl [] and () operators (default)
  --disable-vnl-legacy-methods  disable bound checks in the vnl [] and () operators],
[if test "$enable_vnl_legacy_methods" = yes; then
  VNL_CONFIG_LEGACY_METHODS=1
else
  VNL_CONFIG_LEGACY_METHODS=0
fi
export VNL_CONFIG_LEGACY_METHODS
],[
VNL_CONFIG_LEGACY_METHODS=0
export VNL_CONFIG_LEGACY_METHODS
])

# enable thread safe code in vnl? default is yes.
AC_ARG_ENABLE(vnl_thread_safe,[
  --enable-vnl-thread-safe   enable bound checks in the vnl [] and () operators (default)
  --disable-vnl-thread-safe  disable bound checks in the vnl [] and () operators],
[if test "$enable_vnl_thread_safe" = yes; then
  VNL_CONFIG_THREAD_SAFE=1
else
  VNL_CONFIG_THREAD_SAFE=0
fi
export VNL_CONFIG_THREAD_SAFE
],[
VNL_CONFIG_THREAD_SAFE=1
export VNL_CONFIG_THREAD_SAFE
])

#--------------------------------------------------------------------------------
# COMPILER CHARACTERISTICS

# Try to figure out the type of compiler
#
AC_MSG_CHECKING("the C++ compiler type")

if   ( $CXX -v < /dev/null 2>&1 | grep 'gcc version' > /dev/null 2>&1); then
  compiler=gcc
  version=`$CXX -v < /dev/null 2>&1 | grep 'gcc version' | awk '{print $3}'`
elif ( $CXX -V < /dev/null 2>&1 | grep 'WorkShop' > /dev/null ); then
  compiler=workshop
  version=`$CXX -V < /dev/null 2>&1 | grep 'WorkShop' | awk '{print $4}'`
elif ( $CXX -version < /dev/null 2>&1 | grep 'MIPSpro' > /dev/null ); then
  compiler=mipspro
  version=`$CXX -version < /dev/null 2>&1 | grep 'MIPSpro' | awk '{print $4}'`
else
  compiler=unknown
  version=unknown
fi

AC_MSG_RESULT( $compiler version $version )

## syntax
VCL_CXX_HAS_BOOL
VCL_CXX_HAS_TYPENAME
VCL_CXX_HAS_EXPORT
VCL_CXX_HAS_MUTABLE
VCL_CXX_HAS_EXPLICIT
VCL_CXX_HAS_RTTI
VCL_CXX_HAS_DYNAMIC_CAST
VCL_CXX_CHECK_FOR_SCOPE
VCL_CXX_COMPLEX_POW_WORKS
VCL_CXX_DEFAULT_VALUE
VCL_CXX_HAS_MEMBER_TEMPLATES
VCL_CXX_CAN_DO_PARTIAL_SPECIALIZATION
VCL_CXX_DEFINE_SPECIALIZATION
VCL_CXX_CANNOT_SPECIALIZE_CV
VCL_CXX_ALLOWS_INLINE_INSTANTIATION
if test "$VCL_ALLOWS_INLINE_INSTANTIATION" = "1"; then
VCL_CXX_NEEDS_INLINE_INSTANTIATION
else
VCL_NEEDS_INLINE_INSTANTIATION=0;
export VCL_NEEDS_INLINE_INSTANTIATION;
fi
VCL_CXX_STATIC_CONST_INIT_INT
VCL_CXX_STATIC_CONST_INIT_NO_DEFN
VCL_CXX_STATIC_CONST_INIT_FLOAT
VCL_CXX_CAN_DO_STATIC_TEMPLATE_MEMBER
VCL_CXX_CAN_DO_NON_TYPE_FUNCTION_TEMPLATE_PARAMETER
VCL_CXX_NEED_FRIEND_FOR_TEMPLATE_OVERLOAD
VCL_CXX_OVERLOAD_CAST
VCL_CXX_NULL_TMPL_ARGS
VCL_CXX_NO_STATIC_DATA_MEMBERS
VCL_CXX_HAS_TEMPLATE_SYMBOLS
VCL_CXX_TEMPLATE_MATCHES_TOO_OFTEN
VCL_CXX_HAS_SLICED_DESTRUCTOR_BUG
VCL_CXX_CHAR_IS_SIGNED
VCL_CXX_NUMERIC_LIMITS_HAS_INFINITY
VCL_CXX_PROCESSOR_HAS_INFINITY
VCL_CXX_CAN_DO_IMPLICIT_TEMPLATES
if test "$VCL_CAN_DO_IMPLICIT_TEMPLATES" = "0" -a "$VCL_USE_IMPLICIT_TEMPLATES" = "1"; then
  echo "Warning: turning off implicit template instantiation";
  VCL_USE_IMPLICIT_TEMPLATES=0;
fi
#VCL_DFL_TYPE_PARAM_STLDECL
#VCL_DFL_TMPL_PARAM_STLDECL
#VCL_DFL_TMPL_ARG
VCL_CXX_CAN_DO_COMPLETE_DEFAULT_TYPE_PARAMETER
if test "$VCL_CAN_DO_COMPLETE_DEFAULT_TYPE_PARAMETER" = "1"; then
VCL_CXX_CAN_DO_TEMPLATE_DEFAULT_TYPE_PARAMETER
else
VCL_CAN_DO_TEMPLATE_DEFAULT_TYPE_PARAMETER=0;
export VCL_CAN_DO_TEMPLATE_DEFAULT_TYPE_PARAMETER;
fi
#VCL_CXX_DEFAULT_TMPL_ARG
VCL_CXX_SUNPRO_CLASS_SCOPE_HACK
VCL_CXX_HAS_EXCEPTIONS
VCL_CXX_HAS_NAMESPACES
VCL_CXX_ALLOWS_NAMESPACE_STD
if test "$VCL_ALLOWS_NAMESPACE_STD" = "1"; then
VCL_CXX_NEEDS_NAMESPACE_STD
else
VCL_NEEDS_NAMESPACE_STD=0; export VCL_NEEDS_NAMESPACE_STD
fi

## architecture
AC_C_BIGENDIAN
if test "$ac_cv_c_bigendian" = "yes"; then
  VCL_BIG_ENDIAN=1;
  VCL_LITTLE_ENDIAN=0;
else
  VCL_BIG_ENDIAN=0;
  VCL_LITTLE_ENDIAN=1;
fi
export VCL_BIG_ENDIAN
export VCL_LITTLE_ENDIAN

ifelse([],[],[
## standard header files.
VCL_CXX_HAS_HEADER(cassert,VCL_CXX_HAS_HEADER_CASSERT)
VCL_CXX_HAS_HEADER(ciso646,VCL_CXX_HAS_HEADER_CISO646)
VCL_CXX_HAS_HEADER(csetjmp,VCL_CXX_HAS_HEADER_CSETJMP)
VCL_CXX_HAS_HEADER(cstdio,VCL_CXX_HAS_HEADER_CSTDIO)
VCL_CXX_HAS_HEADER(ctime,VCL_CXX_HAS_HEADER_CTIME)
VCL_CXX_HAS_HEADER(cctype,VCL_CXX_HAS_HEADER_CCTYPE)
VCL_CXX_HAS_HEADER(climits,VCL_CXX_HAS_HEADER_CLIMITS)
VCL_CXX_HAS_HEADER(csignal,VCL_CXX_HAS_HEADER_CSIGNAL)
VCL_CXX_HAS_HEADER(cstdlib,VCL_CXX_HAS_HEADER_CSTDLIB)
VCL_CXX_HAS_HEADER(cwchar,VCL_CXX_HAS_HEADER_CWCHAR)
VCL_CXX_HAS_HEADER(cerrno,VCL_CXX_HAS_HEADER_CERRNO)
VCL_CXX_HAS_HEADER(clocale,VCL_CXX_HAS_HEADER_CLOCALE)
VCL_CXX_HAS_HEADER(cstdarg,VCL_CXX_HAS_HEADER_CSTDARG)
VCL_CXX_HAS_HEADER(cstring,VCL_CXX_HAS_HEADER_CSTRING)
VCL_CXX_HAS_HEADER(cwctype,VCL_CXX_HAS_HEADER_CWCTYPE)
VCL_CXX_HAS_HEADER(cfloat,VCL_CXX_HAS_HEADER_CFLOAT)
VCL_CXX_HAS_HEADER(cmath,VCL_CXX_HAS_HEADER_CMATH)
VCL_CXX_HAS_HEADER(cstddef,VCL_CXX_HAS_HEADER_CSTDDEF)
VCL_CXX_HAS_HEADER(algorithm,VCL_CXX_HAS_HEADER_ALGORITHM)
VCL_CXX_HAS_HEADER(iomanip,VCL_CXX_HAS_HEADER_IOMANIP)
VCL_CXX_HAS_HEADER(list,VCL_CXX_HAS_HEADER_LIST)
VCL_CXX_HAS_HEADER(ostream,VCL_CXX_HAS_HEADER_OSTREAM)
VCL_CXX_HAS_HEADER(streambuf,VCL_CXX_HAS_HEADER_STREAMBUF)
VCL_CXX_HAS_HEADER(bitset,VCL_CXX_HAS_HEADER_BITSET)
VCL_CXX_HAS_HEADER(ios,VCL_CXX_HAS_HEADER_IOS)
VCL_CXX_HAS_HEADER(locale,VCL_CXX_HAS_HEADER_LOCALE)
VCL_CXX_HAS_HEADER(queue,VCL_CXX_HAS_HEADER_QUEUE)
VCL_CXX_HAS_HEADER(string,VCL_CXX_HAS_HEADER_STRING)
VCL_CXX_HAS_HEADER(complex,VCL_CXX_HAS_HEADER_COMPLEX)
VCL_CXX_HAS_HEADER(iosfwd,VCL_CXX_HAS_HEADER_IOSFWD)
VCL_CXX_HAS_HEADER(map,VCL_CXX_HAS_HEADER_MAP)
VCL_CXX_HAS_HEADER(set,VCL_CXX_HAS_HEADER_SET)
VCL_CXX_HAS_HEADER(typeinfo,VCL_CXX_HAS_HEADER_TYPEINFO)
VCL_CXX_HAS_HEADER(deque,VCL_CXX_HAS_HEADER_DEQUE)
VCL_CXX_HAS_HEADER(iostream,VCL_CXX_HAS_HEADER_IOSTREAM)
VCL_CXX_HAS_HEADER(memory,VCL_CXX_HAS_HEADER_MEMORY)
VCL_CXX_HAS_HEADER(sstream,VCL_CXX_HAS_HEADER_SSTREAM)
VCL_CXX_HAS_HEADER(utility,VCL_CXX_HAS_HEADER_UTILITY)
VCL_CXX_HAS_HEADER(exception,VCL_CXX_HAS_HEADER_EXCEPTION)
VCL_CXX_HAS_HEADER(istream,VCL_CXX_HAS_HEADER_ISTREAM)
VCL_CXX_HAS_HEADER(new,VCL_CXX_HAS_HEADER_NEW)
VCL_CXX_HAS_HEADER(stack,VCL_CXX_HAS_HEADER_STACK)
VCL_CXX_HAS_HEADER(valarray,VCL_CXX_HAS_HEADER_VALARRAY)
VCL_CXX_HAS_HEADER(fstream,VCL_CXX_HAS_HEADER_FSTREAM)
VCL_CXX_HAS_HEADER(iterator,VCL_CXX_HAS_HEADER_ITERATOR)
VCL_CXX_HAS_HEADER(numeric,VCL_CXX_HAS_HEADER_NUMERIC)
VCL_CXX_HAS_HEADER(stdexcept,VCL_CXX_HAS_HEADER_STDEXCEPT)
VCL_CXX_HAS_HEADER(vector,VCL_CXX_HAS_HEADER_VECTOR)
VCL_CXX_HAS_HEADER(functional,VCL_CXX_HAS_HEADER_FUNCTIONAL)
VCL_CXX_HAS_HEADER(limits,VCL_CXX_HAS_HEADER_LIMITS)
VCL_CXX_HAS_HEADER(strstream,VCL_CXX_HAS_HEADER_STRSTREAM)
])

#--------------------------------------------------------------------------------
# SUBSTITUTIONS

# manual
AC_SUBST(VCL_USE_NATIVE_STL)
AC_SUBST(VCL_USE_NATIVE_COMPLEX)
AC_SUBST(VCL_USE_IMPLICIT_TEMPLATES)
AC_SUBST(VNL_CONFIG_CHECK_BOUNDS)
AC_SUBST(VNL_CONFIG_LEGACY_METHODS)
AC_SUBST(VNL_CONFIG_THREAD_SAFE)

# compiler
AC_SUBST(VCL_HAS_BOOL)
AC_SUBST(VCL_HAS_DYNAMIC_CAST)
AC_SUBST(VCL_HAS_RTTI)
AC_SUBST(VCL_HAS_TYPENAME)
AC_SUBST(VCL_HAS_EXPORT)
AC_SUBST(VCL_HAS_MUTABLE)
AC_SUBST(VCL_HAS_EXPLICIT)
AC_SUBST(VCL_STATIC_CONST_INIT_INT)
AC_SUBST(VCL_STATIC_CONST_INIT_NO_DEFN)
AC_SUBST(VCL_STATIC_CONST_INIT_FLOAT)
AC_SUBST(VCL_FOR_SCOPE_HACK)
AC_SUBST(VCL_HAS_MEMBER_TEMPLATES)
AC_SUBST(VCL_CAN_DO_PARTIAL_SPECIALIZATION)
AC_SUBST(VCL_ALLOWS_INLINE_INSTANTIATION)
AC_SUBST(VCL_NEEDS_INLINE_INSTANTIATION)
#AC_SUBST(VCL_DO_NOT_INSTANTIATE)
#AC_SUBST(VCL_UNINSTANTIATE_SPECIALIZATION)
#AC_SUBST(VCL_UNINSTANTIATE_UNSEEN_SPECIALIZATION) # dubious
AC_SUBST(VCL_CAN_DO_STATIC_TEMPLATE_MEMBER)
AC_SUBST(VCL_CAN_DO_NON_TYPE_FUNCTION_TEMPLATE_PARAMETER)
AC_SUBST(VCL_NEED_FRIEND_FOR_TEMPLATE_OVERLOAD)
AC_SUBST(VCL_OVERLOAD_CAST)
AC_SUBST(VCL_DEFINE_SPECIALIZATION)
AC_SUBST(VCL_CANNOT_SPECIALIZE_CV)
AC_SUBST(VCL_NULL_TMPL_ARGS)
AC_SUBST(VCL_COMPLEX_POW_WORKS)
AC_SUBST(VCL_DEFAULT_VALUE)
AC_SUBST(VCL_NO_STATIC_DATA_MEMBERS)
AC_SUBST(VCL_HAS_TEMPLATE_SYMBOLS)
AC_SUBST(VCL_TEMPLATE_MATCHES_TOO_OFTEN)
AC_SUBST(VCL_HAS_SLICED_DESTRUCTOR_BUG)
AC_SUBST(VCL_CHAR_IS_SIGNED)
AC_SUBST(VCL_NUMERIC_LIMITS_HAS_INFINITY)
AC_SUBST(VCL_PROCESSOR_HAS_INFINITY)
#
AC_SUBST(VCL_DEFAULT_TMPL_ARG)
AC_SUBST(VCL_CAN_DO_COMPLETE_DEFAULT_TYPE_PARAMETER)
AC_SUBST(VCL_CAN_DO_TEMPLATE_DEFAULT_TYPE_PARAMETER)
AC_SUBST(VCL_SUNPRO_CLASS_SCOPE_HACK)
#
AC_SUBST(VCL_HAS_EXCEPTIONS)
AC_SUBST(VCL_HAS_NAMESPACES)
AC_SUBST(VCL_ALLOWS_NAMESPACE_STD)
AC_SUBST(VCL_NEEDS_NAMESPACE_STD)
#
AC_SUBST(VCL_BIG_ENDIAN)
AC_SUBST(VCL_LITTLE_ENDIAN)

# standard header files.
AC_SUBST(VCL_CXX_HAS_HEADER_CASSERT)
AC_SUBST(VCL_CXX_HAS_HEADER_CISO646)
AC_SUBST(VCL_CXX_HAS_HEADER_CSETJMP)
AC_SUBST(VCL_CXX_HAS_HEADER_CSTDIO)
AC_SUBST(VCL_CXX_HAS_HEADER_CTIME)
AC_SUBST(VCL_CXX_HAS_HEADER_CCTYPE)
AC_SUBST(VCL_CXX_HAS_HEADER_CLIMITS)
AC_SUBST(VCL_CXX_HAS_HEADER_CSIGNAL)
AC_SUBST(VCL_CXX_HAS_HEADER_CSTDLIB)
AC_SUBST(VCL_CXX_HAS_HEADER_CWCHAR)
AC_SUBST(VCL_CXX_HAS_HEADER_CERRNO)
AC_SUBST(VCL_CXX_HAS_HEADER_CLOCALE)
AC_SUBST(VCL_CXX_HAS_HEADER_CSTDARG)
AC_SUBST(VCL_CXX_HAS_HEADER_CSTRING)
AC_SUBST(VCL_CXX_HAS_HEADER_CWCTYPE)
AC_SUBST(VCL_CXX_HAS_HEADER_CFLOAT)
AC_SUBST(VCL_CXX_HAS_HEADER_CMATH)
AC_SUBST(VCL_CXX_HAS_HEADER_CSTDDEF)
AC_SUBST(VCL_CXX_HAS_HEADER_ALGORITHM)
AC_SUBST(VCL_CXX_HAS_HEADER_IOMANIP)
AC_SUBST(VCL_CXX_HAS_HEADER_LIST)
AC_SUBST(VCL_CXX_HAS_HEADER_OSTREAM)
AC_SUBST(VCL_CXX_HAS_HEADER_STREAMBUF)
AC_SUBST(VCL_CXX_HAS_HEADER_BITSET)
AC_SUBST(VCL_CXX_HAS_HEADER_IOS)
AC_SUBST(VCL_CXX_HAS_HEADER_LOCALE)
AC_SUBST(VCL_CXX_HAS_HEADER_QUEUE)
AC_SUBST(VCL_CXX_HAS_HEADER_STRING)
AC_SUBST(VCL_CXX_HAS_HEADER_COMPLEX)
AC_SUBST(VCL_CXX_HAS_HEADER_IOSFWD)
AC_SUBST(VCL_CXX_HAS_HEADER_MAP)
AC_SUBST(VCL_CXX_HAS_HEADER_SET)
AC_SUBST(VCL_CXX_HAS_HEADER_TYPEINFO)
AC_SUBST(VCL_CXX_HAS_HEADER_DEQUE)
AC_SUBST(VCL_CXX_HAS_HEADER_IOSTREAM)
AC_SUBST(VCL_CXX_HAS_HEADER_MEMORY)
AC_SUBST(VCL_CXX_HAS_HEADER_SSTREAM)
AC_SUBST(VCL_CXX_HAS_HEADER_UTILITY)
AC_SUBST(VCL_CXX_HAS_HEADER_EXCEPTION)
AC_SUBST(VCL_CXX_HAS_HEADER_ISTREAM)
AC_SUBST(VCL_CXX_HAS_HEADER_NEW)
AC_SUBST(VCL_CXX_HAS_HEADER_STACK)
AC_SUBST(VCL_CXX_HAS_HEADER_VALARRAY)
AC_SUBST(VCL_CXX_HAS_HEADER_FSTREAM)
AC_SUBST(VCL_CXX_HAS_HEADER_ITERATOR)
AC_SUBST(VCL_CXX_HAS_HEADER_NUMERIC)
AC_SUBST(VCL_CXX_HAS_HEADER_STDEXCEPT)
AC_SUBST(VCL_CXX_HAS_HEADER_VECTOR)
AC_SUBST(VCL_CXX_HAS_HEADER_FUNCTIONAL)
AC_SUBST(VCL_CXX_HAS_HEADER_LIMITS)
AC_SUBST(VCL_CXX_HAS_HEADER_STRSTREAM)

# from vxl/configure.in

# fsm. after running glimpse, I can't find anywhere but
# vxl/vbl/vbl_timer.cxx which uses TWO_ARG_GETTIME. Can someone
# confirm that?
# If so, that would mean we can remove the makefile -D flags
# to do with time.
if test "$ac_twoarg_timeofday" = "yes"; then
  VXL_TWO_ARG_GETTIME=1
else
  VXL_TWO_ARG_GETTIME=0
fi

# fsm
VCL_CXX_HAS_HEADER(pthread.h,VXL_HAS_PTHREAD_H)
AC_SUBST(VXL_HAS_PTHREAD_H)
VCL_CXX_HAS_HEADER(semaphore.h,VXL_HAS_SEMAPHORE_H)
AC_SUBST(VXL_HAS_SEMAPHORE_H)
VXL_CXX_UNISTD
VXL_CXX_WORDS
VCL_CXX_HAS_HEADER(ieeefp.h,VXL_HAS_IEEEFP_H)
AC_SUBST(VXL_HAS_IEEEFP_H)
# brad king
VCL_CXX_HAS_HEADER(iso646.h,VCL_CXX_HAS_HEADER_ISO646_H)
AC_SUBST(VCL_CXX_HAS_HEADER_ISO646_H)

# these math functions are probably defined in libm, so make sure the
# library can be found before trying to link against it.
AC_CHECK_LIB(m,cos)
VXL_MATH_HAS_FINITEF
VXL_MATH_HAS_FINITE
VXL_MATH_HAS_FINITEL
VXL_MATH_HAS_SQRTF
VXL_IEEEFP_FINITE
VXL_STDLIB_RAND48
VXL_HAS_QSORT

# check for bigendian
AC_C_BIGENDIAN
if test $ac_cv_c_bigendian = no; then
  VXL_BIG_ENDIAN=0;
  VXL_LITTLE_ENDIAN=1;
else
  VXL_BIG_ENDIAN=1;
  VXL_LITTLE_ENDIAN=0;
fi

#--------------------------------------------------------------------------------
# complete list of substitutions:

# libraries
AC_SUBST(VXL_UNISTD_HAS_USECONDS_T)
AC_SUBST(VXL_UNISTD_HAS_INTPTR_T)
AC_SUBST(VXL_UNISTD_HAS_UALARM)
AC_SUBST(VXL_UNISTD_HAS_USLEEP)
AC_SUBST(VXL_UNISTD_HAS_LCHOWN)
AC_SUBST(VXL_UNISTD_HAS_PREAD)
AC_SUBST(VXL_UNISTD_HAS_PWRITE)
AC_SUBST(VXL_UNISTD_HAS_TELL)
AC_SUBST(VXL_STDLIB_HAS_QSORT)
AC_SUBST(VXL_STDLIB_HAS_LRAND48)
AC_SUBST(VXL_STDLIB_HAS_DRAND48)
AC_SUBST(VXL_STDLIB_HAS_SRAND48)
AC_SUBST(VXL_IEEEFP_HAS_FINITE)
AC_SUBST(VXL_C_MATH_HAS_FINITEF)
AC_SUBST(VXL_C_MATH_HAS_FINITE)
AC_SUBST(VXL_C_MATH_HAS_FINITEL)
AC_SUBST(VXL_C_MATH_HAS_SQRTF)
AC_SUBST(VXL_UNISTD_USLEEP_IS_VOID)
AC_SUBST(VXL_TWO_ARG_GETTIME)

# architecture
AC_SUBST(VXL_BIG_ENDIAN)
AC_SUBST(VXL_LITTLE_ENDIAN)
AC_SUBST(VXL_HAS_BYTE)
AC_SUBST(VXL_HAS_INT_8)
AC_SUBST(VXL_HAS_INT_16)
AC_SUBST(VXL_HAS_INT_32)
AC_SUBST(VXL_HAS_INT_64)
AC_SUBST(VXL_HAS_IEEE_32)
AC_SUBST(VXL_HAS_IEEE_64)
AC_SUBST(VXL_HAS_IEEE_96)
AC_SUBST(VXL_HAS_IEEE_128)
AC_SUBST(VXL_BYTE)
AC_SUBST(VXL_INT_8)
AC_SUBST(VXL_INT_16)
AC_SUBST(VXL_INT_32)
AC_SUBST(VXL_INT_64)
AC_SUBST(VXL_INT_64_IS_LONG)
AC_SUBST(VXL_IEEE_32)
AC_SUBST(VXL_IEEE_64)
AC_SUBST(VXL_IEEE_96)
AC_SUBST(VXL_IEEE_128)

CXXFLAGS=$given_CXXFLAGS
TXXFLAGS=$given_TXXFLAGS

AC_OUTPUT(
vcl/vcl_config_manual.h~:vcl/vcl_config_manual.h.in
vcl/vcl_config_compiler.h~:vcl/vcl_config_compiler.h.in
vcl/vcl_config_headers.h~:vcl/vcl_config_headers.h.in
core/vxl_config.h~:core/vxl_config.h.in
core/vnl/vnl_config.h~:core/vnl/vnl_config.h.in
)

# only touch files that actually change.
for f in "vcl/vcl_config_manual.h" "vcl/vcl_config_compiler.h" "vcl/vcl_config_headers.h" "core/vxl_config.h" "core/vnl/vnl_config.h"; do
  if test -f $f; then
    if diff ${f} ${f}~ 2>&1 >/dev/null ; then
      echo "no change to ${f}"
      rm -f ${f}~
    else
      echo "replacing old ${f}"
      mv -f ${f}~ ${f}
    fi
  else
    echo "creating new ${f}"
    mv -f ${f}~ ${f}
  fi
done

# END VXL STUFF
#=========================================================================