ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/configure
(Generate patch)

Comparing trunk/configure (file contents):
Revision 1395 by gezelter, Fri Dec 4 17:38:47 2009 UTC vs.
Revision 1396 by gezelter, Sat Dec 5 02:57:05 2009 UTC

# Line 650 | Line 650 | MPIFC
650   CPP
651   USE_MPI
652   MPIFC
653 + MPICC
654 + MPILIBS
655 + MPICXX
656   ac_ct_FC
657   FCFLAGS
658   FC
656 MPICC
659   ac_ct_CC
660   CFLAGS
661   CC
660 MPILIBS
661 MPICXX
662   OBJEXT
663   EXEEXT
664   ac_ct_CXX
# Line 666 | Line 666 | CXX
666   LDFLAGS
667   CXXFLAGS
668   CXX
669 ac_fc_path
670 ac_fc_set
671 ac_cxx_path
672 ac_cxx_set
673 ac_cc_path
674 ac_cc_set
669   USE_SINGLE_PRECISION
670   debug
671   PROGNAME
# Line 747 | Line 741 | CCC
741   LIBS
742   CPPFLAGS
743   CCC
750 MPICXX
744   CC
745   CFLAGS
753 MPICC
746   FC
747   FCFLAGS
748 + MPICXX
749 + MPICC
750   MPIFC
751   CPP
752   CXXCPP'
# Line 1402 | Line 1396 | Some influential environment variables:
1396    LIBS        libraries to pass to the linker, e.g. -l<library>
1397    CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1398                you have headers in a nonstandard directory <include dir>
1405  MPICXX      MPI C++ compiler command
1399    CC          C compiler command
1400    CFLAGS      C compiler flags
1408  MPICC       MPI C compiler command
1401    FC          Fortran compiler command
1402    FCFLAGS     Fortran compiler flags
1403 +  MPICXX      MPI C++ compiler command
1404 +  MPICC       MPI C compiler command
1405    MPIFC       MPI Fortran compiler command
1406    CPP         C preprocessor
1407    CXXCPP      C++ preprocessor
# Line 1529 | Line 1523 | fi
1523    as_fn_set_status $ac_retval
1524  
1525   } # ac_fn_cxx_try_compile
1526 +
1527 + # ac_fn_c_try_compile LINENO
1528 + # --------------------------
1529 + # Try to compile conftest.$ac_ext, and return whether this succeeded.
1530 + ac_fn_c_try_compile ()
1531 + {
1532 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1533 +  rm -f conftest.$ac_objext
1534 +  if { { ac_try="$ac_compile"
1535 + case "(($ac_try" in
1536 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1537 +  *) ac_try_echo=$ac_try;;
1538 + esac
1539 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1540 + $as_echo "$ac_try_echo"; } >&5
1541 +  (eval "$ac_compile") 2>conftest.err
1542 +  ac_status=$?
1543 +  if test -s conftest.err; then
1544 +    grep -v '^ *+' conftest.err >conftest.er1
1545 +    cat conftest.er1 >&5
1546 +    mv -f conftest.er1 conftest.err
1547 +  fi
1548 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1549 +  test $ac_status = 0; } && {
1550 +         test -z "$ac_c_werror_flag" ||
1551 +         test ! -s conftest.err
1552 +       } && test -s conftest.$ac_objext; then :
1553 +  ac_retval=0
1554 + else
1555 +  $as_echo "$as_me: failed program was:" >&5
1556 + sed 's/^/| /' conftest.$ac_ext >&5
1557 +
1558 +        ac_retval=1
1559 + fi
1560 +  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1561 +  as_fn_set_status $ac_retval
1562 +
1563 + } # ac_fn_c_try_compile
1564 +
1565 + # ac_fn_fc_try_compile LINENO
1566 + # ---------------------------
1567 + # Try to compile conftest.$ac_ext, and return whether this succeeded.
1568 + ac_fn_fc_try_compile ()
1569 + {
1570 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1571 +  rm -f conftest.$ac_objext
1572 +  if { { ac_try="$ac_compile"
1573 + case "(($ac_try" in
1574 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1575 +  *) ac_try_echo=$ac_try;;
1576 + esac
1577 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1578 + $as_echo "$ac_try_echo"; } >&5
1579 +  (eval "$ac_compile") 2>conftest.err
1580 +  ac_status=$?
1581 +  if test -s conftest.err; then
1582 +    grep -v '^ *+' conftest.err >conftest.er1
1583 +    cat conftest.er1 >&5
1584 +    mv -f conftest.er1 conftest.err
1585 +  fi
1586 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1587 +  test $ac_status = 0; } && {
1588 +         test -z "$ac_fc_werror_flag" ||
1589 +         test ! -s conftest.err
1590 +       } && test -s conftest.$ac_objext; then :
1591 +  ac_retval=0
1592 + else
1593 +  $as_echo "$as_me: failed program was:" >&5
1594 + sed 's/^/| /' conftest.$ac_ext >&5
1595  
1596 +        ac_retval=1
1597 + fi
1598 +  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1599 +  as_fn_set_status $ac_retval
1600 +
1601 + } # ac_fn_fc_try_compile
1602 +
1603   # ac_fn_cxx_try_link LINENO
1604   # -------------------------
1605   # Try to link conftest.$ac_ext, and return whether this succeeded.
# Line 1642 | Line 1712 | $as_echo "$ac_res" >&6; }
1712    eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1713  
1714   } # ac_fn_cxx_check_func
1645
1646 # ac_fn_c_try_compile LINENO
1647 # --------------------------
1648 # Try to compile conftest.$ac_ext, and return whether this succeeded.
1649 ac_fn_c_try_compile ()
1650 {
1651  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1652  rm -f conftest.$ac_objext
1653  if { { ac_try="$ac_compile"
1654 case "(($ac_try" in
1655  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1656  *) ac_try_echo=$ac_try;;
1657 esac
1658 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1659 $as_echo "$ac_try_echo"; } >&5
1660  (eval "$ac_compile") 2>conftest.err
1661  ac_status=$?
1662  if test -s conftest.err; then
1663    grep -v '^ *+' conftest.err >conftest.er1
1664    cat conftest.er1 >&5
1665    mv -f conftest.er1 conftest.err
1666  fi
1667  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1668  test $ac_status = 0; } && {
1669         test -z "$ac_c_werror_flag" ||
1670         test ! -s conftest.err
1671       } && test -s conftest.$ac_objext; then :
1672  ac_retval=0
1673 else
1674  $as_echo "$as_me: failed program was:" >&5
1675 sed 's/^/| /' conftest.$ac_ext >&5
1676
1677        ac_retval=1
1678 fi
1679  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1680  as_fn_set_status $ac_retval
1715  
1682 } # ac_fn_c_try_compile
1683
1716   # ac_fn_c_try_link LINENO
1717   # -----------------------
1718   # Try to link conftest.$ac_ext, and return whether this succeeded.
# Line 1794 | Line 1826 | $as_echo "$ac_res" >&6; }
1826  
1827   } # ac_fn_c_check_func
1828  
1797 # ac_fn_fc_try_compile LINENO
1798 # ---------------------------
1799 # Try to compile conftest.$ac_ext, and return whether this succeeded.
1800 ac_fn_fc_try_compile ()
1801 {
1802  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1803  rm -f conftest.$ac_objext
1804  if { { ac_try="$ac_compile"
1805 case "(($ac_try" in
1806  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1807  *) ac_try_echo=$ac_try;;
1808 esac
1809 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1810 $as_echo "$ac_try_echo"; } >&5
1811  (eval "$ac_compile") 2>conftest.err
1812  ac_status=$?
1813  if test -s conftest.err; then
1814    grep -v '^ *+' conftest.err >conftest.er1
1815    cat conftest.er1 >&5
1816    mv -f conftest.er1 conftest.err
1817  fi
1818  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1819  test $ac_status = 0; } && {
1820         test -z "$ac_fc_werror_flag" ||
1821         test ! -s conftest.err
1822       } && test -s conftest.$ac_objext; then :
1823  ac_retval=0
1824 else
1825  $as_echo "$as_me: failed program was:" >&5
1826 sed 's/^/| /' conftest.$ac_ext >&5
1827
1828        ac_retval=1
1829 fi
1830  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1831  as_fn_set_status $ac_retval
1832
1833 } # ac_fn_fc_try_compile
1834
1829   # ac_fn_fc_try_link LINENO
1830   # ------------------------
1831   # Try to link conftest.$ac_ext, and return whether this succeeded.
# Line 2972 | Line 2966 | case $host_os in *\ *) host_os=`echo "$host_os" | sed
2966  
2967  
2968   # set program name
2969 < PROGNAME="openmd"
2976 <
2977 <
2978 <
2979 <
2980 < OBJEXT=".$OBJEXT"
2981 <
2982 < OPENMD=openmd
2983 <
2984 < if test "x${prefix}" = "xNONE"
2985 < then
2986 <  OPENMD_HOME=${ac_default_prefix}/openmd
2987 < else
2988 <  OPENMD_HOME=${prefix}/openmd
2989 < fi
2990 < # Check whether --enable-openmd-home was given.
2991 < if test "${enable_openmd_home+set}" = set; then :
2992 <  enableval=$enable_openmd_home; OPENMD_HOME="${enableval}"
2993 < fi
2994 <
2995 <
2996 < # there are two ways to do debugging.  One with the --enable-debug flag
2997 < # and one using the DEBUG environment variable
2998 <
2999 < debug=0
3000 < # Check whether --enable-debug was given.
3001 < if test "${enable_debug+set}" = set; then :
3002 <  enableval=$enable_debug; debug=1
3003 < fi
3004 <
3005 < if test "${DEBUG}"; then
3006 <
3007 < $as_echo "#define debug 1" >>confdefs.h
3008 <
3009 <  msg="$msg, debug mode"
3010 < fi
3011 <
3012 <
3013 < # Check whether --enable-single was given.
3014 < if test "${enable_single+set}" = set; then :
3015 <  enableval=$enable_single; ok=$enableval
3016 < else
3017 <  ok=no
3018 < fi
3019 <
3020 < # Check whether --enable-float was given.
3021 < if test "${enable_float+set}" = set; then :
3022 <  enableval=$enable_float; ok=$enableval
3023 < fi
3024 <
3025 < if test "$ok" = "yes"; then
3026 <
3027 < $as_echo "#define SINGLE_PRECISION 1" >>confdefs.h
3028 <
3029 <        USE_SINGLE_PRECISION=yes
3030 <
3031 < fi
3032 <
3033 < if test x"$CC" != x; then
3034 <   for ac_prog in $CC
3035 < do
3036 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3037 < set dummy $ac_prog; ac_word=$2
3038 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3039 < $as_echo_n "checking for $ac_word... " >&6; }
3040 < if test "${ac_cv_prog_ac_cc_set+set}" = set; then :
3041 <  $as_echo_n "(cached) " >&6
3042 < else
3043 <  if test -n "$ac_cc_set"; then
3044 <  ac_cv_prog_ac_cc_set="$ac_cc_set" # Let the user override the test.
3045 < else
3046 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3047 < for as_dir in $PATH
3048 < do
3049 <  IFS=$as_save_IFS
3050 <  test -z "$as_dir" && as_dir=.
3051 <    for ac_exec_ext in '' $ac_executable_extensions; do
3052 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3053 <    ac_cv_prog_ac_cc_set="$ac_prog"
3054 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3055 <    break 2
3056 <  fi
3057 < done
3058 <  done
3059 < IFS=$as_save_IFS
3060 <
3061 < fi
3062 < fi
3063 < ac_cc_set=$ac_cv_prog_ac_cc_set
3064 < if test -n "$ac_cc_set"; then
3065 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cc_set" >&5
3066 < $as_echo "$ac_cc_set" >&6; }
3067 < else
3068 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3069 < $as_echo "no" >&6; }
3070 < fi
3071 <
3072 <
3073 <  test -n "$ac_cc_set" && break
3074 < done
3075 < test -n "$ac_cc_set" || ac_cc_set="no"
3076 <
3077 <   if test $ac_cc_set != no; then :
3078 <
3079 <     # Extract the first word of "$ac_cc_set", so it can be a program name with args.
3080 < set dummy $ac_cc_set; ac_word=$2
3081 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3082 < $as_echo_n "checking for $ac_word... " >&6; }
3083 < if test "${ac_cv_path_ac_cc_path+set}" = set; then :
3084 <  $as_echo_n "(cached) " >&6
3085 < else
3086 <  case $ac_cc_path in
3087 <  [\\/]* | ?:[\\/]*)
3088 <  ac_cv_path_ac_cc_path="$ac_cc_path" # Let the user override the test with a path.
3089 <  ;;
3090 <  *)
3091 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3092 < for as_dir in $PATH
3093 < do
3094 <  IFS=$as_save_IFS
3095 <  test -z "$as_dir" && as_dir=.
3096 <    for ac_exec_ext in '' $ac_executable_extensions; do
3097 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3098 <    ac_cv_path_ac_cc_path="$as_dir/$ac_word$ac_exec_ext"
3099 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3100 <    break 2
3101 <  fi
3102 < done
3103 <  done
3104 < IFS=$as_save_IFS
3105 <
3106 <  test -z "$ac_cv_path_ac_cc_path" && ac_cv_path_ac_cc_path="no"
3107 <  ;;
3108 < esac
3109 < fi
3110 < ac_cc_path=$ac_cv_path_ac_cc_path
3111 < if test -n "$ac_cc_path"; then
3112 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cc_path" >&5
3113 < $as_echo "$ac_cc_path" >&6; }
3114 < else
3115 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3116 < $as_echo "no" >&6; }
3117 < fi
3118 <
3119 <
3120 < else
3121 <
3122 <     as_fn_error "Specified C compiler $CC doesn't seem to exist!" "$LINENO" 5
3123 < fi
3124 <
3125 <   if test $ac_cc_path != no; then :
3126 <
3127 <     { $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $CC as C compiler" >&5
3128 < $as_echo "$as_me: Will attempt to use $CC as C compiler" >&6;}
3129 <     MPICC=$CC
3130 <
3131 < else
3132 <
3133 <     as_fn_error "Can't find path to user-specified C compiler $CC" "$LINENO" 5
3134 < fi
3135 < fi
3136 <
3137 < if test x"$CXX" != x; then
3138 <   for ac_prog in $CXX
3139 < do
3140 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3141 < set dummy $ac_prog; ac_word=$2
3142 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3143 < $as_echo_n "checking for $ac_word... " >&6; }
3144 < if test "${ac_cv_prog_ac_cxx_set+set}" = set; then :
3145 <  $as_echo_n "(cached) " >&6
3146 < else
3147 <  if test -n "$ac_cxx_set"; then
3148 <  ac_cv_prog_ac_cxx_set="$ac_cxx_set" # Let the user override the test.
3149 < else
3150 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3151 < for as_dir in $PATH
3152 < do
3153 <  IFS=$as_save_IFS
3154 <  test -z "$as_dir" && as_dir=.
3155 <    for ac_exec_ext in '' $ac_executable_extensions; do
3156 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3157 <    ac_cv_prog_ac_cxx_set="$ac_prog"
3158 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3159 <    break 2
3160 <  fi
3161 < done
3162 <  done
3163 < IFS=$as_save_IFS
3164 <
3165 < fi
3166 < fi
3167 < ac_cxx_set=$ac_cv_prog_ac_cxx_set
3168 < if test -n "$ac_cxx_set"; then
3169 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cxx_set" >&5
3170 < $as_echo "$ac_cxx_set" >&6; }
3171 < else
3172 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3173 < $as_echo "no" >&6; }
3174 < fi
3175 <
3176 <
3177 <  test -n "$ac_cxx_set" && break
3178 < done
3179 < test -n "$ac_cxx_set" || ac_cxx_set="no"
3180 <
3181 <   if test $ac_cxx_set != no; then :
3182 <
3183 <     # Extract the first word of "$ac_cxx_set", so it can be a program name with args.
3184 < set dummy $ac_cxx_set; ac_word=$2
3185 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3186 < $as_echo_n "checking for $ac_word... " >&6; }
3187 < if test "${ac_cv_path_ac_cxx_path+set}" = set; then :
3188 <  $as_echo_n "(cached) " >&6
3189 < else
3190 <  case $ac_cxx_path in
3191 <  [\\/]* | ?:[\\/]*)
3192 <  ac_cv_path_ac_cxx_path="$ac_cxx_path" # Let the user override the test with a path.
3193 <  ;;
3194 <  *)
3195 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3196 < for as_dir in $PATH
3197 < do
3198 <  IFS=$as_save_IFS
3199 <  test -z "$as_dir" && as_dir=.
3200 <    for ac_exec_ext in '' $ac_executable_extensions; do
3201 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3202 <    ac_cv_path_ac_cxx_path="$as_dir/$ac_word$ac_exec_ext"
3203 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3204 <    break 2
3205 <  fi
3206 < done
3207 <  done
3208 < IFS=$as_save_IFS
3209 <
3210 <  test -z "$ac_cv_path_ac_cxx_path" && ac_cv_path_ac_cxx_path="no"
3211 <  ;;
3212 < esac
3213 < fi
3214 < ac_cxx_path=$ac_cv_path_ac_cxx_path
3215 < if test -n "$ac_cxx_path"; then
3216 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cxx_path" >&5
3217 < $as_echo "$ac_cxx_path" >&6; }
3218 < else
3219 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3220 < $as_echo "no" >&6; }
3221 < fi
3222 <
3223 <
3224 < else
3225 <
3226 <     as_fn_error "Specified C++ compiler $CXX doesn't seem to exist!" "$LINENO" 5
3227 < fi
3228 <
3229 <   if test $ac_cxx_path != no; then :
3230 <
3231 <     { $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $CXX as C++ compiler" >&5
3232 < $as_echo "$as_me: Will attempt to use $CXX as C++ compiler" >&6;}
3233 <     MPICXX=$CXX
3234 <
3235 < else
3236 <
3237 <     as_fn_error "Can't find path to user-specified C++ compiler $CXX" "$LINENO" 5
3238 < fi
3239 < fi
3240 <
3241 < if test x"$FC" != x; then
3242 <   for ac_prog in $FC
3243 < do
3244 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3245 < set dummy $ac_prog; ac_word=$2
3246 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3247 < $as_echo_n "checking for $ac_word... " >&6; }
3248 < if test "${ac_cv_prog_ac_fc_set+set}" = set; then :
3249 <  $as_echo_n "(cached) " >&6
3250 < else
3251 <  if test -n "$ac_fc_set"; then
3252 <  ac_cv_prog_ac_fc_set="$ac_fc_set" # Let the user override the test.
3253 < else
3254 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3255 < for as_dir in $PATH
3256 < do
3257 <  IFS=$as_save_IFS
3258 <  test -z "$as_dir" && as_dir=.
3259 <    for ac_exec_ext in '' $ac_executable_extensions; do
3260 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3261 <    ac_cv_prog_ac_fc_set="$ac_prog"
3262 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3263 <    break 2
3264 <  fi
3265 < done
3266 <  done
3267 < IFS=$as_save_IFS
3268 <
3269 < fi
3270 < fi
3271 < ac_fc_set=$ac_cv_prog_ac_fc_set
3272 < if test -n "$ac_fc_set"; then
3273 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_fc_set" >&5
3274 < $as_echo "$ac_fc_set" >&6; }
3275 < else
3276 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3277 < $as_echo "no" >&6; }
3278 < fi
3279 <
3280 <
3281 <  test -n "$ac_fc_set" && break
3282 < done
3283 < test -n "$ac_fc_set" || ac_fc_set="no"
3284 <
3285 <   if test $ac_fc_set != no; then :
3286 <
3287 <     # Extract the first word of "$ac_fc_set", so it can be a program name with args.
3288 < set dummy $ac_fc_set; ac_word=$2
3289 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3290 < $as_echo_n "checking for $ac_word... " >&6; }
3291 < if test "${ac_cv_path_ac_fc_path+set}" = set; then :
3292 <  $as_echo_n "(cached) " >&6
3293 < else
3294 <  case $ac_fc_path in
3295 <  [\\/]* | ?:[\\/]*)
3296 <  ac_cv_path_ac_fc_path="$ac_fc_path" # Let the user override the test with a path.
3297 <  ;;
3298 <  *)
3299 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3300 < for as_dir in $PATH
3301 < do
3302 <  IFS=$as_save_IFS
3303 <  test -z "$as_dir" && as_dir=.
3304 <    for ac_exec_ext in '' $ac_executable_extensions; do
3305 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3306 <    ac_cv_path_ac_fc_path="$as_dir/$ac_word$ac_exec_ext"
3307 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3308 <    break 2
3309 <  fi
3310 < done
3311 <  done
3312 < IFS=$as_save_IFS
3313 <
3314 <  test -z "$ac_cv_path_ac_fc_path" && ac_cv_path_ac_fc_path="no"
3315 <  ;;
3316 < esac
3317 < fi
3318 < ac_fc_path=$ac_cv_path_ac_fc_path
3319 < if test -n "$ac_fc_path"; then
3320 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_fc_path" >&5
3321 < $as_echo "$ac_fc_path" >&6; }
3322 < else
3323 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3324 < $as_echo "no" >&6; }
3325 < fi
3326 <
3327 <
3328 < else
3329 <
3330 <     as_fn_error "Specified Fortran compiler $FC doesn't seem to exist!" "$LINENO" 5
3331 < fi
3332 <
3333 <   if test $ac_fc_path != no; then :
3334 <
3335 <     { $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $FC as Fortran compiler" >&5
3336 < $as_echo "$as_me: Will attempt to use $FC as Fortran compiler" >&6;}
3337 <     MPIFC=$FC
3338 <
3339 < else
3340 <
3341 <     as_fn_error "Can't find path to user-specified Fortran compiler $FC" "$LINENO" 5
3342 < fi
3343 < fi
3344 <
3345 <
3346 < save_LIBS_CHECK_CXX_LIB="$LIBS"
3347 <
3348 < ac_ext=cpp
3349 < ac_cpp='$CXXCPP $CPPFLAGS'
3350 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3351 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3352 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3353 <
3354 < ac_ext=cpp
3355 < ac_cpp='$CXXCPP $CPPFLAGS'
3356 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3357 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3358 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3359 < if test -z "$CXX"; then
3360 <  if test -n "$CCC"; then
3361 <    CXX=$CCC
3362 <  else
3363 <    if test -n "$ac_tool_prefix"; then
3364 <  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3365 <  do
3366 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3367 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3368 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3369 < $as_echo_n "checking for $ac_word... " >&6; }
3370 < if test "${ac_cv_prog_CXX+set}" = set; then :
3371 <  $as_echo_n "(cached) " >&6
3372 < else
3373 <  if test -n "$CXX"; then
3374 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
3375 < else
3376 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3377 < for as_dir in $PATH
3378 < do
3379 <  IFS=$as_save_IFS
3380 <  test -z "$as_dir" && as_dir=.
3381 <    for ac_exec_ext in '' $ac_executable_extensions; do
3382 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3383 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3384 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3385 <    break 2
3386 <  fi
3387 < done
3388 <  done
3389 < IFS=$as_save_IFS
3390 <
3391 < fi
3392 < fi
3393 < CXX=$ac_cv_prog_CXX
3394 < if test -n "$CXX"; then
3395 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
3396 < $as_echo "$CXX" >&6; }
3397 < else
3398 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3399 < $as_echo "no" >&6; }
3400 < fi
3401 <
3402 <
3403 <    test -n "$CXX" && break
3404 <  done
3405 < fi
3406 < if test -z "$CXX"; then
3407 <  ac_ct_CXX=$CXX
3408 <  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3409 < do
3410 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3411 < set dummy $ac_prog; ac_word=$2
3412 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3413 < $as_echo_n "checking for $ac_word... " >&6; }
3414 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
3415 <  $as_echo_n "(cached) " >&6
3416 < else
3417 <  if test -n "$ac_ct_CXX"; then
3418 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3419 < else
3420 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3421 < for as_dir in $PATH
3422 < do
3423 <  IFS=$as_save_IFS
3424 <  test -z "$as_dir" && as_dir=.
3425 <    for ac_exec_ext in '' $ac_executable_extensions; do
3426 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3427 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
3428 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3429 <    break 2
3430 <  fi
3431 < done
3432 <  done
3433 < IFS=$as_save_IFS
3434 <
3435 < fi
3436 < fi
3437 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3438 < if test -n "$ac_ct_CXX"; then
3439 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
3440 < $as_echo "$ac_ct_CXX" >&6; }
3441 < else
3442 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3443 < $as_echo "no" >&6; }
3444 < fi
3445 <
3446 <
3447 <  test -n "$ac_ct_CXX" && break
3448 < done
3449 <
3450 <  if test "x$ac_ct_CXX" = x; then
3451 <    CXX="g++"
3452 <  else
3453 <    case $cross_compiling:$ac_tool_warned in
3454 < yes:)
3455 < { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3456 < $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3457 < ac_tool_warned=yes ;;
3458 < esac
3459 <    CXX=$ac_ct_CXX
3460 <  fi
3461 < fi
3462 <
3463 <  fi
3464 < fi
3465 < # Provide some information about the compiler.
3466 < $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
3467 < set X $ac_compile
3468 < ac_compiler=$2
3469 < for ac_option in --version -v -V -qversion; do
3470 <  { { ac_try="$ac_compiler $ac_option >&5"
3471 < case "(($ac_try" in
3472 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3473 <  *) ac_try_echo=$ac_try;;
3474 < esac
3475 < eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3476 < $as_echo "$ac_try_echo"; } >&5
3477 <  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
3478 <  ac_status=$?
3479 <  if test -s conftest.err; then
3480 <    sed '10a\
3481 < ... rest of stderr output deleted ...
3482 <         10q' conftest.err >conftest.er1
3483 <    cat conftest.er1 >&5
3484 <  fi
3485 <  rm -f conftest.er1 conftest.err
3486 <  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3487 <  test $ac_status = 0; }
3488 < done
3489 <
3490 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3491 < /* end confdefs.h.  */
3492 <
3493 < int
3494 < main ()
3495 < {
3496 <
3497 <  ;
3498 <  return 0;
3499 < }
3500 < _ACEOF
3501 < ac_clean_files_save=$ac_clean_files
3502 < ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
3503 < # Try to create an executable without -o first, disregard a.out.
3504 < # It will help us diagnose broken compilers, and finding out an intuition
3505 < # of exeext.
3506 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
3507 < $as_echo_n "checking whether the C++ compiler works... " >&6; }
3508 < ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3509 <
3510 < # The possible output files:
3511 < ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
3512 <
3513 < ac_rmfiles=
3514 < for ac_file in $ac_files
3515 < do
3516 <  case $ac_file in
3517 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3518 <    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
3519 <  esac
3520 < done
3521 < rm -f $ac_rmfiles
3522 <
3523 < if { { ac_try="$ac_link_default"
3524 < case "(($ac_try" in
3525 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3526 <  *) ac_try_echo=$ac_try;;
3527 < esac
3528 < eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3529 < $as_echo "$ac_try_echo"; } >&5
3530 <  (eval "$ac_link_default") 2>&5
3531 <  ac_status=$?
3532 <  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3533 <  test $ac_status = 0; }; then :
3534 <  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3535 < # So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3536 < # in a Makefile.  We should not override ac_cv_exeext if it was cached,
3537 < # so that the user can short-circuit this test for compilers unknown to
3538 < # Autoconf.
3539 < for ac_file in $ac_files ''
3540 < do
3541 <  test -f "$ac_file" || continue
3542 <  case $ac_file in
3543 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
3544 <        ;;
3545 <    [ab].out )
3546 <        # We found the default executable, but exeext='' is most
3547 <        # certainly right.
3548 <        break;;
3549 <    *.* )
3550 <        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3551 <        then :; else
3552 <           ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3553 <        fi
3554 <        # We set ac_cv_exeext here because the later test for it is not
3555 <        # safe: cross compilers may not add the suffix if given an `-o'
3556 <        # argument, so we may need to know it at that point already.
3557 <        # Even if this section looks crufty: it has the advantage of
3558 <        # actually working.
3559 <        break;;
3560 <    * )
3561 <        break;;
3562 <  esac
3563 < done
3564 < test "$ac_cv_exeext" = no && ac_cv_exeext=
3565 <
3566 < else
3567 <  ac_file=''
3568 < fi
3569 < if test -z "$ac_file"; then :
3570 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3571 < $as_echo "no" >&6; }
3572 < $as_echo "$as_me: failed program was:" >&5
3573 < sed 's/^/| /' conftest.$ac_ext >&5
3574 <
3575 < { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3576 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3577 < { as_fn_set_status 77
3578 < as_fn_error "C++ compiler cannot create executables
3579 < See \`config.log' for more details." "$LINENO" 5; }; }
3580 < else
3581 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
3582 < $as_echo "yes" >&6; }
3583 < fi
3584 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
3585 < $as_echo_n "checking for C++ compiler default output file name... " >&6; }
3586 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
3587 < $as_echo "$ac_file" >&6; }
3588 < ac_exeext=$ac_cv_exeext
3589 <
3590 < rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
3591 < ac_clean_files=$ac_clean_files_save
3592 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
3593 < $as_echo_n "checking for suffix of executables... " >&6; }
3594 < if { { ac_try="$ac_link"
3595 < case "(($ac_try" in
3596 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3597 <  *) ac_try_echo=$ac_try;;
3598 < esac
3599 < eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3600 < $as_echo "$ac_try_echo"; } >&5
3601 <  (eval "$ac_link") 2>&5
3602 <  ac_status=$?
3603 <  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3604 <  test $ac_status = 0; }; then :
3605 <  # If both `conftest.exe' and `conftest' are `present' (well, observable)
3606 < # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3607 < # work properly (i.e., refer to `conftest.exe'), while it won't with
3608 < # `rm'.
3609 < for ac_file in conftest.exe conftest conftest.*; do
3610 <  test -f "$ac_file" || continue
3611 <  case $ac_file in
3612 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3613 <    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3614 <          break;;
3615 <    * ) break;;
3616 <  esac
3617 < done
3618 < else
3619 <  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3620 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3621 < as_fn_error "cannot compute suffix of executables: cannot compile and link
3622 < See \`config.log' for more details." "$LINENO" 5; }
3623 < fi
3624 < rm -f conftest conftest$ac_cv_exeext
3625 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
3626 < $as_echo "$ac_cv_exeext" >&6; }
3627 <
3628 < rm -f conftest.$ac_ext
3629 < EXEEXT=$ac_cv_exeext
3630 < ac_exeext=$EXEEXT
3631 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3632 < /* end confdefs.h.  */
3633 < #include <stdio.h>
3634 < int
3635 < main ()
3636 < {
3637 < FILE *f = fopen ("conftest.out", "w");
3638 < return ferror (f) || fclose (f) != 0;
3639 <
3640 <  ;
3641 <  return 0;
3642 < }
3643 < _ACEOF
3644 < ac_clean_files="$ac_clean_files conftest.out"
3645 < # Check that the compiler produces executables we can run.  If not, either
3646 < # the compiler is broken, or we cross compile.
3647 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
3648 < $as_echo_n "checking whether we are cross compiling... " >&6; }
3649 < if test "$cross_compiling" != yes; then
3650 <  { { ac_try="$ac_link"
3651 < case "(($ac_try" in
3652 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3653 <  *) ac_try_echo=$ac_try;;
3654 < esac
3655 < eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3656 < $as_echo "$ac_try_echo"; } >&5
3657 <  (eval "$ac_link") 2>&5
3658 <  ac_status=$?
3659 <  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3660 <  test $ac_status = 0; }
3661 <  if { ac_try='./conftest$ac_cv_exeext'
3662 <  { { case "(($ac_try" in
3663 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3664 <  *) ac_try_echo=$ac_try;;
3665 < esac
3666 < eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3667 < $as_echo "$ac_try_echo"; } >&5
3668 <  (eval "$ac_try") 2>&5
3669 <  ac_status=$?
3670 <  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3671 <  test $ac_status = 0; }; }; then
3672 <    cross_compiling=no
3673 <  else
3674 <    if test "$cross_compiling" = maybe; then
3675 <        cross_compiling=yes
3676 <    else
3677 <        { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3678 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3679 < as_fn_error "cannot run C++ compiled programs.
3680 < If you meant to cross compile, use \`--host'.
3681 < See \`config.log' for more details." "$LINENO" 5; }
3682 <    fi
3683 <  fi
3684 < fi
3685 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
3686 < $as_echo "$cross_compiling" >&6; }
3687 <
3688 < rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
3689 < ac_clean_files=$ac_clean_files_save
3690 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
3691 < $as_echo_n "checking for suffix of object files... " >&6; }
3692 < if test "${ac_cv_objext+set}" = set; then :
3693 <  $as_echo_n "(cached) " >&6
3694 < else
3695 <  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3696 < /* end confdefs.h.  */
3697 <
3698 < int
3699 < main ()
3700 < {
3701 <
3702 <  ;
3703 <  return 0;
3704 < }
3705 < _ACEOF
3706 < rm -f conftest.o conftest.obj
3707 < if { { ac_try="$ac_compile"
3708 < case "(($ac_try" in
3709 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3710 <  *) ac_try_echo=$ac_try;;
3711 < esac
3712 < eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3713 < $as_echo "$ac_try_echo"; } >&5
3714 <  (eval "$ac_compile") 2>&5
3715 <  ac_status=$?
3716 <  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3717 <  test $ac_status = 0; }; then :
3718 <  for ac_file in conftest.o conftest.obj conftest.*; do
3719 <  test -f "$ac_file" || continue;
3720 <  case $ac_file in
3721 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
3722 <    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3723 <       break;;
3724 <  esac
3725 < done
3726 < else
3727 <  $as_echo "$as_me: failed program was:" >&5
3728 < sed 's/^/| /' conftest.$ac_ext >&5
3729 <
3730 < { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3731 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3732 < as_fn_error "cannot compute suffix of object files: cannot compile
3733 < See \`config.log' for more details." "$LINENO" 5; }
3734 < fi
3735 < rm -f conftest.$ac_cv_objext conftest.$ac_ext
3736 < fi
3737 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
3738 < $as_echo "$ac_cv_objext" >&6; }
3739 < OBJEXT=$ac_cv_objext
3740 < ac_objext=$OBJEXT
3741 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
3742 < $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3743 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
3744 <  $as_echo_n "(cached) " >&6
3745 < else
3746 <  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3747 < /* end confdefs.h.  */
3748 <
3749 < int
3750 < main ()
3751 < {
3752 < #ifndef __GNUC__
3753 <       choke me
3754 < #endif
3755 <
3756 <  ;
3757 <  return 0;
3758 < }
3759 < _ACEOF
3760 < if ac_fn_cxx_try_compile "$LINENO"; then :
3761 <  ac_compiler_gnu=yes
3762 < else
3763 <  ac_compiler_gnu=no
3764 < fi
3765 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3766 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3767 <
3768 < fi
3769 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
3770 < $as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
3771 < if test $ac_compiler_gnu = yes; then
3772 <  GXX=yes
3773 < else
3774 <  GXX=
3775 < fi
3776 < ac_test_CXXFLAGS=${CXXFLAGS+set}
3777 < ac_save_CXXFLAGS=$CXXFLAGS
3778 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
3779 < $as_echo_n "checking whether $CXX accepts -g... " >&6; }
3780 < if test "${ac_cv_prog_cxx_g+set}" = set; then :
3781 <  $as_echo_n "(cached) " >&6
3782 < else
3783 <  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
3784 <   ac_cxx_werror_flag=yes
3785 <   ac_cv_prog_cxx_g=no
3786 <   CXXFLAGS="-g"
3787 <   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3788 < /* end confdefs.h.  */
3789 <
3790 < int
3791 < main ()
3792 < {
3793 <
3794 <  ;
3795 <  return 0;
3796 < }
3797 < _ACEOF
3798 < if ac_fn_cxx_try_compile "$LINENO"; then :
3799 <  ac_cv_prog_cxx_g=yes
3800 < else
3801 <  CXXFLAGS=""
3802 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3803 < /* end confdefs.h.  */
3804 <
3805 < int
3806 < main ()
3807 < {
3808 <
3809 <  ;
3810 <  return 0;
3811 < }
3812 < _ACEOF
3813 < if ac_fn_cxx_try_compile "$LINENO"; then :
3814 <
3815 < else
3816 <  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3817 <         CXXFLAGS="-g"
3818 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3819 < /* end confdefs.h.  */
3820 <
3821 < int
3822 < main ()
3823 < {
3824 <
3825 <  ;
3826 <  return 0;
3827 < }
3828 < _ACEOF
3829 < if ac_fn_cxx_try_compile "$LINENO"; then :
3830 <  ac_cv_prog_cxx_g=yes
3831 < fi
3832 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3833 < fi
3834 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3835 < fi
3836 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3837 <   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3838 < fi
3839 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
3840 < $as_echo "$ac_cv_prog_cxx_g" >&6; }
3841 < if test "$ac_test_CXXFLAGS" = set; then
3842 <  CXXFLAGS=$ac_save_CXXFLAGS
3843 < elif test $ac_cv_prog_cxx_g = yes; then
3844 <  if test "$GXX" = yes; then
3845 <    CXXFLAGS="-g -O2"
3846 <  else
3847 <    CXXFLAGS="-g"
3848 <  fi
3849 < else
3850 <  if test "$GXX" = yes; then
3851 <    CXXFLAGS="-O2"
3852 <  else
3853 <    CXXFLAGS=
3854 <  fi
3855 < fi
3856 < ac_ext=cpp
3857 < ac_cpp='$CXXCPP $CPPFLAGS'
3858 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3859 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3860 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3861 <
3862 <
3863 <
3864 <
3865 <
3866 <
3867 <
3868 <        for ac_prog in openmpicxx openmpiCC openmpic++ mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++
3869 < do
3870 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3871 < set dummy $ac_prog; ac_word=$2
3872 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3873 < $as_echo_n "checking for $ac_word... " >&6; }
3874 < if test "${ac_cv_prog_MPICXX+set}" = set; then :
3875 <  $as_echo_n "(cached) " >&6
3876 < else
3877 <  if test -n "$MPICXX"; then
3878 <  ac_cv_prog_MPICXX="$MPICXX" # Let the user override the test.
3879 < else
3880 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3881 < for as_dir in $PATH
3882 < do
3883 <  IFS=$as_save_IFS
3884 <  test -z "$as_dir" && as_dir=.
3885 <    for ac_exec_ext in '' $ac_executable_extensions; do
3886 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3887 <    ac_cv_prog_MPICXX="$ac_prog"
3888 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3889 <    break 2
3890 <  fi
3891 < done
3892 <  done
3893 < IFS=$as_save_IFS
3894 <
3895 < fi
3896 < fi
3897 < MPICXX=$ac_cv_prog_MPICXX
3898 < if test -n "$MPICXX"; then
3899 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICXX" >&5
3900 < $as_echo "$MPICXX" >&6; }
3901 < else
3902 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3903 < $as_echo "no" >&6; }
3904 < fi
3905 <
3906 <
3907 <  test -n "$MPICXX" && break
3908 < done
3909 < test -n "$MPICXX" || MPICXX="$CXX"
3910 <
3911 <        ax_mpi_save_CXX="$CXX"
3912 <        CXX="$MPICXX"
3913 <
3914 <
3915 <
3916 < if test x = x"$MPILIBS"; then
3917 <        ac_fn_cxx_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
3918 < if test "x$ac_cv_func_MPI_Init" = x""yes; then :
3919 <  MPILIBS=" "
3920 < fi
3921 <
3922 < fi
3923 <
3924 < if test x = x"$MPILIBS"; then
3925 <        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
3926 < $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
3927 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
3928 <  $as_echo_n "(cached) " >&6
3929 < else
3930 <  ac_check_lib_save_LIBS=$LIBS
3931 < LIBS="-lmpi  $LIBS"
3932 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3933 < /* end confdefs.h.  */
3934 <
3935 < /* Override any GCC internal prototype to avoid an error.
3936 <   Use char because int might match the return type of a GCC
3937 <   builtin and then its argument prototype would still apply.  */
3938 < #ifdef __cplusplus
3939 < extern "C"
3940 < #endif
3941 < char MPI_Init ();
3942 < int
3943 < main ()
3944 < {
3945 < return MPI_Init ();
3946 <  ;
3947 <  return 0;
3948 < }
3949 < _ACEOF
3950 < if ac_fn_cxx_try_link "$LINENO"; then :
3951 <  ac_cv_lib_mpi_MPI_Init=yes
3952 < else
3953 <  ac_cv_lib_mpi_MPI_Init=no
3954 < fi
3955 < rm -f core conftest.err conftest.$ac_objext \
3956 <    conftest$ac_exeext conftest.$ac_ext
3957 < LIBS=$ac_check_lib_save_LIBS
3958 < fi
3959 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
3960 < $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
3961 < if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
3962 <  MPILIBS="-lmpi"
3963 < fi
3964 <
3965 < fi
3966 < if test x = x"$MPILIBS"; then
3967 <        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
3968 < $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
3969 < if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
3970 <  $as_echo_n "(cached) " >&6
3971 < else
3972 <  ac_check_lib_save_LIBS=$LIBS
3973 < LIBS="-lmpich  $LIBS"
3974 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3975 < /* end confdefs.h.  */
3976 <
3977 < /* Override any GCC internal prototype to avoid an error.
3978 <   Use char because int might match the return type of a GCC
3979 <   builtin and then its argument prototype would still apply.  */
3980 < #ifdef __cplusplus
3981 < extern "C"
3982 < #endif
3983 < char MPI_Init ();
3984 < int
3985 < main ()
3986 < {
3987 < return MPI_Init ();
3988 <  ;
3989 <  return 0;
3990 < }
3991 < _ACEOF
3992 < if ac_fn_cxx_try_link "$LINENO"; then :
3993 <  ac_cv_lib_mpich_MPI_Init=yes
3994 < else
3995 <  ac_cv_lib_mpich_MPI_Init=no
3996 < fi
3997 < rm -f core conftest.err conftest.$ac_objext \
3998 <    conftest$ac_exeext conftest.$ac_ext
3999 < LIBS=$ac_check_lib_save_LIBS
4000 < fi
4001 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4002 < $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4003 < if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4004 <  MPILIBS="-lmpich"
4005 < fi
4006 <
4007 < fi
4008 <
4009 < if test x != x"$MPILIBS"; then
4010 <        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4011 < $as_echo_n "checking for mpi.h... " >&6; }
4012 <        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4013 < /* end confdefs.h.  */
4014 < #include <mpi.h>
4015 < int
4016 < main ()
4017 < {
4018 <
4019 <  ;
4020 <  return 0;
4021 < }
4022 < _ACEOF
4023 < if ac_fn_cxx_try_compile "$LINENO"; then :
4024 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4025 < $as_echo "yes" >&6; }
4026 < else
4027 <  MPILIBS=""
4028 <                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4029 < $as_echo "no" >&6; }
4030 < fi
4031 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4032 < fi
4033 <
4034 < CXX="$ax_mpi_save_CXX"
4035 <
4036 <
4037 <
4038 < # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4039 < if test x = x"$MPILIBS"; then
4040 <        USE_MPI="no"
4041 <       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&5
4042 < $as_echo "$as_me: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&2;}
4043 <        :
4044 < else
4045 <        USE_MPI="yes"
4046 <        :
4047 < fi
4048 <
4049 < ac_ext=c
4050 < ac_cpp='$CPP $CPPFLAGS'
4051 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4052 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4053 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4054 < if test -n "$ac_tool_prefix"; then
4055 <  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
4056 < set dummy ${ac_tool_prefix}gcc; ac_word=$2
4057 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4058 < $as_echo_n "checking for $ac_word... " >&6; }
4059 < if test "${ac_cv_prog_CC+set}" = set; then :
4060 <  $as_echo_n "(cached) " >&6
4061 < else
4062 <  if test -n "$CC"; then
4063 <  ac_cv_prog_CC="$CC" # Let the user override the test.
4064 < else
4065 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4066 < for as_dir in $PATH
4067 < do
4068 <  IFS=$as_save_IFS
4069 <  test -z "$as_dir" && as_dir=.
4070 <    for ac_exec_ext in '' $ac_executable_extensions; do
4071 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4072 <    ac_cv_prog_CC="${ac_tool_prefix}gcc"
4073 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4074 <    break 2
4075 <  fi
4076 < done
4077 <  done
4078 < IFS=$as_save_IFS
4079 <
4080 < fi
4081 < fi
4082 < CC=$ac_cv_prog_CC
4083 < if test -n "$CC"; then
4084 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4085 < $as_echo "$CC" >&6; }
4086 < else
4087 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4088 < $as_echo "no" >&6; }
4089 < fi
4090 <
4091 <
4092 < fi
4093 < if test -z "$ac_cv_prog_CC"; then
4094 <  ac_ct_CC=$CC
4095 <  # Extract the first word of "gcc", so it can be a program name with args.
4096 < set dummy gcc; ac_word=$2
4097 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4098 < $as_echo_n "checking for $ac_word... " >&6; }
4099 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
4100 <  $as_echo_n "(cached) " >&6
4101 < else
4102 <  if test -n "$ac_ct_CC"; then
4103 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4104 < else
4105 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4106 < for as_dir in $PATH
4107 < do
4108 <  IFS=$as_save_IFS
4109 <  test -z "$as_dir" && as_dir=.
4110 <    for ac_exec_ext in '' $ac_executable_extensions; do
4111 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4112 <    ac_cv_prog_ac_ct_CC="gcc"
4113 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4114 <    break 2
4115 <  fi
4116 < done
4117 <  done
4118 < IFS=$as_save_IFS
4119 <
4120 < fi
4121 < fi
4122 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
4123 < if test -n "$ac_ct_CC"; then
4124 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
4125 < $as_echo "$ac_ct_CC" >&6; }
4126 < else
4127 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4128 < $as_echo "no" >&6; }
4129 < fi
4130 <
4131 <  if test "x$ac_ct_CC" = x; then
4132 <    CC=""
4133 <  else
4134 <    case $cross_compiling:$ac_tool_warned in
4135 < yes:)
4136 < { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4137 < $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4138 < ac_tool_warned=yes ;;
4139 < esac
4140 <    CC=$ac_ct_CC
4141 <  fi
4142 < else
4143 <  CC="$ac_cv_prog_CC"
4144 < fi
4145 <
4146 < if test -z "$CC"; then
4147 <          if test -n "$ac_tool_prefix"; then
4148 <    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
4149 < set dummy ${ac_tool_prefix}cc; ac_word=$2
4150 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4151 < $as_echo_n "checking for $ac_word... " >&6; }
4152 < if test "${ac_cv_prog_CC+set}" = set; then :
4153 <  $as_echo_n "(cached) " >&6
4154 < else
4155 <  if test -n "$CC"; then
4156 <  ac_cv_prog_CC="$CC" # Let the user override the test.
4157 < else
4158 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4159 < for as_dir in $PATH
4160 < do
4161 <  IFS=$as_save_IFS
4162 <  test -z "$as_dir" && as_dir=.
4163 <    for ac_exec_ext in '' $ac_executable_extensions; do
4164 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4165 <    ac_cv_prog_CC="${ac_tool_prefix}cc"
4166 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4167 <    break 2
4168 <  fi
4169 < done
4170 <  done
4171 < IFS=$as_save_IFS
4172 <
4173 < fi
4174 < fi
4175 < CC=$ac_cv_prog_CC
4176 < if test -n "$CC"; then
4177 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4178 < $as_echo "$CC" >&6; }
4179 < else
4180 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4181 < $as_echo "no" >&6; }
4182 < fi
4183 <
4184 <
4185 <  fi
4186 < fi
4187 < if test -z "$CC"; then
4188 <  # Extract the first word of "cc", so it can be a program name with args.
4189 < set dummy cc; ac_word=$2
4190 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4191 < $as_echo_n "checking for $ac_word... " >&6; }
4192 < if test "${ac_cv_prog_CC+set}" = set; then :
4193 <  $as_echo_n "(cached) " >&6
4194 < else
4195 <  if test -n "$CC"; then
4196 <  ac_cv_prog_CC="$CC" # Let the user override the test.
4197 < else
4198 <  ac_prog_rejected=no
4199 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4200 < for as_dir in $PATH
4201 < do
4202 <  IFS=$as_save_IFS
4203 <  test -z "$as_dir" && as_dir=.
4204 <    for ac_exec_ext in '' $ac_executable_extensions; do
4205 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4206 <    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
4207 <       ac_prog_rejected=yes
4208 <       continue
4209 <     fi
4210 <    ac_cv_prog_CC="cc"
4211 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4212 <    break 2
4213 <  fi
4214 < done
4215 <  done
4216 < IFS=$as_save_IFS
4217 <
4218 < if test $ac_prog_rejected = yes; then
4219 <  # We found a bogon in the path, so make sure we never use it.
4220 <  set dummy $ac_cv_prog_CC
4221 <  shift
4222 <  if test $# != 0; then
4223 <    # We chose a different compiler from the bogus one.
4224 <    # However, it has the same basename, so the bogon will be chosen
4225 <    # first if we set CC to just the basename; use the full file name.
4226 <    shift
4227 <    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
4228 <  fi
4229 < fi
4230 < fi
4231 < fi
4232 < CC=$ac_cv_prog_CC
4233 < if test -n "$CC"; then
4234 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4235 < $as_echo "$CC" >&6; }
4236 < else
4237 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4238 < $as_echo "no" >&6; }
4239 < fi
4240 <
4241 <
4242 < fi
4243 < if test -z "$CC"; then
4244 <  if test -n "$ac_tool_prefix"; then
4245 <  for ac_prog in cl.exe
4246 <  do
4247 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4248 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4249 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4250 < $as_echo_n "checking for $ac_word... " >&6; }
4251 < if test "${ac_cv_prog_CC+set}" = set; then :
4252 <  $as_echo_n "(cached) " >&6
4253 < else
4254 <  if test -n "$CC"; then
4255 <  ac_cv_prog_CC="$CC" # Let the user override the test.
4256 < else
4257 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4258 < for as_dir in $PATH
4259 < do
4260 <  IFS=$as_save_IFS
4261 <  test -z "$as_dir" && as_dir=.
4262 <    for ac_exec_ext in '' $ac_executable_extensions; do
4263 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4264 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
4265 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4266 <    break 2
4267 <  fi
4268 < done
4269 <  done
4270 < IFS=$as_save_IFS
4271 <
4272 < fi
4273 < fi
4274 < CC=$ac_cv_prog_CC
4275 < if test -n "$CC"; then
4276 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4277 < $as_echo "$CC" >&6; }
4278 < else
4279 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4280 < $as_echo "no" >&6; }
4281 < fi
4282 <
4283 <
4284 <    test -n "$CC" && break
4285 <  done
4286 < fi
4287 < if test -z "$CC"; then
4288 <  ac_ct_CC=$CC
4289 <  for ac_prog in cl.exe
4290 < do
4291 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
4292 < set dummy $ac_prog; ac_word=$2
4293 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4294 < $as_echo_n "checking for $ac_word... " >&6; }
4295 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
4296 <  $as_echo_n "(cached) " >&6
4297 < else
4298 <  if test -n "$ac_ct_CC"; then
4299 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4300 < else
4301 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4302 < for as_dir in $PATH
4303 < do
4304 <  IFS=$as_save_IFS
4305 <  test -z "$as_dir" && as_dir=.
4306 <    for ac_exec_ext in '' $ac_executable_extensions; do
4307 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4308 <    ac_cv_prog_ac_ct_CC="$ac_prog"
4309 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4310 <    break 2
4311 <  fi
4312 < done
4313 <  done
4314 < IFS=$as_save_IFS
4315 <
4316 < fi
4317 < fi
4318 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
4319 < if test -n "$ac_ct_CC"; then
4320 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
4321 < $as_echo "$ac_ct_CC" >&6; }
4322 < else
4323 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4324 < $as_echo "no" >&6; }
4325 < fi
4326 <
4327 <
4328 <  test -n "$ac_ct_CC" && break
4329 < done
4330 <
4331 <  if test "x$ac_ct_CC" = x; then
4332 <    CC=""
4333 <  else
4334 <    case $cross_compiling:$ac_tool_warned in
4335 < yes:)
4336 < { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4337 < $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4338 < ac_tool_warned=yes ;;
4339 < esac
4340 <    CC=$ac_ct_CC
4341 <  fi
4342 < fi
4343 <
4344 < fi
4345 <
4346 <
4347 < test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
4348 < $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
4349 < as_fn_error "no acceptable C compiler found in \$PATH
4350 < See \`config.log' for more details." "$LINENO" 5; }
4351 <
4352 < # Provide some information about the compiler.
4353 < $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
4354 < set X $ac_compile
4355 < ac_compiler=$2
4356 < for ac_option in --version -v -V -qversion; do
4357 <  { { ac_try="$ac_compiler $ac_option >&5"
4358 < case "(($ac_try" in
4359 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4360 <  *) ac_try_echo=$ac_try;;
4361 < esac
4362 < eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
4363 < $as_echo "$ac_try_echo"; } >&5
4364 <  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
4365 <  ac_status=$?
4366 <  if test -s conftest.err; then
4367 <    sed '10a\
4368 < ... rest of stderr output deleted ...
4369 <         10q' conftest.err >conftest.er1
4370 <    cat conftest.er1 >&5
4371 <  fi
4372 <  rm -f conftest.er1 conftest.err
4373 <  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
4374 <  test $ac_status = 0; }
4375 < done
4376 <
4377 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
4378 < $as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
4379 < if test "${ac_cv_c_compiler_gnu+set}" = set; then :
4380 <  $as_echo_n "(cached) " >&6
4381 < else
4382 <  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4383 < /* end confdefs.h.  */
4384 <
4385 < int
4386 < main ()
4387 < {
4388 < #ifndef __GNUC__
4389 <       choke me
4390 < #endif
4391 <
4392 <  ;
4393 <  return 0;
4394 < }
4395 < _ACEOF
4396 < if ac_fn_c_try_compile "$LINENO"; then :
4397 <  ac_compiler_gnu=yes
4398 < else
4399 <  ac_compiler_gnu=no
4400 < fi
4401 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4402 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
4403 <
4404 < fi
4405 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
4406 < $as_echo "$ac_cv_c_compiler_gnu" >&6; }
4407 < if test $ac_compiler_gnu = yes; then
4408 <  GCC=yes
4409 < else
4410 <  GCC=
4411 < fi
4412 < ac_test_CFLAGS=${CFLAGS+set}
4413 < ac_save_CFLAGS=$CFLAGS
4414 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
4415 < $as_echo_n "checking whether $CC accepts -g... " >&6; }
4416 < if test "${ac_cv_prog_cc_g+set}" = set; then :
4417 <  $as_echo_n "(cached) " >&6
4418 < else
4419 <  ac_save_c_werror_flag=$ac_c_werror_flag
4420 <   ac_c_werror_flag=yes
4421 <   ac_cv_prog_cc_g=no
4422 <   CFLAGS="-g"
4423 <   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4424 < /* end confdefs.h.  */
4425 <
4426 < int
4427 < main ()
4428 < {
4429 <
4430 <  ;
4431 <  return 0;
4432 < }
4433 < _ACEOF
4434 < if ac_fn_c_try_compile "$LINENO"; then :
4435 <  ac_cv_prog_cc_g=yes
4436 < else
4437 <  CFLAGS=""
4438 <      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4439 < /* end confdefs.h.  */
4440 <
4441 < int
4442 < main ()
4443 < {
4444 <
4445 <  ;
4446 <  return 0;
4447 < }
4448 < _ACEOF
4449 < if ac_fn_c_try_compile "$LINENO"; then :
4450 <
4451 < else
4452 <  ac_c_werror_flag=$ac_save_c_werror_flag
4453 <         CFLAGS="-g"
4454 <         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4455 < /* end confdefs.h.  */
4456 <
4457 < int
4458 < main ()
4459 < {
4460 <
4461 <  ;
4462 <  return 0;
4463 < }
4464 < _ACEOF
4465 < if ac_fn_c_try_compile "$LINENO"; then :
4466 <  ac_cv_prog_cc_g=yes
4467 < fi
4468 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4469 < fi
4470 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4471 < fi
4472 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4473 <   ac_c_werror_flag=$ac_save_c_werror_flag
4474 < fi
4475 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
4476 < $as_echo "$ac_cv_prog_cc_g" >&6; }
4477 < if test "$ac_test_CFLAGS" = set; then
4478 <  CFLAGS=$ac_save_CFLAGS
4479 < elif test $ac_cv_prog_cc_g = yes; then
4480 <  if test "$GCC" = yes; then
4481 <    CFLAGS="-g -O2"
4482 <  else
4483 <    CFLAGS="-g"
4484 <  fi
4485 < else
4486 <  if test "$GCC" = yes; then
4487 <    CFLAGS="-O2"
4488 <  else
4489 <    CFLAGS=
4490 <  fi
4491 < fi
4492 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
4493 < $as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
4494 < if test "${ac_cv_prog_cc_c89+set}" = set; then :
4495 <  $as_echo_n "(cached) " >&6
4496 < else
4497 <  ac_cv_prog_cc_c89=no
4498 < ac_save_CC=$CC
4499 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4500 < /* end confdefs.h.  */
4501 < #include <stdarg.h>
4502 < #include <stdio.h>
4503 < #include <sys/types.h>
4504 < #include <sys/stat.h>
4505 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
4506 < struct buf { int x; };
4507 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
4508 < static char *e (p, i)
4509 <     char **p;
4510 <     int i;
4511 < {
4512 <  return p[i];
4513 < }
4514 < static char *f (char * (*g) (char **, int), char **p, ...)
4515 < {
4516 <  char *s;
4517 <  va_list v;
4518 <  va_start (v,p);
4519 <  s = g (p, va_arg (v,int));
4520 <  va_end (v);
4521 <  return s;
4522 < }
4523 <
4524 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
4525 <   function prototypes and stuff, but not '\xHH' hex character constants.
4526 <   These don't provoke an error unfortunately, instead are silently treated
4527 <   as 'x'.  The following induces an error, until -std is added to get
4528 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
4529 <   array size at least.  It's necessary to write '\x00'==0 to get something
4530 <   that's true only with -std.  */
4531 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
4532 <
4533 < /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
4534 <   inside strings and character constants.  */
4535 < #define FOO(x) 'x'
4536 < int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
4537 <
4538 < int test (int i, double x);
4539 < struct s1 {int (*f) (int a);};
4540 < struct s2 {int (*f) (double a);};
4541 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
4542 < int argc;
4543 < char **argv;
4544 < int
4545 < main ()
4546 < {
4547 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
4548 <  ;
4549 <  return 0;
4550 < }
4551 < _ACEOF
4552 < for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
4553 <        -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
4554 < do
4555 <  CC="$ac_save_CC $ac_arg"
4556 <  if ac_fn_c_try_compile "$LINENO"; then :
4557 <  ac_cv_prog_cc_c89=$ac_arg
4558 < fi
4559 < rm -f core conftest.err conftest.$ac_objext
4560 <  test "x$ac_cv_prog_cc_c89" != "xno" && break
4561 < done
4562 < rm -f conftest.$ac_ext
4563 < CC=$ac_save_CC
4564 <
4565 < fi
4566 < # AC_CACHE_VAL
4567 < case "x$ac_cv_prog_cc_c89" in
4568 <  x)
4569 <    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
4570 < $as_echo "none needed" >&6; } ;;
4571 <  xno)
4572 <    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
4573 < $as_echo "unsupported" >&6; } ;;
4574 <  *)
4575 <    CC="$CC $ac_cv_prog_cc_c89"
4576 <    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
4577 < $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
4578 < esac
4579 < if test "x$ac_cv_prog_cc_c89" != xno; then :
4580 <
4581 < fi
4582 <
4583 < ac_ext=c
4584 < ac_cpp='$CPP $CPPFLAGS'
4585 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4586 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4587 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4588 <
4589 <
4590 < if test $USE_MPI != no; then :
4591 <
4592 < ac_ext=c
4593 < ac_cpp='$CPP $CPPFLAGS'
4594 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4595 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4596 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4597 <
4598 <
4599 <
4600 <
4601 <
4602 <
4603 <        for ac_prog in openmpicc mpicc hcc mpxlc_r mpxlc mpcc cmpicc
4604 < do
4605 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
4606 < set dummy $ac_prog; ac_word=$2
4607 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4608 < $as_echo_n "checking for $ac_word... " >&6; }
4609 < if test "${ac_cv_prog_MPICC+set}" = set; then :
4610 <  $as_echo_n "(cached) " >&6
4611 < else
4612 <  if test -n "$MPICC"; then
4613 <  ac_cv_prog_MPICC="$MPICC" # Let the user override the test.
4614 < else
4615 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4616 < for as_dir in $PATH
4617 < do
4618 <  IFS=$as_save_IFS
4619 <  test -z "$as_dir" && as_dir=.
4620 <    for ac_exec_ext in '' $ac_executable_extensions; do
4621 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4622 <    ac_cv_prog_MPICC="$ac_prog"
4623 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4624 <    break 2
4625 <  fi
4626 < done
4627 <  done
4628 < IFS=$as_save_IFS
4629 <
4630 < fi
4631 < fi
4632 < MPICC=$ac_cv_prog_MPICC
4633 < if test -n "$MPICC"; then
4634 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICC" >&5
4635 < $as_echo "$MPICC" >&6; }
4636 < else
4637 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4638 < $as_echo "no" >&6; }
4639 < fi
4640 <
4641 <
4642 <  test -n "$MPICC" && break
4643 < done
4644 < test -n "$MPICC" || MPICC="$CC"
4645 <
4646 <        ax_mpi_save_CC="$CC"
4647 <        CC="$MPICC"
4648 <
4649 <
4650 <
4651 < if test x = x"$MPILIBS"; then
4652 <        ac_fn_c_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4653 < if test "x$ac_cv_func_MPI_Init" = x""yes; then :
4654 <  MPILIBS=" "
4655 < fi
4656 <
4657 < fi
4658 <
4659 < if test x = x"$MPILIBS"; then
4660 <        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4661 < $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4662 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4663 <  $as_echo_n "(cached) " >&6
4664 < else
4665 <  ac_check_lib_save_LIBS=$LIBS
4666 < LIBS="-lmpi  $LIBS"
4667 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4668 < /* end confdefs.h.  */
4669 <
4670 < /* Override any GCC internal prototype to avoid an error.
4671 <   Use char because int might match the return type of a GCC
4672 <   builtin and then its argument prototype would still apply.  */
4673 < #ifdef __cplusplus
4674 < extern "C"
4675 < #endif
4676 < char MPI_Init ();
4677 < int
4678 < main ()
4679 < {
4680 < return MPI_Init ();
4681 <  ;
4682 <  return 0;
4683 < }
4684 < _ACEOF
4685 < if ac_fn_c_try_link "$LINENO"; then :
4686 <  ac_cv_lib_mpi_MPI_Init=yes
4687 < else
4688 <  ac_cv_lib_mpi_MPI_Init=no
4689 < fi
4690 < rm -f core conftest.err conftest.$ac_objext \
4691 <    conftest$ac_exeext conftest.$ac_ext
4692 < LIBS=$ac_check_lib_save_LIBS
4693 < fi
4694 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4695 < $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4696 < if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4697 <  MPILIBS="-lmpi"
4698 < fi
4699 <
4700 < fi
4701 < if test x = x"$MPILIBS"; then
4702 <        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4703 < $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4704 < if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4705 <  $as_echo_n "(cached) " >&6
4706 < else
4707 <  ac_check_lib_save_LIBS=$LIBS
4708 < LIBS="-lmpich  $LIBS"
4709 < cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4710 < /* end confdefs.h.  */
4711 <
4712 < /* Override any GCC internal prototype to avoid an error.
4713 <   Use char because int might match the return type of a GCC
4714 <   builtin and then its argument prototype would still apply.  */
4715 < #ifdef __cplusplus
4716 < extern "C"
4717 < #endif
4718 < char MPI_Init ();
4719 < int
4720 < main ()
4721 < {
4722 < return MPI_Init ();
4723 <  ;
4724 <  return 0;
4725 < }
4726 < _ACEOF
4727 < if ac_fn_c_try_link "$LINENO"; then :
4728 <  ac_cv_lib_mpich_MPI_Init=yes
4729 < else
4730 <  ac_cv_lib_mpich_MPI_Init=no
4731 < fi
4732 < rm -f core conftest.err conftest.$ac_objext \
4733 <    conftest$ac_exeext conftest.$ac_ext
4734 < LIBS=$ac_check_lib_save_LIBS
4735 < fi
4736 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4737 < $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4738 < if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4739 <  MPILIBS="-lmpich"
4740 < fi
4741 <
4742 < fi
4743 <
4744 < if test x != x"$MPILIBS"; then
4745 <        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4746 < $as_echo_n "checking for mpi.h... " >&6; }
4747 <        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4748 < /* end confdefs.h.  */
4749 < #include <mpi.h>
4750 < int
4751 < main ()
4752 < {
4753 <
4754 <  ;
4755 <  return 0;
4756 < }
4757 < _ACEOF
4758 < if ac_fn_c_try_compile "$LINENO"; then :
4759 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4760 < $as_echo "yes" >&6; }
4761 < else
4762 <  MPILIBS=""
4763 <                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4764 < $as_echo "no" >&6; }
4765 < fi
4766 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4767 < fi
4768 <
4769 < CC="$ax_mpi_save_CC"
4770 <
4771 <
4772 <
4773 < # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4774 < if test x = x"$MPILIBS"; then
4775 <        USE_MPI="no"
4776 <       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&5
4777 < $as_echo "$as_me: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&2;}
4778 <        :
4779 < else
4780 <        USE_MPI="yes"
4781 <        :
4782 < fi
4783 <
4784 <
4785 < fi
4786 < ac_ext=${ac_fc_srcext-f}
4787 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4788 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4789 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4790 < if test -n "$ac_tool_prefix"; then
4791 <  for ac_prog in gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn xlf90 f90 pgf90 pghpf epcf90 g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77
4792 <  do
4793 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4794 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4795 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4796 < $as_echo_n "checking for $ac_word... " >&6; }
4797 < if test "${ac_cv_prog_FC+set}" = set; then :
4798 <  $as_echo_n "(cached) " >&6
4799 < else
4800 <  if test -n "$FC"; then
4801 <  ac_cv_prog_FC="$FC" # Let the user override the test.
4802 < else
4803 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4804 < for as_dir in $PATH
4805 < do
4806 <  IFS=$as_save_IFS
4807 <  test -z "$as_dir" && as_dir=.
4808 <    for ac_exec_ext in '' $ac_executable_extensions; do
4809 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4810 <    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4811 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4812 <    break 2
4813 <  fi
4814 < done
4815 <  done
4816 < IFS=$as_save_IFS
4817 <
4818 < fi
4819 < fi
4820 < FC=$ac_cv_prog_FC
4821 < if test -n "$FC"; then
4822 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FC" >&5
4823 < $as_echo "$FC" >&6; }
4824 < else
4825 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4826 < $as_echo "no" >&6; }
4827 < fi
4828 <
4829 <
4830 <    test -n "$FC" && break
4831 <  done
4832 < fi
4833 < if test -z "$FC"; then
4834 <  ac_ct_FC=$FC
4835 <  for ac_prog in gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn xlf90 f90 pgf90 pghpf epcf90 g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77
4836 < do
4837 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
4838 < set dummy $ac_prog; ac_word=$2
4839 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4840 < $as_echo_n "checking for $ac_word... " >&6; }
4841 < if test "${ac_cv_prog_ac_ct_FC+set}" = set; then :
4842 <  $as_echo_n "(cached) " >&6
4843 < else
4844 <  if test -n "$ac_ct_FC"; then
4845 <  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4846 < else
4847 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4848 < for as_dir in $PATH
4849 < do
4850 <  IFS=$as_save_IFS
4851 <  test -z "$as_dir" && as_dir=.
4852 <    for ac_exec_ext in '' $ac_executable_extensions; do
4853 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4854 <    ac_cv_prog_ac_ct_FC="$ac_prog"
4855 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4856 <    break 2
4857 <  fi
4858 < done
4859 <  done
4860 < IFS=$as_save_IFS
4861 <
4862 < fi
4863 < fi
4864 < ac_ct_FC=$ac_cv_prog_ac_ct_FC
4865 < if test -n "$ac_ct_FC"; then
4866 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_FC" >&5
4867 < $as_echo "$ac_ct_FC" >&6; }
4868 < else
4869 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4870 < $as_echo "no" >&6; }
4871 < fi
4872 <
4873 <
4874 <  test -n "$ac_ct_FC" && break
4875 < done
4876 <
4877 <  if test "x$ac_ct_FC" = x; then
4878 <    FC=""
4879 <  else
4880 <    case $cross_compiling:$ac_tool_warned in
4881 < yes:)
4882 < { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4883 < $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4884 < ac_tool_warned=yes ;;
4885 < esac
4886 <    FC=$ac_ct_FC
4887 <  fi
4888 < fi
4889 <
4890 <
4891 < # Provide some information about the compiler.
4892 < $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran compiler version" >&5
4893 < set X $ac_compile
4894 < ac_compiler=$2
4895 < for ac_option in --version -v -V -qversion; do
4896 <  { { ac_try="$ac_compiler $ac_option >&5"
4897 < case "(($ac_try" in
4898 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4899 <  *) ac_try_echo=$ac_try;;
4900 < esac
4901 < eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
4902 < $as_echo "$ac_try_echo"; } >&5
4903 <  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
4904 <  ac_status=$?
4905 <  if test -s conftest.err; then
4906 <    sed '10a\
4907 < ... rest of stderr output deleted ...
4908 <         10q' conftest.err >conftest.er1
4909 <    cat conftest.er1 >&5
4910 <  fi
4911 <  rm -f conftest.er1 conftest.err
4912 <  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
4913 <  test $ac_status = 0; }
4914 < done
4915 < rm -f a.out
4916 <
4917 < # If we don't use `.F' as extension, the preprocessor is not run on the
4918 < # input file.  (Note that this only needs to work for GNU compilers.)
4919 < ac_save_ext=$ac_ext
4920 < ac_ext=F
4921 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Fortran compiler" >&5
4922 < $as_echo_n "checking whether we are using the GNU Fortran compiler... " >&6; }
4923 < if test "${ac_cv_fc_compiler_gnu+set}" = set; then :
4924 <  $as_echo_n "(cached) " >&6
4925 < else
4926 <  cat > conftest.$ac_ext <<_ACEOF
4927 <      program main
4928 < #ifndef __GNUC__
4929 <       choke me
4930 < #endif
4931 <
4932 <      end
4933 < _ACEOF
4934 < if ac_fn_fc_try_compile "$LINENO"; then :
4935 <  ac_compiler_gnu=yes
4936 < else
4937 <  ac_compiler_gnu=no
4938 < fi
4939 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4940 < ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4941 <
4942 < fi
4943 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_compiler_gnu" >&5
4944 < $as_echo "$ac_cv_fc_compiler_gnu" >&6; }
4945 < ac_ext=$ac_save_ext
4946 < ac_test_FCFLAGS=${FCFLAGS+set}
4947 < ac_save_FCFLAGS=$FCFLAGS
4948 < FCFLAGS=
4949 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $FC accepts -g" >&5
4950 < $as_echo_n "checking whether $FC accepts -g... " >&6; }
4951 < if test "${ac_cv_prog_fc_g+set}" = set; then :
4952 <  $as_echo_n "(cached) " >&6
4953 < else
4954 <  FCFLAGS=-g
4955 < cat > conftest.$ac_ext <<_ACEOF
4956 <      program main
4957 <
4958 <      end
4959 < _ACEOF
4960 < if ac_fn_fc_try_compile "$LINENO"; then :
4961 <  ac_cv_prog_fc_g=yes
4962 < else
4963 <  ac_cv_prog_fc_g=no
4964 < fi
4965 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4966 <
4967 < fi
4968 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_fc_g" >&5
4969 < $as_echo "$ac_cv_prog_fc_g" >&6; }
4970 < if test "$ac_test_FCFLAGS" = set; then
4971 <  FCFLAGS=$ac_save_FCFLAGS
4972 < elif test $ac_cv_prog_fc_g = yes; then
4973 <  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4974 <    FCFLAGS="-g -O2"
4975 <  else
4976 <    FCFLAGS="-g"
4977 <  fi
4978 < else
4979 <  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4980 <    FCFLAGS="-O2"
4981 <  else
4982 <    FCFLAGS=
4983 <  fi
4984 < fi
4985 <
4986 < ac_ext=${ac_fc_srcext-f}
4987 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4988 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4989 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4990 <
4991 <
4992 < if test $USE_MPI != no; then :
4993 <
4994 < ac_ext=${ac_fc_srcext-f}
4995 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4996 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4997 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4998 <
4999 <
5000 <
5001 <
5002 <
5003 <
5004 <        for ac_prog in openmpif90 mpif90 mpxlf95_r mpxlf90_r mpxlf95 mpxlf90 mpf90 cmpif90c
5005 < do
5006 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
5007 < set dummy $ac_prog; ac_word=$2
5008 < { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5009 < $as_echo_n "checking for $ac_word... " >&6; }
5010 < if test "${ac_cv_prog_MPIFC+set}" = set; then :
5011 <  $as_echo_n "(cached) " >&6
5012 < else
5013 <  if test -n "$MPIFC"; then
5014 <  ac_cv_prog_MPIFC="$MPIFC" # Let the user override the test.
5015 < else
5016 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5017 < for as_dir in $PATH
5018 < do
5019 <  IFS=$as_save_IFS
5020 <  test -z "$as_dir" && as_dir=.
5021 <    for ac_exec_ext in '' $ac_executable_extensions; do
5022 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5023 <    ac_cv_prog_MPIFC="$ac_prog"
5024 <    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5025 <    break 2
5026 <  fi
5027 < done
5028 <  done
5029 < IFS=$as_save_IFS
5030 <
5031 < fi
5032 < fi
5033 < MPIFC=$ac_cv_prog_MPIFC
5034 < if test -n "$MPIFC"; then
5035 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPIFC" >&5
5036 < $as_echo "$MPIFC" >&6; }
5037 < else
5038 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5039 < $as_echo "no" >&6; }
5040 < fi
5041 <
5042 <
5043 <  test -n "$MPIFC" && break
5044 < done
5045 < test -n "$MPIFC" || MPIFC="$FC"
5046 <
5047 <        ax_mpi_save_FC="$FC"
5048 <        FC="$MPIFC"
5049 <
5050 <
5051 <
5052 < if test x = x"$MPILIBS"; then
5053 <        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init" >&5
5054 < $as_echo_n "checking for MPI_Init... " >&6; }
5055 <                        cat > conftest.$ac_ext <<_ACEOF
5056 <      program main
5057 <      call MPI_Init
5058 <      end
5059 < _ACEOF
5060 < if ac_fn_fc_try_link "$LINENO"; then :
5061 <  MPILIBS=" "
5062 <                                { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
5063 < $as_echo "yes" >&6; }
5064 < else
5065 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5066 < $as_echo "no" >&6; }
5067 < fi
5068 < rm -f core conftest.err conftest.$ac_objext \
5069 <    conftest$ac_exeext conftest.$ac_ext
5070 < fi
5071 <
5072 <        if test x = x"$MPILIBS"; then
5073 <                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lfmpi" >&5
5074 < $as_echo_n "checking for MPI_Init in -lfmpi... " >&6; }
5075 < if test "${ac_cv_lib_fmpi_MPI_Init+set}" = set; then :
5076 <  $as_echo_n "(cached) " >&6
5077 < else
5078 <  ac_check_lib_save_LIBS=$LIBS
5079 < LIBS="-lfmpi  $LIBS"
5080 < cat > conftest.$ac_ext <<_ACEOF
5081 <      program main
5082 <      call MPI_Init
5083 <      end
5084 < _ACEOF
5085 < if ac_fn_fc_try_link "$LINENO"; then :
5086 <  ac_cv_lib_fmpi_MPI_Init=yes
5087 < else
5088 <  ac_cv_lib_fmpi_MPI_Init=no
5089 < fi
5090 < rm -f core conftest.err conftest.$ac_objext \
5091 <    conftest$ac_exeext conftest.$ac_ext
5092 < LIBS=$ac_check_lib_save_LIBS
5093 < fi
5094 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fmpi_MPI_Init" >&5
5095 < $as_echo "$ac_cv_lib_fmpi_MPI_Init" >&6; }
5096 < if test "x$ac_cv_lib_fmpi_MPI_Init" = x""yes; then :
5097 <  MPILIBS="-lfmpi"
5098 < fi
5099 <
5100 <        fi
5101 <        if test x = x"$MPILIBS"; then
5102 <                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpichf90" >&5
5103 < $as_echo_n "checking for MPI_Init in -lmpichf90... " >&6; }
5104 < if test "${ac_cv_lib_mpichf90_MPI_Init+set}" = set; then :
5105 <  $as_echo_n "(cached) " >&6
5106 < else
5107 <  ac_check_lib_save_LIBS=$LIBS
5108 < LIBS="-lmpichf90  $LIBS"
5109 < cat > conftest.$ac_ext <<_ACEOF
5110 <      program main
5111 <      call MPI_Init
5112 <      end
5113 < _ACEOF
5114 < if ac_fn_fc_try_link "$LINENO"; then :
5115 <  ac_cv_lib_mpichf90_MPI_Init=yes
5116 < else
5117 <  ac_cv_lib_mpichf90_MPI_Init=no
5118 < fi
5119 < rm -f core conftest.err conftest.$ac_objext \
5120 <    conftest$ac_exeext conftest.$ac_ext
5121 < LIBS=$ac_check_lib_save_LIBS
5122 < fi
5123 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpichf90_MPI_Init" >&5
5124 < $as_echo "$ac_cv_lib_mpichf90_MPI_Init" >&6; }
5125 < if test "x$ac_cv_lib_mpichf90_MPI_Init" = x""yes; then :
5126 <  MPILIBS="-lmpichf90"
5127 < fi
5128 <
5129 <        fi
5130 <
5131 < if test x = x"$MPILIBS"; then
5132 <        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
5133 < $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
5134 < if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
5135 <  $as_echo_n "(cached) " >&6
5136 < else
5137 <  ac_check_lib_save_LIBS=$LIBS
5138 < LIBS="-lmpi  $LIBS"
5139 < cat > conftest.$ac_ext <<_ACEOF
5140 <      program main
5141 <      call MPI_Init
5142 <      end
5143 < _ACEOF
5144 < if ac_fn_fc_try_link "$LINENO"; then :
5145 <  ac_cv_lib_mpi_MPI_Init=yes
5146 < else
5147 <  ac_cv_lib_mpi_MPI_Init=no
5148 < fi
5149 < rm -f core conftest.err conftest.$ac_objext \
5150 <    conftest$ac_exeext conftest.$ac_ext
5151 < LIBS=$ac_check_lib_save_LIBS
5152 < fi
5153 < { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
5154 < $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
5155 < if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
5156 <  MPILIBS="-lmpi"
5157 < fi
2969 > PROGNAME="openmd"
2970  
2971 < fi
2972 < if test x = x"$MPILIBS"; then
2973 <        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
2974 < $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
2975 < if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
2976 <  $as_echo_n "(cached) " >&6
2971 >
2972 >
2973 >
2974 > OBJEXT=".$OBJEXT"
2975 >
2976 > OPENMD=openmd
2977 >
2978 > if test "x${prefix}" = "xNONE"
2979 > then
2980 >  OPENMD_HOME=${ac_default_prefix}/openmd
2981   else
2982 <  ac_check_lib_save_LIBS=$LIBS
5167 < LIBS="-lmpich  $LIBS"
5168 < cat > conftest.$ac_ext <<_ACEOF
5169 <      program main
5170 <      call MPI_Init
5171 <      end
5172 < _ACEOF
5173 < if ac_fn_fc_try_link "$LINENO"; then :
5174 <  ac_cv_lib_mpich_MPI_Init=yes
5175 < else
5176 <  ac_cv_lib_mpich_MPI_Init=no
2982 >  OPENMD_HOME=${prefix}/openmd
2983   fi
2984 < rm -f core conftest.err conftest.$ac_objext \
2985 <    conftest$ac_exeext conftest.$ac_ext
2986 < LIBS=$ac_check_lib_save_LIBS
2984 > # Check whether --enable-openmd-home was given.
2985 > if test "${enable_openmd_home+set}" = set; then :
2986 >  enableval=$enable_openmd_home; OPENMD_HOME="${enableval}"
2987   fi
5182 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
5183 $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
5184 if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
5185  MPILIBS="-lmpich"
5186 fi
2988  
5188 fi
2989  
2990 < if test x != x"$MPILIBS"; then
2991 <        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpif.h" >&5
2992 < $as_echo_n "checking for mpif.h... " >&6; }
2993 <        cat > conftest.$ac_ext <<_ACEOF
2994 <      program main
2995 <      include 'mpif.h'
2996 <      end
5197 < _ACEOF
5198 < if ac_fn_fc_try_compile "$LINENO"; then :
5199 <  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
5200 < $as_echo "yes" >&6; }
5201 < else
5202 <  MPILIBS=""
5203 <                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5204 < $as_echo "no" >&6; }
2990 > # there are two ways to do debugging.  One with the --enable-debug flag
2991 > # and one using the DEBUG environment variable
2992 >
2993 > debug=0
2994 > # Check whether --enable-debug was given.
2995 > if test "${enable_debug+set}" = set; then :
2996 >  enableval=$enable_debug; debug=1
2997   fi
5206 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5207 fi
2998  
2999 < FC="$ax_mpi_save_FC"
2999 > if test "${DEBUG}"; then
3000  
3001 + $as_echo "#define debug 1" >>confdefs.h
3002  
3003 +  msg="$msg, debug mode"
3004 + fi
3005  
3006 < # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
3007 < if test x = x"$MPILIBS"; then
3008 <        USE_MPI="no"
3009 <       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable Fortran MPI implementation found. openmd_MPI will not be built." >&5
5217 < $as_echo "$as_me: WARNING: No suitable Fortran MPI implementation found. openmd_MPI will not be built." >&2;}
5218 <        :
3006 >
3007 > # Check whether --enable-single was given.
3008 > if test "${enable_single+set}" = set; then :
3009 >  enableval=$enable_single; ok=$enableval
3010   else
3011 <        USE_MPI="yes"
5221 <        :
3011 >  ok=no
3012   fi
3013  
3014 <
3014 > # Check whether --enable-float was given.
3015 > if test "${enable_float+set}" = set; then :
3016 >  enableval=$enable_float; ok=$enableval
3017   fi
5226 if test $USE_MPI != no; then :
3018  
3019 <        CXX=$MPICXX
5229 <        CC=$MPICC
5230 <        FC=$MPIFC
3019 > if test "$ok" = "yes"; then
3020  
3021 < fi
3021 > $as_echo "#define SINGLE_PRECISION 1" >>confdefs.h
3022  
3023 +        USE_SINGLE_PRECISION=yes
3024  
3025 < # Checks for programs.
3025 > fi
3026 >
3027   ac_ext=cpp
3028   ac_cpp='$CXXCPP $CPPFLAGS'
3029   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 5367 | Line 3158 | $as_echo "$ac_try_echo"; } >&5
3158    rm -f conftest.er1 conftest.err
3159    $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3160    test $ac_status = 0; }
3161 + done
3162 +
3163 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3164 + /* end confdefs.h.  */
3165 +
3166 + int
3167 + main ()
3168 + {
3169 +
3170 +  ;
3171 +  return 0;
3172 + }
3173 + _ACEOF
3174 + ac_clean_files_save=$ac_clean_files
3175 + ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
3176 + # Try to create an executable without -o first, disregard a.out.
3177 + # It will help us diagnose broken compilers, and finding out an intuition
3178 + # of exeext.
3179 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
3180 + $as_echo_n "checking whether the C++ compiler works... " >&6; }
3181 + ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3182 +
3183 + # The possible output files:
3184 + ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
3185 +
3186 + ac_rmfiles=
3187 + for ac_file in $ac_files
3188 + do
3189 +  case $ac_file in
3190 +    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3191 +    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
3192 +  esac
3193   done
3194 + rm -f $ac_rmfiles
3195  
3196 + if { { ac_try="$ac_link_default"
3197 + case "(($ac_try" in
3198 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3199 +  *) ac_try_echo=$ac_try;;
3200 + esac
3201 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3202 + $as_echo "$ac_try_echo"; } >&5
3203 +  (eval "$ac_link_default") 2>&5
3204 +  ac_status=$?
3205 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3206 +  test $ac_status = 0; }; then :
3207 +  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3208 + # So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3209 + # in a Makefile.  We should not override ac_cv_exeext if it was cached,
3210 + # so that the user can short-circuit this test for compilers unknown to
3211 + # Autoconf.
3212 + for ac_file in $ac_files ''
3213 + do
3214 +  test -f "$ac_file" || continue
3215 +  case $ac_file in
3216 +    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
3217 +        ;;
3218 +    [ab].out )
3219 +        # We found the default executable, but exeext='' is most
3220 +        # certainly right.
3221 +        break;;
3222 +    *.* )
3223 +        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3224 +        then :; else
3225 +           ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3226 +        fi
3227 +        # We set ac_cv_exeext here because the later test for it is not
3228 +        # safe: cross compilers may not add the suffix if given an `-o'
3229 +        # argument, so we may need to know it at that point already.
3230 +        # Even if this section looks crufty: it has the advantage of
3231 +        # actually working.
3232 +        break;;
3233 +    * )
3234 +        break;;
3235 +  esac
3236 + done
3237 + test "$ac_cv_exeext" = no && ac_cv_exeext=
3238 +
3239 + else
3240 +  ac_file=''
3241 + fi
3242 + if test -z "$ac_file"; then :
3243 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3244 + $as_echo "no" >&6; }
3245 + $as_echo "$as_me: failed program was:" >&5
3246 + sed 's/^/| /' conftest.$ac_ext >&5
3247 +
3248 + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3249 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3250 + { as_fn_set_status 77
3251 + as_fn_error "C++ compiler cannot create executables
3252 + See \`config.log' for more details." "$LINENO" 5; }; }
3253 + else
3254 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
3255 + $as_echo "yes" >&6; }
3256 + fi
3257 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
3258 + $as_echo_n "checking for C++ compiler default output file name... " >&6; }
3259 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
3260 + $as_echo "$ac_file" >&6; }
3261 + ac_exeext=$ac_cv_exeext
3262 +
3263 + rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
3264 + ac_clean_files=$ac_clean_files_save
3265 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
3266 + $as_echo_n "checking for suffix of executables... " >&6; }
3267 + if { { ac_try="$ac_link"
3268 + case "(($ac_try" in
3269 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3270 +  *) ac_try_echo=$ac_try;;
3271 + esac
3272 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3273 + $as_echo "$ac_try_echo"; } >&5
3274 +  (eval "$ac_link") 2>&5
3275 +  ac_status=$?
3276 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3277 +  test $ac_status = 0; }; then :
3278 +  # If both `conftest.exe' and `conftest' are `present' (well, observable)
3279 + # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3280 + # work properly (i.e., refer to `conftest.exe'), while it won't with
3281 + # `rm'.
3282 + for ac_file in conftest.exe conftest conftest.*; do
3283 +  test -f "$ac_file" || continue
3284 +  case $ac_file in
3285 +    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3286 +    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3287 +          break;;
3288 +    * ) break;;
3289 +  esac
3290 + done
3291 + else
3292 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3293 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3294 + as_fn_error "cannot compute suffix of executables: cannot compile and link
3295 + See \`config.log' for more details." "$LINENO" 5; }
3296 + fi
3297 + rm -f conftest conftest$ac_cv_exeext
3298 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
3299 + $as_echo "$ac_cv_exeext" >&6; }
3300 +
3301 + rm -f conftest.$ac_ext
3302 + EXEEXT=$ac_cv_exeext
3303 + ac_exeext=$EXEEXT
3304 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3305 + /* end confdefs.h.  */
3306 + #include <stdio.h>
3307 + int
3308 + main ()
3309 + {
3310 + FILE *f = fopen ("conftest.out", "w");
3311 + return ferror (f) || fclose (f) != 0;
3312 +
3313 +  ;
3314 +  return 0;
3315 + }
3316 + _ACEOF
3317 + ac_clean_files="$ac_clean_files conftest.out"
3318 + # Check that the compiler produces executables we can run.  If not, either
3319 + # the compiler is broken, or we cross compile.
3320 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
3321 + $as_echo_n "checking whether we are cross compiling... " >&6; }
3322 + if test "$cross_compiling" != yes; then
3323 +  { { ac_try="$ac_link"
3324 + case "(($ac_try" in
3325 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3326 +  *) ac_try_echo=$ac_try;;
3327 + esac
3328 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3329 + $as_echo "$ac_try_echo"; } >&5
3330 +  (eval "$ac_link") 2>&5
3331 +  ac_status=$?
3332 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3333 +  test $ac_status = 0; }
3334 +  if { ac_try='./conftest$ac_cv_exeext'
3335 +  { { case "(($ac_try" in
3336 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3337 +  *) ac_try_echo=$ac_try;;
3338 + esac
3339 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3340 + $as_echo "$ac_try_echo"; } >&5
3341 +  (eval "$ac_try") 2>&5
3342 +  ac_status=$?
3343 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3344 +  test $ac_status = 0; }; }; then
3345 +    cross_compiling=no
3346 +  else
3347 +    if test "$cross_compiling" = maybe; then
3348 +        cross_compiling=yes
3349 +    else
3350 +        { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3351 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3352 + as_fn_error "cannot run C++ compiled programs.
3353 + If you meant to cross compile, use \`--host'.
3354 + See \`config.log' for more details." "$LINENO" 5; }
3355 +    fi
3356 +  fi
3357 + fi
3358 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
3359 + $as_echo "$cross_compiling" >&6; }
3360 +
3361 + rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
3362 + ac_clean_files=$ac_clean_files_save
3363 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
3364 + $as_echo_n "checking for suffix of object files... " >&6; }
3365 + if test "${ac_cv_objext+set}" = set; then :
3366 +  $as_echo_n "(cached) " >&6
3367 + else
3368 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3369 + /* end confdefs.h.  */
3370 +
3371 + int
3372 + main ()
3373 + {
3374 +
3375 +  ;
3376 +  return 0;
3377 + }
3378 + _ACEOF
3379 + rm -f conftest.o conftest.obj
3380 + if { { ac_try="$ac_compile"
3381 + case "(($ac_try" in
3382 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3383 +  *) ac_try_echo=$ac_try;;
3384 + esac
3385 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3386 + $as_echo "$ac_try_echo"; } >&5
3387 +  (eval "$ac_compile") 2>&5
3388 +  ac_status=$?
3389 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3390 +  test $ac_status = 0; }; then :
3391 +  for ac_file in conftest.o conftest.obj conftest.*; do
3392 +  test -f "$ac_file" || continue;
3393 +  case $ac_file in
3394 +    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
3395 +    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3396 +       break;;
3397 +  esac
3398 + done
3399 + else
3400 +  $as_echo "$as_me: failed program was:" >&5
3401 + sed 's/^/| /' conftest.$ac_ext >&5
3402 +
3403 + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3404 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3405 + as_fn_error "cannot compute suffix of object files: cannot compile
3406 + See \`config.log' for more details." "$LINENO" 5; }
3407 + fi
3408 + rm -f conftest.$ac_cv_objext conftest.$ac_ext
3409 + fi
3410 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
3411 + $as_echo "$ac_cv_objext" >&6; }
3412 + OBJEXT=$ac_cv_objext
3413 + ac_objext=$OBJEXT
3414   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
3415   $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3416   if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
# Line 5484 | Line 3526 | fi
3526      CXXFLAGS=
3527    fi
3528   fi
3529 < ac_ext=${ac_fc_srcext-f}
3530 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
3531 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
3532 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3529 > ac_ext=c
3530 > ac_cpp='$CPP $CPPFLAGS'
3531 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3532 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3533 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
3534  
3535   ac_ext=c
3536   ac_cpp='$CPP $CPPFLAGS'
# Line 5831 | Line 3874 | fi
3874  
3875   fi
3876  
3877 < ac_ext=${ac_fc_srcext-f}
3878 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
3879 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
3880 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3877 > ac_ext=c
3878 > ac_cpp='$CPP $CPPFLAGS'
3879 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3880 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3881 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
3882  
3883   ac_ext=${ac_fc_srcext-f}
3884   ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
# Line 6033 | Line 4077 | else
4077      FCFLAGS="-O2"
4078    else
4079      FCFLAGS=
4080 +  fi
4081 + fi
4082 +
4083 + ac_ext=c
4084 + ac_cpp='$CPP $CPPFLAGS'
4085 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4086 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4087 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4088 +
4089 +
4090 + save_CXX=$CXX
4091 + save_CC=$CC
4092 + save_FC=$FC
4093 + save_LIBS=$LIBS
4094 +
4095 + ac_ext=cpp
4096 + ac_cpp='$CXXCPP $CPPFLAGS'
4097 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4098 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4099 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
4100 +
4101 +
4102 +
4103 +
4104 +
4105 +
4106 +
4107 +        for ac_prog in openmpicxx openmpiCC openmpic++ mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++
4108 + do
4109 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
4110 + set dummy $ac_prog; ac_word=$2
4111 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4112 + $as_echo_n "checking for $ac_word... " >&6; }
4113 + if test "${ac_cv_prog_MPICXX+set}" = set; then :
4114 +  $as_echo_n "(cached) " >&6
4115 + else
4116 +  if test -n "$MPICXX"; then
4117 +  ac_cv_prog_MPICXX="$MPICXX" # Let the user override the test.
4118 + else
4119 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4120 + for as_dir in $PATH
4121 + do
4122 +  IFS=$as_save_IFS
4123 +  test -z "$as_dir" && as_dir=.
4124 +    for ac_exec_ext in '' $ac_executable_extensions; do
4125 +  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4126 +    ac_cv_prog_MPICXX="$ac_prog"
4127 +    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4128 +    break 2
4129    fi
4130 + done
4131 +  done
4132 + IFS=$as_save_IFS
4133 +
4134   fi
4135 + fi
4136 + MPICXX=$ac_cv_prog_MPICXX
4137 + if test -n "$MPICXX"; then
4138 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICXX" >&5
4139 + $as_echo "$MPICXX" >&6; }
4140 + else
4141 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4142 + $as_echo "no" >&6; }
4143 + fi
4144  
4145 +
4146 +  test -n "$MPICXX" && break
4147 + done
4148 + test -n "$MPICXX" || MPICXX="$CXX"
4149 +
4150 +        ax_mpi_save_CXX="$CXX"
4151 +        CXX="$MPICXX"
4152 +
4153 +
4154 +
4155 + if test x = x"$MPILIBS"; then
4156 +        ac_fn_cxx_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4157 + if test "x$ac_cv_func_MPI_Init" = x""yes; then :
4158 +  MPILIBS=" "
4159 + fi
4160 +
4161 + fi
4162 +
4163 + if test x = x"$MPILIBS"; then
4164 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4165 + $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4166 + if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4167 +  $as_echo_n "(cached) " >&6
4168 + else
4169 +  ac_check_lib_save_LIBS=$LIBS
4170 + LIBS="-lmpi  $LIBS"
4171 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4172 + /* end confdefs.h.  */
4173 +
4174 + /* Override any GCC internal prototype to avoid an error.
4175 +   Use char because int might match the return type of a GCC
4176 +   builtin and then its argument prototype would still apply.  */
4177 + #ifdef __cplusplus
4178 + extern "C"
4179 + #endif
4180 + char MPI_Init ();
4181 + int
4182 + main ()
4183 + {
4184 + return MPI_Init ();
4185 +  ;
4186 +  return 0;
4187 + }
4188 + _ACEOF
4189 + if ac_fn_cxx_try_link "$LINENO"; then :
4190 +  ac_cv_lib_mpi_MPI_Init=yes
4191 + else
4192 +  ac_cv_lib_mpi_MPI_Init=no
4193 + fi
4194 + rm -f core conftest.err conftest.$ac_objext \
4195 +    conftest$ac_exeext conftest.$ac_ext
4196 + LIBS=$ac_check_lib_save_LIBS
4197 + fi
4198 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4199 + $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4200 + if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4201 +  MPILIBS="-lmpi"
4202 + fi
4203 +
4204 + fi
4205 + if test x = x"$MPILIBS"; then
4206 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4207 + $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4208 + if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4209 +  $as_echo_n "(cached) " >&6
4210 + else
4211 +  ac_check_lib_save_LIBS=$LIBS
4212 + LIBS="-lmpich  $LIBS"
4213 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4214 + /* end confdefs.h.  */
4215 +
4216 + /* Override any GCC internal prototype to avoid an error.
4217 +   Use char because int might match the return type of a GCC
4218 +   builtin and then its argument prototype would still apply.  */
4219 + #ifdef __cplusplus
4220 + extern "C"
4221 + #endif
4222 + char MPI_Init ();
4223 + int
4224 + main ()
4225 + {
4226 + return MPI_Init ();
4227 +  ;
4228 +  return 0;
4229 + }
4230 + _ACEOF
4231 + if ac_fn_cxx_try_link "$LINENO"; then :
4232 +  ac_cv_lib_mpich_MPI_Init=yes
4233 + else
4234 +  ac_cv_lib_mpich_MPI_Init=no
4235 + fi
4236 + rm -f core conftest.err conftest.$ac_objext \
4237 +    conftest$ac_exeext conftest.$ac_ext
4238 + LIBS=$ac_check_lib_save_LIBS
4239 + fi
4240 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4241 + $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4242 + if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4243 +  MPILIBS="-lmpich"
4244 + fi
4245 +
4246 + fi
4247 +
4248 + if test x != x"$MPILIBS"; then
4249 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4250 + $as_echo_n "checking for mpi.h... " >&6; }
4251 +        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4252 + /* end confdefs.h.  */
4253 + #include <mpi.h>
4254 + int
4255 + main ()
4256 + {
4257 +
4258 +  ;
4259 +  return 0;
4260 + }
4261 + _ACEOF
4262 + if ac_fn_cxx_try_compile "$LINENO"; then :
4263 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4264 + $as_echo "yes" >&6; }
4265 + else
4266 +  MPILIBS=""
4267 +                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4268 + $as_echo "no" >&6; }
4269 + fi
4270 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4271 + fi
4272 +
4273 + CXX="$ax_mpi_save_CXX"
4274 +
4275 +
4276 +
4277 + # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4278 + if test x = x"$MPILIBS"; then
4279 +        USE_MPI="no"
4280 +       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&5
4281 + $as_echo "$as_me: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&2;}
4282 +        :
4283 + else
4284 +        USE_MPI="yes"
4285 +        :
4286 + fi
4287 +
4288 +
4289 + if test $USE_MPI != no; then :
4290 +
4291 + ac_ext=c
4292 + ac_cpp='$CPP $CPPFLAGS'
4293 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4294 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4295 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4296 +
4297 +
4298 +
4299 +
4300 +
4301 +
4302 +        for ac_prog in openmpicc mpicc hcc mpxlc_r mpxlc mpcc cmpicc
4303 + do
4304 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
4305 + set dummy $ac_prog; ac_word=$2
4306 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4307 + $as_echo_n "checking for $ac_word... " >&6; }
4308 + if test "${ac_cv_prog_MPICC+set}" = set; then :
4309 +  $as_echo_n "(cached) " >&6
4310 + else
4311 +  if test -n "$MPICC"; then
4312 +  ac_cv_prog_MPICC="$MPICC" # Let the user override the test.
4313 + else
4314 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4315 + for as_dir in $PATH
4316 + do
4317 +  IFS=$as_save_IFS
4318 +  test -z "$as_dir" && as_dir=.
4319 +    for ac_exec_ext in '' $ac_executable_extensions; do
4320 +  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4321 +    ac_cv_prog_MPICC="$ac_prog"
4322 +    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4323 +    break 2
4324 +  fi
4325 + done
4326 +  done
4327 + IFS=$as_save_IFS
4328 +
4329 + fi
4330 + fi
4331 + MPICC=$ac_cv_prog_MPICC
4332 + if test -n "$MPICC"; then
4333 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICC" >&5
4334 + $as_echo "$MPICC" >&6; }
4335 + else
4336 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4337 + $as_echo "no" >&6; }
4338 + fi
4339 +
4340 +
4341 +  test -n "$MPICC" && break
4342 + done
4343 + test -n "$MPICC" || MPICC="$CC"
4344 +
4345 +        ax_mpi_save_CC="$CC"
4346 +        CC="$MPICC"
4347 +
4348 +
4349 +
4350 + if test x = x"$MPILIBS"; then
4351 +        ac_fn_c_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4352 + if test "x$ac_cv_func_MPI_Init" = x""yes; then :
4353 +  MPILIBS=" "
4354 + fi
4355 +
4356 + fi
4357 +
4358 + if test x = x"$MPILIBS"; then
4359 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4360 + $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4361 + if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4362 +  $as_echo_n "(cached) " >&6
4363 + else
4364 +  ac_check_lib_save_LIBS=$LIBS
4365 + LIBS="-lmpi  $LIBS"
4366 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4367 + /* end confdefs.h.  */
4368 +
4369 + /* Override any GCC internal prototype to avoid an error.
4370 +   Use char because int might match the return type of a GCC
4371 +   builtin and then its argument prototype would still apply.  */
4372 + #ifdef __cplusplus
4373 + extern "C"
4374 + #endif
4375 + char MPI_Init ();
4376 + int
4377 + main ()
4378 + {
4379 + return MPI_Init ();
4380 +  ;
4381 +  return 0;
4382 + }
4383 + _ACEOF
4384 + if ac_fn_c_try_link "$LINENO"; then :
4385 +  ac_cv_lib_mpi_MPI_Init=yes
4386 + else
4387 +  ac_cv_lib_mpi_MPI_Init=no
4388 + fi
4389 + rm -f core conftest.err conftest.$ac_objext \
4390 +    conftest$ac_exeext conftest.$ac_ext
4391 + LIBS=$ac_check_lib_save_LIBS
4392 + fi
4393 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4394 + $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4395 + if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4396 +  MPILIBS="-lmpi"
4397 + fi
4398 +
4399 + fi
4400 + if test x = x"$MPILIBS"; then
4401 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4402 + $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4403 + if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4404 +  $as_echo_n "(cached) " >&6
4405 + else
4406 +  ac_check_lib_save_LIBS=$LIBS
4407 + LIBS="-lmpich  $LIBS"
4408 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4409 + /* end confdefs.h.  */
4410 +
4411 + /* Override any GCC internal prototype to avoid an error.
4412 +   Use char because int might match the return type of a GCC
4413 +   builtin and then its argument prototype would still apply.  */
4414 + #ifdef __cplusplus
4415 + extern "C"
4416 + #endif
4417 + char MPI_Init ();
4418 + int
4419 + main ()
4420 + {
4421 + return MPI_Init ();
4422 +  ;
4423 +  return 0;
4424 + }
4425 + _ACEOF
4426 + if ac_fn_c_try_link "$LINENO"; then :
4427 +  ac_cv_lib_mpich_MPI_Init=yes
4428 + else
4429 +  ac_cv_lib_mpich_MPI_Init=no
4430 + fi
4431 + rm -f core conftest.err conftest.$ac_objext \
4432 +    conftest$ac_exeext conftest.$ac_ext
4433 + LIBS=$ac_check_lib_save_LIBS
4434 + fi
4435 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4436 + $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4437 + if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4438 +  MPILIBS="-lmpich"
4439 + fi
4440 +
4441 + fi
4442 +
4443 + if test x != x"$MPILIBS"; then
4444 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4445 + $as_echo_n "checking for mpi.h... " >&6; }
4446 +        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4447 + /* end confdefs.h.  */
4448 + #include <mpi.h>
4449 + int
4450 + main ()
4451 + {
4452 +
4453 +  ;
4454 +  return 0;
4455 + }
4456 + _ACEOF
4457 + if ac_fn_c_try_compile "$LINENO"; then :
4458 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4459 + $as_echo "yes" >&6; }
4460 + else
4461 +  MPILIBS=""
4462 +                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4463 + $as_echo "no" >&6; }
4464 + fi
4465 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4466 + fi
4467 +
4468 + CC="$ax_mpi_save_CC"
4469 +
4470 +
4471 +
4472 + # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4473 + if test x = x"$MPILIBS"; then
4474 +        USE_MPI="no"
4475 +       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&5
4476 + $as_echo "$as_me: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&2;}
4477 +        :
4478 + else
4479 +        USE_MPI="yes"
4480 +        :
4481 + fi
4482 +
4483 +
4484 + fi
4485 +
4486 + if test $USE_MPI != no; then :
4487 +
4488   ac_ext=${ac_fc_srcext-f}
4489   ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4490   ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4491   ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4492 +
4493 +
4494 +
4495 +
4496 +
4497 +
4498 +        for ac_prog in openmpif90 mpif90 mpxlf95_r mpxlf90_r mpxlf95 mpxlf90 mpf90 cmpif90c
4499 + do
4500 +  # Extract the first word of "$ac_prog", so it can be a program name with args.
4501 + set dummy $ac_prog; ac_word=$2
4502 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4503 + $as_echo_n "checking for $ac_word... " >&6; }
4504 + if test "${ac_cv_prog_MPIFC+set}" = set; then :
4505 +  $as_echo_n "(cached) " >&6
4506 + else
4507 +  if test -n "$MPIFC"; then
4508 +  ac_cv_prog_MPIFC="$MPIFC" # Let the user override the test.
4509 + else
4510 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4511 + for as_dir in $PATH
4512 + do
4513 +  IFS=$as_save_IFS
4514 +  test -z "$as_dir" && as_dir=.
4515 +    for ac_exec_ext in '' $ac_executable_extensions; do
4516 +  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4517 +    ac_cv_prog_MPIFC="$ac_prog"
4518 +    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4519 +    break 2
4520 +  fi
4521 + done
4522 +  done
4523 + IFS=$as_save_IFS
4524 +
4525 + fi
4526 + fi
4527 + MPIFC=$ac_cv_prog_MPIFC
4528 + if test -n "$MPIFC"; then
4529 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPIFC" >&5
4530 + $as_echo "$MPIFC" >&6; }
4531 + else
4532 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4533 + $as_echo "no" >&6; }
4534 + fi
4535 +
4536 +
4537 +  test -n "$MPIFC" && break
4538 + done
4539 + test -n "$MPIFC" || MPIFC="$FC"
4540 +
4541 +        ax_mpi_save_FC="$FC"
4542 +        FC="$MPIFC"
4543 +
4544 +
4545 +
4546 + if test x = x"$MPILIBS"; then
4547 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init" >&5
4548 + $as_echo_n "checking for MPI_Init... " >&6; }
4549 +                        cat > conftest.$ac_ext <<_ACEOF
4550 +      program main
4551 +      call MPI_Init
4552 +      end
4553 + _ACEOF
4554 + if ac_fn_fc_try_link "$LINENO"; then :
4555 +  MPILIBS=" "
4556 +                                { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4557 + $as_echo "yes" >&6; }
4558 + else
4559 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4560 + $as_echo "no" >&6; }
4561 + fi
4562 + rm -f core conftest.err conftest.$ac_objext \
4563 +    conftest$ac_exeext conftest.$ac_ext
4564 + fi
4565 +
4566 +        if test x = x"$MPILIBS"; then
4567 +                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lfmpi" >&5
4568 + $as_echo_n "checking for MPI_Init in -lfmpi... " >&6; }
4569 + if test "${ac_cv_lib_fmpi_MPI_Init+set}" = set; then :
4570 +  $as_echo_n "(cached) " >&6
4571 + else
4572 +  ac_check_lib_save_LIBS=$LIBS
4573 + LIBS="-lfmpi  $LIBS"
4574 + cat > conftest.$ac_ext <<_ACEOF
4575 +      program main
4576 +      call MPI_Init
4577 +      end
4578 + _ACEOF
4579 + if ac_fn_fc_try_link "$LINENO"; then :
4580 +  ac_cv_lib_fmpi_MPI_Init=yes
4581 + else
4582 +  ac_cv_lib_fmpi_MPI_Init=no
4583 + fi
4584 + rm -f core conftest.err conftest.$ac_objext \
4585 +    conftest$ac_exeext conftest.$ac_ext
4586 + LIBS=$ac_check_lib_save_LIBS
4587 + fi
4588 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fmpi_MPI_Init" >&5
4589 + $as_echo "$ac_cv_lib_fmpi_MPI_Init" >&6; }
4590 + if test "x$ac_cv_lib_fmpi_MPI_Init" = x""yes; then :
4591 +  MPILIBS="-lfmpi"
4592 + fi
4593 +
4594 +        fi
4595 +        if test x = x"$MPILIBS"; then
4596 +                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpichf90" >&5
4597 + $as_echo_n "checking for MPI_Init in -lmpichf90... " >&6; }
4598 + if test "${ac_cv_lib_mpichf90_MPI_Init+set}" = set; then :
4599 +  $as_echo_n "(cached) " >&6
4600 + else
4601 +  ac_check_lib_save_LIBS=$LIBS
4602 + LIBS="-lmpichf90  $LIBS"
4603 + cat > conftest.$ac_ext <<_ACEOF
4604 +      program main
4605 +      call MPI_Init
4606 +      end
4607 + _ACEOF
4608 + if ac_fn_fc_try_link "$LINENO"; then :
4609 +  ac_cv_lib_mpichf90_MPI_Init=yes
4610 + else
4611 +  ac_cv_lib_mpichf90_MPI_Init=no
4612 + fi
4613 + rm -f core conftest.err conftest.$ac_objext \
4614 +    conftest$ac_exeext conftest.$ac_ext
4615 + LIBS=$ac_check_lib_save_LIBS
4616 + fi
4617 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpichf90_MPI_Init" >&5
4618 + $as_echo "$ac_cv_lib_mpichf90_MPI_Init" >&6; }
4619 + if test "x$ac_cv_lib_mpichf90_MPI_Init" = x""yes; then :
4620 +  MPILIBS="-lmpichf90"
4621 + fi
4622 +
4623 +        fi
4624 +
4625 + if test x = x"$MPILIBS"; then
4626 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4627 + $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4628 + if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4629 +  $as_echo_n "(cached) " >&6
4630 + else
4631 +  ac_check_lib_save_LIBS=$LIBS
4632 + LIBS="-lmpi  $LIBS"
4633 + cat > conftest.$ac_ext <<_ACEOF
4634 +      program main
4635 +      call MPI_Init
4636 +      end
4637 + _ACEOF
4638 + if ac_fn_fc_try_link "$LINENO"; then :
4639 +  ac_cv_lib_mpi_MPI_Init=yes
4640 + else
4641 +  ac_cv_lib_mpi_MPI_Init=no
4642 + fi
4643 + rm -f core conftest.err conftest.$ac_objext \
4644 +    conftest$ac_exeext conftest.$ac_ext
4645 + LIBS=$ac_check_lib_save_LIBS
4646 + fi
4647 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4648 + $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4649 + if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4650 +  MPILIBS="-lmpi"
4651 + fi
4652 +
4653 + fi
4654 + if test x = x"$MPILIBS"; then
4655 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4656 + $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4657 + if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4658 +  $as_echo_n "(cached) " >&6
4659 + else
4660 +  ac_check_lib_save_LIBS=$LIBS
4661 + LIBS="-lmpich  $LIBS"
4662 + cat > conftest.$ac_ext <<_ACEOF
4663 +      program main
4664 +      call MPI_Init
4665 +      end
4666 + _ACEOF
4667 + if ac_fn_fc_try_link "$LINENO"; then :
4668 +  ac_cv_lib_mpich_MPI_Init=yes
4669 + else
4670 +  ac_cv_lib_mpich_MPI_Init=no
4671 + fi
4672 + rm -f core conftest.err conftest.$ac_objext \
4673 +    conftest$ac_exeext conftest.$ac_ext
4674 + LIBS=$ac_check_lib_save_LIBS
4675 + fi
4676 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4677 + $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4678 + if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4679 +  MPILIBS="-lmpich"
4680 + fi
4681 +
4682 + fi
4683 +
4684 + if test x != x"$MPILIBS"; then
4685 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpif.h" >&5
4686 + $as_echo_n "checking for mpif.h... " >&6; }
4687 +        cat > conftest.$ac_ext <<_ACEOF
4688 +      program main
4689 +      include 'mpif.h'
4690 +      end
4691 + _ACEOF
4692 + if ac_fn_fc_try_compile "$LINENO"; then :
4693 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4694 + $as_echo "yes" >&6; }
4695 + else
4696 +  MPILIBS=""
4697 +                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4698 + $as_echo "no" >&6; }
4699 + fi
4700 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4701 + fi
4702 +
4703 + FC="$ax_mpi_save_FC"
4704 +
4705 +
4706 +
4707 + # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4708 + if test x = x"$MPILIBS"; then
4709 +        USE_MPI="no"
4710 +       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable Fortran MPI implementation found. openmd_MPI will not be built." >&5
4711 + $as_echo "$as_me: WARNING: No suitable Fortran MPI implementation found. openmd_MPI will not be built." >&2;}
4712 +        :
4713 + else
4714 +        USE_MPI="yes"
4715 +        :
4716 + fi
4717 +
4718 +
4719 + fi
4720 + if test $USE_MPI != no; then :
4721 +
4722 +        CXX=$MPICXX
4723 +        CC=$MPICC
4724 +        FC=$MPIFC
4725 +        LIBS="$MPILIBS $LIBS"
4726 +
4727 + else
4728 +
4729 +        CXX=$save_CXX
4730 +        CC=$save_CC
4731 +        FC=$save_FC
4732 +        LIBS=$save_LIBS
4733 +
4734 +
4735 + fi
4736 +
4737  
4738 + # Checks for programs.
4739   ac_ext=c
4740   ac_cpp='$CPP $CPPFLAGS'
4741   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines