path: root/lib/make/configure.in

dnl @@
dnl    @file      configure.in
dnl    @date      Sun Jan 17 15:54:23 1999
dnl    @author    Tom Goodale
dnl    @desc 
dnl    
dnl    @enddesc 
dnl    @version $Id$
dnl  @@
dnl Process this file with autoconf to produce a configure script.

AC_REVISION($Id$)
AC_INIT()
AC_CONFIG_HEADER(config.h)

dnl Check the system type
AC_CANONICAL_SYSTEM

dnl Checks for programs.
AC_PROG_MAKE_SET

if test -z "$CC" ; then
AC_PROG_CC
fi

if test -z "$CXX" ; then
AC_PROG_CXX
fi

if test -z "$RANLIB" ; then
AC_PROG_RANLIB
fi

dnl Look for a standalone CPP

if test -z "$CPP" ; then
AC_PATH_PROGS(CPP, cpp, echo, /lib:/usr/lib:/usr/local/lib:$PATH)
fi

if test -z "$PERL" ; then
AC_PATH_PROGS(PERL, perl)
fi

if test -z "$F90" ; then
AC_PATH_PROGS(F90, f90 pgf90)
fi

if test -z "$F77" ; then
AC_PATH_PROGS(F77, f77 pgf77 g77 f90 pgf90)
fi

if test -z "$AR" ; then
AC_PATH_PROGS(AR, ar)
fi

if test -z "$MKDIR" ; then
AC_PATH_PROGS(MKDIR, mkdir)
fi

if test -z "$SHELL" ; then
AC_PATH_PROGS(SHELL, sh bash)
fi

if test -z "$LD" ; then
AC_SUBST(LD)
LD=$CXX
fi

# If this is a known architecture, setup any specific flags.
# This has to be done here as flags given to the compiler may
# change the things detected later.

# Create a file to put any #defines etc needed for this architecture
# known architecture stuff should use cat >> etc to append to this file.
cat > cctk_archdefs.h <<EOF
/* Stuff from known architectures */
#ifndef _CCTK_ARCHDEFS_H_
#define _CCTK_ARCHDEFS_H_
EOF

if test -r $srcdir/known-architectures/$host_os ; then
. $srcdir/known-architectures/$host_os
fi

# Finish the architecture stuff
cat >> cctk_archdefs.h <<EOF
#endif /* _CCTK_ARCHDEFS_H_ */
EOF

# Deal with the Fortran compiler issues.
# If there's a Fortran 90 compiler use that for all the Fortran.
if test "x$F90" != "x" ; then
F77=$F90 
F77FLAGS=$F90FLAGS ;
fi

# The known architecture stuff has probably set the LIBS variable
# So remember what it is and set it to blank to prevent any problems with the
# rest of the configure stuff.

KNOWN_LIBS="$LIBS"
LIBS=

KNOWN_LDFLAGS="$LDFLAGS"
LDFLAGS=

dnl Checks for libraries.

dnl Checks for header files.

AC_HEADER_STDC

dnl Checks for typedefs, structures, and compiler characteristics.

AC_C_BIGENDIAN
AC_C_CONST
AC_C_INLINE
AC_C_LONG_DOUBLE

# Check for sizes of integer types
AC_CHECK_SIZEOF(long int)
AC_CHECK_SIZEOF(int)
AC_CHECK_SIZEOF(short int)

# Check for sizes of floating point types
AC_CHECK_SIZEOF(long double)
AC_CHECK_SIZEOF(double)
AC_CHECK_SIZEOF(float)

# Check for sizes of pointers.  
AC_CHECK_SIZEOF(char *)

# Various flags

AC_SUBST(ARFLAGS)
: ${ARFLAGS=rucs}


AC_SUBST(F90FLAGS)
AC_SUBST(F77FLAGS)

: ${F90FLAGS=$CFLAGS}
: ${F77FLAGS=$CFLAGS}

dnl Checks for library functions.

dnl Misc stuff

AC_SUBST(LIBDIRS)

AC_SUBST(PACKAGE_DIR)
AC_SUBST(BUILD_DIR)
AC_SUBST(CCTK_LIBDIR)
AC_SUBST(EXEDIR)
AC_SUBST(EXE)

: ${PACKAGE_DIR=packages}
: ${BUILD_DIR=build}
: ${CCTK_LIBDIR=lib}
: ${EXEDIR='$(CCTK_HOME)'}
: ${EXE=cactus-unknown}

# Integer types

case "x$ac_cv_sizeof_long_int" in
    "x8")
      CCTK_INT8="long int" ;;
    "x4")
      CCTK_INT4="long int" ;;
    "x2")
      CCTK_INT2="long int" ;;
esac

case "x$ac_cv_sizeof_int" in
    "x8")
      CCTK_INT8="int" ;;
    "x4")
      CCTK_INT4="int" ;;
    "x2")
      CCTK_INT2="int" ;;
esac

case "x$ac_cv_sizeof_short_int" in
    "x8")
      CCTK_INT8="short int" ;;
    "x4")
      CCTK_INT4="short int" ;;
    "x2")
      CCTK_INT2="short int" ;;
esac

if test -n  "$CCTK_INT8" ; then
AC_DEFINE_UNQUOTED(CCTK_INT8, $CCTK_INT8)
fi

if test -n  "$CCTK_INT4" ; then
AC_DEFINE_UNQUOTED(CCTK_INT4, $CCTK_INT4)
fi

if test -n  "$CCTK_INT2" ; then
AC_DEFINE_UNQUOTED(CCTK_INT2, $CCTK_INT2)
fi

# Float types

case "x$ac_cv_sizeof_long_double" in
    "x16")
      CCTK_REAL16="long double" ;;
    "x8")
      CCTK_REAL8="long double" ;;
    "x4")
      CCTK_REAL4="long double" ;;
esac

case "x$ac_cv_sizeof_double" in
    "x16")
      CCTK_REAL16="double" ;;
    "x8")
      CCTK_REAL8="double" ;;
    "x4")
      CCTK_REAL4="double" ;;
esac

case "x$ac_cv_sizeof_float" in
    "x16")
      CCTK_REAL16="float" ;;
    "x8")
      CCTK_REAL8="float" ;;
    "x4")
      CCTK_REAL4="float" ;;
esac

if test -n  "$CCTK_REAL16" ; then
AC_DEFINE_UNQUOTED(CCTK_REAL16, $CCTK_REAL16)
fi

if test -n  "$CCTK_REAL8" ; then
AC_DEFINE_UNQUOTED(CCTK_REAL8, $CCTK_REAL8)
fi

if test -n  "$CCTK_REAL4" ; then
AC_DEFINE_UNQUOTED(CCTK_REAL4, $CCTK_REAL4)
fi


# Define the default floating point and integer precisions
case "x$REAL_PRECISION" in
    "x16")
	AC_DEFINE_UNQUOTED(CCTK_REAL_PRECISION_16, 1) ;;
    "x8")
	AC_DEFINE_UNQUOTED(CCTK_REAL_PRECISION_8, 1) ;;
    "x4")
	AC_DEFINE_UNQUOTED(CCTK_REAL_PRECISION_4, 1) ;;
    *)
	AC_DEFINE_UNQUOTED(CCTK_REAL_PRECISION_8, 1) ;;
esac

case "x$INTEGER_PRECISION" in
    "x8")
	AC_DEFINE_UNQUOTED(CCTK_INTEGER_PRECISION_8, 1) ;;
    "x4")
	AC_DEFINE_UNQUOTED(CCTK_INTEGER_PRECISION_4, 1) ;;
    "x2")
	AC_DEFINE_UNQUOTED(CCTK_INTEGER_PRECISION_2, 1) ;;
    *)
	AC_DEFINE_UNQUOTED(CCTK_INTEGER_PRECISION_4, 1) ;;
esac

# Define any code needed before the definition of a Fortran subroutine
# This is empty on most architectures.

: ${FMODIFIER=""}

AC_DEFINE_UNQUOTED(FMODIFIER, $FMODIFIER) 

# The perl scripts run by the make system need to have their names
# changed if under cygwin - e.g. //d/foo needs to be d:/foo

PERL_CONFIGURE_SCRIPT=`echo $srcdir/configure.pl | sed 's,^//\(.\)/,\1:/,'`

AC_SUBST(BUILD_ACTIVETHORNS)
BUILD_ACTIVETHORNS=`echo $srcdir/../sbin/BuildActiveThorns.pl | sed 's,^//\(.\)/,\1:/,'`
AC_SUBST(CST)
CST=`echo $srcdir/../sbin/CST | sed 's,^//\(.\)/,\1:/,'`

AC_SUBST(F_FILE_PROCESSOR)
F_FILE_PROCESSOR=`echo $srcdir/../sbin/f_file_processor.pl | sed 's,^//\(.\)/,\1:/,'`
AC_SUBST(C_FILE_PROCESSOR)
C_FILE_PROCESSOR=`echo $srcdir/../sbin/c_file_processor.pl | sed 's,^//\(.\)/,\1:/,'`



AC_SUBST(CCOMPILEONLY)
AC_SUBST(FCOMPILEONLY)

# Put the libraries from the known-architectures onto the LIB variable.
LIBS="$KNOWN_LIBS $LIBS"
LDFLAGS="$KNOWN_LDFLAGS $LDFLAGS"

#Set the compileonly flags if they've not been set by now

: ${CCOMPILEONLY="-c -o"}
: ${FCOMPILEONLY="-c -o"}

#Set the createexe flag if it's not been set by now

AC_SUBST(CREATEEXE)

: ${CREATEEXE="-o # Please leave the space, it's important !"}

dnl Run any other scripts necessary

AC_OUTPUT_COMMANDS(,$PERL -s $PERL_CONFIGURE_SCRIPT -compiler="$F77" -opts="$F77FLAGS" .) 

dnl Output everything
AC_OUTPUT(make.config.defn make.config.deps make.config.rules)