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