configure

一个通用的数学库

echo "$ac_t""$MSVCPP_CXX" 1>&6  ; fi


BACKEND=""
MATHLIB=""
LDOUT="-o "


case "$compiler" in
     kai*)               # KAI C++  http://www.kai.com/
       echo "Configuring for KAI C++"
       CXX_PICKY_FLAGS="--strict_warnings"
       cxxwith=`echo $withval | sed -e 's/ /@/'`
   case "$cxxwith" in
     *:*@*)                 # Full initialization syntax
       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)@.*/\1/p'`
       CXXFLAGS=`echo "$cxxwith" | sed  -n -e 's/.*:.*@\(.*\)/\1/p'`
     ;;
     *:*)                   # Simple initialization syntax
       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)/\1/p'`
       CXXFLAGS="--restrict $CXX_PICKY_FLAGS"
     ;;
     *)                     # Default values
       CXX="KCC"
       CXXFLAGS="--restrict $CXX_PICKY_FLAGS"
     ;;
   esac
       CXX_OPTIMIZE_FLAGS="+K3 -O3 -fast --inline_keyword_space_time=10000"
       CXX_DEBUG_FLAGS="-g +K0 -DBZ_DEBUG"
       BACKEND="--backend"
       CXXLD="$CXX"
     ;;
     sgi*)               # SGI C++  http://www.sgi.com
       echo "Configuring for SGI C++"
       CXX_PICKY_FLAGS=""
       cxxwith=`echo $withval | sed -e 's/ /@/'`
   case "$cxxwith" in
     *:*@*)                 # Full initialization syntax
       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)@.*/\1/p'`
       CXXFLAGS=`echo "$cxxwith" | sed  -n -e 's/.*:.*@\(.*\)/\1/p'`
     ;;
     *:*)                   # Simple initialization syntax
       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)/\1/p'`
       CXXFLAGS="-LANG:restrict -LANG:std $CXX_PICKY_FLAGS"
     ;;
     *)                     # Default values
       CXX="$CXX"
       CXXFLAGS="-LANG:restrict -LANG:std $CXX_PICKY_FLAGS"
     ;;
   esac
       CXX_OPTIMIZE_FLAGS="-Ofast -LANG:restrict"
       CXX_DEBUG_FLAGS="-g -DBZ_DEBUG"
       CXXLD="$CXX"
       LDFLAGS=
     ;;
     gnu*)              # EGCS  http://egcs.cygnus.com/
       echo "Configuring for GNU C++"
       CXX_PICKY_FLAGS="-Wall"
       cxxwith=`echo $withval | sed -e 's/ /@/'`
   case "$cxxwith" in
     *:*@*)                 # Full initialization syntax
       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)@.*/\1/p'`
       CXXFLAGS=`echo "$cxxwith" | sed  -n -e 's/.*:.*@\(.*\)/\1/p'`
     ;;
     *:*)                   # Simple initialization syntax
       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)/\1/p'`
       CXXFLAGS="-ftemplate-depth-30 $CXX_PICKY_FLAGS"
     ;;
     *)                     # Default values
       CXX="g++"
       CXXFLAGS="-ftemplate-depth-30 $CXX_PICKY_FLAGS"
     ;;
   esac
       CXX_OPTIMIZE_FLAGS="-O2 -funroll-loops -fstrict-aliasing -fno-gcse"
       CXX_DEBUG_FLAGS="-g -DBZ_DEBUG"
       CXXLD="$CXX"
       F77=g77
       F77_OPTIMIZE_FLAGS="-O2 -funroll-loops"
       FORTLIBS=-lg2c
       CXXFFLAGS="-DMTL_FORTRAN_SYMBOLS_WITH_DOUBLE_TRAILING_UNDERSCORES"
     ;;
     msvc*) # Microsoft Visual C++
       echo "Configuring for Microsoft Visual C++"
       CXX_PICKY_FLAGS="/W0" # VC++ gives warnings for its own headers!
       cxxwith=`echo $withval | sed -e 's/ /@/'`
   case "$cxxwith" in
     *:*@*)                 # Full initialization syntax
       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)@.*/\1/p'`
       CXXFLAGS=`echo "$cxxwith" | sed  -n -e 's/.*:.*@\(.*\)/\1/p'`
     ;;
     *:*)                   # Simple initialization syntax
       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)/\1/p'`
       CXXFLAGS=""
     ;;
     *)                     # Default values
       CXX="cl"
       CXXFLAGS=""
     ;;
   esac
# had to move this below AC_PROG_CC
#       CPPFLAGS="/TP /ML /GX /YX /FD $CXX_PICKY_FLAGS /Fo\$*.o"
       CXX_OPTIMIZE_FLAGS="/Ox"
       CXX_DEBUG_FLAGS="/Zi"
       LDOUT="/out:"
       CXXLD="link"
     ;;
     mwerk*)
       echo "Configuring for Metrowerks Codewarrior (x86)"
       CXX_PICKY_FLAGS="-w on"
       cxxwith=`echo $withval | sed -e 's/ /@/'`
   case "$cxxwith" in
     *:*@*)                 # Full initialization syntax
       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)@.*/\1/p'`
       CXXFLAGS=`echo "$cxxwith" | sed  -n -e 's/.*:.*@\(.*\)/\1/p'`
     ;;
     *:*)                   # Simple initialization syntax
       CXX=`echo "$cxxwith" | sed  -n -e 's/.*:\(.*\)/\1/p'`
       CXXFLAGS=""
     ;;
     *)                     # Default values
       CXX="mwcc -i-"
       CXXFLAGS=""
     ;;
   esac
# had to move this below AC_PROG_CC
#       CPPFLAGS="$CXX_PICKY_FLAGS -o \$*.o"
       CXX_OPTIMIZE_FLAGS="-opt all"
       CXX_DEBUG_FLAGS="-g"
       CXXLD="mwld"
     ;;
     *)
        CXXLD="$CXX"
        echo "configure: warning: Compiler not recognized" 1>&2
     ;;
   esac

# Set platform-specific fortran compilers and optimization settings

if test "$GXX" = "yes"; then
    F77=g77
    F77_OPTIMIZE_FLAGS="-O2 -funroll-loops"
    FORTLIBS=-lg2c
    MATHLIB="-lm"
else
case "$target" in
  *linux*)
    echo "Linux: assuming g77 fortran compiler"
    F77=g77
    F77_OPTIMIZE_FLAGS="-O2 -funroll-loops"
    FORTLIBS=-lg2c
    MATHLIB="-lm"
  ;;
  *aix*)
    echo "AIX: assuming f77 and xlf90"
    F77=f77
    F77_OPTIMIZE_FLAGS="-O3 -qhot"
    F90=xlf90
    F90_OPTIMIZE_FLAGS="-O3 -qhot"
    FORTLIBS=-lxlf90
    MATHLIB="-lm"
  ;;
  *irix*)
    echo "IRIX: assuming cc, f77 and f90 native compilers"
    CC=cc
    F77=f77
    F90=f90
    CC_OPTIMIZE_FLAGS="-Ofast"
    F77_OPTIMIZE_FLAGS="-Ofast"
    F90_OPTIMIZE_FLAGS="-Ofast"
    MATHLIB="-lm"
    CXXFFLAGS="-DMTL_FORTRAN_SYMBOLS_WITH_TRAILING_UNDERSCORES"
    case "$CXX" in
      KCC)
       # When using KAI C++ under IRIX, enable some backend optimizations
      CXX_OPTIMIZE_FLAGS="+K3 -O3 --COMPO_fe --output_restrict --backend -LANG:restrict=on -mips4"
      CXX_DEBUG_FLAGS="-g +K0 -DBZ_DEBUG -mips4"
      ;;
    esac
  ;;
  *solaris*)
    echo "Solaris: assuming cc as the native C compiler, "
    echo "  and f77 and f90 as the fortran compilers"
    echo "  Also assuming v8plusa architecture."
    CC=cc
    CC_OPTIMIZE_FLAGS="-fast -xO4 -xtarget=native -xarch=v8plusa -xdepend -dalign"
    F77=f77
    F77_OPTIMIZE_FLAGS="-fast -xO4 -xtarget=native -xarch=v8plusa -xdepend -dalign"
    F90=f90
    F90_OPTIMIZE_FLAGS="-fast -xO4 -xtarget=native -xarch=v8plusa -xdepend -dalign"
    MATHLIB="-L/usr/lib -lm"
    case "$CXX" in
      KCC)
        # When using KAI C++ under Solaris, enable some backend optimizations
        CXX_OPTIMIZE_FLAGS="+K3 -fast  --backend -xO4  --backend -xtarget=native  -backend -xarch=v8plusa  --backend -xdepend  --backend -dalign "
        CXX_DEBUG_FLAGS="-g +K0 -DBZ_DEBUG"
      ;;
    esac
  ;;
  *osf*)
    echo "OSF: assuming f77 and f90 fortran compilers"
    F77=f77
    F77_OPTIMIZE_FLAGS="-O4 -tune host"
    F90=f90
    F90_OPTIMIZE_FLAGS="-O4 -tune host"
    CXXFFLAGS="-DMTL_FORTRAN_SYMBOLS_WITH_TRAILING_UNDERSCORES"
    MATHLIB="-lm"
  ;;
  alpha-cray-unicos)
    echo "Cray T3D/E: Setting special optimization flags"
    F77=fort77
    F77_OPTIMIZE_FLAGS="-O aggress -O 3 -O unroll2 -O pipeline3"
    F90=f90
    F90_OPTIMIZE_FLAGS="-O 3 -O aggress -O unroll2 -O pipeline3"
    CXXFFLAGS="-DMTL_FORTRAN_SYMBOLS_CAPS"
    MATHLIB="-lm"
    case "$CXX" in
      KCC)
        # When using KAI C++ on the T3E, need to enable a bunch of
        # backend optimizations
        CXX_OPTIMIZE_FLAGS="+K3 -O3 --backend -hpipeline3 --backend -hunroll \
--backend -haggress --backend -hscalar2"
      ;;
    esac
  ;;
  *)
    echo << EOF

MTL has not been tuned for this platform.  You may have trouble
building fortran benchmarks, and performance may be unexciting.

EOF
  ;;
esac
fi


# Extract the first word of "gcc", so it can be a program name with args.
set dummy gcc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1483: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_CC="gcc"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
fi
CC="$ac_cv_prog_CC"
if test -n "$CC"; then
  echo "$ac_t""$CC" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

if test -z "$CC"; then
  # Extract the first word of "cc", so it can be a program name with args.
set dummy cc; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1513: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_prog_rejected=no
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
        ac_prog_rejected=yes
	continue
      fi
      ac_cv_prog_CC="cc"
      break
    fi
  done
  IFS="$ac_save_ifs"
if test $ac_prog_rejected = yes; then
  # We found a bogon in the path, so make sure we never use it.
  set dummy $ac_cv_prog_CC
  shift
  if test $# -gt 0; then
    # We chose a different compiler from the bogus one.
    # However, it has the same basename, so the bogon will be chosen
    # first if we set CC to just the basename; use the full file name.
    shift
    set dummy "$ac_dir/$ac_word" "$@"
    shift
    ac_cv_prog_CC="$@"
  fi
fi
fi
fi
CC="$ac_cv_prog_CC"
if test -n "$CC"; then
  echo "$ac_t""$CC" 1>&6
else
  echo "$ac_t""no" 1>&6
fi

  if test -z "$CC"; then
    case "`uname -s`" in
    *win32* | *WIN32*)
      # Extract the first word of "cl", so it can be a program name with args.
set dummy cl; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
echo "configure:1564: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  if test -n "$CC"; then
  ac_cv_prog_CC="$CC" # Let the user override the test.
else
  IFS="${IFS= 	}"; ac_save_ifs="$IFS"; IFS=":"
  ac_dummy="$PATH"
  for ac_dir in $ac_dummy; do
    test -z "$ac_dir" && ac_dir=.
    if test -f $ac_dir/$ac_word; then
      ac_cv_prog_CC="cl"
      break
    fi
  done
  IFS="$ac_save_ifs"
fi
fi
CC="$ac_cv_prog_CC"
if test -n "$CC"; then
  echo "$ac_t""$CC" 1>&6
else
  echo "$ac_t""no" 1>&6
fi
 ;;
    esac
  fi
  test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
fi

echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
echo "configure:1596: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5

ac_ext=c
# CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CPP $CPPFLAGS'
ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cc_cross

cat > conftest.$ac_ext << EOF

#line 1607 "configure"
#include "confdefs.h"

main(){return(0);}
EOF
if { (eval echo configure:1612: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
  ac_cv_prog_cc_works=yes
  # If we can't run a trivial program, we are probably using a cross compiler.
  if (./conftest; exit) 2>/dev/null; then
    ac_cv_prog_cc_cross=no
  else
    ac_cv_prog_cc_cross=yes
  fi
else
  echo "configure: failed program was:" >&5
  cat conftest.$ac_ext >&5
  ac_cv_prog_cc_works=no
fi
rm -fr conftest*
ac_ext=C
# CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
ac_cpp='$CXXCPP $CPPFLAGS'
ac_compile='${CXX-g++} -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
ac_link='${CXX-g++} -o conftest${ac_exeext} $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
cross_compiling=$ac_cv_prog_cxx_cross

echo "$ac_t""$ac_cv_prog_cc_works" 1>&6
if test $ac_cv_prog_cc_works = no; then
  { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
fi
echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
echo "configure:1638: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
cross_compiling=$ac_cv_prog_cc_cross

echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
echo "configure:1643: checking whether we are using GNU C" >&5
if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
  echo $ac_n "(cached) $ac_c" 1>&6
else
  cat > conftest.c <<EOF
#ifdef __GNUC__
  yes;
#endif
EOF
if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:1652: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
  ac_cv_prog_gcc=yes
else
  ac_cv_prog_gcc=no
fi
fi